#include <CSCMotherboardME11GEM.h>

Inheritance diagram for CSCMotherboardME11GEM:

Public Types
enum	ME11Part { ME1B = 1, ME1A =4 }

Public Member Functions
void	clear ()

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

	CSCMotherboardME11GEM ()

std::vector< CSCALCTDigi >	getALCTs1b ()

std::vector< CSCCLCTDigi >	getCLCTs1a ()

std::vector< CSCCLCTDigi >	getCLCTs1b ()

std::vector< CSCCorrelatedLCTDigi >	getLCTs1a ()

std::vector< CSCCorrelatedLCTDigi >	getLCTs1b ()

std::vector< GEMCoPadDigi >	readoutCoPads ()

std::vector< CSCCorrelatedLCTDigi >	readoutLCTs (enum ME11Part me1ab)

std::vector< CSCCorrelatedLCTDigi >	readoutLCTs1a ()

std::vector< CSCCorrelatedLCTDigi >	readoutLCTs1b ()

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

void	setConfigParameters (const CSCDBL1TPParameters *conf)

void	setCSCGeometry (const CSCGeometry *g)
	set CSC and GEM geometries for the matching needs More...

void	setGEMGeometry (const GEMGeometry *g)

std::vector< CSCCorrelatedLCTDigi >	sortLCTsByGEMDPhi (int bx, enum ME11Part=ME1B)

std::vector< CSCCorrelatedLCTDigi >	sortLCTsByGEMDPhi (enum ME11Part=ME1B)

std::vector< CSCCorrelatedLCTDigi >	sortLCTsByGEMDPhi (std::vector< CSCCorrelatedLCTDigi >)

std::vector< CSCCorrelatedLCTDigi >	sortLCTsByQuality (int bx, enum ME11Part=ME1B)

std::vector< CSCCorrelatedLCTDigi >	sortLCTsByQuality (enum ME11Part=ME1B)

std::vector< CSCCorrelatedLCTDigi >	sortLCTsByQuality (std::vector< CSCCorrelatedLCTDigi >)

	~CSCMotherboardME11GEM ()

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

std::vector< CSCCorrelatedLCTDigi >	readoutLCTs ()

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)

	~CSCMotherboard ()

Public Attributes
std::unique_ptr < CSCCathodeLCTProcessor >	clct1a

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

std::unique_ptr < CSCCathodeLCTProcessor >	clct

Private Types
typedef std::pair< unsigned int, const GEMPadDigi >	GEMPadBX

typedef std::map< int, GEMPadsBX >	GEMPads

typedef std::vector< GEMPadBX >	GEMPadsBX

Private Member Functions
int	assignGEMRoll (double eta)

void	buildCoincidencePads (const GEMPadDigiCollection *out_pads, GEMCoPadDigiCollection &out_co_pads, CSCDetId csc_id)

CSCCorrelatedLCTDigi	constructLCTsGEM (const CSCALCTDigi &alct, const GEMPadDigi &gem, int me, bool oldDataFormat=false)

CSCCorrelatedLCTDigi	constructLCTsGEM (const CSCCLCTDigi &clct, const GEMPadDigi &gem, int roll, int me, bool oldDataFormat=true)

CSCCorrelatedLCTDigi	constructLCTsGEM (const CSCALCTDigi &alct, const CSCCLCTDigi &clct, bool hasPad, bool hasCoPad)

void	correlateLCTs (CSCALCTDigi bestALCT, CSCALCTDigi secondALCT, CSCCLCTDigi bestCLCT, CSCCLCTDigi secondCLCT, CSCCorrelatedLCTDigi &lct1, CSCCorrelatedLCTDigi &lct2)

void	correlateLCTsGEM (CSCALCTDigi bestALCT, CSCALCTDigi secondALCT, CSCCLCTDigi bestCLCT, CSCCLCTDigi secondCLCT, CSCCorrelatedLCTDigi &lct1, CSCCorrelatedLCTDigi &lct2, int me, const GEMPadsBX &pads=GEMPadsBX(), const GEMPadsBX &copads=GEMPadsBX())

void	correlateLCTsGEM (CSCALCTDigi bestALCT, CSCALCTDigi secondALCT, GEMPadDigi gemPad, CSCCorrelatedLCTDigi &lct1, CSCCorrelatedLCTDigi &lct2, int me)

void	correlateLCTsGEM (CSCCLCTDigi bestCLCT, CSCCLCTDigi secondCLCT, GEMPadDigi gemPad, int roll, CSCCorrelatedLCTDigi &lct1, CSCCorrelatedLCTDigi &lct2, int me)

void	createGEMRollEtaLUT (bool isEven)

int	deltaPad (int hs, int pad)

int	deltaRoll (int wg, int roll)

bool	doesALCTCrossCLCT (CSCALCTDigi &a, CSCCLCTDigi &c, int me)

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

unsigned int	findQualityGEM (const CSCALCTDigi &aLCT, const GEMPadDigi &gem)

unsigned int	findQualityGEM (const CSCCLCTDigi &cLCT, const GEMPadDigi &gem)

unsigned int	findQualityGEM (const CSCALCTDigi &aLCT, const CSCCLCTDigi &cLCT, bool hasPad, bool hasCoPad)

bool	isPadInOverlap (int roll)

GEMPadsBX	matchingGEMPads (const CSCCLCTDigi &cLCT, const GEMPadsBX &pads=GEMPadsBX(), enum ME11Part=ME1B, bool isCopad=false, bool first=true)

GEMPadsBX	matchingGEMPads (const CSCALCTDigi &aLCT, const GEMPadsBX &pads=GEMPadsBX(), enum ME11Part=ME1B, bool isCopad=false, bool first=true)

GEMPadsBX	matchingGEMPads (const CSCCLCTDigi &cLCT, const CSCALCTDigi &aLCT, const GEMPadsBX &pads=GEMPadsBX(), enum ME11Part=ME1B, bool isCopad=false, bool first=true)

void	printGEMTriggerPads (int minBX, int maxBx, bool iscopad=false)

void	retrieveGEMCoPads (const GEMCoPadDigiCollection *pads, unsigned id)

void	retrieveGEMPads (const GEMPadDigiCollection *pads, unsigned id)

Private Attributes
std::vector< CSCALCTDigi >	alctV

CSCCorrelatedLCTDigi	allLCTs1a [MAX_LCT_BINS][15][2]

CSCCorrelatedLCTDigi	allLCTs1b [MAX_LCT_BINS][15][2]

bool	buildLCTfromALCTandGEM_ME1a_

bool	buildLCTfromALCTandGEM_ME1b_

bool	buildLCTfromCLCTandGEM_ME1a_

bool	buildLCTfromCLCTandGEM_ME1b_

bool	clct_to_alct

std::vector< CSCCLCTDigi >	clctV1a

std::vector< CSCCLCTDigi >	clctV1b

GEMPads	coPads_

bool	correctLCTtimingWithGEM_

const CSCGeometry *	csc_g

std::map< int, std::pair< int, int > >	cscHsToGemPadME1a_

std::map< int, std::pair< int, int > >	cscHsToGemPadME1b_

std::map< int, std::pair< int, int > >	cscWgToGemRoll_

bool	debug_gem_dphi

bool	debug_gem_matching

bool	debug_luts

bool	disableME1a

bool	doLCTGhostBustingWithGEMs_

bool	drop_used_clcts

bool	dropLowQualityALCTsNoGEMs_ME1a_

bool	dropLowQualityALCTsNoGEMs_ME1b_

bool	dropLowQualityCLCTsNoGEMs_ME1a_

bool	dropLowQualityCLCTsNoGEMs_ME1b_

bool	firstTwoLCTsInChamber_

bool	gangedME1a

const GEMGeometry *	gem_g

std::vector< GEMCoPadDigi >	gemCoPadV

std::map< int, int >	gemPadToCscHsME1a_

std::map< int, int >	gemPadToCscHsME1b_

std::map< int, std::pair < double, double > >	gemRollToEtaLimits_

bool	match_earliest_alct_me11_only

bool	match_earliest_clct_me11_only

unsigned int	max_me11_lcts

int	maxDeltaBXCoPad_

int	maxDeltaBXCoPadEven_

int	maxDeltaBXCoPadOdd_

int	maxDeltaBXInCoPad_

int	maxDeltaBXPad_

int	maxDeltaBXPadEven_

int	maxDeltaBXPadOdd_

int	maxDeltaPadCoPad_

int	maxDeltaPadCoPadEven_

int	maxDeltaPadCoPadOdd_

int	maxDeltaPadInCoPad_

int	maxDeltaPadPad_

int	maxDeltaPadPadEven_

int	maxDeltaPadPadOdd_

GEMPads	pads_

int	pref [MAX_LCT_BINS]

bool	promoteALCTGEMpattern_

bool	promoteALCTGEMquality_

bool	promoteCLCTGEMquality_ME1a_

bool	promoteCLCTGEMquality_ME1b_

bool	runME11ILT_
	GEM-CSC integrated local algorithm. More...

bool	smartME1aME1b

unsigned int	tmb_cross_bx_algo

bool	useOldLCTDataFormat_

Static Private Attributes
static const double	lut_pt_vs_dphi_gemcsc [8][3]

static const double	lut_wg_etaMin_etaMax_even [48][3]

static const double	lut_wg_etaMin_etaMax_odd [48][3]

static const int	lut_wg_vs_hs_me1a [48][2]

static const int	lut_wg_vs_hs_me1ag [48][2]

static const int	lut_wg_vs_hs_me1b [48][2]

Additional Inherited Members
Protected Types inherited from CSCMotherboard
enum	{ MAX_LCT_BINS = 16 }

Protected Member Functions inherited from CSCMotherboard
void	checkConfigParameters ()

CSCCorrelatedLCTDigi	constructLCTs (const CSCALCTDigi &aLCT, const CSCCLCTDigi &cLCT)

void	correlateLCTs (CSCALCTDigi bestALCT, CSCALCTDigi secondALCT, CSCCLCTDigi bestCLCT, CSCCLCTDigi secondCLCT)

void	dumpConfigParams () const

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

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

void	testLCT ()

Static Protected Member Functions inherited from CSCMotherboard
static bool	sortByGEMDphi (const CSCCorrelatedLCTDigi &, const CSCCorrelatedLCTDigi &)

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

Protected Attributes inherited from CSCMotherboard
unsigned int	alct_trig_enable

unsigned int	clct_trig_enable

bool	drop_used_alcts

int	early_tbins

CSCCorrelatedLCTDigi	firstLCT [MAX_LCT_BINS]

int	infoV

bool	isMTCC

bool	isSLHC

bool	isTMB07

int	lct_central_bx

unsigned int	match_trig_enable

unsigned int	match_trig_window_size

unsigned int	mpc_block_me1a

bool	readout_earliest_2

CSCCorrelatedLCTDigi	secondLCT [MAX_LCT_BINS]

const unsigned	theEndcap

unsigned	theRing

const unsigned	theSector

const unsigned	theStation

const unsigned	theSubsector

const unsigned	theTrigChamber

unsigned int	tmb_l1a_window_size

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

static const unsigned int	def_clct_trig_enable = 0

static const unsigned int	def_match_trig_enable = 1

static const unsigned int	def_match_trig_window_size = 7

static const unsigned int	def_mpc_block_me1a = 1

static const unsigned int	def_tmb_l1a_window_size = 7

Detailed Description

Extended CSCMotherboard for ME11 TMB upgrade

Author: Sven Dildick March 2014

Based on CSCMotherboard code

Definition at line 23 of file CSCMotherboardME11GEM.h.

Member Typedef Documentation

typedef std::pair<unsigned int, const GEMPadDigi> CSCMotherboardME11GEM::GEMPadBX

private

Definition at line 25 of file CSCMotherboardME11GEM.h.

typedef std::map<int, GEMPadsBX> CSCMotherboardME11GEM::GEMPads

private

Definition at line 27 of file CSCMotherboardME11GEM.h.

typedef std::vector<GEMPadBX> CSCMotherboardME11GEM::GEMPadsBX

private

Definition at line 26 of file CSCMotherboardME11GEM.h.

Member Enumeration Documentation

enum CSCMotherboardME11GEM::ME11Part

labels for ME1a and ME1B

Enumerator
ME1B
ME1A

Definition at line 52 of file CSCMotherboardME11GEM.h.

52 {ME1B = 1, ME1A=4};

CSCMotherboardME11GEM::ME1A

Definition: CSCMotherboardME11GEM.h:52

CSCMotherboardME11GEM::ME1B

Definition: CSCMotherboardME11GEM.h:52

Constructor & Destructor Documentation

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

Normal constructor.

Definition at line 181 of file CSCMotherboardME11GEM.cc.

References buildLCTfromALCTandGEM_ME1a_, buildLCTfromALCTandGEM_ME1b_, buildLCTfromCLCTandGEM_ME1a_, buildLCTfromCLCTandGEM_ME1b_, clct1a, clct_to_alct, correctLCTtimingWithGEM_, debug_gem_dphi, debug_gem_matching, debug_luts, disableME1a, doLCTGhostBustingWithGEMs_, drop_used_clcts, dropLowQualityALCTsNoGEMs_ME1a_, dropLowQualityALCTsNoGEMs_ME1b_, dropLowQualityCLCTsNoGEMs_ME1a_, dropLowQualityCLCTsNoGEMs_ME1b_, firstTwoLCTsInChamber_, gangedME1a, edm::ParameterSet::getParameter(), CSCMotherboard::isSLHC, visualization-live-secondInstance_cfg::m, match_earliest_alct_me11_only, match_earliest_clct_me11_only, CSCMotherboard::match_trig_window_size, max_me11_lcts, maxDeltaBXCoPadEven_, maxDeltaBXCoPadOdd_, maxDeltaBXInCoPad_, maxDeltaBXPadEven_, maxDeltaBXPadOdd_, maxDeltaPadCoPadEven_, maxDeltaPadCoPadOdd_, maxDeltaPadInCoPad_, maxDeltaPadPadEven_, maxDeltaPadPadOdd_, pref, promoteALCTGEMpattern_, promoteALCTGEMquality_, promoteCLCTGEMquality_ME1a_, promoteCLCTGEMquality_ME1b_, runME11ILT_, smartME1aME1b, tmb_cross_bx_algo, and useOldLCTDataFormat_.

                                                 :
         CSCMotherboard(endcap, station, sector, subsector, chamber, conf)
 {
   const edm::ParameterSet commonParams(conf.getParameter<edm::ParameterSet>("commonParam"));
 
   // special configuration parameters for ME11 treatment
   smartME1aME1b = commonParams.getParameter<bool>("smartME1aME1b");
   disableME1a = commonParams.getParameter<bool>("disableME1a");
   gangedME1a = commonParams.getParameter<bool>("gangedME1a");
   runME11ILT_ = commonParams.getParameter<bool>("runME11ILT");
 
   if (!isSLHC) edm::LogError("L1CSCTPEmulatorConfigError")
     << "+++ Upgrade CSCMotherboardME11GEM constructed while isSLHC is not set! +++\n";
   if (!smartME1aME1b) edm::LogError("L1CSCTPEmulatorConfigError")
     << "+++ Upgrade CSCMotherboardME11GEM constructed while smartME1aME1b is not set! +++\n";
 
   const edm::ParameterSet alctParams(conf.getParameter<edm::ParameterSet>("alctSLHC"));
   const edm::ParameterSet clctParams(conf.getParameter<edm::ParameterSet>("clctSLHC"));
   const edm::ParameterSet me11tmbParams(conf.getParameter<edm::ParameterSet>("me11tmbSLHCGEM"));
 
   clct1a.reset( new CSCCathodeLCTProcessor(endcap, station, sector, subsector, chamber, clctParams, commonParams, me11tmbParams) );
   clct1a->setRing(4);
 
   match_earliest_alct_me11_only = me11tmbParams.getParameter<bool>("matchEarliestAlctME11Only");
   match_earliest_clct_me11_only = me11tmbParams.getParameter<bool>("matchEarliestClctME11Only");
 
   // if true: use regular CLCT-to-ALCT matching in TMB
   // if false: do ALCT-to-CLCT matching
   clct_to_alct = me11tmbParams.getParameter<bool>("clctToAlct");
 
   // whether to not reuse CLCTs that were used by previous matching ALCTs
   // in ALCT-to-CLCT algorithm
   drop_used_clcts = me11tmbParams.getParameter<bool>("tmbDropUsedClcts");
 
   tmb_cross_bx_algo = me11tmbParams.getParameter<unsigned int>("tmbCrossBxAlgorithm");
 
   // maximum lcts per BX in ME11: 2, 3, 4 or 999
   max_me11_lcts = me11tmbParams.getParameter<unsigned int>("maxME11LCTs");
 
   pref[0] = match_trig_window_size/2;
   for (unsigned int m=2; m<match_trig_window_size; m+=2)
   {
     pref[m-1] = pref[0] - m/2;
     pref[m]   = pref[0] + m/2;
   }
 
   //----------------------------------------------------------------------------------------//
 
   //       G E M  -  C S C   I N T E G R A T E D   L O C A L   A L G O R I T H M
 
   //----------------------------------------------------------------------------------------//
 
   // debug gem matching
   debug_gem_matching = me11tmbParams.getParameter<bool>("debugMatching");
   debug_luts = me11tmbParams.getParameter<bool>("debugLUTs");
   debug_gem_dphi = me11tmbParams.getParameter<bool>("debugGEMDphi");
 
   //  deltas used to construct GEM coincidence pads
   maxDeltaBXInCoPad_ = me11tmbParams.getParameter<int>("maxDeltaBXInCoPad");
   maxDeltaPadInCoPad_ = me11tmbParams.getParameter<int>("maxDeltaPadInCoPad");
 
   //  deltas used to match to GEM pads
   maxDeltaBXPadEven_ = me11tmbParams.getParameter<int>("maxDeltaBXPadEven");
   maxDeltaPadPadEven_ = me11tmbParams.getParameter<int>("maxDeltaPadPadEven");
   maxDeltaBXPadOdd_ = me11tmbParams.getParameter<int>("maxDeltaBXPadOdd");
   maxDeltaPadPadOdd_ = me11tmbParams.getParameter<int>("maxDeltaPadPadOdd");
 
   //  deltas used to match to GEM coincidence pads
   maxDeltaBXCoPadEven_ = me11tmbParams.getParameter<int>("maxDeltaBXCoPadEven");
   maxDeltaPadCoPadEven_ = me11tmbParams.getParameter<int>("maxDeltaPadCoPadEven");
   maxDeltaBXCoPadOdd_ = me11tmbParams.getParameter<int>("maxDeltaBXCoPadOdd");
   maxDeltaPadCoPadOdd_ = me11tmbParams.getParameter<int>("maxDeltaPadCoPadOdd");
 
   // drop low quality stubs if they don't have GEMs
   dropLowQualityCLCTsNoGEMs_ME1a_ = me11tmbParams.getParameter<bool>("dropLowQualityCLCTsNoGEMs_ME1a");
   dropLowQualityCLCTsNoGEMs_ME1b_ = me11tmbParams.getParameter<bool>("dropLowQualityCLCTsNoGEMs_ME1b");
   dropLowQualityALCTsNoGEMs_ME1a_ = me11tmbParams.getParameter<bool>("dropLowQualityALCTsNoGEMs_ME1a");
   dropLowQualityALCTsNoGEMs_ME1b_ = me11tmbParams.getParameter<bool>("dropLowQualityALCTsNoGEMs_ME1b");
 
   // build LCT from ALCT and GEM
   buildLCTfromALCTandGEM_ME1a_ = me11tmbParams.getParameter<bool>("buildLCTfromALCTandGEM_ME1a");
   buildLCTfromALCTandGEM_ME1b_ = me11tmbParams.getParameter<bool>("buildLCTfromALCTandGEM_ME1b");
   buildLCTfromCLCTandGEM_ME1a_ = me11tmbParams.getParameter<bool>("buildLCTfromCLCTandGEM_ME1a");
   buildLCTfromCLCTandGEM_ME1b_ = me11tmbParams.getParameter<bool>("buildLCTfromCLCTandGEM_ME1b");
 
   // LCT ghostbusting
   doLCTGhostBustingWithGEMs_ = me11tmbParams.getParameter<bool>("doLCTGhostBustingWithGEMs");
 
   // correct LCT timing with GEMs
   correctLCTtimingWithGEM_ = me11tmbParams.getParameter<bool>("correctLCTtimingWithGEM");
 
   // use "old" or "new" dataformat for integrated LCTs?
   useOldLCTDataFormat_ = me11tmbParams.getParameter<bool>("useOldLCTDataFormat");
 
   // promote ALCT-GEM pattern
   promoteALCTGEMpattern_ = me11tmbParams.getParameter<bool>("promoteALCTGEMpattern");
 
   // promote ALCT-GEM quality
   promoteALCTGEMquality_ = me11tmbParams.getParameter<bool>("promoteALCTGEMquality");
   promoteCLCTGEMquality_ME1a_ = me11tmbParams.getParameter<bool>("promoteCLCTGEMquality_ME1a");
   promoteCLCTGEMquality_ME1b_ = me11tmbParams.getParameter<bool>("promoteCLCTGEMquality_ME1b");
 
   // send first 2 LCTs
   firstTwoLCTsInChamber_ = me11tmbParams.getParameter<bool>("firstTwoLCTsInChamber");
 }

CSCMotherboardME11GEM::CSCMotherboardME11GEM ( )

Constructor for use during testing.

Definition at line 291 of file CSCMotherboardME11GEM.cc.

References clct1a, visualization-live-secondInstance_cfg::m, CSCMotherboard::match_trig_window_size, and pref.

                                              : CSCMotherboard()
 {
   // Constructor used only for testing.
 
   clct1a.reset( new CSCCathodeLCTProcessor() );
   clct1a->setRing(4);
 
   pref[0] = match_trig_window_size/2;
   for (unsigned int m=2; m<match_trig_window_size; m+=2)
   {
     pref[m-1] = pref[0] - m/2;
     pref[m]   = pref[0] + m/2;
   }
 }

CSCMotherboardME11GEM::~CSCMotherboardME11GEM ( )

Default destructor.

Definition at line 307 of file CSCMotherboardME11GEM.cc.

308 {

309 }

Member Function Documentation

int CSCMotherboardME11GEM::assignGEMRoll ( double eta )

private

Definition at line 1610 of file CSCMotherboardME11GEM.cc.

References gemRollToEtaLimits_, maxEta, HLT_FULL_cff::minEta, AlCaHLTBitMon_ParallelJobs::p, and mps_fire::result.

Referenced by run().

 {
   int result = -99;
   for(auto p : gemRollToEtaLimits_) {
     const float minEta((p.second).first);
     const float maxEta((p.second).second);
     if (minEta <= eta and eta <= maxEta) {
       result = p.first;
       break;
     }
   }
   return result;
 }

void CSCMotherboardME11GEM::buildCoincidencePads	(	const GEMPadDigiCollection *	out_pads,
		GEMCoPadDigiCollection &	out_co_pads,
		CSCDetId	csc_id
	)

private

Definition at line 1549 of file CSCMotherboardME11GEM.cc.

References funct::abs(), CSCDetId::chamber(), gemCoPadV, maxDeltaBXInCoPad_, maxDeltaPadInCoPad_, or, AlCaHLTBitMon_ParallelJobs::p, HLT_FULL_cff::region, relativeConstraints::ring, CSCDetId::ring(), relativeConstraints::station, CSCDetId::station(), and CSCDetId::zendcap().

Referenced by run().

 {
   gemCoPadV.clear();
 
   // Build coincidences
   for (auto det_range = out_pads->begin(); det_range != out_pads->end(); ++det_range) {
     const GEMDetId& id = (*det_range).first;
    // same chamber
     if (id.region() != csc_id.zendcap() or id.station() != csc_id.station() or 
     id.ring() != csc_id.ring() or id.chamber() != csc_id.chamber()) continue;
 
     // all coincidences detIDs will have layer=1
     if (id.layer() != 1) continue;
     
     // find the corresponding id with layer=2
     GEMDetId co_id(id.region(), id.ring(), id.station(), 2, id.chamber(), id.roll());
     
     auto co_pads_range = out_pads->get(co_id);
     // empty range = no possible coincidence pads
     if (co_pads_range.first == co_pads_range.second) continue;
       
     // now let's correlate the pads in two layers of this partition
     const auto& pads_range = (*det_range).second;
     for (auto p = pads_range.first; p != pads_range.second; ++p) {
       for (auto co_p = co_pads_range.first; co_p != co_pads_range.second; ++co_p) {
         // check the match in pad
         if (std::abs(p->pad() - co_p->pad()) > maxDeltaPadInCoPad_) continue;
         // check the match in BX
         if (std::abs(p->bx() - co_p->bx()) > maxDeltaBXInCoPad_ ) continue;
 
         // make a new coincidence pad digi
         gemCoPadV.push_back(GEMCoPadDigi(id.roll(),*p,*co_p));
         out_co_pads.insertDigi(id, GEMCoPadDigi(id.roll(),*p,*co_p));
       }
     }
   }
 }

void CSCMotherboardME11GEM::clear ( void )

Clears correlated LCT and passes clear signal on to cathode and anode LCT processors.

Definition at line 312 of file CSCMotherboardME11GEM.cc.

References allLCTs1a, allLCTs1b, clct1a, CSCCorrelatedLCTDigi::clear(), CSCMotherboard::clear(), coPads_, cscHsToGemPadME1a_, cscHsToGemPadME1b_, cscWgToGemRoll_, gemPadToCscHsME1a_, gemPadToCscHsME1b_, gemRollToEtaLimits_, i, CSCMotherboard::match_trig_window_size, CSCMotherboard::MAX_LCT_BINS, and pads_.

Referenced by run().

 {
   CSCMotherboard::clear();
   if (clct1a) clct1a->clear();
   for (int bx = 0; bx < MAX_LCT_BINS; bx++)
   {
     //firstLCT1a[bx].clear();
     //secondLCT1a[bx].clear();
     for (unsigned int mbx = 0; mbx < match_trig_window_size; mbx++)
       for (int i=0;i<2;i++)
       {
         allLCTs1b[bx][mbx][i].clear();
         allLCTs1a[bx][mbx][i].clear();
       }
   }
   gemRollToEtaLimits_.clear();
   cscWgToGemRoll_.clear();
 
   gemPadToCscHsME1a_.clear();
   gemPadToCscHsME1b_.clear();
 
   cscHsToGemPadME1a_.clear();
   cscHsToGemPadME1b_.clear();
 
   pads_.clear();
   coPads_.clear();
 }

CSCCorrelatedLCTDigi CSCMotherboardME11GEM::constructLCTsGEM	(	const CSCALCTDigi &	alct,
		const GEMPadDigi &	gem,
		int	me,
		bool	oldDataFormat = `false`
	)

private

Definition at line 1625 of file CSCMotherboardME11GEM.cc.

References GEMPadDigi::bx(), gemPadToCscHsME1a_, gemPadToCscHsME1b_, CSCALCTDigi::getBX(), CSCALCTDigi::getKeyWG(), CSCMotherboard::lct_central_bx, lut_wg_vs_hs_me1a, lut_wg_vs_hs_me1b, ME1A, GEMPadDigi::pad(), listBenchmarks::pattern, promoteALCTGEMpattern_, promoteALCTGEMquality_, TrackCollections2monitor_cff::quality, and CSCMotherboard::theTrigChamber.

Referenced by correlateLCTsGEM().

 {
   auto mymap(ME==ME1A ? gemPadToCscHsME1a_ : gemPadToCscHsME1b_);
   auto wgvshs(ME==ME1A ? lut_wg_vs_hs_me1a : lut_wg_vs_hs_me1b);
   if (oldDataFormat){
     // CLCT pattern number - set it to a highest value
     // hack to get LCTs in the CSCTF
     unsigned int pattern = promoteALCTGEMpattern_ ? 10 : 0;
     
     // LCT quality number - set it to a very high value 
     // hack to get LCTs in the CSCTF
     unsigned int quality = promoteALCTGEMquality_ ? 14 : 11;
     
     // Bunch crossing
     int bx = alct.getBX();
     
     // get keyStrip from LUT
     int keyStrip = mymap[gem.pad()];
 
     // get wiregroup from ALCT
     int wg = alct.getKeyWG();
 
     if (keyStrip>wgvshs[wg][0] && keyStrip<wgvshs[wg][1])
     { // construct correlated LCT; temporarily assign track number of 0.
       return CSCCorrelatedLCTDigi(0, 1, quality, wg, keyStrip, pattern, 0, bx, 0, 0, 0, theTrigChamber);
     }
     else return CSCCorrelatedLCTDigi(0,0,0,0,0,0,0,0,0,0,0,0);
    } 
   else {
     
     // CLCT pattern number - no pattern
     unsigned int pattern = 0;
 
     // LCT quality number
     unsigned int quality = 1;
     
     // Bunch crossing
     int bx = gem.bx() + lct_central_bx;
     
     // get keyStrip from LUT
     int keyStrip = mymap[gem.pad()];
 
     // get wiregroup from ALCT
     int wg = alct.getKeyWG();
     
     if (keyStrip>wgvshs[wg][0] && keyStrip<wgvshs[wg][1])
     { // construct correlated LCT; temporarily assign track number of 0.
       return CSCCorrelatedLCTDigi(0, 1, quality, wg, keyStrip, pattern, 0, bx, 0, 0, 0, theTrigChamber);
     }
     else return CSCCorrelatedLCTDigi(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
    }
 }

CSCCorrelatedLCTDigi CSCMotherboardME11GEM::constructLCTsGEM	(	const CSCCLCTDigi &	clct,
		const GEMPadDigi &	gem,
		int	roll,
		int	me,
		bool	oldDataFormat = `true`
	)

private

Definition at line 1680 of file CSCMotherboardME11GEM.cc.

References GEMPadDigi::bx(), encodePatternGEM(), CSCCLCTDigi::getBend(), CSCCLCTDigi::getKeyStrip(), CSCCLCTDigi::getPattern(), CSCCLCTDigi::getStripType(), CSCMotherboard::lct_central_bx, ME1A, listBenchmarks::pattern, promoteCLCTGEMquality_ME1a_, promoteCLCTGEMquality_ME1b_, TrackCollections2monitor_cff::quality, and CSCMotherboard::theTrigChamber.

 {
 //  auto mymap(ME==ME1A ? gemPadToCscHsME1a_ : gemPadToCscHsME1b_);
   if (oldDataFormat){
     // CLCT pattern number - no pattern
     unsigned int pattern = encodePatternGEM(clct.getPattern(), clct.getStripType());
     
     // LCT quality number -  dummy quality
     const bool promoteCLCTGEMquality(ME == ME1A ? promoteCLCTGEMquality_ME1a_:promoteCLCTGEMquality_ME1b_);
     unsigned int quality = promoteCLCTGEMquality ? 14 : 11;
     
     // Bunch crossing: get it from cathode LCT if anode LCT is not there.
     int bx = gem.bx() + lct_central_bx;;
     
    // pick a random WG in the roll range    
     int wg(5);
     
     // construct correlated LCT; temporarily assign track number of 0.
     return CSCCorrelatedLCTDigi(0, 1, quality, wg, clct.getKeyStrip(), pattern, clct.getBend(), bx, 0, 0, 0, theTrigChamber);
   }
   else {
     // CLCT pattern number - no pattern
     unsigned int pattern = encodePatternGEM(clct.getPattern(), clct.getStripType());
     
     // LCT quality number -  dummy quality
     unsigned int quality = 5;//findQualityGEM(alct, gem);
     
     // Bunch crossing: get it from cathode LCT if anode LCT is not there.
     int bx = gem.bx() + lct_central_bx;;
     
     // ALCT WG
     int wg();
     
     // construct correlated LCT; temporarily assign track number of 0.
     return CSCCorrelatedLCTDigi(0, 1, quality, 0, 0, pattern, 0, bx, 0, 0, 0, theTrigChamber);
   }
 }

CSCCorrelatedLCTDigi CSCMotherboardME11GEM::constructLCTsGEM	(	const CSCALCTDigi &	alct,
		const CSCCLCTDigi &	clct,
		bool	hasPad,
		bool	hasCoPad
	)

private

Definition at line 1721 of file CSCMotherboardME11GEM.cc.

References CSCMotherboard::encodePattern(), findQualityGEM(), CSCCLCTDigi::getBend(), CSCALCTDigi::getBX(), CSCCLCTDigi::getBX(), CSCCLCTDigi::getKeyStrip(), CSCALCTDigi::getKeyWG(), CSCCLCTDigi::getPattern(), CSCCLCTDigi::getStripType(), CSCALCTDigi::isValid(), listBenchmarks::pattern, TrackCollections2monitor_cff::quality, and CSCMotherboard::theTrigChamber.

 {
   // CLCT pattern number
   unsigned int pattern = encodePattern(cLCT.getPattern(), cLCT.getStripType());
 
   // LCT quality number
   unsigned int quality = findQualityGEM(aLCT, cLCT, hasPad, hasCoPad);
 
   // Bunch crossing: get it from cathode LCT if anode LCT is not there.
   int bx = aLCT.isValid() ? aLCT.getBX() : cLCT.getBX();
 
   // construct correlated LCT; temporarily assign track number of 0.
   int trknmb = 0;
   CSCCorrelatedLCTDigi thisLCT(trknmb, 1, quality, aLCT.getKeyWG(),
                                cLCT.getKeyStrip(), pattern, cLCT.getBend(),
                                bx, 0, 0, 0, theTrigChamber);
   return thisLCT;
 }

void CSCMotherboardME11GEM::correlateLCTs	(	CSCALCTDigi	bestALCT,
		CSCALCTDigi	secondALCT,
		CSCCLCTDigi	bestCLCT,
		CSCCLCTDigi	secondCLCT,
		CSCCorrelatedLCTDigi &	lct1,
		CSCCorrelatedLCTDigi &	lct2
	)

private

Definition at line 1264 of file CSCMotherboardME11GEM.cc.

References CSCMotherboard::alct_trig_enable, CSCMotherboard::clct_trig_enable, CSCMotherboard::constructLCTs(), CSCCLCTDigi::isValid(), CSCALCTDigi::isValid(), CSCMotherboard::match_trig_enable, or, and CSCCorrelatedLCTDigi::setTrknmb().

 {
   bool anodeBestValid     = bestALCT.isValid();
   bool anodeSecondValid   = secondALCT.isValid();
   bool cathodeBestValid   = bestCLCT.isValid();
   bool cathodeSecondValid = secondCLCT.isValid();
 
   if (anodeBestValid and !anodeSecondValid)     secondALCT = bestALCT;
   if (!anodeBestValid and anodeSecondValid)     bestALCT   = secondALCT;
   if (cathodeBestValid and !cathodeSecondValid) secondCLCT = bestCLCT;
   if (!cathodeBestValid and cathodeSecondValid) bestCLCT   = secondCLCT;
 
   // ALCT-CLCT matching conditions are defined by "trig_enable" configuration
   // parameters.
   if ((alct_trig_enable  and bestALCT.isValid()) or
       (clct_trig_enable  and bestCLCT.isValid()) or
       (match_trig_enable and bestALCT.isValid() and bestCLCT.isValid()))
   {
     lct1 = constructLCTs(bestALCT, bestCLCT);
     lct1.setTrknmb(1);
   }
 
   if (((secondALCT != bestALCT) or (secondCLCT != bestCLCT)) and
       ((alct_trig_enable  and secondALCT.isValid()) or
        (clct_trig_enable  and secondCLCT.isValid()) or
        (match_trig_enable and secondALCT.isValid() and secondCLCT.isValid())))
   {
     lct2 = constructLCTs(secondALCT, secondCLCT);
     lct2.setTrknmb(2);
   }
 }

void CSCMotherboardME11GEM::correlateLCTsGEM	(	CSCALCTDigi	bestALCT,
		CSCALCTDigi	secondALCT,
		CSCCLCTDigi	bestCLCT,
		CSCCLCTDigi	secondCLCT,
		CSCCorrelatedLCTDigi &	lct1,
		CSCCorrelatedLCTDigi &	lct2,
		int	me,
		const GEMPadsBX &	pads = `GEMPadsBX()`,
		const GEMPadsBX &	copads = `GEMPadsBX()`
	)

private

Definition at line 1359 of file CSCMotherboardME11GEM.cc.

References EnergyCorrector::c, CSCTriggerNumbering::chamberFromTriggerLabels(), CSCCLCTDigi::clear(), CSCALCTDigi::clear(), constructLCTsGEM(), gather_cfg::cout, debug_gem_matching, deltaPad(), deltaRoll(), doesALCTCrossCLCT(), doLCTGhostBustingWithGEMs_, plotBeamSpotDB::first, CSCCLCTDigi::getKeyStrip(), CSCALCTDigi::getKeyWG(), i, LogTrace, lumiPlot::lut, hlt_dqm_clientPB-live_cfg::me, ME1B, AlCaHLTBitMon_ParallelJobs::p, relativeConstraints::ring, GEMDetId::roll(), CSCCorrelatedLCTDigi::setTrknmb(), CSCMotherboard::theEndcap, CSCMotherboard::theSector, CSCMotherboard::theStation, CSCMotherboard::theSubsector, and CSCMotherboard::theTrigChamber.

Referenced by run().

 {
   // assume that always anodeBestValid and cathodeBestValid
   
   if (secondALCT == bestALCT) secondALCT.clear();
   if (secondCLCT == bestCLCT) secondCLCT.clear();
 
   int ok11 = doesALCTCrossCLCT( bestALCT, bestCLCT, me);
   int ok12 = doesALCTCrossCLCT( bestALCT, secondCLCT, me);
   int ok21 = doesALCTCrossCLCT( secondALCT, bestCLCT, me);
   int ok22 = doesALCTCrossCLCT( secondALCT, secondCLCT, me);
   int code = (ok11<<3) | (ok12<<2) | (ok21<<1) | (ok22);
 
   int dbg=0;
   int ring = me;
   int chamb= CSCTriggerNumbering::chamberFromTriggerLabels(theSector,theSubsector, theStation, theTrigChamber);
   CSCDetId did(theEndcap, theStation, ring, chamb, 0);
   if (dbg) LogTrace("CSCMotherboardME11GEM")<<"debug correlateLCTs in "<<did<<std::endl
        <<"ALCT1: "<<bestALCT<<std::endl
        <<"ALCT2: "<<secondALCT<<std::endl
        <<"CLCT1: "<<bestCLCT<<std::endl
        <<"CLCT2: "<<secondCLCT<<std::endl
        <<"ok 11 12 21 22 code = "<<ok11<<" "<<ok12<<" "<<ok21<<" "<<ok22<<" "<<code<<std::endl;
 
   if ( code==0 ) return;
 
   // LUT defines correspondence between possible ok## combinations
   // and resulting lct1 and lct2
   int lut[16][2] = {
           //ok: 11 12 21 22
     {0 ,0 }, // 0  0  0  0
     {22,0 }, // 0  0  0  1
     {21,0 }, // 0  0  1  0
     {21,22}, // 0  0  1  1
     {12,0 }, // 0  1  0  0
     {12,22}, // 0  1  0  1
     {12,21}, // 0  1  1  0
     {12,21}, // 0  1  1  1
     {11,0 }, // 1  0  0  0
     {11,22}, // 1  0  0  1
     {11,21}, // 1  0  1  0
     {11,22}, // 1  0  1  1
     {11,12}, // 1  1  0  0
     {11,22}, // 1  1  0  1
     {11,12}, // 1  1  1  0
     {11,22}, // 1  1  1  1
   };
 
   if (dbg) LogTrace("CSCMotherboardME11GEM")<<"lut 0 1 = "<<lut[code][0]<<" "<<lut[code][1]<<std::endl;
 
   // first check the special case (11,22) where we have an ambiguity
   const int nPads(pads.size());
   const int nCoPads(copads.size());
   const bool hasPads(nPads!=0);
   const bool hasCoPads(nCoPads!=0);
   
   if (doLCTGhostBustingWithGEMs_ and (lut[code][0] == 11) and (lut[code][0] == 22) and hasPads and (me==ME1B)){
 
     if (debug_gem_matching) std::cout << "++Info: 2 valid ALCTs-CLCTs pairs with trigger pads. Call the GHOSTBUSTERS!!!" << std::endl;    
     // first check if there are any copads
     typedef std::pair<int,int> mypair;
     // for each trigger pad, store (deltaRoll,deltaHS) for 11,22,12 and 21.
     std::vector<std::tuple<mypair,mypair,mypair,mypair>> deltas;
     deltas.clear();
 
     if (hasCoPads){
       for (auto p : copads) {
         const GEMDetId detId(p.first);
         const int rollN(detId.roll());
         const int padN((p.second).pad());
         
         auto t11(std::make_pair(deltaRoll(  bestALCT.getKeyWG(), rollN), deltaPad(  bestCLCT.getKeyStrip(), padN)));
         auto t22(std::make_pair(deltaRoll(secondALCT.getKeyWG(), rollN), deltaPad(secondCLCT.getKeyStrip(), padN)));
         auto t12(std::make_pair(deltaRoll(  bestALCT.getKeyWG(), rollN), deltaPad(secondCLCT.getKeyStrip(), padN)));
         auto t21(std::make_pair(deltaRoll(secondALCT.getKeyWG(), rollN), deltaPad(  bestCLCT.getKeyStrip(), padN)));
 
         deltas.push_back(std::make_tuple(t11,t22,t12,t21));
       }
       if (debug_gem_matching){
         std::cout << "- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - " << std::endl;
         std::cout << "Printing (deltaRoll, deltaPad) for each (ALCT,CLCT) pair and for each trigger copad" << std::endl;
         for (unsigned i =0; i < deltas.size(); ++i){
           auto c(deltas.at(i));
           std::cout << "\tCoPad " << i << std::endl;
           std::cout << "\t11: " << "(" << std::get<0>(c).first << "," << std::get<0>(c).second << "); "
                     << "22: "   << "(" << std::get<1>(c).first << "," << std::get<1>(c).second << "); " 
                     << "12: "   << "(" << std::get<2>(c).first << "," << std::get<2>(c).second << "); "
                     << "21: "   << "(" << std::get<3>(c).first << "," << std::get<3>(c).second << ")" << std::endl << std::endl;
         }
         std::cout << "- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - " << std::endl;
       }
       
       
 //      lct1 = constructLCTs(bestALCT, bestCLCT);
 //      lct1.setTrknmb(1);
 //      lct2 = constructLCTs(secondALCT, secondCLCT);
 //      lct2.setTrknmb(2);
   
 //      lct1 = constructLCTs(bestALCT, secondCLCT);
 //      lct1.setTrknmb(1);
 //      lct2 = constructLCTs(secondLCT, bestCLCT);
 //      lct2.setTrknmb(2);
       return;
     }
 
     // if no copads were found, do the same with pads...
     if (hasPads){
       for (auto p : pads) {
         const GEMDetId detId(p.first);
         const int rollN(detId.roll());
         const int padN((p.second).pad());
         
         auto t11(std::make_pair(deltaRoll(  bestALCT.getKeyWG(), rollN), deltaPad(  bestCLCT.getKeyStrip(), padN)));
         auto t22(std::make_pair(deltaRoll(secondALCT.getKeyWG(), rollN), deltaPad(secondCLCT.getKeyStrip(), padN)));
         auto t12(std::make_pair(deltaRoll(  bestALCT.getKeyWG(), rollN), deltaPad(secondCLCT.getKeyStrip(), padN)));
         auto t21(std::make_pair(deltaRoll(secondALCT.getKeyWG(), rollN), deltaPad(  bestCLCT.getKeyStrip(), padN)));
 
         deltas.push_back(std::make_tuple(t11,t22,t12,t21));
       }
       if (debug_gem_matching){
         std::cout << "- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - " << std::endl;
         std::cout << "Printing (deltaRoll, deltaPad) for each (ALCT,CLCT) pair and for each trigger pad" << std::endl;
         for (unsigned i =0; i < deltas.size(); ++i){
           auto c(deltas.at(i));
           std::cout << "\tPad " << i << std::endl;
           std::cout << "\t11: " << "(" << std::get<0>(c).first << "," << std::get<0>(c).second << "); "
                     << "22: "   << "(" << std::get<1>(c).first << "," << std::get<1>(c).second << "); " 
                     << "12: "   << "(" << std::get<2>(c).first << "," << std::get<2>(c).second << "); "
                     << "21: "   << "(" << std::get<3>(c).first << "," << std::get<3>(c).second << ")" << std::endl << std::endl;
         }
         std::cout << "- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - " << std::endl;
       }
 
       return;
     }
   }
 
   switch (lut[code][0]) {
     case 11:
       lct1 = constructLCTsGEM(bestALCT, bestCLCT, hasPads, hasCoPads);
       break;
     case 12:
       lct1 = constructLCTsGEM(bestALCT, secondCLCT, hasPads, hasCoPads);
       break;
     case 21:
       lct1 = constructLCTsGEM(secondALCT, bestCLCT, hasPads, hasCoPads);
       break;
     case 22:
       lct1 = constructLCTsGEM(secondALCT, secondCLCT, hasPads, hasCoPads);
       break;
     default: 
       return;  
   }
   lct1.setTrknmb(1);
 
   if (dbg) LogTrace("CSCMotherboardME11GEM")<<"lct1: "<<lct1<<std::endl;
   
   switch (lut[code][1])
   {
     case 12:
       lct2 = constructLCTsGEM(bestALCT, secondCLCT, hasPads, hasCoPads);
       lct2.setTrknmb(2);
       if (dbg) LogTrace("CSCMotherboardME11GEM")<<"lct2: "<<lct2<<std::endl;
       return;
     case 21:
       lct2 = constructLCTsGEM(secondALCT, bestCLCT, hasPads, hasCoPads);
       lct2.setTrknmb(2);
       if (dbg) LogTrace("CSCMotherboardME11GEM")<<"lct2: "<<lct2<<std::endl;
       return;
     case 22:
       lct2 = constructLCTsGEM(secondALCT, secondCLCT, hasPads, hasCoPads);
       lct2.setTrknmb(2);
       if (dbg) LogTrace("CSCMotherboardME11GEM")<<"lct2: "<<lct2<<std::endl;
       return;
     default: 
       return;
   }
   if (dbg) LogTrace("CSCMotherboardME11GEM")<<"out of correlateLCTs"<<std::endl;
 
   return;
 }

void CSCMotherboardME11GEM::correlateLCTsGEM	(	CSCALCTDigi	bestALCT,
		CSCALCTDigi	secondALCT,
		GEMPadDigi	gemPad,
		CSCCorrelatedLCTDigi &	lct1,
		CSCCorrelatedLCTDigi &	lct2,
		int	me
	)

private

Definition at line 1302 of file CSCMotherboardME11GEM.cc.

References CSCMotherboard::alct_trig_enable, constructLCTsGEM(), CSCALCTDigi::isValid(), CSCMotherboard::match_trig_enable, or, CSCCorrelatedLCTDigi::setTrknmb(), and useOldLCTDataFormat_.

 {
   bool anodeBestValid     = bestALCT.isValid();
   bool anodeSecondValid   = secondALCT.isValid();
 
   if (anodeBestValid and !anodeSecondValid)     secondALCT = bestALCT;
   if (!anodeBestValid and anodeSecondValid)     bestALCT   = secondALCT;
 
   if ((alct_trig_enable  and bestALCT.isValid()) or
       (match_trig_enable and bestALCT.isValid()))
   {
     lct1 = constructLCTsGEM(bestALCT, gemPad, ME, useOldLCTDataFormat_);
     lct1.setTrknmb(1);
     //    lct1.setGEMDPhi(0.0);
   }
 
   if ((alct_trig_enable  and secondALCT.isValid()) or
       (match_trig_enable and secondALCT.isValid() and secondALCT != bestALCT))
   {
     lct2 = constructLCTsGEM(secondALCT, gemPad, ME, useOldLCTDataFormat_);
     lct2.setTrknmb(2);
     //    lct2.setGEMDPhi(0.0);
   }
 }

void CSCMotherboardME11GEM::correlateLCTsGEM	(	CSCCLCTDigi	bestCLCT,
		CSCCLCTDigi	secondCLCT,
		GEMPadDigi	gemPad,
		int	roll,
		CSCCorrelatedLCTDigi &	lct1,
		CSCCorrelatedLCTDigi &	lct2,
		int	me
	)

private

Definition at line 1332 of file CSCMotherboardME11GEM.cc.

References CSCMotherboard::clct_trig_enable, constructLCTsGEM(), CSCCLCTDigi::isValid(), CSCMotherboard::match_trig_enable, or, CSCCorrelatedLCTDigi::setTrknmb(), and useOldLCTDataFormat_.

 {
   bool cathodeBestValid     = bestCLCT.isValid();
   bool cathodeSecondValid   = secondCLCT.isValid();
 
   if (cathodeBestValid and !cathodeSecondValid)     secondCLCT = bestCLCT;
   if (!cathodeBestValid and cathodeSecondValid)     bestCLCT   = secondCLCT;
 
   if ((clct_trig_enable  and bestCLCT.isValid()) or
       (match_trig_enable and bestCLCT.isValid()))
   {
     lct1 = constructLCTsGEM(bestCLCT, gemPad, roll, ME, useOldLCTDataFormat_);
     lct1.setTrknmb(1);
   }
 
   if ((clct_trig_enable  and secondCLCT.isValid()) or
        (match_trig_enable and secondCLCT.isValid() and secondCLCT != bestCLCT))
   {
     lct2 = constructLCTsGEM(secondCLCT, gemPad, roll, ME, useOldLCTDataFormat_);
     lct2.setTrknmb(2);
   }
 }

void CSCMotherboardME11GEM::createGEMRollEtaLUT ( bool isEven )

private

Definition at line 1590 of file CSCMotherboardME11GEM.cc.

References GEMGeometry::chamber(), gem_g, gemRollToEtaLimits_, and gen::n.

Referenced by run().

 {
   int ch(isEven ? 2 : 1);
   auto chamber(gem_g->chamber(GEMDetId(1,1,1,1,ch,0)));
   if (chamber==nullptr) return;
 
   int n = 1;
   if (isEven) n = 2; // this only works for the 9-10 partition geometry!!! FIXME
   for(auto roll : chamber->etaPartitions()) {
     const float half_striplength(roll->specs()->specificTopology().stripLength()/2.);
     const LocalPoint lp_top(0., half_striplength, 0.);
     const LocalPoint lp_bottom(0., -half_striplength, 0.);
     const GlobalPoint gp_top(roll->toGlobal(lp_top));
     const GlobalPoint gp_bottom(roll->toGlobal(lp_bottom));
     gemRollToEtaLimits_[n] = std::make_pair(gp_top.eta(), gp_bottom.eta());
     ++n;
   }
 }

int CSCMotherboardME11GEM::deltaPad	(	int	hs,
		int	pad
	)

private

Definition at line 1966 of file CSCMotherboardME11GEM.cc.

References funct::abs(), cscHsToGemPadME1b_, min(), and AlCaHLTBitMon_ParallelJobs::p.

Referenced by correlateLCTsGEM(), and matchingGEMPads().

 {
   const auto p(cscHsToGemPadME1b_[hs]);
   return std::min(std::abs(p.first - pad), std::abs(p.second - pad));
 }

int CSCMotherboardME11GEM::deltaRoll	(	int	wg,
		int	roll
	)

private

Definition at line 1959 of file CSCMotherboardME11GEM.cc.

References funct::abs(), cscWgToGemRoll_, min(), and AlCaHLTBitMon_ParallelJobs::p.

Referenced by correlateLCTsGEM().

 {
   const auto p(cscWgToGemRoll_[wg]);
   return std::min(std::abs(p.first - pad), std::abs(p.second - pad));
 }

bool CSCMotherboardME11GEM::doesALCTCrossCLCT	(	CSCALCTDigi &	a,
		CSCCLCTDigi &	c,
		int	me
	)

private

Definition at line 1232 of file CSCMotherboardME11GEM.cc.

References gangedME1a, CSCCLCTDigi::getKeyStrip(), CSCALCTDigi::getKeyWG(), CSCCLCTDigi::isValid(), CSCALCTDigi::isValid(), lut_wg_vs_hs_me1a, lut_wg_vs_hs_me1ag, lut_wg_vs_hs_me1b, ME1A, ME1B, or, and CSCMotherboard::theEndcap.

Referenced by correlateLCTsGEM().

 {
   if ( !c.isValid() or !a.isValid() ) return false;
   int key_hs = c.getKeyStrip();
   int key_wg = a.getKeyWG();
   if ( me == ME1A )
   {
     if ( !gangedME1a )
     {
       // wrap around ME11 HS number for -z endcap
       if (theEndcap==2) key_hs = 95 - key_hs;
       if ( key_hs >= lut_wg_vs_hs_me1a[key_wg][0] and 
            key_hs <= lut_wg_vs_hs_me1a[key_wg][1]    ) return true;
       return false;
     }
     else
     {
       if (theEndcap==2) key_hs = 31 - key_hs;
       if ( key_hs >= lut_wg_vs_hs_me1ag[key_wg][0] and
            key_hs <= lut_wg_vs_hs_me1ag[key_wg][1]    ) return true;
       return false;
     }
   }
   if ( me == ME1B)
   {
     if (theEndcap==2) key_hs = 127 - key_hs;
     if ( key_hs >= lut_wg_vs_hs_me1b[key_wg][0] and 
          key_hs <= lut_wg_vs_hs_me1b[key_wg][1]      ) return true;
   }
   return false;
 }

unsigned int CSCMotherboardME11GEM::encodePatternGEM	(	const int	ptn,
		const int	highPt
	)

private

Definition at line 1742 of file CSCMotherboardME11GEM.cc.

Referenced by constructLCTsGEM().

 {
   return 0;
 }

unsigned int CSCMotherboardME11GEM::findQualityGEM	(	const CSCALCTDigi &	aLCT,
		const GEMPadDigi &	gem
	)

private

Referenced by constructLCTsGEM().

unsigned int CSCMotherboardME11GEM::findQualityGEM	(	const CSCCLCTDigi &	cLCT,
		const GEMPadDigi &	gem
	)

private

Definition at line 1875 of file CSCMotherboardME11GEM.cc.

 {
   return 0;
 }

unsigned int CSCMotherboardME11GEM::findQualityGEM	(	const CSCALCTDigi &	aLCT,
		const CSCCLCTDigi &	cLCT,
		bool	hasPad,
		bool	hasCoPad
	)

private

Definition at line 1748 of file CSCMotherboardME11GEM.cc.

References CSCALCTDigi::getAccelerator(), CSCCLCTDigi::getPattern(), CSCCLCTDigi::getQuality(), CSCALCTDigi::getQuality(), CSCCLCTDigi::getStripType(), CSCMotherboard::infoV, CSCMotherboard::isTMB07, CSCALCTDigi::isValid(), CSCCLCTDigi::isValid(), hltrates_dqm_sourceclient-live_cfg::offset, or, listBenchmarks::pattern, and TrackCollections2monitor_cff::quality.

 {
 
   /*
     Same LCT quality definition as standard LCTs
     c4 takes GEMs into account!!!
   */
 
   unsigned int quality = 0;
 
   if (!isTMB07) {
     bool isDistrip = (cLCT.getStripType() == 0);
 
     if (aLCT.isValid() && !(cLCT.isValid())) {    // no CLCT
       if (aLCT.getAccelerator()) {quality =  1;}
       else                       {quality =  3;}
     }
     else if (!(aLCT.isValid()) && cLCT.isValid()) { // no ALCT
       if (isDistrip)             {quality =  4;}
       else                       {quality =  5;}
     }
     else if (aLCT.isValid() && cLCT.isValid()) { // both ALCT and CLCT
       if (aLCT.getAccelerator()) {quality =  2;} // accelerator muon
       else {                                     // collision muon
         // CLCT quality is, in fact, the number of layers hit, so subtract 3
         // to get quality analogous to ALCT one.
         int sumQual = aLCT.getQuality() + (cLCT.getQuality()-3);
         if (sumQual < 1 || sumQual > 6) {
           if (infoV >= 0) edm::LogWarning("L1CSCTPEmulatorWrongValues")
             << "+++ findQuality: sumQual = " << sumQual << "+++ \n";
         }
         if (isDistrip) { // distrip pattern
           if (sumQual == 2)      {quality =  6;}
           else if (sumQual == 3) {quality =  7;}
           else if (sumQual == 4) {quality =  8;}
           else if (sumQual == 5) {quality =  9;}
           else if (sumQual == 6) {quality = 10;}
         }
         else {            // halfstrip pattern
           if (sumQual == 2)      {quality = 11;}
           else if (sumQual == 3) {quality = 12;}
           else if (sumQual == 4) {quality = 13;}
           else if (sumQual == 5) {quality = 14;}
           else if (sumQual == 6) {quality = 15;}
         }
       }
     }
   }
 #ifdef OLD
   else {
     // Temporary definition, used until July 2008.
     // First if statement is fictitious, just to help the CSC TF emulator
     // handle such cases (one needs to make sure they will be accounted for
     // in the new quality definition.
     if (!(aLCT.isValid()) || !(cLCT.isValid())) {
       if (aLCT.isValid() && !(cLCT.isValid()))      quality = 1; // no CLCT
       else if (!(aLCT.isValid()) && cLCT.isValid()) quality = 2; // no ALCT
       else quality = 0; // both absent; should never happen.
     }
     else {
       // Sum of ALCT and CLCT quality bits.  CLCT quality is, in fact, the
       // number of layers hit, so subtract 3 to put it to the same footing as
       // the ALCT quality.
       int sumQual = aLCT.getQuality() + (cLCT.getQuality()-3);
       if (sumQual < 1 || sumQual > 6) {
         if (infoV >= 0) edm::LogWarning("L1CSCTPEmulatorWrongValues")
           << "+++ findQuality: Unexpected sumQual = " << sumQual << "+++\n";
       }
 
       // LCT quality is basically the sum of ALCT and CLCT qualities, but split
       // in two groups depending on the CLCT pattern id (higher quality for
       // straighter patterns).
       int offset = 0;
       if (cLCT.getPattern() <= 7) offset = 4;
       else                        offset = 9;
       quality = offset + sumQual;
     }
   }
 #endif
   else {
     // 2008 definition.
     if (!(aLCT.isValid()) || !(cLCT.isValid())) {
       if (aLCT.isValid() && !(cLCT.isValid()))      quality = 1; // no CLCT
       else if (!(aLCT.isValid()) && cLCT.isValid()) quality = 2; // no ALCT
       else quality = 0; // both absent; should never happen.
     }
     else {
       int pattern = cLCT.getPattern();
       if (pattern == 1) quality = 3; // layer-trigger in CLCT
       else {
         // CLCT quality is the number of layers hit minus 3.
         // CLCT quality is the number of layers hit.
     //  const int n_gem((pad!=NULL and 1) or (copad!=NULL and 2));
     int n_gem = 0;  
     if (hasPad) n_gem = 1;
     if (hasCoPad) n_gem = 2;
         const bool a4(aLCT.getQuality() >= 1);
     const bool c4((cLCT.getQuality() >= 4) or (cLCT.getQuality() >= 3 and n_gem>=1));
         //              quality = 4; "reserved for low-quality muons in future"
         if      (!a4 && !c4) quality = 5; // marginal anode and cathode
         else if ( a4 && !c4) quality = 6; // HQ anode, but marginal cathode
         else if (!a4 &&  c4) quality = 7; // HQ cathode, but marginal anode
         else if ( a4 &&  c4) {
           if (aLCT.getAccelerator()) quality = 8; // HQ muon, but accel ALCT
           else {
             // quality =  9; "reserved for HQ muons with future patterns
             // quality = 10; "reserved for HQ muons with future patterns
             if (pattern == 2 || pattern == 3)      quality = 11;
             else if (pattern == 4 || pattern == 5) quality = 12;
             else if (pattern == 6 || pattern == 7) quality = 13;
             else if (pattern == 8 || pattern == 9) quality = 14;
             else if (pattern == 10)                quality = 15;
             else {
               if (infoV >= 0) edm::LogWarning("L1CSCTPEmulatorWrongValues")
                 << "+++ findQuality: Unexpected CLCT pattern id = "
                 << pattern << "+++\n";
             }
           }
         }
       }
     }
   }
   return quality;
 }

std::vector<CSCALCTDigi> CSCMotherboardME11GEM::getALCTs1b ( )

inline

Returns vectors of found ALCTs in ME1a and ME1b, if any.

Definition at line 63 of file CSCMotherboardME11GEM.h.

References alctV.

63 {return alctV;}

CSCMotherboardME11GEM::alctV

std::vector< CSCALCTDigi > alctV

Definition: CSCMotherboardME11GEM.h:165

std::vector<CSCCLCTDigi> CSCMotherboardME11GEM::getCLCTs1a ( )

inline

Returns vectors of found CLCTs in ME1a and ME1b, if any.

Definition at line 66 of file CSCMotherboardME11GEM.h.

References clctV1a.

66 {return clctV1a;}

CSCMotherboardME11GEM::clctV1a

std::vector< CSCCLCTDigi > clctV1a

Definition: CSCMotherboardME11GEM.h:167

std::vector<CSCCLCTDigi> CSCMotherboardME11GEM::getCLCTs1b ( )

inline

Definition at line 67 of file CSCMotherboardME11GEM.h.

References clctV1b.

67 {return clctV1b;}

CSCMotherboardME11GEM::clctV1b

std::vector< CSCCLCTDigi > clctV1b

Definition: CSCMotherboardME11GEM.h:166

std::vector< CSCCorrelatedLCTDigi > CSCMotherboardME11GEM::getLCTs1a ( )

Returns vectors of found correlated LCTs in ME1a and ME1b, if any.

Definition at line 1054 of file CSCMotherboardME11GEM.cc.

References allLCTs1a, disableME1a, i, CSCMotherboard::match_trig_window_size, CSCMotherboard::MAX_LCT_BINS, CSCMotherboard::mpc_block_me1a, and or.

Referenced by readoutLCTs().

 {
   std::vector<CSCCorrelatedLCTDigi> tmpV;
   
   // disabled ME1a
   if (mpc_block_me1a or disableME1a) return tmpV;
 
   // Report all LCTs found.
   for (int bx = 0; bx < MAX_LCT_BINS; bx++)
     for (unsigned int mbx = 0; mbx < match_trig_window_size; mbx++) 
       for (int i=0;i<2;i++)
         if (allLCTs1a[bx][mbx][i].isValid())  tmpV.push_back(allLCTs1a[bx][mbx][i]);
   return tmpV;
 }

std::vector< CSCCorrelatedLCTDigi > CSCMotherboardME11GEM::getLCTs1b ( )

Definition at line 1041 of file CSCMotherboardME11GEM.cc.

References allLCTs1b, i, CSCMotherboard::match_trig_window_size, and CSCMotherboard::MAX_LCT_BINS.

Referenced by readoutLCTs().

 {
   std::vector<CSCCorrelatedLCTDigi> tmpV;
 
   for (int bx = 0; bx < MAX_LCT_BINS; bx++) 
     for (unsigned int mbx = 0; mbx < match_trig_window_size; mbx++)
       for (int i=0;i<2;i++)
         if (allLCTs1b[bx][mbx][i].isValid()) tmpV.push_back(allLCTs1b[bx][mbx][i]);
   return tmpV;
 }

bool CSCMotherboardME11GEM::isPadInOverlap ( int roll )

private

Definition at line 1948 of file CSCMotherboardME11GEM.cc.

References cscWgToGemRoll_, or, and AlCaHLTBitMon_ParallelJobs::p.

Referenced by matchingGEMPads(), and printGEMTriggerPads().

 {
   for (auto& p : cscWgToGemRoll_) {
     // overlap region are WGs 10-15
     if ((p.first < 10) or (p.first > 15)) continue;
     if (((p.second).first <= roll) and (roll <= (p.second).second)) return true;
   }
   return false;
 }

CSCMotherboardME11GEM::GEMPadsBX CSCMotherboardME11GEM::matchingGEMPads	(	const CSCCLCTDigi &	cLCT,
		const GEMPadsBX &	pads = `GEMPadsBX()`,
		enum ME11Part	part = `ME1B`,
		bool	isCopad = `false`,
		bool	first = `true`
	)

private

Definition at line 1974 of file CSCMotherboardME11GEM.cc.

References funct::abs(), gather_cfg::cout, cscHsToGemPadME1a_, cscHsToGemPadME1b_, debug, deltaPad(), CSCCLCTDigi::getKeyStrip(), maxDeltaPadCoPad_, maxDeltaPadPad_, ME1A, or, AlCaHLTBitMon_ParallelJobs::p, and mps_fire::result.

Referenced by matchingGEMPads(), and run().

 {
   CSCMotherboardME11GEM::GEMPadsBX result;
 
   // fetch the low and high pad edges
   auto mymap(part==ME1A ? cscHsToGemPadME1a_ : cscHsToGemPadME1b_);
   int deltaPad(isCoPad ? maxDeltaPadCoPad_ : maxDeltaPadPad_);
   const int lowPad(mymap[clct.getKeyStrip()].first);
   const int highPad(mymap[clct.getKeyStrip()].second);
   const bool debug(false);
   if (debug) std::cout << "lowpad " << lowPad << " highpad " << highPad << " delta pad " << deltaPad <<std::endl;
   for (auto p: pads){
     auto padRoll((p.second).pad());
     if (debug) std::cout << "padRoll " << padRoll << std::endl;
     if (std::abs(lowPad - padRoll) <= deltaPad or std::abs(padRoll - highPad) <= deltaPad){
     if (debug) std::cout << "++Matches! " << std::endl;
       result.push_back(p);
       if (first) return result;
     }
   }
   return result;
 }

CSCMotherboardME11GEM::GEMPadsBX CSCMotherboardME11GEM::matchingGEMPads	(	const CSCALCTDigi &	aLCT,
		const GEMPadsBX &	pads = `GEMPadsBX()`,
		enum ME11Part	part = `ME1B`,
		bool	isCopad = `false`,
		bool	first = `true`
	)

private

Definition at line 1999 of file CSCMotherboardME11GEM.cc.

References gather_cfg::cout, cscWgToGemRoll_, debug, CSCALCTDigi::getKeyWG(), isPadInOverlap(), ME1A, or, AlCaHLTBitMon_ParallelJobs::p, mps_fire::result, and GEMDetId::roll().

 {
   CSCMotherboardME11GEM::GEMPadsBX result;
   
   auto alctRoll(cscWgToGemRoll_[alct.getKeyWG()]);
   const bool debug(false);
   if (debug) std::cout << "ALCT keyWG " << alct.getKeyWG() << ", rolls " << alctRoll.first << " " << alctRoll.second << std::endl;
   for (auto p: pads){
     auto padRoll(GEMDetId(p.first).roll());
     if (debug) std::cout << "Candidate ALCT: " << padRoll << std::endl;
     // only pads in overlap are good for ME1A
     if (part==ME1A and !isPadInOverlap(padRoll)) continue;
     if (alctRoll.first == -99 and alctRoll.second == -99) continue;  //invalid region
     else if (alctRoll.first == -99 and !(padRoll <= alctRoll.second)) continue; // top of the chamber
     else if (alctRoll.second == -99 and !(padRoll >= alctRoll.first)) continue; // bottom of the chamber
     else if ((alctRoll.first != -99 and alctRoll.second != -99) and // center
              (alctRoll.first > padRoll or padRoll > alctRoll.second)) continue;
     if (debug) std::cout << "++Matches! " << std::endl;
     result.push_back(p);
     if (first) return result;
   }
   return result;
 }

CSCMotherboardME11GEM::GEMPadsBX CSCMotherboardME11GEM::matchingGEMPads	(	const CSCCLCTDigi &	cLCT,
		const CSCALCTDigi &	aLCT,
		const GEMPadsBX &	pads = `GEMPadsBX()`,
		enum ME11Part	part = `ME1B`,
		bool	isCopad = `false`,
		bool	first = `true`
	)

private

Definition at line 2025 of file CSCMotherboardME11GEM.cc.

References gather_cfg::cout, debug, matchingGEMPads(), or, AlCaHLTBitMon_ParallelJobs::p, lumiQueryAPI::q, and mps_fire::result.

 {
   CSCMotherboardME11GEM::GEMPadsBX result;
 
   // Fetch all (!) pads matching to ALCTs and CLCTs
   auto padsClct(matchingGEMPads(clct, pads, part, isCoPad, false));
   auto padsAlct(matchingGEMPads(alct, pads, part, isCoPad, false));
 
   const bool debug(false);
   if (debug) std::cout << "-----------------------------------------------------------------------"<<std::endl;
   // Check if the pads overlap
   for (auto p : padsAlct){
     if (debug) std::cout<< "Candidate ALCT: " << p.first << " " << p.second << std::endl;
     for (auto q: padsClct){
       if (debug) std::cout<< "++Candidate CLCT: " << q.first << " " << q.second << std::endl;
       // look for exactly the same pads
       if ((p.first != q.first) or GEMPadDigi(p.second) != q.second) continue;
       if (debug) std::cout << "++Matches! " << std::endl;
       result.push_back(p);
       if (first) return result;
     }
   }
   if (debug) std::cout << "-----------------------------------------------------------------------"<<std::endl;
   return result;
 }

void CSCMotherboardME11GEM::printGEMTriggerPads	(	int	minBX,
		int	maxBx,
		bool	iscopad = `false`
	)

private

Definition at line 1881 of file CSCMotherboardME11GEM.cc.

References coPads_, gather_cfg::cout, plotBeamSpotDB::first, isPadInOverlap(), CSCMotherboard::lct_central_bx, and pads_.

Referenced by run().

 {
   // pads or copads?
   auto thePads(!iscopad ? pads_ : coPads_); 
   const bool hasPads(thePads.size()!=0);
   
   std::cout << "------------------------------------------------------------------------" << std::endl;
   bool first = true;
   for (int bx = bx_start; bx <= bx_stop; bx++) {
     // print only the pads for the central BX
     if (bx!=lct_central_bx and iscopad) continue;
     std::vector<std::pair<unsigned int, const GEMPadDigi> > in_pads = thePads[bx];
     if (first) {
       if (!iscopad) std::cout << "* GEM trigger pads: " << std::endl;
       else          std::cout << "* GEM trigger coincidence pads: " << std::endl;
     }
     first = false;
     if (!iscopad) std::cout << "N(pads) BX " << bx << " : " << in_pads.size() << std::endl;
     else          std::cout << "N(copads) BX " << bx << " : " << in_pads.size() << std::endl;
     if (hasPads){
       for (auto pad : in_pads){
         auto roll_id(GEMDetId(pad.first));
         std::cout << "\tdetId " << pad.first << " " << roll_id << ", pad = " << pad.second.pad() << ", BX = " << pad.second.bx() + 6;
         if (isPadInOverlap(roll_id.roll())) std::cout << " (in overlap)" << std::endl;
         else std::cout << std::endl;
       }
     }
     else
       break;
   }
 }

std::vector< GEMCoPadDigi > CSCMotherboardME11GEM::readoutCoPads ( )

Definition at line 2053 of file CSCMotherboardME11GEM.cc.

References gemCoPadV.

Referenced by CSCTriggerPrimitivesBuilder::build().

 {
   return gemCoPadV;
 }

std::vector< CSCCorrelatedLCTDigi > CSCMotherboardME11GEM::readoutLCTs ( enum ME11Part me1ab )

Definition at line 979 of file CSCMotherboardME11GEM.cc.

References gather_cfg::cout, CSCMotherboard::early_tbins, getLCTs1a(), getLCTs1b(), ME1A, ME1B, or, CSCMotherboard::readout_earliest_2, sortLCTsByGEMDPhi(), sortLCTsByQuality(), tmb_cross_bx_algo, and CSCMotherboard::tmb_l1a_window_size.

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

std::vector< CSCCorrelatedLCTDigi > CSCMotherboardME11GEM::readoutLCTs1a ( )

Definition at line 964 of file CSCMotherboardME11GEM.cc.

References ME1A, and CSCMotherboard::readoutLCTs().

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

 {
   return readoutLCTs(ME1A);
 }

std::vector< CSCCorrelatedLCTDigi > CSCMotherboardME11GEM::readoutLCTs1b ( )

Definition at line 970 of file CSCMotherboardME11GEM.cc.

References ME1B, and CSCMotherboard::readoutLCTs().

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

 {
   return readoutLCTs(ME1B);
 }

void CSCMotherboardME11GEM::retrieveGEMCoPads	(	const GEMCoPadDigiCollection *	pads,
		unsigned	id
	)

private

Definition at line 1930 of file CSCMotherboardME11GEM.cc.

References coPads_, gem_g, CSCMotherboard::lct_central_bx, maxDeltaBXPad_, and GEMGeometry::superChamber().

Referenced by run().

 {
   auto superChamber(gem_g->superChamber(id));
   for (auto ch : superChamber->chambers()) {
     for (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(lct_central_bx + (pad->second()).bx());
     for (int bx = bx_shifted - maxDeltaBXPad_;bx <= bx_shifted + maxDeltaBXPad_; ++bx) {
       if(bx != lct_central_bx) continue;
       coPads_[bx].push_back(std::make_pair(roll_id, (*pad).second()));  
     }
       }
     }
   }
 }

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

private

Definition at line 1913 of file CSCMotherboardME11GEM.cc.

References gem_g, CSCMotherboard::lct_central_bx, maxDeltaBXPad_, pads_, and GEMGeometry::superChamber().

Referenced by run().

 {
   auto superChamber(gem_g->superChamber(id));
   for (auto ch : superChamber->chambers()) {
     for (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(lct_central_bx + pad->bx());
         for (int bx = bx_shifted - maxDeltaBXPad_;bx <= bx_shifted + maxDeltaBXPad_; ++bx) {
       pads_[bx].push_back(std::make_pair(roll_id, *pad));  
         }
       }
     }
   }
 }

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

Run function for normal usage. Runs cathode and anode LCT processors, takes results and correlates into CorrelatedLCT.

Definition at line 350 of file CSCMotherboardME11GEM.cc.

References CSCMotherboard::alct, alctV, allLCTs1a, allLCTs1b, assignGEMRoll(), b, buildCoincidencePads(), buildLCTfromALCTandGEM_ME1a_, buildLCTfromALCTandGEM_ME1b_, buildLCTfromCLCTandGEM_ME1a_, buildLCTfromCLCTandGEM_ME1b_, CSCTriggerGeomManager::chamber(), CSCGeometry::chamber(), GEMGeometry::chamber(), CSCMotherboard::clct, clct1a, clctV1a, clctV1b, CSCCorrelatedLCTDigi::clear(), clear(), coPads_, correctLCTtimingWithGEM_, correlateLCTsGEM(), gather_cfg::cout, createGEMRollEtaLUT(), csc_g, cscHsToGemPadME1a_, cscHsToGemPadME1b_, cscWgToGemRoll_, debug_gem_matching, debug_luts, drop_used_clcts, dropLowQualityCLCTsNoGEMs_ME1a_, dropLowQualityCLCTsNoGEMs_ME1b_, TrackCollections2monitor_cff::etaMax, TrackCollections2monitor_cff::etaMin, plotBeamSpotDB::first, gem_g, gemPadToCscHsME1a_, gemPadToCscHsME1b_, gemRollToEtaLimits_, CSCTriggerGeometry::get(), runTauDisplay::gp, i, CSCMotherboard::infoV, LogDebug, lut_wg_etaMin_etaMax_even, lut_wg_etaMin_etaMax_odd, match_earliest_clct_me11_only, CSCMotherboard::match_trig_window_size, matchingGEMPads(), CSCAnodeLCTProcessor::MAX_ALCT_BINS, CSCCathodeLCTProcessor::MAX_CLCT_BINS, CSCMotherboard::MAX_LCT_BINS, max_me11_lcts, maxDeltaBXCoPad_, maxDeltaBXCoPadEven_, maxDeltaBXCoPadOdd_, maxDeltaBXPad_, maxDeltaBXPadEven_, maxDeltaBXPadOdd_, maxDeltaPadCoPad_, maxDeltaPadCoPadEven_, maxDeltaPadCoPadOdd_, maxDeltaPadPad_, maxDeltaPadPadEven_, maxDeltaPadPadOdd_, ME1A, ME1B, or, AlCaHLTBitMon_ParallelJobs::p, pads_, pref, printGEMTriggerPads(), TrackCollections2monitor_cff::quality, readoutLCTs1a(), readoutLCTs1b(), HLT_FULL_cff::region, retrieveGEMCoPads(), retrieveGEMPads(), runME11ILT_, smartME1aME1b, CSCMotherboard::theEndcap, CSCMotherboard::theSector, CSCMotherboard::theStation, CSCMotherboard::theSubsector, CSCMotherboard::theTrigChamber, and tmb_cross_bx_algo.

Referenced by CSCTriggerPrimitivesBuilder::build().

 {
   clear();
   
   if (!( alct and clct and  clct1a and smartME1aME1b))
   {
     if (infoV >= 0) edm::LogError("L1CSCTPEmulatorSetupError")
       << "+++ run() called for non-existing ALCT/CLCT processor! +++ \n";
     return;
   }
 
   alctV = alct->run(wiredc); // run anodeLCT
   clctV1b = clct->run(compdc); // run cathodeLCT in ME1/b
   clctV1a = clct1a->run(compdc); // run cathodeLCT in ME1/a
 
   bool gemGeometryAvailable(false);
   if (gem_g != nullptr) {
     if (infoV >= 0) edm::LogInfo("L1CSCTPEmulatorSetupInfo")
       << "+++ run() called for GEM-CSC integrated trigger! +++ \n";
     gemGeometryAvailable = true;
   }
   
   int used_clct_mask[20], used_clct_mask_1a[20];
   for (int b=0;b<20;b++)
     used_clct_mask[b] = used_clct_mask_1a[b] = 0;
 
   // retrieve CSCChamber geometry                                                                                                                                       
   CSCTriggerGeomManager* geo_manager(CSCTriggerGeometry::get());
   const CSCChamber* cscChamberME1b(geo_manager->chamber(theEndcap, theStation, theSector, theSubsector, theTrigChamber));
   const CSCDetId me1bId(cscChamberME1b->id());
   const CSCDetId me1aId(me1bId.endcap(), 1, 4, me1bId.chamber());
   const CSCChamber* cscChamberME1a(csc_g->chamber(me1aId));
 
   if (runME11ILT_){
       
     // check for GEM geometry
     if (not gemGeometryAvailable){
       if (infoV >= 0) edm::LogError("L1CSCTPEmulatorSetupError")
     << "+++ run() called for GEM-CSC integrated trigger without valid GEM geometry! +++ \n";
       return;
     }
 
     // trigger geometry
     const CSCLayer* keyLayerME1b(cscChamberME1b->layer(3));
     const CSCLayerGeometry* keyLayerGeometryME1b(keyLayerME1b->geometry());
     const CSCLayer* keyLayerME1a(cscChamberME1a->layer(3));
     const CSCLayerGeometry* keyLayerGeometryME1a(keyLayerME1a->geometry());
 
     const bool isEven(me1bId.chamber()%2==0);
     const int region((theEndcap == 1) ? 1: -1);
     const GEMDetId gem_id(region, 1, theStation, 1, me1bId.chamber(), 0);
     const GEMChamber* gemChamber(gem_g->chamber(gem_id));
 
     // initialize depending on whether even or odd     
     maxDeltaBXPad_ = isEven ? maxDeltaBXPadEven_ : maxDeltaBXPadOdd_;
     maxDeltaPadPad_ = isEven ? maxDeltaPadPadEven_ : maxDeltaPadPadOdd_;
     maxDeltaBXCoPad_ = isEven ? maxDeltaBXCoPadEven_ : maxDeltaBXCoPadOdd_;
     maxDeltaPadCoPad_ = isEven ? maxDeltaPadCoPadEven_ : maxDeltaPadCoPadOdd_;
     
     // LUT<roll,<etaMin,etaMax> >    
     createGEMRollEtaLUT(isEven);
     if (debug_luts){
       LogDebug("CSCMotherboardME11GEM") << "me1b Det "<< me1bId<<" "<< me1bId.rawId() <<" " 
                     << (isEven ? "Even":"odd") <<" chamber "<< me1bId.chamber()<<std::endl;
       if (gemRollToEtaLimits_.size())
         for(auto p : gemRollToEtaLimits_) 
       LogDebug("CSCMotherboardME11GEM") << "pad "<< p.first << " min eta " << (p.second).first << " max eta " << (p.second).second << std::endl;
     }
     
     // loop on all wiregroups to create a LUT <WG,rollMin,rollMax>
     const int numberOfWG(keyLayerGeometryME1b->numberOfWireGroups());
     for (int i = 0; i< numberOfWG; ++i){
       auto etaMin(isEven ? lut_wg_etaMin_etaMax_even[i][1] : lut_wg_etaMin_etaMax_odd[i][1]); 
       auto etaMax(isEven ? lut_wg_etaMin_etaMax_even[i][2] : lut_wg_etaMin_etaMax_odd[i][2]); 
       cscWgToGemRoll_[i] = std::make_pair(assignGEMRoll(etaMin), assignGEMRoll(etaMax));
     }
     if (debug_luts){
       for(auto p : cscWgToGemRoll_) {
     LogDebug("CSCMotherboardME11GEM") << "WG "<< p.first << " GEM pads " << (p.second).first << " " << (p.second).second << std::endl;
       }
     }
 
     // pick any roll
     auto randRoll(gemChamber->etaPartition(2));
 
     // ME1a
     auto nStripsME1a(keyLayerGeometryME1a->numberOfStrips());
     for (float i = 0; i< nStripsME1a; i = i+0.5){
       const LocalPoint lpCSC(keyLayerGeometryME1a->topology()->localPosition(i));
       const GlobalPoint gp(keyLayerME1a->toGlobal(lpCSC));
       const LocalPoint lpGEM(randRoll->toLocal(gp));
       const int HS(i/0.5);
       const bool edge(HS < 4 or HS > 93);
       const float pad(edge ? -99 : randRoll->pad(lpGEM));
       // HS are wrapped-around
       cscHsToGemPadME1a_[HS] = std::make_pair(std::floor(pad),std::ceil(pad));
     }
     // ME1b
     auto nStripsME1b(keyLayerGeometryME1b->numberOfStrips());
     for (float i = 0; i< nStripsME1b; i = i+0.5){
       const LocalPoint lpCSC(keyLayerGeometryME1b->topology()->localPosition(i));
       const GlobalPoint gp(keyLayerME1b->toGlobal(lpCSC));
       const LocalPoint lpGEM(randRoll->toLocal(gp));
       const int HS(i/0.5);
       const bool edge(HS < 5 or HS > 124);
       const float pad(edge ? -99 : randRoll->pad(lpGEM));
       // HS are wrapped-around
       cscHsToGemPadME1b_[HS] = std::make_pair(std::floor(pad),std::ceil(pad));
     }
     if (debug_luts){
       LogDebug("CSCMotherboardME11GEM") << "detId " << me1bId;
       LogDebug("CSCMotherboardME11GEM") << "CSCHSToGEMPad LUT in ME1a";
       for(auto p : cscHsToGemPadME1a_) {
         LogDebug("CSCMotherboardME11GEM") << "CSC HS "<< p.first << " GEM Pad low " << (p.second).first << " GEM Pad high " << (p.second).second;
       }
       LogDebug("CSCMotherboardME11GEM") << "CSCHSToGEMPad LUT in ME1b";
       for(auto p : cscHsToGemPadME1b_) {
         LogDebug("CSCMotherboardME11GEM") << "CSC HS "<< p.first << " GEM Pad low " << (p.second).first << " GEM Pad high " << (p.second).second;
       }
     }
 
     const int nGEMPads(randRoll->npads());
     for (int i = 0; i< nGEMPads; ++i){
       const LocalPoint lpGEM(randRoll->centreOfPad(i));
       const GlobalPoint gp(randRoll->toGlobal(lpGEM));
       const LocalPoint lpCSCME1a(keyLayerME1a->toLocal(gp));
       const LocalPoint lpCSCME1b(keyLayerME1b->toLocal(gp));
       const float stripME1a(keyLayerGeometryME1a->strip(lpCSCME1a));
       const float stripME1b(keyLayerGeometryME1b->strip(lpCSCME1b));
       // HS are wrapped-around
       gemPadToCscHsME1a_[i] = (int) (stripME1a - 0.25)/0.5;
       gemPadToCscHsME1b_[i] = (int) (stripME1b - 0.25)/0.5;
     }
     if (debug_luts){
       LogDebug("CSCMotherboardME11GEM") << "detId " << me1bId;
       LogDebug("CSCMotherboardME11GEM") << "GEMPadToCSCHs LUT in ME1a";
       for(auto p : gemPadToCscHsME1a_) {
         LogDebug("CSCMotherboardME11GEM") << "GEM Pad "<< p.first << " CSC HS: " << p.second;
       }
       LogDebug("CSCMotherboardME11GEM") << "GEMPadToCSCHs LUT in ME1b";
       for(auto p : gemPadToCscHsME1b_) {
         LogDebug("CSCMotherboardME11GEM") << "GEM Pad "<< p.first << " CSC HS: " << p.second;
       }
     }
 
     // build coincidence pads
     std::unique_ptr<GEMCoPadDigiCollection> pCoPads(new GEMCoPadDigiCollection());
     buildCoincidencePads(gemPads, *pCoPads, me1bId);
     
     // retrieve pads and copads in a certain BX window for this CSC 
     pads_.clear();
     coPads_.clear();
     retrieveGEMPads(gemPads, gem_id);
     retrieveGEMCoPads(pCoPads.get(), gem_id);
   }
   
   const bool hasPads(pads_.size()!=0);
   const bool hasCoPads(hasPads and coPads_.size()!=0);
   bool hasLCTs(false);
 
   // ALCT-centric matching
   for (int bx_alct = 0; bx_alct < CSCAnodeLCTProcessor::MAX_ALCT_BINS; bx_alct++)
   {
     if (alct->bestALCT[bx_alct].isValid())
     {
       const int bx_clct_start(bx_alct - match_trig_window_size/2);
       const int bx_clct_stop(bx_alct + match_trig_window_size/2);
       const int bx_copad_start(bx_alct - maxDeltaBXCoPad_);
       const int bx_copad_stop(bx_alct + maxDeltaBXCoPad_);
 
       if (debug_gem_matching){ 
         std::cout << "========================================================================" << std::endl;
         std::cout << "ALCT-CLCT matching in ME1/1 chamber: " << cscChamberME1b->id() << std::endl;
         std::cout << "------------------------------------------------------------------------" << std::endl;
         std::cout << "+++ Best ALCT Details: ";
         alct->bestALCT[bx_alct].print();
         std::cout << "+++ Second ALCT Details: ";
         alct->secondALCT[bx_alct].print();
         
         printGEMTriggerPads(bx_clct_start, bx_clct_stop);      
         printGEMTriggerPads(bx_clct_start, bx_clct_stop, true);      
         
         std::cout << "------------------------------------------------------------------------" << std::endl;
         std::cout << "Attempt ALCT-CLCT matching in ME1/b in bx range: [" << bx_clct_start << "," << bx_clct_stop << "]" << std::endl;
       }
       
       // ALCT-to-CLCT matching in ME1b
       int nSuccesFulMatches = 0;
       for (int bx_clct = bx_clct_start; bx_clct <= bx_clct_stop; bx_clct++)
       {
         if (bx_clct < 0 or bx_clct >= CSCCathodeLCTProcessor::MAX_CLCT_BINS) continue;
         if (drop_used_clcts and used_clct_mask[bx_clct]) continue;
         if (clct->bestCLCT[bx_clct].isValid())
         {
           const int quality(clct->bestCLCT[bx_clct].getQuality());
           if (debug_gem_matching) std::cout << "++Valid ME1b CLCT: " << clct->bestCLCT[bx_clct] << std::endl;
 
       // pick the pad that corresponds 
       auto matchingPads(matchingGEMPads(clct->bestCLCT[bx_clct], alct->bestALCT[bx_alct], pads_[bx_clct], ME1B, false));
       auto matchingCoPads(matchingGEMPads(clct->bestCLCT[bx_clct], alct->bestALCT[bx_alct], coPads_[bx_clct], ME1B, true));
           if (runME11ILT_ and dropLowQualityCLCTsNoGEMs_ME1b_ and quality < 4 and hasPads){
             int nFound(matchingPads.size());
             const bool clctInEdge(clct->bestCLCT[bx_clct].getKeyStrip() < 5 or clct->bestCLCT[bx_clct].getKeyStrip() > 124);
             if (clctInEdge){
               if (debug_gem_matching) std::cout << "\tInfo: low quality CLCT in CSC chamber edge, don't care about GEM pads" << std::endl;
             }
             else {
               if (nFound != 0){
                 if (debug_gem_matching) std::cout << "\tInfo: low quality CLCT with " << nFound << " matching GEM trigger pads" << std::endl;
               }
               else {
                 if (debug_gem_matching) std::cout << "\tWarning: low quality CLCT without matching GEM trigger pad" << std::endl;
                 continue;
               }
             }
           }
 
           // check timing
           if (runME11ILT_ and correctLCTtimingWithGEM_){
             int nFound(matchingCoPads.size());
             if (nFound != 0 and bx_alct == 6 and bx_clct != 6){
               if (debug_gem_matching) std::cout << "\tInfo: CLCT with incorrect timing" << std::endl;
               continue;
             }
           }
           
           ++nSuccesFulMatches;
       
           hasLCTs = true;
           //        if (infoV > 1) LogTrace("CSCMotherboard")
           int mbx = bx_clct-bx_clct_start;
           correlateLCTsGEM(alct->bestALCT[bx_alct], alct->secondALCT[bx_alct],
                clct->bestCLCT[bx_clct], clct->secondCLCT[bx_clct],
                allLCTs1b[bx_alct][mbx][0], allLCTs1b[bx_alct][mbx][1], ME1B, matchingPads, matchingCoPads);
           if (debug_gem_matching) {
             std::cout << "Successful ALCT-CLCT match in ME1b: bx_alct = " << bx_alct
                       << "; match window: [" << bx_clct_start << "; " << bx_clct_stop
                       << "]; bx_clct = " << bx_clct << std::endl;
             std::cout << "+++ Best CLCT Details: ";
             clct->bestCLCT[bx_clct].print();
             std::cout << "+++ Second CLCT Details: ";
             clct->secondCLCT[bx_clct].print();
           }
           
           if (allLCTs1b[bx_alct][mbx][0].isValid()) {
             used_clct_mask[bx_clct] += 1;
             if (match_earliest_clct_me11_only) break;
           }
         }
       }
 
       // ALCT-to-GEM matching in ME1b
       int nSuccesFulGEMMatches = 0;
       if (runME11ILT_ and nSuccesFulMatches==0 and buildLCTfromALCTandGEM_ME1b_){
         if (debug_gem_matching) std::cout << "++No valid ALCT-CLCT matches in ME1b" << std::endl;
         for (int bx_gem = bx_copad_start; bx_gem <= bx_copad_stop; bx_gem++) {
           if (not hasCoPads) {
             continue;
           }
           
           // find the best matching copad - first one 
           auto copads(matchingGEMPads(alct->bestALCT[bx_alct], coPads_[bx_gem], ME1B, true));             
           if (debug_gem_matching) std::cout << "\t++Number of matching GEM CoPads in BX " << bx_alct << " : "<< copads.size() << std::endl;
           if (copads.size()==0) {
             continue;
           }
           
           correlateLCTsGEM(alct->bestALCT[bx_alct], alct->secondALCT[bx_alct],
                            copads.at(0).second, allLCTs1b[bx_alct][0][0], allLCTs1b[bx_alct][0][1], ME1B);
           if (allLCTs1b[bx_alct][0][0].isValid()) {
             ++nSuccesFulGEMMatches;            
             if (match_earliest_clct_me11_only) break;
           }
           if (debug_gem_matching) {
             std::cout << "Successful ALCT-GEM CoPad match in ME1b: bx_alct = " << bx_alct << std::endl << std::endl;
             std::cout << "------------------------------------------------------------------------" << std::endl << std::endl;
           }
         }
       }
 
       if (debug_gem_matching) {
         std::cout << "========================================================================" << std::endl;
         std::cout << "Summary: " << std::endl;
         if (nSuccesFulMatches>1)
           std::cout << "Too many successful ALCT-CLCT matches in ME1b: " << nSuccesFulMatches
                     << ", CSCDetId " << cscChamberME1b->id()
                     << ", bx_alct = " << bx_alct
                     << "; match window: [" << bx_clct_start << "; " << bx_clct_stop << "]" << std::endl;
         else if (nSuccesFulMatches==1)
           std::cout << "1 successful ALCT-CLCT match in ME1b: " 
                     << " CSCDetId " << cscChamberME1b->id()
                     << ", bx_alct = " << bx_alct
                     << "; match window: [" << bx_clct_start << "; " << bx_clct_stop << "]" << std::endl;
         else if (nSuccesFulGEMMatches==1)
           std::cout << "1 successful ALCT-GEM match in ME1b: " 
                     << " CSCDetId " << cscChamberME1b->id()
                     << ", bx_alct = " << bx_alct
                     << "; match window: [" << bx_clct_start << "; " << bx_clct_stop << "]" << std::endl;
         else 
           std::cout << "Unsuccessful ALCT-CLCT match in ME1b: " 
                     << "CSCDetId " << cscChamberME1b->id()
                     << ", bx_alct = " << bx_alct
                     << "; match window: [" << bx_clct_start << "; " << bx_clct_stop << "]" << std::endl;
 
         std::cout << "------------------------------------------------------------------------" << std::endl;
         std::cout << "Attempt ALCT-CLCT matching in ME1/a in bx range: [" << bx_clct_start << "," << bx_clct_stop << "]" << std::endl;
       }
 
       // ALCT-to-CLCT matching in ME1a
       nSuccesFulMatches = 0;
       for (int bx_clct = bx_clct_start; bx_clct <= bx_clct_stop; bx_clct++)
       {
         if (bx_clct < 0 or bx_clct >= CSCCathodeLCTProcessor::MAX_CLCT_BINS) continue;
         if (drop_used_clcts and used_clct_mask_1a[bx_clct]) continue;
         if (clct1a->bestCLCT[bx_clct].isValid())
         {
           const int quality(clct1a->bestCLCT[bx_clct].getQuality());
           if (debug_gem_matching) std::cout << "++Valid ME1a CLCT: " << clct1a->bestCLCT[bx_clct] << std::endl;
 
       // pick the pad that corresponds 
       auto matchingPads(matchingGEMPads(clct1a->bestCLCT[bx_clct], alct->bestALCT[bx_alct], pads_[bx_clct], ME1A, false));
       auto matchingCoPads(matchingGEMPads(clct1a->bestCLCT[bx_clct], alct->bestALCT[bx_alct], coPads_[bx_clct], ME1A, true));
           if (runME11ILT_ and dropLowQualityCLCTsNoGEMs_ME1a_ and quality < 4 and hasPads){
             int nFound(matchingPads.size());
             const bool clctInEdge(clct1a->bestCLCT[bx_clct].getKeyStrip() < 4 or clct1a->bestCLCT[bx_clct].getKeyStrip() > 93);
             if (clctInEdge){
               if (debug_gem_matching) std::cout << "\tInfo: low quality CLCT in CSC chamber edge, don't care about GEM pads" << std::endl;
             }
             else {
               if (nFound != 0){
                 if (debug_gem_matching) std::cout << "\tInfo: low quality CLCT with " << nFound << " matching GEM trigger pads" << std::endl;
               }
               else {
                 if (debug_gem_matching) std::cout << "\tWarning: low quality CLCT without matching GEM trigger pad" << std::endl;
                 continue;
               }
             }
           }
           ++nSuccesFulMatches;
           int mbx = bx_clct-bx_clct_start;
           correlateLCTsGEM(alct->bestALCT[bx_alct], alct->secondALCT[bx_alct],
                clct1a->bestCLCT[bx_clct], clct1a->secondCLCT[bx_clct],
                allLCTs1a[bx_alct][mbx][0], allLCTs1a[bx_alct][mbx][1], ME1A, matchingPads, matchingCoPads);
           if (debug_gem_matching) {
             std::cout << "Successful ALCT-CLCT match in ME1a: bx_alct = " << bx_alct
                       << "; match window: [" << bx_clct_start << "; " << bx_clct_stop
                       << "]; bx_clct = " << bx_clct << std::endl;
             std::cout << "+++ Best CLCT Details: ";
             clct1a->bestCLCT[bx_clct].print();
             std::cout << "+++ Second CLCT Details: ";
             clct1a->secondCLCT[bx_clct].print();
           }
           if (allLCTs1a[bx_alct][mbx][0].isValid()){
             used_clct_mask_1a[bx_clct] += 1;
             if (match_earliest_clct_me11_only) break;
           }
         }
       }
 
       // ALCT-to-GEM matching in ME1a
       nSuccesFulGEMMatches = 0;
       if (runME11ILT_ and nSuccesFulMatches==0 and buildLCTfromALCTandGEM_ME1a_){
         if (debug_gem_matching) std::cout << "++No valid ALCT-CLCT matches in ME1a" << std::endl;
         for (int bx_gem = bx_copad_start; bx_gem <= bx_copad_stop; bx_gem++) {
           if (not hasCoPads) {
             continue;
           }
 
           // find the best matching copad - first one 
           auto copads(matchingGEMPads(alct->bestALCT[bx_alct], coPads_[bx_gem], ME1A, true));             
           if (debug_gem_matching) std::cout << "\t++Number of matching GEM CoPads in BX " << bx_alct << " : "<< copads.size() << std::endl;
           if (copads.size()==0) {
             continue;
           }
           
           correlateLCTsGEM(alct->bestALCT[bx_alct], alct->secondALCT[bx_alct],
                            copads.at(0).second, allLCTs1a[bx_alct][0][0], allLCTs1a[bx_alct][0][1], ME1A);
           if (allLCTs1a[bx_alct][0][0].isValid()) {
              ++nSuccesFulGEMMatches;            
             if (match_earliest_clct_me11_only) break;
           }
           if (debug_gem_matching) {
             std::cout << "Successful ALCT-GEM CoPad match in ME1a: bx_alct = " << bx_alct << std::endl << std::endl;
             std::cout << "------------------------------------------------------------------------" << std::endl << std::endl;
           }
         }
       }
             
       if (debug_gem_matching) {
         std::cout << "========================================================================" << std::endl;
         std::cout << "Summary: " << std::endl;
         if (nSuccesFulMatches>1)
           std::cout << "Too many successful ALCT-CLCT matches in ME1a: " << nSuccesFulMatches
                     << ", CSCDetId " << cscChamberME1a->id()
                     << ", bx_alct = " << bx_alct
                     << "; match window: [" << bx_clct_start << "; " << bx_clct_stop << "]" << std::endl;
         else if (nSuccesFulMatches==1)
           std::cout << "1 successful ALCT-CLCT match in ME1a: " 
                     << " CSCDetId " << cscChamberME1a->id()
                     << ", bx_alct = " << bx_alct
                     << "; match window: [" << bx_clct_start << "; " << bx_clct_stop << "]" << std::endl;
         else if (nSuccesFulGEMMatches==1)
           std::cout << "1 successful ALCT-GEM match in ME1a: " 
                     << " CSCDetId " << cscChamberME1a->id()
                     << ", bx_alct = " << bx_alct
                     << "; match window: [" << bx_clct_start << "; " << bx_clct_stop << "]" << std::endl;
         else 
           std::cout << "Unsuccessful ALCT-CLCT match in ME1a: " 
                     << "CSCDetId " << cscChamberME1a->id()
                     << ", bx_alct = " << bx_alct
                     << "; match window: [" << bx_clct_start << "; " << bx_clct_stop << "]" << std::endl;
       }
 
     } // end of ALCT valid block 
     else {
       auto coPads(coPads_[bx_alct]);
       if (runME11ILT_ and coPads.size()!=0) {
         // keep it simple for the time being, only consider the first copad
         const int bx_clct_start(bx_alct - match_trig_window_size/2);
         const int bx_clct_stop(bx_alct + match_trig_window_size/2);
         
         // matching in ME1b
         if (buildLCTfromCLCTandGEM_ME1b_) {
           for (int bx_clct = bx_clct_start; bx_clct <= bx_clct_stop; bx_clct++) {
             if (bx_clct < 0 or bx_clct >= CSCCathodeLCTProcessor::MAX_CLCT_BINS) continue;
             if (drop_used_clcts and used_clct_mask[bx_clct]) continue;
             if (clct->bestCLCT[bx_clct].isValid()) {
               const int quality(clct->bestCLCT[bx_clct].getQuality());
               // only use high-Q stubs for the time being
               if (quality < 4) continue;
               int mbx = bx_clct-bx_clct_start;            
               correlateLCTsGEM(clct->bestCLCT[bx_clct], clct->secondCLCT[bx_clct], coPads[0].second, GEMDetId(coPads[0].first).roll(),
                                allLCTs1b[bx_alct][mbx][0], allLCTs1b[bx_alct][mbx][1], ME1B);
               if (debug_gem_matching) {
                 //      if (infoV > 1) LogTrace("CSCMotherboard")
                 std::cout << "Successful GEM-CLCT match in ME1b: bx_alct = " << bx_alct
                           << "; match window: [" << bx_clct_start << "; " << bx_clct_stop
                           << "]; bx_clct = " << bx_clct << std::endl;
                 std::cout << "+++ Best CLCT Details: ";
                 clct->bestCLCT[bx_clct].print();
                 std::cout << "+++ Second CLCT Details: ";
                 clct->secondCLCT[bx_clct].print();
               }
               if (allLCTs1b[bx_alct][mbx][0].isValid()) {
                 used_clct_mask[bx_clct] += 1;
                 if (match_earliest_clct_me11_only) break;
               }
             }
           }
         }
 
         // matching in ME1a
         if (buildLCTfromCLCTandGEM_ME1a_) {
           for (int bx_clct = bx_clct_start; bx_clct <= bx_clct_stop; bx_clct++) {
             if (bx_clct < 0 || bx_clct >= CSCCathodeLCTProcessor::MAX_CLCT_BINS) continue;
             if (drop_used_clcts && used_clct_mask_1a[bx_clct]) continue;
             if (clct1a->bestCLCT[bx_clct].isValid()){
               const int quality(clct1a->bestCLCT[bx_clct].getQuality());
               // only use high-Q stubs for the time being
               if (quality < 4) continue;
               int mbx = bx_clct-bx_clct_start;            
               correlateLCTsGEM(clct1a->bestCLCT[bx_clct], clct1a->secondCLCT[bx_clct], coPads[0].second, GEMDetId(coPads[0].first).roll(),
                                allLCTs1a[bx_alct][mbx][0], allLCTs1a[bx_alct][mbx][1], ME1A);
               if (debug_gem_matching) {
                 //      if (infoV > 1) LogTrace("CSCMotherboard")
                 std::cout << "Successful GEM-CLCT match in ME1a: bx_alct = " << bx_alct
                           << "; match window: [" << bx_clct_start << "; " << bx_clct_stop
                           << "]; bx_clct = " << bx_clct << std::endl;
                 std::cout << "+++ Best CLCT Details: ";
                 clct1a->bestCLCT[bx_clct].print();
                 std::cout << "+++ Second CLCT Details: ";
                 clct1a->secondCLCT[bx_clct].print();
               }
               if (allLCTs1a[bx_alct][mbx][0].isValid()){
                 used_clct_mask_1a[bx_clct] += 1;
                 if (match_earliest_clct_me11_only) break;
               }
             }
           }
         }
       }        
     }
   } // end of ALCT-centric matching
   
   if (hasLCTs and debug_gem_matching){
     std::cout << "========================================================================" << std::endl;
     std::cout << "Counting the LCTs" << std::endl;
     std::cout << "========================================================================" << std::endl;
   }
   
   // reduction of nLCTs per each BX
   for (int bx = 0; bx < MAX_LCT_BINS; bx++)
   {
     // counting
     unsigned int n1a=0, n1b=0;
     for (unsigned int mbx = 0; mbx < match_trig_window_size; mbx++)
       for (int i=0;i<2;i++)
       {
         int cbx = bx + mbx - match_trig_window_size/2;
         if (allLCTs1b[bx][mbx][i].isValid())
         {
           n1b++;
       if (infoV > 0) LogDebug("CSCMotherboard") 
         << "1b LCT"<<i+1<<" "<<bx<<"/"<<cbx<<": "<<allLCTs1b[bx][mbx][i]<<std::endl;
         }
         if (allLCTs1a[bx][mbx][i].isValid())
         {
           n1a++;
       if (infoV > 0) LogDebug("CSCMotherboard") 
         << "1a LCT"<<i+1<<" "<<bx<<"/"<<cbx<<": "<<allLCTs1a[bx][mbx][i]<<std::endl;
         }
       }
     if (infoV > 0 and n1a+n1b>0) LogDebug("CSCMotherboard") 
       <<"bx "<<bx<<" nLCT:"<<n1a<<" "<<n1b<<" "<<n1a+n1b<<std::endl;
     
     // some simple cross-bx sorting algorithms
     if (tmb_cross_bx_algo == 1 and (n1a>2 or n1b>2) )
     {
       n1a=0, n1b=0;
       for (unsigned int mbx = 0; mbx < match_trig_window_size; mbx++)
         for (int i=0;i<2;i++)
         {
           if (allLCTs1b[bx][pref[mbx]][i].isValid())
           {
             n1b++;
             if (n1b>2) allLCTs1b[bx][pref[mbx]][i].clear();
           }
           if (allLCTs1a[bx][pref[mbx]][i].isValid())
           {
             n1a++;
             if (n1a>2) allLCTs1a[bx][pref[mbx]][i].clear();
           }
         }
 
       n1a=0, n1b=0;
       for (unsigned int mbx = 0; mbx < match_trig_window_size; mbx++)
         for (int i=0;i<2;i++)
         {
           int cbx = bx + mbx - match_trig_window_size/2;
           if (allLCTs1b[bx][mbx][i].isValid())
           {
             n1b++;
            if (infoV > 0) LogDebug("CSCMotherboard") 
              << "1b LCT"<<i+1<<" "<<bx<<"/"<<cbx<<": "<<allLCTs1b[bx][mbx][i]<<std::cout;
           }
           if (allLCTs1a[bx][mbx][i].isValid())
           {
             n1a++;
             if (infoV > 0) LogDebug("CSCMotherboard") 
               << "1a LCT"<<i+1<<" "<<bx<<"/"<<cbx<<": "<<allLCTs1a[bx][mbx][i]<<std::cout;
           }
         }
       if (infoV > 0 and n1a+n1b>0) LogDebug("CSCMotherboard") 
         <<"bx "<<bx<<" nnLCT:"<<n1a<<" "<<n1b<<" "<<n1a+n1b<<std::endl;
     } // x-bx sorting
 
     // Maximum 2 per whole ME11 per BX case:
     // (supposedly, now we should have max 2 per bx in each 1a and 1b)
     if (n1a+n1b > max_me11_lcts and tmb_cross_bx_algo == 1)
     {
       // do it simple so far: take all low eta 1/b stubs
       unsigned int nLCT=n1b;
       n1a=0;
       // right now nLCT<=2; cut 1a if necessary
       for (unsigned int mbx=0; mbx<match_trig_window_size; mbx++)
         for (int i=0;i<2;i++)
           if (allLCTs1a[bx][mbx][i].isValid()) {
             nLCT++;
             if (nLCT>max_me11_lcts) allLCTs1a[bx][mbx][i].clear();
             else n1a++;
           }
       // if (infoV > 0 and nLCT>0) LogDebug("CSCMotherboard") 
 //       std::cout <<"bx "<<bx<<" nnnLCT: "<<n1a<<" "<<n1b<<" "<<n1a+n1b<<std::cout;
     }
   }// reduction per bx
   
   bool first = true;
   unsigned int n1b=0, n1a=0;
   for (auto p : readoutLCTs1b())
     {
       if (debug_gem_matching and first){
         std::cout << "========================================================================" << std::endl;
         std::cout << "Counting the final LCTs" << std::endl;
         std::cout << "========================================================================" << std::endl;
         first = false;
         std::cout << "tmb_cross_bx_algo: " << tmb_cross_bx_algo << std::endl;
         
       }
       n1b++;
       if (debug_gem_matching)
         std::cout << "1b LCT "<<n1b<<"  " << p <<std::endl;
     }
   
   for (auto p : readoutLCTs1a())
     {
       if (debug_gem_matching and first){
         std::cout << "========================================================================" << std::endl;
         std::cout << "Counting the final LCTs" << std::endl;
         std::cout << "========================================================================" << std::endl;
         first = false;
         std::cout << "tmb_cross_bx_algo: " << tmb_cross_bx_algo << std::endl;
       }
       n1a++;
       if (debug_gem_matching)
         std::cout << "1a LCT "<<n1a<<"  " << p <<std::endl;
     }
   
   //   if (infoV > 1) LogTrace("CSCMotherboardME11GEM")<<"clct_count E:"<<theEndcap<<"S:"<<theStation<<"R:"<<1<<"C:"
   //                           <<CSCTriggerNumbering::chamberFromTriggerLabels(theSector,theSubsector, theStation, theTrigChamber)
   //                           <<"  a "<<n_clct_a<<"  b "<<n_clct_b<<"  ab "<<n_clct_a+n_clct_b;
 }

void CSCMotherboardME11GEM::setConfigParameters ( const CSCDBL1TPParameters * conf )

Set configuration parameters obtained via EventSetup mechanism.

Definition at line 341 of file CSCMotherboardME11GEM.cc.

References CSCMotherboard::alct, CSCMotherboard::clct, and clct1a.

 {
   alct->setConfigParameters(conf);
   clct->setConfigParameters(conf);
   clct1a->setConfigParameters(conf);
   // No config. parameters in DB for the TMB itself yet.
 }

void CSCMotherboardME11GEM::setCSCGeometry ( const CSCGeometry * g )

inline

set CSC and GEM geometries for the matching needs

Definition at line 85 of file CSCMotherboardME11GEM.h.

References csc_g, and g.

Referenced by CSCTriggerPrimitivesBuilder::build().

85 { csc_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

CSCMotherboardME11GEM::csc_g

const CSCGeometry * csc_g

Definition: CSCMotherboardME11GEM.h:192

void CSCMotherboardME11GEM::setGEMGeometry ( const GEMGeometry * g )

inline

Definition at line 86 of file CSCMotherboardME11GEM.h.

References g, and gem_g.

Referenced by CSCTriggerPrimitivesBuilder::build().

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

CSCMotherboardME11GEM::gem_g

const GEMGeometry * gem_g

Definition: CSCMotherboardME11GEM.h:193

std::vector< CSCCorrelatedLCTDigi > CSCMotherboardME11GEM::sortLCTsByGEMDPhi	(	int	bx,
		enum ME11Part	me = `ME1B`
	)

Definition at line 1151 of file CSCMotherboardME11GEM.cc.

References allLCTs1a, allLCTs1b, i, CSCMotherboard::match_trig_window_size, max_me11_lcts, ME1A, and CSCMotherboard::sortByGEMDphi().

Referenced by readoutLCTs(), and sortLCTsByGEMDPhi().

 {
    
   auto allLCTs(me==ME1A ? allLCTs1a : allLCTs1b); 
   std::vector<CSCCorrelatedLCTDigi> LCTs;
   std::vector<CSCCorrelatedLCTDigi> tmpV;
   tmpV.clear();
   LCTs.clear();
   for (unsigned int mbx = 0; mbx < match_trig_window_size; mbx++) 
     for (int i=0;i<2;i++)
       if (allLCTs[bx][mbx][i].isValid())  
         LCTs.push_back(allLCTs[bx][mbx][i]);
 
   std::sort(LCTs.begin(), LCTs.end(), CSCMotherboard::sortByGEMDphi);
   tmpV = LCTs;
   if (tmpV.size() > max_me11_lcts) tmpV.erase(tmpV.begin()+max_me11_lcts, tmpV.end());
   return tmpV;
 }

std::vector< CSCCorrelatedLCTDigi > CSCMotherboardME11GEM::sortLCTsByGEMDPhi ( enum ME11Part me = ME1B )

Definition at line 1182 of file CSCMotherboardME11GEM.cc.

References firstTwoLCTsInChamber_, CSCMotherboard::MAX_LCT_BINS, ME1A, ME1B, and sortLCTsByGEMDPhi().

 {
   std::vector<CSCCorrelatedLCTDigi> LCTs_final;
   LCTs_final.clear();
   for (int bx = 0; bx < MAX_LCT_BINS; bx++)
     {
       std::vector<CSCCorrelatedLCTDigi> LCTs1a;
       std::vector<CSCCorrelatedLCTDigi> LCTs1b;
       std::vector<CSCCorrelatedLCTDigi> LCTs_tmp;
       std::vector<CSCCorrelatedLCTDigi> LCTs_tmp1;
       LCTs1a = sortLCTsByGEMDPhi(bx, ME1A);
       LCTs1b = sortLCTsByGEMDPhi(bx, ME1B);
       std::vector<CSCCorrelatedLCTDigi>::iterator it1a = LCTs1a.begin();
       std::vector<CSCCorrelatedLCTDigi>::iterator it1b = LCTs1b.begin();
       LCTs_tmp.insert(LCTs_tmp.begin(), LCTs1b.begin(), LCTs1b.end());
       LCTs_tmp.insert(LCTs_tmp.end(), LCTs1a.begin(), LCTs1a.end());
       LCTs_tmp1 = sortLCTsByGEMDPhi(LCTs_tmp);//LCTs reduction per BX
       if (firstTwoLCTsInChamber_)
         {
           std::vector<CSCCorrelatedLCTDigi>::iterator itp = LCTs_tmp1.begin();
           while (itp != LCTs_tmp1.end())
             {
               if (me==ME1B and it1b != LCTs1b.end() and *itp==*it1b)
                 {
                   LCTs_final.push_back(*it1b);
                   it1b++;
                 }
               if (me==ME1A and it1a != LCTs1a.end() and *itp==*it1a) 
                 {
                   LCTs_final.push_back(*it1a);
                   it1a++;
                 }
               itp++;
             }
         }
       else {
         if (LCTs1a.size() and LCTs1b.size() and me==ME1A)
           LCTs_final.push_back(*LCTs1a.begin());
         else if (LCTs1a.size() and LCTs1b.size() and me==ME1B)
           LCTs_final.push_back(*LCTs1b.begin());
         else if (LCTs1a.size() and LCTs1b.size()==0 and me==ME1A)
           LCTs_final.insert(LCTs_final.end(), LCTs1a.begin(), LCTs1a.end());
         else if (LCTs1b.size() and LCTs1a.size()==0 and me==ME1B)
           LCTs_final.insert(LCTs_final.end(), LCTs1b.begin(), LCTs1b.end());
       }
     }
   return LCTs_final;
 }

std::vector< CSCCorrelatedLCTDigi > CSCMotherboardME11GEM::sortLCTsByGEMDPhi ( std::vector< CSCCorrelatedLCTDigi > LCTs )

Definition at line 1170 of file CSCMotherboardME11GEM.cc.

References max_me11_lcts, and CSCMotherboard::sortByGEMDphi().

 {
   std::vector<CSCCorrelatedLCTDigi> tmpV;
   tmpV.clear();
   std::sort(LCTs.begin(), LCTs.end(), CSCMotherboard::sortByGEMDphi);
   tmpV = LCTs;
   if (tmpV.size() > max_me11_lcts) tmpV.erase(tmpV.begin()+max_me11_lcts, tmpV.end());
   return tmpV;
 }

std::vector< CSCCorrelatedLCTDigi > CSCMotherboardME11GEM::sortLCTsByQuality	(	int	bx,
		enum ME11Part	me = `ME1B`
	)

Methods to sort the LCTs

Definition at line 1071 of file CSCMotherboardME11GEM.cc.

References allLCTs1a, allLCTs1b, i, CSCMotherboard::match_trig_window_size, max_me11_lcts, ME1A, and CSCMotherboard::sortByQuality().

Referenced by readoutLCTs(), and sortLCTsByQuality().

 {
   auto allLCTs(me==ME1A ? allLCTs1a : allLCTs1b); 
   std::vector<CSCCorrelatedLCTDigi> LCTs;
   std::vector<CSCCorrelatedLCTDigi> tmpV;
   tmpV.clear();
   LCTs.clear();
   for (unsigned int mbx = 0; mbx < match_trig_window_size; mbx++) 
     for (int i=0;i<2;i++)
       if (allLCTs[bx][mbx][i].isValid())  
         LCTs.push_back(allLCTs[bx][mbx][i]);
 
   std::sort(LCTs.begin(), LCTs.end(), CSCMotherboard::sortByQuality);
   tmpV = LCTs;
   if (tmpV.size()> max_me11_lcts) tmpV.erase(tmpV.begin()+max_me11_lcts, tmpV.end());
   return  tmpV;
 }

std::vector< CSCCorrelatedLCTDigi > CSCMotherboardME11GEM::sortLCTsByQuality ( enum ME11Part me = ME1B )

Definition at line 1101 of file CSCMotherboardME11GEM.cc.

References firstTwoLCTsInChamber_, CSCMotherboard::MAX_LCT_BINS, ME1A, ME1B, and sortLCTsByQuality().

 {
   std::vector<CSCCorrelatedLCTDigi> LCTs_final;
   LCTs_final.clear();
   for (int bx = 0; bx < MAX_LCT_BINS; bx++)
     {
       std::vector<CSCCorrelatedLCTDigi> LCTs1a;
       std::vector<CSCCorrelatedLCTDigi> LCTs1b;
       std::vector<CSCCorrelatedLCTDigi> LCTs_tmp;
       std::vector<CSCCorrelatedLCTDigi> LCTs_tmp1;
       LCTs1a = sortLCTsByQuality(bx, ME1A);
       LCTs1b = sortLCTsByQuality(bx, ME1B);
       std::vector<CSCCorrelatedLCTDigi>::iterator it1a = LCTs1a.begin();
       std::vector<CSCCorrelatedLCTDigi>::iterator it1b = LCTs1b.begin();
       LCTs_tmp.insert(LCTs_tmp.begin(), LCTs1b.begin(), LCTs1b.end());
       LCTs_tmp.insert(LCTs_tmp.end(), LCTs1a.begin(), LCTs1a.end());
       LCTs_tmp1 = sortLCTsByQuality(LCTs_tmp);//LCTs reduction per BX
       if (firstTwoLCTsInChamber_)
         {
           std::vector<CSCCorrelatedLCTDigi>::iterator itp = LCTs_tmp1.begin();
           for ( ; itp != LCTs_tmp1.end(); itp++)
             {
               if (me==ME1A and it1a != LCTs1a.end() and *itp==*it1a ) 
                 {
                   LCTs_final.push_back(*it1a);
                   it1a++;
                 }
               if (me==ME1B and it1b != LCTs1b.end() and *itp==*it1b)
                 {
                   LCTs_final.push_back(*it1b);
                   it1b++;
                 }
             }
         }   
       else {
         if (LCTs1a.size() and LCTs1b.size() and me==ME1A)
           LCTs_final.push_back(*LCTs1a.begin());
         else if (LCTs1a.size() and LCTs1b.size() and me==ME1B)
           LCTs_final.push_back(*LCTs1b.begin());
         else if (LCTs1a.size() and LCTs1b.size()==0 and me==ME1A)
           LCTs_final.insert(LCTs_final.end(), LCTs1a.begin(), LCTs1a.end());
         else if (LCTs1b.size() and LCTs1a.size()==0 and me==ME1B)
           LCTs_final.insert(LCTs_final.end(), LCTs1b.begin(), LCTs1b.end());
       }
     }
   return LCTs_final;
 }

std::vector< CSCCorrelatedLCTDigi > CSCMotherboardME11GEM::sortLCTsByQuality ( std::vector< CSCCorrelatedLCTDigi > LCTs )

Definition at line 1089 of file CSCMotherboardME11GEM.cc.

References max_me11_lcts, and CSCMotherboard::sortByQuality().

 {
   std::vector<CSCCorrelatedLCTDigi> tmpV;
   tmpV.clear();
   std::sort(LCTs.begin(), LCTs.end(), CSCMotherboard::sortByQuality);
   tmpV = LCTs;
   if (tmpV.size()> max_me11_lcts) tmpV.erase(tmpV.begin()+max_me11_lcts, tmpV.end());
   return  tmpV;
 }

Member Data Documentation

std::vector<CSCALCTDigi> CSCMotherboardME11GEM::alctV

private

Definition at line 165 of file CSCMotherboardME11GEM.h.

Referenced by getALCTs1b(), and run().

CSCCorrelatedLCTDigi CSCMotherboardME11GEM::allLCTs1a[MAX_LCT_BINS][15][2]

private

Definition at line 111 of file CSCMotherboardME11GEM.h.

Referenced by clear(), getLCTs1a(), run(), sortLCTsByGEMDPhi(), and sortLCTsByQuality().

CSCCorrelatedLCTDigi CSCMotherboardME11GEM::allLCTs1b[MAX_LCT_BINS][15][2]

private

Container for first correlated LCT in ME1a. Container for second correlated LCT in ME1a. for the case when more than 2 LCTs/BX are allowed; maximum match window = 15

Definition at line 110 of file CSCMotherboardME11GEM.h.

Referenced by clear(), getLCTs1b(), run(), sortLCTsByGEMDPhi(), and sortLCTsByQuality().

bool CSCMotherboardME11GEM::buildLCTfromALCTandGEM_ME1a_

private

Definition at line 227 of file CSCMotherboardME11GEM.h.

Referenced by CSCMotherboardME11GEM(), and run().

bool CSCMotherboardME11GEM::buildLCTfromALCTandGEM_ME1b_

private

Definition at line 228 of file CSCMotherboardME11GEM.h.

Referenced by CSCMotherboardME11GEM(), and run().

bool CSCMotherboardME11GEM::buildLCTfromCLCTandGEM_ME1a_

private

Definition at line 229 of file CSCMotherboardME11GEM.h.

Referenced by CSCMotherboardME11GEM(), and run().

bool CSCMotherboardME11GEM::buildLCTfromCLCTandGEM_ME1b_

private

Definition at line 230 of file CSCMotherboardME11GEM.h.

Referenced by CSCMotherboardME11GEM(), and run().

std::unique_ptr<CSCCathodeLCTProcessor> CSCMotherboardME11GEM::clct1a

additional Cathode LCT processor for ME1a

Definition at line 77 of file CSCMotherboardME11GEM.h.

Referenced by CSCTriggerPrimitivesBuilder::build(), clear(), CSCMotherboardME11GEM(), run(), and setConfigParameters().

bool CSCMotherboardME11GEM::clct_to_alct

private

if true: use regular CLCT-to-ALCT matching in TMB if false: do ALCT-to-CLCT matching

Definition at line 178 of file CSCMotherboardME11GEM.h.

Referenced by CSCMotherboardME11GEM().

std::vector<CSCCLCTDigi> CSCMotherboardME11GEM::clctV1a

private

Definition at line 167 of file CSCMotherboardME11GEM.h.

Referenced by getCLCTs1a(), and run().

std::vector<CSCCLCTDigi> CSCMotherboardME11GEM::clctV1b

private

Definition at line 166 of file CSCMotherboardME11GEM.h.

Referenced by getCLCTs1b(), and run().

GEMPads CSCMotherboardME11GEM::coPads_

private

Definition at line 264 of file CSCMotherboardME11GEM.h.

Referenced by clear(), printGEMTriggerPads(), retrieveGEMCoPads(), and run().

bool CSCMotherboardME11GEM::correctLCTtimingWithGEM_

private

Definition at line 236 of file CSCMotherboardME11GEM.h.

Referenced by CSCMotherboardME11GEM(), and run().

const CSCGeometry* CSCMotherboardME11GEM::csc_g

private

Definition at line 192 of file CSCMotherboardME11GEM.h.

Referenced by run(), and setCSCGeometry().

std::map<int,std::pair<int,int> > CSCMotherboardME11GEM::cscHsToGemPadME1a_

private

Definition at line 259 of file CSCMotherboardME11GEM.h.

Referenced by clear(), matchingGEMPads(), and run().

std::map<int,std::pair<int,int> > CSCMotherboardME11GEM::cscHsToGemPadME1b_

private

Definition at line 260 of file CSCMotherboardME11GEM.h.

Referenced by clear(), deltaPad(), matchingGEMPads(), and run().

std::map<int,std::pair<int,int> > CSCMotherboardME11GEM::cscWgToGemRoll_

private

Definition at line 254 of file CSCMotherboardME11GEM.h.

Referenced by clear(), deltaRoll(), isPadInOverlap(), matchingGEMPads(), and run().

bool CSCMotherboardME11GEM::debug_gem_dphi

private

Definition at line 198 of file CSCMotherboardME11GEM.h.

Referenced by CSCMotherboardME11GEM().

bool CSCMotherboardME11GEM::debug_gem_matching

private

Definition at line 196 of file CSCMotherboardME11GEM.h.

Referenced by correlateLCTsGEM(), CSCMotherboardME11GEM(), and run().

bool CSCMotherboardME11GEM::debug_luts

private

Definition at line 197 of file CSCMotherboardME11GEM.h.

Referenced by CSCMotherboardME11GEM(), and run().

bool CSCMotherboardME11GEM::disableME1a

private

Definition at line 98 of file CSCMotherboardME11GEM.h.

Referenced by CSCMotherboardME11GEM(), and getLCTs1a().

bool CSCMotherboardME11GEM::doLCTGhostBustingWithGEMs_

private

Definition at line 233 of file CSCMotherboardME11GEM.h.

Referenced by correlateLCTsGEM(), and CSCMotherboardME11GEM().

bool CSCMotherboardME11GEM::drop_used_clcts

private

whether to not reuse CLCTs that were used by previous matching ALCTs in ALCT-to-CLCT algorithm

Definition at line 182 of file CSCMotherboardME11GEM.h.

Referenced by CSCMotherboardME11GEM(), and run().

bool CSCMotherboardME11GEM::dropLowQualityALCTsNoGEMs_ME1a_

private

Definition at line 223 of file CSCMotherboardME11GEM.h.

Referenced by CSCMotherboardME11GEM().

bool CSCMotherboardME11GEM::dropLowQualityALCTsNoGEMs_ME1b_

private

Definition at line 224 of file CSCMotherboardME11GEM.h.

Referenced by CSCMotherboardME11GEM().

bool CSCMotherboardME11GEM::dropLowQualityCLCTsNoGEMs_ME1a_

private

Definition at line 221 of file CSCMotherboardME11GEM.h.

Referenced by CSCMotherboardME11GEM(), and run().

bool CSCMotherboardME11GEM::dropLowQualityCLCTsNoGEMs_ME1b_

private

Definition at line 222 of file CSCMotherboardME11GEM.h.

Referenced by CSCMotherboardME11GEM(), and run().

bool CSCMotherboardME11GEM::firstTwoLCTsInChamber_

private

Definition at line 242 of file CSCMotherboardME11GEM.h.

Referenced by CSCMotherboardME11GEM(), sortLCTsByGEMDPhi(), and sortLCTsByQuality().

bool CSCMotherboardME11GEM::gangedME1a

private

Definition at line 98 of file CSCMotherboardME11GEM.h.

Referenced by CSCMotherboardME11GEM(), and doesALCTCrossCLCT().

const GEMGeometry* CSCMotherboardME11GEM::gem_g

private

Definition at line 193 of file CSCMotherboardME11GEM.h.

Referenced by createGEMRollEtaLUT(), retrieveGEMCoPads(), retrieveGEMPads(), run(), and setGEMGeometry().

std::vector<GEMCoPadDigi> CSCMotherboardME11GEM::gemCoPadV

private

Definition at line 168 of file CSCMotherboardME11GEM.h.

Referenced by buildCoincidencePads(), and readoutCoPads().

std::map<int,int> CSCMotherboardME11GEM::gemPadToCscHsME1a_

private

Definition at line 257 of file CSCMotherboardME11GEM.h.

Referenced by clear(), constructLCTsGEM(), and run().

std::map<int,int> CSCMotherboardME11GEM::gemPadToCscHsME1b_

private

Definition at line 258 of file CSCMotherboardME11GEM.h.

Referenced by clear(), constructLCTsGEM(), and run().

std::map<int,std::pair<double,double> > CSCMotherboardME11GEM::gemRollToEtaLimits_

private

Definition at line 253 of file CSCMotherboardME11GEM.h.

Referenced by assignGEMRoll(), clear(), createGEMRollEtaLUT(), and run().

const double CSCMotherboardME11GEM::lut_pt_vs_dphi_gemcsc

staticprivate

Initial value:

= {
  {3, 0.03971647, 0.01710244},                                    
  {5, 0.02123785, 0.00928431}, 
  {7, 0.01475524, 0.00650928},                                                                                                  
  {10, 0.01023299, 0.00458796},                                                                                                 
  {15, 0.00689220, 0.00331313},                                                                  
  {20, 0.00535176, 0.00276152},                                                                                                                        
  {30, 0.00389050, 0.00224959},               
  {40, 0.00329539, 0.00204670}}

Definition at line 93 of file CSCMotherboardME11GEM.h.

const double CSCMotherboardME11GEM::lut_wg_etaMin_etaMax_even

staticprivate

Definition at line 95 of file CSCMotherboardME11GEM.h.

Referenced by run().

const double CSCMotherboardME11GEM::lut_wg_etaMin_etaMax_odd

staticprivate

Definition at line 94 of file CSCMotherboardME11GEM.h.

Referenced by run().

const int CSCMotherboardME11GEM::lut_wg_vs_hs_me1a

staticprivate

Initial value:

= {
{0, 95},{0, 95},{0, 95},{0, 95},{0, 95},
{0, 95},{0, 95},{0, 95},{0, 95},{0, 95},
{0, 95},{0, 95},{0, 77},{0, 61},{0, 39},
{0, 22},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
{-1,-1},{-1,-1},{-1,-1} }

Definition at line 91 of file CSCMotherboardME11GEM.h.

Referenced by constructLCTsGEM(), and doesALCTCrossCLCT().

const int CSCMotherboardME11GEM::lut_wg_vs_hs_me1ag

staticprivate

Initial value:

= {
{0, 31},{0, 31},{0, 31},{0, 31},{0, 31},
{0, 31},{0, 31},{0, 31},{0, 31},{0, 31},
{0, 31},{0, 31},{0, 31},{0, 31},{0, 31},
{0, 22},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
{-1,-1},{-1,-1},{-1,-1} }

Definition at line 92 of file CSCMotherboardME11GEM.h.

Referenced by doesALCTCrossCLCT().

const int CSCMotherboardME11GEM::lut_wg_vs_hs_me1b

staticprivate

Initial value:

= {
{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
{100, 127},{73, 127},{47, 127},{22, 127},{0, 127},
{0, 127},{0, 127},{0, 127},{0, 127},{0, 127},
{0, 127},{0, 127},{0, 127},{0, 127},{0, 127},
{0, 127},{0, 127},{0, 127},{0, 127},{0, 127},
{0, 127},{0, 127},{0, 127},{0, 127},{0, 127},
{0, 127},{0, 127},{0, 127},{0, 127},{0, 127},
{0, 127},{0, 127},{0, 127},{0, 127},{0, 105},
{0, 93},{0, 78},{0, 63} }