#include <CSCGEMMotherboard.h>

Inheritance diagram for CSCGEMMotherboard:

Public Types
enum	Default_values { DEFAULT_MATCHING_VALUE = -99 }

Public Member Functions
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 ()

virtual void	run (const CSCWireDigiCollection wiredc, const CSCComparatorDigiCollection compdc, const GEMPadDigiCollection *gemPads)=0

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

Public Attributes
std::unique_ptr< GEMCoPadProcessor >	coPadProcessor

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

std::unique_ptr< CSCCathodeLCTProcessor >	clctProc

Protected Member Functions
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 (const T &best, const 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

virtual bool	doesWiregroupCrossStrip (int key_wg, int key_strip) const

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

int	getBX (const GEMPadDigi &p) const

int	getBX (const GEMCoPadDigi &p) const

virtual const CSCGEMMotherboardLUT *	getLUT () const =0

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

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

bool	isGEMDetId (unsigned int) const

bool	isPadInOverlap (int roll) const

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

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

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

CSCCLCTDigi	getBXShiftedCLCT (const CSCCLCTDigi &) const

Protected Attributes
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_

Private Member Functions
template<class T >
int	getLctTrigEnable () const

template<>
int	getLctTrigEnable () const

template<>
int	getLctTrigEnable () const

template<class T >
int	getMaxDeltaBX () const

template<>
int	getMaxDeltaBX () const

template<>
int	getMaxDeltaBX () const

template<class T >
const matchesBX< T > &	getPads () const

template<>
const matchesBX< GEMPadDigi > &	getPads () const

template<>
const matchesBX< GEMCoPadDigi > &	getPads () const

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

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

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 }

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

Base class for TMBs for the GEM-CSC integrated local trigger. Inherits from CSCUpgradeMotherboard. Provides common functionality to match ALCT/CLCT to GEM pads or copads. Matching functions are templated so they work both for GEMPadDigi and GEMCoPadDigi

Author: Sven Dildick (TAMU)

Definition at line 29 of file CSCGEMMotherboard.h.

Member Enumeration Documentation

enum CSCGEMMotherboard::Default_values

Enumerator
DEFAULT_MATCHING_VALUE

Definition at line 31 of file CSCGEMMotherboard.h.

31 { DEFAULT_MATCHING_VALUE = -99 };

CSCGEMMotherboard::DEFAULT_MATCHING_VALUE

Definition: CSCGEMMotherboard.h:31

Constructor & Destructor Documentation

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

Definition at line 3 of file CSCGEMMotherboard.cc.

References coPadProcessor, gemId, edm::ParameterSet::getParameter(), maxDeltaPadL1_, maxDeltaPadL2_, DetId::rawId(), CSCBaseboard::theChamber, CSCUpgradeMotherboard::theParity, CSCBaseboard::theRegion, CSCBaseboard::theStation, and CSCBaseboard::tmbParams_.

     : CSCUpgradeMotherboard(endcap, station, sector, subsector, chamber, conf),
       maxDeltaBXPad_(tmbParams_.getParameter<int>("maxDeltaBXPad")),
       maxDeltaBXCoPad_(tmbParams_.getParameter<int>("maxDeltaBXCoPad")),
       useOldLCTDataFormat_(tmbParams_.getParameter<bool>("useOldLCTDataFormat")),
       promoteALCTGEMpattern_(tmbParams_.getParameter<bool>("promoteALCTGEMpattern")),
       promoteALCTGEMquality_(tmbParams_.getParameter<bool>("promoteALCTGEMquality")),
       doLCTGhostBustingWithGEMs_(tmbParams_.getParameter<bool>("doLCTGhostBustingWithGEMs")) {
   // super chamber has layer=0!
   gemId = GEMDetId(theRegion, 1, theStation, 0, theChamber, 0).rawId();
 
   const edm::ParameterSet coPadParams(station == 1 ? conf.getParameter<edm::ParameterSet>("copadParamGE11")
                                                    : conf.getParameter<edm::ParameterSet>("copadParamGE21"));
   coPadProcessor.reset(new GEMCoPadProcessor(theRegion, theStation, theChamber, coPadParams));
 
   maxDeltaPadL1_ = (theParity ? tmbParams_.getParameter<int>("maxDeltaPadL1Even")
                               : tmbParams_.getParameter<int>("maxDeltaPadL1Odd"));
   maxDeltaPadL2_ = (theParity ? tmbParams_.getParameter<int>("maxDeltaPadL2Even")
                               : tmbParams_.getParameter<int>("maxDeltaPadL2Odd"));
 }

CSCGEMMotherboard::CSCGEMMotherboard ( )

Definition at line 29 of file CSCGEMMotherboard.cc.

29 : CSCUpgradeMotherboard() {}

CSCUpgradeMotherboard::CSCUpgradeMotherboard

CSCUpgradeMotherboard()

Definition: CSCUpgradeMotherboard.cc:41

CSCGEMMotherboard::~CSCGEMMotherboard ( )

override

Definition at line 31 of file CSCGEMMotherboard.cc.

31 {}

Member Function Documentation

template<class T >

T CSCGEMMotherboard::bestMatchingPad	(	const CSCALCTDigi &	,
		const matches< T > &
	)		const

protected

Referenced by doesWiregroupCrossStrip().

template<class T >

T CSCGEMMotherboard::bestMatchingPad	(	const CSCCLCTDigi &	,
		const matches< T > &
	)		const

protected

template<class T >

T CSCGEMMotherboard::bestMatchingPad	(	const CSCALCTDigi &	,
		const CSCCLCTDigi &	,
		const matches< T > &
	)		const

protected

template<class S >

S CSCGEMMotherboard::bestMatchingPad	(	const CSCALCTDigi &	alct1,
		const matches< S > &	pads
	)		const

Definition at line 380 of file CSCGEMMotherboard.h.

References getRoll(), getRolls(), isGEMDetId(), CSCALCTDigi::isValid(), AlCaHLTBitMon_ParallelJobs::p, and mps_fire::result.

                                                                                            {
   S result;
   // no matching pads for invalid stub
   if (not alct1.isValid()) {
     return result;
   }
   // return the first one with the same roll number
   for (const auto& p : pads) {
     // protection against corrupted DetIds
     if (not isGEMDetId(p.first))
       continue;
 
     // roll number of pad and ALCT must match
     if (getRolls(alct1).first <= getRoll(p) and getRoll(p) <= getRolls(alct1).second) {
       return p.second;
     }
   }
   return result;
 }

template<class S >

S CSCGEMMotherboard::bestMatchingPad	(	const CSCCLCTDigi &	clct,
		const matches< S > &	pads
	)		const

Definition at line 401 of file CSCGEMMotherboard.h.

References funct::abs(), CSCUpgradeMotherboard::getCSCPart(), CSCCLCTDigi::getKeyStrip(), getPad(), isGEMDetId(), CSCCLCTDigi::isValid(), AlCaHLTBitMon_ParallelJobs::p, and mps_fire::result.

                                                                                           {
   S result;
   // no matching pads for invalid stub
   if (not clct.isValid())
     return result;
 
   auto part(getCSCPart(clct.getKeyStrip()));
 
   // return the pad with the smallest bending angle
   float averagePadNumberCSC = getPad(clct, part);
   float minDeltaPad = 999;
   for (const auto& p : pads) {
     // protection against corrupted DetIds
     if (not isGEMDetId(p.first))
       continue;
 
     // best pad is closest to CLCT in number of halfstrips
     float averagePadNumberGEM = getPad(p.second);
     if (std::abs(averagePadNumberCSC - averagePadNumberGEM) < minDeltaPad) {
       minDeltaPad = std::abs(averagePadNumberCSC - averagePadNumberGEM);
       result = p.second;
     }
   }
   return result;
 }

template<class S >

S CSCGEMMotherboard::bestMatchingPad	(	const CSCALCTDigi &	alct1,
		const CSCCLCTDigi &	clct1,
		const matches< S > &	pads
	)		const

Definition at line 428 of file CSCGEMMotherboard.h.

References funct::abs(), dumpMFGeometry_cfg::delta, CSCUpgradeMotherboard::getCSCPart(), CSCCLCTDigi::getKeyStrip(), getPad(), getRoll(), getRolls(), isGEMDetId(), CSCALCTDigi::isValid(), CSCCLCTDigi::isValid(), or, AlCaHLTBitMon_ParallelJobs::p, mps_fire::result, and GEMDetId::station().

                                                                                                                      {
   S result;
   // no matching pads for invalid stub
   if (not alct1.isValid() or not clct1.isValid()) {
     return result;
   }
 
   auto part(getCSCPart(clct1.getKeyStrip()));
 
   // return the pad with the smallest bending angle
   float averagePadNumberCSC = getPad(clct1, part);
   float minDeltaPad = 999;
   for (const auto& p : pads) {
     // protection against corrupted DetIds
     if (not isGEMDetId(p.first))
       continue;
 
     float averagePadNumberGEM = getPad(p.second);
 
     int delta;
     if (GEMDetId(p.first).station() == 2)
       delta = 1;
 
     // add another safety to make sure that the deltaPad is not larger than max value!!!
     if (std::abs(averagePadNumberCSC - averagePadNumberGEM) < minDeltaPad and
         getRolls(alct1).first - delta <= getRoll(p) and getRoll(p) <= getRolls(alct1).second) {
       minDeltaPad = std::abs(averagePadNumberCSC - averagePadNumberGEM);
       result = p.second;
     }
   }
   return result;
 }

void CSCGEMMotherboard::clear ( void )

Definition at line 33 of file CSCGEMMotherboard.cc.

References CSCUpgradeMotherboard::clear(), coPads_, and pads_.

Referenced by CSCGEMMotherboardME11::run(), and CSCGEMMotherboardME21::run().

                               {
   CSCUpgradeMotherboard::clear();
   pads_.clear();
   coPads_.clear();
 }

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

protected

Definition at line 74 of file CSCGEMMotherboard.cc.

Referenced by constructLCTsGEM(), CSCGEMMotherboardME21::correlateLCTsGEM(), CSCGEMMotherboardME11::correlateLCTsGEM(), correlateLCTsGEM(), and doesWiregroupCrossStrip().

                                                                            {
   return constructLCTsGEM(alct, CSCCLCTDigi(), GEMPadDigi(), gem, trknmb);
 }

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

protected

Definition at line 80 of file CSCGEMMotherboard.cc.

References constructLCTsGEM().

                                                                            {
   return constructLCTsGEM(CSCALCTDigi(), clct, GEMPadDigi(), gem, trknmb);
 }

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

protected

Definition at line 86 of file CSCGEMMotherboard.cc.

References constructLCTsGEM().

                                                                            {
   return constructLCTsGEM(alct, clct, GEMPadDigi(), gem, trknmb);
 }

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

protected

Definition at line 93 of file CSCGEMMotherboard.cc.

References constructLCTsGEM().

                                                                            {
   return constructLCTsGEM(alct, clct, gem, GEMCoPadDigi(), trknmb);
 }

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

protected

Definition at line 100 of file CSCGEMMotherboard.cc.

                                                                            {
   int pattern = 0, quality = 0, bx = 0, keyStrip = 0, keyWG = 0, bend = 0, valid = 0;
 
   // make a new LCT
   CSCCorrelatedLCTDigi thisLCT;
   if (not alct.isValid() and not clct.isValid()) {
     LogTrace("CSCGEMCMotherboard") << "Warning!!! either ALCT or CLCT not valid, return invalid LCT \n";
     return thisLCT;
   }
 
   // Determine the case and assign properties depending on the LCT dataformat (old/new)
   if (alct.isValid() and clct.isValid() and gem1.isValid() and not gem2.isValid()) {
     pattern = encodePattern(clct.getPattern());
     quality = findQualityGEM(alct, clct, 1);
     bx = alct.getBX();
     keyStrip = clct.getKeyStrip();
     keyWG = alct.getKeyWG();
     bend = clct.getBend();
     thisLCT.setALCT(getBXShiftedALCT(alct));
     thisLCT.setCLCT(getBXShiftedCLCT(clct));
     thisLCT.setGEM1(gem1);
     thisLCT.setType(CSCCorrelatedLCTDigi::ALCTCLCTGEM);
     valid = doesWiregroupCrossStrip(keyWG, keyStrip) ? 1 : 0;
   } else if (alct.isValid() and clct.isValid() and not gem1.isValid() and gem2.isValid()) {
     pattern = encodePattern(clct.getPattern());
     quality = findQualityGEM(alct, clct, 2);
     bx = alct.getBX();
     keyStrip = clct.getKeyStrip();
     keyWG = alct.getKeyWG();
     bend = clct.getBend();
     thisLCT.setALCT(getBXShiftedALCT(alct));
     thisLCT.setCLCT(getBXShiftedCLCT(clct));
     thisLCT.setGEM1(gem2.first());
     thisLCT.setGEM2(gem2.second());
     thisLCT.setType(CSCCorrelatedLCTDigi::ALCTCLCT2GEM);
     valid = doesWiregroupCrossStrip(keyWG, keyStrip) ? 1 : 0;
   } else if (alct.isValid() and gem2.isValid() and not clct.isValid()) {
     //in ME11
     //ME1b: keyWG >15,
     //ME1a and ME1b overlap:  10<=keyWG<=15
     //ME1a: keyWG < 10
     //in overlap region, firstly try a match in ME1b
 
     auto p(getCSCPart(-1));  //use -1 as fake halfstrip, it returns ME11 if station==1 && (ring==1 or ring==4)
     if (p == CSCPart::ME11) {
       if (alct.getKeyWG() >= 10)
         p = CSCPart::ME1B;
       else
         p = CSCPart::ME1A;
     }
 
     const auto& mymap1 = getLUT()->get_gem_pad_to_csc_hs(theParity, p);
     // GEM pad number is counting from 1
     // keyStrip from mymap:  for ME1b 0-127 and for ME1a 0-95
     // keyStrip for CLCT: for ME1b 0-127 and for ME1a 128-223
     keyStrip = mymap1[gem2.pad(2) - 1];
     if (p == CSCPart::ME1A and keyStrip <= CSCConstants::MAX_HALF_STRIP_ME1B)
       keyStrip += CSCConstants::MAX_HALF_STRIP_ME1B + 1;
     keyWG = alct.getKeyWG();
 
     if ((not doesWiregroupCrossStrip(keyWG, keyStrip)) and p == CSCPart::ME1B and keyWG <= 15) {
       //try ME1A as strip and WG do not cross
       p = CSCPart::ME1A;
       const auto& mymap2 = getLUT()->get_gem_pad_to_csc_hs(theParity, p);
       keyStrip = mymap2[gem2.pad(2) - 1] + CSCConstants::MAX_HALF_STRIP_ME1B + 1;
     }
 
     pattern = promoteALCTGEMpattern_ ? 10 : 0;
     quality = promoteALCTGEMquality_ ? 15 : 11;
     bx = alct.getBX();
     thisLCT.setALCT(getBXShiftedALCT(alct));
     thisLCT.setGEM1(gem2.first());
     thisLCT.setGEM2(gem2.second());
     thisLCT.setType(CSCCorrelatedLCTDigi::ALCT2GEM);
     valid = true;
   } else if (clct.isValid() and gem2.isValid() and not alct.isValid()) {
     const auto& mymap2 = getLUT()->get_gem_roll_to_csc_wg(theParity);
     pattern = encodePattern(clct.getPattern());
     quality = promoteCLCTGEMquality_ ? 15 : 11;
     bx = gem2.bx(1) + CSCConstants::LCT_CENTRAL_BX;
     keyStrip = clct.getKeyStrip();
     // choose the corresponding wire-group in the middle of the partition
     keyWG = mymap2[gem2.roll()];
     bend = clct.getBend();
     thisLCT.setCLCT(clct);
     thisLCT.setGEM1(gem2.first());
     thisLCT.setGEM2(gem2.second());
     thisLCT.setType(CSCCorrelatedLCTDigi::CLCT2GEM);
     valid = true;
   }
 
   if (valid == 0)
     LogTrace("CSCGEMCMotherboard") << "Warning!!! wiregroup and strip pair are not crossing each other"
                                    << " detid " << cscId_ << " with wiregroup " << keyWG << "keyStrip " << keyStrip
                                    << " \n";
 
   // fill the rest of the properties
   thisLCT.setTrknmb(trknmb);
   thisLCT.setValid(valid);
   thisLCT.setQuality(quality);
   thisLCT.setWireGroup(keyWG);
   thisLCT.setStrip(keyStrip);
   thisLCT.setPattern(pattern);
   thisLCT.setBend(bend);
   thisLCT.setBX(bx);
   thisLCT.setMPCLink(0);
   thisLCT.setBX0(0);
   thisLCT.setSyncErr(0);
   thisLCT.setCSCID(theTrigChamber);
 
   // future work: add a section that produces LCTs according
   // to the new LCT dataformat (not yet defined)
 
   // return new LCT
   return thisLCT;
 }

template<class T >

void CSCGEMMotherboard::correlateLCTsGEM	(	const T &	best,
		const T &	second,
		const GEMCoPadDigiIds &	coPads,
		CSCCorrelatedLCTDigi &	lct1,
		CSCCorrelatedLCTDigi &	lct2
	)		const

protected

Definition at line 462 of file CSCGEMMotherboard.h.

References CSCCorrelatedLCTDigi::isValid(), and CSCMotherboard::secondLCT.

Referenced by doesWiregroupCrossStrip(), CSCGEMMotherboardME21::run(), and CSCGEMMotherboardME11::run().

                                                                            {
   T bestLCT = bLCT;
   T secondLCT = sLCT;
 
   // Check which LCTs are valid
   bool bestValid = bestLCT.isValid();
   bool secondValid = secondLCT.isValid();
 
   // At this point, set both LCTs valid if they are invalid
   // Duplicate LCTs are taken into account later
   if (bestValid and !secondValid)
     secondLCT = bestLCT;
   if (!bestValid and secondValid)
     bestLCT = secondLCT;
 
   // get best matching copad1
   const GEMCoPadDigi& bestCoPad = bestMatchingPad<GEMCoPadDigi>(bestLCT, coPads);
   const GEMCoPadDigi& secondCoPad = bestMatchingPad<GEMCoPadDigi>(secondLCT, coPads);
 
   correlateLCTsGEM(bestLCT, secondLCT, bestCoPad, secondCoPad, lct1, lct2);
 }

template<class T >

void CSCGEMMotherboard::correlateLCTsGEM	(	const T &	best,
		const T &	second,
		const GEMCoPadDigi &	bestCoPad,
		const GEMCoPadDigi &	secondCoPad,
		CSCCorrelatedLCTDigi &	lct1,
		CSCCorrelatedLCTDigi &	lct2
	)		const

protected

Definition at line 489 of file CSCGEMMotherboard.h.

References constructLCTsGEM(), CSCMotherboard::match_trig_enable, and or.

                                                                            {
   // construct the first LCT from ALCT(CLCT) and a GEM Copad
   if ((getLctTrigEnable<T>() and bestLCT.isValid()) or (match_trig_enable and bestLCT.isValid())) {
     lct1 = constructLCTsGEM(bestLCT, bestCoPad, 1);
   }
 
   // construct the second LCT from ALCT(CLCT) and a GEM Copad
   if ((getLctTrigEnable<T>() and secondLCT.isValid()) or
       (match_trig_enable and secondLCT.isValid() and secondLCT != bestLCT)) {
     lct2 = constructLCTsGEM(secondLCT, secondCoPad, 2);
   }
 }

virtual bool CSCGEMMotherboard::doesWiregroupCrossStrip	(	int	key_wg,
		int	key_strip
	)		const

inlineprotectedvirtual

Reimplemented in CSCGEMMotherboardME11, and CSCGEMMotherboardME21.

Definition at line 71 of file CSCGEMMotherboard.h.

References bestMatchingPad(), constructLCTsGEM(), correlateLCTsGEM(), findQualityGEM(), getBX(), getPad(), getRoll(), getRolls(), mps_fire::i, isGEMDetId(), isPadInOverlap(), matchingPads(), AlCaHLTBitMon_ParallelJobs::p, printGEMTriggerCoPads(), printGEMTriggerPads(), retrieveGEMCoPads(), retrieveGEMPads(), edm::second(), and setupGeometry().

Referenced by constructLCTsGEM().

71 { return true; }

unsigned int CSCGEMMotherboard::findQualityGEM	(	const CSCALCTDigi &	aLCT,
		const CSCCLCTDigi &	cLCT,
		int	gemlayer
	)		const

protected

Definition at line 314 of file CSCGEMMotherboard.cc.

References CSCALCTDigi::getAccelerator(), CSCCLCTDigi::getPattern(), CSCALCTDigi::getQuality(), CSCCLCTDigi::getQuality(), CSCBaseboard::infoV, cond::time::INVALID, CSCALCTDigi::isValid(), CSCCLCTDigi::isValid(), or, topSingleLeptonDQM_PU_cfi::pattern, and CSCBaseboard::theStation.

Referenced by constructLCTsGEM(), and doesWiregroupCrossStrip().

                                                                                                                     {
   // Either ALCT or CLCT is invalid
   if (!(aLCT.isValid()) || !(cLCT.isValid())) {
     // No CLCT
     if (aLCT.isValid() && !(cLCT.isValid()))
       return LCT_Quality::NO_CLCT;
 
     // No ALCT
     else if (!(aLCT.isValid()) && cLCT.isValid())
       return LCT_Quality::NO_ALCT;
 
     // No ALCT and no CLCT
     else
       return LCT_Quality::INVALID;
   }
   // Both ALCT and CLCT are valid
   else {
     const int pattern(cLCT.getPattern());
 
     // Layer-trigger in CLCT
     if (pattern == 1)
       return LCT_Quality::CLCT_LAYER_TRIGGER;
 
     // Multi-layer pattern in CLCT
     else {
       // ALCT quality is the number of layers hit minus 3.
       bool a4 = false;
 
       // Case of ME11 with GEMs: require 4 layers for ALCT
       if (theStation == 1)
         a4 = aLCT.getQuality() >= 1;
 
       // Case of ME21 with GEMs: require 4 layers for ALCT+GEM
       if (theStation == 2)
         a4 = aLCT.getQuality() + gemlayers >= 1;
 
       // CLCT quality is the number of layers hit.
       const bool c4((cLCT.getQuality() >= 4) or (cLCT.getQuality() >= 3 and gemlayers >= 1));
 
       // quality = 4; "reserved for low-quality muons in future"
 
       // marginal anode and cathode
       if (!a4 && !c4)
         return LCT_Quality::MARGINAL_ANODE_CATHODE;
 
       // HQ anode, but marginal cathode
       else if (a4 && !c4)
         return LCT_Quality::HQ_ANODE_MARGINAL_CATHODE;
 
       // HQ cathode, but marginal anode
       else if (!a4 && c4)
         return LCT_Quality::HQ_CATHODE_MARGINAL_ANODE;
 
       // HQ muon, but accelerator ALCT
       else if (a4 && c4) {
         if (aLCT.getAccelerator())
           return LCT_Quality::HQ_ACCEL_ALCT;
 
         else {
           // quality =  9; "reserved for HQ muons with future patterns
           // quality = 10; "reserved for HQ muons with future patterns
 
           // High quality muons are determined by their CLCT pattern
           if (pattern == 2 || pattern == 3)
             return LCT_Quality::HQ_PATTERN_2_3;
 
           else if (pattern == 4 || pattern == 5)
             return LCT_Quality::HQ_PATTERN_4_5;
 
           else if (pattern == 6 || pattern == 7)
             return LCT_Quality::HQ_PATTERN_6_7;
 
           else if (pattern == 8 || pattern == 9)
             return LCT_Quality::HQ_PATTERN_8_9;
 
           else if (pattern == 10)
             return LCT_Quality::HQ_PATTERN_10;
 
           else {
             if (infoV >= 0)
               edm::LogWarning("L1CSCTPEmulatorWrongValues")
                   << "+++ findQuality: Unexpected CLCT pattern id = " << pattern << "+++\n";
             return LCT_Quality::INVALID;
           }
         }
       }
     }
   }
   return LCT_Quality::INVALID;
 }

int CSCGEMMotherboard::getBX ( const GEMPadDigi & p ) const

protected

Definition at line 238 of file CSCGEMMotherboard.cc.

References GEMPadDigi::bx().

Referenced by doesWiregroupCrossStrip(), and matchingPads().

238 { return p.bx(); }

GEMPadDigi::bx

int bx() const

Definition: GEMPadDigi.h:27

int CSCGEMMotherboard::getBX ( const GEMCoPadDigi & p ) const

protected

Definition at line 240 of file CSCGEMMotherboard.cc.

References GEMCoPadDigi::bx().

240 { return p.bx(1); }

GEMCoPadDigi::bx

int bx(int l) const

Definition: GEMCoPadDigi.cc:29

template<class T >

int CSCGEMMotherboard::getLctTrigEnable ( ) const

private

template<>

int CSCGEMMotherboard::getLctTrigEnable ( ) const

private

Definition at line 426 of file CSCGEMMotherboard.cc.

References CSCMotherboard::alct_trig_enable.

                                                            {
   return alct_trig_enable;
 }

template<>

int CSCGEMMotherboard::getLctTrigEnable ( ) const

private

Definition at line 431 of file CSCGEMMotherboard.cc.

References CSCMotherboard::clct_trig_enable.

                                                            {
   return clct_trig_enable;
 }

virtual const CSCGEMMotherboardLUT* CSCGEMMotherboard::getLUT ( ) const

protectedpure virtual

Implemented in CSCGEMMotherboardME11, and CSCGEMMotherboardME21.

Referenced by constructLCTsGEM(), getPad(), getRolls(), isPadInOverlap(), matchingPads(), and setGEMGeometry().

template<class T >

int CSCGEMMotherboard::getMaxDeltaBX ( ) const

private

template<>

int CSCGEMMotherboard::getMaxDeltaBX ( ) const

private

Definition at line 416 of file CSCGEMMotherboard.cc.

References maxDeltaBXPad_.

                                                        {
   return maxDeltaBXPad_;
 }

template<>

int CSCGEMMotherboard::getMaxDeltaBX ( ) const

private

Definition at line 421 of file CSCGEMMotherboard.cc.

References maxDeltaBXCoPad_.

                                                          {
   return maxDeltaBXCoPad_;
 }

float CSCGEMMotherboard::getPad ( const GEMPadDigi & p ) const

protected

Definition at line 251 of file CSCGEMMotherboard.cc.

References GEMPadDigi::pad().

Referenced by bestMatchingPad(), doesWiregroupCrossStrip(), and matchingPads().

251 { return p.pad(); }

GEMPadDigi::pad

int pad() const

Definition: GEMPadDigi.h:26

float CSCGEMMotherboard::getPad ( const GEMCoPadDigi & p ) const

protected

Definition at line 253 of file CSCGEMMotherboard.cc.

References GEMCoPadDigi::pad().

                                                            {
   // average pad number for a GEMCoPad
   return 0.5 * (p.pad(1) + p.pad(2));
 }

float CSCGEMMotherboard::getPad	(	const CSCCLCTDigi &	clct,
		enum CSCPart	par
	)		const

protected

Definition at line 258 of file CSCGEMMotherboard.cc.

References CSCGEMMotherboardLUT::get_csc_hs_to_gem_pad(), CSCCLCTDigi::getKeyStrip(), getLUT(), CSCConstants::MAX_HALF_STRIP_ME1B, ME1A, and CSCUpgradeMotherboard::theParity.

                                                                                 {
   const auto& mymap = (getLUT()->get_csc_hs_to_gem_pad(theParity, part));
   int keyStrip = clct.getKeyStrip();
   //ME1A part, convert halfstrip from 128-223 to 0-95
   if (part == CSCPart::ME1A and keyStrip > CSCConstants::MAX_HALF_STRIP_ME1B)
     keyStrip = keyStrip - CSCConstants::MAX_HALF_STRIP_ME1B - 1;
   return 0.5 * (mymap[keyStrip].first + mymap[keyStrip].second);
 }

template<class T >

const matchesBX<T>& CSCGEMMotherboard::getPads ( ) const

private

template<>

const matchesBX<GEMPadDigi>& CSCGEMMotherboard::getPads ( ) const

private

Definition at line 406 of file CSCGEMMotherboard.cc.

References pads_.

                                                                           {
   return pads_;
 }

template<>

const matchesBX<GEMCoPadDigi>& CSCGEMMotherboard::getPads ( ) const

private

Definition at line 411 of file CSCGEMMotherboard.cc.

References coPads_.

                                                                               {
   return coPads_;
 }

int CSCGEMMotherboard::getRoll ( const GEMPadDigiId & p ) const

protected

Definition at line 242 of file CSCGEMMotherboard.cc.

References GEMDetId::roll().

Referenced by bestMatchingPad(), doesWiregroupCrossStrip(), and matchingPads().

242 { return GEMDetId(p.first).roll(); }

GEMDetId

Definition: GEMDetId.h:17

AlCaHLTBitMon_ParallelJobs.p

p

Definition: AlCaHLTBitMon_ParallelJobs.py:153

GEMDetId::roll

int roll() const

Definition: GEMDetId.h:188

int CSCGEMMotherboard::getRoll ( const GEMCoPadDigiId & p ) const

protected

Definition at line 244 of file CSCGEMMotherboard.cc.

244 { return p.second.roll(); }

AlCaHLTBitMon_ParallelJobs.p

p

Definition: AlCaHLTBitMon_ParallelJobs.py:153

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

protected

Definition at line 246 of file CSCGEMMotherboard.cc.

References CSCGEMMotherboardLUT::get_csc_wg_to_gem_roll(), CSCALCTDigi::getKeyWG(), getLUT(), and CSCUpgradeMotherboard::theParity.

Referenced by bestMatchingPad(), and doesWiregroupCrossStrip().

                                                                            {
   return std::make_pair((getLUT()->get_csc_wg_to_gem_roll(theParity))[alct.getKeyWG()].first,
                         (getLUT()->get_csc_wg_to_gem_roll(theParity))[alct.getKeyWG()].second);
 }

bool CSCGEMMotherboard::isGEMDetId ( unsigned int p ) const

protected

Definition at line 234 of file CSCGEMMotherboard.cc.

References MuonSubdetId::GEM, and DetId::Muon.

Referenced by bestMatchingPad(), and doesWiregroupCrossStrip().

                                                        {
   return (DetId(p).subdetId() == MuonSubdetId::GEM and DetId(p).det() == DetId::Muon);
 }

bool CSCGEMMotherboard::isPadInOverlap ( int roll ) const

protected

Definition at line 221 of file CSCGEMMotherboard.cc.

References dqmdumpme::first, CSCGEMMotherboardLUT::get_csc_wg_to_gem_roll(), getLUT(), mps_fire::i, or, edm::second(), and CSCUpgradeMotherboard::theParity.

Referenced by doesWiregroupCrossStrip(), printGEMTriggerCoPads(), and printGEMTriggerPads().

                                                      {
   // this only works for ME1A!
   const auto& mymap = (getLUT()->get_csc_wg_to_gem_roll(theParity));
   for (unsigned i = 0; i < mymap.size(); i++) {
     // overlap region are WGs 10-15
     if ((i < 10) or (i > 15))
       continue;
     if ((mymap[i].first <= roll) and (roll <= mymap[i].second))
       return true;
   }
   return false;
 }

template<class T >

void CSCGEMMotherboard::matchingPads	(	const CSCALCTDigi &	alct,
		matches< T > &	result
	)		const

protected

Definition at line 243 of file CSCGEMMotherboard.h.

References funct::abs(), DEFAULT_MATCHING_VALUE, dumpMFGeometry_cfg::delta, CSCGEMMotherboardLUT::get_csc_wg_to_gem_roll(), CSCALCTDigi::getBX(), getBX(), CSCALCTDigi::getKeyWG(), getLUT(), getRoll(), CSCALCTDigi::isValid(), CSCConstants::LCT_CENTRAL_BX, or, AlCaHLTBitMon_ParallelJobs::p, GEMDetId::station(), and CSCUpgradeMotherboard::theParity.

Referenced by doesWiregroupCrossStrip().

                                                                                       {
   result.clear();
   // Invalid ALCTs have no matching pads
   if (not alct.isValid())
     return;
 
   // Get the corresponding roll numbers for a given ALCT
   std::pair<int, int> alctRoll = (getLUT()->get_csc_wg_to_gem_roll(theParity))[alct.getKeyWG()];
 
   // Get the pads in the ALCT bx
   const matchesBX<T>& lut = getPads<T>();
 
   // If no pads in that bx...
   if (lut.count(alct.getBX()) == 0)
     return;
 
   for (const auto& p : lut.at(alct.getBX())) {
     auto padRoll(getRoll(p));
 
     int delta;
     if (GEMDetId(p.first).station() == 2)
       delta = 1;
 
     // pad bx needs to match to ALCT bx
     int pad_bx = getBX(p.second) + CSCConstants::LCT_CENTRAL_BX;
 
     if (std::abs(alct.getBX() - pad_bx) > getMaxDeltaBX<T>())
       continue;
 
     // gem roll number if invalid
     if (alctRoll.first == CSCGEMMotherboard::DEFAULT_MATCHING_VALUE and
         alctRoll.second == CSCGEMMotherboard::DEFAULT_MATCHING_VALUE)
       continue;
     // ALCTs at the top of the chamber
     else if (alctRoll.first == CSCGEMMotherboard::DEFAULT_MATCHING_VALUE and padRoll > alctRoll.second)
       continue;
     // ALCTs at the bottom of the chamber
     else if (alctRoll.second == CSCGEMMotherboard::DEFAULT_MATCHING_VALUE and padRoll < alctRoll.first)
       continue;
     // ignore pads that are too far away in roll number
     else if ((alctRoll.first != CSCGEMMotherboard::DEFAULT_MATCHING_VALUE and
               alctRoll.second != CSCGEMMotherboard::DEFAULT_MATCHING_VALUE) and
              (alctRoll.first - delta > padRoll or padRoll > alctRoll.second))
       continue;
     result.push_back(p);
   }
 }

template<class T >

void CSCGEMMotherboard::matchingPads	(	const CSCCLCTDigi &	alct,
		matches< T > &	result
	)		const

protected

Definition at line 292 of file CSCGEMMotherboard.h.

References funct::abs(), dqmdumpme::first, CSCGEMMotherboardLUT::get_csc_hs_to_gem_pad(), CSCCLCTDigi::getBX(), getBX(), CSCUpgradeMotherboard::getCSCPart(), CSCCLCTDigi::getKeyStrip(), getLUT(), getPad(), CSCCLCTDigi::isValid(), CSCConstants::LCT_CENTRAL_BX, CSCConstants::MAX_HALF_STRIP_ME1B, maxDeltaPadL1_, ME1A, or, AlCaHLTBitMon_ParallelJobs::p, edm::second(), and CSCUpgradeMotherboard::theParity.

                                                                                       {
   result.clear();
   // Invalid ALCTs have no matching pads
   if (not clct.isValid())
     return;
 
   auto part(getCSCPart(clct.getKeyStrip()));
   // Get the corresponding pad numbers for a given CLCT
   const auto& mymap = (getLUT()->get_csc_hs_to_gem_pad(theParity, part));
   int keyStrip = clct.getKeyStrip();
   //ME1A part, convert halfstrip from 128-223 to 0-95
   if (part == CSCPart::ME1A and keyStrip > CSCConstants::MAX_HALF_STRIP_ME1B)
     keyStrip = keyStrip - CSCConstants::MAX_HALF_STRIP_ME1B - 1;
   const int lowPad(mymap[keyStrip].first);
   const int highPad(mymap[keyStrip].second);
 
   // Get the pads in the CLCT bx
   const matchesBX<T>& lut = getPads<T>();
 
   // If no pads in that bx...
   if (lut.count(clct.getBX()) == 0)
     return;
 
   for (const auto& p : lut.at(clct.getBX())) {
     // pad bx needs to match to CLCT bx
     int pad_bx = getBX(p.second) + CSCConstants::LCT_CENTRAL_BX;
     if (std::abs(clct.getBX() - pad_bx) > getMaxDeltaBX<T>())
       continue;
 
     // pad number must match
     int padNumber(getPad(p.second));
     if (std::abs(lowPad - padNumber) <= maxDeltaPadL1_ or std::abs(padNumber - highPad) <= maxDeltaPadL1_) {
       result.push_back(p);
     }
   }
 }

template<class S , class T >

void CSCGEMMotherboard::matchingPads	(	const S &	d1,
		const S &	d2,
		matches< T > &	result
	)		const

protected

Definition at line 330 of file CSCGEMMotherboard.h.

References begin, end, p1, and p2.

                                                                                        {
   matches<T> p1, p2;
 
   // pads matching to the CLCT/ALCT
   matchingPads<T>(d1, p1);
 
   // pads matching to the CLCT/ALCT
   matchingPads<T>(d2, p2);
 
   // collect *all* matching pads
   result.reserve(p1.size() + p2.size());
   result.insert(std::end(result), std::begin(p1), std::end(p1));
   result.insert(std::end(result), std::begin(p2), std::end(p2));
 }

template<class T >

void CSCGEMMotherboard::matchingPads	(	const CSCCLCTDigi &	clct1,
		const CSCALCTDigi &	alct1,
		matches< T > &	result
	)		const

protected

Definition at line 346 of file CSCGEMMotherboard.h.

References CSCUpgradeMotherboard::intersection().

                                                                                                                  {
   matches<T> padsClct, padsAlct;
 
   // pads matching to the CLCT
   matchingPads<T>(clct1, padsClct);
 
   // pads matching to the ALCT
   matchingPads<T>(alct1, padsAlct);
 
   // collect all *common* pads
   intersection(padsClct, padsAlct, result);
 }

template<class T >

void CSCGEMMotherboard::matchingPads	(	const CSCCLCTDigi &	clct1,
		const CSCCLCTDigi &	clct2,
		const CSCALCTDigi &	alct1,
		const CSCALCTDigi &	alct2,
		matches< T > &	result
	)		const

protected

Definition at line 360 of file CSCGEMMotherboard.h.

References begin, and end.

                                                                {
   matches<T> padsClct, padsAlct;
 
   // pads matching to CLCTs
   matchingPads<CSCCLCTDigi, T>(clct1, clct2, padsClct);
 
   // pads matching to ALCTs
   matchingPads<CSCALCTDigi, T>(alct1, alct2, padsAlct);
 
   // collect *all* matching pads
   result.reserve(padsClct.size() + padsAlct.size());
   result.insert(std::end(result), std::begin(padsClct), std::end(padsClct));
   result.insert(std::end(result), std::begin(padsAlct), std::end(padsAlct));
 }

void CSCGEMMotherboard::printGEMTriggerCoPads	(	int	bx_start,
		int	bx_stop,
		enum CSCPart	part
	)

protected

Definition at line 293 of file CSCGEMMotherboard.cc.

References l1GtPatternGenerator_cfi::bx, coPads_, isPadInOverlap(), LogTrace, and ME11.

Referenced by doesWiregroupCrossStrip(), CSCGEMMotherboardME21::run(), and CSCGEMMotherboardME11::run().

                                                                                           {
   LogTrace("CSCGEMMotherboard") << "------------------------------------------------------------------------"
                                 << std::endl;
   LogTrace("CSCGEMMotherboard") << "* GEM trigger coincidence pads: " << std::endl;
 
   for (int bx = bx_start; bx <= bx_stop; bx++) {
     const auto& in_pads = coPads_[bx];
     LogTrace("CSCGEMMotherboard") << "N(copads) BX " << bx << " : " << in_pads.size() << std::endl;
 
     for (const auto& pad : in_pads) {
       LogTrace("CSCGEMMotherboard") << "\tdetId " << GEMDetId(pad.first) << ", pad = " << pad.second;
       const auto& roll_id(GEMDetId(pad.first));
 
       if (part == CSCPart::ME11 and isPadInOverlap(GEMDetId(roll_id).roll()))
         LogTrace("CSCGEMMotherboard") << " (in overlap)" << std::endl;
       else
         LogTrace("CSCGEMMotherboard") << std::endl;
     }
   }
 }

void CSCGEMMotherboard::printGEMTriggerPads	(	int	bx_start,
		int	bx_stop,
		enum CSCPart	part
	)

protected

Definition at line 272 of file CSCGEMMotherboard.cc.

References l1GtPatternGenerator_cfi::bx, isPadInOverlap(), LogTrace, ME11, and pads_.

Referenced by doesWiregroupCrossStrip(), CSCGEMMotherboardME21::run(), and CSCGEMMotherboardME11::run().

                                                                                         {
   LogTrace("CSCGEMMotherboard") << "------------------------------------------------------------------------"
                                 << std::endl;
   LogTrace("CSCGEMMotherboard") << "* GEM trigger pads: " << std::endl;
 
   for (int bx = bx_start; bx <= bx_stop; bx++) {
     const auto& in_pads = pads_[bx];
     LogTrace("CSCGEMMotherboard") << "N(pads) BX " << bx << " : " << in_pads.size() << std::endl;
 
     for (const auto& pad : in_pads) {
       LogTrace("CSCGEMMotherboard") << "\tdetId " << GEMDetId(pad.first) << ", pad = " << pad.second;
       const auto& roll_id(GEMDetId(pad.first));
 
       if (part == CSCPart::ME11 and isPadInOverlap(GEMDetId(roll_id).roll()))
         LogTrace("CSCGEMMotherboard") << " (in overlap)" << std::endl;
       else
         LogTrace("CSCGEMMotherboard") << std::endl;
     }
   }
 }

void CSCGEMMotherboard::retrieveGEMCoPads ( )

protected

Definition at line 65 of file CSCGEMMotherboard.cc.

References coPads_, gemCoPadV, CSCConstants::LCT_CENTRAL_BX, DetId::rawId(), CSCBaseboard::theChamber, CSCBaseboard::theRegion, and CSCBaseboard::theStation.

Referenced by doesWiregroupCrossStrip(), CSCGEMMotherboardME21::run(), and CSCGEMMotherboardME11::run().

                                           {
   coPads_.clear();
   for (const auto& copad : gemCoPadV) {
     GEMDetId detId(theRegion, 1, theStation, 0, theChamber, 0);
     // only consider matches with same BX
     coPads_[CSCConstants::LCT_CENTRAL_BX + copad.bx(1)].emplace_back(detId.rawId(), copad);
   }
 }

void CSCGEMMotherboard::retrieveGEMPads	(	const GEMPadDigiCollection *	pads,
		unsigned	id
	)

protected

Definition at line 47 of file CSCGEMMotherboard.cc.

References l1GtPatternGenerator_cfi::bx, gem_g, CSCConstants::LCT_CENTRAL_BX, maxDeltaBXPad_, pads_, and GEMGeometry::superChamber().

