Back to home page

Project CMSSW displayed by LXR
 
 

    

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

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 #include "DataFormats/Common/interface/OrphanHandle.h"
0013 
0014 #include "DataFormats/L1TrackTrigger/interface/TTTypes.h"
0015 #include "L1Trigger/TrackTrigger/interface/Setup.h"
0016 #include "L1Trigger/TrackerTFP/interface/DataFormats.h"
0017 #include "L1Trigger/TrackerTFP/interface/CleanTrackBuilder.h"
0018 
0019 #include <string>
0020 #include <vector>
0021 #include <deque>
0022 #include <iterator>
0023 #include <cmath>
0024 #include <numeric>
0025 #include <algorithm>
0026 
0027 namespace trackerTFP {
0028 
0029   /*! \class  trackerTFP::ProducerCTB
0030    *  \brief  clean HT tracks and rrestructures them
0031    *  \author Thomas Schuh
0032    *  \date   2020, July
0033    */
0034   class ProducerCTB : public edm::stream::EDProducer<> {
0035   public:
0036     explicit ProducerCTB(const edm::ParameterSet&);
0037     ~ProducerCTB() override = default;
0038 
0039   private:
0040     void beginRun(const edm::Run&, const edm::EventSetup&) override;
0041     void produce(edm::Event&, const edm::EventSetup&) override;
0042     // ED input token of Stubs
0043     edm::EDGetTokenT<tt::StreamsStub> edGetToken_;
0044     // ED output token for TTTracks
0045     edm::EDPutTokenT<tt::TTTracks> edPutTokenTTTracks_;
0046     // ED output token for stubs
0047     edm::EDPutTokenT<tt::StreamsStub> edPutTokenStubs_;
0048     // ED output token for tracks
0049     edm::EDPutTokenT<tt::StreamsTrack> edPutTokenTracks_;
0050     // Setup token
0051     edm::ESGetToken<tt::Setup, tt::SetupRcd> esGetTokenSetup_;
0052     // DataFormats token
0053     edm::ESGetToken<DataFormats, DataFormatsRcd> esGetTokenDataFormats_;
0054     // LayerEncoding token
0055     edm::ESGetToken<LayerEncoding, DataFormatsRcd> esGetTokenLayerEncoding_;
0056     //
0057     DataFormat cot_;
0058     // number of inpit channel
0059     int numChannelIn_;
0060     // number of output channel
0061     int numChannelOut_;
0062     // number of processing regions
0063     int numRegions_;
0064     // number of kf layers
0065     int numLayers_;
0066   };
0067 
0068   ProducerCTB::ProducerCTB(const edm::ParameterSet& iConfig) {
0069     const std::string& label = iConfig.getParameter<std::string>("InputLabelCTB");
0070     const std::string& branchStubs = iConfig.getParameter<std::string>("BranchStubs");
0071     const std::string& branchTracks = iConfig.getParameter<std::string>("BranchTracks");
0072     // book in- and output ED products
0073     edGetToken_ = consumes<tt::StreamsStub>(edm::InputTag(label, branchStubs));
0074     edPutTokenStubs_ = produces<tt::StreamsStub>(branchStubs);
0075     edPutTokenTTTracks_ = produces<tt::TTTracks>(branchTracks);
0076     edPutTokenTracks_ = produces<tt::StreamsTrack>(branchTracks);
0077     // book ES products
0078     esGetTokenSetup_ = esConsumes();
0079     esGetTokenDataFormats_ = esConsumes();
0080     esGetTokenLayerEncoding_ = esConsumes();
0081   }
0082 
0083   void ProducerCTB::beginRun(const edm::Run& iRun, const edm::EventSetup& iSetup) {
0084     const tt::Setup* setup = &iSetup.getData(esGetTokenSetup_);
0085     const DataFormats* dataFormats = &iSetup.getData(esGetTokenDataFormats_);
0086     numChannelIn_ = dataFormats->numChannel(Process::ht);
0087     numChannelOut_ = dataFormats->numChannel(Process::ctb);
0088     numRegions_ = setup->numRegions();
0089     numLayers_ = setup->numLayers();
0090     // create data format for cot(theta)
0091     const double baseZ = dataFormats->base(Variable::z, Process::ctb);
0092     const double baseR = dataFormats->base(Variable::r, Process::ctb);
0093     const double range = dataFormats->range(Variable::cot, Process::kf);
0094     const int baseShift = std::ceil(std::log2(range / baseZ * baseR / setup->ctbNumBinsCot()));
0095     const int width = std::ceil(std::log2(setup->ctbNumBinsCot()));
0096     const double base = baseZ / baseR * pow(2, baseShift);
0097     cot_ = DataFormat(true, width, base, range);
0098   }
0099 
0100   void ProducerCTB::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) {
0101     const tt::Setup* setup = &iSetup.getData(esGetTokenSetup_);
0102     const DataFormats* dataFormats = &iSetup.getData(esGetTokenDataFormats_);
0103     const LayerEncoding* layerEncoding = &iSetup.getData(esGetTokenLayerEncoding_);
0104     // empty output products
0105     tt::StreamsTrack acceptedTracks(numRegions_ * numChannelOut_);
0106     tt::StreamsStub acceptedStubs(numRegions_ * numChannelOut_ * numLayers_);
0107     std::vector<std::vector<std::deque<TrackCTB*>>> streamsTracks(numRegions_,
0108                                                                   std::vector<std::deque<TrackCTB*>>(numChannelOut_));
0109     std::vector<std::vector<std::vector<std::deque<StubCTB*>>>> streamsStubs(
0110         numRegions_,
0111         std::vector<std::vector<std::deque<StubCTB*>>>(numChannelOut_, std::vector<std::deque<StubCTB*>>(numLayers_)));
0112     // read input Product and produce output product
0113     const tt::StreamsStub& streamsStub = iEvent.get(edGetToken_);
0114     // count stubs
0115     int nStubsHT(0);
0116     auto validFrame = [](int sum, const tt::FrameStub& frame) { return sum + (frame.first.isNonnull() ? 1 : 0); };
0117     for (const tt::StreamStub& stream : streamsStub)
0118       nStubsHT += std::accumulate(stream.begin(), stream.end(), 0, validFrame);
0119     // create input objects and count tracks
0120     std::vector<StubHT> stubsHT;
0121     stubsHT.reserve(nStubsHT);
0122     // count stubs
0123     int nTracksHT(0);
0124     for (const tt::StreamStub& stream : streamsStub) {
0125       std::pair<int, int> trackId({setup->htNumBinsPhiT(), setup->gpNumBinsZT()});
0126       for (const tt::FrameStub& frame : stream) {
0127         if (frame.first.isNull())
0128           continue;
0129         stubsHT.emplace_back(frame, dataFormats);
0130         StubHT* stub = &stubsHT.back();
0131         if (trackId.first != stub->phiT() || trackId.second != stub->zT()) {
0132           nTracksHT++;
0133           trackId = {stub->phiT(), stub->zT()};
0134         }
0135       }
0136     }
0137     // object to clean and restructure tracks
0138     std::vector<StubCTB> stubsCTB;
0139     stubsCTB.reserve(nStubsHT);
0140     std::vector<TrackCTB> tracksCTB;
0141     tracksCTB.reserve(nTracksHT);
0142     CleanTrackBuilder ctb(setup, dataFormats, layerEncoding, cot_, stubsCTB, tracksCTB);
0143     int iStub(0);
0144     for (int region = 0; region < numRegions_; region++) {
0145       const int offsetIn = region * numChannelIn_;
0146       const int offsetOut = region * numChannelOut_;
0147       // read h/w liked organized pointer to input data
0148       std::vector<std::vector<StubHT*>> streamsIn(numChannelIn_);
0149       for (int channelIn = 0; channelIn < numChannelIn_; channelIn++) {
0150         const tt::StreamStub& channelStubs = streamsStub[offsetIn + channelIn];
0151         std::vector<StubHT*>& stream = streamsIn[channelIn];
0152         stream.reserve(channelStubs.size());
0153         for (const tt::FrameStub& frame : channelStubs)
0154           stream.push_back(frame.first.isNull() ? nullptr : &stubsHT[iStub++]);
0155       }
0156       // empty h/w liked organized pointer to output data
0157       std::vector<std::deque<TrackCTB*>>& regionTracks = streamsTracks[region];
0158       std::vector<std::vector<std::deque<StubCTB*>>>& regionStubs = streamsStubs[region];
0159       // fill output data
0160       ctb.produce(streamsIn, regionTracks, regionStubs);
0161       // fill ed stubs
0162       for (int channelOut = 0; channelOut < numChannelOut_; channelOut++) {
0163         const int offset = (offsetOut + channelOut) * numLayers_;
0164         const std::vector<std::deque<StubCTB*>>& channelStubs = regionStubs[channelOut];
0165         for (int layer = 0; layer < numLayers_; layer++) {
0166           tt::StreamStub& accepted = acceptedStubs[offset + layer];
0167           const std::deque<StubCTB*>& layerStubs = channelStubs[layer];
0168           accepted.reserve(layerStubs.size());
0169           for (StubCTB* stub : layerStubs)
0170             accepted.emplace_back(stub ? stub->frame() : tt::FrameStub());
0171         }
0172       }
0173     }
0174     // store TTTracks
0175     int nTracks(0);
0176     auto valid = [](int sum, TrackCTB* track) { return sum + (track ? 1 : 0); };
0177     for (const std::vector<std::deque<TrackCTB*>>& region : streamsTracks)
0178       for (const std::deque<TrackCTB*>& channel : region)
0179         nTracks += std::accumulate(channel.begin(), channel.end(), 0, valid);
0180     tt::TTTracks ttTracks;
0181     ttTracks.reserve(nTracks);
0182     for (int region = 0; region < numRegions_; region++) {
0183       const std::vector<std::deque<TrackCTB*>>& regionTracks = streamsTracks[region];
0184       const std::vector<std::vector<std::deque<StubCTB*>>>& regionStubs = streamsStubs[region];
0185       for (int channelOut = 0; channelOut < numChannelOut_; channelOut++) {
0186         const std::deque<TrackCTB*>& channelTracks = regionTracks[channelOut];
0187         const std::vector<std::deque<StubCTB*>>& channelStubs = regionStubs[channelOut];
0188         for (int frame = 0; frame < static_cast<int>(channelTracks.size()); frame++) {
0189           TrackCTB* track = channelTracks[frame];
0190           if (!track)
0191             continue;
0192           const auto begin = std::next(channelTracks.begin(), frame);
0193           const auto end = std::find_if(begin + 1, channelTracks.end(), [](TrackCTB* track) { return track; });
0194           const int size = std::distance(begin, end);
0195           std::vector<std::vector<StubCTB*>> stubs(numLayers_);
0196           for (int layer = 0; layer < numLayers_; layer++) {
0197             const std::deque<StubCTB*>& layerStubs = channelStubs[layer];
0198             std::vector<StubCTB*>& layerTrack = stubs[layer];
0199             layerTrack.reserve(size);
0200             for (int s = 0; s < size; s++) {
0201               StubCTB* stub = layerStubs[frame + s];
0202               if (stub)
0203                 layerTrack.push_back(stub);
0204             }
0205           }
0206           ctb.put(track, stubs, region, ttTracks);
0207         }
0208       }
0209     }
0210     const edm::OrphanHandle<tt::TTTracks> handle = iEvent.emplace(edPutTokenTTTracks_, std::move(ttTracks));
0211     // add TTTrackRefs
0212     int iTrk(0);
0213     int iChan(0);
0214     for (const std::vector<std::deque<TrackCTB*>>& region : streamsTracks) {
0215       for (const std::deque<TrackCTB*>& stream : region) {
0216         tt::StreamTrack& streamTrack = acceptedTracks[iChan++];
0217         for (TrackCTB* track : stream) {
0218           if (!track) {
0219             streamTrack.emplace_back(tt::FrameTrack());
0220             continue;
0221           }
0222           tt::FrameTrack frame = track->frame();
0223           frame.first = TTTrackRef(handle, iTrk++);
0224           streamTrack.emplace_back(frame);
0225         }
0226       }
0227     }
0228     // store tracks
0229     iEvent.emplace(edPutTokenTracks_, std::move(acceptedTracks));
0230     // store stubs
0231     iEvent.emplace(edPutTokenStubs_, std::move(acceptedStubs));
0232   }
0233 
0234 }  // namespace trackerTFP
0235 
0236 DEFINE_FWK_MODULE(trackerTFP::ProducerCTB);
[ 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!