CMS 3D CMS Logo
List of all members | Public Types | Public Member Functions | Public Attributes | Protected Types | 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
 
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 Types

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

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
 
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
 
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 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

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_
 

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 &)
 
- 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 };

◆ LCT_QualityRun3

enum CSCGEMMotherboard::LCT_QualityRun3
protected
Enumerator
INVALID 
CLCT_2GEM 
ALCT_2GEM 
ALCTCLCT 
ALCTCLCT_1GEM 
ALCTCLCT_2GEM 

Definition at line 187 of file CSCGEMMotherboard.h.

187  {
188  INVALID = 0,
189  CLCT_2GEM = 3,
190  ALCT_2GEM = 4,
191  ALCTCLCT = 5,
192  ALCTCLCT_1GEM = 6,
193  ALCTCLCT_2GEM = 7,
194  };

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 5 of file CSCGEMMotherboard.cc.

11  : CSCUpgradeMotherboard(endcap, station, sector, subsector, chamber, conf),
12  maxDeltaBXPad_(tmbParams_.getParameter<int>("maxDeltaBXPad")),
13  maxDeltaBXCoPad_(tmbParams_.getParameter<int>("maxDeltaBXCoPad")),
14  promoteALCTGEMpattern_(tmbParams_.getParameter<bool>("promoteALCTGEMpattern")),
15  promoteALCTGEMquality_(tmbParams_.getParameter<bool>("promoteALCTGEMquality")) {
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 = std::make_unique<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 431 of file CSCGEMMotherboard.h.

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

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 383 of file CSCGEMMotherboard.h.

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

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 404 of file CSCGEMMotherboard.h.

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

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  gemCoPadV.clear();
36  coPadProcessor->clear();
37  pads_.clear();
38  coPads_.clear();
39 }

References CSCUpgradeMotherboard::clear(), coPadProcessor, coPads_, gemCoPadV, 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 103 of file CSCGEMMotherboard.cc.

106  {
107  return constructLCTsGEM(alct, clct, GEMPadDigi(), gem, trknmb);
108 }

References constructLCTsGEM().

◆ constructLCTsGEM() [2/5]

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

Definition at line 110 of file CSCGEMMotherboard.cc.

113  {
114  return constructLCTsGEM(alct, clct, gem, GEMCoPadDigi(), trknmb);
115 }

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 117 of file CSCGEMMotherboard.cc.

121  {
122  int pattern = 0, quality = 0, bx = 0, keyStrip = 0, keyWG = 0, bend = 0, valid = 0;
123 
124  // make a new LCT
125  CSCCorrelatedLCTDigi thisLCT;
126  if (!alct.isValid() and !clct.isValid()) {
127  edm::LogError("CSCGEMCMotherboard") << "Warning!!! neither ALCT nor CLCT valid, return invalid LCT";
128  return thisLCT;
129  }
130 
131  // Determine the case and assign properties depending on the LCT dataformat (old/new)
132  if (alct.isValid() and clct.isValid() and gem1.isValid() and not gem2.isValid()) {
133  pattern = encodePattern(clct.getPattern());
134  if (runCCLUT_) {
135  quality = static_cast<unsigned int>(findQualityGEMv2(alct, clct, 1));
136  } else {
137  quality = static_cast<unsigned int>(findQualityGEMv1(alct, clct, 1));
138  }
139  bx = alct.getBX();
140  keyStrip = clct.getKeyStrip();
141  keyWG = alct.getKeyWG();
142  bend = clct.getBend();
143  thisLCT.setALCT(getBXShiftedALCT(alct));
144  thisLCT.setCLCT(getBXShiftedCLCT(clct));
145  thisLCT.setGEM1(gem1);
146  thisLCT.setType(CSCCorrelatedLCTDigi::ALCTCLCTGEM);
147  valid = doesWiregroupCrossStrip(keyWG, keyStrip) ? 1 : 0;
148  } else if (alct.isValid() and clct.isValid() and not gem1.isValid() and gem2.isValid()) {
149  pattern = encodePattern(clct.getPattern());
150  if (runCCLUT_) {
151  quality = static_cast<unsigned int>(findQualityGEMv2(alct, clct, 2));
152  } else {
153  quality = static_cast<unsigned int>(findQualityGEMv1(alct, clct, 2));
154  }
155  bx = alct.getBX();
156  keyStrip = clct.getKeyStrip();
157  keyWG = alct.getKeyWG();
158  bend = clct.getBend();
159  thisLCT.setALCT(getBXShiftedALCT(alct));
160  thisLCT.setCLCT(getBXShiftedCLCT(clct));
161  thisLCT.setGEM1(gem2.first());
162  thisLCT.setGEM2(gem2.second());
163  thisLCT.setType(CSCCorrelatedLCTDigi::ALCTCLCT2GEM);
164  valid = doesWiregroupCrossStrip(keyWG, keyStrip) ? 1 : 0;
165  } else if (alct.isValid() and gem2.isValid() and not clct.isValid()) {
166  //in ME11
167  //ME1b: keyWG >15,
168  //ME1a and ME1b overlap: 10<=keyWG<=15
169  //ME1a: keyWG < 10
170  //in overlap region, firstly try a match in ME1b
171 
172  auto p(getCSCPart(-1)); //use -1 as fake halfstrip, it returns ME11 if station==1 && (ring==1 or ring==4)
173  if (p == CSCPart::ME11) {
174  if (alct.getKeyWG() >= 10)
175  p = CSCPart::ME1B;
176  else
177  p = CSCPart::ME1A;
178  }
179 
180  // min pad number is always 0
181  // max pad number is 191 or 383, depending on the station
182  assert(gem2.pad(1) >= 0);
183  assert(gem2.pad(2) >= 0);
184  assert(gem2.pad(1) < maxPads());
185  assert(gem2.pad(2) < maxPads());
186 
187  const auto& mymap1 = getLUT()->get_gem_pad_to_csc_hs(theParity, p);
188  // GEM pad number is counting from 1
189  // keyStrip from mymap: for ME1b 0-127 and for ME1a 0-95
190  // keyStrip for CLCT: for ME1b 0-127 and for ME1a 128-223
191  keyStrip = mymap1.at(gem2.pad(2));
192  if (p == CSCPart::ME1A and keyStrip <= CSCConstants::MAX_HALF_STRIP_ME1B) {
193  keyStrip += CSCConstants::MAX_HALF_STRIP_ME1B + 1;
194  }
195  keyWG = alct.getKeyWG();
196 
197  if ((not doesWiregroupCrossStrip(keyWG, keyStrip)) and p == CSCPart::ME1B and keyWG <= 15) {
198  //try ME1A as strip and WG do not cross
199  p = CSCPart::ME1A;
200  const auto& mymap2 = getLUT()->get_gem_pad_to_csc_hs(theParity, p);
201  keyStrip = mymap2.at(gem2.pad(2)) + CSCConstants::MAX_HALF_STRIP_ME1B + 1;
202  }
203 
204  pattern = promoteALCTGEMpattern_ ? 10 : 0;
205  quality = promoteALCTGEMquality_ ? 15 : 11;
206  bx = alct.getBX();
207  thisLCT.setALCT(getBXShiftedALCT(alct));
208  thisLCT.setGEM1(gem2.first());
209  thisLCT.setGEM2(gem2.second());
210  thisLCT.setType(CSCCorrelatedLCTDigi::ALCT2GEM);
211  valid = true;
212  } else if (clct.isValid() and gem2.isValid() and not alct.isValid()) {
213  // min roll number is always 1
214  // max roll number is 8 or 16, depending on the station
215  assert(gem2.roll() >= GEMDetId::minRollId);
216  assert(gem2.roll() <= maxRolls());
217 
218  const auto& mymap2 = getLUT()->get_gem_roll_to_csc_wg(theParity);
219  pattern = encodePattern(clct.getPattern());
220  quality = promoteCLCTGEMquality_ ? 15 : 11;
221  bx = gem2.bx(1) + CSCConstants::LCT_CENTRAL_BX;
222  keyStrip = clct.getKeyStrip();
223  // choose the corresponding wire-group in the middle of the partition
224  keyWG = mymap2.at(gem2.roll() - 1);
225  bend = clct.getBend();
226  thisLCT.setCLCT(clct);
227  thisLCT.setGEM1(gem2.first());
228  thisLCT.setGEM2(gem2.second());
229  thisLCT.setType(CSCCorrelatedLCTDigi::CLCT2GEM);
230  valid = true;
231  }
232 
233  if (valid == 0)
234  LogTrace("CSCGEMCMotherboard") << "Warning!!! wiregroup and strip pair are not crossing each other"
235  << " detid " << cscId_ << " with wiregroup " << keyWG << "keyStrip " << keyStrip
236  << " \n";
237 
238  // fill the rest of the properties
239  thisLCT.setTrknmb(trknmb);
240  thisLCT.setValid(valid);
241  thisLCT.setQuality(quality);
242  thisLCT.setWireGroup(keyWG);
243  thisLCT.setStrip(keyStrip);
244  thisLCT.setPattern(pattern);
245  thisLCT.setBend(bend);
246  thisLCT.setBX(bx);
247  thisLCT.setMPCLink(0);
248  thisLCT.setBX0(0);
249  // Not used in Run-2. Will not be assigned in Run-3
250  thisLCT.setSyncErr(0);
251  thisLCT.setCSCID(theTrigChamber);
252  thisLCT.setRun3(true);
253  // in Run-3 we plan to denote the presence of exotic signatures in the chamber
254  if (useHighMultiplicityBits_)
255  thisLCT.setHMT(highMultiplicityBits_);
256 
257  // future work: add a section that produces LCTs according
258  // to the new LCT dataformat (not yet defined)
259 
260  // return new LCT
261  return thisLCT;
262 }

References CSCCorrelatedLCTDigi::ALCT2GEM, CSCCorrelatedLCTDigi::ALCTCLCT2GEM, CSCCorrelatedLCTDigi::ALCTCLCTGEM, cms::cuda::assert(), trklet::bend(), l1GtPatternGenerator_cfi::bx, GEMCoPadDigi::bx(), CSCCorrelatedLCTDigi::CLCT2GEM, CSCBaseboard::cscId_, doesWiregroupCrossStrip(), CSCMotherboard::encodePattern(), findQualityGEMv1(), findQualityGEMv2(), 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_, GEMCoPadDigi::isValid(), GEMPadDigi::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(), CSCBaseboard::runCCLUT_, GEMCoPadDigi::second(), CSCCorrelatedLCTDigi::setALCT(), CSCCorrelatedLCTDigi::setBend(), CSCCorrelatedLCTDigi::setBX(), CSCCorrelatedLCTDigi::setBX0(), CSCCorrelatedLCTDigi::setCLCT(), CSCCorrelatedLCTDigi::setCSCID(), CSCCorrelatedLCTDigi::setGEM1(), CSCCorrelatedLCTDigi::setGEM2(), CSCCorrelatedLCTDigi::setHMT(), CSCCorrelatedLCTDigi::setMPCLink(), CSCCorrelatedLCTDigi::setPattern(), CSCCorrelatedLCTDigi::setQuality(), CSCCorrelatedLCTDigi::setRun3(), CSCCorrelatedLCTDigi::setStrip(), CSCCorrelatedLCTDigi::setSyncErr(), CSCCorrelatedLCTDigi::setTrknmb(), CSCCorrelatedLCTDigi::setType(), CSCCorrelatedLCTDigi::setValid(), CSCCorrelatedLCTDigi::setWireGroup(), CSCUpgradeMotherboard::theParity, CSCBaseboard::theTrigChamber, CSCMotherboard::useHighMultiplicityBits_, and RunInfoPI::valid.

◆ constructLCTsGEM() [4/5]

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

Definition at line 91 of file CSCGEMMotherboard.cc.

93  {
94  return constructLCTsGEM(alct, CSCCLCTDigi(), GEMPadDigi(), gem, trknmb);
95 }

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 97 of file CSCGEMMotherboard.cc.

99  {
100  return constructLCTsGEM(CSCALCTDigi(), clct, GEMPadDigi(), gem, trknmb);
101 }

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 492 of file CSCGEMMotherboard.h.

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

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 465 of file CSCGEMMotherboard.h.

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

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 67 of file CSCGEMMotherboard.h.

67 { return true; }

Referenced by constructLCTsGEM().

◆ findQualityGEMv1()

CSCMotherboard::LCT_Quality CSCGEMMotherboard::findQualityGEMv1 ( const CSCALCTDigi &  aLCT,
const CSCCLCTDigi &  cLCT,
int  gemlayer 
) const
protected

Definition at line 361 of file CSCGEMMotherboard.cc.

363  {
364  // Either ALCT or CLCT is invalid
365  if (!(aLCT.isValid()) || !(cLCT.isValid())) {
366  // No CLCT
367  if (aLCT.isValid() && !(cLCT.isValid()))
368  return LCT_Quality::NO_CLCT;
369 
370  // No ALCT
371  else if (!(aLCT.isValid()) && cLCT.isValid())
372  return LCT_Quality::NO_ALCT;
373 
374  // No ALCT and no CLCT
375  else
376  return LCT_Quality::INVALID;
377  }
378  // Both ALCT and CLCT are valid
379  else {
380  const int pattern(cLCT.getPattern());
381 
382  // Layer-trigger in CLCT
383  if (pattern == 1)
384  return LCT_Quality::CLCT_LAYER_TRIGGER;
385 
386  // Multi-layer pattern in CLCT
387  else {
388  // ALCT quality is the number of layers hit minus 3.
389  bool a4 = false;
390 
391  // Case of ME11 with GEMs: require 4 layers for ALCT
392  if (theStation == 1)
393  a4 = aLCT.getQuality() >= 1;
394 
395  // Case of ME21 with GEMs: require 4 layers for ALCT+GEM
396  if (theStation == 2)
397  a4 = aLCT.getQuality() + gemlayers >= 1;
398 
399  // CLCT quality is the number of layers hit.
400  const bool c4((cLCT.getQuality() >= 4) or (cLCT.getQuality() >= 3 and gemlayers >= 1));
401 
402  // quality = 4; "reserved for low-quality muons in future"
403 
404  // marginal anode and cathode
405  if (!a4 && !c4)
406  return LCT_Quality::MARGINAL_ANODE_CATHODE;
407 
408  // HQ anode, but marginal cathode
409  else if (a4 && !c4)
410  return LCT_Quality::HQ_ANODE_MARGINAL_CATHODE;
411 
412  // HQ cathode, but marginal anode
413  else if (!a4 && c4)
414  return LCT_Quality::HQ_CATHODE_MARGINAL_ANODE;
415 
416  // HQ muon, but accelerator ALCT
417  else if (a4 && c4) {
418  if (aLCT.getAccelerator())
419  return LCT_Quality::HQ_ACCEL_ALCT;
420 
421  else {
422  // quality = 9; "reserved for HQ muons with future patterns
423  // quality = 10; "reserved for HQ muons with future patterns
424 
425  // High quality muons are determined by their CLCT pattern
426  if (pattern == 2 || pattern == 3)
427  return LCT_Quality::HQ_PATTERN_2_3;
428 
429  else if (pattern == 4 || pattern == 5)
430  return LCT_Quality::HQ_PATTERN_4_5;
431 
432  else if (pattern == 6 || pattern == 7)
433  return LCT_Quality::HQ_PATTERN_6_7;
434 
435  else if (pattern == 8 || pattern == 9)
436  return LCT_Quality::HQ_PATTERN_8_9;
437 
438  else if (pattern == 10)
439  return LCT_Quality::HQ_PATTERN_10;
440 
441  else {
442  edm::LogWarning("CSCGEMMotherboard")
443  << "findQualityGEMv1: Unexpected CLCT pattern id = " << pattern << " in " << theCSCName_;
444  return LCT_Quality::INVALID;
445  }
446  }
447  }
448  }
449  }
450  return LCT_Quality::INVALID;
451 }

References CSCMotherboard::CLCT_LAYER_TRIGGER, CSCALCTDigi::getAccelerator(), CSCCLCTDigi::getPattern(), CSCALCTDigi::getQuality(), CSCCLCTDigi::getQuality(), CSCMotherboard::HQ_ACCEL_ALCT, CSCMotherboard::HQ_ANODE_MARGINAL_CATHODE, CSCMotherboard::HQ_CATHODE_MARGINAL_ANODE, CSCMotherboard::HQ_PATTERN_10, CSCMotherboard::HQ_PATTERN_2_3, CSCMotherboard::HQ_PATTERN_4_5, CSCMotherboard::HQ_PATTERN_6_7, CSCMotherboard::HQ_PATTERN_8_9, CSCMotherboard::INVALID, CSCALCTDigi::isValid(), CSCCLCTDigi::isValid(), CSCMotherboard::MARGINAL_ANODE_CATHODE, CSCMotherboard::NO_ALCT, CSCMotherboard::NO_CLCT, or, topSingleLeptonDQM_PU_cfi::pattern, CSCBaseboard::theCSCName_, and CSCBaseboard::theStation.

Referenced by constructLCTsGEM().

◆ findQualityGEMv2()

CSCGEMMotherboard::LCT_QualityRun3 CSCGEMMotherboard::findQualityGEMv2 ( const CSCALCTDigi &  aLCT,
const CSCCLCTDigi &  cLCT,
int  gemlayer 
) const
protected

Definition at line 453 of file CSCGEMMotherboard.cc.

455  {
456  // ALCT and CLCT invalid
457  if (!(aLCT.isValid()) and !(cLCT.isValid())) {
458  return LCT_QualityRun3::INVALID;
459  } else if (!aLCT.isValid() && cLCT.isValid() and gemlayers == 2) {
460  return LCT_QualityRun3::CLCT_2GEM;
461  } else if (aLCT.isValid() && !cLCT.isValid() and gemlayers == 2) {
462  return LCT_QualityRun3::ALCT_2GEM;
463  } else if (aLCT.isValid() && cLCT.isValid()) {
464  if (gemlayers == 0)
465  return LCT_QualityRun3::ALCTCLCT;
466  else if (gemlayers == 1)
467  return LCT_QualityRun3::ALCTCLCT_1GEM;
468  else if (gemlayers == 2)
469  return LCT_QualityRun3::ALCTCLCT_2GEM;
470  }
471  return LCT_QualityRun3::INVALID;
472 }

References cond::time::INVALID, CSCALCTDigi::isValid(), and CSCCLCTDigi::isValid().

Referenced by constructLCTsGEM().

◆ getBX() [1/2]

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

Definition at line 283 of file CSCGEMMotherboard.cc.

283 { return p.bx(1); }

References AlCaHLTBitMon_ParallelJobs::p.

◆ getBX() [2/2]

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

Definition at line 281 of file CSCGEMMotherboard.cc.

281 { 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 495 of file CSCGEMMotherboard.cc.

495  {
496  return alct_trig_enable;
497 }

References CSCMotherboard::alct_trig_enable.

◆ getLctTrigEnable() [3/3]

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

Definition at line 500 of file CSCGEMMotherboard.cc.

500  {
501  return clct_trig_enable;
502 }

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 485 of file CSCGEMMotherboard.cc.

485  {
486  return maxDeltaBXPad_;
487 }

References maxDeltaBXPad_.

◆ getMaxDeltaBX() [3/3]

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

Definition at line 490 of file CSCGEMMotherboard.cc.

490  {
491  return maxDeltaBXCoPad_;
492 }

References maxDeltaBXCoPad_.

◆ getPad() [1/3]

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

Definition at line 301 of file CSCGEMMotherboard.cc.

301  {
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  return 0.5 * (mymap.at(keyStrip).first + mymap.at(keyStrip).second);
308 }

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 296 of file CSCGEMMotherboard.cc.

296  {
297  // average pad number for a GEMCoPad
298  return 0.5 * (p.pad(1) + p.pad(2));
299 }

References AlCaHLTBitMon_ParallelJobs::p.

◆ getPad() [3/3]

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

Definition at line 294 of file CSCGEMMotherboard.cc.

294 { 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<GEMCoPadDigi>& CSCGEMMotherboard::getPads ( ) const
private

Definition at line 480 of file CSCGEMMotherboard.cc.

480  {
481  return coPads_;
482 }

References coPads_.

◆ getPads() [3/3]

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

Definition at line 475 of file CSCGEMMotherboard.cc.

475  {
476  return pads_;
477 }

References pads_.

◆ getRoll() [1/2]

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

Definition at line 287 of file CSCGEMMotherboard.cc.

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

References AlCaHLTBitMon_ParallelJobs::p.

◆ getRoll() [2/2]

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

Definition at line 285 of file CSCGEMMotherboard.cc.

285 { 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 289 of file CSCGEMMotherboard.cc.

289  {
290  const auto& mymap(getLUT()->get_csc_wg_to_gem_roll(theParity));
291  return mymap.at(alct.getKeyWG());
292 }

References CSCALCTDigi::getKeyWG(), getLUT(), and CSCUpgradeMotherboard::theParity.

Referenced by bestMatchingPad().

◆ isGEMDetId()

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

Definition at line 277 of file CSCGEMMotherboard.cc.

277  {
278  return (DetId(p).subdetId() == MuonSubdetId::GEM and DetId(p).det() == DetId::Muon);
279 }

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

Referenced by bestMatchingPad().

◆ isPadInOverlap()

bool CSCGEMMotherboard::isPadInOverlap ( int  roll) const
protected

Definition at line 264 of file CSCGEMMotherboard.cc.

264  {
265  // this only works for ME1A!
266  const auto& mymap = (getLUT()->get_csc_wg_to_gem_roll(theParity));
267  for (unsigned i = 0; i < mymap.size(); i++) {
268  // overlap region are WGs 10-15
269  if ((i < 10) or (i > 15))
270  continue;
271  if ((mymap.at(i).first <= roll) and (roll <= mymap.at(i).second))
272  return true;
273  }
274  return false;
275 }

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 246 of file CSCGEMMotherboard.h.

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

References funct::abs(), DEFAULT_MATCHING_VALUE, dumpMFGeometry_cfg::delta, CSCGEMMotherboardLUT::get_csc_wg_to_gem_roll(), getBX(), CSCALCTDigi::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 295 of file CSCGEMMotherboard.h.

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

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 349 of file CSCGEMMotherboard.h.

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

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 363 of file CSCGEMMotherboard.h.

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

References mps_fire::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 333 of file CSCGEMMotherboard.h.

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

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

◆ maxPads()

int CSCGEMMotherboard::maxPads ( ) const
protected

Definition at line 315 of file CSCGEMMotherboard.cc.

315 { 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 317 of file CSCGEMMotherboard.cc.

317 { 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 340 of file CSCGEMMotherboard.cc.

340  {
341  LogTrace("CSCGEMMotherboard") << "------------------------------------------------------------------------"
342  << std::endl;
343  LogTrace("CSCGEMMotherboard") << "* GEM trigger coincidence pads: " << std::endl;
344 
345  for (int bx = bx_start; bx <= bx_stop; bx++) {
346  const auto& in_pads = coPads_[bx];
347  LogTrace("CSCGEMMotherboard") << "N(copads) BX " << bx << " : " << in_pads.size() << std::endl;
348 
349  for (const auto& pad : in_pads) {
350  LogTrace("CSCGEMMotherboard") << "\tdetId " << GEMDetId(pad.first) << ", pad = " << pad.second;
351  const auto& roll_id(GEMDetId(pad.first));
352 
353  if (part == CSCPart::ME11 and isPadInOverlap(GEMDetId(roll_id).roll()))
354  LogTrace("CSCGEMMotherboard") << " (in overlap)" << std::endl;
355  else
356  LogTrace("CSCGEMMotherboard") << std::endl;
357  }
358  }
359 }

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 319 of file CSCGEMMotherboard.cc.

319  {
320  LogTrace("CSCGEMMotherboard") << "------------------------------------------------------------------------"
321  << std::endl;
322  LogTrace("CSCGEMMotherboard") << "* GEM trigger pads: " << std::endl;
323 
324  for (int bx = bx_start; bx <= bx_stop; bx++) {
325  const auto& in_pads = pads_[bx];
326  LogTrace("CSCGEMMotherboard") << "N(pads) BX " << bx << " : " << in_pads.size() << std::endl;
327 
328  for (const auto& pad : in_pads) {
329  LogTrace("CSCGEMMotherboard") << "\tdetId " << GEMDetId(pad.first) << ", pad = " << pad.second;
330  const auto& roll_id(GEMDetId(pad.first));
331 
332  if (part == CSCPart::ME11 and isPadInOverlap(GEMDetId(roll_id).roll()))
333  LogTrace("CSCGEMMotherboard") << " (in overlap)" << std::endl;
334  else
335  LogTrace("CSCGEMMotherboard") << std::endl;
336  }
337  }
338 }

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

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

◆ processGEMClusters()

void CSCGEMMotherboard::processGEMClusters ( const GEMPadDigiClusterCollection *  pads)
protected

Definition at line 41 of file CSCGEMMotherboard.cc.

41  {
42  std::unique_ptr<GEMPadDigiCollection> gemPads(new GEMPadDigiCollection());
43  coPadProcessor->declusterize(gemClusters, *gemPads);
44 
45  gemCoPadV = coPadProcessor->run(gemPads.get());
46 
47  processGEMPads(gemPads.get());
48  processGEMCoPads();
49 }

References coPadProcessor, gemCoPadV, processGEMCoPads(), and processGEMPads().

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

◆ processGEMCoPads()

void CSCGEMMotherboard::processGEMCoPads ( )
protected

Definition at line 77 of file CSCGEMMotherboard.cc.

77  {
78  coPads_.clear();
79  for (const auto& copad : gemCoPadV) {
80  GEMDetId detId(theRegion, 1, theStation, 0, theChamber, 0);
81 
82  // ignore 16-partition GE2/1 pads
83  if (detId.isGE21() and copad.first().nPartitions() == GEMPadDigi::GE21SplitStrip)
84  continue;
85 
86  // only consider matches with same BX
87  coPads_[CSCConstants::LCT_CENTRAL_BX + copad.bx(1)].emplace_back(detId.rawId(), copad);
88  }
89 }

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

Referenced by processGEMClusters().

◆ processGEMPads()

void CSCGEMMotherboard::processGEMPads ( const GEMPadDigiCollection *  pads)
protected

Definition at line 51 of file CSCGEMMotherboard.cc.

51  {
52  pads_.clear();
53  const auto& superChamber(gem_g->superChamber(gemId));
54  for (const auto& ch : superChamber->chambers()) {
55  for (const auto& roll : ch->etaPartitions()) {
56  GEMDetId roll_id(roll->id());
57  auto pads_in_det = gemPads->get(roll_id);
58  for (auto pad = pads_in_det.first; pad != pads_in_det.second; ++pad) {
59  // ignore 16-partition GE2/1 pads
60  if (roll->isGE21() and pad->nPartitions() == GEMPadDigi::GE21SplitStrip)
61  continue;
62 
63  // ignore invalid pads
64  if (!pad->isValid())
65  continue;
66 
67  const int bx_shifted(CSCConstants::LCT_CENTRAL_BX + pad->bx());
68  // consider matches with BX difference +1/0/-1
69  for (int bx = bx_shifted - maxDeltaBXPad_; bx <= bx_shifted + maxDeltaBXPad_; ++bx) {
70  pads_[bx].emplace_back(roll_id.rawId(), *pad);
71  }
72  }
73  }
74  }
75 }

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

Referenced by processGEMClusters().

◆ readoutLCTs()

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

Definition at line 262 of file CSCUpgradeMotherboard.cc.

262  {
263  std::vector<CSCCorrelatedLCTDigi> result;
264  allLCTs.getMatched(result);
265  if (tmb_cross_bx_algo == 2)
266  CSCUpgradeMotherboard::sortLCTs(result, CSCUpgradeMotherboard::sortLCTsByQuality);
267 
268  // do a final check on the LCTs in readout
269  qualityControl_->checkMultiplicityBX(result);
270  for (const auto& lct : result) {
271  qualityControl_->checkValid(lct);
272  }
273 
274  return result;
275 }

◆ run() [1/2]

void CSCUpgradeMotherboard::run
override

Definition at line 71 of file CSCUpgradeMotherboard.cc.

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

◆ run() [2/2]

virtual void CSCGEMMotherboard::run ( const CSCWireDigiCollection *  wiredc,
const CSCComparatorDigiCollection *  compdc,
const GEMPadDigiClusterCollection *  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 62 of file CSCGEMMotherboard.h.

62 { gem_g = g; }

References g, and gem_g.

Referenced by CSCTriggerPrimitivesBuilder::build().

◆ setupGeometry()

void CSCGEMMotherboard::setupGeometry ( )
protected

Definition at line 310 of file CSCGEMMotherboard.cc.

310  {
311  CSCUpgradeMotherboard::setupGeometry();
312  generator_->setGEMGeometry(gem_g);
313 }

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 59 of file CSCGEMMotherboard.h.

Referenced by CSCTriggerPrimitivesBuilder::build(), clear(), CSCGEMMotherboard(), and processGEMClusters().

◆ coPads_

GEMCoPadDigiIdsBX CSCGEMMotherboard::coPads_
protected

Definition at line 220 of file CSCGEMMotherboard.h.

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

◆ gem_g

const GEMGeometry* CSCGEMMotherboard::gem_g
protected

Definition at line 213 of file CSCGEMMotherboard.h.

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

◆ gemCoPadV

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

Definition at line 216 of file CSCGEMMotherboard.h.

Referenced by clear(), processGEMClusters(), and processGEMCoPads().

◆ gemGeometryAvailable

bool CSCGEMMotherboard::gemGeometryAvailable
protected

Definition at line 214 of file CSCGEMMotherboard.h.

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

◆ gemId

unsigned CSCGEMMotherboard::gemId
protected

Chamber id (trigger-type labels).

Definition at line 209 of file CSCGEMMotherboard.h.

Referenced by CSCGEMMotherboard(), maxPads(), maxRolls(), and processGEMPads().

◆ maxDeltaBXCoPad_

int CSCGEMMotherboard::maxDeltaBXCoPad_
protected

Definition at line 224 of file CSCGEMMotherboard.h.

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

◆ maxDeltaBXPad_

int CSCGEMMotherboard::maxDeltaBXPad_
protected

Definition at line 223 of file CSCGEMMotherboard.h.

Referenced by getMaxDeltaBX(), and processGEMPads().

◆ maxDeltaPadL1_

int CSCGEMMotherboard::maxDeltaPadL1_
protected

Definition at line 225 of file CSCGEMMotherboard.h.

Referenced by CSCGEMMotherboard(), and matchingPads().

◆ maxDeltaPadL2_

int CSCGEMMotherboard::maxDeltaPadL2_
protected

Definition at line 226 of file CSCGEMMotherboard.h.

Referenced by CSCGEMMotherboard().

◆ pads_

GEMPadDigiIdsBX CSCGEMMotherboard::pads_
protected

Definition at line 219 of file CSCGEMMotherboard.h.

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

◆ promoteALCTGEMpattern_

bool CSCGEMMotherboard::promoteALCTGEMpattern_
protected

Definition at line 229 of file CSCGEMMotherboard.h.

Referenced by constructLCTsGEM().

◆ promoteALCTGEMquality_

bool CSCGEMMotherboard::promoteALCTGEMquality_
protected

Definition at line 231 of file CSCGEMMotherboard.h.

Referenced by constructLCTsGEM().

◆ promoteCLCTGEMquality_

bool CSCGEMMotherboard::promoteCLCTGEMquality_
protected

Definition at line 232 of file CSCGEMMotherboard.h.

Referenced by constructLCTsGEM().

CSCMotherboard::LCT_Quality::NO_CLCT
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:67
CSCALCTDigi::getBX
uint16_t getBX() const
return BX - five low bits of BXN counter tagged by the ALCT
Definition: CSCALCTDigi.h:73
CSCGEMMotherboard::isPadInOverlap
bool isPadInOverlap(int roll) const
Definition: CSCGEMMotherboard.cc:264
CSCMotherboard::qualityControl_
std::unique_ptr< LCTQualityControl > qualityControl_
Definition: CSCMotherboard.h:128
ME11
Definition: CSCUpgradeMotherboardLUT.h:12
mps_fire.i
i
Definition: mps_fire.py:428
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:151
GEMPadDigi
Definition: GEMPadDigi.h:17
CSCBaseboard::theRegion
unsigned theRegion
Definition: CSCBaseboard.h:47
CSCGEMMotherboard::maxDeltaPadL2_
int maxDeltaPadL2_
Definition: CSCGEMMotherboard.h:226
CSCCorrelatedLCTDigi::ALCT2GEM
Definition: CSCCorrelatedLCTDigi.h:194
CSCBaseboard::cscGeometry_
const CSCGeometry * cscGeometry_
Definition: CSCBaseboard.h:66
CSCMotherboard::secondLCT
CSCCorrelatedLCTDigi secondLCT[CSCConstants::MAX_LCT_TBINS]
Definition: CSCMotherboard.h:90
CSCConstants::MAX_ALCT_TBINS
Definition: CSCConstants.h:64
CSCMotherboard::useHighMultiplicityBits_
bool useHighMultiplicityBits_
Definition: CSCMotherboard.h:119
CSCMotherboard::LCT_Quality::HQ_CATHODE_MARGINAL_ANODE
CSCGEMMotherboard::findQualityGEMv1
CSCMotherboard::LCT_Quality findQualityGEMv1(const CSCALCTDigi &, const CSCCLCTDigi &, int gemlayer) const
Definition: CSCGEMMotherboard.cc:361
CSCBaseboard::tmbParams_
edm::ParameterSet tmbParams_
Definition: CSCBaseboard.h:73
CSCMotherboard::LCT_Quality::NO_ALCT
relativeConstraints.station
station
Definition: relativeConstraints.py:67
CSCMotherboard::alctProc
std::unique_ptr< CSCAnodeLCTProcessor > alctProc
Definition: CSCMotherboard.h:75
CSCGEMMotherboard::ALCTCLCT_1GEM
Definition: CSCGEMMotherboard.h:192
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
CSCMotherboard::LCT_Quality::CLCT_LAYER_TRIGGER
CSCUpgradeMotherboard::clear
void clear()
Definition: CSCUpgradeMotherboard.cc:332
CSCGEMMotherboard::findQualityGEMv2
LCT_QualityRun3 findQualityGEMv2(const CSCALCTDigi &, const CSCCLCTDigi &, int gemlayer) const
Definition: CSCGEMMotherboard.cc:453
CSCCorrelatedLCTDigi::setQuality
void setQuality(const uint16_t q)
set quality code
Definition: CSCCorrelatedLCTDigi.h:148
l1GtPatternGenerator_cfi.bx
bx
Definition: l1GtPatternGenerator_cfi.py:18
CSCBaseboard::theCSCName_
std::string theCSCName_
Definition: CSCBaseboard.h:82
CSCGEMMotherboard::ALCTCLCT_2GEM
Definition: CSCGEMMotherboard.h:193
CSCUpgradeMotherboard::intersection
void intersection(const S &d1, const S &d2, S &result) const
Definition: CSCUpgradeMotherboard.h:127
CSCConstants::LCT_CENTRAL_BX
Definition: CSCConstants.h:79
CSCGEMMotherboard::INVALID
Definition: CSCGEMMotherboard.h:188
cms::cuda::assert
assert(be >=bs)
GEMPadDigiCollection
MuonDigiCollection< GEMDetId, GEMPadDigi > GEMPadDigiCollection
Definition: GEMPadDigiCollection.h:13
CSCGEMMotherboard::constructLCTsGEM
CSCCorrelatedLCTDigi constructLCTsGEM(const CSCALCTDigi &alct, const GEMCoPadDigi &gem, int i) const
Definition: CSCGEMMotherboard.cc:91
edm::second
U second(std::pair< T, U > const &p)
Definition: ParameterSet.cc:222
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:145
CSCGEMMotherboard::promoteALCTGEMquality_
bool promoteALCTGEMquality_
Definition: CSCGEMMotherboard.h:231
CSCGEMMotherboard::coPads_
GEMCoPadDigiIdsBX coPads_
Definition: CSCGEMMotherboard.h:220
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
CSCConstants::ALCT_CLCT_OFFSET
Definition: CSCConstants.h:81
makeMuonMisalignmentScenario.endcap
endcap
Definition: makeMuonMisalignmentScenario.py:320
CSCCLCTDigi::getKeyStrip
uint16_t getKeyStrip(const uint16_t n=2) const
Definition: CSCCLCTDigi.cc:133
CSCCorrelatedLCTDigi::setBX0
void setBX0(const uint16_t b)
set bx0
Definition: CSCCorrelatedLCTDigi.h:172
dqmdumpme.first
first
Definition: dqmdumpme.py:55
edm::LogWarning
Log< level::Warning, false > LogWarning
Definition: MessageLogger.h:122
CSCCLCTDigi
Definition: CSCCLCTDigi.h:17
GEMPadDigi::GE21SplitStrip
Definition: GEMPadDigi.h:22
CSCCorrelatedLCTDigi::CLCT2GEM
Definition: CSCCorrelatedLCTDigi.h:195
CSCCorrelatedLCTDigi::setHMT
void setHMT(const uint16_t h)
set high-multiplicity bits
Definition: CSCCorrelatedLCTDigi.cc:160
CSCCorrelatedLCTDigi::setCLCT
void setCLCT(const CSCCLCTDigi &clct)
Definition: CSCCorrelatedLCTDigi.h:205
CSCMotherboard::clctV
std::vector< CSCCLCTDigi > clctV
Definition: CSCMotherboard.h:84
CSCMotherboard::clctProc
std::unique_ptr< CSCCathodeLCTProcessor > clctProc
Definition: CSCMotherboard.h:78
CSCMotherboard::LCT_Quality::HQ_PATTERN_10
DetId
Definition: DetId.h:17
CSCCorrelatedLCTDigi::setALCT
void setALCT(const CSCALCTDigi &alct)
Definition: CSCCorrelatedLCTDigi.h:204
CSCALCTDigi::getKeyWG
uint16_t getKeyWG() const
return key wire group
Definition: CSCALCTDigi.h:67
CSCCLCTDigi::getQuality
uint16_t getQuality() const
return quality of a pattern (number of layers hit!)
Definition: CSCCLCTDigi.h:54
CSCCorrelatedLCTDigi::setStrip
void setStrip(const uint16_t s)
set strip
Definition: CSCCorrelatedLCTDigi.h:154
LCTContainer::getMatched
void getMatched(std::vector< CSCCorrelatedLCTDigi > &) const
Definition: LCTContainer.cc:23
CSCCLCTDigi::getBend
uint16_t getBend() const
Definition: CSCCLCTDigi.h:89
part
part
Definition: HCALResponse.h:20
CSCMotherboard::alctV
std::vector< CSCALCTDigi > alctV
Definition: CSCMotherboard.h:83
CSCConstants::MAX_LCTS_PER_CSC
Definition: CSCConstants.h:75
CSCUpgradeMotherboard::readoutLCTs
std::vector< CSCCorrelatedLCTDigi > readoutLCTs() const override
Definition: CSCUpgradeMotherboard.cc:262
CSCGEMMotherboard::correlateLCTsGEM
void correlateLCTsGEM(const T &best, const T &second, const GEMCoPadDigiIds &coPads, CSCCorrelatedLCTDigi &lct1, CSCCorrelatedLCTDigi &lct2) const
Definition: CSCGEMMotherboard.h:465
CSCUpgradeMotherboard::getCSCPart
enum CSCPart getCSCPart(int keystrip) const
Definition: CSCUpgradeMotherboard.cc:279
CSCMotherboard::LCT_Quality::INVALID
CSCUpgradeMotherboard::setupGeometry
void setupGeometry()
Definition: CSCUpgradeMotherboard.cc:322
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
mps_fire.end
end
Definition: mps_fire.py:242
CSCCorrelatedLCTDigi::setMPCLink
void setMPCLink(const uint16_t &link)
Set mpc link number after MPC sorting.
Definition: CSCCorrelatedLCTDigi.h:135
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:65
CSCGEMMotherboard::gemId
unsigned gemId
Definition: CSCGEMMotherboard.h:209
CSCGEMMotherboard::promoteCLCTGEMquality_
bool promoteCLCTGEMquality_
Definition: CSCGEMMotherboard.h:232
CSCMotherboard::LCT_Quality::HQ_PATTERN_4_5
CSCGEMMotherboard::ALCTCLCT
Definition: CSCGEMMotherboard.h:191
CSCALCTDigi::getQuality
uint16_t getQuality() const
return quality of a pattern
Definition: CSCALCTDigi.h:46
CSCCorrelatedLCTDigi::ALCTCLCTGEM
Definition: CSCCorrelatedLCTDigi.h:192
CSCGEMMotherboard::coPadProcessor
std::unique_ptr< GEMCoPadProcessor > coPadProcessor
Definition: CSCGEMMotherboard.h:59
CSCGEMMotherboard::gemCoPadV
std::vector< GEMCoPadDigi > gemCoPadV
Definition: CSCGEMMotherboard.h:216
CSCGEMMotherboard::promoteALCTGEMpattern_
bool promoteALCTGEMpattern_
Definition: CSCGEMMotherboard.h:229
CSCCorrelatedLCTDigi::setBend
void setBend(const uint16_t b)
set bend
Definition: CSCCorrelatedLCTDigi.h:166
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:222
CSCCorrelatedLCTDigi::setGEM1
void setGEM1(const GEMPadDigi &gem)
Definition: CSCCorrelatedLCTDigi.h:206
CSCCorrelatedLCTDigi::ALCTCLCT2GEM
Definition: CSCCorrelatedLCTDigi.h:193
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:223
CSCCorrelatedLCTDigi::setBX
void setBX(const uint16_t b)
set bx
Definition: CSCCorrelatedLCTDigi.h:169
CSCCorrelatedLCTDigi::setTrknmb
void setTrknmb(const uint16_t number)
Set track number (1,2) after sorting LCTs.
Definition: CSCCorrelatedLCTDigi.h:132
edm::ParameterSet
Definition: ParameterSet.h:47
ME1A
Definition: CSCUpgradeMotherboardLUT.h:12
LCTContainer::clear
void clear()
Definition: LCTContainer.cc:31
CSCGEMMotherboard::CLCT_2GEM
Definition: CSCGEMMotherboard.h:189
CSCUpgradeMotherboard::debug_matching
bool debug_matching
Definition: CSCUpgradeMotherboard.h:115
CSCGEMMotherboard::isGEMDetId
bool isGEMDetId(unsigned int) const
Definition: CSCGEMMotherboard.cc:277
CSCCorrelatedLCTDigi::setPattern
void setPattern(const uint16_t p)
set pattern
Definition: CSCCorrelatedLCTDigi.cc:142
CSCGEMMotherboard::getRoll
int getRoll(const GEMPadDigiId &p) const
Definition: CSCGEMMotherboard.cc:285
GEMDetId::roll
constexpr int roll() const
Definition: GEMDetId.h:191
CSCMotherboard::LCT_Quality::HQ_PATTERN_8_9
CSCMotherboard::LCT_Quality::MARGINAL_ANODE_CATHODE
CSCCorrelatedLCTDigi::setGEM2
void setGEM2(const GEMPadDigi &gem)
Definition: CSCCorrelatedLCTDigi.h:207
CSCConstants::MAX_HALF_STRIP_ME1B
Definition: CSCConstants.h:39
dumpMFGeometry_cfg.delta
delta
Definition: dumpMFGeometry_cfg.py:25
GEMDetId
Definition: GEMDetId.h:18
CSCCorrelatedLCTDigi::setCSCID
void setCSCID(const uint16_t c)
set cscID
Definition: CSCCorrelatedLCTDigi.h:178
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:48
CSCUpgradeMotherboard::sortLCTs
void sortLCTs(std::vector< CSCCorrelatedLCTDigi > &lcts, bool(*sorter)(const CSCCorrelatedLCTDigi &, const CSCCorrelatedLCTDigi &)) const
Definition: CSCUpgradeMotherboard.cc:315
topSingleLeptonDQM_PU_cfi.pattern
pattern
Definition: topSingleLeptonDQM_PU_cfi.py:39
CSCUpgradeMotherboard::pref
int pref[CSCConstants::MAX_LCT_TBINS]
Definition: CSCUpgradeMotherboard.h:103
CSCGEMMotherboard::ALCT_2GEM
Definition: CSCGEMMotherboard.h:190
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:289
edm::LogError
Log< level::Error, false > LogError
Definition: MessageLogger.h:123
CSCBaseboard::theChamber
unsigned theChamber
Definition: CSCBaseboard.h:49
CSCCorrelatedLCTDigi::setSyncErr
void setSyncErr(const uint16_t s)
set syncErr
Definition: CSCCorrelatedLCTDigi.h:175
CSCUpgradeMotherboard::CSCUpgradeMotherboard
CSCUpgradeMotherboard()
Definition: CSCUpgradeMotherboard.cc:53
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
CSCGEMMotherboard::processGEMCoPads
void processGEMCoPads()
Definition: CSCGEMMotherboard.cc:77
CSCMotherboard::encodeHighMultiplicityBits
void encodeHighMultiplicityBits(unsigned alctBits)
Definition: CSCMotherboard.cc:709
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:307
CSCMotherboard::getBXShiftedCLCT
CSCCLCTDigi getBXShiftedCLCT(const CSCCLCTDigi &) const
Definition: CSCMotherboard.cc:703
GEMEtaPartition::npads
int npads() const
number of GEM-CSC trigger readout pads in partition
Definition: GEMEtaPartition.cc:43
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:223
CSCGEMMotherboard::processGEMPads
void processGEMPads(const GEMPadDigiCollection *pads)
Definition: CSCGEMMotherboard.cc:51
qcdUeDQM_cfi.quality
quality
Definition: qcdUeDQM_cfi.py:31
CSCALCTDigi::getAccelerator
uint16_t getAccelerator() const
Definition: CSCALCTDigi.h:53
CSCMotherboard::LCT_Quality::HQ_PATTERN_2_3
trklet::bend
double bend(double r, double rinv, double stripPitch)
Definition: Util.h:160
T
long double T
Definition: Basic3DVectorLD.h:48
CSCMotherboard::LCT_Quality::HQ_ACCEL_ALCT
CSCMotherboard::highMultiplicityBits_
unsigned int highMultiplicityBits_
Definition: CSCMotherboard.h:118
CSCGEMMotherboard::maxRolls
int maxRolls() const
Definition: CSCGEMMotherboard.cc:317
CSCALCTDigi
Definition: CSCALCTDigi.h:17
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:63
relativeConstraints.chamber
chamber
Definition: relativeConstraints.py:53
or
The Signals That Services Can Subscribe To This is based on ActivityRegistry and is current per Services can connect to the signals distributed by the ActivityRegistry in order to monitor the activity of the application Each possible callback has some defined which we here list in angle e< void, edm::EventID const &, edm::Timestamp const & > We also list in braces which AR_WATCH_USING_METHOD_ is used for those or
Definition: Activities.doc:12
CSCGEMMotherboard::clear
void clear()
Definition: CSCGEMMotherboard.cc:33
CSCBaseboard::theTrigChamber
const unsigned theTrigChamber
Definition: CSCBaseboard.h:46
GEMDetId::minRollId
static constexpr int32_t minRollId
Definition: GEMDetId.h:33
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
Definition: ParameterSet.h:303
CSCMotherboard::encodePattern
unsigned int encodePattern(const int clctPattern) const
Definition: CSCMotherboard.cc:540
CSCGEMMotherboard::DEFAULT_MATCHING_VALUE
Definition: CSCGEMMotherboard.h:31
CSCGEMMotherboard::pads_
GEMPadDigiIdsBX pads_
Definition: CSCGEMMotherboard.h:219
CSCGEMMotherboard::maxDeltaBXCoPad_
int maxDeltaBXCoPad_
Definition: CSCGEMMotherboard.h:224
CSCBaseboard::cscId_
CSCDetId cscId_
Definition: CSCBaseboard.h:58
S
Definition: CSCDBL1TPParametersExtended.h:16
CSCALCTDigi::isValid
bool isValid() const
check ALCT validity (1 - valid ALCT)
Definition: CSCALCTDigi.h:40
CSCGEMMotherboard::getPad
float getPad(const GEMPadDigi &) const
Definition: CSCGEMMotherboard.cc:294
GEMDetId::station
constexpr int station() const
Definition: GEMDetId.h:176
CSCMotherboard::LCT_Quality::HQ_ANODE_MARGINAL_CATHODE
CSCGEMMotherboard::maxPads
int maxPads() const
Definition: CSCGEMMotherboard.cc:315
CSCCorrelatedLCTDigi::setRun3
void setRun3(const bool isRun3)
Definition: CSCCorrelatedLCTDigi.cc:162
mps_fire.result
result
Definition: mps_fire.py:311
DetId::Muon
Definition: DetId.h:26
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
RunInfoPI::valid
Definition: RunInfoPayloadInspectoHelper.h:16
LogTrace
#define LogTrace(id)
Definition: MessageLogger.h:224
CSCMotherboard::match_trig_enable
unsigned int match_trig_enable
Definition: CSCMotherboard.h:98
GEMPadDigi::isValid
bool isValid() const
Definition: GEMPadDigi.cc:26
GEMGeometry::superChamber
const GEMSuperChamber * superChamber(GEMDetId id) const
Definition: GEMGeometry.cc:69
CSCMotherboard::getBXShiftedALCT
CSCALCTDigi getBXShiftedALCT(const CSCALCTDigi &) const
Definition: CSCMotherboard.cc:697
CSCCLCTDigi::getPattern
uint16_t getPattern() const
return pattern
Definition: CSCCLCTDigi.cc:88
CSCUpgradeMotherboard::generator_
std::unique_ptr< CSCUpgradeMotherboardLUTGenerator > generator_
Definition: CSCUpgradeMotherboard.h:100
CSCCorrelatedLCTDigi::setType
void setType(int type)
Definition: CSCCorrelatedLCTDigi.h:202
CSCCorrelatedLCTDigi::isValid
bool isValid() const
return valid pattern bit
Definition: CSCCorrelatedLCTDigi.h:53
CSCGEMMotherboard::getBX
int getBX(const GEMPadDigi &p) const
Definition: CSCGEMMotherboard.cc:281
CSCGEMMotherboard::maxDeltaPadL1_
int maxDeltaPadL1_
Definition: CSCGEMMotherboard.h:225
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:213
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
CSCBaseboard::runCCLUT_
bool runCCLUT_
Definition: CSCBaseboard.h:103
GEMCoPadDigi::isValid
bool isValid() const
Definition: GEMCoPadDigi.cc:18
ME1B
Definition: CSCUpgradeMotherboardLUT.h:12
CSCMotherboard::LCT_Quality::HQ_PATTERN_6_7
CSCBaseboard::infoV
int infoV
Definition: CSCBaseboard.h:64
Generated for CMSSW Reference Manual by doxygen 1.8.16