diff --git a/DataFormats/L1Trigger/interface/P2GTCandidate.h b/DataFormats/L1Trigger/interface/P2GTCandidate.h index a0d8867f55554..a9c9e15420f33 100644 --- a/DataFormats/L1Trigger/interface/P2GTCandidate.h +++ b/DataFormats/L1Trigger/interface/P2GTCandidate.h @@ -32,7 +32,7 @@ namespace l1t { typedef ap_int<14> hwEta_t; typedef ap_int<18> hwZ0_t; typedef ap_uint<11> hwIsolationPT_t; - typedef ap_uint<4> hwQualityFlags_t; + typedef ap_uint<6> hwQualityFlags_t; typedef ap_uint<10> hwQualityScore_t; typedef ap_uint<1> hwCharge_t; typedef ap_int<12> hwD0_t; @@ -43,6 +43,7 @@ namespace l1t { typedef ap_int<10> hwSeed_z0_t; typedef ap_uint<16> hwScalarSumPT_t; typedef ap_uint<5> hwNumber_of_tracks_t; + typedef ap_uint<4> hwNumber_of_displaced_tracks_t; typedef ap_uint<12> hwSum_pT_pv_t; typedef ap_uint<2> hwType_t; typedef ap_uint<8> hwNumber_of_tracks_in_pv_t; @@ -117,6 +118,10 @@ namespace l1t { hwNumber_of_tracks_ = hwNumber_of_tracks.to_int(); } + void setHwNumber_of_displaced_tracks(hwNumber_of_displaced_tracks_t hwNumber_of_displaced_tracks) { + hwNumber_of_displaced_tracks_ = hwNumber_of_displaced_tracks.to_int(); + } + void setHwSum_pT_pv(hwSum_pT_pv_t hwSum_pT_pv) { hwSum_pT_pv_ = hwSum_pT_pv.to_int(); } void setHwType(hwType_t hwType) { hwType_ = hwType.to_int(); } void setHwNumber_of_tracks_in_pv(hwNumber_of_tracks_in_pv_t hwNumber_of_tracks_in_pv) { @@ -238,6 +243,13 @@ namespace l1t { return static_cast(hwNumber_of_tracks_); } + hwNumber_of_displaced_tracks_t hwNumber_of_displaced_tracks() const { + if (!hwNumber_of_displaced_tracks_) { + throw std::invalid_argument("Object doesn't have hwNumber_of_displaced_tracks"); + } + return static_cast(hwNumber_of_displaced_tracks_); + } + hwSum_pT_pv_t hwSum_pT_pv() const { if (!hwSum_pT_pv_) { throw std::invalid_argument("Object doesn't have sum_pT_pv"); @@ -285,6 +297,7 @@ namespace l1t { int hwSeed_z0_toInt() const { return hwSeed_z0().to_int(); } int hwScalarSumPT_toInt() const { return hwScalarSumPT().to_int(); } int hwNumber_of_tracks_toInt() const { return hwNumber_of_tracks().to_int(); } + int hwNumber_of_displaced_tracks_toInt() const { return hwNumber_of_displaced_tracks().to_int(); } int hwSum_pT_pv_toInt() const { return hwSum_pT_pv().to_int(); } int hwType_toInt() const { return hwType().to_int(); } int hwNumber_of_tracks_in_pv_toInt() const { return hwNumber_of_tracks_in_pv().to_int(); } @@ -329,6 +342,7 @@ namespace l1t { Optional hwSeed_z0_; Optional hwScalarSumPT_; Optional hwNumber_of_tracks_; + Optional hwNumber_of_displaced_tracks_; // TODO ? Optional hwSum_pT_pv_; diff --git a/DataFormats/L1Trigger/src/P2GTCandidate.cc b/DataFormats/L1Trigger/src/P2GTCandidate.cc index bdee357c39a3e..32480e715e596 100644 --- a/DataFormats/L1Trigger/src/P2GTCandidate.cc +++ b/DataFormats/L1Trigger/src/P2GTCandidate.cc @@ -8,7 +8,8 @@ namespace l1t { hwQualityFlags_ == rhs.hwQualityFlags_ && hwCharge_ == rhs.hwCharge_ && hwD0_ == rhs.hwD0_ && hwBeta_ == rhs.hwBeta_ && hwMass_ == rhs.hwMass_ && hwIndex_ == rhs.hwIndex_ && hwSeed_pT_ == rhs.hwSeed_pT_ && hwSeed_z0_ == rhs.hwSeed_z0_ && hwScalarSumPT_ == rhs.hwScalarSumPT_ && - hwNumber_of_tracks_ == rhs.hwNumber_of_tracks_ && hwSum_pT_pv_ == rhs.hwSum_pT_pv_ && + hwNumber_of_tracks_ == rhs.hwNumber_of_tracks_ && + hwNumber_of_displaced_tracks_ == rhs.hwNumber_of_displaced_tracks_ && hwSum_pT_pv_ == rhs.hwSum_pT_pv_ && hwType_ == rhs.hwType_ && hwNumber_of_tracks_in_pv_ == rhs.hwNumber_of_tracks_in_pv_ && hwNumber_of_tracks_not_in_pv_ == rhs.hwNumber_of_tracks_not_in_pv_; } diff --git a/DataFormats/L1Trigger/src/classes_def.xml b/DataFormats/L1Trigger/src/classes_def.xml index 3b76a6164b287..bdcbc96f17e57 100644 --- a/DataFormats/L1Trigger/src/classes_def.xml +++ b/DataFormats/L1Trigger/src/classes_def.xml @@ -16,7 +16,8 @@ - + + diff --git a/L1Trigger/Phase2L1GT/README.md b/L1Trigger/Phase2L1GT/README.md index 8feb6f1359efa..f32fa240a0ac6 100644 --- a/L1Trigger/Phase2L1GT/README.md +++ b/L1Trigger/Phase2L1GT/README.md @@ -68,19 +68,19 @@ process.TripleTkMuon533 = l1tGTTripleObjectCond.clone( tag = cms.InputTag("l1tGTProducer", "GMTTkMuons"), minPt = cms.double(5), maxAbsEta = cms.double(2.4), - minQualityScore = cms.uint32(0) + qualityFlags = cms.uint32(0b0001) ), collection2 = cms.PSet( tag = cms.InputTag("l1tGTProducer", "GMTTkMuons"), minPt = cms.double(3), maxAbsEta = cms.double(2.4), - minQualityScore = cms.uint32(0) + qualityFlags = cms.uint32(0b0001) ), collection3 = cms.PSet( tag = cms.InputTag("l1tGTProducer", "GMTTkMuons"), minPt = cms.double(3), maxAbsEta = cms.double(2.4), - minQualityScore = cms.uint32(0) + qualityFlags = cms.uint32(0b0001) ), # Correlations are ambiguous (can be {1,2}, {1,3}, or {2,3}), correlXY PSets are thus required. correl12 = cms.PSet( @@ -116,9 +116,12 @@ Possible cuts on single quantities are: | `maxRelIsolationPt` | $\mathrm{isolationPT} < X \cdot p_T$ | `cms.double` | `ceil(X * pT_lsb * 2**18 / isolationPT)` | | `minPrimVertDz`* | $\| z_0 - Z_{0,i} \| > X $ | `cms.double` | `floor(X / z0_lsb)` | | `maxPrimVertDz`* | $\| z_0 - Z_{0,i} \| < X $ | `cms.double` | `ceil(X / z0_lsb)` | +| `minPtMultiplicityCut`** | $\sum \left( p_T > X\right) \geq N$ | `cms.double` | `floor(X / pT_lsb)` | \* : To select a $Z_0$ index $i$ from the `GTTPrimaryVert` collection for the comparison use `primVertex = cms.uint32(i)`. This parameter is mandatory when using a `maxPrimVertDz` cut. +\** : Requires additional parameter $N$ with `minPtMultiplicityN = cms.uint32(N)`. + ### $\eta$-regional cuts Certain cuts can also be specified $\eta$-region dependent, to allow different thresholds in different regions. In order to use this feature, one has to first provide the lower bounds for the regions via `regionsAbsEtaLowerBounds`. This parameter takes an `cms.vdouble`, whose length determines the number of $\eta$-regions. A region then ranges from the specified lower bound (inclusive) up to the next region's lower bound (exclusive). The last region's upper bound is always the maximum allowed $|\eta| = 2\pi$. One can use additional global $\eta$ or $|\eta|$ cuts to exclude large $|\eta|$ values, effectively overriding the last region's upper bound. The following cuts can be specified per each $\eta$-region: @@ -196,3 +199,93 @@ process.pDoubleTkEle25_12 = cms.Path(process.DoubleTkEle2512) algorithms.append(cms.PSet(expression = cms.string("pSingleTkMuon22 or pDoubleTkEle25_12"))) ``` + +## Firmware pattern writers + +There are 3 types of Global Trigger pattern writers currently implemented. + +* `L1GTAlgoBoardWriter`: Used to write out the algorithm bits into 2 channels. With config + +| Name | Datatype | Description | +|:-----|:----------:|:--------------| +| `filename` | `cms.string` | The filename prefix to use for pattern files (required) | +| `fileExtension` | `cms.string` | `txt`, `txt.gz` or `txt.xz` (default: `txt`) | +| `algoBlocksTag` | `cms.InputTag` | AlgoBlock producer input tag to use (required) | +| `maxFrames` | `cms.unit32` | Maximum number of frames (default: 1024) | +| `maxEvents` | `cms.unit32` | Maximum number of events (default: events that fit into `maxFrames`) | +| `channels` | `cms.vuint32` | Vector of 2 channel numbers for output (required) | +| `algoBitMask` | `cms.vuint64` | Vector of 9 64 bit masks (default: all set to 1) | +| `patternFormat` | `cms.string` | `APx`, `EMPv1`, `EMPv2` or `X2O` (default: `EMPv2`) | + +* `L1GTFinOrBoardWriter`: Used to write out Final OR bits (beforeBxMaskAndPrescale, beforePrescale and final) each on a different channel for the low bits (0 - 575), mid bits (576 - 1151) and high bits (1152 - 1727). 9 channels in total + one channel for the passing Final OR trigger types. Config: + +| Name | Datatype | Description | +|:-----|:----------:|:--------------| +| `filename` | `cms.string` | The filename prefix to use for pattern files (required) | +| `fileExtension` | `cms.string` | `txt`, `txt.gz` or `txt.xz` (default: `txt`) | +| `algoBlocksTag` | `cms.InputTag` | AlgoBlock producer input tag to use (required) | +| `maxFrames` | `cms.unit32` | Maximum number of frames (default: 1024) | +| `maxEvents` | `cms.unit32` | Maximum number of events (default: events that fit into `maxFrames`) | +| `channelsLow` | `cms.vuint32` | Vector of 3 channel numbers for low bits (0 - 575) (required) | +| `channelsMid` | `cms.vuint32` | Vector of 3 channel numbers for mid bits (576 - 1151) (required) | +| `channelsHigh` | `cms.vuint32` | Vector of 3 channel numbers for high bits (1152 - 1727) (required) | +| `channelFinOr` | `cms.uint32` | Channel for FinalOr trigger types (required) | +| `patternFormat` | `cms.string` | `APx`, `EMPv1`, `EMPv2` or `X2O` (default: `EMPv2`) | + +* `L1GTObjectBoardWriter`: Used to write input and output object patterns using the upstream provided pack functions. + +| Name | Datatype | Description | +|:-----|:----------:|:--------------| +| `filename` | `cms.string` | The filename prefix to use for pattern files (required) | +| `fileExtension` | `cms.string` | `txt`, `txt.gz` or `txt.xz` (default: `txt`) | +| `maxFrames` | `cms.unit32` | Maximum number of frames (default: 1024) | +| `maxEvents` | `cms.unit32` | Maximum number of events (default: events that fit into `maxFrames`) | +| `patternFormat` | `cms.string` | `APx`, `EMPv1`, `EMPv2` or `X2O` (default: `EMPv2`) | +| `bufferFileType`| `cms.string` | Either `input` or `output` (required) | +| `InputChannels.GCT_1` | `cms.vuint32` | Channels for GCT link 1 (required if `bufferFileType` = `input`) | +| `InputChannels.GMT_1` | `cms.vuint32` | Channels for GMT link 1 (required if `bufferFileType` = `input`) | +| `InputChannels.GTT_1` | `cms.vuint32` | Channels for GTT link 1 (required if `bufferFileType` = `input`) | +| `InputChannels.GTT_2` | `cms.vuint32` | Channels for GTT link 2 (required if `bufferFileType` = `input`) | +| `InputChannels.GTT_3` | `cms.vuint32` | Channels for GTT link 3 (required if `bufferFileType` = `input`) | +| `InputChannels.GTT_4` | `cms.vuint32` | Channels for GTT link 4 (required if `bufferFileType` = `input`) | +| `InputChannels.CL2_1` | `cms.vuint32` | Channels for CL2 link 1 (required if `bufferFileType` = `input`) | +| `InputChannels.CL2_2` | `cms.vuint32` | Channels for CL2 link 2 (required if `bufferFileType` = `input`) | +| `InputChannels.CL2_3` | `cms.vuint32` | Channels for CL2 link 3 (required if `bufferFileType` = `input`) | +| `OutputChannels.GTTPromptJets` | `cms.vuint32` | Channels for collection GTTPromptJets (required if `bufferFileType` = `output`) | +| `OutputChannels.GTTDisplacedJets` | `cms.vuint32` | Channels for collection GTTDisplacedJets (required if `bufferFileType` = `output`) | +| `OutputChannels.GTTPromptHtSum` | `cms.vuint32` | Channels for collection GTTPromptHtSum (required if `bufferFileType` = `output`) | +| `OutputChannels.GTTDisplacedHtSum` | `cms.vuint32` | Channels for collection GTTDisplacedHtSum (required if `bufferFileType` = `output`) | +| `OutputChannels.GTTEtSum` | `cms.vuint32` | Channels for collection GTTEtSum (required if `bufferFileType` = `output`) | +| `OutputChannels.GTTPrimaryVert` | `cms.vuint32` | Channels for collection GTTPrimaryVert (required if `bufferFileType` = `output`) | +| `OutputChannels.GMTSaPromptMuons` | `cms.vuint32` | Channels for collection GMTSaPromptMuons (required if `bufferFileType` = `output`) | +| `OutputChannels.GMTSaDisplacedMuons` | `cms.vuint32` | Channels for collection GMTSaDisplacedMuons (required if `bufferFileType` = `output`) | +| `OutputChannels.GMTTkMuons` | `cms.vuint32` | Channels for collection GMTTkMuons (required if `bufferFileType` = `output`) | +| `OutputChannels.CL2JetsSC4` | `cms.vuint32` | Channels for collection CL2JetsSC4 (required if `bufferFileType` = `output`) | +| `OutputChannels.CL2JetsSC8` | `cms.vuint32` | Channels for collection CL2JetsSC8 (required if `bufferFileType` = `output`) | +| `OutputChannels.CL2Photons` | `cms.vuint32` | Channels for collection CL2Photons (required if `bufferFileType` = `output`) | +| `OutputChannels.CL2Electrons` | `cms.vuint32` | Channels for collection CL2Electrons (required if `bufferFileType` = `output`) | +| `OutputChannels.CL2Taus` | `cms.vuint32` | Channels for collection CL2Taus (required if `bufferFileType` = `output`) | +| `OutputChannels.CL2EtSum` | `cms.vuint32` | Channels for collection CL2EtSum (required if `bufferFileType` = `output`) | +| `OutputChannels.CL2HtSum` | `cms.vuint32` | Channels for collection CL2HtSum (required if `bufferFileType` = `output`) | + +Note: In order to get consistency across multiple pattern files written by multiple writers it is recommended to produce patterns in single threaded mode only (i.e. `process.options.numberOfThreads = 1`). + +Default configurations for `L1GTAlgoBoardWriter` and `L1GTObjectBoardWriter` in input and output direction can be pulled into the configuration for each of the two prototype implementations VU9P and VU13P via: + +```python +# Serenity VU9P prototype board +process.load('L1Trigger.Phase2L1GT.l1tGTBoardWriterVU9P_cff') + +process.pBoardDataInputVU9P = cms.EndPath(process.BoardDataInputVU9P) +process.pBoardDataOutputObjectsVU9P = cms.EndPath(process.BoardDataOutputObjectsVU9P) +process.pAlgoBitBoardDataVU9P = cms.EndPath(process.AlgoBitBoardDataVU9P) +``` + +```python +# Serenity VU13P prototype board +process.load('L1Trigger.Phase2L1GT.l1tGTBoardWriterVU13P_cff') + +process.pBoardDataInputVU13P = cms.EndPath(process.BoardDataInputVU13P) +process.pBoardDataOutputObjectsVU13P = cms.EndPath(process.BoardDataOutputObjectsVU13P) +process.pAlgoBitBoardDataVU13P = cms.EndPath(process.AlgoBitBoardDataVU13P) +``` diff --git a/L1Trigger/Phase2L1GT/plugins/L1GTAlgoBoardWriter.cc b/L1Trigger/Phase2L1GT/plugins/L1GTAlgoBoardWriter.cc index 603680e2940ab..565d460398fd9 100644 --- a/L1Trigger/Phase2L1GT/plugins/L1GTAlgoBoardWriter.cc +++ b/L1Trigger/Phase2L1GT/plugins/L1GTAlgoBoardWriter.cc @@ -16,6 +16,7 @@ #include "L1Trigger/DemonstratorTools/interface/utilities.h" #include "FWCore/Utilities/interface/EDGetToken.h" +#include "FWCore/Utilities/interface/EDMException.h" #include "DataFormats/L1Trigger/interface/P2GTAlgoBlock.h" @@ -24,6 +25,7 @@ #include #include #include +#include using namespace l1t; @@ -37,6 +39,9 @@ class L1GTAlgoBoardWriter : public edm::one::EDAnalyzer<> { void analyze(const edm::Event&, const edm::EventSetup&) override; void endJob() override; + unsigned int eventCounter_; + unsigned int maxEvents_; + const std::array channels_; const std::array algoBitMask_; const edm::EDGetTokenT algoBlocksToken_; @@ -46,17 +51,33 @@ class L1GTAlgoBoardWriter : public edm::one::EDAnalyzer<> { std::size_t tmuxCounter_; }; +template +static std::array convert(std::vector vec, const char* name) { + if (vec.size() != N) { + throw edm::Exception(edm::errors::Configuration) + << "The parameter '" << name << "' should have " << N << " elements, but has " << vec.size() + << " elements in the configuration.\n"; + } + std::array a; + std::copy_n(std::make_move_iterator(vec.begin()), N, a.begin()); + return a; +} + L1GTAlgoBoardWriter::L1GTAlgoBoardWriter(const edm::ParameterSet& config) - : channels_(config.getParameter>("channels")), - algoBitMask_(config.getParameter>("algoBitMask")), - algoBlocksToken_(consumes(config.getParameter("algoBlocksTag"))), + : eventCounter_(0), + maxEvents_(config.getUntrackedParameter("maxEvents")), + channels_( + convert(config.getUntrackedParameter>("channels"), "channels")), + algoBitMask_(convert( + config.getUntrackedParameter>("algoBitMask"), "algoBitMask")), + algoBlocksToken_(consumes(config.getUntrackedParameter("algoBlocksTag"))), boardDataWriter_( - l1t::demo::parseFileFormat(config.getParameter("patternFormat")), - config.getParameter("outputFilename"), - config.getParameter("outputFileExtension"), + l1t::demo::parseFileFormat(config.getUntrackedParameter("patternFormat")), + config.getUntrackedParameter("filename"), + config.getUntrackedParameter("fileExtension"), 9, 2, - config.getParameter("maxLines"), + config.getUntrackedParameter("maxFrames"), [](const std::array& channels) { l1t::demo::BoardDataWriter::ChannelMap_t channelMap; for (unsigned int channel : channels) { @@ -94,6 +115,12 @@ void L1GTAlgoBoardWriter::analyze(const edm::Event& event, const edm::EventSetup } tmuxCounter_ = (tmuxCounter_ + 1) % 2; + eventCounter_++; + + if (maxEvents_ != 0 && eventCounter_ == maxEvents_) { + boardDataWriter_.flush(); + eventCounter_ = 0; + } } void L1GTAlgoBoardWriter::endJob() { @@ -106,22 +133,23 @@ void L1GTAlgoBoardWriter::endJob() { void L1GTAlgoBoardWriter::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { edm::ParameterSetDescription desc; - desc.add("outputFilename"); - desc.add("outputFileExtension", "txt"); - desc.add("algoBlocksTag"); - desc.add>("channels"); - desc.add>("algoBitMask", - {0xffffffffffffffffull, - 0xffffffffffffffffull, - 0xffffffffffffffffull, - 0xffffffffffffffffull, - 0xffffffffffffffffull, - 0xffffffffffffffffull, - 0xffffffffffffffffull, - 0xffffffffffffffffull, - 0xffffffffffffffffull}); - desc.add("maxLines", 1024); - desc.add("patternFormat", "EMPv2"); + desc.addUntracked("filename"); + desc.addUntracked("fileExtension", "txt"); + desc.addUntracked("algoBlocksTag"); + desc.addUntracked("maxEvents", 0); + desc.addUntracked>("channels"); + desc.addUntracked>("algoBitMask", + {0xffffffffffffffffull, + 0xffffffffffffffffull, + 0xffffffffffffffffull, + 0xffffffffffffffffull, + 0xffffffffffffffffull, + 0xffffffffffffffffull, + 0xffffffffffffffffull, + 0xffffffffffffffffull, + 0xffffffffffffffffull}); + desc.addUntracked("maxFrames", 1024); + desc.addUntracked("patternFormat", "EMPv2"); descriptions.addDefault(desc); } diff --git a/L1Trigger/Phase2L1GT/plugins/L1GTDoubleObjectCond.cc b/L1Trigger/Phase2L1GT/plugins/L1GTDoubleObjectCond.cc index 36b1295a07174..d759334aa4e09 100644 --- a/L1Trigger/Phase2L1GT/plugins/L1GTDoubleObjectCond.cc +++ b/L1Trigger/Phase2L1GT/plugins/L1GTDoubleObjectCond.cc @@ -142,6 +142,9 @@ bool L1GTDoubleObjectCond::filter(edm::StreamID, edm::Event& event, const edm::E } } + condition_result &= collection1Cuts_.checkCollection(*col1); + condition_result &= collection2Cuts_.checkCollection(*col2); + if (condition_result) { std::unique_ptr triggerCol1 = std::make_unique(); diff --git a/L1Trigger/Phase2L1GT/plugins/L1GTEvaluationInterface.h b/L1Trigger/Phase2L1GT/plugins/L1GTEvaluationInterface.h index 275e0fb87d49e..69d9c0cdc2d9c 100644 --- a/L1Trigger/Phase2L1GT/plugins/L1GTEvaluationInterface.h +++ b/L1Trigger/Phase2L1GT/plugins/L1GTEvaluationInterface.h @@ -282,24 +282,40 @@ namespace l1t { struct L1TGT_GTT_PromptJet : public L1TGT_Common3Vector<128> { ap_int<10> z0; ap_uint<5> number_of_tracks; - // ap_uint<5> /* unassigned */; - - L1TGT_GTT_PromptJet(int valid = 0, int pT = 0, int phi = 0, int eta = 0, int z0 = 0, int number_of_tracks = 0) - : L1TGT_Common3Vector(valid, pT, phi, eta), z0(z0), number_of_tracks(number_of_tracks) {} + ap_uint<4> number_of_displaced_tracks; + + L1TGT_GTT_PromptJet(int valid = 0, + int pT = 0, + int phi = 0, + int eta = 0, + int z0 = 0, + int number_of_tracks = 0, + int number_of_displaced_tracks = 0) + : L1TGT_Common3Vector(valid, pT, phi, eta), + z0(z0), + number_of_tracks(number_of_tracks), + number_of_displaced_tracks(number_of_displaced_tracks) {} ap_uint pack() const override { - return l1t_pack_int>(L1TGT_Common3Vector::pack_common(), z0, number_of_tracks); + return l1t_pack_int>( + L1TGT_Common3Vector::pack_common(), z0, number_of_tracks, number_of_displaced_tracks); } static L1TGT_GTT_PromptJet from_GTObject(const P2GTCandidate& gtObject) { - return L1TGT_GTT_PromptJet( - 1, gtObject.hwPT(), gtObject.hwPhi(), gtObject.hwEta(), gtObject.hwZ0() >> 7, gtObject.hwNumber_of_tracks()); + return L1TGT_GTT_PromptJet(1, + gtObject.hwPT(), + gtObject.hwPhi(), + gtObject.hwEta(), + gtObject.hwZ0() >> 7, + gtObject.hwNumber_of_tracks(), + gtObject.hwNumber_of_displaced_tracks()); } P2GTCandidate to_GTObject() const override { P2GTCandidate gt_object(L1TGT_Common3Vector::to_GTObject()); gt_object.setHwZ0(static_cast(z0) << 7); gt_object.setHwNumber_of_tracks(number_of_tracks); + gt_object.setHwNumber_of_displaced_tracks(number_of_displaced_tracks); return gt_object; } @@ -308,15 +324,23 @@ namespace l1t { struct L1TGT_GTT_DisplacedJet : public L1TGT_Common3Vector<128> { ap_int<10> z0; ap_uint<5> number_of_tracks; - // ap_uint<5> /* unassigned */; - ap_int<12> d0; - - L1TGT_GTT_DisplacedJet( - int valid = 0, int pT = 0, int phi = 0, int eta = 0, int z0 = 0, int number_of_tracks = 0, int d0 = 0) - : L1TGT_Common3Vector(valid, pT, phi, eta), z0(z0), number_of_tracks(number_of_tracks), d0(d0) {} + ap_uint<4> number_of_displaced_tracks; + + L1TGT_GTT_DisplacedJet(int valid = 0, + int pT = 0, + int phi = 0, + int eta = 0, + int z0 = 0, + int number_of_tracks = 0, + int number_of_displaced_tracks = 0) + : L1TGT_Common3Vector(valid, pT, phi, eta), + z0(z0), + number_of_tracks(number_of_tracks), + number_of_displaced_tracks(number_of_displaced_tracks) {} ap_uint pack() const override { - return l1t_pack_int>(L1TGT_Common3Vector::pack_common(), z0, number_of_tracks, ap_uint<5>(0), d0); + return l1t_pack_int>( + L1TGT_Common3Vector::pack_common(), z0, number_of_tracks, number_of_displaced_tracks); } static L1TGT_GTT_DisplacedJet from_GTObject(const P2GTCandidate& gtObject) { @@ -326,14 +350,14 @@ namespace l1t { gtObject.hwEta(), gtObject.hwZ0() >> 7, gtObject.hwNumber_of_tracks(), - gtObject.hwD0()); + gtObject.hwNumber_of_displaced_tracks()); } P2GTCandidate to_GTObject() const override { P2GTCandidate gt_object(L1TGT_Common3Vector::to_GTObject()); gt_object.setHwZ0(static_cast(z0) << 7); gt_object.setHwNumber_of_tracks(number_of_tracks); - gt_object.setHwD0(d0); + gt_object.setHwNumber_of_displaced_tracks(number_of_displaced_tracks); return gt_object; } diff --git a/L1Trigger/Phase2L1GT/plugins/L1GTEvaluationProducer.cc b/L1Trigger/Phase2L1GT/plugins/L1GTEvaluationProducer.cc index 53c3ad54beded..fabce2325a93f 100644 --- a/L1Trigger/Phase2L1GT/plugins/L1GTEvaluationProducer.cc +++ b/L1Trigger/Phase2L1GT/plugins/L1GTEvaluationProducer.cc @@ -1,3 +1,8 @@ +/** Produces Pseudo-random upstream objects converts them into P2GTCandidates and + * writes them into buffer files. Intended to more thoroughly test the whole + * phase space of Phase-2 GT inputs. + * */ + #include "FWCore/ParameterSet/interface/ParameterSetDescription.h" #include "FWCore/ParameterSet/interface/allowedValues.h" #include "DataFormats/Common/interface/Handle.h" @@ -58,101 +63,157 @@ class L1GTEvaluationProducer : public edm::one::EDProducer<> { void writeInputPatterns( const std::unordered_map>> &inputObjects); + void writeOutputPatterns( + const std::unordered_map>> &inputObjects); + void endJob() override; std::mt19937 randomGenerator_; - l1t::demo::BoardDataWriter boardDataWriter_; + l1t::demo::BoardDataWriter inputBoardDataWriter_; + std::unordered_map numChannels_; + l1t::demo::BoardDataWriter outputBoardDataWriter_; }; -template -static constexpr std::array arange() { - std::array array; - T value = low; - for (T &el : array) { - el = value; - value += incr; - } - return array; -} - -template -static std::vector vrange() { - std::array arr(arange()); - return std::vector(std::begin(arr), std::end(arr)); +static constexpr std::array AVAILABLE_COLLECTIONS{{"GTTPromptJets", + "GTTDisplacedJets", + "GTTPromptHtSum", + "GTTDisplacedHtSum", + "GTTEtSum", + "GTTHadronicTaus", + "CL2JetsSC4", + "CL2JetsSC8", + "CL2Taus", + "CL2HtSum", + "CL2EtSum", + "GCTNonIsoEg", + "GCTIsoEg", + "GCTJets", + "GCTTaus", + "GCTHtSum", + "GCTEtSum", + "GMTSaPromptMuons", + "GMTSaDisplacedMuons", + "GMTTkMuons", + "GMTTopo", + "CL2Electrons", + "CL2Photons", + "GTTPhiCandidates", + "GTTRhoCandidates", + "GTTBsCandidates", + "GTTPromptTracks", + "GTTDisplacedTracks", + "GTTPrimaryVert"}}; + +template +static std::vector vconvert(std::vector ivec) { + return std::vector(ivec.begin(), ivec.end()); } -static const l1t::demo::BoardDataWriter::ChannelMap_t CHANNEL_MAP_VU9P{ - {{"GTT", 0}, {{6, 0}, vrange()}}, - {{"GTT", 1}, {{6, 0}, vrange()}}, - {{"CL2", 0}, {{6, 0}, vrange()}}, - {{"CL2", 1}, {{6, 0}, vrange()}}, - {{"GCT", 0}, {{6, 0}, vrange()}}, - {{"GMT", 0}, {{18, 0}, vrange()}}, - {{"CL2", 2}, {{6, 0}, vrange()}}, - {{"GTT", 2}, {{6, 0}, vrange()}}, - {{"GTT", 3}, {{6, 0}, vrange()}}}; - -static const l1t::demo::BoardDataWriter::ChannelMap_t CHANNEL_MAP_VU13P{ - {{"GTT", 0}, {{6, 0}, vrange()}}, - {{"GTT", 1}, {{6, 0}, vrange()}}, - {{"GCT", 0}, {{6, 0}, vrange()}}, - {{"CL2", 0}, {{6, 0}, vrange()}}, - {{"CL2", 1}, {{6, 0}, vrange()}}, - {{"GMT", 0}, {{18, 0}, {48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 68, 69, 70, 71, 72, 73}}}, - {{"CL2", 2}, {{6, 0}, vrange()}}, - {{"GTT", 2}, {{6, 0}, vrange()}}, - {{"GTT", 3}, {{6, 0}, vrange()}}}; - L1GTEvaluationProducer::L1GTEvaluationProducer(const edm::ParameterSet &config) - : randomGenerator_(config.exists("random_seed") ? config.getParameter("random_seed") + : randomGenerator_(config.exists("random_seed") ? config.getUntrackedParameter("random_seed") : std::random_device()()), - boardDataWriter_(l1t::demo::parseFileFormat(config.getParameter("patternFormat")), - config.getParameter("outputFilename"), - config.getParameter("outputFileExtension"), - 9, - 1, - config.getParameter("maxLines"), - config.getParameter("platform") == "VU13P" ? CHANNEL_MAP_VU13P : CHANNEL_MAP_VU9P) { - produces("GCTNonIsoEg"); - produces("GCTIsoEg"); - produces("GCTJets"); - produces("GCTTaus"); - produces("GCTHtSum"); - produces("GCTEtSum"); - produces("GMTSaPromptMuons"); - produces("GMTSaDisplacedMuons"); - produces("GMTTkMuons"); - produces("GMTTopo"); - produces("GTTPromptJets"); - produces("GTTDisplacedJets"); - produces("GTTPhiCandidates"); - produces("GTTRhoCandidates"); - produces("GTTBsCandidates"); - produces("GTTHadronicTaus"); - produces("GTTPromptTracks"); - produces("GTTDisplacedTracks"); - produces("GTTPrimaryVert"); - produces("GTTPromptHtSum"); - produces("GTTDisplacedHtSum"); - produces("GTTEtSum"); - produces("CL2JetsSC4"); - produces("CL2JetsSC8"); - produces("CL2Taus"); - produces("CL2Electrons"); - produces("CL2Photons"); - produces("CL2HtSum"); - produces("CL2EtSum"); + inputBoardDataWriter_( + l1t::demo::parseFileFormat(config.getUntrackedParameter("patternFormat")), + config.getUntrackedParameter("inputFilename"), + config.getUntrackedParameter("inputFileExtension"), + 9, + 1, + config.getUntrackedParameter("maxFrames"), + [&]() { + const edm::ParameterSet &iChannels = config.getUntrackedParameterSet("InputChannels"); + demo::BoardDataWriter::ChannelMap_t channelMap; + + channelMap.insert( + {{"GCT", 1}, + {{6, 0}, vconvert(iChannels.getUntrackedParameter>("GCT_1"))}}); + channelMap.insert( + {{"GMT", 1}, + {{18, 0}, + vconvert(iChannels.getUntrackedParameter>("GMT_1"))}}); + channelMap.insert( + {{"GTT", 1}, + {{6, 0}, vconvert(iChannels.getUntrackedParameter>("GTT_1"))}}); + channelMap.insert( + {{"GTT", 2}, + {{6, 0}, vconvert(iChannels.getUntrackedParameter>("GTT_2"))}}); + channelMap.insert( + {{"GTT", 3}, + {{6, 0}, vconvert(iChannels.getUntrackedParameter>("GTT_3"))}}); + channelMap.insert( + {{"GTT", 4}, + {{6, 0}, vconvert(iChannels.getUntrackedParameter>("GTT_4"))}}); + channelMap.insert( + {{"CL2", 1}, + {{6, 0}, vconvert(iChannels.getUntrackedParameter>("CL2_1"))}}); + channelMap.insert( + {{"CL2", 2}, + {{6, 0}, vconvert(iChannels.getUntrackedParameter>("CL2_2"))}}); + channelMap.insert( + {{"CL2", 3}, + {{6, 0}, vconvert(iChannels.getUntrackedParameter>("CL2_3"))}}); + + return channelMap; + }()), + numChannels_(), + outputBoardDataWriter_(l1t::demo::parseFileFormat(config.getUntrackedParameter("patternFormat")), + config.getUntrackedParameter("outputFilename"), + config.getUntrackedParameter("outputFileExtension"), + 9, + 1, + config.getUntrackedParameter("maxFrames"), + [&]() { + const edm::ParameterSet &oChannels = config.getUntrackedParameterSet("OutputChannels"); + demo::BoardDataWriter::ChannelMap_t channelMap; + for (const char *name : AVAILABLE_COLLECTIONS) { + if (oChannels.exists(name)) { + std::vector channels = + oChannels.getUntrackedParameter>(name); + for (std::size_t i = 0; i < channels.size(); i++) { + channelMap.insert({{name, i}, {{1, 0}, {channels.at(i)}}}); + } + + numChannels_.insert({name, channels.size()}); + } else { + numChannels_.insert({name, 0}); + } + } + return channelMap; + }()) { + for (const char *name : AVAILABLE_COLLECTIONS) { + produces(name); + } } void L1GTEvaluationProducer::fillDescriptions(edm::ConfigurationDescriptions &description) { edm::ParameterSetDescription desc; - desc.addOptional("random_seed"); - desc.add("maxLines", 1024); - desc.add("outputFilename"); - desc.add("outputFileExtension", "txt"); - desc.add("patternFormat", "EMPv2"); - desc.ifValue(edm::ParameterDescription("platform", "VU9P", true), - edm::allowedValues("VU9P", "VU13P")); + desc.addOptionalUntracked("random_seed"); + desc.addUntracked("maxFrames", 1024); + desc.addUntracked("inputFilename"); + desc.addUntracked("inputFileExtension", "txt"); + desc.addUntracked("outputFilename"); + desc.addUntracked("outputFileExtension", "txt"); + desc.addUntracked("patternFormat", "EMPv2"); + + edm::ParameterSetDescription inputChannelDesc; + inputChannelDesc.addUntracked>("GCT_1"); + inputChannelDesc.addUntracked>("GMT_1"); + inputChannelDesc.addUntracked>("GTT_1"); + inputChannelDesc.addUntracked>("GTT_2"); + inputChannelDesc.addUntracked>("GTT_3"); + inputChannelDesc.addUntracked>("GTT_4"); + inputChannelDesc.addUntracked>("CL2_1"); + inputChannelDesc.addUntracked>("CL2_2"); + inputChannelDesc.addUntracked>("CL2_3"); + + desc.addUntracked("InputChannels", inputChannelDesc); + + edm::ParameterSetDescription outputChannelDesc; + for (const char *name : AVAILABLE_COLLECTIONS) { + outputChannelDesc.addOptionalUntracked>(name); + } + + desc.addUntracked("OutputChannels", outputChannelDesc); + description.addWithDefaultLabel(desc); } @@ -205,43 +266,64 @@ static std::vector> vpack(const Args &...vobjects) { void L1GTEvaluationProducer::writeInputPatterns( const std::unordered_map>> &inputObjects) { - boardDataWriter_.addEvent( - l1t::demo::EventData{{{{"GTT", 0}, + inputBoardDataWriter_.addEvent( + l1t::demo::EventData{{{{"GTT", 1}, vpack(inputObjects.at("GTTPromptJets"), inputObjects.at("GTTDisplacedJets"), inputObjects.at("GTTPromptHtSum"), inputObjects.at("GTTDisplacedHtSum"), inputObjects.at("GTTEtSum"))}, - {{"GTT", 1}, vpack(inputObjects.at("GTTHadronicTaus"))}, - {{"CL2", 0}, + {{"GTT", 2}, vpack(inputObjects.at("GTTHadronicTaus"))}, + {{"CL2", 1}, vpack(inputObjects.at("CL2JetsSC4"), inputObjects.at("CL2HtSum"), inputObjects.at("CL2EtSum"), inputObjects.at("CL2JetsSC8"))}, - {{"CL2", 1}, vpack(inputObjects.at("CL2Taus"))}, - {{"GCT", 0}, + {{"CL2", 2}, vpack(inputObjects.at("CL2Taus"))}, + {{"GCT", 1}, vpack(inputObjects.at("GCTNonIsoEg"), inputObjects.at("GCTIsoEg"), inputObjects.at("GCTJets"), inputObjects.at("GCTTaus"), inputObjects.at("GCTEtSum"), inputObjects.at("GCTHtSum"))}, - {{"GMT", 0}, + {{"GMT", 1}, vpack(inputObjects.at("GMTSaPromptMuons"), inputObjects.at("GMTSaDisplacedMuons"), inputObjects.at("GMTTkMuons"), inputObjects.at("GMTTopo"))}, - {{"CL2", 2}, vpack(inputObjects.at("CL2Electrons"), inputObjects.at("CL2Photons"))}, - {{"GTT", 2}, + {{"CL2", 3}, vpack(inputObjects.at("CL2Electrons"), inputObjects.at("CL2Photons"))}, + {{"GTT", 3}, vpack(inputObjects.at("GTTPhiCandidates"), inputObjects.at("GTTRhoCandidates"), inputObjects.at("GTTBsCandidates"))}, - {{"GTT", 3}, + {{"GTT", 4}, vpack(inputObjects.at("GTTPromptTracks"), inputObjects.at("GTTDisplacedTracks"), inputObjects.at("GTTPrimaryVert"))}}}); } +void L1GTEvaluationProducer::writeOutputPatterns( + const std::unordered_map>> &outputObjects) { + std::map>> eventData; + + for (const char *name : AVAILABLE_COLLECTIONS) { + std::vector> data = vpack(outputObjects.at(name)); + + for (std::size_t i = 0; i < numChannels_.at(name); i++) { + for (std::size_t j = i; j < data.size(); j += numChannels_.at(name)) { + eventData[{name, i}].push_back(data[j]); + } + + while (eventData[{name, i}].size() < 9) { + eventData[{name, i}].push_back(0); + } + } + } + + outputBoardDataWriter_.addEvent(eventData); +} + void L1GTEvaluationProducer::produce(edm::Event &event, const edm::EventSetup &setup) { // Generate random input objects std::unordered_map>> inputObjects; @@ -323,6 +405,7 @@ void L1GTEvaluationProducer::produce(edm::Event &event, const edm::EventSetup &s // Write them to a pattern file writeInputPatterns(inputObjects); + writeOutputPatterns(inputObjects); for (const auto &[key, inputCollection] : inputObjects) { std::unique_ptr gtCollection = std::make_unique(); @@ -334,6 +417,9 @@ void L1GTEvaluationProducer::produce(edm::Event &event, const edm::EventSetup &s } } -void L1GTEvaluationProducer::endJob() { boardDataWriter_.flush(); } +void L1GTEvaluationProducer::endJob() { + inputBoardDataWriter_.flush(); + outputBoardDataWriter_.flush(); +} DEFINE_FWK_MODULE(L1GTEvaluationProducer); diff --git a/L1Trigger/Phase2L1GT/plugins/L1GTFinOrBoardWriter.cc b/L1Trigger/Phase2L1GT/plugins/L1GTFinOrBoardWriter.cc index e2b2d3569b7b3..14f76a2cb0ac9 100644 --- a/L1Trigger/Phase2L1GT/plugins/L1GTFinOrBoardWriter.cc +++ b/L1Trigger/Phase2L1GT/plugins/L1GTFinOrBoardWriter.cc @@ -16,6 +16,7 @@ #include "L1Trigger/DemonstratorTools/interface/utilities.h" #include "FWCore/Utilities/interface/EDGetToken.h" +#include "FWCore/Utilities/interface/EDMException.h" #include "DataFormats/L1Trigger/interface/P2GTAlgoBlock.h" @@ -24,6 +25,7 @@ #include #include #include +#include using namespace l1t; @@ -37,6 +39,8 @@ class L1GTFinOrBoardWriter : public edm::one::EDAnalyzer<> { void analyze(const edm::Event&, const edm::EventSetup&) override; void endJob() override; + unsigned int eventCounter_; + const unsigned int maxEvents_; const std::array channelsLow_; const std::array channelsMid_; const std::array channelsHigh_; @@ -48,18 +52,35 @@ class L1GTFinOrBoardWriter : public edm::one::EDAnalyzer<> { std::size_t tmuxCounter_; }; +template +static std::array convert(std::vector vec, const char* name) { + if (vec.size() != N) { + throw edm::Exception(edm::errors::Configuration) + << "The parameter '" << name << "' should have " << N << " elements, but has " << vec.size() + << " elements in the configuration.\n"; + } + std::array a; + std::copy_n(std::make_move_iterator(vec.begin()), N, a.begin()); + return a; +} + L1GTFinOrBoardWriter::L1GTFinOrBoardWriter(const edm::ParameterSet& config) - : channelsLow_(config.getParameter>("channelsLow")), - channelsMid_(config.getParameter>("channelsMid")), - channelsHigh_(config.getParameter>("channelsHigh")), - channelFinOr_(config.getParameter("channelFinOr")), - algoBlocksToken_(consumes(config.getParameter("algoBlocksTag"))), - boardDataWriter_(l1t::demo::parseFileFormat(config.getParameter("patternFormat")), - config.getParameter("outputFilename"), - config.getParameter("outputFileExtension"), + : eventCounter_(0), + maxEvents_(config.getUntrackedParameter("maxEvents")), + channelsLow_(convert(config.getUntrackedParameter>("channelsLow"), + "channelsLow")), + channelsMid_(convert(config.getUntrackedParameter>("channelsMid"), + "channelsMid")), + channelsHigh_(convert(config.getUntrackedParameter>("channelsHigh"), + "channelsHigh")), + channelFinOr_(config.getUntrackedParameter("channelFinOr")), + algoBlocksToken_(consumes(config.getUntrackedParameter("algoBlocksTag"))), + boardDataWriter_(l1t::demo::parseFileFormat(config.getUntrackedParameter("patternFormat")), + config.getUntrackedParameter("filename"), + config.getUntrackedParameter("fileExtension"), 9, 2, - config.getParameter("maxLines"), + config.getUntrackedParameter("maxFrames"), [&]() { l1t::demo::BoardDataWriter::ChannelMap_t channelMap; channelMap.insert({l1t::demo::LinkId{"BeforeBxMaskAndPrescaleLow", channelsLow_[0]}, @@ -169,6 +190,13 @@ void L1GTFinOrBoardWriter::analyze(const edm::Event& event, const edm::EventSetu } tmuxCounter_ = (tmuxCounter_ + 1) % 2; + + eventCounter_++; + + if (maxEvents_ != 0 && eventCounter_ == maxEvents_) { + boardDataWriter_.flush(); + eventCounter_ = 0; + } } void L1GTFinOrBoardWriter::endJob() { @@ -181,15 +209,16 @@ void L1GTFinOrBoardWriter::endJob() { void L1GTFinOrBoardWriter::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { edm::ParameterSetDescription desc; - desc.add("outputFilename"); - desc.add("outputFileExtension", "txt"); - desc.add("algoBlocksTag"); - desc.add>("channelsLow"); - desc.add>("channelsMid"); - desc.add>("channelsHigh"); - desc.add("channelFinOr"); - desc.add("maxLines", 1024); - desc.add("patternFormat", "EMPv2"); + desc.addUntracked("filename"); + desc.addUntracked("fileExtension", "txt"); + desc.addUntracked("algoBlocksTag"); + desc.addUntracked>("channelsLow"); + desc.addUntracked>("channelsMid"); + desc.addUntracked>("channelsHigh"); + desc.addUntracked("channelFinOr"); + desc.addUntracked("maxFrames", 1024); + desc.addUntracked("maxEvents", 0); + desc.addUntracked("patternFormat", "EMPv2"); descriptions.addDefault(desc); } diff --git a/L1Trigger/Phase2L1GT/plugins/L1GTObjectBoardWriter.cc b/L1Trigger/Phase2L1GT/plugins/L1GTObjectBoardWriter.cc new file mode 100644 index 0000000000000..6059c3b474f62 --- /dev/null +++ b/L1Trigger/Phase2L1GT/plugins/L1GTObjectBoardWriter.cc @@ -0,0 +1,469 @@ +/** + * BoardDataWriter for input/output patterns of upstream objects. + **/ + +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/one/EDAnalyzer.h" + +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/MakerMacros.h" + +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ParameterSet/interface/allowedValues.h" +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" +#include "FWCore/Utilities/interface/InputTag.h" + +#include "L1Trigger/DemonstratorTools/interface/BoardDataWriter.h" +#include "L1Trigger/DemonstratorTools/interface/utilities.h" +#include "L1Trigger/DemonstratorTools/interface/codecs/etsums.h" +#include "L1Trigger/DemonstratorTools/interface/codecs/htsums.h" + +#include "FWCore/Utilities/interface/EDGetToken.h" + +#include "DataFormats/L1Trigger/interface/TkJetWord.h" +#include "DataFormats/L1Trigger/interface/VertexWord.h" + +#include "DataFormats/L1TMuonPhase2/interface/SAMuon.h" +#include "DataFormats/L1TMuonPhase2/interface/TrackerMuon.h" + +#include "DataFormats/L1TParticleFlow/interface/PFJet.h" +#include "DataFormats/L1TCorrelator/interface/TkEmFwd.h" +#include "DataFormats/L1TCorrelator/interface/TkEm.h" +#include "DataFormats/L1TCorrelator/interface/TkElectronFwd.h" +#include "DataFormats/L1TCorrelator/interface/TkElectron.h" +#include "DataFormats/L1TParticleFlow/interface/PFTau.h" + +#include "DataFormats/L1Trigger/interface/EtSum.h" +#include "DataFormats/L1Trigger/interface/P2GTCandidate.h" + +#include +#include +#include +#include +#include +#include +#include + +using namespace l1t; + +class L1GTObjectBoardWriter : public edm::one::EDAnalyzer<> { +public: + explicit L1GTObjectBoardWriter(const edm::ParameterSet&); + + static void fillDescriptions(edm::ConfigurationDescriptions&); + +private: + void analyze(const edm::Event&, const edm::EventSetup&) override; + void endJob() override; + + enum BufferType { INPUT, OUTPUT }; + + const BufferType bufferFileType_; + unsigned int eventCounter_; + unsigned int maxEvents_; + std::unordered_map numChannels_; + demo::BoardDataWriter boardDataWriter_; + + // From upstream + const edm::EDGetTokenT gttPromptJetToken_; + const edm::EDGetTokenT gttDisplacedJetToken_; + const edm::EDGetTokenT> gttPromptHtSumToken_; + const edm::EDGetTokenT> gttDisplacedHtSumToken_; + const edm::EDGetTokenT> gttEtSumToken_; + const edm::EDGetTokenT gttPrimaryVertexToken_; + + const edm::EDGetTokenT gmtSaPromptMuonToken_; + const edm::EDGetTokenT gmtSaDisplacedMuonToken_; + const edm::EDGetTokenT gmtTkMuonToken_; + + const edm::EDGetTokenT cl2JetSC4Token_; + const edm::EDGetTokenT cl2JetSC8Token_; + const edm::EDGetTokenT cl2PhotonToken_; + const edm::EDGetTokenT cl2ElectronToken_; + const edm::EDGetTokenT cl2TauToken_; + const edm::EDGetTokenT> cl2EtSumToken_; + const edm::EDGetTokenT> cl2HtSumToken_; +}; + +template +static std::vector vconvert(std::vector ivec) { + return std::vector(ivec.begin(), ivec.end()); +} + +static constexpr std::array AVAILABLE_COLLECTIONS{{"GTTPromptJets", + "GTTDisplacedJets", + "GTTPromptHtSum", + "GTTDisplacedHtSum", + "GTTEtSum", + "GTTHadronicTaus", + "CL2JetsSC4", + "CL2JetsSC8", + "CL2Taus", + "CL2HtSum", + "CL2EtSum", + "GCTNonIsoEg", + "GCTIsoEg", + "GCTJets", + "GCTTaus", + "GCTHtSum", + "GCTEtSum", + "GMTSaPromptMuons", + "GMTSaDisplacedMuons", + "GMTTkMuons", + "GMTTopo", + "CL2Electrons", + "CL2Photons", + "GTTPhiCandidates", + "GTTRhoCandidates", + "GTTBsCandidates", + "GTTPrimaryVert"}}; + +L1GTObjectBoardWriter::L1GTObjectBoardWriter(const edm::ParameterSet& config) + : bufferFileType_(config.getUntrackedParameter("bufferFileType") == "input" ? INPUT : OUTPUT), + eventCounter_(0), + maxEvents_(config.getUntrackedParameter("maxEvents")), + numChannels_(), + boardDataWriter_( + demo::parseFileFormat(config.getUntrackedParameter("patternFormat")), + config.getUntrackedParameter("filename"), + config.getUntrackedParameter("fileExtension"), + 9, + 1, + config.getUntrackedParameter("maxFrames"), + [&]() { + if (bufferFileType_ == INPUT) { + const edm::ParameterSet& iChannels = config.getUntrackedParameterSet("InputChannels"); + demo::BoardDataWriter::ChannelMap_t channelMap; + + channelMap.insert( + {{"GCT", 1}, + {{6, 0}, + vconvert(iChannels.getUntrackedParameter>("GCT_1"))}}); + channelMap.insert( + {{"GMT", 1}, + {{18, 0}, + vconvert(iChannels.getUntrackedParameter>("GMT_1"))}}); + channelMap.insert( + {{"GTT", 1}, + {{6, 0}, + vconvert(iChannels.getUntrackedParameter>("GTT_1"))}}); + channelMap.insert( + {{"GTT", 2}, + {{6, 0}, + vconvert(iChannels.getUntrackedParameter>("GTT_2"))}}); + channelMap.insert( + {{"GTT", 3}, + {{6, 0}, + vconvert(iChannels.getUntrackedParameter>("GTT_3"))}}); + channelMap.insert( + {{"GTT", 4}, + {{6, 0}, + vconvert(iChannels.getUntrackedParameter>("GTT_4"))}}); + channelMap.insert( + {{"CL2", 1}, + {{6, 0}, + vconvert(iChannels.getUntrackedParameter>("CL2_1"))}}); + channelMap.insert( + {{"CL2", 2}, + {{6, 0}, + vconvert(iChannels.getUntrackedParameter>("CL2_2"))}}); + channelMap.insert( + {{"CL2", 3}, + {{6, 0}, + vconvert(iChannels.getUntrackedParameter>("CL2_3"))}}); + + return channelMap; + } else { + const edm::ParameterSet& oChannels = config.getUntrackedParameterSet("OutputChannels"); + demo::BoardDataWriter::ChannelMap_t channelMap; + for (const char* name : AVAILABLE_COLLECTIONS) { + std::vector channels = oChannels.getUntrackedParameter>(name); + for (std::size_t i = 0; i < channels.size(); i++) { + channelMap.insert({{name, i}, {{1, 0}, {channels.at(i)}}}); + } + numChannels_.insert({name, channels.size()}); + } + return channelMap; + } + }()), + gttPromptJetToken_(consumes(config.getUntrackedParameter("GTTPromptJets"))), + gttDisplacedJetToken_( + consumes(config.getUntrackedParameter("GTTDisplacedJets"))), + gttPromptHtSumToken_(consumes>(config.getUntrackedParameter("GTTPromptHtSum"))), + gttDisplacedHtSumToken_( + consumes>(config.getUntrackedParameter("GTTDisplacedHtSum"))), + gttEtSumToken_(consumes>(config.getUntrackedParameter("GTTEtSum"))), + gttPrimaryVertexToken_( + consumes(config.getUntrackedParameter("GTTPrimaryVert"))), + gmtSaPromptMuonToken_( + consumes(config.getUntrackedParameter("GMTSaPromptMuons"))), + gmtSaDisplacedMuonToken_( + consumes(config.getUntrackedParameter("GMTSaDisplacedMuons"))), + gmtTkMuonToken_(consumes(config.getUntrackedParameter("GMTTkMuons"))), + cl2JetSC4Token_(consumes(config.getUntrackedParameter("CL2JetsSC4"))), + cl2JetSC8Token_(consumes(config.getUntrackedParameter("CL2JetsSC8"))), + cl2PhotonToken_(consumes(config.getUntrackedParameter("CL2Photons"))), + cl2ElectronToken_(consumes(config.getUntrackedParameter("CL2Electrons"))), + cl2TauToken_(consumes(config.getUntrackedParameter("CL2Taus"))), + cl2EtSumToken_(consumes>(config.getUntrackedParameter("CL2EtSum"))), + cl2HtSumToken_(consumes>(config.getUntrackedParameter("CL2HtSum"))) {} + +template +static std::vector> packCollection(const std::vector& collection) { + std::vector> packed; + std::optional> next_packed; + + for (std::size_t idx = 0; idx < collection.size() && idx < 12; idx++) { + const T& obj = collection[idx]; + if constexpr (std::is_same_v) { + ap_uint<128> word = obj.tkJetWord(); + packed.emplace_back(word(63, 0)); + packed.emplace_back(word(127, 64)); + } else if constexpr (std::is_same_v) { + if constexpr (type == P2GTCandidate::GTTEtSum) { + packed.emplace_back(l1t::demo::codecs::encodeEtSum(obj)); + } else if constexpr (type == P2GTCandidate::GTTPromptHtSum || type == P2GTCandidate::GTTDisplacedHtSum) { + packed.emplace_back(l1t::demo::codecs::encodeHtSum(obj)); + } else if constexpr (type == P2GTCandidate::CL2EtSum) { + l1gt::Sum sum{true /* valid */, obj.pt(), obj.phi() / l1gt::Scales::ETAPHI_LSB, 0 /* scalar sum */}; + packed.emplace_back(sum.pack_ap()); + } else if constexpr (type == P2GTCandidate::CL2HtSum) { + // Make interfaces great again! + const EtSum& ht = collection[0]; + const EtSum& mht = collection[1]; + + l1gt::Sum sum{true /* valid */, mht.pt(), mht.phi() / l1gt::Scales::ETAPHI_LSB, ht.pt()}; + packed.emplace_back(sum.pack_ap()); + } + break; + } else if constexpr (std::is_same_v) { + packed.emplace_back(obj.vertexWord()); + } else if constexpr (std::is_same_v) { + packed.emplace_back(obj.word()); + } else if constexpr (std::is_same_v) { + std::array word = obj.word(); + if (next_packed.has_value()) { + packed.emplace_back(word[1] << 32 | next_packed.value()); + next_packed.reset(); + } else { + next_packed = word[1]; + } + + packed.emplace_back(word[0]); + } else if constexpr (std::is_same_v) { + packed.emplace_back(obj.encodedJet()[0]); + packed.emplace_back(obj.encodedJet()[1]); + } else if constexpr (std::is_same_v || std::is_same_v) { + ap_uint<96> word = obj.template egBinaryWord<96>(); + if (next_packed.has_value()) { + packed.emplace_back(word(95, 64) << 32 | next_packed.value()); + next_packed.reset(); + } else { + next_packed = word(95, 64); + } + + packed.emplace_back(word(63, 0)); + } else if constexpr (std::is_same_v) { + std::array word = obj.encodedTau(); + if (next_packed.has_value()) { + packed.emplace_back(word[1] << 32 | next_packed.value()); + next_packed.reset(); + } else { + next_packed = word[1]; + } + + packed.emplace_back(word[0]); + } + } + + // Filling up remaining words with 0 + if constexpr (std::is_same_v || std::is_same_v) { + while (packed.size() < 24) { + packed.emplace_back(0); + } + } else if constexpr (std::is_same_v || std::is_same_v || std::is_same_v || + std::is_same_v) { + while (packed.size() < 18) { + if (next_packed) { + packed.emplace_back(next_packed.value()); + next_packed.reset(); + } else { + packed.emplace_back(0); + } + } + } else if constexpr (std::is_same_v || std::is_same_v) { + while (packed.size() < 12) { + packed.emplace_back(0); + } + } else if constexpr (std::is_same_v) { + if (packed.size() < 1) { + packed.emplace_back(0); + } + } + + return packed; +} + +template +static std::vector operator+(std::vector&& lhs, std::vector&& rhs) { + std::vector concat; + concat.reserve(lhs.size() + rhs.size()); + std::move(lhs.begin(), lhs.end(), std::back_inserter(concat)); + std::move(rhs.begin(), rhs.end(), std::back_inserter(concat)); + return concat; +} + +void L1GTObjectBoardWriter::analyze(const edm::Event& event, const edm::EventSetup&) { + const TkJetWordCollection& gttPromptJets = event.get(gttPromptJetToken_); + const TkJetWordCollection& gttDisplacedJets = event.get(gttDisplacedJetToken_); + const std::vector& gttPromptHtSum = event.get(gttPromptHtSumToken_); + const std::vector& gttDisplacedHtSum = event.get(gttDisplacedHtSumToken_); + const std::vector& gttEtSum = event.get(gttEtSumToken_); + const VertexWordCollection& gttPrimaryVertices = event.get(gttPrimaryVertexToken_); + const SAMuonCollection& gmtSaPromptMuons = event.get(gmtSaPromptMuonToken_); + const SAMuonCollection& gmtSaDisplacedMuons = event.get(gmtSaDisplacedMuonToken_); + const TrackerMuonCollection& gmtTkMuons = event.get(gmtTkMuonToken_); + const PFJetCollection& cl2JetsSC4 = event.get(cl2JetSC4Token_); + const PFJetCollection& cl2JetsSC8 = event.get(cl2JetSC8Token_); + const TkEmCollection& cl2Photons = event.get(cl2PhotonToken_); + const TkElectronCollection& cl2Electrons = event.get(cl2ElectronToken_); + const PFTauCollection& cl2Taus = event.get(cl2TauToken_); + const std::vector& cl2EtSum = event.get(cl2EtSumToken_); + const std::vector& cl2HtSum = event.get(cl2HtSumToken_); + + if (bufferFileType_ == INPUT) { + boardDataWriter_.addEvent( + demo::EventData{{{{"GTT", 1}, + packCollection(gttPromptJets) + packCollection(gttDisplacedJets) + + packCollection(gttPromptHtSum) + + packCollection(gttDisplacedHtSum) + + packCollection(gttEtSum)}, + {{"GTT", 2}, std::vector>(18, 0)}, + {{"CL2", 1}, + packCollection(cl2JetsSC4) + packCollection(cl2HtSum) + + packCollection(cl2EtSum) + packCollection(cl2JetsSC8)}, + {{"CL2", 2}, packCollection(cl2Taus)}, + {{"GCT", 1}, std::vector>(50, 0)}, + {{"GMT", 1}, + packCollection(gmtSaPromptMuons) + packCollection(gmtSaDisplacedMuons) + + packCollection(gmtTkMuons) + std::vector>(12, 0)}, + {{"CL2", 3}, packCollection(cl2Electrons) + packCollection(cl2Photons)}, + {{"GTT", 3}, std::vector>(39, 0)}, + {{"GTT", 4}, std::vector>(36, 0) + packCollection(gttPrimaryVertices)}}}); + } else { + std::map>> eventData; + + for (const char* name : AVAILABLE_COLLECTIONS) { + std::vector> data; + + if (std::string("GTTPromptJets") == name) { + data = packCollection(gttPromptJets); + } else if (std::string("GTTDisplacedJets") == name) { + data = packCollection(gttDisplacedJets); + } else if (std::string("GTTPromptHtSum") == name) { + data = packCollection(gttPromptHtSum); + } else if (std::string("GTTDisplacedHtSum") == name) { + data = packCollection(gttDisplacedHtSum); + } else if (std::string("GTTEtSum") == name) { + data = packCollection(gttEtSum); + } else if (std::string("GTTPrimaryVert") == name) { + data = packCollection(gttPrimaryVertices); + } else if (std::string("GMTSaPromptMuons") == name) { + data = packCollection(gmtSaPromptMuons); + } else if (std::string("GMTSaDisplacedMuons") == name) { + data = packCollection(gmtSaDisplacedMuons); + } else if (std::string("GMTTkMuons") == name) { + data = packCollection(gmtTkMuons); + } else if (std::string("CL2JetsSC4") == name) { + data = packCollection(cl2JetsSC4); + } else if (std::string("CL2JetsSC8") == name) { + data = packCollection(cl2JetsSC8); + } else if (std::string("CL2Photons") == name) { + data = packCollection(cl2Photons); + } else if (std::string("CL2Electrons") == name) { + data = packCollection(cl2Electrons); + } else if (std::string("CL2Taus") == name) { + data = packCollection(cl2Taus); + } else if (std::string("CL2EtSum") == name) { + data = packCollection(cl2EtSum); + } else if (std::string("CL2HtSum") == name) { + data = packCollection(cl2HtSum); + } + + for (std::size_t i = 0; i < numChannels_.at(name); i++) { + for (std::size_t j = i; j < data.size(); j += numChannels_.at(name)) { + eventData[{name, i}].push_back(data[j]); + } + + while (eventData[{name, i}].size() < 9) { + eventData[{name, i}].push_back(0); + } + } + } + + boardDataWriter_.addEvent(eventData); + } + + eventCounter_++; + + if (maxEvents_ != 0 && eventCounter_ == maxEvents_) { + boardDataWriter_.flush(); + eventCounter_ = 0; + } +} + +void L1GTObjectBoardWriter::endJob() { boardDataWriter_.flush(); } + +void L1GTObjectBoardWriter::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + desc.addUntracked("filename"); + desc.addUntracked("fileExtension", "txt"); + desc.addUntracked("maxFrames", 1024); + desc.addUntracked("maxEvents", 0); + desc.addUntracked("patternFormat", "EMPv2"); + desc.ifValue(edm::ParameterDescription("bufferFileType", "input", false), + edm::allowedValues("input", "output")); + + desc.addUntracked("GTTPromptJets"); + desc.addUntracked("GTTDisplacedJets"); + desc.addUntracked("GTTPromptHtSum"); + desc.addUntracked("GTTDisplacedHtSum"); + desc.addUntracked("GTTEtSum"); + desc.addUntracked("GTTPrimaryVert"); + + desc.addUntracked("GMTSaPromptMuons"); + desc.addUntracked("GMTSaDisplacedMuons"); + desc.addUntracked("GMTTkMuons"); + + desc.addUntracked("CL2JetsSC4"); + desc.addUntracked("CL2JetsSC8"); + desc.addUntracked("CL2Photons"); + desc.addUntracked("CL2Electrons"); + desc.addUntracked("CL2Taus"); + desc.addUntracked("CL2EtSum"); + desc.addUntracked("CL2HtSum"); + + edm::ParameterSetDescription inputChannelDesc; + inputChannelDesc.addUntracked>("GCT_1"); + inputChannelDesc.addUntracked>("GMT_1"); + inputChannelDesc.addUntracked>("GTT_1"); + inputChannelDesc.addUntracked>("GTT_2"); + inputChannelDesc.addUntracked>("GTT_3"); + inputChannelDesc.addUntracked>("GTT_4"); + inputChannelDesc.addUntracked>("CL2_1"); + inputChannelDesc.addUntracked>("CL2_2"); + inputChannelDesc.addUntracked>("CL2_3"); + + desc.addOptionalUntracked("InputChannels", inputChannelDesc); + + edm::ParameterSetDescription outputChannelDesc; + for (const char* name : AVAILABLE_COLLECTIONS) { + outputChannelDesc.addUntracked>(name); + } + + desc.addOptionalUntracked("OutputChannels", outputChannelDesc); + + descriptions.addDefault(desc); +} + +DEFINE_FWK_MODULE(L1GTObjectBoardWriter); diff --git a/L1Trigger/Phase2L1GT/plugins/L1GTOutputObjectWriter.cc b/L1Trigger/Phase2L1GT/plugins/L1GTOutputObjectWriter.cc deleted file mode 100644 index b8d5760bb30bd..0000000000000 --- a/L1Trigger/Phase2L1GT/plugins/L1GTOutputObjectWriter.cc +++ /dev/null @@ -1,323 +0,0 @@ -#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" -#include "FWCore/ParameterSet/interface/allowedValues.h" -#include "DataFormats/Common/interface/Handle.h" - -#include "FWCore/Framework/interface/MakerMacros.h" -#include "DataFormats/Common/interface/View.h" - -#include "FWCore/Framework/interface/Frameworkfwd.h" -#include "FWCore/Framework/interface/one/EDAnalyzer.h" - -#include "FWCore/Framework/interface/Event.h" - -#include "L1Trigger/DemonstratorTools/interface/BoardDataWriter.h" -#include "L1Trigger/DemonstratorTools/interface/utilities.h" - -#include "DataFormats/L1Trigger/interface/P2GTCandidate.h" - -#include "L1GTEvaluationInterface.h" - -#include -#include -#include -#include -#include -#include - -#include - -using namespace l1t; - -static constexpr std::array, 27> OUTPUT_CHANNELS_VU9P{ - {{"GTTPromptJets", 2, 6}, - {"GTTDisplacedJets", 6, 10}, - {"GTTPromptHtSum", 10, 11}, - {"GTTDisplacedHtSum", 11, 12}, - {"GTTEtSum", 12, 13}, - {"GTTHadronicTaus", 13, 16}, - {"CL2JetsSC4", 24, 28}, - {"CL2JetsSC8", 28, 32}, - {"CL2Taus", 34, 37}, - {"CL2HtSum", 37, 38}, - {"CL2EtSum", 38, 39}, - {"GCTNonIsoEg", 48, 50}, - {"GCTIsoEg", 50, 52}, - {"GCTJets", 52, 54}, - {"GCTTaus", 54, 56}, - {"GCTHtSum", 56, 57}, - {"GCTEtSum", 57, 58}, - {"GMTSaPromptMuons", 60, 62}, - {"GMTSaDisplacedMuons", 62, 64}, - {"GMTTkMuons", 64, 67}, - {"GMTTopo", 67, 69}, - {"CL2Electrons", 80, 83}, - {"CL2Photons", 83, 86}, - {"GTTPhiCandidates", 104, 107}, - {"GTTRhoCandidates", 107, 110}, - {"GTTBsCandidates", 110, 113}, - {"GTTPrimaryVert", 113, 115}}}; - -static constexpr std::array, 27> OUTPUT_CHANNELS_VU13P{ - {{"GTTPromptJets", 2, 6}, - {"GTTDisplacedJets", 6, 10}, - {"GTTPromptHtSum", 10, 11}, - {"GTTDisplacedHtSum", 11, 12}, - {"GTTEtSum", 12, 13}, - {"GTTHadronicTaus", 13, 16}, - {"GCTNonIsoEg", 26, 28}, - {"GCTIsoEg", 28, 30}, - {"GCTJets", 30, 32}, - {"CL2JetsSC4", 32, 36}, - {"CL2JetsSC8", 36, 40}, - {"CL2Taus", 40, 43}, - {"CL2HtSum", 43, 44}, - {"CL2EtSum", 44, 45}, - {"GMTSaPromptMuons", 68, 70}, - {"GMTSaDisplacedMuons", 70, 72}, - {"GMTTkMuons", 72, 75}, - {"GMTTopo", 75, 77}, - {"CL2Electrons", 80, 83}, - {"CL2Photons", 83, 86}, - {"GCTTaus", 96, 98}, - {"GCTHtSum", 98, 99}, - {"GCTEtSum", 99, 100}, - {"GTTPhiCandidates", 112, 115}, - {"GTTRhoCandidates", 115, 118}, - {"GTTBsCandidates", 118, 121}, - {"GTTPrimaryVert", 121, 123}}}; - -class L1GTOutputObjectWriter : public edm::one::EDAnalyzer<> { -public: - explicit L1GTOutputObjectWriter(const edm::ParameterSet&); - - static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); - -private: - template - std::vector> fillCollection( - const edm::Event& event, const edm::EDGetTokenT& token) const; - void analyze(const edm::Event&, const edm::EventSetup&) override; - void endJob() override; - - const edm::EDGetTokenT gctNonIsoEgToken_; - const edm::EDGetTokenT gctIsoEgToken_; - const edm::EDGetTokenT gctJetsToken_; - const edm::EDGetTokenT gctTausToken_; - const edm::EDGetTokenT gctHtSumToken_; - const edm::EDGetTokenT gctEtSumToken_; - const edm::EDGetTokenT gmtSaPromptMuonsToken_; - const edm::EDGetTokenT gmtSaDisplacedMuonsToken_; - const edm::EDGetTokenT gmtTkMuonsToken_; - const edm::EDGetTokenT gmtTopoToken_; - const edm::EDGetTokenT gttPromptJetsToken_; - const edm::EDGetTokenT gttDisplacedJetsToken_; - const edm::EDGetTokenT gttPhiCandidatesToken_; - const edm::EDGetTokenT gttRhoCandidatesToken_; - const edm::EDGetTokenT gttBsCandidatesToken_; - const edm::EDGetTokenT gttHadronicTausToken_; - const edm::EDGetTokenT gttPrimaryVertToken_; - const edm::EDGetTokenT gttPromptHtSumToken_; - const edm::EDGetTokenT gttDisplacedHtSumToken_; - const edm::EDGetTokenT gttEtSumToken_; - const edm::EDGetTokenT cl2JetsSc4Token_; - const edm::EDGetTokenT cl2JetsSc8Token_; - const edm::EDGetTokenT cl2TausToken_; - const edm::EDGetTokenT cl2ElectronsToken_; - const edm::EDGetTokenT cl2PhotonsToken_; - const edm::EDGetTokenT cl2HtSumToken_; - const edm::EDGetTokenT cl2EtSumToken_; - const std::array, 27> outputChannelDef_; - l1t::demo::BoardDataWriter boardDataWriter_; -}; - -L1GTOutputObjectWriter::L1GTOutputObjectWriter(const edm::ParameterSet& config) - : gctNonIsoEgToken_(consumes(config.getParameter("GCTNonIsoEg"))), - gctIsoEgToken_(consumes(config.getParameter("GCTIsoEg"))), - gctJetsToken_(consumes(config.getParameter("GCTJets"))), - gctTausToken_(consumes(config.getParameter("GCTTaus"))), - gctHtSumToken_(consumes(config.getParameter("GCTHtSum"))), - gctEtSumToken_(consumes(config.getParameter("GCTEtSum"))), - gmtSaPromptMuonsToken_(consumes(config.getParameter("GMTSaPromptMuons"))), - gmtSaDisplacedMuonsToken_( - consumes(config.getParameter("GMTSaDisplacedMuons"))), - gmtTkMuonsToken_(consumes(config.getParameter("GMTTkMuons"))), - gmtTopoToken_(consumes(config.getParameter("GMTTopo"))), - gttPromptJetsToken_(consumes(config.getParameter("GTTPromptJets"))), - gttDisplacedJetsToken_(consumes(config.getParameter("GTTDisplacedJets"))), - gttPhiCandidatesToken_(consumes(config.getParameter("GTTPhiCandidates"))), - gttRhoCandidatesToken_(consumes(config.getParameter("GTTRhoCandidates"))), - gttBsCandidatesToken_(consumes(config.getParameter("GTTBsCandidates"))), - gttHadronicTausToken_(consumes(config.getParameter("GTTHadronicTaus"))), - gttPrimaryVertToken_(consumes(config.getParameter("GTTPrimaryVert"))), - gttPromptHtSumToken_(consumes(config.getParameter("GTTPromptHtSum"))), - gttDisplacedHtSumToken_( - consumes(config.getParameter("GTTDisplacedHtSum"))), - gttEtSumToken_(consumes(config.getParameter("GTTEtSum"))), - cl2JetsSc4Token_(consumes(config.getParameter("CL2JetsSC4"))), - cl2JetsSc8Token_(consumes(config.getParameter("CL2JetsSC8"))), - cl2TausToken_(consumes(config.getParameter("CL2Taus"))), - cl2ElectronsToken_(consumes(config.getParameter("CL2Electrons"))), - cl2PhotonsToken_(consumes(config.getParameter("CL2Photons"))), - cl2HtSumToken_(consumes(config.getParameter("CL2HtSum"))), - cl2EtSumToken_(consumes(config.getParameter("CL2EtSum"))), - outputChannelDef_(config.getParameter("platform") == "VU13P" ? OUTPUT_CHANNELS_VU13P - : OUTPUT_CHANNELS_VU9P), - boardDataWriter_(l1t::demo::parseFileFormat(config.getParameter("patternFormat")), - config.getParameter("outputFilename"), - config.getParameter("outputFileExtension"), - 9, - 1, - config.getParameter("maxLines"), - [&]() { - demo::BoardDataWriter::ChannelMap_t channelMap; - for (const auto& [name, start, end] : outputChannelDef_) { - for (std::size_t i = start; i < end; i++) { - channelMap.insert({{name, i - start}, {{1, 0}, {i}}}); - } - } - return channelMap; - }()) {} - -void L1GTOutputObjectWriter::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { - edm::ParameterSetDescription desc; - desc.add("GCTNonIsoEg"); - desc.add("GCTIsoEg"); - desc.add("GCTJets"); - desc.add("GCTTaus"); - desc.add("GCTHtSum"); - desc.add("GCTEtSum"); - desc.add("GMTSaPromptMuons"); - desc.add("GMTSaDisplacedMuons"); - desc.add("GMTTkMuons"); - desc.add("GMTTopo"); - desc.add("GTTPromptJets"); - desc.add("GTTDisplacedJets"); - desc.add("GTTPhiCandidates"); - desc.add("GTTRhoCandidates"); - desc.add("GTTBsCandidates"); - desc.add("GTTHadronicTaus"); - desc.add("GTTPrimaryVert"); - desc.add("GTTPromptHtSum"); - desc.add("GTTDisplacedHtSum"); - desc.add("GTTEtSum"); - desc.add("CL2JetsSC4"); - desc.add("CL2JetsSC8"); - desc.add("CL2Taus"); - desc.add("CL2Electrons"); - desc.add("CL2Photons"); - desc.add("CL2HtSum"); - desc.add("CL2EtSum"); - - desc.add("maxLines", 1024); - desc.add("outputFilename"); - desc.add("outputFileExtension", "txt"); - desc.add("patternFormat", "EMPv2"); - desc.ifValue(edm::ParameterDescription("platform", "VU9P", true), - edm::allowedValues("VU9P", "VU13P")); - - descriptions.addWithDefaultLabel(desc); -} - -template -std::vector> L1GTOutputObjectWriter::fillCollection( - const edm::Event& event, const edm::EDGetTokenT& token) const { - std::vector> outputCollection; - - for (const P2GTCandidate& object : event.get(token)) { - outputCollection.push_back(std::make_unique(T::from_GTObject(object))); - } - - return outputCollection; -} - -template -static std::vector> vpack(const Args&... vobjects) { - std::vector> vpacked; - - ( - [&vpacked](const std::vector>& objects) { - std::optional> next_packed; - for (const auto& object : objects) { - if (object->packed_width() == 64) { - const l1t::L1TGT_Interface<64>& interface_obj = dynamic_cast&>(*object); - vpacked.emplace_back(interface_obj.pack()); - } else if (object->packed_width() == 96) { - const l1t::L1TGT_Interface<96>& interface_obj = dynamic_cast&>(*object); - ap_uint<96> packed = interface_obj.pack(); - if (next_packed.has_value()) { - vpacked.emplace_back(packed(95, 64) << 32 | next_packed.value()); - next_packed.reset(); - } else { - next_packed = packed(95, 64); - } - - vpacked.emplace_back(packed(63, 0)); - - } else if (object->packed_width() == 128) { - const l1t::L1TGT_Interface<128>& interface_obj = dynamic_cast&>(*object); - ap_uint<128> packed = interface_obj.pack(); - vpacked.emplace_back(packed(63, 0)); - vpacked.emplace_back(packed(127, 64)); - } - } - }(vobjects), - ...); - - return vpacked; -} - -void L1GTOutputObjectWriter::analyze(const edm::Event& event, const edm::EventSetup&) { - std::map>> outputObjects; - - outputObjects.emplace("GCTNonIsoEg", fillCollection>(event, gctNonIsoEgToken_)); - outputObjects.emplace("GCTIsoEg", fillCollection>(event, gctIsoEgToken_)); - outputObjects.emplace("GCTJets", fillCollection>(event, gctJetsToken_)); - outputObjects.emplace("GCTTaus", fillCollection(event, gctTausToken_)); - outputObjects.emplace("GCTHtSum", fillCollection(event, gctHtSumToken_)); - outputObjects.emplace("GCTEtSum", fillCollection(event, gctEtSumToken_)); - outputObjects.emplace("GMTSaPromptMuons", - fillCollection(event, gmtSaPromptMuonsToken_)); - outputObjects.emplace("GMTSaDisplacedMuons", - fillCollection(event, gmtSaDisplacedMuonsToken_)); - outputObjects.emplace("GMTTkMuons", fillCollection(event, gmtTkMuonsToken_)); - outputObjects.emplace("GMTTopo", fillCollection(event, gmtTopoToken_)); - outputObjects.emplace("GTTPromptJets", fillCollection(event, gttPromptJetsToken_)); - outputObjects.emplace("GTTDisplacedJets", fillCollection(event, gttDisplacedJetsToken_)); - outputObjects.emplace("GTTPhiCandidates", fillCollection(event, gttPhiCandidatesToken_)); - outputObjects.emplace("GTTRhoCandidates", fillCollection(event, gttRhoCandidatesToken_)); - outputObjects.emplace("GTTBsCandidates", fillCollection(event, gttBsCandidatesToken_)); - outputObjects.emplace("GTTHadronicTaus", fillCollection(event, gttHadronicTausToken_)); - outputObjects.emplace("GTTPrimaryVert", fillCollection(event, gttPrimaryVertToken_)); - outputObjects.emplace("GTTPromptHtSum", fillCollection(event, gttPromptHtSumToken_)); - outputObjects.emplace("GTTDisplacedHtSum", fillCollection(event, gttDisplacedHtSumToken_)); - outputObjects.emplace("GTTEtSum", fillCollection(event, gttEtSumToken_)); - outputObjects.emplace("CL2JetsSC4", fillCollection(event, cl2JetsSc4Token_)); - outputObjects.emplace("CL2JetsSC8", fillCollection(event, cl2JetsSc8Token_)); - outputObjects.emplace("CL2Taus", fillCollection(event, cl2TausToken_)); - outputObjects.emplace("CL2Electrons", fillCollection(event, cl2ElectronsToken_)); - outputObjects.emplace("CL2Photons", fillCollection(event, cl2PhotonsToken_)); - outputObjects.emplace("CL2HtSum", fillCollection(event, cl2HtSumToken_)); - outputObjects.emplace("CL2EtSum", fillCollection(event, cl2EtSumToken_)); - - std::map>> eventData; - - for (const auto& [name, start, end] : outputChannelDef_) { - std::vector> data = vpack(outputObjects[name]); - std::size_t numChannels = end - start; - for (std::size_t i = start; i < end; i++) { - for (std::size_t j = i - start; j < data.size(); j += numChannels) { - eventData[{name, i - start}].push_back(data[j]); - } - - while (eventData[{name, i - start}].size() < 9) { - eventData[{name, i - start}].push_back(0); - } - } - } - - boardDataWriter_.addEvent(eventData); -} - -void L1GTOutputObjectWriter::endJob() { boardDataWriter_.flush(); } - -DEFINE_FWK_MODULE(L1GTOutputObjectWriter); diff --git a/L1Trigger/Phase2L1GT/plugins/L1GTProducer.cc b/L1Trigger/Phase2L1GT/plugins/L1GTProducer.cc index 8045f322348d6..6da0d5766cb81 100644 --- a/L1Trigger/Phase2L1GT/plugins/L1GTProducer.cc +++ b/L1Trigger/Phase2L1GT/plugins/L1GTProducer.cc @@ -30,6 +30,8 @@ #include "DataFormats/L1Trigger/interface/EtSum.h" +#include "L1Trigger/L1TTrackMatch/interface/L1TkHTMissEmulatorProducer.h" + #include #include #include @@ -47,6 +49,9 @@ namespace l1t { private: void produceGTTPromptJets(edm::Event &event) const; void produceGTTDisplacedJets(edm::Event &event) const; + void produceGTTPromptHtSum(edm::Event &event) const; + void produceGTTDisplacedHtSum(edm::Event &event) const; + void produceGTTEtSum(edm::Event &event) const; void produceGTTPrimaryVert(edm::Event &event) const; void produceGMTSaPromptMuons(edm::Event &event) const; @@ -67,6 +72,9 @@ namespace l1t { const edm::EDGetTokenT gttPromptJetToken_; const edm::EDGetTokenT gttDisplacedJetToken_; + const edm::EDGetTokenT> gttPromptHtSumToken_; + const edm::EDGetTokenT> gttDisplacedHtSumToken_; + const edm::EDGetTokenT> gttEtSumToken_; const edm::EDGetTokenT gttPrimaryVertexToken_; const edm::EDGetTokenT gmtSaPromptMuonToken_; @@ -86,6 +94,10 @@ namespace l1t { : scales_(config.getParameter("scales")), gttPromptJetToken_(consumes(config.getParameter("GTTPromptJets"))), gttDisplacedJetToken_(consumes(config.getParameter("GTTDisplacedJets"))), + gttPromptHtSumToken_(consumes>(config.getParameter("GTTPromptHtSum"))), + gttDisplacedHtSumToken_( + consumes>(config.getParameter("GTTDisplacedHtSum"))), + gttEtSumToken_(consumes>(config.getParameter("GTTEtSum"))), gttPrimaryVertexToken_(consumes(config.getParameter("GTTPrimaryVert"))), gmtSaPromptMuonToken_(consumes(config.getParameter("GMTSaPromptMuons"))), gmtSaDisplacedMuonToken_(consumes(config.getParameter("GMTSaDisplacedMuons"))), @@ -99,6 +111,9 @@ namespace l1t { cl2HtSumToken_(consumes>(config.getParameter("CL2HtSum"))) { produces("GTTPromptJets"); produces("GTTDisplacedJets"); + produces("GTTPromptHtSum"); + produces("GTTDisplacedHtSum"); + produces("GTTEtSum"); produces("GTTPrimaryVert"); produces("GMTSaPromptMuons"); @@ -123,6 +138,9 @@ namespace l1t { desc.add("GTTPromptJets"); desc.add("GTTDisplacedJets"); + desc.add("GTTPromptHtSum"); + desc.add("GTTDisplacedHtSum"); + desc.add("GTTEtSum"); desc.add("GTTPrimaryVert"); desc.add("GMTSaPromptMuons"); @@ -208,6 +226,67 @@ namespace l1t { event.put(std::move(outputCollection), "GTTDisplacedJets"); } + void L1GTProducer::produceGTTPromptHtSum(edm::Event &event) const { + std::unique_ptr outputCollection = std::make_unique(); + const std::vector &collection = event.get(gttPromptHtSumToken_); + if (collection.size() > 0) { + const l1t::EtSum &obj = collection[0]; + l1tmhtemu::EtMiss htMiss; + htMiss.Et = obj.p4().energy(); + P2GTCandidate gtObj(0, + reco::ParticleState::PolarLorentzVector( + scales_.to_pT(htMiss.Et.V.to_int()), 0, scales_.to_phi(obj.hwPhi()), 0)); + + gtObj.hwPT_ = htMiss.Et.V.to_int(); + gtObj.hwPhi_ = obj.hwPhi(); + gtObj.hwScalarSumPT_ = obj.hwPt(); + gtObj.objectType_ = P2GTCandidate::GTTPromptHtSum; + + outputCollection->push_back(gtObj); + } + + event.put(std::move(outputCollection), "GTTPromptHtSum"); + } + + void L1GTProducer::produceGTTDisplacedHtSum(edm::Event &event) const { + std::unique_ptr outputCollection = std::make_unique(); + const std::vector &collection = event.get(gttDisplacedHtSumToken_); + if (collection.size() > 0) { + const l1t::EtSum &obj = collection[0]; + l1tmhtemu::EtMiss htMiss; + htMiss.Et = obj.p4().energy(); + P2GTCandidate gtObj(0, + reco::ParticleState::PolarLorentzVector( + scales_.to_pT(htMiss.Et.V.to_int()), 0, scales_.to_phi(obj.hwPhi()), 0)); + + gtObj.hwPT_ = htMiss.Et.V.to_int(); + gtObj.hwPhi_ = obj.hwPhi(); + gtObj.hwScalarSumPT_ = obj.hwPt(); + gtObj.objectType_ = P2GTCandidate::GTTDisplacedHtSum; + + outputCollection->push_back(gtObj); + } + + event.put(std::move(outputCollection), "GTTDisplacedHtSum"); + } + + void L1GTProducer::produceGTTEtSum(edm::Event &event) const { + std::unique_ptr outputCollection = std::make_unique(); + const std::vector &collection = event.get(gttEtSumToken_); + if (collection.size() > 0) { + const l1t::EtSum &obj = collection[0]; + P2GTCandidate gtObj( + 0, reco::ParticleState::PolarLorentzVector(scales_.to_pT(obj.hwPt()), 0, scales_.to_phi(obj.hwPhi()), 0)); + gtObj.hwPT_ = obj.hwPt(); + gtObj.hwPhi_ = obj.hwPhi(); + gtObj.objectType_ = P2GTCandidate::GTTEtSum; + + outputCollection->push_back(gtObj); + } + + event.put(std::move(outputCollection), "GTTEtSum"); + } + void L1GTProducer::produceGMTSaPromptMuons(edm::Event &event) const { std::unique_ptr outputCollection = std::make_unique(); const SAMuonCollection &collection = event.get(gmtSaPromptMuonToken_); @@ -224,7 +303,7 @@ namespace l1t { gtObj.hwPhi_ = obj.apPhi().to_int(); gtObj.hwEta_ = obj.apEta().to_int(); gtObj.hwZ0_ = hwZ0; - gtObj.hwQualityScore_ = obj.apQualFlags().to_int(); + gtObj.hwQualityFlags_ = obj.apQualFlags().to_int(); gtObj.hwCharge_ = obj.apCharge().to_int(); gtObj.hwD0_ = obj.apD0().to_int(); gtObj.objectType_ = P2GTCandidate::GMTSaPromptMuons; @@ -250,7 +329,7 @@ namespace l1t { gtObj.hwPhi_ = obj.apPhi().to_int(); gtObj.hwEta_ = obj.apEta().to_int(); gtObj.hwZ0_ = hwZ0; - gtObj.hwQualityScore_ = obj.apQualFlags().to_int(); + gtObj.hwQualityFlags_ = obj.apQualFlags().to_int(); gtObj.hwCharge_ = obj.apCharge().to_int(); gtObj.hwD0_ = obj.apD0().to_int(); gtObj.objectType_ = P2GTCandidate::GMTSaDisplacedMuons; @@ -276,7 +355,7 @@ namespace l1t { gtObj.hwPhi_ = obj.apPhi().to_int(); gtObj.hwEta_ = obj.apEta().to_int(); gtObj.hwZ0_ = hwZ0; - gtObj.hwQualityScore_ = obj.apQualFlags().to_int(); + gtObj.hwQualityFlags_ = obj.apQualFlags().to_int(); gtObj.hwIsolationPT_ = obj.apIso().to_int(); gtObj.hwCharge_ = obj.apCharge().to_int(); gtObj.hwD0_ = obj.apD0().to_int(); @@ -446,6 +525,9 @@ namespace l1t { void L1GTProducer::produce(edm::StreamID, edm::Event &event, const edm::EventSetup &setup) const { produceGTTPromptJets(event); produceGTTDisplacedJets(event); + produceGTTPromptHtSum(event); + produceGTTDisplacedHtSum(event); + produceGTTEtSum(event); produceGTTPrimaryVert(event); produceGMTSaPromptMuons(event); diff --git a/L1Trigger/Phase2L1GT/plugins/L1GTQuadObjectCond.cc b/L1Trigger/Phase2L1GT/plugins/L1GTQuadObjectCond.cc index 811a465dd8383..8aaa210c3540d 100644 --- a/L1Trigger/Phase2L1GT/plugins/L1GTQuadObjectCond.cc +++ b/L1Trigger/Phase2L1GT/plugins/L1GTQuadObjectCond.cc @@ -302,6 +302,11 @@ bool L1GTQuadObjectCond::filter(edm::StreamID, edm::Event& event, const edm::Eve } } + condition_result &= collection1Cuts_.checkCollection(*col1); + condition_result &= collection2Cuts_.checkCollection(*col2); + condition_result &= collection3Cuts_.checkCollection(*col3); + condition_result &= collection4Cuts_.checkCollection(*col4); + if (condition_result) { std::unique_ptr triggerCol1 = std::make_unique(); diff --git a/L1Trigger/Phase2L1GT/plugins/L1GTSingleCollectionCut.h b/L1Trigger/Phase2L1GT/plugins/L1GTSingleCollectionCut.h index a5fedf6e4e18b..d8703e95049a8 100644 --- a/L1Trigger/Phase2L1GT/plugins/L1GTSingleCollectionCut.h +++ b/L1Trigger/Phase2L1GT/plugins/L1GTSingleCollectionCut.h @@ -87,7 +87,10 @@ namespace l1t { "minPrimVertDz", config, [&scales](double value) { return scales.to_hw_z0_floor(value); })), maxPrimVertDz_(getOptionalParam( "maxPrimVertDz", config, [&scales](double value) { return scales.to_hw_z0_ceil(value); })), - primVertex_(getOptionalParam("primVertex", config)) {} + primVertex_(getOptionalParam("primVertex", config)), + minPtMultiplicityN_(config.getParameter("minPtMultiplicityN")), + minPtMultiplicityCut_(getOptionalParam( + "minPtMultiplicityCut", config, [&scales](double value) { return scales.to_hw_pT_floor(value); })) {} bool checkObject(const P2GTCandidate& obj) const { bool result = true; @@ -128,6 +131,20 @@ namespace l1t { return result; } + bool checkCollection(const P2GTCandidateCollection& col) const { + if (minPtMultiplicityN_ > 0 && minPtMultiplicityCut_) { + unsigned int minPtMultiplicity = 0; + + for (const P2GTCandidate& obj : col) { + minPtMultiplicity = obj.hwPT() > minPtMultiplicityCut_ ? minPtMultiplicity + 1 : minPtMultiplicity; + } + + return minPtMultiplicity >= minPtMultiplicityN_; + } + + return true; + } + bool checkPrimaryVertices(const P2GTCandidate& obj, const P2GTCandidateCollection& primVertCol) const { if (!minPrimVertDz_ && !maxPrimVertDz_) { return true; @@ -179,6 +196,8 @@ namespace l1t { desc.addOptional("minPrimVertDz"); desc.addOptional("maxPrimVertDz"); desc.addOptional("primVertex"); + desc.add("minPtMultiplicityN", 0); + desc.addOptional("minPtMultiplicityCut"); } const edm::InputTag& tag() const { return tag_; } @@ -241,6 +260,8 @@ namespace l1t { const std::optional minPrimVertDz_; const std::optional maxPrimVertDz_; const std::optional primVertex_; + const unsigned int minPtMultiplicityN_; + const std::optional minPtMultiplicityCut_; }; } // namespace l1t diff --git a/L1Trigger/Phase2L1GT/plugins/L1GTSingleObjectCond.cc b/L1Trigger/Phase2L1GT/plugins/L1GTSingleObjectCond.cc index ba57e3aa62365..bda7d9da5be87 100644 --- a/L1Trigger/Phase2L1GT/plugins/L1GTSingleObjectCond.cc +++ b/L1Trigger/Phase2L1GT/plugins/L1GTSingleObjectCond.cc @@ -77,6 +77,8 @@ bool L1GTSingleObjectCond::filter(edm::StreamID, edm::Event& event, const edm::E } } + condition_result &= collection.checkCollection(*col); + if (condition_result) { event.put(std::move(triggerCol), collection.tag().instance()); } diff --git a/L1Trigger/Phase2L1GT/plugins/L1GTTripleObjectCond.cc b/L1Trigger/Phase2L1GT/plugins/L1GTTripleObjectCond.cc index 9e35c7c2545f1..24872e47d6a21 100644 --- a/L1Trigger/Phase2L1GT/plugins/L1GTTripleObjectCond.cc +++ b/L1Trigger/Phase2L1GT/plugins/L1GTTripleObjectCond.cc @@ -204,6 +204,10 @@ bool L1GTTripleObjectCond::filter(edm::StreamID, edm::Event& event, const edm::E } } + condition_result &= collection1Cuts_.checkCollection(*col1); + condition_result &= collection2Cuts_.checkCollection(*col2); + condition_result &= collection3Cuts_.checkCollection(*col3); + if (condition_result) { std::unique_ptr triggerCol1 = std::make_unique(); diff --git a/L1Trigger/Phase2L1GT/python/l1tGTBoardWriterVU13P_cff.py b/L1Trigger/Phase2L1GT/python/l1tGTBoardWriterVU13P_cff.py new file mode 100644 index 0000000000000..c1edfc6684536 --- /dev/null +++ b/L1Trigger/Phase2L1GT/python/l1tGTBoardWriterVU13P_cff.py @@ -0,0 +1,55 @@ +import FWCore.ParameterSet.Config as cms +from L1Trigger.Phase2L1GT.l1tGTBoardWriter_cff import BoardDataInput as BoardDataInputVU13P +from L1Trigger.Phase2L1GT.l1tGTBoardWriter_cff import BoardDataOutputObjects as BoardDataOutputObjectsVU13P +from L1Trigger.Phase2L1GT.l1tGTBoardWriter_cff import AlgoBitBoardData as AlgoBitBoardDataVU13P + +BoardDataInputVU13P.InputChannels = cms.untracked.PSet( + # SLR 0 + GTT_1 = cms.untracked.vuint32(range(0, 6)), + GTT_2 = cms.untracked.vuint32(range(6, 12)), + GTT_3 = cms.untracked.vuint32(range(112, 118)), + GTT_4 = cms.untracked.vuint32(range(118, 124)), + + # SLR 1 + GCT_1 = cms.untracked.vuint32(range(24, 30)), + + # SLR 2 + CL2_1 = cms.untracked.vuint32(range(32, 38)), + CL2_2 = cms.untracked.vuint32(range(38, 44)), + CL2_3 = cms.untracked.vuint32(range(80, 86)), + + # SLR 3 + GMT_1 = cms.untracked.vuint32(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 68, 69, 70, 71, 72, 73) +) + +BoardDataOutputObjectsVU13P.OutputChannels = cms.untracked.PSet( + GTTPromptJets = cms.untracked.vuint32(range(2, 6)), + GTTDisplacedJets = cms.untracked.vuint32(range(6, 10)), + GTTPromptHtSum = cms.untracked.vuint32(range(10, 11)), + GTTDisplacedHtSum = cms.untracked.vuint32(range(11, 12)), + GTTEtSum = cms.untracked.vuint32(range(12, 13)), + GTTHadronicTaus = cms.untracked.vuint32(range(13, 16)), + GCTNonIsoEg = cms.untracked.vuint32(range(26, 28)), + GCTIsoEg = cms.untracked.vuint32(range(28, 30)), + GCTJets = cms.untracked.vuint32(range(30, 32)), + CL2JetsSC4 = cms.untracked.vuint32(range(32, 36)), + CL2JetsSC8 = cms.untracked.vuint32(range(36, 40)), + CL2Taus = cms.untracked.vuint32(range(40, 43)), + CL2HtSum = cms.untracked.vuint32(range(43, 44)), + CL2EtSum = cms.untracked.vuint32(range(44, 45)), + GMTSaPromptMuons = cms.untracked.vuint32(range(68, 70)), + GMTSaDisplacedMuons = cms.untracked.vuint32(range(70, 72)), + GMTTkMuons = cms.untracked.vuint32(range(72, 75)), + GMTTopo = cms.untracked.vuint32(range(75, 77)), + CL2Electrons = cms.untracked.vuint32(range(80, 83)), + CL2Photons = cms.untracked.vuint32(range(83, 86)), + GCTTaus = cms.untracked.vuint32(range(96, 98)), + GCTHtSum = cms.untracked.vuint32(range(98, 99)), + GCTEtSum = cms.untracked.vuint32(range(99, 100)), + GTTPhiCandidates = cms.untracked.vuint32(range(112, 115)), + GTTRhoCandidates = cms.untracked.vuint32(range(115, 118)), + GTTBsCandidates = cms.untracked.vuint32(range(118, 121)), + GTTPrimaryVert = cms.untracked.vuint32(range(121, 123)) +) + +AlgoBitBoardDataVU13P.channels = cms.untracked.vuint32(46, 47) diff --git a/L1Trigger/Phase2L1GT/python/l1tGTBoardWriterVU9P_cff.py b/L1Trigger/Phase2L1GT/python/l1tGTBoardWriterVU9P_cff.py new file mode 100644 index 0000000000000..d1c75e5725838 --- /dev/null +++ b/L1Trigger/Phase2L1GT/python/l1tGTBoardWriterVU9P_cff.py @@ -0,0 +1,54 @@ +import FWCore.ParameterSet.Config as cms +from L1Trigger.Phase2L1GT.l1tGTBoardWriter_cff import BoardDataInput as BoardDataInputVU9P +from L1Trigger.Phase2L1GT.l1tGTBoardWriter_cff import BoardDataOutputObjects as BoardDataOutputObjectsVU9P +from L1Trigger.Phase2L1GT.l1tGTBoardWriter_cff import AlgoBitBoardData as AlgoBitBoardDataVU9P + + +BoardDataInputVU9P.InputChannels = cms.untracked.PSet( + # SLR 0 + GTT_1 = cms.untracked.vuint32(range(0, 6)), + GTT_2 = cms.untracked.vuint32(range(6, 12)), + GTT_3 = cms.untracked.vuint32(range(104, 110)), + GTT_4 = cms.untracked.vuint32(range(110, 116)), + + # SLR 1 + CL2_1 = cms.untracked.vuint32(range(28, 34)), + CL2_2 = cms.untracked.vuint32(range(34, 40)), + CL2_3 = cms.untracked.vuint32(range(80, 86)), + + # SLR 2 + GCT_1 = cms.untracked.vuint32(range(54, 60)), + GMT_1 = cms.untracked.vuint32(range(60, 78)) +) + +BoardDataOutputObjectsVU9P.OutputChannels = cms.untracked.PSet( + GTTPromptJets = cms.untracked.vuint32(range(2, 6)), + GTTDisplacedJets = cms.untracked.vuint32(range(6, 10)), + GTTPromptHtSum = cms.untracked.vuint32(range(10, 11)), + GTTDisplacedHtSum = cms.untracked.vuint32(range(11, 12)), + GTTEtSum = cms.untracked.vuint32(range(12, 13)), + GTTHadronicTaus = cms.untracked.vuint32(range(13, 16)), + CL2JetsSC4 = cms.untracked.vuint32(range(24, 28)), + CL2JetsSC8 = cms.untracked.vuint32(range(28, 32)), + CL2Taus = cms.untracked.vuint32(range(34, 37)), + CL2HtSum = cms.untracked.vuint32(range(37, 38)), + CL2EtSum = cms.untracked.vuint32(range(38, 39)), + GCTNonIsoEg = cms.untracked.vuint32(range(48, 50)), + GCTIsoEg = cms.untracked.vuint32(range(50, 52)), + GCTJets = cms.untracked.vuint32(range(52, 54)), + GCTTaus = cms.untracked.vuint32(range(54, 56)), + GCTHtSum = cms.untracked.vuint32(range(56, 57)), + GCTEtSum = cms.untracked.vuint32(range(57, 58)), + GMTSaPromptMuons = cms.untracked.vuint32(range(60, 62)), + GMTSaDisplacedMuons = cms.untracked.vuint32(range(62, 64)), + GMTTkMuons = cms.untracked.vuint32(range(64, 67)), + GMTTopo = cms.untracked.vuint32(range(67, 69)), + CL2Electrons = cms.untracked.vuint32(range(80, 83)), + CL2Photons = cms.untracked.vuint32(range(83, 86)), + GTTPhiCandidates = cms.untracked.vuint32(range(104, 107)), + GTTRhoCandidates = cms.untracked.vuint32(range(107, 110)), + GTTBsCandidates = cms.untracked.vuint32(range(110, 113)), + GTTPrimaryVert = cms.untracked.vuint32(range(113, 115)) +) + +AlgoBitBoardDataVU9P.channels = cms.untracked.vuint32(32, 33) diff --git a/L1Trigger/Phase2L1GT/python/l1tGTBoardWriter_cff.py b/L1Trigger/Phase2L1GT/python/l1tGTBoardWriter_cff.py new file mode 100644 index 0000000000000..993ae5b879a11 --- /dev/null +++ b/L1Trigger/Phase2L1GT/python/l1tGTBoardWriter_cff.py @@ -0,0 +1,49 @@ +import FWCore.ParameterSet.Config as cms +from L1Trigger.Phase2L1GT.l1tGTProducer_cff import l1tGTProducer + +BoardDataInput = cms.EDAnalyzer("L1GTObjectBoardWriter", + GTTPromptJets = cms.untracked.InputTag(l1tGTProducer.GTTPromptJets.value()), + GTTDisplacedJets = cms.untracked.InputTag(l1tGTProducer.GTTDisplacedJets.value()), + GTTPromptHtSum = cms.untracked.InputTag(l1tGTProducer.GTTPromptHtSum.value()), + GTTDisplacedHtSum = cms.untracked.InputTag(l1tGTProducer.GTTDisplacedHtSum.value()), + GTTEtSum = cms.untracked.InputTag(l1tGTProducer.GTTEtSum.value()), + GTTPrimaryVert = cms.untracked.InputTag(l1tGTProducer.GTTPrimaryVert.value()), + GMTSaPromptMuons = cms.untracked.InputTag(l1tGTProducer.GMTSaPromptMuons.value()), + GMTSaDisplacedMuons = cms.untracked.InputTag(l1tGTProducer.GMTSaDisplacedMuons.value()), + GMTTkMuons = cms.untracked.InputTag(l1tGTProducer.GMTTkMuons.value()), + CL2JetsSC4 = cms.untracked.InputTag(l1tGTProducer.CL2JetsSC4.value()), + CL2JetsSC8 = cms.untracked.InputTag(l1tGTProducer.CL2JetsSC8.value()), + CL2Electrons = cms.untracked.InputTag(l1tGTProducer.CL2Electrons.value()), + CL2Photons = cms.untracked.InputTag(l1tGTProducer.CL2Photons.value()), + CL2Taus = cms.untracked.InputTag(l1tGTProducer.CL2Taus.value()), + CL2EtSum = cms.untracked.InputTag(l1tGTProducer.CL2EtSum.value()), + CL2HtSum = cms.untracked.InputTag(l1tGTProducer.CL2HtSum.value()), + filename = cms.untracked.string("inputPattern"), + bufferFileType = cms.untracked.string("input") +) + +BoardDataOutputObjects = cms.EDAnalyzer("L1GTObjectBoardWriter", + GTTPromptJets = cms.untracked.InputTag(l1tGTProducer.GTTPromptJets.value()), + GTTDisplacedJets = cms.untracked.InputTag(l1tGTProducer.GTTDisplacedJets.value()), + GTTPromptHtSum = cms.untracked.InputTag(l1tGTProducer.GTTPromptHtSum.value()), + GTTDisplacedHtSum = cms.untracked.InputTag(l1tGTProducer.GTTDisplacedHtSum.value()), + GTTEtSum = cms.untracked.InputTag(l1tGTProducer.GTTEtSum.value()), + GTTPrimaryVert = cms.untracked.InputTag(l1tGTProducer.GTTPrimaryVert.value()), + GMTSaPromptMuons = cms.untracked.InputTag(l1tGTProducer.GMTSaPromptMuons.value()), + GMTSaDisplacedMuons = cms.untracked.InputTag(l1tGTProducer.GMTSaDisplacedMuons.value()), + GMTTkMuons = cms.untracked.InputTag(l1tGTProducer.GMTTkMuons.value()), + CL2JetsSC4 = cms.untracked.InputTag(l1tGTProducer.CL2JetsSC4.value()), + CL2JetsSC8 = cms.untracked.InputTag(l1tGTProducer.CL2JetsSC8.value()), + CL2Electrons = cms.untracked.InputTag(l1tGTProducer.CL2Electrons.value()), + CL2Photons = cms.untracked.InputTag(l1tGTProducer.CL2Photons.value()), + CL2Taus = cms.untracked.InputTag(l1tGTProducer.CL2Taus.value()), + CL2EtSum = cms.untracked.InputTag(l1tGTProducer.CL2EtSum.value()), + CL2HtSum = cms.untracked.InputTag(l1tGTProducer.CL2HtSum.value()), + filename = cms.untracked.string("outputObjectPattern"), + bufferFileType = cms.untracked.string("output") +) + +AlgoBitBoardData = cms.EDAnalyzer("L1GTAlgoBoardWriter", + filename = cms.untracked.string("algoBitPattern"), + algoBlocksTag = cms.untracked.InputTag("l1tGTAlgoBlockProducer"), +) diff --git a/L1Trigger/Phase2L1GT/python/l1tGTMenu_BTagSeeds_cff.py b/L1Trigger/Phase2L1GT/python/l1tGTMenu_BTagSeeds_cff.py index 75fbc620dc075..b17d8d36d742d 100644 --- a/L1Trigger/Phase2L1GT/python/l1tGTMenu_BTagSeeds_cff.py +++ b/L1Trigger/Phase2L1GT/python/l1tGTMenu_BTagSeeds_cff.py @@ -20,13 +20,13 @@ tag = cms.InputTag("l1tGTProducer", "GMTTkMuons"), minEta = cms.double(-1.5), maxEta = cms.double(1.5), - minQualityScore = cms.uint32(0) + qualityFlags = cms.uint32(0b0001) ), collection2 = cms.PSet( tag = cms.InputTag("l1tGTProducer", "GMTTkMuons"), minEta = cms.double(-1.5), maxEta = cms.double(1.5), - minQualityScore = cms.uint32(0) + qualityFlags = cms.uint32(0b0001) ), minDR = cms.double(0), maxDR =cms.double(1.4), @@ -43,7 +43,7 @@ maxEta = cms.double(2.4), regionsAbsEtaLowerBounds=cms.vdouble(0,0.83,1.24), regionsMinPt=cms.vdouble(4,4,4), - minQualityScore = cms.uint32(0) + qualityFlags = cms.uint32(0b0001) ), collection2 = cms.PSet( tag = cms.InputTag("l1tGTProducer", "GMTTkMuons"), @@ -51,7 +51,7 @@ maxEta = cms.double(2.4), regionsAbsEtaLowerBounds=cms.vdouble(0,0.83,1.24), regionsMinPt=cms.vdouble(4,4,4), - minQualityScore = cms.uint32(0) + qualityFlags = cms.uint32(0b0001) ), minDR = cms.double(0), maxDR =cms.double(1.2), @@ -68,7 +68,7 @@ maxEta = cms.double(2.0), regionsAbsEtaLowerBounds=cms.vdouble(0,0.83,1.24), regionsMinPt=cms.vdouble(4,4,4), - minQualityScore = cms.uint32(0) + qualityFlags = cms.uint32(0b0001) ), collection2 = cms.PSet( tag = cms.InputTag("l1tGTProducer", "GMTTkMuons"), @@ -76,7 +76,7 @@ maxEta = cms.double(2.0), regionsAbsEtaLowerBounds=cms.vdouble(0,0.83,1.24), regionsMinPt=cms.vdouble(4,4,4), - minQualityScore = cms.uint32(0) + qualityFlags = cms.uint32(0b0001) ), minDR = cms.double(0), minInvMass = cms.double(7), @@ -93,21 +93,21 @@ minPt = cms.double(5), minEta = cms.double(-2.4), maxEta = cms.double(2.4), - minQualityScore = cms.uint32(0) + qualityFlags = cms.uint32(0b0001) ), collection2 = cms.PSet( tag = cms.InputTag("l1tGTProducer", "GMTTkMuons"), minPt = cms.double(3), minEta = cms.double(-2.4), maxEta = cms.double(2.4), - minQualityScore = cms.uint32(0) + qualityFlags = cms.uint32(0b0001) ), collection3 = cms.PSet( tag = cms.InputTag("l1tGTProducer", "GMTTkMuons"), minPt = cms.double(0), minEta = cms.double(-2.4), maxEta = cms.double(2.4), - minQualityScore = cms.uint32(0) + qualityFlags = cms.uint32(0b0001) ), correl12 = cms.PSet( minDR = cms.double(0), @@ -132,21 +132,21 @@ minPt = cms.double(5), minEta = cms.double(-2.4), maxEta = cms.double(2.4), - minQualityScore = cms.uint32(0) + qualityFlags = cms.uint32(0b0001) ), collection2 = cms.PSet( tag = cms.InputTag("l1tGTProducer", "GMTTkMuons"), minPt = cms.double(4), minEta = cms.double(-2.4), maxEta = cms.double(2.4), - minQualityScore = cms.uint32(0) + qualityFlags = cms.uint32(0b0001) ), collection3 = cms.PSet( tag = cms.InputTag("l1tGTProducer", "GMTTkMuons"), minPt = cms.double(2), minEta = cms.double(-2.4), maxEta = cms.double(2.4), - minQualityScore = cms.uint32(0) + qualityFlags = cms.uint32(0b0001) ), correl12 = cms.PSet( minDR = cms.double(0), diff --git a/L1Trigger/Phase2L1GT/python/l1tGTMenu_crossLepSeeds_cff.py b/L1Trigger/Phase2L1GT/python/l1tGTMenu_crossLepSeeds_cff.py index 85889c220d02e..00a2363a49c4a 100644 --- a/L1Trigger/Phase2L1GT/python/l1tGTMenu_crossLepSeeds_cff.py +++ b/L1Trigger/Phase2L1GT/python/l1tGTMenu_crossLepSeeds_cff.py @@ -22,7 +22,7 @@ maxEta = cms.double(2.4), regionsAbsEtaLowerBounds=cms.vdouble(0,0.83,1.24), regionsMinPt=cms.vdouble(7,7,7), - minQualityScore = cms.uint32(0), + qualityFlags = cms.uint32(0b0001), ), collection2 = cms.PSet( tag = cms.InputTag("l1tGTProducer", "CL2Electrons"), @@ -44,7 +44,7 @@ maxEta = cms.double(2.4), regionsAbsEtaLowerBounds=cms.vdouble(0,0.83,1.24), regionsMinPt=cms.vdouble(7,7,7), - minQualityScore = cms.uint32(0), + qualityFlags = cms.uint32(0b0001), ), collection2 = cms.PSet( tag = cms.InputTag("l1tGTProducer", "CL2Electrons"), @@ -87,7 +87,7 @@ maxEta = cms.double(2.4), regionsAbsEtaLowerBounds=cms.vdouble(0,0.83,1.24), regionsMinPt=cms.vdouble(6,6,6), - minQualityScore = cms.uint32(0), + qualityFlags = cms.uint32(0b0001), ), collection2 = cms.PSet( tag = cms.InputTag("l1tGTProducer", "CL2Electrons"), @@ -122,7 +122,7 @@ maxEta = cms.double(2.4), regionsAbsEtaLowerBounds=cms.vdouble(0,0.83,1.24), regionsMinPt=cms.vdouble(5,5,5), - minQualityScore = cms.uint32(0), + qualityFlags = cms.uint32(0b0001), ), collection2 = cms.PSet( tag = cms.InputTag("l1tGTProducer", "GMTTkMuons"), @@ -130,7 +130,7 @@ maxEta = cms.double(2.4), regionsAbsEtaLowerBounds=cms.vdouble(0,0.83,1.24), regionsMinPt=cms.vdouble(5,5,5), - minQualityScore = cms.uint32(0), + qualityFlags = cms.uint32(0b0001), ), collection3 = cms.PSet( tag = cms.InputTag("l1tGTProducer", "CL2Electrons"), diff --git a/L1Trigger/Phase2L1GT/python/l1tGTMenu_hadr_crossLepSeeds_cff.py b/L1Trigger/Phase2L1GT/python/l1tGTMenu_hadr_crossLepSeeds_cff.py index 7ccdcef7a1025..33190f33fbf4f 100644 --- a/L1Trigger/Phase2L1GT/python/l1tGTMenu_hadr_crossLepSeeds_cff.py +++ b/L1Trigger/Phase2L1GT/python/l1tGTMenu_hadr_crossLepSeeds_cff.py @@ -24,7 +24,7 @@ regionsMinPt=cms.vdouble(6,6,6), maxPrimVertDz = cms.double(1), # in cm primVertex = cms.uint32(0), # primary vertex index (choose 0) - minQualityScore = cms.uint32(0) + qualityFlags = cms.uint32(0b0001) ), collection2 = cms.PSet( tag = cms.InputTag("l1tGTProducer", "CL2HtSum"), @@ -44,7 +44,7 @@ regionsMinPt=cms.vdouble(10,10,11), maxPrimVertDz = cms.double(1), # in cm primVertex = cms.uint32(0), # primary vertex index (choose 0) - minQualityScore = cms.uint32(0), + qualityFlags = cms.uint32(0b0001), ), collection2 = cms.PSet( tag = cms.InputTag("l1tGTProducer", "CL2JetsSC4"), @@ -89,7 +89,7 @@ regionsMinPt=cms.vdouble(3,3,3), maxPrimVertDz = cms.double(1), # in cm primVertex = cms.uint32(0), # primary vertex index (choose 0) - minQualityScore = cms.uint32(0) + qualityFlags = cms.uint32(0b0001) ), collection2 = cms.PSet( tag = cms.InputTag("l1tGTProducer", "CL2JetsSC4"), @@ -118,7 +118,7 @@ regionsMinPt=cms.vdouble(3,3,3), maxPrimVertDz = cms.double(1), # in cm primVertex = cms.uint32(0), # primary vertex index (choose 0) - minQualityScore = cms.uint32(0) + qualityFlags = cms.uint32(0b0001) ), collection2 = cms.PSet( tag = cms.InputTag("l1tGTProducer", "GMTTkMuons"), @@ -128,7 +128,7 @@ regionsMinPt=cms.vdouble(3,3,3), maxPrimVertDz = cms.double(1), # in cm primVertex = cms.uint32(0), # primary vertex index (choose 0) - minQualityScore = cms.uint32(0) + qualityFlags = cms.uint32(0b0001) ), collection3 = cms.PSet( tag = cms.InputTag("l1tGTProducer", "CL2JetsSC4"), @@ -159,7 +159,7 @@ regionsMinPt=cms.vdouble(3,3,3), maxPrimVertDz = cms.double(1), # in cm primVertex = cms.uint32(0), # primary vertex index (choose 0) - minQualityScore = cms.uint32(0) + qualityFlags = cms.uint32(0b0001) ), collection2 = cms.PSet( tag = cms.InputTag("l1tGTProducer", "GMTTkMuons"), @@ -169,7 +169,7 @@ regionsMinPt=cms.vdouble(3,3,3), maxPrimVertDz = cms.double(1), # in cm primVertex = cms.uint32(0), # primary vertex index (choose 0) - minQualityScore = cms.uint32(0) + qualityFlags = cms.uint32(0b0001) ), collection3 = cms.PSet( tag = cms.InputTag("l1tGTProducer", "CL2HtSum"), diff --git a/L1Trigger/Phase2L1GT/python/l1tGTMenu_lepSeeds_cff.py b/L1Trigger/Phase2L1GT/python/l1tGTMenu_lepSeeds_cff.py index c4b6326763bb0..d325c0c0df5ba 100644 --- a/L1Trigger/Phase2L1GT/python/l1tGTMenu_lepSeeds_cff.py +++ b/L1Trigger/Phase2L1GT/python/l1tGTMenu_lepSeeds_cff.py @@ -46,7 +46,7 @@ maxEta = cms.double(2.4), regionsAbsEtaLowerBounds=cms.vdouble(0,0.83,1.24), regionsMinPt=cms.vdouble(7,7,7), - minQualityScore = cms.uint32(0) + qualityFlags = cms.uint32(0b0001) ), maxDz = cms.double(1), minDR = cms.double(0), @@ -60,21 +60,21 @@ minPt = cms.double(5), minEta = cms.double(-2.4), maxEta = cms.double(2.4), - minQualityScore = cms.uint32(0) + qualityFlags = cms.uint32(0b0001) ), collection2 = cms.PSet( tag = cms.InputTag("l1tGTProducer", "GMTTkMuons"), minPt = cms.double(3), minEta = cms.double(-2.4), maxEta = cms.double(2.4), - minQualityScore = cms.uint32(0) + qualityFlags = cms.uint32(0b0001) ), collection3 = cms.PSet( tag = cms.InputTag("l1tGTProducer", "GMTTkMuons"), minPt = cms.double(3), minEta = cms.double(-2.4), maxEta = cms.double(2.4), - minQualityScore = cms.uint32(0) + qualityFlags = cms.uint32(0b0001) ), correl12 = cms.PSet( minDR = cms.double(0), diff --git a/L1Trigger/Phase2L1GT/python/l1tGTProducer_cff.py b/L1Trigger/Phase2L1GT/python/l1tGTProducer_cff.py index cd1417d8d3b6d..1d4686603360d 100644 --- a/L1Trigger/Phase2L1GT/python/l1tGTProducer_cff.py +++ b/L1Trigger/Phase2L1GT/python/l1tGTProducer_cff.py @@ -6,6 +6,9 @@ scales=scale_parameter, GTTPromptJets = cms.InputTag("l1tTrackJetsEmulation", "L1TrackJets"), GTTDisplacedJets = cms.InputTag("l1tTrackJetsExtendedEmulation", "L1TrackJetsExtended"), + GTTPromptHtSum = cms.InputTag("l1tTrackerEmuHTMiss", "L1TrackerEmuHTMiss"), + GTTDisplacedHtSum = cms.InputTag("l1tTrackerEmuHTMissExtended", "L1TrackerEmuHTMissExtended"), + GTTEtSum = cms.InputTag("l1tTrackerEmuEtMiss","L1TrackerEmuEtMiss"), GTTPrimaryVert = cms.InputTag("l1tVertexFinderEmulator", "L1VerticesEmulation"), GMTSaPromptMuons = cms.InputTag("l1tSAMuonsGmt", "prompt"), GMTSaDisplacedMuons = cms.InputTag("l1tSAMuonsGmt", "displaced"), diff --git a/L1Trigger/Phase2L1GT/test/gt_firmware_evaluation.py b/L1Trigger/Phase2L1GT/test/gt_firmware_evaluation.py index 3517d9474909b..f37d67bcdefe9 100644 --- a/L1Trigger/Phase2L1GT/test/gt_firmware_evaluation.py +++ b/L1Trigger/Phase2L1GT/test/gt_firmware_evaluation.py @@ -3,10 +3,6 @@ process = cms.Process('L1Test') -# import of standard configurations -process.load('Configuration.StandardSequences.Services_cff') - - # Input source process.source = cms.Source("EmptySource") process.maxEvents = cms.untracked.PSet(input=cms.untracked.int32(94)) @@ -21,10 +17,10 @@ process.l1tGTProducer = cms.EDProducer( "L1GTEvaluationProducer", - outputFilename=cms.string("inputPattern"), - random_seed=cms.uint32(0), - maxLines=cms.uint32(1024), - platform=cms.string(options.platform) + inputFilename=cms.untracked.string("inputPattern"), + outputFilename=cms.untracked.string("outputObjectPattern"), + random_seed=cms.untracked.uint32(0), + maxFrames=cms.untracked.uint32(1024) ) process.l1t_GTProducer = cms.Path(process.l1tGTProducer) @@ -804,62 +800,35 @@ process.pl1tGTAlgoBlockProducer = cms.Path(process.l1tGTAlgoBlockProducer) if options.platform == "VU13P": - channels = cms.vuint32(46, 47) + from L1Trigger.Phase2L1GT.l1tGTBoardWriterVU13P_cff import BoardDataInput, BoardDataOutputObjects + channels = cms.untracked.vuint32(46, 47) else: - channels = cms.vuint32(32, 33) + from L1Trigger.Phase2L1GT.l1tGTBoardWriterVU9P_cff import BoardDataInput, BoardDataOutputObjects + channels = cms.untracked.vuint32(32, 33) + + +process.l1tGTProducer.InputChannels = BoardDataInput.InputChannels +process.l1tGTProducer.OutputChannels = BoardDataOutputObjects.OutputChannels process.BoardData = cms.EDAnalyzer("L1GTAlgoBoardWriter", - outputFilename = cms.string("outputPattern"), - algoBlocksTag = cms.InputTag("l1tGTAlgoBlockProducer"), - maxLines = cms.uint32(1024), + filename = cms.untracked.string("outputPattern"), + algoBlocksTag = cms.untracked.InputTag("l1tGTAlgoBlockProducer"), + maxFrames = cms.untracked.uint32(1024), channels = channels ) -process.BoardDataObjects = cms.EDAnalyzer("L1GTOutputObjectWriter", - GCTNonIsoEg = cms.InputTag("l1tGTProducer", "GCTNonIsoEg"), - GCTIsoEg = cms.InputTag("l1tGTProducer", "GCTIsoEg"), - GCTJets = cms.InputTag("l1tGTProducer", "GCTJets"), - GCTTaus = cms.InputTag("l1tGTProducer", "GCTTaus"), - GCTHtSum = cms.InputTag("l1tGTProducer", "GCTHtSum"), - GCTEtSum = cms.InputTag("l1tGTProducer", "GCTEtSum"), - GMTSaPromptMuons = cms.InputTag("l1tGTProducer", "GMTSaPromptMuons"), - GMTSaDisplacedMuons = cms.InputTag("l1tGTProducer", "GMTSaDisplacedMuons"), - GMTTkMuons = cms.InputTag("l1tGTProducer", "GMTTkMuons"), - GMTTopo = cms.InputTag("l1tGTProducer", "GMTTopo"), - GTTPromptJets = cms.InputTag("l1tGTProducer", "GTTPromptJets"), - GTTDisplacedJets = cms.InputTag("l1tGTProducer", "GTTDisplacedJets"), - GTTPhiCandidates = cms.InputTag("l1tGTProducer", "GTTPhiCandidates"), - GTTRhoCandidates = cms.InputTag("l1tGTProducer", "GTTRhoCandidates"), - GTTBsCandidates = cms.InputTag("l1tGTProducer", "GTTBsCandidates"), - GTTHadronicTaus = cms.InputTag("l1tGTProducer", "GTTHadronicTaus"), - GTTPrimaryVert = cms.InputTag("l1tGTProducer", "GTTPrimaryVert"), - GTTPromptHtSum = cms.InputTag("l1tGTProducer", "GTTPromptHtSum"), - GTTDisplacedHtSum = cms.InputTag("l1tGTProducer", "GTTDisplacedHtSum"), - GTTEtSum = cms.InputTag("l1tGTProducer", "GTTEtSum"), - CL2JetsSC4 = cms.InputTag("l1tGTProducer", "CL2JetsSC4"), - CL2JetsSC8 = cms.InputTag("l1tGTProducer", "CL2JetsSC8"), - CL2Taus = cms.InputTag("l1tGTProducer", "CL2Taus"), - CL2Electrons = cms.InputTag("l1tGTProducer", "CL2Electrons"), - CL2Photons = cms.InputTag("l1tGTProducer", "CL2Photons"), - CL2HtSum = cms.InputTag("l1tGTProducer", "CL2HtSum"), - CL2EtSum = cms.InputTag("l1tGTProducer", "CL2EtSum"), - outputFilename = cms.string("outputObjectsPattern"), - maxLines = cms.uint32(1024) -) - process.FinOrBoardData = cms.EDAnalyzer("L1GTFinOrBoardWriter", - outputFilename = cms.string("outputFinOrPattern"), - algoBlocksTag = cms.InputTag("l1tGTAlgoBlockProducer"), - maxLines = cms.uint32(1024), - channelsLow = cms.vuint32(4, 5, 6), - channelsMid = cms.vuint32(40, 41, 42), - channelsHigh = cms.vuint32(52, 53, 54), - channelFinOr = cms.uint32(99) + filename = cms.untracked.string("outputFinOrPattern"), + algoBlocksTag = cms.untracked.InputTag("l1tGTAlgoBlockProducer"), + maxFrames = cms.untracked.uint32(1024), + channelsLow = cms.untracked.vuint32(4, 5, 6), + channelsMid = cms.untracked.vuint32(40, 41, 42), + channelsHigh = cms.untracked.vuint32(52, 53, 54), + channelFinOr = cms.untracked.uint32(99) ) process.l1t_BoardData = cms.EndPath(process.BoardData) -process.l1t_BoardDataObjects = cms.EndPath(process.BoardDataObjects) process.l1t_FinOrBoardData = cms.EndPath(process.FinOrBoardData) process.output = cms.OutputModule("PoolOutputModule", diff --git a/L1Trigger/Phase2L1GT/test/test_GT.py b/L1Trigger/Phase2L1GT/test/test_GT.py index 9bb06490f63ad..85b402c536a1b 100644 --- a/L1Trigger/Phase2L1GT/test/test_GT.py +++ b/L1Trigger/Phase2L1GT/test/test_GT.py @@ -25,20 +25,16 @@ process.source = cms.Source("PoolSource", fileNames=cms.untracked.vstring( -'/store/mc/Phase2Fall22DRMiniAOD/TT_TuneCP5_14TeV-powheg-pythia8/GEN-SIM-DIGI-RAW-MINIAOD/PU200_125X_mcRun4_realistic_v2_ext1-v1/30001/9ac14ec7-19fe-4933-a6c6-bc873f473f67.root', -'/store/mc/Phase2Fall22DRMiniAOD/TT_TuneCP5_14TeV-powheg-pythia8/GEN-SIM-DIGI-RAW-MINIAOD/PU200_125X_mcRun4_realistic_v2_ext1-v1/30001/cf19f554-5b35-4074-b297-937986db7743.root', -'/store/mc/Phase2Fall22DRMiniAOD/TT_TuneCP5_14TeV-powheg-pythia8/GEN-SIM-DIGI-RAW-MINIAOD/PU200_125X_mcRun4_realistic_v2_ext1-v1/30001/2215647c-cacd-4c9d-a84f-646a4c11c347.root', -'/store/mc/Phase2Fall22DRMiniAOD/TT_TuneCP5_14TeV-powheg-pythia8/GEN-SIM-DIGI-RAW-MINIAOD/PU200_125X_mcRun4_realistic_v2_ext1-v1/30000/bec8fe62-c75f-459d-ba69-366fff94d3e5.root', -'/store/mc/Phase2Fall22DRMiniAOD/TT_TuneCP5_14TeV-powheg-pythia8/GEN-SIM-DIGI-RAW-MINIAOD/PU200_125X_mcRun4_realistic_v2_ext1-v1/30001/0d870582-78fd-4c25-b476-2ccd2129edc7.root', -'/store/mc/Phase2Fall22DRMiniAOD/TT_TuneCP5_14TeV-powheg-pythia8/GEN-SIM-DIGI-RAW-MINIAOD/PU200_125X_mcRun4_realistic_v2_ext1-v1/30001/b7256d6c-d4b1-4ca4-bbf1-bf0853220641.root', -'/store/mc/Phase2Fall22DRMiniAOD/TT_TuneCP5_14TeV-powheg-pythia8/GEN-SIM-DIGI-RAW-MINIAOD/PU200_125X_mcRun4_realistic_v2_ext1-v1/30000/3eaace9c-7465-4f52-94e8-b07e3b2630e8.root', -'/store/mc/Phase2Fall22DRMiniAOD/TT_TuneCP5_14TeV-powheg-pythia8/GEN-SIM-DIGI-RAW-MINIAOD/PU200_125X_mcRun4_realistic_v2_ext1-v1/30000/0f2c534d-5292-4bd3-9948-e8003583d2f6.root', -'/store/mc/Phase2Fall22DRMiniAOD/TT_TuneCP5_14TeV-powheg-pythia8/GEN-SIM-DIGI-RAW-MINIAOD/PU200_125X_mcRun4_realistic_v2_ext1-v1/30001/70c30283-78fd-44b4-8a30-60db56b3c0f9.root', -'/store/mc/Phase2Fall22DRMiniAOD/TT_TuneCP5_14TeV-powheg-pythia8/GEN-SIM-DIGI-RAW-MINIAOD/PU200_125X_mcRun4_realistic_v2_ext1-v1/30001/90196109-a57c-4df8-931d-7b42bc7b6a3e.root', - ), +"/store/mc/Phase2Spring23DIGIRECOMiniAOD/TT_TuneCP5_14TeV-powheg-pythia8/GEN-SIM-DIGI-RAW-MINIAOD/PU200_L1TFix_Trk1GeV_131X_mcRun4_realistic_v9-v1/50000/005bc30b-cf79-4b3b-9ec1-a80e13072afd.root", + "/store/mc/Phase2Spring23DIGIRECOMiniAOD/TT_TuneCP5_14TeV-powheg-pythia8/GEN-SIM-DIGI-RAW-MINIAOD/PU200_L1TFix_Trk1GeV_131X_mcRun4_realistic_v9-v1/50000/009bd7ba-4295-46ef-a5bc-9eb3d2cd3cf7.root", + "/store/mc/Phase2Spring23DIGIRECOMiniAOD/TT_TuneCP5_14TeV-powheg-pythia8/GEN-SIM-DIGI-RAW-MINIAOD/PU200_L1TFix_Trk1GeV_131X_mcRun4_realistic_v9-v1/50000/017a99d2-4636-4584-97d0-d5499c3b453c.root", + "/store/mc/Phase2Spring23DIGIRECOMiniAOD/TT_TuneCP5_14TeV-powheg-pythia8/GEN-SIM-DIGI-RAW-MINIAOD/PU200_L1TFix_Trk1GeV_131X_mcRun4_realistic_v9-v1/50000/02020287-a16f-41db-8021-f9bcd272f6c9.root", + "/store/mc/Phase2Spring23DIGIRECOMiniAOD/TT_TuneCP5_14TeV-powheg-pythia8/GEN-SIM-DIGI-RAW-MINIAOD/PU200_L1TFix_Trk1GeV_131X_mcRun4_realistic_v9-v1/50000/02ca41cb-9638-4703-88b7-799c30fd2656.root", + "/store/mc/Phase2Spring23DIGIRECOMiniAOD/TT_TuneCP5_14TeV-powheg-pythia8/GEN-SIM-DIGI-RAW-MINIAOD/PU200_L1TFix_Trk1GeV_131X_mcRun4_realistic_v9-v1/50000/03171e00-8880-4c09-807a-0c1d5bac2797.root", + "/store/mc/Phase2Spring23DIGIRECOMiniAOD/TT_TuneCP5_14TeV-powheg-pythia8/GEN-SIM-DIGI-RAW-MINIAOD/PU200_L1TFix_Trk1GeV_131X_mcRun4_realistic_v9-v1/50000/04c836c3-66f4-44d5-a8fd-2faf5e4aa623.root", ), ) -process.maxEvents = cms.untracked.PSet(input=cms.untracked.int32(500)) +process.maxEvents = cms.untracked.PSet(input=cms.untracked.int32(94)) process.options = cms.untracked.PSet( @@ -122,14 +118,20 @@ process.pGToutput = cms.EndPath(process.GToutput) +process.load('L1Trigger.Phase2L1GT.l1tGTBoardWriterVU13P_cff') + +process.pBoardDataInputVU13P = cms.EndPath(process.BoardDataInputVU13P) +process.pBoardDataOutputObjectsVU13P = cms.EndPath(process.BoardDataOutputObjectsVU13P) + # Schedule definition -process.schedule = cms.Schedule(process.raw2digi_step,process.L1simulation_step,process.GTemulation_step, *collectAlgorithmPaths(process), process.pGToutput, process.endjob_step) +process.schedule = cms.Schedule(process.raw2digi_step,process.L1simulation_step,process.GTemulation_step, *collectAlgorithmPaths(process), process.pGToutput, + process.pBoardDataInputVU13P, process.pBoardDataOutputObjectsVU13P, process.endjob_step) from PhysicsTools.PatAlgos.tools.helpers import associatePatAlgosToolsTask associatePatAlgosToolsTask(process) #Setup FWK for multithreaded -process.options.numberOfThreads = 8 +process.options.numberOfThreads = 4 process.options.numberOfStreams = 0 # customisation of the process.