#include <CSCGEMMotherboard.h>

Inheritance diagram for CSCGEMMotherboard:

Public Types
typedef std::vector < GEMInternalCluster >	GEMInternalClusters

Public Member Functions
void	clear ()

std::shared_ptr < GEMClusterProcessor >	clusterProc () const

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

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

void	setGEMGeometry (const GEMGeometry *g)

	~CSCGEMMotherboard () override

Public Member Functions inherited from CSCMotherboard
void	clear ()

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

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

CSCShowerDigi	readoutShower () const

void	run (const CSCWireDigiCollection wiredc, const CSCComparatorDigiCollection compdc)

void	selectLCTs ()

void	setConfigParameters (const CSCDBL1TPParameters *conf)

void	setESLookupTables (const CSCL1TPLookupTableCCLUT *conf)

void	setESLookupTables (const CSCL1TPLookupTableME11ILT *conf)

void	setESLookupTables (const CSCL1TPLookupTableME21ILT *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

CSCDetId	id () const

void	setCSCGeometry (const CSCGeometry *g)

virtual	~CSCBaseboard ()=default

Private Member Functions
void	constructLCTsGEM (const CSCALCTDigi &alct, const CSCCLCTDigi &clct, const GEMInternalCluster &gem, CSCCorrelatedLCTDigi &lct) const

void	constructLCTsGEM (const CSCCLCTDigi &clct, const GEMInternalCluster &gem, int trackNumber, CSCCorrelatedLCTDigi &lct) const

void	constructLCTsGEM (const CSCALCTDigi &alct, const GEMInternalCluster &gem, int trackNumber, CSCCorrelatedLCTDigi &lct) const

void	correlateLCTsGEM (const CSCALCTDigi &bestALCT, const CSCALCTDigi &secondALCT, const CSCCLCTDigi &bestCLCT, const CSCCLCTDigi &secondCLCT, const GEMInternalClusters &clusters, CSCCorrelatedLCTDigi &lct1, CSCCorrelatedLCTDigi &lct2) const

void	correlateLCTsGEM (const CSCCLCTDigi &bestCLCT, const CSCCLCTDigi &secondCLCT, const GEMInternalClusters &clusters, CSCCorrelatedLCTDigi &lct1, CSCCorrelatedLCTDigi &lct2) const

void	correlateLCTsGEM (const CSCALCTDigi &bestALCT, const CSCALCTDigi &secondALCT, const GEMInternalClusters &clusters, CSCCorrelatedLCTDigi &lct1, CSCCorrelatedLCTDigi &lct2) const

void	dropLowQualityALCTNoClusters (CSCALCTDigi &alct, const GEMInternalCluster &cluster) const

void	dropLowQualityCLCTNoClusters (CSCCLCTDigi &clct, const GEMInternalCluster &cluster) const

void	matchALCT2GEM (bool bunch_crossing_mask[CSCConstants::MAX_ALCT_TBINS])

void	matchALCTCLCT (bool bunch_crossing_mask[CSCConstants::MAX_ALCT_TBINS])

void	matchALCTCLCTGEM (bool bunch_crossing_mask[CSCConstants::MAX_ALCT_TBINS])

void	matchCLCT2GEM (bool bunch_crossing_mask[CSCConstants::MAX_ALCT_TBINS])

void	sortLCTsByBending (std::vector< CSCCorrelatedLCTDigi > &lcts) const

Private Attributes
bool	assign_gem_csc_bending_

bool	build_lct_from_alct_clct_1gem_

bool	build_lct_from_alct_clct_2gem_

bool	build_lct_from_alct_gem_

bool	build_lct_from_clct_gem_

bool	build_lct_from_clct_gem_me1a_

std::shared_ptr < GEMClusterProcessor >	clusterProc_

std::map< int, GEMInternalClusters >	clusters_

std::unique_ptr< CSCGEMMatcher >	cscGEMMatcher_

bool	drop_low_quality_alct_no_gems_

bool	drop_low_quality_clct_no_gems_

bool	drop_low_quality_clct_no_gems_me1a_

bool	drop_used_gems_

const GEMGeometry *	gem_g

unsigned	gemId

bool	hasGE21Geometry16Partitions_

bool	match_earliest_gem_only_

unsigned	max_delta_bx_alct_gem_

unsigned	max_delta_bx_clct_gem_

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

std::unique_ptr < CSCCathodeLCTProcessor >	clctProc

Protected Member Functions inherited from CSCMotherboard
void	checkConfigParameters ()

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

void	copyValidToInValid (CSCALCTDigi &, CSCALCTDigi &, CSCCLCTDigi &, CSCCLCTDigi &) const

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

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

void	dumpConfigParams () const

void	encodeHighMultiplicityBits ()

unsigned int	encodePattern (const int clctPattern) const

CSCALCTDigi	getBXShiftedALCT (const CSCALCTDigi &) const

CSCCLCTDigi	getBXShiftedCLCT (const CSCCLCTDigi &) const

void	matchALCTCLCT (bool bunch_crossing_mask[CSCConstants::MAX_ALCT_TBINS])

Protected Member Functions inherited from CSCBaseboard
void	checkConfigParameters (unsigned int &var, const unsigned int var_max, const unsigned int var_def, const std::string &var_str)

Protected Attributes inherited from CSCMotherboard
unsigned int	alct_trig_enable

std::vector< CSCALCTDigi >	alctV

LCTContainer	allLCTs_

unsigned int	clct_trig_enable

std::vector< CSCCLCTDigi >	clctV

std::unique_ptr< CSCALCTCrossCLCT >	cscOverlap_

bool	drop_used_clcts

int	early_tbins

bool	ignoreAlctCrossClct_

std::vector< CSCCorrelatedLCTDigi >	lctV

const CSCL1TPLookupTableCCLUT *	lookupTableCCLUT_

const CSCL1TPLookupTableME11ILT *	lookupTableME11ILT_

const CSCL1TPLookupTableME21ILT *	lookupTableME21ILT_

bool	match_earliest_clct_only_

unsigned int	match_trig_enable

unsigned int	match_trig_window_size

unsigned int	mpc_block_me1a

std::vector< int >	preferred_bx_match_

std::unique_ptr < LCTQualityAssignment >	qualityAssignment_

std::unique_ptr < LCTQualityControl >	qualityControl_

bool	readout_earliest_2

CSCShowerDigi	shower_

unsigned	showerSource_

unsigned int	tmb_l1a_window_size

Protected Attributes inherited from CSCBaseboard
edm::ParameterSet	alctParams_

edm::ParameterSet	clctParams_

edm::ParameterSet	commonParams_

const CSCChamber *	cscChamber_

const CSCGeometry *	cscGeometry_

CSCDetId	cscId_

bool	disableME1a_

bool	enableAlctPhase2_

bool	gangedME1a_

int	infoV

bool	isME11_

bool	isME12_

bool	isME13_

bool	isME21_

bool	isME22_

bool	isME31_

bool	isME32_

bool	isME41_

bool	isME42_

bool	runCCLUT_

bool	runCCLUT_OTMB_

bool	runCCLUT_TMB_

bool	runME11ILT_

bool	runME11Up_

bool	runME21ILT_

bool	runME21Up_

bool	runME31Up_

bool	runME41Up_

bool	runPhase2_

edm::ParameterSet	showerParams_

unsigned	theChamber

std::string	theCSCName_

const unsigned	theEndcap

int	theRegion

unsigned	theRing

const unsigned	theSector

const unsigned	theStation

const unsigned	theSubsector

const unsigned	theTrigChamber

edm::ParameterSet	tmbParams_

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

static const unsigned int	def_clct_trig_enable = 0

static const unsigned int	def_match_trig_enable = 1

static const unsigned int	def_match_trig_window_size = 7

static const unsigned int	def_mpc_block_me1a = 1

static const unsigned int	def_tmb_l1a_window_size = 7

Detailed Description

Class for TMBs for the GEM-CSC integrated local trigger. Inherits from CSCMotherboard. Provides functionality to match ALCT/CLCT to GEM single clusters or coincidences of clusters

Author: Sven Dildick (Rice University)

Definition at line 19 of file CSCGEMMotherboard.h.

Member Typedef Documentation

typedef std::vector<GEMInternalCluster> CSCGEMMotherboard::GEMInternalClusters

Definition at line 21 of file CSCGEMMotherboard.h.

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 assign_gem_csc_bending_, build_lct_from_clct_gem_me1a_, clusterProc_, cscGEMMatcher_, drop_low_quality_clct_no_gems_me1a_, drop_used_gems_, gemId, edm::ParameterSet::getParameter(), CSCBaseboard::isME11_, CSCBaseboard::isME21_, match_earliest_gem_only_, max_delta_bx_alct_gem_, max_delta_bx_clct_gem_, CSCMotherboard::qualityAssignment_, DetId::rawId(), CSCBaseboard::runME11ILT_, CSCBaseboard::runME21ILT_, CSCBaseboard::theChamber, CSCBaseboard::theRegion, CSCBaseboard::theStation, and CSCBaseboard::tmbParams_.

     : CSCMotherboard(endcap, station, sector, subsector, chamber, conf),
       drop_low_quality_alct_no_gems_(tmbParams_.getParameter<bool>("dropLowQualityALCTsNoGEMs")),
       drop_low_quality_clct_no_gems_(tmbParams_.getParameter<bool>("dropLowQualityCLCTsNoGEMs")),
       build_lct_from_alct_clct_2gem_(tmbParams_.getParameter<bool>("buildLCTfromALCTCLCTand2GEM")),
       build_lct_from_alct_clct_1gem_(tmbParams_.getParameter<bool>("buildLCTfromALCTCLCTand1GEM")),
       build_lct_from_alct_gem_(tmbParams_.getParameter<bool>("buildLCTfromALCTandGEM")),
       build_lct_from_clct_gem_(tmbParams_.getParameter<bool>("buildLCTfromCLCTandGEM")) {
   // case for ME1/1
   if (isME11_) {
     drop_low_quality_clct_no_gems_me1a_ = tmbParams_.getParameter<bool>("dropLowQualityCLCTsNoGEMs_ME1a");
     build_lct_from_clct_gem_me1a_ = tmbParams_.getParameter<bool>("buildLCTfromCLCTandGEM_ME1a");
   }
 
   max_delta_bx_alct_gem_ = tmbParams_.getParameter<unsigned>("maxDeltaBXALCTGEM");
   max_delta_bx_clct_gem_ = tmbParams_.getParameter<unsigned>("maxDeltaBXCLCTGEM");
 
   assign_gem_csc_bending_ = tmbParams_.getParameter<bool>("assignGEMCSCBending");
   qualityAssignment_->setGEMCSCBending(assign_gem_csc_bending_);
 
   drop_used_gems_ = tmbParams_.getParameter<bool>("tmbDropUsedGems");
   match_earliest_gem_only_ = tmbParams_.getParameter<bool>("matchEarliestGemsOnly");
 
   // These LogErrors are sanity checks and should not be printed
   if (isME11_ and !runME11ILT_) {
     edm::LogError("CSCGEMMotherboard") << "TMB constructed while runME11ILT_ is not set!";
   };
 
   if (isME21_ and !runME21ILT_) {
     edm::LogError("CSCGEMMotherboard") << "TMB constructed while runME21ILT_ is not set!";
   };
 
   // super chamber has layer=0!
   gemId = GEMDetId(theRegion, 1, theStation, 0, theChamber, 0).rawId();
 
   clusterProc_ = std::make_shared<GEMClusterProcessor>(theRegion, theStation, theChamber, conf);
 
   cscGEMMatcher_ = std::make_unique<CSCGEMMatcher>(theRegion, theStation, theChamber, tmbParams_, conf);
 }

CSCGEMMotherboard::~CSCGEMMotherboard ( )

override

Definition at line 49 of file CSCGEMMotherboard.cc.

49 {}

Member Function Documentation

void CSCGEMMotherboard::clear ( void )

Definition at line 51 of file CSCGEMMotherboard.cc.

References CSCMotherboard::clear(), and clusterProc_.

Referenced by run().

                               {
   CSCMotherboard::clear();
   clusterProc_->clear();
 }

std::shared_ptr<GEMClusterProcessor> CSCGEMMotherboard::clusterProc ( ) const

inline

Definition at line 50 of file CSCGEMMotherboard.h.

References clusterProc_.

Referenced by CSCTriggerPrimitivesBuilder::build().

50 { return clusterProc_; }

CSCGEMMotherboard::clusterProc_

std::shared_ptr< GEMClusterProcessor > clusterProc_

Definition: CSCGEMMotherboard.h:140

void CSCGEMMotherboard::constructLCTsGEM	(	const CSCALCTDigi &	alct,
		const CSCCLCTDigi &	clct,
		const GEMInternalCluster &	gem,
		CSCCorrelatedLCTDigi &	lct
	)		const

private

Definition at line 485 of file CSCGEMMotherboard.cc.

Referenced by correlateLCTsGEM().

                                                                               {
   thisLCT.setValid(true);
   if (gem.isCoincidence()) {
     thisLCT.setType(CSCCorrelatedLCTDigi::ALCTCLCT2GEM);
   } else if (gem.isValid()) {
     thisLCT.setType(CSCCorrelatedLCTDigi::ALCTCLCTGEM);
   } else {
     thisLCT.setType(CSCCorrelatedLCTDigi::ALCTCLCT);
   }
   thisLCT.setQuality(qualityAssignment_->findQuality(alct, clct, gem));
   thisLCT.setALCT(getBXShiftedALCT(alct));
   thisLCT.setCLCT(getBXShiftedCLCT(clct));
   // set pads if there are any
   thisLCT.setGEM1(gem.mid1());
   thisLCT.setGEM2(gem.mid2());
   thisLCT.setPattern(encodePattern(clct.getPattern()));
   thisLCT.setMPCLink(0);
   thisLCT.setBX0(0);
   thisLCT.setSyncErr(0);
   thisLCT.setCSCID(theTrigChamber);
   // track number to be set later in final sorting stage
   thisLCT.setTrknmb(0);
   thisLCT.setWireGroup(alct.getKeyWG());
   thisLCT.setStrip(clct.getKeyStrip());
   thisLCT.setBend(clct.getBend());
   thisLCT.setBX(alct.getBX());
   if (runCCLUT_) {
     thisLCT.setRun3(true);
     if (assign_gem_csc_bending_)
       thisLCT.setSlope(cscGEMMatcher_->calculateGEMCSCBending(clct, gem));
     else
       thisLCT.setSlope(clct.getSlope());
     thisLCT.setQuartStripBit(clct.getQuartStripBit());
     thisLCT.setEighthStripBit(clct.getEighthStripBit());
     thisLCT.setRun3Pattern(clct.getRun3Pattern());
   }
 }

void CSCGEMMotherboard::constructLCTsGEM	(	const CSCCLCTDigi &	clct,
		const GEMInternalCluster &	gem,
		int	trackNumber,
		CSCCorrelatedLCTDigi &	lct
	)		const

private

Definition at line 527 of file CSCGEMMotherboard.cc.

                                                                               {
   thisLCT.setValid(true);
   thisLCT.setType(CSCCorrelatedLCTDigi::CLCT2GEM);
   thisLCT.setQuality(qualityAssignment_->findQuality(clct, gem));
   thisLCT.setCLCT(getBXShiftedCLCT(clct));
   thisLCT.setGEM1(gem.mid1());
   thisLCT.setGEM2(gem.mid2());
   thisLCT.setPattern(encodePattern(clct.getPattern()));
   thisLCT.setMPCLink(0);
   thisLCT.setBX0(0);
   thisLCT.setSyncErr(0);
   thisLCT.setCSCID(theTrigChamber);
   thisLCT.setTrknmb(trackNumber);
   thisLCT.setWireGroup(gem.getKeyWG());
   thisLCT.setStrip(clct.getKeyStrip());
   thisLCT.setBend(clct.getBend());
   thisLCT.setBX(gem.bx());
   if (runCCLUT_) {
     thisLCT.setRun3(true);
     if (assign_gem_csc_bending_)
       thisLCT.setSlope(cscGEMMatcher_->calculateGEMCSCBending(clct, gem));
     else
       thisLCT.setSlope(clct.getSlope());
     thisLCT.setQuartStripBit(clct.getQuartStripBit());
     thisLCT.setEighthStripBit(clct.getEighthStripBit());
     thisLCT.setRun3Pattern(clct.getRun3Pattern());
   }
 }

void CSCGEMMotherboard::constructLCTsGEM	(	const CSCALCTDigi &	alct,
		const GEMInternalCluster &	gem,
		int	trackNumber,
		CSCCorrelatedLCTDigi &	lct
	)		const

private

Definition at line 560 of file CSCGEMMotherboard.cc.

                                                                               {
   thisLCT.setValid(true);
   thisLCT.setType(CSCCorrelatedLCTDigi::ALCT2GEM);
   thisLCT.setQuality(qualityAssignment_->findQuality(alct, gem));
   thisLCT.setALCT(getBXShiftedALCT(alct));
   thisLCT.setGEM1(gem.mid1());
   thisLCT.setGEM2(gem.mid2());
   thisLCT.setPattern(10);
   thisLCT.setMPCLink(0);
   thisLCT.setBX0(0);
   thisLCT.setSyncErr(0);
   thisLCT.setCSCID(theTrigChamber);
   thisLCT.setTrknmb(trackNumber);
   thisLCT.setWireGroup(alct.getKeyWG());
   thisLCT.setStrip(gem.getKeyStrip());
   thisLCT.setBend(0);
   thisLCT.setBX(alct.getBX());
   if (runCCLUT_) {
     thisLCT.setRun3(true);
     thisLCT.setSlope(0);
     thisLCT.setQuartStripBit(false);
     thisLCT.setEighthStripBit(false);
     // ALCT-2GEM type LCTs do not bend in the chamber
     thisLCT.setRun3Pattern(4);
   }
 }

void CSCGEMMotherboard::correlateLCTsGEM	(	const CSCALCTDigi &	bestALCT,
		const CSCALCTDigi &	secondALCT,
		const CSCCLCTDigi &	bestCLCT,
		const CSCCLCTDigi &	secondCLCT,
		const GEMInternalClusters &	clusters,
		CSCCorrelatedLCTDigi &	lct1,
		CSCCorrelatedLCTDigi &	lct2
	)		const

private

Definition at line 307 of file CSCGEMMotherboard.cc.

References constructLCTsGEM(), CSCMotherboard::copyValidToInValid(), cscGEMMatcher_, dropLowQualityALCTNoClusters(), dropLowQualityCLCTNoClusters(), CSCALCTDigi::isValid(), sistrip::SpyUtilities::isValid(), CSCCLCTDigi::isValid(), CSCConstants::MAX_LCTS_PER_CSC, CSCCorrelatedLCTDigi::setTrknmb(), and sortLCTsByBending().

Referenced by matchALCT2GEM(), matchALCTCLCTGEM(), and matchCLCT2GEM().

                                                                            {
   // case where there no valid clusters
   if (clusters.empty())
     return;
 
   // temporary container
   std::vector<CSCCorrelatedLCTDigi> lcts;
 
   CSCALCTDigi bestALCT = bALCT;
   CSCALCTDigi secondALCT = sALCT;
   CSCCLCTDigi bestCLCT = bCLCT;
   CSCCLCTDigi secondCLCT = sCLCT;
 
   // Sanity checks on the ALCT and CLCT
   if (!bestALCT.isValid()) {
     edm::LogError("CSCGEMMotherboard") << "Best ALCT invalid in correlateLCTsGEM!";
     return;
   }
 
   if (!bestCLCT.isValid()) {
     edm::LogError("CSCGEMMotherboard") << "Best CLCT invalid in correlateLCTsGEM!";
     return;
   }
 
   // at this point, we have at least one valid cluster, and we're either dealing
   // wit GE1/1 or GE2/1 with 16 partitions, both are OK for GEM-CSC trigger
 
   // before matching ALCT-CLCT pairs with clusters, we check if we need
   // to drop particular low quality ALCTs or CLCTs without matching clusters
   // drop low quality CLCTs if no clusters and flags are set
   GEMInternalCluster bestALCTCluster, secondALCTCluster;
   GEMInternalCluster bestCLCTCluster, secondCLCTCluster;
   cscGEMMatcher_->bestClusterBXLoc(bestALCT, clusters, bestALCTCluster);
   cscGEMMatcher_->bestClusterBXLoc(secondALCT, clusters, secondALCTCluster);
   cscGEMMatcher_->bestClusterBXLoc(bestCLCT, clusters, bestCLCTCluster);
   cscGEMMatcher_->bestClusterBXLoc(secondCLCT, clusters, secondCLCTCluster);
 
   dropLowQualityALCTNoClusters(bestALCT, bestALCTCluster);
   dropLowQualityALCTNoClusters(secondALCT, secondALCTCluster);
   dropLowQualityCLCTNoClusters(bestCLCT, bestCLCTCluster);
   dropLowQualityCLCTNoClusters(secondCLCT, secondCLCTCluster);
 
   // check which ALCTs and CLCTs are valid after dropping the low-quality ones
   copyValidToInValid(bestALCT, secondALCT, bestCLCT, secondCLCT);
 
   // We can now check possible triplets and construct all LCTs with
   // valid ALCT, valid CLCTs and coincidence clusters
   GEMInternalCluster bbCluster, bsCluster, sbCluster, ssCluster;
   cscGEMMatcher_->bestClusterBXLoc(bestALCT, bestCLCT, clusters, bbCluster);
   cscGEMMatcher_->bestClusterBXLoc(bestALCT, secondCLCT, clusters, bsCluster);
   cscGEMMatcher_->bestClusterBXLoc(secondALCT, bestCLCT, clusters, sbCluster);
   cscGEMMatcher_->bestClusterBXLoc(secondALCT, secondCLCT, clusters, ssCluster);
 
   // At this point it is still possible that certain pairs with high-quality
   // ALCTs and CLCTs do not have matching clusters. In that case we construct
   // a regular ALCT-CLCT type LCT. For instance, it could be that two muons went
   // through the chamber, produced 2 ALCTs, 2 CLCTs, but only 1 GEM cluster - because
   // GEM cluster efficiency is not 100% (closer to 95%). So we don't require
   // all clusters to be valid. If they are valid, the LCTs is constructed accordingly.
   // But we do require that the ALCT and CLCT are valid for each pair.
   CSCCorrelatedLCTDigi lctbb, lctbs, lctsb, lctss;
   if (bestALCT.isValid() and bestCLCT.isValid()) {
     constructLCTsGEM(bestALCT, bestCLCT, bbCluster, lctbb);
     lcts.push_back(lctbb);
   }
   if (bestALCT.isValid() and secondCLCT.isValid() and (secondCLCT != bestCLCT)) {
     constructLCTsGEM(bestALCT, secondCLCT, bsCluster, lctbs);
     lcts.push_back(lctbs);
   }
   if (bestCLCT.isValid() and secondALCT.isValid() and (secondALCT != bestALCT)) {
     constructLCTsGEM(secondALCT, bestCLCT, sbCluster, lctsb);
     lcts.push_back(lctsb);
   }
   if (secondALCT.isValid() and secondCLCT.isValid() and (secondALCT != bestALCT) and (secondCLCT != bestCLCT)) {
     constructLCTsGEM(secondALCT, secondCLCT, ssCluster, lctss);
     lcts.push_back(lctss);
   }
 
   // no LCTs
   if (lcts.empty())
     return;
 
   // sort by bending angle
   sortLCTsByBending(lcts);
 
   // retain best two
   lcts.resize(CSCConstants::MAX_LCTS_PER_CSC);
 
   // assign the track number
   if (lcts[0].isValid()) {
     lct1 = lcts[0];
     lct1.setTrknmb(1);
   }
 
   if (lcts[1].isValid()) {
     lct2 = lcts[1];
     lct2.setTrknmb(2);
   }
 }

void CSCGEMMotherboard::correlateLCTsGEM	(	const CSCCLCTDigi &	bestCLCT,
		const CSCCLCTDigi &	secondCLCT,
		const GEMInternalClusters &	clusters,
		CSCCorrelatedLCTDigi &	lct1,
		CSCCorrelatedLCTDigi &	lct2
	)		const

private

Definition at line 413 of file CSCGEMMotherboard.cc.

References CSCCLCTDigi::clear(), constructLCTsGEM(), cscGEMMatcher_, dropLowQualityCLCTNoClusters(), GEMInternalCluster::isCoincidence(), and CSCCLCTDigi::isValid().

                                                                            {
   CSCCLCTDigi bestCLCT = bCLCT;
   CSCCLCTDigi secondCLCT = sCLCT;
 
   if (!bestCLCT.isValid()) {
     edm::LogError("CSCGEMMotherboard") << "Best CLCT invalid in correlateLCTsGEM!";
     return;
   }
 
   // if the second best CLCT equals the best CLCT, clear it
   if (secondCLCT == bestCLCT)
     secondCLCT.clear();
 
   // get the best matching cluster
   GEMInternalCluster bestCluster;
   GEMInternalCluster secondCluster;
   cscGEMMatcher_->bestClusterBXLoc(bestCLCT, clusters, bestCluster);
   cscGEMMatcher_->bestClusterBXLoc(secondCLCT, clusters, secondCluster);
 
   // drop low quality CLCTs if no clusters and flags are set
   dropLowQualityCLCTNoClusters(bestCLCT, bestCluster);
   dropLowQualityCLCTNoClusters(secondCLCT, secondCluster);
 
   // construct all LCTs with valid CLCTs and coincidence clusters
   if (bestCLCT.isValid() and bestCluster.isCoincidence()) {
     constructLCTsGEM(bestCLCT, bestCluster, 1, lct1);
   }
   if (secondCLCT.isValid() and secondCluster.isCoincidence()) {
     constructLCTsGEM(secondCLCT, secondCluster, 2, lct2);
   }
 }

void CSCGEMMotherboard::correlateLCTsGEM	(	const CSCALCTDigi &	bestALCT,
		const CSCALCTDigi &	secondALCT,
		const GEMInternalClusters &	clusters,
		CSCCorrelatedLCTDigi &	lct1,
		CSCCorrelatedLCTDigi &	lct2
	)		const

private

Definition at line 449 of file CSCGEMMotherboard.cc.

References CSCALCTDigi::clear(), constructLCTsGEM(), cscGEMMatcher_, dropLowQualityALCTNoClusters(), GEMInternalCluster::isCoincidence(), and CSCALCTDigi::isValid().

                                                                            {
   CSCALCTDigi bestALCT = bALCT;
   CSCALCTDigi secondALCT = sALCT;
 
   if (!bestALCT.isValid()) {
     edm::LogError("CSCGEMMotherboard") << "Best ALCT invalid in correlateLCTsGEM!";
     return;
   }
 
   // if the second best ALCT equals the best ALCT, clear it
   if (secondALCT == bestALCT)
     secondALCT.clear();
 
   // get the best matching cluster
   GEMInternalCluster bestCluster;
   GEMInternalCluster secondCluster;
   cscGEMMatcher_->bestClusterBXLoc(bestALCT, clusters, bestCluster);
   cscGEMMatcher_->bestClusterBXLoc(secondALCT, clusters, secondCluster);
 
   // drop low quality ALCTs if no clusters and flags are set
   dropLowQualityALCTNoClusters(bestALCT, bestCluster);
   dropLowQualityALCTNoClusters(secondALCT, secondCluster);
 
   // construct all LCTs with valid ALCTs and coincidence clusters
   if (bestALCT.isValid() and bestCluster.isCoincidence()) {
     constructLCTsGEM(bestALCT, bestCluster, 1, lct1);
   }
   if (secondALCT.isValid() and secondCluster.isCoincidence()) {
     constructLCTsGEM(secondALCT, secondCluster, 2, lct2);
   }
 }

void CSCGEMMotherboard::dropLowQualityALCTNoClusters	(	CSCALCTDigi &	alct,
		const GEMInternalCluster &	cluster
	)		const

private

Definition at line 590 of file CSCGEMMotherboard.cc.

References CSCALCTDigi::clear(), drop_low_quality_alct_no_gems_, CSCALCTDigi::getQuality(), and GEMInternalCluster::isValid().

Referenced by correlateLCTsGEM().

                                                                                                                {
   // clear alct if they are of low quality without matching GEM clusters
   if (alct.getQuality() == 0 and !cluster.isValid() and drop_low_quality_alct_no_gems_)
     alct.clear();
 }

void CSCGEMMotherboard::dropLowQualityCLCTNoClusters	(	CSCCLCTDigi &	clct,
		const GEMInternalCluster &	cluster
	)		const

private

Definition at line 596 of file CSCGEMMotherboard.cc.

References CSCCLCTDigi::clear(), drop_low_quality_clct_no_gems_, drop_low_quality_clct_no_gems_me1a_, CSCCLCTDigi::getKeyStrip(), CSCCLCTDigi::getQuality(), CSCBaseboard::isME11_, GEMInternalCluster::isValid(), and CSCConstants::MAX_HALF_STRIP_ME1B.

Referenced by correlateLCTsGEM().

                                                                                                                {
   // Here, we need to check which could be an ME1/a LCT
   bool dropLQCLCTNoGEMs = drop_low_quality_clct_no_gems_;
   if (isME11_ and clct.getKeyStrip() > CSCConstants::MAX_HALF_STRIP_ME1B)
     dropLQCLCTNoGEMs = drop_low_quality_clct_no_gems_me1a_;
 
   // clear clct if they are of low quality without matching GEM clusters
   if (clct.getQuality() <= 3 and !cluster.isValid() and dropLQCLCTNoGEMs)
     clct.clear();
 }

void CSCGEMMotherboard::matchALCT2GEM ( bool bunch_crossing_mask[CSCConstants::MAX_ALCT_TBINS] )

private

Definition at line 255 of file CSCGEMMotherboard.cc.

References CSCMotherboard::alctProc, CSCMotherboard::allLCTs_, clusterProc_, correlateLCTsGEM(), drop_used_gems_, hasGE21Geometry16Partitions_, CSCBaseboard::isME21_, match_earliest_gem_only_, CSCConstants::MAX_ALCT_TBINS, max_delta_bx_alct_gem_, and CSCMotherboard::preferred_bx_match_.

Referenced by run().

                                                                                           {
   // no matching is done for GE2/1 geometries with 8 eta partitions
   // this has been superseded by 16-eta partition geometries
   if (isME21_ and !hasGE21Geometry16Partitions_)
     return;
 
   // clear the array to mask GEMs  this window is quite wide.
   // We don't expect GEM coincidence clusters to show up too far
   // from the central BX (8)
   bool used_gem_mask[CSCConstants::MAX_ALCT_TBINS] = {false};
 
   for (int bx_alct = 0; bx_alct < CSCConstants::MAX_ALCT_TBINS; bx_alct++) {
     // do not consider LCT building in this BX if the mask was set
     if (bunch_crossing_mask[bx_alct])
       continue;
 
     if (alctProc->getBestALCT(bx_alct).isValid()) {
       for (unsigned mbx = 0; mbx < 2 * max_delta_bx_alct_gem_ + 1; mbx++) {
         // evaluate the preffered GEM BX
         int bx_gem = bx_alct + preferred_bx_match_[mbx];
 
         if (bx_gem < 0 or bx_gem >= CSCConstants::MAX_ALCT_TBINS)
           continue;
         // drop GEMs in this BX if one of them was previously matched to an ALCT
         if (drop_used_gems_ and used_gem_mask[bx_gem])
           continue;
         // check for at least one valid GEM cluster
         if (!clusterProc_->getCoincidenceClusters(bx_gem).empty()) {
           // now correlate the ALCT and GEM into LCT.
           // smaller mbx means more preferred!
           correlateLCTsGEM(alctProc->getBestALCT(bx_alct),
                            alctProc->getSecondALCT(bx_alct),
                            clusterProc_->getCoincidenceClusters(bx_gem),
                            allLCTs_(bx_alct, mbx, 0),
                            allLCTs_(bx_alct, mbx, 1));
 
           if (allLCTs_(bx_alct, mbx, 0).isValid()) {
             // do not consider GEM clusters
             used_gem_mask[bx_gem] = true;
             // mask this bunch crossing for future consideration
             bunch_crossing_mask[bx_alct] = true;
             // if we only consider the first valid GEM coincidence clusters,
             // we move on to the next ALCT immediately
             if (match_earliest_gem_only_)
               break;
           }
         }
       }
     }
   }
 }

void CSCGEMMotherboard::matchALCTCLCT ( bool bunch_crossing_mask[CSCConstants::MAX_ALCT_TBINS] )

private

void CSCGEMMotherboard::matchALCTCLCTGEM ( bool bunch_crossing_mask[CSCConstants::MAX_ALCT_TBINS] )

private

Definition at line 138 of file CSCGEMMotherboard.cc.

References CSCConstants::ALCT_CLCT_OFFSET, CSCMotherboard::alctProc, GEMClusterProcessor::AllClusters, CSCMotherboard::allLCTs_, build_lct_from_alct_clct_2gem_, CSCMotherboard::clctProc, clusterProc_, correlateLCTsGEM(), CSCMotherboard::drop_used_clcts, hasGE21Geometry16Partitions_, CSCBaseboard::isME21_, LogTrace, CSCMotherboard::match_earliest_clct_only_, CSCMotherboard::match_trig_window_size, CSCConstants::MAX_ALCT_TBINS, CSCConstants::MAX_CLCT_TBINS, max_delta_bx_alct_gem_, CSCMotherboard::preferred_bx_match_, and GEMClusterProcessor::SingleClusters.

Referenced by run().

                                                                                              {
   // no matching is done for GE2/1 geometries with 8 eta partitions
   // this has been superseded by 16-eta partition geometries
   if (isME21_ and !hasGE21Geometry16Partitions_)
     return;
 
   // by default we will try to match with both single clusters and coincidence clusters
   // if we do not build ALCT-CLCT-2GEM type LCTs, consider only single clusters
   GEMClusterProcessor::ClusterTypes option = GEMClusterProcessor::AllClusters;
   if (!build_lct_from_alct_clct_2gem_)
     option = GEMClusterProcessor::SingleClusters;
 
   // array to mask CLCTs
   bool used_clct_mask[CSCConstants::MAX_CLCT_TBINS] = {false};
 
   for (int bx_alct = 0; bx_alct < CSCConstants::MAX_ALCT_TBINS; bx_alct++) {
     // do not consider invalid ALCTs
     if (alctProc->getBestALCT(bx_alct).isValid()) {
       for (unsigned mbx = 0; mbx < match_trig_window_size; mbx++) {
         // evaluate the preffered CLCT BX, taking into account that there is an offset in the simulation
         unsigned bx_clct = bx_alct + preferred_bx_match_[mbx] - CSCConstants::ALCT_CLCT_OFFSET;
 
         // CLCT BX must be in the time window
         if (bx_clct >= CSCConstants::MAX_CLCT_TBINS)
           continue;
         // drop this CLCT if it was previously matched to an ALCT
         if (drop_used_clcts and used_clct_mask[bx_clct])
           continue;
         // do not consider invalid CLCTs
         if (clctProc->getBestCLCT(bx_clct).isValid()) {
           LogTrace("CSCMotherboard") << "Successful ALCT-CLCT match: bx_alct = " << bx_alct << "; bx_clct = " << bx_clct
                                      << "; mbx = " << mbx;
 
           // now correlate the ALCT and CLCT into LCT.
           // smaller mbx means more preferred!
           correlateLCTsGEM(alctProc->getBestALCT(bx_alct),
                            alctProc->getSecondALCT(bx_alct),
                            clctProc->getBestCLCT(bx_clct),
                            clctProc->getSecondCLCT(bx_clct),
                            clusterProc_->getClusters(bx_alct, max_delta_bx_alct_gem_, option),
                            allLCTs_(bx_alct, mbx, 0),
                            allLCTs_(bx_alct, mbx, 1));
 
           if (allLCTs_(bx_alct, mbx, 0).isValid()) {
             // mask this CLCT as used. If a flag is set, the CLCT may or may not be reused
             used_clct_mask[bx_clct] = true;
             // mask this bunch crossing for future considation
             bunch_crossing_mask[bx_alct] = true;
             // if we only consider the first valid CLCT, we move on to the next ALCT immediately
             if (match_earliest_clct_only_)
               break;
           }
         }
       }
     }
   }
 }

void CSCGEMMotherboard::matchCLCT2GEM ( bool bunch_crossing_mask[CSCConstants::MAX_ALCT_TBINS] )

private

Definition at line 196 of file CSCGEMMotherboard.cc.

References CSCConstants::ALCT_CLCT_OFFSET, CSCMotherboard::allLCTs_, build_lct_from_clct_gem_me1a_, CSCMotherboard::clctProc, clusterProc_, correlateLCTsGEM(), CSCMotherboard::drop_used_clcts, hasGE21Geometry16Partitions_, CSCBaseboard::isME11_, CSCBaseboard::isME21_, CSCMotherboard::match_earliest_clct_only_, CSCConstants::MAX_ALCT_TBINS, CSCConstants::MAX_CLCT_TBINS, max_delta_bx_clct_gem_, CSCConstants::MAX_HALF_STRIP_ME1B, and CSCMotherboard::preferred_bx_match_.

Referenced by run().

                                                                                           {
   // no matching is done for GE2/1 geometries with 8 eta partitions
   // this has been superseded by 16-eta partition geometries
   if (isME21_ and !hasGE21Geometry16Partitions_)
     return;
 
   // array to mask CLCTs
   bool used_clct_mask[CSCConstants::MAX_CLCT_TBINS] = {false};
 
   for (int bx_gem = 0; bx_gem < CSCConstants::MAX_ALCT_TBINS; bx_gem++) {
     // do not consider LCT building in this BX if the mask was set
     if (bunch_crossing_mask[bx_gem])
       continue;
 
     // Check that there is at least one valid GEM coincidence cluster in this BX
     if (!clusterProc_->getCoincidenceClusters(bx_gem).empty()) {
       // GEM clusters will have central BX 8. So do ALCTs. But! CLCTs still have central BX 7
       // therefore we need to make a correction. The correction is thus the same as for ALCT-CLCT
       for (unsigned mbx = 0; mbx < 2 * max_delta_bx_clct_gem_ + 1; mbx++) {
         // evaluate the preffered CLCT BX, taking into account that there is an offset in the simulation
         int bx_clct = bx_gem + preferred_bx_match_[mbx] - CSCConstants::ALCT_CLCT_OFFSET;
 
         // CLCT BX must be in the time window
         if (bx_clct < 0 or bx_clct >= CSCConstants::MAX_CLCT_TBINS)
           continue;
         // drop this CLCT if it was previously matched to a GEM coincidence cluster
         if (drop_used_clcts and used_clct_mask[bx_clct])
           continue;
         // do not consider invalid CLCTs
         if (clctProc->getBestCLCT(bx_clct).isValid()) {
           // if this is an ME1/a CLCT, you could consider not building this LCT
           if (!build_lct_from_clct_gem_me1a_ and isME11_ and
               clctProc->getBestCLCT(bx_clct).getKeyStrip() > CSCConstants::MAX_HALF_STRIP_ME1B)
             continue;
           // mbx is a relative time difference, which is used later in the
           // cross-bunching sorting algorithm to determine the preferred LCTs
           // to be sent to the MPC
           correlateLCTsGEM(clctProc->getBestCLCT(bx_clct),
                            clctProc->getSecondCLCT(bx_clct),
                            clusterProc_->getCoincidenceClusters(bx_gem),
                            allLCTs_(bx_gem, mbx, 0),
                            allLCTs_(bx_gem, mbx, 1));
 
           if (allLCTs_(bx_gem, mbx, 0).isValid()) {
             // do not consider GEM clusters
             used_clct_mask[bx_clct] = true;
             // mask this bunch crossing for future consideration
             bunch_crossing_mask[bx_gem] = true;
             // if we only consider the first valid GEM coincidence clusters,
             // we move on to the next ALCT immediately
             if (match_earliest_clct_only_)
               break;
           }
         }
       }
     }
   }
 }

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

Definition at line 56 of file CSCGEMMotherboard.cc.

References CSCMotherboard::alctProc, CSCMotherboard::alctV, build_lct_from_alct_clct_1gem_, build_lct_from_alct_clct_2gem_, build_lct_from_alct_gem_, build_lct_from_clct_gem_, CSCMotherboard::clctProc, CSCMotherboard::clctV, clear(), clusterProc_, cscGEMMatcher_, CSCBaseboard::cscGeometry_, CSCMotherboard::encodeHighMultiplicityBits(), gem_g, hasGE21Geometry16Partitions_, CSCBaseboard::isME11_, CSCBaseboard::isME21_, CSCMotherboard::lookupTableCCLUT_, CSCMotherboard::lookupTableME11ILT_, CSCMotherboard::lookupTableME21ILT_, matchALCT2GEM(), CSCMotherboard::matchALCTCLCT(), matchALCTCLCTGEM(), matchCLCT2GEM(), CSCConstants::MAX_ALCT_TBINS, or, CSCBaseboard::runCCLUT_, and CSCMotherboard::selectLCTs().

Referenced by CSCTriggerPrimitivesBuilder::build().

                                                                             {
   // Step 1: Setup
   clear();
 
   // check for GEM geometry
   if (gem_g == nullptr) {
     edm::LogError("CSCGEMMotherboard") << "run() called for GEM-CSC integrated trigger without valid GEM geometry! \n";
     return;
   }
 
   // Check that the processors can deliver data
   if (!(alctProc and clctProc)) {
     edm::LogError("CSCGEMMotherboard") << "run() called for non-existing ALCT/CLCT processor! \n";
     return;
   }
 
   alctProc->setCSCGeometry(cscGeometry_);
   clctProc->setCSCGeometry(cscGeometry_);
 
   // set CCLUT parameters if necessary
   if (runCCLUT_) {
     clctProc->setESLookupTables(lookupTableCCLUT_);
   }
 
   // Step 2: Run the processors
   const std::vector<CSCALCTDigi>& alctV = alctProc->run(wiredc);  // run anodeLCT
   const std::vector<CSCCLCTDigi>& clctV = clctProc->run(compdc);  // run cathodeLCT
 
   // Step 2b: encode high multiplicity bits (independent of LCT construction)
   encodeHighMultiplicityBits();
 
   // if there are no ALCTs and no CLCTs, do not run the ALCT-CLCT correlation
   if (alctV.empty() and clctV.empty())
     return;
 
   // set the lookup tables for coordinate conversion and matching
   if (isME11_) {
     clusterProc_->setESLookupTables(lookupTableME11ILT_);
     cscGEMMatcher_->setESLookupTables(lookupTableME11ILT_);
   }
   if (isME21_) {
     clusterProc_->setESLookupTables(lookupTableME21ILT_);
     cscGEMMatcher_->setESLookupTables(lookupTableME21ILT_);
   }
 
   // Step 3: run the GEM cluster processor to get the internal clusters
   clusterProc_->run(gemClusters);
   hasGE21Geometry16Partitions_ = clusterProc_->hasGE21Geometry16Partitions();
 
   /*
     Mask for bunch crossings were LCTs were previously found
     If LCTs were found in BXi for ALCT-CLCT-2GEM or ALCT-CLCT-1GEM,
     we do not consider BXi in the future. This is
     because we consider ALCT-CLCT-2GEM > ALCT-CLCT-1GEM > ALCT-CLCT
     > CLCT-2GEM > ALCT-2GEM. The mask is passsed from one function to the next.
   */
   bool bunch_crossing_mask[CSCConstants::MAX_ALCT_TBINS] = {false};
 
   // Step 4: ALCT-CLCT-2GEM and ALCT-CLCT-1GEM matching
   if (build_lct_from_alct_clct_2gem_ or build_lct_from_alct_clct_1gem_) {
     matchALCTCLCTGEM(bunch_crossing_mask);
   }
 
   // Step 5: regular ALCT-CLCT matching (always enabled)
   CSCMotherboard::matchALCTCLCT(bunch_crossing_mask);
 
   // Step 6: CLCT-2GEM matching for BX's that were not previously masked
   if (build_lct_from_clct_gem_) {
     matchCLCT2GEM(bunch_crossing_mask);
   }
 
   // Step 7: ALCT-2GEM matching for BX's that were not previously masked
   if (build_lct_from_alct_gem_) {
     matchALCT2GEM(bunch_crossing_mask);
   }
 
   // Step 8: Select at most 2 LCTs per BX
   selectLCTs();
 }

void CSCGEMMotherboard::setGEMGeometry ( const GEMGeometry * g )

inline

Definition at line 53 of file CSCGEMMotherboard.h.

References g, and gem_g.

Referenced by CSCTriggerPrimitivesBuilder::build().

53 { 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:132

void CSCGEMMotherboard::sortLCTsByBending ( std::vector< CSCCorrelatedLCTDigi > & lcts ) const

private

Definition at line 607 of file CSCGEMMotherboard.cc.

References CSCCorrelatedLCTDigi::getQuality(), CSCCorrelatedLCTDigi::getSlope(), and CSCBaseboard::runCCLUT_.

Referenced by correlateLCTsGEM().

                                                                                      {
   /*
     For Run-2 GEM-CSC trigger primitives, which we temporarily have
     to integrate with the Run-2 EMTF during LS2, we sort by quality.
     Larger quality means smaller bending
   */
   if (!runCCLUT_) {
     std::sort(lcts.begin(), lcts.end(), [](const CSCCorrelatedLCTDigi& lct1, const CSCCorrelatedLCTDigi& lct2) -> bool {
       return lct1.getQuality() > lct2.getQuality();
     });
   }
 
   /*
     For Run-3 GEM-CSC trigger primitives, which we have
     to integrate with the Run-3 EMTF, we sort by slope.
     Smaller slope means smaller bending
   */
   else {
     std::sort(lcts.begin(), lcts.end(), [](const CSCCorrelatedLCTDigi& lct1, const CSCCorrelatedLCTDigi& lct2) -> bool {
       return lct1.getSlope() < lct2.getSlope();
     });
   }
 }