#include <CSCGEMMotherboardME11.h>

Inheritance diagram for CSCGEMMotherboardME11:

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

	CSCGEMMotherboardME11 ()

std::vector< CSCCorrelatedLCTDigi >	readoutLCTs1a () const

std::vector< CSCCorrelatedLCTDigi >	readoutLCTs1b () const

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

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

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

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

const CSCGEMMotherboardLUTME11 *	getLUT () const override

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

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

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

Private Attributes
bool	buildLCTfromALCTandGEM_ME1a_

bool	buildLCTfromALCTandGEM_ME1b_

bool	buildLCTfromCLCTandGEM_ME1a_

bool	buildLCTfromCLCTandGEM_ME1b_

std::vector< CSCCLCTDigi >	clctV

std::unique_ptr< CSCMotherboardLUTME11 >	cscTmbLUT_

bool	dropLowQualityALCTsNoGEMs_ME1a_

bool	dropLowQualityALCTsNoGEMs_ME1b_

bool	dropLowQualityCLCTsNoGEMs_ME1a_

bool	dropLowQualityCLCTsNoGEMs_ME1b_

bool	promoteCLCTGEMquality_ME1a_

bool	promoteCLCTGEMquality_ME1b_

std::unique_ptr< CSCGEMMotherboardLUTME11 >	tmbLUT_

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

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

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

Public Attributes inherited from CSCGEMMotherboard
std::unique_ptr< GEMCoPadProcessor >	coPadProcessor

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

std::unique_ptr< CSCCathodeLCTProcessor >	clctProc

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

Protected Member Functions inherited from CSCGEMMotherboard
template<class T >
T	bestMatchingPad (const CSCALCTDigi &, const 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	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

const CSCChamber *	cscChamber

bool	debug_luts

bool	debug_matching

bool	disableME1a

bool	gangedME1a

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

Protected Attributes inherited from CSCMotherboard
unsigned int	alct_trig_enable

unsigned int	alctClctOffset

edm::ParameterSet	alctParams_

std::vector< CSCALCTDigi >	alctV

bool	clct_to_alct

unsigned int	clct_trig_enable

edm::ParameterSet	clctParams_

std::vector< CSCCLCTDigi >	clctV

edm::ParameterSet	commonParams_

const CSCGeometry *	csc_g

bool	drop_used_alcts

bool	drop_used_clcts

int	early_tbins

CSCCorrelatedLCTDigi	firstLCT [CSCConstants::MAX_LCT_TBINS]

int	infoV

bool	isSLHC_

unsigned int	match_trig_enable

unsigned int	match_trig_window_size

unsigned int	mpc_block_me1a

bool	readout_earliest_2

bool	runME11ILT_

bool	runME21ILT_

bool	runME3141ILT_

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

edm::ParameterSet	tmbParams_

Static Protected Attributes inherited from CSCMotherboard
static const unsigned int	def_alct_trig_enable = 0

static const unsigned int	def_clct_trig_enable = 0

static const unsigned int	def_match_trig_enable = 1

static const unsigned int	def_match_trig_window_size = 7

static const unsigned int	def_mpc_block_me1a = 1

static const unsigned int	def_tmb_l1a_window_size = 7

Detailed Description

Extended CSCMotherboard for ME11 TMB upgrade

Author: Sven Dildick March 2014

Based on CSCMotherboard code

Definition at line 16 of file CSCGEMMotherboardME11.h.

Constructor & Destructor Documentation

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

Normal constructor.

Definition at line 3 of file CSCGEMMotherboardME11.cc.

References cscTmbLUT_, CSCMotherboard::isSLHC_, and tmbLUT_.

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

CSCGEMMotherboardME11::CSCGEMMotherboardME11 ( )

Constructor for use during testing.

Definition at line 29 of file CSCGEMMotherboardME11.cc.

References CSCMotherboard::isSLHC_.

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

CSCGEMMotherboardME11::~CSCGEMMotherboardME11 ( )

override

Default destructor.

Definition at line 38 of file CSCGEMMotherboardME11.cc.

39 {

40 }

Member Function Documentation

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

private

Definition at line 437 of file CSCGEMMotherboardME11.cc.

References CSCCorrelatedLCTDigi::ALCTCLCT, CSCTriggerNumbering::chamberFromTriggerLabels(), CSCCLCTDigi::clear(), CSCALCTDigi::clear(), CSCMotherboard::constructLCTs(), CSCGEMMotherboard::constructLCTsGEM(), doesALCTCrossCLCT(), GEMCoPadDigi::isValid(), CSCCLCTDigi::isValid(), CSCALCTDigi::isValid(), LogTrace, lumiPlot::lut, CSCMotherboard::theEndcap, CSCMotherboard::theSector, CSCMotherboard::theStation, CSCMotherboard::theSubsector, and CSCMotherboard::theTrigChamber.

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();
 
   const int ok11 = doesALCTCrossCLCT( bestALCT, bestCLCT);
   const int ok12 = doesALCTCrossCLCT( bestALCT, secondCLCT);
   const int ok21 = doesALCTCrossCLCT( secondALCT, bestCLCT);
   const int ok22 = doesALCTCrossCLCT( secondALCT, secondCLCT);
   const int code = (ok11<<3) | (ok12<<2) | (ok21<<1) | (ok22);
 
   int dbg=0;
   int chamb= CSCTriggerNumbering::chamberFromTriggerLabels(theSector,theSubsector, theStation, theTrigChamber);
   CSCDetId did(theEndcap, theStation, 1, chamb, 0);
   if (dbg) LogTrace("CSCGEMMotherboardME11")<<"debug correlateLCTs in ME11"<<did<< "\n"
        <<"ALCT1: "<<bestALCT<<"\n"
        <<"ALCT2: "<<secondALCT<<"\n"
        <<"CLCT1: "<<bestCLCT<<"\n"
        <<"CLCT2: "<<secondCLCT<<"\n"
        <<"ok 11 12 21 22 code = "<<ok11<<" "<<ok12<<" "<<ok21<<" "<<ok22<<" "<<code<<std::endl;
 
   if ( code==0 ) return;
 
   // LUT defines correspondence between possible ok## combinations
   // and resulting lct1 and lct2
   int lut[16][2] = {
           //ok: 11 12 21 22
     {0 ,0 }, // 0  0  0  0
     {22,0 }, // 0  0  0  1
     {21,0 }, // 0  0  1  0
     {21,22}, // 0  0  1  1
     {12,0 }, // 0  1  0  0
     {12,22}, // 0  1  0  1
     {12,21}, // 0  1  1  0
     {12,21}, // 0  1  1  1
     {11,0 }, // 1  0  0  0
     {11,22}, // 1  0  0  1
     {11,21}, // 1  0  1  0
     {11,22}, // 1  0  1  1
     {11,12}, // 1  1  0  0
     {11,22}, // 1  1  0  1
     {11,12}, // 1  1  1  0
     {11,22}, // 1  1  1  1
   };
 
   if (dbg) LogTrace("CSCGEMMotherboardME11")<<"lut 0 1 = "<<lut[code][0]<<" "<<lut[code][1]<<std::endl;
 
   // check matching copads
   const GEMCoPadDigi& bb_copad = bestMatchingPad<GEMCoPadDigi>(bestALCT,   bestCLCT,   copads);
   const GEMCoPadDigi& bs_copad = bestMatchingPad<GEMCoPadDigi>(bestALCT,   secondCLCT, copads);
   const GEMCoPadDigi& sb_copad = bestMatchingPad<GEMCoPadDigi>(secondALCT, bestCLCT,   copads);
   const GEMCoPadDigi& ss_copad = bestMatchingPad<GEMCoPadDigi>(secondALCT, secondCLCT, copads);
 
   // check matching pads
   const GEMPadDigi& bb_pad = bestMatchingPad<GEMPadDigi>(bestALCT,   bestCLCT,   pads);
   const GEMPadDigi& bs_pad = bestMatchingPad<GEMPadDigi>(bestALCT,   secondCLCT, pads);
   const GEMPadDigi& sb_pad = bestMatchingPad<GEMPadDigi>(secondALCT, bestCLCT,   pads);
   const GEMPadDigi& ss_pad = bestMatchingPad<GEMPadDigi>(secondALCT, secondCLCT, pads);
 
   // evaluate possible combinations
   const bool ok_bb_copad = ok11==1 and ok_bb and bb_copad.isValid();
   const bool ok_bs_copad = ok12==1 and ok_bs and bs_copad.isValid();
   const bool ok_sb_copad = ok21==1 and ok_sb and sb_copad.isValid();
   const bool ok_ss_copad = ok22==1 and ok_ss and ss_copad.isValid();
 
   const bool ok_bb_pad = (not ok_bb_copad) and ok11==1 and ok_bb and bb_pad.isValid();
   const bool ok_bs_pad = (not ok_bs_copad) and ok12==1 and ok_bs and bs_pad.isValid();
   const bool ok_sb_pad = (not ok_sb_copad) and ok21==1 and ok_sb and sb_pad.isValid();
   const bool ok_ss_pad = (not ok_ss_copad) and ok22==1 and ok_ss and ss_pad.isValid();
 
   switch (lut[code][0]) {
   case 11:
     if (ok_bb_copad)    lct1 = CSCGEMMotherboard::constructLCTsGEM(bestALCT, bestCLCT, bb_copad, 1);
     else if (ok_bb_pad) lct1 = CSCGEMMotherboard::constructLCTsGEM(bestALCT, bestCLCT, bb_pad, 1);
     else                lct1 = constructLCTs(bestALCT, bestCLCT, CSCCorrelatedLCTDigi::ALCTCLCT, 1);
     break;
   case 12:
     if (ok_bs_copad)    lct1 = CSCGEMMotherboard::constructLCTsGEM(bestALCT, secondCLCT, bs_copad, 1);
     else if (ok_bs_pad) lct1 = CSCGEMMotherboard::constructLCTsGEM(bestALCT, secondCLCT, bs_pad, 1);
     else                lct1 = constructLCTs(bestALCT, secondCLCT, CSCCorrelatedLCTDigi::ALCTCLCT, 1);
     break;
   case 21:
     if (ok_sb_copad)    lct1 = CSCGEMMotherboard::constructLCTsGEM(secondALCT, bestCLCT, sb_copad, 1);
     else if (ok_sb_pad) lct1 = CSCGEMMotherboard::constructLCTsGEM(secondALCT, bestCLCT, sb_pad, 1);
     else                lct1 = constructLCTs(secondALCT, bestCLCT, CSCCorrelatedLCTDigi::ALCTCLCT, 1);
     break;
   case 22:
     if (ok_ss_copad)    lct1 = CSCGEMMotherboard::constructLCTsGEM(secondALCT, secondCLCT, ss_copad, 1);
     else if (ok_ss_pad) lct1 = CSCGEMMotherboard::constructLCTsGEM(secondALCT, secondCLCT, ss_pad, 1);
     else                lct1 = constructLCTs(secondALCT, secondCLCT, CSCCorrelatedLCTDigi::ALCTCLCT, 1);
     break;
   default:
     return;
   }
 
   if (dbg) LogTrace("CSCGEMMotherboardME11")<<"lct1: "<<lct1<<std::endl;
 
   switch (lut[code][1]){
   case 12:
     if (ok_bs_copad)    lct2 = CSCGEMMotherboard::constructLCTsGEM(bestALCT, secondCLCT, bs_copad, 2);
     else if (ok_bs_pad) lct2 = CSCGEMMotherboard::constructLCTsGEM(bestALCT, secondCLCT, bs_pad, 2);
     else                lct2 = constructLCTs(bestALCT, secondCLCT, CSCCorrelatedLCTDigi::ALCTCLCT, 2);
     break;
   case 21:
     if (ok_sb_copad)    lct2 = CSCGEMMotherboard::constructLCTsGEM(secondALCT, bestCLCT, sb_copad, 2);
     else if (ok_sb_pad) lct2 = CSCGEMMotherboard::constructLCTsGEM(secondALCT, bestCLCT, sb_pad, 2);
     else                lct2 = constructLCTs(secondALCT, bestCLCT, CSCCorrelatedLCTDigi::ALCTCLCT, 2);
     break;
   case 22:
     if (ok_bb_copad)    lct2 = CSCGEMMotherboard::constructLCTsGEM(secondALCT, secondCLCT, bb_copad, 2);
     else if (ok_bb_pad) lct2 = CSCGEMMotherboard::constructLCTsGEM(secondALCT, secondCLCT, bb_pad, 2);
     else                lct2 = constructLCTs(secondALCT, secondCLCT, CSCCorrelatedLCTDigi::ALCTCLCT, 2);
     break;
   default:
     return;
   }
 
   if (dbg) LogTrace("CSCGEMMotherboardME11")<<"lct2: "<<lct2<<std::endl;
 
   if (dbg) LogTrace("CSCGEMMotherboardME11")<<"out of correlateLCTs"<<std::endl;
   return;
 }

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

private

Definition at line 431 of file CSCGEMMotherboardME11.cc.

References cscTmbLUT_, CSCUpgradeMotherboard::gangedME1a, and CSCMotherboard::theEndcap.

Referenced by correlateLCTsGEM().

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

const CSCGEMMotherboardLUTME11* CSCGEMMotherboardME11::getLUT ( ) const

inlineoverrideprivatevirtual

Implements CSCGEMMotherboard.

Definition at line 44 of file CSCGEMMotherboardME11.h.

References tmbLUT_.

44 {return tmbLUT_.get();}

CSCGEMMotherboardME11::tmbLUT_

std::unique_ptr< CSCGEMMotherboardLUTME11 > tmbLUT_

Definition: CSCGEMMotherboardME11.h:45

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

private

Definition at line 344 of file CSCGEMMotherboardME11.cc.

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

 {
   std::vector<CSCCorrelatedLCTDigi> tmpV;
 
   // The start time of the L1A*LCT coincidence window should be related
   // to the fifo_pretrig parameter, but I am not completely sure how.
   // Just choose it such that the window is centered at bx=7.  This may
   // need further tweaking if the value of tmb_l1a_window_size changes.
   //static int early_tbins = 4;
   // The number of LCT bins in the read-out is given by the
   // tmb_l1a_window_size parameter, forced to be odd
   const int lct_bins   =
     (tmb_l1a_window_size % 2 == 0) ? tmb_l1a_window_size + 1 : tmb_l1a_window_size;
   const int late_tbins = early_tbins + lct_bins;
 
   // Start from the vector of all found correlated LCTs and select
   // those within the LCT*L1A coincidence window.
   int bx_readout = -1;
   std::vector<CSCCorrelatedLCTDigi> all_lcts;
   switch(tmb_cross_bx_algo){
   case 0:  case 1:
     allLCTs.getMatched(all_lcts);
     break;
   case 2: sortLCTs(all_lcts, CSCUpgradeMotherboard::sortLCTsByQuality);
     break;
   case 3: sortLCTs(all_lcts, CSCUpgradeMotherboard::sortLCTsByGEMDphi);
     break;
   default: LogTrace("CSCGEMCMotherboardME11")<<"tmb_cross_bx_algo error" <<std::endl;
     break;
   }
 
   for (const auto& lct: all_lcts)
   {
     if (!lct.isValid()) continue;
 
     int bx = lct.getBX();
     // Skip LCTs found too early relative to L1Accept.
     if (bx <= early_tbins) continue;
 
     // Skip LCTs found too late relative to L1Accept.
     if (bx > late_tbins) continue;
 
     if ((me1ab == CSCPart::ME1B and lct.getStrip() >  CSCConstants::MAX_HALF_STRIP_ME1B  ) or (me1ab == CSCPart::ME1A and lct.getStrip() <=  CSCConstants::MAX_HALF_STRIP_ME1B))
     continue;
 
     // If (readout_earliest_2) take only LCTs in the earliest bx in the read-out window:
     // in digi->raw step, LCTs have to be packed into the TMB header, and
     // currently there is room just for two.
     if (readout_earliest_2 and (bx_readout == -1 or bx == bx_readout) )
     {
       tmpV.push_back(lct);
       if (bx_readout == -1) bx_readout = bx;
     }
     else tmpV.push_back(lct);
   }
   return tmpV;
 }

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

Definition at line 329 of file CSCGEMMotherboardME11.cc.

References ME1A, and CSCMotherboard::readoutLCTs().

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

 {
   return readoutLCTs(ME1A);
 }

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

Definition at line 335 of file CSCGEMMotherboardME11.cc.

References ME1B, and CSCMotherboard::readoutLCTs().

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

 {
   return readoutLCTs(ME1B);
 }

void CSCGEMMotherboardME11::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 50 of file CSCGEMMotherboardME11.cc.

References CSCMotherboard::alctClctOffset, CSCMotherboard::alctProc, CSCMotherboard::alctV, CSCUpgradeMotherboard::allLCTs, b, buildLCTfromALCTandGEM_ME1b_, buildLCTfromCLCTandGEM_ME1b_, CSCMotherboard::clctProc, clctV, CSCGEMMotherboard::clear(), CSCGEMMotherboard::coPadProcessor, CSCGEMMotherboard::coPads_, correlateLCTsGEM(), CSCGEMMotherboard::correlateLCTsGEM(), CSCMotherboard::csc_g, CSCUpgradeMotherboard::cscChamber, CSCUpgradeMotherboard::debug_matching, CSCUpgradeMotherboard::debugLUTs(), CSCMotherboard::drop_used_clcts, dropLowQualityCLCTsNoGEMs_ME1b_, CSCGEMMotherboard::gem_g, CSCGEMMotherboard::gemCoPadV, CSCGEMMotherboard::gemGeometryAvailable, CSCGEMMotherboard::gemId, CSCChamber::id(), CSCMotherboard::infoV, CSCMotherboard::isSLHC_, LogTrace, CSCUpgradeMotherboard::match_earliest_clct_only, CSCMotherboard::match_trig_window_size, CSCConstants::MAX_ALCT_TBINS, CSCConstants::MAX_CLCT_TBINS, CSCGEMMotherboard::maxDeltaBXCoPad_, ME11, or, AlCaHLTBitMon_ParallelJobs::p, CSCGEMMotherboard::pads_, CSCGEMMotherboard::printGEMTriggerCoPads(), CSCGEMMotherboard::printGEMTriggerPads(), jets_cff::quality, readoutLCTs1a(), readoutLCTs1b(), 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("CSCGEMMotherboardME11|SetupInfo")
               << "+++ run() called for GEM-CSC integrated trigger! +++ \n";
     gemGeometryAvailable = true;
   }
 
   // check for GEM geometry
   if (not gemGeometryAvailable){
     if (infoV >= 0) edm::LogError("CSCGEMMotherboardME11|SetupError")
               << "+++ run() called for GEM-CSC integrated trigger without valid GEM geometry! +++ \n";
     return;
   }
   gemCoPadV = coPadProcessor->run(gemPads); // run copad processor in GE1/1
 
   if (!( alctProc and clctProc and isSLHC_))
   {
     if (infoV >= 0) edm::LogError("CSCGEMMotherboardME11|SetupError")
       << "+++ run() called for non-existing ALCT/CLCT processor! +++ \n";
     return;
   }
 
   alctProc->setCSCGeometry(csc_g);
   clctProc->setCSCGeometry(csc_g);
 
   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("CSCGEMCMotherboardME11") <<"ALL ALCTs from ME11 "<< std::endl;
   for (const auto& alct : alctV)
     if (alct.isValid())
       LogTrace("CSCGEMCMotherboardME11") << alct << std::endl;
 
   LogTrace("CSCGEMCMotherboardME11") <<"ALL CLCTs from ME11 "<< std::endl;
   for (const auto& clct : clctV)
     if (clct.isValid())
       LogTrace("CSCGEMCMotherboardME11") << clct << std::endl;
 
   int used_clct_mask[20];
   for (int b=0;b<20;b++)
     used_clct_mask[b] = 0;
 
   retrieveGEMPads(gemPads, gemId);
   retrieveGEMCoPads();
 
   const bool hasPads(!pads_.empty());
   const bool hasCoPads(hasPads and !coPads_.empty());
 
   // 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("CSCGEMCMotherboardME11") << "========================================================================\n"
                                            << "ALCT-CLCT matching in ME1/1 chamber: " << cscChamber->id() << "\n"
                                            << "------------------------------------------------------------------------\n"
                                            << "+++ Best ALCT Details: " << alctProc->bestALCT[bx_alct]  << "\n"
                                            << "+++ Second ALCT Details: " << alctProc->secondALCT[bx_alct] << std::endl;
 
         printGEMTriggerPads(bx_clct_start, bx_clct_stop, CSCPart::ME11);
         printGEMTriggerCoPads(bx_clct_start, bx_clct_stop, CSCPart::ME11);
 
         LogTrace("CSCGEMCMotherboardME11") << "------------------------------------------------------------------------ \n"
                                            << "Attempt ALCT-CLCT matching in ME1/b in bx range: [" << bx_clct_start << "," << bx_clct_stop << "]" << std::endl;
       }
 
       // ALCT-to-CLCT matching in ME1b
       int nSuccesFulMatches = 0;
       for (int bx_clct = bx_clct_start; bx_clct <= bx_clct_stop; bx_clct++)
       {
         if (bx_clct < 0 or bx_clct >= CSCConstants::MAX_CLCT_TBINS) continue;
         if (drop_used_clcts and used_clct_mask[bx_clct]) continue;
         if (clctProc->bestCLCT[bx_clct].isValid())
         {
           const int quality(clctProc->bestCLCT[bx_clct].getQuality());
           if (debug_matching) LogTrace("CSCGEMCMotherboardME11") << "++Valid ME1b 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);
 
     // Low quality LCTs have at most 3 layers. Check if there is a matching GEM pad to keep the CLCT
     if (dropLowQualityCLCTsNoGEMs_ME1b_ and quality < 4 and hasPads){
       int nFound(mPads.size());
       // these halfstrips (1,2,3,4) and (125,126,127,128) do not have matching GEM pads because GEM chambers are slightly wider than CSCs
       const bool clctInEdge(clctProc->bestCLCT[bx_clct].getKeyStrip() < 5 or clctProc->bestCLCT[bx_clct].getKeyStrip() > 124);
             if (clctInEdge){
               if (debug_matching) LogTrace("CSCGEMCMotherboardME11") << "\tInfo: low quality CLCT in CSC chamber edge, don't care about GEM pads" << std::endl;
             }
             else {
               if (nFound != 0){
                 if (debug_matching) LogTrace("CSCGEMCMotherboardME11") << "\tInfo: low quality CLCT with " << nFound << " matching GEM trigger pads" << std::endl;
               }
               else {
                 if (debug_matching) LogTrace("CSCGEMCMotherboardME11") << "\tWarning: low quality CLCT without matching GEM trigger pad" << std::endl;
                 continue;
               }
             }
           }
 
           ++nSuccesFulMatches;
 
           //        if (infoV > 1) LogTrace("CSCMotherboard")
           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 ) {
             LogTrace("CSCGEMCMotherboardME11") << "Successful ALCT-CLCT match in ME1b: bx_alct = " << bx_alct
                                                << "; match window: [" << bx_clct_start << "; " << bx_clct_stop
                                                << "]; bx_clct = " << bx_clct << "\n"
                                                << "+++ Best CLCT Details: " << clctProc->bestCLCT[bx_clct] << "\n"
                                                << "+++ Second CLCT Details: " << clctProc->secondCLCT[bx_clct] << std::endl;
             if (allLCTs(bx_alct,mbx,0).isValid())
               LogTrace("CSCGEMCMotherboardME11") << "LCT #1 "<< allLCTs(bx_alct,mbx,0) << std::endl;
             else
               LogTrace("CSCGEMCMotherboardME11") << "No valid LCT is built from ALCT-CLCT matching in ME1b"  << std::endl;
             if (allLCTs(bx_alct,mbx,1).isValid())
               LogTrace("CSCGEMCMotherboardME11") << "LCT #2 "<< allLCTs(bx_alct,mbx,1) << std::endl;
           }
 
           if (allLCTs(bx_alct,mbx,0).isValid()) {
             used_clct_mask[bx_clct] += 1;
             if (match_earliest_clct_only) break;
           }
         }
       }
 
       // ALCT-to-GEM matching in ME1b
       int nSuccesFulGEMMatches = 0;
       if (nSuccesFulMatches==0 and buildLCTfromALCTandGEM_ME1b_){
         if (debug_matching) LogTrace("CSCGEMCMotherboardME11") << "++No valid ALCT-CLCT matches in ME1b" << std::endl;
         for (int bx_gem = bx_copad_start; bx_gem <= bx_copad_stop; bx_gem++) {
           if (not hasCoPads) {
             continue;
           }
 
           // find the best matching copad
       matches<GEMCoPadDigi> copads;
       matchingPads<CSCALCTDigi, GEMCoPadDigi>(alctProc->bestALCT[bx_alct], alctProc->secondALCT[bx_alct], copads);
 
           if (debug_matching) LogTrace("CSCGEMCMotherboardME11") << "\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 (debug_matching) {
             LogTrace("CSCGEMCMotherboardME11") << "Successful ALCT-GEM CoPad match in ME1b: bx_alct = " << bx_alct << "\n\n"
                                                << "------------------------------------------------------------------------" << std::endl << std::endl;
             if (allLCTs(bx_alct,0,0).isValid())
               LogTrace("CSCGEMCMotherboardME11") << "LCT #1 "<< allLCTs(bx_alct,0,0) << std::endl;
             else
               LogTrace("CSCGEMCMotherboardME11") << "No valid LCT is built from ALCT-GEM matching in ME1b"  << std::endl;
             if (allLCTs(bx_alct,0,1).isValid())
               LogTrace("CSCGEMCMotherboardME11") << "LCT #2 "<< allLCTs(bx_alct,0,1) << std::endl;
           }
 
           if (allLCTs(bx_alct,0,0).isValid()) {
             ++nSuccesFulGEMMatches;
             if (match_earliest_clct_only) break;
           }
         }
       }
 
       if (debug_matching) {
         LogTrace("CSCGEMCMotherboardME11") << "========================================================================" << std::endl
                                            << "Summary: " << std::endl;
         if (nSuccesFulMatches>1)
           LogTrace("CSCGEMCMotherboardME11") << "Too many successful ALCT-CLCT matches in ME1b: " << nSuccesFulMatches
                          << ", CSCDetId " << cscChamber->id()
                          << ", bx_alct = " << bx_alct
                          << "; match window: [" << bx_clct_start << "; " << bx_clct_stop << "]" << std::endl;
         else if (nSuccesFulMatches==1)
           LogTrace("CSCGEMCMotherboardME11") << "1 successful ALCT-CLCT match in ME1b: "
                          << " CSCDetId " << cscChamber->id()
                          << ", bx_alct = " << bx_alct
                          << "; match window: [" << bx_clct_start << "; " << bx_clct_stop << "]" << std::endl;
         else if (nSuccesFulGEMMatches==1)
           LogTrace("CSCGEMCMotherboardME11") << "1 successful ALCT-GEM match in ME1b: "
                          << " CSCDetId " << cscChamber->id()
                          << ", bx_alct = " << bx_alct
                          << "; match window: [" << bx_clct_start << "; " << bx_clct_stop << "]" << std::endl;
         else
           LogTrace("CSCGEMCMotherboardME11") << "Unsuccessful ALCT-CLCT match in ME1b: "
                          << "CSCDetId " << cscChamber->id()
                          << ", bx_alct = " << bx_alct
                          << "; match window: [" << bx_clct_start << "; " << bx_clct_stop << "]" << std::endl;
 
         LogTrace("CSCGEMCMotherboardME11") << "------------------------------------------------------------------------" << std::endl
                                            << "Attempt ALCT-CLCT matching in ME1/a in bx range: [" << bx_clct_start << "," << bx_clct_stop << "]" << std::endl;
       }
     } // end of ALCT valid block
     else {
       auto coPads(coPads_[bx_alct]);
       if (!coPads.empty()) {
         // keep it simple for the time being, only consider the first copad
         const int bx_clct_start(bx_alct - match_trig_window_size/2);
         const int bx_clct_stop(bx_alct + match_trig_window_size/2);
 
         // matching in ME1b
         if (buildLCTfromCLCTandGEM_ME1b_) {
           for (int bx_clct = bx_clct_start; bx_clct <= bx_clct_stop; bx_clct++) {
             if (bx_clct < 0 or bx_clct >= CSCConstants::MAX_CLCT_TBINS) continue;
             if (drop_used_clcts and used_clct_mask[bx_clct]) continue;
             if (clctProc->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;
               int mbx = bx_clct-bx_clct_start;
               CSCGEMMotherboard::correlateLCTsGEM(clctProc->bestCLCT[bx_clct], clctProc->secondCLCT[bx_clct], coPads,
                                                   allLCTs(bx_alct,mbx,0), allLCTs(bx_alct,mbx,1));
               if (debug_matching) {
                 //      if (infoV > 1) LogTrace("CSCMotherboard")
                 LogTrace("CSCGEMCMotherboardME11") << "Successful GEM-CLCT match in ME1b: bx_alct = " << bx_alct
                                                    << "; match window: [" << bx_clct_start << "; " << bx_clct_stop
                                                    << "]; bx_clct = " << bx_clct << "\n"
                                                    << "+++ Best CLCT Details: " << clctProc->bestCLCT[bx_clct] << "\n"
                                                    << "+++ Second CLCT Details: " << clctProc->secondCLCT[bx_clct] << std::endl;
               }
               if (allLCTs(bx_alct,mbx,0).isValid()) {
                 used_clct_mask[bx_clct] += 1;
                 if (match_earliest_clct_only) break;
               }
             }
           } //end of clct loop
         }
       } // if (!coPads.empty())
     }
   } // end of ALCT-centric matching
 
   if (debug_matching){
     LogTrace("CSCGEMCMotherboardME11") << "======================================================================== \n"
                                        << "Counting the LCTs in CSCGEMMotherboard ME11 \n"
                                        << "========================================================================" << std::endl;
   }
 
 
   unsigned int n1b=0, n1a=0;
   LogTrace("CSCGEMCMotherboardME11") << "======================================================================== \n"
                                      << "Counting the final LCTs in CSCGEMMotherboard ME11\n"
                                      << "======================================================================== \n"
                                      << "tmb_cross_bx_algo: " << tmb_cross_bx_algo << std::endl;
 
   for (const auto& p : readoutLCTs1b()) {
     n1b++;
     LogTrace("CSCGEMCMotherboardME11") << "1b LCT "<<n1b<<"  " << p <<std::endl;
   }
 
   for (const auto& p : readoutLCTs1a()){
     n1a++;
     LogTrace("CSCGEMCMotherboardME11") << "1a LCT "<<n1a<<"  " << p <<std::endl;
 
   }
 }

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

private

Methods to sort the LCTs

Definition at line 404 of file CSCGEMMotherboardME11.cc.

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

Referenced by readoutLCTs(), and sortLCTs().

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

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

private

Definition at line 415 of file CSCGEMMotherboardME11.cc.

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

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

Member Data Documentation

bool CSCGEMMotherboardME11::buildLCTfromALCTandGEM_ME1a_

private

Definition at line 81 of file CSCGEMMotherboardME11.h.

bool CSCGEMMotherboardME11::buildLCTfromALCTandGEM_ME1b_

private

Definition at line 82 of file CSCGEMMotherboardME11.h.

Referenced by run().

bool CSCGEMMotherboardME11::buildLCTfromCLCTandGEM_ME1a_

private

Definition at line 83 of file CSCGEMMotherboardME11.h.

bool CSCGEMMotherboardME11::buildLCTfromCLCTandGEM_ME1b_

private

Definition at line 84 of file CSCGEMMotherboardME11.h.

Referenced by run().

std::vector<CSCCLCTDigi> CSCGEMMotherboardME11::clctV

private

Definition at line 72 of file CSCGEMMotherboardME11.h.

Referenced by run().

std::unique_ptr<CSCMotherboardLUTME11> CSCGEMMotherboardME11::cscTmbLUT_

private

Definition at line 46 of file CSCGEMMotherboardME11.h.

Referenced by CSCGEMMotherboardME11(), and doesALCTCrossCLCT().

bool CSCGEMMotherboardME11::dropLowQualityALCTsNoGEMs_ME1a_

private

Definition at line 77 of file CSCGEMMotherboardME11.h.

bool CSCGEMMotherboardME11::dropLowQualityALCTsNoGEMs_ME1b_

private

Definition at line 78 of file CSCGEMMotherboardME11.h.

bool CSCGEMMotherboardME11::dropLowQualityCLCTsNoGEMs_ME1a_

private

Definition at line 75 of file CSCGEMMotherboardME11.h.

bool CSCGEMMotherboardME11::dropLowQualityCLCTsNoGEMs_ME1b_

private

Definition at line 76 of file CSCGEMMotherboardME11.h.

Referenced by run().

bool CSCGEMMotherboardME11::promoteCLCTGEMquality_ME1a_

private

Definition at line 87 of file CSCGEMMotherboardME11.h.

bool CSCGEMMotherboardME11::promoteCLCTGEMquality_ME1b_

private

Definition at line 88 of file CSCGEMMotherboardME11.h.

std::unique_ptr<CSCGEMMotherboardLUTME11> CSCGEMMotherboardME11::tmbLUT_

private

Definition at line 45 of file CSCGEMMotherboardME11.h.

Referenced by CSCGEMMotherboardME11(), and getLUT().

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation