CSCMotherboard Class Reference

#include <CSCMotherboard.h>

Inheritance diagram for CSCMotherboard:

Public Member Functions
void	clear ()
	CSCMotherboard (unsigned endcap, unsigned station, unsigned sector, unsigned subsector, unsigned chamber, const edm::ParameterSet &conf)
virtual std::vector< CSCCorrelatedLCTDigi >	readoutLCTs () const
CSCShowerDigi	readoutShower () const
void	run (const CSCWireDigiCollection *wiredc, const CSCComparatorDigiCollection *compdc)
void	selectLCTs ()
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< CSCAnodeLCTProcessor >	alctProc
std::unique_ptr< CSCCathodeLCTProcessor >	clctProc

Protected Member Functions
void	checkConfigParameters ()
void	constructLCTs (const CSCALCTDigi &aLCT, const CSCCLCTDigi &cLCT, int type, int trknmb, CSCCorrelatedLCTDigi &lct) const
void	copyValidToInValid (CSCALCTDigi &, CSCALCTDigi &, CSCCLCTDigi &, CSCCLCTDigi &) const
void	correlateLCTs (const CSCALCTDigi &bestALCT, const CSCALCTDigi &secondALCT, const CSCCLCTDigi &bestCLCT, const CSCCLCTDigi &secondCLCT, CSCCorrelatedLCTDigi &bLCT, CSCCorrelatedLCTDigi &sLCT, int type) const
void	dumpConfigParams () const
void	encodeHighMultiplicityBits ()
unsigned int	encodePattern (const int clctPattern) 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
unsigned int	alct_trig_enable
std::vector< CSCALCTDigi >	alctV
LCTContainer	allLCTs_
unsigned int	clct_trig_enable
std::vector< CSCCLCTDigi >	clctV
std::unique_ptr< CSCALCTCrossCLCT >	cscOverlap_
bool	drop_used_clcts
int	early_tbins
std::vector< CSCCorrelatedLCTDigi >	lctV
bool	match_earliest_clct_only_
unsigned int	match_trig_enable
unsigned int	match_trig_window_size
unsigned int	mpc_block_me1a
std::vector< int >	preferred_bx_match_
std::unique_ptr< LCTQualityAssignment >	qualityAssignment_
std::unique_ptr< LCTQualityControl >	qualityControl_
bool	readout_earliest_2
CSCShowerDigi	shower_
unsigned	showerSource_
unsigned int	tmb_l1a_window_size
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_
edm::ParameterSet	showerParams_
unsigned	theChamber
std::string	theCSCName_
const unsigned	theEndcap
int	theRegion
unsigned	theRing
const unsigned	theSector
const unsigned	theStation
const unsigned	theSubsector
const unsigned	theTrigChamber
edm::ParameterSet	tmbParams_

Static Protected Attributes
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

Correlates anode and cathode LCTs from the same chamber.

When the Trigger MotherBoard (TMB) is instantiated it instantiates an ALCT and CLCT board. The MotherBoard takes up to two LCTs from each anode and cathode LCT card and combines them into a single Correlated LCT. The output is up to two Correlated LCTs.

It can be run in either a test mode, where the arguments are a collection of wire times and arrays of halfstrip times, or for general use, with wire digi and comparator digi collections as arguments. In the latter mode, the wire & strip info is passed on the LCTProcessors, where it is decoded and converted into a convenient form. After running the anode and cathode LCTProcessors, TMB correlates the anode and cathode LCTs. At present, it simply matches the best CLCT with the best ALCT; perhaps a better algorithm will be determined in the future. The MotherBoard then determines a few more numbers (such as quality and pattern) from the ALCT and CLCT information, and constructs two correlated LCT "digis".

Author

Benn Tannenbaum 28 August 1999 benn@.nosp@m.phys.nosp@m.ics.u.nosp@m.cla..nosp@m.edu

Based on code by Nick Wisniewski (nw@it.nosp@m.s.ca.nosp@m.ltech.nosp@m..edu) and a framework by Darin Acosta (acost.nosp@m.a@ph.nosp@m.ys.uf.nosp@m.l.ed.nosp@m.u).

Numerous later improvements by Jason Mumford and Slava Valuev (see cvs in ORCA). Porting from ORCA by S. Valuev (Slava.nosp@m..Val.nosp@m.uev@c.nosp@m.ern..nosp@m.ch), May 2006.

Extended for Run-3 and Phase-2 by Vadim Khotilovich, Tao Huang and Sven Dildick

Definition at line 47 of file CSCMotherboard.h.

Constructor & Destructor Documentation

CSCMotherboard()

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

Normal constructor.

Definition at line 13 of file CSCMotherboard.cc.

    : CSCBaseboard(endcap, station, sector, subsector, chamber, conf) {
  // Normal constructor.  -JM
  // Pass ALCT, CLCT, and common parameters on to ALCT and CLCT processors.
  static std::atomic<bool> config_dumped{false};
 
  mpc_block_me1a = tmbParams_.getParameter<unsigned int>("mpcBlockMe1a");
  alct_trig_enable = tmbParams_.getParameter<unsigned int>("alctTrigEnable");
  clct_trig_enable = tmbParams_.getParameter<unsigned int>("clctTrigEnable");
  match_trig_enable = tmbParams_.getParameter<unsigned int>("matchTrigEnable");
  match_trig_window_size = tmbParams_.getParameter<unsigned int>("matchTrigWindowSize");
  tmb_l1a_window_size =  // Common to CLCT and TMB
      tmbParams_.getParameter<unsigned int>("tmbL1aWindowSize");
 
  // configuration handle for number of early time bins
  early_tbins = tmbParams_.getParameter<int>("tmbEarlyTbins");
 
  // whether to not reuse CLCTs that were used by previous matching ALCTs
  drop_used_clcts = tmbParams_.getParameter<bool>("tmbDropUsedClcts");
 
  // whether to readout only the earliest two LCTs in readout window
  readout_earliest_2 = tmbParams_.getParameter<bool>("tmbReadoutEarliest2");
 
  match_earliest_clct_only_ = tmbParams_.getParameter<bool>("matchEarliestClctOnly");
 
  infoV = tmbParams_.getParameter<int>("verbosity");
 
  alctProc = std::make_unique<CSCAnodeLCTProcessor>(endcap, station, sector, subsector, chamber, conf);
  clctProc = std::make_unique<CSCCathodeLCTProcessor>(endcap, station, sector, subsector, chamber, conf);
 
  // Check and print configuration parameters.
  checkConfigParameters();
  if (infoV > 0 && !config_dumped) {
    dumpConfigParams();
    config_dumped = true;
  }
 
  allLCTs_.setMatchTrigWindowSize(match_trig_window_size);
 
  // get the preferred CLCT BX match array
  preferred_bx_match_ = tmbParams_.getParameter<std::vector<int> >("preferredBxMatch");
 
  // quality assignment
  qualityAssignment_ = std::make_unique<LCTQualityAssignment>(endcap, station, sector, subsector, chamber, conf);
 
  // quality control of stubs
  qualityControl_ = std::make_unique<LCTQualityControl>(endcap, station, sector, subsector, chamber, conf);
 
  // shower-trigger source
  showerSource_ = showerParams_.getParameter<unsigned>("source");
 
  // enable the upgrade processors for ring 1 stations
  if (runPhase2_ and theRing == 1) {
    clctProc = std::make_unique<CSCUpgradeCathodeLCTProcessor>(endcap, station, sector, subsector, chamber, conf);
    if (enableAlctPhase2_) {
      alctProc = std::make_unique<CSCUpgradeAnodeLCTProcessor>(endcap, station, sector, subsector, chamber, conf);
    }
  }
 
  // set up helper class to check if ALCT and CLCT cross
  const bool ignoreAlctCrossClct = tmbParams_.getParameter<bool>("ignoreAlctCrossClct");
  cscOverlap_ = std::make_unique<CSCALCTCrossCLCT>(endcap, station, theRing, ignoreAlctCrossClct, conf);
}

References alct_trig_enable, alctProc, allLCTs_, relativeConstraints::chamber, checkConfigParameters(), clct_trig_enable, clctProc, cscOverlap_, drop_used_clcts, dumpConfigParams(), early_tbins, CSCBaseboard::enableAlctPhase2_, makeMuonMisalignmentScenario::endcap, edm::ParameterSet::getParameter(), tmbParams::ignoreAlctCrossClct, CSCBaseboard::infoV, match_earliest_clct_only_, match_trig_enable, match_trig_window_size, mpc_block_me1a, preferred_bx_match_, qualityAssignment_, qualityControl_, readout_earliest_2, CSCBaseboard::runPhase2_, LCTContainer::setMatchTrigWindowSize(), CSCBaseboard::showerParams_, showerSource_, relativeConstraints::station, CSCBaseboard::theRing, tmb_l1a_window_size, and CSCBaseboard::tmbParams_.

~CSCMotherboard()

CSCMotherboard::~CSCMotherboard ( )

overridedefault

Default destructor.

Member Function Documentation

checkConfigParameters()

void CSCMotherboard::checkConfigParameters ( )

protected

Make sure that the parameter values are within the allowed range.

Definition at line 498 of file CSCMotherboard.cc.

                                           {
  // Make sure that the parameter values are within the allowed range.
 
  // Max expected values.
  static const unsigned int max_mpc_block_me1a = 1 << 1;
  static const unsigned int max_alct_trig_enable = 1 << 1;
  static const unsigned int max_clct_trig_enable = 1 << 1;
  static const unsigned int max_match_trig_enable = 1 << 1;
  static const unsigned int max_match_trig_window_size = 1 << 4;
  static const unsigned int max_tmb_l1a_window_size = 1 << 4;
 
  // Checks.
  CSCBaseboard::checkConfigParameters(mpc_block_me1a, max_mpc_block_me1a, def_mpc_block_me1a, "mpc_block_me1a");
  CSCBaseboard::checkConfigParameters(alct_trig_enable, max_alct_trig_enable, def_alct_trig_enable, "alct_trig_enable");
  CSCBaseboard::checkConfigParameters(clct_trig_enable, max_clct_trig_enable, def_clct_trig_enable, "clct_trig_enable");
  CSCBaseboard::checkConfigParameters(
      match_trig_enable, max_match_trig_enable, def_match_trig_enable, "match_trig_enable");
  CSCBaseboard::checkConfigParameters(
      match_trig_window_size, max_match_trig_window_size, def_match_trig_window_size, "match_trig_window_size");
  CSCBaseboard::checkConfigParameters(
      tmb_l1a_window_size, max_tmb_l1a_window_size, def_tmb_l1a_window_size, "tmb_l1a_window_size");
}

References alct_trig_enable, CSCBaseboard::checkConfigParameters(), clct_trig_enable, def_alct_trig_enable, def_clct_trig_enable, def_match_trig_enable, def_match_trig_window_size, def_mpc_block_me1a, def_tmb_l1a_window_size, match_trig_enable, match_trig_window_size, mpc_block_me1a, and tmb_l1a_window_size.

Referenced by CSCMotherboard(), and setConfigParameters().

clear()

void CSCMotherboard::clear

(

void

)

Clears correlated LCT and passes clear signal on to cathode and anode LCT processors.

Definition at line 82 of file CSCMotherboard.cc.

                           {
  // clear the processors
  if (alctProc)
    alctProc->clear();
  if (clctProc)
    clctProc->clear();
 
  // clear the ALCT and CLCT containers
  alctV.clear();
  clctV.clear();
  lctV.clear();
 
  allLCTs_.clear();
 
  // reset the shower trigger
  shower_.clear();
}

References alctProc, alctV, allLCTs_, clctProc, clctV, CSCShowerDigi::clear(), LCTContainer::clear(), lctV, and shower_.

Referenced by CSCGEMMotherboard::clear(), and run().

constructLCTs()

void CSCMotherboard::constructLCTs ( const CSCALCTDigi &  aLCT, const CSCCLCTDigi &  cLCT, int  type, int  trknmb, CSCCorrelatedLCTDigi &  lct  ) const

protected

Definition at line 428 of file CSCMotherboard.cc.

                                                                                                                 {
  thisLCT.setValid(true);
  thisLCT.setType(type);
  // make sure to shift the ALCT BX from 8 to 3 and the CLCT BX from 8 to 7!
  thisLCT.setALCT(getBXShiftedALCT(aLCT));
  thisLCT.setCLCT(getBXShiftedCLCT(cLCT));
  thisLCT.setPattern(encodePattern(cLCT.getPattern()));
  thisLCT.setMPCLink(0);
  thisLCT.setBX0(0);
  thisLCT.setSyncErr(0);
  thisLCT.setCSCID(theTrigChamber);
  thisLCT.setTrknmb(trknmb);
  thisLCT.setWireGroup(aLCT.getKeyWG());
  thisLCT.setStrip(cLCT.getKeyStrip());
  thisLCT.setBend(cLCT.getBend());
  // Bunch crossing: get it from cathode LCT if anode LCT is not there.
  int bx = aLCT.isValid() ? aLCT.getBX() : cLCT.getBX();
  thisLCT.setBX(bx);
  thisLCT.setQuality(qualityAssignment_->findQuality(aLCT, cLCT));
  if (runCCLUT_) {
    thisLCT.setRun3(true);
    // 4-bit slope value derived with the CCLUT algorithm
    thisLCT.setSlope(cLCT.getSlope());
    thisLCT.setQuartStripBit(cLCT.getQuartStripBit());
    thisLCT.setEighthStripBit(cLCT.getEighthStripBit());
    thisLCT.setRun3Pattern(cLCT.getRun3Pattern());
  }
}

References l1GtPatternGenerator_cfi::bx, encodePattern(), CSCCLCTDigi::getBend(), CSCALCTDigi::getBX(), CSCCLCTDigi::getBX(), getBXShiftedALCT(), getBXShiftedCLCT(), CSCCLCTDigi::getEighthStripBit(), CSCCLCTDigi::getKeyStrip(), CSCALCTDigi::getKeyWG(), CSCCLCTDigi::getPattern(), CSCCLCTDigi::getQuartStripBit(), CSCCLCTDigi::getRun3Pattern(), CSCCLCTDigi::getSlope(), CSCALCTDigi::isValid(), qualityAssignment_, CSCBaseboard::runCCLUT_, CSCCorrelatedLCTDigi::setALCT(), CSCCorrelatedLCTDigi::setBend(), CSCCorrelatedLCTDigi::setBX(), CSCCorrelatedLCTDigi::setBX0(), CSCCorrelatedLCTDigi::setCLCT(), CSCCorrelatedLCTDigi::setCSCID(), CSCCorrelatedLCTDigi::setEighthStripBit(), CSCCorrelatedLCTDigi::setMPCLink(), CSCCorrelatedLCTDigi::setPattern(), CSCCorrelatedLCTDigi::setQuality(), CSCCorrelatedLCTDigi::setQuartStripBit(), CSCCorrelatedLCTDigi::setRun3(), CSCCorrelatedLCTDigi::setRun3Pattern(), CSCCorrelatedLCTDigi::setSlope(), CSCCorrelatedLCTDigi::setStrip(), CSCCorrelatedLCTDigi::setSyncErr(), CSCCorrelatedLCTDigi::setTrknmb(), CSCCorrelatedLCTDigi::setType(), CSCCorrelatedLCTDigi::setValid(), CSCCorrelatedLCTDigi::setWireGroup(), and CSCBaseboard::theTrigChamber.

Referenced by correlateLCTs().

copyValidToInValid()

void CSCMotherboard::copyValidToInValid ( CSCALCTDigi &  bestALCT, CSCALCTDigi &  secondALCT, CSCCLCTDigi &  bestCLCT, CSCCLCTDigi &  secondCLCT  ) const

protected

Definition at line 405 of file CSCMotherboard.cc.

                                                                       {
  // check which ALCTs and CLCTs are valid
  const bool anodeBestValid = bestALCT.isValid();
  const bool anodeSecondValid = secondALCT.isValid();
  const bool cathodeBestValid = bestCLCT.isValid();
  const bool cathodeSecondValid = secondCLCT.isValid();
 
  // copy the valid ALCT/CLCT information to the valid ALCT/CLCT
  if (anodeBestValid && !anodeSecondValid)
    secondALCT = bestALCT;
  if (!anodeBestValid && anodeSecondValid)
    bestALCT = secondALCT;
  if (cathodeBestValid && !cathodeSecondValid)
    secondCLCT = bestCLCT;
  if (!cathodeBestValid && cathodeSecondValid)
    bestCLCT = secondCLCT;
}

References CSCALCTDigi::isValid(), and CSCCLCTDigi::isValid().

Referenced by correlateLCTs(), and CSCGEMMotherboard::correlateLCTsGEM().

correlateLCTs()

void CSCMotherboard::correlateLCTs ( const CSCALCTDigi &  bestALCT, const CSCALCTDigi &  secondALCT, const CSCCLCTDigi &  bestCLCT, const CSCCLCTDigi &  secondCLCT, CSCCorrelatedLCTDigi &  bLCT, CSCCorrelatedLCTDigi &  sLCT, int  type  ) const

protected

Definition at line 346 of file CSCMotherboard.cc.

                                                   {
  CSCALCTDigi bestALCT = bALCT;
  CSCALCTDigi secondALCT = sALCT;
  CSCCLCTDigi bestCLCT = bCLCT;
  CSCCLCTDigi secondCLCT = sCLCT;
 
  // check which ALCTs and CLCTs are valid
  copyValidToInValid(bestALCT, secondALCT, bestCLCT, secondCLCT);
 
  // ALCT-only LCTs
  const bool bestCase1(alct_trig_enable and bestALCT.isValid());
  // CLCT-only LCTs
  const bool bestCase2(clct_trig_enable and bestCLCT.isValid());
  /*
    Normal case: ALCT-CLCT matched LCTs. We require ALCT and CLCT to be valid.
    Optionally, we can check if the ALCT cross the CLCT. This check will always return true
    for a valid ALCT-CLCT pair in non-ME1/1 chambers. For ME1/1 chambers, it returns true,
    only when the ALCT-CLCT pair crosses and when the parameter "checkAlctCrossClct" is set to True.
    It is recommended to keep "checkAlctCrossClct" set to False, so that the EMTF receives
    all information, even if it's unphysical.
  */
  const bool bestCase3(match_trig_enable and bestALCT.isValid() and bestCLCT.isValid() and
                       cscOverlap_->doesALCTCrossCLCT(bestALCT, bestCLCT));
 
  // at least one of the cases must be valid
  if (bestCase1 or bestCase2 or bestCase3) {
    constructLCTs(bestALCT, bestCLCT, type, 1, bLCT);
  }
 
  // ALCT-only LCTs
  const bool secondCase1(alct_trig_enable and secondALCT.isValid());
  // CLCT-only LCTs
  const bool secondCase2(clct_trig_enable and secondCLCT.isValid());
  /*
    Normal case: ALCT-CLCT matched LCTs. We require ALCT and CLCT to be valid.
    Optionally, we can check if the ALCT cross the CLCT. This check will always return true
    for a valid ALCT-CLCT pair in non-ME1/1 chambers. For ME1/1 chambers, it returns true,
    only when the ALCT-CLCT pair crosses and when the parameter "checkAlctCrossClct" is set to True.
    It is recommended to keep "checkAlctCrossClct" set to False, so that the EMTF receives
    all information, even if it's unphysical.
  */
  const bool secondCase3(match_trig_enable and secondALCT.isValid() and secondCLCT.isValid() and
                         cscOverlap_->doesALCTCrossCLCT(secondALCT, secondCLCT));
 
  // at least one component must be different in order to consider the secondLCT
  if ((secondALCT != bestALCT) or (secondCLCT != bestCLCT)) {
    // at least one of the cases must be valid
    if (secondCase1 or secondCase2 or secondCase3) {
      constructLCTs(secondALCT, secondCLCT, type, 2, sLCT);
    }
  }
}

References alct_trig_enable, clct_trig_enable, constructLCTs(), copyValidToInValid(), cscOverlap_, CSCALCTDigi::isValid(), CSCCLCTDigi::isValid(), match_trig_enable, and or.

Referenced by CSCGEMMotherboard::correlateLCTsGEM(), and run().

dumpConfigParams()

void CSCMotherboard::dumpConfigParams ( ) const

protected

Dump TMB/MPC configuration parameters.

Definition at line 521 of file CSCMotherboard.cc.

                                            {
  std::ostringstream strm;
  strm << "\n";
  strm << "++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n";
  strm << "+                   TMB configuration parameters:                  +\n";
  strm << "++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n";
  strm << " mpc_block_me1a [block/not block triggers which come from ME1/A] = " << mpc_block_me1a << "\n";
  strm << " alct_trig_enable [allow ALCT-only triggers] = " << alct_trig_enable << "\n";
  strm << " clct_trig_enable [allow CLCT-only triggers] = " << clct_trig_enable << "\n";
  strm << " match_trig_enable [allow matched ALCT-CLCT triggers] = " << match_trig_enable << "\n";
  strm << " match_trig_window_size [ALCT-CLCT match window width, in 25 ns] = " << match_trig_window_size << "\n";
  strm << " tmb_l1a_window_size [L1Accept window width, in 25 ns bins] = " << tmb_l1a_window_size << "\n";
  strm << "++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n";
  LogDebug("CSCMotherboard") << strm.str();
}

References alct_trig_enable, clct_trig_enable, LogDebug, match_trig_enable, match_trig_window_size, mpc_block_me1a, and tmb_l1a_window_size.

Referenced by CSCMotherboard(), and setConfigParameters().

encodeHighMultiplicityBits()

void CSCMotherboard::encodeHighMultiplicityBits ( )

protected

Definition at line 549 of file CSCMotherboard.cc.

                                                {
  // get the high multiplicity
  // for anode this reflects what is already in the anode CSCShowerDigi object
  unsigned cathodeInTime = clctProc->getInTimeHMT();
  unsigned cathodeOutTime = clctProc->getOutTimeHMT();
  unsigned anodeInTime = alctProc->getInTimeHMT();
  unsigned anodeOutTime = alctProc->getOutTimeHMT();
 
  // assign the bits
  unsigned inTimeHMT_;
  unsigned outTimeHMT_;
 
  // set the value according to source
  switch (showerSource_) {
    case 0:
      inTimeHMT_ = cathodeInTime;
      outTimeHMT_ = cathodeOutTime;
      break;
    case 1:
      inTimeHMT_ = anodeInTime;
      outTimeHMT_ = anodeOutTime;
      break;
    case 2:
      inTimeHMT_ = anodeInTime | cathodeInTime;
      outTimeHMT_ = anodeOutTime | cathodeOutTime;
      break;
    default:
      inTimeHMT_ = cathodeInTime;
      outTimeHMT_ = cathodeOutTime;
      break;
  };
 
  // create a new object
  shower_ = CSCShowerDigi(inTimeHMT_, outTimeHMT_, theTrigChamber);
}

References alctProc, clctProc, shower_, showerSource_, and CSCBaseboard::theTrigChamber.

Referenced by CSCGEMMotherboard::run(), and run().

encodePattern()

unsigned int CSCMotherboard::encodePattern ( const int  clctPattern ) const

protected

Definition at line 459 of file CSCMotherboard.cc.

                                                              {
  const int kPatternBitWidth = 4;
 
  // In the TMB07 firmware, LCT pattern is just a 4-bit CLCT pattern.
  unsigned int pattern = (abs(ptn) & ((1 << kPatternBitWidth) - 1));
 
  return pattern;
}

References funct::abs(), and topSingleLeptonDQM_PU_cfi::pattern.

Referenced by constructLCTs(), and CSCGEMMotherboard::constructLCTsGEM().

getBXShiftedALCT()

CSCALCTDigi CSCMotherboard::getBXShiftedALCT ( const CSCALCTDigi &  aLCT ) const

protected

Definition at line 537 of file CSCMotherboard.cc.

                                                                          {
  CSCALCTDigi aLCT_shifted = aLCT;
  aLCT_shifted.setBX(aLCT_shifted.getBX() - (CSCConstants::LCT_CENTRAL_BX - CSCConstants::ALCT_CENTRAL_BX));
  return aLCT_shifted;
}

References CSCConstants::ALCT_CENTRAL_BX, CSCALCTDigi::getBX(), CSCConstants::LCT_CENTRAL_BX, and CSCALCTDigi::setBX().

Referenced by constructLCTs(), and CSCGEMMotherboard::constructLCTsGEM().

getBXShiftedCLCT()

CSCCLCTDigi CSCMotherboard::getBXShiftedCLCT ( const CSCCLCTDigi &  cLCT ) const

protected

Definition at line 543 of file CSCMotherboard.cc.

                                                                          {
  CSCCLCTDigi cLCT_shifted = cLCT;
  cLCT_shifted.setBX(cLCT_shifted.getBX() - CSCConstants::ALCT_CLCT_OFFSET);
  return cLCT_shifted;
}

References CSCConstants::ALCT_CLCT_OFFSET, CSCCLCTDigi::getBX(), and CSCCLCTDigi::setBX().

Referenced by constructLCTs(), and CSCGEMMotherboard::constructLCTsGEM().

readoutLCTs()

std::vector< CSCCorrelatedLCTDigi > CSCMotherboard::readoutLCTs ( ) const

virtual

Definition at line 247 of file CSCMotherboard.cc.

                                                                  {
  // temporary container for further selection
  std::vector<CSCCorrelatedLCTDigi> tmpV;
 
  /*
    LCTs in the BX window [early_tbin,...,late_tbin] are considered good for physics
    The central LCT BX is time bin 8.
    For tmb_l1a_window_size set to 7 (Run-1, Run-2), the window is [5, 6, 7, 8, 9, 10, 11]
    For tmb_l1a_window_size set to 5 (Run-3), the window is [6, 7, 8, 9, 10]
    For tmb_l1a_window_size set to 3 (Run-4?), the window is [ 7, 8, 9]
  */
  const unsigned delta_tbin = tmb_l1a_window_size / 2;
  int early_tbin = CSCConstants::LCT_CENTRAL_BX - delta_tbin;
  int late_tbin = CSCConstants::LCT_CENTRAL_BX + delta_tbin;
  /*
     Special case for an even-numbered time-window,
     For instance tmb_l1a_window_size set to 6: [5, 6, 7, 8, 9, 10]
  */
  if (tmb_l1a_window_size % 2 == 0)
    late_tbin = CSCConstants::LCT_CENTRAL_BX + delta_tbin - 1;
  const int max_late_tbin = CSCConstants::MAX_LCT_TBINS - 1;
 
  // debugging messages when early_tbin or late_tbin has a suspicious value
  bool debugTimeBins = true;
  if (debugTimeBins) {
    if (early_tbin < 0) {
      edm::LogWarning("CSCMotherboard|SuspiciousParameters")
          << "Early time bin (early_tbin) smaller than minimum allowed, which is 0. set early_tbin to 0.";
      early_tbin = 0;
    }
    if (late_tbin > max_late_tbin) {
      edm::LogWarning("CSCMotherboard|SuspiciousParameters")
          << "Late time bin (late_tbin) larger than maximum allowed, which is " << max_late_tbin
          << ". set early_tbin to max allowed";
      late_tbin = CSCConstants::MAX_LCT_TBINS - 1;
    }
    debugTimeBins = false;
  }
 
  // Start from the vector of all found correlated LCTs and select
  // those within the LCT*L1A coincidence window.
  int bx_readout = -1;
  for (const auto& lct : lctV) {
    // extra check on invalid LCTs
    if (!lct.isValid()) {
      continue;
    }
 
    const int bx = lct.getBX();
    // Skip LCTs found too early relative to L1Accept.
    if (bx < early_tbin) {
      if (infoV > 1)
        LogDebug("CSCMotherboard") << " Do not report correlated LCT on key halfstrip " << lct.getStrip()
                                   << " and key wire " << lct.getKeyWG() << ": found at bx " << bx
                                   << ", whereas the earliest allowed bx is " << early_tbin;
      continue;
    }
 
    // Skip LCTs found too late relative to L1Accept.
    if (bx > late_tbin) {
      if (infoV > 1)
        LogDebug("CSCMotherboard") << " Do not report correlated LCT on key halfstrip " << lct.getStrip()
                                   << " and key wire " << lct.getKeyWG() << ": found at bx " << bx
                                   << ", whereas the latest allowed bx is " << late_tbin;
      continue;
    }
 
    // Do not report LCTs found in ME1/A if mpc_block_me1a is set.
    if (mpc_block_me1a and isME11_ and lct.getStrip() > CSCConstants::MAX_HALF_STRIP_ME1B) {
      continue;
    }
 
    // If (readout_earliest_2) take only LCTs in the earliest bx in the read-out window:
    // in digi->raw step, LCTs have to be packed into the TMB header, and
    // currently there is room just for two.
    if (readout_earliest_2) {
      if (bx_readout == -1 || bx == bx_readout) {
        tmpV.push_back(lct);
        if (bx_readout == -1)
          bx_readout = bx;
      }
    }
    // if readout_earliest_2 == false, save all LCTs
    else {
      tmpV.push_back(lct);
    }
  }
 
  // do a final check on the LCTs in readout
  qualityControl_->checkMultiplicityBX(tmpV);
  for (const auto& lct : tmpV) {
    qualityControl_->checkValid(lct);
  }
 
  return tmpV;
}

References l1GtPatternGenerator_cfi::bx, CSCBaseboard::infoV, CSCBaseboard::isME11_, CSCConstants::LCT_CENTRAL_BX, lctV, LogDebug, CSCConstants::MAX_HALF_STRIP_ME1B, CSCConstants::MAX_LCT_TBINS, mpc_block_me1a, qualityControl_, readout_earliest_2, and tmb_l1a_window_size.

Referenced by CSCTriggerPrimitivesBuilder::build().

readoutShower()

CSCShowerDigi CSCMotherboard::readoutShower

(

)

const

Returns shower bits

Definition at line 344 of file CSCMotherboard.cc.

{ return shower_; }

References shower_.

Referenced by CSCTriggerPrimitivesBuilder::build().

run()

void CSCMotherboard::run	(	const CSCWireDigiCollection *	wiredc,
		const CSCComparatorDigiCollection *	compdc
	)

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

Definition at line 124 of file CSCMotherboard.cc.

                                                                                                       {
  // Step 1: Setup
  clear();
 
  // Check for existing processors
  if (!(alctProc && clctProc)) {
    edm::LogError("CSCMotherboard|SetupError") << "+++ run() called for non-existing ALCT/CLCT processor! +++ \n";
    return;
  }
 
  // set geometry
  alctProc->setCSCGeometry(cscGeometry_);
  clctProc->setCSCGeometry(cscGeometry_);
 
  // Step 2: Run the processors
  alctV = alctProc->run(wiredc);  // run anodeLCT
  clctV = clctProc->run(compdc);  // run cathodeLCT
 
  // Step 2b: encode high multiplicity bits (independent of LCT construction)
  encodeHighMultiplicityBits();
 
  // if there are no ALCTs and no CLCTs, it does not make sense to run this TMB
  if (alctV.empty() and clctV.empty())
    return;
 
  // array to mask CLCTs
  bool used_clct_mask[CSCConstants::MAX_CLCT_TBINS] = {false};
 
  // Step 3: ALCT-centric ALCT-to-CLCT matching
  int bx_clct_matched = 0;  // bx of last matched CLCT
  for (int bx_alct = 0; bx_alct < CSCConstants::MAX_ALCT_TBINS; bx_alct++) {
    // There should be at least one valid CLCT or ALCT for a
    // correlated LCT to be formed.  Decision on whether to reject
    // non-complete LCTs (and if yes of which type) is made further
    // upstream.
    if (alctProc->getBestALCT(bx_alct).isValid()) {
      // Look for CLCTs within the match-time window.  The window is
      // centered at the ALCT bx; therefore, we make an assumption
      // that anode and cathode hits are perfectly synchronized.  This
      // is always true for MC, but only an approximation when the
      // data is analyzed (which works fairly good as long as wide
      // windows are used).  To get rid of this assumption, one would
      // need to access "full BX" words, which are not readily
      // available.
      bool is_matched = false;
      // loop on the preferred "delta BX" array
      for (unsigned mbx = 0; mbx < match_trig_window_size; mbx++) {
        // evaluate the preffered CLCT BX, taking into account that there is an offset in the simulation
        unsigned bx_clct = bx_alct + preferred_bx_match_[mbx] - CSCConstants::ALCT_CLCT_OFFSET;
        // check that the CLCT BX is valid
        if (bx_clct >= CSCConstants::MAX_CLCT_TBINS)
          continue;
        // do not consider previously matched CLCTs
        if (drop_used_clcts && used_clct_mask[bx_clct])
          continue;
        if (clctProc->getBestCLCT(bx_clct).isValid()) {
          if (infoV > 1)
            LogTrace("CSCMotherboard") << "Successful ALCT-CLCT match: bx_alct = " << bx_alct
                                       << "; bx_clct = " << bx_clct << "; mbx = " << mbx;
          // now correlate the ALCT and CLCT into LCT.
          // smaller mbx means more preferred!
          correlateLCTs(alctProc->getBestALCT(bx_alct),
                        alctProc->getSecondALCT(bx_alct),
                        clctProc->getBestCLCT(bx_clct),
                        clctProc->getSecondCLCT(bx_clct),
                        allLCTs_(bx_alct, mbx, 0),
                        allLCTs_(bx_alct, mbx, 1),
                        CSCCorrelatedLCTDigi::ALCTCLCT);
          // when the first LCT is valid, you can mask the matched CLCT and/or
          // move on to the next ALCT if match_earliest_clct_only_ is set to true
          if (allLCTs_(bx_alct, mbx, 0).isValid()) {
            is_matched = true;
            used_clct_mask[bx_clct] = true;
            if (match_earliest_clct_only_)
              break;
          }
        }
      }
      // No CLCT within the match time interval found: report ALCT-only LCT
      // (use dummy CLCTs).
      if (!is_matched) {
        if (infoV > 1)
          LogTrace("CSCMotherboard") << "Unsuccessful ALCT-CLCT match (ALCT only): bx_alct = " << bx_alct
                                     << " first ALCT " << alctProc->getBestALCT(bx_alct);
        if (alct_trig_enable)
          correlateLCTs(alctProc->getBestALCT(bx_alct),
                        alctProc->getSecondALCT(bx_alct),
                        clctProc->getBestCLCT(bx_alct),
                        clctProc->getSecondCLCT(bx_alct),
                        allLCTs_(bx_alct, 0, 0),
                        allLCTs_(bx_alct, 0, 1),
                        CSCCorrelatedLCTDigi::ALCTONLY);
      }
    }
    // No valid ALCTs; attempt to make CLCT-only LCT.  Use only CLCTs
    // which have zeroth chance to be matched at later cathode times.
    // (I am not entirely sure this perfectly matches the firmware logic.)
    // Use dummy ALCTs.
    else {
      int bx_clct = bx_alct - match_trig_window_size / 2;
      if (bx_clct >= 0 && bx_clct > bx_clct_matched) {
        if (clctProc->getBestCLCT(bx_clct).isValid() and clct_trig_enable) {
          if (infoV > 1)
            LogTrace("CSCMotherboard") << "Unsuccessful ALCT-CLCT match (CLCT only): bx_clct = " << bx_clct;
          correlateLCTs(alctProc->getBestALCT(bx_alct),
                        alctProc->getSecondALCT(bx_alct),
                        clctProc->getBestCLCT(bx_clct),
                        clctProc->getSecondCLCT(bx_clct),
                        allLCTs_(bx_clct, 0, 0),
                        allLCTs_(bx_clct, 0, 1),
                        CSCCorrelatedLCTDigi::CLCTONLY);
        }
      }
    }
  }
 
  // Step 4: Select at most 2 LCTs per BX
  selectLCTs();
}

References CSCConstants::ALCT_CLCT_OFFSET, alct_trig_enable, CSCCorrelatedLCTDigi::ALCTCLCT, CSCCorrelatedLCTDigi::ALCTONLY, alctProc, alctV, allLCTs_, clct_trig_enable, CSCCorrelatedLCTDigi::CLCTONLY, clctProc, clctV, clear(), correlateLCTs(), CSCBaseboard::cscGeometry_, drop_used_clcts, encodeHighMultiplicityBits(), CSCBaseboard::infoV, LogTrace, match_earliest_clct_only_, match_trig_window_size, CSCConstants::MAX_ALCT_TBINS, CSCConstants::MAX_CLCT_TBINS, preferred_bx_match_, and selectLCTs().

Referenced by CSCTriggerPrimitivesBuilder::build().

selectLCTs()

void CSCMotherboard::selectLCTs

(

)

Definition at line 468 of file CSCMotherboard.cc.

                                {
  // in each of the LCT time bins
  for (int bx = 0; bx < CSCConstants::MAX_LCT_TBINS; bx++) {
    unsigned nLCTs = 0;
 
    std::vector<CSCCorrelatedLCTDigi> tempV;
    // check each of the preferred combinations
    for (unsigned int mbx = 0; mbx < match_trig_window_size; mbx++) {
      // select at most 2
      for (int i = 0; i < CSCConstants::MAX_LCTS_PER_CSC; i++) {
        if (allLCTs_(bx, mbx, i).isValid() and nLCTs < 2) {
          tempV.push_back(allLCTs_(bx, mbx, i));
          ++nLCTs;
        }
      }
    }
    // store the best 2
    for (const auto& lct : tempV) {
      lctV.push_back(lct);
    }
  }
 
  // Show the pre-selected LCTs. They're not final yet. Some selection is done in the readoutLCTs function
  if (infoV > 0) {
    for (const auto& lct : lctV) {
      LogDebug("CSCMotherboard") << "Selected LCT" << lct;
    }
  }
}

References allLCTs_, l1GtPatternGenerator_cfi::bx, mps_fire::i, CSCBaseboard::infoV, sistrip::SpyUtilities::isValid(), lctV, LogDebug, match_trig_window_size, CSCConstants::MAX_LCT_TBINS, and CSCConstants::MAX_LCTS_PER_CSC.

Referenced by CSCGEMMotherboard::run(), and run().

setConfigParameters()

void CSCMotherboard::setConfigParameters

(

const CSCDBL1TPParameters *

conf

)

Set configuration parameters obtained via EventSetup mechanism.

Definition at line 101 of file CSCMotherboard.cc.

                                                                        {
  static std::atomic<bool> config_dumped{false};
 
  // Config. parameters for the TMB itself.
  mpc_block_me1a = conf->tmbMpcBlockMe1a();
  alct_trig_enable = conf->tmbAlctTrigEnable();
  clct_trig_enable = conf->tmbClctTrigEnable();
  match_trig_enable = conf->tmbMatchTrigEnable();
  match_trig_window_size = conf->tmbMatchTrigWindowSize();
  tmb_l1a_window_size = conf->tmbTmbL1aWindowSize();
 
  // Config. paramteres for ALCT and CLCT processors.
  alctProc->setConfigParameters(conf);
  clctProc->setConfigParameters(conf);
 
  // Check and print configuration parameters.
  checkConfigParameters();
  if (!config_dumped) {
    dumpConfigParams();
    config_dumped = true;
  }
}

References alct_trig_enable, alctProc, checkConfigParameters(), clct_trig_enable, clctProc, dumpConfigParams(), match_trig_enable, match_trig_window_size, mpc_block_me1a, tmb_l1a_window_size, CSCDBL1TPParameters::tmbAlctTrigEnable(), CSCDBL1TPParameters::tmbClctTrigEnable(), CSCDBL1TPParameters::tmbMatchTrigEnable(), CSCDBL1TPParameters::tmbMatchTrigWindowSize(), CSCDBL1TPParameters::tmbMpcBlockMe1a(), and CSCDBL1TPParameters::tmbTmbL1aWindowSize().

Member Data Documentation

alct_trig_enable

unsigned int CSCMotherboard::alct_trig_enable

protected

Definition at line 123 of file CSCMotherboard.h.

Referenced by checkConfigParameters(), correlateLCTs(), CSCMotherboard(), dumpConfigParams(), run(), and setConfigParameters().

alctProc

std::unique_ptr<CSCAnodeLCTProcessor> CSCMotherboard::alctProc

Anode LCT processor.

Definition at line 98 of file CSCMotherboard.h.

Referenced by CSCTriggerPrimitivesBuilder::build(), clear(), CSCMotherboard(), encodeHighMultiplicityBits(), CSCGEMMotherboard::matchALCT2GEM(), CSCGEMMotherboard::matchALCTCLCTGEM(), CSCGEMMotherboard::run(), run(), and setConfigParameters().

alctV

std::vector<CSCALCTDigi> CSCMotherboard::alctV

protected

Definition at line 106 of file CSCMotherboard.h.

Referenced by clear(), CSCGEMMotherboard::run(), and run().

allLCTs_

LCTContainer CSCMotherboard::allLCTs_

protected

Container with all LCTs prior to sorting and selecting.

Definition at line 110 of file CSCMotherboard.h.

Referenced by clear(), CSCMotherboard(), CSCGEMMotherboard::matchALCT2GEM(), CSCGEMMotherboard::matchALCTCLCTGEM(), CSCGEMMotherboard::matchCLCT2GEM(), run(), and selectLCTs().

clct_trig_enable

unsigned int CSCMotherboard::clct_trig_enable

protected

Definition at line 123 of file CSCMotherboard.h.

Referenced by checkConfigParameters(), correlateLCTs(), CSCMotherboard(), dumpConfigParams(), run(), and setConfigParameters().

clctProc

std::unique_ptr<CSCCathodeLCTProcessor> CSCMotherboard::clctProc

Cathode LCT processor.

Definition at line 101 of file CSCMotherboard.h.

Referenced by CSCTriggerPrimitivesBuilder::build(), clear(), CSCMotherboard(), encodeHighMultiplicityBits(), CSCGEMMotherboard::matchALCTCLCTGEM(), CSCGEMMotherboard::matchCLCT2GEM(), CSCGEMMotherboard::run(), run(), and setConfigParameters().

clctV

std::vector<CSCCLCTDigi> CSCMotherboard::clctV

protected

Definition at line 107 of file CSCMotherboard.h.

Referenced by clear(), CSCGEMMotherboard::run(), and run().

cscOverlap_

std::unique_ptr<CSCALCTCrossCLCT> CSCMotherboard::cscOverlap_

protected

Definition at line 166 of file CSCMotherboard.h.

Referenced by correlateLCTs(), and CSCMotherboard().

def_alct_trig_enable

const unsigned int CSCMotherboard::def_alct_trig_enable = 0

staticprotected

Definition at line 150 of file CSCMotherboard.h.

Referenced by checkConfigParameters().

def_clct_trig_enable

const unsigned int CSCMotherboard::def_clct_trig_enable = 0

staticprotected

Definition at line 150 of file CSCMotherboard.h.

Referenced by checkConfigParameters().

def_match_trig_enable

const unsigned int CSCMotherboard::def_match_trig_enable = 1

staticprotected

Definition at line 151 of file CSCMotherboard.h.

Referenced by checkConfigParameters().

def_match_trig_window_size

const unsigned int CSCMotherboard::def_match_trig_window_size = 7

staticprotected

Definition at line 151 of file CSCMotherboard.h.

Referenced by checkConfigParameters().

def_mpc_block_me1a

const unsigned int CSCMotherboard::def_mpc_block_me1a = 1

staticprotected

Default values of configuration parameters.

Definition at line 149 of file CSCMotherboard.h.

Referenced by checkConfigParameters().

def_tmb_l1a_window_size

const unsigned int CSCMotherboard::def_tmb_l1a_window_size = 7

staticprotected

Definition at line 152 of file CSCMotherboard.h.

Referenced by checkConfigParameters().

drop_used_clcts

bool CSCMotherboard::drop_used_clcts

protected

Phase2: whether to not reuse CLCTs that were used by previous matching ALCTs

Definition at line 127 of file CSCMotherboard.h.

Referenced by CSCMotherboard(), CSCGEMMotherboard::matchALCTCLCTGEM(), CSCGEMMotherboard::matchCLCT2GEM(), and run().

early_tbins

int CSCMotherboard::early_tbins

protected

Phase2: separate handle for early time bins

Definition at line 130 of file CSCMotherboard.h.

Referenced by CSCMotherboard().

lctV

std::vector<CSCCorrelatedLCTDigi> CSCMotherboard::lctV

protected

Definition at line 113 of file CSCMotherboard.h.

Referenced by clear(), readoutLCTs(), and selectLCTs().

match_earliest_clct_only_

bool CSCMotherboard::match_earliest_clct_only_

protected

Definition at line 136 of file CSCMotherboard.h.

Referenced by CSCMotherboard(), CSCGEMMotherboard::matchALCTCLCTGEM(), CSCGEMMotherboard::matchCLCT2GEM(), and run().

match_trig_enable

unsigned int CSCMotherboard::match_trig_enable

protected

Definition at line 123 of file CSCMotherboard.h.

Referenced by checkConfigParameters(), correlateLCTs(), CSCMotherboard(), dumpConfigParams(), and setConfigParameters().

match_trig_window_size

unsigned int CSCMotherboard::match_trig_window_size

protected

Definition at line 124 of file CSCMotherboard.h.

Referenced by checkConfigParameters(), CSCMotherboard(), dumpConfigParams(), CSCGEMMotherboard::matchALCTCLCTGEM(), run(), selectLCTs(), and setConfigParameters().

mpc_block_me1a

unsigned int CSCMotherboard::mpc_block_me1a

protected

Configuration parameters.

Definition at line 122 of file CSCMotherboard.h.

Referenced by checkConfigParameters(), CSCMotherboard(), dumpConfigParams(), readoutLCTs(), and setConfigParameters().

preferred_bx_match_

std::vector<int> CSCMotherboard::preferred_bx_match_

protected

Definition at line 146 of file CSCMotherboard.h.

Referenced by CSCMotherboard(), CSCGEMMotherboard::matchALCT2GEM(), CSCGEMMotherboard::matchALCTCLCTGEM(), CSCGEMMotherboard::matchCLCT2GEM(), and run().

qualityAssignment_

std::unique_ptr<LCTQualityAssignment> CSCMotherboard::qualityAssignment_

protected

Definition at line 155 of file CSCMotherboard.h.

Referenced by constructLCTs(), CSCGEMMotherboard::constructLCTsGEM(), CSCGEMMotherboard::CSCGEMMotherboard(), and CSCMotherboard().

qualityControl_

std::unique_ptr<LCTQualityControl> CSCMotherboard::qualityControl_

protected

Definition at line 158 of file CSCMotherboard.h.

Referenced by CSCMotherboard(), and readoutLCTs().

readout_earliest_2

bool CSCMotherboard::readout_earliest_2

protected

Phase2: whether to readout only the earliest two LCTs in readout window

Definition at line 133 of file CSCMotherboard.h.

Referenced by CSCMotherboard(), and readoutLCTs().

shower_

CSCShowerDigi CSCMotherboard::shower_

protected

Definition at line 115 of file CSCMotherboard.h.

Referenced by clear(), encodeHighMultiplicityBits(), and readoutShower().

showerSource_

unsigned CSCMotherboard::showerSource_

protected

Definition at line 139 of file CSCMotherboard.h.

Referenced by CSCMotherboard(), and encodeHighMultiplicityBits().

tmb_l1a_window_size

unsigned int CSCMotherboard::tmb_l1a_window_size

protected

Definition at line 124 of file CSCMotherboard.h.

Referenced by checkConfigParameters(), CSCMotherboard(), dumpConfigParams(), readoutLCTs(), and setConfigParameters().