#include <CSCGEMMotherboardME21.h>

Inheritance diagram for CSCGEMMotherboardME21:

Public Member Functions
	CSCGEMMotherboardME21 ()

	CSCGEMMotherboardME21 (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, const GEMPadDigiClusterCollection *gemPads) override

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

	~CSCGEMMotherboardME21 () 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	doesWiregroupCrossStrip (int key_wg, int key_strip) const override

const CSCGEMMotherboardLUTME21 *	getLUT () const override

Private Attributes
bool	buildLCTfromALCTandGEM_

bool	buildLCTfromCLCTandGEM_

bool	dropLowQualityALCTsNoGEMs_

bool	dropLowQualityCLCTsNoGEMs_

std::unique_ptr< CSCGEMMotherboardLUTME21 >	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 ME21 TMB upgrade

Author: Sven Dildick March 2014

Based on CSCMotherboard code

Definition at line 16 of file CSCGEMMotherboardME21.h.

Constructor & Destructor Documentation

◆ CSCGEMMotherboardME21() [1/2]

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

Normal constructor.

Definition at line 3 of file CSCGEMMotherboardME21.cc.

     : CSCGEMMotherboard(endcap, station, sector, subsector, chamber, conf),
       dropLowQualityCLCTsNoGEMs_(tmbParams_.getParameter<bool>("dropLowQualityCLCTsNoGEMs")),
       dropLowQualityALCTsNoGEMs_(tmbParams_.getParameter<bool>("dropLowQualityALCTsNoGEMs")),
       buildLCTfromALCTandGEM_(tmbParams_.getParameter<bool>("buildLCTfromALCTandGEM")),
       buildLCTfromCLCTandGEM_(tmbParams_.getParameter<bool>("buildLCTfromCLCTandGEM")) {
   if (!isSLHC_) {
     edm::LogError("CSCGEMMotherboardME21|SetupError") << "+++ TMB constructed while isSLHC is not set! +++\n";
   }
  
   if (!runME21ILT_) {
     edm::LogError("CSCGEMMotherboardME21|SetupError") << "+++ TMB constructed while runME21ILT_ is not set! +++\n";
   }
  
   // set LUTs
   tmbLUT_.reset(new CSCGEMMotherboardLUTME21());
 }

References CSCBaseboard::isSLHC_, CSCBaseboard::runME21ILT_, and tmbLUT_.

◆ CSCGEMMotherboardME21() [2/2]

CSCGEMMotherboardME21::CSCGEMMotherboardME21 ( )

Test destructor.

Definition at line 26 of file CSCGEMMotherboardME21.cc.

                                              : CSCGEMMotherboard() {
   if (!isSLHC_) {
     edm::LogError("CSCGEMMotherboardME21|SetupError") << "+++ TMB constructed while isSLHC is not set! +++\n";
   }
  
   if (!runME21ILT_) {
     edm::LogError("CSCGEMMotherboardME21|SetupError") << "+++ TMB constructed while runME21ILT_ is not set! +++\n";
   }
 }

References CSCBaseboard::isSLHC_, and CSCBaseboard::runME21ILT_.

◆ ~CSCGEMMotherboardME21()

CSCGEMMotherboardME21::~CSCGEMMotherboardME21 ( )

override

Default destructor.

Definition at line 36 of file CSCGEMMotherboardME21.cc.

36 {}

Member Function Documentation

◆ correlateLCTsGEM()

void CSCGEMMotherboardME21::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 457 of file CSCGEMMotherboardME21.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();
  
   if (!copads.empty() or !pads.empty()) {
     // 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 = ok_bb and bb_copad.isValid();
     const bool ok_bs_copad = ok_bs and bs_copad.isValid();
     const bool ok_sb_copad = ok_sb and sb_copad.isValid();
     const bool ok_ss_copad = ok_ss and ss_copad.isValid();
  
     const bool ok_bb_pad = (not ok_bb_copad) and ok_bb and bb_pad.isValid();
     const bool ok_bs_pad = (not ok_bs_copad) and ok_bs and bs_pad.isValid();
     const bool ok_sb_pad = (not ok_sb_copad) and ok_sb and sb_pad.isValid();
     const bool ok_ss_pad = (not ok_ss_copad) and ok_ss and ss_pad.isValid();
  
     // possible cases with copad
     if (ok_bb_copad or ok_ss_copad) {
       if (ok_bb_copad)
         lct1 = constructLCTsGEM(bestALCT, bestCLCT, bb_copad, 1);
       if (ok_ss_copad)
         lct2 = constructLCTsGEM(secondALCT, secondCLCT, ss_copad, 2);
     } else if (ok_bs_copad or ok_sb_copad) {
       if (ok_bs_copad)
         lct1 = constructLCTsGEM(bestALCT, secondCLCT, bs_copad, 1);
       if (ok_sb_copad)
         lct2 = constructLCTsGEM(secondALCT, bestCLCT, sb_copad, 2);
     }
  
     // done processing?
     if (lct1.isValid() and lct2.isValid())
       return;
  
     // possible cases with pad
     if ((ok_bb_pad or ok_ss_pad) and not(ok_bs_copad or ok_sb_copad)) {
       if (ok_bb_pad)
         lct1 = constructLCTsGEM(bestALCT, bestCLCT, bb_pad, 1);
       if (ok_ss_pad)
         lct2 = constructLCTsGEM(secondALCT, secondCLCT, ss_pad, 2);
     } else if ((ok_bs_pad or ok_sb_pad) and not(ok_bb_copad or ok_ss_copad)) {
       if (ok_bs_pad)
         lct1 = constructLCTsGEM(bestALCT, secondCLCT, bs_pad, 1);
       if (ok_sb_pad)
         lct2 = constructLCTsGEM(secondALCT, bestCLCT, sb_pad, 2);
     }
   } else {
     // run without gems - happens in less than 0.04% of the time
     if (ok_bb)
       lct1 = constructLCTs(bestALCT, bestCLCT, CSCCorrelatedLCTDigi::ALCTCLCT, 1);
     if (ok_ss)
       lct2 = constructLCTs(secondALCT, secondCLCT, CSCCorrelatedLCTDigi::ALCTCLCT, 2);
   }
 }

References CSCCorrelatedLCTDigi::ALCTCLCT, CSCALCTDigi::clear(), CSCCLCTDigi::clear(), CSCMotherboard::constructLCTs(), CSCGEMMotherboard::constructLCTsGEM(), GEMPadDigi::isValid(), GEMCoPadDigi::isValid(), CSCALCTDigi::isValid(), CSCCLCTDigi::isValid(), CSCCorrelatedLCTDigi::isValid(), and or.

Referenced by run().

◆ doesWiregroupCrossStrip()

bool CSCGEMMotherboardME21::doesWiregroupCrossStrip	(	int	key_wg,
		int	key_strip
	)		const

inlineoverrideprivatevirtual

Reimplemented from CSCGEMMotherboard.

Definition at line 51 of file CSCGEMMotherboardME21.h.

51 { return true; }

◆ getLUT()

const CSCGEMMotherboardLUTME21* CSCGEMMotherboardME21::getLUT ( ) const

inlineoverrideprivatevirtual

Implements CSCGEMMotherboard.

Definition at line 47 of file CSCGEMMotherboardME21.h.

47 { return tmbLUT_.get(); }

References tmbLUT_.

◆ readoutLCTs()

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

overridevirtual

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

Reimplemented from CSCMotherboard.

Definition at line 441 of file CSCGEMMotherboardME21.cc.

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

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

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

◆ run() [1/2]

void CSCGEMMotherboardME21::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 38 of file CSCGEMMotherboardME21.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 CSCGEMMotherboardME21::run	(	const CSCWireDigiCollection *	wiredc,
		const CSCComparatorDigiCollection *	compdc,
		const GEMPadDigiCollection *	gemPads
	)

overridevirtual

Implements CSCGEMMotherboard.

Definition at line 46 of file CSCGEMMotherboardME21.cc.

                                                                      {
   CSCGEMMotherboard::clear();
   setupGeometry();
   debugLUTs();
  
   // encode high multiplicity bits
   unsigned alctBits = alctProc->getHighMultiplictyBits();
   encodeHighMultiplicityBits(alctBits);
  
   if (gem_g != nullptr) {
     if (infoV >= 0)
       edm::LogInfo("CSCGEMMotherboardME21|SetupInfo") << "+++ run() called for GEM-CSC integrated trigger! +++ \n";
     gemGeometryAvailable = true;
   }
  
   // check for GEM geometry
   if (not gemGeometryAvailable) {
     edm::LogError("CSCGEMMotherboardME21|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("CSCGEMMotherboardME21|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;
  
   LogTrace("CSCGEMCMotherboardME21") << "ALL ALCTs from ME21 " << std::endl;
   for (const auto& alct : alctV)
     if (alct.isValid())
       LogTrace("CSCGEMCMotherboardME21") << alct << std::endl;
  
   LogTrace("CSCGEMCMotherboardME21") << "ALL CLCTs from ME21 " << std::endl;
   for (const auto& clct : clctV)
     if (clct.isValid())
       LogTrace("CSCGEMCMotherboardME21") << clct << std::endl;
  
   int used_clct_mask[20];
   for (int c = 0; c < 20; ++c)
     used_clct_mask[c] = 0;
  
   // retrieve pads and copads in a certain BX window for this CSC
  
   retrieveGEMPads(gemPads, gemId);
   retrieveGEMCoPads();
  
   const bool hasCoPads(!coPads_.empty());
  
   // 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_);
  
       const int quality(alctProc->getBestALCT(bx_alct).getQuality());
  
       if (debug_matching) {
         LogTrace("CSCGEMMotherboardME21")
             << "========================================================================" << std::endl
             << "ALCT-CLCT matching in ME2/1 chamber: " << cscId_ << " in bx range: [" << bx_clct_start << ","
             << bx_clct_stop << "] for bx " << bx_alct << std::endl
             << "------------------------------------------------------------------------" << std::endl
             << "+++ Best ALCT Details: " << alctProc->getBestALCT(bx_alct) << std::endl
             << "+++ Second ALCT Details: " << alctProc->getSecondALCT(bx_alct) << std::endl;
  
         printGEMTriggerPads(bx_clct_start, bx_clct_stop, CSCPart::ME21);
         printGEMTriggerCoPads(bx_clct_start, bx_clct_stop, CSCPart::ME21);
       }
  
       // ALCT-to-CLCT
       int nGoodMatches = 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("CSCGEMMotherboardME21")
                 << "+++ Best CLCT Details: " << clctProc->getBestCLCT(bx_clct) << std::endl
                 << "+++ Second CLCT Details: " << clctProc->getSecondCLCT(bx_clct) << std::endl;
           }
  
           // clct quality
           const bool lowQualityCLCT(clctProc->getBestCLCT(bx_clct).getQuality() <= 3);
           // low quality ALCT
           const bool lowQualityALCT(alctProc->getBestALCT(bx_alct).getQuality() == 0);
  
           // 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);
  
           bool hasMatchingPads(!mPads.empty() or !mCoPads.empty());
  
           if (dropLowQualityCLCTsNoGEMs_ and lowQualityCLCT and !hasMatchingPads) {
             continue;
           }
           if (dropLowQualityALCTsNoGEMs_ and lowQualityALCT and !hasMatchingPads) {
             continue;
           }
  
           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()) {
             used_clct_mask[bx_clct] += 1;
             ++nGoodMatches;
  
             if (debug_matching) {
               LogTrace("CSCGEMMotherboardME21")
                   << "Good ALCT-CLCT match in ME21: bx_alct = " << bx_alct << "; match window: [" << bx_clct_start
                   << "; " << bx_clct_stop << "]; bx_clct = " << bx_clct << "\n"
                   << std::endl;
  
               if (allLCTs(bx_alct, mbx, 0).isValid()) {
                 LogTrace("CSCGEMMotherboardME21") << "LCT #1 " << allLCTs(bx_alct, mbx, 0) << std::endl
                                                   << allLCTs(bx_alct, mbx, 0).getALCT() << std::endl
                                                   << allLCTs(bx_alct, mbx, 0).getCLCT() << std::endl;
                 if (allLCTs(bx_alct, mbx, 0).getType() == 2)
                   LogTrace("CSCGEMMotherboardME21") << allLCTs(bx_alct, mbx, 0).getGEM1() << std::endl;
                 if (allLCTs(bx_alct, mbx, 0).getType() == 3)
                   LogTrace("CSCGEMMotherboardME21")
                       << allLCTs(bx_alct, mbx, 0).getGEM1() << " " << allLCTs(bx_alct, mbx, 0).getGEM2() << std::endl;
               }
  
               if (allLCTs(bx_alct, mbx, 1).isValid()) {
                 LogTrace("CSCGEMMotherboardME21") << "LCT #2 " << allLCTs(bx_alct, mbx, 1) << std::endl
                                                   << allLCTs(bx_alct, mbx, 1).getALCT() << std::endl
                                                   << allLCTs(bx_alct, mbx, 1).getCLCT() << std::endl;
                 if (allLCTs(bx_alct, mbx, 1).getType() == 2)
                   LogTrace("CSCGEMMotherboardME21") << allLCTs(bx_alct, mbx, 1).getGEM1() << std::endl;
                 if (allLCTs(bx_alct, mbx, 1).getType() == 3)
                   LogTrace("CSCGEMMotherboardME21")
                       << allLCTs(bx_alct, mbx, 1).getGEM1() << " " << allLCTs(bx_alct, mbx, 1).getGEM2() << std::endl;
               }
             }
  
             if (match_earliest_clct_only) {
               break;
             }
           }
         }
       }
  
       // ALCT-to-GEM matching
       int nGoodGEMMatches = 0;
       // only use high-quality stubs
       if (nGoodMatches == 0 and buildLCTfromALCTandGEM_ and quality >=1) {
         if (debug_matching)
           LogTrace("CSCGEMMotherboardME21") << "++No valid ALCT-CLCT matches in ME21" << 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("CSCGEMMotherboardME21")
                 << "\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()) {
             ++nGoodGEMMatches;
  
             if (debug_matching) {
               LogTrace("CSCGEMMotherboardME21")
                   << "Good ALCT-GEM CoPad match in ME21: bx_alct = " << bx_alct << "\n\n"
                   << "------------------------------------------------------------------------" << std::endl
                   << std::endl;
               if (allLCTs(bx_alct, 0, 0).isValid()) {
                 LogTrace("CSCGEMMotherboardME21") << "LCT #1 " << allLCTs(bx_alct, 0, 0) << std::endl
                                                   << allLCTs(bx_alct, 0, 0).getALCT() << std::endl;
                 if (allLCTs(bx_alct, 0, 0).getType() == 4)
                   LogTrace("CSCGEMMotherboardME21")
                       << allLCTs(bx_alct, 0, 0).getGEM1() << " " << allLCTs(bx_alct, 0, 0).getGEM2() << std::endl
                       << std::endl;
               }
               if (allLCTs(bx_alct, 0, 1).isValid()) {
                 LogTrace("CSCGEMMotherboardME21") << "LCT #2 " << allLCTs(bx_alct, 0, 1) << std::endl
                                                   << allLCTs(bx_alct, 0, 1).getALCT() << std::endl;
                 if (allLCTs(bx_alct, 0, 1).getType() == 4)
                   LogTrace("CSCGEMMotherboardME21")
                       << allLCTs(bx_alct, 0, 1).getGEM1() << " " << allLCTs(bx_alct, 0, 1).getGEM2() << std::endl
                       << std::endl;
               }
             }
             if (match_earliest_clct_only)
               break;
           } else {
             LogTrace("CSCGEMMotherboardME21") << "No valid LCT is built from ALCT-GEM matching in ME21" << std::endl;
           }
         }
       }
  
       if (debug_matching) {
         LogTrace("CSCGEMMotherboardME21")
             << "========================================================================" << std::endl;
         LogTrace("CSCGEMMotherboardME21") << "Summary: " << std::endl;
         if (nGoodMatches > 1)
           LogTrace("CSCGEMMotherboardME21")
               << "Too many good ALCT-CLCT matches in ME21: " << nGoodMatches << ", CSCDetId " << cscId_
               << ", bx_alct = " << bx_alct << "; match window: [" << bx_clct_start << "; " << bx_clct_stop << "]"
               << std::endl;
         else if (nGoodMatches == 1)
           LogTrace("CSCGEMMotherboardME21")
               << "1 good ALCT-CLCT match in ME21: "
               << " CSCDetId " << cscId_ << ", bx_alct = " << bx_alct << "; match window: [" << bx_clct_start << "; "
               << bx_clct_stop << "]" << std::endl;
         else if (nGoodGEMMatches == 1)
           LogTrace("CSCGEMMotherboardME21")
               << "1 good ALCT-GEM match in ME21: "
               << " CSCDetId " << cscId_ << ", bx_alct = " << bx_alct << "; match window: [" << bx_clct_start << "; "
               << bx_clct_stop << "]" << std::endl;
         else
           LogTrace("CSCGEMMotherboardME21") << "Bad ALCT-CLCT match in ME21: "
                                             << "CSCDetId " << cscId_ << ", bx_alct = " << bx_alct << "; match window: ["
                                             << bx_clct_start << "; " << bx_clct_stop << "]" << std::endl;
       }
     }
     // at this point we have invalid ALCTs --> try GEM pad matching
     else {
       auto coPads(coPads_[bx_alct]);
       if (!coPads.empty() and buildLCTfromCLCTandGEM_) {
         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("CSCGEMMotherboardME21")
               << "========================================================================" << std::endl
               << "GEM-CLCT matching in ME2/1 chamber: " << cscId_ << "in bx:" << bx_alct << std::endl
               << "------------------------------------------------------------------------" << std::endl;
         }
         // GEM-to-CLCT
         // matching in ME21
         if (buildLCTfromCLCTandGEM_) {
           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) {
                   LogTrace("CSCGEMMotherboardME21")
                       << "Good GEM-CLCT match in ME21: 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("CSCGEMMotherboardME21") << "LCT #1 " << allLCTs(bx_alct, mbx, 0) << std::endl
                                                     << allLCTs(bx_alct, mbx, 0).getALCT() << std::endl;
                   if (allLCTs(bx_alct, mbx, 0).getType() == 5)
                     LogTrace("CSCGEMMotherboardME21")
                         << allLCTs(bx_alct, mbx, 0).getGEM1() << " " << allLCTs(bx_alct, mbx, 0).getGEM2() << std::endl;
  
                   LogTrace("CSCGEMMotherboardME21") << "LCT #2 " << allLCTs(bx_alct, mbx, 1) << std::endl
                                                     << allLCTs(bx_alct, mbx, 1).getALCT() << std::endl;
                   if (allLCTs(bx_alct, mbx, 1).getType() == 5)
                     LogTrace("CSCGEMMotherboardME21")
                         << allLCTs(bx_alct, mbx, 1).getGEM1() << " " << allLCTs(bx_alct, mbx, 1).getGEM2() << std::endl;
                 }
  
                 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("CSCGEMMotherboardME21")
                 << "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("CSCGEMMotherboardME21")
                   << "LCT" << i + 1 << " " << bx << "/" << bx + mbx - match_trig_window_size / 2 << ": "
                   << allLCTs(bx, mbx, i) << std::endl;
             }
           }
         }
         if (infoV > 0 and n > 0)
           LogDebug("CSCGEMMotherboardME21") << "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("CSCGEMCMotherboardME21") << "========================================================================"
                                          << std::endl;
       LogTrace("CSCGEMCMotherboardME21") << "Counting the final LCTs in CSCGEM Motherboard ME21" << std::endl;
       LogTrace("CSCGEMCMotherboardME21") << "========================================================================"
                                          << std::endl;
       first = false;
       LogTrace("CSCGEMCMotherboardME21") << "tmb_cross_bx_algo: " << tmb_cross_bx_algo << std::endl;
     }
     n++;
     if (debug_matching)
       LogTrace("CSCGEMCMotherboardME21") << "LCT " << n << "  " << p << std::endl;
   }
 }

Member Data Documentation

◆ buildLCTfromALCTandGEM_

bool CSCGEMMotherboardME21::buildLCTfromALCTandGEM_

private

Definition at line 69 of file CSCGEMMotherboardME21.h.

Referenced by run().

◆ buildLCTfromCLCTandGEM_

bool CSCGEMMotherboardME21::buildLCTfromCLCTandGEM_

private

Definition at line 70 of file CSCGEMMotherboardME21.h.

Referenced by run().

◆ dropLowQualityALCTsNoGEMs_

bool CSCGEMMotherboardME21::dropLowQualityALCTsNoGEMs_

private

Definition at line 66 of file CSCGEMMotherboardME21.h.

Referenced by run().

◆ dropLowQualityCLCTsNoGEMs_

bool CSCGEMMotherboardME21::dropLowQualityCLCTsNoGEMs_

private

Definition at line 65 of file CSCGEMMotherboardME21.h.

Referenced by run().

◆ tmbLUT_

std::unique_ptr<CSCGEMMotherboardLUTME21> CSCGEMMotherboardME21::tmbLUT_

private

Definition at line 48 of file CSCGEMMotherboardME21.h.

Referenced by CSCGEMMotherboardME21(), and getLUT().

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ CSCGEMMotherboardME21() [1/2]

◆ CSCGEMMotherboardME21() [2/2]

◆ ~CSCGEMMotherboardME21()

Member Function Documentation

◆ correlateLCTsGEM()

◆ doesWiregroupCrossStrip()

◆ getLUT()

◆ readoutLCTs()

◆ run() [1/2]

◆ run() [2/2]

Member Data Documentation

◆ buildLCTfromALCTandGEM_

◆ buildLCTfromCLCTandGEM_

◆ dropLowQualityALCTsNoGEMs_

◆ dropLowQualityCLCTsNoGEMs_

◆ tmbLUT_