#include <CSCMotherboardME11.h>

Inheritance diagram for CSCMotherboardME11:

Public Member Functions
void	clear ()

	CSCMotherboardME11 ()

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

std::vector< CSCCorrelatedLCTDigi >	getLCTs1a () const

std::vector< CSCCorrelatedLCTDigi >	getLCTs1b () const

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

std::vector< CSCCorrelatedLCTDigi >	readoutLCTs (int me1ab) const

std::vector< CSCCorrelatedLCTDigi >	readoutLCTs1a () const

std::vector< CSCCorrelatedLCTDigi >	readoutLCTs1b () const

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

void	setConfigParameters (const CSCDBL1TPParameters *conf)

	~CSCMotherboardME11 () override

Public Member Functions inherited from CSCUpgradeMotherboard
void	clear ()

template<class S >
bool	compare (const S &p, const S &q) const

	CSCUpgradeMotherboard ()

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

enum CSCPart	getCSCPart (int keystrip) const

template<class S >
void	intersection (const S &d1, const S &d2, S &result) const

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

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

void	sortLCTs (std::vector< CSCCorrelatedLCTDigi > &lcts, bool(*sorter)(const CSCCorrelatedLCTDigi &, const CSCCorrelatedLCTDigi &)) const

	~CSCUpgradeMotherboard () override

Public Member Functions inherited from CSCMotherboard
void	clear ()

	CSCMotherboard ()

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

std::vector< CSCCorrelatedLCTDigi >	getLCTs () const

void	setConfigParameters (const CSCDBL1TPParameters *conf)

	~CSCMotherboard () override=default

Public Member Functions inherited from CSCBaseboard
	CSCBaseboard ()

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

std::string	getCSCName () const

void	setCSCGeometry (const CSCGeometry *g)

virtual	~CSCBaseboard ()=default

Private Types
enum	{ ME1B = 1, ME1A = 4 }

Private Member Functions
void	correlateLCTsME11 (const CSCALCTDigi &bestALCT, const CSCALCTDigi &secondALCT, const CSCCLCTDigi &bestCLCT, const CSCCLCTDigi &secondCLCT, CSCCorrelatedLCTDigi &lct1, CSCCorrelatedLCTDigi &lct2) const

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

Private Attributes
std::unique_ptr< CSCMotherboardLUTME11 >	cscTmbLUT_

bool	ignoreAlctCrossClct

Additional Inherited Members
Static Public Member Functions inherited from CSCUpgradeMotherboard
static bool	sortLCTsByGEMDphi (const CSCCorrelatedLCTDigi &, const CSCCorrelatedLCTDigi &)

static bool	sortLCTsByQuality (const CSCCorrelatedLCTDigi &, const CSCCorrelatedLCTDigi &)

Public Attributes inherited from CSCMotherboard
std::unique_ptr< CSCAnodeLCTProcessor >	alctProc

std::unique_ptr< CSCCathodeLCTProcessor >	clctProc

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

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

Protected Member Functions inherited from CSCUpgradeMotherboard
void	correlateLCTs (const CSCALCTDigi &bestALCT, const CSCALCTDigi &secondALCT, const CSCCLCTDigi &bestCLCT, const CSCCLCTDigi &secondCLCT, CSCCorrelatedLCTDigi &lct1, CSCCorrelatedLCTDigi &lct2) const

void	setPrefIndex ()

Protected Member Functions inherited from CSCMotherboard
void	checkConfigParameters ()

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

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

void	dumpConfigParams () const

void	encodeHighMultiplicityBits (unsigned alctBits)

unsigned int	encodePattern (const int clctPattern) const

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

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

CSCALCTDigi	getBXShiftedALCT (const CSCALCTDigi &) const

CSCCLCTDigi	getBXShiftedCLCT (const CSCCLCTDigi &) const

Protected Member Functions inherited from CSCBaseboard
void	checkConfigParameters (unsigned int &var, const unsigned int var_max, const unsigned int var_def, const std::string &var_str)

Protected Attributes inherited from CSCUpgradeMotherboard
LCTContainer	allLCTs

bool	debug_luts

bool	debug_matching

bool	match_earliest_alct_only

bool	match_earliest_clct_only

unsigned int	max_lcts

int	pref [CSCConstants::MAX_LCT_TBINS]

Parity	theParity

unsigned int	tmb_cross_bx_algo

Protected Attributes inherited from CSCMotherboard
unsigned int	alct_trig_enable

std::vector< CSCALCTDigi >	alctV

bool	clct_to_alct

unsigned int	clct_trig_enable

std::vector< CSCCLCTDigi >	clctV

bool	drop_used_alcts

bool	drop_used_clcts

int	early_tbins

CSCCorrelatedLCTDigi	firstLCT [CSCConstants::MAX_LCT_TBINS]

unsigned int	highMultiplicityBits_

unsigned int	match_trig_enable

unsigned int	match_trig_window_size

unsigned int	mpc_block_me1a

std::unique_ptr< LCTQualityControl >	qualityControl_

bool	readout_earliest_2

CSCCorrelatedLCTDigi	secondLCT [CSCConstants::MAX_LCT_TBINS]

unsigned int	tmb_l1a_window_size

bool	useHighMultiplicityBits_

Protected Attributes inherited from CSCBaseboard
edm::ParameterSet	alctParams_

edm::ParameterSet	clctParams_

edm::ParameterSet	commonParams_

const CSCChamber *	cscChamber_

const CSCGeometry *	cscGeometry_

CSCDetId	cscId_

bool	disableME1a_

bool	enableAlctPhase2_

bool	gangedME1a_

int	infoV

bool	isME11_

bool	isME21_

bool	isME31_

bool	isME41_

bool	runCCLUT_

bool	runME11ILT_

bool	runME11Up_

bool	runME21ILT_

bool	runME21Up_

bool	runME31Up_

bool	runME41Up_

bool	runPhase2_

unsigned	theChamber

std::string	theCSCName_

const unsigned	theEndcap

unsigned	theRegion

unsigned	theRing

const unsigned	theSector

const unsigned	theStation

const unsigned	theSubsector

const unsigned	theTrigChamber

edm::ParameterSet	tmbParams_

Static Protected Attributes inherited from CSCMotherboard
static const unsigned int	def_alct_trig_enable = 0

static const unsigned int	def_clct_trig_enable = 0

static const unsigned int	def_match_trig_enable = 1

static const unsigned int	def_match_trig_window_size = 7

static const unsigned int	def_mpc_block_me1a = 1

static const unsigned int	def_tmb_l1a_window_size = 7

Detailed Description

Extended CSCMotherboard for ME11 TMB upgrade to handle ME1b and (primarily unganged) ME1a separately

Author: Vadim Khotilovich 12 May 2009

Based on CSCMotherboard code

Definition at line 18 of file CSCMotherboardME11.h.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum

private

labels for ME1a and ME1B

Enumerator
ME1B
ME1A

Definition at line 59 of file CSCMotherboardME11.h.

59 { ME1B = 1, ME1A = 4 };

Constructor & Destructor Documentation

◆ CSCMotherboardME11() [1/2]

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

Normal constructor.

Definition at line 17 of file CSCMotherboardME11.cc.

     : CSCUpgradeMotherboard(endcap, station, sector, subsector, chamber, conf) {
   if (!runPhase2_)
     edm::LogError("CSCMotherboardME11|SetupError") << "+++ TMB constructed while runPhase2_ is not set! +++\n";
  
   if (!runME11Up_)
     edm::LogError("CSCMotherboardME11|SetupError") << "+++ TMB constructed while runME11Up_ is not set! +++\n";
  
   cscTmbLUT_ = std::make_unique<CSCMotherboardLUTME11>();
  
   // ignore unphysical ALCT-CLCT matches
   ignoreAlctCrossClct = tmbParams_.getParameter<bool>("ignoreAlctCrossClct");
 }

References cscTmbLUT_, edm::ParameterSet::getParameter(), ignoreAlctCrossClct, CSCBaseboard::runME11Up_, CSCBaseboard::runPhase2_, and CSCBaseboard::tmbParams_.

◆ CSCMotherboardME11() [2/2]

CSCMotherboardME11::CSCMotherboardME11 ( )

Constructor for use during testing.

Definition at line 36 of file CSCMotherboardME11.cc.

                                        : CSCUpgradeMotherboard() {
   if (!runPhase2_)
     edm::LogError("CSCMotherboardME11|SetupError") << "+++ TMB constructed while runPhase2_ is not set! +++\n";
  
   if (!runME11Up_)
     edm::LogError("CSCMotherboardME11|SetupError") << "+++ TMB constructed while runME11Up_ is not set! +++\n";
 }

References CSCBaseboard::runME11Up_, and CSCBaseboard::runPhase2_.

◆ ~CSCMotherboardME11()

CSCMotherboardME11::~CSCMotherboardME11 ( )

override

Default destructor.

Definition at line 44 of file CSCMotherboardME11.cc.

44 {}

Member Function Documentation

◆ clear()

void CSCMotherboardME11::clear ( void )

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

Definition at line 46 of file CSCMotherboardME11.cc.

46 { CSCUpgradeMotherboard::clear(); }

References CSCUpgradeMotherboard::clear().

Referenced by run().

◆ correlateLCTsME11()

void CSCMotherboardME11::correlateLCTsME11	(	const CSCALCTDigi &	bestALCT,
		const CSCALCTDigi &	secondALCT,
		const CSCCLCTDigi &	bestCLCT,
		const CSCCLCTDigi &	secondCLCT,
		CSCCorrelatedLCTDigi &	lct1,
		CSCCorrelatedLCTDigi &	lct2
	)		const

private

Definition at line 333 of file CSCMotherboardME11.cc.

                                                                              {
   // assume that always anodeBestValid && cathodeBestValid
   CSCALCTDigi bestALCT = bALCT;
   CSCALCTDigi secondALCT = sALCT;
   CSCCLCTDigi bestCLCT = bCLCT;
   CSCCLCTDigi secondCLCT = sCLCT;
  
   if (ignoreAlctCrossClct) {
     const bool anodeBestValid = bestALCT.isValid();
     const bool anodeSecondValid = secondALCT.isValid();
     const bool cathodeBestValid = bestCLCT.isValid();
     const bool cathodeSecondValid = secondCLCT.isValid();
     if (anodeBestValid and !anodeSecondValid)
       secondALCT = bestALCT;
     if (!anodeBestValid and anodeSecondValid)
       bestALCT = secondALCT;
     if (cathodeBestValid and !cathodeSecondValid)
       secondCLCT = bestCLCT;
     if (!cathodeBestValid and cathodeSecondValid)
       bestCLCT = secondCLCT;
     // ALCT-CLCT matching conditions are defined by "trig_enable" configuration
     // parameters.
     if ((alct_trig_enable and bestALCT.isValid()) or (clct_trig_enable and bestCLCT.isValid()) or
         (match_trig_enable and bestALCT.isValid() and bestCLCT.isValid())) {
       lct1 = constructLCTs(bestALCT, bestCLCT, CSCCorrelatedLCTDigi::ALCTCLCT, 1);
     }
     if (((secondALCT != bestALCT) or (secondCLCT != bestCLCT)) and
         ((alct_trig_enable and secondALCT.isValid()) or (clct_trig_enable and secondCLCT.isValid()) or
          (match_trig_enable and secondALCT.isValid() and secondCLCT.isValid()))) {
       lct2 = constructLCTs(secondALCT, secondCLCT, CSCCorrelatedLCTDigi::ALCTCLCT, 2);
     }
     return;
   } else {
     if (secondALCT == bestALCT)
       secondALCT.clear();
     if (secondCLCT == bestCLCT)
       secondCLCT.clear();
  
     const int ok11 = doesALCTCrossCLCT(bestALCT, bestCLCT);
     const int ok12 = doesALCTCrossCLCT(bestALCT, secondCLCT);
     const int ok21 = doesALCTCrossCLCT(secondALCT, bestCLCT);
     const int ok22 = doesALCTCrossCLCT(secondALCT, secondCLCT);
     const int code = (ok11 << 3) | (ok12 << 2) | (ok21 << 1) | (ok22);
  
     int dbg = 0;
     if (dbg)
       LogTrace("CSCMotherboardME11") << "debug correlateLCTs in ME11 " << cscId_ << std::endl
                                      << "ALCT1: " << bestALCT << std::endl
                                      << "ALCT2: " << secondALCT << std::endl
                                      << "CLCT1: " << bestCLCT << std::endl
                                      << "CLCT2: " << secondCLCT << std::endl
                                      << "ok 11 12 21 22 code = " << ok11 << " " << ok12 << " " << ok21 << " " << ok22
                                      << " " << code << std::endl;
  
     if (code == 0)
       return;
  
     // LUT defines correspondence between possible ok## combinations
     // and resulting lct1 and lct2
     int lut[16][2] = {
         //ok: 11 12 21 22
         {0, 0},    // 0  0  0  0
         {22, 0},   // 0  0  0  1
         {21, 0},   // 0  0  1  0
         {21, 22},  // 0  0  1  1
         {12, 0},   // 0  1  0  0
         {12, 22},  // 0  1  0  1
         {12, 21},  // 0  1  1  0
         {12, 21},  // 0  1  1  1
         {11, 0},   // 1  0  0  0
         {11, 22},  // 1  0  0  1
         {11, 21},  // 1  0  1  0
         {11, 22},  // 1  0  1  1
         {11, 12},  // 1  1  0  0
         {11, 22},  // 1  1  0  1
         {11, 12},  // 1  1  1  0
         {11, 22},  // 1  1  1  1
     };
  
     if (dbg)
       LogTrace("CSCMotherboardME11") << "lut 0 1 = " << lut[code][0] << " " << lut[code][1] << std::endl;
  
     switch (lut[code][0]) {
       case 11:
         lct1 = constructLCTs(bestALCT, bestCLCT, CSCCorrelatedLCTDigi::ALCTCLCT, 1);
         break;
       case 12:
         lct1 = constructLCTs(bestALCT, secondCLCT, CSCCorrelatedLCTDigi::ALCTCLCT, 1);
         break;
       case 21:
         lct1 = constructLCTs(secondALCT, bestCLCT, CSCCorrelatedLCTDigi::ALCTCLCT, 1);
         break;
       case 22:
         lct1 = constructLCTs(secondALCT, secondCLCT, CSCCorrelatedLCTDigi::ALCTCLCT, 1);
         break;
       default:
         return;
     }
  
     if (dbg)
       LogTrace("CSCMotherboardME11") << "lct1: " << lct1 << std::endl;
  
     switch (lut[code][1]) {
       case 12:
         lct2 = constructLCTs(bestALCT, secondCLCT, CSCCorrelatedLCTDigi::ALCTCLCT, 2);
         if (dbg)
           LogTrace("CSCMotherboardME11") << "lct2: " << lct2 << std::endl;
         return;
       case 21:
         lct2 = constructLCTs(secondALCT, bestCLCT, CSCCorrelatedLCTDigi::ALCTCLCT, 2);
         if (dbg)
           LogTrace("CSCMotherboardME11") << "lct2: " << lct2 << std::endl;
         return;
       case 22:
         lct2 = constructLCTs(secondALCT, secondCLCT, CSCCorrelatedLCTDigi::ALCTCLCT, 2);
         if (dbg)
           LogTrace("CSCMotherboardME11") << "lct2: " << lct2 << std::endl;
         return;
       default:
         return;
     }
     if (dbg)
       LogTrace("CSCMotherboardME11") << "out of correlateLCTsME11" << std::endl;
  
     return;
   }
 }

References CSCMotherboard::alct_trig_enable, CSCCorrelatedLCTDigi::ALCTCLCT, CSCMotherboard::clct_trig_enable, CSCALCTDigi::clear(), CSCCLCTDigi::clear(), CSCMotherboard::constructLCTs(), CSCBaseboard::cscId_, doesALCTCrossCLCT(), ignoreAlctCrossClct, CSCALCTDigi::isValid(), CSCCLCTDigi::isValid(), LogTrace, CSCMotherboard::match_trig_enable, and or.

Referenced by run().

◆ doesALCTCrossCLCT()

bool CSCMotherboardME11::doesALCTCrossCLCT	(	const CSCALCTDigi &	a,
		const CSCCLCTDigi &	c
	)		const

private

Definition at line 329 of file CSCMotherboardME11.cc.

                                                                                            {
   return cscTmbLUT_->doesALCTCrossCLCT(a, c, theEndcap, gangedME1a_);
 }

References a, c, cscTmbLUT_, CSCBaseboard::gangedME1a_, and CSCBaseboard::theEndcap.

Referenced by correlateLCTsME11().

◆ getLCTs1a()

std::vector< CSCCorrelatedLCTDigi > CSCMotherboardME11::getLCTs1a ( ) const

Returns vectors of found correlated LCTs in ME1a and ME1b, if any.

Definition at line 309 of file CSCMotherboardME11.cc.

                                                                     {
   std::vector<CSCCorrelatedLCTDigi> tmpV;
  
   // disabled ME1a
   if (mpc_block_me1a || disableME1a_)
     return tmpV;
  
   for (int bx = 0; bx < CSCConstants::MAX_LCT_TBINS; bx++) {
     for (unsigned int mbx = 0; mbx < match_trig_window_size; mbx++) {
       for (int i = 0; i < CSCConstants::MAX_LCTS_PER_CSC; i++) {
         const CSCCorrelatedLCTDigi& lct = allLCTs.data[bx][mbx][i];
         if (lct.isValid() and lct.getStrip() >= CSCConstants::MAX_HALF_STRIP_ME1B) {
           tmpV.push_back(lct);
         }
       }
     }
   }  // Report all LCTs found.
   return tmpV;
 }

References CSCUpgradeMotherboard::allLCTs, l1GtPatternGenerator_cfi::bx, LCTContainer::data, CSCBaseboard::disableME1a_, CSCCorrelatedLCTDigi::getStrip(), mps_fire::i, CSCCorrelatedLCTDigi::isValid(), CSCMotherboard::match_trig_window_size, CSCConstants::MAX_HALF_STRIP_ME1B, CSCConstants::MAX_LCT_TBINS, CSCConstants::MAX_LCTS_PER_CSC, and CSCMotherboard::mpc_block_me1a.

Referenced by readoutLCTs().

◆ getLCTs1b()

std::vector< CSCCorrelatedLCTDigi > CSCMotherboardME11::getLCTs1b ( ) const

Definition at line 292 of file CSCMotherboardME11.cc.

                                                                     {
   std::vector<CSCCorrelatedLCTDigi> tmpV;
  
   for (int bx = 0; bx < CSCConstants::MAX_LCT_TBINS; bx++) {
     for (unsigned int mbx = 0; mbx < match_trig_window_size; mbx++) {
       for (int i = 0; i < CSCConstants::MAX_LCTS_PER_CSC; i++) {
         const CSCCorrelatedLCTDigi& lct = allLCTs.data[bx][mbx][i];
         if (lct.isValid() and lct.getStrip() < CSCConstants::MAX_HALF_STRIP_ME1B) {
           tmpV.push_back(lct);
         }
       }
     }
   }
   return tmpV;
 }

References CSCUpgradeMotherboard::allLCTs, l1GtPatternGenerator_cfi::bx, LCTContainer::data, CSCCorrelatedLCTDigi::getStrip(), mps_fire::i, CSCCorrelatedLCTDigi::isValid(), CSCMotherboard::match_trig_window_size, CSCConstants::MAX_HALF_STRIP_ME1B, CSCConstants::MAX_LCT_TBINS, and CSCConstants::MAX_LCTS_PER_CSC.

Referenced by readoutLCTs().

◆ readoutLCTs() [1/2]

std::vector< CSCCorrelatedLCTDigi > CSCUpgradeMotherboard::readoutLCTs

override

Definition at line 259 of file CSCUpgradeMotherboard.cc.

                                                                          {
   std::vector<CSCCorrelatedLCTDigi> result;
   allLCTs.getMatched(result);
   if (tmb_cross_bx_algo == 2)
     CSCUpgradeMotherboard::sortLCTs(result, CSCUpgradeMotherboard::sortLCTsByQuality);
  
   // do a final check on the LCTs in readout
   qualityControl_->checkMultiplicityBX(result);
   for (const auto& lct : result) {
     qualityControl_->checkValid(lct);
   }
  
   return result;
 }

◆ readoutLCTs() [2/2]

std::vector< CSCCorrelatedLCTDigi > CSCMotherboardME11::readoutLCTs ( int me1ab ) const

Definition at line 236 of file CSCMotherboardME11.cc.

                                                                                {
   std::vector<CSCCorrelatedLCTDigi> tmpV;
  
   // The start time of the L1A*LCT coincidence window should be related
   // to the fifo_pretrig parameter, but I am not completely sure how.
   // Just choose it such that the window is centered at bx=7.  This may
   // need further tweaking if the value of tmb_l1a_window_size changes.
   //static int early_tbins = 4;
   // The number of LCT bins in the read-out is given by the
   // tmb_l1a_window_size parameter, forced to be odd
   const int lct_bins = (tmb_l1a_window_size % 2 == 0) ? tmb_l1a_window_size + 1 : tmb_l1a_window_size;
   const int late_tbins = early_tbins + lct_bins;
  
   // Start from the vector of all found correlated LCTs and select
   // those within the LCT*L1A coincidence window.
   int bx_readout = -1;
   std::vector<CSCCorrelatedLCTDigi> all_lcts;
   if (me1ab == ME1A)
     all_lcts = getLCTs1a();
   if (me1ab == ME1B)
     all_lcts = getLCTs1b();
   std::vector<CSCCorrelatedLCTDigi>::const_iterator plct = all_lcts.begin();
   for (; plct != all_lcts.end(); plct++) {
     if (!plct->isValid())
       continue;
  
     int bx = (*plct).getBX();
     // Skip LCTs found too early relative to L1Accept.
     if (bx <= early_tbins)
       continue;
  
     // Skip LCTs found too late relative to L1Accept.
     if (bx > late_tbins)
       continue;
  
     // If (readout_earliest_2) take only LCTs in the earliest bx in the read-out window:
     // in digi->raw step, LCTs have to be packed into the TMB header, and
     // currently there is room just for two.
     if (readout_earliest_2 && (bx_readout == -1 || bx == bx_readout)) {
       tmpV.push_back(*plct);
       if (bx_readout == -1)
         bx_readout = bx;
     } else
       tmpV.push_back(*plct);
   }
  
   // do a final check on the LCTs in readout
   qualityControl_->checkMultiplicityBX(tmpV);
   for (const auto& lct : tmpV) {
     qualityControl_->checkValid(lct);
   }
  
   return tmpV;
 }

References l1GtPatternGenerator_cfi::bx, CSCMotherboard::early_tbins, getLCTs1a(), getLCTs1b(), ME1A, ME1B, CSCMotherboard::qualityControl_, CSCMotherboard::readout_earliest_2, and CSCMotherboard::tmb_l1a_window_size.

◆ readoutLCTs1a()

std::vector< CSCCorrelatedLCTDigi > CSCMotherboardME11::readoutLCTs1a ( ) const

Definition at line 229 of file CSCMotherboardME11.cc.

229 { return readoutLCTs(ME1A); }

References ME1A, and CSCUpgradeMotherboard::readoutLCTs().

Referenced by CSCTriggerPrimitivesBuilder::build().

◆ readoutLCTs1b()

std::vector< CSCCorrelatedLCTDigi > CSCMotherboardME11::readoutLCTs1b ( ) const

Definition at line 231 of file CSCMotherboardME11.cc.

231 { return readoutLCTs(ME1B); }

References ME1B, and CSCUpgradeMotherboard::readoutLCTs().

Referenced by CSCTriggerPrimitivesBuilder::build().

◆ run()

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

overridevirtual

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

Reimplemented from CSCMotherboard.

Definition at line 55 of file CSCMotherboardME11.cc.

                                                                                                            {
   clear();
  
   // Check for existing processors
   if (!(alctProc && clctProc)) {
     edm::LogError("CSCMotherboardME11|SetupError") << "+++ run() called for non-existing ALCT/CLCT processor! +++ \n";
     return;
   }
  
   alctProc->setCSCGeometry(cscGeometry_);
   clctProc->setCSCGeometry(cscGeometry_);
  
   alctV = alctProc->run(wiredc);  // run anodeLCT
   clctV = clctProc->run(compdc);  // run cathodeLCT
  
   // if there are no ALCTs and no CLCTs, it does not make sense to run this TMB
   if (alctV.empty() and clctV.empty())
     return;
  
   // encode high multiplicity bits
   unsigned alctBits = alctProc->getHighMultiplictyBits();
   encodeHighMultiplicityBits(alctBits);
  
   int used_alct_mask[20];
   int used_clct_mask[20];
   for (int b = 0; b < 20; b++)
     used_alct_mask[b] = used_clct_mask[b] = 0;
  
   // CLCT-centric CLCT-to-ALCT matching
   if (clct_to_alct) {
     for (int bx_clct = 0; bx_clct < CSCConstants::MAX_CLCT_TBINS; bx_clct++) {
       if (clctProc->getBestCLCT(bx_clct).isValid()) {
         bool is_matched = false;
         const int bx_alct_start = bx_clct - match_trig_window_size / 2 + CSCConstants::ALCT_CLCT_OFFSET;
         const int bx_alct_stop = bx_clct + match_trig_window_size / 2 + CSCConstants::ALCT_CLCT_OFFSET;
         for (int bx_alct = bx_alct_start; bx_alct <= bx_alct_stop; bx_alct++) {
           if (bx_alct < 0 || bx_alct >= CSCConstants::MAX_ALCT_TBINS)
             continue;
           if (drop_used_alcts && used_alct_mask[bx_alct])
             continue;
           if (alctProc->getBestALCT(bx_alct).isValid()) {
             if (infoV > 1)
               LogTrace("CSCMotherboardME11")
                   << "Successful CLCT-ALCT match in ME11: bx_clct = " << bx_clct << "; match window: [" << bx_alct_start
                   << "; " << bx_alct_stop << "]; bx_alct = " << bx_alct;
             int mbx = bx_alct_stop - bx_alct;
             correlateLCTsME11(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));
             if (allLCTs(bx_alct, mbx, 0).isValid()) {
               used_alct_mask[bx_alct] += 1;
               if (match_earliest_alct_only)
                 break;
             }
           }
         }
         // Do not report CLCT-only LCT for ME11
         if (!is_matched) {
           if (infoV > 1)
             LogTrace("CSCMotherboard") << "Unsuccessful ALCT-CLCT match (CLCT only): bx_clct = " << bx_clct
                                        << " first CLCT " << clctProc->getBestCLCT(bx_clct) << "; match window: ["
                                        << bx_alct_start << "; " << bx_alct_stop << "]";
         }
       }
     }  // end of CLCT-centric matching
  
     // ALCT-centric ALCT-to-CLCT matching
   } else {
     for (int bx_alct = 0; bx_alct < CSCConstants::MAX_ALCT_TBINS; bx_alct++) {
       if (alctProc->getBestALCT(bx_alct).isValid()) {
         const int bx_clct_start = bx_alct - match_trig_window_size / 2 - CSCConstants::ALCT_CLCT_OFFSET;
         const int bx_clct_stop = bx_alct + match_trig_window_size / 2 - CSCConstants::ALCT_CLCT_OFFSET;
  
         // matching in ME11
         bool is_matched = false;
         for (int bx_clct = bx_clct_start; bx_clct <= bx_clct_stop; bx_clct++) {
           if (bx_clct < 0 || bx_clct >= CSCConstants::MAX_CLCT_TBINS)
             continue;
           if (drop_used_clcts && used_clct_mask[bx_clct])
             continue;
           if (clctProc->getBestCLCT(bx_clct).isValid()) {
             if (infoV > 1)
               LogTrace("CSCMotherboardME11")
                   << "Successful ALCT-CLCT match in ME11: bx_alct = " << bx_alct << "; match window: [" << bx_clct_start
                   << "; " << bx_clct_stop << "]; bx_clct = " << bx_clct;
             int mbx = bx_clct - bx_clct_start;
             correlateLCTsME11(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));
             if (allLCTs(bx_alct, mbx, 0).isValid()) {
               is_matched = true;
               used_clct_mask[bx_clct] += 1;
               if (match_earliest_clct_only)
                 break;
             }
           }
         }
         if (!is_matched) {
           if (infoV > 1)
             LogTrace("CSCMotherboard") << "Unsuccessful ALCT-CLCT match (ALCT only): bx_alct = " << bx_alct
                                        << " first ALCT " << alctProc->getBestALCT(bx_alct) << "; match window: ["
                                        << bx_clct_start << "; " << bx_clct_stop << "]";
         }
       }
     }  // end of ALCT-centric matching
   }
  
   // reduction of nLCTs per each BX
   //add similar cross bx algorithm to standard TMB in next step
   for (int bx = 0; bx < CSCConstants::MAX_LCT_TBINS; bx++) {
     // counting
     unsigned int nlct = 0;
     unsigned int nbx = 0;
     for (unsigned int mbx = 0; mbx < match_trig_window_size; mbx++) {
       bool hasLCT = false;
       for (int i = 0; i < CSCConstants::MAX_LCTS_PER_CSC; i++) {
         if (allLCTs(bx, mbx, i).isValid()) {
           nlct++;
           hasLCT = true;
           if (infoV > 0) {
             LogDebug("CSCMotherboardME11") << "LCT" << i + 1 << " " << bx << "/"
                                            << bx + mbx - match_trig_window_size / 2 << ": " << allLCTs(bx, mbx, i);
           }
         }
       }
       if (hasLCT)
         nbx++;
     }
     if (infoV > 0 && nlct > 0)
       LogDebug("CSCMotherboardME11") << "bx " << bx << " nLCT: " << nlct << " total mbx with LCTs " << nbx;
  
     // some simple cross-bx sorting algorithms
     if (tmb_cross_bx_algo == 1 and (nlct > 2 or nbx > 1)) {
       nbx = 0;
       for (unsigned int mbx = 0; mbx < match_trig_window_size; mbx++) {
         nlct = 0;
         bool hasLCT = false;
         for (int i = 0; i < CSCConstants::MAX_LCTS_PER_CSC; i++) {
           if (allLCTs(bx, pref[mbx], i).isValid()) {
             nlct++;
             hasLCT = true;
             if (nlct > CSCConstants::MAX_LCTS_PER_CSC or nbx > 0)
               allLCTs(bx, pref[mbx], i).clear();
           }
         }
         if (hasLCT)
           nbx++;
       }
  
       if (infoV > 0)
         LogDebug("CSCMotherboardME11") << "After x-bx sorting:";
       nlct = 0;
       for (unsigned int mbx = 0; mbx < match_trig_window_size; mbx++)
         for (int i = 0; i < CSCConstants::MAX_LCTS_PER_CSC; i++) {
           if (allLCTs(bx, mbx, i).isValid()) {
             nlct++;
             if (infoV > 0) {
               LogDebug("CSCMotherboardME11") << "LCT" << i + 1 << " " << bx << "/"
                                              << bx + mbx - match_trig_window_size / 2 << ": " << allLCTs(bx, mbx, i);
             }
           }
         }
       if (infoV > 0 && nlct > 0)
         LogDebug("CSCMotherboardME11") << "bx " << bx << " nnLCT: " << nlct;
     }  // x-bx sorting
   }    // end of for (int bx = 0; bx < CSCConstants::MAX_LCT_TBINS; bx++)
 }

References CSCConstants::ALCT_CLCT_OFFSET, CSCMotherboard::alctProc, CSCMotherboard::alctV, CSCUpgradeMotherboard::allLCTs, b, l1GtPatternGenerator_cfi::bx, CSCMotherboard::clct_to_alct, CSCMotherboard::clctProc, CSCMotherboard::clctV, LCTContainer::clear(), clear(), correlateLCTsME11(), CSCBaseboard::cscGeometry_, CSCMotherboard::drop_used_alcts, CSCMotherboard::drop_used_clcts, CSCMotherboard::encodeHighMultiplicityBits(), mps_fire::i, CSCBaseboard::infoV, sistrip::SpyUtilities::isValid(), LogDebug, LogTrace, CSCUpgradeMotherboard::match_earliest_alct_only, CSCUpgradeMotherboard::match_earliest_clct_only, CSCMotherboard::match_trig_window_size, CSCConstants::MAX_ALCT_TBINS, CSCConstants::MAX_CLCT_TBINS, CSCConstants::MAX_LCT_TBINS, CSCConstants::MAX_LCTS_PER_CSC, or, CSCUpgradeMotherboard::pref, and CSCUpgradeMotherboard::tmb_cross_bx_algo.

Referenced by CSCTriggerPrimitivesBuilder::build().

◆ setConfigParameters()

void CSCMotherboardME11::setConfigParameters ( const CSCDBL1TPParameters * conf )

Set configuration parameters obtained via EventSetup mechanism.

Definition at line 49 of file CSCMotherboardME11.cc.

                                                                             {
   alctProc->setConfigParameters(conf);
   clctProc->setConfigParameters(conf);
   // No config. parameters in DB for the TMB itself yet.
 }

References CSCMotherboard::alctProc, and CSCMotherboard::clctProc.

Member Data Documentation

◆ cscTmbLUT_

std::unique_ptr<CSCMotherboardLUTME11> CSCMotherboardME11::cscTmbLUT_

private

Definition at line 56 of file CSCMotherboardME11.h.

Referenced by CSCMotherboardME11(), and doesALCTCrossCLCT().

◆ ignoreAlctCrossClct

bool CSCMotherboardME11::ignoreAlctCrossClct

private

Definition at line 70 of file CSCMotherboardME11.h.

Referenced by correlateLCTsME11(), and CSCMotherboardME11().

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ anonymous enum

Constructor & Destructor Documentation

◆ CSCMotherboardME11() [1/2]

◆ CSCMotherboardME11() [2/2]

◆ ~CSCMotherboardME11()

Member Function Documentation

◆ clear()

◆ correlateLCTsME11()

◆ doesALCTCrossCLCT()

◆ getLCTs1a()

◆ getLCTs1b()

◆ readoutLCTs() [1/2]

◆ readoutLCTs() [2/2]

◆ readoutLCTs1a()

◆ readoutLCTs1b()

◆ run()

◆ setConfigParameters()

Member Data Documentation

◆ cscTmbLUT_

◆ ignoreAlctCrossClct