CMS 3D CMS Logo
List of all members | Public Types | Public Member Functions | Public Attributes | Protected Member Functions | Protected Attributes | Private Member Functions
CSCGEMMotherboard Class Referenceabstract

#include <CSCGEMMotherboard.h>

Inheritance diagram for CSCGEMMotherboard:
CSCUpgradeMotherboard CSCMotherboard CSCBaseboard CSCGEMMotherboardME11 CSCGEMMotherboardME21

Public Types

enum  Default_values { DEFAULT_MATCHING_VALUE = -99 }
 

Public Member Functions

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
 
virtual void run (const CSCWireDigiCollection *wiredc, const CSCComparatorDigiCollection *compdc, const GEMPadDigiClusterCollection *gemPads)=0
 
virtual void run (const CSCWireDigiCollection *wiredc, const CSCComparatorDigiCollection *compdc, const GEMPadDigiCollection *gemPads)=0
 
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
 

Public Attributes

std::unique_ptr< GEMCoPadProcessor > coPadProcessor
 
- Public Attributes inherited from CSCMotherboard
std::unique_ptr< CSCAnodeLCTProcessor > alctProc
 
std::unique_ptr< CSCCathodeLCTProcessor > clctProc
 

Protected Member Functions

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
 
virtual bool doesWiregroupCrossStrip (int key_wg, int key_strip) const
 
unsigned int findQualityGEM (const CSCALCTDigi &, const CSCCLCTDigi &, int gemlayer) const
 
int getBX (const GEMCoPadDigi &p) const
 
int getBX (const GEMPadDigi &p) const
 
virtual const CSCGEMMotherboardLUT * getLUT () const =0
 
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 retrieveGEMCoPads ()
 
void retrieveGEMPads (const GEMPadDigiCollection *pads, unsigned id)
 
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
 
unsigned int findQuality (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

GEMCoPadDigiIdsBX coPads_
 
bool doLCTGhostBustingWithGEMs_
 
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_
 
bool useOldLCTDataFormat_
 
- 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
 
bool readout_earliest_2
 
CSCCorrelatedLCTDigi secondLCT [CSCConstants::MAX_LCT_TBINS]
 
unsigned int tmb_l1a_window_size
 
bool useHighMultiplicityBits_
 
- Protected Attributes inherited from CSCBaseboard
unsigned int alctClctOffset_
 
edm::ParameterSet alctParams_
 
edm::ParameterSet clctParams_
 
edm::ParameterSet commonParams_
 
const CSCChamber * cscChamber_
 
const CSCGeometry * cscGeometry_
 
CSCDetId cscId_
 
bool disableME1a_
 
bool enableAlctSLHC_
 
bool gangedME1a_
 
int infoV
 
bool isME11_
 
bool isSLHC_
 
bool runME11ILT_
 
bool runME11Up_
 
bool runME21ILT_
 
bool runME21Up_
 
bool runME31Up_
 
bool runME41Up_
 
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_
 

Private Member Functions

template<class T >
int getLctTrigEnable () const
 
template<>
int getLctTrigEnable () const
 
template<>
int getLctTrigEnable () const
 
template<class T >
int getMaxDeltaBX () const
 
template<>
int getMaxDeltaBX () const
 
template<>
int getMaxDeltaBX () const
 
template<class T >
const matchesBX< T > & getPads () const
 
template<>
const matchesBX< GEMCoPadDigi > & getPads () const
 
template<>
const matchesBX< GEMPadDigi > & getPads () const
 

Additional Inherited Members

- Static Public Member Functions inherited from CSCUpgradeMotherboard
static bool sortLCTsByGEMDphi (const CSCCorrelatedLCTDigi &, const CSCCorrelatedLCTDigi &)
 
static bool sortLCTsByQuality (const CSCCorrelatedLCTDigi &, const CSCCorrelatedLCTDigi &)
 
- Protected Types inherited from CSCMotherboard
enum  LCT_Quality {
  INVALID = 0, NO_CLCT = 1, NO_ALCT = 2, CLCT_LAYER_TRIGGER = 3,
  LOW_QUALITY = 4, MARGINAL_ANODE_CATHODE = 5, HQ_ANODE_MARGINAL_CATHODE = 6, HQ_CATHODE_MARGINAL_ANODE = 7,
  HQ_ACCEL_ALCT = 8, HQ_RESERVED_1 = 9, HQ_RESERVED_2 = 10, HQ_PATTERN_2_3 = 11,
  HQ_PATTERN_4_5 = 12, HQ_PATTERN_6_7 = 13, HQ_PATTERN_8_9 = 14, HQ_PATTERN_10 = 15
}
 
- 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

Base class for TMBs for the GEM-CSC integrated local trigger. Inherits from CSCUpgradeMotherboard. Provides common functionality to match ALCT/CLCT to GEM pads or copads. Matching functions are templated so they work both for GEMPadDigi and GEMCoPadDigi

Author
Sven Dildick (TAMU)

Definition at line 29 of file CSCGEMMotherboard.h.

Member Enumeration Documentation

◆ Default_values

enum CSCGEMMotherboard::Default_values
Enumerator
DEFAULT_MATCHING_VALUE 

Definition at line 31 of file CSCGEMMotherboard.h.

31 { DEFAULT_MATCHING_VALUE = -99 };

Constructor & Destructor Documentation

◆ CSCGEMMotherboard() [1/2]

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

Definition at line 3 of file CSCGEMMotherboard.cc.

9  : CSCUpgradeMotherboard(endcap, station, sector, subsector, chamber, conf),
10  maxDeltaBXPad_(tmbParams_.getParameter<int>("maxDeltaBXPad")),
11  maxDeltaBXCoPad_(tmbParams_.getParameter<int>("maxDeltaBXCoPad")),
12  useOldLCTDataFormat_(tmbParams_.getParameter<bool>("useOldLCTDataFormat")),
13  promoteALCTGEMpattern_(tmbParams_.getParameter<bool>("promoteALCTGEMpattern")),
14  promoteALCTGEMquality_(tmbParams_.getParameter<bool>("promoteALCTGEMquality")),
15  doLCTGhostBustingWithGEMs_(tmbParams_.getParameter<bool>("doLCTGhostBustingWithGEMs")) {
16  // super chamber has layer=0!
17  gemId = GEMDetId(theRegion, 1, theStation, 0, theChamber, 0).rawId();
18 
19  const edm::ParameterSet coPadParams(station == 1 ? conf.getParameter<edm::ParameterSet>("copadParamGE11")
20  : conf.getParameter<edm::ParameterSet>("copadParamGE21"));
21  coPadProcessor.reset(new GEMCoPadProcessor(theRegion, theStation, theChamber, coPadParams));
22 
23  maxDeltaPadL1_ = (theParity ? tmbParams_.getParameter<int>("maxDeltaPadL1Even")
24  : tmbParams_.getParameter<int>("maxDeltaPadL1Odd"));
25  maxDeltaPadL2_ = (theParity ? tmbParams_.getParameter<int>("maxDeltaPadL2Even")
26  : tmbParams_.getParameter<int>("maxDeltaPadL2Odd"));
27 }

References coPadProcessor, gemId, edm::ParameterSet::getParameter(), maxDeltaPadL1_, maxDeltaPadL2_, DetId::rawId(), relativeConstraints::station, CSCBaseboard::theChamber, CSCUpgradeMotherboard::theParity, CSCBaseboard::theRegion, CSCBaseboard::theStation, and CSCBaseboard::tmbParams_.

◆ CSCGEMMotherboard() [2/2]

CSCGEMMotherboard::CSCGEMMotherboard ( )

Definition at line 29 of file CSCGEMMotherboard.cc.

29 : CSCUpgradeMotherboard() {}

◆ ~CSCGEMMotherboard()

CSCGEMMotherboard::~CSCGEMMotherboard ( )
override

Definition at line 31 of file CSCGEMMotherboard.cc.

31 {}

Member Function Documentation

◆ bestMatchingPad() [1/6]

template<class T >
T CSCGEMMotherboard::bestMatchingPad ( const CSCALCTDigi &  ,
const CSCCLCTDigi &  ,
const matches< T > &   
) const
protected

◆ bestMatchingPad() [2/6]

template<class T >
T CSCGEMMotherboard::bestMatchingPad ( const CSCALCTDigi &  ,
const matches< T > &   
) const
protected

◆ bestMatchingPad() [3/6]

template<class S >
S CSCGEMMotherboard::bestMatchingPad ( const CSCALCTDigi &  alct1,
const CSCCLCTDigi &  clct1,
const matches< S > &  pads 
) const
protected

Definition at line 430 of file CSCGEMMotherboard.h.

430  {
431  S result;
432  // no matching pads for invalid stub
433  if (not alct1.isValid() or not clct1.isValid()) {
434  return result;
435  }
436 
437  auto part(getCSCPart(clct1.getKeyStrip()));
438 
439  // return the pad with the smallest bending angle
440  float averagePadNumberCSC = getPad(clct1, part);
441  float minDeltaPad = 999;
442  for (const auto& p : pads) {
443  // protection against corrupted DetIds
444  if (not isGEMDetId(p.first))
445  continue;
446 
447  float averagePadNumberGEM = getPad(p.second);
448 
449  int delta;
450  if (GEMDetId(p.first).station() == 2)
451  delta = 1;
452 
453  // add another safety to make sure that the deltaPad is not larger than max value!!!
454  if (std::abs(averagePadNumberCSC - averagePadNumberGEM) < minDeltaPad and
455  getRolls(alct1).first - delta <= getRoll(p) and getRoll(p) <= getRolls(alct1).second) {
456  minDeltaPad = std::abs(averagePadNumberCSC - averagePadNumberGEM);
457  result = p.second;
458  }
459  }
460  return result;
461 }

References funct::abs(), dumpMFGeometry_cfg::delta, CSCUpgradeMotherboard::getCSCPart(), CSCCLCTDigi::getKeyStrip(), getPad(), getRoll(), getRolls(), isGEMDetId(), CSCALCTDigi::isValid(), CSCCLCTDigi::isValid(), or, AlCaHLTBitMon_ParallelJobs::p, mps_fire::result, and GEMDetId::station().

◆ bestMatchingPad() [4/6]

template<class S >
S CSCGEMMotherboard::bestMatchingPad ( const CSCALCTDigi &  alct1,
const matches< S > &  pads 
) const
protected

Definition at line 382 of file CSCGEMMotherboard.h.

382  {
383  S result;
384  // no matching pads for invalid stub
385  if (not alct1.isValid()) {
386  return result;
387  }
388  // return the first one with the same roll number
389  for (const auto& p : pads) {
390  // protection against corrupted DetIds
391  if (not isGEMDetId(p.first))
392  continue;
393 
394  // roll number of pad and ALCT must match
395  if (getRolls(alct1).first <= getRoll(p) and getRoll(p) <= getRolls(alct1).second) {
396  return p.second;
397  }
398  }
399  return result;
400 }

References getRoll(), getRolls(), isGEMDetId(), CSCALCTDigi::isValid(), AlCaHLTBitMon_ParallelJobs::p, and mps_fire::result.

◆ bestMatchingPad() [5/6]

template<class T >
T CSCGEMMotherboard::bestMatchingPad ( const CSCCLCTDigi &  ,
const matches< T > &   
) const
protected

◆ bestMatchingPad() [6/6]

template<class S >
S CSCGEMMotherboard::bestMatchingPad ( const CSCCLCTDigi &  clct,
const matches< S > &  pads 
) const
protected

Definition at line 403 of file CSCGEMMotherboard.h.

403  {
404  S result;
405  // no matching pads for invalid stub
406  if (not clct.isValid())
407  return result;
408 
409  auto part(getCSCPart(clct.getKeyStrip()));
410 
411  // return the pad with the smallest bending angle
412  float averagePadNumberCSC = getPad(clct, part);
413  float minDeltaPad = 999;
414  for (const auto& p : pads) {
415  // protection against corrupted DetIds
416  if (not isGEMDetId(p.first))
417  continue;
418 
419  // best pad is closest to CLCT in number of halfstrips
420  float averagePadNumberGEM = getPad(p.second);
421  if (std::abs(averagePadNumberCSC - averagePadNumberGEM) < minDeltaPad) {
422  minDeltaPad = std::abs(averagePadNumberCSC - averagePadNumberGEM);
423  result = p.second;
424  }
425  }
426  return result;
427 }

References funct::abs(), CSCUpgradeMotherboard::getCSCPart(), CSCCLCTDigi::getKeyStrip(), getPad(), isGEMDetId(), CSCCLCTDigi::isValid(), AlCaHLTBitMon_ParallelJobs::p, and mps_fire::result.

◆ clear()

void CSCGEMMotherboard::clear ( void  )

Definition at line 33 of file CSCGEMMotherboard.cc.

33  {
34  CSCUpgradeMotherboard::clear();
35  pads_.clear();
36  coPads_.clear();
37 }

References CSCUpgradeMotherboard::clear(), coPads_, and pads_.

Referenced by CSCGEMMotherboardME11::run(), and CSCGEMMotherboardME21::run().

◆ constructLCTsGEM() [1/5]

CSCCorrelatedLCTDigi CSCGEMMotherboard::constructLCTsGEM ( const CSCALCTDigi &  alct,
const CSCCLCTDigi &  clct,
const GEMCoPadDigi &  gem,
int  i 
) const
protected

Definition at line 78 of file CSCGEMMotherboard.cc.

81  {
82  return constructLCTsGEM(alct, clct, GEMPadDigi(), gem, trknmb);
83 }

References constructLCTsGEM().

◆ constructLCTsGEM() [2/5]

CSCCorrelatedLCTDigi CSCGEMMotherboard::constructLCTsGEM ( const CSCALCTDigi &  alct,
const CSCCLCTDigi &  clct,
const GEMPadDigi &  gem,
int  i 
) const
protected

Definition at line 85 of file CSCGEMMotherboard.cc.

88  {
89  return constructLCTsGEM(alct, clct, gem, GEMCoPadDigi(), trknmb);
90 }

References constructLCTsGEM().

◆ constructLCTsGEM() [3/5]

CSCCorrelatedLCTDigi CSCGEMMotherboard::constructLCTsGEM ( const CSCALCTDigi &  alct,
const CSCCLCTDigi &  clct,
const GEMPadDigi &  gem1,
const GEMCoPadDigi &  gem2,
int  i 
) const
protected

Definition at line 92 of file CSCGEMMotherboard.cc.

96  {
97  int pattern = 0, quality = 0, bx = 0, keyStrip = 0, keyWG = 0, bend = 0, valid = 0;
98 
99  // make a new LCT
100  CSCCorrelatedLCTDigi thisLCT;
101  if (not alct.isValid() and not clct.isValid()) {
102  LogTrace("CSCGEMCMotherboard") << "Warning!!! either ALCT or CLCT not valid, return invalid LCT \n";
103  return thisLCT;
104  }
105 
106  // Determine the case and assign properties depending on the LCT dataformat (old/new)
107  if (alct.isValid() and clct.isValid() and gem1.isValid() and not gem2.isValid()) {
108  pattern = encodePattern(clct.getPattern());
109  quality = findQualityGEM(alct, clct, 1);
110  bx = alct.getBX();
111  keyStrip = clct.getKeyStrip();
112  keyWG = alct.getKeyWG();
113  bend = clct.getBend();
114  thisLCT.setALCT(getBXShiftedALCT(alct));
115  thisLCT.setCLCT(getBXShiftedCLCT(clct));
116  thisLCT.setGEM1(gem1);
117  thisLCT.setType(CSCCorrelatedLCTDigi::ALCTCLCTGEM);
118  valid = doesWiregroupCrossStrip(keyWG, keyStrip) ? 1 : 0;
119  } else if (alct.isValid() and clct.isValid() and not gem1.isValid() and gem2.isValid()) {
120  pattern = encodePattern(clct.getPattern());
121  quality = findQualityGEM(alct, clct, 2);
122  bx = alct.getBX();
123  keyStrip = clct.getKeyStrip();
124  keyWG = alct.getKeyWG();
125  bend = clct.getBend();
126  thisLCT.setALCT(getBXShiftedALCT(alct));
127  thisLCT.setCLCT(getBXShiftedCLCT(clct));
128  thisLCT.setGEM1(gem2.first());
129  thisLCT.setGEM2(gem2.second());
130  thisLCT.setType(CSCCorrelatedLCTDigi::ALCTCLCT2GEM);
131  valid = doesWiregroupCrossStrip(keyWG, keyStrip) ? 1 : 0;
132  } else if (alct.isValid() and gem2.isValid() and not clct.isValid()) {
133  //in ME11
134  //ME1b: keyWG >15,
135  //ME1a and ME1b overlap: 10<=keyWG<=15
136  //ME1a: keyWG < 10
137  //in overlap region, firstly try a match in ME1b
138 
139  auto p(getCSCPart(-1)); //use -1 as fake halfstrip, it returns ME11 if station==1 && (ring==1 or ring==4)
140  if (p == CSCPart::ME11) {
141  if (alct.getKeyWG() >= 10)
142  p = CSCPart::ME1B;
143  else
144  p = CSCPart::ME1A;
145  }
146 
147  // min pad number is always 0
148  // max pad number is 191 or 383, depending on the station
149  assert(gem2.pad(1) >= 0);
150  assert(gem2.pad(2) >= 0);
151  assert(gem2.pad(1) < maxPads());
152  assert(gem2.pad(2) < maxPads());
153 
154  const auto& mymap1 = getLUT()->get_gem_pad_to_csc_hs(theParity, p);
155  // GEM pad number is counting from 1
156  // keyStrip from mymap: for ME1b 0-127 and for ME1a 0-95
157  // keyStrip for CLCT: for ME1b 0-127 and for ME1a 128-223
158  keyStrip = mymap1.at(gem2.pad(2));
159  if (p == CSCPart::ME1A and keyStrip <= CSCConstants::MAX_HALF_STRIP_ME1B) {
160  keyStrip += CSCConstants::MAX_HALF_STRIP_ME1B + 1;
161  }
162  keyWG = alct.getKeyWG();
163 
164  if ((not doesWiregroupCrossStrip(keyWG, keyStrip)) and p == CSCPart::ME1B and keyWG <= 15) {
165  //try ME1A as strip and WG do not cross
166  p = CSCPart::ME1A;
167  const auto& mymap2 = getLUT()->get_gem_pad_to_csc_hs(theParity, p);
168  keyStrip = mymap2.at(gem2.pad(2)) + CSCConstants::MAX_HALF_STRIP_ME1B + 1;
169  }
170 
171  pattern = promoteALCTGEMpattern_ ? 10 : 0;
172  quality = promoteALCTGEMquality_ ? 15 : 11;
173  bx = alct.getBX();
174  thisLCT.setALCT(getBXShiftedALCT(alct));
175  thisLCT.setGEM1(gem2.first());
176  thisLCT.setGEM2(gem2.second());
177  thisLCT.setType(CSCCorrelatedLCTDigi::ALCT2GEM);
178  valid = true;
179  } else if (clct.isValid() and gem2.isValid() and not alct.isValid()) {
180  // min roll number is always 1
181  // max roll number is 8 or 16, depending on the station
182  assert(gem2.roll() >= GEMDetId::minRollId);
183  assert(gem2.roll() <= maxRolls());
184 
185  const auto& mymap2 = getLUT()->get_gem_roll_to_csc_wg(theParity);
186  pattern = encodePattern(clct.getPattern());
187  quality = promoteCLCTGEMquality_ ? 15 : 11;
188  bx = gem2.bx(1) + CSCConstants::LCT_CENTRAL_BX;
189  keyStrip = clct.getKeyStrip();
190  // choose the corresponding wire-group in the middle of the partition
191  keyWG = mymap2.at(gem2.roll() - 1);
192  bend = clct.getBend();
193  thisLCT.setCLCT(clct);
194  thisLCT.setGEM1(gem2.first());
195  thisLCT.setGEM2(gem2.second());
196  thisLCT.setType(CSCCorrelatedLCTDigi::CLCT2GEM);
197  valid = true;
198  }
199 
200  if (valid == 0)
201  LogTrace("CSCGEMCMotherboard") << "Warning!!! wiregroup and strip pair are not crossing each other"
202  << " detid " << cscId_ << " with wiregroup " << keyWG << "keyStrip " << keyStrip
203  << " \n";
204 
205  // in Run-3 we plan to use the synchronization error bit
206  // to denote the presence of exotic signatures in the chamber
207  unsigned int syncErr = useHighMultiplicityBits_ ? highMultiplicityBits_ : 0;
208 
209  // fill the rest of the properties
210  thisLCT.setTrknmb(trknmb);
211  thisLCT.setValid(valid);
212  thisLCT.setQuality(quality);
213  thisLCT.setWireGroup(keyWG);
214  thisLCT.setStrip(keyStrip);
215  thisLCT.setPattern(pattern);
216  thisLCT.setBend(bend);
217  thisLCT.setBX(bx);
218  thisLCT.setMPCLink(0);
219  thisLCT.setBX0(0);
220  thisLCT.setSyncErr(syncErr);
221  thisLCT.setCSCID(theTrigChamber);
222 
223  // future work: add a section that produces LCTs according
224  // to the new LCT dataformat (not yet defined)
225 
226  // return new LCT
227  return thisLCT;
228 }

References CSCCorrelatedLCTDigi::ALCT2GEM, CSCCorrelatedLCTDigi::ALCTCLCT2GEM, CSCCorrelatedLCTDigi::ALCTCLCTGEM, cms::cuda::assert(), trklet::bend(), l1GtPatternGenerator_cfi::bx, GEMCoPadDigi::bx(), CSCCorrelatedLCTDigi::CLCT2GEM, CSCBaseboard::cscId_, doesWiregroupCrossStrip(), CSCMotherboard::encodePattern(), findQualityGEM(), GEMCoPadDigi::first(), CSCGEMMotherboardLUT::get_gem_pad_to_csc_hs(), CSCGEMMotherboardLUT::get_gem_roll_to_csc_wg(), CSCCLCTDigi::getBend(), CSCALCTDigi::getBX(), CSCMotherboard::getBXShiftedALCT(), CSCMotherboard::getBXShiftedCLCT(), CSCUpgradeMotherboard::getCSCPart(), CSCCLCTDigi::getKeyStrip(), CSCALCTDigi::getKeyWG(), getLUT(), CSCCLCTDigi::getPattern(), CSCMotherboard::highMultiplicityBits_, GEMPadDigi::isValid(), GEMCoPadDigi::isValid(), CSCALCTDigi::isValid(), CSCCLCTDigi::isValid(), CSCConstants::LCT_CENTRAL_BX, LogTrace, CSCConstants::MAX_HALF_STRIP_ME1B, maxPads(), maxRolls(), ME11, ME1A, ME1B, GEMDetId::minRollId, AlCaHLTBitMon_ParallelJobs::p, GEMCoPadDigi::pad(), topSingleLeptonDQM_PU_cfi::pattern, promoteALCTGEMpattern_, promoteALCTGEMquality_, promoteCLCTGEMquality_, qcdUeDQM_cfi::quality, GEMCoPadDigi::roll(), GEMCoPadDigi::second(), CSCCorrelatedLCTDigi::setALCT(), CSCCorrelatedLCTDigi::setBend(), CSCCorrelatedLCTDigi::setBX(), CSCCorrelatedLCTDigi::setBX0(), CSCCorrelatedLCTDigi::setCLCT(), CSCCorrelatedLCTDigi::setCSCID(), CSCCorrelatedLCTDigi::setGEM1(), CSCCorrelatedLCTDigi::setGEM2(), CSCCorrelatedLCTDigi::setMPCLink(), CSCCorrelatedLCTDigi::setPattern(), CSCCorrelatedLCTDigi::setQuality(), CSCCorrelatedLCTDigi::setStrip(), CSCCorrelatedLCTDigi::setSyncErr(), CSCCorrelatedLCTDigi::setTrknmb(), CSCCorrelatedLCTDigi::setType(), CSCCorrelatedLCTDigi::setValid(), CSCCorrelatedLCTDigi::setWireGroup(), CSCUpgradeMotherboard::theParity, CSCBaseboard::theTrigChamber, CSCMotherboard::useHighMultiplicityBits_, and validateGeometry_cfg::valid.

◆ constructLCTsGEM() [4/5]

CSCCorrelatedLCTDigi CSCGEMMotherboard::constructLCTsGEM ( const CSCALCTDigi &  alct,
const GEMCoPadDigi &  gem,
int  i 
) const
protected

Definition at line 66 of file CSCGEMMotherboard.cc.

68  {
69  return constructLCTsGEM(alct, CSCCLCTDigi(), GEMPadDigi(), gem, trknmb);
70 }

Referenced by constructLCTsGEM(), CSCGEMMotherboardME21::correlateLCTsGEM(), CSCGEMMotherboardME11::correlateLCTsGEM(), and correlateLCTsGEM().

◆ constructLCTsGEM() [5/5]

CSCCorrelatedLCTDigi CSCGEMMotherboard::constructLCTsGEM ( const CSCCLCTDigi &  clct,
const GEMCoPadDigi &  gem,
int  i 
) const
protected

Definition at line 72 of file CSCGEMMotherboard.cc.

74  {
75  return constructLCTsGEM(CSCALCTDigi(), clct, GEMPadDigi(), gem, trknmb);
76 }

References constructLCTsGEM().

◆ correlateLCTsGEM() [1/2]

template<class T >
void CSCGEMMotherboard::correlateLCTsGEM ( const T &  best,
const T &  second,
const GEMCoPadDigi &  bestCoPad,
const GEMCoPadDigi &  secondCoPad,
CSCCorrelatedLCTDigi &  lct1,
CSCCorrelatedLCTDigi &  lct2 
) const
protected

Definition at line 491 of file CSCGEMMotherboard.h.

496  {
497  // construct the first LCT from ALCT(CLCT) and a GEM Copad
498  if ((getLctTrigEnable<T>() and bestLCT.isValid()) or (match_trig_enable and bestLCT.isValid())) {
499  lct1 = constructLCTsGEM(bestLCT, bestCoPad, 1);
500  }
501 
502  // construct the second LCT from ALCT(CLCT) and a GEM Copad
503  if ((getLctTrigEnable<T>() and secondLCT.isValid()) or
504  (match_trig_enable and secondLCT.isValid() and secondLCT != bestLCT)) {
505  lct2 = constructLCTsGEM(secondLCT, secondCoPad, 2);
506  }
507 }

References constructLCTsGEM(), CSCCorrelatedLCTDigi::isValid(), CSCMotherboard::match_trig_enable, or, and CSCMotherboard::secondLCT.

◆ correlateLCTsGEM() [2/2]

template<class T >
void CSCGEMMotherboard::correlateLCTsGEM ( const T &  best,
const T &  second,
const GEMCoPadDigiIds &  coPads,
CSCCorrelatedLCTDigi &  lct1,
CSCCorrelatedLCTDigi &  lct2 
) const
protected

Definition at line 464 of file CSCGEMMotherboard.h.

468  {
469  T bestLCT = bLCT;
470  T secondLCT = sLCT;
471 
472  // Check which LCTs are valid
473  bool bestValid = bestLCT.isValid();
474  bool secondValid = secondLCT.isValid();
475 
476  // At this point, set both LCTs valid if they are invalid
477  // Duplicate LCTs are taken into account later
478  if (bestValid and !secondValid)
479  secondLCT = bestLCT;
480  if (!bestValid and secondValid)
481  bestLCT = secondLCT;
482 
483  // get best matching copad1
484  const GEMCoPadDigi& bestCoPad = bestMatchingPad<GEMCoPadDigi>(bestLCT, coPads);
485  const GEMCoPadDigi& secondCoPad = bestMatchingPad<GEMCoPadDigi>(secondLCT, coPads);
486 
487  correlateLCTsGEM(bestLCT, secondLCT, bestCoPad, secondCoPad, lct1, lct2);
488 }

References CSCCorrelatedLCTDigi::isValid(), and CSCMotherboard::secondLCT.

Referenced by CSCGEMMotherboardME11::run(), and CSCGEMMotherboardME21::run().

◆ doesWiregroupCrossStrip()

virtual bool CSCGEMMotherboard::doesWiregroupCrossStrip ( int  key_wg,
int  key_strip 
) const
inlineprotectedvirtual

Reimplemented in CSCGEMMotherboardME21, and CSCGEMMotherboardME11.

Definition at line 71 of file CSCGEMMotherboard.h.

71 { return true; }

Referenced by constructLCTsGEM().

◆ findQualityGEM()

unsigned int CSCGEMMotherboard::findQualityGEM ( const CSCALCTDigi &  aLCT,
const CSCCLCTDigi &  cLCT,
int  gemlayer 
) const
protected

Definition at line 327 of file CSCGEMMotherboard.cc.

327  {
328  // Either ALCT or CLCT is invalid
329  if (!(aLCT.isValid()) || !(cLCT.isValid())) {
330  // No CLCT
331  if (aLCT.isValid() && !(cLCT.isValid()))
332  return LCT_Quality::NO_CLCT;
333 
334  // No ALCT
335  else if (!(aLCT.isValid()) && cLCT.isValid())
336  return LCT_Quality::NO_ALCT;
337 
338  // No ALCT and no CLCT
339  else
340  return LCT_Quality::INVALID;
341  }
342  // Both ALCT and CLCT are valid
343  else {
344  const int pattern(cLCT.getPattern());
345 
346  // Layer-trigger in CLCT
347  if (pattern == 1)
348  return LCT_Quality::CLCT_LAYER_TRIGGER;
349 
350  // Multi-layer pattern in CLCT
351  else {
352  // ALCT quality is the number of layers hit minus 3.
353  bool a4 = false;
354 
355  // Case of ME11 with GEMs: require 4 layers for ALCT
356  if (theStation == 1)
357  a4 = aLCT.getQuality() >= 1;
358 
359  // Case of ME21 with GEMs: require 4 layers for ALCT+GEM
360  if (theStation == 2)
361  a4 = aLCT.getQuality() + gemlayers >= 1;
362 
363  // CLCT quality is the number of layers hit.
364  const bool c4((cLCT.getQuality() >= 4) or (cLCT.getQuality() >= 3 and gemlayers >= 1));
365 
366  // quality = 4; "reserved for low-quality muons in future"
367 
368  // marginal anode and cathode
369  if (!a4 && !c4)
370  return LCT_Quality::MARGINAL_ANODE_CATHODE;
371 
372  // HQ anode, but marginal cathode
373  else if (a4 && !c4)
374  return LCT_Quality::HQ_ANODE_MARGINAL_CATHODE;
375 
376  // HQ cathode, but marginal anode
377  else if (!a4 && c4)
378  return LCT_Quality::HQ_CATHODE_MARGINAL_ANODE;
379 
380  // HQ muon, but accelerator ALCT
381  else if (a4 && c4) {
382  if (aLCT.getAccelerator())
383  return LCT_Quality::HQ_ACCEL_ALCT;
384 
385  else {
386  // quality = 9; "reserved for HQ muons with future patterns
387  // quality = 10; "reserved for HQ muons with future patterns
388 
389  // High quality muons are determined by their CLCT pattern
390  if (pattern == 2 || pattern == 3)
391  return LCT_Quality::HQ_PATTERN_2_3;
392 
393  else if (pattern == 4 || pattern == 5)
394  return LCT_Quality::HQ_PATTERN_4_5;
395 
396  else if (pattern == 6 || pattern == 7)
397  return LCT_Quality::HQ_PATTERN_6_7;
398 
399  else if (pattern == 8 || pattern == 9)
400  return LCT_Quality::HQ_PATTERN_8_9;
401 
402  else if (pattern == 10)
403  return LCT_Quality::HQ_PATTERN_10;
404 
405  else {
406  if (infoV >= 0)
407  edm::LogWarning("L1CSCTPEmulatorWrongValues")
408  << "+++ findQuality: Unexpected CLCT pattern id = " << pattern << "+++\n";
409  return LCT_Quality::INVALID;
410  }
411  }
412  }
413  }
414  }
415  return LCT_Quality::INVALID;
416 }

References CSCALCTDigi::getAccelerator(), CSCCLCTDigi::getPattern(), CSCALCTDigi::getQuality(), CSCCLCTDigi::getQuality(), CSCBaseboard::infoV, cond::time::INVALID, CSCALCTDigi::isValid(), CSCCLCTDigi::isValid(), or, topSingleLeptonDQM_PU_cfi::pattern, and CSCBaseboard::theStation.

Referenced by constructLCTsGEM().

◆ getBX() [1/2]

int CSCGEMMotherboard::getBX ( const GEMCoPadDigi &  p) const
protected

Definition at line 249 of file CSCGEMMotherboard.cc.

249 { return p.bx(1); }

References AlCaHLTBitMon_ParallelJobs::p.

◆ getBX() [2/2]

int CSCGEMMotherboard::getBX ( const GEMPadDigi &  p) const
protected

Definition at line 247 of file CSCGEMMotherboard.cc.

247 { return p.bx(); }

References AlCaHLTBitMon_ParallelJobs::p.

Referenced by matchingPads().

◆ getLctTrigEnable() [1/3]

template<class T >
int CSCGEMMotherboard::getLctTrigEnable ( ) const
private

◆ getLctTrigEnable() [2/3]

template<>
int CSCGEMMotherboard::getLctTrigEnable ( ) const
private

Definition at line 439 of file CSCGEMMotherboard.cc.

439  {
440  return alct_trig_enable;
441 }

References CSCMotherboard::alct_trig_enable.

◆ getLctTrigEnable() [3/3]

template<>
int CSCGEMMotherboard::getLctTrigEnable ( ) const
private

Definition at line 444 of file CSCGEMMotherboard.cc.

444  {
445  return clct_trig_enable;
446 }

References CSCMotherboard::clct_trig_enable.

◆ getLUT()

virtual const CSCGEMMotherboardLUT* CSCGEMMotherboard::getLUT ( ) const
protectedpure virtual

Implemented in CSCGEMMotherboardME11, and CSCGEMMotherboardME21.

Referenced by constructLCTsGEM(), getPad(), getRolls(), isPadInOverlap(), and matchingPads().

◆ getMaxDeltaBX() [1/3]

template<class T >
int CSCGEMMotherboard::getMaxDeltaBX ( ) const
private

◆ getMaxDeltaBX() [2/3]

template<>
int CSCGEMMotherboard::getMaxDeltaBX ( ) const
private

Definition at line 429 of file CSCGEMMotherboard.cc.

429  {
430  return maxDeltaBXPad_;
431 }

References maxDeltaBXPad_.

◆ getMaxDeltaBX() [3/3]

template<>
int CSCGEMMotherboard::getMaxDeltaBX ( ) const
private

Definition at line 434 of file CSCGEMMotherboard.cc.

434  {
435  return maxDeltaBXCoPad_;
436 }

References maxDeltaBXCoPad_.

◆ getPad() [1/3]

float CSCGEMMotherboard::getPad ( const CSCCLCTDigi &  clct,
enum CSCPart  par 
) const
protected

Definition at line 267 of file CSCGEMMotherboard.cc.

267  {
268  const auto& mymap = (getLUT()->get_csc_hs_to_gem_pad(theParity, part));
269  int keyStrip = clct.getKeyStrip();
270  //ME1A part, convert halfstrip from 128-223 to 0-95
271  if (part == CSCPart::ME1A and keyStrip > CSCConstants::MAX_HALF_STRIP_ME1B)
272  keyStrip = keyStrip - CSCConstants::MAX_HALF_STRIP_ME1B - 1;
273  return 0.5 * (mymap.at(keyStrip).first + mymap.at(keyStrip).second);
274 }

References CSCGEMMotherboardLUT::get_csc_hs_to_gem_pad(), CSCCLCTDigi::getKeyStrip(), getLUT(), CSCConstants::MAX_HALF_STRIP_ME1B, ME1A, and CSCUpgradeMotherboard::theParity.

◆ getPad() [2/3]

float CSCGEMMotherboard::getPad ( const GEMCoPadDigi &  p) const
protected

Definition at line 262 of file CSCGEMMotherboard.cc.

262  {
263  // average pad number for a GEMCoPad
264  return 0.5 * (p.pad(1) + p.pad(2));
265 }

References AlCaHLTBitMon_ParallelJobs::p.

◆ getPad() [3/3]

float CSCGEMMotherboard::getPad ( const GEMPadDigi &  p) const
protected

Definition at line 260 of file CSCGEMMotherboard.cc.

260 { return p.pad(); }

References AlCaHLTBitMon_ParallelJobs::p.

Referenced by bestMatchingPad(), and matchingPads().

◆ getPads() [1/3]

template<class T >
const matchesBX<T>& CSCGEMMotherboard::getPads ( ) const
private

◆ getPads() [2/3]

template<>
const matchesBX<GEMPadDigi>& CSCGEMMotherboard::getPads ( ) const
private

Definition at line 419 of file CSCGEMMotherboard.cc.

419  {
420  return pads_;
421 }

References pads_.

◆ getPads() [3/3]

template<>
const matchesBX<GEMCoPadDigi>& CSCGEMMotherboard::getPads ( ) const
private

Definition at line 424 of file CSCGEMMotherboard.cc.

424  {
425  return coPads_;
426 }

References coPads_.

◆ getRoll() [1/2]

int CSCGEMMotherboard::getRoll ( const GEMCoPadDigiId &  p) const
protected

Definition at line 253 of file CSCGEMMotherboard.cc.

253 { return p.second.roll(); }

References AlCaHLTBitMon_ParallelJobs::p.

◆ getRoll() [2/2]

int CSCGEMMotherboard::getRoll ( const GEMPadDigiId &  p) const
protected

Definition at line 251 of file CSCGEMMotherboard.cc.

251 { return GEMDetId(p.first).roll(); }

References AlCaHLTBitMon_ParallelJobs::p, and GEMDetId::roll().

Referenced by bestMatchingPad(), and matchingPads().

◆ getRolls()

std::pair< int, int > CSCGEMMotherboard::getRolls ( const CSCALCTDigi &  alct) const
protected

Definition at line 255 of file CSCGEMMotherboard.cc.

255  {
256  const auto& mymap(getLUT()->get_csc_wg_to_gem_roll(theParity));
257  return std::make_pair(mymap.at(alct.getKeyWG()).first, mymap.at(alct.getKeyWG()).second);
258 }

References dqmdumpme::first, CSCALCTDigi::getKeyWG(), getLUT(), edm::second(), and CSCUpgradeMotherboard::theParity.

Referenced by bestMatchingPad().

◆ isGEMDetId()

bool CSCGEMMotherboard::isGEMDetId ( unsigned int  p) const
protected

Definition at line 243 of file CSCGEMMotherboard.cc.

243  {
244  return (DetId(p).subdetId() == MuonSubdetId::GEM and DetId(p).det() == DetId::Muon);
245 }

References MuonSubdetId::GEM, DetId::Muon, and AlCaHLTBitMon_ParallelJobs::p.

Referenced by bestMatchingPad().

◆ isPadInOverlap()

bool CSCGEMMotherboard::isPadInOverlap ( int  roll) const
protected

Definition at line 230 of file CSCGEMMotherboard.cc.

230  {
231  // this only works for ME1A!
232  const auto& mymap = (getLUT()->get_csc_wg_to_gem_roll(theParity));
233  for (unsigned i = 0; i < mymap.size(); i++) {
234  // overlap region are WGs 10-15
235  if ((i < 10) or (i > 15))
236  continue;
237  if ((mymap.at(i).first <= roll) and (roll <= mymap.at(i).second))
238  return true;
239  }
240  return false;
241 }

References CSCGEMMotherboardLUT::get_csc_wg_to_gem_roll(), getLUT(), mps_fire::i, or, and CSCUpgradeMotherboard::theParity.

Referenced by printGEMTriggerCoPads(), and printGEMTriggerPads().

◆ matchingPads() [1/5]

template<class T >
void CSCGEMMotherboard::matchingPads ( const CSCALCTDigi &  alct,
matches< T > &  result 
) const
protected

Definition at line 245 of file CSCGEMMotherboard.h.

245  {
246  result.clear();
247  // Invalid ALCTs have no matching pads
248  if (not alct.isValid())
249  return;
250 
251  // Get the corresponding roll numbers for a given ALCT
252  std::pair<int, int> alctRoll = (getLUT()->get_csc_wg_to_gem_roll(theParity))[alct.getKeyWG()];
253 
254  // Get the pads in the ALCT bx
255  const matchesBX<T>& lut = getPads<T>();
256 
257  // If no pads in that bx...
258  if (lut.count(alct.getBX()) == 0)
259  return;
260 
261  for (const auto& p : lut.at(alct.getBX())) {
262  auto padRoll(getRoll(p));
263 
264  int delta;
265  if (GEMDetId(p.first).station() == 2)
266  delta = 1;
267 
268  // pad bx needs to match to ALCT bx
269  int pad_bx = getBX(p.second) + CSCConstants::LCT_CENTRAL_BX;
270 
271  if (std::abs(alct.getBX() - pad_bx) > getMaxDeltaBX<T>())
272  continue;
273 
274  // gem roll number if invalid
275  if (alctRoll.first == CSCGEMMotherboard::DEFAULT_MATCHING_VALUE and
276  alctRoll.second == CSCGEMMotherboard::DEFAULT_MATCHING_VALUE)
277  continue;
278  // ALCTs at the top of the chamber
279  else if (alctRoll.first == CSCGEMMotherboard::DEFAULT_MATCHING_VALUE and padRoll > alctRoll.second)
280  continue;
281  // ALCTs at the bottom of the chamber
282  else if (alctRoll.second == CSCGEMMotherboard::DEFAULT_MATCHING_VALUE and padRoll < alctRoll.first)
283  continue;
284  // ignore pads that are too far away in roll number
285  else if ((alctRoll.first != CSCGEMMotherboard::DEFAULT_MATCHING_VALUE and
286  alctRoll.second != CSCGEMMotherboard::DEFAULT_MATCHING_VALUE) and
287  (alctRoll.first - delta > padRoll or padRoll > alctRoll.second))
288  continue;
289  result.push_back(p);
290  }
291 }

References funct::abs(), DEFAULT_MATCHING_VALUE, dumpMFGeometry_cfg::delta, CSCGEMMotherboardLUT::get_csc_wg_to_gem_roll(), CSCALCTDigi::getBX(), getBX(), CSCALCTDigi::getKeyWG(), getLUT(), getRoll(), CSCALCTDigi::isValid(), CSCConstants::LCT_CENTRAL_BX, or, AlCaHLTBitMon_ParallelJobs::p, mps_fire::result, GEMDetId::station(), and CSCUpgradeMotherboard::theParity.

◆ matchingPads() [2/5]

template<class T >
void CSCGEMMotherboard::matchingPads ( const CSCCLCTDigi &  alct,
matches< T > &  result 
) const
protected

Definition at line 294 of file CSCGEMMotherboard.h.

294  {
295  result.clear();
296  // Invalid ALCTs have no matching pads
297  if (not clct.isValid())
298  return;
299 
300  auto part(getCSCPart(clct.getKeyStrip()));
301  // Get the corresponding pad numbers for a given CLCT
302  const auto& mymap = (getLUT()->get_csc_hs_to_gem_pad(theParity, part));
303  int keyStrip = clct.getKeyStrip();
304  //ME1A part, convert halfstrip from 128-223 to 0-95
305  if (part == CSCPart::ME1A and keyStrip > CSCConstants::MAX_HALF_STRIP_ME1B)
306  keyStrip = keyStrip - CSCConstants::MAX_HALF_STRIP_ME1B - 1;
307  const int lowPad(mymap[keyStrip].first);
308  const int highPad(mymap[keyStrip].second);
309 
310  // Get the pads in the CLCT bx
311  const matchesBX<T>& lut = getPads<T>();
312 
313  // If no pads in that bx...
314  if (lut.count(clct.getBX()) == 0)
315  return;
316 
317  for (const auto& p : lut.at(clct.getBX())) {
318  // pad bx needs to match to CLCT bx
319  int pad_bx = getBX(p.second) + CSCConstants::LCT_CENTRAL_BX;
320  if (std::abs(clct.getBX() - pad_bx) > getMaxDeltaBX<T>())
321  continue;
322 
323  // pad number must match
324  int padNumber(getPad(p.second));
325  if (std::abs(lowPad - padNumber) <= maxDeltaPadL1_ or std::abs(padNumber - highPad) <= maxDeltaPadL1_) {
326  result.push_back(p);
327  }
328  }
329 }

References funct::abs(), dqmdumpme::first, CSCGEMMotherboardLUT::get_csc_hs_to_gem_pad(), getBX(), CSCCLCTDigi::getBX(), CSCUpgradeMotherboard::getCSCPart(), CSCCLCTDigi::getKeyStrip(), getLUT(), getPad(), CSCCLCTDigi::isValid(), CSCConstants::LCT_CENTRAL_BX, CSCConstants::MAX_HALF_STRIP_ME1B, maxDeltaPadL1_, ME1A, or, AlCaHLTBitMon_ParallelJobs::p, mps_fire::result, edm::second(), and CSCUpgradeMotherboard::theParity.

◆ matchingPads() [3/5]

template<class T >
void CSCGEMMotherboard::matchingPads ( const CSCCLCTDigi &  clct1,
const CSCALCTDigi &  alct1,
matches< T > &  result 
) const
protected

Definition at line 348 of file CSCGEMMotherboard.h.

348  {
349  matches<T> padsClct, padsAlct;
350 
351  // pads matching to the CLCT
352  matchingPads<T>(clct1, padsClct);
353 
354  // pads matching to the ALCT
355  matchingPads<T>(alct1, padsAlct);
356 
357  // collect all *common* pads
358  intersection(padsClct, padsAlct, result);
359 }

References CSCUpgradeMotherboard::intersection(), and mps_fire::result.

◆ matchingPads() [4/5]

template<class T >
void CSCGEMMotherboard::matchingPads ( const CSCCLCTDigi &  clct1,
const CSCCLCTDigi &  clct2,
const CSCALCTDigi &  alct1,
const CSCALCTDigi &  alct2,
matches< T > &  result 
) const
protected

Definition at line 362 of file CSCGEMMotherboard.h.

366  {
367  matches<T> padsClct, padsAlct;
368 
369  // pads matching to CLCTs
370  matchingPads<CSCCLCTDigi, T>(clct1, clct2, padsClct);
371 
372  // pads matching to ALCTs
373  matchingPads<CSCALCTDigi, T>(alct1, alct2, padsAlct);
374 
375  // collect *all* matching pads
376  result.reserve(padsClct.size() + padsAlct.size());
377  result.insert(std::end(result), std::begin(padsClct), std::end(padsClct));
378  result.insert(std::end(result), std::begin(padsAlct), std::end(padsAlct));
379 }

References begin, end, and mps_fire::result.

◆ matchingPads() [5/5]

template<class S , class T >
void CSCGEMMotherboard::matchingPads ( const S &  d1,
const S &  d2,
matches< T > &  result 
) const
protected

Definition at line 332 of file CSCGEMMotherboard.h.

332  {
333  matches<T> p1, p2;
334 
335  // pads matching to the CLCT/ALCT
336  matchingPads<T>(d1, p1);
337 
338  // pads matching to the CLCT/ALCT
339  matchingPads<T>(d2, p2);
340 
341  // collect *all* matching pads
342  result.reserve(p1.size() + p2.size());
343  result.insert(std::end(result), std::begin(p1), std::end(p1));
344  result.insert(std::end(result), std::begin(p2), std::end(p2));
345 }

References begin, d1, end, p1, p2, and mps_fire::result.

◆ maxPads()

int CSCGEMMotherboard::maxPads ( ) const
protected

Definition at line 281 of file CSCGEMMotherboard.cc.

281 { return gem_g->superChamber(gemId)->chamber(1)->etaPartition(1)->npads(); }

References GEMSuperChamber::chamber(), GEMChamber::etaPartition(), gem_g, gemId, GEMEtaPartition::npads(), and GEMGeometry::superChamber().

Referenced by constructLCTsGEM().

◆ maxRolls()

int CSCGEMMotherboard::maxRolls ( ) const
protected

Definition at line 283 of file CSCGEMMotherboard.cc.

283 { return gem_g->superChamber(gemId)->chamber(1)->nEtaPartitions(); }

References GEMSuperChamber::chamber(), gem_g, gemId, GEMChamber::nEtaPartitions(), and GEMGeometry::superChamber().

Referenced by constructLCTsGEM().

◆ printGEMTriggerCoPads()

void CSCGEMMotherboard::printGEMTriggerCoPads ( int  bx_start,
int  bx_stop,
enum CSCPart  part 
)
protected

Definition at line 306 of file CSCGEMMotherboard.cc.

306  {
307  LogTrace("CSCGEMMotherboard") << "------------------------------------------------------------------------"
308  << std::endl;
309  LogTrace("CSCGEMMotherboard") << "* GEM trigger coincidence pads: " << std::endl;
310 
311  for (int bx = bx_start; bx <= bx_stop; bx++) {
312  const auto& in_pads = coPads_[bx];
313  LogTrace("CSCGEMMotherboard") << "N(copads) BX " << bx << " : " << in_pads.size() << std::endl;
314 
315  for (const auto& pad : in_pads) {
316  LogTrace("CSCGEMMotherboard") << "\tdetId " << GEMDetId(pad.first) << ", pad = " << pad.second;
317  const auto& roll_id(GEMDetId(pad.first));
318 
319  if (part == CSCPart::ME11 and isPadInOverlap(GEMDetId(roll_id).roll()))
320  LogTrace("CSCGEMMotherboard") << " (in overlap)" << std::endl;
321  else
322  LogTrace("CSCGEMMotherboard") << std::endl;
323  }
324  }
325 }

References l1GtPatternGenerator_cfi::bx, coPads_, isPadInOverlap(), LogTrace, and ME11.

Referenced by CSCGEMMotherboardME11::run(), and CSCGEMMotherboardME21::run().

◆ printGEMTriggerPads()

void CSCGEMMotherboard::printGEMTriggerPads ( int  bx_start,
int  bx_stop,
enum CSCPart  part 
)
protected

Definition at line 285 of file CSCGEMMotherboard.cc.

285  {
286  LogTrace("CSCGEMMotherboard") << "------------------------------------------------------------------------"
287  << std::endl;
288  LogTrace("CSCGEMMotherboard") << "* GEM trigger pads: " << std::endl;
289 
290  for (int bx = bx_start; bx <= bx_stop; bx++) {
291  const auto& in_pads = pads_[bx];
292  LogTrace("CSCGEMMotherboard") << "N(pads) BX " << bx << " : " << in_pads.size() << std::endl;
293 
294  for (const auto& pad : in_pads) {
295  LogTrace("CSCGEMMotherboard") << "\tdetId " << GEMDetId(pad.first) << ", pad = " << pad.second;
296  const auto& roll_id(GEMDetId(pad.first));
297 
298  if (part == CSCPart::ME11 and isPadInOverlap(GEMDetId(roll_id).roll()))
299  LogTrace("CSCGEMMotherboard") << " (in overlap)" << std::endl;
300  else
301  LogTrace("CSCGEMMotherboard") << std::endl;
302  }
303  }
304 }

References l1GtPatternGenerator_cfi::bx, isPadInOverlap(), LogTrace, ME11, and pads_.

Referenced by CSCGEMMotherboardME11::run(), and CSCGEMMotherboardME21::run().

◆ readoutLCTs()

std::vector< CSCCorrelatedLCTDigi > CSCUpgradeMotherboard::readoutLCTs
override

Definition at line 241 of file CSCUpgradeMotherboard.cc.

241  {
242  std::vector<CSCCorrelatedLCTDigi> result;
243  allLCTs.getMatched(result);
244  if (tmb_cross_bx_algo == 2)
245  CSCUpgradeMotherboard::sortLCTs(result, CSCUpgradeMotherboard::sortLCTsByQuality);
246  return result;
247 }

◆ retrieveGEMCoPads()

void CSCGEMMotherboard::retrieveGEMCoPads ( )
protected

Definition at line 57 of file CSCGEMMotherboard.cc.

57  {
58  coPads_.clear();
59  for (const auto& copad : gemCoPadV) {
60  GEMDetId detId(theRegion, 1, theStation, 0, theChamber, 0);
61  // only consider matches with same BX
62  coPads_[CSCConstants::LCT_CENTRAL_BX + copad.bx(1)].emplace_back(detId.rawId(), copad);
63  }
64 }

References coPads_, gemCoPadV, CSCConstants::LCT_CENTRAL_BX, DetId::rawId(), CSCBaseboard::theChamber, CSCBaseboard::theRegion, and CSCBaseboard::theStation.

Referenced by CSCGEMMotherboardME11::run(), and CSCGEMMotherboardME21::run().

◆ retrieveGEMPads()

void CSCGEMMotherboard::retrieveGEMPads ( const GEMPadDigiCollection *  pads,
unsigned  id 
)
protected

Definition at line 39 of file CSCGEMMotherboard.cc.

39  {
40  pads_.clear();
41  const auto& superChamber(gem_g->superChamber(id));
42  for (const auto& ch : superChamber->chambers()) {
43  for (const auto& roll : ch->etaPartitions()) {
44  GEMDetId roll_id(roll->id());
45  auto pads_in_det = gemPads->get(roll_id);
46  for (auto pad = pads_in_det.first; pad != pads_in_det.second; ++pad) {
47  const int bx_shifted(CSCConstants::LCT_CENTRAL_BX + pad->bx());
48  // consider matches with BX difference +1/0/-1
49  for (int bx = bx_shifted - maxDeltaBXPad_; bx <= bx_shifted + maxDeltaBXPad_; ++bx) {
50  pads_[bx].emplace_back(roll_id.rawId(), *pad);
51  }
52  }
53  }
54  }
55 }

References l1GtPatternGenerator_cfi::bx, gem_g, CSCConstants::LCT_CENTRAL_BX, maxDeltaBXPad_, pads_, and GEMGeometry::superChamber().

Referenced by CSCGEMMotherboardME11::run(), and CSCGEMMotherboardME21::run().

◆ run() [1/3]

void CSCUpgradeMotherboard::run
override

Definition at line 49 of file CSCUpgradeMotherboard.cc.

49  {
50  clear();
51 
52  if (!(alctProc and clctProc)) {
53  if (infoV >= 0)
54  edm::LogError("CSCUpgradeMotherboard|SetupError")
55  << "+++ run() called for non-existing ALCT/CLCT processor! +++ \n";
56  return;
57  }
58 
59  alctProc->setCSCGeometry(cscGeometry_);
60  clctProc->setCSCGeometry(cscGeometry_);
61 
62  alctV = alctProc->run(wiredc); // run anodeLCT
63  clctV = clctProc->run(compdc); // run cathodeLCT
64 
65  // if there are no ALCTs and no CLCTs, it does not make sense to run this TMB
66  if (alctV.empty() and clctV.empty())
67  return;
68 
69  // encode high multiplicity bits
70  unsigned alctBits = alctProc->getHighMultiplictyBits();
71  encodeHighMultiplicityBits(alctBits);
72 
73  int used_clct_mask[20];
74  for (int c = 0; c < 20; ++c)
75  used_clct_mask[c] = 0;
76 
77  // ALCT centric matching
78  for (int bx_alct = 0; bx_alct < CSCConstants::MAX_ALCT_TBINS; bx_alct++) {
79  if (alctProc->getBestALCT(bx_alct).isValid()) {
80  const int bx_clct_start(bx_alct - match_trig_window_size / 2 - alctClctOffset_);
81  const int bx_clct_stop(bx_alct + match_trig_window_size / 2 - alctClctOffset_);
82 
83  if (debug_matching) {
84  LogTrace("CSCUpgradeMotherboard")
85  << "========================================================================" << std::endl;
86  LogTrace("CSCUpgradeMotherboard") << "ALCT-CLCT matching in ME34/1 chamber: " << cscId_ << std::endl;
87  LogTrace("CSCUpgradeMotherboard")
88  << "------------------------------------------------------------------------" << std::endl;
89  LogTrace("CSCUpgradeMotherboard") << "+++ Best ALCT Details: ";
90  alctProc->getBestALCT(bx_alct).print();
91  LogTrace("CSCUpgradeMotherboard") << "+++ Second ALCT Details: ";
92  alctProc->getSecondALCT(bx_alct).print();
93 
94  LogTrace("CSCUpgradeMotherboard")
95  << "------------------------------------------------------------------------" << std::endl;
96  LogTrace("CSCUpgradeMotherboard") << "Attempt ALCT-CLCT matching in ME34/13 in bx range: [" << bx_clct_start
97  << "," << bx_clct_stop << "]" << std::endl;
98  }
99 
100  // ALCT-to-CLCT
101  for (int bx_clct = bx_clct_start; bx_clct <= bx_clct_stop; bx_clct++) {
102  if (bx_clct < 0 or bx_clct >= CSCConstants::MAX_CLCT_TBINS)
103  continue;
104  if (drop_used_clcts and used_clct_mask[bx_clct])
105  continue;
106  if (clctProc->getBestCLCT(bx_clct).isValid()) {
107  if (debug_matching)
108  LogTrace("CSCUpgradeMotherboard") << "++Valid ME21 CLCT: " << clctProc->getBestCLCT(bx_clct) << std::endl;
109 
110  int mbx = bx_clct - bx_clct_start;
111  CSCUpgradeMotherboard::correlateLCTs(alctProc->getBestALCT(bx_alct),
112  alctProc->getSecondALCT(bx_alct),
113  clctProc->getBestCLCT(bx_clct),
114  clctProc->getSecondCLCT(bx_clct),
115  allLCTs(bx_alct, mbx, 0),
116  allLCTs(bx_alct, mbx, 1));
117  if (infoV > 1)
118  LogTrace("CSCUpgradeMotherboard")
119  << "Successful ALCT-CLCT match in ME21: bx_alct = " << bx_alct << "; match window: [" << bx_clct_start
120  << "; " << bx_clct_stop << "]; bx_clct = " << bx_clct << std::endl;
121  LogTrace("CSCUpgradeMotherboard") << "+++ Best CLCT Details: ";
122  clctProc->getBestCLCT(bx_clct).print();
123  LogTrace("CSCUpgradeMotherboard") << "+++ Second CLCT Details: ";
124  clctProc->getSecondCLCT(bx_clct).print();
125  if (allLCTs(bx_alct, mbx, 0).isValid()) {
126  used_clct_mask[bx_clct] += 1;
127  if (match_earliest_clct_only)
128  break;
129  }
130  }
131  }
132  }
133  }
134 
135  // reduction of nLCTs per each BX
136  for (int bx = 0; bx < CSCConstants::MAX_LCT_TBINS; bx++) {
137  // counting
138  unsigned int n = 0;
139  for (unsigned int mbx = 0; mbx < match_trig_window_size; mbx++) {
140  for (int i = 0; i < CSCConstants::MAX_LCTS_PER_CSC; i++) {
141  if (allLCTs(bx, mbx, i).isValid()) {
142  ++n;
143  if (infoV > 0) {
144  LogDebug("CSCUpgradeMotherboard")
145  << "LCT" << i + 1 << " " << bx << "/" << bx + mbx - match_trig_window_size / 2 << ": "
146  << allLCTs(bx, mbx, i) << std::endl;
147  }
148  }
149  }
150  }
151 
152  // some simple cross-bx sorting algorithms
153  if (tmb_cross_bx_algo == 1 and (n > 2)) {
154  n = 0;
155  for (unsigned int mbx = 0; mbx < match_trig_window_size; mbx++) {
156  for (int i = 0; i < CSCConstants::MAX_LCTS_PER_CSC; i++) {
157  if (allLCTs(bx, pref[mbx], i).isValid()) {
158  n++;
159  if (n > 2)
160  allLCTs(bx, pref[mbx], i).clear();
161  }
162  }
163  }
164 
165  n = 0;
166  for (unsigned int mbx = 0; mbx < match_trig_window_size; mbx++) {
167  for (int i = 0; i < CSCConstants::MAX_LCTS_PER_CSC; i++) {
168  if (allLCTs(bx, mbx, i).isValid()) {
169  n++;
170  if (infoV > 0) {
171  LogDebug("CSCUpgradeMotherboard")
172  << "LCT" << i + 1 << " " << bx << "/" << bx + mbx - match_trig_window_size / 2 << ": "
173  << allLCTs(bx, mbx, i) << std::endl;
174  }
175  }
176  }
177  }
178  if (infoV > 0 and n > 0)
179  LogDebug("CSCUpgradeMotherboard") << "bx " << bx << " nnLCT:" << n << " " << n << std::endl;
180  } // x-bx sorting
181  }
182 
183  bool first = true;
184  unsigned int n = 0;
185  for (const auto& p : readoutLCTs()) {
186  if (debug_matching and first) {
187  LogTrace("CSCUpgradeMotherboard") << "========================================================================"
188  << std::endl;
189  LogTrace("CSCUpgradeMotherboard") << "Counting the final LCTs" << std::endl;
190  LogTrace("CSCUpgradeMotherboard") << "========================================================================"
191  << std::endl;
192  first = false;
193  LogTrace("CSCUpgradeMotherboard") << "tmb_cross_bx_algo: " << tmb_cross_bx_algo << std::endl;
194  }
195  n++;
196  if (debug_matching)
197  LogTrace("CSCUpgradeMotherboard") << "LCT " << n << " " << p << std::endl;
198  }
199 }

◆ run() [2/3]

virtual void CSCGEMMotherboard::run ( const CSCWireDigiCollection *  wiredc,
const CSCComparatorDigiCollection *  compdc,
const GEMPadDigiClusterCollection *  gemPads 
)
pure virtual

Implemented in CSCGEMMotherboardME11, and CSCGEMMotherboardME21.

◆ run() [3/3]

virtual void CSCGEMMotherboard::run ( const CSCWireDigiCollection *  wiredc,
const CSCComparatorDigiCollection *  compdc,
const GEMPadDigiCollection *  gemPads 
)
pure virtual

Implemented in CSCGEMMotherboardME11, and CSCGEMMotherboardME21.

◆ setGEMGeometry()

void CSCGEMMotherboard::setGEMGeometry ( const GEMGeometry *  g)
inline

set CSC and GEM geometries for the matching needs

Definition at line 66 of file CSCGEMMotherboard.h.

66 { gem_g = g; }

References g, and gem_g.

Referenced by CSCTriggerPrimitivesBuilder::build().

◆ setupGeometry()

void CSCGEMMotherboard::setupGeometry ( )
protected

Definition at line 276 of file CSCGEMMotherboard.cc.

276  {
277  CSCUpgradeMotherboard::setupGeometry();
278  generator_->setGEMGeometry(gem_g);
279 }

References gem_g, CSCUpgradeMotherboard::generator_, and CSCUpgradeMotherboard::setupGeometry().

Referenced by CSCGEMMotherboardME11::run(), and CSCGEMMotherboardME21::run().

Member Data Documentation

◆ coPadProcessor

std::unique_ptr<GEMCoPadProcessor> CSCGEMMotherboard::coPadProcessor

additional processor for GEMs

Definition at line 63 of file CSCGEMMotherboard.h.

Referenced by CSCTriggerPrimitivesBuilder::build(), CSCGEMMotherboard(), CSCGEMMotherboardME21::run(), and CSCGEMMotherboardME11::run().

◆ coPads_

GEMCoPadDigiIdsBX CSCGEMMotherboard::coPads_
protected

Definition at line 213 of file CSCGEMMotherboard.h.

Referenced by clear(), getPads(), printGEMTriggerCoPads(), retrieveGEMCoPads(), CSCGEMMotherboardME11::run(), and CSCGEMMotherboardME21::run().

◆ doLCTGhostBustingWithGEMs_

bool CSCGEMMotherboard::doLCTGhostBustingWithGEMs_
protected

Definition at line 231 of file CSCGEMMotherboard.h.

◆ gem_g

const GEMGeometry* CSCGEMMotherboard::gem_g
protected

Definition at line 206 of file CSCGEMMotherboard.h.

Referenced by maxPads(), maxRolls(), retrieveGEMPads(), CSCGEMMotherboardME21::run(), CSCGEMMotherboardME11::run(), setGEMGeometry(), and setupGeometry().

◆ gemCoPadV

std::vector<GEMCoPadDigi> CSCGEMMotherboard::gemCoPadV
protected

Definition at line 209 of file CSCGEMMotherboard.h.

Referenced by retrieveGEMCoPads(), CSCGEMMotherboardME21::run(), and CSCGEMMotherboardME11::run().

◆ gemGeometryAvailable

bool CSCGEMMotherboard::gemGeometryAvailable
protected

Definition at line 207 of file CSCGEMMotherboard.h.

Referenced by CSCGEMMotherboardME11::run(), and CSCGEMMotherboardME21::run().

◆ gemId

unsigned CSCGEMMotherboard::gemId
protected

Chamber id (trigger-type labels).

Definition at line 202 of file CSCGEMMotherboard.h.

Referenced by CSCGEMMotherboard(), maxPads(), maxRolls(), CSCGEMMotherboardME11::run(), and CSCGEMMotherboardME21::run().

◆ maxDeltaBXCoPad_

int CSCGEMMotherboard::maxDeltaBXCoPad_
protected

Definition at line 217 of file CSCGEMMotherboard.h.

Referenced by getMaxDeltaBX(), CSCGEMMotherboardME21::run(), and CSCGEMMotherboardME11::run().

◆ maxDeltaBXPad_

int CSCGEMMotherboard::maxDeltaBXPad_
protected

Definition at line 216 of file CSCGEMMotherboard.h.

Referenced by getMaxDeltaBX(), and retrieveGEMPads().

◆ maxDeltaPadL1_

int CSCGEMMotherboard::maxDeltaPadL1_
protected

Definition at line 218 of file CSCGEMMotherboard.h.

Referenced by CSCGEMMotherboard(), and matchingPads().

◆ maxDeltaPadL2_

int CSCGEMMotherboard::maxDeltaPadL2_
protected

Definition at line 219 of file CSCGEMMotherboard.h.

Referenced by CSCGEMMotherboard().

◆ pads_

GEMPadDigiIdsBX CSCGEMMotherboard::pads_
protected

Definition at line 212 of file CSCGEMMotherboard.h.

Referenced by clear(), getPads(), printGEMTriggerPads(), retrieveGEMPads(), and CSCGEMMotherboardME11::run().

◆ promoteALCTGEMpattern_

bool CSCGEMMotherboard::promoteALCTGEMpattern_
protected

Definition at line 225 of file CSCGEMMotherboard.h.

Referenced by constructLCTsGEM().

◆ promoteALCTGEMquality_

bool CSCGEMMotherboard::promoteALCTGEMquality_
protected

Definition at line 227 of file CSCGEMMotherboard.h.

Referenced by constructLCTsGEM().

◆ promoteCLCTGEMquality_

bool CSCGEMMotherboard::promoteCLCTGEMquality_
protected

Definition at line 228 of file CSCGEMMotherboard.h.

Referenced by constructLCTsGEM().

◆ useOldLCTDataFormat_

bool CSCGEMMotherboard::useOldLCTDataFormat_
protected

Definition at line 222 of file CSCGEMMotherboard.h.

MuonSubdetId::GEM
static constexpr int GEM
Definition: MuonSubdetId.h:14
CSCGEMMotherboard::doesWiregroupCrossStrip
virtual bool doesWiregroupCrossStrip(int key_wg, int key_strip) const
Definition: CSCGEMMotherboard.h:71
GEMCoPadProcessor
Definition: GEMCoPadProcessor.h:17
CSCALCTDigi::getBX
uint16_t getBX() const
return BX - five low bits of BXN counter tagged by the ALCT
Definition: CSCALCTDigi.h:70
CSCGEMMotherboard::isPadInOverlap
bool isPadInOverlap(int roll) const
Definition: CSCGEMMotherboard.cc:230
ME11
Definition: CSCUpgradeMotherboardLUT.h:12
mps_fire.i
i
Definition: mps_fire.py:355
CSCMotherboard::match_trig_window_size
unsigned int match_trig_window_size
Definition: CSCMotherboard.h:99
GEMCoPadDigi::bx
int bx(int l) const
Definition: GEMCoPadDigi.cc:29
CSCGEMMotherboardLUT::get_gem_pad_to_csc_hs
virtual std::vector< int > get_gem_pad_to_csc_hs(Parity par, enum CSCPart) const =0
dqmiodumpmetadata.n
n
Definition: dqmiodumpmetadata.py:28
GEMCoPadDigi::pad
int pad(int l) const
Definition: GEMCoPadDigi.cc:20
CSCCorrelatedLCTDigi::setValid
void setValid(const uint16_t v)
set valid
Definition: CSCCorrelatedLCTDigi.h:126
GEMPadDigi
Definition: GEMPadDigi.h:15
CSCBaseboard::theRegion
unsigned theRegion
Definition: CSCBaseboard.h:47
CSCGEMMotherboard::maxDeltaPadL2_
int maxDeltaPadL2_
Definition: CSCGEMMotherboard.h:219
CSCCorrelatedLCTDigi::ALCT2GEM
Definition: CSCCorrelatedLCTDigi.h:163
CSCBaseboard::cscGeometry_
const CSCGeometry * cscGeometry_
Definition: CSCBaseboard.h:63
CSCMotherboard::secondLCT
CSCCorrelatedLCTDigi secondLCT[CSCConstants::MAX_LCT_TBINS]
Definition: CSCMotherboard.h:90
CSCConstants::MAX_ALCT_TBINS
Definition: CSCConstants.h:62
CSCMotherboard::useHighMultiplicityBits_
bool useHighMultiplicityBits_
Definition: CSCMotherboard.h:119
CSCBaseboard::tmbParams_
edm::ParameterSet tmbParams_
Definition: CSCBaseboard.h:70
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
CSCGEMMotherboard::getLUT
virtual const CSCGEMMotherboardLUT * getLUT() const =0
CSCBaseboard::theStation
const unsigned theStation
Definition: CSCBaseboard.h:43
CSCUpgradeMotherboard::clear
void clear()
Definition: CSCUpgradeMotherboard.cc:304
CSCCorrelatedLCTDigi::setQuality
void setQuality(const uint16_t q)
set quality code
Definition: CSCCorrelatedLCTDigi.h:123
l1GtPatternGenerator_cfi.bx
bx
Definition: l1GtPatternGenerator_cfi.py:18
CSCUpgradeMotherboard::intersection
void intersection(const S &d1, const S &d2, S &result) const
Definition: CSCUpgradeMotherboard.h:127
CSCConstants::LCT_CENTRAL_BX
Definition: CSCConstants.h:77
cms::cuda::assert
assert(be >=bs)
CSCGEMMotherboard::constructLCTsGEM
CSCCorrelatedLCTDigi constructLCTsGEM(const CSCALCTDigi &alct, const GEMCoPadDigi &gem, int i) const
Definition: CSCGEMMotherboard.cc:66
edm::second
U second(std::pair< T, U > const &p)
Definition: ParameterSet.cc:215
GEMSuperChamber::chamber
const GEMChamber * chamber(GEMDetId id) const
Return the chamber corresponding to the given id.
Definition: GEMSuperChamber.cc:27
CSCCorrelatedLCTDigi::setWireGroup
void setWireGroup(const uint16_t wiregroup)
set wiregroup number
Definition: CSCCorrelatedLCTDigi.h:120
CSCGEMMotherboard::promoteALCTGEMquality_
bool promoteALCTGEMquality_
Definition: CSCGEMMotherboard.h:227
CSCGEMMotherboard::useOldLCTDataFormat_
bool useOldLCTDataFormat_
Definition: CSCGEMMotherboard.h:222
CSCGEMMotherboard::coPads_
GEMCoPadDigiIdsBX coPads_
Definition: CSCGEMMotherboard.h:213
CSCUpgradeMotherboard::tmb_cross_bx_algo
unsigned int tmb_cross_bx_algo
Definition: CSCUpgradeMotherboard.h:109
CSCMotherboard::clct_trig_enable
unsigned int clct_trig_enable
Definition: CSCMotherboard.h:98
makeMuonMisalignmentScenario.endcap
endcap
Definition: makeMuonMisalignmentScenario.py:320
CSCCorrelatedLCTDigi::setBX0
void setBX0(const uint16_t b)
set bx0
Definition: CSCCorrelatedLCTDigi.h:141
dqmdumpme.first
first
Definition: dqmdumpme.py:55
CSCCLCTDigi
Definition: CSCCLCTDigi.h:17
validateGeometry_cfg.valid
valid
Definition: validateGeometry_cfg.py:21
end
#define end
Definition: vmac.h:39
CSCCorrelatedLCTDigi::CLCT2GEM
Definition: CSCCorrelatedLCTDigi.h:164
CSCCorrelatedLCTDigi::setCLCT
void setCLCT(const CSCCLCTDigi &clct)
Definition: CSCCorrelatedLCTDigi.h:174
CSCMotherboard::clctV
std::vector< CSCCLCTDigi > clctV
Definition: CSCMotherboard.h:84
CSCMotherboard::clctProc
std::unique_ptr< CSCCathodeLCTProcessor > clctProc
Definition: CSCMotherboard.h:78
DetId
Definition: DetId.h:17
CSCCorrelatedLCTDigi::setALCT
void setALCT(const CSCALCTDigi &alct)
Definition: CSCCorrelatedLCTDigi.h:173
CSCALCTDigi::getKeyWG
uint16_t getKeyWG() const
return key wire group
Definition: CSCALCTDigi.h:64
CSCCLCTDigi::getQuality
uint16_t getQuality() const
return quality of a pattern (number of layers hit!)
Definition: CSCCLCTDigi.h:51
CSCCorrelatedLCTDigi::setStrip
void setStrip(const uint16_t s)
set strip
Definition: CSCCorrelatedLCTDigi.h:129
LCTContainer::getMatched
void getMatched(std::vector< CSCCorrelatedLCTDigi > &) const
Definition: LCTContainer.cc:23
CSCCLCTDigi::getBend
uint16_t getBend() const
return bend
Definition: CSCCLCTDigi.h:69
part
part
Definition: HCALResponse.h:20
CSCMotherboard::alctV
std::vector< CSCALCTDigi > alctV
Definition: CSCMotherboard.h:83
CSCConstants::MAX_LCTS_PER_CSC
Definition: CSCConstants.h:73
CSCUpgradeMotherboard::readoutLCTs
std::vector< CSCCorrelatedLCTDigi > readoutLCTs() const override
Definition: CSCUpgradeMotherboard.cc:241
CSCGEMMotherboard::correlateLCTsGEM
void correlateLCTsGEM(const T &best, const T &second, const GEMCoPadDigiIds &coPads, CSCCorrelatedLCTDigi &lct1, CSCCorrelatedLCTDigi &lct2) const
Definition: CSCGEMMotherboard.h:464
CSCUpgradeMotherboard::getCSCPart
enum CSCPart getCSCPart(int keystrip) const
Definition: CSCUpgradeMotherboard.cc:251
CSCCLCTDigi::getKeyStrip
uint16_t getKeyStrip(uint16_t n=2) const
Definition: CSCCLCTDigi.cc:87
CSCUpgradeMotherboard::setupGeometry
void setupGeometry()
Definition: CSCUpgradeMotherboard.cc:294
CSCUpgradeMotherboard::match_earliest_clct_only
bool match_earliest_clct_only
Definition: CSCUpgradeMotherboard.h:106
cond::time::INVALID
static constexpr TimeType INVALID
Definition: Time.h:33
CSCCorrelatedLCTDigi::setMPCLink
void setMPCLink(const uint16_t &link)
Set mpc link number after MPC sorting.
Definition: CSCCorrelatedLCTDigi.h:110
CSCBaseboard::alctClctOffset_
unsigned int alctClctOffset_
Definition: CSCBaseboard.h:95
p2
double p2[4]
Definition: TauolaWrapper.h:90
CSCUpgradeMotherboard::theParity
Parity theParity
Definition: CSCUpgradeMotherboard.h:92
CSCGEMMotherboardLUT::get_csc_hs_to_gem_pad
virtual std::vector< std::pair< int, int > > get_csc_hs_to_gem_pad(Parity par, enum CSCPart) const =0
CSCConstants::MAX_LCT_TBINS
Definition: CSCConstants.h:63
CSCGEMMotherboard::gemId
unsigned gemId
Definition: CSCGEMMotherboard.h:202
CSCGEMMotherboard::promoteCLCTGEMquality_
bool promoteCLCTGEMquality_
Definition: CSCGEMMotherboard.h:228
CSCALCTDigi::getQuality
uint16_t getQuality() const
return quality of a pattern
Definition: CSCALCTDigi.h:43
CSCCorrelatedLCTDigi::ALCTCLCTGEM
Definition: CSCCorrelatedLCTDigi.h:161
CSCGEMMotherboard::coPadProcessor
std::unique_ptr< GEMCoPadProcessor > coPadProcessor
Definition: CSCGEMMotherboard.h:63
CSCGEMMotherboard::gemCoPadV
std::vector< GEMCoPadDigi > gemCoPadV
Definition: CSCGEMMotherboard.h:209
edm::LogWarning
Definition: MessageLogger.h:141
CSCGEMMotherboard::promoteALCTGEMpattern_
bool promoteALCTGEMpattern_
Definition: CSCGEMMotherboard.h:225
CSCCorrelatedLCTDigi::setBend
void setBend(const uint16_t b)
set bend
Definition: CSCCorrelatedLCTDigi.h:135
GEMCoPadDigi
Definition: GEMCoPadDigi.h:16
CSCUpgradeMotherboard::correlateLCTs
void correlateLCTs(const CSCALCTDigi &bestALCT, const CSCALCTDigi &secondALCT, const CSCCLCTDigi &bestCLCT, const CSCCLCTDigi &secondCLCT, CSCCorrelatedLCTDigi &lct1, CSCCorrelatedLCTDigi &lct2) const
Definition: CSCUpgradeMotherboard.cc:201
CSCCorrelatedLCTDigi::setGEM1
void setGEM1(const GEMPadDigi &gem)
Definition: CSCCorrelatedLCTDigi.h:175
CSCCorrelatedLCTDigi::ALCTCLCT2GEM
Definition: CSCCorrelatedLCTDigi.h:162
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:670
CSCCorrelatedLCTDigi::setBX
void setBX(const uint16_t b)
set bx
Definition: CSCCorrelatedLCTDigi.h:138
CSCCorrelatedLCTDigi::setTrknmb
void setTrknmb(const uint16_t number)
Set track number (1,2) after sorting LCTs.
Definition: CSCCorrelatedLCTDigi.h:107
edm::ParameterSet
Definition: ParameterSet.h:36
edm::LogError
Definition: MessageLogger.h:183
ME1A
Definition: CSCUpgradeMotherboardLUT.h:12
LCTContainer::clear
void clear()
Definition: LCTContainer.cc:31
CSCUpgradeMotherboard::debug_matching
bool debug_matching
Definition: CSCUpgradeMotherboard.h:115
CSCGEMMotherboard::isGEMDetId
bool isGEMDetId(unsigned int) const
Definition: CSCGEMMotherboard.cc:243
CSCCorrelatedLCTDigi::setPattern
void setPattern(const uint16_t p)
set pattern
Definition: CSCCorrelatedLCTDigi.h:132
CSCGEMMotherboard::getRoll
int getRoll(const GEMPadDigiId &p) const
Definition: CSCGEMMotherboard.cc:251
GEMDetId::roll
constexpr int roll() const
Definition: GEMDetId.h:188
CSCCorrelatedLCTDigi::setGEM2
void setGEM2(const GEMPadDigi &gem)
Definition: CSCCorrelatedLCTDigi.h:176
CSCConstants::MAX_HALF_STRIP_ME1B
Definition: CSCConstants.h:39
dumpMFGeometry_cfg.delta
delta
Definition: dumpMFGeometry_cfg.py:25
GEMDetId
Definition: GEMDetId.h:17
CSCCorrelatedLCTDigi::setCSCID
void setCSCID(const uint16_t c)
set cscID
Definition: CSCCorrelatedLCTDigi.h:147
CSCGEMMotherboardLUT::get_gem_roll_to_csc_wg
std::vector< int > get_gem_roll_to_csc_wg(Parity par) const
Definition: CSCUpgradeMotherboardLUT.cc:106
CSCCLCTDigi::isValid
bool isValid() const
check CLCT validity (1 - valid CLCT)
Definition: CSCCLCTDigi.h:45
CSCUpgradeMotherboard::sortLCTs
void sortLCTs(std::vector< CSCCorrelatedLCTDigi > &lcts, bool(*sorter)(const CSCCorrelatedLCTDigi &, const CSCCorrelatedLCTDigi &)) const
Definition: CSCUpgradeMotherboard.cc:287
topSingleLeptonDQM_PU_cfi.pattern
pattern
Definition: topSingleLeptonDQM_PU_cfi.py:39
CSCUpgradeMotherboard::pref
int pref[CSCConstants::MAX_LCT_TBINS]
Definition: CSCUpgradeMotherboard.h:103
p1
double p1[4]
Definition: TauolaWrapper.h:89
GEMCoPadDigi::second
GEMPadDigi second() const
Definition: GEMCoPadDigi.h:30
HltBtagPostValidation_cff.c
c
Definition: HltBtagPostValidation_cff.py:31
CSCGEMMotherboard::getRolls
std::pair< int, int > getRolls(const CSCALCTDigi &) const
Definition: CSCGEMMotherboard.cc:255
CSCBaseboard::theChamber
unsigned theChamber
Definition: CSCBaseboard.h:49
CSCCorrelatedLCTDigi::setSyncErr
void setSyncErr(const uint16_t s)
set syncErr
Definition: CSCCorrelatedLCTDigi.h:144
CSCUpgradeMotherboard::CSCUpgradeMotherboard
CSCUpgradeMotherboard()
Definition: CSCUpgradeMotherboard.cc:41
gem
Definition: AMC13Event.h:6
GEMChamber::etaPartition
const GEMEtaPartition * etaPartition(GEMDetId id) const
Return the eta partition corresponding to the given id.
Definition: GEMChamber.cc:33
CSCMotherboard::drop_used_clcts
bool drop_used_clcts
Definition: CSCMotherboard.h:105
CSCMotherboard::encodeHighMultiplicityBits
void encodeHighMultiplicityBits(unsigned alctBits)
Definition: CSCMotherboard.cc:630
GEMChamber::nEtaPartitions
int nEtaPartitions() const
Retunr numbers of eta partitions.
Definition: GEMChamber.cc:31
CSCUpgradeMotherboard::sortLCTsByQuality
static bool sortLCTsByQuality(const CSCCorrelatedLCTDigi &, const CSCCorrelatedLCTDigi &)
Definition: CSCUpgradeMotherboard.cc:279
CSCMotherboard::getBXShiftedCLCT
CSCCLCTDigi getBXShiftedCLCT(const CSCCLCTDigi &) const
Definition: CSCMotherboard.cc:624
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
GEMEtaPartition::npads
int npads() const
number of GEM-CSC trigger readout pads in partition
Definition: GEMEtaPartition.cc:43
CSCGEMMotherboard::findQualityGEM
unsigned int findQualityGEM(const CSCALCTDigi &, const CSCCLCTDigi &, int gemlayer) const
Definition: CSCGEMMotherboard.cc:327
CSCUpgradeMotherboard::allLCTs
LCTContainer allLCTs
Definition: CSCUpgradeMotherboard.h:98
CSCGEMMotherboardLUT::get_csc_wg_to_gem_roll
std::vector< std::pair< int, int > > get_csc_wg_to_gem_roll(Parity par, int layer=1) const
Definition: CSCUpgradeMotherboardLUT.cc:98
DetId::rawId
constexpr uint32_t rawId() const
get the raw id
Definition: DetId.h:57
CSCGEMMotherboard::maxDeltaBXPad_
int maxDeltaBXPad_
Definition: CSCGEMMotherboard.h:216
qcdUeDQM_cfi.quality
quality
Definition: qcdUeDQM_cfi.py:31
CSCALCTDigi::getAccelerator
uint16_t getAccelerator() const
Definition: CSCALCTDigi.h:50
trklet::bend
double bend(double r, double rinv, double stripPitch)
Definition: Util.h:160
T
long double T
Definition: Basic3DVectorLD.h:48
CSCMotherboard::highMultiplicityBits_
unsigned int highMultiplicityBits_
Definition: CSCMotherboard.h:118
CSCGEMMotherboard::maxRolls
int maxRolls() const
Definition: CSCGEMMotherboard.cc:283
CSCALCTDigi
Definition: CSCALCTDigi.h:16
GEMCoPadDigi::roll
int roll() const
Definition: GEMCoPadDigi.h:25
CSCMotherboard::alct_trig_enable
unsigned int alct_trig_enable
Definition: CSCMotherboard.h:98
CSCConstants::MAX_CLCT_TBINS
Definition: CSCConstants.h:61
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
CSCBaseboard::theTrigChamber
const unsigned theTrigChamber
Definition: CSCBaseboard.h:46
GEMDetId::minRollId
static constexpr int32_t minRollId
Definition: GEMDetId.h:32
CSCMotherboard::encodePattern
unsigned int encodePattern(const int clctPattern) const
Definition: CSCMotherboard.cc:514
CSCGEMMotherboard::DEFAULT_MATCHING_VALUE
Definition: CSCGEMMotherboard.h:31
CSCGEMMotherboard::doLCTGhostBustingWithGEMs_
bool doLCTGhostBustingWithGEMs_
Definition: CSCGEMMotherboard.h:231
CSCGEMMotherboard::pads_
GEMPadDigiIdsBX pads_
Definition: CSCGEMMotherboard.h:212
CSCGEMMotherboard::maxDeltaBXCoPad_
int maxDeltaBXCoPad_
Definition: CSCGEMMotherboard.h:217
CSCBaseboard::cscId_
CSCDetId cscId_
Definition: CSCBaseboard.h:55
S
Definition: CSCDBL1TPParametersExtended.h:16
CSCALCTDigi::isValid
bool isValid() const
check ALCT validity (1 - valid ALCT)
Definition: CSCALCTDigi.h:37
CSCGEMMotherboard::getPad
float getPad(const GEMPadDigi &) const
Definition: CSCGEMMotherboard.cc:260
GEMDetId::station
constexpr int station() const
Definition: GEMDetId.h:173
CSCGEMMotherboard::maxPads
int maxPads() const
Definition: CSCGEMMotherboard.cc:281
mps_fire.result
result
Definition: mps_fire.py:303
DetId::Muon
Definition: DetId.h:26
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
LogTrace
#define LogTrace(id)
Definition: MessageLogger.h:671
CSCMotherboard::match_trig_enable
unsigned int match_trig_enable
Definition: CSCMotherboard.h:98
GEMPadDigi::isValid
bool isValid() const
Definition: GEMPadDigi.cc:22
GEMGeometry::superChamber
const GEMSuperChamber * superChamber(GEMDetId id) const
Definition: GEMGeometry.cc:69
CSCMotherboard::getBXShiftedALCT
CSCALCTDigi getBXShiftedALCT(const CSCALCTDigi &) const
Definition: CSCMotherboard.cc:618
CSCCLCTDigi::getPattern
uint16_t getPattern() const
return pattern
Definition: CSCCLCTDigi.h:57
CSCUpgradeMotherboard::generator_
std::unique_ptr< CSCUpgradeMotherboardLUTGenerator > generator_
Definition: CSCUpgradeMotherboard.h:100
CSCCorrelatedLCTDigi::setType
void setType(int type)
Definition: CSCCorrelatedLCTDigi.h:171
CSCCorrelatedLCTDigi::isValid
bool isValid() const
return valid pattern bit
Definition: CSCCorrelatedLCTDigi.h:50
CSCGEMMotherboard::getBX
int getBX(const GEMPadDigi &p) const
Definition: CSCGEMMotherboard.cc:247
CSCGEMMotherboard::maxDeltaPadL1_
int maxDeltaPadL1_
Definition: CSCGEMMotherboard.h:218
begin
#define begin
Definition: vmac.h:32
GEMCoPadDigi::first
GEMPadDigi first() const
Definition: GEMCoPadDigi.h:29
d1
static constexpr float d1
Definition: L1EGammaCrystalsEmulatorProducer.cc:84
CSCGEMMotherboard::gem_g
const GEMGeometry * gem_g
Definition: CSCGEMMotherboard.h:206
CSCCorrelatedLCTDigi
Definition: CSCCorrelatedLCTDigi.h:19
g
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 g
Definition: Activities.doc:4
GEMCoPadDigi::isValid
bool isValid() const
Definition: GEMCoPadDigi.cc:18
ME1B
Definition: CSCUpgradeMotherboardLUT.h:12
CSCBaseboard::infoV
int infoV
Definition: CSCBaseboard.h:61
Generated for CMSSW Reference Manual by doxygen 1.8.16