From a5a6c3b12ff3a1ce875efd72286b293c3fbc6424 Mon Sep 17 00:00:00 2001 From: tahuang1991 Date: Fri, 27 May 2022 09:07:58 +0200 Subject: [PATCH 01/10] Rebase step 2 --- DataFormats/CSCDigi/interface/CSCShowerDigi.h | 15 +- DataFormats/CSCDigi/src/CSCShowerDigi.cc | 30 +++- DataFormats/CSCDigi/src/classes_def.xml | 4 +- .../CSCDigi/src/classes_def.xml.generated | 169 ++++++++++++++++++ .../CSCRawToDigi/interface/CSCALCTHeader.h | 4 +- .../CSCRawToDigi/interface/CSCTMBHeader.h | 1 + .../CSCRawToDigi/interface/CSCTMBHeader2006.h | 1 + .../CSCRawToDigi/interface/CSCTMBHeader2007.h | 1 + .../interface/CSCTMBHeader2007_rev0x50c3.h | 1 + .../CSCRawToDigi/interface/CSCTMBHeader2013.h | 1 + .../interface/CSCTMBHeader2020_CCLUT.h | 1 + .../interface/CSCTMBHeader2020_GEM.h | 1 + .../interface/CSCTMBHeader2020_Run2.h | 1 + .../interface/CSCTMBHeader2020_TMB.h | 1 + .../interface/CSCVTMBHeaderFormat.h | 2 + EventFilter/CSCRawToDigi/src/CSCALCTHeader.cc | 5 +- .../src/CSCTMBHeader2020_CCLUT.cc | 51 +++++- .../CSCRawToDigi/src/CSCTMBHeader2020_GEM.cc | 51 +++++- .../CSCRawToDigi/src/CSCTMBHeader2020_TMB.cc | 34 +++- .../interface/CSCAnodeLCTProcessor.h | 19 +- .../interface/CSCCathodeLCTProcessor.h | 23 ++- .../interface/CSCMotherboard.h | 11 +- .../interface/CSCTriggerPrimitivesBuilder.h | 3 + .../python/cscTriggerPrimitiveDigis_cfi.py | 2 + .../python/params/showerParams.py | 45 +++-- .../src/CSCAnodeLCTProcessor.cc | 121 +++++++------ .../src/CSCCathodeLCTProcessor.cc | 128 +++++++------ .../src/CSCMotherboard.cc | 94 ++++++++-- .../src/CSCTriggerPrimitivesBuilder.cc | 29 ++- 29 files changed, 648 insertions(+), 201 deletions(-) create mode 100644 DataFormats/CSCDigi/src/classes_def.xml.generated diff --git a/DataFormats/CSCDigi/interface/CSCShowerDigi.h b/DataFormats/CSCDigi/interface/CSCShowerDigi.h index 942bbec739398..f376ddfa56e73 100644 --- a/DataFormats/CSCDigi/interface/CSCShowerDigi.h +++ b/DataFormats/CSCDigi/interface/CSCShowerDigi.h @@ -10,9 +10,12 @@ class CSCShowerDigi { public: // Run-3 definitions as provided in DN-20-033 enum Run3Shower { kInvalid = 0, kLoose = 1, kNominal = 2, kTight = 3 }; + // Shower types. and showers from OTMB/TMB are assigned with kLCTShower + enum ShowerType { kInvalidShower = 0, kALCTShower = 1, kCLCTShower = 2, kLCTShower = 3}; /// Constructors - CSCShowerDigi(const uint16_t inTimeBits, const uint16_t outTimeBits, const uint16_t cscID); + CSCShowerDigi(const uint16_t inTimeBits, const uint16_t outTimeBits, const uint16_t cscID, + const uint16_t bx, const uint16_t showerType, const uint16_t wireNHits, const uint16_t compNHits); /// default CSCShowerDigi(); @@ -28,20 +31,30 @@ class CSCShowerDigi { bool isLooseOutOfTime() const; bool isNominalOutOfTime() const; bool isTightOutOfTime() const; + bool isValidShowerType() const; uint16_t bitsInTime() const { return bitsInTime_; } uint16_t bitsOutOfTime() const { return bitsOutOfTime_; } + uint16_t getBX() const {return bx_; } uint16_t getCSCID() const { return cscID_; } + uint16_t getShowerType() const { return showerType_; } + uint16_t getWireNHits() const { return wireNHits_; } + uint16_t getComparatorNHits() const { return comparatorNHits_; } /// set cscID void setCSCID(const uint16_t c) { cscID_ = c; } + void setBX(const uint16_t bx) {bx_ = bx; } private: uint16_t bitsInTime_; uint16_t bitsOutOfTime_; // 4-bit CSC chamber identifier uint16_t cscID_; + uint16_t bx_; + uint16_t showerType_; + uint16_t wireNHits_; + uint16_t comparatorNHits_; }; std::ostream& operator<<(std::ostream& o, const CSCShowerDigi& digi); diff --git a/DataFormats/CSCDigi/src/CSCShowerDigi.cc b/DataFormats/CSCDigi/src/CSCShowerDigi.cc index 9a50ef75cb39b..b269ebedef6f6 100644 --- a/DataFormats/CSCDigi/src/CSCShowerDigi.cc +++ b/DataFormats/CSCDigi/src/CSCShowerDigi.cc @@ -6,21 +6,29 @@ using namespace std; /// Constructors -CSCShowerDigi::CSCShowerDigi(const uint16_t bitsInTime, const uint16_t bitsOutOfTime, const uint16_t cscID) - : bitsInTime_(bitsInTime), bitsOutOfTime_(bitsOutOfTime), cscID_(cscID) {} +CSCShowerDigi::CSCShowerDigi(const uint16_t bitsInTime, const uint16_t bitsOutOfTime, const uint16_t cscID, + const uint16_t bx, const uint16_t showerType, const uint16_t wireNHits, const uint16_t compNHits) + : bitsInTime_(bitsInTime), bitsOutOfTime_(bitsOutOfTime), cscID_(cscID), + bx_(bx), showerType_(showerType), wireNHits_(wireNHits), comparatorNHits_(compNHits) {} /// Default -CSCShowerDigi::CSCShowerDigi() : bitsInTime_(0), bitsOutOfTime_(0), cscID_(0) {} +CSCShowerDigi::CSCShowerDigi() : bitsInTime_(0), bitsOutOfTime_(0), cscID_(0), + bx_(0), showerType_(0), wireNHits_(0), comparatorNHits_(0){} void CSCShowerDigi::clear() { bitsInTime_ = 0; bitsOutOfTime_ = 0; cscID_ = 0; + bx_ = 0; + showerType_ = 0; + wireNHits_ = 0; + comparatorNHits_ = 0; } bool CSCShowerDigi::isValid() const { // any loose shower is valid - return isLooseInTime() or isLooseOutOfTime(); + // isLooseOutofTime() is removed as out-of-time shower is not used for Run3 + return isLooseInTime() and isValidShowerType(); } bool CSCShowerDigi::isLooseInTime() const { return bitsInTime() >= kLoose; } @@ -35,6 +43,18 @@ bool CSCShowerDigi::isNominalOutOfTime() const { return bitsOutOfTime() >= kNomi bool CSCShowerDigi::isTightOutOfTime() const { return bitsOutOfTime() >= kTight; } +bool CSCShowerDigi::isValidShowerType() const { return showerType_ > kInvalidShower; } + std::ostream& operator<<(std::ostream& o, const CSCShowerDigi& digi) { - return o << "CSC Shower: in-time bits " << digi.bitsInTime() << ", out-of-time bits " << digi.bitsOutOfTime(); + + unsigned int showerType = digi.getShowerType(); + std::string compHitsStr(", comparatorHits "); + compHitsStr += std::to_string(digi.getComparatorNHits()); + std::string wireHitsStr(", wireHits "); + wireHitsStr += std::to_string(digi.getWireNHits()); + + return o <<(showerType == 0 ? "Invalid ShowerType" : (showerType == 1 ? "ALCTShower" : (showerType == 2 ? "CLCTShower" : "correlatedLCTShower"))) + <<": bx "<< digi.getBX() <<", in-time bits " << digi.bitsInTime() << ", out-of-time bits " << digi.bitsOutOfTime() + << ((showerType == 1 or showerType == 3 ) ? wireHitsStr : "") + << ((showerType == 2 or showerType == 3 ) ? compHitsStr : "") << ";"; } diff --git a/DataFormats/CSCDigi/src/classes_def.xml b/DataFormats/CSCDigi/src/classes_def.xml index 67bc65d4f4b75..7eebb15fcfaeb 100644 --- a/DataFormats/CSCDigi/src/classes_def.xml +++ b/DataFormats/CSCDigi/src/classes_def.xml @@ -39,7 +39,9 @@ - + + + diff --git a/DataFormats/CSCDigi/src/classes_def.xml.generated b/DataFormats/CSCDigi/src/classes_def.xml.generated new file mode 100644 index 0000000000000..4a4b1e09b45e4 --- /dev/null +++ b/DataFormats/CSCDigi/src/classes_def.xml.generated @@ -0,0 +1,169 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/EventFilter/CSCRawToDigi/interface/CSCALCTHeader.h b/EventFilter/CSCRawToDigi/interface/CSCALCTHeader.h index 999bce7197353..5a116fce7ef08 100644 --- a/EventFilter/CSCRawToDigi/interface/CSCALCTHeader.h +++ b/EventFilter/CSCRawToDigi/interface/CSCALCTHeader.h @@ -168,7 +168,9 @@ class CSCALCTHeader { // { if ((!theALCTs.empty()) && (theALCTs.size() == unsigned(header2007.lctBins * 2))) { for (unsigned bx = 0; bx < header2007.lctBins; bx++) { - results.push_back(CSCShowerDigi(theALCTs[bx * 2].reserved & 0x3, 0, bx)); + //CSCID is set to be 0 + //ALCTshower, showerType_= 1, wireNHits and ComparatorNHits are not available in data + results.push_back(CSCShowerDigi(theALCTs[bx * 2].reserved & 0x3, 0, 0, bx, 1, 0, 0)); } return results; } else diff --git a/EventFilter/CSCRawToDigi/interface/CSCTMBHeader.h b/EventFilter/CSCRawToDigi/interface/CSCTMBHeader.h index 1ffa9fdb3ab4a..d71bdca80b374 100644 --- a/EventFilter/CSCRawToDigi/interface/CSCTMBHeader.h +++ b/EventFilter/CSCRawToDigi/interface/CSCTMBHeader.h @@ -54,6 +54,7 @@ class CSCTMBHeader { uint16_t sizeInBytes() const { return theHeaderFormat->sizeInWords() * 2; } + uint16_t L1AMatchTime() const {return theHeaderFormat->L1AMatchTime(); } /// will throw if the cast fails CSCTMBHeader2007 tmbHeader2007() const; CSCTMBHeader2007_rev0x50c3 tmbHeader2007_rev0x50c3() const; diff --git a/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2006.h b/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2006.h index f38d8404a95ba..fa950b531c8a4 100644 --- a/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2006.h +++ b/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2006.h @@ -26,6 +26,7 @@ struct CSCTMBHeader2006 : public CSCVTMBHeaderFormat { uint16_t syncErrorCLCT() const override { return (bits.clct0_sync_err | bits.clct1_sync_err); } uint16_t syncErrorMPC0() const override { return bits.MPC_Muon0_SyncErr_; } uint16_t syncErrorMPC1() const override { return bits.MPC_Muon1_SyncErr_; } + uint16_t L1AMatchTime() const override {return bits.pop_l1a_match_win; } /// == Run 3 CSC-GEM Trigger Format uint16_t clct0_ComparatorCode() const override { return 0; } diff --git a/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2007.h b/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2007.h index 64cee063d9ef3..02296fb8dc008 100644 --- a/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2007.h +++ b/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2007.h @@ -26,6 +26,7 @@ struct CSCTMBHeader2007 : public CSCVTMBHeaderFormat { uint16_t syncErrorCLCT() const override { return (bits.clct0_sync_err | bits.clct1_sync_err); } uint16_t syncErrorMPC0() const override { return bits.MPC_Muon0_SyncErr_; } uint16_t syncErrorMPC1() const override { return bits.MPC_Muon1_SyncErr_; } + uint16_t L1AMatchTime() const override {return bits.pop_l1a_match_win; } /// == Run 3 CSC-GEM Trigger Format uint16_t clct0_ComparatorCode() const override { return 0; } diff --git a/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2007_rev0x50c3.h b/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2007_rev0x50c3.h index f0f83f065d380..cf3366ff8577b 100644 --- a/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2007_rev0x50c3.h +++ b/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2007_rev0x50c3.h @@ -26,6 +26,7 @@ struct CSCTMBHeader2007_rev0x50c3 : public CSCVTMBHeaderFormat { uint16_t syncErrorCLCT() const override { return bits.clct_sync_err; } uint16_t syncErrorMPC0() const override { return bits.MPC_Muon0_SyncErr_; } uint16_t syncErrorMPC1() const override { return bits.MPC_Muon1_SyncErr_; } + uint16_t L1AMatchTime() const override {return bits.pop_l1a_match_win; } /// == Run 3 CSC-GEM Trigger Format uint16_t clct0_ComparatorCode() const override { return 0; } diff --git a/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2013.h b/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2013.h index 82d00e229b6d0..73f61796bd54c 100644 --- a/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2013.h +++ b/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2013.h @@ -26,6 +26,7 @@ struct CSCTMBHeader2013 : public CSCVTMBHeaderFormat { uint16_t syncErrorCLCT() const override { return bits.clct_sync_err; } uint16_t syncErrorMPC0() const override { return bits.MPC_Muon0_SyncErr_; } uint16_t syncErrorMPC1() const override { return bits.MPC_Muon1_SyncErr_; } + uint16_t L1AMatchTime() const override {return bits.pop_l1a_match_win; } /// == Run 3 CSC-GEM Trigger Format uint16_t clct0_ComparatorCode() const override { return 0; } diff --git a/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2020_CCLUT.h b/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2020_CCLUT.h index 5a6b4780751e7..fbbc576126387 100644 --- a/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2020_CCLUT.h +++ b/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2020_CCLUT.h @@ -26,6 +26,7 @@ struct CSCTMBHeader2020_CCLUT : public CSCVTMBHeaderFormat { uint16_t syncErrorCLCT() const override { return bits.clct_sync_err; } uint16_t syncErrorMPC0() const override { return 0; } uint16_t syncErrorMPC1() const override { return 0; } + uint16_t L1AMatchTime() const override {return bits.pop_l1a_match_win; } // == Run 3 CSC-GEM Trigger Format uint16_t clct0_ComparatorCode() const override { return bits.clct0_comparator_code; } diff --git a/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2020_GEM.h b/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2020_GEM.h index b066bf7f50a97..446e7fc5c253e 100644 --- a/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2020_GEM.h +++ b/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2020_GEM.h @@ -26,6 +26,7 @@ struct CSCTMBHeader2020_GEM : public CSCVTMBHeaderFormat { uint16_t syncErrorCLCT() const override { return bits.clct_sync_err; } uint16_t syncErrorMPC0() const override { return 0; } uint16_t syncErrorMPC1() const override { return 0; } + uint16_t L1AMatchTime() const override {return bits.pop_l1a_match_win; } // == Run 3 CSC-GEM Trigger Format uint16_t clct0_ComparatorCode() const override { return bits.clct0_comparator_code; } diff --git a/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2020_Run2.h b/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2020_Run2.h index 790bc1c89505a..163d588d2832f 100644 --- a/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2020_Run2.h +++ b/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2020_Run2.h @@ -26,6 +26,7 @@ struct CSCTMBHeader2020_Run2 : public CSCVTMBHeaderFormat { uint16_t syncErrorCLCT() const override { return bits.clct_sync_err; } uint16_t syncErrorMPC0() const override { return bits.MPC_Muon0_SyncErr_; } uint16_t syncErrorMPC1() const override { return bits.MPC_Muon1_SyncErr_; } + uint16_t L1AMatchTime() const override {return bits.pop_l1a_match_win; } // == Run 3 CSC-GEM Trigger Format uint16_t clct0_ComparatorCode() const override { return 0; } diff --git a/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2020_TMB.h b/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2020_TMB.h index 61931dbe428b9..6705e6092af1d 100644 --- a/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2020_TMB.h +++ b/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2020_TMB.h @@ -26,6 +26,7 @@ struct CSCTMBHeader2020_TMB : public CSCVTMBHeaderFormat { uint16_t syncErrorCLCT() const override { return bits.clct_sync_err; } uint16_t syncErrorMPC0() const override { return 0; } uint16_t syncErrorMPC1() const override { return 0; } + uint16_t L1AMatchTime() const override {return bits.pop_l1a_match_win; } // == Run 3 CSC-GEM Trigger Format uint16_t clct0_ComparatorCode() const override { return 0; } diff --git a/EventFilter/CSCRawToDigi/interface/CSCVTMBHeaderFormat.h b/EventFilter/CSCRawToDigi/interface/CSCVTMBHeaderFormat.h index 619d075cac3ca..53f57ed2c3e81 100644 --- a/EventFilter/CSCRawToDigi/interface/CSCVTMBHeaderFormat.h +++ b/EventFilter/CSCRawToDigi/interface/CSCVTMBHeaderFormat.h @@ -30,6 +30,7 @@ class CSCVTMBHeaderFormat { virtual uint16_t syncErrorCLCT() const = 0; virtual uint16_t syncErrorMPC0() const = 0; virtual uint16_t syncErrorMPC1() const = 0; + virtual uint16_t L1AMatchTime() const = 0; /// == Run 3 CSC-GEM Trigger Format virtual uint16_t clct0_ComparatorCode() const = 0; @@ -85,6 +86,7 @@ class CSCVTMBHeaderFormat { virtual void print(std::ostream& os) const = 0; + protected: void swapCLCTs(CSCCLCTDigi& digi1, CSCCLCTDigi& digi2); }; diff --git a/EventFilter/CSCRawToDigi/src/CSCALCTHeader.cc b/EventFilter/CSCRawToDigi/src/CSCALCTHeader.cc index 295621b85886a..bca6c7589787b 100644 --- a/EventFilter/CSCRawToDigi/src/CSCALCTHeader.cc +++ b/EventFilter/CSCRawToDigi/src/CSCALCTHeader.cc @@ -229,8 +229,9 @@ void CSCALCTHeader::addShower(const std::vector &digis) { if (bx < (int)header2007.lctBins) { const CSCShowerDigi &digi = digis[bx]; int i = bx * 2; - theALCTs[i].reserved = digi.bitsInTime() & 0x3; - theALCTs[i + 1].reserved = digi.bitsInTime() & 0x3; + unsigned hmt_bits = digi.isValid() ? digi.bitsInTime() : 0; + theALCTs[i].reserved = hmt_bits & 0x3; + theALCTs[i + 1].reserved = hmt_bits & 0x3; } } } diff --git a/EventFilter/CSCRawToDigi/src/CSCTMBHeader2020_CCLUT.cc b/EventFilter/CSCRawToDigi/src/CSCTMBHeader2020_CCLUT.cc index 49711092538e4..cd7e7c4d6cf09 100644 --- a/EventFilter/CSCRawToDigi/src/CSCTMBHeader2020_CCLUT.cc +++ b/EventFilter/CSCRawToDigi/src/CSCTMBHeader2020_CCLUT.cc @@ -161,20 +161,29 @@ std::vector CSCTMBHeader2020_CCLUT::CorrelatedLCTDigis(uin CSCShowerDigi CSCTMBHeader2020_CCLUT::showerDigi(uint32_t idlayer) const { unsigned hmt_bits = bits.MPC_Muon_HMT_bit0 | (bits.MPC_Muon_HMT_high << 1); // HighMultiplicityTrigger bits - uint16_t cscid = 0; // ??? What is 4-bits CSC Id in CSshowerDigi - CSCShowerDigi result(hmt_bits & 0x3, (hmt_bits >> 2) & 0x3, cscid); // 2-bits intime, 2-bits out of time + uint16_t cscid = bits.cscID; // ??? What is 4-bits CSC Id in CSshowerDigi + //L1A_TMB_WINDOW is not included in below formula + //correct version: CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win + L1A_TMB_WINDOW/2; + // same for anode HMT and cathode HMT + uint16_t bx = CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win; + //LCTshower with showerType = 3. comparatorNHits from hmt_nhits() and wireNHit is not available + CSCShowerDigi result(hmt_bits & 0x3, (hmt_bits >> 2) & 0x3, cscid, bx, 3, 0, hmt_nhits()); // 2-bits intime, 2-bits out of time return result; } CSCShowerDigi CSCTMBHeader2020_CCLUT::anodeShowerDigi(uint32_t idlayer) const { - uint16_t cscid = 0; - CSCShowerDigi result(bits.anode_hmt & 0x3, 0, cscid); // 2-bits intime, no out of time + uint16_t cscid = bits.cscID; + uint16_t bx = CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win; + //ALCT shower with showerType = 1. nhits_ is not available from unpack data + CSCShowerDigi result(bits.anode_hmt & 0x3, 0, cscid, bx, 1, 0, 0); // 2-bits intime, no out of time return result; } CSCShowerDigi CSCTMBHeader2020_CCLUT::cathodeShowerDigi(uint32_t idlayer) const { - uint16_t cscid = 0; - CSCShowerDigi result(bits.cathode_hmt & 0x3, 0, cscid); // 2-bits intime, no out of time + uint16_t cscid = bits.cscID; + uint16_t bx = CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win - bits.hmt_match_win + 3; + //CLCT shower with showerType = 2. + CSCShowerDigi result(bits.cathode_hmt & 0x3, 0, cscid, bx, 2, 0, hmt_nhits()); // 2-bits intime, no out of time return result; } @@ -272,18 +281,44 @@ void CSCTMBHeader2020_CCLUT::addCorrelatedLCT1(const CSCCorrelatedLCTDigi& digi) void CSCTMBHeader2020_CCLUT::addShower(const CSCShowerDigi& digi) { uint16_t hmt_bits = (digi.bitsInTime() & 0x3) + ((digi.bitsOutOfTime() & 0x3) << 2); + //not valid LCT shower, then in-time bits must be 0. keep out-of-time HMT + if (not digi.isValid()) hmt_bits = ((digi.bitsOutOfTime() & 0x3) << 2); bits.MPC_Muon_HMT_bit0 = hmt_bits & 0x1; bits.MPC_Muon_HMT_high = (hmt_bits >> 1) & 0x7; + //to keep pop_l1a_match_win + if (digi.isValid()) + bits.pop_l1a_match_win = CSCConstants::LCT_CENTRAL_BX - digi.getBX(); + else + bits.pop_l1a_match_win = 3;//default value } void CSCTMBHeader2020_CCLUT::addAnodeShower(const CSCShowerDigi& digi) { uint16_t hmt_bits = digi.bitsInTime() & 0x3; + if (not digi.isValid()) hmt_bits = 0; bits.anode_hmt = hmt_bits; + if (not(bits.MPC_Muon_HMT_bit0 or bits.MPC_Muon_HMT_high) and digi.isValid()) + bits.pop_l1a_match_win = CSCConstants::LCT_CENTRAL_BX - digi.getBX(); + else if (not(digi.isValid())) + bits.pop_l1a_match_win = 3;//default value } void CSCTMBHeader2020_CCLUT::addCathodeShower(const CSCShowerDigi& digi) { uint16_t hmt_bits = digi.bitsInTime() & 0x3; + if (not digi.isValid()) hmt_bits = 0; bits.cathode_hmt = hmt_bits; + bits.hmt_nhits_bit0 = digi.getComparatorNHits() & 0x1; + bits.hmt_nhits_bit1 = (digi.getComparatorNHits() >> 1) & 0x1; + bits.hmt_nhits_bits_high = (digi.getComparatorNHits() >> 2) & 0x1F; + if (bits.MPC_Muon_HMT_bit0 or bits.MPC_Muon_HMT_high or bits.anode_hmt){ + //matched HMT is found, then pop_l1a_match_win is assigned + bits.hmt_match_win = CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win + 3 - digi.getBX(); + }else if (digi.isValid()){ + bits.pop_l1a_match_win = 3;//default value + bits.hmt_match_win = CSCConstants::LCT_CENTRAL_BX - digi.getBX(); + }else { + bits.pop_l1a_match_win = 3;//default value + bits.hmt_match_win = 0; //no HMT case + } } void CSCTMBHeader2020_CCLUT::print(std::ostream& os) const { @@ -298,6 +333,8 @@ void CSCTMBHeader2020_CCLUT::print(std::ostream& os) const { << std::hex << (bits.activeCFEBs | (bits.activeCFEBs_2 << 5)) << ", readCFEBs = 0x" << std::hex << (bits.readCFEBs | (bits.readCFEBs_2 << 5)) << std::dec << "\n"; os << "bxnPreTrigger = " << bits.bxnPreTrigger << "\n"; + os << "ALCT location in CLCt window "<< bits.matchWin << " L1A location in TMB window "<< bits.pop_l1a_match_win + << " ALCT in cathde HMT window "<< bits.hmt_match_win << "\n"; os << "tmbMatch = " << bits.tmbMatch << " alctOnly = " << bits.alctOnly << " clctOnly = " << bits.clctOnly << "\n"; os << "readoutCounter: " << std::dec << bits.readoutCounter << ", buf_q_ovf: " << bits.stackOvf @@ -341,5 +378,5 @@ void CSCTMBHeader2020_CCLUT::print(std::ostream& os) const { os << " clct_5bit_pattern_id = " << (bits.MPC_Muon_clct_pattern_low | (bits.MPC_Muon_clct_pattern_bit5 << 4)) << " HMT = " << (bits.MPC_Muon_HMT_bit0 | (bits.MPC_Muon_HMT_high << 1)) << ", alctHMT = " << bits.anode_hmt - << ", clctHMT = " << bits.cathode_hmt << "\n"; + << ", clctHMT = " << bits.cathode_hmt << " cathode nhits "<< hmt_nhits() <<"\n"; } diff --git a/EventFilter/CSCRawToDigi/src/CSCTMBHeader2020_GEM.cc b/EventFilter/CSCRawToDigi/src/CSCTMBHeader2020_GEM.cc index 8fb5dfaf66d49..77ddaa9810309 100644 --- a/EventFilter/CSCRawToDigi/src/CSCTMBHeader2020_GEM.cc +++ b/EventFilter/CSCRawToDigi/src/CSCTMBHeader2020_GEM.cc @@ -165,20 +165,29 @@ std::vector CSCTMBHeader2020_GEM::CorrelatedLCTDigis(uint3 CSCShowerDigi CSCTMBHeader2020_GEM::showerDigi(uint32_t idlayer) const { unsigned hmt_bits = bits.MPC_Muon_HMT_bit0 | (bits.MPC_Muon_HMT_high << 1); // HighMultiplicityTrigger bits - uint16_t cscid = 0; // ??? What is 4-bits CSC Id in CSshowerDigi - CSCShowerDigi result(hmt_bits & 0x3, (hmt_bits >> 2) & 0x3, cscid); // 2-bits intime, 2-bits out of time + uint16_t cscid = bits.cscID; // ??? What is 4-bits CSC Id in CSshowerDigi + //L1A_TMB_WINDOW is not included in below formula + //correct version: CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win + L1A_TMB_WINDOW/2; + // same for anode HMT and cathode HMT. offline analysis would take care of this + uint16_t bx = CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win; + //LCTshower with showerType = 3. comparatorNHits from hmt_nhits() and wireNHits is not available + CSCShowerDigi result(hmt_bits & 0x3, (hmt_bits >> 2) & 0x3, cscid, bx, 3, 0, hmt_nhits()); // 2-bits intime, 2-bits out of time return result; } CSCShowerDigi CSCTMBHeader2020_GEM::anodeShowerDigi(uint32_t idlayer) const { - uint16_t cscid = 0; - CSCShowerDigi result(bits.anode_hmt & 0x3, 0, cscid); // 2-bits intime, no out of time + uint16_t cscid = bits.cscID; + uint16_t bx = CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win; + //ALCT shower with showerType = 1. wireNHits is not available from unpack data + CSCShowerDigi result(bits.anode_hmt & 0x3, 0, cscid, bx, 1, 0, 0); // 2-bits intime, no out of time return result; } CSCShowerDigi CSCTMBHeader2020_GEM::cathodeShowerDigi(uint32_t idlayer) const { - uint16_t cscid = 0; - CSCShowerDigi result(bits.cathode_hmt & 0x3, 0, cscid); // 2-bits intime, no out of time + uint16_t cscid = bits.cscID; + uint16_t bx = CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win - bits.hmt_match_win + 3; + //CLCT shower with showerType = 2. comparatorNHits from hmt_nhits() + CSCShowerDigi result(bits.cathode_hmt & 0x3, 0, cscid, bx, 2, 0, hmt_nhits()); // 2-bits intime, no out of time return result; } @@ -276,18 +285,44 @@ void CSCTMBHeader2020_GEM::addCorrelatedLCT1(const CSCCorrelatedLCTDigi& digi) { void CSCTMBHeader2020_GEM::addShower(const CSCShowerDigi& digi) { uint16_t hmt_bits = (digi.bitsInTime() & 0x3) + ((digi.bitsOutOfTime() & 0x3) << 2); + //not valid LCT shower, then in-time bits must be 0 + if (not digi.isValid()) hmt_bits = ((digi.bitsOutOfTime() & 0x3) << 2); bits.MPC_Muon_HMT_bit0 = hmt_bits & 0x1; bits.MPC_Muon_HMT_high = (hmt_bits >> 1) & 0x7; + //to keep pop_l1a_match_win + if (digi.isValid()) + bits.pop_l1a_match_win = CSCConstants::LCT_CENTRAL_BX - digi.getBX(); + else + bits.pop_l1a_match_win = 3;//default value } void CSCTMBHeader2020_GEM::addAnodeShower(const CSCShowerDigi& digi) { uint16_t hmt_bits = digi.bitsInTime() & 0x3; + if (not digi.isValid()) hmt_bits = 0; bits.anode_hmt = hmt_bits; + if (not(bits.MPC_Muon_HMT_bit0 or bits.MPC_Muon_HMT_high) and digi.isValid()) + bits.pop_l1a_match_win = CSCConstants::LCT_CENTRAL_BX - digi.getBX(); + else if (not(digi.isValid())) + bits.pop_l1a_match_win = 3;//default value } void CSCTMBHeader2020_GEM::addCathodeShower(const CSCShowerDigi& digi) { uint16_t hmt_bits = digi.bitsInTime() & 0x3; + if (not digi.isValid()) hmt_bits = 0; bits.cathode_hmt = hmt_bits; + bits.hmt_nhits_bit0 = digi.getComparatorNHits() & 0x1; + bits.hmt_nhits_bit1 = (digi.getComparatorNHits() >> 1) & 0x1; + bits.hmt_nhits_bits_high = (digi.getComparatorNHits() >> 2) & 0x1F; + if (bits.MPC_Muon_HMT_bit0 or bits.MPC_Muon_HMT_high or bits.anode_hmt){ + //pop_l1a_match_win is assigned + bits.hmt_match_win = CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win + 3 - digi.getBX(); + }else if (digi.isValid()){ + bits.pop_l1a_match_win = 3;//default value + bits.hmt_match_win = CSCConstants::LCT_CENTRAL_BX - digi.getBX(); + }else { + bits.pop_l1a_match_win = 3;//default value + bits.hmt_match_win = 0; //no HMT case + } } void CSCTMBHeader2020_GEM::print(std::ostream& os) const { @@ -303,6 +338,8 @@ void CSCTMBHeader2020_GEM::print(std::ostream& os) const { << ", activeCFEBs = 0x" << std::hex << (bits.activeCFEBs | (bits.activeCFEBs_2 << 5)) << ", readCFEBs = 0x" << std::hex << (bits.readCFEBs | (bits.readCFEBs_2 << 5)) << std::dec << "\n"; os << "bxnPreTrigger = " << bits.bxnPreTrigger << "\n"; + os << "ALCT location in CLCt window "<< bits.matchWin << " L1A location in TMB window "<< bits.pop_l1a_match_win + << " ALCT in cathde HMT window "<< bits.hmt_match_win << "\n"; os << "tmbMatch = " << bits.tmbMatch << " alctOnly = " << bits.alctOnly << " clctOnly = " << bits.clctOnly << "\n"; os << "readoutCounter: " << std::dec << bits.readoutCounter << ", buf_q_ovf: " << bits.stackOvf @@ -347,7 +384,7 @@ void CSCTMBHeader2020_GEM::print(std::ostream& os) const { os << " clct_5bit_pattern_id = " << (bits.MPC_Muon_clct_pattern_low | (bits.MPC_Muon_clct_pattern_bit5 << 4)) << " HMT = " << (bits.MPC_Muon_HMT_bit0 | (bits.MPC_Muon_HMT_high << 1)) << ", alctHMT = " << bits.anode_hmt - << ", clctHMT = " << bits.cathode_hmt << "\n"; + << ", clctHMT = " << bits.cathode_hmt << " cathode nhits "<< hmt_nhits() <<"\n"; // os << "..................CLCT....................." << "\n"; os << "GEM Data:\n" diff --git a/EventFilter/CSCRawToDigi/src/CSCTMBHeader2020_TMB.cc b/EventFilter/CSCRawToDigi/src/CSCTMBHeader2020_TMB.cc index 3d51c5b76959b..5ae3f6f5ecf57 100644 --- a/EventFilter/CSCRawToDigi/src/CSCTMBHeader2020_TMB.cc +++ b/EventFilter/CSCRawToDigi/src/CSCTMBHeader2020_TMB.cc @@ -131,20 +131,30 @@ std::vector CSCTMBHeader2020_TMB::CorrelatedLCTDigis(uint3 CSCShowerDigi CSCTMBHeader2020_TMB::showerDigi(uint32_t idlayer) const { unsigned hmt_bits = bits.MPC_Muon_HMT_bit0 | (bits.MPC_Muon_HMT_high << 1); // HighMultiplicityTrigger bits - uint16_t cscid = 0; // ??? What is 4-bits CSC Id in CSshowerDigi - CSCShowerDigi result(hmt_bits & 0x3, (hmt_bits >> 2) & 0x3, cscid); // 2-bits intime, 2-bits out of time + uint16_t cscid = bits.cscID; // ??? What is 4-bits CSC Id in CSshowerDigi + //L1A_TMB_WINDOW is not included in below formula + //correct version: CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win + L1A_TMB_WINDOW/2; + // same for anode HMT and cathode HMT + uint16_t bx = CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win; + //LCTshower with showerType = 3. wireNHits is not avaiable + //TMB LCT shower is copied from ALCT shower + CSCShowerDigi result(hmt_bits & 0x3, (hmt_bits >> 2) & 0x3, cscid, bx, 3, 0, 0); // 2-bits intime, 2-bits out of time return result; } CSCShowerDigi CSCTMBHeader2020_TMB::anodeShowerDigi(uint32_t idlayer) const { - uint16_t cscid = 0; - CSCShowerDigi result(bits.anode_hmt & 0x3, 0, cscid); // 2-bits intime, no out of time + uint16_t cscid = bits.cscID; + uint16_t bx = CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win; + //ALCTshower with showerType = 1. wireNHits is not avaiable + CSCShowerDigi result(bits.anode_hmt & 0x3, 0, cscid, bx, 1, 0, 0); // 2-bits intime, no out of time return result; } CSCShowerDigi CSCTMBHeader2020_TMB::cathodeShowerDigi(uint32_t idlayer) const { - uint16_t cscid = 0; - CSCShowerDigi result(bits.cathode_hmt & 0x3, 0, cscid); // 2-bits intime, no out of time + uint16_t cscid = bits.cscID; + uint16_t bx = CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win; + //CLCTshower with showerType = 2. comparatorNhits is not avaiable for TMB yet + CSCShowerDigi result(bits.cathode_hmt & 0x3, 0, cscid, bx, 2, 0, 0); // 2-bits intime, no out of time return result; } @@ -256,13 +266,24 @@ void CSCTMBHeader2020_TMB::addCorrelatedLCT1(const CSCCorrelatedLCTDigi& digi) { void CSCTMBHeader2020_TMB::addShower(const CSCShowerDigi& digi) { uint16_t hmt_bits = (digi.bitsInTime() & 0x3) + ((digi.bitsOutOfTime() & 0x3) << 2); + //not valid LCT shower, then in-time bits must be 0 + if (not digi.isValid()) hmt_bits = ((digi.bitsOutOfTime() & 0x3) << 2); bits.MPC_Muon_HMT_bit0 = hmt_bits & 0x1; bits.MPC_Muon_HMT_high = (hmt_bits >> 1) & 0x7; + if (digi.isValid()) + bits.pop_l1a_match_win = CSCConstants::LCT_CENTRAL_BX - digi.getBX(); + else + bits.pop_l1a_match_win = 3;//default value } void CSCTMBHeader2020_TMB::addAnodeShower(const CSCShowerDigi& digi) { uint16_t hmt_bits = digi.bitsInTime() & 0x3; + if (not digi.isValid()) hmt_bits = 0; bits.anode_hmt = hmt_bits; + if (digi.isValid()) + bits.pop_l1a_match_win = CSCConstants::LCT_CENTRAL_BX - digi.getBX(); + else + bits.pop_l1a_match_win = 3;//default value } void CSCTMBHeader2020_TMB::addCathodeShower(const CSCShowerDigi& digi) { @@ -285,6 +306,7 @@ void CSCTMBHeader2020_TMB::print(std::ostream& os) const { << (bits.activeCFEBs | (bits.activeCFEBs_2 << 5)) << ", readCFEBs = 0x" << std::hex << (bits.readCFEBs | (bits.readCFEBs_2 << 5)) << std::dec << "\n"; os << "bxnPreTrigger = " << bits.bxnPreTrigger << "\n"; + os << "ALCT location in CLCt window "<< bits.matchWin << " L1A location in TMB window "<< bits.pop_l1a_match_win << "\n"; os << "tmbMatch = " << bits.tmbMatch << " alctOnly = " << bits.alctOnly << " clctOnly = " << bits.clctOnly << "\n"; os << "CLCT Words:\n" diff --git a/L1Trigger/CSCTriggerPrimitives/interface/CSCAnodeLCTProcessor.h b/L1Trigger/CSCTriggerPrimitives/interface/CSCAnodeLCTProcessor.h index aa1f26807b8fd..f29dd0e06f123 100644 --- a/L1Trigger/CSCTriggerPrimitives/interface/CSCAnodeLCTProcessor.h +++ b/L1Trigger/CSCTriggerPrimitives/interface/CSCAnodeLCTProcessor.h @@ -87,12 +87,11 @@ class CSCAnodeLCTProcessor : public CSCBaseboard { CSCALCTDigi getBestALCT(int bx) const; CSCALCTDigi getSecondALCT(int bx) const; - /* get special bits for high multiplicity triggers */ - unsigned getInTimeHMT() const { return inTimeHMT_; } - unsigned getOutTimeHMT() const { return outTimeHMT_; } + /* get array of high multiplicity triggers */ + std::vector getAllShower() const; /** Returns shower bits */ - CSCShowerDigi readoutShower() const; + std::vector readoutShower() const; protected: /** Best LCTs in this chamber, as found by the processor. @@ -107,7 +106,7 @@ class CSCAnodeLCTProcessor : public CSCBaseboard { PulseArray pulse_; - CSCShowerDigi shower_; + CSCShowerDigi anode_showers_[CSCConstants::MAX_ALCT_TBINS]; /** Access routines to wire digis. */ bool getDigis(const CSCWireDigiCollection* wiredc); @@ -127,15 +126,9 @@ class CSCAnodeLCTProcessor : public CSCBaseboard { std::vector thePreTriggerDigis; /* data members for high multiplicity triggers */ - void encodeHighMultiplicityBits( - const std::vector wire[CSCConstants::NUM_LAYERS][CSCConstants::MAX_NUM_WIREGROUPS]); - unsigned inTimeHMT_; - unsigned outTimeHMT_; + void encodeHighMultiplicityBits(); std::vector thresholds_; - unsigned showerMinInTBin_; - unsigned showerMaxInTBin_; - unsigned showerMinOutTBin_; - unsigned showerMaxOutTBin_; + unsigned showerNumTBins_; unsigned minLayersCentralTBin_; /** Configuration parameters. */ diff --git a/L1Trigger/CSCTriggerPrimitives/interface/CSCCathodeLCTProcessor.h b/L1Trigger/CSCTriggerPrimitives/interface/CSCCathodeLCTProcessor.h index d1ab3c2d209c1..722c006e9f11a 100644 --- a/L1Trigger/CSCTriggerPrimitives/interface/CSCCathodeLCTProcessor.h +++ b/L1Trigger/CSCTriggerPrimitives/interface/CSCCathodeLCTProcessor.h @@ -87,11 +87,13 @@ class CSCCathodeLCTProcessor : public CSCBaseboard { std::vector preTriggerDigis() const { return thePreTriggerDigis; } /* get special bits for high multiplicity triggers */ - unsigned getInTimeHMT() const { return inTimeHMT_; } - unsigned getOutTimeHMT() const { return outTimeHMT_; } + //unsigned getInTimeHMT() const { return inTimeHMT_; } + //unsigned getOutTimeHMT() const { return outTimeHMT_; } + /* get array of high multiplicity triggers */ + std::vector getAllShower() const; /** Returns shower bits */ - CSCShowerDigi readoutShower() const; + std::vector readoutShower() const; protected: /** Best LCT in this chamber, as found by the processor. */ @@ -100,7 +102,8 @@ class CSCCathodeLCTProcessor : public CSCBaseboard { /** Second best LCT in this chamber, as found by the processor. */ CSCCLCTDigi secondCLCT[CSCConstants::MAX_CLCT_TBINS]; - CSCShowerDigi shower_; + CSCShowerDigi cathode_showers_[CSCConstants::MAX_CLCT_TBINS]; + //CSCShowerDigi shower_; /** Access routines to comparator digis. */ bool getDigis(const CSCComparatorDigiCollection* compdc); @@ -188,16 +191,12 @@ class CSCCathodeLCTProcessor : public CSCBaseboard { std::vector thePreTriggerDigis; /* data members for high multiplicity triggers */ - void encodeHighMultiplicityBits( - const std::vector halfstrip[CSCConstants::NUM_LAYERS][CSCConstants::MAX_NUM_HALF_STRIPS_RUN2_TRIGGER]); - unsigned inTimeHMT_; - unsigned outTimeHMT_; + void encodeHighMultiplicityBits(); std::vector thresholds_; - unsigned showerMinInTBin_; - unsigned showerMaxInTBin_; - unsigned showerMinOutTBin_; - unsigned showerMaxOutTBin_; + unsigned showerNumTBins_; unsigned minLayersCentralTBin_; + /** check the peak of total hits and single bx hits for cathode HMT */ + bool peakCheck_; /** Configuration parameters. */ unsigned int fifo_tbins, fifo_pretrig; // only for test beam mode. diff --git a/L1Trigger/CSCTriggerPrimitives/interface/CSCMotherboard.h b/L1Trigger/CSCTriggerPrimitives/interface/CSCMotherboard.h index 967023a75fabe..afc8bcf33c33c 100644 --- a/L1Trigger/CSCTriggerPrimitives/interface/CSCMotherboard.h +++ b/L1Trigger/CSCTriggerPrimitives/interface/CSCMotherboard.h @@ -88,7 +88,7 @@ class CSCMotherboard : public CSCBaseboard { void selectLCTs(); /** Returns shower bits */ - CSCShowerDigi readoutShower() const; + std::vector readoutShower() const; /** Clears correlated LCT and passes clear signal on to cathode and anode LCT processors. */ @@ -123,7 +123,7 @@ class CSCMotherboard : public CSCBaseboard { /* Container with sorted and selected LCTs */ std::vector lctV; - CSCShowerDigi shower_; + CSCShowerDigi showers_[CSCConstants::MAX_LCT_TBINS]; // helper function to return ALCT/CLCT with correct central BX CSCALCTDigi getBXShiftedALCT(const CSCALCTDigi&) const; @@ -147,7 +147,8 @@ class CSCMotherboard : public CSCBaseboard { bool match_earliest_clct_only_; // encode special bits for high-multiplicity triggers - unsigned showerSource_; + std::vector showerSource_; + unsigned thisShowerSource_; bool ignoreAlctCrossClct_; @@ -232,7 +233,11 @@ class CSCMotherboard : public CSCBaseboard { /** Dump TMB/MPC configuration parameters. */ void dumpConfigParams() const; + /* match cathode shower and anode shower with and/or logic */ + void matchShowers(CSCShowerDigi * anode_showers, CSCShowerDigi * cathode_showers, bool andlogic); + /* encode high multiplicity bits for Run-3 exotic triggers */ void encodeHighMultiplicityBits(); + }; #endif diff --git a/L1Trigger/CSCTriggerPrimitives/interface/CSCTriggerPrimitivesBuilder.h b/L1Trigger/CSCTriggerPrimitives/interface/CSCTriggerPrimitivesBuilder.h index 31432c848b4d1..9add27b0c7c63 100644 --- a/L1Trigger/CSCTriggerPrimitives/interface/CSCTriggerPrimitivesBuilder.h +++ b/L1Trigger/CSCTriggerPrimitives/interface/CSCTriggerPrimitivesBuilder.h @@ -132,6 +132,9 @@ class CSCTriggerPrimitivesBuilder { /** Phase2: special switch for the upgrade ME2/1 TMB */ bool runME21ILT_; + /** Selected chambers to run */ + std::vector selectedChambers_; + /** Pointers to TMB processors for all possible chambers. */ std::unique_ptr tmb_[MAX_ENDCAPS][MAX_STATIONS][MAX_SECTORS][MAX_SUBSECTORS][MAX_CHAMBERS]; diff --git a/L1Trigger/CSCTriggerPrimitives/python/cscTriggerPrimitiveDigis_cfi.py b/L1Trigger/CSCTriggerPrimitives/python/cscTriggerPrimitiveDigis_cfi.py index 44e5948595c22..db0ac182ecad8 100644 --- a/L1Trigger/CSCTriggerPrimitives/python/cscTriggerPrimitiveDigis_cfi.py +++ b/L1Trigger/CSCTriggerPrimitives/python/cscTriggerPrimitiveDigis_cfi.py @@ -34,6 +34,8 @@ # If True, output collections will only be built for good chambers checkBadChambers = cms.bool(True), + #selected chamebrs to process + selectedChambers = cms.vstring(""), # Anode-DAQ rate determined by pre-CLCTs keepCLCTPreTriggers = cms.bool(True), diff --git a/L1Trigger/CSCTriggerPrimitives/python/params/showerParams.py b/L1Trigger/CSCTriggerPrimitives/python/params/showerParams.py index b7fa3ec6a8885..cf3b766462780 100644 --- a/L1Trigger/CSCTriggerPrimitives/python/params/showerParams.py +++ b/L1Trigger/CSCTriggerPrimitives/python/params/showerParams.py @@ -13,7 +13,26 @@ ## loose -> 'loose anode and loose cathode' ## nominal -> 'nominal anode and nominal cathode' ## tight -> 'tight anode and tight cathode' - source = cms.uint32(3), + source = cms.vuint32( + # ME1/1 + 3, + # ME1/2 + 1, + # ME1/3 + 1, + # ME2/1 + 3, + # ME2/2 + 1, + # ME3/1 + 3, + # ME3/2 + 1, + # ME4/1 + 3, + # ME4/2 + 1 + ), ## settings for cathode showers (counting CSCComparatorDigi) cathodeShower = cms.PSet( @@ -21,31 +40,32 @@ ## loose ~ 0.75 kHz ## nominal ~ 0.5 kHz ## tight ~ 0.25 kHz + ## 10000 means to disable cathode HMT for this chamber type showerThresholds = cms.vuint32( # ME1/1 100, 100, 100, # ME1/2 - 0, 0, 0, + 10000, 10000, 10000, # ME1/3 - 0, 0, 0, + 10000, 10000, 10000, # ME2/1 17, 33, 35, # ME2/2 - 0, 0, 0, + 10000, 10000, 10000, # ME3/1 15, 31, 33, # ME3/2 - 0, 0, 0, + 10000, 10000, 10000, # ME4/1 17, 34, 36, # ME4/2 - 0, 0, 0 + 10000, 10000, 10000 ), - showerMinInTBin = cms.uint32(6), - showerMaxInTBin = cms.uint32(8), - showerMinOutTBin = cms.uint32(2), - showerMaxOutTBin = cms.uint32(5), + showerNumTBins = cms.uint32(3),# 3BX for cathode HMT minLayersCentralTBin = cms.uint32(5), + ## peack check feature is not implemented in firmware + ## plan to upgrade in future + peakCheck = cms.bool(False), ), ## settings for anode showers (counting CSCWireDigi) anodeShower = cms.PSet( @@ -70,10 +90,7 @@ # ME4/2 13, 27, 31 ), - showerMinInTBin = cms.uint32(8), - showerMaxInTBin = cms.uint32(8), - showerMinOutTBin = cms.uint32(4), - showerMaxOutTBin = cms.uint32(7), + showerNumTBins = cms.uint32(1),# 1BX for anode HMT minLayersCentralTBin = cms.uint32(5), ) ) diff --git a/L1Trigger/CSCTriggerPrimitives/src/CSCAnodeLCTProcessor.cc b/L1Trigger/CSCTriggerPrimitives/src/CSCAnodeLCTProcessor.cc index 05166b8607aa9..2aed3f8223aeb 100644 --- a/L1Trigger/CSCTriggerPrimitives/src/CSCAnodeLCTProcessor.cc +++ b/L1Trigger/CSCTriggerPrimitives/src/CSCAnodeLCTProcessor.cc @@ -84,10 +84,11 @@ CSCAnodeLCTProcessor::CSCAnodeLCTProcessor(unsigned endcap, const auto& shower = showerParams_.getParameterSet("anodeShower"); thresholds_ = shower.getParameter>("showerThresholds"); - showerMinInTBin_ = shower.getParameter("showerMinInTBin"); - showerMaxInTBin_ = shower.getParameter("showerMaxInTBin"); - showerMinOutTBin_ = shower.getParameter("showerMinOutTBin"); - showerMaxOutTBin_ = shower.getParameter("showerMaxOutTBin"); + showerNumTBins_ = shower.getParameter("showerNumTBins"); + //showerMinInTBin_ = shower.getParameter("showerMinInTBin"); + //showerMaxInTBin_ = shower.getParameter("showerMaxInTBin"); + //showerMinOutTBin_ = shower.getParameter("showerMinOutTBin"); + //showerMaxOutTBin_ = shower.getParameter("showerMaxOutTBin"); minLayersCentralTBin_ = shower.getParameter("minLayersCentralTBin"); } @@ -177,9 +178,9 @@ void CSCAnodeLCTProcessor::clear() { for (int bx = 0; bx < CSCConstants::MAX_ALCT_TBINS; bx++) { bestALCT[bx].clear(); secondALCT[bx].clear(); + anode_showers_[bx].clear();//? } lct_list.clear(); - inTimeHMT_ = 0; } void CSCAnodeLCTProcessor::clear(const int wire, const int pattern) { @@ -259,7 +260,7 @@ std::vector CSCAnodeLCTProcessor::run(const CSCWireDigiCollection* if (layersHit >= min_layers) run(wireGroupTimes); // Get the high multiplicity bits in this chamber - encodeHighMultiplicityBits(wireGroupTimes); + encodeHighMultiplicityBits(); } // Return vector of all found ALCTs. @@ -1276,8 +1277,31 @@ CSCALCTDigi CSCAnodeLCTProcessor::getBestALCT(int bx) const { return bestALCT[bx CSCALCTDigi CSCAnodeLCTProcessor::getSecondALCT(int bx) const { return secondALCT[bx]; } +/** return vector of CSCShower digi **/ +std::vector CSCAnodeLCTProcessor::getAllShower() const { + std::vector vshowers(anode_showers_, anode_showers_ + CSCConstants::MAX_ALCT_TBINS); + return vshowers; +}; + /** Returns shower bits */ -CSCShowerDigi CSCAnodeLCTProcessor::readoutShower() const { return shower_; } +std::vector CSCAnodeLCTProcessor::readoutShower() const { + unsigned minbx_readout = CSCConstants::LCT_CENTRAL_BX - l1a_window_width/2; + unsigned maxbx_readout = CSCConstants::LCT_CENTRAL_BX + l1a_window_width/2; + unsigned minBXdiff = 2*l1a_window_width;//impossible value + unsigned minBX = 0; + std::vector showerOut; + for (unsigned bx = minbx_readout; bx < maxbx_readout; bx++){ + unsigned bx_diff = (bx > bx-CSCConstants::LCT_CENTRAL_BX ) ? bx-CSCConstants::LCT_CENTRAL_BX : CSCConstants::LCT_CENTRAL_BX-bx; + if (anode_showers_[bx].isValid() and bx_diff < minBXdiff){ + minBXdiff = bx_diff; + minBX = bx; + } + } + + for (unsigned bx = minbx_readout; bx < maxbx_readout; bx++) + if (bx == minBX) showerOut.push_back(anode_showers_[bx]); + return showerOut; +} //////////////////////////////////////////////////////////////////////// ////////////////////////////Test Routines/////////////////////////////// @@ -1336,50 +1360,30 @@ void CSCAnodeLCTProcessor::setWireContainer(CSCALCTDigi& alct, CSCALCTDigi::Wire alct.setHits(wireHits); } -void CSCAnodeLCTProcessor::encodeHighMultiplicityBits( - const std::vector wires[CSCConstants::NUM_LAYERS][CSCConstants::MAX_NUM_WIREGROUPS]) { - inTimeHMT_ = 0; - - auto layerTime = [=](unsigned time) { return time == CSCConstants::LCT_CENTRAL_BX; }; +void CSCAnodeLCTProcessor::encodeHighMultiplicityBits(){ + //numer of layer with hits and number of hits for 0-15 BXs + std::set layersWithHits [CSCConstants::MAX_ALCT_TBINS]; + unsigned hitsInTime [CSCConstants::MAX_ALCT_TBINS]; // Calculate layers with hits - unsigned nLayersWithHits = 0; - for (int i_layer = 0; i_layer < CSCConstants::NUM_LAYERS; i_layer++) { - bool atLeastOneWGHit = false; - for (int i_wire = 0; i_wire < CSCConstants::MAX_NUM_WIREGROUPS; i_wire++) { - // there is at least one wiregroup... - if (!wires[i_layer][i_wire].empty()) { - auto times = wires[i_layer][i_wire]; - int nLayerTime = std::count_if(times.begin(), times.end(), layerTime); - // ...for which at least one time bin was on for the central BX - if (nLayerTime > 0) { - atLeastOneWGHit = true; - break; + for (unsigned bx = 0; bx < CSCConstants::MAX_ALCT_TBINS; bx++){ + hitsInTime[bx] = 0; + for (unsigned i_layer = 0; i_layer < CSCConstants::NUM_LAYERS; i_layer++) { + bool atLeastOneWGHit = false; + for (const auto& wd : digiV[i_layer]) { + std::vector bx_times = wd.getTimeBinsOn(); + // there is at least one wiregroup in this bx + if (std::find(bx_times.begin(), bx_times.end(), bx) != bx_times.end()){ + hitsInTime[bx] += 1; + atLeastOneWGHit = true; } } - } // add this layer to the number of layers hit - if (atLeastOneWGHit) { - nLayersWithHits++; - } - } - - // require at least nLayersWithHits for the central time bin - // do nothing if there are not enough layers with hits - if (nLayersWithHits < minLayersCentralTBin_) - return; - - // functions for in-time and out-of-time - auto inTime = [=](unsigned time) { return time >= showerMinInTBin_ and time <= showerMaxInTBin_; }; - - // count the wires in-time and out-time - unsigned hitsInTime = 0; - for (int i_layer = 0; i_layer < CSCConstants::NUM_LAYERS; i_layer++) { - for (int i_wire = 0; i_wire < CSCConstants::MAX_NUM_WIREGROUPS; i_wire++) { - auto times = wires[i_layer][i_wire]; - hitsInTime += std::count_if(times.begin(), times.end(), inTime); + if (atLeastOneWGHit) { + layersWithHits[bx].insert(i_layer); + } } - } + }//end of full bx loop // convert station and ring number to index // index runs from 2 to 10, subtract 2 @@ -1389,13 +1393,26 @@ void CSCAnodeLCTProcessor::encodeHighMultiplicityBits( std::vector station_thresholds = { thresholds_[csc_idx * 3], thresholds_[csc_idx * 3 + 1], thresholds_[csc_idx * 3 + 2]}; - // assign the bits - for (unsigned i = 0; i < station_thresholds.size(); i++) { - if (hitsInTime >= station_thresholds[i]) { - inTimeHMT_ = i + 1; + for (unsigned bx = 0; bx < CSCConstants::MAX_ALCT_TBINS; bx++){ + unsigned minbx = bx >= showerNumTBins_/2 ? bx-showerNumTBins_/2 : bx; + unsigned maxbx = bx < CSCConstants::MAX_ALCT_TBINS - showerNumTBins_/2 ? bx+showerNumTBins_/2 : CSCConstants::MAX_ALCT_TBINS - 1; + unsigned this_hitsInTime = 0; + for (unsigned mbx = minbx; mbx <= maxbx; mbx++){ + this_hitsInTime += hitsInTime[mbx]; } - } - // create a new object - shower_ = CSCShowerDigi(inTimeHMT_, false, theTrigChamber); + unsigned this_inTimeHMT = 0; + // require at least nLayersWithHits for the central time bin + // do nothing if there are not enough layers with hits + if (layersWithHits[bx].size() >= minLayersCentralTBin_){ + // assign the bits + for (unsigned i = 0; i < station_thresholds.size(); i++) { + if (this_hitsInTime >= station_thresholds[i]) { + this_inTimeHMT = i + 1; + } + } + } + //ALCT shower construction with showerType_=1, comparatorhits_= 0; + anode_showers_[bx] = CSCShowerDigi(this_inTimeHMT, false, theTrigChamber, bx, 1, this_hitsInTime, 0); + } } diff --git a/L1Trigger/CSCTriggerPrimitives/src/CSCCathodeLCTProcessor.cc b/L1Trigger/CSCTriggerPrimitives/src/CSCCathodeLCTProcessor.cc index 3bf4626b1afb1..102e4d5995e48 100644 --- a/L1Trigger/CSCTriggerPrimitives/src/CSCCathodeLCTProcessor.cc +++ b/L1Trigger/CSCTriggerPrimitives/src/CSCCathodeLCTProcessor.cc @@ -95,11 +95,9 @@ CSCCathodeLCTProcessor::CSCCathodeLCTProcessor(unsigned endcap, const auto& shower = showerParams_.getParameterSet("cathodeShower"); thresholds_ = shower.getParameter>("showerThresholds"); - showerMinInTBin_ = shower.getParameter("showerMinInTBin"); - showerMaxInTBin_ = shower.getParameter("showerMaxInTBin"); - showerMinOutTBin_ = shower.getParameter("showerMinOutTBin"); - showerMaxOutTBin_ = shower.getParameter("showerMaxOutTBin"); + showerNumTBins_ = shower.getParameter("showerNumTBins"); minLayersCentralTBin_ = shower.getParameter("minLayersCentralTBin"); + peakCheck_ = shower.getParameter("peakCheck"); thePreTriggerDigis.clear(); // quality control of stubs @@ -178,8 +176,8 @@ void CSCCathodeLCTProcessor::clear() { for (int bx = 0; bx < CSCConstants::MAX_CLCT_TBINS; bx++) { bestCLCT[bx].clear(); secondCLCT[bx].clear(); + cathode_showers_[bx].clear(); } - inTimeHMT_ = 0; } std::vector CSCCathodeLCTProcessor::run(const CSCComparatorDigiCollection* compdc) { @@ -300,7 +298,7 @@ std::vector CSCCathodeLCTProcessor::run(const CSCComparatorDigiColl run(halfStripTimes); // Get the high multiplicity bits in this chamber - encodeHighMultiplicityBits(halfStripTimes); + encodeHighMultiplicityBits(); } // Return vector of CLCTs. @@ -1201,52 +1199,47 @@ CSCCLCTDigi CSCCathodeLCTProcessor::getSecondCLCT(int bx) const { return lct; } +/** return vector of CSCShower digi **/ +std::vector CSCCathodeLCTProcessor::getAllShower() const { + std::vector vshowers(cathode_showers_, cathode_showers_ + CSCConstants::MAX_CLCT_TBINS); + return vshowers; +}; + /** Returns shower bits */ -CSCShowerDigi CSCCathodeLCTProcessor::readoutShower() const { return shower_; } +std::vector CSCCathodeLCTProcessor::readoutShower() const { + unsigned minbx_readout = CSCConstants::LCT_CENTRAL_BX - tmb_l1a_window_size/2; + unsigned maxbx_readout = CSCConstants::LCT_CENTRAL_BX + tmb_l1a_window_size/2; + std::vector showerOut; + for (unsigned bx = minbx_readout; bx < maxbx_readout; bx++) + if (cathode_showers_[bx].isValid()) showerOut.push_back(cathode_showers_[bx]); + return showerOut; +} -void CSCCathodeLCTProcessor::encodeHighMultiplicityBits( - const std::vector halfstrip[CSCConstants::NUM_LAYERS][CSCConstants::MAX_NUM_HALF_STRIPS_RUN2_TRIGGER]) { - inTimeHMT_ = 0; +void CSCCathodeLCTProcessor::encodeHighMultiplicityBits(){ + //inTimeHMT_ = 0; - auto layerTime = [=](unsigned time) { return time == CSCConstants::CLCT_CENTRAL_BX; }; + //numer of layer with hits and number of hits for 0-15 BXs + std::set layersWithHits [CSCConstants::MAX_CLCT_TBINS]; + unsigned hitsInTime [CSCConstants::MAX_CLCT_TBINS]; // Calculate layers with hits - unsigned nLayersWithHits = 0; - for (int i_layer = 0; i_layer < CSCConstants::NUM_LAYERS; i_layer++) { - bool atLeastOneWGHit = false; - for (int i_hstrip = 0; i_hstrip < CSCConstants::MAX_NUM_HALF_STRIPS_RUN2_TRIGGER; i_hstrip++) { - // there is at least one halfstrip... - if (!halfstrip[i_layer][i_hstrip].empty()) { - auto times = halfstrip[i_layer][i_hstrip]; - int nLayerTime = std::count_if(times.begin(), times.end(), layerTime); - // ...for which at least one time bin was on for the central BX - if (nLayerTime > 0) { - atLeastOneWGHit = true; - break; + for (unsigned bx = 0; bx < CSCConstants::MAX_CLCT_TBINS; bx++){ + hitsInTime[bx] = 0; + for (unsigned i_layer = 0; i_layer < CSCConstants::NUM_LAYERS; i_layer++) { + bool atLeastOneCompHit = false; + for (const auto& compdigi : digiV[i_layer]) { + std::vector bx_times = compdigi.getTimeBinsOn(); + // there is at least one comparator digi in this bx + if (std::find(bx_times.begin(), bx_times.end(), bx) != bx_times.end()){ + hitsInTime[bx] += 1; + atLeastOneCompHit = true; } } - } // add this layer to the number of layers hit - if (atLeastOneWGHit) { - nLayersWithHits++; - } - } - - // require at least nLayersWithHits for the central time bin - // do nothing if there are not enough layers with hits - if (nLayersWithHits < minLayersCentralTBin_) - return; - - // functions for in-time and out-of-time - auto inTime = [=](unsigned time) { return time >= showerMinInTBin_ and time <= showerMaxInTBin_; }; - - // count the half-strips in-time and out-time - unsigned hitsInTime = 0; - for (int i_layer = 0; i_layer < CSCConstants::NUM_LAYERS; i_layer++) { - for (int i_hstrip = 0; i_hstrip < CSCConstants::MAX_NUM_HALF_STRIPS_RUN2_TRIGGER; i_hstrip++) { - auto times = halfstrip[i_layer][i_hstrip]; - hitsInTime += std::count_if(times.begin(), times.end(), inTime); + if (atLeastOneCompHit) { + layersWithHits[bx].insert(i_layer); + } } - } + }//end of full bx loop // convert station and ring number to index // index runs from 2 to 10, subtract 2 @@ -1256,13 +1249,48 @@ void CSCCathodeLCTProcessor::encodeHighMultiplicityBits( std::vector station_thresholds = { thresholds_[csc_idx * 3], thresholds_[csc_idx * 3 + 1], thresholds_[csc_idx * 3 + 2]}; - // assign the bits - for (unsigned i = 0; i < station_thresholds.size(); i++) { - if (hitsInTime >= station_thresholds[i]) { - inTimeHMT_ = i + 1; + //hard coded dead time as 2Bx, since showerNumTBins = 3, like firmware + // for example, nhits = 0 at bx7; = 100 at bx8; = 0 at bx9 + //cathode HMT must be triggered at bx8, not bx7 and bx9 + //meanwhile we forced 2BX dead time after active shower trigger + unsigned int deadtime = showerNumTBins_-1;// firmware hard coded dead time as 2Bx, since showerNumTBins = 3 in firmware + unsigned int dead_count = 0; + bool dead_status = false; + + for (unsigned bx = 0; bx < CSCConstants::MAX_CLCT_TBINS; bx++){ + unsigned minbx = bx >= showerNumTBins_/2 ? bx-showerNumTBins_/2 : bx; + unsigned maxbx = bx < CSCConstants::MAX_CLCT_TBINS - showerNumTBins_/2 ? bx+showerNumTBins_/2 : CSCConstants::MAX_CLCT_TBINS - 1; + unsigned this_hitsInTime = 0; + bool isPeak = true;//check whether total hits in bx is peak of nhits over time bins + /*following is to count number of hits over [minbx, maxbx], showerNumTBins=3 =>[n-1, n+1]*/ + for (unsigned mbx = minbx; mbx <= maxbx; mbx++){ + this_hitsInTime += hitsInTime[mbx]; + } + + if (peakCheck_ and bx < CSCConstants::MAX_CLCT_TBINS - showerNumTBins_/2 - 1){ + if (hitsInTime[minbx] < hitsInTime[maxbx+1] or (hitsInTime[minbx] == hitsInTime[maxbx+1] and hitsInTime[bx] < hitsInTime[bx+1])) + isPeak = false; //next bx would have more hits or in the center + } + if (dead_count > 0){ + dead_count--; + dead_status = true; + }else + dead_status = false; + + unsigned this_inTimeHMT = 0; + // require at least nLayersWithHits for the central time bin + // do nothing if there are not enough layers with hits + if (layersWithHits[bx].size() >= minLayersCentralTBin_ and !dead_status and isPeak){ + // assign the bits + for (unsigned i = 0; i < station_thresholds.size(); i++) { + if (this_hitsInTime >= station_thresholds[i]) { + this_inTimeHMT = i + 1; + dead_count = deadtime; + } + } } + //CLCTshower constructor with showerType_ = 2, wirehits = 0; + cathode_showers_[bx] = CSCShowerDigi(this_inTimeHMT, false, theTrigChamber, bx, 2, 0, this_hitsInTime); } - // create a new object - shower_ = CSCShowerDigi(inTimeHMT_, false, theTrigChamber); } diff --git a/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboard.cc b/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboard.cc index 7ca47cdf64a68..8bd8cfd5be3f9 100644 --- a/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboard.cc +++ b/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboard.cc @@ -64,7 +64,10 @@ CSCMotherboard::CSCMotherboard(unsigned endcap, qualityControl_ = std::make_unique(endcap, station, sector, subsector, chamber, conf); // shower-trigger source - showerSource_ = showerParams_.getParameter("source"); + showerSource_ = showerParams_.getParameter>("source"); + + unsigned csc_idx = CSCDetId::iChamberType(theStation, theRing) - 2; + thisShowerSource_ = showerSource_[csc_idx]; // enable the upgrade processors for ring 1 stations if (runPhase2_ and theRing == 1) { @@ -95,8 +98,9 @@ void CSCMotherboard::clear() { allLCTs_.clear(); - // reset the shower trigger - shower_.clear(); + for (int bx = 0; bx < CSCConstants::MAX_LCT_TBINS; bx++) { + showers_[bx].clear(); + } } // Set configuration parameters obtained via EventSetup mechanism. @@ -190,9 +194,9 @@ void CSCMotherboard::matchALCTCLCT() { // loop on the preferred "delta BX" array for (unsigned mbx = 0; mbx < match_trig_window_size; mbx++) { // evaluate the preffered CLCT BX, taking into account that there is an offset in the simulation - unsigned bx_clct = bx_alct + preferred_bx_match_[mbx] - CSCConstants::ALCT_CLCT_OFFSET; + int bx_clct = bx_alct + preferred_bx_match_[mbx] - CSCConstants::ALCT_CLCT_OFFSET; // check that the CLCT BX is valid - if (bx_clct >= CSCConstants::MAX_CLCT_TBINS) + if (bx_clct >= CSCConstants::MAX_CLCT_TBINS or bx_clct < 0) continue; // do not consider previously matched CLCTs if (drop_used_clcts && used_clct_mask[bx_clct]) @@ -365,7 +369,24 @@ std::vector CSCMotherboard::readoutLCTs() const { return tmpV; } -CSCShowerDigi CSCMotherboard::readoutShower() const { return shower_; } +std::vector CSCMotherboard::readoutShower() const { + unsigned minbx_readout = CSCConstants::LCT_CENTRAL_BX - tmb_l1a_window_size/2; + unsigned maxbx_readout = CSCConstants::LCT_CENTRAL_BX + tmb_l1a_window_size/2; + unsigned minBXdiff = 2*tmb_l1a_window_size;//impossible value + unsigned minBX = 0; + std::vector showerOut; + for (unsigned bx = minbx_readout; bx < maxbx_readout; bx++){ + unsigned bx_diff = (bx > bx-CSCConstants::LCT_CENTRAL_BX ) ? bx-CSCConstants::LCT_CENTRAL_BX : CSCConstants::LCT_CENTRAL_BX-bx; + if (showers_[bx].isValid() and bx_diff < minBXdiff){ + minBXdiff = bx_diff; + minBX = bx; + } + } + + for (unsigned bx = minbx_readout; bx < maxbx_readout; bx++) + if (bx == minBX) showerOut.push_back(showers_[bx]); + return showerOut; +} void CSCMotherboard::correlateLCTs(const CSCALCTDigi& bALCT, const CSCALCTDigi& sALCT, @@ -578,34 +599,71 @@ CSCCLCTDigi CSCMotherboard::getBXShiftedCLCT(const CSCCLCTDigi& cLCT) const { return cLCT_shifted; } +void CSCMotherboard::matchShowers(CSCShowerDigi * anode_showers, CSCShowerDigi * cathode_showers, bool andlogic){ + + CSCShowerDigi ashower, cshower; + bool used_cshower_mask[CSCConstants::MAX_CLCT_TBINS] = {false}; + for (unsigned bx = 0; bx < CSCConstants::MAX_ALCT_TBINS; bx++){ + ashower = anode_showers[bx]; + cshower = CSCShowerDigi();//use empty shower digi to initialize cshower + if (ashower.isValid()){ + for (unsigned mbx = 0; mbx < match_trig_window_size; mbx++) { + int cbx = bx + preferred_bx_match_[mbx] - CSCConstants::ALCT_CLCT_OFFSET; + //check bx range [0, CSCConstants::MAX_LCT_TBINS] + if (cbx < 0 || cbx >= CSCConstants::MAX_CLCT_TBINS) + continue; + if (cathode_showers[cbx].isValid() and not used_cshower_mask[cbx]) { + cshower = cathode_showers[cbx]; + used_cshower_mask[cbx] = true; + break; + } + } + }else cshower = cathode_showers[bx];//if anode shower is not valid, use the cshower from this bx + + //matched HMT, with and/or logic + unsigned matchHMT = 0; + if (andlogic) { + if (ashower.isTightInTime() and cshower.isTightInTime()) matchHMT = 3; + else if (ashower.isNominalInTime() and cshower.isNominalInTime()) matchHMT = 2; + else if (ashower.isLooseInTime() and cshower.isLooseInTime()) matchHMT = 1; + }else{ + if (ashower.isTightInTime() or cshower.isTightInTime()) matchHMT = 3; + else if (ashower.isNominalInTime() or cshower.isNominalInTime()) matchHMT = 2; + else if (ashower.isLooseInTime() or cshower.isLooseInTime()) matchHMT = 1; + } + //LCTShower with showerType = 3 + showers_[bx] = CSCShowerDigi(matchHMT&3, false, ashower.getCSCID(), bx, 3, ashower.getWireNHits(), cshower.getComparatorNHits()); + } +} + void CSCMotherboard::encodeHighMultiplicityBits() { // get the high multiplicity // for anode this reflects what is already in the anode CSCShowerDigi object - unsigned cathodeInTime = clctProc->getInTimeHMT(); - unsigned anodeInTime = alctProc->getInTimeHMT(); + CSCShowerDigi cathode_showers [CSCConstants::MAX_CLCT_TBINS]; + CSCShowerDigi anode_showers [CSCConstants::MAX_ALCT_TBINS]; + auto cshowers_v = clctProc->getAllShower(); + auto ashowers_v = alctProc->getAllShower(); - // assign the bits - unsigned inTimeHMT_; + std::copy(cshowers_v.begin(), cshowers_v.end(), cathode_showers); + std::copy(ashowers_v.begin(), ashowers_v.end(), anode_showers); // set the value according to source - switch (showerSource_) { + switch (thisShowerSource_) { case 0: - inTimeHMT_ = cathodeInTime; + std::copy(std::begin(cathode_showers), std::end(cathode_showers), std::begin(showers_)); break; case 1: - inTimeHMT_ = anodeInTime; + std::copy(std::begin(anode_showers), std::end(anode_showers), std::begin(showers_)); break; case 2: - inTimeHMT_ = anodeInTime | cathodeInTime; + matchShowers(anode_showers, cathode_showers, false); break; case 3: - inTimeHMT_ = anodeInTime & cathodeInTime; + matchShowers(anode_showers, cathode_showers, true); break; default: - inTimeHMT_ = cathodeInTime; + std::copy(std::begin(anode_showers), std::end(anode_showers), std::begin(showers_)); break; }; - // create a new object - shower_ = CSCShowerDigi(inTimeHMT_, 0, theTrigChamber); } diff --git a/L1Trigger/CSCTriggerPrimitives/src/CSCTriggerPrimitivesBuilder.cc b/L1Trigger/CSCTriggerPrimitives/src/CSCTriggerPrimitivesBuilder.cc index c0aed699dabc1..1fd5eef2bce21 100644 --- a/L1Trigger/CSCTriggerPrimitives/src/CSCTriggerPrimitivesBuilder.cc +++ b/L1Trigger/CSCTriggerPrimitives/src/CSCTriggerPrimitivesBuilder.cc @@ -25,6 +25,7 @@ CSCTriggerPrimitivesBuilder::CSCTriggerPrimitivesBuilder(const edm::ParameterSet disableME42_ = commonParams.getParameter("disableME42"); checkBadChambers_ = conf.getParameter("checkBadChambers"); + selectedChambers_ = conf.getParameter>("selectedChambers"); runME11Up_ = commonParams.getParameter("runME11Up"); runME21Up_ = commonParams.getParameter("runME21Up"); @@ -191,6 +192,13 @@ void CSCTriggerPrimitivesBuilder::build(const CSCBadChambers* badChambers, if (checkBadChambers_ && badChambers->isInBadChamber(detid)) continue; + //only process the selected chambers when selectedChambers is not empty + if (!selectedChambers_.empty()) { + if (std::find(selectedChambers_.begin(), selectedChambers_.end(), detid.chamberName()) == + selectedChambers_.end()) { + continue; + } + } const bool upgrade = runPhase2_ and ring == 1; const bool upgradeGE11 = upgrade and stat == 1 and runME11Up_ and runME11ILT_; const bool upgradeGE21 = upgrade and stat == 2 and runME21Up_ and runME21ILT_; @@ -227,9 +235,9 @@ void CSCTriggerPrimitivesBuilder::build(const CSCBadChambers* badChambers, const std::vector& alctpretriggerV = tmb->alctProc->preTriggerDigis(); // showers - const CSCShowerDigi& shower = tmb->readoutShower(); - const CSCShowerDigi& anodeShower = tmb->alctProc->readoutShower(); - const CSCShowerDigi& cathodeShower = tmb->clctProc->readoutShower(); + const std::vector& shower = tmb->readoutShower(); + const std::vector& anodeShower = tmb->alctProc->readoutShower(); + const std::vector& cathodeShower = tmb->clctProc->readoutShower(); put(alctV, oc_alct, detid, tmb->getCSCName() + " ALCT digi"); put(clctV, oc_clct, detid, tmb->getCSCName() + " CLCT digi"); @@ -239,12 +247,15 @@ void CSCTriggerPrimitivesBuilder::build(const CSCBadChambers* badChambers, put(pretriggerV, oc_pretrigger, detid, tmb->getCSCName() + " CLCT pre-trigger digi"); put(alctpretriggerV, oc_alctpretrigger, detid, tmb->getCSCName() + " ALCT pre-trigger digi"); - if (shower.isValid()) - oc_shower.insertDigi(detid, shower); - if (anodeShower.isValid()) - oc_shower_anode.insertDigi(detid, anodeShower); - if (cathodeShower.isValid()) - oc_shower_cathode.insertDigi(detid, cathodeShower); + put(shower, oc_shower, detid, tmb->getCSCName()+"TMB shower"); + put(anodeShower, oc_shower_anode, detid, tmb->getCSCName()+"Anode shower"); + put(cathodeShower, oc_shower_cathode, detid, tmb->getCSCName()+"Cathode shower"); + //if (shower.isValid()) + // oc_shower.insertDigi(detid, shower); + //if (anodeShower.isValid()) + // oc_shower_anode.insertDigi(detid, anodeShower); + //if (cathodeShower.isValid()) + // oc_shower_cathode.insertDigi(detid, cathodeShower); if (!(alctV.empty() && clctV.empty() && lctV.empty()) and infoV > 1) { LogTrace("L1CSCTrigger") << "CSCTriggerPrimitivesBuilder got results in " << detid; From af71bd75a4995ce1eed5d248a7aa77db5964696f Mon Sep 17 00:00:00 2001 From: Martin Date: Tue, 2 Aug 2022 12:19:42 +0200 Subject: [PATCH 02/10] code format --- DataFormats/CSCDigi/interface/CSCShowerDigi.h | 15 +- DataFormats/CSCDigi/src/CSCShowerDigi.cc | 33 ++-- .../CSCDigi/src/classes_def.xml.generated | 169 ------------------ .../CSCRawToDigi/interface/CSCALCTHeader.h | 2 +- .../CSCRawToDigi/interface/CSCTMBHeader.h | 2 +- .../CSCRawToDigi/interface/CSCTMBHeader2006.h | 2 +- .../CSCRawToDigi/interface/CSCTMBHeader2007.h | 2 +- .../interface/CSCTMBHeader2007_rev0x50c3.h | 2 +- .../CSCRawToDigi/interface/CSCTMBHeader2013.h | 2 +- .../interface/CSCTMBHeader2020_CCLUT.h | 2 +- .../interface/CSCTMBHeader2020_GEM.h | 2 +- .../interface/CSCTMBHeader2020_Run2.h | 2 +- .../interface/CSCTMBHeader2020_TMB.h | 2 +- .../interface/CSCVTMBHeaderFormat.h | 1 - EventFilter/CSCRawToDigi/src/CSCALCTHeader.cc | 2 +- .../src/CSCTMBHeader2020_CCLUT.cc | 56 +++--- .../CSCRawToDigi/src/CSCTMBHeader2020_GEM.cc | 54 +++--- .../CSCRawToDigi/src/CSCTMBHeader2020_TMB.cc | 25 +-- .../interface/CSCAnodeLCTProcessor.h | 2 +- .../interface/CSCCathodeLCTProcessor.h | 2 +- .../interface/CSCMotherboard.h | 3 +- .../python/cscTriggerPrimitiveDigis_cfi.py | 2 +- .../src/CSCAnodeLCTProcessor.cc | 68 +++---- .../src/CSCCathodeLCTProcessor.cc | 73 ++++---- .../src/CSCMotherboard.cc | 76 ++++---- .../src/CSCTriggerPrimitivesBuilder.cc | 20 +-- 26 files changed, 245 insertions(+), 376 deletions(-) delete mode 100644 DataFormats/CSCDigi/src/classes_def.xml.generated diff --git a/DataFormats/CSCDigi/interface/CSCShowerDigi.h b/DataFormats/CSCDigi/interface/CSCShowerDigi.h index f376ddfa56e73..78896227eec3d 100644 --- a/DataFormats/CSCDigi/interface/CSCShowerDigi.h +++ b/DataFormats/CSCDigi/interface/CSCShowerDigi.h @@ -11,11 +11,16 @@ class CSCShowerDigi { // Run-3 definitions as provided in DN-20-033 enum Run3Shower { kInvalid = 0, kLoose = 1, kNominal = 2, kTight = 3 }; // Shower types. and showers from OTMB/TMB are assigned with kLCTShower - enum ShowerType { kInvalidShower = 0, kALCTShower = 1, kCLCTShower = 2, kLCTShower = 3}; + enum ShowerType { kInvalidShower = 0, kALCTShower = 1, kCLCTShower = 2, kLCTShower = 3 }; /// Constructors - CSCShowerDigi(const uint16_t inTimeBits, const uint16_t outTimeBits, const uint16_t cscID, - const uint16_t bx, const uint16_t showerType, const uint16_t wireNHits, const uint16_t compNHits); + CSCShowerDigi(const uint16_t inTimeBits, + const uint16_t outTimeBits, + const uint16_t cscID, + const uint16_t bx, + const uint16_t showerType, + const uint16_t wireNHits, + const uint16_t compNHits); /// default CSCShowerDigi(); @@ -36,7 +41,7 @@ class CSCShowerDigi { uint16_t bitsInTime() const { return bitsInTime_; } uint16_t bitsOutOfTime() const { return bitsOutOfTime_; } - uint16_t getBX() const {return bx_; } + uint16_t getBX() const { return bx_; } uint16_t getCSCID() const { return cscID_; } uint16_t getShowerType() const { return showerType_; } uint16_t getWireNHits() const { return wireNHits_; } @@ -44,7 +49,7 @@ class CSCShowerDigi { /// set cscID void setCSCID(const uint16_t c) { cscID_ = c; } - void setBX(const uint16_t bx) {bx_ = bx; } + void setBX(const uint16_t bx) { bx_ = bx; } private: uint16_t bitsInTime_; diff --git a/DataFormats/CSCDigi/src/CSCShowerDigi.cc b/DataFormats/CSCDigi/src/CSCShowerDigi.cc index b269ebedef6f6..415b8c0ac502a 100644 --- a/DataFormats/CSCDigi/src/CSCShowerDigi.cc +++ b/DataFormats/CSCDigi/src/CSCShowerDigi.cc @@ -6,14 +6,24 @@ using namespace std; /// Constructors -CSCShowerDigi::CSCShowerDigi(const uint16_t bitsInTime, const uint16_t bitsOutOfTime, const uint16_t cscID, - const uint16_t bx, const uint16_t showerType, const uint16_t wireNHits, const uint16_t compNHits) - : bitsInTime_(bitsInTime), bitsOutOfTime_(bitsOutOfTime), cscID_(cscID), - bx_(bx), showerType_(showerType), wireNHits_(wireNHits), comparatorNHits_(compNHits) {} +CSCShowerDigi::CSCShowerDigi(const uint16_t bitsInTime, + const uint16_t bitsOutOfTime, + const uint16_t cscID, + const uint16_t bx, + const uint16_t showerType, + const uint16_t wireNHits, + const uint16_t compNHits) + : bitsInTime_(bitsInTime), + bitsOutOfTime_(bitsOutOfTime), + cscID_(cscID), + bx_(bx), + showerType_(showerType), + wireNHits_(wireNHits), + comparatorNHits_(compNHits) {} /// Default -CSCShowerDigi::CSCShowerDigi() : bitsInTime_(0), bitsOutOfTime_(0), cscID_(0), - bx_(0), showerType_(0), wireNHits_(0), comparatorNHits_(0){} +CSCShowerDigi::CSCShowerDigi() + : bitsInTime_(0), bitsOutOfTime_(0), cscID_(0), bx_(0), showerType_(0), wireNHits_(0), comparatorNHits_(0) {} void CSCShowerDigi::clear() { bitsInTime_ = 0; @@ -46,15 +56,16 @@ bool CSCShowerDigi::isTightOutOfTime() const { return bitsOutOfTime() >= kTight; bool CSCShowerDigi::isValidShowerType() const { return showerType_ > kInvalidShower; } std::ostream& operator<<(std::ostream& o, const CSCShowerDigi& digi) { - unsigned int showerType = digi.getShowerType(); std::string compHitsStr(", comparatorHits "); compHitsStr += std::to_string(digi.getComparatorNHits()); std::string wireHitsStr(", wireHits "); wireHitsStr += std::to_string(digi.getWireNHits()); - return o <<(showerType == 0 ? "Invalid ShowerType" : (showerType == 1 ? "ALCTShower" : (showerType == 2 ? "CLCTShower" : "correlatedLCTShower"))) - <<": bx "<< digi.getBX() <<", in-time bits " << digi.bitsInTime() << ", out-of-time bits " << digi.bitsOutOfTime() - << ((showerType == 1 or showerType == 3 ) ? wireHitsStr : "") - << ((showerType == 2 or showerType == 3 ) ? compHitsStr : "") << ";"; + return o << (showerType == 0 + ? "Invalid ShowerType" + : (showerType == 1 ? "ALCTShower" : (showerType == 2 ? "CLCTShower" : "correlatedLCTShower"))) + << ": bx " << digi.getBX() << ", in-time bits " << digi.bitsInTime() << ", out-of-time bits " + << digi.bitsOutOfTime() << ((showerType == 1 or showerType == 3) ? wireHitsStr : "") + << ((showerType == 2 or showerType == 3) ? compHitsStr : "") << ";"; } diff --git a/DataFormats/CSCDigi/src/classes_def.xml.generated b/DataFormats/CSCDigi/src/classes_def.xml.generated deleted file mode 100644 index 4a4b1e09b45e4..0000000000000 --- a/DataFormats/CSCDigi/src/classes_def.xml.generated +++ /dev/null @@ -1,169 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/EventFilter/CSCRawToDigi/interface/CSCALCTHeader.h b/EventFilter/CSCRawToDigi/interface/CSCALCTHeader.h index 5a116fce7ef08..4c4b021e5f14d 100644 --- a/EventFilter/CSCRawToDigi/interface/CSCALCTHeader.h +++ b/EventFilter/CSCRawToDigi/interface/CSCALCTHeader.h @@ -169,7 +169,7 @@ class CSCALCTHeader { if ((!theALCTs.empty()) && (theALCTs.size() == unsigned(header2007.lctBins * 2))) { for (unsigned bx = 0; bx < header2007.lctBins; bx++) { //CSCID is set to be 0 - //ALCTshower, showerType_= 1, wireNHits and ComparatorNHits are not available in data + //ALCTshower, showerType_= 1, wireNHits and ComparatorNHits are not available in data results.push_back(CSCShowerDigi(theALCTs[bx * 2].reserved & 0x3, 0, 0, bx, 1, 0, 0)); } return results; diff --git a/EventFilter/CSCRawToDigi/interface/CSCTMBHeader.h b/EventFilter/CSCRawToDigi/interface/CSCTMBHeader.h index d71bdca80b374..86f04d6324750 100644 --- a/EventFilter/CSCRawToDigi/interface/CSCTMBHeader.h +++ b/EventFilter/CSCRawToDigi/interface/CSCTMBHeader.h @@ -54,7 +54,7 @@ class CSCTMBHeader { uint16_t sizeInBytes() const { return theHeaderFormat->sizeInWords() * 2; } - uint16_t L1AMatchTime() const {return theHeaderFormat->L1AMatchTime(); } + uint16_t L1AMatchTime() const { return theHeaderFormat->L1AMatchTime(); } /// will throw if the cast fails CSCTMBHeader2007 tmbHeader2007() const; CSCTMBHeader2007_rev0x50c3 tmbHeader2007_rev0x50c3() const; diff --git a/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2006.h b/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2006.h index fa950b531c8a4..aace95458d019 100644 --- a/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2006.h +++ b/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2006.h @@ -26,7 +26,7 @@ struct CSCTMBHeader2006 : public CSCVTMBHeaderFormat { uint16_t syncErrorCLCT() const override { return (bits.clct0_sync_err | bits.clct1_sync_err); } uint16_t syncErrorMPC0() const override { return bits.MPC_Muon0_SyncErr_; } uint16_t syncErrorMPC1() const override { return bits.MPC_Muon1_SyncErr_; } - uint16_t L1AMatchTime() const override {return bits.pop_l1a_match_win; } + uint16_t L1AMatchTime() const override { return bits.pop_l1a_match_win; } /// == Run 3 CSC-GEM Trigger Format uint16_t clct0_ComparatorCode() const override { return 0; } diff --git a/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2007.h b/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2007.h index 02296fb8dc008..6d851838d3021 100644 --- a/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2007.h +++ b/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2007.h @@ -26,7 +26,7 @@ struct CSCTMBHeader2007 : public CSCVTMBHeaderFormat { uint16_t syncErrorCLCT() const override { return (bits.clct0_sync_err | bits.clct1_sync_err); } uint16_t syncErrorMPC0() const override { return bits.MPC_Muon0_SyncErr_; } uint16_t syncErrorMPC1() const override { return bits.MPC_Muon1_SyncErr_; } - uint16_t L1AMatchTime() const override {return bits.pop_l1a_match_win; } + uint16_t L1AMatchTime() const override { return bits.pop_l1a_match_win; } /// == Run 3 CSC-GEM Trigger Format uint16_t clct0_ComparatorCode() const override { return 0; } diff --git a/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2007_rev0x50c3.h b/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2007_rev0x50c3.h index cf3366ff8577b..fc2a5b118e816 100644 --- a/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2007_rev0x50c3.h +++ b/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2007_rev0x50c3.h @@ -26,7 +26,7 @@ struct CSCTMBHeader2007_rev0x50c3 : public CSCVTMBHeaderFormat { uint16_t syncErrorCLCT() const override { return bits.clct_sync_err; } uint16_t syncErrorMPC0() const override { return bits.MPC_Muon0_SyncErr_; } uint16_t syncErrorMPC1() const override { return bits.MPC_Muon1_SyncErr_; } - uint16_t L1AMatchTime() const override {return bits.pop_l1a_match_win; } + uint16_t L1AMatchTime() const override { return bits.pop_l1a_match_win; } /// == Run 3 CSC-GEM Trigger Format uint16_t clct0_ComparatorCode() const override { return 0; } diff --git a/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2013.h b/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2013.h index 73f61796bd54c..dba992dd22e6a 100644 --- a/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2013.h +++ b/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2013.h @@ -26,7 +26,7 @@ struct CSCTMBHeader2013 : public CSCVTMBHeaderFormat { uint16_t syncErrorCLCT() const override { return bits.clct_sync_err; } uint16_t syncErrorMPC0() const override { return bits.MPC_Muon0_SyncErr_; } uint16_t syncErrorMPC1() const override { return bits.MPC_Muon1_SyncErr_; } - uint16_t L1AMatchTime() const override {return bits.pop_l1a_match_win; } + uint16_t L1AMatchTime() const override { return bits.pop_l1a_match_win; } /// == Run 3 CSC-GEM Trigger Format uint16_t clct0_ComparatorCode() const override { return 0; } diff --git a/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2020_CCLUT.h b/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2020_CCLUT.h index fbbc576126387..f1b3847aa701e 100644 --- a/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2020_CCLUT.h +++ b/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2020_CCLUT.h @@ -26,7 +26,7 @@ struct CSCTMBHeader2020_CCLUT : public CSCVTMBHeaderFormat { uint16_t syncErrorCLCT() const override { return bits.clct_sync_err; } uint16_t syncErrorMPC0() const override { return 0; } uint16_t syncErrorMPC1() const override { return 0; } - uint16_t L1AMatchTime() const override {return bits.pop_l1a_match_win; } + uint16_t L1AMatchTime() const override { return bits.pop_l1a_match_win; } // == Run 3 CSC-GEM Trigger Format uint16_t clct0_ComparatorCode() const override { return bits.clct0_comparator_code; } diff --git a/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2020_GEM.h b/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2020_GEM.h index 446e7fc5c253e..f95f1a5f02727 100644 --- a/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2020_GEM.h +++ b/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2020_GEM.h @@ -26,7 +26,7 @@ struct CSCTMBHeader2020_GEM : public CSCVTMBHeaderFormat { uint16_t syncErrorCLCT() const override { return bits.clct_sync_err; } uint16_t syncErrorMPC0() const override { return 0; } uint16_t syncErrorMPC1() const override { return 0; } - uint16_t L1AMatchTime() const override {return bits.pop_l1a_match_win; } + uint16_t L1AMatchTime() const override { return bits.pop_l1a_match_win; } // == Run 3 CSC-GEM Trigger Format uint16_t clct0_ComparatorCode() const override { return bits.clct0_comparator_code; } diff --git a/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2020_Run2.h b/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2020_Run2.h index 163d588d2832f..163d5bf01349a 100644 --- a/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2020_Run2.h +++ b/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2020_Run2.h @@ -26,7 +26,7 @@ struct CSCTMBHeader2020_Run2 : public CSCVTMBHeaderFormat { uint16_t syncErrorCLCT() const override { return bits.clct_sync_err; } uint16_t syncErrorMPC0() const override { return bits.MPC_Muon0_SyncErr_; } uint16_t syncErrorMPC1() const override { return bits.MPC_Muon1_SyncErr_; } - uint16_t L1AMatchTime() const override {return bits.pop_l1a_match_win; } + uint16_t L1AMatchTime() const override { return bits.pop_l1a_match_win; } // == Run 3 CSC-GEM Trigger Format uint16_t clct0_ComparatorCode() const override { return 0; } diff --git a/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2020_TMB.h b/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2020_TMB.h index 6705e6092af1d..a3d03d1642876 100644 --- a/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2020_TMB.h +++ b/EventFilter/CSCRawToDigi/interface/CSCTMBHeader2020_TMB.h @@ -26,7 +26,7 @@ struct CSCTMBHeader2020_TMB : public CSCVTMBHeaderFormat { uint16_t syncErrorCLCT() const override { return bits.clct_sync_err; } uint16_t syncErrorMPC0() const override { return 0; } uint16_t syncErrorMPC1() const override { return 0; } - uint16_t L1AMatchTime() const override {return bits.pop_l1a_match_win; } + uint16_t L1AMatchTime() const override { return bits.pop_l1a_match_win; } // == Run 3 CSC-GEM Trigger Format uint16_t clct0_ComparatorCode() const override { return 0; } diff --git a/EventFilter/CSCRawToDigi/interface/CSCVTMBHeaderFormat.h b/EventFilter/CSCRawToDigi/interface/CSCVTMBHeaderFormat.h index 53f57ed2c3e81..11ea88b519dd4 100644 --- a/EventFilter/CSCRawToDigi/interface/CSCVTMBHeaderFormat.h +++ b/EventFilter/CSCRawToDigi/interface/CSCVTMBHeaderFormat.h @@ -86,7 +86,6 @@ class CSCVTMBHeaderFormat { virtual void print(std::ostream& os) const = 0; - protected: void swapCLCTs(CSCCLCTDigi& digi1, CSCCLCTDigi& digi2); }; diff --git a/EventFilter/CSCRawToDigi/src/CSCALCTHeader.cc b/EventFilter/CSCRawToDigi/src/CSCALCTHeader.cc index bca6c7589787b..4c90847f15f03 100644 --- a/EventFilter/CSCRawToDigi/src/CSCALCTHeader.cc +++ b/EventFilter/CSCRawToDigi/src/CSCALCTHeader.cc @@ -229,7 +229,7 @@ void CSCALCTHeader::addShower(const std::vector &digis) { if (bx < (int)header2007.lctBins) { const CSCShowerDigi &digi = digis[bx]; int i = bx * 2; - unsigned hmt_bits = digi.isValid() ? digi.bitsInTime() : 0; + unsigned hmt_bits = digi.isValid() ? digi.bitsInTime() : 0; theALCTs[i].reserved = hmt_bits & 0x3; theALCTs[i + 1].reserved = hmt_bits & 0x3; } diff --git a/EventFilter/CSCRawToDigi/src/CSCTMBHeader2020_CCLUT.cc b/EventFilter/CSCRawToDigi/src/CSCTMBHeader2020_CCLUT.cc index cd7e7c4d6cf09..eb830ef41c62b 100644 --- a/EventFilter/CSCRawToDigi/src/CSCTMBHeader2020_CCLUT.cc +++ b/EventFilter/CSCRawToDigi/src/CSCTMBHeader2020_CCLUT.cc @@ -161,19 +161,20 @@ std::vector CSCTMBHeader2020_CCLUT::CorrelatedLCTDigis(uin CSCShowerDigi CSCTMBHeader2020_CCLUT::showerDigi(uint32_t idlayer) const { unsigned hmt_bits = bits.MPC_Muon_HMT_bit0 | (bits.MPC_Muon_HMT_high << 1); // HighMultiplicityTrigger bits - uint16_t cscid = bits.cscID; // ??? What is 4-bits CSC Id in CSshowerDigi + uint16_t cscid = bits.cscID; // ??? What is 4-bits CSC Id in CSshowerDigi //L1A_TMB_WINDOW is not included in below formula //correct version: CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win + L1A_TMB_WINDOW/2; // same for anode HMT and cathode HMT - uint16_t bx = CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win; + uint16_t bx = CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win; //LCTshower with showerType = 3. comparatorNHits from hmt_nhits() and wireNHit is not available - CSCShowerDigi result(hmt_bits & 0x3, (hmt_bits >> 2) & 0x3, cscid, bx, 3, 0, hmt_nhits()); // 2-bits intime, 2-bits out of time + CSCShowerDigi result( + hmt_bits & 0x3, (hmt_bits >> 2) & 0x3, cscid, bx, 3, 0, hmt_nhits()); // 2-bits intime, 2-bits out of time return result; } CSCShowerDigi CSCTMBHeader2020_CCLUT::anodeShowerDigi(uint32_t idlayer) const { uint16_t cscid = bits.cscID; - uint16_t bx = CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win; + uint16_t bx = CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win; //ALCT shower with showerType = 1. nhits_ is not available from unpack data CSCShowerDigi result(bits.anode_hmt & 0x3, 0, cscid, bx, 1, 0, 0); // 2-bits intime, no out of time return result; @@ -181,8 +182,8 @@ CSCShowerDigi CSCTMBHeader2020_CCLUT::anodeShowerDigi(uint32_t idlayer) const { CSCShowerDigi CSCTMBHeader2020_CCLUT::cathodeShowerDigi(uint32_t idlayer) const { uint16_t cscid = bits.cscID; - uint16_t bx = CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win - bits.hmt_match_win + 3; - //CLCT shower with showerType = 2. + uint16_t bx = CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win - bits.hmt_match_win + 3; + //CLCT shower with showerType = 2. CSCShowerDigi result(bits.cathode_hmt & 0x3, 0, cscid, bx, 2, 0, hmt_nhits()); // 2-bits intime, no out of time return result; } @@ -282,42 +283,45 @@ void CSCTMBHeader2020_CCLUT::addCorrelatedLCT1(const CSCCorrelatedLCTDigi& digi) void CSCTMBHeader2020_CCLUT::addShower(const CSCShowerDigi& digi) { uint16_t hmt_bits = (digi.bitsInTime() & 0x3) + ((digi.bitsOutOfTime() & 0x3) << 2); //not valid LCT shower, then in-time bits must be 0. keep out-of-time HMT - if (not digi.isValid()) hmt_bits = ((digi.bitsOutOfTime() & 0x3) << 2); + if (not digi.isValid()) + hmt_bits = ((digi.bitsOutOfTime() & 0x3) << 2); bits.MPC_Muon_HMT_bit0 = hmt_bits & 0x1; bits.MPC_Muon_HMT_high = (hmt_bits >> 1) & 0x7; - //to keep pop_l1a_match_win + //to keep pop_l1a_match_win if (digi.isValid()) - bits.pop_l1a_match_win = CSCConstants::LCT_CENTRAL_BX - digi.getBX(); + bits.pop_l1a_match_win = CSCConstants::LCT_CENTRAL_BX - digi.getBX(); else - bits.pop_l1a_match_win = 3;//default value + bits.pop_l1a_match_win = 3; //default value } void CSCTMBHeader2020_CCLUT::addAnodeShower(const CSCShowerDigi& digi) { uint16_t hmt_bits = digi.bitsInTime() & 0x3; - if (not digi.isValid()) hmt_bits = 0; + if (not digi.isValid()) + hmt_bits = 0; bits.anode_hmt = hmt_bits; if (not(bits.MPC_Muon_HMT_bit0 or bits.MPC_Muon_HMT_high) and digi.isValid()) - bits.pop_l1a_match_win = CSCConstants::LCT_CENTRAL_BX - digi.getBX(); + bits.pop_l1a_match_win = CSCConstants::LCT_CENTRAL_BX - digi.getBX(); else if (not(digi.isValid())) - bits.pop_l1a_match_win = 3;//default value + bits.pop_l1a_match_win = 3; //default value } void CSCTMBHeader2020_CCLUT::addCathodeShower(const CSCShowerDigi& digi) { uint16_t hmt_bits = digi.bitsInTime() & 0x3; - if (not digi.isValid()) hmt_bits = 0; + if (not digi.isValid()) + hmt_bits = 0; bits.cathode_hmt = hmt_bits; bits.hmt_nhits_bit0 = digi.getComparatorNHits() & 0x1; bits.hmt_nhits_bit1 = (digi.getComparatorNHits() >> 1) & 0x1; bits.hmt_nhits_bits_high = (digi.getComparatorNHits() >> 2) & 0x1F; - if (bits.MPC_Muon_HMT_bit0 or bits.MPC_Muon_HMT_high or bits.anode_hmt){ - //matched HMT is found, then pop_l1a_match_win is assigned - bits.hmt_match_win = CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win + 3 - digi.getBX(); - }else if (digi.isValid()){ - bits.pop_l1a_match_win = 3;//default value - bits.hmt_match_win = CSCConstants::LCT_CENTRAL_BX - digi.getBX(); - }else { - bits.pop_l1a_match_win = 3;//default value - bits.hmt_match_win = 0; //no HMT case + if (bits.MPC_Muon_HMT_bit0 or bits.MPC_Muon_HMT_high or bits.anode_hmt) { + //matched HMT is found, then pop_l1a_match_win is assigned + bits.hmt_match_win = CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win + 3 - digi.getBX(); + } else if (digi.isValid()) { + bits.pop_l1a_match_win = 3; //default value + bits.hmt_match_win = CSCConstants::LCT_CENTRAL_BX - digi.getBX(); + } else { + bits.pop_l1a_match_win = 3; //default value + bits.hmt_match_win = 0; //no HMT case } } @@ -333,8 +337,8 @@ void CSCTMBHeader2020_CCLUT::print(std::ostream& os) const { << std::hex << (bits.activeCFEBs | (bits.activeCFEBs_2 << 5)) << ", readCFEBs = 0x" << std::hex << (bits.readCFEBs | (bits.readCFEBs_2 << 5)) << std::dec << "\n"; os << "bxnPreTrigger = " << bits.bxnPreTrigger << "\n"; - os << "ALCT location in CLCt window "<< bits.matchWin << " L1A location in TMB window "<< bits.pop_l1a_match_win - << " ALCT in cathde HMT window "<< bits.hmt_match_win << "\n"; + os << "ALCT location in CLCT window " << bits.matchWin << " L1A location in TMB window " << bits.pop_l1a_match_win + << " ALCT in cathde HMT window " << bits.hmt_match_win << "\n"; os << "tmbMatch = " << bits.tmbMatch << " alctOnly = " << bits.alctOnly << " clctOnly = " << bits.clctOnly << "\n"; os << "readoutCounter: " << std::dec << bits.readoutCounter << ", buf_q_ovf: " << bits.stackOvf @@ -378,5 +382,5 @@ void CSCTMBHeader2020_CCLUT::print(std::ostream& os) const { os << " clct_5bit_pattern_id = " << (bits.MPC_Muon_clct_pattern_low | (bits.MPC_Muon_clct_pattern_bit5 << 4)) << " HMT = " << (bits.MPC_Muon_HMT_bit0 | (bits.MPC_Muon_HMT_high << 1)) << ", alctHMT = " << bits.anode_hmt - << ", clctHMT = " << bits.cathode_hmt << " cathode nhits "<< hmt_nhits() <<"\n"; + << ", clctHMT = " << bits.cathode_hmt << " cathode nhits " << hmt_nhits() << "\n"; } diff --git a/EventFilter/CSCRawToDigi/src/CSCTMBHeader2020_GEM.cc b/EventFilter/CSCRawToDigi/src/CSCTMBHeader2020_GEM.cc index 77ddaa9810309..f17e85c096ea4 100644 --- a/EventFilter/CSCRawToDigi/src/CSCTMBHeader2020_GEM.cc +++ b/EventFilter/CSCRawToDigi/src/CSCTMBHeader2020_GEM.cc @@ -165,19 +165,20 @@ std::vector CSCTMBHeader2020_GEM::CorrelatedLCTDigis(uint3 CSCShowerDigi CSCTMBHeader2020_GEM::showerDigi(uint32_t idlayer) const { unsigned hmt_bits = bits.MPC_Muon_HMT_bit0 | (bits.MPC_Muon_HMT_high << 1); // HighMultiplicityTrigger bits - uint16_t cscid = bits.cscID; // ??? What is 4-bits CSC Id in CSshowerDigi + uint16_t cscid = bits.cscID; // ??? What is 4-bits CSC Id in CSshowerDigi //L1A_TMB_WINDOW is not included in below formula //correct version: CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win + L1A_TMB_WINDOW/2; // same for anode HMT and cathode HMT. offline analysis would take care of this - uint16_t bx = CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win; + uint16_t bx = CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win; //LCTshower with showerType = 3. comparatorNHits from hmt_nhits() and wireNHits is not available - CSCShowerDigi result(hmt_bits & 0x3, (hmt_bits >> 2) & 0x3, cscid, bx, 3, 0, hmt_nhits()); // 2-bits intime, 2-bits out of time + CSCShowerDigi result( + hmt_bits & 0x3, (hmt_bits >> 2) & 0x3, cscid, bx, 3, 0, hmt_nhits()); // 2-bits intime, 2-bits out of time return result; } CSCShowerDigi CSCTMBHeader2020_GEM::anodeShowerDigi(uint32_t idlayer) const { uint16_t cscid = bits.cscID; - uint16_t bx = CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win; + uint16_t bx = CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win; //ALCT shower with showerType = 1. wireNHits is not available from unpack data CSCShowerDigi result(bits.anode_hmt & 0x3, 0, cscid, bx, 1, 0, 0); // 2-bits intime, no out of time return result; @@ -185,7 +186,7 @@ CSCShowerDigi CSCTMBHeader2020_GEM::anodeShowerDigi(uint32_t idlayer) const { CSCShowerDigi CSCTMBHeader2020_GEM::cathodeShowerDigi(uint32_t idlayer) const { uint16_t cscid = bits.cscID; - uint16_t bx = CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win - bits.hmt_match_win + 3; + uint16_t bx = CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win - bits.hmt_match_win + 3; //CLCT shower with showerType = 2. comparatorNHits from hmt_nhits() CSCShowerDigi result(bits.cathode_hmt & 0x3, 0, cscid, bx, 2, 0, hmt_nhits()); // 2-bits intime, no out of time return result; @@ -286,42 +287,45 @@ void CSCTMBHeader2020_GEM::addCorrelatedLCT1(const CSCCorrelatedLCTDigi& digi) { void CSCTMBHeader2020_GEM::addShower(const CSCShowerDigi& digi) { uint16_t hmt_bits = (digi.bitsInTime() & 0x3) + ((digi.bitsOutOfTime() & 0x3) << 2); //not valid LCT shower, then in-time bits must be 0 - if (not digi.isValid()) hmt_bits = ((digi.bitsOutOfTime() & 0x3) << 2); + if (not digi.isValid()) + hmt_bits = ((digi.bitsOutOfTime() & 0x3) << 2); bits.MPC_Muon_HMT_bit0 = hmt_bits & 0x1; bits.MPC_Muon_HMT_high = (hmt_bits >> 1) & 0x7; - //to keep pop_l1a_match_win + //to keep pop_l1a_match_win if (digi.isValid()) - bits.pop_l1a_match_win = CSCConstants::LCT_CENTRAL_BX - digi.getBX(); + bits.pop_l1a_match_win = CSCConstants::LCT_CENTRAL_BX - digi.getBX(); else - bits.pop_l1a_match_win = 3;//default value + bits.pop_l1a_match_win = 3; //default value } void CSCTMBHeader2020_GEM::addAnodeShower(const CSCShowerDigi& digi) { uint16_t hmt_bits = digi.bitsInTime() & 0x3; - if (not digi.isValid()) hmt_bits = 0; + if (not digi.isValid()) + hmt_bits = 0; bits.anode_hmt = hmt_bits; if (not(bits.MPC_Muon_HMT_bit0 or bits.MPC_Muon_HMT_high) and digi.isValid()) - bits.pop_l1a_match_win = CSCConstants::LCT_CENTRAL_BX - digi.getBX(); + bits.pop_l1a_match_win = CSCConstants::LCT_CENTRAL_BX - digi.getBX(); else if (not(digi.isValid())) - bits.pop_l1a_match_win = 3;//default value + bits.pop_l1a_match_win = 3; //default value } void CSCTMBHeader2020_GEM::addCathodeShower(const CSCShowerDigi& digi) { uint16_t hmt_bits = digi.bitsInTime() & 0x3; - if (not digi.isValid()) hmt_bits = 0; + if (not digi.isValid()) + hmt_bits = 0; bits.cathode_hmt = hmt_bits; bits.hmt_nhits_bit0 = digi.getComparatorNHits() & 0x1; bits.hmt_nhits_bit1 = (digi.getComparatorNHits() >> 1) & 0x1; bits.hmt_nhits_bits_high = (digi.getComparatorNHits() >> 2) & 0x1F; - if (bits.MPC_Muon_HMT_bit0 or bits.MPC_Muon_HMT_high or bits.anode_hmt){ - //pop_l1a_match_win is assigned - bits.hmt_match_win = CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win + 3 - digi.getBX(); - }else if (digi.isValid()){ - bits.pop_l1a_match_win = 3;//default value - bits.hmt_match_win = CSCConstants::LCT_CENTRAL_BX - digi.getBX(); - }else { - bits.pop_l1a_match_win = 3;//default value - bits.hmt_match_win = 0; //no HMT case + if (bits.MPC_Muon_HMT_bit0 or bits.MPC_Muon_HMT_high or bits.anode_hmt) { + //pop_l1a_match_win is assigned + bits.hmt_match_win = CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win + 3 - digi.getBX(); + } else if (digi.isValid()) { + bits.pop_l1a_match_win = 3; //default value + bits.hmt_match_win = CSCConstants::LCT_CENTRAL_BX - digi.getBX(); + } else { + bits.pop_l1a_match_win = 3; //default value + bits.hmt_match_win = 0; //no HMT case } } @@ -338,8 +342,8 @@ void CSCTMBHeader2020_GEM::print(std::ostream& os) const { << ", activeCFEBs = 0x" << std::hex << (bits.activeCFEBs | (bits.activeCFEBs_2 << 5)) << ", readCFEBs = 0x" << std::hex << (bits.readCFEBs | (bits.readCFEBs_2 << 5)) << std::dec << "\n"; os << "bxnPreTrigger = " << bits.bxnPreTrigger << "\n"; - os << "ALCT location in CLCt window "<< bits.matchWin << " L1A location in TMB window "<< bits.pop_l1a_match_win - << " ALCT in cathde HMT window "<< bits.hmt_match_win << "\n"; + os << "ALCT location in CLCT window " << bits.matchWin << " L1A location in TMB window " << bits.pop_l1a_match_win + << " ALCT in cathde HMT window " << bits.hmt_match_win << "\n"; os << "tmbMatch = " << bits.tmbMatch << " alctOnly = " << bits.alctOnly << " clctOnly = " << bits.clctOnly << "\n"; os << "readoutCounter: " << std::dec << bits.readoutCounter << ", buf_q_ovf: " << bits.stackOvf @@ -384,7 +388,7 @@ void CSCTMBHeader2020_GEM::print(std::ostream& os) const { os << " clct_5bit_pattern_id = " << (bits.MPC_Muon_clct_pattern_low | (bits.MPC_Muon_clct_pattern_bit5 << 4)) << " HMT = " << (bits.MPC_Muon_HMT_bit0 | (bits.MPC_Muon_HMT_high << 1)) << ", alctHMT = " << bits.anode_hmt - << ", clctHMT = " << bits.cathode_hmt << " cathode nhits "<< hmt_nhits() <<"\n"; + << ", clctHMT = " << bits.cathode_hmt << " cathode nhits " << hmt_nhits() << "\n"; // os << "..................CLCT....................." << "\n"; os << "GEM Data:\n" diff --git a/EventFilter/CSCRawToDigi/src/CSCTMBHeader2020_TMB.cc b/EventFilter/CSCRawToDigi/src/CSCTMBHeader2020_TMB.cc index 5ae3f6f5ecf57..7486051c8f24c 100644 --- a/EventFilter/CSCRawToDigi/src/CSCTMBHeader2020_TMB.cc +++ b/EventFilter/CSCRawToDigi/src/CSCTMBHeader2020_TMB.cc @@ -131,11 +131,11 @@ std::vector CSCTMBHeader2020_TMB::CorrelatedLCTDigis(uint3 CSCShowerDigi CSCTMBHeader2020_TMB::showerDigi(uint32_t idlayer) const { unsigned hmt_bits = bits.MPC_Muon_HMT_bit0 | (bits.MPC_Muon_HMT_high << 1); // HighMultiplicityTrigger bits - uint16_t cscid = bits.cscID; // ??? What is 4-bits CSC Id in CSshowerDigi + uint16_t cscid = bits.cscID; // ??? What is 4-bits CSC Id in CSshowerDigi //L1A_TMB_WINDOW is not included in below formula //correct version: CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win + L1A_TMB_WINDOW/2; // same for anode HMT and cathode HMT - uint16_t bx = CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win; + uint16_t bx = CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win; //LCTshower with showerType = 3. wireNHits is not avaiable //TMB LCT shower is copied from ALCT shower CSCShowerDigi result(hmt_bits & 0x3, (hmt_bits >> 2) & 0x3, cscid, bx, 3, 0, 0); // 2-bits intime, 2-bits out of time @@ -144,7 +144,7 @@ CSCShowerDigi CSCTMBHeader2020_TMB::showerDigi(uint32_t idlayer) const { CSCShowerDigi CSCTMBHeader2020_TMB::anodeShowerDigi(uint32_t idlayer) const { uint16_t cscid = bits.cscID; - uint16_t bx = CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win; + uint16_t bx = CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win; //ALCTshower with showerType = 1. wireNHits is not avaiable CSCShowerDigi result(bits.anode_hmt & 0x3, 0, cscid, bx, 1, 0, 0); // 2-bits intime, no out of time return result; @@ -152,7 +152,7 @@ CSCShowerDigi CSCTMBHeader2020_TMB::anodeShowerDigi(uint32_t idlayer) const { CSCShowerDigi CSCTMBHeader2020_TMB::cathodeShowerDigi(uint32_t idlayer) const { uint16_t cscid = bits.cscID; - uint16_t bx = CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win; + uint16_t bx = CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win; //CLCTshower with showerType = 2. comparatorNhits is not avaiable for TMB yet CSCShowerDigi result(bits.cathode_hmt & 0x3, 0, cscid, bx, 2, 0, 0); // 2-bits intime, no out of time return result; @@ -267,23 +267,25 @@ void CSCTMBHeader2020_TMB::addCorrelatedLCT1(const CSCCorrelatedLCTDigi& digi) { void CSCTMBHeader2020_TMB::addShower(const CSCShowerDigi& digi) { uint16_t hmt_bits = (digi.bitsInTime() & 0x3) + ((digi.bitsOutOfTime() & 0x3) << 2); //not valid LCT shower, then in-time bits must be 0 - if (not digi.isValid()) hmt_bits = ((digi.bitsOutOfTime() & 0x3) << 2); + if (not digi.isValid()) + hmt_bits = ((digi.bitsOutOfTime() & 0x3) << 2); bits.MPC_Muon_HMT_bit0 = hmt_bits & 0x1; bits.MPC_Muon_HMT_high = (hmt_bits >> 1) & 0x7; if (digi.isValid()) - bits.pop_l1a_match_win = CSCConstants::LCT_CENTRAL_BX - digi.getBX(); + bits.pop_l1a_match_win = CSCConstants::LCT_CENTRAL_BX - digi.getBX(); else - bits.pop_l1a_match_win = 3;//default value + bits.pop_l1a_match_win = 3; //default value } void CSCTMBHeader2020_TMB::addAnodeShower(const CSCShowerDigi& digi) { uint16_t hmt_bits = digi.bitsInTime() & 0x3; - if (not digi.isValid()) hmt_bits = 0; + if (not digi.isValid()) + hmt_bits = 0; bits.anode_hmt = hmt_bits; if (digi.isValid()) - bits.pop_l1a_match_win = CSCConstants::LCT_CENTRAL_BX - digi.getBX(); + bits.pop_l1a_match_win = CSCConstants::LCT_CENTRAL_BX - digi.getBX(); else - bits.pop_l1a_match_win = 3;//default value + bits.pop_l1a_match_win = 3; //default value } void CSCTMBHeader2020_TMB::addCathodeShower(const CSCShowerDigi& digi) { @@ -306,7 +308,8 @@ void CSCTMBHeader2020_TMB::print(std::ostream& os) const { << (bits.activeCFEBs | (bits.activeCFEBs_2 << 5)) << ", readCFEBs = 0x" << std::hex << (bits.readCFEBs | (bits.readCFEBs_2 << 5)) << std::dec << "\n"; os << "bxnPreTrigger = " << bits.bxnPreTrigger << "\n"; - os << "ALCT location in CLCt window "<< bits.matchWin << " L1A location in TMB window "<< bits.pop_l1a_match_win << "\n"; + os << "ALCT location in CLCT window " << bits.matchWin << " L1A location in TMB window " << bits.pop_l1a_match_win + << "\n"; os << "tmbMatch = " << bits.tmbMatch << " alctOnly = " << bits.alctOnly << " clctOnly = " << bits.clctOnly << "\n"; os << "CLCT Words:\n" diff --git a/L1Trigger/CSCTriggerPrimitives/interface/CSCAnodeLCTProcessor.h b/L1Trigger/CSCTriggerPrimitives/interface/CSCAnodeLCTProcessor.h index f29dd0e06f123..11f01af9278e2 100644 --- a/L1Trigger/CSCTriggerPrimitives/interface/CSCAnodeLCTProcessor.h +++ b/L1Trigger/CSCTriggerPrimitives/interface/CSCAnodeLCTProcessor.h @@ -88,7 +88,7 @@ class CSCAnodeLCTProcessor : public CSCBaseboard { CSCALCTDigi getSecondALCT(int bx) const; /* get array of high multiplicity triggers */ - std::vector getAllShower() const; + std::vector getAllShower() const; /** Returns shower bits */ std::vector readoutShower() const; diff --git a/L1Trigger/CSCTriggerPrimitives/interface/CSCCathodeLCTProcessor.h b/L1Trigger/CSCTriggerPrimitives/interface/CSCCathodeLCTProcessor.h index 722c006e9f11a..fa93609ae8df1 100644 --- a/L1Trigger/CSCTriggerPrimitives/interface/CSCCathodeLCTProcessor.h +++ b/L1Trigger/CSCTriggerPrimitives/interface/CSCCathodeLCTProcessor.h @@ -90,7 +90,7 @@ class CSCCathodeLCTProcessor : public CSCBaseboard { //unsigned getInTimeHMT() const { return inTimeHMT_; } //unsigned getOutTimeHMT() const { return outTimeHMT_; } /* get array of high multiplicity triggers */ - std::vector getAllShower() const; + std::vector getAllShower() const; /** Returns shower bits */ std::vector readoutShower() const; diff --git a/L1Trigger/CSCTriggerPrimitives/interface/CSCMotherboard.h b/L1Trigger/CSCTriggerPrimitives/interface/CSCMotherboard.h index afc8bcf33c33c..f2fb3df3ce39c 100644 --- a/L1Trigger/CSCTriggerPrimitives/interface/CSCMotherboard.h +++ b/L1Trigger/CSCTriggerPrimitives/interface/CSCMotherboard.h @@ -234,10 +234,9 @@ class CSCMotherboard : public CSCBaseboard { void dumpConfigParams() const; /* match cathode shower and anode shower with and/or logic */ - void matchShowers(CSCShowerDigi * anode_showers, CSCShowerDigi * cathode_showers, bool andlogic); + void matchShowers(CSCShowerDigi* anode_showers, CSCShowerDigi* cathode_showers, bool andlogic); /* encode high multiplicity bits for Run-3 exotic triggers */ void encodeHighMultiplicityBits(); - }; #endif diff --git a/L1Trigger/CSCTriggerPrimitives/python/cscTriggerPrimitiveDigis_cfi.py b/L1Trigger/CSCTriggerPrimitives/python/cscTriggerPrimitiveDigis_cfi.py index db0ac182ecad8..472b64cabac3c 100644 --- a/L1Trigger/CSCTriggerPrimitives/python/cscTriggerPrimitiveDigis_cfi.py +++ b/L1Trigger/CSCTriggerPrimitives/python/cscTriggerPrimitiveDigis_cfi.py @@ -35,7 +35,7 @@ # If True, output collections will only be built for good chambers checkBadChambers = cms.bool(True), #selected chamebrs to process - selectedChambers = cms.vstring(""), + selectedChambers = cms.vstring(), # Anode-DAQ rate determined by pre-CLCTs keepCLCTPreTriggers = cms.bool(True), diff --git a/L1Trigger/CSCTriggerPrimitives/src/CSCAnodeLCTProcessor.cc b/L1Trigger/CSCTriggerPrimitives/src/CSCAnodeLCTProcessor.cc index 2aed3f8223aeb..2d13d2dafc533 100644 --- a/L1Trigger/CSCTriggerPrimitives/src/CSCAnodeLCTProcessor.cc +++ b/L1Trigger/CSCTriggerPrimitives/src/CSCAnodeLCTProcessor.cc @@ -178,7 +178,7 @@ void CSCAnodeLCTProcessor::clear() { for (int bx = 0; bx < CSCConstants::MAX_ALCT_TBINS; bx++) { bestALCT[bx].clear(); secondALCT[bx].clear(); - anode_showers_[bx].clear();//? + anode_showers_[bx].clear(); //? } lct_list.clear(); } @@ -1278,29 +1278,31 @@ CSCALCTDigi CSCAnodeLCTProcessor::getBestALCT(int bx) const { return bestALCT[bx CSCALCTDigi CSCAnodeLCTProcessor::getSecondALCT(int bx) const { return secondALCT[bx]; } /** return vector of CSCShower digi **/ -std::vector CSCAnodeLCTProcessor::getAllShower() const { +std::vector CSCAnodeLCTProcessor::getAllShower() const { std::vector vshowers(anode_showers_, anode_showers_ + CSCConstants::MAX_ALCT_TBINS); - return vshowers; + return vshowers; }; - + /** Returns shower bits */ -std::vector CSCAnodeLCTProcessor::readoutShower() const { - unsigned minbx_readout = CSCConstants::LCT_CENTRAL_BX - l1a_window_width/2; - unsigned maxbx_readout = CSCConstants::LCT_CENTRAL_BX + l1a_window_width/2; - unsigned minBXdiff = 2*l1a_window_width;//impossible value +std::vector CSCAnodeLCTProcessor::readoutShower() const { + unsigned minbx_readout = CSCConstants::LCT_CENTRAL_BX - l1a_window_width / 2; + unsigned maxbx_readout = CSCConstants::LCT_CENTRAL_BX + l1a_window_width / 2; + unsigned minBXdiff = 2 * l1a_window_width; //impossible value unsigned minBX = 0; std::vector showerOut; - for (unsigned bx = minbx_readout; bx < maxbx_readout; bx++){ - unsigned bx_diff = (bx > bx-CSCConstants::LCT_CENTRAL_BX ) ? bx-CSCConstants::LCT_CENTRAL_BX : CSCConstants::LCT_CENTRAL_BX-bx; - if (anode_showers_[bx].isValid() and bx_diff < minBXdiff){ - minBXdiff = bx_diff; - minBX = bx; + for (unsigned bx = minbx_readout; bx < maxbx_readout; bx++) { + unsigned bx_diff = (bx > bx - CSCConstants::LCT_CENTRAL_BX) ? bx - CSCConstants::LCT_CENTRAL_BX + : CSCConstants::LCT_CENTRAL_BX - bx; + if (anode_showers_[bx].isValid() and bx_diff < minBXdiff) { + minBXdiff = bx_diff; + minBX = bx; } } - for (unsigned bx = minbx_readout; bx < maxbx_readout; bx++) - if (bx == minBX) showerOut.push_back(anode_showers_[bx]); - return showerOut; + for (unsigned bx = minbx_readout; bx < maxbx_readout; bx++) + if (bx == minBX) + showerOut.push_back(anode_showers_[bx]); + return showerOut; } //////////////////////////////////////////////////////////////////////// @@ -1360,30 +1362,29 @@ void CSCAnodeLCTProcessor::setWireContainer(CSCALCTDigi& alct, CSCALCTDigi::Wire alct.setHits(wireHits); } -void CSCAnodeLCTProcessor::encodeHighMultiplicityBits(){ - +void CSCAnodeLCTProcessor::encodeHighMultiplicityBits() { //numer of layer with hits and number of hits for 0-15 BXs - std::set layersWithHits [CSCConstants::MAX_ALCT_TBINS]; - unsigned hitsInTime [CSCConstants::MAX_ALCT_TBINS]; + std::set layersWithHits[CSCConstants::MAX_ALCT_TBINS]; + unsigned hitsInTime[CSCConstants::MAX_ALCT_TBINS]; // Calculate layers with hits - for (unsigned bx = 0; bx < CSCConstants::MAX_ALCT_TBINS; bx++){ + for (unsigned bx = 0; bx < CSCConstants::MAX_ALCT_TBINS; bx++) { hitsInTime[bx] = 0; for (unsigned i_layer = 0; i_layer < CSCConstants::NUM_LAYERS; i_layer++) { bool atLeastOneWGHit = false; for (const auto& wd : digiV[i_layer]) { std::vector bx_times = wd.getTimeBinsOn(); // there is at least one wiregroup in this bx - if (std::find(bx_times.begin(), bx_times.end(), bx) != bx_times.end()){ - hitsInTime[bx] += 1; - atLeastOneWGHit = true; + if (std::find(bx_times.begin(), bx_times.end(), bx) != bx_times.end()) { + hitsInTime[bx] += 1; + atLeastOneWGHit = true; } } - // add this layer to the number of layers hit + // add this layer to the number of layers hit if (atLeastOneWGHit) { - layersWithHits[bx].insert(i_layer); + layersWithHits[bx].insert(i_layer); } } - }//end of full bx loop + } //end of full bx loop // convert station and ring number to index // index runs from 2 to 10, subtract 2 @@ -1393,18 +1394,19 @@ void CSCAnodeLCTProcessor::encodeHighMultiplicityBits(){ std::vector station_thresholds = { thresholds_[csc_idx * 3], thresholds_[csc_idx * 3 + 1], thresholds_[csc_idx * 3 + 2]}; - for (unsigned bx = 0; bx < CSCConstants::MAX_ALCT_TBINS; bx++){ - unsigned minbx = bx >= showerNumTBins_/2 ? bx-showerNumTBins_/2 : bx; - unsigned maxbx = bx < CSCConstants::MAX_ALCT_TBINS - showerNumTBins_/2 ? bx+showerNumTBins_/2 : CSCConstants::MAX_ALCT_TBINS - 1; + for (unsigned bx = 0; bx < CSCConstants::MAX_ALCT_TBINS; bx++) { + unsigned minbx = bx >= showerNumTBins_ / 2 ? bx - showerNumTBins_ / 2 : bx; + unsigned maxbx = bx < CSCConstants::MAX_ALCT_TBINS - showerNumTBins_ / 2 ? bx + showerNumTBins_ / 2 + : CSCConstants::MAX_ALCT_TBINS - 1; unsigned this_hitsInTime = 0; - for (unsigned mbx = minbx; mbx <= maxbx; mbx++){ + for (unsigned mbx = minbx; mbx <= maxbx; mbx++) { this_hitsInTime += hitsInTime[mbx]; } unsigned this_inTimeHMT = 0; // require at least nLayersWithHits for the central time bin // do nothing if there are not enough layers with hits - if (layersWithHits[bx].size() >= minLayersCentralTBin_){ + if (layersWithHits[bx].size() >= minLayersCentralTBin_) { // assign the bits for (unsigned i = 0; i < station_thresholds.size(); i++) { if (this_hitsInTime >= station_thresholds[i]) { @@ -1413,6 +1415,6 @@ void CSCAnodeLCTProcessor::encodeHighMultiplicityBits(){ } } //ALCT shower construction with showerType_=1, comparatorhits_= 0; - anode_showers_[bx] = CSCShowerDigi(this_inTimeHMT, false, theTrigChamber, bx, 1, this_hitsInTime, 0); + anode_showers_[bx] = CSCShowerDigi(this_inTimeHMT, false, theTrigChamber, bx, 1, this_hitsInTime, 0); } } diff --git a/L1Trigger/CSCTriggerPrimitives/src/CSCCathodeLCTProcessor.cc b/L1Trigger/CSCTriggerPrimitives/src/CSCCathodeLCTProcessor.cc index 102e4d5995e48..5efc1f2bbbf47 100644 --- a/L1Trigger/CSCTriggerPrimitives/src/CSCCathodeLCTProcessor.cc +++ b/L1Trigger/CSCTriggerPrimitives/src/CSCCathodeLCTProcessor.cc @@ -97,7 +97,7 @@ CSCCathodeLCTProcessor::CSCCathodeLCTProcessor(unsigned endcap, thresholds_ = shower.getParameter>("showerThresholds"); showerNumTBins_ = shower.getParameter("showerNumTBins"); minLayersCentralTBin_ = shower.getParameter("minLayersCentralTBin"); - peakCheck_ = shower.getParameter("peakCheck"); + peakCheck_ = shower.getParameter("peakCheck"); thePreTriggerDigis.clear(); // quality control of stubs @@ -1200,46 +1200,47 @@ CSCCLCTDigi CSCCathodeLCTProcessor::getSecondCLCT(int bx) const { } /** return vector of CSCShower digi **/ -std::vector CSCCathodeLCTProcessor::getAllShower() const { +std::vector CSCCathodeLCTProcessor::getAllShower() const { std::vector vshowers(cathode_showers_, cathode_showers_ + CSCConstants::MAX_CLCT_TBINS); - return vshowers; + return vshowers; }; - + /** Returns shower bits */ -std::vector CSCCathodeLCTProcessor::readoutShower() const { - unsigned minbx_readout = CSCConstants::LCT_CENTRAL_BX - tmb_l1a_window_size/2; - unsigned maxbx_readout = CSCConstants::LCT_CENTRAL_BX + tmb_l1a_window_size/2; +std::vector CSCCathodeLCTProcessor::readoutShower() const { + unsigned minbx_readout = CSCConstants::LCT_CENTRAL_BX - tmb_l1a_window_size / 2; + unsigned maxbx_readout = CSCConstants::LCT_CENTRAL_BX + tmb_l1a_window_size / 2; std::vector showerOut; for (unsigned bx = minbx_readout; bx < maxbx_readout; bx++) - if (cathode_showers_[bx].isValid()) showerOut.push_back(cathode_showers_[bx]); - return showerOut; + if (cathode_showers_[bx].isValid()) + showerOut.push_back(cathode_showers_[bx]); + return showerOut; } -void CSCCathodeLCTProcessor::encodeHighMultiplicityBits(){ +void CSCCathodeLCTProcessor::encodeHighMultiplicityBits() { //inTimeHMT_ = 0; //numer of layer with hits and number of hits for 0-15 BXs - std::set layersWithHits [CSCConstants::MAX_CLCT_TBINS]; - unsigned hitsInTime [CSCConstants::MAX_CLCT_TBINS]; + std::set layersWithHits[CSCConstants::MAX_CLCT_TBINS]; + unsigned hitsInTime[CSCConstants::MAX_CLCT_TBINS]; // Calculate layers with hits - for (unsigned bx = 0; bx < CSCConstants::MAX_CLCT_TBINS; bx++){ + for (unsigned bx = 0; bx < CSCConstants::MAX_CLCT_TBINS; bx++) { hitsInTime[bx] = 0; for (unsigned i_layer = 0; i_layer < CSCConstants::NUM_LAYERS; i_layer++) { bool atLeastOneCompHit = false; for (const auto& compdigi : digiV[i_layer]) { std::vector bx_times = compdigi.getTimeBinsOn(); // there is at least one comparator digi in this bx - if (std::find(bx_times.begin(), bx_times.end(), bx) != bx_times.end()){ - hitsInTime[bx] += 1; - atLeastOneCompHit = true; + if (std::find(bx_times.begin(), bx_times.end(), bx) != bx_times.end()) { + hitsInTime[bx] += 1; + atLeastOneCompHit = true; } } - // add this layer to the number of layers hit + // add this layer to the number of layers hit if (atLeastOneCompHit) { - layersWithHits[bx].insert(i_layer); + layersWithHits[bx].insert(i_layer); } } - }//end of full bx loop + } //end of full bx loop // convert station and ring number to index // index runs from 2 to 10, subtract 2 @@ -1249,48 +1250,50 @@ void CSCCathodeLCTProcessor::encodeHighMultiplicityBits(){ std::vector station_thresholds = { thresholds_[csc_idx * 3], thresholds_[csc_idx * 3 + 1], thresholds_[csc_idx * 3 + 2]}; - //hard coded dead time as 2Bx, since showerNumTBins = 3, like firmware + //hard coded dead time as 2Bx, since showerNumTBins = 3, like firmware // for example, nhits = 0 at bx7; = 100 at bx8; = 0 at bx9 //cathode HMT must be triggered at bx8, not bx7 and bx9 //meanwhile we forced 2BX dead time after active shower trigger - unsigned int deadtime = showerNumTBins_-1;// firmware hard coded dead time as 2Bx, since showerNumTBins = 3 in firmware + unsigned int deadtime = + showerNumTBins_ - 1; // firmware hard coded dead time as 2Bx, since showerNumTBins = 3 in firmware unsigned int dead_count = 0; bool dead_status = false; - for (unsigned bx = 0; bx < CSCConstants::MAX_CLCT_TBINS; bx++){ - unsigned minbx = bx >= showerNumTBins_/2 ? bx-showerNumTBins_/2 : bx; - unsigned maxbx = bx < CSCConstants::MAX_CLCT_TBINS - showerNumTBins_/2 ? bx+showerNumTBins_/2 : CSCConstants::MAX_CLCT_TBINS - 1; + for (unsigned bx = 0; bx < CSCConstants::MAX_CLCT_TBINS; bx++) { + unsigned minbx = bx >= showerNumTBins_ / 2 ? bx - showerNumTBins_ / 2 : bx; + unsigned maxbx = bx < CSCConstants::MAX_CLCT_TBINS - showerNumTBins_ / 2 ? bx + showerNumTBins_ / 2 + : CSCConstants::MAX_CLCT_TBINS - 1; unsigned this_hitsInTime = 0; - bool isPeak = true;//check whether total hits in bx is peak of nhits over time bins + bool isPeak = true; //check whether total hits in bx is peak of nhits over time bins /*following is to count number of hits over [minbx, maxbx], showerNumTBins=3 =>[n-1, n+1]*/ - for (unsigned mbx = minbx; mbx <= maxbx; mbx++){ + for (unsigned mbx = minbx; mbx <= maxbx; mbx++) { this_hitsInTime += hitsInTime[mbx]; } - - if (peakCheck_ and bx < CSCConstants::MAX_CLCT_TBINS - showerNumTBins_/2 - 1){ - if (hitsInTime[minbx] < hitsInTime[maxbx+1] or (hitsInTime[minbx] == hitsInTime[maxbx+1] and hitsInTime[bx] < hitsInTime[bx+1])) - isPeak = false; //next bx would have more hits or in the center + + if (peakCheck_ and bx < CSCConstants::MAX_CLCT_TBINS - showerNumTBins_ / 2 - 1) { + if (hitsInTime[minbx] < hitsInTime[maxbx + 1] or + (hitsInTime[minbx] == hitsInTime[maxbx + 1] and hitsInTime[bx] < hitsInTime[bx + 1])) + isPeak = false; //next bx would have more hits or in the center } - if (dead_count > 0){ + if (dead_count > 0) { dead_count--; dead_status = true; - }else + } else dead_status = false; unsigned this_inTimeHMT = 0; // require at least nLayersWithHits for the central time bin // do nothing if there are not enough layers with hits - if (layersWithHits[bx].size() >= minLayersCentralTBin_ and !dead_status and isPeak){ + if (layersWithHits[bx].size() >= minLayersCentralTBin_ and !dead_status and isPeak) { // assign the bits for (unsigned i = 0; i < station_thresholds.size(); i++) { if (this_hitsInTime >= station_thresholds[i]) { this_inTimeHMT = i + 1; - dead_count = deadtime; + dead_count = deadtime; } } } //CLCTshower constructor with showerType_ = 2, wirehits = 0; cathode_showers_[bx] = CSCShowerDigi(this_inTimeHMT, false, theTrigChamber, bx, 2, 0, this_hitsInTime); } - } diff --git a/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboard.cc b/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboard.cc index 8bd8cfd5be3f9..cd2cdf95e2303 100644 --- a/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboard.cc +++ b/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboard.cc @@ -55,7 +55,7 @@ CSCMotherboard::CSCMotherboard(unsigned endcap, allLCTs_.setMatchTrigWindowSize(match_trig_window_size); // get the preferred CLCT BX match array - preferred_bx_match_ = tmbParams_.getParameter >("preferredBxMatch"); + preferred_bx_match_ = tmbParams_.getParameter>("preferredBxMatch"); // quality assignment qualityAssignment_ = std::make_unique(endcap, station, sector, subsector, chamber, conf); @@ -369,23 +369,25 @@ std::vector CSCMotherboard::readoutLCTs() const { return tmpV; } -std::vector CSCMotherboard::readoutShower() const { - unsigned minbx_readout = CSCConstants::LCT_CENTRAL_BX - tmb_l1a_window_size/2; - unsigned maxbx_readout = CSCConstants::LCT_CENTRAL_BX + tmb_l1a_window_size/2; - unsigned minBXdiff = 2*tmb_l1a_window_size;//impossible value +std::vector CSCMotherboard::readoutShower() const { + unsigned minbx_readout = CSCConstants::LCT_CENTRAL_BX - tmb_l1a_window_size / 2; + unsigned maxbx_readout = CSCConstants::LCT_CENTRAL_BX + tmb_l1a_window_size / 2; + unsigned minBXdiff = 2 * tmb_l1a_window_size; //impossible value unsigned minBX = 0; std::vector showerOut; - for (unsigned bx = minbx_readout; bx < maxbx_readout; bx++){ - unsigned bx_diff = (bx > bx-CSCConstants::LCT_CENTRAL_BX ) ? bx-CSCConstants::LCT_CENTRAL_BX : CSCConstants::LCT_CENTRAL_BX-bx; - if (showers_[bx].isValid() and bx_diff < minBXdiff){ - minBXdiff = bx_diff; - minBX = bx; + for (unsigned bx = minbx_readout; bx < maxbx_readout; bx++) { + unsigned bx_diff = (bx > bx - CSCConstants::LCT_CENTRAL_BX) ? bx - CSCConstants::LCT_CENTRAL_BX + : CSCConstants::LCT_CENTRAL_BX - bx; + if (showers_[bx].isValid() and bx_diff < minBXdiff) { + minBXdiff = bx_diff; + minBX = bx; } } - for (unsigned bx = minbx_readout; bx < maxbx_readout; bx++) - if (bx == minBX) showerOut.push_back(showers_[bx]); - return showerOut; + for (unsigned bx = minbx_readout; bx < maxbx_readout; bx++) + if (bx == minBX) + showerOut.push_back(showers_[bx]); + return showerOut; } void CSCMotherboard::correlateLCTs(const CSCALCTDigi& bALCT, @@ -599,14 +601,13 @@ CSCCLCTDigi CSCMotherboard::getBXShiftedCLCT(const CSCCLCTDigi& cLCT) const { return cLCT_shifted; } -void CSCMotherboard::matchShowers(CSCShowerDigi * anode_showers, CSCShowerDigi * cathode_showers, bool andlogic){ - +void CSCMotherboard::matchShowers(CSCShowerDigi* anode_showers, CSCShowerDigi* cathode_showers, bool andlogic) { CSCShowerDigi ashower, cshower; bool used_cshower_mask[CSCConstants::MAX_CLCT_TBINS] = {false}; - for (unsigned bx = 0; bx < CSCConstants::MAX_ALCT_TBINS; bx++){ + for (unsigned bx = 0; bx < CSCConstants::MAX_ALCT_TBINS; bx++) { ashower = anode_showers[bx]; - cshower = CSCShowerDigi();//use empty shower digi to initialize cshower - if (ashower.isValid()){ + cshower = CSCShowerDigi(); //use empty shower digi to initialize cshower + if (ashower.isValid()) { for (unsigned mbx = 0; mbx < match_trig_window_size; mbx++) { int cbx = bx + preferred_bx_match_[mbx] - CSCConstants::ALCT_CLCT_OFFSET; //check bx range [0, CSCConstants::MAX_LCT_TBINS] @@ -614,33 +615,41 @@ void CSCMotherboard::matchShowers(CSCShowerDigi * anode_showers, CSCShowerDigi * continue; if (cathode_showers[cbx].isValid() and not used_cshower_mask[cbx]) { cshower = cathode_showers[cbx]; - used_cshower_mask[cbx] = true; + used_cshower_mask[cbx] = true; break; - } + } } - }else cshower = cathode_showers[bx];//if anode shower is not valid, use the cshower from this bx - - //matched HMT, with and/or logic + } else + cshower = cathode_showers[bx]; //if anode shower is not valid, use the cshower from this bx + + //matched HMT, with and/or logic unsigned matchHMT = 0; if (andlogic) { - if (ashower.isTightInTime() and cshower.isTightInTime()) matchHMT = 3; - else if (ashower.isNominalInTime() and cshower.isNominalInTime()) matchHMT = 2; - else if (ashower.isLooseInTime() and cshower.isLooseInTime()) matchHMT = 1; - }else{ - if (ashower.isTightInTime() or cshower.isTightInTime()) matchHMT = 3; - else if (ashower.isNominalInTime() or cshower.isNominalInTime()) matchHMT = 2; - else if (ashower.isLooseInTime() or cshower.isLooseInTime()) matchHMT = 1; + if (ashower.isTightInTime() and cshower.isTightInTime()) + matchHMT = 3; + else if (ashower.isNominalInTime() and cshower.isNominalInTime()) + matchHMT = 2; + else if (ashower.isLooseInTime() and cshower.isLooseInTime()) + matchHMT = 1; + } else { + if (ashower.isTightInTime() or cshower.isTightInTime()) + matchHMT = 3; + else if (ashower.isNominalInTime() or cshower.isNominalInTime()) + matchHMT = 2; + else if (ashower.isLooseInTime() or cshower.isLooseInTime()) + matchHMT = 1; } //LCTShower with showerType = 3 - showers_[bx] = CSCShowerDigi(matchHMT&3, false, ashower.getCSCID(), bx, 3, ashower.getWireNHits(), cshower.getComparatorNHits()); + showers_[bx] = CSCShowerDigi( + matchHMT & 3, false, ashower.getCSCID(), bx, 3, ashower.getWireNHits(), cshower.getComparatorNHits()); } } void CSCMotherboard::encodeHighMultiplicityBits() { // get the high multiplicity // for anode this reflects what is already in the anode CSCShowerDigi object - CSCShowerDigi cathode_showers [CSCConstants::MAX_CLCT_TBINS]; - CSCShowerDigi anode_showers [CSCConstants::MAX_ALCT_TBINS]; + CSCShowerDigi cathode_showers[CSCConstants::MAX_CLCT_TBINS]; + CSCShowerDigi anode_showers[CSCConstants::MAX_ALCT_TBINS]; auto cshowers_v = clctProc->getAllShower(); auto ashowers_v = alctProc->getAllShower(); @@ -665,5 +674,4 @@ void CSCMotherboard::encodeHighMultiplicityBits() { std::copy(std::begin(anode_showers), std::end(anode_showers), std::begin(showers_)); break; }; - } diff --git a/L1Trigger/CSCTriggerPrimitives/src/CSCTriggerPrimitivesBuilder.cc b/L1Trigger/CSCTriggerPrimitives/src/CSCTriggerPrimitivesBuilder.cc index 1fd5eef2bce21..e8b54327aec2c 100644 --- a/L1Trigger/CSCTriggerPrimitives/src/CSCTriggerPrimitivesBuilder.cc +++ b/L1Trigger/CSCTriggerPrimitives/src/CSCTriggerPrimitivesBuilder.cc @@ -192,13 +192,13 @@ void CSCTriggerPrimitivesBuilder::build(const CSCBadChambers* badChambers, if (checkBadChambers_ && badChambers->isInBadChamber(detid)) continue; - //only process the selected chambers when selectedChambers is not empty - if (!selectedChambers_.empty()) { - if (std::find(selectedChambers_.begin(), selectedChambers_.end(), detid.chamberName()) == - selectedChambers_.end()) { - continue; - } - } + //only process the selected chambers when selectedChambers is not empty + if (!selectedChambers_.empty()) { + if (std::find(selectedChambers_.begin(), selectedChambers_.end(), detid.chamberName()) == + selectedChambers_.end()) { + continue; + } + } const bool upgrade = runPhase2_ and ring == 1; const bool upgradeGE11 = upgrade and stat == 1 and runME11Up_ and runME11ILT_; const bool upgradeGE21 = upgrade and stat == 2 and runME21Up_ and runME21ILT_; @@ -247,9 +247,9 @@ void CSCTriggerPrimitivesBuilder::build(const CSCBadChambers* badChambers, put(pretriggerV, oc_pretrigger, detid, tmb->getCSCName() + " CLCT pre-trigger digi"); put(alctpretriggerV, oc_alctpretrigger, detid, tmb->getCSCName() + " ALCT pre-trigger digi"); - put(shower, oc_shower, detid, tmb->getCSCName()+"TMB shower"); - put(anodeShower, oc_shower_anode, detid, tmb->getCSCName()+"Anode shower"); - put(cathodeShower, oc_shower_cathode, detid, tmb->getCSCName()+"Cathode shower"); + put(shower, oc_shower, detid, tmb->getCSCName() + "TMB shower"); + put(anodeShower, oc_shower_anode, detid, tmb->getCSCName() + "Anode shower"); + put(cathodeShower, oc_shower_cathode, detid, tmb->getCSCName() + "Cathode shower"); //if (shower.isValid()) // oc_shower.insertDigi(detid, shower); //if (anodeShower.isValid()) From e6bd40e0b1acf5bd7806dfa960537a2202e0c88c Mon Sep 17 00:00:00 2001 From: tahuang1991 Date: Thu, 4 Aug 2022 17:53:58 +0200 Subject: [PATCH 03/10] 1.update CSCShowerDigi constructor and the codes that used the constructor 2.Add two more shower types: EMTFShower and GMTShower 3.removed comment-out lines in CSCAnodeLCTProcessor.cc --- DataFormats/CSCDigi/interface/CSCShowerDigi.h | 17 +++++++--- DataFormats/CSCDigi/src/CSCShowerDigi.cc | 31 ++++++++++++++++--- .../CSCRawToDigi/interface/CSCALCTHeader.h | 2 +- .../src/CSCTMBHeader2020_CCLUT.cc | 6 ++-- .../CSCRawToDigi/src/CSCTMBHeader2020_GEM.cc | 6 ++-- .../CSCRawToDigi/src/CSCTMBHeader2020_TMB.cc | 6 ++-- .../implementations_stage2/EMTFBlockME.cc | 4 ++- .../src/CSCAnodeLCTProcessor.cc | 7 ++--- .../src/CSCCathodeLCTProcessor.cc | 3 +- .../src/CSCMotherboard.cc | 9 ++++-- 10 files changed, 63 insertions(+), 28 deletions(-) diff --git a/DataFormats/CSCDigi/interface/CSCShowerDigi.h b/DataFormats/CSCDigi/interface/CSCShowerDigi.h index 78896227eec3d..f637fd89299e1 100644 --- a/DataFormats/CSCDigi/interface/CSCShowerDigi.h +++ b/DataFormats/CSCDigi/interface/CSCShowerDigi.h @@ -11,16 +11,23 @@ class CSCShowerDigi { // Run-3 definitions as provided in DN-20-033 enum Run3Shower { kInvalid = 0, kLoose = 1, kNominal = 2, kTight = 3 }; // Shower types. and showers from OTMB/TMB are assigned with kLCTShower - enum ShowerType { kInvalidShower = 0, kALCTShower = 1, kCLCTShower = 2, kLCTShower = 3 }; + enum ShowerType { + kInvalidShower = 0, + kALCTShower = 1, + kCLCTShower = 2, + kLCTShower = 3, + kEMTFShower = 4, + kGMTShower = 5 + }; /// Constructors CSCShowerDigi(const uint16_t inTimeBits, const uint16_t outTimeBits, const uint16_t cscID, - const uint16_t bx, - const uint16_t showerType, - const uint16_t wireNHits, - const uint16_t compNHits); + const uint16_t bx = 0, + const uint16_t showerType = 4, + const uint16_t wireNHits = 0, + const uint16_t compNHits = 0); /// default CSCShowerDigi(); diff --git a/DataFormats/CSCDigi/src/CSCShowerDigi.cc b/DataFormats/CSCDigi/src/CSCShowerDigi.cc index 415b8c0ac502a..84439efd6b40e 100644 --- a/DataFormats/CSCDigi/src/CSCShowerDigi.cc +++ b/DataFormats/CSCDigi/src/CSCShowerDigi.cc @@ -61,11 +61,34 @@ std::ostream& operator<<(std::ostream& o, const CSCShowerDigi& digi) { compHitsStr += std::to_string(digi.getComparatorNHits()); std::string wireHitsStr(", wireHits "); wireHitsStr += std::to_string(digi.getWireNHits()); + std::string showerStr; + switch (showerType) { + case 0: + showerStr = "Invalid ShowerType"; + break; + case 1: + showerStr = "AnodeShower"; + break; + case 2: + showerStr = "CathodeShower"; + break; + case 3: + showerStr = "MatchedShower"; + break; + case 4: + showerStr = "EMTFShower"; + break; + case 5: + showerStr = "GMTShower"; + break; + default: + showerStr = "UnknownShowerType"; + } - return o << (showerType == 0 - ? "Invalid ShowerType" - : (showerType == 1 ? "ALCTShower" : (showerType == 2 ? "CLCTShower" : "correlatedLCTShower"))) - << ": bx " << digi.getBX() << ", in-time bits " << digi.bitsInTime() << ", out-of-time bits " + //return o << (showerType == 0 + // ? "Invalid ShowerType" + // : (showerType == 1 ? "ALCTShower" : (showerType == 2 ? "CLCTShower" : "correlatedLCTShower"))) + return o << showerStr << ": bx " << digi.getBX() << ", in-time bits " << digi.bitsInTime() << ", out-of-time bits " << digi.bitsOutOfTime() << ((showerType == 1 or showerType == 3) ? wireHitsStr : "") << ((showerType == 2 or showerType == 3) ? compHitsStr : "") << ";"; } diff --git a/EventFilter/CSCRawToDigi/interface/CSCALCTHeader.h b/EventFilter/CSCRawToDigi/interface/CSCALCTHeader.h index 4c4b021e5f14d..938809932a900 100644 --- a/EventFilter/CSCRawToDigi/interface/CSCALCTHeader.h +++ b/EventFilter/CSCRawToDigi/interface/CSCALCTHeader.h @@ -170,7 +170,7 @@ class CSCALCTHeader { for (unsigned bx = 0; bx < header2007.lctBins; bx++) { //CSCID is set to be 0 //ALCTshower, showerType_= 1, wireNHits and ComparatorNHits are not available in data - results.push_back(CSCShowerDigi(theALCTs[bx * 2].reserved & 0x3, 0, 0, bx, 1, 0, 0)); + results.push_back(CSCShowerDigi(theALCTs[bx * 2].reserved & 0x3, 0, 0, bx, CSCShowerDigi::ShowerType::kALCTShower, 0, 0)); } return results; } else diff --git a/EventFilter/CSCRawToDigi/src/CSCTMBHeader2020_CCLUT.cc b/EventFilter/CSCRawToDigi/src/CSCTMBHeader2020_CCLUT.cc index eb830ef41c62b..d320ed1a8aa39 100644 --- a/EventFilter/CSCRawToDigi/src/CSCTMBHeader2020_CCLUT.cc +++ b/EventFilter/CSCRawToDigi/src/CSCTMBHeader2020_CCLUT.cc @@ -168,7 +168,7 @@ CSCShowerDigi CSCTMBHeader2020_CCLUT::showerDigi(uint32_t idlayer) const { uint16_t bx = CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win; //LCTshower with showerType = 3. comparatorNHits from hmt_nhits() and wireNHit is not available CSCShowerDigi result( - hmt_bits & 0x3, (hmt_bits >> 2) & 0x3, cscid, bx, 3, 0, hmt_nhits()); // 2-bits intime, 2-bits out of time + hmt_bits & 0x3, (hmt_bits >> 2) & 0x3, cscid, bx, CSCShowerDigi::ShowerType::kLCTShower, 0, hmt_nhits()); // 2-bits intime, 2-bits out of time return result; } @@ -176,7 +176,7 @@ CSCShowerDigi CSCTMBHeader2020_CCLUT::anodeShowerDigi(uint32_t idlayer) const { uint16_t cscid = bits.cscID; uint16_t bx = CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win; //ALCT shower with showerType = 1. nhits_ is not available from unpack data - CSCShowerDigi result(bits.anode_hmt & 0x3, 0, cscid, bx, 1, 0, 0); // 2-bits intime, no out of time + CSCShowerDigi result(bits.anode_hmt & 0x3, 0, cscid, bx, CSCShowerDigi::ShowerType::kALCTShower, 0, 0); // 2-bits intime, no out of time return result; } @@ -184,7 +184,7 @@ CSCShowerDigi CSCTMBHeader2020_CCLUT::cathodeShowerDigi(uint32_t idlayer) const uint16_t cscid = bits.cscID; uint16_t bx = CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win - bits.hmt_match_win + 3; //CLCT shower with showerType = 2. - CSCShowerDigi result(bits.cathode_hmt & 0x3, 0, cscid, bx, 2, 0, hmt_nhits()); // 2-bits intime, no out of time + CSCShowerDigi result(bits.cathode_hmt & 0x3, 0, cscid, bx, CSCShowerDigi::ShowerType::kCLCTShower, 0, hmt_nhits()); // 2-bits intime, no out of time return result; } diff --git a/EventFilter/CSCRawToDigi/src/CSCTMBHeader2020_GEM.cc b/EventFilter/CSCRawToDigi/src/CSCTMBHeader2020_GEM.cc index f17e85c096ea4..b7563a1213e84 100644 --- a/EventFilter/CSCRawToDigi/src/CSCTMBHeader2020_GEM.cc +++ b/EventFilter/CSCRawToDigi/src/CSCTMBHeader2020_GEM.cc @@ -172,7 +172,7 @@ CSCShowerDigi CSCTMBHeader2020_GEM::showerDigi(uint32_t idlayer) const { uint16_t bx = CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win; //LCTshower with showerType = 3. comparatorNHits from hmt_nhits() and wireNHits is not available CSCShowerDigi result( - hmt_bits & 0x3, (hmt_bits >> 2) & 0x3, cscid, bx, 3, 0, hmt_nhits()); // 2-bits intime, 2-bits out of time + hmt_bits & 0x3, (hmt_bits >> 2) & 0x3, cscid, bx, CSCShowerDigi::ShowerType::kLCTShower, 0, hmt_nhits()); // 2-bits intime, 2-bits out of time return result; } @@ -180,7 +180,7 @@ CSCShowerDigi CSCTMBHeader2020_GEM::anodeShowerDigi(uint32_t idlayer) const { uint16_t cscid = bits.cscID; uint16_t bx = CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win; //ALCT shower with showerType = 1. wireNHits is not available from unpack data - CSCShowerDigi result(bits.anode_hmt & 0x3, 0, cscid, bx, 1, 0, 0); // 2-bits intime, no out of time + CSCShowerDigi result(bits.anode_hmt & 0x3, 0, cscid, bx, CSCShowerDigi::ShowerType::kALCTShower, 0, 0); // 2-bits intime, no out of time return result; } @@ -188,7 +188,7 @@ CSCShowerDigi CSCTMBHeader2020_GEM::cathodeShowerDigi(uint32_t idlayer) const { uint16_t cscid = bits.cscID; uint16_t bx = CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win - bits.hmt_match_win + 3; //CLCT shower with showerType = 2. comparatorNHits from hmt_nhits() - CSCShowerDigi result(bits.cathode_hmt & 0x3, 0, cscid, bx, 2, 0, hmt_nhits()); // 2-bits intime, no out of time + CSCShowerDigi result(bits.cathode_hmt & 0x3, 0, cscid, bx, CSCShowerDigi::ShowerType::kCLCTShower, 0, hmt_nhits()); // 2-bits intime, no out of time return result; } diff --git a/EventFilter/CSCRawToDigi/src/CSCTMBHeader2020_TMB.cc b/EventFilter/CSCRawToDigi/src/CSCTMBHeader2020_TMB.cc index 7486051c8f24c..6873732843c2a 100644 --- a/EventFilter/CSCRawToDigi/src/CSCTMBHeader2020_TMB.cc +++ b/EventFilter/CSCRawToDigi/src/CSCTMBHeader2020_TMB.cc @@ -138,7 +138,7 @@ CSCShowerDigi CSCTMBHeader2020_TMB::showerDigi(uint32_t idlayer) const { uint16_t bx = CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win; //LCTshower with showerType = 3. wireNHits is not avaiable //TMB LCT shower is copied from ALCT shower - CSCShowerDigi result(hmt_bits & 0x3, (hmt_bits >> 2) & 0x3, cscid, bx, 3, 0, 0); // 2-bits intime, 2-bits out of time + CSCShowerDigi result(hmt_bits & 0x3, (hmt_bits >> 2) & 0x3, cscid, bx, CSCShowerDigi::ShowerType::kLCTShower, 0, 0); // 2-bits intime, 2-bits out of time return result; } @@ -146,7 +146,7 @@ CSCShowerDigi CSCTMBHeader2020_TMB::anodeShowerDigi(uint32_t idlayer) const { uint16_t cscid = bits.cscID; uint16_t bx = CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win; //ALCTshower with showerType = 1. wireNHits is not avaiable - CSCShowerDigi result(bits.anode_hmt & 0x3, 0, cscid, bx, 1, 0, 0); // 2-bits intime, no out of time + CSCShowerDigi result(bits.anode_hmt & 0x3, 0, cscid, bx, CSCShowerDigi::ShowerType::kALCTShower, 0, 0); // 2-bits intime, no out of time return result; } @@ -154,7 +154,7 @@ CSCShowerDigi CSCTMBHeader2020_TMB::cathodeShowerDigi(uint32_t idlayer) const { uint16_t cscid = bits.cscID; uint16_t bx = CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win; //CLCTshower with showerType = 2. comparatorNhits is not avaiable for TMB yet - CSCShowerDigi result(bits.cathode_hmt & 0x3, 0, cscid, bx, 2, 0, 0); // 2-bits intime, no out of time + CSCShowerDigi result(bits.cathode_hmt & 0x3, 0, cscid, bx, CSCShowerDigi::ShowerType::kCLCTShower, 0, 0); // 2-bits intime, no out of time return result; } diff --git a/EventFilter/L1TRawToDigi/plugins/implementations_stage2/EMTFBlockME.cc b/EventFilter/L1TRawToDigi/plugins/implementations_stage2/EMTFBlockME.cc index e08a6d8a9f9de..8578d08d502b1 100644 --- a/EventFilter/L1TRawToDigi/plugins/implementations_stage2/EMTFBlockME.cc +++ b/EventFilter/L1TRawToDigi/plugins/implementations_stage2/EMTFBlockME.cc @@ -304,7 +304,9 @@ namespace l1t { // Fill the CSCShowerDigi CSCShowerDigi Shower_(ME_.HMT_inTime() == -99 ? 0 : ME_.HMT_inTime(), ME_.HMT_outOfTime() == -99 ? 0 : ME_.HMT_outOfTime(), - Hit_.CSC_DetId()); + Hit_.CSC_DetId(), + Hit_.BX(), + CSCShowerDigi::ShowerType::kEMTFShower); // Set the stub number for this hit // Each chamber can send up to 2 stubs per BX diff --git a/L1Trigger/CSCTriggerPrimitives/src/CSCAnodeLCTProcessor.cc b/L1Trigger/CSCTriggerPrimitives/src/CSCAnodeLCTProcessor.cc index 2d13d2dafc533..33ce88ec7568e 100644 --- a/L1Trigger/CSCTriggerPrimitives/src/CSCAnodeLCTProcessor.cc +++ b/L1Trigger/CSCTriggerPrimitives/src/CSCAnodeLCTProcessor.cc @@ -85,10 +85,6 @@ CSCAnodeLCTProcessor::CSCAnodeLCTProcessor(unsigned endcap, const auto& shower = showerParams_.getParameterSet("anodeShower"); thresholds_ = shower.getParameter>("showerThresholds"); showerNumTBins_ = shower.getParameter("showerNumTBins"); - //showerMinInTBin_ = shower.getParameter("showerMinInTBin"); - //showerMaxInTBin_ = shower.getParameter("showerMaxInTBin"); - //showerMinOutTBin_ = shower.getParameter("showerMinOutTBin"); - //showerMaxOutTBin_ = shower.getParameter("showerMaxOutTBin"); minLayersCentralTBin_ = shower.getParameter("minLayersCentralTBin"); } @@ -1415,6 +1411,7 @@ void CSCAnodeLCTProcessor::encodeHighMultiplicityBits() { } } //ALCT shower construction with showerType_=1, comparatorhits_= 0; - anode_showers_[bx] = CSCShowerDigi(this_inTimeHMT, false, theTrigChamber, bx, 1, this_hitsInTime, 0); + anode_showers_[bx] = CSCShowerDigi( + this_inTimeHMT, false, theTrigChamber, bx, CSCShowerDigi::ShowerType::kALCTShower, this_hitsInTime, 0); } } diff --git a/L1Trigger/CSCTriggerPrimitives/src/CSCCathodeLCTProcessor.cc b/L1Trigger/CSCTriggerPrimitives/src/CSCCathodeLCTProcessor.cc index 5efc1f2bbbf47..2eff3897e3326 100644 --- a/L1Trigger/CSCTriggerPrimitives/src/CSCCathodeLCTProcessor.cc +++ b/L1Trigger/CSCTriggerPrimitives/src/CSCCathodeLCTProcessor.cc @@ -1294,6 +1294,7 @@ void CSCCathodeLCTProcessor::encodeHighMultiplicityBits() { } } //CLCTshower constructor with showerType_ = 2, wirehits = 0; - cathode_showers_[bx] = CSCShowerDigi(this_inTimeHMT, false, theTrigChamber, bx, 2, 0, this_hitsInTime); + cathode_showers_[bx] = CSCShowerDigi( + this_inTimeHMT, false, theTrigChamber, bx, CSCShowerDigi::ShowerType::kCLCTShower, 0, this_hitsInTime); } } diff --git a/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboard.cc b/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboard.cc index cd2cdf95e2303..c57413908d1a3 100644 --- a/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboard.cc +++ b/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboard.cc @@ -640,8 +640,13 @@ void CSCMotherboard::matchShowers(CSCShowerDigi* anode_showers, CSCShowerDigi* c matchHMT = 1; } //LCTShower with showerType = 3 - showers_[bx] = CSCShowerDigi( - matchHMT & 3, false, ashower.getCSCID(), bx, 3, ashower.getWireNHits(), cshower.getComparatorNHits()); + showers_[bx] = CSCShowerDigi(matchHMT & 3, + false, + ashower.getCSCID(), + bx, + CSCShowerDigi::ShowerType::kLCTShower, + ashower.getWireNHits(), + cshower.getComparatorNHits()); } } From 0c85cf6c1d64493c951690b849ded63ed42552b9 Mon Sep 17 00:00:00 2001 From: tahuang1991 Date: Thu, 4 Aug 2022 18:50:40 +0200 Subject: [PATCH 04/10] fixed the code-format in CSCRawToDigi from scram build code-format --- .../CSCRawToDigi/interface/CSCALCTHeader.h | 3 ++- .../src/CSCTMBHeader2020_CCLUT.cc | 20 +++++++++++++++---- .../CSCRawToDigi/src/CSCTMBHeader2020_GEM.cc | 20 +++++++++++++++---- .../CSCRawToDigi/src/CSCTMBHeader2020_TMB.cc | 19 +++++++++++++++--- 4 files changed, 50 insertions(+), 12 deletions(-) diff --git a/EventFilter/CSCRawToDigi/interface/CSCALCTHeader.h b/EventFilter/CSCRawToDigi/interface/CSCALCTHeader.h index 938809932a900..d2dc5546e400f 100644 --- a/EventFilter/CSCRawToDigi/interface/CSCALCTHeader.h +++ b/EventFilter/CSCRawToDigi/interface/CSCALCTHeader.h @@ -170,7 +170,8 @@ class CSCALCTHeader { for (unsigned bx = 0; bx < header2007.lctBins; bx++) { //CSCID is set to be 0 //ALCTshower, showerType_= 1, wireNHits and ComparatorNHits are not available in data - results.push_back(CSCShowerDigi(theALCTs[bx * 2].reserved & 0x3, 0, 0, bx, CSCShowerDigi::ShowerType::kALCTShower, 0, 0)); + results.push_back( + CSCShowerDigi(theALCTs[bx * 2].reserved & 0x3, 0, 0, bx, CSCShowerDigi::ShowerType::kALCTShower, 0, 0)); } return results; } else diff --git a/EventFilter/CSCRawToDigi/src/CSCTMBHeader2020_CCLUT.cc b/EventFilter/CSCRawToDigi/src/CSCTMBHeader2020_CCLUT.cc index d320ed1a8aa39..f1789fe56775b 100644 --- a/EventFilter/CSCRawToDigi/src/CSCTMBHeader2020_CCLUT.cc +++ b/EventFilter/CSCRawToDigi/src/CSCTMBHeader2020_CCLUT.cc @@ -167,8 +167,13 @@ CSCShowerDigi CSCTMBHeader2020_CCLUT::showerDigi(uint32_t idlayer) const { // same for anode HMT and cathode HMT uint16_t bx = CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win; //LCTshower with showerType = 3. comparatorNHits from hmt_nhits() and wireNHit is not available - CSCShowerDigi result( - hmt_bits & 0x3, (hmt_bits >> 2) & 0x3, cscid, bx, CSCShowerDigi::ShowerType::kLCTShower, 0, hmt_nhits()); // 2-bits intime, 2-bits out of time + CSCShowerDigi result(hmt_bits & 0x3, + (hmt_bits >> 2) & 0x3, + cscid, + bx, + CSCShowerDigi::ShowerType::kLCTShower, + 0, + hmt_nhits()); // 2-bits intime, 2-bits out of time return result; } @@ -176,7 +181,8 @@ CSCShowerDigi CSCTMBHeader2020_CCLUT::anodeShowerDigi(uint32_t idlayer) const { uint16_t cscid = bits.cscID; uint16_t bx = CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win; //ALCT shower with showerType = 1. nhits_ is not available from unpack data - CSCShowerDigi result(bits.anode_hmt & 0x3, 0, cscid, bx, CSCShowerDigi::ShowerType::kALCTShower, 0, 0); // 2-bits intime, no out of time + CSCShowerDigi result( + bits.anode_hmt & 0x3, 0, cscid, bx, CSCShowerDigi::ShowerType::kALCTShower, 0, 0); // 2-bits intime, no out of time return result; } @@ -184,7 +190,13 @@ CSCShowerDigi CSCTMBHeader2020_CCLUT::cathodeShowerDigi(uint32_t idlayer) const uint16_t cscid = bits.cscID; uint16_t bx = CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win - bits.hmt_match_win + 3; //CLCT shower with showerType = 2. - CSCShowerDigi result(bits.cathode_hmt & 0x3, 0, cscid, bx, CSCShowerDigi::ShowerType::kCLCTShower, 0, hmt_nhits()); // 2-bits intime, no out of time + CSCShowerDigi result(bits.cathode_hmt & 0x3, + 0, + cscid, + bx, + CSCShowerDigi::ShowerType::kCLCTShower, + 0, + hmt_nhits()); // 2-bits intime, no out of time return result; } diff --git a/EventFilter/CSCRawToDigi/src/CSCTMBHeader2020_GEM.cc b/EventFilter/CSCRawToDigi/src/CSCTMBHeader2020_GEM.cc index b7563a1213e84..4e393e88601b7 100644 --- a/EventFilter/CSCRawToDigi/src/CSCTMBHeader2020_GEM.cc +++ b/EventFilter/CSCRawToDigi/src/CSCTMBHeader2020_GEM.cc @@ -171,8 +171,13 @@ CSCShowerDigi CSCTMBHeader2020_GEM::showerDigi(uint32_t idlayer) const { // same for anode HMT and cathode HMT. offline analysis would take care of this uint16_t bx = CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win; //LCTshower with showerType = 3. comparatorNHits from hmt_nhits() and wireNHits is not available - CSCShowerDigi result( - hmt_bits & 0x3, (hmt_bits >> 2) & 0x3, cscid, bx, CSCShowerDigi::ShowerType::kLCTShower, 0, hmt_nhits()); // 2-bits intime, 2-bits out of time + CSCShowerDigi result(hmt_bits & 0x3, + (hmt_bits >> 2) & 0x3, + cscid, + bx, + CSCShowerDigi::ShowerType::kLCTShower, + 0, + hmt_nhits()); // 2-bits intime, 2-bits out of time return result; } @@ -180,7 +185,8 @@ CSCShowerDigi CSCTMBHeader2020_GEM::anodeShowerDigi(uint32_t idlayer) const { uint16_t cscid = bits.cscID; uint16_t bx = CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win; //ALCT shower with showerType = 1. wireNHits is not available from unpack data - CSCShowerDigi result(bits.anode_hmt & 0x3, 0, cscid, bx, CSCShowerDigi::ShowerType::kALCTShower, 0, 0); // 2-bits intime, no out of time + CSCShowerDigi result( + bits.anode_hmt & 0x3, 0, cscid, bx, CSCShowerDigi::ShowerType::kALCTShower, 0, 0); // 2-bits intime, no out of time return result; } @@ -188,7 +194,13 @@ CSCShowerDigi CSCTMBHeader2020_GEM::cathodeShowerDigi(uint32_t idlayer) const { uint16_t cscid = bits.cscID; uint16_t bx = CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win - bits.hmt_match_win + 3; //CLCT shower with showerType = 2. comparatorNHits from hmt_nhits() - CSCShowerDigi result(bits.cathode_hmt & 0x3, 0, cscid, bx, CSCShowerDigi::ShowerType::kCLCTShower, 0, hmt_nhits()); // 2-bits intime, no out of time + CSCShowerDigi result(bits.cathode_hmt & 0x3, + 0, + cscid, + bx, + CSCShowerDigi::ShowerType::kCLCTShower, + 0, + hmt_nhits()); // 2-bits intime, no out of time return result; } diff --git a/EventFilter/CSCRawToDigi/src/CSCTMBHeader2020_TMB.cc b/EventFilter/CSCRawToDigi/src/CSCTMBHeader2020_TMB.cc index 6873732843c2a..2f6edfc8252fc 100644 --- a/EventFilter/CSCRawToDigi/src/CSCTMBHeader2020_TMB.cc +++ b/EventFilter/CSCRawToDigi/src/CSCTMBHeader2020_TMB.cc @@ -138,7 +138,13 @@ CSCShowerDigi CSCTMBHeader2020_TMB::showerDigi(uint32_t idlayer) const { uint16_t bx = CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win; //LCTshower with showerType = 3. wireNHits is not avaiable //TMB LCT shower is copied from ALCT shower - CSCShowerDigi result(hmt_bits & 0x3, (hmt_bits >> 2) & 0x3, cscid, bx, CSCShowerDigi::ShowerType::kLCTShower, 0, 0); // 2-bits intime, 2-bits out of time + CSCShowerDigi result(hmt_bits & 0x3, + (hmt_bits >> 2) & 0x3, + cscid, + bx, + CSCShowerDigi::ShowerType::kLCTShower, + 0, + 0); // 2-bits intime, 2-bits out of time return result; } @@ -146,7 +152,8 @@ CSCShowerDigi CSCTMBHeader2020_TMB::anodeShowerDigi(uint32_t idlayer) const { uint16_t cscid = bits.cscID; uint16_t bx = CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win; //ALCTshower with showerType = 1. wireNHits is not avaiable - CSCShowerDigi result(bits.anode_hmt & 0x3, 0, cscid, bx, CSCShowerDigi::ShowerType::kALCTShower, 0, 0); // 2-bits intime, no out of time + CSCShowerDigi result( + bits.anode_hmt & 0x3, 0, cscid, bx, CSCShowerDigi::ShowerType::kALCTShower, 0, 0); // 2-bits intime, no out of time return result; } @@ -154,7 +161,13 @@ CSCShowerDigi CSCTMBHeader2020_TMB::cathodeShowerDigi(uint32_t idlayer) const { uint16_t cscid = bits.cscID; uint16_t bx = CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win; //CLCTshower with showerType = 2. comparatorNhits is not avaiable for TMB yet - CSCShowerDigi result(bits.cathode_hmt & 0x3, 0, cscid, bx, CSCShowerDigi::ShowerType::kCLCTShower, 0, 0); // 2-bits intime, no out of time + CSCShowerDigi result(bits.cathode_hmt & 0x3, + 0, + cscid, + bx, + CSCShowerDigi::ShowerType::kCLCTShower, + 0, + 0); // 2-bits intime, no out of time return result; } From 35ff4e1f120b45366ae4db4ecb5112935336eb8d Mon Sep 17 00:00:00 2001 From: Martin Date: Mon, 8 Aug 2022 16:51:26 +0200 Subject: [PATCH 05/10] change class version to 12 --- DataFormats/CSCDigi/src/classes_def.xml | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/DataFormats/CSCDigi/src/classes_def.xml b/DataFormats/CSCDigi/src/classes_def.xml index 7eebb15fcfaeb..28e2a0113e2df 100644 --- a/DataFormats/CSCDigi/src/classes_def.xml +++ b/DataFormats/CSCDigi/src/classes_def.xml @@ -39,9 +39,8 @@ - - - + + From 5eb66037a3fe46e47876ae64512ddcb10a5cdc49 Mon Sep 17 00:00:00 2001 From: Martin Date: Thu, 18 Aug 2022 13:16:54 +0200 Subject: [PATCH 06/10] remove commented lines --- DataFormats/CSCDigi/src/CSCShowerDigi.cc | 3 --- 1 file changed, 3 deletions(-) diff --git a/DataFormats/CSCDigi/src/CSCShowerDigi.cc b/DataFormats/CSCDigi/src/CSCShowerDigi.cc index 84439efd6b40e..e79ab6453bdcc 100644 --- a/DataFormats/CSCDigi/src/CSCShowerDigi.cc +++ b/DataFormats/CSCDigi/src/CSCShowerDigi.cc @@ -85,9 +85,6 @@ std::ostream& operator<<(std::ostream& o, const CSCShowerDigi& digi) { showerStr = "UnknownShowerType"; } - //return o << (showerType == 0 - // ? "Invalid ShowerType" - // : (showerType == 1 ? "ALCTShower" : (showerType == 2 ? "CLCTShower" : "correlatedLCTShower"))) return o << showerStr << ": bx " << digi.getBX() << ", in-time bits " << digi.bitsInTime() << ", out-of-time bits " << digi.bitsOutOfTime() << ((showerType == 1 or showerType == 3) ? wireHitsStr : "") << ((showerType == 2 or showerType == 3) ? compHitsStr : "") << ";"; From 712e67041262b5428b5f7101256cf2bbdbbf9f04 Mon Sep 17 00:00:00 2001 From: Martin Date: Mon, 29 Aug 2022 11:45:40 +0200 Subject: [PATCH 07/10] move minbx_readout, maxbx_readout to header, assert minbx_readout>0 --- .../src/CSCTMBHeader2020_CCLUT.cc | 7 +++--- .../interface/CSCAnodeLCTProcessor.h | 2 ++ .../interface/CSCCathodeLCTProcessor.h | 2 ++ .../interface/CSCMotherboard.h | 2 ++ .../src/CSCAnodeLCTProcessor.cc | 18 +++++++------ .../src/CSCCathodeLCTProcessor.cc | 25 ++++++++++--------- .../src/CSCMotherboard.cc | 10 +++++--- 7 files changed, 39 insertions(+), 27 deletions(-) diff --git a/EventFilter/CSCRawToDigi/src/CSCTMBHeader2020_CCLUT.cc b/EventFilter/CSCRawToDigi/src/CSCTMBHeader2020_CCLUT.cc index f1789fe56775b..a1d539d99b5a7 100644 --- a/EventFilter/CSCRawToDigi/src/CSCTMBHeader2020_CCLUT.cc +++ b/EventFilter/CSCRawToDigi/src/CSCTMBHeader2020_CCLUT.cc @@ -293,10 +293,9 @@ void CSCTMBHeader2020_CCLUT::addCorrelatedLCT1(const CSCCorrelatedLCTDigi& digi) } void CSCTMBHeader2020_CCLUT::addShower(const CSCShowerDigi& digi) { - uint16_t hmt_bits = (digi.bitsInTime() & 0x3) + ((digi.bitsOutOfTime() & 0x3) << 2); - //not valid LCT shower, then in-time bits must be 0. keep out-of-time HMT - if (not digi.isValid()) - hmt_bits = ((digi.bitsOutOfTime() & 0x3) << 2); + uint16_t hmt_bits = digi.isValid() ? (digi.bitsInTime() & 0x3) + ((digi.bitsOutOfTime() & 0x3) << 2) + //if not valid LCT shower, then in-time bits must be 0. keep out-of-time HMT: + : ((digi.bitsOutOfTime() & 0x3) << 2); bits.MPC_Muon_HMT_bit0 = hmt_bits & 0x1; bits.MPC_Muon_HMT_high = (hmt_bits >> 1) & 0x7; //to keep pop_l1a_match_win diff --git a/L1Trigger/CSCTriggerPrimitives/interface/CSCAnodeLCTProcessor.h b/L1Trigger/CSCTriggerPrimitives/interface/CSCAnodeLCTProcessor.h index 11f01af9278e2..0005946ff8fb8 100644 --- a/L1Trigger/CSCTriggerPrimitives/interface/CSCAnodeLCTProcessor.h +++ b/L1Trigger/CSCTriggerPrimitives/interface/CSCAnodeLCTProcessor.h @@ -130,6 +130,8 @@ class CSCAnodeLCTProcessor : public CSCBaseboard { std::vector thresholds_; unsigned showerNumTBins_; unsigned minLayersCentralTBin_; + unsigned minbx_readout_; + unsigned maxbx_readout_; /** Configuration parameters. */ unsigned int fifo_tbins, fifo_pretrig, drift_delay; diff --git a/L1Trigger/CSCTriggerPrimitives/interface/CSCCathodeLCTProcessor.h b/L1Trigger/CSCTriggerPrimitives/interface/CSCCathodeLCTProcessor.h index fa93609ae8df1..5aacd295f25da 100644 --- a/L1Trigger/CSCTriggerPrimitives/interface/CSCCathodeLCTProcessor.h +++ b/L1Trigger/CSCTriggerPrimitives/interface/CSCCathodeLCTProcessor.h @@ -195,6 +195,8 @@ class CSCCathodeLCTProcessor : public CSCBaseboard { std::vector thresholds_; unsigned showerNumTBins_; unsigned minLayersCentralTBin_; + unsigned minbx_readout_; + unsigned maxbx_readout_; /** check the peak of total hits and single bx hits for cathode HMT */ bool peakCheck_; diff --git a/L1Trigger/CSCTriggerPrimitives/interface/CSCMotherboard.h b/L1Trigger/CSCTriggerPrimitives/interface/CSCMotherboard.h index f2fb3df3ce39c..98cbc65872623 100644 --- a/L1Trigger/CSCTriggerPrimitives/interface/CSCMotherboard.h +++ b/L1Trigger/CSCTriggerPrimitives/interface/CSCMotherboard.h @@ -149,6 +149,8 @@ class CSCMotherboard : public CSCBaseboard { // encode special bits for high-multiplicity triggers std::vector showerSource_; unsigned thisShowerSource_; + unsigned minbx_readout_; + unsigned maxbx_readout_; bool ignoreAlctCrossClct_; diff --git a/L1Trigger/CSCTriggerPrimitives/src/CSCAnodeLCTProcessor.cc b/L1Trigger/CSCTriggerPrimitives/src/CSCAnodeLCTProcessor.cc index 33ce88ec7568e..e054cf3b8638c 100644 --- a/L1Trigger/CSCTriggerPrimitives/src/CSCAnodeLCTProcessor.cc +++ b/L1Trigger/CSCTriggerPrimitives/src/CSCAnodeLCTProcessor.cc @@ -86,6 +86,9 @@ CSCAnodeLCTProcessor::CSCAnodeLCTProcessor(unsigned endcap, thresholds_ = shower.getParameter>("showerThresholds"); showerNumTBins_ = shower.getParameter("showerNumTBins"); minLayersCentralTBin_ = shower.getParameter("minLayersCentralTBin"); + minbx_readout_ = CSCConstants::LCT_CENTRAL_BX - l1a_window_width / 2; + maxbx_readout_ = CSCConstants::LCT_CENTRAL_BX + l1a_window_width / 2; + assert(minbx_readout_ > 0); } void CSCAnodeLCTProcessor::loadPatternMask() { @@ -1281,12 +1284,10 @@ std::vector CSCAnodeLCTProcessor::getAllShower() const { /** Returns shower bits */ std::vector CSCAnodeLCTProcessor::readoutShower() const { - unsigned minbx_readout = CSCConstants::LCT_CENTRAL_BX - l1a_window_width / 2; - unsigned maxbx_readout = CSCConstants::LCT_CENTRAL_BX + l1a_window_width / 2; unsigned minBXdiff = 2 * l1a_window_width; //impossible value unsigned minBX = 0; std::vector showerOut; - for (unsigned bx = minbx_readout; bx < maxbx_readout; bx++) { + for (unsigned bx = minbx_readout_; bx < maxbx_readout_; bx++) { unsigned bx_diff = (bx > bx - CSCConstants::LCT_CENTRAL_BX) ? bx - CSCConstants::LCT_CENTRAL_BX : CSCConstants::LCT_CENTRAL_BX - bx; if (anode_showers_[bx].isValid() and bx_diff < minBXdiff) { @@ -1295,7 +1296,7 @@ std::vector CSCAnodeLCTProcessor::readoutShower() const { } } - for (unsigned bx = minbx_readout; bx < maxbx_readout; bx++) + for (unsigned bx = minbx_readout_; bx < maxbx_readout_; bx++) if (bx == minBX) showerOut.push_back(anode_showers_[bx]); return showerOut; @@ -1404,9 +1405,12 @@ void CSCAnodeLCTProcessor::encodeHighMultiplicityBits() { // do nothing if there are not enough layers with hits if (layersWithHits[bx].size() >= minLayersCentralTBin_) { // assign the bits - for (unsigned i = 0; i < station_thresholds.size(); i++) { - if (this_hitsInTime >= station_thresholds[i]) { - this_inTimeHMT = i + 1; + if (!station_thresholds.empty()) { + for (int i = station_thresholds.size() - 1; i >= 0; i--) { + if (this_hitsInTime >= station_thresholds[i]) { + this_inTimeHMT = i + 1; + break; + } } } } diff --git a/L1Trigger/CSCTriggerPrimitives/src/CSCCathodeLCTProcessor.cc b/L1Trigger/CSCTriggerPrimitives/src/CSCCathodeLCTProcessor.cc index 2eff3897e3326..afad90ba66ec3 100644 --- a/L1Trigger/CSCTriggerPrimitives/src/CSCCathodeLCTProcessor.cc +++ b/L1Trigger/CSCTriggerPrimitives/src/CSCCathodeLCTProcessor.cc @@ -98,6 +98,9 @@ CSCCathodeLCTProcessor::CSCCathodeLCTProcessor(unsigned endcap, showerNumTBins_ = shower.getParameter("showerNumTBins"); minLayersCentralTBin_ = shower.getParameter("minLayersCentralTBin"); peakCheck_ = shower.getParameter("peakCheck"); + minbx_readout_ = CSCConstants::LCT_CENTRAL_BX - tmb_l1a_window_size / 2; + maxbx_readout_ = CSCConstants::LCT_CENTRAL_BX + tmb_l1a_window_size / 2; + assert(minbx_readout_ > 0); thePreTriggerDigis.clear(); // quality control of stubs @@ -1207,10 +1210,8 @@ std::vector CSCCathodeLCTProcessor::getAllShower() const { /** Returns shower bits */ std::vector CSCCathodeLCTProcessor::readoutShower() const { - unsigned minbx_readout = CSCConstants::LCT_CENTRAL_BX - tmb_l1a_window_size / 2; - unsigned maxbx_readout = CSCConstants::LCT_CENTRAL_BX + tmb_l1a_window_size / 2; std::vector showerOut; - for (unsigned bx = minbx_readout; bx < maxbx_readout; bx++) + for (unsigned bx = minbx_readout_; bx < maxbx_readout_; bx++) if (cathode_showers_[bx].isValid()) showerOut.push_back(cathode_showers_[bx]); return showerOut; @@ -1257,7 +1258,6 @@ void CSCCathodeLCTProcessor::encodeHighMultiplicityBits() { unsigned int deadtime = showerNumTBins_ - 1; // firmware hard coded dead time as 2Bx, since showerNumTBins = 3 in firmware unsigned int dead_count = 0; - bool dead_status = false; for (unsigned bx = 0; bx < CSCConstants::MAX_CLCT_TBINS; bx++) { unsigned minbx = bx >= showerNumTBins_ / 2 ? bx - showerNumTBins_ / 2 : bx; @@ -1275,21 +1275,22 @@ void CSCCathodeLCTProcessor::encodeHighMultiplicityBits() { (hitsInTime[minbx] == hitsInTime[maxbx + 1] and hitsInTime[bx] < hitsInTime[bx + 1])) isPeak = false; //next bx would have more hits or in the center } - if (dead_count > 0) { + bool dead_status = dead_count > 0; + if (dead_status) dead_count--; - dead_status = true; - } else - dead_status = false; unsigned this_inTimeHMT = 0; // require at least nLayersWithHits for the central time bin // do nothing if there are not enough layers with hits if (layersWithHits[bx].size() >= minLayersCentralTBin_ and !dead_status and isPeak) { // assign the bits - for (unsigned i = 0; i < station_thresholds.size(); i++) { - if (this_hitsInTime >= station_thresholds[i]) { - this_inTimeHMT = i + 1; - dead_count = deadtime; + if (!station_thresholds.empty()) { + for (int i = station_thresholds.size() - 1; i >= 0; i--) { + if (this_hitsInTime >= station_thresholds[i]) { + this_inTimeHMT = i + 1; + dead_count = deadtime; + break; + } } } } diff --git a/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboard.cc b/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboard.cc index c57413908d1a3..0a62263e80616 100644 --- a/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboard.cc +++ b/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboard.cc @@ -66,6 +66,10 @@ CSCMotherboard::CSCMotherboard(unsigned endcap, // shower-trigger source showerSource_ = showerParams_.getParameter>("source"); + minbx_readout_ = CSCConstants::LCT_CENTRAL_BX - tmb_l1a_window_size / 2; + maxbx_readout_ = CSCConstants::LCT_CENTRAL_BX + tmb_l1a_window_size / 2; + assert(minbx_readout_ > 0); + unsigned csc_idx = CSCDetId::iChamberType(theStation, theRing) - 2; thisShowerSource_ = showerSource_[csc_idx]; @@ -370,12 +374,10 @@ std::vector CSCMotherboard::readoutLCTs() const { } std::vector CSCMotherboard::readoutShower() const { - unsigned minbx_readout = CSCConstants::LCT_CENTRAL_BX - tmb_l1a_window_size / 2; - unsigned maxbx_readout = CSCConstants::LCT_CENTRAL_BX + tmb_l1a_window_size / 2; unsigned minBXdiff = 2 * tmb_l1a_window_size; //impossible value unsigned minBX = 0; std::vector showerOut; - for (unsigned bx = minbx_readout; bx < maxbx_readout; bx++) { + for (unsigned bx = minbx_readout_; bx < maxbx_readout_; bx++) { unsigned bx_diff = (bx > bx - CSCConstants::LCT_CENTRAL_BX) ? bx - CSCConstants::LCT_CENTRAL_BX : CSCConstants::LCT_CENTRAL_BX - bx; if (showers_[bx].isValid() and bx_diff < minBXdiff) { @@ -384,7 +386,7 @@ std::vector CSCMotherboard::readoutShower() const { } } - for (unsigned bx = minbx_readout; bx < maxbx_readout; bx++) + for (unsigned bx = minbx_readout_; bx < maxbx_readout_; bx++) if (bx == minBX) showerOut.push_back(showers_[bx]); return showerOut; From 961576d73120fc31f27ad175fbfa4b84ef8faf3f Mon Sep 17 00:00:00 2001 From: Martin Date: Mon, 29 Aug 2022 14:17:16 +0200 Subject: [PATCH 08/10] update readout range config --- .../CSCTriggerPrimitives/src/CSCAnodeLCTProcessor.cc | 11 ++++++++--- .../src/CSCCathodeLCTProcessor.cc | 10 +++++++--- L1Trigger/CSCTriggerPrimitives/src/CSCMotherboard.cc | 9 +++++---- 3 files changed, 20 insertions(+), 10 deletions(-) diff --git a/L1Trigger/CSCTriggerPrimitives/src/CSCAnodeLCTProcessor.cc b/L1Trigger/CSCTriggerPrimitives/src/CSCAnodeLCTProcessor.cc index e054cf3b8638c..9d02793416a61 100644 --- a/L1Trigger/CSCTriggerPrimitives/src/CSCAnodeLCTProcessor.cc +++ b/L1Trigger/CSCTriggerPrimitives/src/CSCAnodeLCTProcessor.cc @@ -86,9 +86,6 @@ CSCAnodeLCTProcessor::CSCAnodeLCTProcessor(unsigned endcap, thresholds_ = shower.getParameter>("showerThresholds"); showerNumTBins_ = shower.getParameter("showerNumTBins"); minLayersCentralTBin_ = shower.getParameter("minLayersCentralTBin"); - minbx_readout_ = CSCConstants::LCT_CENTRAL_BX - l1a_window_width / 2; - maxbx_readout_ = CSCConstants::LCT_CENTRAL_BX + l1a_window_width / 2; - assert(minbx_readout_ > 0); } void CSCAnodeLCTProcessor::loadPatternMask() { @@ -112,6 +109,8 @@ void CSCAnodeLCTProcessor::setDefaultConfigParameters() { trig_mode = def_trig_mode; accel_mode = def_accel_mode; l1a_window_width = def_l1a_window_width; + minbx_readout_ = CSCConstants::LCT_CENTRAL_BX - l1a_window_width / 2; + maxbx_readout_ = CSCConstants::LCT_CENTRAL_BX + l1a_window_width / 2; } // Set configuration parameters obtained via EventSetup mechanism. @@ -135,6 +134,9 @@ void CSCAnodeLCTProcessor::setConfigParameters(const CSCDBL1TPParameters* conf) dumpConfigParams(); config_dumped = true; } + minbx_readout_ = CSCConstants::LCT_CENTRAL_BX - l1a_window_width / 2; + maxbx_readout_ = CSCConstants::LCT_CENTRAL_BX + l1a_window_width / 2; + assert(minbx_readout_ > 0); } void CSCAnodeLCTProcessor::checkConfigParameters() { @@ -171,6 +173,9 @@ void CSCAnodeLCTProcessor::checkConfigParameters() { CSCBaseboard::checkConfigParameters(trig_mode, max_trig_mode, def_trig_mode, "trig_mode"); CSCBaseboard::checkConfigParameters(accel_mode, max_accel_mode, def_accel_mode, "accel_mode"); CSCBaseboard::checkConfigParameters(l1a_window_width, max_l1a_window_width, def_l1a_window_width, "l1a_window_width"); + + minbx_readout_ = CSCConstants::LCT_CENTRAL_BX - l1a_window_width / 2; + maxbx_readout_ = CSCConstants::LCT_CENTRAL_BX + l1a_window_width / 2; } void CSCAnodeLCTProcessor::clear() { diff --git a/L1Trigger/CSCTriggerPrimitives/src/CSCCathodeLCTProcessor.cc b/L1Trigger/CSCTriggerPrimitives/src/CSCCathodeLCTProcessor.cc index afad90ba66ec3..6e2658a4e58c1 100644 --- a/L1Trigger/CSCTriggerPrimitives/src/CSCCathodeLCTProcessor.cc +++ b/L1Trigger/CSCTriggerPrimitives/src/CSCCathodeLCTProcessor.cc @@ -98,9 +98,6 @@ CSCCathodeLCTProcessor::CSCCathodeLCTProcessor(unsigned endcap, showerNumTBins_ = shower.getParameter("showerNumTBins"); minLayersCentralTBin_ = shower.getParameter("minLayersCentralTBin"); peakCheck_ = shower.getParameter("peakCheck"); - minbx_readout_ = CSCConstants::LCT_CENTRAL_BX - tmb_l1a_window_size / 2; - maxbx_readout_ = CSCConstants::LCT_CENTRAL_BX + tmb_l1a_window_size / 2; - assert(minbx_readout_ > 0); thePreTriggerDigis.clear(); // quality control of stubs @@ -118,6 +115,8 @@ void CSCCathodeLCTProcessor::setDefaultConfigParameters() { pid_thresh_pretrig = def_pid_thresh_pretrig; min_separation = def_min_separation; tmb_l1a_window_size = def_tmb_l1a_window_size; + minbx_readout_ = CSCConstants::LCT_CENTRAL_BX - tmb_l1a_window_size / 2; + maxbx_readout_ = CSCConstants::LCT_CENTRAL_BX + tmb_l1a_window_size / 2; } // Set configuration parameters obtained via EventSetup mechanism. @@ -139,6 +138,9 @@ void CSCCathodeLCTProcessor::setConfigParameters(const CSCDBL1TPParameters* conf dumpConfigParams(); config_dumped = true; } + minbx_readout_ = CSCConstants::LCT_CENTRAL_BX - tmb_l1a_window_size / 2; + maxbx_readout_ = CSCConstants::LCT_CENTRAL_BX + tmb_l1a_window_size / 2; + assert(minbx_readout_ > 0); } void CSCCathodeLCTProcessor::setESLookupTables(const CSCL1TPLookupTableCCLUT* conf) { cclut_->setESLookupTables(conf); } @@ -171,6 +173,8 @@ void CSCCathodeLCTProcessor::checkConfigParameters() { CSCBaseboard::checkConfigParameters(min_separation, max_min_separation, def_min_separation, "min_separation"); CSCBaseboard::checkConfigParameters( tmb_l1a_window_size, max_tmb_l1a_window_size, def_tmb_l1a_window_size, "tmb_l1a_window_size"); + minbx_readout_ = CSCConstants::LCT_CENTRAL_BX - tmb_l1a_window_size / 2; + maxbx_readout_ = CSCConstants::LCT_CENTRAL_BX + tmb_l1a_window_size / 2; } void CSCCathodeLCTProcessor::clear() { diff --git a/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboard.cc b/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboard.cc index 0a62263e80616..dab96a97c5c4d 100644 --- a/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboard.cc +++ b/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboard.cc @@ -66,10 +66,6 @@ CSCMotherboard::CSCMotherboard(unsigned endcap, // shower-trigger source showerSource_ = showerParams_.getParameter>("source"); - minbx_readout_ = CSCConstants::LCT_CENTRAL_BX - tmb_l1a_window_size / 2; - maxbx_readout_ = CSCConstants::LCT_CENTRAL_BX + tmb_l1a_window_size / 2; - assert(minbx_readout_ > 0); - unsigned csc_idx = CSCDetId::iChamberType(theStation, theRing) - 2; thisShowerSource_ = showerSource_[csc_idx]; @@ -129,6 +125,9 @@ void CSCMotherboard::setConfigParameters(const CSCDBL1TPParameters* conf) { dumpConfigParams(); config_dumped = true; } + minbx_readout_ = CSCConstants::LCT_CENTRAL_BX - tmb_l1a_window_size / 2; + maxbx_readout_ = CSCConstants::LCT_CENTRAL_BX + tmb_l1a_window_size / 2; + assert(minbx_readout_ > 0); } void CSCMotherboard::setESLookupTables(const CSCL1TPLookupTableCCLUT* conf) { lookupTableCCLUT_ = conf; } @@ -573,6 +572,8 @@ void CSCMotherboard::checkConfigParameters() { match_trig_window_size, max_match_trig_window_size, def_match_trig_window_size, "match_trig_window_size"); CSCBaseboard::checkConfigParameters( tmb_l1a_window_size, max_tmb_l1a_window_size, def_tmb_l1a_window_size, "tmb_l1a_window_size"); + minbx_readout_ = CSCConstants::LCT_CENTRAL_BX - tmb_l1a_window_size / 2; + maxbx_readout_ = CSCConstants::LCT_CENTRAL_BX + tmb_l1a_window_size / 2; } void CSCMotherboard::dumpConfigParams() const { From 82c8581965d0c6ef872b3217e88f57603bf20c78 Mon Sep 17 00:00:00 2001 From: Martin Date: Mon, 29 Aug 2022 18:00:42 +0200 Subject: [PATCH 09/10] fix assert --- L1Trigger/CSCTriggerPrimitives/src/CSCAnodeLCTProcessor.cc | 4 +--- L1Trigger/CSCTriggerPrimitives/src/CSCCathodeLCTProcessor.cc | 4 +--- L1Trigger/CSCTriggerPrimitives/src/CSCMotherboard.cc | 4 +--- 3 files changed, 3 insertions(+), 9 deletions(-) diff --git a/L1Trigger/CSCTriggerPrimitives/src/CSCAnodeLCTProcessor.cc b/L1Trigger/CSCTriggerPrimitives/src/CSCAnodeLCTProcessor.cc index 9d02793416a61..9c22a47e1ad11 100644 --- a/L1Trigger/CSCTriggerPrimitives/src/CSCAnodeLCTProcessor.cc +++ b/L1Trigger/CSCTriggerPrimitives/src/CSCAnodeLCTProcessor.cc @@ -136,7 +136,6 @@ void CSCAnodeLCTProcessor::setConfigParameters(const CSCDBL1TPParameters* conf) } minbx_readout_ = CSCConstants::LCT_CENTRAL_BX - l1a_window_width / 2; maxbx_readout_ = CSCConstants::LCT_CENTRAL_BX + l1a_window_width / 2; - assert(minbx_readout_ > 0); } void CSCAnodeLCTProcessor::checkConfigParameters() { @@ -174,8 +173,7 @@ void CSCAnodeLCTProcessor::checkConfigParameters() { CSCBaseboard::checkConfigParameters(accel_mode, max_accel_mode, def_accel_mode, "accel_mode"); CSCBaseboard::checkConfigParameters(l1a_window_width, max_l1a_window_width, def_l1a_window_width, "l1a_window_width"); - minbx_readout_ = CSCConstants::LCT_CENTRAL_BX - l1a_window_width / 2; - maxbx_readout_ = CSCConstants::LCT_CENTRAL_BX + l1a_window_width / 2; + assert(l1a_window_width / 2 <= CSCConstants::LCT_CENTRAL_BX); } void CSCAnodeLCTProcessor::clear() { diff --git a/L1Trigger/CSCTriggerPrimitives/src/CSCCathodeLCTProcessor.cc b/L1Trigger/CSCTriggerPrimitives/src/CSCCathodeLCTProcessor.cc index 6e2658a4e58c1..95a13e5a767bb 100644 --- a/L1Trigger/CSCTriggerPrimitives/src/CSCCathodeLCTProcessor.cc +++ b/L1Trigger/CSCTriggerPrimitives/src/CSCCathodeLCTProcessor.cc @@ -140,7 +140,6 @@ void CSCCathodeLCTProcessor::setConfigParameters(const CSCDBL1TPParameters* conf } minbx_readout_ = CSCConstants::LCT_CENTRAL_BX - tmb_l1a_window_size / 2; maxbx_readout_ = CSCConstants::LCT_CENTRAL_BX + tmb_l1a_window_size / 2; - assert(minbx_readout_ > 0); } void CSCCathodeLCTProcessor::setESLookupTables(const CSCL1TPLookupTableCCLUT* conf) { cclut_->setESLookupTables(conf); } @@ -173,8 +172,7 @@ void CSCCathodeLCTProcessor::checkConfigParameters() { CSCBaseboard::checkConfigParameters(min_separation, max_min_separation, def_min_separation, "min_separation"); CSCBaseboard::checkConfigParameters( tmb_l1a_window_size, max_tmb_l1a_window_size, def_tmb_l1a_window_size, "tmb_l1a_window_size"); - minbx_readout_ = CSCConstants::LCT_CENTRAL_BX - tmb_l1a_window_size / 2; - maxbx_readout_ = CSCConstants::LCT_CENTRAL_BX + tmb_l1a_window_size / 2; + assert(tmb_l1a_window_size / 2 <= CSCConstants::LCT_CENTRAL_BX); } void CSCCathodeLCTProcessor::clear() { diff --git a/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboard.cc b/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboard.cc index dab96a97c5c4d..5348036f90e26 100644 --- a/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboard.cc +++ b/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboard.cc @@ -127,7 +127,6 @@ void CSCMotherboard::setConfigParameters(const CSCDBL1TPParameters* conf) { } minbx_readout_ = CSCConstants::LCT_CENTRAL_BX - tmb_l1a_window_size / 2; maxbx_readout_ = CSCConstants::LCT_CENTRAL_BX + tmb_l1a_window_size / 2; - assert(minbx_readout_ > 0); } void CSCMotherboard::setESLookupTables(const CSCL1TPLookupTableCCLUT* conf) { lookupTableCCLUT_ = conf; } @@ -572,8 +571,7 @@ void CSCMotherboard::checkConfigParameters() { match_trig_window_size, max_match_trig_window_size, def_match_trig_window_size, "match_trig_window_size"); CSCBaseboard::checkConfigParameters( tmb_l1a_window_size, max_tmb_l1a_window_size, def_tmb_l1a_window_size, "tmb_l1a_window_size"); - minbx_readout_ = CSCConstants::LCT_CENTRAL_BX - tmb_l1a_window_size / 2; - maxbx_readout_ = CSCConstants::LCT_CENTRAL_BX + tmb_l1a_window_size / 2; + assert(tmb_l1a_window_size / 2 <= CSCConstants::LCT_CENTRAL_BX); } void CSCMotherboard::dumpConfigParams() const { From e27b5f3daeceeb6a7ba33893c959c70feaf0a669 Mon Sep 17 00:00:00 2001 From: Martin Date: Tue, 30 Aug 2022 10:05:17 +0200 Subject: [PATCH 10/10] set readout window in constructor --- L1Trigger/CSCTriggerPrimitives/src/CSCAnodeLCTProcessor.cc | 3 +++ L1Trigger/CSCTriggerPrimitives/src/CSCCathodeLCTProcessor.cc | 4 ++++ L1Trigger/CSCTriggerPrimitives/src/CSCMotherboard.cc | 5 +++++ 3 files changed, 12 insertions(+) diff --git a/L1Trigger/CSCTriggerPrimitives/src/CSCAnodeLCTProcessor.cc b/L1Trigger/CSCTriggerPrimitives/src/CSCAnodeLCTProcessor.cc index 9c22a47e1ad11..42d341e25843a 100644 --- a/L1Trigger/CSCTriggerPrimitives/src/CSCAnodeLCTProcessor.cc +++ b/L1Trigger/CSCTriggerPrimitives/src/CSCAnodeLCTProcessor.cc @@ -86,6 +86,9 @@ CSCAnodeLCTProcessor::CSCAnodeLCTProcessor(unsigned endcap, thresholds_ = shower.getParameter>("showerThresholds"); showerNumTBins_ = shower.getParameter("showerNumTBins"); minLayersCentralTBin_ = shower.getParameter("minLayersCentralTBin"); + minbx_readout_ = CSCConstants::LCT_CENTRAL_BX - l1a_window_width / 2; + maxbx_readout_ = CSCConstants::LCT_CENTRAL_BX + l1a_window_width / 2; + assert(l1a_window_width / 2 <= CSCConstants::LCT_CENTRAL_BX); } void CSCAnodeLCTProcessor::loadPatternMask() { diff --git a/L1Trigger/CSCTriggerPrimitives/src/CSCCathodeLCTProcessor.cc b/L1Trigger/CSCTriggerPrimitives/src/CSCCathodeLCTProcessor.cc index 95a13e5a767bb..4432781b6b84b 100644 --- a/L1Trigger/CSCTriggerPrimitives/src/CSCCathodeLCTProcessor.cc +++ b/L1Trigger/CSCTriggerPrimitives/src/CSCCathodeLCTProcessor.cc @@ -98,6 +98,10 @@ CSCCathodeLCTProcessor::CSCCathodeLCTProcessor(unsigned endcap, showerNumTBins_ = shower.getParameter("showerNumTBins"); minLayersCentralTBin_ = shower.getParameter("minLayersCentralTBin"); peakCheck_ = shower.getParameter("peakCheck"); + minbx_readout_ = CSCConstants::LCT_CENTRAL_BX - tmb_l1a_window_size / 2; + maxbx_readout_ = CSCConstants::LCT_CENTRAL_BX + tmb_l1a_window_size / 2; + assert(tmb_l1a_window_size / 2 <= CSCConstants::LCT_CENTRAL_BX); + thePreTriggerDigis.clear(); // quality control of stubs diff --git a/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboard.cc b/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboard.cc index 5348036f90e26..669d3b6493ea8 100644 --- a/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboard.cc +++ b/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboard.cc @@ -69,6 +69,11 @@ CSCMotherboard::CSCMotherboard(unsigned endcap, unsigned csc_idx = CSCDetId::iChamberType(theStation, theRing) - 2; thisShowerSource_ = showerSource_[csc_idx]; + // shower readout window + minbx_readout_ = CSCConstants::LCT_CENTRAL_BX - tmb_l1a_window_size / 2; + maxbx_readout_ = CSCConstants::LCT_CENTRAL_BX + tmb_l1a_window_size / 2; + assert(tmb_l1a_window_size / 2 <= CSCConstants::LCT_CENTRAL_BX); + // enable the upgrade processors for ring 1 stations if (runPhase2_ and theRing == 1) { clctProc = std::make_unique(endcap, station, sector, subsector, chamber, conf);