Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2025-06-03 00:12:25 

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 #include "L1Trigger/TrackFindingTracklet/interface/ChannelAssignment.h"
0015 
0016 #include <sstream>
0017 #include <utility>
0018 #include <numeric>
0019 
0020 namespace trklet {
0021 
0022   /*! \class  trklet::AnalyzerDemonstrator
0023    *  \brief  calls questasim to simulate the f/w and compares the results with clock-and-bit-accurate emulation.
0024    *          At the end the number of passing events (not a single bit error) are reported.
0025    *  \author Thomas Schuh
0026    *  \date   2022, March
0027    */
0028   class AnalyzerDemonstrator : public edm::one::EDAnalyzer<edm::one::WatchRuns> {
0029   public:
0030     AnalyzerDemonstrator(const edm::ParameterSet& iConfig);
0031     void beginJob() override {}
0032     void beginRun(const edm::Run& iEvent, const edm::EventSetup& iSetup) override;
0033     void analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) override;
0034     void endRun(const edm::Run& iEvent, const edm::EventSetup& iSetup) override {}
0035     void endJob() override;
0036 
0037   private:
0038     //
0039     void convert(const edm::Event& iEvent,
0040                  const edm::EDGetTokenT<tt::StreamsTrack>& tokenTracks,
0041                  const edm::EDGetTokenT<tt::StreamsStub>& tokenStubs,
0042                  std::vector<std::vector<tt::Frame>>& bits,
0043                  bool TB = false) const;
0044     //
0045     template <typename T>
0046     void convert(const T& collection, std::vector<std::vector<tt::Frame>>& bits) const;
0047     // ED input token of Tracks
0048     edm::EDGetTokenT<tt::StreamsStub> edGetTokenStubsIn_;
0049     edm::EDGetTokenT<tt::StreamsStub> edGetTokenStubsOut_;
0050     // ED input token of Stubs
0051     edm::EDGetTokenT<tt::StreamsTrack> edGetTokenTracksIn_;
0052     edm::EDGetTokenT<tt::StreamsTrack> edGetTokenTracksOut_;
0053     // Setup token
0054     edm::ESGetToken<tt::Setup, tt::SetupRcd> esGetTokenSetup_;
0055     // ChannelAssignment token
0056     edm::ESGetToken<ChannelAssignment, ChannelAssignmentRcd> esGetTokenChannelAssignment_;
0057     // Demonstrator token
0058     edm::ESGetToken<trackerTFP::Demonstrator, tt::SetupRcd> esGetTokenDemonstrator_;
0059     //
0060     const tt::Setup* setup_ = nullptr;
0061     //
0062     const ChannelAssignment* channelAssignment_ = nullptr;
0063     //
0064     const trackerTFP::Demonstrator* demonstrator_ = nullptr;
0065     //
0066     int nEvents_ = 0;
0067     //
0068     int nEventsSuccessful_ = 0;
0069     //
0070     bool TBin_;
0071     bool TBout_;
0072   };
0073 
0074   AnalyzerDemonstrator::AnalyzerDemonstrator(const edm::ParameterSet& iConfig) {
0075     // book in- and output ED products
0076     const std::string& labelIn = iConfig.getParameter<std::string>("LabelIn");
0077     const std::string& labelOut = iConfig.getParameter<std::string>("LabelOut");
0078     const std::string& branchStubs = iConfig.getParameter<std::string>("BranchStubs");
0079     const std::string& branchTracks = iConfig.getParameter<std::string>("BranchTracks");
0080     edGetTokenStubsIn_ = consumes<tt::StreamsStub>(edm::InputTag(labelIn, branchStubs));
0081     edGetTokenStubsOut_ = consumes<tt::StreamsStub>(edm::InputTag(labelOut, branchStubs));
0082     if (labelIn != "ProducerIRin")
0083       edGetTokenTracksIn_ = consumes<tt::StreamsTrack>(edm::InputTag(labelIn, branchTracks));
0084     if (labelOut != "ProducerIRin")
0085       edGetTokenTracksOut_ = consumes<tt::StreamsTrack>(edm::InputTag(labelOut, branchTracks));
0086     // book ES products
0087     esGetTokenSetup_ = esConsumes<edm::Transition::BeginRun>();
0088     esGetTokenChannelAssignment_ = esConsumes<edm::Transition::BeginRun>();
0089     esGetTokenDemonstrator_ = esConsumes<edm::Transition::BeginRun>();
0090     //
0091     TBin_ = labelIn == "l1tTTTracksFromTrackletEmulation";
0092     TBout_ = labelOut == "l1tTTTracksFromTrackletEmulation";
0093   }
0094 
0095   void AnalyzerDemonstrator::beginRun(const edm::Run& iEvent, const edm::EventSetup& iSetup) {
0096     //
0097     setup_ = &iSetup.getData(esGetTokenSetup_);
0098     //
0099     channelAssignment_ = &iSetup.getData(esGetTokenChannelAssignment_);
0100     //
0101     demonstrator_ = &iSetup.getData(esGetTokenDemonstrator_);
0102   }
0103 
0104   void AnalyzerDemonstrator::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) {
0105     nEvents_++;
0106     std::vector<std::vector<tt::Frame>> input;
0107     std::vector<std::vector<tt::Frame>> output;
0108     convert(iEvent, edGetTokenTracksIn_, edGetTokenStubsIn_, input, TBin_);
0109     convert(iEvent, edGetTokenTracksOut_, edGetTokenStubsOut_, output, TBout_);
0110     if (demonstrator_->analyze(input, output))
0111       nEventsSuccessful_++;
0112   }
0113 
0114   //
0115   void AnalyzerDemonstrator::convert(const edm::Event& iEvent,
0116                                      const edm::EDGetTokenT<tt::StreamsTrack>& tokenTracks,
0117                                      const edm::EDGetTokenT<tt::StreamsStub>& tokenStubs,
0118                                      std::vector<std::vector<tt::Frame>>& bits,
0119                                      bool TB) const {
0120     const bool tracks = !tokenTracks.isUninitialized();
0121     const bool stubs = !tokenStubs.isUninitialized();
0122     edm::Handle<tt::StreamsStub> handleStubs;
0123     edm::Handle<tt::StreamsTrack> handleTracks;
0124     int numChannelStubs(0);
0125     if (stubs) {
0126       iEvent.getByToken<tt::StreamsStub>(tokenStubs, handleStubs);
0127       numChannelStubs = handleStubs->size();
0128     }
0129     int numChannelTracks(0);
0130     if (tracks) {
0131       iEvent.getByToken<tt::StreamsTrack>(tokenTracks, handleTracks);
0132       numChannelTracks = handleTracks->size();
0133     }
0134     numChannelTracks /= setup_->numRegions();
0135     numChannelStubs /= (setup_->numRegions() * (tracks ? numChannelTracks : 1));
0136     if (TB)
0137       numChannelStubs = channelAssignment_->numChannelsStub();
0138     bits.reserve(numChannelTracks + numChannelStubs);
0139     for (int region = 0; region < setup_->numRegions(); region++) {
0140       if (tracks) {
0141         const int offsetTracks = region * numChannelTracks;
0142         for (int channelTracks = 0; channelTracks < numChannelTracks; channelTracks++) {
0143           int offsetStubs = (region * numChannelTracks + channelTracks) * numChannelStubs;
0144           if (TB) {
0145             numChannelStubs =
0146                 channelAssignment_->numProjectionLayers(channelTracks) + channelAssignment_->numSeedingLayers();
0147             offsetStubs = channelAssignment_->offsetStub(offsetTracks + channelTracks);
0148           }
0149           if (tracks)
0150             convert(handleTracks->at(offsetTracks + channelTracks), bits);
0151           if (stubs) {
0152             for (int channelStubs = 0; channelStubs < numChannelStubs; channelStubs++)
0153               convert(handleStubs->at(offsetStubs + channelStubs), bits);
0154           }
0155         }
0156       } else {
0157         const int offsetStubs = region * numChannelStubs;
0158         for (int channelStubs = 0; channelStubs < numChannelStubs; channelStubs++)
0159           convert(handleStubs->at(offsetStubs + channelStubs), bits);
0160       }
0161     }
0162   }
0163 
0164   //
0165   template <typename T>
0166   void AnalyzerDemonstrator::convert(const T& collection, std::vector<std::vector<tt::Frame>>& bits) const {
0167     bits.emplace_back();
0168     std::vector<tt::Frame>& bvs = bits.back();
0169     bvs.reserve(collection.size());
0170     transform(collection.begin(), collection.end(), back_inserter(bvs), [](const auto& frame) { return frame.second; });
0171   }
0172 
0173   void AnalyzerDemonstrator::endJob() {
0174     std::stringstream log;
0175     log << "Successrate: " << nEventsSuccessful_ << " / " << nEvents_ << " = " << nEventsSuccessful_ / (double)nEvents_;
0176     edm::LogPrint(moduleDescription().moduleName()) << log.str();
0177   }
0178 
0179 }  // namespace trklet
0180 
0181 DEFINE_FWK_MODULE(trklet::AnalyzerDemonstrator);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.2.1 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!