#include <CSCUpgradeMotherboard.h>

Inheritance diagram for CSCUpgradeMotherboard:

Public Member Functions
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)

void	debugLUTs ()

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

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

Static Public Member Functions
static bool	sortLCTsByGEMDphi (const CSCCorrelatedLCTDigi &, const CSCCorrelatedLCTDigi &)

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

Protected Member Functions
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 ()

void	checkValid (const CSCCorrelatedLCTDigi &lct) const

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

unsigned int	findQuality (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
LCTContainer	allLCTs

bool	debug_luts

bool	debug_matching

std::unique_ptr< CSCUpgradeMotherboardLUTGenerator >	generator_

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

bool	readout_earliest_2

CSCCorrelatedLCTDigi	secondLCT [CSCConstants::MAX_LCT_TBINS]

unsigned int	tmb_l1a_window_size

bool	use_run3_patterns_

bool	useHighMultiplicityBits_

Protected Attributes inherited from CSCBaseboard
unsigned int	alctClctOffset_

edm::ParameterSet	alctParams_

edm::ParameterSet	clctParams_

edm::ParameterSet	commonParams_

const CSCChamber *	cscChamber_

const CSCGeometry *	cscGeometry_

CSCDetId	cscId_

bool	disableME1a_

bool	enableAlctSLHC_

bool	gangedME1a_

int	infoV

bool	isME11_

bool	isME21_

bool	isSLHC_

bool	runME11ILT_

bool	runME11Up_

bool	runME21ILT_

bool	runME21Up_

bool	runME31Up_

bool	runME41Up_

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_

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

std::unique_ptr< CSCCathodeLCTProcessor >	clctProc

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

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

Base class for upgrade TMBs (MEX/1) chambers, that either run the upgrade CSC-only TMB algorithm or the CSC-GEM algorithm

Author: Sven Dildick (TAMU)

Definition at line 35 of file CSCUpgradeMotherboard.h.

Constructor & Destructor Documentation

◆ CSCUpgradeMotherboard() [1/2]

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

Definition at line 3 of file CSCUpgradeMotherboard.cc.

     :  // special configuration parameters for ME11 treatment
       CSCMotherboard(endcap, station, sector, subsector, chamber, conf),
       allLCTs(match_trig_window_size) {
   if (!isSLHC_)
     edm::LogError("CSCUpgradeMotherboard|SetupError") << "+++ TMB constructed while isSLHC_ is not set! +++\n";
  
   if (theRing == 1) {
     if (theStation == 1 and !runME11Up_)
       edm::LogError("CSCUpgradeMotherboard|SetupError") << "+++ TMB constructed while runME11Up_ is not set! +++\n";
     if (theStation == 2 and !runME21Up_)
       edm::LogError("CSCUpgradeMotherboard|SetupError") << "+++ TMB constructed while runME21Up_ is not set! +++\n";
     if (theStation == 3 and !runME31Up_)
       edm::LogError("CSCUpgradeMotherboard|SetupError") << "+++ TMB constructed while runME31Up_ is not set! +++\n";
     if (theStation == 4 and !runME41Up_)
       edm::LogError("CSCUpgradeMotherboard|SetupError") << "+++ TMB constructed while runME41Up_ is not set! +++\n";
   }
  
   theParity = theChamber % 2 == 0 ? Parity::Even : Parity::Odd;
  
   // generate the LUTs
   generator_.reset(new CSCUpgradeMotherboardLUTGenerator());
  
   // enable the upgrade processors
   if (isSLHC_ and theRing == 1) {
     clctProc.reset(new CSCUpgradeCathodeLCTProcessor(endcap, station, sector, subsector, chamber, conf));
     if (enableAlctSLHC_) {
       alctProc.reset(new CSCUpgradeAnodeLCTProcessor(endcap, station, sector, subsector, chamber, conf));
     }
   }
  
   match_earliest_alct_only = tmbParams_.getParameter<bool>("matchEarliestAlctOnly");
   match_earliest_clct_only = tmbParams_.getParameter<bool>("matchEarliestClctOnly");
   clct_to_alct = tmbParams_.getParameter<bool>("clctToAlct");
   drop_used_clcts = tmbParams_.getParameter<bool>("tmbDropUsedClcts");
   tmb_cross_bx_algo = tmbParams_.getParameter<unsigned int>("tmbCrossBxAlgorithm");
   max_lcts = tmbParams_.getParameter<unsigned int>("maxLCTs");
   debug_matching = tmbParams_.getParameter<bool>("debugMatching");
   debug_luts = tmbParams_.getParameter<bool>("debugLUTs");
  
   setPrefIndex();
 }

References CSCMotherboard::alctProc, relativeConstraints::chamber, CSCMotherboard::clct_to_alct, CSCMotherboard::clctProc, debug_luts, debug_matching, CSCMotherboard::drop_used_clcts, CSCBaseboard::enableAlctSLHC_, makeMuonMisalignmentScenario::endcap, Even, generator_, edm::ParameterSet::getParameter(), CSCBaseboard::isSLHC_, match_earliest_alct_only, match_earliest_clct_only, max_lcts, Odd, CSCBaseboard::runME11Up_, CSCBaseboard::runME21Up_, CSCBaseboard::runME31Up_, CSCBaseboard::runME41Up_, setPrefIndex(), relativeConstraints::station, CSCBaseboard::theChamber, theParity, CSCBaseboard::theRing, CSCBaseboard::theStation, tmb_cross_bx_algo, and CSCBaseboard::tmbParams_.

◆ CSCUpgradeMotherboard() [2/2]

CSCUpgradeMotherboard::CSCUpgradeMotherboard ( )

Definition at line 51 of file CSCUpgradeMotherboard.cc.

                                              : CSCMotherboard(), allLCTs(match_trig_window_size) {
   if (!isSLHC_)
     edm::LogError("CSCUpgradeMotherboard|SetupError") << "+++ TMB constructed while isSLHC_ is not set! +++\n";
  
   if (theRing == 1) {
     if (theStation == 1 and !runME11Up_)
       edm::LogError("CSCUpgradeMotherboard|SetupError") << "+++ TMB constructed while runME11Up_ is not set! +++\n";
     if (theStation == 2 and !runME21Up_)
       edm::LogError("CSCUpgradeMotherboard|SetupError") << "+++ TMB constructed while runME21Up_ is not set! +++\n";
     if (theStation == 3 and !runME31Up_)
       edm::LogError("CSCUpgradeMotherboard|SetupError") << "+++ TMB constructed while runME31Up_ is not set! +++\n";
     if (theStation == 4 and !runME41Up_)
       edm::LogError("CSCUpgradeMotherboard|SetupError") << "+++ TMB constructed while runME41Up_ is not set! +++\n";
   }
  
   setPrefIndex();
 }

References CSCBaseboard::isSLHC_, CSCBaseboard::runME11Up_, CSCBaseboard::runME21Up_, CSCBaseboard::runME31Up_, CSCBaseboard::runME41Up_, setPrefIndex(), CSCBaseboard::theRing, and CSCBaseboard::theStation.

◆ ~CSCUpgradeMotherboard()

CSCUpgradeMotherboard::~CSCUpgradeMotherboard ( )

override

Definition at line 274 of file CSCUpgradeMotherboard.cc.

274 {}

Member Function Documentation

◆ clear()

void CSCUpgradeMotherboard::clear ( void )

Definition at line 329 of file CSCUpgradeMotherboard.cc.

                                   {
   CSCMotherboard::clear();
   allLCTs.clear();
 }

References allLCTs, LCTContainer::clear(), and CSCMotherboard::clear().

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

◆ compare()

template<class S >

bool CSCUpgradeMotherboard::compare	(	const S &	p,
		const S &	q
	)		const

Definition at line 122 of file CSCUpgradeMotherboard.h.

                                                                 {
   return (p.first == q.first) and (p.second == q.second);
 }

References AlCaHLTBitMon_ParallelJobs::p, and data-class-funcs::q.

Referenced by intersection().

◆ correlateLCTs()

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

protected

Definition at line 220 of file CSCUpgradeMotherboard.cc.

                                                                             {
   CSCALCTDigi bestALCT = bALCT;
   CSCALCTDigi secondALCT = sALCT;
   CSCCLCTDigi bestCLCT = bCLCT;
   CSCCLCTDigi secondCLCT = sCLCT;
  
   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);
   }
 }

References CSCMotherboard::alct_trig_enable, CSCCorrelatedLCTDigi::ALCTCLCT, CSCMotherboard::clct_trig_enable, CSCMotherboard::constructLCTs(), CSCALCTDigi::isValid(), CSCCLCTDigi::isValid(), CSCMotherboard::match_trig_enable, and or.

Referenced by run().

◆ debugLUTs()

void CSCUpgradeMotherboard::debugLUTs ( )

Definition at line 299 of file CSCUpgradeMotherboard.cc.

                                       {
   if (debug_luts)
     generator_->generateLUTs(theEndcap, theStation, theSector, theSubsector, theTrigChamber);
 }

References debug_luts, generator_, CSCBaseboard::theEndcap, CSCBaseboard::theSector, CSCBaseboard::theStation, CSCBaseboard::theSubsector, and CSCBaseboard::theTrigChamber.

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

◆ getCSCPart()

enum CSCPart CSCUpgradeMotherboard::getCSCPart ( int keystrip ) const

get CSCPart from HS, station, ring number

Definition at line 276 of file CSCUpgradeMotherboard.cc.

                                                                  {
   if (theStation == 1 and (theRing == 1 or theRing == 4)) {
     if (keystrip > CSCConstants::MAX_HALF_STRIP_ME1B) {
       if (gangedME1a_)
         return CSCPart::ME1Ag;
       else
         return CSCPart::ME1A;
     } else if (keystrip <= CSCConstants::MAX_HALF_STRIP_ME1B and keystrip >= 0)
       return CSCPart::ME1B;
     else
       return CSCPart::ME11;
   } else if (theStation == 2 and theRing == 1)
     return CSCPart::ME21;
   else if (theStation == 3 and theRing == 1)
     return CSCPart::ME31;
   else if (theStation == 4 and theRing == 1)
     return CSCPart::ME41;
   else {
     edm::LogError("CSCUpgradeMotherboard|Error") << " ++ getCSCPart() failed to find the CSC chamber for in case ";
     return CSCPart::ME11;  // return ME11 by default
   }
 }

References CSCBaseboard::gangedME1a_, CSCConstants::MAX_HALF_STRIP_ME1B, ME11, ME1A, ME1Ag, ME1B, ME21, ME31, ME41, or, CSCBaseboard::theRing, and CSCBaseboard::theStation.

Referenced by CSCGEMMotherboard::bestMatchingPad(), CSCGEMMotherboard::constructLCTsGEM(), and CSCGEMMotherboard::matchingPads().

◆ intersection()

template<class S >

void CSCUpgradeMotherboard::intersection	(	const S &	d1,
		const S &	d2,
		S &	result
	)		const

Definition at line 127 of file CSCUpgradeMotherboard.h.

                                                                                   {
   for (const auto& p : d1) {
     for (const auto& q : d2) {
       if (compare(p, q)) {
         result.push_back(p);
       }
     }
   }
 }

References compare(), d1, AlCaHLTBitMon_ParallelJobs::p, data-class-funcs::q, and mps_fire::result.

Referenced by CSCGEMMotherboard::matchingPads().

◆ readoutLCTs()

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

overridevirtual

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

Reimplemented from CSCMotherboard.

Definition at line 260 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
   for (const auto& lct : result) {
     checkValid(lct);
   }
  
   return result;
 }

References allLCTs, CSCMotherboard::checkValid(), LCTContainer::getMatched(), mps_fire::result, sortLCTs(), sortLCTsByQuality(), and tmb_cross_bx_algo.

Referenced by CSCTriggerPrimitivesBuilder::build(), CSCMotherboardME11::readoutLCTs1a(), CSCMotherboardME11::readoutLCTs1b(), and run().

◆ run()

void CSCUpgradeMotherboard::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 69 of file CSCUpgradeMotherboard.cc.

                                                                                                               {
   clear();
  
   if (!(alctProc and clctProc)) {
     edm::LogError("CSCUpgradeMotherboard|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_clct_mask[20];
   for (int c = 0; c < 20; ++c)
     used_clct_mask[c] = 0;
  
   // ALCT centric matching
   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 - alctClctOffset_);
       const int bx_clct_stop(bx_alct + match_trig_window_size / 2 - alctClctOffset_);
  
       if (debug_matching) {
         LogTrace("CSCUpgradeMotherboard")
             << "========================================================================" << std::endl;
         LogTrace("CSCUpgradeMotherboard") << "ALCT-CLCT matching in ME34/1 chamber: " << cscId_ << std::endl;
         LogTrace("CSCUpgradeMotherboard")
             << "------------------------------------------------------------------------" << std::endl;
         LogTrace("CSCUpgradeMotherboard") << "+++ Best ALCT Details: ";
         alctProc->getBestALCT(bx_alct).print();
         LogTrace("CSCUpgradeMotherboard") << "+++ Second ALCT Details: ";
         alctProc->getSecondALCT(bx_alct).print();
  
         LogTrace("CSCUpgradeMotherboard")
             << "------------------------------------------------------------------------" << std::endl;
         LogTrace("CSCUpgradeMotherboard") << "Attempt ALCT-CLCT matching in ME34/13 in bx range: [" << bx_clct_start
                                           << "," << bx_clct_stop << "]" << std::endl;
       }
  
       // ALCT-to-CLCT
       for (int bx_clct = bx_clct_start; bx_clct <= bx_clct_stop; bx_clct++) {
         if (bx_clct < 0 or bx_clct >= CSCConstants::MAX_CLCT_TBINS)
           continue;
         if (drop_used_clcts and used_clct_mask[bx_clct])
           continue;
         if (clctProc->getBestCLCT(bx_clct).isValid()) {
           if (debug_matching)
             LogTrace("CSCUpgradeMotherboard") << "++Valid ME21 CLCT: " << clctProc->getBestCLCT(bx_clct) << std::endl;
  
           int mbx = bx_clct - bx_clct_start;
           CSCUpgradeMotherboard::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));
           if (infoV > 1)
             LogTrace("CSCUpgradeMotherboard")
                 << "Successful ALCT-CLCT match in ME21: bx_alct = " << bx_alct << "; match window: [" << bx_clct_start
                 << "; " << bx_clct_stop << "]; bx_clct = " << bx_clct << std::endl;
           LogTrace("CSCUpgradeMotherboard") << "+++ Best CLCT Details: ";
           clctProc->getBestCLCT(bx_clct).print();
           LogTrace("CSCUpgradeMotherboard") << "+++ Second CLCT Details: ";
           clctProc->getSecondCLCT(bx_clct).print();
           if (allLCTs(bx_alct, mbx, 0).isValid()) {
             used_clct_mask[bx_clct] += 1;
             if (match_earliest_clct_only)
               break;
           }
         }
       }
     }
   }
  
   // reduction of nLCTs per each BX
   for (int bx = 0; bx < CSCConstants::MAX_LCT_TBINS; bx++) {
     // counting
     unsigned int n = 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()) {
           ++n;
           if (infoV > 0) {
             LogDebug("CSCUpgradeMotherboard")
                 << "LCT" << i + 1 << " " << bx << "/" << bx + mbx - match_trig_window_size / 2 << ": "
                 << allLCTs(bx, mbx, i) << std::endl;
           }
         }
       }
     }
  
     // some simple cross-bx sorting algorithms
     if (tmb_cross_bx_algo == 1 and (n > 2)) {
       n = 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, pref[mbx], i).isValid()) {
             n++;
             if (n > 2)
               allLCTs(bx, pref[mbx], i).clear();
           }
         }
       }
  
       n = 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()) {
             n++;
             if (infoV > 0) {
               LogDebug("CSCUpgradeMotherboard")
                   << "LCT" << i + 1 << " " << bx << "/" << bx + mbx - match_trig_window_size / 2 << ": "
                   << allLCTs(bx, mbx, i) << std::endl;
             }
           }
         }
       }
       if (infoV > 0 and n > 0)
         LogDebug("CSCUpgradeMotherboard") << "bx " << bx << " nnLCT:" << n << " " << n << std::endl;
     }  // x-bx sorting
   }
  
   bool first = true;
   unsigned int n = 0;
   for (const auto& p : readoutLCTs()) {
     if (debug_matching and first) {
       LogTrace("CSCUpgradeMotherboard") << "========================================================================"
                                         << std::endl;
       LogTrace("CSCUpgradeMotherboard") << "Counting the final LCTs" << std::endl;
       LogTrace("CSCUpgradeMotherboard") << "========================================================================"
                                         << std::endl;
       first = false;
       LogTrace("CSCUpgradeMotherboard") << "tmb_cross_bx_algo: " << tmb_cross_bx_algo << std::endl;
     }
     n++;
     if (debug_matching)
       LogTrace("CSCUpgradeMotherboard") << "LCT " << n << "  " << p << std::endl;
   }
 }

References CSCBaseboard::alctClctOffset_, CSCMotherboard::alctProc, CSCMotherboard::alctV, allLCTs, l1GtPatternGenerator_cfi::bx, HltBtagPostValidation_cff::c, CSCMotherboard::clctProc, CSCMotherboard::clctV, LCTContainer::clear(), clear(), correlateLCTs(), CSCBaseboard::cscGeometry_, CSCBaseboard::cscId_, debug_matching, CSCMotherboard::drop_used_clcts, CSCMotherboard::encodeHighMultiplicityBits(), dqmdumpme::first, mps_fire::i, CSCBaseboard::infoV, LogDebug, LogTrace, 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, dqmiodumpmetadata::n, AlCaHLTBitMon_ParallelJobs::p, pref, readoutLCTs(), and tmb_cross_bx_algo.

Referenced by CSCTriggerPrimitivesBuilder::build().

◆ setPrefIndex()

void CSCUpgradeMotherboard::setPrefIndex ( )

protected

Definition at line 321 of file CSCUpgradeMotherboard.cc.

                                          {
   pref[0] = match_trig_window_size / 2;
   for (unsigned int m = 2; m < match_trig_window_size; m += 2) {
     pref[m - 1] = pref[0] - m / 2;
     pref[m] = pref[0] + m / 2;
   }
 }

References visualization-live-secondInstance_cfg::m, CSCMotherboard::match_trig_window_size, and pref.

Referenced by CSCUpgradeMotherboard().

◆ setupGeometry()

void CSCUpgradeMotherboard::setupGeometry ( )

Definition at line 319 of file CSCUpgradeMotherboard.cc.

319 { generator_->setCSCGeometry(cscGeometry_); }

References CSCBaseboard::cscGeometry_, and generator_.

Referenced by CSCGEMMotherboard::setupGeometry().

◆ sortLCTs()

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

Definition at line 312 of file CSCUpgradeMotherboard.cc.

                                                                                                                      {
   std::sort(lcts.begin(), lcts.end(), *sorter);
   if (lcts.size() > max_lcts)
     lcts.erase(lcts.begin() + max_lcts, lcts.end());
 }

References max_lcts, and MCScenario_CRAFT1_22X::sorter().

Referenced by CSCGEMMotherboardME21::readoutLCTs(), readoutLCTs(), and CSCGEMMotherboardME11::sortLCTs().

◆ sortLCTsByGEMDphi()

bool CSCUpgradeMotherboard::sortLCTsByGEMDphi	(	const CSCCorrelatedLCTDigi &	lct1,
		const CSCCorrelatedLCTDigi &	lct2
	)

static

Definition at line 308 of file CSCUpgradeMotherboard.cc.

                                                                                                                 {
   return true;
 }

Referenced by CSCGEMMotherboardME21::readoutLCTs(), and CSCGEMMotherboardME11::readoutLCTsME11().

◆ sortLCTsByQuality()

bool CSCUpgradeMotherboard::sortLCTsByQuality	(	const CSCCorrelatedLCTDigi &	lct1,
		const CSCCorrelatedLCTDigi &	lct2
	)

static

Methods to sort the LCTs

Definition at line 304 of file CSCUpgradeMotherboard.cc.

                                                                                                                 {
   return lct1.getQuality() > lct2.getQuality();
 }

References CSCCorrelatedLCTDigi::getQuality().

Referenced by CSCGEMMotherboardME21::readoutLCTs(), readoutLCTs(), and CSCGEMMotherboardME11::readoutLCTsME11().

Member Data Documentation

◆ allLCTs

LCTContainer CSCUpgradeMotherboard::allLCTs

protected

for the case when more than 2 LCTs/BX are allowed; maximum match window = 15

Definition at line 98 of file CSCUpgradeMotherboard.h.

Referenced by clear(), CSCMotherboardME11::getLCTs1a(), CSCMotherboardME11::getLCTs1b(), CSCGEMMotherboardME21::readoutLCTs(), readoutLCTs(), CSCGEMMotherboardME11::readoutLCTsME11(), CSCMotherboardME11::run(), CSCGEMMotherboardME11::run(), CSCGEMMotherboardME21::run(), run(), and CSCGEMMotherboardME11::sortLCTs().

◆ debug_luts

bool CSCUpgradeMotherboard::debug_luts

protected

Definition at line 118 of file CSCUpgradeMotherboard.h.

Referenced by CSCUpgradeMotherboard(), and debugLUTs().

◆ debug_matching

bool CSCUpgradeMotherboard::debug_matching

protected

Definition at line 115 of file CSCUpgradeMotherboard.h.

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

◆ generator_

std::unique_ptr<CSCUpgradeMotherboardLUTGenerator> CSCUpgradeMotherboard::generator_

protected

Definition at line 100 of file CSCUpgradeMotherboard.h.

Referenced by CSCUpgradeMotherboard(), debugLUTs(), setupGeometry(), and CSCGEMMotherboard::setupGeometry().

◆ match_earliest_alct_only

bool CSCUpgradeMotherboard::match_earliest_alct_only

protected

Definition at line 105 of file CSCUpgradeMotherboard.h.

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

◆ match_earliest_clct_only

bool CSCUpgradeMotherboard::match_earliest_clct_only

protected

Definition at line 106 of file CSCUpgradeMotherboard.h.

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

◆ max_lcts

unsigned int CSCUpgradeMotherboard::max_lcts

protected

maximum lcts per BX in MEX1: 2, 3, 4 or 999

Definition at line 112 of file CSCUpgradeMotherboard.h.

Referenced by CSCUpgradeMotherboard(), CSCGEMMotherboardME11::sortLCTs(), and sortLCTs().

◆ pref

int CSCUpgradeMotherboard::pref[CSCConstants::MAX_LCT_TBINS]

protected

"preferential" index array in matching window for cross-BX sorting

Definition at line 103 of file CSCUpgradeMotherboard.h.

Referenced by CSCMotherboardME11::run(), CSCGEMMotherboardME21::run(), run(), and setPrefIndex().

◆ theParity

Parity CSCUpgradeMotherboard::theParity

protected

Definition at line 92 of file CSCUpgradeMotherboard.h.

Referenced by CSCGEMMotherboard::constructLCTsGEM(), CSCGEMMotherboard::CSCGEMMotherboard(), CSCUpgradeMotherboard(), CSCGEMMotherboard::getPad(), CSCGEMMotherboard::getRolls(), CSCGEMMotherboard::isPadInOverlap(), and CSCGEMMotherboard::matchingPads().

◆ tmb_cross_bx_algo

unsigned int CSCUpgradeMotherboard::tmb_cross_bx_algo

protected

Definition at line 109 of file CSCUpgradeMotherboard.h.

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

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ CSCUpgradeMotherboard() [1/2]

◆ CSCUpgradeMotherboard() [2/2]

◆ ~CSCUpgradeMotherboard()

Member Function Documentation

◆ clear()

◆ compare()

◆ correlateLCTs()

◆ debugLUTs()

◆ getCSCPart()

◆ intersection()

◆ readoutLCTs()

◆ run()

◆ setPrefIndex()

◆ setupGeometry()

◆ sortLCTs()

◆ sortLCTsByGEMDphi()

◆ sortLCTsByQuality()

Member Data Documentation

◆ allLCTs

◆ debug_luts

◆ debug_matching

◆ generator_

◆ match_earliest_alct_only

◆ match_earliest_clct_only

◆ max_lcts

◆ pref

◆ theParity

◆ tmb_cross_bx_algo