#include <CSCGEMMotherboardME21.h>

Inheritance diagram for CSCGEMMotherboardME21:

Public Member Functions
void	clear ()

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

	CSCGEMMotherboardME21 ()

std::vector< CSCCorrelatedLCTDigi >	readoutLCTs () const

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

	~CSCGEMMotherboardME21 () override

Public Member Functions inherited from CSCGEMMotherboard
template<class S >
S	bestMatchingPad (const CSCALCTDigi &alct1, const matches< S > &pads, enum CSCPart) const

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

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

void	clear ()

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

	CSCGEMMotherboard ()

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

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

	~CSCGEMMotherboard () override

Public Member Functions inherited from CSCUpgradeMotherboard
template<class S >
bool	compare (const S &p, const S &q) const

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

	CSCUpgradeMotherboard ()

void	debugLUTs ()

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

void	setCSCGeometry (const CSCGeometry *g)

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 (unsigned endcap, unsigned station, unsigned sector, unsigned subsector, unsigned chamber, const edm::ParameterSet &conf)

	CSCMotherboard ()

std::vector< CSCCorrelatedLCTDigi >	getLCTs () const

std::vector< CSCCorrelatedLCTDigi >	readoutLCTs () const

void	run (const std::vector< int > w_time[CSCConstants::NUM_LAYERS][CSCConstants::MAX_NUM_WIRES], const std::vector< int > hs_times[CSCConstants::NUM_LAYERS][CSCConstants::NUM_HALF_STRIPS_7CFEBS], const std::vector< int > ds_times[CSCConstants::NUM_LAYERS][CSCConstants::NUM_HALF_STRIPS_7CFEBS])

void	run (const CSCWireDigiCollection wiredc, const CSCComparatorDigiCollection compdc)

void	setConfigParameters (const CSCDBL1TPParameters *conf)

void	setCSCGeometry (const CSCGeometry *g)

virtual	~CSCMotherboard ()=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, enum CSCPart p) const

const CSCGEMMotherboardLUTME21 *	getLUT () const override

Private Attributes
LCTContainer	allLCTs

bool	buildLCTfromALCTandGEM_

bool	buildLCTfromCLCTandGEM_

std::vector< CSCCLCTDigi >	clctV

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 >	alct

std::unique_ptr< CSCCathodeLCTProcessor >	clct

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 matches< T > &, enum CSCPart) const

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

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

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

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

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

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

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

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

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

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

int	getBX (const GEMPadDigi &p) const

int	getBX (const GEMCoPadDigi &p) const

float	getPad (const GEMPadDigi &) const

float	getPad (const GEMCoPadDigi &) const

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

int	getRoll (const GEMPadDigiId &p) const

int	getRoll (const GEMCoPadDigiId &p) const

int	getRoll (const CSCALCTDigi &) const

bool	isGEMDetId (unsigned int) const

bool	isPadInOverlap (int roll) const

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

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

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

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

template<class T >
void	matchingPads (const CSCCLCTDigi &clct1, const CSCCLCTDigi &clct2, const CSCALCTDigi &alct1, const CSCALCTDigi &alct2, enum CSCPart part, matches< T > &) 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 CSCMotherboard
void	checkConfigParameters ()

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

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

void	dumpConfigParams () const

unsigned int	encodePattern (const int ptn, const int highPt) const

unsigned int	findQuality (const CSCALCTDigi &aLCT, const CSCCLCTDigi &cLCT) const

CSCALCTDigi	getBXShiftedALCT (const CSCALCTDigi &) const

void	testLCT ()

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
std::vector< CSCALCTDigi >	alctV

bool	clct_to_alct

edm::ParameterSet	commonParams_

const CSCGeometry *	csc_g

const CSCChamber *	cscChamber

bool	debug_luts

bool	debug_matching

bool	drop_used_clcts

std::unique_ptr< CSCUpgradeMotherboardLUTGenerator >	generator_

bool	match_earliest_alct_only

bool	match_earliest_clct_only

unsigned int	max_lcts

Parity	par

int	pref [CSCConstants::MAX_LCT_TBINS]

unsigned	theChamber

unsigned	theRegion

unsigned int	tmb_cross_bx_algo

edm::ParameterSet	tmbParams_

Protected Attributes inherited from CSCMotherboard
unsigned int	alct_trig_enable

bool	clct_to_alct

unsigned int	clct_trig_enable

const CSCGeometry *	csc_g

bool	drop_used_alcts

bool	drop_used_clcts

int	early_tbins

CSCCorrelatedLCTDigi	firstLCT [CSCConstants::MAX_LCT_TBINS]

int	infoV

bool	isMTCC

bool	isSLHC

bool	isTMB07

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]

const unsigned	theEndcap

unsigned	theRing

const unsigned	theSector

const unsigned	theStation

const unsigned	theSubsector

const unsigned	theTrigChamber

unsigned int	tmb_l1a_window_size

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::CSCGEMMotherboardME21	(	unsigned	endcap,
		unsigned	station,
		unsigned	sector,
		unsigned	subsector,
		unsigned	chamber,
		const edm::ParameterSet &	conf
	)

Normal constructor.

Definition at line 6 of file CSCGEMMotherboardME21.cc.

References tmbLUT_.

   : CSCGEMMotherboard(endcap, station, sector, subsector, chamber, conf)
   , allLCTs(match_trig_window_size)
   , dropLowQualityCLCTsNoGEMs_(tmbParams_.getParameter<bool>("dropLowQualityCLCTsNoGEMs"))
   , dropLowQualityALCTsNoGEMs_(tmbParams_.getParameter<bool>("dropLowQualityALCTsNoGEMs"))
   , buildLCTfromALCTandGEM_(tmbParams_.getParameter<bool>("buildLCTfromALCTandGEM"))
   , buildLCTfromCLCTandGEM_(tmbParams_.getParameter<bool>("buildLCTfromCLCTandGEM"))
 {
   // set LUTs
   tmbLUT_.reset(new CSCGEMMotherboardLUTME21());
 }

CSCGEMMotherboardME21::CSCGEMMotherboardME21 ( )

Test destructor.

Definition at line 22 of file CSCGEMMotherboardME21.cc.

   : CSCGEMMotherboard()
   , allLCTs(match_trig_window_size)
 {
 }

CSCGEMMotherboardME21::~CSCGEMMotherboardME21 ( )

override

Default destructor.

Definition at line 29 of file CSCGEMMotherboardME21.cc.

30 {

31 }

Member Function Documentation

void CSCGEMMotherboardME21::clear ( void )

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

Definition at line 34 of file CSCGEMMotherboardME21.cc.

References allLCTs, CSCGEMMotherboard::clear(), CSCMotherboard::clear(), mps_fire::i, CSCMotherboard::match_trig_window_size, CSCConstants::MAX_LCT_TBINS, and CSCConstants::MAX_LCTS_PER_CSC.

Referenced by run().

 {
   CSCMotherboard::clear();
   CSCGEMMotherboard::clear();
 
   for (int bx = 0; bx < CSCConstants::MAX_LCT_TBINS; bx++) {
     for (unsigned int mbx = 0; mbx < match_trig_window_size; mbx++) {
       for (int i=0;i<CSCConstants::MAX_LCTS_PER_CSC;i++) {
     allLCTs(bx,mbx,i).clear();
       }
     }
   }
 }

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,
		enum CSCPart	p
	)		const

private

Definition at line 369 of file CSCGEMMotherboardME21.cc.

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

Referenced by run().

 {
   CSCALCTDigi bestALCT = bALCT;
   CSCALCTDigi secondALCT = sALCT;
   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, p);
     const GEMCoPadDigi& bs_copad = bestMatchingPad<GEMCoPadDigi>(bestALCT,   secondCLCT, copads, p);
     const GEMCoPadDigi& sb_copad = bestMatchingPad<GEMCoPadDigi>(secondALCT, bestCLCT,   copads, p);
     const GEMCoPadDigi& ss_copad = bestMatchingPad<GEMCoPadDigi>(secondALCT, secondCLCT, copads, p);
 
     // check matching pads
     const GEMPadDigi& bb_pad = bestMatchingPad<GEMPadDigi>(bestALCT,   bestCLCT,   pads, p);
     const GEMPadDigi& bs_pad = bestMatchingPad<GEMPadDigi>(bestALCT,   secondCLCT, pads, p);
     const GEMPadDigi& sb_pad = bestMatchingPad<GEMPadDigi>(secondALCT, bestCLCT,   pads, p);
     const GEMPadDigi& ss_pad = bestMatchingPad<GEMPadDigi>(secondALCT, secondCLCT, pads, p);
 
     // 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, p, 1);
       if (ok_ss_copad) lct2 = constructLCTsGEM(secondALCT, secondCLCT, ss_copad, p, 2);
     }
     else if(ok_bs_copad or ok_sb_copad){
       if (ok_bs_copad) lct1 = constructLCTsGEM(bestALCT, secondCLCT, bs_copad, p, 1);
       if (ok_sb_copad) lct2 = constructLCTsGEM(secondALCT, bestCLCT, sb_copad, p, 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, p, 1);
       if (ok_ss_pad) lct2 = constructLCTsGEM(secondALCT, secondCLCT, ss_pad, p, 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, p, 1);
       if (ok_sb_pad) lct2 = constructLCTsGEM(secondALCT, bestCLCT, sb_pad, p, 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);
   }
 }

const CSCGEMMotherboardLUTME21* CSCGEMMotherboardME21::getLUT ( ) const

inlineoverrideprivatevirtual

Implements CSCGEMMotherboard.

Definition at line 47 of file CSCGEMMotherboardME21.h.

References tmbLUT_.

47 {return tmbLUT_.get();}

CSCGEMMotherboardME21::tmbLUT_

std::unique_ptr< CSCGEMMotherboardLUTME21 > tmbLUT_

Definition: CSCGEMMotherboardME21.h:48

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

Definition at line 359 of file CSCGEMMotherboardME21.cc.

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

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

 {
   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);
   return result;
 }

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

overridevirtual

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

Implements CSCGEMMotherboard.

Definition at line 49 of file CSCGEMMotherboardME21.cc.

Referenced by CSCTriggerPrimitivesBuilder::build().

 {
   clear();
   setupGeometry();
   debugLUTs();
 
   if (gem_g != nullptr) {
     if (infoV >= 0) edm::LogInfo("L1CSCTPEmulatorSetupInfo")
               << "+++ run() called for GEM-CSC integrated trigger! +++ \n";
     gemGeometryAvailable = true;
   }
 
   // check for GEM geometry
   if (not gemGeometryAvailable){
     if (infoV >= 0) edm::LogError("L1CSCTPEmulatorSetupError")
               << "+++ run() called for GEM-CSC integrated trigger without valid GEM geometry! +++ \n";
     return;
   }
   gemCoPadV = coPadProcessor->run(gemPads); // run copad processor in GE1/1
 
   if (!( alct and clct))
   {
     if (infoV >= 0) edm::LogError("L1CSCTPEmulatorSetupError")
       << "+++ run() called for non-existing ALCT/CLCT processor! +++ \n";
     return;
   }
 
   alct->setCSCGeometry(csc_g);
   clct->setCSCGeometry(csc_g);
 
   alctV = alct->run(wiredc); // run anodeLCT
   clctV = clct->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;
 
   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 hasPads(!pads_.empty());
   const bool hasCoPads(!coPads_.empty());
 
   // ALCT centric matching
   for (int bx_alct = 0; bx_alct < CSCConstants::MAX_ALCT_TBINS; bx_alct++)
   {
     if (alct->bestALCT[bx_alct].isValid())
     {
       const int bx_clct_start(bx_alct - match_trig_window_size/2);
       const int bx_clct_stop(bx_alct + match_trig_window_size/2);
       const int bx_copad_start(bx_alct - maxDeltaBXCoPad_);
       const int bx_copad_stop(bx_alct + maxDeltaBXCoPad_);
 
       if (debug_matching){
         LogTrace("CSCGEMCMotherboardME21") << "========================================================================" << std::endl;
         LogTrace("CSCGEMCMotherboardME21") << "ALCT-CLCT matching in ME2/1 chamber: " << cscChamber->id() << std::endl;
         LogTrace("CSCGEMCMotherboardME21") << "------------------------------------------------------------------------" << std::endl;
         LogTrace("CSCGEMCMotherboardME21") << "+++ Best ALCT Details: ";
         alct->bestALCT[bx_alct].print();
         LogTrace("CSCGEMCMotherboardME21") << "+++ Second ALCT Details: ";
         alct->secondALCT[bx_alct].print();
 
         printGEMTriggerPads(bx_clct_start, bx_clct_stop, CSCPart::ME21);
         printGEMTriggerCoPads(bx_clct_start, bx_clct_stop, CSCPart::ME21);
 
         LogTrace("CSCGEMCMotherboardME21") << "------------------------------------------------------------------------" << std::endl;
         LogTrace("CSCGEMCMotherboardME21") << "Attempt ALCT-CLCT matching in ME2/1 in bx range: [" << bx_clct_start << "," << bx_clct_stop << "]" << std::endl;
       }
 
       // ALCT-to-CLCT
       int nSuccessFulMatches = 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 (clct->bestCLCT[bx_clct].isValid())
         {
           // clct quality
           const int quality(clct->bestCLCT[bx_clct].getQuality());
           // low quality ALCT
           const bool lowQualityALCT(alct->bestALCT[bx_alct].getQuality() == 0);
           // low quality ALCT or CLCT
           const bool lowQuality(quality<4 or lowQualityALCT);
           if (debug_matching) LogTrace("CSCGEMCMotherboardME21") << "++Valid ME21 CLCT: " << clct->bestCLCT[bx_clct] << std::endl;
 
       // pick the pad that corresponds
       matches<GEMPadDigi> mPads;
       matchingPads<GEMPadDigi>(clct->bestCLCT[bx_clct], clct->secondCLCT[bx_clct],
                    alct->bestALCT[bx_alct], alct->secondALCT[bx_alct], ME21, mPads);
       matches<GEMCoPadDigi> mCoPads;
       matchingPads<GEMCoPadDigi>(clct->bestCLCT[bx_clct], clct->secondCLCT[bx_clct],
                      alct->bestALCT[bx_alct], alct->secondALCT[bx_alct], ME21, mCoPads);
 
           if (dropLowQualityCLCTsNoGEMs_ and lowQuality and hasPads){
             int nFound(mPads.size());
             const bool clctInEdge(clct->bestCLCT[bx_clct].getKeyStrip() < 5 or clct->bestCLCT[bx_clct].getKeyStrip() > 155);
             if (clctInEdge){
               if (debug_matching) LogTrace("CSCGEMCMotherboardME21") << "\tInfo: low quality CLCT in CSC chamber edge, don't care about GEM pads" << std::endl;
             }
             else {
               if (nFound != 0){
                 if (debug_matching) LogTrace("CSCGEMCMotherboardME21") << "\tInfo: low quality CLCT with " << nFound << " matching GEM trigger pads" << std::endl;
               }
               else {
                 if (debug_matching) LogTrace("CSCGEMCMotherboardME21") << "\tWarning: low quality CLCT without matching GEM trigger pad" << std::endl;
                 continue;
               }
             }
           }
 
           ++nSuccessFulMatches;
 
           int mbx = bx_clct-bx_clct_start;
       correlateLCTsGEM(alct->bestALCT[bx_alct], alct->secondALCT[bx_alct],
                clct->bestCLCT[bx_clct], clct->secondCLCT[bx_clct],
                mPads, mCoPads,
                allLCTs(bx_alct,mbx,0), allLCTs(bx_alct,mbx,1), CSCPart::ME21);
           if (debug_matching) {
         //      if (infoV > 1) LogTrace("CSCMotherboard")
             LogTrace("CSCGEMCMotherboardME21") << "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("CSCGEMCMotherboardME21") << "+++ Best CLCT Details: ";
             clct->bestCLCT[bx_clct].print();
             LogTrace("CSCGEMCMotherboardME21") << "+++ Second CLCT Details: ";
             clct->secondCLCT[bx_clct].print();
           }
           if (allLCTs(bx_alct,mbx,0).isValid()) {
             used_clct_mask[bx_clct] += 1;
             if (match_earliest_clct_only) break;
           }
         }
       }
 
       // ALCT-to-GEM matching
       int nSuccessFulGEMMatches = 0;
       if (nSuccessFulMatches==0 and buildLCTfromALCTandGEM_){
         if (debug_matching) LogTrace("CSCGEMCMotherboardME21") << "++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>(alct->bestALCT[bx_alct], alct->secondALCT[bx_alct], ME21, copads);
 
           if (debug_matching) LogTrace("CSCGEMCMotherboardME21") << "\t++Number of matching GEM CoPads in BX " << bx_alct << " : "<< copads.size() << std::endl;
           if (copads.empty()) {
             continue;
           }
 
       CSCGEMMotherboard::correlateLCTsGEM(alct->bestALCT[bx_alct], alct->secondALCT[bx_alct],
                           copads, allLCTs(bx_alct,0,0), allLCTs(bx_alct,0,1), CSCPart::ME21);
           if (allLCTs(bx_alct,0,0).isValid()) {
             ++nSuccessFulGEMMatches;
             if (match_earliest_clct_only) break;
           }
           if (debug_matching) {
             LogTrace("CSCGEMCMotherboardME21") << "Successful ALCT-GEM CoPad match in ME21: bx_alct = " << bx_alct << std::endl << std::endl;
             LogTrace("CSCGEMCMotherboardME21") << "------------------------------------------------------------------------" << std::endl << std::endl;
           }
         }
       }
 
       if (debug_matching) {
         LogTrace("CSCGEMCMotherboardME21") << "========================================================================" << std::endl;
         LogTrace("CSCGEMCMotherboardME21") << "Summary: " << std::endl;
         if (nSuccessFulMatches>1)
           LogTrace("CSCGEMCMotherboardME21") << "Too many successful ALCT-CLCT matches in ME21: " << nSuccessFulMatches
                     << ", CSCDetId " << cscChamber->id()
                     << ", bx_alct = " << bx_alct
                     << "; match window: [" << bx_clct_start << "; " << bx_clct_stop << "]" << std::endl;
         else if (nSuccessFulMatches==1)
           LogTrace("CSCGEMCMotherboardME21") << "1 successful ALCT-CLCT match in ME21: "
                     << " CSCDetId " << cscChamber->id()
                     << ", bx_alct = " << bx_alct
                     << "; match window: [" << bx_clct_start << "; " << bx_clct_stop << "]" << std::endl;
         else if (nSuccessFulGEMMatches==1)
           LogTrace("CSCGEMCMotherboardME21") << "1 successful ALCT-GEM match in ME21: "
                     << " CSCDetId " << cscChamber->id()
                     << ", bx_alct = " << bx_alct
                     << "; match window: [" << bx_clct_start << "; " << bx_clct_stop << "]" << std::endl;
         else
           LogTrace("CSCGEMCMotherboardME21") << "Unsuccessful ALCT-CLCT match in ME21: "
                     << "CSCDetId " << cscChamber->id()
                     << ", 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);
         const int bx_clct_stop(bx_alct + match_trig_window_size/2);
 
         if (debug_matching){
           LogTrace("CSCGEMCMotherboardME21") << "========================================================================" << std::endl;
           LogTrace("CSCGEMCMotherboardME21") <<"GEM-CLCT matching in ME2/1 chamber: "<< cscChamber->id()<< "in bx:"<<bx_alct<<std::endl;
           LogTrace("CSCGEMCMotherboardME21") << "------------------------------------------------------------------------" << std::endl;
         }
         // GEM-to-CLCT
         int nSuccessFulMatches = 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 (clct->bestCLCT[bx_clct].isValid())
               {
                 const int quality(clct->bestCLCT[bx_clct].getQuality());
                 // only use high-Q stubs for the time being
                 if (quality < 4) continue;
 
          ++nSuccessFulMatches;
 
          int mbx = std::abs(clct->bestCLCT[bx_clct].getBX()-bx_alct);
          int bx_gem = (coPads[0].second).bx(1)+CSCConstants::LCT_CENTRAL_BX;
          CSCGEMMotherboard::correlateLCTsGEM(clct->bestCLCT[bx_clct], clct->secondCLCT[bx_clct], coPads,
                          allLCTs(bx_gem,mbx,0), allLCTs(bx_gem,mbx,1), CSCPart::ME21);
          if (debug_matching) {
            //       if (infoV > 1) LogTrace("CSCGEMMotherboardME21")
            LogTrace("CSCGEMCMotherboardME21") << "Successful GEM-CLCT match in ME21: bx_alct = " << bx_alct <<std::endl;
            //<< "; match window: [" << bx_clct_start << "; " << bx_clct_stop
            //<< "]; bx_clct = " << bx_clct << std::endl;
            LogTrace("CSCGEMCMotherboardME21") << "+++ Best CLCT Details: ";
            clct->bestCLCT[bx_clct].print();
            LogTrace("CSCGEMCMotherboardME21") << "+++ Second CLCT Details: ";
            clct->secondCLCT[bx_clct].print();
          }
          if (allLCTs(bx_gem,mbx,0).isValid()) {
            used_clct_mask[bx_gem] += 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++)
       {
         int cbx = bx + mbx - match_trig_window_size/2;
         if (allLCTs(bx,mbx,i).isValid())
           {
         ++n;
         if (infoV > 0) LogDebug("CSCGEMMotherboardME21")
                  << "LCT"<<i+1<<" "<<bx<<"/"<<cbx<<": "<<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++)
           {
         int cbx = bx + mbx - match_trig_window_size/2;
         if (allLCTs(bx,mbx,i).isValid())
           {
             n++;
             if (infoV > 0) LogDebug("CSCGEMMotherboardME21")
                      << "LCT"<<i+1<<" "<<bx<<"/"<<cbx<<": "<<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" << 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

LCTContainer CSCGEMMotherboardME21::allLCTs

private

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

Definition at line 64 of file CSCGEMMotherboardME21.h.

Referenced by clear(), readoutLCTs(), and run().

bool CSCGEMMotherboardME21::buildLCTfromALCTandGEM_

private

Definition at line 74 of file CSCGEMMotherboardME21.h.

Referenced by run().

bool CSCGEMMotherboardME21::buildLCTfromCLCTandGEM_

private

Definition at line 75 of file CSCGEMMotherboardME21.h.

Referenced by run().

std::vector<CSCCLCTDigi> CSCGEMMotherboardME21::clctV

private

Definition at line 67 of file CSCGEMMotherboardME21.h.

Referenced by run().

bool CSCGEMMotherboardME21::dropLowQualityALCTsNoGEMs_

private

Definition at line 71 of file CSCGEMMotherboardME21.h.

bool CSCGEMMotherboardME21::dropLowQualityCLCTsNoGEMs_

private

Definition at line 70 of file CSCGEMMotherboardME21.h.

Referenced by run().

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

Member Function Documentation

Member Data Documentation