TrackerTFP/test/AnalyzerDemonstrator.cc

0001 #include "FWCore/Framework/interface/one/EDAnalyzer.h"
0002 #include "FWCore/Framework/interface/Run.h"
0003 #include "FWCore/Framework/interface/Event.h"
0004 #include "FWCore/Framework/interface/EventSetup.h"
0005 #include "FWCore/Framework/interface/MakerMacros.h"
0006 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0007 #include "FWCore/Utilities/interface/EDGetToken.h"
0008 #include "FWCore/Utilities/interface/ESGetToken.h"
0009 #include "FWCore/Utilities/interface/InputTag.h"
0010 #include "FWCore/Utilities/interface/Exception.h"
0011 #include "DataFormats/Common/interface/Handle.h"
0012
0013 #include "L1Trigger/TrackerTFP/interface/Demonstrator.h"
0014
0015 #include <sstream>
0016
0017 namespace trackerTFP {
0018
0019   /*! \class  trackerTFP::AnalyzerDemonstrator
0020    *  \brief  calls questasim to simulate the f/w and compares the results with clock-and-bit-accurate emulation.
0021    *          A single bit error interrupts the run.
0022    *  \author Thomas Schuh
0023    *  \date   2020, Nov
0024    */
0025   class AnalyzerDemonstrator : public edm::one::EDAnalyzer<edm::one::WatchRuns> {
0026   public:
0027     AnalyzerDemonstrator(const edm::ParameterSet& iConfig);
0028     void beginJob() override {}
0029     void beginRun(const edm::Run& iEvent, const edm::EventSetup& iSetup) override;
0030     void analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) override;
0031     void endRun(const edm::Run& iEvent, const edm::EventSetup& iSetup) override {}
0032     void endJob() override {}
0033
0034   private:
0035     //
0036     void convert(const edm::Event& iEvent,
0037                  const edm::EDGetTokenT<tt::StreamsTrack>& tokenTracks,
0038                  const edm::EDGetTokenT<tt::StreamsStub>& tokenStubs,
0039                  std::vector<std::vector<tt::Frame>>& bits) const;
0040     //
0041     template <typename T>
0042     void convert(const T& collection, std::vector<std::vector<tt::Frame>>& bits) const;
0043     // ED input token of Tracks
0044     edm::EDGetTokenT<tt::StreamsStub> edGetTokenStubsIn_;
0045     edm::EDGetTokenT<tt::StreamsStub> edGetTokenStubsOut_;
0046     // ED input token of Stubs
0047     edm::EDGetTokenT<tt::StreamsTrack> edGetTokenTracksIn_;
0048     edm::EDGetTokenT<tt::StreamsTrack> edGetTokenTracksOut_;
0049     // Setup token
0050     edm::ESGetToken<tt::Setup, tt::SetupRcd> esGetTokenSetup_;
0051     // Demonstrator token
0052     edm::ESGetToken<Demonstrator, tt::SetupRcd> esGetTokenDemonstrator_;
0053     //
0054     const tt::Setup* setup_ = nullptr;
0055     //
0056     const Demonstrator* demonstrator_ = nullptr;
0057   };
0058
0059   AnalyzerDemonstrator::AnalyzerDemonstrator(const edm::ParameterSet& iConfig) {
0060     // book in- and output ED products
0061     const std::string& labelIn = iConfig.getParameter<std::string>("LabelIn");
0062     const std::string& labelOut = iConfig.getParameter<std::string>("LabelOut");
0063     const std::string& branchStubs = iConfig.getParameter<std::string>("BranchStubs");
0064     const std::string& branchTracks = iConfig.getParameter<std::string>("BranchTracks");
0065     edGetTokenStubsIn_ = consumes<tt::StreamsStub>(edm::InputTag(labelIn, branchStubs));
0066     if (labelOut != "ProducerTFP")
0067       edGetTokenStubsOut_ = consumes<tt::StreamsStub>(edm::InputTag(labelOut, branchStubs));
0068     if (labelIn == "ProducerCTB" || labelIn == "ProducerKF" || labelIn == "ProducerDR")
0069       edGetTokenTracksIn_ = consumes<tt::StreamsTrack>(edm::InputTag(labelIn, branchTracks));
0070     if (labelOut == "ProducerCTB" || labelOut == "ProducerKF" || labelOut == "ProducerDR" || labelOut == "ProducerTFP")
0071       edGetTokenTracksOut_ = consumes<tt::StreamsTrack>(edm::InputTag(labelOut, branchTracks));
0072     // book ES products
0073     esGetTokenSetup_ = esConsumes<edm::Transition::BeginRun>();
0074     esGetTokenDemonstrator_ = esConsumes<edm::Transition::BeginRun>();
0075   }
0076
0077   void AnalyzerDemonstrator::beginRun(const edm::Run& iEvent, const edm::EventSetup& iSetup) {
0078     //
0079     setup_ = &iSetup.getData(esGetTokenSetup_);
0080     //
0081     demonstrator_ = &iSetup.getData(esGetTokenDemonstrator_);
0082   }
0083
0084   void AnalyzerDemonstrator::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) {
0085     edm::Handle<tt::StreamsStub> handle;
0086     iEvent.getByToken<tt::StreamsStub>(edGetTokenStubsIn_, handle);
0087     std::vector<std::vector<tt::Frame>> input;
0088     std::vector<std::vector<tt::Frame>> output;
0089     convert(iEvent, edGetTokenTracksIn_, edGetTokenStubsIn_, input);
0090     convert(iEvent, edGetTokenTracksOut_, edGetTokenStubsOut_, output);
0091     if (!demonstrator_->analyze(input, output)) {
0092       cms::Exception exception("RunTimeError.");
0093       exception.addContext("trackerTFP::AnalyzerDemonstrator::analyze");
0094       exception << "Bit error detected.";
0095       throw exception;
0096     }
0097   }
0098
0099   //
0100   void AnalyzerDemonstrator::convert(const edm::Event& iEvent,
0101                                      const edm::EDGetTokenT<tt::StreamsTrack>& tokenTracks,
0102                                      const edm::EDGetTokenT<tt::StreamsStub>& tokenStubs,
0103                                      std::vector<std::vector<tt::Frame>>& bits) const {
0104     const bool tracks = !tokenTracks.isUninitialized();
0105     const bool stubs = !tokenStubs.isUninitialized();
0106     edm::Handle<tt::StreamsStub> handleStubs;
0107     edm::Handle<tt::StreamsTrack> handleTracks;
0108     int numChannelStubs(0);
0109     if (stubs) {
0110       iEvent.getByToken<tt::StreamsStub>(tokenStubs, handleStubs);
0111       numChannelStubs = handleStubs->size();
0112     }
0113     int numChannelTracks(0);
0114     if (tracks) {
0115       iEvent.getByToken<tt::StreamsTrack>(tokenTracks, handleTracks);
0116       numChannelTracks = handleTracks->size();
0117     }
0118     numChannelTracks /= setup_->numRegions();
0119     numChannelStubs /= (setup_->numRegions() * (tracks ? numChannelTracks : 1));
0120     bits.reserve(numChannelTracks + numChannelStubs);
0121     for (int region = 0; region < setup_->numRegions(); region++) {
0122       if (tracks) {
0123         const int offsetTracks = region * numChannelTracks;
0124         for (int channelTracks = 0; channelTracks < numChannelTracks; channelTracks++) {
0125           const int offsetStubs = (region * numChannelTracks + channelTracks) * numChannelStubs;
0126           if (tracks)
0127             convert(handleTracks->at(offsetTracks + channelTracks), bits);
0128           if (stubs) {
0129             for (int channelStubs = 0; channelStubs < numChannelStubs; channelStubs++)
0130               convert(handleStubs->at(offsetStubs + channelStubs), bits);
0131           }
0132         }
0133       } else {
0134         const int offsetStubs = region * numChannelStubs;
0135         for (int channelStubs = 0; channelStubs < numChannelStubs; channelStubs++)
0136           convert(handleStubs->at(offsetStubs + channelStubs), bits);
0137       }
0138     }
0139   }
0140
0141   //
0142   template <typename T>
0143   void AnalyzerDemonstrator::convert(const T& collection, std::vector<std::vector<tt::Frame>>& bits) const {
0144     bits.emplace_back();
0145     std::vector<tt::Frame>& bvs = bits.back();
0146     bvs.reserve(collection.size());
0147     std::transform(
0148         collection.begin(), collection.end(), std::back_inserter(bvs), [](const auto& frame) { return frame.second; });
0149   }
0150
0151 }  // namespace trackerTFP
0152
0153 DEFINE_FWK_MODULE(trackerTFP::AnalyzerDemonstrator);