#include <CSCGEMMotherboardME21.h>

Inheritance diagram for CSCGEMMotherboardME21:

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

	CSCGEMMotherboardME21 ()

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

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

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

template<class S >
S	bestMatchingPad (const CSCALCTDigi &alct1, const CSCCLCTDigi &clct1, const matches< S > &pads) 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
void	clear ()

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

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

	CSCMotherboard ()

std::vector< CSCCorrelatedLCTDigi >	getLCTs () const

void	setConfigParameters (const CSCDBL1TPParameters *conf)

	~CSCMotherboard () override=default

Public Member Functions inherited from CSCBaseboard
	CSCBaseboard (unsigned endcap, unsigned station, unsigned sector, unsigned subsector, unsigned chamber, const edm::ParameterSet &conf)

	CSCBaseboard ()

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

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

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

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

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

CSCCorrelatedLCTDigi	constructLCTsGEM (const CSCCLCTDigi &clct, const GEMCoPadDigi &gem, int i) 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

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

template<class T >
void	correlateLCTsGEM (const T &best, const T &second, const GEMCoPadDigi &, const GEMCoPadDigi &, CSCCorrelatedLCTDigi &lct1, CSCCorrelatedLCTDigi &lct2) 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 par) 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, matches< T > &) const

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

template<class S , class T >
void	matchingPads (const S &d1, const S &d2, 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

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

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 clctPattern) const

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

CSCALCTDigi	getBXShiftedALCT (const CSCALCTDigi &) const

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

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	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::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.

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

   : 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_ or !runME21ILT_) edm::LogError("CSCGEMMotherboardME21|ConfigError")
     << "+++ Upgrade CSCGEMMotherboardME21 constructed while isSLHC is not set! +++\n";
 
   // set LUTs
   tmbLUT_.reset(new CSCGEMMotherboardLUTME21());
 }

CSCGEMMotherboardME21::CSCGEMMotherboardME21 ( )

Test destructor.

Definition at line 21 of file CSCGEMMotherboardME21.cc.

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

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

CSCGEMMotherboardME21::~CSCGEMMotherboardME21 ( )

override

Default destructor.

Definition at line 29 of file CSCGEMMotherboardME21.cc.

30 {

31 }

Member Function Documentation

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 355 of file CSCGEMMotherboardME21.cc.

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

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);
     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);
   }
 }

const CSCGEMMotherboardLUTME21* CSCGEMMotherboardME21::getLUT ( ) const

inlineoverrideprivatevirtual

Implements CSCGEMMotherboard.

Definition at line 43 of file CSCGEMMotherboardME21.h.

References tmbLUT_.

43 {return tmbLUT_.get();}

CSCGEMMotherboardME21::tmbLUT_

std::unique_ptr< CSCGEMMotherboardLUTME21 > tmbLUT_

Definition: CSCGEMMotherboardME21.h:44

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 345 of file CSCGEMMotherboardME21.cc.

References CSCUpgradeMotherboard::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 35 of file CSCGEMMotherboardME21.cc.

References funct::abs(), CSCBaseboard::alctClctOffset_, CSCMotherboard::alctProc, CSCMotherboard::alctV, CSCUpgradeMotherboard::allLCTs, buildLCTfromALCTandGEM_, buildLCTfromCLCTandGEM_, EnergyCorrector::c, CSCMotherboard::clctProc, CSCMotherboard::clctV, CSCGEMMotherboard::clear(), CSCUpgradeMotherboard::LCTContainer::clear(), CSCGEMMotherboard::coPadProcessor, CSCGEMMotherboard::coPads_, correlateLCTsGEM(), CSCGEMMotherboard::correlateLCTsGEM(), CSCBaseboard::cscGeometry_, CSCBaseboard::cscId_, CSCUpgradeMotherboard::debug_matching, CSCUpgradeMotherboard::debugLUTs(), CSCMotherboard::drop_used_clcts, dropLowQualityCLCTsNoGEMs_, plotBeamSpotDB::first, CSCGEMMotherboard::gem_g, CSCGEMMotherboard::gemCoPadV, CSCGEMMotherboard::gemGeometryAvailable, CSCGEMMotherboard::gemId, mps_fire::i, CSCBaseboard::infoV, CSCConstants::LCT_CENTRAL_BX, LogDebug, LogTrace, CSCUpgradeMotherboard::match_earliest_clct_only, CSCMotherboard::match_trig_window_size, CSCConstants::MAX_ALCT_TBINS, CSCConstants::MAX_CLCT_TBINS, CSCConstants::MAX_LCT_TBINS, CSCConstants::MAX_LCTS_PER_CSC, CSCGEMMotherboard::maxDeltaBXCoPad_, ME21, gen::n, or, AlCaHLTBitMon_ParallelJobs::p, CSCGEMMotherboard::pads_, CSCUpgradeMotherboard::pref, CSCGEMMotherboard::printGEMTriggerCoPads(), CSCGEMMotherboard::printGEMTriggerPads(), jets_cff::quality, readoutLCTs(), CSCGEMMotherboard::retrieveGEMCoPads(), CSCGEMMotherboard::retrieveGEMPads(), CSCGEMMotherboard::setupGeometry(), and CSCUpgradeMotherboard::tmb_cross_bx_algo.

Referenced by CSCTriggerPrimitivesBuilder::build().

 {
   CSCGEMMotherboard::clear();
   setupGeometry();
   debugLUTs();
 
   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) {
     if (infoV >= 0) 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)) {
     if (infoV >= 0) 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 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 (alctProc->bestALCT[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("CSCGEMCMotherboardME21") << "========================================================================" << std::endl;
         LogTrace("CSCGEMCMotherboardME21") << "ALCT-CLCT matching in ME2/1 chamber: " << cscId_ << std::endl;
         LogTrace("CSCGEMCMotherboardME21") << "------------------------------------------------------------------------" << std::endl;
         LogTrace("CSCGEMCMotherboardME21") << "+++ Best ALCT Details: ";
         alctProc->bestALCT[bx_alct].print();
         LogTrace("CSCGEMCMotherboardME21") << "+++ Second ALCT Details: ";
         alctProc->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 (clctProc->bestCLCT[bx_clct].isValid()) {
           // clct quality
           const int quality(clctProc->bestCLCT[bx_clct].getQuality());
           // low quality ALCT
           const bool lowQualityALCT(alctProc->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: " << clctProc->bestCLCT[bx_clct] << std::endl;
 
           // pick the pad that corresponds
           matches<GEMPadDigi> mPads;
           matchingPads<GEMPadDigi>(clctProc->bestCLCT[bx_clct], clctProc->secondCLCT[bx_clct],
                                    alctProc->bestALCT[bx_alct], alctProc->secondALCT[bx_alct], mPads);
           matches<GEMCoPadDigi> mCoPads;
           matchingPads<GEMCoPadDigi>(clctProc->bestCLCT[bx_clct], clctProc->secondCLCT[bx_clct],
                                      alctProc->bestALCT[bx_alct], alctProc->secondALCT[bx_alct], mCoPads);
 
           if (dropLowQualityCLCTsNoGEMs_ and lowQuality and hasPads) {
             int nFound(mPads.size());
             const bool clctInEdge(clctProc->bestCLCT[bx_clct].getKeyStrip() < 5 or clctProc->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(alctProc->bestALCT[bx_alct], alctProc->secondALCT[bx_alct],
                            clctProc->bestCLCT[bx_clct], clctProc->secondCLCT[bx_clct],
                            mPads, mCoPads,
                            allLCTs(bx_alct,mbx,0), allLCTs(bx_alct,mbx,1));
           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: ";
             clctProc->bestCLCT[bx_clct].print();
             LogTrace("CSCGEMCMotherboardME21") << "+++ Second CLCT Details: ";
             clctProc->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>(alctProc->bestALCT[bx_alct], alctProc->secondALCT[bx_alct], 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(alctProc->bestALCT[bx_alct], alctProc->secondALCT[bx_alct],
                                               copads, allLCTs(bx_alct,0,0), allLCTs(bx_alct,0,1));
           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 " << cscId_
                                              << ", 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 " << cscId_
                                              << ", 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 " << cscId_
                                              << ", bx_alct = " << bx_alct
                                              << "; match window: [" << bx_clct_start << "; " << bx_clct_stop << "]" << std::endl;
         else
           LogTrace("CSCGEMCMotherboardME21") << "Unsuccessful 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);
         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: "<< cscId_<< "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 (clctProc->bestCLCT[bx_clct].isValid()) {
             const int quality(clctProc->bestCLCT[bx_clct].getQuality());
             // only use high-Q stubs for the time being
             if (quality < 4) continue;
 
             ++nSuccessFulMatches;
 
             int mbx = std::abs(clctProc->bestCLCT[bx_clct].getBX()-bx_alct);
             int bx_gem = (coPads[0].second).bx(1)+CSCConstants::LCT_CENTRAL_BX;
             CSCGEMMotherboard::correlateLCTsGEM(clctProc->bestCLCT[bx_clct], clctProc->secondCLCT[bx_clct], coPads,
                                                 allLCTs(bx_gem,mbx,0), allLCTs(bx_gem,mbx,1));
             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: ";
               clctProc->bestCLCT[bx_clct].print();
               LogTrace("CSCGEMCMotherboardME21") << "+++ Second CLCT Details: ";
               clctProc->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++) {
         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

bool CSCGEMMotherboardME21::buildLCTfromALCTandGEM_

private

Definition at line 62 of file CSCGEMMotherboardME21.h.

Referenced by run().

bool CSCGEMMotherboardME21::buildLCTfromCLCTandGEM_

private

Definition at line 63 of file CSCGEMMotherboardME21.h.

Referenced by run().

bool CSCGEMMotherboardME21::dropLowQualityALCTsNoGEMs_

private

Definition at line 59 of file CSCGEMMotherboardME21.h.

bool CSCGEMMotherboardME21::dropLowQualityCLCTsNoGEMs_

private

Definition at line 58 of file CSCGEMMotherboardME21.h.

Referenced by run().

std::unique_ptr<CSCGEMMotherboardLUTME21> CSCGEMMotherboardME21::tmbLUT_

private

Definition at line 44 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