#include <CSCMotherboardME11.h>

Inheritance diagram for CSCMotherboardME11:

Public Member Functions
void	clear ()

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

	CSCMotherboardME11 ()

std::vector< CSCCorrelatedLCTDigi >	getLCTs1a () const

std::vector< CSCCorrelatedLCTDigi >	getLCTs1b () const

std::vector< CSCCorrelatedLCTDigi >	readoutLCTs (int me1ab) const

std::vector< CSCCorrelatedLCTDigi >	readoutLCTs1a () const

std::vector< CSCCorrelatedLCTDigi >	readoutLCTs1b () const

void	run (const CSCWireDigiCollection wiredc, const CSCComparatorDigiCollection compdc)

void	setConfigParameters (const CSCDBL1TPParameters *conf)

	~CSCMotherboardME11 () override

Public Member Functions inherited from CSCUpgradeMotherboard
void	clear ()

template<class S >
bool	compare (const S &p, const S &q) const

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

	CSCUpgradeMotherboard ()

void	debugLUTs ()

enum CSCPart	getCSCPart (int keystrip) const

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

void	setupGeometry ()

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

	~CSCUpgradeMotherboard () override

Public Member Functions inherited from CSCMotherboard
void	clear ()

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

	CSCMotherboard ()

std::vector< CSCCorrelatedLCTDigi >	getLCTs () const

std::vector< CSCCorrelatedLCTDigi >	readoutLCTs () const

void	run (const CSCWireDigiCollection wiredc, const CSCComparatorDigiCollection compdc)

void	setConfigParameters (const CSCDBL1TPParameters *conf)

void	setCSCGeometry (const CSCGeometry *g)

virtual	~CSCMotherboard ()=default

Private Types
enum	{ ME1B = 1, ME1A =4 }

Private Member Functions
void	correlateLCTsME11 (const CSCALCTDigi &bestALCT, const CSCALCTDigi &secondALCT, const CSCCLCTDigi &bestCLCT, const CSCCLCTDigi &secondCLCT, CSCCorrelatedLCTDigi &lct1, CSCCorrelatedLCTDigi &lct2) const

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

Private Attributes
std::unique_ptr< CSCMotherboardLUTME11 >	cscTmbLUT_

bool	ignoreAlctCrossClct

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

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

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

std::unique_ptr< CSCCathodeLCTProcessor >	clctProc

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

Protected Member Functions inherited from CSCUpgradeMotherboard
void	setPrefIndex ()

Protected Member Functions inherited from CSCMotherboard
void	checkConfigParameters ()

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

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

void	dumpConfigParams () const

unsigned int	encodePattern (const int clctPattern) const

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

CSCALCTDigi	getBXShiftedALCT (const CSCALCTDigi &) const

Protected Attributes inherited from CSCUpgradeMotherboard
LCTContainer	allLCTs

const CSCChamber *	cscChamber

bool	debug_luts

bool	debug_matching

bool	disableME1a

bool	gangedME1a

std::unique_ptr< CSCUpgradeMotherboardLUTGenerator >	generator_

bool	match_earliest_alct_only

bool	match_earliest_clct_only

unsigned int	max_lcts

Parity	par

int	pref [CSCConstants::MAX_LCT_TBINS]

unsigned	theChamber

unsigned	theRegion

unsigned int	tmb_cross_bx_algo

Protected Attributes inherited from CSCMotherboard
unsigned int	alct_trig_enable

unsigned int	alctClctOffset

edm::ParameterSet	alctParams_

std::vector< CSCALCTDigi >	alctV

bool	clct_to_alct

unsigned int	clct_trig_enable

edm::ParameterSet	clctParams_

std::vector< CSCCLCTDigi >	clctV

edm::ParameterSet	commonParams_

const CSCGeometry *	csc_g

bool	drop_used_alcts

bool	drop_used_clcts

int	early_tbins

CSCCorrelatedLCTDigi	firstLCT [CSCConstants::MAX_LCT_TBINS]

int	infoV

bool	isSLHC_

unsigned int	match_trig_enable

unsigned int	match_trig_window_size

unsigned int	mpc_block_me1a

bool	readout_earliest_2

bool	runME11ILT_

bool	runME21ILT_

bool	runME3141ILT_

CSCCorrelatedLCTDigi	secondLCT [CSCConstants::MAX_LCT_TBINS]

const unsigned	theEndcap

unsigned	theRing

const unsigned	theSector

const unsigned	theStation

const unsigned	theSubsector

const unsigned	theTrigChamber

unsigned int	tmb_l1a_window_size

edm::ParameterSet	tmbParams_

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

static const unsigned int	def_clct_trig_enable = 0

static const unsigned int	def_match_trig_enable = 1

static const unsigned int	def_match_trig_window_size = 7

static const unsigned int	def_mpc_block_me1a = 1

static const unsigned int	def_tmb_l1a_window_size = 7

Detailed Description

Extended CSCMotherboard for ME11 TMB upgrade to handle ME1b and (primarily unganged) ME1a separately

Author: Vadim Khotilovich 12 May 2009

Based on CSCMotherboard code

Definition at line 19 of file CSCMotherboardME11.h.

Member Enumeration Documentation

anonymous enum

private

labels for ME1a and ME1B

Enumerator
ME1B
ME1A

Definition at line 58 of file CSCMotherboardME11.h.

58 {ME1B = 1, ME1A=4};

CSCMotherboardME11::ME1B

Definition: CSCMotherboardME11.h:58

CSCMotherboardME11::ME1A

Definition: CSCMotherboardME11.h:58

Constructor & Destructor Documentation

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

Normal constructor.

Definition at line 15 of file CSCMotherboardME11.cc.

References cscTmbLUT_, edm::ParameterSet::getParameter(), ignoreAlctCrossClct, CSCMotherboard::isSLHC_, and CSCMotherboard::tmbParams_.

                                                 :
         CSCUpgradeMotherboard(endcap, station, sector, subsector, chamber, conf)
 {
   if (!isSLHC_) edm::LogError("CSCMotherboardME11|ConfigError")
     << "+++ Upgrade CSCMotherboardME11 constructed while isSLHC_ is not set! +++\n";
 
   cscTmbLUT_.reset(new CSCMotherboardLUTME11());
 
   // ignore unphysical ALCT-CLCT matches
   ignoreAlctCrossClct = tmbParams_.getParameter<bool>("ignoreAlctCrossClct");
 }

CSCMotherboardME11::CSCMotherboardME11 ( )

Constructor for use during testing.

Definition at line 31 of file CSCMotherboardME11.cc.

References CSCMotherboard::isSLHC_.

   : CSCUpgradeMotherboard()
 {
   if (!isSLHC_) edm::LogError("CSCMotherboardME11|ConfigError")
     << "+++ Upgrade CSCMotherboardME11 constructed while isSLHC_ is not set! +++\n";
 }

CSCMotherboardME11::~CSCMotherboardME11 ( )

override

Default destructor.

Definition at line 39 of file CSCMotherboardME11.cc.

40 {

41 }

Member Function Documentation

void CSCMotherboardME11::clear ( void )

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

Definition at line 44 of file CSCMotherboardME11.cc.

References CSCUpgradeMotherboard::clear().

Referenced by run().

 {
   CSCUpgradeMotherboard::clear();
 }

void CSCMotherboardME11::correlateLCTsME11	(	const CSCALCTDigi &	bestALCT,
		const CSCALCTDigi &	secondALCT,
		const CSCCLCTDigi &	bestCLCT,
		const CSCCLCTDigi &	secondCLCT,
		CSCCorrelatedLCTDigi &	lct1,
		CSCCorrelatedLCTDigi &	lct2
	)		const

private

Definition at line 310 of file CSCMotherboardME11.cc.

References CSCMotherboard::alct_trig_enable, CSCCorrelatedLCTDigi::ALCTCLCT, CSCTriggerNumbering::chamberFromTriggerLabels(), CSCMotherboard::clct_trig_enable, CSCALCTDigi::clear(), CSCCLCTDigi::clear(), CSCMotherboard::constructLCTs(), doesALCTCrossCLCT(), ignoreAlctCrossClct, CSCALCTDigi::isValid(), CSCCLCTDigi::isValid(), LogTrace, lumiPlot::lut, CSCMotherboard::match_trig_enable, or, CSCMotherboard::theEndcap, CSCMotherboard::theSector, CSCMotherboard::theStation, CSCMotherboard::theSubsector, and CSCMotherboard::theTrigChamber.

Referenced by run().

 {
   // assume that always anodeBestValid && cathodeBestValid
   CSCALCTDigi bestALCT = bALCT;
   CSCALCTDigi secondALCT = sALCT;
   CSCCLCTDigi bestCLCT = bCLCT;
   CSCCLCTDigi secondCLCT = sCLCT;
 
   if (ignoreAlctCrossClct) {
     const bool anodeBestValid     = bestALCT.isValid();
     const bool anodeSecondValid   = secondALCT.isValid();
     const bool cathodeBestValid   = bestCLCT.isValid();
     const 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, CSCCorrelatedLCTDigi::ALCTCLCT, 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, CSCCorrelatedLCTDigi::ALCTCLCT, 2);
     }
     return;
   }
   else {
 
     if (secondALCT == bestALCT) secondALCT.clear();
     if (secondCLCT == bestCLCT) secondCLCT.clear();
 
     const int ok11 = doesALCTCrossCLCT( bestALCT, bestCLCT);
     const int ok12 = doesALCTCrossCLCT( bestALCT, secondCLCT);
     const int ok21 = doesALCTCrossCLCT( secondALCT, bestCLCT);
     const int ok22 = doesALCTCrossCLCT( secondALCT, secondCLCT);
     const int code = (ok11<<3) | (ok12<<2) | (ok21<<1) | (ok22);
 
     int dbg=0;
     int chamb= CSCTriggerNumbering::chamberFromTriggerLabels(theSector,theSubsector, theStation, theTrigChamber);
     CSCDetId did(theEndcap, theStation, 1, chamb, 0);
     if (dbg) LogTrace("CSCMotherboardME11")<<"debug correlateLCTs in ME11 "<<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("CSCMotherboardME11")<<"lut 0 1 = "<<lut[code][0]<<" "<<lut[code][1]<<std::endl;
 
     switch (lut[code][0]) {
     case 11:
       lct1 = constructLCTs(bestALCT, bestCLCT, CSCCorrelatedLCTDigi::ALCTCLCT, 1);
       break;
     case 12:
       lct1 = constructLCTs(bestALCT, secondCLCT, CSCCorrelatedLCTDigi::ALCTCLCT, 1);
       break;
     case 21:
       lct1 = constructLCTs(secondALCT, bestCLCT, CSCCorrelatedLCTDigi::ALCTCLCT, 1);
       break;
     case 22:
       lct1 = constructLCTs(secondALCT, secondCLCT, CSCCorrelatedLCTDigi::ALCTCLCT, 1);
       break;
     default: return;
     }
 
     if (dbg) LogTrace("CSCMotherboardME11")<<"lct1: "<<lct1<<std::endl;
 
     switch (lut[code][1]){
     case 12:
       lct2 = constructLCTs(bestALCT, secondCLCT, CSCCorrelatedLCTDigi::ALCTCLCT, 2);
       if (dbg) LogTrace("CSCMotherboardME11")<<"lct2: "<<lct2<<std::endl;
       return;
     case 21:
       lct2 = constructLCTs(secondALCT, bestCLCT, CSCCorrelatedLCTDigi::ALCTCLCT, 2);
       if (dbg) LogTrace("CSCMotherboardME11")<<"lct2: "<<lct2<<std::endl;
       return;
     case 22:
       lct2 = constructLCTs(secondALCT, secondCLCT, CSCCorrelatedLCTDigi::ALCTCLCT, 2);
       if (dbg) LogTrace("CSCMotherboardME11")<<"lct2: "<<lct2<<std::endl;
       return;
     default: return;
     }
     if (dbg) LogTrace("CSCMotherboardME11")<<"out of correlateLCTsME11"<<std::endl;
 
     return;
   }
 }

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

private

Definition at line 305 of file CSCMotherboardME11.cc.

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

Referenced by correlateLCTsME11().

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

std::vector< CSCCorrelatedLCTDigi > CSCMotherboardME11::getLCTs1a ( ) const

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

Definition at line 283 of file CSCMotherboardME11.cc.

References CSCUpgradeMotherboard::allLCTs, CSCUpgradeMotherboard::LCTContainer::data, CSCUpgradeMotherboard::disableME1a, CSCCorrelatedLCTDigi::getStrip(), mps_fire::i, CSCCorrelatedLCTDigi::isValid(), CSCMotherboard::match_trig_window_size, CSCConstants::MAX_HALF_STRIP_ME1B, CSCConstants::MAX_LCT_TBINS, CSCConstants::MAX_LCTS_PER_CSC, and CSCMotherboard::mpc_block_me1a.

Referenced by readoutLCTs().

 {
   std::vector<CSCCorrelatedLCTDigi> tmpV;
 
   // disabled ME1a
   if (mpc_block_me1a || disableME1a) return tmpV;
 
   for (int bx = 0; bx < CSCConstants::MAX_LCT_TBINS; bx++) {
     for (unsigned int mbx = 0; mbx < match_trig_window_size; mbx++) {
       for (int i=0;i<CSCConstants::MAX_LCTS_PER_CSC;i++) {
         const CSCCorrelatedLCTDigi& lct = allLCTs.data[bx][mbx][i];
         if (lct.isValid() and
             lct.getStrip() >= CSCConstants::MAX_HALF_STRIP_ME1B){
           tmpV.push_back(lct);
         }
       }
     }
   }  // Report all LCTs found.
   return tmpV;
 }

std::vector< CSCCorrelatedLCTDigi > CSCMotherboardME11::getLCTs1b ( ) const

Definition at line 264 of file CSCMotherboardME11.cc.

References CSCUpgradeMotherboard::allLCTs, CSCUpgradeMotherboard::LCTContainer::data, CSCCorrelatedLCTDigi::getStrip(), mps_fire::i, CSCCorrelatedLCTDigi::isValid(), CSCMotherboard::match_trig_window_size, CSCConstants::MAX_HALF_STRIP_ME1B, CSCConstants::MAX_LCT_TBINS, and CSCConstants::MAX_LCTS_PER_CSC.

Referenced by readoutLCTs().

 {
   std::vector<CSCCorrelatedLCTDigi> tmpV;
 
   for (int bx = 0; bx < CSCConstants::MAX_LCT_TBINS; bx++) {
     for (unsigned int mbx = 0; mbx < match_trig_window_size; mbx++) {
       for (int i=0;i<CSCConstants::MAX_LCTS_PER_CSC;i++) {
         const CSCCorrelatedLCTDigi& lct = allLCTs.data[bx][mbx][i];
         if (lct.isValid() and
             lct.getStrip() < CSCConstants::MAX_HALF_STRIP_ME1B) {
           tmpV.push_back(lct);
         }
       }
     }
   }
   return tmpV;
 }

std::vector< CSCCorrelatedLCTDigi > CSCMotherboardME11::readoutLCTs ( int me1ab ) const

Definition at line 215 of file CSCMotherboardME11.cc.

References CSCMotherboard::early_tbins, getLCTs1a(), getLCTs1b(), ME1A, ME1B, CSCMotherboard::readout_earliest_2, and CSCMotherboard::tmb_l1a_window_size.

 {
   std::vector<CSCCorrelatedLCTDigi> tmpV;
 
   // The start time of the L1A*LCT coincidence window should be related
   // to the fifo_pretrig parameter, but I am not completely sure how.
   // Just choose it such that the window is centered at bx=7.  This may
   // need further tweaking if the value of tmb_l1a_window_size changes.
   //static int early_tbins = 4;
   // The number of LCT bins in the read-out is given by the
   // tmb_l1a_window_size parameter, forced to be odd
   const int lct_bins   =
     (tmb_l1a_window_size % 2 == 0) ? tmb_l1a_window_size + 1 : tmb_l1a_window_size;
   const int late_tbins = early_tbins + lct_bins;
 
 
   // Start from the vector of all found correlated LCTs and select
   // those within the LCT*L1A coincidence window.
   int bx_readout = -1;
   std::vector<CSCCorrelatedLCTDigi> all_lcts;
   if (me1ab == ME1A) all_lcts = getLCTs1a();
   if (me1ab == ME1B) all_lcts = getLCTs1b();
   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 && (bx_readout == -1 || bx == bx_readout) )
     {
       tmpV.push_back(*plct);
       if (bx_readout == -1) bx_readout = bx;
     }
     else tmpV.push_back(*plct);
   }
   return tmpV;
 }

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

Definition at line 200 of file CSCMotherboardME11.cc.

References ME1A, and CSCMotherboard::readoutLCTs().

Referenced by CSCTriggerPrimitivesBuilder::build().

 {
   return readoutLCTs(ME1A);
 }

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

Definition at line 206 of file CSCMotherboardME11.cc.

References ME1B, and CSCMotherboard::readoutLCTs().

Referenced by CSCTriggerPrimitivesBuilder::build().

 {
   return readoutLCTs(ME1B);
 }

void CSCMotherboardME11::run	(	const CSCWireDigiCollection *	wiredc,
		const CSCComparatorDigiCollection *	compdc
	)

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

Definition at line 58 of file CSCMotherboardME11.cc.

References CSCMotherboard::alctClctOffset, CSCMotherboard::alctProc, CSCMotherboard::alctV, CSCUpgradeMotherboard::allLCTs, b, CSCMotherboard::clct_to_alct, CSCMotherboard::clctProc, CSCMotherboard::clctV, clear(), CSCUpgradeMotherboard::LCTContainer::clear(), correlateLCTsME11(), CSCMotherboard::csc_g, CSCMotherboard::drop_used_alcts, CSCMotherboard::drop_used_clcts, mps_fire::i, CSCMotherboard::infoV, CSCMotherboard::isSLHC_, LogDebug, LogTrace, CSCUpgradeMotherboard::match_earliest_alct_only, CSCUpgradeMotherboard::match_earliest_clct_only, CSCMotherboard::match_trig_window_size, CSCConstants::MAX_ALCT_TBINS, CSCConstants::MAX_CLCT_TBINS, CSCConstants::MAX_LCT_TBINS, CSCConstants::MAX_LCTS_PER_CSC, CSCUpgradeMotherboard::pref, and CSCUpgradeMotherboard::tmb_cross_bx_algo.

Referenced by CSCTriggerPrimitivesBuilder::build().

 {
   clear();
 
   // Check for existing processors
   if (!( alctProc && clctProc && isSLHC_))
   {
     if (infoV >= 0) edm::LogError("CSCMotherboardME11|SetupError")
       << "+++ run() called for non-existing ALCT/CLCT processor! +++ \n";
     return;
   }
 
   alctProc->setCSCGeometry(csc_g);
   clctProc->setCSCGeometry(csc_g);
 
   alctV = alctProc->run(wiredc); // run anodeLCT
   clctV = clctProc->run(compdc); // run cathodeLCT
 
   // if there are no ALCTs and no CLCTs, it does not make sense to run this TMB
   if (alctV.empty() and clctV.empty()) return;
 
   int used_alct_mask[20];
   int used_clct_mask[20];
   for (int b=0;b<20;b++)
     used_alct_mask[b] = used_clct_mask[b] = 0;
 
   // CLCT-centric CLCT-to-ALCT matching
   if (clct_to_alct) for (int bx_clct = 0; bx_clct < CSCConstants::MAX_CLCT_TBINS; bx_clct++)
   {
 
     if (clctProc->bestCLCT[bx_clct].isValid())
     {
       const int bx_alct_start = bx_clct - match_trig_window_size/2 + alctClctOffset;
       const int bx_alct_stop  = bx_clct + match_trig_window_size/2 + alctClctOffset;
       for (int bx_alct = bx_alct_start; bx_alct <= bx_alct_stop; bx_alct++)
       {
         if (bx_alct < 0 || bx_alct >= CSCConstants::MAX_ALCT_TBINS) continue;
         if (drop_used_alcts && used_alct_mask[bx_alct]) continue;
         if (alctProc->bestALCT[bx_alct].isValid())
         {
           if (infoV > 1) LogTrace("CSCMotherboardME11")
             << "Successful CLCT-ALCT match in ME11: bx_clct = " << bx_clct
             << "; match window: [" << bx_alct_start << "; " << bx_alct_stop
             << "]; bx_alct = " << bx_alct;
           int mbx = bx_alct_stop - bx_alct;
           correlateLCTsME11(alctProc->bestALCT[bx_alct], alctProc->secondALCT[bx_alct],
                         clctProc->bestCLCT[bx_clct], clctProc->secondCLCT[bx_clct],
                         allLCTs(bx_alct,mbx,0), allLCTs(bx_alct,mbx,1));
           if (allLCTs(bx_alct,mbx,0).isValid())
           {
             used_alct_mask[bx_alct] += 1;
             if (match_earliest_alct_only) break;
           }
         }
       }
       // Do not report CLCT-only LCT for ME11
     }
   } // end of CLCT-centric matching
 
   // ALCT-centric ALCT-to-CLCT matching
   else for (int bx_alct = 0; bx_alct < CSCConstants::MAX_ALCT_TBINS; bx_alct++)
   {
     if (alctProc->bestALCT[bx_alct].isValid())
     {
       const int bx_clct_start = bx_alct - match_trig_window_size/2 - alctClctOffset;
       const int bx_clct_stop  = bx_alct + match_trig_window_size/2 - alctClctOffset;
 
       // matching in ME11
       for (int bx_clct = bx_clct_start; bx_clct <= bx_clct_stop; bx_clct++)
       {
         if (bx_clct < 0 || bx_clct >= CSCConstants::MAX_CLCT_TBINS) continue;
         if (drop_used_clcts && used_clct_mask[bx_clct]) continue;
         if (clctProc->bestCLCT[bx_clct].isValid())
         {
           if (infoV > 1) LogTrace("CSCMotherboardME11")
             << "Successful ALCT-CLCT match in ME11: bx_alct = " << bx_alct
             << "; match window: [" << bx_clct_start << "; " << bx_clct_stop
             << "]; bx_clct = " << bx_clct;
           int mbx = bx_clct-bx_clct_start;
           correlateLCTsME11(alctProc->bestALCT[bx_alct], alctProc->secondALCT[bx_alct],
                         clctProc->bestCLCT[bx_clct], clctProc->secondCLCT[bx_clct],
                         allLCTs(bx_alct,mbx,0), allLCTs(bx_alct,mbx,1));
           if (allLCTs(bx_alct,mbx,0).isValid())
           {
             used_clct_mask[bx_clct] += 1;
             if (match_earliest_clct_only) break;
           }
         }
       }
     }
   } // end of ALCT-centric matching
 
   // reduction of nLCTs per each BX
   for (int bx = 0; bx < CSCConstants::MAX_LCT_TBINS; bx++)
   {
     // counting
     unsigned int nlct=0;
     for (unsigned int mbx = 0; mbx < match_trig_window_size; mbx++)
       for (int i=0;i<CSCConstants::MAX_LCTS_PER_CSC;i++)
       {
         int cbx = bx + mbx - match_trig_window_size/2;
         if (allLCTs(bx,mbx,i).isValid())
         {
           nlct++;
           if (infoV > 0) LogDebug("CSCMotherboardME11") << "LCT"<<i+1<<" "<<bx<<"/"<<cbx<<": "<<allLCTs(bx,mbx,i);
         }
       }
     if (infoV > 0 && nlct>0) LogDebug("CSCMotherboardME11") <<"bx "<<bx<<" nLCT: "<<nlct;
 
     // some simple cross-bx sorting algorithms
     if (tmb_cross_bx_algo == 1 && nlct>2 )
     {
       nlct=0;
       for (unsigned int mbx = 0; mbx < match_trig_window_size; mbx++)
         for (int i=0;i<CSCConstants::MAX_LCTS_PER_CSC;i++)
         {
           if (allLCTs(bx,pref[mbx],i).isValid())
           {
             nlct++;
             if (nlct > CSCConstants::MAX_LCTS_PER_CSC) allLCTs(bx,pref[mbx],i).clear();
           }
         }
 
       if (infoV > 0) LogDebug("CSCMotherboardME11") <<"After x-bx sorting:";
       nlct=0;
       for (unsigned int mbx = 0; mbx < match_trig_window_size; mbx++)
         for (int i=0;i<CSCConstants::MAX_LCTS_PER_CSC;i++)
         {
           int cbx = bx + mbx - match_trig_window_size/2;
           if (allLCTs(bx,mbx,i).isValid())
           {
             nlct++;
             if (infoV > 0) LogDebug("CSCMotherboardME11") << "LCT"<<i+1<<" "<<bx<<"/"<<cbx<<": "<<allLCTs(bx,mbx,i);
           }
         }
       if (infoV > 0 && nlct>0) LogDebug("CSCMotherboardME11") <<"bx "<<bx<<" nnLCT: "<<nlct;
     } // x-bx sorting
   }
 }

void CSCMotherboardME11::setConfigParameters ( const CSCDBL1TPParameters * conf )

Set configuration parameters obtained via EventSetup mechanism.

Definition at line 50 of file CSCMotherboardME11.cc.

References CSCMotherboard::alctProc, and CSCMotherboard::clctProc.

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

Member Data Documentation

std::unique_ptr<CSCMotherboardLUTME11> CSCMotherboardME11::cscTmbLUT_

private

Definition at line 55 of file CSCMotherboardME11.h.

Referenced by CSCMotherboardME11(), and doesALCTCrossCLCT().

bool CSCMotherboardME11::ignoreAlctCrossClct

private

Definition at line 69 of file CSCMotherboardME11.h.

Referenced by correlateLCTsME11(), and CSCMotherboardME11().

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation