TrackerTFP/plugins/ProducerKF.cc

0001 #include "FWCore/Framework/interface/stream/EDProducer.h"
0002 #include "FWCore/Framework/interface/Run.h"
0003 #include "FWCore/Framework/interface/EventSetup.h"
0004 #include "FWCore/Framework/interface/Event.h"
0005 #include "FWCore/Framework/interface/MakerMacros.h"
0006 #include "FWCore/Utilities/interface/EDGetToken.h"
0007 #include "FWCore/Utilities/interface/EDPutToken.h"
0008 #include "FWCore/Utilities/interface/ESGetToken.h"
0009 #include "FWCore/Utilities/interface/InputTag.h"
0010 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0011 #include "DataFormats/Common/interface/Handle.h"
0012
0013 #include "DataFormats/L1TrackTrigger/interface/TTTypes.h"
0014 #include "L1Trigger/TrackTrigger/interface/Setup.h"
0015 #include "L1Trigger/TrackerTFP/interface/DataFormats.h"
0016 #include "L1Trigger/TrackerTFP/interface/KalmanFilterFormats.h"
0017 #include "L1Trigger/TrackerTFP/interface/LayerEncoding.h"
0018 #include "L1Trigger/TrackerTFP/interface/KalmanFilter.h"
0019
0020 #include <string>
0021 #include <vector>
0022 #include <utility>
0023
0024 namespace trackerTFP {
0025
0026   /*! \class  trackerTFP::ProducerKF
0027    *  \brief  L1TrackTrigger Kamlan Filter emulator
0028    *  \author Thomas Schuh
0029    *  \date   2020, July
0030    */
0031   class ProducerKF : public edm::stream::EDProducer<> {
0032   public:
0033     explicit ProducerKF(const edm::ParameterSet&);
0034     ~ProducerKF() override = default;
0035
0036   private:
0037     typedef State::Stub Stub;
0038     void beginRun(const edm::Run&, const edm::EventSetup&) override;
0039     void produce(edm::Event&, const edm::EventSetup&) override;
0040     void endStream() override {
0041       std::stringstream ss;
0042       if (printDebug_)
0043         kalmanFilterFormats_.endJob(ss);
0044       edm::LogPrint(moduleDescription().moduleName()) << ss.str();
0045     }
0046     // ED input token of sf stubs and tracks
0047     edm::EDGetTokenT<tt::StreamsStub> edGetTokenStubs_;
0048     edm::EDGetTokenT<tt::StreamsTrack> edGetTokenTracks_;
0049     // ED output token for accepted stubs and tracks
0050     edm::EDPutTokenT<tt::StreamsStub> edPutTokenStubs_;
0051     edm::EDPutTokenT<tt::StreamsTrack> edPutTokenTracks_;
0052     // ED output token for number of accepted and lost States
0053     edm::EDPutTokenT<int> edPutTokenNumStatesAccepted_;
0054     edm::EDPutTokenT<int> edPutTokenNumStatesTruncated_;
0055     // ED output token for chi2s in r-phi and r-z plane
0056     edm::EDPutTokenT<std::vector<std::pair<double, double>>> edPutTokenChi2s_;
0057     // Setup token
0058     edm::ESGetToken<tt::Setup, tt::SetupRcd> esGetTokenSetup_;
0059     // DataFormats token
0060     edm::ESGetToken<DataFormats, DataFormatsRcd> esGetTokenDataFormats_;
0061     // LayerEncoding token
0062     edm::ESGetToken<LayerEncoding, DataFormatsRcd> esGetTokenLayerEncoding_;
0063     // helper class to tune internal kf variables
0064     KalmanFilterFormats kalmanFilterFormats_;
0065     // KalmanFilterFormats configuraation
0066     ConfigKF iConfig_;
0067     // print end job internal unused MSB
0068     bool printDebug_;
0069     // number of channels
0070     int numChannel_;
0071     // number of processing regions
0072     int numRegions_;
0073     // number of kf layers
0074     int numLayers_;
0075   };
0076
0077   ProducerKF::ProducerKF(const edm::ParameterSet& iConfig) {
0078     // KalmanFilterFormats configuraation
0079     iConfig_.enableIntegerEmulation_ = iConfig.getParameter<bool>("EnableIntegerEmulation");
0080     iConfig_.widthR00_ = iConfig.getParameter<int>("WidthR00");
0081     iConfig_.widthR11_ = iConfig.getParameter<int>("WidthR11");
0082     iConfig_.widthC00_ = iConfig.getParameter<int>("WidthC00");
0083     iConfig_.widthC01_ = iConfig.getParameter<int>("WidthC01");
0084     iConfig_.widthC11_ = iConfig.getParameter<int>("WidthC11");
0085     iConfig_.widthC22_ = iConfig.getParameter<int>("WidthC22");
0086     iConfig_.widthC23_ = iConfig.getParameter<int>("WidthC23");
0087     iConfig_.widthC33_ = iConfig.getParameter<int>("WidthC33");
0088     iConfig_.baseShiftx0_ = iConfig.getParameter<int>("BaseShiftx0");
0089     iConfig_.baseShiftx1_ = iConfig.getParameter<int>("BaseShiftx1");
0090     iConfig_.baseShiftx2_ = iConfig.getParameter<int>("BaseShiftx2");
0091     iConfig_.baseShiftx3_ = iConfig.getParameter<int>("BaseShiftx3");
0092     iConfig_.baseShiftr0_ = iConfig.getParameter<int>("BaseShiftr0");
0093     iConfig_.baseShiftr1_ = iConfig.getParameter<int>("BaseShiftr1");
0094     iConfig_.baseShiftS00_ = iConfig.getParameter<int>("BaseShiftS00");
0095     iConfig_.baseShiftS01_ = iConfig.getParameter<int>("BaseShiftS01");
0096     iConfig_.baseShiftS12_ = iConfig.getParameter<int>("BaseShiftS12");
0097     iConfig_.baseShiftS13_ = iConfig.getParameter<int>("BaseShiftS13");
0098     iConfig_.baseShiftR00_ = iConfig.getParameter<int>("BaseShiftR00");
0099     iConfig_.baseShiftR11_ = iConfig.getParameter<int>("BaseShiftR11");
0100     iConfig_.baseShiftInvR00Approx_ = iConfig.getParameter<int>("BaseShiftInvR00Approx");
0101     iConfig_.baseShiftInvR11Approx_ = iConfig.getParameter<int>("BaseShiftInvR11Approx");
0102     iConfig_.baseShiftInvR00Cor_ = iConfig.getParameter<int>("BaseShiftInvR00Cor");
0103     iConfig_.baseShiftInvR11Cor_ = iConfig.getParameter<int>("BaseShiftInvR11Cor");
0104     iConfig_.baseShiftInvR00_ = iConfig.getParameter<int>("BaseShiftInvR00");
0105     iConfig_.baseShiftInvR11_ = iConfig.getParameter<int>("BaseShiftInvR11");
0106     iConfig_.baseShiftS00Shifted_ = iConfig.getParameter<int>("BaseShiftS00Shifted");
0107     iConfig_.baseShiftS01Shifted_ = iConfig.getParameter<int>("BaseShiftS01Shifted");
0108     iConfig_.baseShiftS12Shifted_ = iConfig.getParameter<int>("BaseShiftS12Shifted");
0109     iConfig_.baseShiftS13Shifted_ = iConfig.getParameter<int>("BaseShiftS13Shifted");
0110     iConfig_.baseShiftK00_ = iConfig.getParameter<int>("BaseShiftK00");
0111     iConfig_.baseShiftK10_ = iConfig.getParameter<int>("BaseShiftK10");
0112     iConfig_.baseShiftK21_ = iConfig.getParameter<int>("BaseShiftK21");
0113     iConfig_.baseShiftK31_ = iConfig.getParameter<int>("BaseShiftK31");
0114     iConfig_.baseShiftC00_ = iConfig.getParameter<int>("BaseShiftC00");
0115     iConfig_.baseShiftC01_ = iConfig.getParameter<int>("BaseShiftC01");
0116     iConfig_.baseShiftC11_ = iConfig.getParameter<int>("BaseShiftC11");
0117     iConfig_.baseShiftC22_ = iConfig.getParameter<int>("BaseShiftC22");
0118     iConfig_.baseShiftC23_ = iConfig.getParameter<int>("BaseShiftC23");
0119     iConfig_.baseShiftC33_ = iConfig.getParameter<int>("BaseShiftC33");
0120     iConfig_.baseShiftr0Shifted_ = iConfig.getParameter<int>("BaseShiftr0Shifted");
0121     iConfig_.baseShiftr1Shifted_ = iConfig.getParameter<int>("BaseShiftr1Shifted");
0122     iConfig_.baseShiftr02_ = iConfig.getParameter<int>("BaseShiftr02");
0123     iConfig_.baseShiftr12_ = iConfig.getParameter<int>("BaseShiftr12");
0124     iConfig_.baseShiftchi20_ = iConfig.getParameter<int>("BaseShiftchi20");
0125     iConfig_.baseShiftchi21_ = iConfig.getParameter<int>("BaseShiftchi21");
0126     printDebug_ = iConfig.getParameter<bool>("PrintKFDebug");
0127     const std::string& label = iConfig.getParameter<std::string>("InputLabelKF");
0128     const std::string& branchStubs = iConfig.getParameter<std::string>("BranchStubs");
0129     const std::string& branchTracks = iConfig.getParameter<std::string>("BranchTracks");
0130     const std::string& branchTruncated = iConfig.getParameter<std::string>("BranchTruncated");
0131     // book in- and output ED products
0132     edGetTokenStubs_ = consumes<tt::StreamsStub>(edm::InputTag(label, branchStubs));
0133     edGetTokenTracks_ = consumes<tt::StreamsTrack>(edm::InputTag(label, branchTracks));
0134     edPutTokenStubs_ = produces<tt::StreamsStub>(branchStubs);
0135     edPutTokenTracks_ = produces<tt::StreamsTrack>(branchTracks);
0136     edPutTokenNumStatesAccepted_ = produces<int>(branchTracks);
0137     edPutTokenNumStatesTruncated_ = produces<int>(branchTruncated);
0138     edPutTokenChi2s_ = produces<std::vector<std::pair<double, double>>>(branchTracks);
0139     // book ES products
0140     esGetTokenSetup_ = esConsumes();
0141     esGetTokenDataFormats_ = esConsumes();
0142     esGetTokenLayerEncoding_ = esConsumes();
0143   }
0144
0145   void ProducerKF::beginRun(const edm::Run& iRun, const edm::EventSetup& iSetup) {
0146     const tt::Setup* setup = &iSetup.getData(esGetTokenSetup_);
0147     numRegions_ = setup->numRegions();
0148     numLayers_ = setup->numLayers();
0149     const DataFormats* dataFormats = &iSetup.getData(esGetTokenDataFormats_);
0150     numChannel_ = dataFormats->numChannel(Process::kf);
0151     kalmanFilterFormats_.beginRun(dataFormats, iConfig_);
0152   }
0153
0154   void ProducerKF::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) {
0155     // helper class to store configurations
0156     const tt::Setup* setup = &iSetup.getData(esGetTokenSetup_);
0157     // helper class to extract structured data from tt::Frames
0158     const DataFormats* dataFormats = &iSetup.getData(esGetTokenDataFormats_);
0159     // helper class to encode layer
0160     const LayerEncoding* layerEncoding = &iSetup.getData(esGetTokenLayerEncoding_);
0161     // empty KF products
0162     tt::StreamsStub acceptedStubs(numRegions_ * numChannel_ * numLayers_);
0163     tt::StreamsTrack acceptedTracks(numRegions_ * numChannel_);
0164     int numStatesAccepted(0);
0165     int numStatesTruncated(0);
0166     std::deque<std::pair<double, double>> chi2s;
0167     // read in SF Product and produce KF product
0168     const tt::StreamsStub& allStubs = iEvent.get(edGetTokenStubs_);
0169     const tt::StreamsTrack& allTracks = iEvent.get(edGetTokenTracks_);
0170     // helper
0171     auto validFrameT = [](int sum, const tt::FrameTrack& frame) { return sum + (frame.first.isNonnull() ? 1 : 0); };
0172     auto validFrameS = [](int sum, const tt::FrameStub& frame) { return sum + (frame.first.isNonnull() ? 1 : 0); };
0173     auto putT = [](const std::vector<TrackKF*>& objects, tt::StreamTrack& stream) {
0174       auto toFrame = [](TrackKF* object) { return object ? object->frame() : tt::FrameTrack(); };
0175       stream.reserve(objects.size());
0176       std::transform(objects.begin(), objects.end(), std::back_inserter(stream), toFrame);
0177     };
0178     auto putS = [](const std::vector<StubKF*>& objects, tt::StreamStub& stream) {
0179       auto toFrame = [](StubKF* object) { return object ? object->frame() : tt::FrameStub(); };
0180       stream.reserve(objects.size());
0181       std::transform(objects.begin(), objects.end(), std::back_inserter(stream), toFrame);
0182     };
0183     for (int region = 0; region < numRegions_; region++) {
0184       const int offset = region * numChannel_;
0185       // count input objects
0186       int nTracks(0);
0187       int nStubs(0);
0188       for (int channel = 0; channel < numChannel_; channel++) {
0189         const int index = offset + channel;
0190         const int offsetStubs = index * numLayers_;
0191         const tt::StreamTrack& tracks = allTracks[index];
0192         nTracks += std::accumulate(tracks.begin(), tracks.end(), 0, validFrameT);
0193         for (int layer = 0; layer < numLayers_; layer++) {
0194           const tt::StreamStub& stubs = allStubs[offsetStubs + layer];
0195           nStubs += std::accumulate(stubs.begin(), stubs.end(), 0, validFrameS);
0196         }
0197       }
0198       // storage of input data
0199       std::vector<TrackCTB> tracksCTB;
0200       tracksCTB.reserve(nTracks);
0201       std::vector<Stub> stubs;
0202       stubs.reserve(nStubs);
0203       // h/w liked organized pointer to input data
0204       std::vector<std::vector<TrackCTB*>> regionTracks(numChannel_);
0205       std::vector<std::vector<Stub*>> regionStubs(numChannel_ * numLayers_);
0206       // read input data
0207       for (int channel = 0; channel < numChannel_; channel++) {
0208         const int index = offset + channel;
0209         const int offsetAll = index * numLayers_;
0210         const int offsetRegion = channel * numLayers_;
0211         const tt::StreamTrack& streamTrack = allTracks[index];
0212         std::vector<TrackCTB*>& tracks = regionTracks[channel];
0213         tracks.reserve(streamTrack.size());
0214         for (const tt::FrameTrack& frame : streamTrack) {
0215           TrackCTB* track = nullptr;
0216           if (frame.first.isNonnull()) {
0217             tracksCTB.emplace_back(frame, dataFormats);
0218             track = &tracksCTB.back();
0219           }
0220           tracks.push_back(track);
0221         }
0222         for (int layer = 0; layer < numLayers_; layer++) {
0223           for (const tt::FrameStub& frame : allStubs[offsetAll + layer]) {
0224             Stub* stub = nullptr;
0225             if (frame.first.isNonnull()) {
0226               stubs.emplace_back(&kalmanFilterFormats_, frame);
0227               stub = &stubs.back();
0228             }
0229             regionStubs[offsetRegion + layer].push_back(stub);
0230           }
0231         }
0232       }
0233       // empty storage of output data
0234       std::vector<TrackKF> tracksKF;
0235       tracksKF.reserve(nTracks);
0236       std::vector<StubKF> stubsKF;
0237       stubsKF.reserve(nStubs);
0238       // object to fit tracks in a processing region
0239       KalmanFilter kf(setup, dataFormats, layerEncoding, &kalmanFilterFormats_, tracksKF, stubsKF);
0240       // empty h/w liked organized pointer to output data
0241       std::vector<std::vector<TrackKF*>> streamsTrack(numChannel_);
0242       std::vector<std::vector<std::vector<StubKF*>>> streamsStub(numChannel_,
0243                                                                  std::vector<std::vector<StubKF*>>(numLayers_));
0244       // fill output products
0245       kf.produce(regionTracks, regionStubs, streamsTrack, streamsStub, numStatesAccepted, numStatesTruncated, chi2s);
0246       // convert data to ed products
0247       for (int channel = 0; channel < numChannel_; channel++) {
0248         const int index = offset + channel;
0249         const int offsetStubs = index * numLayers_;
0250         putT(streamsTrack[channel], acceptedTracks[index]);
0251         for (int layer = 0; layer < numLayers_; layer++)
0252           putS(streamsStub[channel][layer], acceptedStubs[offsetStubs + layer]);
0253       }
0254     }
0255     // store products
0256     iEvent.emplace(edPutTokenStubs_, std::move(acceptedStubs));
0257     iEvent.emplace(edPutTokenTracks_, std::move(acceptedTracks));
0258     iEvent.emplace(edPutTokenNumStatesAccepted_, numStatesAccepted);
0259     iEvent.emplace(edPutTokenNumStatesTruncated_, numStatesTruncated);
0260     iEvent.emplace(edPutTokenChi2s_, chi2s.begin(), chi2s.end());
0261   }
0262
0263 }  // namespace trackerTFP
0264
0265 DEFINE_FWK_MODULE(trackerTFP::ProducerKF);