#include <CSCMotherboard.h>

Inheritance diagram for CSCMotherboard:

Public Member Functions
void	clear ()

	CSCMotherboard (unsigned endcap, unsigned station, unsigned sector, unsigned subsector, unsigned chamber, CSCBaseboard::Parameters &conf)

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

std::vector< CSCShowerDigi >	readoutShower () const

void	run (const CSCWireDigiCollection wiredc, const CSCComparatorDigiCollection compdc)

void	selectLCTs ()

void	setConfigParameters (const CSCDBL1TPParameters *conf)

void	setESLookupTables (const CSCL1TPLookupTableCCLUT *conf)

void	setESLookupTables (const CSCL1TPLookupTableME11ILT *conf)

void	setESLookupTables (const CSCL1TPLookupTableME21ILT *conf)

	~CSCMotherboard () override=default

Public Member Functions inherited from CSCBaseboard
	CSCBaseboard (unsigned endcap, unsigned station, unsigned sector, unsigned subsector, unsigned chamber, Parameters &conf)

	CSCBaseboard ()

std::string	getCSCName () const

CSCDetId	id () 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	copyValidToInValidALCT (CSCALCTDigi &, CSCALCTDigi &) const

void	copyValidToInValidCLCT (CSCCLCTDigi &, CSCCLCTDigi &) const

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

bool	doesALCTCrossCLCT (const CSCALCTDigi &, const CSCCLCTDigi &) const

void	dumpConfigParams () const

void	encodeHighMultiplicityBits ()

unsigned int	encodePattern (const int clctPattern) const

CSCALCTDigi	getBXShiftedALCT (const CSCALCTDigi &) const

CSCCLCTDigi	getBXShiftedCLCT (const CSCCLCTDigi &) const

void	matchALCTCLCT ()

void	matchShowers (CSCShowerDigi anode_showers, CSCShowerDigi cathode_showers, bool andlogic)

void	sortCLCTByQualBend (int alct_bx, std::vector< unsigned > &clctBxVector)

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

bool	ignoreAlctCrossClct_

std::vector< CSCCorrelatedLCTDigi >	lctV

const CSCL1TPLookupTableCCLUT *	lookupTableCCLUT_

const CSCL1TPLookupTableME11ILT *	lookupTableME11ILT_

const CSCL1TPLookupTableME21ILT *	lookupTableME21ILT_

bool	match_earliest_clct_only_

unsigned int	match_trig_enable

unsigned int	match_trig_window_size

unsigned	maxbx_readout_

unsigned	minbx_readout_

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	showers_ [CSCConstants::MAX_LCT_TBINS]

std::vector< unsigned >	showerSource_

bool	sort_clct_bx_

unsigned	thisShowerSource_

unsigned int	tmb_l1a_window_size

Protected Attributes inherited from CSCBaseboard
const CSCChamber *	cscChamber_

const CSCGeometry *	cscGeometry_

CSCDetId	cscId_

bool	disableME1a_

bool	enableAlctPhase2_

bool	gangedME1a_

int	infoV

bool	isME11_

bool	isME12_

bool	isME13_

bool	isME21_

bool	isME22_

bool	isME31_

bool	isME32_

bool	isME41_

bool	isME42_

bool	run3_

bool	runCCLUT_

bool	runCCLUT_OTMB_

bool	runCCLUT_TMB_

bool	runME11ILT_

bool	runME11Up_

bool	runME21ILT_

bool	runME21Up_

bool	runME31Up_

bool	runME41Up_

bool	runPhase2_

unsigned	theChamber

std::string	theCSCName_

const unsigned	theEndcap

int	theRegion

unsigned	theRing

const unsigned	theSector

const unsigned	theStation

const unsigned	theSubsector

const unsigned	theTrigChamber

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, Sven Dildick and Giovanni Mocellin

Definition at line 50 of file CSCMotherboard.h.

Constructor & Destructor Documentation

◆ CSCMotherboard()

CSCMotherboard::CSCMotherboard	(	unsigned	endcap,
		unsigned	station,
		unsigned	sector,
		unsigned	subsector,
		unsigned	chamber,
		CSCBaseboard::Parameters &	conf
	)

Normal constructor.

Definition at line 13 of file CSCMotherboard.cc.

References alct_trig_enable, alctProc, allLCTs_, cms::cuda::assert(), relativeConstraints::chamber, checkConfigParameters(), clct_trig_enable, clctProc, CSCBaseboard::Parameters::conf(), cscOverlap_, drop_used_clcts, dumpConfigParams(), early_tbins, CSCBaseboard::enableAlctPhase2_, makeMuonMisalignmentScenario::endcap, edm::ParameterSet::getParameter(), CSCDetId::iChamberType(), ignoreAlctCrossClct_, CSCBaseboard::infoV, CSCConstants::LCT_CENTRAL_BX, match_earliest_clct_only_, match_trig_enable, match_trig_window_size, maxbx_readout_, minbx_readout_, mpc_block_me1a, preferred_bx_match_, qualityAssignment_, qualityControl_, readout_earliest_2, CSCBaseboard::runPhase2_, hgcalTBTopologyTester_cfi::sector, LCTContainer::setMatchTrigWindowSize(), CSCBaseboard::Parameters::showerParams(), showerSource_, sort_clct_bx_, relativeConstraints::station, CSCBaseboard::theRing, CSCBaseboard::theStation, thisShowerSource_, tmb_l1a_window_size, and CSCBaseboard::Parameters::tmbParams().

     : 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 = conf.tmbParams().getParameter<unsigned int>("mpcBlockMe1a");
   alct_trig_enable = conf.tmbParams().getParameter<unsigned int>("alctTrigEnable");
   clct_trig_enable = conf.tmbParams().getParameter<unsigned int>("clctTrigEnable");
   match_trig_enable = conf.tmbParams().getParameter<unsigned int>("matchTrigEnable");
   match_trig_window_size = conf.tmbParams().getParameter<unsigned int>("matchTrigWindowSize");
   tmb_l1a_window_size =  // Common to CLCT and TMB
       conf.tmbParams().getParameter<unsigned int>("tmbL1aWindowSize");
 
   // configuration handle for number of early time bins
   early_tbins = conf.tmbParams().getParameter<int>("tmbEarlyTbins");
 
   // whether to not reuse CLCTs that were used by previous matching ALCTs
   drop_used_clcts = conf.tmbParams().getParameter<bool>("tmbDropUsedClcts");
 
   // whether to readout only the earliest two LCTs in readout window
   readout_earliest_2 = conf.tmbParams().getParameter<bool>("tmbReadoutEarliest2");
 
   match_earliest_clct_only_ = conf.tmbParams().getParameter<bool>("matchEarliestClctOnly");
 
   infoV = conf.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_ = conf.tmbParams().getParameter<std::vector<int>>("preferredBxMatch");
 
   // sort CLCT only by bx or by quality+bending for  ALCT-CLCT match
   sort_clct_bx_ = conf.tmbParams().getParameter<bool>("sortClctBx");
 
   // 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_ = conf.showerParams().getParameter<std::vector<unsigned>>("source");
 
   unsigned csc_idx = CSCDetId::iChamberType(theStation, theRing) - 2;
   thisShowerSource_ = showerSource_[csc_idx];
 
   // shower readout window
   minbx_readout_ = CSCConstants::LCT_CENTRAL_BX - tmb_l1a_window_size / 2;
   maxbx_readout_ = CSCConstants::LCT_CENTRAL_BX + tmb_l1a_window_size / 2;
   assert(tmb_l1a_window_size / 2 <= CSCConstants::LCT_CENTRAL_BX);
 
   // 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
   ignoreAlctCrossClct_ = conf.tmbParams().getParameter<bool>("ignoreAlctCrossClct");
   if (!ignoreAlctCrossClct_) {
     cscOverlap_ = std::make_unique<CSCALCTCrossCLCT>(endcap, station, theRing, ignoreAlctCrossClct_, conf.conf());
   }
 }

◆ ~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 611 of file CSCMotherboard.cc.

References alct_trig_enable, cms::cuda::assert(), 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, CSCConstants::LCT_CENTRAL_BX, match_trig_enable, match_trig_window_size, mpc_block_me1a, and tmb_l1a_window_size.

Referenced by CSCMotherboard(), and setConfigParameters().

                                            {
   // 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");
   assert(tmb_l1a_window_size / 2 <= CSCConstants::LCT_CENTRAL_BX);
 }

◆ clear()

void CSCMotherboard::clear ( void )

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

Definition at line 95 of file CSCMotherboard.cc.

References alctProc, alctV, allLCTs_, l1GtPatternGenerator_cfi::bx, clctProc, clctV, CSCShowerDigi::clear(), LCTContainer::clear(), lctV, CSCConstants::MAX_LCT_TBINS, and showers_.

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

                            {
   // 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();
 
   for (int bx = 0; bx < CSCConstants::MAX_LCT_TBINS; bx++) {
     showers_[bx].clear();
   }
 }

◆ constructLCTs()

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

protected

Definition at line 504 of file CSCMotherboard.cc.

Referenced by correlateLCTs().

                                                                                                                  {
   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());
   }
 }

◆ copyValidToInValidALCT()

void CSCMotherboard::copyValidToInValidALCT	(	CSCALCTDigi &	bestALCT,
		CSCALCTDigi &	secondALCT
	)		const

protected

Definition at line 484 of file CSCMotherboard.cc.

References CSCALCTDigi::isValid().

Referenced by correlateLCTs().

                                                                                                 {
   if (bestALCT.isValid() and !secondALCT.isValid())
     secondALCT = bestALCT;
 }

◆ copyValidToInValidCLCT()

void CSCMotherboard::copyValidToInValidCLCT	(	CSCCLCTDigi &	bestCLCT,
		CSCCLCTDigi &	secondCLCT
	)		const

protected

Definition at line 490 of file CSCMotherboard.cc.

References CSCCLCTDigi::isValid().

Referenced by correlateLCTs().

                                                                                                 {
   if (bestCLCT.isValid() and !secondCLCT.isValid())
     secondCLCT = bestCLCT;
 }

◆ 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 414 of file CSCMotherboard.cc.

References alct_trig_enable, clct_trig_enable, CSCCLCTDigi::clear(), constructLCTs(), copyValidToInValidALCT(), copyValidToInValidCLCT(), doesALCTCrossCLCT(), CSCCLCTDigi::getQuality(), CSCALCTDigi::isValid(), CSCCLCTDigi::isValid(), match_trig_enable, and or.

Referenced by matchALCTCLCT().

                                                    {
   CSCALCTDigi bestALCT = bALCT;
   CSCALCTDigi secondALCT = sALCT;
   CSCCLCTDigi bestCLCT = bCLCT;
   CSCCLCTDigi secondCLCT = sCLCT;
 
   // extra check to make sure that both CLCTs have at least 4 layers
   // for regular ALCT-CLCT type LCTs. A check was already done on the
   // best CLCT, but not yet on the second best CLCT. The check on best
   // CLCT is repeated for completeness
   if (bestCLCT.getQuality() <= 3)
     bestCLCT.clear();
   if (secondCLCT.getQuality() <= 3)
     secondCLCT.clear();
 
   // if the best ALCT/CLCT is valid, but the second ALCT/CLCT is not,
   // the information is copied over
   copyValidToInValidALCT(bestALCT, secondALCT);
   copyValidToInValidCLCT(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
                        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
                          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);
   }
 }

◆ doesALCTCrossCLCT()

bool CSCMotherboard::doesALCTCrossCLCT	(	const CSCALCTDigi &	alct,
		const CSCCLCTDigi &	clct
	)		const

protected

Definition at line 495 of file CSCMotherboard.cc.

References cscOverlap_, and ignoreAlctCrossClct_.

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

                                                                                              {
   if (ignoreAlctCrossClct_)
     return true;
   else
     return cscOverlap_->doesALCTCrossCLCT(alct, clct);
 }

◆ dumpConfigParams()

void CSCMotherboard::dumpConfigParams ( ) const

protected

Dump TMB/MPC configuration parameters.

Definition at line 635 of file CSCMotherboard.cc.

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().

                                             {
   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();
 }

◆ encodeHighMultiplicityBits()

void CSCMotherboard::encodeHighMultiplicityBits ( )

protected

Definition at line 712 of file CSCMotherboard.cc.

References alctProc, clctProc, filterCSVwithJSON::copy, matchShowers(), CSCConstants::MAX_ALCT_TBINS, CSCConstants::MAX_CLCT_TBINS, showers_, and thisShowerSource_.

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

                                                 {
   // get the high multiplicity
   // for anode this reflects what is already in the anode CSCShowerDigi object
   CSCShowerDigi cathode_showers[CSCConstants::MAX_CLCT_TBINS];
   CSCShowerDigi anode_showers[CSCConstants::MAX_ALCT_TBINS];
   auto cshowers_v = clctProc->getAllShower();
   auto ashowers_v = alctProc->getAllShower();
 
   std::copy(cshowers_v.begin(), cshowers_v.end(), cathode_showers);
   std::copy(ashowers_v.begin(), ashowers_v.end(), anode_showers);
 
   // set the value according to source
   switch (thisShowerSource_) {
     case 0:
       std::copy(std::begin(cathode_showers), std::end(cathode_showers), std::begin(showers_));
       break;
     case 1:
       std::copy(std::begin(anode_showers), std::end(anode_showers), std::begin(showers_));
       break;
     case 2:
       matchShowers(anode_showers, cathode_showers, false);
       break;
     case 3:
       matchShowers(anode_showers, cathode_showers, true);
       break;
     default:
       std::copy(std::begin(anode_showers), std::end(anode_showers), std::begin(showers_));
       break;
   };
 }

◆ encodePattern()

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

protected

Definition at line 535 of file CSCMotherboard.cc.

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

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

                                                               {
   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;
 }

◆ getBXShiftedALCT()

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

protected

Definition at line 651 of file CSCMotherboard.cc.

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

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

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

◆ getBXShiftedCLCT()

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

protected

Definition at line 657 of file CSCMotherboard.cc.

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

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

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

◆ matchALCTCLCT()

void CSCMotherboard::matchALCTCLCT ( )

protected

Definition at line 183 of file CSCMotherboard.cc.

References CSCConstants::ALCT_CLCT_OFFSET, alct_trig_enable, CSCCorrelatedLCTDigi::ALCTCLCT, CSCCorrelatedLCTDigi::ALCTONLY, alctProc, allLCTs_, clct_trig_enable, CSCCorrelatedLCTDigi::CLCTONLY, clctProc, correlateLCTs(), drop_used_clcts, CSCBaseboard::infoV, LogTrace, match_earliest_clct_only_, match_trig_window_size, CSCConstants::MAX_ALCT_TBINS, CSCConstants::MAX_CLCT_TBINS, or, preferred_bx_match_, sort_clct_bx_, and sortCLCTByQualBend().

Referenced by run().

                                    {
   // 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;
       // we can use single value to best CLCT but here use vector to keep the
       // the future option to do multiple ALCT-CLCT matches wiht CLCT from different bx
       std::vector<unsigned> clctBx_qualbend_match;
       sortCLCTByQualBend(bx_alct, clctBx_qualbend_match);
 
       bool hasLocalShower = false;
       for (unsigned ibx = 1; ibx <= match_trig_window_size / 2; ibx++)
         hasLocalShower =
             (hasLocalShower or clctProc->getLocalShowerFlag(bx_alct - CSCConstants::ALCT_CLCT_OFFSET - ibx));
 
       // 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
         //bx_clct_run2 would be overflow when bx_alct is small but it is okay
         unsigned bx_clct_run2 = bx_alct + preferred_bx_match_[mbx] - CSCConstants::ALCT_CLCT_OFFSET;
         unsigned bx_clct_qualbend = clctBx_qualbend_match[mbx];
         unsigned bx_clct = (sort_clct_bx_ or not(hasLocalShower)) ? bx_clct_run2 : bx_clct_qualbend;
         // 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;
         // only consider >=4 layer CLCTs for ALCT-CLCT type LCTs
         // this condition is lowered to >=3 layers for CLCTs in the
         // matchALCTCLCTGEM function
         if (clctProc->getBestCLCT(bx_clct).getQuality() <= 3)
           continue;
         // a valid CLCT with sufficient layers!
         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;
             bx_clct_matched = bx_clct;
             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);
         }
       }
     }
   }
 }

◆ matchShowers()

void CSCMotherboard::matchShowers	(	CSCShowerDigi *	anode_showers,
		CSCShowerDigi *	cathode_showers,
		bool	andlogic
	)

protected

Definition at line 663 of file CSCMotherboard.cc.

References CSCConstants::ALCT_CLCT_OFFSET, l1GtPatternGenerator_cfi::bx, CSCShowerDigi::getComparatorNHits(), CSCShowerDigi::getCSCID(), CSCShowerDigi::getWireNHits(), CSCShowerDigi::isLooseInTime(), CSCShowerDigi::isNominalInTime(), CSCShowerDigi::isTightInTime(), CSCShowerDigi::isValid(), sistrip::SpyUtilities::isValid(), match_trig_window_size, CSCConstants::MAX_ALCT_TBINS, CSCConstants::MAX_CLCT_TBINS, or, preferred_bx_match_, and showers_.

Referenced by encodeHighMultiplicityBits().

                                                                                                              {
   CSCShowerDigi ashower, cshower;
   bool used_cshower_mask[CSCConstants::MAX_CLCT_TBINS] = {false};
   for (unsigned bx = 0; bx < CSCConstants::MAX_ALCT_TBINS; bx++) {
     ashower = anode_showers[bx];
     cshower = CSCShowerDigi();  //use empty shower digi to initialize cshower
     if (ashower.isValid()) {
       for (unsigned mbx = 0; mbx < match_trig_window_size; mbx++) {
         int cbx = bx + preferred_bx_match_[mbx] - CSCConstants::ALCT_CLCT_OFFSET;
         //check bx range [0, CSCConstants::MAX_LCT_TBINS]
         if (cbx < 0 || cbx >= CSCConstants::MAX_CLCT_TBINS)
           continue;
         if (cathode_showers[cbx].isValid() and not used_cshower_mask[cbx]) {
           cshower = cathode_showers[cbx];
           used_cshower_mask[cbx] = true;
           break;
         }
       }
     } else
       cshower = cathode_showers[bx];  //if anode shower is not valid, use the cshower from this bx
 
     //matched HMT, with and/or logic
     unsigned matchHMT = 0;
     if (andlogic) {
       if (ashower.isTightInTime() and cshower.isTightInTime())
         matchHMT = 3;
       else if (ashower.isNominalInTime() and cshower.isNominalInTime())
         matchHMT = 2;
       else if (ashower.isLooseInTime() and cshower.isLooseInTime())
         matchHMT = 1;
     } else {
       if (ashower.isTightInTime() or cshower.isTightInTime())
         matchHMT = 3;
       else if (ashower.isNominalInTime() or cshower.isNominalInTime())
         matchHMT = 2;
       else if (ashower.isLooseInTime() or cshower.isLooseInTime())
         matchHMT = 1;
     }
     //LCTShower with showerType = 3
     showers_[bx] = CSCShowerDigi(matchHMT & 3,
                                  false,
                                  ashower.getCSCID(),
                                  bx,
                                  CSCShowerDigi::ShowerType::kLCTShower,
                                  ashower.getWireNHits(),
                                  cshower.getComparatorNHits());
   }
 }

◆ readoutLCTs()

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

virtual

Definition at line 299 of file CSCMotherboard.cc.

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().

                                                                   {
   // 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
   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;
   }
 
   // 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);
     /*std::cout << "\n########################################## Emu LCT ##########################################\n" << std::endl;
     std::cout << "Emu LCT: " << lct << std::endl;
     std::cout << "\n########################################## THE END ##########################################\n" << std::endl;*/
   }
 
   return tmpV;
 }

◆ readoutShower()

std::vector< CSCShowerDigi > CSCMotherboard::readoutShower ( ) const

Returns shower bits

Definition at line 395 of file CSCMotherboard.cc.

References l1GtPatternGenerator_cfi::bx, sistrip::SpyUtilities::isValid(), CSCConstants::LCT_CENTRAL_BX, maxbx_readout_, hltL1TEGammaFilteredCollectionProducer_cfi::minBX, minbx_readout_, showers_, and tmb_l1a_window_size.

Referenced by CSCTriggerPrimitivesBuilder::build().

                                                              {
   unsigned minBXdiff = 2 * tmb_l1a_window_size;  //impossible value
   unsigned minBX = 0;
   std::vector<CSCShowerDigi> showerOut;
   for (unsigned bx = minbx_readout_; bx < maxbx_readout_; bx++) {
     unsigned bx_diff = (bx > bx - CSCConstants::LCT_CENTRAL_BX) ? bx - CSCConstants::LCT_CENTRAL_BX
                                                                 : CSCConstants::LCT_CENTRAL_BX - bx;
     if (showers_[bx].isValid() and bx_diff < minBXdiff) {
       minBXdiff = bx_diff;
       minBX = bx;
     }
   }
 
   for (unsigned bx = minbx_readout_; bx < maxbx_readout_; bx++)
     if (bx == minBX)
       showerOut.push_back(showers_[bx]);
   return showerOut;
 }

◆ 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 146 of file CSCMotherboard.cc.

References alctProc, alctV, clctProc, clctV, clear(), CSCBaseboard::cscGeometry_, encodeHighMultiplicityBits(), lookupTableCCLUT_, matchALCTCLCT(), CSCBaseboard::runCCLUT_, and selectLCTs().

Referenced by CSCTriggerPrimitivesBuilder::build().

                                                                                                        {
   // 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_);
 
   // set CCLUT parameters if necessary
   if (runCCLUT_) {
     clctProc->setESLookupTables(lookupTableCCLUT_);
   }
 
   // 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;
 
   // step 3: match the ALCTs to the CLCTs
   matchALCTCLCT();
 
   // Step 4: Select at most 2 LCTs per BX
   selectLCTs();
 }

◆ selectLCTs()

void CSCMotherboard::selectLCTs ( )

Definition at line 544 of file CSCMotherboard.cc.

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().

                                 {
   // 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;
     }
   }
 }

◆ setConfigParameters()

void CSCMotherboard::setConfigParameters ( const CSCDBL1TPParameters * conf )

Set configuration parameters obtained via EventSetup mechanism.

Definition at line 115 of file CSCMotherboard.cc.

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

                                                                         {
   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;
   }
   minbx_readout_ = CSCConstants::LCT_CENTRAL_BX - tmb_l1a_window_size / 2;
   maxbx_readout_ = CSCConstants::LCT_CENTRAL_BX + tmb_l1a_window_size / 2;
 }

◆ setESLookupTables() [1/3]

void CSCMotherboard::setESLookupTables ( const CSCL1TPLookupTableCCLUT * conf )

Definition at line 140 of file CSCMotherboard.cc.

References lookupTableCCLUT_.

140 { lookupTableCCLUT_ = conf; }

CSCMotherboard::lookupTableCCLUT_

const CSCL1TPLookupTableCCLUT * lookupTableCCLUT_

Definition: CSCMotherboard.h:112

◆ setESLookupTables() [2/3]

void CSCMotherboard::setESLookupTables ( const CSCL1TPLookupTableME11ILT * conf )

Definition at line 142 of file CSCMotherboard.cc.

References lookupTableME11ILT_.

142 { lookupTableME11ILT_ = conf; }

CSCMotherboard::lookupTableME11ILT_

const CSCL1TPLookupTableME11ILT * lookupTableME11ILT_

Definition: CSCMotherboard.h:113

◆ setESLookupTables() [3/3]

void CSCMotherboard::setESLookupTables ( const CSCL1TPLookupTableME21ILT * conf )

Definition at line 144 of file CSCMotherboard.cc.

References lookupTableME21ILT_.

144 { lookupTableME21ILT_ = conf; }

CSCMotherboard::lookupTableME21ILT_

const CSCL1TPLookupTableME21ILT * lookupTableME21ILT_

Definition: CSCMotherboard.h:114

◆ sortCLCTByQualBend()

void CSCMotherboard::sortCLCTByQualBend	(	int	alct_bx,
		std::vector< unsigned > &	clctBxVector
	)

protected

Definition at line 574 of file CSCMotherboard.cc.

References CSCConstants::ALCT_CLCT_OFFSET, l1GtPatternGenerator_cfi::bx, clctProc, CSCCLCTDigi::getPattern(), CSCCLCTDigi::getQuality(), CSCCLCTDigi::getSlope(), CSCCLCTDigi::isRun3(), match_trig_window_size, CSCConstants::MAX_CLCT_TBINS, and preferred_bx_match_.

Referenced by matchALCTCLCT(), and CSCGEMMotherboard::matchALCTCLCTGEM().

                                                                                       {
   //find clct bx range in [centerbx-window_size/2, center_bx+window_size/2]
   //Then sort CLCT based quality+bend within the match window
   //if two CLCTs from different BX has same qual+bend, the in-time one has higher priority
   clctBxVector.clear();
   int clctQualBendArray[CSCConstants::MAX_CLCT_TBINS + 1] = {0};
   for (unsigned mbx = 0; mbx < match_trig_window_size; mbx++) {
     unsigned bx_clct = bx_alct + preferred_bx_match_[mbx] - CSCConstants::ALCT_CLCT_OFFSET;
     int tempQualBend = 0;
     if (bx_clct >= CSCConstants::MAX_CLCT_TBINS)
       continue;
     if (!clctProc->getBestCLCT(bx_clct).isValid()) {
       clctQualBendArray[bx_clct] = tempQualBend;
       continue;
     }
     CSCCLCTDigi bestCLCT = clctProc->getBestCLCT(bx_clct);
     //for run2 pattern, ignore direction and use &0xe
     //for run3, slope=0 is straighest pattern
     int clctBend = bestCLCT.isRun3() ? (16 - bestCLCT.getSlope()) : (bestCLCT.getPattern() & 0xe);
     //shift quality to left for 4 bits
     int clctQualBend = clctBend | (bestCLCT.getQuality() << 5);
     clctQualBendArray[bx_clct] = clctQualBend;
     if (clctBxVector.empty())
       clctBxVector.push_back(bx_clct);
     else {
       for (auto it = clctBxVector.begin(); it != clctBxVector.end(); it++)
         if (clctQualBend > clctQualBendArray[*it]) {  //insert the Bx with better clct
           clctBxVector.insert(it, bx_clct);
           break;
         }
     }
   }
   //fill rest of vector with MAX_CLCT_TBINS
   for (unsigned bx = clctBxVector.size(); bx < match_trig_window_size; bx++)
     clctBxVector.push_back(CSCConstants::MAX_CLCT_TBINS);
 }

Member Data Documentation

◆ alct_trig_enable

unsigned int CSCMotherboard::alct_trig_enable

protected

Definition at line 134 of file CSCMotherboard.h.

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

◆ alctProc

std::unique_ptr<CSCAnodeLCTProcessor> CSCMotherboard::alctProc

Anode LCT processor.

Definition at line 104 of file CSCMotherboard.h.

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

◆ alctV

std::vector<CSCALCTDigi> CSCMotherboard::alctV

protected

Definition at line 117 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 121 of file CSCMotherboard.h.

Referenced by clear(), CSCMotherboard(), matchALCTCLCT(), CSCGEMMotherboard::matchALCTCLCTGEM(), and selectLCTs().

◆ clct_trig_enable

unsigned int CSCMotherboard::clct_trig_enable

protected

Definition at line 134 of file CSCMotherboard.h.

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

◆ clctProc

std::unique_ptr<CSCCathodeLCTProcessor> CSCMotherboard::clctProc

Cathode LCT processor.

Definition at line 107 of file CSCMotherboard.h.

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

◆ clctV

std::vector<CSCCLCTDigi> CSCMotherboard::clctV

protected

Definition at line 118 of file CSCMotherboard.h.

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

◆ cscOverlap_

std::unique_ptr<CSCALCTCrossCLCT> CSCMotherboard::cscOverlap_

protected

Definition at line 185 of file CSCMotherboard.h.

Referenced by CSCMotherboard(), and doesALCTCrossCLCT().

◆ def_alct_trig_enable

const unsigned int CSCMotherboard::def_alct_trig_enable = 0

staticprotected

Definition at line 169 of file CSCMotherboard.h.

Referenced by checkConfigParameters().

◆ def_clct_trig_enable

const unsigned int CSCMotherboard::def_clct_trig_enable = 0

staticprotected

Definition at line 169 of file CSCMotherboard.h.

Referenced by checkConfigParameters().

◆ def_match_trig_enable

const unsigned int CSCMotherboard::def_match_trig_enable = 1

staticprotected

Definition at line 170 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 170 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 168 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 171 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 138 of file CSCMotherboard.h.

Referenced by CSCMotherboard(), and matchALCTCLCT().

◆ early_tbins

int CSCMotherboard::early_tbins

protected

Phase2: separate handle for early time bins

Definition at line 141 of file CSCMotherboard.h.

Referenced by CSCMotherboard().

◆ ignoreAlctCrossClct_

bool CSCMotherboard::ignoreAlctCrossClct_

protected

Definition at line 155 of file CSCMotherboard.h.

Referenced by CSCMotherboard(), and doesALCTCrossCLCT().

◆ lctV

std::vector<CSCCorrelatedLCTDigi> CSCMotherboard::lctV

protected

Definition at line 124 of file CSCMotherboard.h.

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

◆ lookupTableCCLUT_

const CSCL1TPLookupTableCCLUT* CSCMotherboard::lookupTableCCLUT_

protected

Definition at line 112 of file CSCMotherboard.h.

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

◆ lookupTableME11ILT_

const CSCL1TPLookupTableME11ILT* CSCMotherboard::lookupTableME11ILT_

protected

Definition at line 113 of file CSCMotherboard.h.

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

◆ lookupTableME21ILT_

const CSCL1TPLookupTableME21ILT* CSCMotherboard::lookupTableME21ILT_

protected

Definition at line 114 of file CSCMotherboard.h.

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

◆ match_earliest_clct_only_

bool CSCMotherboard::match_earliest_clct_only_

protected

Definition at line 147 of file CSCMotherboard.h.

Referenced by CSCMotherboard(), and matchALCTCLCT().

◆ match_trig_enable

unsigned int CSCMotherboard::match_trig_enable

protected

Definition at line 134 of file CSCMotherboard.h.

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

◆ match_trig_window_size

unsigned int CSCMotherboard::match_trig_window_size

protected

Definition at line 135 of file CSCMotherboard.h.

Referenced by checkConfigParameters(), CSCMotherboard(), dumpConfigParams(), matchALCTCLCT(), CSCGEMMotherboard::matchALCTCLCTGEM(), matchShowers(), selectLCTs(), setConfigParameters(), and sortCLCTByQualBend().

◆ maxbx_readout_

unsigned CSCMotherboard::maxbx_readout_

protected

Definition at line 153 of file CSCMotherboard.h.

Referenced by CSCMotherboard(), readoutShower(), and setConfigParameters().

◆ minbx_readout_

unsigned CSCMotherboard::minbx_readout_

protected

Definition at line 152 of file CSCMotherboard.h.

Referenced by CSCMotherboard(), readoutShower(), and setConfigParameters().

◆ mpc_block_me1a

unsigned int CSCMotherboard::mpc_block_me1a

protected

Configuration parameters.

Definition at line 133 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 162 of file CSCMotherboard.h.

Referenced by CSCMotherboard(), matchALCTCLCT(), CSCGEMMotherboard::matchALCTCLCTGEM(), matchShowers(), and sortCLCTByQualBend().

◆ qualityAssignment_

std::unique_ptr<LCTQualityAssignment> CSCMotherboard::qualityAssignment_

protected

Definition at line 174 of file CSCMotherboard.h.

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

◆ qualityControl_

std::unique_ptr<LCTQualityControl> CSCMotherboard::qualityControl_

protected

Definition at line 177 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 144 of file CSCMotherboard.h.

Referenced by CSCMotherboard(), and readoutLCTs().

◆ showers_

CSCShowerDigi CSCMotherboard::showers_[CSCConstants::MAX_LCT_TBINS]

protected

Definition at line 126 of file CSCMotherboard.h.

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

◆ showerSource_

std::vector<unsigned> CSCMotherboard::showerSource_

protected

Definition at line 150 of file CSCMotherboard.h.

Referenced by CSCMotherboard().

◆ sort_clct_bx_

bool CSCMotherboard::sort_clct_bx_

protected

Definition at line 165 of file CSCMotherboard.h.

Referenced by CSCMotherboard(), matchALCTCLCT(), and CSCGEMMotherboard::matchALCTCLCTGEM().

◆ thisShowerSource_

unsigned CSCMotherboard::thisShowerSource_

protected

Definition at line 151 of file CSCMotherboard.h.

Referenced by CSCMotherboard(), and encodeHighMultiplicityBits().

◆ tmb_l1a_window_size

unsigned int CSCMotherboard::tmb_l1a_window_size

protected

Definition at line 135 of file CSCMotherboard.h.

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

Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Static Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ CSCMotherboard()

◆ ~CSCMotherboard()

Member Function Documentation

◆ checkConfigParameters()

◆ clear()

◆ constructLCTs()

◆ copyValidToInValidALCT()

◆ copyValidToInValidCLCT()

◆ correlateLCTs()

◆ doesALCTCrossCLCT()

◆ dumpConfigParams()

◆ encodeHighMultiplicityBits()

◆ encodePattern()

◆ getBXShiftedALCT()

◆ getBXShiftedCLCT()

◆ matchALCTCLCT()

◆ matchShowers()

◆ readoutLCTs()

◆ readoutShower()

◆ run()

◆ selectLCTs()

◆ setConfigParameters()

◆ setESLookupTables() [1/3]

◆ setESLookupTables() [2/3]

◆ setESLookupTables() [3/3]

◆ sortCLCTByQualBend()

Member Data Documentation

◆ alct_trig_enable

◆ alctProc

◆ alctV

◆ allLCTs_

◆ clct_trig_enable

◆ clctProc

◆ clctV

◆ cscOverlap_

◆ 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

◆ drop_used_clcts

◆ early_tbins

◆ ignoreAlctCrossClct_

◆ lctV

◆ lookupTableCCLUT_

◆ lookupTableME11ILT_

◆ lookupTableME21ILT_

◆ match_earliest_clct_only_

◆ match_trig_enable

◆ match_trig_window_size

◆ maxbx_readout_

◆ minbx_readout_

◆ mpc_block_me1a

◆ preferred_bx_match_

◆ qualityAssignment_

◆ qualityControl_

◆ readout_earliest_2

◆ showers_

◆ showerSource_

◆ sort_clct_bx_

◆ thisShowerSource_

◆ tmb_l1a_window_size