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

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

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

void	clear ()

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

	CSCGEMMotherboard ()

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
template<class S >
bool	compare (const S &p, const S &q) const

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

	CSCUpgradeMotherboard ()

void	debugLUTs ()

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

void	setCSCGeometry (const CSCGeometry *g)

void	setupGeometry ()

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

	~CSCUpgradeMotherboard () override

Public Member Functions inherited from CSCMotherboard
void	clear ()

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

	CSCMotherboard ()

std::vector< CSCCorrelatedLCTDigi >	getLCTs () const

std::vector< CSCCorrelatedLCTDigi >	readoutLCTs () const

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

void	run (const CSCWireDigiCollection wiredc, const CSCComparatorDigiCollection compdc)

void	setConfigParameters (const CSCDBL1TPParameters *conf)

void	setCSCGeometry (const CSCGeometry *g)

virtual	~CSCMotherboard ()=default

Public Attributes
std::unique_ptr< GEMCoPadProcessor >	coPadProcessor

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

std::unique_ptr< CSCCathodeLCTProcessor >	clct

Protected Member Functions
template<class T >
T	bestMatchingPad (const CSCALCTDigi &, const matches< T > &, enum CSCPart) const

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

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

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

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

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

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

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

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

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

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

int	getBX (const GEMPadDigi &p) const

int	getBX (const GEMCoPadDigi &p) const

virtual const CSCGEMMotherboardLUT *	getLUT () const =0

float	getPad (const GEMPadDigi &) const

float	getPad (const GEMCoPadDigi &) const

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

int	getRoll (const GEMPadDigiId &p) const

int	getRoll (const GEMCoPadDigiId &p) const

int	getRoll (const CSCALCTDigi &) const

bool	isGEMDetId (unsigned int) const

bool	isPadInOverlap (int roll) const

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

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

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

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

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

void	printGEMTriggerCoPads (int bx_start, int bx_stop, enum CSCPart)

void	printGEMTriggerPads (int bx_start, int bx_stop, enum CSCPart)

void	retrieveGEMCoPads ()

void	retrieveGEMPads (const GEMPadDigiCollection *pads, unsigned id)

void	setupGeometry ()

Protected Member Functions inherited from CSCMotherboard
void	checkConfigParameters ()

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

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

void	dumpConfigParams () const

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

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

CSCALCTDigi	getBXShiftedALCT (const CSCALCTDigi &) const

void	testLCT ()

Protected Attributes
GEMCoPadDigiIdsBX	coPads_

bool	doLCTGhostBustingWithGEMs_

const GEMGeometry *	gem_g

std::vector< GEMCoPadDigi >	gemCoPadV

bool	gemGeometryAvailable

unsigned	gemId

int	maxDeltaBXCoPad_

int	maxDeltaBXPad_

int	maxDeltaPadL1_

int	maxDeltaPadL2_

GEMPadDigiIdsBX	pads_

bool	promoteALCTGEMpattern_

bool	promoteALCTGEMquality_

bool	promoteCLCTGEMquality_

bool	useOldLCTDataFormat_

Protected Attributes inherited from CSCUpgradeMotherboard
std::vector< CSCALCTDigi >	alctV

bool	clct_to_alct

edm::ParameterSet	commonParams_

const CSCGeometry *	csc_g

const CSCChamber *	cscChamber

bool	debug_luts

bool	debug_matching

bool	drop_used_clcts

std::unique_ptr< CSCUpgradeMotherboardLUTGenerator >	generator_

bool	match_earliest_alct_only

bool	match_earliest_clct_only

unsigned int	max_lcts

Parity	par

int	pref [CSCConstants::MAX_LCT_TBINS]

unsigned	theChamber

unsigned	theRegion

unsigned int	tmb_cross_bx_algo

edm::ParameterSet	tmbParams_

Protected Attributes inherited from CSCMotherboard
unsigned int	alct_trig_enable

bool	clct_to_alct

unsigned int	clct_trig_enable

const CSCGeometry *	csc_g

bool	drop_used_alcts

bool	drop_used_clcts

int	early_tbins

CSCCorrelatedLCTDigi	firstLCT [CSCConstants::MAX_LCT_TBINS]

int	infoV

bool	isMTCC

bool	isSLHC

bool	isTMB07

unsigned int	match_trig_enable

unsigned int	match_trig_window_size

unsigned int	mpc_block_me1a

bool	readout_earliest_2

