CMS 3D CMS Logo
List of all members | Public Member Functions | Private Member Functions | Private Attributes
CSCGEMMotherboardME21 Class Reference

#include <CSCGEMMotherboardME21.h>

Inheritance diagram for CSCGEMMotherboardME21:
CSCGEMMotherboard CSCUpgradeMotherboard CSCMotherboard CSCBaseboard

Public Member Functions

 CSCGEMMotherboardME21 ()
 
 CSCGEMMotherboardME21 (unsigned endcap, unsigned station, unsigned sector, unsigned subsector, unsigned chamber, const edm::ParameterSet &conf)
 
std::vector< CSCCorrelatedLCTDigi > readoutLCTs () const override
 
void run (const CSCWireDigiCollection *wiredc, const CSCComparatorDigiCollection *compdc, const GEMPadDigiClusterCollection *gemPads) override
 
 ~CSCGEMMotherboardME21 () override
 
- Public Member Functions inherited from CSCGEMMotherboard
void clear ()
 
 CSCGEMMotherboard ()
 
 CSCGEMMotherboard (unsigned endcap, unsigned station, unsigned sector, unsigned subsector, unsigned chamber, const edm::ParameterSet &conf)
 
std::vector< CSCCorrelatedLCTDigi > readoutLCTs () const override
 
void run (const CSCWireDigiCollection *wiredc, const CSCComparatorDigiCollection *compdc) override
 
void setGEMGeometry (const GEMGeometry *g)
 set CSC and GEM geometries for the matching needs More...
 
 ~CSCGEMMotherboard () override
 
- Public Member Functions inherited from CSCUpgradeMotherboard
void clear ()
 
template<class S >
bool compare (const S &p, const S &q) const
 
 CSCUpgradeMotherboard ()
 
 CSCUpgradeMotherboard (unsigned endcap, unsigned station, unsigned sector, unsigned subsector, unsigned chamber, const edm::ParameterSet &conf)
 
void debugLUTs ()
 
enum CSCPart getCSCPart (int keystrip) const
 
template<class S >
void intersection (const S &d1, const S &d2, S &result) const
 
std::vector< CSCCorrelatedLCTDigi > readoutLCTs () const override
 
void run (const CSCWireDigiCollection *wiredc, const CSCComparatorDigiCollection *compdc) override
 
void setupGeometry ()
 
void sortLCTs (std::vector< CSCCorrelatedLCTDigi > &lcts, bool(*sorter)(const CSCCorrelatedLCTDigi &, const CSCCorrelatedLCTDigi &)) const
 
 ~CSCUpgradeMotherboard () override
 
- Public Member Functions inherited from CSCMotherboard
void clear ()
 
 CSCMotherboard ()
 
 CSCMotherboard (unsigned endcap, unsigned station, unsigned sector, unsigned subsector, unsigned chamber, const edm::ParameterSet &conf)
 
std::vector< CSCCorrelatedLCTDigi > getLCTs () const
 
void setConfigParameters (const CSCDBL1TPParameters *conf)
 
 ~CSCMotherboard () override=default
 
- Public Member Functions inherited from CSCBaseboard
 CSCBaseboard ()
 
 CSCBaseboard (unsigned endcap, unsigned station, unsigned sector, unsigned subsector, unsigned chamber, const edm::ParameterSet &conf)
 
std::string getCSCName () const
 
void setCSCGeometry (const CSCGeometry *g)
 
virtual ~CSCBaseboard ()=default
 

Private Member Functions

void correlateLCTsGEM (const CSCALCTDigi &bestALCT, const CSCALCTDigi &secondALCT, const CSCCLCTDigi &bestCLCT, const CSCCLCTDigi &secondCLCT, const GEMPadDigiIds &pads, const GEMCoPadDigiIds &copads, CSCCorrelatedLCTDigi &lct1, CSCCorrelatedLCTDigi &lct2) const
 
bool doesWiregroupCrossStrip (int key_wg, int key_strip) const override
 
const CSCGEMMotherboardLUTME21 * getLUT () const override
 

Private Attributes

bool buildLCTfromALCTandGEM_
 
bool buildLCTfromCLCTandGEM_
 
bool dropLowQualityALCTsNoGEMs_
 
bool dropLowQualityCLCTsNoGEMs_
 
std::unique_ptr< CSCGEMMotherboardLUTME21 > tmbLUT_
 

Additional Inherited Members

- Public Types inherited from CSCGEMMotherboard
enum  Default_values { DEFAULT_MATCHING_VALUE = -99 }
 
- Static Public Member Functions inherited from CSCUpgradeMotherboard
static bool sortLCTsByGEMDphi (const CSCCorrelatedLCTDigi &, const CSCCorrelatedLCTDigi &)
 
static bool sortLCTsByQuality (const CSCCorrelatedLCTDigi &, const CSCCorrelatedLCTDigi &)
 
- Public Attributes inherited from CSCGEMMotherboard
std::unique_ptr< GEMCoPadProcessor > coPadProcessor
 
- Public Attributes inherited from CSCMotherboard
std::unique_ptr< CSCAnodeLCTProcessor > alctProc
 
std::unique_ptr< CSCCathodeLCTProcessor > clctProc
 
- Protected Types inherited from CSCGEMMotherboard
enum  LCT_QualityRun3 {
  INVALID = 0, CLCT_2GEM = 3, ALCT_2GEM = 4, ALCTCLCT = 5,
  ALCTCLCT_1GEM = 6, ALCTCLCT_2GEM = 7
}
 
- Protected Types inherited from CSCMotherboard
enum  LCT_Quality : unsigned int {
  LCT_Quality::INVALID = 0, LCT_Quality::NO_CLCT = 1, LCT_Quality::NO_ALCT = 2, LCT_Quality::CLCT_LAYER_TRIGGER = 3,
  LCT_Quality::LOW_QUALITY = 4, LCT_Quality::MARGINAL_ANODE_CATHODE = 5, LCT_Quality::HQ_ANODE_MARGINAL_CATHODE = 6, LCT_Quality::HQ_CATHODE_MARGINAL_ANODE = 7,
  LCT_Quality::HQ_ACCEL_ALCT = 8, LCT_Quality::HQ_RESERVED_1 = 9, LCT_Quality::HQ_RESERVED_2 = 10, LCT_Quality::HQ_PATTERN_2_3 = 11,
  LCT_Quality::HQ_PATTERN_4_5 = 12, LCT_Quality::HQ_PATTERN_6_7 = 13, LCT_Quality::HQ_PATTERN_8_9 = 14, LCT_Quality::HQ_PATTERN_10 = 15
}
 
enum  LCT_QualityRun3 : unsigned int { LCT_QualityRun3::INVALID = 0, LCT_QualityRun3::LowQ = 1, LCT_QualityRun3::MedQ = 2, LCT_QualityRun3::HighQ = 3 }
 
- Protected Member Functions inherited from CSCGEMMotherboard
template<class T >
T bestMatchingPad (const CSCALCTDigi &, const CSCCLCTDigi &, const matches< T > &) const
 
template<class T >
T bestMatchingPad (const CSCALCTDigi &, const matches< T > &) const
 
template<class S >
S bestMatchingPad (const CSCALCTDigi &alct1, const CSCCLCTDigi &clct1, const matches< S > &pads) const
 
template<class S >
S bestMatchingPad (const CSCALCTDigi &alct1, const matches< S > &pads) const
 
template<class T >
T bestMatchingPad (const CSCCLCTDigi &, const matches< T > &) const
 
template<class S >
S bestMatchingPad (const CSCCLCTDigi &clct, const matches< S > &pads) const
 
CSCCorrelatedLCTDigi constructLCTsGEM (const CSCALCTDigi &alct, const CSCCLCTDigi &clct, const GEMCoPadDigi &gem, int i) const
 
CSCCorrelatedLCTDigi constructLCTsGEM (const CSCALCTDigi &alct, const CSCCLCTDigi &clct, const GEMPadDigi &gem, int i) const
 
CSCCorrelatedLCTDigi constructLCTsGEM (const CSCALCTDigi &alct, const CSCCLCTDigi &clct, const GEMPadDigi &gem1, const GEMCoPadDigi &gem2, int i) const
 
CSCCorrelatedLCTDigi constructLCTsGEM (const CSCALCTDigi &alct, const GEMCoPadDigi &gem, int i) const
 
CSCCorrelatedLCTDigi constructLCTsGEM (const CSCCLCTDigi &clct, const GEMCoPadDigi &gem, int i) const
 
template<class T >
void correlateLCTsGEM (const T &best, const T &second, const GEMCoPadDigi &, const GEMCoPadDigi &, CSCCorrelatedLCTDigi &lct1, CSCCorrelatedLCTDigi &lct2) const
 
template<class T >
void correlateLCTsGEM (const T &best, const T &second, const GEMCoPadDigiIds &coPads, CSCCorrelatedLCTDigi &lct1, CSCCorrelatedLCTDigi &lct2) const
 
CSCMotherboard::LCT_Quality findQualityGEMv1 (const CSCALCTDigi &, const CSCCLCTDigi &, int gemlayer) const
 
LCT_QualityRun3 findQualityGEMv2 (const CSCALCTDigi &, const CSCCLCTDigi &, int gemlayer) const
 
int getBX (const GEMCoPadDigi &p) const
 
int getBX (const GEMPadDigi &p) const
 
float getPad (const CSCCLCTDigi &, enum CSCPart par) const
 
float getPad (const GEMCoPadDigi &) const
 
float getPad (const GEMPadDigi &) const
 
int getRoll (const GEMCoPadDigiId &p) const
 
int getRoll (const GEMPadDigiId &p) const
 
std::pair< int, int > getRolls (const CSCALCTDigi &) const
 
bool isGEMDetId (unsigned int) const
 
bool isPadInOverlap (int roll) const
 
template<class T >
void matchingPads (const CSCALCTDigi &alct, matches< T > &) const
 
template<class T >
void matchingPads (const CSCCLCTDigi &alct, matches< T > &) const
 
template<class T >
void matchingPads (const CSCCLCTDigi &clct1, const CSCALCTDigi &alct1, matches< T > &) const
 
template<class T >
void matchingPads (const CSCCLCTDigi &clct1, const CSCCLCTDigi &clct2, const CSCALCTDigi &alct1, const CSCALCTDigi &alct2, matches< T > &) const
 
template<class S , class T >
void matchingPads (const S &d1, const S &d2, matches< T > &) const
 
int maxPads () const
 
int maxRolls () const
 
void printGEMTriggerCoPads (int bx_start, int bx_stop, enum CSCPart)
 
void printGEMTriggerPads (int bx_start, int bx_stop, enum CSCPart)
 
void processGEMClusters (const GEMPadDigiClusterCollection *pads)
 
void processGEMCoPads ()
 
void processGEMPads (const GEMPadDigiCollection *pads)
 
void setupGeometry ()
 
- Protected Member Functions inherited from CSCUpgradeMotherboard
void correlateLCTs (const CSCALCTDigi &bestALCT, const CSCALCTDigi &secondALCT, const CSCCLCTDigi &bestCLCT, const CSCCLCTDigi &secondCLCT, CSCCorrelatedLCTDigi &lct1, CSCCorrelatedLCTDigi &lct2) const
 
void setPrefIndex ()
 
- Protected Member Functions inherited from CSCMotherboard
void checkConfigParameters ()
 
CSCCorrelatedLCTDigi constructLCTs (const CSCALCTDigi &aLCT, const CSCCLCTDigi &cLCT, int type, int trknmb) const
 
void correlateLCTs (const CSCALCTDigi &bestALCT, const CSCALCTDigi &secondALCT, const CSCCLCTDigi &bestCLCT, const CSCCLCTDigi &secondCLCT, int type)
 
void dumpConfigParams () const
 
void encodeHighMultiplicityBits (unsigned alctBits)
 
unsigned int encodePattern (const int clctPattern) const
 
LCT_Quality findQuality (const CSCALCTDigi &aLCT, const CSCCLCTDigi &cLCT) const
 
LCT_QualityRun3 findQualityRun3 (const CSCALCTDigi &aLCT, const CSCCLCTDigi &cLCT) const
 
CSCALCTDigi getBXShiftedALCT (const CSCALCTDigi &) const
 
CSCCLCTDigi getBXShiftedCLCT (const CSCCLCTDigi &) const
 
- Protected Member Functions inherited from CSCBaseboard
void checkConfigParameters (unsigned int &var, const unsigned int var_max, const unsigned int var_def, const std::string &var_str)
 
- Protected Attributes inherited from CSCGEMMotherboard
GEMCoPadDigiIdsBX coPads_
 
const GEMGeometry * gem_g
 
std::vector< GEMCoPadDigi > gemCoPadV
 
bool gemGeometryAvailable
 
unsigned gemId
 
int maxDeltaBXCoPad_
 
int maxDeltaBXPad_
 
int maxDeltaPadL1_
 
int maxDeltaPadL2_
 
GEMPadDigiIdsBX pads_
 
bool promoteALCTGEMpattern_
 
bool promoteALCTGEMquality_
 
bool promoteCLCTGEMquality_
 
- Protected Attributes inherited from CSCUpgradeMotherboard
LCTContainer allLCTs
 
bool debug_luts
 
bool debug_matching
 
std::unique_ptr< CSCUpgradeMotherboardLUTGenerator > generator_
 
bool match_earliest_alct_only
 
bool match_earliest_clct_only
 
unsigned int max_lcts
 
int pref [CSCConstants::MAX_LCT_TBINS]
 
Parity theParity
 
unsigned int tmb_cross_bx_algo
 
- Protected Attributes inherited from CSCMotherboard
unsigned int alct_trig_enable
 
std::vector< CSCALCTDigi > alctV
 
bool clct_to_alct
 
unsigned int clct_trig_enable
 
std::vector< CSCCLCTDigi > clctV
 
bool drop_used_alcts
 
bool drop_used_clcts
 
int early_tbins
 
CSCCorrelatedLCTDigi firstLCT [CSCConstants::MAX_LCT_TBINS]
 
unsigned int highMultiplicityBits_
 
unsigned int match_trig_enable
 
unsigned int match_trig_window_size
 
unsigned int mpc_block_me1a
 
std::unique_ptr< LCTQualityControl > qualityControl_
 
bool readout_earliest_2
 
CSCCorrelatedLCTDigi secondLCT [CSCConstants::MAX_LCT_TBINS]
 
unsigned int tmb_l1a_window_size
 
bool useHighMultiplicityBits_
 
- Protected Attributes inherited from CSCBaseboard
edm::ParameterSet alctParams_
 
edm::ParameterSet clctParams_
 
edm::ParameterSet commonParams_
 
const CSCChamber * cscChamber_
 
const CSCGeometry * cscGeometry_
 
CSCDetId cscId_
 
bool disableME1a_
 
bool enableAlctPhase2_
 
bool gangedME1a_
 
int infoV
 
bool isME11_
 
bool isME21_
 
bool isME31_
 
bool isME41_
 
bool runCCLUT_
 
bool runME11ILT_
 
bool runME11Up_
 
bool runME21ILT_
 
bool runME21Up_
 
bool runME31Up_
 
bool runME41Up_
 
bool runPhase2_
 
unsigned theChamber
 
std::string theCSCName_
 
const unsigned theEndcap
 
unsigned theRegion
 
unsigned theRing
 
const unsigned theSector
 
const unsigned theStation
 
const unsigned theSubsector
 
const unsigned theTrigChamber
 
edm::ParameterSet tmbParams_
 
- Static Protected Attributes inherited from CSCMotherboard
static const unsigned int def_alct_trig_enable = 0
 
static const unsigned int def_clct_trig_enable = 0
 
static const unsigned int def_match_trig_enable = 1
 
static const unsigned int def_match_trig_window_size = 7
 
static const unsigned int def_mpc_block_me1a = 1
 
static const unsigned int def_tmb_l1a_window_size = 7
 

Detailed Description

Extended CSCMotherboard for ME21 TMB upgrade

Author
Sven Dildick March 2014

Based on CSCMotherboard code

Definition at line 16 of file CSCGEMMotherboardME21.h.

Constructor & Destructor Documentation

◆ CSCGEMMotherboardME21() [1/2]

CSCGEMMotherboardME21::CSCGEMMotherboardME21 ( unsigned  endcap,
unsigned  station,
unsigned  sector,
unsigned  subsector,
unsigned  chamber,
const edm::ParameterSet &  conf 
)

Normal constructor.

Definition at line 5 of file CSCGEMMotherboardME21.cc.

11  : CSCGEMMotherboard(endcap, station, sector, subsector, chamber, conf),
12  dropLowQualityCLCTsNoGEMs_(tmbParams_.getParameter<bool>("dropLowQualityCLCTsNoGEMs")),
13  dropLowQualityALCTsNoGEMs_(tmbParams_.getParameter<bool>("dropLowQualityALCTsNoGEMs")),
14  buildLCTfromALCTandGEM_(tmbParams_.getParameter<bool>("buildLCTfromALCTandGEM")),
15  buildLCTfromCLCTandGEM_(tmbParams_.getParameter<bool>("buildLCTfromCLCTandGEM")) {
16  if (!runPhase2_) {
17  edm::LogError("CSCGEMMotherboardME21|SetupError") << "+++ TMB constructed while runPhase2 is not set! +++\n";
18  }
19 
20  if (!runME21ILT_) {
21  edm::LogError("CSCGEMMotherboardME21|SetupError") << "+++ TMB constructed while runME21ILT_ is not set! +++\n";
22  }
23 
24  // set LUTs
25  tmbLUT_ = std::make_unique<CSCGEMMotherboardLUTME21>();
26 }

References CSCBaseboard::runME21ILT_, CSCBaseboard::runPhase2_, and tmbLUT_.

◆ CSCGEMMotherboardME21() [2/2]

CSCGEMMotherboardME21::CSCGEMMotherboardME21 ( )

Test destructor.

Definition at line 28 of file CSCGEMMotherboardME21.cc.

28  : CSCGEMMotherboard() {
29  if (!runPhase2_) {
30  edm::LogError("CSCGEMMotherboardME21|SetupError") << "+++ TMB constructed while runPhase2 is not set! +++\n";
31  }
32 
33  if (!runME21ILT_) {
34  edm::LogError("CSCGEMMotherboardME21|SetupError") << "+++ TMB constructed while runME21ILT_ is not set! +++\n";
35  }
36 }

References CSCBaseboard::runME21ILT_, and CSCBaseboard::runPhase2_.

◆ ~CSCGEMMotherboardME21()

CSCGEMMotherboardME21::~CSCGEMMotherboardME21 ( )
override

Default destructor.

Definition at line 38 of file CSCGEMMotherboardME21.cc.

38 {}

Member Function Documentation

◆ correlateLCTsGEM()

void CSCGEMMotherboardME21::correlateLCTsGEM ( const CSCALCTDigi &  bestALCT,
const CSCALCTDigi &  secondALCT,
const CSCCLCTDigi &  bestCLCT,
const CSCCLCTDigi &  secondCLCT,
const GEMPadDigiIds &  pads,
const GEMCoPadDigiIds &  copads,
CSCCorrelatedLCTDigi &  lct1,
CSCCorrelatedLCTDigi &  lct2 
) const
private

Definition at line 439 of file CSCGEMMotherboardME21.cc.

446  {
447  const CSCALCTDigi& bestALCT = bALCT;
448  CSCALCTDigi secondALCT = sALCT;
449  const CSCCLCTDigi& bestCLCT = bCLCT;
450  CSCCLCTDigi secondCLCT = sCLCT;
451 
452  // assume that always anodeBestValid and cathodeBestValid
453  if (secondALCT == bestALCT)
454  secondALCT.clear();
455  if (secondCLCT == bestCLCT)
456  secondCLCT.clear();
457 
458  const bool ok_bb = bestALCT.isValid() and bestCLCT.isValid();
459  const bool ok_bs = bestALCT.isValid() and secondCLCT.isValid();
460  const bool ok_sb = secondALCT.isValid() and bestCLCT.isValid();
461  const bool ok_ss = secondALCT.isValid() and secondCLCT.isValid();
462 
463  if (!copads.empty() or !pads.empty()) {
464  // check matching copads
465  const GEMCoPadDigi& bb_copad = bestMatchingPad<GEMCoPadDigi>(bestALCT, bestCLCT, copads);
466  const GEMCoPadDigi& bs_copad = bestMatchingPad<GEMCoPadDigi>(bestALCT, secondCLCT, copads);
467  const GEMCoPadDigi& sb_copad = bestMatchingPad<GEMCoPadDigi>(secondALCT, bestCLCT, copads);
468  const GEMCoPadDigi& ss_copad = bestMatchingPad<GEMCoPadDigi>(secondALCT, secondCLCT, copads);
469 
470  // check matching pads
471  const GEMPadDigi& bb_pad = bestMatchingPad<GEMPadDigi>(bestALCT, bestCLCT, pads);
472  const GEMPadDigi& bs_pad = bestMatchingPad<GEMPadDigi>(bestALCT, secondCLCT, pads);
473  const GEMPadDigi& sb_pad = bestMatchingPad<GEMPadDigi>(secondALCT, bestCLCT, pads);
474  const GEMPadDigi& ss_pad = bestMatchingPad<GEMPadDigi>(secondALCT, secondCLCT, pads);
475 
476  // evaluate possible combinations
477  const bool ok_bb_copad = ok_bb and bb_copad.isValid();
478  const bool ok_bs_copad = ok_bs and bs_copad.isValid();
479  const bool ok_sb_copad = ok_sb and sb_copad.isValid();
480  const bool ok_ss_copad = ok_ss and ss_copad.isValid();
481 
482  const bool ok_bb_pad = (not ok_bb_copad) and ok_bb and bb_pad.isValid();
483  const bool ok_bs_pad = (not ok_bs_copad) and ok_bs and bs_pad.isValid();
484  const bool ok_sb_pad = (not ok_sb_copad) and ok_sb and sb_pad.isValid();
485  const bool ok_ss_pad = (not ok_ss_copad) and ok_ss and ss_pad.isValid();
486 
487  // possible cases with copad
488  if (ok_bb_copad or ok_ss_copad) {
489  if (ok_bb_copad)
490  lct1 = constructLCTsGEM(bestALCT, bestCLCT, bb_copad, 1);
491  if (ok_ss_copad)
492  lct2 = constructLCTsGEM(secondALCT, secondCLCT, ss_copad, 2);
493  } else if (ok_bs_copad or ok_sb_copad) {
494  if (ok_bs_copad)
495  lct1 = constructLCTsGEM(bestALCT, secondCLCT, bs_copad, 1);
496  if (ok_sb_copad)
497  lct2 = constructLCTsGEM(secondALCT, bestCLCT, sb_copad, 2);
498  }
499 
500  // done processing?
501  if (lct1.isValid() and lct2.isValid())
502  return;
503 
504  // possible cases with pad
505  if ((ok_bb_pad or ok_ss_pad) and not(ok_bs_copad or ok_sb_copad)) {
506  if (ok_bb_pad)
507  lct1 = constructLCTsGEM(bestALCT, bestCLCT, bb_pad, 1);
508  if (ok_ss_pad)
509  lct2 = constructLCTsGEM(secondALCT, secondCLCT, ss_pad, 2);
510  } else if ((ok_bs_pad or ok_sb_pad) and not(ok_bb_copad or ok_ss_copad)) {
511  if (ok_bs_pad)
512  lct1 = constructLCTsGEM(bestALCT, secondCLCT, bs_pad, 1);
513  if (ok_sb_pad)
514  lct2 = constructLCTsGEM(secondALCT, bestCLCT, sb_pad, 2);
515  }
516  } else {
517  // run without gems - happens in less than 0.04% of the time
518  if (ok_bb)
519  lct1 = constructLCTs(bestALCT, bestCLCT, CSCCorrelatedLCTDigi::ALCTCLCT, 1);
520  if (ok_ss)
521  lct2 = constructLCTs(secondALCT, secondCLCT, CSCCorrelatedLCTDigi::ALCTCLCT, 2);
522  }
523 }

References CSCCorrelatedLCTDigi::ALCTCLCT, CSCALCTDigi::clear(), CSCCLCTDigi::clear(), CSCMotherboard::constructLCTs(), CSCGEMMotherboard::constructLCTsGEM(), GEMCoPadDigi::isValid(), GEMPadDigi::isValid(), CSCALCTDigi::isValid(), CSCCLCTDigi::isValid(), CSCCorrelatedLCTDigi::isValid(), and or.

Referenced by run().

◆ doesWiregroupCrossStrip()

bool CSCGEMMotherboardME21::doesWiregroupCrossStrip ( int  key_wg,
int  key_strip 
) const
inlineoverrideprivatevirtual

Reimplemented from CSCGEMMotherboard.

Definition at line 47 of file CSCGEMMotherboardME21.h.

47 { return true; }

◆ getLUT()

const CSCGEMMotherboardLUTME21* CSCGEMMotherboardME21::getLUT ( ) const
inlineoverrideprivatevirtual

Implements CSCGEMMotherboard.

Definition at line 43 of file CSCGEMMotherboardME21.h.

43 { return tmbLUT_.get(); }

References tmbLUT_.

◆ readoutLCTs()

std::vector< CSCCorrelatedLCTDigi > CSCGEMMotherboardME21::readoutLCTs ( ) const
overridevirtual

Returns vector of correlated LCTs in the read-out time window, if any.

Reimplemented from CSCMotherboard.

Definition at line 422 of file CSCGEMMotherboardME21.cc.

422  {
423  std::vector<CSCCorrelatedLCTDigi> result;
424  allLCTs.getMatched(result);
425  if (tmb_cross_bx_algo == 2)
426  CSCUpgradeMotherboard::sortLCTs(result, CSCUpgradeMotherboard::sortLCTsByQuality);
427  if (tmb_cross_bx_algo == 3)
428  CSCUpgradeMotherboard::sortLCTs(result, CSCUpgradeMotherboard::sortLCTsByGEMDphi);
429 
430  // do a final check on the LCTs in readout
431  qualityControl_->checkMultiplicityBX(result);
432  for (const auto& lct : result) {
433  qualityControl_->checkValid(lct);
434  }
435 
436  return result;
437 }

References CSCUpgradeMotherboard::allLCTs, LCTContainer::getMatched(), CSCMotherboard::qualityControl_, mps_fire::result, CSCUpgradeMotherboard::sortLCTs(), CSCUpgradeMotherboard::sortLCTsByGEMDphi(), CSCUpgradeMotherboard::sortLCTsByQuality(), and CSCUpgradeMotherboard::tmb_cross_bx_algo.

Referenced by CSCTriggerPrimitivesBuilder::build(), and run().

◆ run()

void CSCGEMMotherboardME21::run ( const CSCWireDigiCollection *  wiredc,
const CSCComparatorDigiCollection *  compdc,
const GEMPadDigiClusterCollection *  gemPads 
)
overridevirtual

Run function for normal usage. Runs cathode and anode LCT processors, takes results and correlates into CorrelatedLCT.

Implements CSCGEMMotherboard.

Definition at line 40 of file CSCGEMMotherboardME21.cc.

42  {
43  CSCGEMMotherboard::clear();
44  setupGeometry();
45  debugLUTs();
46 
47  // encode high multiplicity bits
48  unsigned alctBits = alctProc->getHighMultiplictyBits();
49  encodeHighMultiplicityBits(alctBits);
50 
51  if (gem_g != nullptr) {
52  if (infoV >= 0)
53  edm::LogInfo("CSCGEMMotherboardME21|SetupInfo") << "+++ run() called for GEM-CSC integrated trigger! +++ \n";
54  gemGeometryAvailable = true;
55  }
56 
57  // check for GEM geometry
58  if (not gemGeometryAvailable) {
59  edm::LogError("CSCGEMMotherboardME21|SetupError")
60  << "+++ run() called for GEM-CSC integrated trigger without valid GEM geometry! +++ \n";
61  return;
62  }
63 
64  if (!(alctProc and clctProc)) {
65  edm::LogError("CSCGEMMotherboardME21|SetupError")
66  << "+++ run() called for non-existing ALCT/CLCT processor! +++ \n";
67  return;
68  }
69 
70  alctProc->setCSCGeometry(cscGeometry_);
71  clctProc->setCSCGeometry(cscGeometry_);
72 
73  alctV = alctProc->run(wiredc); // run anodeLCT
74  clctV = clctProc->run(compdc); // run cathodeLCT
75 
76  // retrieve pads and copads in a certain BX window for this CSC
77  processGEMClusters(gemClusters);
78 
79  // if there are no ALCTs and no CLCTs, it does not make sense to run this TMB
80  if (alctV.empty() and clctV.empty())
81  return;
82 
83  int used_clct_mask[20];
84  for (int c = 0; c < 20; ++c)
85  used_clct_mask[c] = 0;
86 
87  const bool hasCoPads(!coPads_.empty());
88 
89  // ALCT centric matching
90  for (int bx_alct = 0; bx_alct < CSCConstants::MAX_ALCT_TBINS; bx_alct++) {
91  if (alctProc->getBestALCT(bx_alct).isValid()) {
92  const int bx_clct_start(bx_alct - match_trig_window_size / 2 - CSCConstants::ALCT_CLCT_OFFSET);
93  const int bx_clct_stop(bx_alct + match_trig_window_size / 2 - CSCConstants::ALCT_CLCT_OFFSET);
94  const int bx_copad_start(bx_alct - maxDeltaBXCoPad_);
95  const int bx_copad_stop(bx_alct + maxDeltaBXCoPad_);
96 
97  const int quality(alctProc->getBestALCT(bx_alct).getQuality());
98 
99  if (debug_matching) {
100  LogTrace("CSCGEMMotherboardME21")
101  << "========================================================================" << std::endl
102  << "ALCT-CLCT matching in ME2/1 chamber: " << cscId_ << " in bx range: [" << bx_clct_start << ","
103  << bx_clct_stop << "] for bx " << bx_alct << std::endl
104  << "------------------------------------------------------------------------" << std::endl
105  << "+++ Best ALCT Details: " << alctProc->getBestALCT(bx_alct) << std::endl
106  << "+++ Second ALCT Details: " << alctProc->getSecondALCT(bx_alct) << std::endl;
107 
108  printGEMTriggerPads(bx_clct_start, bx_clct_stop, CSCPart::ME21);
109  printGEMTriggerCoPads(bx_clct_start, bx_clct_stop, CSCPart::ME21);
110  }
111 
112  // ALCT-to-CLCT
113  int nGoodMatches = 0;
114  for (int bx_clct = bx_clct_start; bx_clct <= bx_clct_stop; bx_clct++) {
115  if (bx_clct < 0 or bx_clct >= CSCConstants::MAX_CLCT_TBINS)
116  continue;
117  if (drop_used_clcts and used_clct_mask[bx_clct])
118  continue;
119  if (clctProc->getBestCLCT(bx_clct).isValid()) {
120  if (debug_matching) {
121  LogTrace("CSCGEMMotherboardME21")
122  << "+++ Best CLCT Details: " << clctProc->getBestCLCT(bx_clct) << std::endl
123  << "+++ Second CLCT Details: " << clctProc->getSecondCLCT(bx_clct) << std::endl;
124  }
125 
126  // clct quality
127  const bool lowQualityCLCT(clctProc->getBestCLCT(bx_clct).getQuality() <= 3);
128  // low quality ALCT
129  const bool lowQualityALCT(alctProc->getBestALCT(bx_alct).getQuality() == 0);
130 
131  // pick the pad that corresponds
132  matches<GEMPadDigi> mPads;
133  matchingPads<GEMPadDigi>(clctProc->getBestCLCT(bx_clct),
134  clctProc->getSecondCLCT(bx_clct),
135  alctProc->getBestALCT(bx_alct),
136  alctProc->getSecondALCT(bx_alct),
137  mPads);
138  matches<GEMCoPadDigi> mCoPads;
139  matchingPads<GEMCoPadDigi>(clctProc->getBestCLCT(bx_clct),
140  clctProc->getSecondCLCT(bx_clct),
141  alctProc->getBestALCT(bx_alct),
142  alctProc->getSecondALCT(bx_alct),
143  mCoPads);
144 
145  bool hasMatchingPads(!mPads.empty() or !mCoPads.empty());
146 
147  if (dropLowQualityCLCTsNoGEMs_ and lowQualityCLCT and !hasMatchingPads) {
148  continue;
149  }
150  if (dropLowQualityALCTsNoGEMs_ and lowQualityALCT and !hasMatchingPads) {
151  continue;
152  }
153 
154  int mbx = bx_clct - bx_clct_start;
155  correlateLCTsGEM(alctProc->getBestALCT(bx_alct),
156  alctProc->getSecondALCT(bx_alct),
157  clctProc->getBestCLCT(bx_clct),
158  clctProc->getSecondCLCT(bx_clct),
159  mPads,
160  mCoPads,
161  allLCTs(bx_alct, mbx, 0),
162  allLCTs(bx_alct, mbx, 1));
163 
164  if (allLCTs(bx_alct, mbx, 0).isValid()) {
165  used_clct_mask[bx_clct] += 1;
166  ++nGoodMatches;
167 
168  if (debug_matching) {
169  LogTrace("CSCGEMMotherboardME21")
170  << "Good ALCT-CLCT match in ME21: bx_alct = " << bx_alct << "; match window: [" << bx_clct_start
171  << "; " << bx_clct_stop << "]; bx_clct = " << bx_clct << "\n"
172  << std::endl;
173 
174  if (allLCTs(bx_alct, mbx, 0).isValid()) {
175  LogTrace("CSCGEMMotherboardME21") << "LCT #1 " << allLCTs(bx_alct, mbx, 0) << std::endl
176  << allLCTs(bx_alct, mbx, 0).getALCT() << std::endl
177  << allLCTs(bx_alct, mbx, 0).getCLCT() << std::endl;
178  if (allLCTs(bx_alct, mbx, 0).getType() == 2)
179  LogTrace("CSCGEMMotherboardME21") << allLCTs(bx_alct, mbx, 0).getGEM1() << std::endl;
180  if (allLCTs(bx_alct, mbx, 0).getType() == 3)
181  LogTrace("CSCGEMMotherboardME21")
182  << allLCTs(bx_alct, mbx, 0).getGEM1() << " " << allLCTs(bx_alct, mbx, 0).getGEM2() << std::endl;
183  }
184 
185  if (allLCTs(bx_alct, mbx, 1).isValid()) {
186  LogTrace("CSCGEMMotherboardME21") << "LCT #2 " << allLCTs(bx_alct, mbx, 1) << std::endl
187  << allLCTs(bx_alct, mbx, 1).getALCT() << std::endl
188  << allLCTs(bx_alct, mbx, 1).getCLCT() << std::endl;
189  if (allLCTs(bx_alct, mbx, 1).getType() == 2)
190  LogTrace("CSCGEMMotherboardME21") << allLCTs(bx_alct, mbx, 1).getGEM1() << std::endl;
191  if (allLCTs(bx_alct, mbx, 1).getType() == 3)
192  LogTrace("CSCGEMMotherboardME21")
193  << allLCTs(bx_alct, mbx, 1).getGEM1() << " " << allLCTs(bx_alct, mbx, 1).getGEM2() << std::endl;
194  }
195  }
196 
197  if (match_earliest_clct_only) {
198  break;
199  }
200  }
201  }
202  }
203 
204  // ALCT-to-GEM matching
205  int nGoodGEMMatches = 0;
206  // only use high-quality stubs
207  if (nGoodMatches == 0 and buildLCTfromALCTandGEM_ and quality >= 1) {
208  if (debug_matching)
209  LogTrace("CSCGEMMotherboardME21") << "++No valid ALCT-CLCT matches in ME21" << std::endl;
210  for (int bx_gem = bx_copad_start; bx_gem <= bx_copad_stop; bx_gem++) {
211  if (not hasCoPads) {
212  continue;
213  }
214 
215  // find the best matching copad
216  matches<GEMCoPadDigi> copads;
217  matchingPads<CSCALCTDigi, GEMCoPadDigi>(
218  alctProc->getBestALCT(bx_alct), alctProc->getSecondALCT(bx_alct), copads);
219 
220  if (debug_matching)
221  LogTrace("CSCGEMMotherboardME21")
222  << "\t++Number of matching GEM CoPads in BX " << bx_alct << " : " << copads.size() << std::endl;
223  if (copads.empty()) {
224  continue;
225  }
226 
227  CSCGEMMotherboard::correlateLCTsGEM(alctProc->getBestALCT(bx_alct),
228  alctProc->getSecondALCT(bx_alct),
229  copads,
230  allLCTs(bx_alct, 0, 0),
231  allLCTs(bx_alct, 0, 1));
232  if (allLCTs(bx_alct, 0, 0).isValid()) {
233  ++nGoodGEMMatches;
234 
235  if (debug_matching) {
236  LogTrace("CSCGEMMotherboardME21")
237  << "Good ALCT-GEM CoPad match in ME21: bx_alct = " << bx_alct << "\n\n"
238  << "------------------------------------------------------------------------" << std::endl
239  << std::endl;
240  if (allLCTs(bx_alct, 0, 0).isValid()) {
241  LogTrace("CSCGEMMotherboardME21") << "LCT #1 " << allLCTs(bx_alct, 0, 0) << std::endl
242  << allLCTs(bx_alct, 0, 0).getALCT() << std::endl;
243  if (allLCTs(bx_alct, 0, 0).getType() == 4)
244  LogTrace("CSCGEMMotherboardME21")
245  << allLCTs(bx_alct, 0, 0).getGEM1() << " " << allLCTs(bx_alct, 0, 0).getGEM2() << std::endl
246  << std::endl;
247  }
248  if (allLCTs(bx_alct, 0, 1).isValid()) {
249  LogTrace("CSCGEMMotherboardME21") << "LCT #2 " << allLCTs(bx_alct, 0, 1) << std::endl
250  << allLCTs(bx_alct, 0, 1).getALCT() << std::endl;
251  if (allLCTs(bx_alct, 0, 1).getType() == 4)
252  LogTrace("CSCGEMMotherboardME21")
253  << allLCTs(bx_alct, 0, 1).getGEM1() << " " << allLCTs(bx_alct, 0, 1).getGEM2() << std::endl
254  << std::endl;
255  }
256  }
257  if (match_earliest_clct_only)
258  break;
259  } else {
260  LogTrace("CSCGEMMotherboardME21") << "No valid LCT is built from ALCT-GEM matching in ME21" << std::endl;
261  }
262  }
263  }
264 
265  if (debug_matching) {
266  LogTrace("CSCGEMMotherboardME21")
267  << "========================================================================" << std::endl;
268  LogTrace("CSCGEMMotherboardME21") << "Summary: " << std::endl;
269  if (nGoodMatches > 1)
270  LogTrace("CSCGEMMotherboardME21")
271  << "Too many good ALCT-CLCT matches in ME21: " << nGoodMatches << ", CSCDetId " << cscId_
272  << ", bx_alct = " << bx_alct << "; match window: [" << bx_clct_start << "; " << bx_clct_stop << "]"
273  << std::endl;
274  else if (nGoodMatches == 1)
275  LogTrace("CSCGEMMotherboardME21")
276  << "1 good ALCT-CLCT match in ME21: "
277  << " CSCDetId " << cscId_ << ", bx_alct = " << bx_alct << "; match window: [" << bx_clct_start << "; "
278  << bx_clct_stop << "]" << std::endl;
279  else if (nGoodGEMMatches == 1)
280  LogTrace("CSCGEMMotherboardME21")
281  << "1 good ALCT-GEM match in ME21: "
282  << " CSCDetId " << cscId_ << ", bx_alct = " << bx_alct << "; match window: [" << bx_clct_start << "; "
283  << bx_clct_stop << "]" << std::endl;
284  else
285  LogTrace("CSCGEMMotherboardME21") << "Bad ALCT-CLCT match in ME21: "
286  << "CSCDetId " << cscId_ << ", bx_alct = " << bx_alct << "; match window: ["
287  << bx_clct_start << "; " << bx_clct_stop << "]" << std::endl;
288  }
289  }
290  // at this point we have invalid ALCTs --> try GEM pad matching
291  else {
292  auto coPads(coPads_[bx_alct]);
293  if (!coPads.empty() and buildLCTfromCLCTandGEM_) {
294  const int bx_clct_start(bx_alct - match_trig_window_size / 2 - CSCConstants::ALCT_CLCT_OFFSET);
295  const int bx_clct_stop(bx_alct + match_trig_window_size / 2 - CSCConstants::ALCT_CLCT_OFFSET);
296 
297  if (debug_matching) {
298  LogTrace("CSCGEMMotherboardME21")
299  << "========================================================================" << std::endl
300  << "GEM-CLCT matching in ME2/1 chamber: " << cscId_ << "in bx:" << bx_alct << std::endl
301  << "------------------------------------------------------------------------" << std::endl;
302  }
303  // GEM-to-CLCT
304  // matching in ME21
305  if (buildLCTfromCLCTandGEM_) {
306  for (int bx_clct = bx_clct_start; bx_clct <= bx_clct_stop; bx_clct++) {
307  if (bx_clct < 0 or bx_clct >= CSCConstants::MAX_CLCT_TBINS)
308  continue;
309  if (drop_used_clcts and used_clct_mask[bx_clct])
310  continue;
311  if (clctProc->getBestCLCT(bx_clct).isValid()) {
312  const int quality(clctProc->getBestCLCT(bx_clct).getQuality());
313  // only use high-Q stubs for the time being
314  if (quality < 4)
315  continue;
316 
317  int mbx = bx_clct - bx_clct_start;
318  CSCGEMMotherboard::correlateLCTsGEM(clctProc->getBestCLCT(bx_clct),
319  clctProc->getSecondCLCT(bx_clct),
320  coPads,
321  allLCTs(bx_alct, mbx, 0),
322  allLCTs(bx_alct, mbx, 1));
323  if (allLCTs(bx_alct, mbx, 0).isValid()) {
324  used_clct_mask[bx_clct] += 1;
325 
326  if (debug_matching) {
327  LogTrace("CSCGEMMotherboardME21")
328  << "Good GEM-CLCT match in ME21: bx_alct = " << bx_alct << "; match window: [" << bx_clct_start
329  << "; " << bx_clct_stop << "]; bx_clct = " << bx_clct << "\n"
330  << "+++ Best CLCT Details: " << clctProc->getBestCLCT(bx_clct) << "\n"
331  << "+++ Second CLCT Details: " << clctProc->getSecondCLCT(bx_clct) << std::endl;
332 
333  LogTrace("CSCGEMMotherboardME21") << "LCT #1 " << allLCTs(bx_alct, mbx, 0) << std::endl
334  << allLCTs(bx_alct, mbx, 0).getALCT() << std::endl;
335  if (allLCTs(bx_alct, mbx, 0).getType() == 5)
336  LogTrace("CSCGEMMotherboardME21")
337  << allLCTs(bx_alct, mbx, 0).getGEM1() << " " << allLCTs(bx_alct, mbx, 0).getGEM2() << std::endl;
338 
339  LogTrace("CSCGEMMotherboardME21") << "LCT #2 " << allLCTs(bx_alct, mbx, 1) << std::endl
340  << allLCTs(bx_alct, mbx, 1).getALCT() << std::endl;
341  if (allLCTs(bx_alct, mbx, 1).getType() == 5)
342  LogTrace("CSCGEMMotherboardME21")
343  << allLCTs(bx_alct, mbx, 1).getGEM1() << " " << allLCTs(bx_alct, mbx, 1).getGEM2() << std::endl;
344  }
345 
346  if (match_earliest_clct_only)
347  break;
348  }
349  }
350  }
351  }
352  }
353  }
354  }
355  // reduction of nLCTs per each BX
356  for (int bx = 0; bx < CSCConstants::MAX_LCT_TBINS; bx++) {
357  // counting
358  unsigned int n = 0;
359  for (unsigned int mbx = 0; mbx < match_trig_window_size; mbx++) {
360  for (int i = 0; i < CSCConstants::MAX_LCTS_PER_CSC; i++) {
361  if (allLCTs(bx, mbx, i).isValid()) {
362  ++n;
363  if (infoV > 0) {
364  LogDebug("CSCGEMMotherboardME21")
365  << "LCT" << i + 1 << " " << bx << "/" << bx + mbx - match_trig_window_size / 2 << ": "
366  << allLCTs(bx, mbx, i) << std::endl;
367  }
368  }
369  }
370  }
371 
372  // some simple cross-bx sorting algorithms
373  if (tmb_cross_bx_algo == 1 and (n > 2)) {
374  n = 0;
375  for (unsigned int mbx = 0; mbx < match_trig_window_size; mbx++) {
376  for (int i = 0; i < CSCConstants::MAX_LCTS_PER_CSC; i++) {
377  if (allLCTs(bx, pref[mbx], i).isValid()) {
378  n++;
379  if (n > 2)
380  allLCTs(bx, pref[mbx], i).clear();
381  }
382  }
383  }
384 
385  n = 0;
386  for (unsigned int mbx = 0; mbx < match_trig_window_size; mbx++) {
387  for (int i = 0; i < CSCConstants::MAX_LCTS_PER_CSC; i++) {
388  if (allLCTs(bx, mbx, i).isValid()) {
389  n++;
390  if (infoV > 0) {
391  LogDebug("CSCGEMMotherboardME21")
392  << "LCT" << i + 1 << " " << bx << "/" << bx + mbx - match_trig_window_size / 2 << ": "
393  << allLCTs(bx, mbx, i) << std::endl;
394  }
395  }
396  }
397  if (infoV > 0 and n > 0)
398  LogDebug("CSCGEMMotherboardME21") << "bx " << bx << " nnLCT:" << n << " " << n << std::endl;
399  }
400  } // x-bx sorting
401  }
402 
403  bool first = true;
404  unsigned int n = 0;
405  for (const auto& p : readoutLCTs()) {
406  if (debug_matching and first) {
407  LogTrace("CSCGEMCMotherboardME21") << "========================================================================"
408  << std::endl;
409  LogTrace("CSCGEMCMotherboardME21") << "Counting the final LCTs in CSCGEM Motherboard ME21" << std::endl;
410  LogTrace("CSCGEMCMotherboardME21") << "========================================================================"
411  << std::endl;
412  first = false;
413  LogTrace("CSCGEMCMotherboardME21") << "tmb_cross_bx_algo: " << tmb_cross_bx_algo << std::endl;
414  }
415  n++;
416  if (debug_matching)
417  LogTrace("CSCGEMCMotherboardME21") << "LCT " << n << " " << p << std::endl;
418  }
419 }

References CSCConstants::ALCT_CLCT_OFFSET, CSCMotherboard::alctProc, CSCMotherboard::alctV, CSCUpgradeMotherboard::allLCTs, buildLCTfromALCTandGEM_, buildLCTfromCLCTandGEM_, l1GtPatternGenerator_cfi::bx, HltBtagPostValidation_cff::c, CSCMotherboard::clctProc, CSCMotherboard::clctV, LCTContainer::clear(), CSCGEMMotherboard::clear(), CSCGEMMotherboard::coPads_, correlateLCTsGEM(), CSCGEMMotherboard::correlateLCTsGEM(), CSCBaseboard::cscGeometry_, CSCBaseboard::cscId_, CSCUpgradeMotherboard::debug_matching, CSCUpgradeMotherboard::debugLUTs(), CSCMotherboard::drop_used_clcts, dropLowQualityALCTsNoGEMs_, dropLowQualityCLCTsNoGEMs_, CSCMotherboard::encodeHighMultiplicityBits(), dqmdumpme::first, CSCGEMMotherboard::gem_g, CSCGEMMotherboard::gemGeometryAvailable, mps_fire::i, CSCBaseboard::infoV, LogDebug, LogTrace, CSCUpgradeMotherboard::match_earliest_clct_only, CSCMotherboard::match_trig_window_size, CSCConstants::MAX_ALCT_TBINS, CSCConstants::MAX_CLCT_TBINS, CSCConstants::MAX_LCT_TBINS, CSCConstants::MAX_LCTS_PER_CSC, CSCGEMMotherboard::maxDeltaBXCoPad_, ME21, dqmiodumpmetadata::n, or, AlCaHLTBitMon_ParallelJobs::p, CSCUpgradeMotherboard::pref, CSCGEMMotherboard::printGEMTriggerCoPads(), CSCGEMMotherboard::printGEMTriggerPads(), CSCGEMMotherboard::processGEMClusters(), qcdUeDQM_cfi::quality, readoutLCTs(), CSCGEMMotherboard::setupGeometry(), and CSCUpgradeMotherboard::tmb_cross_bx_algo.

Referenced by CSCTriggerPrimitivesBuilder::build().

Member Data Documentation

◆ buildLCTfromALCTandGEM_

bool CSCGEMMotherboardME21::buildLCTfromALCTandGEM_
private

Definition at line 65 of file CSCGEMMotherboardME21.h.

Referenced by run().

◆ buildLCTfromCLCTandGEM_

bool CSCGEMMotherboardME21::buildLCTfromCLCTandGEM_
private

Definition at line 66 of file CSCGEMMotherboardME21.h.

Referenced by run().

◆ dropLowQualityALCTsNoGEMs_

bool CSCGEMMotherboardME21::dropLowQualityALCTsNoGEMs_
private

Definition at line 62 of file CSCGEMMotherboardME21.h.

Referenced by run().

◆ dropLowQualityCLCTsNoGEMs_

bool CSCGEMMotherboardME21::dropLowQualityCLCTsNoGEMs_
private

Definition at line 61 of file CSCGEMMotherboardME21.h.

Referenced by run().

◆ tmbLUT_

std::unique_ptr<CSCGEMMotherboardLUTME21> CSCGEMMotherboardME21::tmbLUT_
private

Definition at line 44 of file CSCGEMMotherboardME21.h.

Referenced by CSCGEMMotherboardME21(), and getLUT().

CSCMotherboard::qualityControl_
std::unique_ptr< LCTQualityControl > qualityControl_
Definition: CSCMotherboard.h:128
mps_fire.i
i
Definition: mps_fire.py:428
CSCMotherboard::match_trig_window_size
unsigned int match_trig_window_size
Definition: CSCMotherboard.h:99
dqmiodumpmetadata.n
n
Definition: dqmiodumpmetadata.py:28
GEMPadDigi
Definition: GEMPadDigi.h:17
CSCBaseboard::cscGeometry_
const CSCGeometry * cscGeometry_
Definition: CSCBaseboard.h:66
CSCConstants::MAX_ALCT_TBINS
Definition: CSCConstants.h:64
CSCBaseboard::tmbParams_
edm::ParameterSet tmbParams_
Definition: CSCBaseboard.h:73
relativeConstraints.station
station
Definition: relativeConstraints.py:67
CSCMotherboard::alctProc
std::unique_ptr< CSCAnodeLCTProcessor > alctProc
Definition: CSCMotherboard.h:75
AlCaHLTBitMon_ParallelJobs.p
p
Definition: AlCaHLTBitMon_ParallelJobs.py:153
CSCALCTDigi::clear
void clear()
clear this ALCT
Definition: CSCALCTDigi.cc:50
CSCGEMMotherboard::gemGeometryAvailable
bool gemGeometryAvailable
Definition: CSCGEMMotherboard.h:214
l1GtPatternGenerator_cfi.bx
bx
Definition: l1GtPatternGenerator_cfi.py:18
CSCGEMMotherboardME21::readoutLCTs
std::vector< CSCCorrelatedLCTDigi > readoutLCTs() const override
Definition: CSCGEMMotherboardME21.cc:422
CSCGEMMotherboard::constructLCTsGEM
CSCCorrelatedLCTDigi constructLCTsGEM(const CSCALCTDigi &alct, const GEMCoPadDigi &gem, int i) const
Definition: CSCGEMMotherboard.cc:91
CSCGEMMotherboard::coPads_
GEMCoPadDigiIdsBX coPads_
Definition: CSCGEMMotherboard.h:220
CSCUpgradeMotherboard::tmb_cross_bx_algo
unsigned int tmb_cross_bx_algo
Definition: CSCUpgradeMotherboard.h:109
edm::LogInfo
Log< level::Info, false > LogInfo
Definition: MessageLogger.h:125
CSCConstants::ALCT_CLCT_OFFSET
Definition: CSCConstants.h:81
CSCUpgradeMotherboard::debugLUTs
void debugLUTs()
Definition: CSCUpgradeMotherboard.cc:302
makeMuonMisalignmentScenario.endcap
endcap
Definition: makeMuonMisalignmentScenario.py:320
CSCGEMMotherboardME21::buildLCTfromALCTandGEM_
bool buildLCTfromALCTandGEM_
Definition: CSCGEMMotherboardME21.h:65
dqmdumpme.first
first
Definition: dqmdumpme.py:55
CSCGEMMotherboard::setupGeometry
void setupGeometry()
Definition: CSCGEMMotherboard.cc:310
CSCCLCTDigi
Definition: CSCCLCTDigi.h:17
CSCCorrelatedLCTDigi::ALCTCLCT
Definition: CSCCorrelatedLCTDigi.h:191
CSCMotherboard::clctV
std::vector< CSCCLCTDigi > clctV
Definition: CSCMotherboard.h:84
CSCMotherboard::clctProc
std::unique_ptr< CSCCathodeLCTProcessor > clctProc
Definition: CSCMotherboard.h:78
LCTContainer::getMatched
void getMatched(std::vector< CSCCorrelatedLCTDigi > &) const
Definition: LCTContainer.cc:23
CSCMotherboard::alctV
std::vector< CSCALCTDigi > alctV
Definition: CSCMotherboard.h:83
CSCConstants::MAX_LCTS_PER_CSC
Definition: CSCConstants.h:75
CSCMotherboard::constructLCTs
CSCCorrelatedLCTDigi constructLCTs(const CSCALCTDigi &aLCT, const CSCCLCTDigi &cLCT, int type, int trknmb) const
Definition: CSCMotherboard.cc:486
CSCGEMMotherboardME21::buildLCTfromCLCTandGEM_
bool buildLCTfromCLCTandGEM_
Definition: CSCGEMMotherboardME21.h:66
CSCGEMMotherboard::correlateLCTsGEM
void correlateLCTsGEM(const T &best, const T &second, const GEMCoPadDigiIds &coPads, CSCCorrelatedLCTDigi &lct1, CSCCorrelatedLCTDigi &lct2) const
Definition: CSCGEMMotherboard.h:465
CSCGEMMotherboard::CSCGEMMotherboard
CSCGEMMotherboard()
Definition: CSCGEMMotherboard.cc:29
CSCUpgradeMotherboard::match_earliest_clct_only
bool match_earliest_clct_only
Definition: CSCUpgradeMotherboard.h:106
CSCGEMMotherboard::processGEMClusters
void processGEMClusters(const GEMPadDigiClusterCollection *pads)
Definition: CSCGEMMotherboard.cc:41
CSCUpgradeMotherboard::sortLCTsByGEMDphi
static bool sortLCTsByGEMDphi(const CSCCorrelatedLCTDigi &, const CSCCorrelatedLCTDigi &)
Definition: CSCUpgradeMotherboard.cc:311
CSCGEMMotherboardME21::dropLowQualityCLCTsNoGEMs_
bool dropLowQualityCLCTsNoGEMs_
Definition: CSCGEMMotherboardME21.h:61
CSCConstants::MAX_LCT_TBINS
Definition: CSCConstants.h:65
CSCGEMMotherboard::printGEMTriggerCoPads
void printGEMTriggerCoPads(int bx_start, int bx_stop, enum CSCPart)
Definition: CSCGEMMotherboard.cc:340
CSCBaseboard::runPhase2_
bool runPhase2_
Definition: CSCBaseboard.h:85
CSCGEMMotherboardME21::dropLowQualityALCTsNoGEMs_
bool dropLowQualityALCTsNoGEMs_
Definition: CSCGEMMotherboardME21.h:62
GEMCoPadDigi
Definition: GEMCoPadDigi.h:16
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:223
LCTContainer::clear
void clear()
Definition: LCTContainer.cc:31
CSCUpgradeMotherboard::debug_matching
bool debug_matching
Definition: CSCUpgradeMotherboard.h:115
CSCCLCTDigi::isValid
bool isValid() const
check CLCT validity (1 - valid CLCT)
Definition: CSCCLCTDigi.h:48
CSCUpgradeMotherboard::sortLCTs
void sortLCTs(std::vector< CSCCorrelatedLCTDigi > &lcts, bool(*sorter)(const CSCCorrelatedLCTDigi &, const CSCCorrelatedLCTDigi &)) const
Definition: CSCUpgradeMotherboard.cc:315
CSCUpgradeMotherboard::pref
int pref[CSCConstants::MAX_LCT_TBINS]
Definition: CSCUpgradeMotherboard.h:103
HltBtagPostValidation_cff.c
c
Definition: HltBtagPostValidation_cff.py:31
edm::LogError
Log< level::Error, false > LogError
Definition: MessageLogger.h:123
CSCMotherboard::drop_used_clcts
bool drop_used_clcts
Definition: CSCMotherboard.h:105
CSCMotherboard::encodeHighMultiplicityBits
void encodeHighMultiplicityBits(unsigned alctBits)
Definition: CSCMotherboard.cc:709
CSCGEMMotherboardME21::tmbLUT_
std::unique_ptr< CSCGEMMotherboardLUTME21 > tmbLUT_
Definition: CSCGEMMotherboardME21.h:44
CSCUpgradeMotherboard::sortLCTsByQuality
static bool sortLCTsByQuality(const CSCCorrelatedLCTDigi &, const CSCCorrelatedLCTDigi &)
Definition: CSCUpgradeMotherboard.cc:307
CSCBaseboard::runME21ILT_
bool runME21ILT_
Definition: CSCBaseboard.h:95
CSCUpgradeMotherboard::allLCTs
LCTContainer allLCTs
Definition: CSCUpgradeMotherboard.h:98
qcdUeDQM_cfi.quality
quality
Definition: qcdUeDQM_cfi.py:31
CSCCLCTDigi::clear
void clear()
clear this CLCT
Definition: CSCCLCTDigi.cc:68
CSCALCTDigi
Definition: CSCALCTDigi.h:17
CSCGEMMotherboard::printGEMTriggerPads
void printGEMTriggerPads(int bx_start, int bx_stop, enum CSCPart)
Definition: CSCGEMMotherboard.cc:319
CSCConstants::MAX_CLCT_TBINS
Definition: CSCConstants.h:63
relativeConstraints.chamber
chamber
Definition: relativeConstraints.py:53
or
The Signals That Services Can Subscribe To This is based on ActivityRegistry and is current per Services can connect to the signals distributed by the ActivityRegistry in order to monitor the activity of the application Each possible callback has some defined which we here list in angle e< void, edm::EventID const &, edm::Timestamp const & > We also list in braces which AR_WATCH_USING_METHOD_ is used for those or
Definition: Activities.doc:12
CSCGEMMotherboard::clear
void clear()
Definition: CSCGEMMotherboard.cc:33
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
Definition: ParameterSet.h:303
CSCGEMMotherboard::maxDeltaBXCoPad_
int maxDeltaBXCoPad_
Definition: CSCGEMMotherboard.h:224
CSCBaseboard::cscId_
CSCDetId cscId_
Definition: CSCBaseboard.h:58
CSCALCTDigi::isValid
bool isValid() const
check ALCT validity (1 - valid ALCT)
Definition: CSCALCTDigi.h:40
CSCGEMMotherboardME21::correlateLCTsGEM
void correlateLCTsGEM(const CSCALCTDigi &bestALCT, const CSCALCTDigi &secondALCT, const CSCCLCTDigi &bestCLCT, const CSCCLCTDigi &secondCLCT, const GEMPadDigiIds &pads, const GEMCoPadDigiIds &copads, CSCCorrelatedLCTDigi &lct1, CSCCorrelatedLCTDigi &lct2) const
Definition: CSCGEMMotherboardME21.cc:439
mps_fire.result
result
Definition: mps_fire.py:311
LogTrace
#define LogTrace(id)
Definition: MessageLogger.h:224
GEMPadDigi::isValid
bool isValid() const
Definition: GEMPadDigi.cc:26
CSCCorrelatedLCTDigi::isValid
bool isValid() const
return valid pattern bit
Definition: CSCCorrelatedLCTDigi.h:53
CSCGEMMotherboard::gem_g
const GEMGeometry * gem_g
Definition: CSCGEMMotherboard.h:213
ME21
Definition: CSCUpgradeMotherboardLUT.h:12
GEMCoPadDigi::isValid
bool isValid() const
Definition: GEMCoPadDigi.cc:18
CSCBaseboard::infoV
int infoV
Definition: CSCBaseboard.h:64
Generated for CMSSW Reference Manual by doxygen 1.8.16