#include <CSCGEMMotherboardME11.h>

Inheritance diagram for CSCGEMMotherboardME11:

Public Member Functions
	CSCGEMMotherboardME11 ()

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

std::vector< CSCCorrelatedLCTDigi >	readoutLCTs1a () const

std::vector< CSCCorrelatedLCTDigi >	readoutLCTs1b () const

void	run (const CSCWireDigiCollection wiredc, const CSCComparatorDigiCollection compdc, const GEMPadDigiClusterCollection *gemPads) override

void	run (const CSCWireDigiCollection wiredc, const CSCComparatorDigiCollection compdc, const GEMPadDigiCollection *gemPads) override

	~CSCGEMMotherboardME11 () override

Public Member Functions inherited from CSCGEMMotherboard
void	clear ()

	CSCGEMMotherboard ()

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

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

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

void	setGEMGeometry (const GEMGeometry *g)
	set CSC and GEM geometries for the matching needs More...

	~CSCGEMMotherboard () 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)

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

Private Member Functions
void	correlateLCTsGEM (const CSCALCTDigi &bestALCT, const CSCALCTDigi &secondALCT, const CSCCLCTDigi &bestCLCT, const CSCCLCTDigi &secondCLCT, const GEMPadDigiIds &pads, const GEMCoPadDigiIds &copads, CSCCorrelatedLCTDigi &lct1, CSCCorrelatedLCTDigi &lct2) const

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

bool	doesWiregroupCrossStrip (int key_wg, int key_hs) const override

const CSCGEMMotherboardLUTME11 *	getLUT () const override

std::vector< CSCCorrelatedLCTDigi >	readoutLCTsME11 (enum CSCPart me1ab) const

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

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

Private Attributes
bool	buildLCTfromALCTandGEM_ME1a_

bool	buildLCTfromALCTandGEM_ME1b_

bool	buildLCTfromCLCTandGEM_ME1a_

bool	buildLCTfromCLCTandGEM_ME1b_

std::vector< CSCCLCTDigi >	clctV

std::unique_ptr< CSCMotherboardLUTME11 >	cscTmbLUT_

bool	dropLowQualityALCTsNoGEMs_ME1a_

bool	dropLowQualityALCTsNoGEMs_ME1b_

bool	dropLowQualityCLCTsNoGEMs_ME1a_

bool	dropLowQualityCLCTsNoGEMs_ME1b_

bool	promoteCLCTGEMquality_ME1a_

bool	promoteCLCTGEMquality_ME1b_

std::unique_ptr< CSCGEMMotherboardLUTME11 >	tmbLUT_

Additional Inherited Members
Public Types inherited from CSCGEMMotherboard
enum	Default_values { DEFAULT_MATCHING_VALUE = -99 }

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 CSCGEMMotherboard
std::unique_ptr< GEMCoPadProcessor >	coPadProcessor

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 }

Protected Member Functions inherited from CSCGEMMotherboard
template<class T >
T	bestMatchingPad (const CSCALCTDigi &, const CSCCLCTDigi &, const matches< T > &) const

template<class T >
T	bestMatchingPad (const CSCALCTDigi &, const matches< T > &) const

template<class S >
S	bestMatchingPad (const CSCALCTDigi &alct1, const CSCCLCTDigi &clct1, const matches< S > &pads) const

template<class S >
S	bestMatchingPad (const CSCALCTDigi &alct1, const matches< S > &pads) const

template<class T >
T	bestMatchingPad (const CSCCLCTDigi &, const matches< T > &) const

template<class S >
S	bestMatchingPad (const CSCCLCTDigi &clct, const matches< S > &pads) const

CSCCorrelatedLCTDigi	constructLCTsGEM (const CSCALCTDigi &alct, const CSCCLCTDigi &clct, const GEMCoPadDigi &gem, int i) const

CSCCorrelatedLCTDigi	constructLCTsGEM (const CSCALCTDigi &alct, const CSCCLCTDigi &clct, const GEMPadDigi &gem, int i) const

CSCCorrelatedLCTDigi	constructLCTsGEM (const CSCALCTDigi &alct, const CSCCLCTDigi &clct, const GEMPadDigi &gem1, const GEMCoPadDigi &gem2, int i) const

CSCCorrelatedLCTDigi	constructLCTsGEM (const CSCALCTDigi &alct, const GEMCoPadDigi &gem, int i) const

CSCCorrelatedLCTDigi	constructLCTsGEM (const CSCCLCTDigi &clct, const GEMCoPadDigi &gem, int i) const

template<class T >
void	correlateLCTsGEM (const T &best, const T &second, const GEMCoPadDigi &, const GEMCoPadDigi &, CSCCorrelatedLCTDigi &lct1, CSCCorrelatedLCTDigi &lct2) const

template<class T >
void	correlateLCTsGEM (const T &best, const T &second, const GEMCoPadDigiIds &coPads, CSCCorrelatedLCTDigi &lct1, CSCCorrelatedLCTDigi &lct2) const

unsigned int	findQualityGEM (const CSCALCTDigi &, const CSCCLCTDigi &, int gemlayer) const

int	getBX (const GEMCoPadDigi &p) const

int	getBX (const GEMPadDigi &p) const

float	getPad (const CSCCLCTDigi &, enum CSCPart par) const

float	getPad (const GEMCoPadDigi &) const

float	getPad (const GEMPadDigi &) const

int	getRoll (const GEMCoPadDigiId &p) const

int	getRoll (const GEMPadDigiId &p) const

std::pair< int, int >	getRolls (const CSCALCTDigi &) const

bool	isGEMDetId (unsigned int) const

bool	isPadInOverlap (int roll) const

template<class T >
void	matchingPads (const CSCALCTDigi &alct, matches< T > &) const

template<class T >
void	matchingPads (const CSCCLCTDigi &alct, matches< T > &) const

template<class T >
void	matchingPads (const CSCCLCTDigi &clct1, const CSCALCTDigi &alct1, matches< T > &) const

template<class T >
void	matchingPads (const CSCCLCTDigi &clct1, const CSCCLCTDigi &clct2, const CSCALCTDigi &alct1, const CSCALCTDigi &alct2, matches< T > &) const

template<class S , class T >
void	matchingPads (const S &d1, const S &d2, matches< T > &) const

int	maxPads () const

int	maxRolls () const

void	printGEMTriggerCoPads (int bx_start, int bx_stop, enum CSCPart)

void	printGEMTriggerPads (int bx_start, int bx_stop, enum CSCPart)

void	retrieveGEMCoPads ()

void	retrieveGEMPads (const GEMPadDigiCollection *pads, unsigned id)

void	setupGeometry ()

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

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 inherited from CSCGEMMotherboard
GEMCoPadDigiIdsBX	coPads_

bool	doLCTGhostBustingWithGEMs_

const GEMGeometry *	gem_g

std::vector< GEMCoPadDigi >	gemCoPadV

bool	gemGeometryAvailable

unsigned	gemId

int	maxDeltaBXCoPad_

int	maxDeltaBXPad_

int	maxDeltaPadL1_

int	maxDeltaPadL2_

GEMPadDigiIdsBX	pads_

bool	promoteALCTGEMpattern_

bool	promoteALCTGEMquality_

bool	promoteCLCTGEMquality_

bool	useOldLCTDataFormat_

Protected Attributes inherited from CSCUpgradeMotherboard
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_

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

Author: Sven Dildick March 2014

Based on CSCMotherboard code

Definition at line 16 of file CSCGEMMotherboardME11.h.

Constructor & Destructor Documentation

◆ CSCGEMMotherboardME11() [1/2]

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

Normal constructor.

Definition at line 3 of file CSCGEMMotherboardME11.cc.

     : CSCGEMMotherboard(endcap, station, sector, subsector, chamber, conf)
       // special configuration parameters for ME11 treatment
       ,
       dropLowQualityCLCTsNoGEMs_ME1a_(tmbParams_.getParameter<bool>("dropLowQualityCLCTsNoGEMs_ME1a")),
       dropLowQualityCLCTsNoGEMs_ME1b_(tmbParams_.getParameter<bool>("dropLowQualityCLCTsNoGEMs_ME1b")),
       dropLowQualityALCTsNoGEMs_ME1a_(tmbParams_.getParameter<bool>("dropLowQualityALCTsNoGEMs_ME1a")),
       dropLowQualityALCTsNoGEMs_ME1b_(tmbParams_.getParameter<bool>("dropLowQualityALCTsNoGEMs_ME1b")),
       buildLCTfromALCTandGEM_ME1a_(tmbParams_.getParameter<bool>("buildLCTfromALCTandGEM_ME1a")),
       buildLCTfromALCTandGEM_ME1b_(tmbParams_.getParameter<bool>("buildLCTfromALCTandGEM_ME1b")),
       buildLCTfromCLCTandGEM_ME1a_(tmbParams_.getParameter<bool>("buildLCTfromCLCTandGEM_ME1a")),
       buildLCTfromCLCTandGEM_ME1b_(tmbParams_.getParameter<bool>("buildLCTfromCLCTandGEM_ME1b")),
       promoteCLCTGEMquality_ME1a_(tmbParams_.getParameter<bool>("promoteCLCTGEMquality_ME1a")),
       promoteCLCTGEMquality_ME1b_(tmbParams_.getParameter<bool>("promoteCLCTGEMquality_ME1b")) {
   if (!isSLHC_) {
     edm::LogError("CSCGEMMotherboardME11|SetupError") << "+++ TMB constructed while isSLHC is not set! +++\n";
   }
  
   if (!runME11ILT_) {
     edm::LogError("CSCGEMMotherboardME11|SetupError") << "+++ TMB constructed while runME11ILT_ is not set! +++\n";
   };
  
   // set LUTs
   tmbLUT_.reset(new CSCGEMMotherboardLUTME11());
   cscTmbLUT_.reset(new CSCMotherboardLUTME11());
 }

References cscTmbLUT_, CSCBaseboard::isSLHC_, CSCBaseboard::runME11ILT_, and tmbLUT_.

◆ CSCGEMMotherboardME11() [2/2]

CSCGEMMotherboardME11::CSCGEMMotherboardME11 ( )

Constructor for use during testing.

Definition at line 35 of file CSCGEMMotherboardME11.cc.

                                              : CSCGEMMotherboard() {
   // Constructor used only for testing.
   if (!isSLHC_) {
     edm::LogError("CSCGEMMotherboardME11|SetupError") << "+++ TMB constructed while isSLHC is not set! +++\n";
   }
  
   if (!runME11ILT_) {
     edm::LogError("CSCGEMMotherboardME11|SetupError") << "+++ TMB constructed while runME11ILT_ is not set! +++\n";
   }
 }

References CSCBaseboard::isSLHC_, and CSCBaseboard::runME11ILT_.

◆ ~CSCGEMMotherboardME11()

CSCGEMMotherboardME11::~CSCGEMMotherboardME11 ( )

override

Default destructor.

Definition at line 46 of file CSCGEMMotherboardME11.cc.

46 {}

Member Function Documentation

◆ correlateLCTsGEM()

void CSCGEMMotherboardME11::correlateLCTsGEM	(	const CSCALCTDigi &	bestALCT,
		const CSCALCTDigi &	secondALCT,
		const CSCCLCTDigi &	bestCLCT,
		const CSCCLCTDigi &	secondCLCT,
		const GEMPadDigiIds &	pads,
		const GEMCoPadDigiIds &	copads,
		CSCCorrelatedLCTDigi &	lct1,
		CSCCorrelatedLCTDigi &	lct2
	)		const

private

Definition at line 532 of file CSCGEMMotherboardME11.cc.

                                                                                {
   CSCALCTDigi bestALCT = bALCT;
   CSCALCTDigi secondALCT = sALCT;
   const CSCCLCTDigi& bestCLCT = bCLCT;
   CSCCLCTDigi secondCLCT = sCLCT;
  
   // assume that always anodeBestValid and cathodeBestValid
   if (secondALCT == bestALCT)
     secondALCT.clear();
   if (secondCLCT == bestCLCT)
     secondCLCT.clear();
  
   const bool ok_bb = bestALCT.isValid() and bestCLCT.isValid();
   const bool ok_bs = bestALCT.isValid() and secondCLCT.isValid();
   const bool ok_sb = secondALCT.isValid() and bestCLCT.isValid();
   const bool ok_ss = secondALCT.isValid() and secondCLCT.isValid();
  
   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("CSCGEMMotherboardME11") << "debug correlateLCTs in ME11" << cscId_ << "\n"
                                       << "ALCT1: " << bestALCT << "\n"
                                       << "ALCT2: " << secondALCT << "\n"
                                       << "CLCT1: " << bestCLCT << "\n"
                                       << "CLCT2: " << secondCLCT << "\n"
                                       << "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("CSCGEMMotherboardME11") << "lut 0 1 = " << lut[code][0] << " " << lut[code][1] << std::endl;
  
   // check matching copads
   const GEMCoPadDigi& bb_copad = bestMatchingPad<GEMCoPadDigi>(bestALCT, bestCLCT, copads);
   const GEMCoPadDigi& bs_copad = bestMatchingPad<GEMCoPadDigi>(bestALCT, secondCLCT, copads);
   const GEMCoPadDigi& sb_copad = bestMatchingPad<GEMCoPadDigi>(secondALCT, bestCLCT, copads);
   const GEMCoPadDigi& ss_copad = bestMatchingPad<GEMCoPadDigi>(secondALCT, secondCLCT, copads);
  
   // check matching pads
   const GEMPadDigi& bb_pad = bestMatchingPad<GEMPadDigi>(bestALCT, bestCLCT, pads);
   const GEMPadDigi& bs_pad = bestMatchingPad<GEMPadDigi>(bestALCT, secondCLCT, pads);
   const GEMPadDigi& sb_pad = bestMatchingPad<GEMPadDigi>(secondALCT, bestCLCT, pads);
   const GEMPadDigi& ss_pad = bestMatchingPad<GEMPadDigi>(secondALCT, secondCLCT, pads);
  
   // evaluate possible combinations
   const bool ok_bb_copad = ok11 == 1 and ok_bb and bb_copad.isValid();
   const bool ok_bs_copad = ok12 == 1 and ok_bs and bs_copad.isValid();
   const bool ok_sb_copad = ok21 == 1 and ok_sb and sb_copad.isValid();
   const bool ok_ss_copad = ok22 == 1 and ok_ss and ss_copad.isValid();
  
   const bool ok_bb_pad = ok11 == 1 and ok_bb and bb_pad.isValid();
   const bool ok_bs_pad = ok12 == 1 and ok_bs and bs_pad.isValid();
   const bool ok_sb_pad = ok21 == 1 and ok_sb and sb_pad.isValid();
   const bool ok_ss_pad = ok22 == 1 and ok_ss and ss_pad.isValid();
  
   switch (lut[code][0]) {
     case 11:
       if (ok_bb_copad)
         lct1 = CSCGEMMotherboard::constructLCTsGEM(bestALCT, bestCLCT, bb_copad, 1);
       else if (ok_bb_pad)
         lct1 = CSCGEMMotherboard::constructLCTsGEM(bestALCT, bestCLCT, bb_pad, 1);
       else
         lct1 = constructLCTs(bestALCT, bestCLCT, CSCCorrelatedLCTDigi::ALCTCLCT, 1);
       break;
     case 12:
       if (ok_bs_copad)
         lct1 = CSCGEMMotherboard::constructLCTsGEM(bestALCT, secondCLCT, bs_copad, 1);
       else if (ok_bs_pad)
         lct1 = CSCGEMMotherboard::constructLCTsGEM(bestALCT, secondCLCT, bs_pad, 1);
       else
         lct1 = constructLCTs(bestALCT, secondCLCT, CSCCorrelatedLCTDigi::ALCTCLCT, 1);
       break;
     case 21:
       if (ok_sb_copad)
         lct1 = CSCGEMMotherboard::constructLCTsGEM(secondALCT, bestCLCT, sb_copad, 1);
       else if (ok_sb_pad)
         lct1 = CSCGEMMotherboard::constructLCTsGEM(secondALCT, bestCLCT, sb_pad, 1);
       else
         lct1 = constructLCTs(secondALCT, bestCLCT, CSCCorrelatedLCTDigi::ALCTCLCT, 1);
       break;
     case 22:
       if (ok_ss_copad)
         lct1 = CSCGEMMotherboard::constructLCTsGEM(secondALCT, secondCLCT, ss_copad, 1);
       else if (ok_ss_pad)
         lct1 = CSCGEMMotherboard::constructLCTsGEM(secondALCT, secondCLCT, ss_pad, 1);
       else
         lct1 = constructLCTs(secondALCT, secondCLCT, CSCCorrelatedLCTDigi::ALCTCLCT, 1);
       break;
     default:
       return;
   }
  
   if (dbg)
     LogTrace("CSCGEMMotherboardME11") << "lct1: " << lct1 << std::endl;
  
   switch (lut[code][1]) {
     case 12:
       if (ok_bs_copad)
         lct2 = CSCGEMMotherboard::constructLCTsGEM(bestALCT, secondCLCT, bs_copad, 2);
       else if (ok_bs_pad)
         lct2 = CSCGEMMotherboard::constructLCTsGEM(bestALCT, secondCLCT, bs_pad, 2);
       else
         lct2 = constructLCTs(bestALCT, secondCLCT, CSCCorrelatedLCTDigi::ALCTCLCT, 2);
       break;
     case 21:
       if (ok_sb_copad)
         lct2 = CSCGEMMotherboard::constructLCTsGEM(secondALCT, bestCLCT, sb_copad, 2);
       else if (ok_sb_pad)
         lct2 = CSCGEMMotherboard::constructLCTsGEM(secondALCT, bestCLCT, sb_pad, 2);
       else
         lct2 = constructLCTs(secondALCT, bestCLCT, CSCCorrelatedLCTDigi::ALCTCLCT, 2);
       break;
     case 22:
       if (ok_bb_copad)
         lct2 = CSCGEMMotherboard::constructLCTsGEM(secondALCT, secondCLCT, bb_copad, 2);
       else if (ok_bb_pad)
         lct2 = CSCGEMMotherboard::constructLCTsGEM(secondALCT, secondCLCT, bb_pad, 2);
       else
         lct2 = constructLCTs(secondALCT, secondCLCT, CSCCorrelatedLCTDigi::ALCTCLCT, 2);
       break;
     default:
       return;
   }
  
   if (dbg)
     LogTrace("CSCGEMMotherboardME11") << "lct2: " << lct2 << std::endl;
  
   if (dbg)
     LogTrace("CSCGEMMotherboardME11") << "out of correlateLCTs" << std::endl;
   return;
 }

References CSCCorrelatedLCTDigi::ALCTCLCT, CSCALCTDigi::clear(), CSCCLCTDigi::clear(), CSCMotherboard::constructLCTs(), CSCGEMMotherboard::constructLCTsGEM(), CSCBaseboard::cscId_, doesALCTCrossCLCT(), GEMCoPadDigi::isValid(), GEMPadDigi::isValid(), CSCALCTDigi::isValid(), CSCCLCTDigi::isValid(), and LogTrace.

Referenced by run().

◆ doesALCTCrossCLCT()

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

private

Definition at line 524 of file CSCGEMMotherboardME11.cc.

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

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

Referenced by correlateLCTsGEM().

◆ doesWiregroupCrossStrip()

bool CSCGEMMotherboardME11::doesWiregroupCrossStrip	(	int	key_wg,
		int	key_hs
	)		const

overrideprivatevirtual

Reimplemented from CSCGEMMotherboard.

Definition at line 528 of file CSCGEMMotherboardME11.cc.

                                                                                    {
   return cscTmbLUT_->doesWiregroupCrossStrip(key_wg, key_strip, theEndcap, gangedME1a_);
 }

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

◆ getLUT()

const CSCGEMMotherboardLUTME11* CSCGEMMotherboardME11::getLUT ( ) const

inlineoverrideprivatevirtual

Implements CSCGEMMotherboard.

Definition at line 48 of file CSCGEMMotherboardME11.h.

48 { return tmbLUT_.get(); }

References tmbLUT_.

◆ readoutLCTs1a()

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

Definition at line 420 of file CSCGEMMotherboardME11.cc.

420 { return readoutLCTsME11(ME1A); }

References ME1A, and readoutLCTsME11().

Referenced by CSCTriggerPrimitivesBuilder::build(), and run().

◆ readoutLCTs1b()

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

Definition at line 422 of file CSCGEMMotherboardME11.cc.

422 { return readoutLCTsME11(ME1B); }

References ME1B, and readoutLCTsME11().

Referenced by CSCTriggerPrimitivesBuilder::build(), and run().

◆ readoutLCTsME11()

std::vector< CSCCorrelatedLCTDigi > CSCGEMMotherboardME11::readoutLCTsME11 ( enum CSCPart me1ab ) const

private

Definition at line 427 of file CSCGEMMotherboardME11.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;
   switch (tmb_cross_bx_algo) {
     case 0:
     case 1:
       allLCTs.getMatched(all_lcts);
       break;
     case 2:
       sortLCTs(all_lcts, CSCUpgradeMotherboard::sortLCTsByQuality);
       break;
     case 3:
       sortLCTs(all_lcts, CSCUpgradeMotherboard::sortLCTsByGEMDphi);
       break;
     default:
       LogTrace("CSCGEMMotherboardME11") << "tmb_cross_bx_algo error" << std::endl;
       break;
   }
  
   for (const auto& lct : all_lcts) {
     if (!lct.isValid())
       continue;
  
     int bx = lct.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 ((me1ab == CSCPart::ME1B and lct.getStrip() > CSCConstants::MAX_HALF_STRIP_ME1B) or
         (me1ab == CSCPart::ME1A 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 and (bx_readout == -1 or bx == bx_readout)) {
       tmpV.push_back(lct);
       if (bx_readout == -1)
         bx_readout = bx;
     } else
       tmpV.push_back(lct);
   }
  
   // do a final check on the LCTs in readout
   for (const auto& lct : tmpV) {
     checkValid(lct);
   }
  
   return tmpV;
 }

References CSCUpgradeMotherboard::allLCTs, l1GtPatternGenerator_cfi::bx, CSCMotherboard::checkValid(), CSCMotherboard::early_tbins, LCTContainer::getMatched(), LogTrace, CSCConstants::MAX_HALF_STRIP_ME1B, ME1A, ME1B, or, CSCMotherboard::readout_earliest_2, sortLCTs(), CSCUpgradeMotherboard::sortLCTsByGEMDphi(), CSCUpgradeMotherboard::sortLCTsByQuality(), CSCUpgradeMotherboard::tmb_cross_bx_algo, and CSCMotherboard::tmb_l1a_window_size.

Referenced by readoutLCTs1a(), and readoutLCTs1b().

◆ run() [1/2]

void CSCGEMMotherboardME11::run	(	const CSCWireDigiCollection *	wiredc,
		const CSCComparatorDigiCollection *	compdc,
		const GEMPadDigiClusterCollection *	gemPads
	)

overridevirtual

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

Implements CSCGEMMotherboard.

Definition at line 55 of file CSCGEMMotherboardME11.cc.

                                                                                 {
   std::unique_ptr<GEMPadDigiCollection> gemPads(new GEMPadDigiCollection());
   coPadProcessor->declusterize(gemClusters, *gemPads);
   run(wiredc, compdc, gemPads.get());
 }

References CSCGEMMotherboard::coPadProcessor.

Referenced by CSCTriggerPrimitivesBuilder::build().

◆ run() [2/2]

void CSCGEMMotherboardME11::run	(	const CSCWireDigiCollection *	wiredc,
		const CSCComparatorDigiCollection *	compdc,
		const GEMPadDigiCollection *	gemPads
	)

overridevirtual

Implements CSCGEMMotherboard.

Definition at line 63 of file CSCGEMMotherboardME11.cc.

                                                                      {
   CSCGEMMotherboard::clear();
   setupGeometry();
   debugLUTs();
  
   // encode high multiplicity bits
   unsigned alctBits = alctProc->getHighMultiplictyBits();
   encodeHighMultiplicityBits(alctBits);
  
   if (gem_g != nullptr) {
     if (infoV >= 0)
       edm::LogInfo("CSCGEMMotherboardME11|SetupInfo") << "+++ run() called for GEM-CSC integrated trigger! +++ \n";
     gemGeometryAvailable = true;
   }
  
   // check for GEM geometry
   if (not gemGeometryAvailable) {
     edm::LogError("CSCGEMMotherboardME11|SetupError")
         << "+++ run() called for GEM-CSC integrated trigger without valid GEM geometry! +++ \n";
     return;
   }
   gemCoPadV = coPadProcessor->run(gemPads);  // run copad processor in GE1/1
  
   if (!(alctProc and clctProc)) {
     edm::LogError("CSCGEMMotherboardME11|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;
  
   if (debug_matching) {
     LogTrace("CSCGEMMotherboardME11") << "ALL ALCTs from ME11 " << std::endl;
     for (const auto& alct : alctV)
       if (alct.isValid())
         LogTrace("CSCGEMMotherboardME11") << alct << std::endl;
  
     LogTrace("CSCGEMMotherboardME11") << "ALL CLCTs from ME11 " << std::endl;
     for (const auto& clct : clctV)
       if (clct.isValid())
         LogTrace("CSCGEMMotherboardME11") << clct << std::endl;
  
     LogTrace("CSCGEMMotherboardME11") << "ALL GEM copads from GE11-ME11 " << std::endl;
     for (const auto& g : gemCoPadV)
       LogTrace("CSCGEMMotherboardME11") << g << std::endl;
   }
  
   int used_clct_mask[20];
   for (int b = 0; b < 20; b++)
     used_clct_mask[b] = 0;
  
   retrieveGEMPads(gemPads, gemId);
   retrieveGEMCoPads();
  
   const bool hasPads(!pads_.empty());
   const bool hasCoPads(hasPads and !coPads_.empty());
  
   if (debug_matching)
     LogTrace("CSCGEMMotherboardME11") << "hascopads " << hasCoPads << std::endl;
  
   // 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_);
       const int bx_copad_start(bx_alct - maxDeltaBXCoPad_);
       const int bx_copad_stop(bx_alct + maxDeltaBXCoPad_);
  
       if (debug_matching) {
         LogTrace("CSCGEMMotherboardME11")
             << "========================================================================\n"
             << "ALCT-CLCT matching in ME1/1 chamber: " << cscId_ << "\n"
             << "------------------------------------------------------------------------\n"
             << "+++ Best ALCT Details: " << alctProc->getBestALCT(bx_alct) << "\n"
             << "+++ Second ALCT Details: " << alctProc->getSecondALCT(bx_alct) << std::endl;
  
         printGEMTriggerPads(bx_clct_start, bx_clct_stop, CSCPart::ME11);
         printGEMTriggerCoPads(bx_clct_start, bx_clct_stop, CSCPart::ME11);
  
         LogTrace("CSCGEMMotherboardME11")
             << "------------------------------------------------------------------------ \n"
             << "Attempt ALCT-CLCT matching in ME1/b in bx range: [" << bx_clct_start << "," << bx_clct_stop << "]"
             << std::endl;
       }
  
       // ALCT-to-CLCT matching in ME1b
       int nSuccesFulMatches = 0;
       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("CSCGEMMotherboardME11") << "++Valid ME1b CLCT: " << clctProc->getBestCLCT(bx_clct) << std::endl;
  
           // pick the pad that corresponds
           matches<GEMPadDigi> mPads;
           matchingPads<GEMPadDigi>(clctProc->getBestCLCT(bx_clct),
                                    clctProc->getSecondCLCT(bx_clct),
                                    alctProc->getBestALCT(bx_alct),
                                    alctProc->getSecondALCT(bx_alct),
                                    mPads);
           matches<GEMCoPadDigi> mCoPads;
           matchingPads<GEMCoPadDigi>(clctProc->getBestCLCT(bx_clct),
                                      clctProc->getSecondCLCT(bx_clct),
                                      alctProc->getBestALCT(bx_alct),
                                      alctProc->getSecondALCT(bx_alct),
                                      mCoPads);
  
           const bool lowQualityCLCT(clctProc->getBestCLCT(bx_clct).getQuality() <= 3);
           const bool hasMatchingPads(!mPads.empty() or !mCoPads.empty());
           // Low quality LCTs have at most 3 layers. Check if there is a matching GEM pad to keep the CLCT
           if (dropLowQualityCLCTsNoGEMs_ME1b_ and lowQualityCLCT and !hasMatchingPads) {
             LogTrace("CSCGEMMotherboardME11") << "Dropping low quality CLCT without matching GEM pads "
                                               << clctProc->getBestCLCT(bx_clct) << std::endl;
             continue;
           }
  
           if (debug_matching) {
             LogTrace("CSCGEMMotherboardME11") << "mPads " << mPads.size() << " "
                                               << " mCoPads " << mCoPads.size() << std::endl;
             for (auto p : mPads) {
               LogTrace("CSCGEMMotherboardME11") << p.first << " " << p.second << std::endl;
             }
             for (auto p : mCoPads) {
               LogTrace("CSCGEMMotherboardME11") << p.first << " " << p.second << std::endl;
             }
           }
           //        if (infoV > 1) LogTrace("CSCMotherboard")
           int mbx = bx_clct - bx_clct_start;
           correlateLCTsGEM(alctProc->getBestALCT(bx_alct),
                            alctProc->getSecondALCT(bx_alct),
                            clctProc->getBestCLCT(bx_clct),
                            clctProc->getSecondCLCT(bx_clct),
                            mPads,
                            mCoPads,
                            allLCTs(bx_alct, mbx, 0),
                            allLCTs(bx_alct, mbx, 1));
  
           if (allLCTs(bx_alct, mbx, 0).isValid()) {
             ++nSuccesFulMatches;
             used_clct_mask[bx_clct] += 1;
  
             if (debug_matching) {
               LogTrace("CSCGEMMotherboardME11")
                   << "Successful ALCT-CLCT match in ME1b: bx_alct = " << bx_alct << "; match window: [" << bx_clct_start
                   << "; " << bx_clct_stop << "]; bx_clct = " << bx_clct << "\n"
                   << "+++ Best CLCT Details: " << clctProc->getBestCLCT(bx_clct) << "\n"
                   << "+++ Second CLCT Details: " << clctProc->getSecondCLCT(bx_clct) << std::endl;
               if (allLCTs(bx_alct, mbx, 0).isValid()) {
                 LogTrace("CSCGEMMotherboardME11") << "LCT #1 " << allLCTs(bx_alct, mbx, 0) << std::endl;
                 LogTrace("CSCGEMMotherboardME11") << allLCTs(bx_alct, mbx, 0).getALCT() << std::endl;
                 LogTrace("CSCGEMMotherboardME11") << allLCTs(bx_alct, mbx, 0).getCLCT() << std::endl;
                 if (allLCTs(bx_alct, mbx, 0).getType() == 2)
                   LogTrace("CSCGEMMotherboardME11") << allLCTs(bx_alct, mbx, 0).getGEM1() << std::endl;
                 if (allLCTs(bx_alct, mbx, 0).getType() == 3)
                   LogTrace("CSCGEMMotherboardME11")
                       << allLCTs(bx_alct, mbx, 0).getGEM1() << " " << allLCTs(bx_alct, mbx, 0).getGEM2() << std::endl;
               }
  
               if (allLCTs(bx_alct, mbx, 1).isValid()) {
                 LogTrace("CSCGEMMotherboardME11") << "LCT #2 " << allLCTs(bx_alct, mbx, 1) << std::endl;
                 LogTrace("CSCGEMMotherboardME11") << allLCTs(bx_alct, mbx, 1).getALCT() << std::endl;
                 LogTrace("CSCGEMMotherboardME11") << allLCTs(bx_alct, mbx, 1).getCLCT() << std::endl;
                 if (allLCTs(bx_alct, mbx, 1).getType() == 2)
                   LogTrace("CSCGEMMotherboardME11") << allLCTs(bx_alct, mbx, 1).getGEM1() << std::endl;
                 if (allLCTs(bx_alct, mbx, 1).getType() == 3)
                   LogTrace("CSCGEMMotherboardME11")
                       << allLCTs(bx_alct, mbx, 1).getGEM1() << " " << allLCTs(bx_alct, mbx, 1).getGEM2() << std::endl;
               }
             }
  
             if (match_earliest_clct_only)
               break;
           } else
             LogTrace("CSCGEMMotherboardME11") << "No valid LCT is built from ALCT-CLCT matching in ME1b" << std::endl;
         }
       }
  
       // ALCT-to-GEM matching in ME1b
       int nSuccesFulGEMMatches = 0;
       if (nSuccesFulMatches == 0 and buildLCTfromALCTandGEM_ME1b_) {
         if (debug_matching)
           LogTrace("CSCGEMMotherboardME11") << "++No valid ALCT-CLCT matches in ME1b" << std::endl;
         for (int bx_gem = bx_copad_start; bx_gem <= bx_copad_stop; bx_gem++) {
           if (not hasCoPads) {
             continue;
           }
  
           // find the best matching copad
           matches<GEMCoPadDigi> copads;
           matchingPads<CSCALCTDigi, GEMCoPadDigi>(
               alctProc->getBestALCT(bx_alct), alctProc->getSecondALCT(bx_alct), copads);
  
           if (debug_matching)
             LogTrace("CSCGEMMotherboardME11")
                 << "\t++Number of matching GEM CoPads in BX " << bx_alct << " : " << copads.size() << std::endl;
           if (copads.empty()) {
             continue;
           }
  
           CSCGEMMotherboard::correlateLCTsGEM(alctProc->getBestALCT(bx_alct),
                                               alctProc->getSecondALCT(bx_alct),
                                               copads,
                                               allLCTs(bx_alct, 0, 0),
                                               allLCTs(bx_alct, 0, 1));
  
           if (allLCTs(bx_alct, 0, 0).isValid()) {
             ++nSuccesFulGEMMatches;
  
             if (debug_matching) {
               LogTrace("CSCGEMMotherboardME11")
                   << "Successful ALCT-GEM CoPad match in ME1b: bx_alct = " << bx_alct << "\n\n"
                   << "------------------------------------------------------------------------" << std::endl
                   << std::endl;
               if (allLCTs(bx_alct, 0, 0).isValid()) {
                 LogTrace("CSCGEMMotherboardME11") << "LCT #1 " << allLCTs(bx_alct, 0, 0) << std::endl;
                 LogTrace("CSCGEMMotherboardME11") << allLCTs(bx_alct, 0, 0).getALCT() << std::endl;
                 if (allLCTs(bx_alct, 0, 0).getType() == 4)
                   LogTrace("CSCGEMMotherboardME11")
                       << allLCTs(bx_alct, 0, 0).getGEM1() << " " << allLCTs(bx_alct, 0, 0).getGEM2() << std::endl
                       << std::endl;
               } else {
                 LogTrace("CSCGEMMotherboardME11")
                     << "No valid LCT is built from ALCT-GEM matching in ME1b" << std::endl;
               }
               if (allLCTs(bx_alct, 0, 1).isValid()) {
                 LogTrace("CSCGEMMotherboardME11") << "LCT #2 " << allLCTs(bx_alct, 0, 1) << std::endl;
                 LogTrace("CSCGEMMotherboardME11") << allLCTs(bx_alct, 0, 1).getALCT() << std::endl;
                 if (allLCTs(bx_alct, 0, 1).getType() == 4)
                   LogTrace("CSCGEMMotherboardME11")
                       << allLCTs(bx_alct, 0, 1).getGEM1() << " " << allLCTs(bx_alct, 0, 1).getGEM2() << std::endl
                       << std::endl;
               }
             }
  
             if (match_earliest_clct_only)
               break;
           }
         }
       }
  
       if (debug_matching) {
         LogTrace("CSCGEMMotherboardME11")
             << "========================================================================" << std::endl
             << "Summary: " << std::endl;
         if (nSuccesFulMatches > 1)
           LogTrace("CSCGEMMotherboardME11")
               << "Too many successful ALCT-CLCT matches in ME1/1: " << nSuccesFulMatches << ", CSCDetId " << cscId_
               << ", bx_alct = " << bx_alct << "; match window: [" << bx_clct_start << "; " << bx_clct_stop << "]"
               << std::endl;
         else if (nSuccesFulMatches == 1)
           LogTrace("CSCGEMMotherboardME11")
               << "1 successful ALCT-CLCT match in ME1/1: "
               << " CSCDetId " << cscId_ << ", bx_alct = " << bx_alct << "; match window: [" << bx_clct_start << "; "
               << bx_clct_stop << "]" << std::endl;
         else if (nSuccesFulGEMMatches == 1)
           LogTrace("CSCGEMMotherboardME11")
               << "1 successful ALCT-GEM match in ME1/1: "
               << " CSCDetId " << cscId_ << ", bx_alct = " << bx_alct << "; match window: [" << bx_clct_start << "; "
               << bx_clct_stop << "]" << std::endl;
         else
           LogTrace("CSCGEMMotherboardME11") << "Unsuccessful ALCT-CLCT match in ME1/1: "
                                             << "CSCDetId " << cscId_ << ", bx_alct = " << bx_alct << "; match window: ["
                                             << bx_clct_start << "; " << bx_clct_stop << "]" << std::endl;
       }
     }  // end of ALCT valid block
     else {
       auto coPads(coPads_[bx_alct]);
       if (!coPads.empty()) {
         // keep it simple for the time being, only consider the first copad
         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_);
  
         // matching in ME1b
         if (buildLCTfromCLCTandGEM_ME1b_) {
           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()) {
               const int quality(clctProc->getBestCLCT(bx_clct).getQuality());
               // only use high-Q stubs for the time being
               if (quality < 4)
                 continue;
               int mbx = bx_clct - bx_clct_start;
               CSCGEMMotherboard::correlateLCTsGEM(clctProc->getBestCLCT(bx_clct),
                                                   clctProc->getSecondCLCT(bx_clct),
                                                   coPads,
                                                   allLCTs(bx_alct, mbx, 0),
                                                   allLCTs(bx_alct, mbx, 1));
               if (allLCTs(bx_alct, mbx, 0).isValid()) {
                 used_clct_mask[bx_clct] += 1;
  
                 if (debug_matching) {
                   //        if (infoV > 1) LogTrace("CSCMotherboard")
                   LogTrace("CSCGEMMotherboardME11")
                       << "Successful GEM-CLCT match in ME1b: bx_alct = " << bx_alct << "; match window: ["
                       << bx_clct_start << "; " << bx_clct_stop << "]; bx_clct = " << bx_clct << "\n"
                       << "+++ Best CLCT Details: " << clctProc->getBestCLCT(bx_clct) << "\n"
                       << "+++ Second CLCT Details: " << clctProc->getSecondCLCT(bx_clct) << std::endl;
  
                   LogTrace("CSCGEMMotherboardME11") << "LCT #1 " << allLCTs(bx_alct, mbx, 0) << std::endl;
                   LogTrace("CSCGEMMotherboardME11") << allLCTs(bx_alct, mbx, 0).getALCT() << std::endl;
                   if (allLCTs(bx_alct, mbx, 0).getType() == 5)
                     LogTrace("CSCGEMMotherboardME11")
                         << allLCTs(bx_alct, mbx, 0).getGEM1() << " " << allLCTs(bx_alct, mbx, 0).getGEM2() << std::endl
                         << std::endl;
  
                   LogTrace("CSCGEMMotherboardME11") << "LCT #2 " << allLCTs(bx_alct, mbx, 1) << std::endl;
                   LogTrace("CSCGEMMotherboardME11") << allLCTs(bx_alct, mbx, 1).getALCT() << std::endl;
                   if (allLCTs(bx_alct, mbx, 1).getType() == 5)
                     LogTrace("CSCGEMMotherboardME11")
                         << allLCTs(bx_alct, mbx, 1).getGEM1() << " " << allLCTs(bx_alct, mbx, 1).getGEM2() << std::endl
                         << std::endl;
                 }
  
                 if (match_earliest_clct_only)
                   break;
               }
             }
           }  //end of clct loop
         }
       }  // if (!coPads.empty())
     }
   }  // end of ALCT-centric matching
  
   if (debug_matching) {
     LogTrace("CSCGEMMotherboardME11") << "======================================================================== \n"
                                       << "Counting the final LCTs in CSCGEMMotherboard ME11\n"
                                       << "======================================================================== \n"
                                       << "tmb_cross_bx_algo: " << tmb_cross_bx_algo << std::endl;
     unsigned int n1b = 0, n1a = 0;
     for (const auto& p : readoutLCTs1b()) {
       n1b++;
       LogTrace("CSCGEMMotherboardME11") << "1b LCT " << n1b << "  " << p << std::endl;
     }
  
     for (const auto& p : readoutLCTs1a()) {
       n1a++;
       LogTrace("CSCGEMMotherboardME11") << "1a LCT " << n1a << "  " << p << std::endl;
     }
   }
 }

◆ sortLCTs() [1/2]

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

private

Definition at line 510 of file CSCGEMMotherboardME11.cc.

                                                                                                                      {
   for (int bx = 0; bx < CSCConstants::MAX_LCT_TBINS; bx++) {
     // temporary collection with all LCTs in the whole chamber
     std::vector<CSCCorrelatedLCTDigi> LCTs_tmp;
     CSCGEMMotherboardME11::sortLCTs(LCTs_tmp, bx, *sorter);
  
     // Add the LCTs
     for (const auto& p : LCTs_tmp) {
       LCTs.push_back(p);
     }
   }
 }

References l1GtPatternGenerator_cfi::bx, CSCConstants::MAX_LCT_TBINS, AlCaHLTBitMon_ParallelJobs::p, and sortLCTs().

◆ sortLCTs() [2/2]

void CSCGEMMotherboardME11::sortLCTs	(	std::vector< CSCCorrelatedLCTDigi > &	LCTs,
		int	bx,
		bool(*)(const CSCCorrelatedLCTDigi &, const CSCCorrelatedLCTDigi &)	sorter
	)		const

private

Methods to sort the LCTs

Definition at line 498 of file CSCGEMMotherboardME11.cc.

                                                                                                                      {
   allLCTs.getTimeMatched(bx, LCTs);
  
   CSCUpgradeMotherboard::sortLCTs(LCTs, *sorter);
  
   if (LCTs.size() > max_lcts)
     LCTs.erase(LCTs.begin() + max_lcts, LCTs.end());
 }

References CSCUpgradeMotherboard::allLCTs, l1GtPatternGenerator_cfi::bx, LCTContainer::getTimeMatched(), CSCUpgradeMotherboard::max_lcts, and CSCUpgradeMotherboard::sortLCTs().

Referenced by readoutLCTsME11(), and sortLCTs().

Member Data Documentation

◆ buildLCTfromALCTandGEM_ME1a_

bool CSCGEMMotherboardME11::buildLCTfromALCTandGEM_ME1a_

private

Definition at line 89 of file CSCGEMMotherboardME11.h.

◆ buildLCTfromALCTandGEM_ME1b_

bool CSCGEMMotherboardME11::buildLCTfromALCTandGEM_ME1b_

private

Definition at line 90 of file CSCGEMMotherboardME11.h.

Referenced by run().

◆ buildLCTfromCLCTandGEM_ME1a_

bool CSCGEMMotherboardME11::buildLCTfromCLCTandGEM_ME1a_

private

Definition at line 91 of file CSCGEMMotherboardME11.h.

◆ buildLCTfromCLCTandGEM_ME1b_

bool CSCGEMMotherboardME11::buildLCTfromCLCTandGEM_ME1b_

private

Definition at line 92 of file CSCGEMMotherboardME11.h.

Referenced by run().

◆ clctV

std::vector<CSCCLCTDigi> CSCGEMMotherboardME11::clctV

private

Definition at line 80 of file CSCGEMMotherboardME11.h.

Referenced by run().

◆ cscTmbLUT_

std::unique_ptr<CSCMotherboardLUTME11> CSCGEMMotherboardME11::cscTmbLUT_

private

Definition at line 50 of file CSCGEMMotherboardME11.h.

Referenced by CSCGEMMotherboardME11(), doesALCTCrossCLCT(), and doesWiregroupCrossStrip().

◆ dropLowQualityALCTsNoGEMs_ME1a_

bool CSCGEMMotherboardME11::dropLowQualityALCTsNoGEMs_ME1a_

private

Definition at line 85 of file CSCGEMMotherboardME11.h.

◆ dropLowQualityALCTsNoGEMs_ME1b_

bool CSCGEMMotherboardME11::dropLowQualityALCTsNoGEMs_ME1b_

private

Definition at line 86 of file CSCGEMMotherboardME11.h.

◆ dropLowQualityCLCTsNoGEMs_ME1a_

bool CSCGEMMotherboardME11::dropLowQualityCLCTsNoGEMs_ME1a_

private

Definition at line 83 of file CSCGEMMotherboardME11.h.

◆ dropLowQualityCLCTsNoGEMs_ME1b_

bool CSCGEMMotherboardME11::dropLowQualityCLCTsNoGEMs_ME1b_

private

Definition at line 84 of file CSCGEMMotherboardME11.h.

Referenced by run().

◆ promoteCLCTGEMquality_ME1a_

bool CSCGEMMotherboardME11::promoteCLCTGEMquality_ME1a_

private

Definition at line 95 of file CSCGEMMotherboardME11.h.

◆ promoteCLCTGEMquality_ME1b_

bool CSCGEMMotherboardME11::promoteCLCTGEMquality_ME1b_

private

Definition at line 96 of file CSCGEMMotherboardME11.h.

◆ tmbLUT_

std::unique_ptr<CSCGEMMotherboardLUTME11> CSCGEMMotherboardME11::tmbLUT_

private

Definition at line 49 of file CSCGEMMotherboardME11.h.

Referenced by CSCGEMMotherboardME11(), and getLUT().

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ CSCGEMMotherboardME11() [1/2]

◆ CSCGEMMotherboardME11() [2/2]

◆ ~CSCGEMMotherboardME11()

Member Function Documentation

◆ correlateLCTsGEM()

◆ doesALCTCrossCLCT()

◆ doesWiregroupCrossStrip()

◆ getLUT()

◆ readoutLCTs1a()

◆ readoutLCTs1b()

◆ readoutLCTsME11()

◆ run() [1/2]

◆ run() [2/2]

◆ sortLCTs() [1/2]

◆ sortLCTs() [2/2]

Member Data Documentation

◆ buildLCTfromALCTandGEM_ME1a_

◆ buildLCTfromALCTandGEM_ME1b_

◆ buildLCTfromCLCTandGEM_ME1a_

◆ buildLCTfromCLCTandGEM_ME1b_

◆ clctV

◆ cscTmbLUT_

◆ dropLowQualityALCTsNoGEMs_ME1a_

◆ dropLowQualityALCTsNoGEMs_ME1b_

◆ dropLowQualityCLCTsNoGEMs_ME1a_

◆ dropLowQualityCLCTsNoGEMs_ME1b_

◆ promoteCLCTGEMquality_ME1a_

◆ promoteCLCTGEMquality_ME1b_

◆ tmbLUT_