#include <CSCMotherboard.h>

Inheritance diagram for CSCMotherboard:

Public Member Functions
void	clear ()

	CSCMotherboard ()

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

std::vector< CSCCorrelatedLCTDigi >	getLCTs () const

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

virtual void	run (const CSCWireDigiCollection wiredc, const CSCComparatorDigiCollection compdc)

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 Types
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
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
unsigned int	alct_trig_enable

std::vector< CSCALCTDigi >	alctV

bool	clct_to_alct

unsigned int	clct_trig_enable

std::vector< CSCCLCTDigi >	clctV

bool	drop_used_alcts

bool	drop_used_clcts

int	early_tbins

CSCCorrelatedLCTDigi	firstLCT [CSCConstants::MAX_LCT_TBINS]

unsigned int	highMultiplicityBits_

unsigned int	match_trig_enable

unsigned int	match_trig_window_size

unsigned int	mpc_block_me1a

std::unique_ptr< LCTQualityControl >	qualityControl_

bool	readout_earliest_2

CSCCorrelatedLCTDigi	secondLCT [CSCConstants::MAX_LCT_TBINS]

unsigned int	tmb_l1a_window_size

bool	useHighMultiplicityBits_

Protected Attributes inherited from CSCBaseboard
edm::ParameterSet	alctParams_

edm::ParameterSet	clctParams_

edm::ParameterSet	commonParams_

const CSCChamber *	cscChamber_

const CSCGeometry *	cscGeometry_

CSCDetId	cscId_

bool	disableME1a_

bool	enableAlctPhase2_

bool	gangedME1a_

int	infoV

bool	isME11_

bool	isME21_

bool	isME31_

bool	isME41_

bool	runCCLUT_

bool	runME11ILT_

bool	runME11Up_

bool	runME21ILT_

bool	runME21Up_

bool	runME31Up_

bool	runME41Up_

bool	runPhase2_

unsigned	theChamber

std::string	theCSCName_

const unsigned	theEndcap

unsigned	theRegion

unsigned	theRing

const unsigned	theSector

const unsigned	theStation

const unsigned	theSubsector

const unsigned	theTrigChamber

edm::ParameterSet	tmbParams_

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

Definition at line 41 of file CSCMotherboard.h.

Member Enumeration Documentation

◆ LCT_Quality

enum CSCMotherboard::LCT_Quality : unsigned int

strongprotected

Enumerator
INVALID
NO_CLCT
NO_ALCT
CLCT_LAYER_TRIGGER
LOW_QUALITY
MARGINAL_ANODE_CATHODE
HQ_ANODE_MARGINAL_CATHODE
HQ_CATHODE_MARGINAL_ANODE
HQ_ACCEL_ALCT
HQ_RESERVED_1
HQ_RESERVED_2
HQ_PATTERN_2_3
HQ_PATTERN_4_5
HQ_PATTERN_6_7
HQ_PATTERN_8_9
HQ_PATTERN_10

Definition at line 147 of file CSCMotherboard.h.

                          : unsigned int {
     INVALID = 0,
     NO_CLCT = 1,
     NO_ALCT = 2,
     CLCT_LAYER_TRIGGER = 3,
     LOW_QUALITY = 4,
     MARGINAL_ANODE_CATHODE = 5,
     HQ_ANODE_MARGINAL_CATHODE = 6,
     HQ_CATHODE_MARGINAL_ANODE = 7,
     HQ_ACCEL_ALCT = 8,
     HQ_RESERVED_1 = 9,
     HQ_RESERVED_2 = 10,
     HQ_PATTERN_2_3 = 11,
     HQ_PATTERN_4_5 = 12,
     HQ_PATTERN_6_7 = 13,
     HQ_PATTERN_8_9 = 14,
     HQ_PATTERN_10 = 15
   };

◆ LCT_QualityRun3

enum CSCMotherboard::LCT_QualityRun3 : unsigned int

strongprotected

Enumerator
INVALID
LowQ
MedQ
HighQ

Definition at line 166 of file CSCMotherboard.h.

                              : unsigned int {
     INVALID = 0,
     LowQ = 1,
     MedQ = 2,
     HighQ = 3,
   };

Constructor & Destructor Documentation

◆ CSCMotherboard() [1/2]

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 ALCTs that were used by previous matching CLCTs
   drop_used_alcts = tmbParams_.getParameter<bool>("tmbDropUsedAlcts");
   drop_used_clcts = tmbParams_.getParameter<bool>("tmbDropUsedClcts");
  
   clct_to_alct = tmbParams_.getParameter<bool>("clctToAlct");
  
   // special tmb bits
   useHighMultiplicityBits_ = tmbParams_.getParameter<bool>("useHighMultiplicityBits");
   highMultiplicityBits_ = 0;
  
   // whether to readout only the earliest two LCTs in readout window
   readout_earliest_2 = tmbParams_.getParameter<bool>("tmbReadoutEarliest2");
  
   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;
   }
  
   // quality control of stubs
   qualityControl_ = std::make_unique<LCTQualityControl>(endcap, station, sector, subsector, chamber, conf);
 }

References alct_trig_enable, alctProc, relativeConstraints::chamber, checkConfigParameters(), clct_to_alct, clct_trig_enable, clctProc, drop_used_alcts, drop_used_clcts, dumpConfigParams(), early_tbins, makeMuonMisalignmentScenario::endcap, edm::ParameterSet::getParameter(), highMultiplicityBits_, CSCBaseboard::infoV, match_trig_enable, match_trig_window_size, mpc_block_me1a, qualityControl_, readout_earliest_2, relativeConstraints::station, tmb_l1a_window_size, CSCBaseboard::tmbParams_, and useHighMultiplicityBits_.

◆ CSCMotherboard() [2/2]

CSCMotherboard::CSCMotherboard ( )

Constructor for use during testing.

Definition at line 64 of file CSCMotherboard.cc.

                                : CSCBaseboard() {
   // Constructor used only for testing.  -JM
   static std::atomic<bool> config_dumped{false};
  
   early_tbins = 4;
  
   alctProc = std::make_unique<CSCAnodeLCTProcessor>();
   clctProc = std::make_unique<CSCCathodeLCTProcessor>();
   mpc_block_me1a = def_mpc_block_me1a;
   alct_trig_enable = def_alct_trig_enable;
   clct_trig_enable = def_clct_trig_enable;
   match_trig_enable = def_match_trig_enable;
   match_trig_window_size = def_match_trig_window_size;
   tmb_l1a_window_size = def_tmb_l1a_window_size;
  
   infoV = 2;
  
   // Check and print configuration parameters.
   checkConfigParameters();
   if (infoV > 0 && !config_dumped) {
     dumpConfigParams();
     config_dumped = true;
   }
 }

References alct_trig_enable, alctProc, checkConfigParameters(), clct_trig_enable, clctProc, 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, dumpConfigParams(), early_tbins, CSCBaseboard::infoV, match_trig_enable, match_trig_window_size, mpc_block_me1a, and tmb_l1a_window_size.

◆ ~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 660 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 89 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();
  
   // clear the LCT containers
   for (int bx = 0; bx < CSCConstants::MAX_LCT_TBINS; bx++) {
     firstLCT[bx].clear();
     secondLCT[bx].clear();
   }
 }

References alctProc, alctV, l1GtPatternGenerator_cfi::bx, clctProc, clctV, CSCCorrelatedLCTDigi::clear(), firstLCT, CSCConstants::MAX_LCT_TBINS, and secondLCT.

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

◆ constructLCTs()

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

protected

Definition at line 486 of file CSCMotherboard.cc.

                                                                      {
   // CLCT pattern number
   unsigned int pattern = encodePattern(cLCT.getPattern());
  
   // LCT quality number
   unsigned int quality;
   if (runCCLUT_) {
     quality = static_cast<unsigned int>(findQualityRun3(aLCT, cLCT));
   } else {
     quality = static_cast<unsigned int>(findQuality(aLCT, cLCT));
   }
  
   // Bunch crossing: get it from cathode LCT if anode LCT is not there.
   int bx = aLCT.isValid() ? aLCT.getBX() : cLCT.getBX();
  
   // Not used in Run-2. Will not be assigned in Run-3
   unsigned int syncErr = 0;
  
   // construct correlated LCT
   CSCCorrelatedLCTDigi thisLCT(trknmb,
                                1,
                                quality,
                                aLCT.getKeyWG(),
                                cLCT.getKeyStrip(),
                                pattern,
                                cLCT.getBend(),
                                bx,
                                0,
                                0,
                                syncErr,
                                theTrigChamber);
   thisLCT.setType(type);
  
   if (runCCLUT_) {
     thisLCT.setRun3(true);
     // 4-bit slope value derived with the CCLUT algorithm
     thisLCT.setSlope(cLCT.getSlope());
     thisLCT.setQuartStrip(cLCT.getQuartStrip());
     thisLCT.setEighthStrip(cLCT.getEighthStrip());
     thisLCT.setRun3Pattern(cLCT.getRun3Pattern());
   }
  
   // in Run-3 we plan to denote the presence of exotic signatures in the chamber
   if (useHighMultiplicityBits_)
     thisLCT.setHMT(highMultiplicityBits_);
  
   // 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));
   return thisLCT;
 }

References l1GtPatternGenerator_cfi::bx, encodePattern(), findQuality(), findQualityRun3(), CSCCLCTDigi::getBend(), CSCALCTDigi::getBX(), CSCCLCTDigi::getBX(), getBXShiftedALCT(), getBXShiftedCLCT(), CSCCLCTDigi::getEighthStrip(), CSCCLCTDigi::getKeyStrip(), CSCALCTDigi::getKeyWG(), CSCCLCTDigi::getPattern(), CSCCLCTDigi::getQuartStrip(), CSCCLCTDigi::getRun3Pattern(), CSCCLCTDigi::getSlope(), highMultiplicityBits_, CSCALCTDigi::isValid(), topSingleLeptonDQM_PU_cfi::pattern, quality, CSCBaseboard::runCCLUT_, CSCCorrelatedLCTDigi::setType(), CSCBaseboard::theTrigChamber, and useHighMultiplicityBits_.

Referenced by CSCUpgradeMotherboard::correlateLCTs(), correlateLCTs(), CSCGEMMotherboardME21::correlateLCTsGEM(), CSCGEMMotherboardME11::correlateLCTsGEM(), and CSCMotherboardME11::correlateLCTsME11().

◆ correlateLCTs()

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

protected

Definition at line 431 of file CSCMotherboard.cc.

                                                                                                                       {
   CSCALCTDigi bestALCT = bALCT;
   CSCALCTDigi secondALCT = sALCT;
   CSCCLCTDigi bestCLCT = bCLCT;
   CSCCLCTDigi secondCLCT = sCLCT;
  
   bool anodeBestValid = bestALCT.isValid();
   bool anodeSecondValid = secondALCT.isValid();
   bool cathodeBestValid = bestCLCT.isValid();
   bool cathodeSecondValid = secondCLCT.isValid();
  
   if (anodeBestValid && !anodeSecondValid)
     secondALCT = bestALCT;
   if (!anodeBestValid && anodeSecondValid)
     bestALCT = secondALCT;
   if (cathodeBestValid && !cathodeSecondValid)
     secondCLCT = bestCLCT;
   if (!cathodeBestValid && cathodeSecondValid)
     bestCLCT = secondCLCT;
  
   // ALCT-CLCT matching conditions are defined by "trig_enable" configuration
   // parameters.
   if ((alct_trig_enable && bestALCT.isValid()) || (clct_trig_enable && bestCLCT.isValid()) ||
       (match_trig_enable && bestALCT.isValid() && bestCLCT.isValid())) {
     const CSCCorrelatedLCTDigi& lct = constructLCTs(bestALCT, bestCLCT, type, 1);
     int bx = lct.getBX();
     if (bx >= 0 && bx < CSCConstants::MAX_LCT_TBINS) {
       firstLCT[bx] = lct;
     } else {
       if (infoV > 0)
         edm::LogWarning("CSCMotherboard|OutOfTimeLCT")
             << "+++ Bx of first LCT candidate, " << bx << ", is not within the allowed range, [0-"
             << CSCConstants::MAX_LCT_TBINS - 1 << "); skipping it... +++\n";
     }
   }
  
   if (((secondALCT != bestALCT) || (secondCLCT != bestCLCT)) &&
       ((alct_trig_enable && secondALCT.isValid()) || (clct_trig_enable && secondCLCT.isValid()) ||
        (match_trig_enable && secondALCT.isValid() && secondCLCT.isValid()))) {
     const CSCCorrelatedLCTDigi& lct = constructLCTs(secondALCT, secondCLCT, type, 2);
     int bx = lct.getBX();
     if (bx >= 0 && bx < CSCConstants::MAX_LCT_TBINS) {
       secondLCT[bx] = lct;
     } else {
       if (infoV > 0)
         edm::LogWarning("CSCMotherboard|OutOfTimeLCT")
             << "+++ Bx of second LCT candidate, " << bx << ", is not within the allowed range, [0-"
             << CSCConstants::MAX_LCT_TBINS - 1 << "); skipping it... +++\n";
     }
   }
 }

References alct_trig_enable, l1GtPatternGenerator_cfi::bx, clct_trig_enable, constructLCTs(), firstLCT, CSCCorrelatedLCTDigi::getBX(), CSCBaseboard::infoV, CSCALCTDigi::isValid(), CSCCLCTDigi::isValid(), match_trig_enable, CSCConstants::MAX_LCT_TBINS, and secondLCT.

Referenced by run().

◆ dumpConfigParams()

void CSCMotherboard::dumpConfigParams ( ) const

protected

Dump TMB/MPC configuration parameters.

Definition at line 683 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 ( unsigned alctBits )

protected

Definition at line 711 of file CSCMotherboard.cc.

                                                                  {
   // encode the high multiplicity bits in the (O)TMB based on
   // the high multiplicity bits from the ALCT processor
   // draft version: simply rellay the ALCT bits.
   // future versions may involve also bits from the CLCT processor
   // this depends on memory constraints in the TMB FPGA
   highMultiplicityBits_ = alctBits;
 }

References highMultiplicityBits_.

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

◆ encodePattern()

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

protected

Definition at line 542 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().

◆ findQuality()

CSCMotherboard::LCT_Quality CSCMotherboard::findQuality	(	const CSCALCTDigi &	aLCT,
		const CSCCLCTDigi &	cLCT
	)		const

protected

Definition at line 552 of file CSCMotherboard.cc.

                                                                                                             {
   // Either ALCT or CLCT is invalid
   if (!(aLCT.isValid()) || !(cLCT.isValid())) {
     // No CLCT
     if (aLCT.isValid() && !(cLCT.isValid()))
       return LCT_Quality::NO_CLCT;
  
     // No ALCT
     else if (!(aLCT.isValid()) && cLCT.isValid())
       return LCT_Quality::NO_ALCT;
  
     // No ALCT and no CLCT
     else
       return LCT_Quality::INVALID;
   }
   // Both ALCT and CLCT are valid
   else {
     const int pattern(cLCT.getPattern());
  
     // Layer-trigger in CLCT
     if (pattern == 1)
       return LCT_Quality::CLCT_LAYER_TRIGGER;
  
     // Multi-layer pattern in CLCT
     else {
       // ALCT quality is the number of layers hit minus 3.
       const bool a4(aLCT.getQuality() >= 1);
  
       // CLCT quality is the number of layers hit.
       const bool c4(cLCT.getQuality() >= 4);
  
       // quality = 4; "reserved for low-quality muons in future"
  
       // marginal anode and cathode
       if (!a4 && !c4)
         return LCT_Quality::MARGINAL_ANODE_CATHODE;
  
       // HQ anode, but marginal cathode
       else if (a4 && !c4)
         return LCT_Quality::HQ_ANODE_MARGINAL_CATHODE;
  
       // HQ cathode, but marginal anode
       else if (!a4 && c4)
         return LCT_Quality::HQ_CATHODE_MARGINAL_ANODE;
  
       // HQ muon, but accelerator ALCT
       else if (a4 && c4) {
         if (aLCT.getAccelerator())
           return LCT_Quality::HQ_ACCEL_ALCT;
  
         else {
           // quality =  9; "reserved for HQ muons with future patterns
           // quality = 10; "reserved for HQ muons with future patterns
  
           // High quality muons are determined by their CLCT pattern
           if (pattern == 2 || pattern == 3)
             return LCT_Quality::HQ_PATTERN_2_3;
  
           else if (pattern == 4 || pattern == 5)
             return LCT_Quality::HQ_PATTERN_4_5;
  
           else if (pattern == 6 || pattern == 7)
             return LCT_Quality::HQ_PATTERN_6_7;
  
           else if (pattern == 8 || pattern == 9)
             return LCT_Quality::HQ_PATTERN_8_9;
  
           else if (pattern == 10)
             return LCT_Quality::HQ_PATTERN_10;
  
           else {
             edm::LogWarning("CSCMotherboard")
                 << "findQuality: Unexpected CLCT pattern id = " << pattern << " in " << theCSCName_;
             return LCT_Quality::INVALID;
           }
         }
       }
     }
   }
   return LCT_Quality::INVALID;
 }

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

Referenced by constructLCTs().

◆ findQualityRun3()

CSCMotherboard::LCT_QualityRun3 CSCMotherboard::findQualityRun3	(	const CSCALCTDigi &	aLCT,
		const CSCCLCTDigi &	cLCT
	)		const

protected

Definition at line 635 of file CSCMotherboard.cc.

                                                                                                {
   // Run-3 definition
   if (!(aLCT.isValid()) and !(cLCT.isValid())) {
     return LCT_QualityRun3::INVALID;
   }
   // use number of layers on each as indicator
   else {
     bool a4 = (aLCT.getQuality() >= 1);
     bool a5 = (aLCT.getQuality() >= 1);
     bool a6 = (aLCT.getQuality() >= 1);
  
     bool c4 = (cLCT.getQuality() >= 4);
     bool c5 = (cLCT.getQuality() >= 4);
     bool c6 = (cLCT.getQuality() >= 4);
     if (a6 or c6)
       return LCT_QualityRun3::HighQ;
     else if (a5 or c5)
       return LCT_QualityRun3::MedQ;
     else if (a4 or c4)
       return LCT_QualityRun3::LowQ;
   }
   return LCT_QualityRun3::INVALID;
 }

References CSCALCTDigi::getQuality(), CSCCLCTDigi::getQuality(), HighQ, INVALID, CSCALCTDigi::isValid(), CSCCLCTDigi::isValid(), LowQ, MedQ, and or.

Referenced by constructLCTs().

◆ getBXShiftedALCT()

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

protected

Definition at line 699 of file CSCMotherboard.cc.

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

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

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

◆ getBXShiftedCLCT()

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

protected

Definition at line 705 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().

◆ getLCTs()

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

Returns vector of all found correlated LCTs, if any.

Definition at line 416 of file CSCMotherboard.cc.

                                                               {
   std::vector<CSCCorrelatedLCTDigi> tmpV;
  
   // Do not report LCTs found in ME1/A if mpc_block_me1/a is set.
   for (int bx = 0; bx < CSCConstants::MAX_LCT_TBINS; bx++) {
     if (firstLCT[bx].isValid())
       if (!mpc_block_me1a || (!isME11_ || firstLCT[bx].getStrip() <= CSCConstants::MAX_HALF_STRIP_ME1B))
         tmpV.push_back(firstLCT[bx]);
     if (secondLCT[bx].isValid())
       if (!mpc_block_me1a || (!isME11_ || secondLCT[bx].getStrip() <= CSCConstants::MAX_HALF_STRIP_ME1B))
         tmpV.push_back(secondLCT[bx]);
   }
   return tmpV;
 }

References l1GtPatternGenerator_cfi::bx, firstLCT, CSCBaseboard::isME11_, sistrip::SpyUtilities::isValid(), CSCConstants::MAX_HALF_STRIP_ME1B, CSCConstants::MAX_LCT_TBINS, mpc_block_me1a, and secondLCT.

Referenced by readoutLCTs().

◆ readoutLCTs()

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

virtual

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

Reimplemented in CSCUpgradeMotherboard, and CSCGEMMotherboardME21.

Definition at line 332 of file CSCMotherboard.cc.

                                                                   {
   std::vector<CSCCorrelatedLCTDigi> tmpV;
  
   // The start time of the L1A*LCT coincidence window should be related
   // to the fifo_pretrig parameter, but I am not completely sure how.
   // Just choose it such that the window is centered at bx=7.  This may
   // need further tweaking if the value of tmb_l1a_window_size changes.
   //static int early_tbins = 4;
  
   // Empirical correction to match 2009 collision data (firmware change?)
   int lct_bins = tmb_l1a_window_size;
   int late_tbins = early_tbins + lct_bins;
  
   int ifois = 0;
   if (ifois == 0) {
     if (infoV >= 0 && early_tbins < 0) {
       edm::LogWarning("CSCMotherboard|SuspiciousParameters")
           << "+++ early_tbins = " << early_tbins << "; in-time LCTs are not getting read-out!!! +++"
           << "\n";
     }
  
     if (late_tbins > CSCConstants::MAX_LCT_TBINS - 1) {
       if (infoV >= 0)
         edm::LogWarning("CSCMotherboard|SuspiciousParameters")
             << "+++ Allowed range of time bins, [0-" << late_tbins << "] exceeds max allowed, "
             << CSCConstants::MAX_LCT_TBINS - 1 << " +++\n"
             << "+++ Set late_tbins to max allowed +++\n";
       late_tbins = CSCConstants::MAX_LCT_TBINS - 1;
     }
     ifois = 1;
   }
  
   // Start from the vector of all found correlated LCTs and select
   // those within the LCT*L1A coincidence window.
   int bx_readout = -1;
   const std::vector<CSCCorrelatedLCTDigi>& all_lcts = getLCTs();
   for (auto plct = all_lcts.begin(); plct != all_lcts.end(); plct++) {
     if (!plct->isValid())
       continue;
  
     int bx = (*plct).getBX();
     // Skip LCTs found too early relative to L1Accept.
     if (bx <= early_tbins) {
       if (infoV > 1)
         LogDebug("CSCMotherboard") << " Do not report correlated LCT on key halfstrip " << plct->getStrip()
                                    << " and key wire " << plct->getKeyWG() << ": found at bx " << bx
                                    << ", whereas the earliest allowed bx is " << early_tbins + 1;
       continue;
     }
  
     // Skip LCTs found too late relative to L1Accept.
     if (bx > late_tbins) {
       if (infoV > 1)
         LogDebug("CSCMotherboard") << " Do not report correlated LCT on key halfstrip " << plct->getStrip()
                                    << " and key wire " << plct->getKeyWG() << ": found at bx " << bx
                                    << ", whereas the latest allowed bx is " << late_tbins;
       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(*plct);
         if (bx_readout == -1)
           bx_readout = bx;
       }
     }
     // if readout_earliest_2 == false, save all LCTs
     else
       tmpV.push_back(*plct);
   }
  
   // 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, early_tbins, getLCTs(), CSCBaseboard::infoV, LogDebug, CSCConstants::MAX_LCT_TBINS, qualityControl_, readout_earliest_2, and tmb_l1a_window_size.

Referenced by CSCTriggerPrimitivesBuilder::build().

◆ run()

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

virtual

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

Reimplemented in CSCUpgradeMotherboard, and CSCMotherboardME11.

Definition at line 131 of file CSCMotherboard.cc.

                                                                                                        {
   // clear the ALCT/CLCT/LCT containers. Clear the processors
   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_);
  
   alctV = alctProc->run(wiredc);  // run anodeLCT
   clctV = clctProc->run(compdc);  // run cathodeLCT
  
   // if there are no ALCTs and no CLCTs, it does not make sense to run this TMB
   if (alctV.empty() and clctV.empty())
     return;
  
   // encode high multiplicity bits
   unsigned alctBits = alctProc->getHighMultiplictyBits();
   encodeHighMultiplicityBits(alctBits);
  
   // CLCT-centric matching
   if (clct_to_alct) {
     int used_alct_mask[20];
     for (int a = 0; a < 20; ++a)
       used_alct_mask[a] = 0;
  
     int bx_alct_matched = 0;  // bx of last matched ALCT
     for (int bx_clct = 0; bx_clct < CSCConstants::MAX_CLCT_TBINS; bx_clct++) {
       // There should be at least one valid ALCT or CLCT 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 (clctProc->getBestCLCT(bx_clct).isValid()) {
         // Look for ALCTs within the match-time window.  The window is
         // centered at the CLCT 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;
         const int bx_alct_start = bx_clct - match_trig_window_size / 2 + CSCConstants::ALCT_CLCT_OFFSET;
         const int bx_alct_stop = bx_clct + match_trig_window_size / 2 + CSCConstants::ALCT_CLCT_OFFSET;
  
         for (int bx_alct = bx_alct_start; bx_alct <= bx_alct_stop; bx_alct++) {
           if (bx_alct < 0 || bx_alct >= CSCConstants::MAX_ALCT_TBINS)
             continue;
           // default: do not reuse ALCTs that were used with previous CLCTs
           if (drop_used_alcts && used_alct_mask[bx_alct])
             continue;
           if (alctProc->getBestALCT(bx_alct).isValid()) {
             if (infoV > 1)
               LogTrace("CSCMotherboard") << "Successful CLCT-ALCT match: bx_clct = " << bx_clct << "; match window: ["
                                          << bx_alct_start << "; " << bx_alct_stop << "]; bx_alct = " << bx_alct;
             correlateLCTs(alctProc->getBestALCT(bx_alct),
                           alctProc->getSecondALCT(bx_alct),
                           clctProc->getBestCLCT(bx_clct),
                           clctProc->getSecondCLCT(bx_clct),
                           CSCCorrelatedLCTDigi::CLCTALCT);
             used_alct_mask[bx_alct] += 1;
             is_matched = true;
             bx_alct_matched = bx_alct;
             break;
           }
         }
         // No ALCT within the match time interval found: report CLCT-only LCT
         // (use dummy ALCTs).
         if (!is_matched and clct_trig_enable) {
           if (infoV > 1)
             LogTrace("CSCMotherboard") << "Unsuccessful CLCT-ALCT match (CLCT only): bx_clct = " << bx_clct
                                        << " first ALCT " << clctProc->getBestCLCT(bx_clct) << "; match window: ["
                                        << bx_alct_start << "; " << bx_alct_stop << "]";
           correlateLCTs(alctProc->getBestALCT(bx_clct),
                         alctProc->getSecondALCT(bx_clct),
                         clctProc->getBestCLCT(bx_clct),
                         clctProc->getSecondCLCT(bx_clct),
                         CSCCorrelatedLCTDigi::CLCTONLY);
         }
       }
       // No valid CLCTs; attempt to make ALCT-only LCT.  Use only ALCTs
       // which have zeroth chance to be matched at later cathode times.
       // (I am not entirely sure this perfectly matches the firmware logic.)
       // Use dummy CLCTs.
       else {
         int bx_alct = bx_clct - match_trig_window_size / 2;
         if (bx_alct >= 0 && bx_alct > bx_alct_matched) {
           if (alctProc->getBestALCT(bx_alct).isValid() and alct_trig_enable) {
             if (infoV > 1)
               LogTrace("CSCMotherboard") << "Unsuccessful CLCT-ALCT match (ALCT only): bx_alct = " << bx_alct;
             correlateLCTs(alctProc->getBestALCT(bx_alct),
                           alctProc->getSecondALCT(bx_alct),
                           clctProc->getBestCLCT(bx_clct),
                           clctProc->getSecondCLCT(bx_clct),
                           CSCCorrelatedLCTDigi::ALCTONLY);
           }
         }
       }
     }
   }
   // ALCT-centric matching
   else {
     int used_clct_mask[20];
     for (int a = 0; a < 20; ++a)
       used_clct_mask[a] = 0;
  
     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;
         const int bx_clct_start = bx_alct - match_trig_window_size / 2 - CSCConstants::ALCT_CLCT_OFFSET;
         const int bx_clct_stop = bx_alct + match_trig_window_size / 2 - CSCConstants::ALCT_CLCT_OFFSET;
  
         for (int bx_clct = bx_clct_start; bx_clct <= bx_clct_stop; bx_clct++) {
           if (bx_clct < 0 || bx_clct >= CSCConstants::MAX_CLCT_TBINS)
             continue;
           // default: do not reuse CLCTs that were used with previous ALCTs
           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 << "; match window: ["
                                          << bx_clct_start << "; " << bx_clct_stop << "]; bx_clct = " << bx_clct;
             correlateLCTs(alctProc->getBestALCT(bx_alct),
                           alctProc->getSecondALCT(bx_alct),
                           clctProc->getBestCLCT(bx_clct),
                           clctProc->getSecondCLCT(bx_clct),
                           CSCCorrelatedLCTDigi::ALCTCLCT);
             used_clct_mask[bx_clct] += 1;
             is_matched = true;
             bx_clct_matched = bx_clct;
             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) << "; match window: ["
                                        << bx_clct_start << "; " << bx_clct_stop << "]";
           if (alct_trig_enable)
             correlateLCTs(alctProc->getBestALCT(bx_alct),
                           alctProc->getSecondALCT(bx_alct),
                           clctProc->getBestCLCT(bx_alct),
                           clctProc->getSecondCLCT(bx_alct),
                           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),
                           CSCCorrelatedLCTDigi::CLCTONLY);
           }
         }
       }
     }
   }
  
   // Debug first and second LCTs
   if (infoV > 0) {
     for (int bx = 0; bx < CSCConstants::MAX_LCT_TBINS; bx++) {
       if (firstLCT[bx].isValid())
         LogDebug("CSCMotherboard") << firstLCT[bx];
       if (secondLCT[bx].isValid())
         LogDebug("CSCMotherboard") << secondLCT[bx];
     }
   }
 }

References a, CSCConstants::ALCT_CLCT_OFFSET, alct_trig_enable, CSCCorrelatedLCTDigi::ALCTCLCT, CSCCorrelatedLCTDigi::ALCTONLY, alctProc, alctV, l1GtPatternGenerator_cfi::bx, clct_to_alct, clct_trig_enable, CSCCorrelatedLCTDigi::CLCTALCT, CSCCorrelatedLCTDigi::CLCTONLY, clctProc, clctV, clear(), correlateLCTs(), CSCBaseboard::cscGeometry_, drop_used_alcts, drop_used_clcts, encodeHighMultiplicityBits(), firstLCT, CSCBaseboard::infoV, sistrip::SpyUtilities::isValid(), LogDebug, LogTrace, match_trig_window_size, CSCConstants::MAX_ALCT_TBINS, CSCConstants::MAX_CLCT_TBINS, CSCConstants::MAX_LCT_TBINS, and secondLCT.

Referenced by CSCTriggerPrimitivesBuilder::build().

◆ setConfigParameters()

void CSCMotherboard::setConfigParameters ( const CSCDBL1TPParameters * conf )

Set configuration parameters obtained via EventSetup mechanism.

Definition at line 108 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;
   }
 }