diff --git a/DataFormats/L1TrackTrigger/interface/TTTypes.h b/DataFormats/L1TrackTrigger/interface/TTTypes.h index 379cfed2375bc..cd39890561977 100644 --- a/DataFormats/L1TrackTrigger/interface/TTTypes.h +++ b/DataFormats/L1TrackTrigger/interface/TTTypes.h @@ -62,8 +62,10 @@ namespace tt { typedef std::pair FrameTrack; typedef std::vector StreamStub; typedef std::vector StreamTrack; + typedef std::vector Stream; typedef std::vector StreamsStub; typedef std::vector StreamsTrack; + typedef std::vector Streams; typedef std::map TTTrackRefMap; typedef std::vector> TTTracks; } // namespace tt diff --git a/DataFormats/L1TrackTrigger/src/classes_def.xml b/DataFormats/L1TrackTrigger/src/classes_def.xml index aed30dd75180b..8aeebb2e3bcb3 100644 --- a/DataFormats/L1TrackTrigger/src/classes_def.xml +++ b/DataFormats/L1TrackTrigger/src/classes_def.xml @@ -38,8 +38,10 @@ + + diff --git a/L1Trigger/TrackFindingTracklet/interface/ChannelAssignment.h b/L1Trigger/TrackFindingTracklet/interface/ChannelAssignment.h index 86ac64270cfab..4c74e19d2a402 100644 --- a/L1Trigger/TrackFindingTracklet/interface/ChannelAssignment.h +++ b/L1Trigger/TrackFindingTracklet/interface/ChannelAssignment.h @@ -26,8 +26,10 @@ namespace trklet { bool channelId(const TTTrackRef& ttTrackRef, int& channelId); // number of used channels int numChannels() const { return numChannels_; } - // sets layerId (0-7 in sequence the seed type projects to) of given TTStubRef and TTTrackRef, returns false if seeed stub - bool layerId(const TTTrackRef& ttTrackRef, const TTStubRef& ttStubRef, int& layerId); + // sets layerId (0-7 in sequence the seed type projects to) of given TTStubRef and seedType, returns false if seeed stub + bool layerId(int seedType, const TTStubRef& ttStubRef, int& layerId) const; + // return tracklet layerId (barrel: [0-5], endcap: [6-10]) for given TTStubRef + int trackletLayerId(const TTStubRef& ttStubRef) const { return setup_->trackletLayerId(ttStubRef); }; // max number layers a sedd type may project to int maxNumProjectionLayers() const { return maxNumProjectionLayers_; } // map of used DTC tfp channels in InputRouter diff --git a/L1Trigger/TrackFindingTracklet/interface/FitTrack.h b/L1Trigger/TrackFindingTracklet/interface/FitTrack.h index e72c4cf664132..6b46739b32665 100644 --- a/L1Trigger/TrackFindingTracklet/interface/FitTrack.h +++ b/L1Trigger/TrackFindingTracklet/interface/FitTrack.h @@ -5,8 +5,10 @@ #include "L1Trigger/TrackFindingTracklet/interface/TrackletParametersMemory.h" #include "L1Trigger/TrackFindingTracklet/interface/FullMatchMemory.h" #include "L1Trigger/TrackFindingTracklet/interface/TrackFitMemory.h" +#include "L1Trigger/TrackFindingTracklet/interface/ChannelAssignment.h" #include +#include namespace trklet { @@ -38,7 +40,10 @@ namespace trklet { std::vector orderedMatches(std::vector& fullmatch); - void execute(unsigned int iSector); + void execute(const ChannelAssignment* channelAssignment, + std::deque& streamTrack, + std::vector>& streamsStub, + unsigned int iSector); private: std::vector seedtracklet_; diff --git a/L1Trigger/TrackFindingTracklet/interface/L1TStub.h b/L1Trigger/TrackFindingTracklet/interface/L1TStub.h index 95a85bdaf4f1a..484836bc6aea9 100644 --- a/L1Trigger/TrackFindingTracklet/interface/L1TStub.h +++ b/L1Trigger/TrackFindingTracklet/interface/L1TStub.h @@ -2,6 +2,7 @@ #define L1Trigger_TrackFindingTracklet_interface_L1TStub_h #include "L1Trigger/TrackFindingTracklet/interface/Settings.h" +#include "DataFormats/L1TrackTrigger/interface/TTTypes.h" #include #include @@ -26,7 +27,8 @@ namespace trklet { double z, double bend, double strip, - std::vector tps); + std::vector tps, + const TTStubRef& ttStubRef); ~L1TStub() = default; @@ -107,6 +109,8 @@ namespace trklet { const std::string& stubword() const { return stubword_; } + TTStubRef ttStubRef() const { return ttStubRef_; } + private: int layerdisk_; std::string DTClink_; @@ -131,6 +135,7 @@ namespace trklet { unsigned int isPSmodule_; unsigned int isFlipped_; + TTStubRef ttStubRef_; }; }; // namespace trklet #endif diff --git a/L1Trigger/TrackFindingTracklet/interface/SLHCEvent.h b/L1Trigger/TrackFindingTracklet/interface/SLHCEvent.h index 74dfc0d22d3fd..6e41e3b475bae 100644 --- a/L1Trigger/TrackFindingTracklet/interface/SLHCEvent.h +++ b/L1Trigger/TrackFindingTracklet/interface/SLHCEvent.h @@ -39,7 +39,8 @@ namespace trklet { double z, double bend, double strip, - std::vector tps); + std::vector tpstt, + const TTStubRef& ttStubRef); const L1TStub& lastStub() const { return stubs_.back(); } diff --git a/L1Trigger/TrackFindingTracklet/interface/Sector.h b/L1Trigger/TrackFindingTracklet/interface/Sector.h index ab3d67bdb39e7..3ce971b0b6fc0 100644 --- a/L1Trigger/TrackFindingTracklet/interface/Sector.h +++ b/L1Trigger/TrackFindingTracklet/interface/Sector.h @@ -4,6 +4,7 @@ #include "L1Trigger/TrackFindingTracklet/interface/L1TStub.h" #include "L1Trigger/TrackFindingTracklet/interface/SLHCEvent.h" +#include "L1Trigger/TrackFindingTracklet/interface/ChannelAssignment.h" #include #include @@ -114,7 +115,7 @@ namespace trklet { void executeME(); void executeMC(); void executeMP(); - void executeFT(); + void executeFT(const ChannelAssignment* channelAssignment, tt::Streams& streamsTrack, tt::StreamsStub& streamsStub); void executePD(std::vector& tracks); std::vector getAllTracklets() const; diff --git a/L1Trigger/TrackFindingTracklet/interface/Settings.h b/L1Trigger/TrackFindingTracklet/interface/Settings.h index 2b2c6254e1d4e..7c6f48202a295 100644 --- a/L1Trigger/TrackFindingTracklet/interface/Settings.h +++ b/L1Trigger/TrackFindingTracklet/interface/Settings.h @@ -241,6 +241,10 @@ namespace trklet { bool doMultipleMatches() const { return doMultipleMatches_; } bool fakefit() const { return fakefit_; } void setFakefit(bool fakefit) { fakefit_ = fakefit; } + bool storeTrackBuilderOutput() const { return storeTrackBuilderOutput_; } + void setStoreTrackBuilderOutput(bool storeTrackBuilderOutput) { + storeTrackBuilderOutput_ = storeTrackBuilderOutput_; + } // configurable unsigned int nHelixPar() const { return nHelixPar_; } @@ -769,7 +773,7 @@ namespace trklet { //IR should be set to 108 to match the FW for the summer chain, but ultimately should be at 156 std::unordered_map maxstep_{{"IR", 156}, //IR will run at a higher clock speed to handle //input links running at 25 Gbits/s - //Set to 108 to match firmware project 240 MHz clock + //Set to 108 to match firmware project 240 MHz clock {"VMR", 107}, {"TE", 107}, @@ -905,6 +909,8 @@ namespace trklet { // if true, run a dummy fit, producing TTracks directly from output of tracklet pattern reco stage bool fakefit_{false}; + // if true EDProducer fills additionaly bit and clock accurate TrackBuilder EDProduct + bool storeTrackBuilderOutput_{false}; unsigned int nHelixPar_{4}; // 4 or 5 param helix fit bool extended_{false}; // turn on displaced tracking diff --git a/L1Trigger/TrackFindingTracklet/interface/TrackletEventProcessor.h b/L1Trigger/TrackFindingTracklet/interface/TrackletEventProcessor.h index 114b2f0e32dc5..fe5ddfd6cc999 100644 --- a/L1Trigger/TrackFindingTracklet/interface/TrackletEventProcessor.h +++ b/L1Trigger/TrackFindingTracklet/interface/TrackletEventProcessor.h @@ -3,10 +3,12 @@ #define L1Trigger_TrackFindingTracklet_interface_TrackletEventProcessor_h #include "L1Trigger/TrackFindingTracklet/interface/Timer.h" +#include "L1Trigger/TrackFindingTracklet/interface/ChannelAssignment.h" #include #include #include +#include #include namespace trklet { @@ -24,7 +26,7 @@ namespace trklet { ~TrackletEventProcessor(); - void init(Settings const& theSettings); + void init(Settings const& theSettings, const ChannelAssignment* channelAssignment); void event(SLHCEvent& ev); @@ -32,10 +34,13 @@ namespace trklet { const std::vector& tracks() const { return tracks_; } + void produce(tt::Streams& streamsTrack, tt::StreamsStub& streamsStub); + private: void configure(std::istream& inwire, std::istream& inmem, std::istream& inproc); const Settings* settings_{nullptr}; + const ChannelAssignment* channelAssignment_{nullptr}; std::unique_ptr globals_; @@ -63,6 +68,8 @@ namespace trklet { Timer PDTimer_; std::vector tracks_; + tt::Streams streamsTrack_; + tt::StreamsStub streamsStub_; }; }; // namespace trklet diff --git a/L1Trigger/TrackFindingTracklet/plugins/L1FPGATrackProducer.cc b/L1Trigger/TrackFindingTracklet/plugins/L1FPGATrackProducer.cc index 6e4c74413e2e2..704f64198c646 100644 --- a/L1Trigger/TrackFindingTracklet/plugins/L1FPGATrackProducer.cc +++ b/L1Trigger/TrackFindingTracklet/plugins/L1FPGATrackProducer.cc @@ -83,6 +83,10 @@ #include "L1Trigger/TrackFindingTracklet/interface/Sector.h" #include "L1Trigger/TrackFindingTracklet/interface/Track.h" #include "L1Trigger/TrackFindingTracklet/interface/TrackletEventProcessor.h" +#include "L1Trigger/TrackFindingTracklet/interface/ChannelAssignment.h" +#include "L1Trigger/TrackFindingTracklet/interface/Tracklet.h" +#include "L1Trigger/TrackFindingTracklet/interface/Residual.h" +#include "L1Trigger/TrackFindingTracklet/interface/Stub.h" //////////////// // PHYSICS TOOLS @@ -106,6 +110,8 @@ // NAMESPACES using namespace edm; using namespace std; +using namespace tt; +using namespace trklet; ////////////////////////////// // // @@ -159,9 +165,6 @@ class L1FPGATrackProducer : public edm::one::EDProducer { // settings containing various constants for the tracklet processing trklet::Settings settings; - // event processor for the tracklet track finding - trklet::TrackletEventProcessor eventProcessor; - unsigned int nHelixPar_; bool extended_; bool reduced_; @@ -181,6 +184,15 @@ class L1FPGATrackProducer : public edm::one::EDProducer { edm::EDGetTokenT> TrackingParticleToken_; edm::EDGetTokenT tokenDTC_; + // ED output token for clock and bit accurate tracks + EDPutTokenT edPutTokenTracks_; + // ED output token for clock and bit accurate stubs + EDPutTokenT edPutTokenStubs_; + // ChannelAssignment token + ESGetToken esGetTokenChannelAssignment_; + // helper class to assign tracks to channel + const ChannelAssignment* channelAssignment_; + // helper class to store DTC configuration tt::Setup setup_; @@ -222,6 +234,10 @@ L1FPGATrackProducer::L1FPGATrackProducer(edm::ParameterSet const& iConfig) } produces>>("Level1TTTracks").setBranchAlias("Level1TTTracks"); + // book ED output token for clock and bit accurate TrackBuilder tracks + edPutTokenTracks_ = produces("Level1TTTracks"); + // book ED output token for clock and bit accurate TrackBuilder stubs + edPutTokenStubs_ = produces("Level1TTTracks"); asciiEventOutName_ = iConfig.getUntrackedParameter("asciiFileName", ""); @@ -239,8 +255,12 @@ L1FPGATrackProducer::L1FPGATrackProducer(edm::ParameterSet const& iConfig) tableTREFile = iConfig.getParameter("tableTREFile"); } - // book ES product + // book ES product to assign tracks and stubs to InputRouter input channel and TrackBuilder output channel + esGetTokenChannelAssignment_ = esConsumes(); + // book ES product for track trigger cinfiguration esGetToken_ = esConsumes(); + // initial ES products + channelAssignment_ = nullptr; // -------------------------------------------------------------------------------- // set options in Settings based on inputs from configuration files @@ -256,6 +276,7 @@ L1FPGATrackProducer::L1FPGATrackProducer(edm::ParameterSet const& iConfig) settings.setWiresFile(wiresFile.fullPath()); settings.setFakefit(iConfig.getParameter("Fakefit")); + settings.setStoreTrackBuilderOutput(iConfig.getParameter("StoreTrackBuilderOutput")); if (extended_) { settings.setTableTEDFile(tableTEDFile.fullPath()); @@ -287,6 +308,15 @@ L1FPGATrackProducer::L1FPGATrackProducer(edm::ParameterSet const& iConfig) if (trackQuality_) { trackQualityModel_ = std::make_unique(iConfig.getParameter("TrackQualityPSet")); } + if (settings.storeTrackBuilderOutput() && (settings.doMultipleMatches() || settings.removalType() != "")) { + cms::Exception exception("ConfigurationNotSupported."); + exception.addContext("L1FPGATrackProducer::produce"); + if (settings.doMultipleMatches()) + exception << "Stroing of TrackBuilder output does not support doMultipleMatches."; + if (settings.removalType() != "") + exception << "Stroing of TrackBuilder output does not support duplicate removal."; + throw exception; + } } ///////////// @@ -311,14 +341,16 @@ void L1FPGATrackProducer::beginRun(const edm::Run& run, const edm::EventSetup& i settings.setBfield(mMagneticFieldStrength); setup_ = iSetup.getData(esGetToken_); - - // initialize the tracklet event processing (this sets all the processing & memory modules, wiring, etc) - eventProcessor.init(settings); + channelAssignment_ = &iSetup.getData(esGetTokenChannelAssignment_); } ////////// // PRODUCE void L1FPGATrackProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) { + // event processor for the tracklet track finding + trklet::TrackletEventProcessor eventProcessor; + // initialize the tracklet event processing (this sets all the processing & memory modules, wiring, etc) + eventProcessor.init(settings, channelAssignment_); typedef std::map>, TTStub>, L1TStubCompare> @@ -543,7 +575,8 @@ void L1FPGATrackProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSe ttPos.z(), stubbend, stub.first->innerClusterPosition(), - assocTPs); + assocTPs, + stub.first); const trklet::L1TStub& lastStub = ev.lastStub(); stubMap[lastStub] = stub.first; @@ -638,6 +671,17 @@ void L1FPGATrackProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSe iEvent.put(std::move(L1TkTracksForOutput), "Level1TTTracks"); + // produce clock and bit output tracks and stubs + // number of track channel + const int numStreamsTrack = N_SECTOR * channelAssignment_->numChannels(); + // number of stub channel + const int numStreamsStub = numStreamsTrack * channelAssignment_->maxNumProjectionLayers(); + Streams streamsTrack(numStreamsTrack); + StreamsStub streamsStub(numStreamsStub); + eventProcessor.produce(streamsTrack, streamsStub); + iEvent.emplace(edPutTokenTracks_, move(streamsTrack)); + iEvent.emplace(edPutTokenStubs_, move(streamsStub)); + } /// End of produce() // /////////////////////////// diff --git a/L1Trigger/TrackFindingTracklet/python/ProducerKF_cff.py b/L1Trigger/TrackFindingTracklet/python/ProducerKF_cff.py index 729b3276310d1..bf7ca23d08416 100644 --- a/L1Trigger/TrackFindingTracklet/python/ProducerKF_cff.py +++ b/L1Trigger/TrackFindingTracklet/python/ProducerKF_cff.py @@ -8,6 +8,8 @@ from L1Trigger.TrackFindingTracklet.ChannelAssignment_cff import ChannelAssignment from L1Trigger.TrackFindingTracklet.ProducerKF_cfi import TrackFindingTrackletProducerKF_params +TrackFindingTrackletProducerIRin = cms.EDProducer( 'trklet::ProducerIRin', TrackFindingTrackletProducerKF_params ) +TrackFindingTrackletProducerTBout = cms.EDProducer( 'trklet::ProducerTBout', TrackFindingTrackletProducerKF_params ) TrackFindingTrackletProducerKFin = cms.EDProducer( 'trklet::ProducerKFin', TrackFindingTrackletProducerKF_params ) TrackFindingTrackletProducerKF = cms.EDProducer( 'trackerTFP::ProducerKF', TrackFindingTrackletProducerKF_params ) TrackFindingTrackletProducerTT = cms.EDProducer( 'trklet::ProducerTT', TrackFindingTrackletProducerKF_params ) diff --git a/L1Trigger/TrackFindingTracklet/python/ProducerKF_cfi.py b/L1Trigger/TrackFindingTracklet/python/ProducerKF_cfi.py index 65c397d5c8ef0..de896adc2fa9b 100644 --- a/L1Trigger/TrackFindingTracklet/python/ProducerKF_cfi.py +++ b/L1Trigger/TrackFindingTracklet/python/ProducerKF_cfi.py @@ -2,7 +2,7 @@ TrackFindingTrackletProducerKF_params = cms.PSet ( - InputTag = cms.InputTag( "TrackletTracksFromTrackletEmulation", "Level1TTTracks"), # + InputTag = cms.InputTag( "TTTracksFromTrackletEmulation", "Level1TTTracks"), # InputTagDTC = cms.InputTag( "TrackerDTCProducer", "StubAccepted"), # LabelKFin = cms.string ( "TrackFindingTrackletProducerKFin" ), # LabelKF = cms.string ( "TrackFindingTrackletProducerKF" ), # diff --git a/L1Trigger/TrackFindingTracklet/python/Tracklet_cfi.py b/L1Trigger/TrackFindingTracklet/python/Tracklet_cfi.py index 3b09605f2a625..8317065d7c172 100644 --- a/L1Trigger/TrackFindingTracklet/python/Tracklet_cfi.py +++ b/L1Trigger/TrackFindingTracklet/python/Tracklet_cfi.py @@ -1,5 +1,6 @@ import FWCore.ParameterSet.Config as cms from L1Trigger.TrackTrigger.TrackQualityParams_cfi import * +from L1Trigger.TrackFindingTracklet.ChannelAssignment_cff import ChannelAssignment TTTracksFromTrackletEmulation = cms.EDProducer("L1FPGATrackProducer", TTStubSource = cms.InputTag("TTStubsFromPhase2TrackerDigis","StubAccepted"), @@ -21,7 +22,8 @@ # Quality Flag and Quality params TrackQuality = cms.bool(True), TrackQualityPSet = cms.PSet(TrackQualityParams), - Fakefit = cms.bool(False) + Fakefit = cms.bool(False), # True causes Tracklet reco to output TTTracks before DR & KF + StoreTrackBuilderOutput = cms.bool(False) # if True EDProducts for TrackBuilder tracks and stubs will be filled ) TTTracksFromExtendedTrackletEmulation = TTTracksFromTrackletEmulation.clone( diff --git a/L1Trigger/TrackFindingTracklet/src/ChannelAssignment.cc b/L1Trigger/TrackFindingTracklet/src/ChannelAssignment.cc index 7b2ebbdebb228..1b8ad715d7747 100644 --- a/L1Trigger/TrackFindingTracklet/src/ChannelAssignment.cc +++ b/L1Trigger/TrackFindingTracklet/src/ChannelAssignment.cc @@ -44,15 +44,16 @@ namespace trklet { vector> allSeedingLayer(seedlayers.size()); vector> allProjectionLayer(seedlayers.size()); for (int iSeed = 0; iSeed < (int)seedlayers.size(); iSeed++) - for (const auto& layer: seedlayers[iSeed]) + for (const auto& layer : seedlayers[iSeed]) if (layer != invalidSeedLayer) - allSeedingLayer[iSeed].insert(layer < numBarrelLayer ? layer + offsetBarrel : layer + offsetDisk - numBarrelLayer); + allSeedingLayer[iSeed].insert(layer < numBarrelLayer ? layer + offsetBarrel + : layer + offsetDisk - numBarrelLayer); for (int iSeed = 0; iSeed < (int)projlayers.size(); iSeed++) - for (const auto& layer: projlayers[iSeed]) + for (const auto& layer : projlayers[iSeed]) if (layer != invalidLayerDisk) allProjectionLayer[iSeed].insert(layer); for (int iSeed = 0; iSeed < (int)projdisks.size(); iSeed++) - for (const auto& disk: projdisks[iSeed]) + for (const auto& disk : projdisks[iSeed]) if (disk != invalidLayerDisk) allProjectionLayer[iSeed].insert(disk - offsetBarrel + offsetDisk); // check if ChannelAssignment seedTypesSeedLayers_ and seedTypesProjectionLayers_ are subsets of Settings pendants @@ -76,7 +77,8 @@ namespace trklet { if (intersect == pl) break; set difference; - set_difference(pl.begin(), pl.end(), intersect.begin(), intersect.end(), inserter(difference, difference.begin())); + set_difference( + pl.begin(), pl.end(), intersect.begin(), intersect.end(), inserter(difference, difference.begin())); cms::Exception exception("LogicError."); exception << "ProjectionLayers ( "; for (int layer : difference) @@ -132,10 +134,9 @@ namespace trklet { return true; } - // sets layerId of given TTStubRef and TTTrackRef, returns false if seeed stub - bool ChannelAssignment::layerId(const TTTrackRef& ttTrackRef, const TTStubRef& ttStubRef, int& layerId) { + // sets layerId of given TTStubRef and seedType, returns false if seeed stub + bool ChannelAssignment::layerId(int seedType, const TTStubRef& ttStubRef, int& layerId) const { layerId = -1; - const int seedType = ttTrackRef->trackSeedType(); if (seedType < 0 || seedType >= numSeedTypes_) { cms::Exception exception("logic_error"); exception.addContext("trklet::ChannelAssignment::layerId"); diff --git a/L1Trigger/TrackFindingTracklet/src/FitTrack.cc b/L1Trigger/TrackFindingTracklet/src/FitTrack.cc index 46cf0eb980fb2..1a94d853cb7e1 100644 --- a/L1Trigger/TrackFindingTracklet/src/FitTrack.cc +++ b/L1Trigger/TrackFindingTracklet/src/FitTrack.cc @@ -869,7 +869,15 @@ std::vector FitTrack::orderedMatches(vector& fullma return tmp; } -void FitTrack::execute(unsigned int iSector) { +// Adds the fitted track to the output memories to be used by pure Tracklet algo. +// (Also used by Hybrid algo with non-exact Old KF emulation) +// Also create output streams, that bypass these memories, (so can include gaps in time), +// to be used by Hybrid case with exact New KF emulation. + +void FitTrack::execute(const ChannelAssignment* channelAssignment, + deque& streamTrack, + vector>& streamsStub, + unsigned int iSector) { // merge const std::vector& matches1 = orderedMatches(fullmatch1_); const std::vector& matches2 = orderedMatches(fullmatch2_); @@ -1023,6 +1031,53 @@ void FitTrack::execute(unsigned int iSector) { trackfit_->addTrack(bestTracklet); } } + // store bit and clock accurate TB output + if (settings_.storeTrackBuilderOutput() && bestTracklet) { + // add gap if enough layer to form track + static constexpr int limit = 4; + if ((int)bestTracklet->getL1Stubs().size() < limit) { + streamTrack.emplace_back(tt::Frame()); + for (auto& stream : streamsStub) + stream.emplace_back(tt::FrameStub()); + continue; + } + // convert Track word + const int seedType = bestTracklet->getISeed(); + static const string valid = "1"; + const string seed = TTBV(seedType, settings_.nbitsseed()).str(); + const string rinv = bestTracklet->fpgarinv().str(); + const string phi0 = bestTracklet->fpgaphi0().str(); + const string z0 = bestTracklet->fpgaz0().str(); + const string t = bestTracklet->fpgat().str(); + streamTrack.emplace_back(valid + seed + rinv + phi0 + z0 + t); + // hitMap used to remember whcih layer had no stub to fill them with gaps + TTBV hitMap(0, channelAssignment->maxNumProjectionLayers()); + // convert and fill stubs on this track into streamsStub + for (const auto& stub : bestTracklet->getL1Stubs()) { + // get TTStubRef of this stub + const TTStubRef& ttStubRef = stub->ttStubRef(); + // get layerId and skip over seeding layer + int layerId(-1); + if (!channelAssignment->layerId(seedType, ttStubRef, layerId)) + continue; + // mark layerId + hitMap.set(layerId); + // tracklet layerId + const int trackletLayerId = channelAssignment->trackletLayerId(ttStubRef); + // get stub Residual + const Residual& resid = bestTracklet->resid(trackletLayerId); + // create bit accurate 64 bit word + const string& r = resid.stubptr()->r().str(); + const string& phi = resid.fpgaphiresid().str(); + const string& rz = resid.fpgarzresid().str(); + // store TTStubRef and bit accurate 64 bit word in clock accurate output + streamsStub[layerId].emplace_back(ttStubRef, valid + r + phi + rz); + } + // fill all layer with no stubs with gaps + for (int layer : hitMap.ids(false)) { + streamsStub[layer].emplace_back(tt::FrameStub()); + } + } } while (bestTracklet != nullptr && countAll < settings_.maxStep("TB")); diff --git a/L1Trigger/TrackFindingTracklet/src/L1TStub.cc b/L1Trigger/TrackFindingTracklet/src/L1TStub.cc index d7cc37d26b863..af02c5095a3eb 100644 --- a/L1Trigger/TrackFindingTracklet/src/L1TStub.cc +++ b/L1Trigger/TrackFindingTracklet/src/L1TStub.cc @@ -16,7 +16,9 @@ L1TStub::L1TStub(std::string DTClink, double z, double bend, double strip, - std::vector tps) { + std::vector tps, + const TTStubRef& ttStubRef) + : ttStubRef_(ttStubRef) { DTClink_ = DTClink; layerdisk_ = layerdisk; region_ = region; diff --git a/L1Trigger/TrackFindingTracklet/src/SLHCEvent.cc b/L1Trigger/TrackFindingTracklet/src/SLHCEvent.cc index 4ea8f49d3f953..d30d60dde5198 100644 --- a/L1Trigger/TrackFindingTracklet/src/SLHCEvent.cc +++ b/L1Trigger/TrackFindingTracklet/src/SLHCEvent.cc @@ -21,8 +21,9 @@ bool SLHCEvent::addStub(string DTClink, double z, double bend, double strip, - vector tps) { - L1TStub stub(DTClink, region, layerdisk, stubword, isPSmodule, isFlipped, x, y, z, bend, strip, tps); + vector tps, + const TTStubRef& ttStubRef) { + L1TStub stub(DTClink, region, layerdisk, stubword, isPSmodule, isFlipped, x, y, z, bend, strip, tps, ttStubRef); stubs_.push_back(stub); return true; @@ -98,7 +99,7 @@ SLHCEvent::SLHCEvent(istream& in) { tps.push_back(tp); } - L1TStub stub(DTClink, region, layerdisk, stubword, isPSmodule, isFlipped, x, y, z, bend, strip, tps); + L1TStub stub(DTClink, region, layerdisk, stubword, isPSmodule, isFlipped, x, y, z, bend, strip, tps, TTStubRef()); in >> tmp; diff --git a/L1Trigger/TrackFindingTracklet/src/Sector.cc b/L1Trigger/TrackFindingTracklet/src/Sector.cc index f4ddd63a21f8a..a190344493c1b 100644 --- a/L1Trigger/TrackFindingTracklet/src/Sector.cc +++ b/L1Trigger/TrackFindingTracklet/src/Sector.cc @@ -42,6 +42,8 @@ #include "DataFormats/Math/interface/deltaPhi.h" #include "L1Trigger/TrackFindingTracklet/interface/TrackletLUT.h" +#include + using namespace std; using namespace trklet; @@ -414,9 +416,22 @@ void Sector::executeMP() { // If using Hybrid, then PurgeDuplicates runs both duplicate removal & KF steps. // (unless duplicate removal disabled, in which case FitTrack runs KF). -void Sector::executeFT() { +void Sector::executeFT(const ChannelAssignment* channelAssignment, + tt::Streams& streamsTrack, + tt::StreamsStub& streamsStub) { + int channelTrack(0); + const int offsetTrack = isector_ * channelAssignment->numChannels(); for (auto& i : FT_) { - i->execute(isector_); + deque streamsTrackTmp; + vector> streamsStubTmp(channelAssignment->maxNumProjectionLayers()); + i->execute(channelAssignment, streamsTrackTmp, streamsStubTmp, isector_); + if (!settings_.storeTrackBuilderOutput()) + continue; + const int offestStub = (offsetTrack + channelTrack) * channelAssignment->maxNumProjectionLayers(); + streamsTrack[offsetTrack + channelTrack++] = tt::Stream(streamsTrackTmp.begin(), streamsTrackTmp.end()); + int channelStub(0); + for (deque& stream : streamsStubTmp) + streamsStub[offestStub + channelStub++] = tt::StreamStub(stream.begin(), stream.end()); } } diff --git a/L1Trigger/TrackFindingTracklet/src/TrackletEventProcessor.cc b/L1Trigger/TrackFindingTracklet/src/TrackletEventProcessor.cc index 5c002b5e5311d..cbb7a62c49e53 100644 --- a/L1Trigger/TrackFindingTracklet/src/TrackletEventProcessor.cc +++ b/L1Trigger/TrackFindingTracklet/src/TrackletEventProcessor.cc @@ -24,8 +24,15 @@ TrackletEventProcessor::~TrackletEventProcessor() { } } -void TrackletEventProcessor::init(Settings const& theSettings) { +void TrackletEventProcessor::init(Settings const& theSettings, const ChannelAssignment* channelAssignment) { settings_ = &theSettings; + channelAssignment_ = channelAssignment; + // number of track channel + const int numStreamsTrack = N_SECTOR * channelAssignment_->numChannels(); + // number of stub channel + const int numStreamsStub = numStreamsTrack * channelAssignment_->maxNumProjectionLayers(); + streamsTrack_ = tt::Streams(numStreamsTrack); + streamsStub_ = tt::StreamsStub(numStreamsStub); globals_ = make_unique(*settings_); @@ -364,7 +371,7 @@ void TrackletEventProcessor::event(SLHCEvent& ev) { // fit track FTTimer_.start(); - sector_->executeFT(); + sector_->executeFT(channelAssignment_, streamsTrack_, streamsStub_); if ((settings_->writeMem() || settings_->writeMonitorData("IFit")) && k == settings_->writememsect()) { sector_->writeTF(first); } @@ -442,3 +449,8 @@ void TrackletEventProcessor::printSummary() { << setprecision(3) << PDTimer_.avgtime() * 1000.0 << setw(20) << setprecision(3) << PDTimer_.tottime(); } + +void TrackletEventProcessor::produce(tt::Streams& streamsTrack, tt::StreamsStub& streamsStub) { + swap(streamsTrack, streamsTrack_); + swap(streamsStub, streamsStub_); +} \ No newline at end of file diff --git a/L1Trigger/TrackFindingTracklet/test/ProducerIRin.cc b/L1Trigger/TrackFindingTracklet/test/ProducerIRin.cc new file mode 100644 index 0000000000000..0b95546871c56 --- /dev/null +++ b/L1Trigger/TrackFindingTracklet/test/ProducerIRin.cc @@ -0,0 +1,104 @@ +#include "FWCore/Framework/interface/stream/EDProducer.h" +#include "FWCore/Framework/interface/Run.h" +#include "FWCore/Framework/interface/EventSetup.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/MakerMacros.h" +#include "FWCore/Utilities/interface/EDGetToken.h" +#include "FWCore/Utilities/interface/EDPutToken.h" +#include "FWCore/Utilities/interface/ESGetToken.h" +#include "FWCore/Utilities/interface/InputTag.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "DataFormats/Common/interface/Handle.h" + +#include "L1Trigger/TrackTrigger/interface/Setup.h" +#include "L1Trigger/TrackFindingTracklet/interface/ChannelAssignment.h" + +#include +#include +#include +#include +#include +#include + +using namespace std; +using namespace edm; +using namespace tt; + +namespace trklet { + + /*! \class trklet::ProducerIRin + * \brief Extracts and rearranges StreamsStub from TTDTC + * Rearrangement may be configured to connect a reduced tracking chain to the correct L1 track board input channels. + * \author Thomas Schuh + * \date 2021, Oct + */ + class ProducerIRin : public stream::EDProducer<> { + public: + explicit ProducerIRin(const ParameterSet&); + ~ProducerIRin() override {} + + private: + virtual void beginRun(const Run&, const EventSetup&) override; + virtual void produce(Event&, const EventSetup&) override; + virtual void endJob() {} + // ED input token of DTC Stubs + EDGetTokenT edGetTokenTTDTC_; + // ED output token for stubs + EDPutTokenT edPutTokenStubs_; + // Setup token + ESGetToken esGetTokenSetup_; + // ChannelAssignment token + ESGetToken esGetTokenChannelAssignment_; + // configuration + ParameterSet iConfig_; + // helper class to store configurations + const Setup* setup_; + // helper class to assign stubs to channel + const ChannelAssignment* channelAssignment_; + }; + + ProducerIRin::ProducerIRin(const ParameterSet& iConfig) : iConfig_(iConfig) { + const InputTag& inputTag = iConfig.getParameter("InputTagDTC"); + const string& branchStubs = iConfig.getParameter("BranchAcceptedStubs"); + // book in- and output ED products + edGetTokenTTDTC_ = consumes(inputTag); + edPutTokenStubs_ = produces(branchStubs); + // book ES products + esGetTokenSetup_ = esConsumes(); + // initial ES products + setup_ = nullptr; + channelAssignment_ = nullptr; + } + + void ProducerIRin::beginRun(const Run& iRun, const EventSetup& iSetup) { + // helper class to store configurations + setup_ = &iSetup.getData(esGetTokenSetup_); + if (!setup_->configurationSupported()) + return; + // check process history if desired + if (iConfig_.getParameter("CheckHistory")) + setup_->checkHistory(iRun.processHistory()); + channelAssignment_ = &iSetup.getData(esGetTokenChannelAssignment_); + } + + void ProducerIRin::produce(Event& iEvent, const EventSetup& iSetup) { + // empty IRin product + StreamsStub streamStubs; + // read in hybrid track finding product and produce KFin product + if (setup_->configurationSupported()) { + Handle handleTTDTC; + iEvent.getByToken(edGetTokenTTDTC_, handleTTDTC); + const vector& channelEncoding = channelAssignment_->channelEncoding(); + const int numChannel = setup_->numRegions() * channelEncoding.size(); + streamStubs.reserve(numChannel); + for (int tfpRegion : handleTTDTC->tfpRegions()) + for (int tfpChannel : channelEncoding) + streamStubs.emplace_back(handleTTDTC->stream(tfpRegion, tfpChannel)); + } + // store products + iEvent.emplace(edPutTokenStubs_, move(streamStubs)); + } + +} // namespace trklet + +DEFINE_FWK_MODULE(trklet::ProducerIRin); diff --git a/L1Trigger/TrackFindingTracklet/test/ProducerTBout.cc b/L1Trigger/TrackFindingTracklet/test/ProducerTBout.cc new file mode 100644 index 0000000000000..8aa34772792e0 --- /dev/null +++ b/L1Trigger/TrackFindingTracklet/test/ProducerTBout.cc @@ -0,0 +1,188 @@ +#include "FWCore/Framework/interface/stream/EDProducer.h" +#include "FWCore/Framework/interface/Run.h" +#include "FWCore/Framework/interface/EventSetup.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/MakerMacros.h" +#include "FWCore/Utilities/interface/EDGetToken.h" +#include "FWCore/Utilities/interface/EDPutToken.h" +#include "FWCore/Utilities/interface/ESGetToken.h" +#include "FWCore/Utilities/interface/InputTag.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "DataFormats/Common/interface/Handle.h" + +#include "L1Trigger/TrackTrigger/interface/Setup.h" +#include "L1Trigger/TrackerTFP/interface/DataFormats.h" +#include "L1Trigger/TrackFindingTracklet/interface/ChannelAssignment.h" +#include "L1Trigger/TrackFindingTracklet/interface/Settings.h" + +#include +#include +#include +#include +#include +#include + +using namespace std; +using namespace edm; +using namespace trackerTFP; +using namespace tt; + +namespace trklet { + + /*! \class trklet::ProducerTBout + * \brief Transforms TTTracks and Streams from Tracklet pattern reco. into StreamsTrack + * by adding to the digitised track stream a reference to the corresponding TTTrack. + * (Could not be done in previous L1TrackFPGAProducer, as single EDProducer can't + * produce output containing both an EDProduct and refs to that product). + * Writes Tracks & stubs rejected/kept after truncation to separate StreamsTrack & StreamsStub branches. + * \author Thomas Schuh + * \date 2021, Oct + */ + class ProducerTBout : public stream::EDProducer<> { + public: + explicit ProducerTBout(const ParameterSet&); + ~ProducerTBout() override {} + + private: + virtual void beginRun(const Run&, const EventSetup&) override; + virtual void produce(Event&, const EventSetup&) override; + virtual void endJob() {} + + // ED input token of TTTracks + EDGetTokenT edGetTokenTTTracks_; + // ED input token of Tracklet tracks + EDGetTokenT edGetTokenTracks_; + // ED input token of Tracklet Stubs + EDGetTokenT edGetTokenStubs_; + // ED output token for stubs + EDPutTokenT edPutTokenAcceptedStubs_; + EDPutTokenT edPutTokenLostStubs_; + // ED output token for tracks + EDPutTokenT edPutTokenAcceptedTracks_; + EDPutTokenT edPutTokenLostTracks_; + // Setup token + ESGetToken esGetTokenSetup_; + // DataFormats token + ESGetToken esGetTokenDataFormats_; + // ChannelAssignment token + ESGetToken esGetTokenChannelAssignment_; + // configuration + ParameterSet iConfig_; + // helper class to store configurations + const Setup* setup_; + // helper class to extract structured data from TTDTC::Frames + const DataFormats* dataFormats_; + // helper class to assign tracks to channel + ChannelAssignment* channelAssignment_; + // + bool enableTruncation_; + // + trklet::Settings settings_; + }; + + ProducerTBout::ProducerTBout(const ParameterSet& iConfig) : iConfig_(iConfig) { + const InputTag& inputTag = iConfig.getParameter("InputTag"); + const string& branchAcceptedStubs = iConfig.getParameter("BranchAcceptedStubs"); + const string& branchAcceptedTracks = iConfig.getParameter("BranchAcceptedTracks"); + const string& branchLostStubs = iConfig.getParameter("BranchLostStubs"); + const string& branchLostTracks = iConfig.getParameter("BranchLostTracks"); + // book in- and output ED products + edGetTokenTTTracks_ = consumes(inputTag); + edGetTokenTracks_ = consumes(inputTag); + edGetTokenStubs_ = consumes(inputTag); + edPutTokenAcceptedStubs_ = produces(branchAcceptedStubs); + edPutTokenAcceptedTracks_ = produces(branchAcceptedTracks); + edPutTokenLostStubs_ = produces(branchLostStubs); + edPutTokenLostTracks_ = produces(branchLostTracks); + // book ES products + esGetTokenSetup_ = esConsumes(); + esGetTokenDataFormats_ = esConsumes(); + esGetTokenChannelAssignment_ = esConsumes(); + // initial ES products + setup_ = nullptr; + dataFormats_ = nullptr; + channelAssignment_ = nullptr; + // + enableTruncation_ = iConfig.getParameter("EnableTruncation"); + } + + void ProducerTBout::beginRun(const Run& iRun, const EventSetup& iSetup) { + // helper class to store configurations + setup_ = &iSetup.getData(esGetTokenSetup_); + if (!setup_->configurationSupported()) + return; + // check process history if desired + if (iConfig_.getParameter("CheckHistory")) + setup_->checkHistory(iRun.processHistory()); + // helper class to extract structured data from TTDTC::Frames + dataFormats_ = &iSetup.getData(esGetTokenDataFormats_); + // helper class to assign tracks to channel + channelAssignment_ = const_cast(&iSetup.getData(esGetTokenChannelAssignment_)); + } + + void ProducerTBout::produce(Event& iEvent, const EventSetup& iSetup) { + const int numStreamsTracks = setup_->numRegions() * channelAssignment_->numChannels(); + const int numStreamsStubs = numStreamsTracks * channelAssignment_->maxNumProjectionLayers(); + // empty KFin products + StreamsStub streamAcceptedStubs(numStreamsStubs); + StreamsTrack streamAcceptedTracks(numStreamsTracks); + StreamsStub streamLostStubs(numStreamsStubs); + StreamsTrack streamLostTracks(numStreamsTracks); + // read in hybrid track finding product and produce KFin product + if (setup_->configurationSupported()) { + // create and structure TTrackRefs in h/w channel + vector> ttTrackRefs(numStreamsTracks); + Handle handleTTTracks; + iEvent.getByToken(edGetTokenTTTracks_, handleTTTracks); + int channelId(-1); + for (int i = 0; i < (int)handleTTTracks->size(); i++) { + const TTTrackRef ttTrackRef(handleTTTracks, i); + if (channelAssignment_->channelId(ttTrackRef, channelId)) + ttTrackRefs[channelId].push_back(ttTrackRef); + } + // get and trunacte tracks + Handle handleTracks; + iEvent.getByToken(edGetTokenTracks_, handleTracks); + channelId = 0; + for (const Stream& streamTrack : *handleTracks) { + StreamTrack& accepted = streamAcceptedTracks[channelId]; + StreamTrack& lost = streamLostTracks[channelId]; + auto limit = streamTrack.end(); + if (enableTruncation_ && (int)streamTrack.size() > setup_->numFrames()) + limit = next(streamTrack.begin(), setup_->numFrames()); + accepted.reserve(distance(streamTrack.begin(), limit)); + lost.reserve(distance(limit, streamTrack.end())); + int nFrame(0); + const deque& ttTracks = ttTrackRefs[channelId++]; + auto toFrameTrack = [&nFrame, &ttTracks](const Frame& frame) { + if (frame.any()) + return FrameTrack(ttTracks[nFrame++], frame); + return FrameTrack(); + }; + transform(streamTrack.begin(), limit, back_inserter(accepted), toFrameTrack); + transform(limit, streamTrack.end(), back_inserter(lost), toFrameTrack); + } + // get and trunacte stubs + Handle handleStubs; + iEvent.getByToken(edGetTokenStubs_, handleStubs); + const StreamsStub& streamsStub = *handleStubs; + // reserve output ed products + channelId = 0; + for (const StreamStub& streamStub : streamsStub) { + auto limit = streamStub.end(); + if (enableTruncation_ && (int)streamStub.size() > setup_->numFrames()) + limit = next(streamStub.begin(), setup_->numFrames()); + streamAcceptedStubs[channelId] = StreamStub(streamStub.begin(), limit); + streamLostStubs[channelId++] = StreamStub(limit, streamStub.end()); + } + } + // store products + iEvent.emplace(edPutTokenAcceptedStubs_, move(streamAcceptedStubs)); + iEvent.emplace(edPutTokenAcceptedTracks_, move(streamAcceptedTracks)); + iEvent.emplace(edPutTokenLostStubs_, move(streamLostStubs)); + iEvent.emplace(edPutTokenLostTracks_, move(streamLostTracks)); + } + +} // namespace trklet + +DEFINE_FWK_MODULE(trklet::ProducerTBout); diff --git a/L1Trigger/TrackFindingTracklet/test/demonstrator_cfg.py b/L1Trigger/TrackFindingTracklet/test/demonstrator_cfg.py index fe4ca21c46886..c74aa97482aa5 100644 --- a/L1Trigger/TrackFindingTracklet/test/demonstrator_cfg.py +++ b/L1Trigger/TrackFindingTracklet/test/demonstrator_cfg.py @@ -3,8 +3,11 @@ process = cms.Process( "Demo" ) process.load( 'FWCore.MessageService.MessageLogger_cfi' ) +process.load( 'Configuration.EventContent.EventContent_cff' ) process.load( 'Configuration.Geometry.GeometryExtended2026D76Reco_cff' ) process.load( 'Configuration.Geometry.GeometryExtended2026D76_cff' ) +#process.load( 'Configuration.Geometry.GeometryExtended2026D49Reco_cff' ) +#process.load( 'Configuration.Geometry.GeometryExtended2026D49_cff' ) process.load( 'Configuration.StandardSequences.MagneticField_cff' ) process.load( 'Configuration.StandardSequences.FrontierConditions_GlobalTag_cff' ) process.load( 'L1Trigger.TrackTrigger.TrackTrigger_cff' ) @@ -25,12 +28,9 @@ # build schedule process.tt = cms.Sequence ( process.TrackerDTCProducer - + process.L1TrackletTracks - + process.TrackFindingTrackletProducerKFin - + process.TrackFindingTrackletProducerKF - + process.TrackFindingTrackletProducerTT - + process.TrackFindingTrackletProducerAS - + process.TrackFindingTrackletProducerKFout + + process.L1HybridTracks + + process.TrackFindingTrackletProducerIRin + + process.TrackFindingTrackletProducerTBout ) process.demo = cms.Path( process.tt + process.TrackerTFPDemonstrator ) process.schedule = cms.Schedule( process.demo ) @@ -39,7 +39,7 @@ import FWCore.ParameterSet.VarParsing as VarParsing options = VarParsing.VarParsing( 'analysis' ) # specify input MC -Samples = [ +inputMC = [ #'/store/relval/CMSSW_11_3_0_pre6/RelValSingleMuFlatPt2To100/GEN-SIM-DIGI-RAW/113X_mcRun4_realistic_v6_2026D76noPU-v1/10000/05f802b7-b0b3-4cca-8b70-754682c3bb4c.root' #'/store/relval/CMSSW_11_3_0_pre6/RelValDisplacedMuPt2To100Dxy100/GEN-SIM-DIGI-RAW/113X_mcRun4_realistic_v6_2026D76noPU-v1/00000/011da61a-9524-4a96-b91f-03e8690af3bd.root' '/store/relval/CMSSW_11_3_0_pre6/RelValTTbar_14TeV/GEN-SIM-DIGI-RAW/PU_113X_mcRun4_realistic_v6_2026D76PU200-v1/00000/00026541-6200-4eed-b6f8-d3a1fd720e9c.root', @@ -52,8 +52,9 @@ '/store/relval/CMSSW_11_3_0_pre6/RelValTTbar_14TeV/GEN-SIM-DIGI-RAW/PU_113X_mcRun4_realistic_v6_2026D76PU200-v1/00000/16760a5c-9cd2-41c3-82e5-399bb962d537.root', '/store/relval/CMSSW_11_3_0_pre6/RelValTTbar_14TeV/GEN-SIM-DIGI-RAW/PU_113X_mcRun4_realistic_v6_2026D76PU200-v1/00000/1752640f-2001-4d14-9276-063ec07cea92.root', '/store/relval/CMSSW_11_3_0_pre6/RelValTTbar_14TeV/GEN-SIM-DIGI-RAW/PU_113X_mcRun4_realistic_v6_2026D76PU200-v1/00000/180712c9-31a5-4f2a-bf92-a7fbee4dabad.root' + #"/store/relval/CMSSW_11_3_0_pre3/RelValTTbar_14TeV/GEN-SIM-DIGI-RAW/PU_113X_mcRun4_realistic_v3_2026D49PU200_rsb-v1/00000/00260a30-734a-4a3a-a4b0-f836ce5502c6.root" ] -options.register( 'inputMC', Samples, VarParsing.VarParsing.multiplicity.singleton, VarParsing.VarParsing.varType.string, "Files to be processed" ) +options.register( 'inputMC', inputMC, VarParsing.VarParsing.multiplicity.singleton, VarParsing.VarParsing.varType.string, "Files to be processed" ) # specify number of events to process. options.register( 'Events',100,VarParsing.VarParsing.multiplicity.singleton, VarParsing.VarParsing.varType.int, "Number of Events to analyze" ) options.parseArguments() @@ -63,7 +64,7 @@ process.source = cms.Source( "PoolSource", fileNames = cms.untracked.vstring( options.inputMC ), - #skipEvents = cms.untracked.uint32( 914 ), + skipEvents = cms.untracked.uint32( 0 ), secondaryFileNames = cms.untracked.vstring(), duplicateCheckMode = cms.untracked.string( 'noDuplicateCheck' ) ) diff --git a/L1Trigger/TrackTrigger/interface/Setup.h b/L1Trigger/TrackTrigger/interface/Setup.h index 3c7502f342744..65d6dae46e9ec 100644 --- a/L1Trigger/TrackTrigger/interface/Setup.h +++ b/L1Trigger/TrackTrigger/interface/Setup.h @@ -94,6 +94,8 @@ namespace tt { bool useForReconstructable(const TrackingParticle& tp) const { return tpSelectorLoose_(tp); } // stub layer id (barrel: 1 - 6, endcap: 11 - 15) int layerId(const TTStubRef& ttStubRef) const; + // return tracklet layerId (barrel: [0-5], endcap: [6-10]) for given TTStubRef + int trackletLayerId(const TTStubRef& ttStubRef) const; // true if stub from barrel module bool barrel(const TTStubRef& ttStubRef) const; // true if stub from barrel module diff --git a/L1Trigger/TrackTrigger/src/Setup.cc b/L1Trigger/TrackTrigger/src/Setup.cc index 33f4d7e0442b9..422cd10c06d3e 100644 --- a/L1Trigger/TrackTrigger/src/Setup.cc +++ b/L1Trigger/TrackTrigger/src/Setup.cc @@ -483,6 +483,13 @@ namespace tt { : trackerTopology_->tidWheel(detId) + offsetLayerDisks_; } + // return tracklet layerId (barrel: [0-5], endcap: [6-10]) for given TTStubRef + int Setup::trackletLayerId(const TTStubRef& ttStubRef) const { + static constexpr int offsetBarrel = 1; + static constexpr int offsetDisks = 5; + return this->layerId(ttStubRef) - (this->barrel(ttStubRef) ? offsetBarrel : offsetDisks); + } + // true if stub from barrel module bool Setup::barrel(const TTStubRef& ttStubRef) const { const DetId& detId = ttStubRef->getDetId(); diff --git a/L1Trigger/TrackerTFP/python/Demonstrator_cfi.py b/L1Trigger/TrackerTFP/python/Demonstrator_cfi.py index 42f0274b982e9..e70d510eeecfb 100644 --- a/L1Trigger/TrackerTFP/python/Demonstrator_cfi.py +++ b/L1Trigger/TrackerTFP/python/Demonstrator_cfi.py @@ -10,9 +10,9 @@ #RunTime = cms.double( 6.0 ) # runtime in us # hybrid - LabelIn = cms.string( "TrackFindingTrackletProducerKF" ), # - LabelOut = cms.string( "TrackFindingTrackletProducerKF" ), # - DirIPBB = cms.string( "/heplnw039/tschuh/work/proj/kfout/" ), # path to ipbb proj area - RunTime = cms.double( 6.0 ) # runtime in us + LabelIn = cms.string( "TrackFindingTrackletProducerIRin" ), # + LabelOut = cms.string( "TrackFindingTrackletProducerTBout" ), # + DirIPBB = cms.string( "/heplnw039/tschuh/work/proj/sim/" ), # path to ipbb proj area + RunTime = cms.double( 8.0 ) # runtime in us ) \ No newline at end of file diff --git a/L1Trigger/TrackerTFP/test/AnalyzerDemonstrator.cc b/L1Trigger/TrackerTFP/test/AnalyzerDemonstrator.cc index a2c0f77338eed..b2d009be5dc77 100644 --- a/L1Trigger/TrackerTFP/test/AnalyzerDemonstrator.cc +++ b/L1Trigger/TrackerTFP/test/AnalyzerDemonstrator.cc @@ -73,7 +73,8 @@ namespace trackerTFP { labelIn == "TrackFindingTrackletProducerKFin" || labelIn == "TrackFindingTrackletProducerKF") edGetTokenTracksIn_ = consumes(InputTag(labelIn, branchTracks)); if (labelOut == "TrackerTFPProducerKF" || labelOut == "TrackerTFPProducerDR" || - labelOut == "TrackFindingTrackletProducerKF" || labelOut == "TrackFindingTrackletProducerKFout") + labelOut == "TrackFindingTrackletProducerKF" || labelOut == "TrackFindingTrackletProducerKFout" || + labelOut == "TrackFindingTrackletProducerTBout") edGetTokenTracksOut_ = consumes(InputTag(labelOut, branchTracks)); // book ES products esGetTokenSetup_ = esConsumes();