#include <CSCMotherboard.h>

Inheritance diagram for CSCMotherboard:

Public Member Functions
void	clear ()

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

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

CSCShowerDigi	readoutShower () const

void	run (const CSCWireDigiCollection wiredc, const CSCComparatorDigiCollection compdc)

void	selectLCTs ()

void	setConfigParameters (const CSCDBL1TPParameters *conf)

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, const edm::ParameterSet &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	copyValidToInValid (CSCALCTDigi &, CSCALCTDigi &, CSCCLCTDigi &, CSCCLCTDigi &) const

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

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 (bool bunch_crossing_mask[CSCConstants::MAX_ALCT_TBINS])

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

std::vector< int >	preferred_bx_match_

std::unique_ptr < LCTQualityAssignment >	qualityAssignment_

std::unique_ptr < LCTQualityControl >	qualityControl_

bool	readout_earliest_2

CSCShowerDigi	shower_

unsigned	showerSource_

unsigned int	tmb_l1a_window_size

Protected Attributes inherited from CSCBaseboard
edm::ParameterSet	alctParams_

edm::ParameterSet	clctParams_

edm::ParameterSet	commonParams_

const CSCChamber *	cscChamber_

const CSCGeometry *	cscGeometry_

CSCDetId	cscId_

bool	disableME1a_

bool	enableAlctPhase2_

bool	gangedME1a_

int	infoV

bool	isME11_

bool	isME12_

bool	isME13_

bool	isME21_

bool	isME22_

bool	isME31_

bool	isME32_

bool	isME41_

bool	isME42_

bool	runCCLUT_

bool	runCCLUT_OTMB_

bool	runCCLUT_TMB_

bool	runME11ILT_

bool	runME11Up_

bool	runME21ILT_

bool	runME21Up_

bool	runME31Up_

bool	runME41Up_

bool	runPhase2_

edm::ParameterSet	showerParams_

unsigned	theChamber

std::string	theCSCName_

const unsigned	theEndcap

int	theRegion

unsigned	theRing

const unsigned	theSector

const unsigned	theStation

const unsigned	theSubsector

const unsigned	theTrigChamber

edm::ParameterSet	tmbParams_

Static Protected Attributes
static const unsigned int	def_alct_trig_enable = 0

static const unsigned int	def_clct_trig_enable = 0

static const unsigned int	def_match_trig_enable = 1

static const unsigned int	def_match_trig_window_size = 7

static const unsigned int	def_mpc_block_me1a = 1

static const unsigned int	def_tmb_l1a_window_size = 7

Detailed Description

Correlates anode and cathode LCTs from the same chamber.

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

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

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

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

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

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

Definition at line 50 of file CSCMotherboard.h.

Constructor & Destructor Documentation

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.

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

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

CSCMotherboard::~CSCMotherboard ( )

overridedefault

Default destructor.

Member Function Documentation

void CSCMotherboard::checkConfigParameters ( )

protected

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

Definition at line 547 of file CSCMotherboard.cc.

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

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

void CSCMotherboard::clear ( void )

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

Definition at line 84 of file CSCMotherboard.cc.

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

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();
 
   // reset the shower trigger
   shower_.clear();
 }

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

protected

Definition at line 477 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());
   }
 }

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

protected

Definition at line 447 of file CSCMotherboard.cc.

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

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

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

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

References alct_trig_enable, clct_trig_enable, CSCCLCTDigi::clear(), constructLCTs(), copyValidToInValid(), 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();
 
   // check which ALCTs and CLCTs are valid
   // if the best ALCT/CLCT is valid, but the second ALCT/CLCT is not,
   // the information is copied over
   copyValidToInValid(bestALCT, secondALCT, bestCLCT, secondCLCT);
 
   // ALCT-only LCTs
   const bool bestCase1(alct_trig_enable and bestALCT.isValid());
   // CLCT-only LCTs
   const bool bestCase2(clct_trig_enable and bestCLCT.isValid());
   /*
     Normal case: ALCT-CLCT matched LCTs. We require ALCT and CLCT to be valid.
     Optionally, we can check if the ALCT cross the CLCT. This check will always return true
     for a valid ALCT-CLCT pair in non-ME1/1 chambers. For ME1/1 chambers, it returns true,
     only when the ALCT-CLCT pair crosses and when the parameter "checkAlctCrossClct" is set to True.
     It is recommended to keep "checkAlctCrossClct" set to False, so that the EMTF receives
     all information, even if it's unphysical.
   */
   const bool bestCase3(match_trig_enable and bestALCT.isValid() and bestCLCT.isValid() and
                        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);
     }
   }
 }

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

protected

Definition at line 468 of file CSCMotherboard.cc.

References cscOverlap_, and ignoreAlctCrossClct_.

Referenced by correlateLCTs().

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

void CSCMotherboard::dumpConfigParams ( ) const

protected

Dump TMB/MPC configuration parameters.

Definition at line 570 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();
 }

void CSCMotherboard::encodeHighMultiplicityBits ( )

protected

Definition at line 598 of file CSCMotherboard.cc.

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

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

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

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

protected

Definition at line 508 of file CSCMotherboard.cc.

References funct::abs().

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

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

protected

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

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

protected

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

void CSCMotherboard::matchALCTCLCT ( bool bunch_crossing_mask[CSCConstants::MAX_ALCT_TBINS] )

protected

Definition at line 170 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, and preferred_bx_match_.

Referenced by CSCGEMMotherboard::run(), and 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++) {
     // do not consider LCT building in this BX if the mask was set
     // this check should have no effect on the regular LCT finding
     // it does play a role in the LCT finding for GEM-CSC ILTs
     // namely, if a GEM-CSC ILT was found a bunch crossing, the
     // algorithm would skip the bunch crossing for regular LCT finding
     if (bunch_crossing_mask[bx_alct])
       continue;
 
     // There should be at least one valid CLCT or ALCT for a
     // correlated LCT to be formed.  Decision on whether to reject
     // non-complete LCTs (and if yes of which type) is made further
     // upstream.
     if (alctProc->getBestALCT(bx_alct).isValid()) {
       // Look for CLCTs within the match-time window.  The window is
       // centered at the ALCT bx; therefore, we make an assumption
       // that anode and cathode hits are perfectly synchronized.  This
       // is always true for MC, but only an approximation when the
       // data is analyzed (which works fairly good as long as wide
       // windows are used).  To get rid of this assumption, one would
       // need to access "full BX" words, which are not readily
       // available.
       bool is_matched = false;
       // loop on the preferred "delta BX" array
       for (unsigned mbx = 0; mbx < match_trig_window_size; mbx++) {
         // evaluate the preffered CLCT BX, taking into account that there is an offset in the simulation
         unsigned bx_clct = bx_alct + preferred_bx_match_[mbx] - CSCConstants::ALCT_CLCT_OFFSET;
         // check that the CLCT BX is valid
         if (bx_clct >= CSCConstants::MAX_CLCT_TBINS)
           continue;
         // do not consider previously matched CLCTs
         if (drop_used_clcts && used_clct_mask[bx_clct])
           continue;
         // 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;
             bunch_crossing_mask[bx_alct] = 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);
         }
       }
     }
   }
 }

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

virtual

Definition at line 282 of file CSCMotherboard.cc.

References makePileupJSON::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);
   }
 
   return tmpV;
 }

CSCShowerDigi CSCMotherboard::readoutShower ( ) const

Returns shower bits

Definition at line 375 of file CSCMotherboard.cc.

References shower_.

Referenced by CSCTriggerPrimitivesBuilder::build().

375 { return shower_; }

CSCMotherboard::shower_

CSCShowerDigi shower_

Definition: CSCMotherboard.h:126

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

References alctProc, alctV, clctProc, clctV, clear(), CSCBaseboard::cscGeometry_, encodeHighMultiplicityBits(), lookupTableCCLUT_, matchALCTCLCT(), CSCConstants::MAX_ALCT_TBINS, 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
   bool bunch_crossing_mask[CSCConstants::MAX_ALCT_TBINS] = {false};
   matchALCTCLCT(bunch_crossing_mask);
 
   // Step 4: Select at most 2 LCTs per BX
   selectLCTs();
 }

void CSCMotherboard::selectLCTs ( )

Definition at line 517 of file CSCMotherboard.cc.

References allLCTs_, makePileupJSON::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;
     }
   }
 }

void CSCMotherboard::setConfigParameters ( const CSCDBL1TPParameters * conf )

Set configuration parameters obtained via EventSetup mechanism.

Definition at line 103 of file CSCMotherboard.cc.

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

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