CSCCorrelatedLCTDigi	secondLCT [CSCConstants::MAX_LCT_TBINS]

const unsigned	theEndcap

unsigned	theRing

const unsigned	theSector

const unsigned	theStation

const unsigned	theSubsector

const unsigned	theTrigChamber

unsigned int	tmb_l1a_window_size

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 33 of file CSCGEMMotherboard.h.

33 {DEFAULT_MATCHING_VALUE = -99};

CSCGEMMotherboard::DEFAULT_MATCHING_VALUE

Definition: CSCGEMMotherboard.h:33

Constructor & Destructor Documentation

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

Definition at line 4 of file CSCGEMMotherboard.cc.

References coPadProcessor, gemId, edm::ParameterSet::getParameter(), maxDeltaPadL1_, maxDeltaPadL2_, CSCUpgradeMotherboard::par, DetId::rawId(), CSCUpgradeMotherboard::theChamber, CSCUpgradeMotherboard::theRegion, CSCMotherboard::theStation, and CSCUpgradeMotherboard::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(endcap, station, chamber, coPadParams) );
 
   maxDeltaPadL1_ = (par ? tmbParams_.getParameter<int>("maxDeltaPadL1Even") :
             tmbParams_.getParameter<int>("maxDeltaPadL1Odd") );
   maxDeltaPadL2_ = (par ? tmbParams_.getParameter<int>("maxDeltaPadL2Even") :
             tmbParams_.getParameter<int>("maxDeltaPadL2Odd") );
 }

CSCGEMMotherboard::CSCGEMMotherboard ( )

Definition at line 30 of file CSCGEMMotherboard.cc.

                                      : CSCUpgradeMotherboard()
 {
 }

CSCGEMMotherboard::~CSCGEMMotherboard ( )

override

Definition at line 34 of file CSCGEMMotherboard.cc.

35 {

36 }

Member Function Documentation

template<class T >

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

protected

Referenced by setGEMGeometry().

template<class T >

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

protected

template<class T >

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

protected

template<class S >

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

Definition at line 395 of file CSCGEMMotherboard.h.

References getRoll(), 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 (getRoll(p) == getRoll(alct1)){
       return p.second;
     }
   }
   return result;
 }

template<class S >

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

Definition at line 418 of file CSCGEMMotherboard.h.

References funct::abs(), 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;
 
   // 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,
		enum CSCPart	part
	)		const

Definition at line 445 of file CSCGEMMotherboard.h.

References funct::abs(), getPad(), getRoll(), isGEMDetId(), CSCALCTDigi::isValid(), CSCCLCTDigi::isValid(), or, AlCaHLTBitMon_ParallelJobs::p, and mps_fire::result.

 {
   S result;
   // no matching pads for invalid stub
   if (not alct1.isValid() or not clct1.isValid()) return result;
 
   // 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);
     // add another safety to make sure that the deltaPad is not larger than max value!!!
     if (std::abs(averagePadNumberCSC - averagePadNumberGEM) < minDeltaPad and
         getRoll(p) == getRoll(alct1)){
       minDeltaPad = std::abs(averagePadNumberCSC - averagePadNumberGEM);
       result = p.second;
     }
   }
   return result;
 }

void CSCGEMMotherboard::clear ( void )

Definition at line 38 of file CSCGEMMotherboard.cc.

References coPads_, and pads_.

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

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

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

protected

Definition at line 84 of file CSCGEMMotherboard.cc.

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

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

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

protected

Definition at line 93 of file CSCGEMMotherboard.cc.

References constructLCTsGEM().

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

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

protected

Definition at line 101 of file CSCGEMMotherboard.cc.

References constructLCTsGEM().

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

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

protected

Definition at line 111 of file CSCGEMMotherboard.cc.

References constructLCTsGEM().

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

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

protected

Definition at line 120 of file CSCGEMMotherboard.cc.

 {
   int pattern = 0, quality = 0, bx = 0, keyStrip = 0, keyWG = 0, bend = 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(), clct.getStripType());
     quality = findQualityGEM(alct, clct, 1);
     bx = alct.getBX();
     keyStrip = clct.getKeyStrip();
     keyWG = alct.getKeyWG();
     bend = clct.getBend();
     thisLCT.setALCT(getBXShiftedALCT(alct));
     thisLCT.setCLCT(clct);
     thisLCT.setGEM1(gem1);
     thisLCT.setType(CSCCorrelatedLCTDigi::ALCTCLCTGEM);
   }
   else if (alct.isValid() and clct.isValid() and not gem1.isValid() and gem2.isValid()) {
     pattern = encodePattern(clct.getPattern(), clct.getStripType());
     quality = findQualityGEM(alct, clct, 2);
     bx = alct.getBX();
     keyStrip = clct.getKeyStrip();
     keyWG = alct.getKeyWG();
     bend = clct.getBend();
     thisLCT.setALCT(getBXShiftedALCT(alct));
     thisLCT.setCLCT(clct);
     thisLCT.setGEM1(gem2.first());
     thisLCT.setGEM2(gem2.second());
     thisLCT.setType(CSCCorrelatedLCTDigi::ALCTCLCT2GEM);
   }
   else if (alct.isValid() and gem2.isValid() and not clct.isValid()) {
     const auto& mymap1 = getLUT()->get_gem_pad_to_csc_hs(par, p);
     pattern = promoteALCTGEMpattern_ ? 10 : 0;
     quality = promoteALCTGEMquality_ ? 15 : 11;
     bx = alct.getBX();
     // GEM pad number is counting from 1
     keyStrip = mymap1[gem2.pad(2) - 1];
     keyWG = alct.getKeyWG();
     thisLCT.setALCT(getBXShiftedALCT(alct));
     thisLCT.setGEM1(gem2.first());
     thisLCT.setGEM2(gem2.second());
     thisLCT.setType(CSCCorrelatedLCTDigi::ALCT2GEM);
   }
   else if (clct.isValid() and gem2.isValid() and not alct.isValid()) {
     const auto& mymap2 = getLUT()->get_gem_roll_to_csc_wg(par, p);
     pattern = encodePattern(clct.getPattern(), clct.getStripType());
     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);
   }
 
   // fill the rest of the properties
   thisLCT.setTrknmb(trknmb);
   thisLCT.setValid(1);
   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	(	T &	best,
		T &	second,
		const GEMCoPadDigiIds &	coPads,
		CSCCorrelatedLCTDigi &	lct1,
		CSCCorrelatedLCTDigi &	lct2,
		enum CSCPart	p
	)		const

protected

Definition at line 474 of file CSCGEMMotherboard.h.

References AlCaHLTBitMon_ParallelJobs::p, and CSCMotherboard::secondLCT.

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

 {
   // 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, p);
   const GEMCoPadDigi& secondCoPad = bestMatchingPad<GEMCoPadDigi>(secondLCT, coPads, p);
 
   correlateLCTsGEM(bestLCT, secondLCT, bestCoPad, secondCoPad, lct1, lct2, p);
 }

template<class T >

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

protected

Definition at line 499 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, p, 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, p, 2);
     }
 }

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

protected

Definition at line 319 of file CSCGEMMotherboard.cc.

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

Referenced by constructLCTsGEM(), and setGEMGeometry().

 {
   // 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 229 of file CSCGEMMotherboard.cc.

References GEMPadDigi::bx().

Referenced by matchingPads(), and setGEMGeometry().

 {
   return p.bx();
 }

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

protected

Definition at line 234 of file CSCGEMMotherboard.cc.

References GEMCoPadDigi::bx().

 {
   return p.bx(1);
 }

template<class T >

int CSCGEMMotherboard::getLctTrigEnable ( ) const

private

template<>

int CSCGEMMotherboard::getLctTrigEnable ( ) const

private

Definition at line 438 of file CSCGEMMotherboard.cc.

References CSCMotherboard::alct_trig_enable.

 {
   return alct_trig_enable;
 }

template<>

int CSCGEMMotherboard::getLctTrigEnable ( ) const

private

Definition at line 444 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(), getRoll(), isPadInOverlap(), matchingPads(), and setGEMGeometry().

template<class T >

int CSCGEMMotherboard::getMaxDeltaBX ( ) const

private

template<>

int CSCGEMMotherboard::getMaxDeltaBX ( ) const

private

Definition at line 426 of file CSCGEMMotherboard.cc.

References maxDeltaBXPad_.

 {
   return maxDeltaBXPad_;
 }

template<>

int CSCGEMMotherboard::getMaxDeltaBX ( ) const

private

Definition at line 432 of file CSCGEMMotherboard.cc.

References maxDeltaBXCoPad_.

 {
   return maxDeltaBXCoPad_;
 }

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

protected

Definition at line 254 of file CSCGEMMotherboard.cc.

References GEMPadDigi::pad().

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

 {
   return p.pad();
 }

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

protected

Definition at line 259 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	part
	)		const