Referenced by doesWiregroupCrossStrip(), CSCGEMMotherboardME21::run(), and CSCGEMMotherboardME11::run().

                                                                                         {
   pads_.clear();
   auto superChamber(gem_g->superChamber(id));
   for (const auto& ch : superChamber->chambers()) {
     for (const auto& roll : ch->etaPartitions()) {
       GEMDetId roll_id(roll->id());
       auto pads_in_det = gemPads->get(roll_id);
       for (auto pad = pads_in_det.first; pad != pads_in_det.second; ++pad) {
         const int bx_shifted(CSCConstants::LCT_CENTRAL_BX + pad->bx());
         // consider matches with BX difference +1/0/-1
         for (int bx = bx_shifted - maxDeltaBXPad_; bx <= bx_shifted + maxDeltaBXPad_; ++bx) {
           pads_[bx].emplace_back(roll_id.rawId(), *pad);
         }
       }
     }
   }
 }

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

pure virtual

Implemented in CSCGEMMotherboardME11, and CSCGEMMotherboardME21.

Referenced by run().

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

Definition at line 39 of file CSCGEMMotherboard.cc.

References coPadProcessor, and run().

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

void CSCGEMMotherboard::setGEMGeometry ( const GEMGeometry * g )

inline

set CSC and GEM geometries for the matching needs

Definition at line 66 of file CSCGEMMotherboard.h.

References g, gem_g, and getLUT().

Referenced by CSCTriggerPrimitivesBuilder::build().

66 { gem_g = g; }

g

The Signals That Services Can Subscribe To This is based on ActivityRegistry and is current per Services can connect to the signals distributed by the ActivityRegistry in order to monitor the activity of the application Each possible callback has some defined which we here list in angle e g

Definition: Activities.doc:4

CSCGEMMotherboard::gem_g

const GEMGeometry * gem_g

Definition: CSCGEMMotherboard.h:204

void CSCGEMMotherboard::setupGeometry ( )

protected

Definition at line 267 of file CSCGEMMotherboard.cc.

References gem_g, CSCUpgradeMotherboard::generator_, and CSCUpgradeMotherboard::setupGeometry().

Referenced by doesWiregroupCrossStrip(), CSCGEMMotherboardME21::run(), and CSCGEMMotherboardME11::run().

                                       {
   CSCUpgradeMotherboard::setupGeometry();
   generator_->setGEMGeometry(gem_g);
 }

Member Data Documentation

std::unique_ptr<GEMCoPadProcessor> CSCGEMMotherboard::coPadProcessor

additional processor for GEMs

Definition at line 63 of file CSCGEMMotherboard.h.

Referenced by CSCTriggerPrimitivesBuilder::build(), CSCGEMMotherboard(), CSCGEMMotherboardME21::run(), CSCGEMMotherboardME11::run(), and run().

GEMCoPadDigiIdsBX CSCGEMMotherboard::coPads_

protected

Definition at line 211 of file CSCGEMMotherboard.h.

Referenced by clear(), getPads(), printGEMTriggerCoPads(), retrieveGEMCoPads(), CSCGEMMotherboardME11::run(), and CSCGEMMotherboardME21::run().

bool CSCGEMMotherboard::doLCTGhostBustingWithGEMs_

protected

Definition at line 229 of file CSCGEMMotherboard.h.

const GEMGeometry* CSCGEMMotherboard::gem_g

protected

Definition at line 204 of file CSCGEMMotherboard.h.

Referenced by retrieveGEMPads(), CSCGEMMotherboardME21::run(), CSCGEMMotherboardME11::run(), setGEMGeometry(), and setupGeometry().

std::vector<GEMCoPadDigi> CSCGEMMotherboard::gemCoPadV

protected

Definition at line 207 of file CSCGEMMotherboard.h.

Referenced by retrieveGEMCoPads(), CSCGEMMotherboardME21::run(), and CSCGEMMotherboardME11::run().

bool CSCGEMMotherboard::gemGeometryAvailable

protected

Definition at line 205 of file CSCGEMMotherboard.h.

Referenced by CSCGEMMotherboardME11::run(), and CSCGEMMotherboardME21::run().

unsigned CSCGEMMotherboard::gemId

protected

Chamber id (trigger-type labels).

Definition at line 202 of file CSCGEMMotherboard.h.

Referenced by CSCGEMMotherboard(), CSCGEMMotherboardME21::run(), and CSCGEMMotherboardME11::run().

int CSCGEMMotherboard::maxDeltaBXCoPad_

protected

Definition at line 215 of file CSCGEMMotherboard.h.

Referenced by getMaxDeltaBX(), CSCGEMMotherboardME21::run(), and CSCGEMMotherboardME11::run().

int CSCGEMMotherboard::maxDeltaBXPad_

protected

Definition at line 214 of file CSCGEMMotherboard.h.

Referenced by getMaxDeltaBX(), and retrieveGEMPads().

int CSCGEMMotherboard::maxDeltaPadL1_

protected

Definition at line 216 of file CSCGEMMotherboard.h.

Referenced by CSCGEMMotherboard(), and matchingPads().

int CSCGEMMotherboard::maxDeltaPadL2_

protected

Definition at line 217 of file CSCGEMMotherboard.h.

Referenced by CSCGEMMotherboard().

GEMPadDigiIdsBX CSCGEMMotherboard::pads_

protected

Definition at line 210 of file CSCGEMMotherboard.h.

Referenced by clear(), getPads(), printGEMTriggerPads(), retrieveGEMPads(), and CSCGEMMotherboardME11::run().

bool CSCGEMMotherboard::promoteALCTGEMpattern_

protected

Definition at line 223 of file CSCGEMMotherboard.h.

Referenced by constructLCTsGEM().

bool CSCGEMMotherboard::promoteALCTGEMquality_

protected

Definition at line 225 of file CSCGEMMotherboard.h.

Referenced by constructLCTsGEM().

bool CSCGEMMotherboard::promoteCLCTGEMquality_

protected

Definition at line 226 of file CSCGEMMotherboard.h.

Referenced by constructLCTsGEM().

bool CSCGEMMotherboard::useOldLCTDataFormat_

protected

Definition at line 220 of file CSCGEMMotherboard.h.

Public Types

Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Private Member Functions

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation