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

#include <CSCGEMMotherboardME11.h>

Inheritance diagram for CSCGEMMotherboardME11:
CSCGEMMotherboard CSCUpgradeMotherboard CSCMotherboard CSCBaseboard

Public Member Functions

 CSCGEMMotherboardME11 ()
 
 CSCGEMMotherboardME11 (unsigned endcap, unsigned station, unsigned sector, unsigned subsector, unsigned chamber, const edm::ParameterSet &conf)
 
std::vector< CSCCorrelatedLCTDigi > readoutLCTs1a () const
 
std::vector< CSCCorrelatedLCTDigi > readoutLCTs1b () const
 
void run (const CSCWireDigiCollection *wiredc, const CSCComparatorDigiCollection *compdc, const GEMPadDigiClusterCollection *gemPads) override
 
 ~CSCGEMMotherboardME11 () 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 doesALCTCrossCLCT (const CSCALCTDigi &a, const CSCCLCTDigi &c) const
 
bool doesWiregroupCrossStrip (int key_wg, int key_hs) const override
 
const CSCGEMMotherboardLUTME11 * getLUT () const override
 
std::vector< CSCCorrelatedLCTDigi > readoutLCTsME11 (enum CSCPart me1ab) const
 
void sortLCTs (std::vector< CSCCorrelatedLCTDigi > &, bool(*sorter)(const CSCCorrelatedLCTDigi &, const CSCCorrelatedLCTDigi &)) const
 
void sortLCTs (std::vector< CSCCorrelatedLCTDigi > &, int bx, bool(*sorter)(const CSCCorrelatedLCTDigi &, const CSCCorrelatedLCTDigi &)) const
 

Private Attributes

bool buildLCTfromALCTandGEM_ME1a_
 
bool buildLCTfromALCTandGEM_ME1b_
 
bool buildLCTfromCLCTandGEM_ME1a_
 
bool buildLCTfromCLCTandGEM_ME1b_
 
std::vector< CSCCLCTDigi > clctV
 
std::unique_ptr< CSCMotherboardLUTME11 > cscTmbLUT_
 
bool dropLowQualityALCTsNoGEMs_ME1a_
 
bool dropLowQualityALCTsNoGEMs_ME1b_
 
bool dropLowQualityCLCTsNoGEMs_ME1a_
 
bool dropLowQualityCLCTsNoGEMs_ME1b_
 
bool promoteCLCTGEMquality_ME1a_
 
bool promoteCLCTGEMquality_ME1b_
 
std::unique_ptr< CSCGEMMotherboardLUTME11 > 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 ME11 TMB upgrade

Author
Sven Dildick March 2014

Based on CSCMotherboard code

Definition at line 16 of file CSCGEMMotherboardME11.h.

Constructor & Destructor Documentation

◆ CSCGEMMotherboardME11() [1/2]

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

Normal constructor.

Definition at line 5 of file CSCGEMMotherboardME11.cc.

11  : CSCGEMMotherboard(endcap, station, sector, subsector, chamber, conf)
12  // special configuration parameters for ME11 treatment
13  ,
14  dropLowQualityCLCTsNoGEMs_ME1a_(tmbParams_.getParameter<bool>("dropLowQualityCLCTsNoGEMs_ME1a")),
15  dropLowQualityCLCTsNoGEMs_ME1b_(tmbParams_.getParameter<bool>("dropLowQualityCLCTsNoGEMs_ME1b")),
16  dropLowQualityALCTsNoGEMs_ME1a_(tmbParams_.getParameter<bool>("dropLowQualityALCTsNoGEMs_ME1a")),
17  dropLowQualityALCTsNoGEMs_ME1b_(tmbParams_.getParameter<bool>("dropLowQualityALCTsNoGEMs_ME1b")),
18  buildLCTfromALCTandGEM_ME1a_(tmbParams_.getParameter<bool>("buildLCTfromALCTandGEM_ME1a")),
19  buildLCTfromALCTandGEM_ME1b_(tmbParams_.getParameter<bool>("buildLCTfromALCTandGEM_ME1b")),
20  buildLCTfromCLCTandGEM_ME1a_(tmbParams_.getParameter<bool>("buildLCTfromCLCTandGEM_ME1a")),
21  buildLCTfromCLCTandGEM_ME1b_(tmbParams_.getParameter<bool>("buildLCTfromCLCTandGEM_ME1b")),
22  promoteCLCTGEMquality_ME1a_(tmbParams_.getParameter<bool>("promoteCLCTGEMquality_ME1a")),
23  promoteCLCTGEMquality_ME1b_(tmbParams_.getParameter<bool>("promoteCLCTGEMquality_ME1b")) {
24  if (!runPhase2_) {
25  edm::LogError("CSCGEMMotherboardME11|SetupError") << "+++ TMB constructed while runPhase2 is not set! +++\n";
26  }
27 
28  if (!runME11ILT_) {
29  edm::LogError("CSCGEMMotherboardME11|SetupError") << "+++ TMB constructed while runME11ILT_ is not set! +++\n";
30  };
31 
32  // set LUTs
33  tmbLUT_ = std::make_unique<CSCGEMMotherboardLUTME11>();
34  cscTmbLUT_ = std::make_unique<CSCMotherboardLUTME11>();
35 }

References cscTmbLUT_, CSCBaseboard::runME11ILT_, CSCBaseboard::runPhase2_, and tmbLUT_.

◆ CSCGEMMotherboardME11() [2/2]

CSCGEMMotherboardME11::CSCGEMMotherboardME11 ( )

Constructor for use during testing.

Definition at line 37 of file CSCGEMMotherboardME11.cc.

37  : CSCGEMMotherboard() {
38  // Constructor used only for testing.
39  if (!runPhase2_) {
40  edm::LogError("CSCGEMMotherboardME11|SetupError") << "+++ TMB constructed while runPhase2 is not set! +++\n";
41  }
42 
43  if (!runME11ILT_) {
44  edm::LogError("CSCGEMMotherboardME11|SetupError") << "+++ TMB constructed while runME11ILT_ is not set! +++\n";
45  }
46 }

References CSCBaseboard::runME11ILT_, and CSCBaseboard::runPhase2_.

◆ ~CSCGEMMotherboardME11()

CSCGEMMotherboardME11::~CSCGEMMotherboardME11 ( )
override

Default destructor.

Definition at line 48 of file CSCGEMMotherboardME11.cc.

48 {}

Member Function Documentation

◆ correlateLCTsGEM()

void CSCGEMMotherboardME11::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 509 of file CSCGEMMotherboardME11.cc.

516  {
517  const CSCALCTDigi& bestALCT = bALCT;
518  CSCALCTDigi secondALCT = sALCT;
519  const CSCCLCTDigi& bestCLCT = bCLCT;
520  CSCCLCTDigi secondCLCT = sCLCT;
521 
522  // assume that always anodeBestValid and cathodeBestValid
523  if (secondALCT == bestALCT)
524  secondALCT.clear();
525  if (secondCLCT == bestCLCT)
526  secondCLCT.clear();
527 
528  const bool ok_bb = bestALCT.isValid() and bestCLCT.isValid();
529  const bool ok_bs = bestALCT.isValid() and secondCLCT.isValid();
530  const bool ok_sb = secondALCT.isValid() and bestCLCT.isValid();
531  const bool ok_ss = secondALCT.isValid() and secondCLCT.isValid();
532 
533  const int ok11 = doesALCTCrossCLCT(bestALCT, bestCLCT);
534  const int ok12 = doesALCTCrossCLCT(bestALCT, secondCLCT);
535  const int ok21 = doesALCTCrossCLCT(secondALCT, bestCLCT);
536  const int ok22 = doesALCTCrossCLCT(secondALCT, secondCLCT);
537  const int code = (ok11 << 3) | (ok12 << 2) | (ok21 << 1) | (ok22);
538 
539  int dbg = 0;
540  if (dbg)
541  LogTrace("CSCGEMMotherboardME11") << "debug correlateLCTs in ME11" << cscId_ << "\n"
542  << "ALCT1: " << bestALCT << "\n"
543  << "ALCT2: " << secondALCT << "\n"
544  << "CLCT1: " << bestCLCT << "\n"
545  << "CLCT2: " << secondCLCT << "\n"
546  << "ok 11 12 21 22 code = " << ok11 << " " << ok12 << " " << ok21 << " " << ok22
547  << " " << code << std::endl;
548 
549  if (code == 0)
550  return;
551 
552  // LUT defines correspondence between possible ok## combinations
553  // and resulting lct1 and lct2
554  int lut[16][2] = {
555  //ok: 11 12 21 22
556  {0, 0}, // 0 0 0 0
557  {22, 0}, // 0 0 0 1
558  {21, 0}, // 0 0 1 0
559  {21, 22}, // 0 0 1 1
560  {12, 0}, // 0 1 0 0
561  {12, 22}, // 0 1 0 1
562  {12, 21}, // 0 1 1 0
563  {12, 21}, // 0 1 1 1
564  {11, 0}, // 1 0 0 0
565  {11, 22}, // 1 0 0 1
566  {11, 21}, // 1 0 1 0
567  {11, 22}, // 1 0 1 1
568  {11, 12}, // 1 1 0 0
569  {11, 22}, // 1 1 0 1
570  {11, 12}, // 1 1 1 0
571  {11, 22}, // 1 1 1 1
572  };
573 
574  if (dbg)
575  LogTrace("CSCGEMMotherboardME11") << "lut 0 1 = " << lut[code][0] << " " << lut[code][1] << std::endl;
576 
577  // check matching copads
578  const GEMCoPadDigi& bb_copad = bestMatchingPad<GEMCoPadDigi>(bestALCT, bestCLCT, copads);
579  const GEMCoPadDigi& bs_copad = bestMatchingPad<GEMCoPadDigi>(bestALCT, secondCLCT, copads);
580  const GEMCoPadDigi& sb_copad = bestMatchingPad<GEMCoPadDigi>(secondALCT, bestCLCT, copads);
581  const GEMCoPadDigi& ss_copad = bestMatchingPad<GEMCoPadDigi>(secondALCT, secondCLCT, copads);
582 
583  // check matching pads
584  const GEMPadDigi& bb_pad = bestMatchingPad<GEMPadDigi>(bestALCT, bestCLCT, pads);
585  const GEMPadDigi& bs_pad = bestMatchingPad<GEMPadDigi>(bestALCT, secondCLCT, pads);
586  const GEMPadDigi& sb_pad = bestMatchingPad<GEMPadDigi>(secondALCT, bestCLCT, pads);
587  const GEMPadDigi& ss_pad = bestMatchingPad<GEMPadDigi>(secondALCT, secondCLCT, pads);
588 
589  // evaluate possible combinations
590  const bool ok_bb_copad = ok11 == 1 and ok_bb and bb_copad.isValid();
591  const bool ok_bs_copad = ok12 == 1 and ok_bs and bs_copad.isValid();
592  const bool ok_sb_copad = ok21 == 1 and ok_sb and sb_copad.isValid();
593  const bool ok_ss_copad = ok22 == 1 and ok_ss and ss_copad.isValid();
594 
595  const bool ok_bb_pad = ok11 == 1 and ok_bb and bb_pad.isValid();
596  const bool ok_bs_pad = ok12 == 1 and ok_bs and bs_pad.isValid();
597  const bool ok_sb_pad = ok21 == 1 and ok_sb and sb_pad.isValid();
598  const bool ok_ss_pad = ok22 == 1 and ok_ss and ss_pad.isValid();
599 
600  switch (lut[code][0]) {
601  case 11:
602  if (ok_bb_copad)
603  lct1 = CSCGEMMotherboard::constructLCTsGEM(bestALCT, bestCLCT, bb_copad, 1);
604  else if (ok_bb_pad)
605  lct1 = CSCGEMMotherboard::constructLCTsGEM(bestALCT, bestCLCT, bb_pad, 1);
606  else
607  lct1 = constructLCTs(bestALCT, bestCLCT, CSCCorrelatedLCTDigi::ALCTCLCT, 1);
608  break;
609  case 12:
610  if (ok_bs_copad)
611  lct1 = CSCGEMMotherboard::constructLCTsGEM(bestALCT, secondCLCT, bs_copad, 1);
612  else if (ok_bs_pad)
613  lct1 = CSCGEMMotherboard::constructLCTsGEM(bestALCT, secondCLCT, bs_pad, 1);
614  else
615  lct1 = constructLCTs(bestALCT, secondCLCT, CSCCorrelatedLCTDigi::ALCTCLCT, 1);
616  break;
617  case 21:
618  if (ok_sb_copad)
619  lct1 = CSCGEMMotherboard::constructLCTsGEM(secondALCT, bestCLCT, sb_copad, 1);
620  else if (ok_sb_pad)
621  lct1 = CSCGEMMotherboard::constructLCTsGEM(secondALCT, bestCLCT, sb_pad, 1);
622  else
623  lct1 = constructLCTs(secondALCT, bestCLCT, CSCCorrelatedLCTDigi::ALCTCLCT, 1);
624  break;
625  case 22:
626  if (ok_ss_copad)
627  lct1 = CSCGEMMotherboard::constructLCTsGEM(secondALCT, secondCLCT, ss_copad, 1);
628  else if (ok_ss_pad)
629  lct1 = CSCGEMMotherboard::constructLCTsGEM(secondALCT, secondCLCT, ss_pad, 1);
630  else
631  lct1 = constructLCTs(secondALCT, secondCLCT, CSCCorrelatedLCTDigi::ALCTCLCT, 1);
632  break;
633  default:
634  return;
635  }
636 
637  if (dbg)
638  LogTrace("CSCGEMMotherboardME11") << "lct1: " << lct1 << std::endl;
639 
640  switch (lut[code][1]) {
641  case 12:
642  if (ok_bs_copad)
643  lct2 = CSCGEMMotherboard::constructLCTsGEM(bestALCT, secondCLCT, bs_copad, 2);
644  else if (ok_bs_pad)
645  lct2 = CSCGEMMotherboard::constructLCTsGEM(bestALCT, secondCLCT, bs_pad, 2);
646  else
647  lct2 = constructLCTs(bestALCT, secondCLCT, CSCCorrelatedLCTDigi::ALCTCLCT, 2);
648  break;
649  case 21:
650  if (ok_sb_copad)
651  lct2 = CSCGEMMotherboard::constructLCTsGEM(secondALCT, bestCLCT, sb_copad, 2);
652  else if (ok_sb_pad)
653  lct2 = CSCGEMMotherboard::constructLCTsGEM(secondALCT, bestCLCT, sb_pad, 2);
654  else
655  lct2 = constructLCTs(secondALCT, bestCLCT, CSCCorrelatedLCTDigi::ALCTCLCT, 2);
656  break;
657  case 22:
658  if (ok_bb_copad)
659  lct2 = CSCGEMMotherboard::constructLCTsGEM(secondALCT, secondCLCT, bb_copad, 2);
660  else if (ok_bb_pad)
661  lct2 = CSCGEMMotherboard::constructLCTsGEM(secondALCT, secondCLCT, bb_pad, 2);
662  else
663  lct2 = constructLCTs(secondALCT, secondCLCT, CSCCorrelatedLCTDigi::ALCTCLCT, 2);
664  break;
665  default:
666  return;
667  }
668 
669  if (dbg)
670  LogTrace("CSCGEMMotherboardME11") << "lct2: " << lct2 << std::endl;
671 
672  if (dbg)
673  LogTrace("CSCGEMMotherboardME11") << "out of correlateLCTs" << std::endl;
674  return;
675 }

References CSCCorrelatedLCTDigi::ALCTCLCT, CSCALCTDigi::clear(), CSCCLCTDigi::clear(), CSCMotherboard::constructLCTs(), CSCGEMMotherboard::constructLCTsGEM(), CSCBaseboard::cscId_, doesALCTCrossCLCT(), GEMCoPadDigi::isValid(), GEMPadDigi::isValid(), CSCALCTDigi::isValid(), CSCCLCTDigi::isValid(), and LogTrace.

Referenced by run().

◆ doesALCTCrossCLCT()

bool CSCGEMMotherboardME11::doesALCTCrossCLCT ( const CSCALCTDigi &  a,
const CSCCLCTDigi &  c 
) const
private

Definition at line 501 of file CSCGEMMotherboardME11.cc.

501  {
502  return cscTmbLUT_->doesALCTCrossCLCT(a, c, theEndcap, gangedME1a_);
503 }

References a, HltBtagPostValidation_cff::c, cscTmbLUT_, CSCBaseboard::gangedME1a_, and CSCBaseboard::theEndcap.

Referenced by correlateLCTsGEM().

◆ doesWiregroupCrossStrip()

bool CSCGEMMotherboardME11::doesWiregroupCrossStrip ( int  key_wg,
int  key_hs 
) const
overrideprivatevirtual

Reimplemented from CSCGEMMotherboard.

Definition at line 505 of file CSCGEMMotherboardME11.cc.

505  {
506  return cscTmbLUT_->doesWiregroupCrossStrip(key_wg, key_strip, theEndcap, gangedME1a_);
507 }

References cscTmbLUT_, CSCBaseboard::gangedME1a_, and CSCBaseboard::theEndcap.

◆ getLUT()

const CSCGEMMotherboardLUTME11* CSCGEMMotherboardME11::getLUT ( ) const
inlineoverrideprivatevirtual

Implements CSCGEMMotherboard.

Definition at line 44 of file CSCGEMMotherboardME11.h.

44 { return tmbLUT_.get(); }

References tmbLUT_.

◆ readoutLCTs1a()

std::vector< CSCCorrelatedLCTDigi > CSCGEMMotherboardME11::readoutLCTs1a ( ) const

Definition at line 396 of file CSCGEMMotherboardME11.cc.

396 { return readoutLCTsME11(ME1A); }

References ME1A, and readoutLCTsME11().

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

◆ readoutLCTs1b()

std::vector< CSCCorrelatedLCTDigi > CSCGEMMotherboardME11::readoutLCTs1b ( ) const

Definition at line 398 of file CSCGEMMotherboardME11.cc.

398 { return readoutLCTsME11(ME1B); }

References ME1B, and readoutLCTsME11().

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

◆ readoutLCTsME11()

std::vector< CSCCorrelatedLCTDigi > CSCGEMMotherboardME11::readoutLCTsME11 ( enum CSCPart  me1ab) const
private

Definition at line 403 of file CSCGEMMotherboardME11.cc.

403  {
404  std::vector<CSCCorrelatedLCTDigi> tmpV;
405 
406  // The start time of the L1A*LCT coincidence window should be related
407  // to the fifo_pretrig parameter, but I am not completely sure how.
408  // Just choose it such that the window is centered at bx=7. This may
409  // need further tweaking if the value of tmb_l1a_window_size changes.
410  //static int early_tbins = 4;
411  // The number of LCT bins in the read-out is given by the
412  // tmb_l1a_window_size parameter, forced to be odd
413  const int lct_bins = (tmb_l1a_window_size % 2 == 0) ? tmb_l1a_window_size + 1 : tmb_l1a_window_size;
414  const int late_tbins = early_tbins + lct_bins;
415 
416  // Start from the vector of all found correlated LCTs and select
417  // those within the LCT*L1A coincidence window.
418  int bx_readout = -1;
419  std::vector<CSCCorrelatedLCTDigi> all_lcts;
420  switch (tmb_cross_bx_algo) {
421  case 0:
422  case 1:
423  allLCTs.getMatched(all_lcts);
424  break;
425  case 2:
426  sortLCTs(all_lcts, CSCUpgradeMotherboard::sortLCTsByQuality);
427  break;
428  case 3:
429  sortLCTs(all_lcts, CSCUpgradeMotherboard::sortLCTsByGEMDphi);
430  break;
431  default:
432  LogTrace("CSCGEMMotherboardME11") << "tmb_cross_bx_algo error" << std::endl;
433  break;
434  }
435 
436  for (const auto& lct : all_lcts) {
437  if (!lct.isValid())
438  continue;
439 
440  int bx = lct.getBX();
441  // Skip LCTs found too early relative to L1Accept.
442  if (bx <= early_tbins)
443  continue;
444 
445  // Skip LCTs found too late relative to L1Accept.
446  if (bx > late_tbins)
447  continue;
448 
449  if ((me1ab == CSCPart::ME1B and lct.getStrip() > CSCConstants::MAX_HALF_STRIP_ME1B) or
450  (me1ab == CSCPart::ME1A and lct.getStrip() <= CSCConstants::MAX_HALF_STRIP_ME1B))
451  continue;
452 
453  // If (readout_earliest_2) take only LCTs in the earliest bx in the read-out window:
454  // in digi->raw step, LCTs have to be packed into the TMB header, and
455  // currently there is room just for two.
456  if (readout_earliest_2 and (bx_readout == -1 or bx == bx_readout)) {
457  tmpV.push_back(lct);
458  if (bx_readout == -1)
459  bx_readout = bx;
460  } else
461  tmpV.push_back(lct);
462  }
463 
464  // do a final check on the LCTs in readout
465  qualityControl_->checkMultiplicityBX(tmpV);
466  for (const auto& lct : tmpV) {
467  qualityControl_->checkValid(lct);
468  }
469 
470  return tmpV;
471 }

References CSCUpgradeMotherboard::allLCTs, l1GtPatternGenerator_cfi::bx, CSCMotherboard::early_tbins, LCTContainer::getMatched(), LogTrace, CSCConstants::MAX_HALF_STRIP_ME1B, ME1A, ME1B, or, CSCMotherboard::qualityControl_, CSCMotherboard::readout_earliest_2, sortLCTs(), CSCUpgradeMotherboard::sortLCTsByGEMDphi(), CSCUpgradeMotherboard::sortLCTsByQuality(), CSCUpgradeMotherboard::tmb_cross_bx_algo, and CSCMotherboard::tmb_l1a_window_size.

Referenced by readoutLCTs1a(), and readoutLCTs1b().

◆ run()

void CSCGEMMotherboardME11::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 57 of file CSCGEMMotherboardME11.cc.

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

References CSCConstants::ALCT_CLCT_OFFSET, CSCMotherboard::alctProc, CSCMotherboard::alctV, CSCUpgradeMotherboard::allLCTs, b, buildLCTfromALCTandGEM_ME1b_, buildLCTfromCLCTandGEM_ME1b_, CSCMotherboard::clctProc, clctV, CSCGEMMotherboard::clear(), CSCGEMMotherboard::coPads_, correlateLCTsGEM(), CSCGEMMotherboard::correlateLCTsGEM(), CSCBaseboard::cscGeometry_, CSCBaseboard::cscId_, CSCUpgradeMotherboard::debug_matching, CSCUpgradeMotherboard::debugLUTs(), CSCMotherboard::drop_used_clcts, dropLowQualityCLCTsNoGEMs_ME1b_, CSCMotherboard::encodeHighMultiplicityBits(), CSCGEMMotherboard::gem_g, CSCGEMMotherboard::gemGeometryAvailable, CSCBaseboard::infoV, LogTrace, CSCUpgradeMotherboard::match_earliest_clct_only, CSCMotherboard::match_trig_window_size, CSCConstants::MAX_ALCT_TBINS, CSCConstants::MAX_CLCT_TBINS, CSCGEMMotherboard::maxDeltaBXCoPad_, ME11, or, AlCaHLTBitMon_ParallelJobs::p, CSCGEMMotherboard::pads_, CSCGEMMotherboard::printGEMTriggerCoPads(), CSCGEMMotherboard::printGEMTriggerPads(), CSCGEMMotherboard::processGEMClusters(), qcdUeDQM_cfi::quality, readoutLCTs1a(), readoutLCTs1b(), CSCGEMMotherboard::setupGeometry(), and CSCUpgradeMotherboard::tmb_cross_bx_algo.

Referenced by CSCTriggerPrimitivesBuilder::build().

◆ sortLCTs() [1/2]

void CSCGEMMotherboardME11::sortLCTs ( std::vector< CSCCorrelatedLCTDigi > &  LCTs,
bool(*)(const CSCCorrelatedLCTDigi &, const CSCCorrelatedLCTDigi &)  sorter 
) const
private

Definition at line 487 of file CSCGEMMotherboardME11.cc.

488  {
489  for (int bx = 0; bx < CSCConstants::MAX_LCT_TBINS; bx++) {
490  // temporary collection with all LCTs in the whole chamber
491  std::vector<CSCCorrelatedLCTDigi> LCTs_tmp;
492  CSCGEMMotherboardME11::sortLCTs(LCTs_tmp, bx, *sorter);
493 
494  // Add the LCTs
495  for (const auto& p : LCTs_tmp) {
496  LCTs.push_back(p);
497  }
498  }
499 }

References l1GtPatternGenerator_cfi::bx, CSCConstants::MAX_LCT_TBINS, AlCaHLTBitMon_ParallelJobs::p, and sortLCTs().

◆ sortLCTs() [2/2]

void CSCGEMMotherboardME11::sortLCTs ( std::vector< CSCCorrelatedLCTDigi > &  LCTs,
int  bx,
bool(*)(const CSCCorrelatedLCTDigi &, const CSCCorrelatedLCTDigi &)  sorter 
) const
private

Methods to sort the LCTs

Definition at line 475 of file CSCGEMMotherboardME11.cc.

477  {
478  allLCTs.getTimeMatched(bx, LCTs);
479 
480  CSCUpgradeMotherboard::sortLCTs(LCTs, *sorter);
481 
482  if (LCTs.size() > max_lcts)
483  LCTs.erase(LCTs.begin() + max_lcts, LCTs.end());
484 }

References CSCUpgradeMotherboard::allLCTs, l1GtPatternGenerator_cfi::bx, LCTContainer::getTimeMatched(), CSCUpgradeMotherboard::max_lcts, and CSCUpgradeMotherboard::sortLCTs().

Referenced by readoutLCTsME11(), and sortLCTs().

Member Data Documentation

◆ buildLCTfromALCTandGEM_ME1a_

bool CSCGEMMotherboardME11::buildLCTfromALCTandGEM_ME1a_
private

Definition at line 85 of file CSCGEMMotherboardME11.h.

◆ buildLCTfromALCTandGEM_ME1b_

bool CSCGEMMotherboardME11::buildLCTfromALCTandGEM_ME1b_
private

Definition at line 86 of file CSCGEMMotherboardME11.h.

Referenced by run().

◆ buildLCTfromCLCTandGEM_ME1a_

bool CSCGEMMotherboardME11::buildLCTfromCLCTandGEM_ME1a_
private

Definition at line 87 of file CSCGEMMotherboardME11.h.

◆ buildLCTfromCLCTandGEM_ME1b_

bool CSCGEMMotherboardME11::buildLCTfromCLCTandGEM_ME1b_
private

Definition at line 88 of file CSCGEMMotherboardME11.h.

Referenced by run().

◆ clctV

std::vector<CSCCLCTDigi> CSCGEMMotherboardME11::clctV
private

Definition at line 76 of file CSCGEMMotherboardME11.h.

Referenced by run().

◆ cscTmbLUT_

std::unique_ptr<CSCMotherboardLUTME11> CSCGEMMotherboardME11::cscTmbLUT_
private

Definition at line 46 of file CSCGEMMotherboardME11.h.

Referenced by CSCGEMMotherboardME11(), doesALCTCrossCLCT(), and doesWiregroupCrossStrip().

◆ dropLowQualityALCTsNoGEMs_ME1a_

bool CSCGEMMotherboardME11::dropLowQualityALCTsNoGEMs_ME1a_
private

Definition at line 81 of file CSCGEMMotherboardME11.h.

◆ dropLowQualityALCTsNoGEMs_ME1b_

bool CSCGEMMotherboardME11::dropLowQualityALCTsNoGEMs_ME1b_
private

Definition at line 82 of file CSCGEMMotherboardME11.h.

◆ dropLowQualityCLCTsNoGEMs_ME1a_

bool CSCGEMMotherboardME11::dropLowQualityCLCTsNoGEMs_ME1a_
private

Definition at line 79 of file CSCGEMMotherboardME11.h.

◆ dropLowQualityCLCTsNoGEMs_ME1b_

bool CSCGEMMotherboardME11::dropLowQualityCLCTsNoGEMs_ME1b_
private

Definition at line 80 of file CSCGEMMotherboardME11.h.

Referenced by run().

◆ promoteCLCTGEMquality_ME1a_

bool CSCGEMMotherboardME11::promoteCLCTGEMquality_ME1a_
private

Definition at line 91 of file CSCGEMMotherboardME11.h.

◆ promoteCLCTGEMquality_ME1b_

bool CSCGEMMotherboardME11::promoteCLCTGEMquality_ME1b_
private

Definition at line 92 of file CSCGEMMotherboardME11.h.

◆ tmbLUT_

std::unique_ptr<CSCGEMMotherboardLUTME11> CSCGEMMotherboardME11::tmbLUT_
private

Definition at line 45 of file CSCGEMMotherboardME11.h.

Referenced by CSCGEMMotherboardME11(), and getLUT().

CSCMotherboard::qualityControl_
std::unique_ptr< LCTQualityControl > qualityControl_
Definition: CSCMotherboard.h:128
ME11
Definition: CSCUpgradeMotherboardLUT.h:12
CSCBaseboard::theEndcap
const unsigned theEndcap
Definition: CSCBaseboard.h:42
CSCMotherboard::match_trig_window_size
unsigned int match_trig_window_size
Definition: CSCMotherboard.h:99
CSCGEMMotherboardME11::clctV
std::vector< CSCCLCTDigi > clctV
Definition: CSCGEMMotherboardME11.h:76
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
CSCGEMMotherboard::constructLCTsGEM
CSCCorrelatedLCTDigi constructLCTsGEM(const CSCALCTDigi &alct, const GEMCoPadDigi &gem, int i) const
Definition: CSCGEMMotherboard.cc:91
CSCGEMMotherboardME11::readoutLCTs1a
std::vector< CSCCorrelatedLCTDigi > readoutLCTs1a() const
Definition: CSCGEMMotherboardME11.cc:396
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
CSCGEMMotherboardME11::buildLCTfromCLCTandGEM_ME1a_
bool buildLCTfromCLCTandGEM_ME1a_
Definition: CSCGEMMotherboardME11.h:87
CSCGEMMotherboard::setupGeometry
void setupGeometry()
Definition: CSCGEMMotherboard.cc:310
CSCCLCTDigi
Definition: CSCCLCTDigi.h:17
CSCCorrelatedLCTDigi::ALCTCLCT
Definition: CSCCorrelatedLCTDigi.h:191
CSCGEMMotherboardME11::dropLowQualityCLCTsNoGEMs_ME1b_
bool dropLowQualityCLCTsNoGEMs_ME1b_
Definition: CSCGEMMotherboardME11.h:80
CSCBaseboard::runME11ILT_
bool runME11ILT_
Definition: CSCBaseboard.h:92
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
CSCMotherboard::constructLCTs
CSCCorrelatedLCTDigi constructLCTs(const CSCALCTDigi &aLCT, const CSCCLCTDigi &cLCT, int type, int trknmb) const
Definition: CSCMotherboard.cc:486
CSCGEMMotherboard::correlateLCTsGEM
void correlateLCTsGEM(const T &best, const T &second, const GEMCoPadDigiIds &coPads, CSCCorrelatedLCTDigi &lct1, CSCCorrelatedLCTDigi &lct2) const
Definition: CSCGEMMotherboard.h:465
CSCGEMMotherboardME11::tmbLUT_
std::unique_ptr< CSCGEMMotherboardLUTME11 > tmbLUT_
Definition: CSCGEMMotherboardME11.h:45
CSCGEMMotherboard::CSCGEMMotherboard
CSCGEMMotherboard()
Definition: CSCGEMMotherboard.cc:29
CSCGEMMotherboardME11::buildLCTfromALCTandGEM_ME1a_
bool buildLCTfromALCTandGEM_ME1a_
Definition: CSCGEMMotherboardME11.h:85
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
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::gangedME1a_
bool gangedME1a_
Definition: CSCBaseboard.h:89
CSCGEMMotherboardME11::dropLowQualityALCTsNoGEMs_ME1b_
bool dropLowQualityALCTsNoGEMs_ME1b_
Definition: CSCGEMMotherboardME11.h:82
b
double b
Definition: hdecay.h:118
CSCBaseboard::runPhase2_
bool runPhase2_
Definition: CSCBaseboard.h:85
CSCGEMMotherboardME11::cscTmbLUT_
std::unique_ptr< CSCMotherboardLUTME11 > cscTmbLUT_
Definition: CSCGEMMotherboardME11.h:46
GEMCoPadDigi
Definition: GEMCoPadDigi.h:16
CSCGEMMotherboardME11::readoutLCTs1b
std::vector< CSCCorrelatedLCTDigi > readoutLCTs1b() const
Definition: CSCGEMMotherboardME11.cc:398
a
double a
Definition: hdecay.h:119
ME1A
Definition: CSCUpgradeMotherboardLUT.h:12
CSCUpgradeMotherboard::debug_matching
bool debug_matching
Definition: CSCUpgradeMotherboard.h:115
sorter
Definition: SETFilter.cc:31
CSCConstants::MAX_HALF_STRIP_ME1B
Definition: CSCConstants.h:39
CSCGEMMotherboardME11::dropLowQualityCLCTsNoGEMs_ME1a_
bool dropLowQualityCLCTsNoGEMs_ME1a_
Definition: CSCGEMMotherboardME11.h:79
LCTContainer::getTimeMatched
void getTimeMatched(const int bx, std::vector< CSCCorrelatedLCTDigi > &) const
Definition: LCTContainer.cc:7
CSCGEMMotherboardME11::promoteCLCTGEMquality_ME1a_
bool promoteCLCTGEMquality_ME1a_
Definition: CSCGEMMotherboardME11.h:91
CSCMotherboard::early_tbins
int early_tbins
Definition: CSCMotherboard.h:108
CSCCLCTDigi::isValid
bool isValid() const
check CLCT validity (1 - valid CLCT)
Definition: CSCCLCTDigi.h:48
CSCGEMMotherboardME11::sortLCTs
void sortLCTs(std::vector< CSCCorrelatedLCTDigi > &, int bx, bool(*sorter)(const CSCCorrelatedLCTDigi &, const CSCCorrelatedLCTDigi &)) const
Definition: CSCGEMMotherboardME11.cc:475
CSCUpgradeMotherboard::sortLCTs
void sortLCTs(std::vector< CSCCorrelatedLCTDigi > &lcts, bool(*sorter)(const CSCCorrelatedLCTDigi &, const CSCCorrelatedLCTDigi &)) const
Definition: CSCUpgradeMotherboard.cc:315
CSCGEMMotherboardME11::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: CSCGEMMotherboardME11.cc:509
CSCGEMMotherboardME11::doesALCTCrossCLCT
bool doesALCTCrossCLCT(const CSCALCTDigi &a, const CSCCLCTDigi &c) const
Definition: CSCGEMMotherboardME11.cc:501
HltBtagPostValidation_cff.c
c
Definition: HltBtagPostValidation_cff.py:31
edm::LogError
Log< level::Error, false > LogError
Definition: MessageLogger.h:123
CSCMotherboard::readout_earliest_2
bool readout_earliest_2
Definition: CSCMotherboard.h:111
CSCMotherboard::drop_used_clcts
bool drop_used_clcts
Definition: CSCMotherboard.h:105
CSCMotherboard::encodeHighMultiplicityBits
void encodeHighMultiplicityBits(unsigned alctBits)
Definition: CSCMotherboard.cc:709
CSCUpgradeMotherboard::sortLCTsByQuality
static bool sortLCTsByQuality(const CSCCorrelatedLCTDigi &, const CSCCorrelatedLCTDigi &)
Definition: CSCUpgradeMotherboard.cc:307
CSCUpgradeMotherboard::allLCTs
LCTContainer allLCTs
Definition: CSCUpgradeMotherboard.h:98
CSCMotherboard::tmb_l1a_window_size
unsigned int tmb_l1a_window_size
Definition: CSCMotherboard.h:99
qcdUeDQM_cfi.quality
quality
Definition: qcdUeDQM_cfi.py:31
CSCGEMMotherboardME11::promoteCLCTGEMquality_ME1b_
bool promoteCLCTGEMquality_ME1b_
Definition: CSCGEMMotherboardME11.h:92
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
CSCGEMMotherboardME11::readoutLCTsME11
std::vector< CSCCorrelatedLCTDigi > readoutLCTsME11(enum CSCPart me1ab) const
Definition: CSCGEMMotherboardME11.cc:403
CSCConstants::MAX_CLCT_TBINS
Definition: CSCConstants.h:63
relativeConstraints.chamber
chamber
Definition: relativeConstraints.py:53
CSCGEMMotherboardME11::dropLowQualityALCTsNoGEMs_ME1a_
bool dropLowQualityALCTsNoGEMs_ME1a_
Definition: CSCGEMMotherboardME11.h:81
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
CSCGEMMotherboardME11::buildLCTfromCLCTandGEM_ME1b_
bool buildLCTfromCLCTandGEM_ME1b_
Definition: CSCGEMMotherboardME11.h:88
CSCGEMMotherboard::pads_
GEMPadDigiIdsBX pads_
Definition: CSCGEMMotherboard.h:219
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
LogTrace
#define LogTrace(id)
Definition: MessageLogger.h:224
GEMPadDigi::isValid
bool isValid() const
Definition: GEMPadDigi.cc:26
CSCUpgradeMotherboard::max_lcts
unsigned int max_lcts
Definition: CSCUpgradeMotherboard.h:112
CSCGEMMotherboard::gem_g
const GEMGeometry * gem_g
Definition: CSCGEMMotherboard.h:213
CSCGEMMotherboardME11::buildLCTfromALCTandGEM_ME1b_
bool buildLCTfromALCTandGEM_ME1b_
Definition: CSCGEMMotherboardME11.h:86
GEMCoPadDigi::isValid
bool isValid() const
Definition: GEMCoPadDigi.cc:18
ME1B
Definition: CSCUpgradeMotherboardLUT.h:12
CSCBaseboard::infoV
int infoV
Definition: CSCBaseboard.h:64
Generated for CMSSW Reference Manual by doxygen 1.8.16