protected

Definition at line 265 of file CSCGEMMotherboard.cc.

References CSCGEMMotherboardLUT::get_csc_hs_to_gem_pad(), CSCCLCTDigi::getKeyStrip(), getLUT(), and CSCUpgradeMotherboard::par.

 {
   const auto& mymap = (getLUT()->get_csc_hs_to_gem_pad(par, part));
   return 0.5*(mymap[clct.getKeyStrip()].first + mymap[clct.getKeyStrip()].second);
 }

template<class T >

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

private

template<>

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

private

Definition at line 414 of file CSCGEMMotherboard.cc.

References pads_.

 {
   return pads_;
 }

template<>

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

private

Definition at line 420 of file CSCGEMMotherboard.cc.

References coPads_.

 {
   return coPads_;
 }

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

protected

Definition at line 239 of file CSCGEMMotherboard.cc.

References GEMDetId::roll().

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

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

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

protected

Definition at line 244 of file CSCGEMMotherboard.cc.

 {
   return p.second.roll();
 }

int CSCGEMMotherboard::getRoll ( const CSCALCTDigi & alct ) const

protected

Definition at line 249 of file CSCGEMMotherboard.cc.

References CSCALCTDigi::getKeyWG(), getLUT(), and CSCUpgradeMotherboard::par.

 {
   return (getLUT()->get_csc_wg_to_gem_roll(par))[alct.getKeyWG()].first;
 }

bool CSCGEMMotherboard::isGEMDetId ( unsigned int p ) const

protected

Definition at line 223 of file CSCGEMMotherboard.cc.

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

Referenced by bestMatchingPad(), and setGEMGeometry().

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

bool CSCGEMMotherboard::isPadInOverlap ( int roll ) const

protected

Definition at line 211 of file CSCGEMMotherboard.cc.

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

Referenced by matchingPads(), printGEMTriggerCoPads(), printGEMTriggerPads(), and setGEMGeometry().

 {
   // this only works for ME1A!
   const auto& mymap = (getLUT()->get_csc_wg_to_gem_roll(par));
   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,
		enum CSCPart	part,
		matches< T > &	result
	)		const

protected

Definition at line 253 of file CSCGEMMotherboard.h.

References funct::abs(), DEFAULT_MATCHING_VALUE, CSCGEMMotherboardLUT::get_csc_wg_to_gem_roll(), CSCALCTDigi::getBX(), getBX(), CSCALCTDigi::getKeyWG(), getLUT(), getRoll(), isPadInOverlap(), CSCALCTDigi::isValid(), CSCConstants::LCT_CENTRAL_BX, lumiPlot::lut, ME1A, or, AlCaHLTBitMon_ParallelJobs::p, and CSCUpgradeMotherboard::par.

Referenced by setGEMGeometry().

 {
   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(par))[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));
 
     // only pads in overlap are good for ME1A
     if (part==CSCPart::ME1A and !isPadInOverlap(padRoll)) continue;
 
     // 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 > padRoll or padRoll > alctRoll.second)) continue;
     result.push_back(p);
   }
 }

template<class T >

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

protected

Definition at line 299 of file CSCGEMMotherboard.h.

References funct::abs(), CSCGEMMotherboardLUT::get_csc_hs_to_gem_pad(), getBX(), CSCCLCTDigi::getBX(), CSCCLCTDigi::getKeyStrip(), getLUT(), getPad(), CSCCLCTDigi::isValid(), CSCConstants::LCT_CENTRAL_BX, lumiPlot::lut, maxDeltaPadL1_, or, AlCaHLTBitMon_ParallelJobs::p, and CSCUpgradeMotherboard::par.

 {
   result.clear();
   // Invalid ALCTs have no matching pads
   if (not clct.isValid()) return;
 
   // Get the corresponding pad numbers for a given CLCT
   const auto& mymap = (getLUT()->get_csc_hs_to_gem_pad(par, part));
   const int lowPad(mymap[clct.getKeyStrip()].first);
   const int highPad(mymap[clct.getKeyStrip()].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,
		enum CSCPart	part,
		matches< T > &	result
	)		const

protected

Definition at line 335 of file CSCGEMMotherboard.h.

References begin, end, p1, and p2.

 {
   matches<T> p1, p2;
 
   // pads matching to the CLCT/ALCT
   matchingPads<T>(d1, part, p1);
 
   // pads matching to the CLCT/ALCT
   matchingPads<T>(d2, part, 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,
		enum CSCPart	part,
		matches< T > &	result
	)		const

protected

Definition at line 354 of file CSCGEMMotherboard.h.

References CSCUpgradeMotherboard::intersection().

 {
   matches<T> padsClct, padsAlct;
 
   // pads matching to the CLCT
   matchingPads<T>(clct1, part, padsClct);
 
   // pads matching to the ALCT
   matchingPads<T>(alct1, part, 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,
		enum CSCPart	part,
		matches< T > &	result
	)		const

protected

Definition at line 372 of file CSCGEMMotherboard.h.

References begin, and end.

 {
   matches<T> padsClct, padsAlct;
 
   // pads matching to CLCTs
   matchingPads<CSCCLCTDigi, T>(clct1, clct2, part, padsClct);
 
   // pads matching to ALCTs
   matchingPads<CSCALCTDigi, T>(alct1, alct2, part, 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 299 of file CSCGEMMotherboard.cc.

References coPads_, isPadInOverlap(), LogTrace, and ME11.

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

 {
   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 277 of file CSCGEMMotherboard.cc.

References isPadInOverlap(), LogTrace, ME11, and pads_.

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

 {
   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 74 of file CSCGEMMotherboard.cc.

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

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

 {
   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 55 of file CSCGEMMotherboard.cc.

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

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

 {
   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 45 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 62 of file CSCGEMMotherboard.h.

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

Referenced by CSCTriggerPrimitivesBuilder::build().

62 { 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:212

void CSCGEMMotherboard::setupGeometry ( )

protected

Definition at line 271 of file CSCGEMMotherboard.cc.

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

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

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

Member Data Documentation

std::unique_ptr<GEMCoPadProcessor> CSCGEMMotherboard::coPadProcessor

additional processor for GEMs

Definition at line 59 of file CSCGEMMotherboard.h.

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

GEMCoPadDigiIdsBX CSCGEMMotherboard::coPads_

protected

Definition at line 219 of file CSCGEMMotherboard.h.

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

bool CSCGEMMotherboard::doLCTGhostBustingWithGEMs_

protected

Definition at line 237 of file CSCGEMMotherboard.h.

const GEMGeometry* CSCGEMMotherboard::gem_g

protected

Definition at line 212 of file CSCGEMMotherboard.h.

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

std::vector<GEMCoPadDigi> CSCGEMMotherboard::gemCoPadV

protected

Definition at line 215 of file CSCGEMMotherboard.h.

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

bool CSCGEMMotherboard::gemGeometryAvailable

protected

Definition at line 213 of file CSCGEMMotherboard.h.

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

unsigned CSCGEMMotherboard::gemId

protected

Chamber id (trigger-type labels).

Definition at line 210 of file CSCGEMMotherboard.h.

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

int CSCGEMMotherboard::maxDeltaBXCoPad_

protected

Definition at line 223 of file CSCGEMMotherboard.h.

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

int CSCGEMMotherboard::maxDeltaBXPad_

protected

Definition at line 222 of file CSCGEMMotherboard.h.

Referenced by getMaxDeltaBX(), and retrieveGEMPads().

int CSCGEMMotherboard::maxDeltaPadL1_

protected

Definition at line 224 of file CSCGEMMotherboard.h.

Referenced by CSCGEMMotherboard(), and matchingPads().

int CSCGEMMotherboard::maxDeltaPadL2_

protected

Definition at line 225 of file CSCGEMMotherboard.h.

Referenced by CSCGEMMotherboard().

GEMPadDigiIdsBX CSCGEMMotherboard::pads_

protected

Definition at line 218 of file CSCGEMMotherboard.h.

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

bool CSCGEMMotherboard::promoteALCTGEMpattern_

protected

Definition at line 231 of file CSCGEMMotherboard.h.

Referenced by constructLCTsGEM().

bool CSCGEMMotherboard::promoteALCTGEMquality_

protected

Definition at line 233 of file CSCGEMMotherboard.h.

Referenced by constructLCTsGEM().

bool CSCGEMMotherboard::promoteCLCTGEMquality_

protected

Definition at line 234 of file CSCGEMMotherboard.h.

Referenced by constructLCTsGEM().

bool CSCGEMMotherboard::useOldLCTDataFormat_

protected

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