#include <CSCAnodeLCTProcessor.h>

Inheritance diagram for CSCAnodeLCTProcessor:

Public Member Functions
void	clear ()

	CSCAnodeLCTProcessor (unsigned endcap, unsigned station, unsigned sector, unsigned subsector, unsigned chamber, CSCBaseboard::Parameters &conf)

std::vector< CSCALCTDigi >	getALCTs () const

std::vector< CSCShowerDigi >	getAllShower () const

CSCALCTDigi	getBestALCT (int bx) const

CSCALCTDigi	getSecondALCT (int bx) const

std::vector< CSCALCTPreTriggerDigi >	preTriggerDigis () const

std::vector< CSCALCTDigi >	readoutALCTs () const

std::vector< CSCShowerDigi >	readoutShower () const

std::vector< CSCALCTDigi >	run (const CSCWireDigiCollection wiredc, CSCChamber const chamber)

void	run (const std::vector< int > wire[CSCConstants::NUM_LAYERS][CSCConstants::MAX_NUM_WIREGROUPS])

void	setConfigParameters (const CSCDBL1TPParameters *conf)

	~CSCAnodeLCTProcessor () override=default

Public Member Functions inherited from CSCBaseboard
	CSCBaseboard (unsigned endcap, unsigned station, unsigned sector, unsigned subsector, unsigned chamber, Parameters &conf)

	CSCBaseboard ()

std::string	getCSCName () const

CSCDetId	id () const

virtual	~CSCBaseboard ()=default

Protected Member Functions
void	accelMode (const int key_wire)

std::vector< CSCALCTDigi >	bestTrackSelector (const std::vector< CSCALCTDigi > &all_alcts)

void	checkConfigParameters ()

void	cleanWireContainer (CSCALCTDigi::WireContainer &wireHits) const

void	clear (const int wire, const int pattern)

void	dumpConfigParams () const

void	dumpDigis (const std::vector< int > wire[CSCConstants::NUM_LAYERS][CSCConstants::MAX_NUM_WIREGROUPS]) const

void	encodeHighMultiplicityBits ()

bool	getDigis (const CSCWireDigiCollection *wiredc)

void	getDigis (const CSCWireDigiCollection *wiredc, const CSCDetId &id)

virtual int	getTempALCTQuality (int temp_quality) const

virtual void	ghostCancellationLogicOneWire (const int key_wire, int *ghost_cleared)

bool	isBetterALCT (const CSCALCTDigi &lhsALCT, const CSCALCTDigi &rhsALCT) const

void	lctSearch ()

void	loadPatternMask ()

bool	patternDetection (const int key_wire, std::map< int, std::map< int, CSCALCTDigi::WireContainer > > &hits_in_patterns)

bool	preTrigger (const int key_wire, const int start_bx)

bool	pulseExtension (const std::vector< int > wire[CSCConstants::NUM_LAYERS][CSCConstants::MAX_NUM_WIREGROUPS])

void	readWireDigis (std::vector< int > wire[CSCConstants::NUM_LAYERS][CSCConstants::MAX_NUM_WIREGROUPS])

void	setDefaultConfigParameters ()

void	setWireContainer (CSCALCTDigi &, CSCALCTDigi::WireContainer &wireHits) const

void	showPatterns (const int key_wire)

void	trigMode (const int key_wire)

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

const CSCChamber *	cscChamber (CSCGeometry const &) const

Protected Attributes
unsigned int	accel_mode

CSCPatternBank::LCTPatterns	alct_pattern_ = {}

CSCShowerDigi	anode_showers_ [CSCConstants::MAX_ALCT_TBINS]

CSCALCTDigi	bestALCT [CSCConstants::MAX_ALCT_TBINS]

std::vector< CSCWireDigi >	digiV [CSCConstants::NUM_LAYERS]

unsigned int	drift_delay

int	early_tbins

unsigned int	fifo_pretrig

unsigned int	fifo_tbins

int	first_bx [CSCConstants::MAX_NUM_WIREGROUPS]

int	first_bx_corrected [CSCConstants::MAX_NUM_WIREGROUPS]

int	ghost_cancellation_bx_depth

bool	ghost_cancellation_side_quality

unsigned int	hit_persist

unsigned int	l1a_window_width

std::vector< CSCALCTDigi >	lct_list

unsigned	maxbx_readout_

int	MESelection

unsigned	minbx_readout_

unsigned	minLayersCentralTBin_

bool	narrow_mask_r1

unsigned int	nplanes_hit_accel_pattern

unsigned int	nplanes_hit_accel_pretrig

unsigned int	nplanes_hit_pattern

unsigned int	nplanes_hit_pretrig

int	numWireGroups

unsigned int	pretrig_extra_deadtime

PulseArray	pulse_

int	quality [CSCConstants::MAX_NUM_WIREGROUPS][CSCConstants::NUM_ALCT_PATTERNS]

std::unique_ptr< LCTQualityControl >	qualityControl_

CSCALCTDigi	secondALCT [CSCConstants::MAX_ALCT_TBINS]

unsigned	showerNumTBins_

std::vector< CSCALCTPreTriggerDigi >	thePreTriggerDigis

std::vector< unsigned >	thresholds_

unsigned int	trig_mode

bool	use_corrected_bx

Protected Attributes inherited from CSCBaseboard
CSCDetId	cscId_

bool	disableME1a_

bool	enableAlctPhase2_

bool	gangedME1a_

int	infoV

bool	isME11_

bool	isME12_

bool	isME13_

bool	isME21_

bool	isME22_

bool	isME31_

bool	isME32_

bool	isME41_

bool	isME42_

bool	run3_

bool	runCCLUT_

bool	runCCLUT_OTMB_

bool	runCCLUT_TMB_

bool	runME11ILT_

bool	runME11Up_

bool	runME21ILT_

bool	runME21Up_

bool	runME31Up_

bool	runME41Up_

bool	runPhase2_

unsigned	theChamber

std::string	theCSCName_

const unsigned	theEndcap

int	theRegion

unsigned	theRing

const unsigned	theSector

const unsigned	theStation

const unsigned	theSubsector

const unsigned	theTrigChamber

Static Protected Attributes
static const unsigned int	def_accel_mode = 0

static const unsigned int	def_drift_delay = 2

static const unsigned int	def_fifo_pretrig = 10

static const unsigned int	def_fifo_tbins = 16

static const unsigned int	def_l1a_window_width = 7

static const unsigned int	def_nplanes_hit_accel_pattern = 4

static const unsigned int	def_nplanes_hit_accel_pretrig = 2

static const unsigned int	def_nplanes_hit_pattern = 4

static const unsigned int	def_nplanes_hit_pretrig = 2

static const unsigned int	def_trig_mode = 2

Detailed Description

This class simulates the functionality of the anode LCT card. It is run by the MotherBoard and returns up to two AnodeLCTs. It can be run either in a test mode, where it is passed an array of wire times, or in normal mode where it determines the wire times from the wire digis.

This is the simulation for the Anode LCT Processor for the Level-1 Trigger. This processor consists of several stages:

Pulse extension of signals coming from wires.
Pretrigger for each key-wire.
Pattern detector if a pretrigger is found for the given key-wire.
Ghost Cancellation Logic (GCL).
Best track search and promotion.
Second best track search and promotion.

The inputs to the ALCT Processor are wire digis. The output is up to two ALCT digi words.

Author: Benn Tannenbaum benn@.nosp@m.phys.nosp@m.ics.u.nosp@m.cla..nosp@m.edu 13 July 1999 Numerous later improvements by Jason Mumford and Slava Valuev (see cvs in ORCA). Porting from ORCA by S. Valuev (Slava.nosp@m..Val.nosp@m.uev@c.nosp@m.ern..nosp@m.ch), May 2006.

Updates for high pileup running by Vadim Khotilovich (TAMU), December 2012

Updates for integrated local trigger with GEMs by Sven Dildick (TAMU) and Tao Huang (TAMU), April 2015

Removing usage of outdated class CSCTriggerGeometry by Sven Dildick (TAMU)

Definition at line 48 of file CSCAnodeLCTProcessor.h.

Constructor & Destructor Documentation

◆ CSCAnodeLCTProcessor()

CSCAnodeLCTProcessor::CSCAnodeLCTProcessor	(	unsigned	endcap,
		unsigned	station,
		unsigned	sector,
		unsigned	subsector,
		unsigned	chamber,
		CSCBaseboard::Parameters &	conf
	)

Normal constructor.

Definition at line 20 of file CSCAnodeLCTProcessor.cc.

References accel_mode, CSCConstants::ALCT_EMUL_TIME_OFFSET, CSCBaseboard::Parameters::alctParams(), cms::cuda::assert(), relativeConstraints::chamber, checkConfigParameters(), drift_delay, dumpConfigParams(), early_tbins, makeMuonMisalignmentScenario::endcap, fifo_pretrig, fifo_tbins, edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterSet(), ghost_cancellation_bx_depth, ghost_cancellation_side_quality, hit_persist, CSCBaseboard::infoV, l1a_window_width, CSCConstants::LCT_CENTRAL_BX, loadPatternMask(), maxbx_readout_, MESelection, minbx_readout_, minLayersCentralTBin_, narrow_mask_r1, nplanes_hit_accel_pattern, nplanes_hit_accel_pretrig, nplanes_hit_pattern, nplanes_hit_pretrig, numWireGroups, pretrig_extra_deadtime, qualityControl_, CSCBaseboard::runPhase2_, nano_mu_digi_cff::sector, showerNumTBins_, CSCBaseboard::Parameters::showerParams(), relativeConstraints::station, nano_mu_digi_cff::subsector, CSCBaseboard::theStation, thresholds_, trig_mode, and use_corrected_bx.

     : CSCBaseboard(endcap, station, sector, subsector, chamber, conf) {
   static std::atomic<bool> config_dumped{false};
 
   // ALCT configuration parameters.
   fifo_tbins = conf.alctParams().getParameter<unsigned int>("alctFifoTbins");
   fifo_pretrig = conf.alctParams().getParameter<unsigned int>("alctFifoPretrig");
   drift_delay = conf.alctParams().getParameter<unsigned int>("alctDriftDelay");
   nplanes_hit_pretrig = conf.alctParams().getParameter<unsigned int>("alctNplanesHitPretrig");
   nplanes_hit_pattern = conf.alctParams().getParameter<unsigned int>("alctNplanesHitPattern");
   nplanes_hit_accel_pretrig = conf.alctParams().getParameter<unsigned int>("alctNplanesHitAccelPretrig");
   nplanes_hit_accel_pattern = conf.alctParams().getParameter<unsigned int>("alctNplanesHitAccelPattern");
   trig_mode = conf.alctParams().getParameter<unsigned int>("alctTrigMode");
   accel_mode = conf.alctParams().getParameter<unsigned int>("alctAccelMode");
   l1a_window_width = conf.alctParams().getParameter<unsigned int>("alctL1aWindowWidth");
 
   hit_persist = conf.alctParams().getParameter<unsigned int>("alctHitPersist");
 
   // Verbosity level, set to 0 (no print) by default.
   infoV = conf.alctParams().getParameter<int>("verbosity");
 
   // separate handle for early time bins
   early_tbins = conf.alctParams().getParameter<int>("alctEarlyTbins");
   if (early_tbins < 0)
     early_tbins = fifo_pretrig - CSCConstants::ALCT_EMUL_TIME_OFFSET;
 
   // delta BX time depth for ghostCancellationLogic
   ghost_cancellation_bx_depth = conf.alctParams().getParameter<int>("alctGhostCancellationBxDepth");
 
   // whether to consider ALCT candidates' qualities while doing ghostCancellationLogic on +-1 wire groups
   ghost_cancellation_side_quality = conf.alctParams().getParameter<bool>("alctGhostCancellationSideQuality");
 
   // deadtime clocks after pretrigger (extra in addition to drift_delay)
   pretrig_extra_deadtime = conf.alctParams().getParameter<unsigned int>("alctPretrigDeadtime");
 
   // whether to use narrow pattern mask for the rings close to the beam
   narrow_mask_r1 = conf.alctParams().getParameter<bool>("alctNarrowMaskForR1");
 
   // Check and print configuration parameters.
   checkConfigParameters();
   if ((infoV > 0 || (runPhase2_)) && !config_dumped) {
     dumpConfigParams();
     config_dumped = true;
   }
 
   numWireGroups = 0;  // Will be set later.
   MESelection = (theStation < 3) ? 0 : 1;
 
   // whether to calculate bx as corrected_bx instead of pretrigger one
   use_corrected_bx = false;
   if (runPhase2_) {
     use_corrected_bx = conf.alctParams().getParameter<bool>("alctUseCorrectedBx");
   }
 
   // Load appropriate pattern mask.
   loadPatternMask();
 
   // quality control of stubs
   qualityControl_ = std::make_unique<LCTQualityControl>(endcap, station, sector, subsector, chamber, conf);
 
   const auto& shower = conf.showerParams().getParameterSet("anodeShower");
   thresholds_ = shower.getParameter<std::vector<unsigned>>("showerThresholds");
   showerNumTBins_ = shower.getParameter<unsigned>("showerNumTBins");
   minLayersCentralTBin_ = shower.getParameter<unsigned>("minLayersCentralTBin");
   minbx_readout_ = CSCConstants::LCT_CENTRAL_BX - l1a_window_width / 2;
   maxbx_readout_ = CSCConstants::LCT_CENTRAL_BX + l1a_window_width / 2;
   assert(l1a_window_width / 2 <= CSCConstants::LCT_CENTRAL_BX);
 }

◆ ~CSCAnodeLCTProcessor()

CSCAnodeLCTProcessor::~CSCAnodeLCTProcessor ( )

overridedefault

Default destructor.

Member Function Documentation

◆ accelMode()

void CSCAnodeLCTProcessor::accelMode ( const int key_wire )

protected

Definition at line 1093 of file CSCAnodeLCTProcessor.cc.

References accel_mode, CSCConstants::ALCT_ACCELERATOR_PATTERN, CSCConstants::ALCT_COLLISIONA_PATTERN, CSCBaseboard::infoV, LogTrace, and quality.

                                                        {
   int promotionBit = 1 << 2;
 
   switch (accel_mode) {
     default:
     case 0:
       // Ignore accelerator muons.
       if (quality[key_wire][0] > 0) {
         quality[key_wire][0] = 0;
         if (infoV > 1)
           LogTrace("CSCAnodeLCTProcessor") << "alctMode(): accelerator track " << key_wire << " ignored"
                                            << "\n";
       }
       break;
     case 1:
       // Prefer collision muons by adding promotion bit.
       if (quality[key_wire][CSCConstants::ALCT_COLLISIONA_PATTERN] > 0) {
         quality[key_wire][CSCConstants::ALCT_COLLISIONA_PATTERN] += promotionBit;
         if (infoV > 1)
           LogTrace("CSCAnodeLCTProcessor") << "alctMode(): collision track " << key_wire << " promoted"
                                            << "\n";
       }
       break;
     case 2:
       // Prefer accelerator muons by adding promotion bit.
       if (quality[key_wire][CSCConstants::ALCT_ACCELERATOR_PATTERN] > 0) {
         quality[key_wire][CSCConstants::ALCT_ACCELERATOR_PATTERN] += promotionBit;
         if (infoV > 1)
           LogTrace("CSCAnodeLCTProcessor") << "alctMode(): accelerator track " << key_wire << " promoted"
                                            << "\n";
       }
       break;
     case 3:
       // Ignore collision muons.
       if (quality[key_wire][CSCConstants::ALCT_COLLISIONA_PATTERN] > 0) {
         quality[key_wire][CSCConstants::ALCT_COLLISIONA_PATTERN] = 0;
         if (infoV > 1)
           LogTrace("CSCAnodeLCTProcessor") << "alctMode(): collision track " << key_wire << " ignored"
                                            << "\n";
       }
       break;
   }
 }

◆ bestTrackSelector()

std::vector< CSCALCTDigi > CSCAnodeLCTProcessor::bestTrackSelector ( const std::vector< CSCALCTDigi > & all_alcts )

protected

Definition at line 916 of file CSCAnodeLCTProcessor.cc.

References nano_mu_digi_cff::bx, CSCALCTDigi::getKeyWG(), CSCALCTDigi::getQuality(), mps_fire::i, CSCBaseboard::infoV, CSCALCTDigi::isValid(), sistrip::SpyUtilities::isValid(), LogTrace, CSCConstants::MAX_ALCT_TBINS, CSCConstants::MAX_ALCTS_PER_PROCESSOR, AlCaHLTBitMon_ParallelJobs::p, and nano_mu_digi_cff::wire.

Referenced by lctSearch().

                                                                                                       {
   CSCALCTDigi bestALCTs[CSCConstants::MAX_ALCT_TBINS][CSCConstants::MAX_ALCTS_PER_PROCESSOR];
   CSCALCTDigi secondALCTs[CSCConstants::MAX_ALCT_TBINS][CSCConstants::MAX_ALCTS_PER_PROCESSOR];
 
   if (infoV > 1) {
     LogTrace("CSCAnodeLCTProcessor") << all_alcts.size() << " ALCTs at the input of best-track selector: ";
     for (const auto& p : all_alcts) {
       if (!p.isValid())
         continue;
       LogTrace("CSCAnodeLCTProcessor") << p;
     }
   }
 
   CSCALCTDigi tA[CSCConstants::MAX_ALCT_TBINS][CSCConstants::MAX_ALCTS_PER_PROCESSOR];
   CSCALCTDigi tB[CSCConstants::MAX_ALCT_TBINS][CSCConstants::MAX_ALCTS_PER_PROCESSOR];
   for (const auto& p : all_alcts) {
     if (!p.isValid())
       continue;
 
     // Select two collision and two accelerator ALCTs with the highest
     // quality at every bx.  The search for best ALCTs is done in parallel
     // for collision and accelerator patterns, and simultaneously for
     // two ALCTs, tA and tB.  If two or more ALCTs have equal qualities,
     // the priority is given to the ALCT with larger wiregroup number
     // in the search for tA (collision and accelerator), and to the ALCT
     // with smaller wiregroup number in the search for tB.
     int bx = p.getBX();
     int accel = p.getAccelerator();
     int qual = p.getQuality();
     int wire = p.getKeyWG();
     bool vA = tA[bx][accel].isValid();
     bool vB = tB[bx][accel].isValid();
     int qA = tA[bx][accel].getQuality();
     int qB = tB[bx][accel].getQuality();
     int wA = tA[bx][accel].getKeyWG();
     int wB = tB[bx][accel].getKeyWG();
     if (!vA || qual > qA || (qual == qA && wire > wA)) {
       tA[bx][accel] = p;
     }
     if (!vB || qual > qB || (qual == qB && wire < wB)) {
       tB[bx][accel] = p;
     }
   }
 
   for (int bx = 0; bx < CSCConstants::MAX_ALCT_TBINS; bx++) {
     for (int accel = 0; accel <= 1; accel++) {
       // Best ALCT is always tA.
       if (tA[bx][accel].isValid()) {
         if (infoV > 2) {
           LogTrace("CSCAnodeLCTProcessor") << "tA: " << tA[bx][accel];
           LogTrace("CSCAnodeLCTProcessor") << "tB: " << tB[bx][accel];
         }
         bestALCTs[bx][accel] = tA[bx][accel];
 
         // If tA exists, tB exists too.
         if (tA[bx][accel] != tB[bx][accel] && tA[bx][accel].getQuality() == tB[bx][accel].getQuality()) {
           secondALCTs[bx][accel] = tB[bx][accel];
         } else {
           // Funny part: if tA and tB are the same, or the quality of tB
           // is inferior to the quality of tA, the second best ALCT is
           // not tB.  Instead it is the largest-wiregroup ALCT among those
           // ALCT whose qualities are lower than the quality of the best one.
           for (const auto& p : all_alcts) {
             if (p.isValid() && p.getAccelerator() == accel && p.getBX() == bx &&
                 p.getQuality() < bestALCTs[bx][accel].getQuality() &&
                 p.getQuality() >= secondALCTs[bx][accel].getQuality() &&
                 p.getKeyWG() >= secondALCTs[bx][accel].getKeyWG()) {
               secondALCTs[bx][accel] = p;
             }
           }
         }
       }
     }
   }
 
   // Fill the vector with up to four best ALCTs per bx and return it.
   std::vector<CSCALCTDigi> fourBest;
   for (int bx = 0; bx < CSCConstants::MAX_ALCT_TBINS; bx++) {
     for (int i = 0; i < CSCConstants::MAX_ALCTS_PER_PROCESSOR; i++) {
       if (bestALCTs[bx][i].isValid()) {
         fourBest.push_back(bestALCTs[bx][i]);
       }
     }
     for (int i = 0; i < CSCConstants::MAX_ALCTS_PER_PROCESSOR; i++) {
       if (secondALCTs[bx][i].isValid()) {
         fourBest.push_back(secondALCTs[bx][i]);
       }
     }
   }
 
   if (infoV > 1) {
     LogTrace("CSCAnodeLCTProcessor") << fourBest.size() << " ALCTs selected: ";
     for (const auto& p : fourBest) {
       LogTrace("CSCAnodeLCTProcessor") << p;
     }
   }
 
   return fourBest;
 }

◆ checkConfigParameters()

void CSCAnodeLCTProcessor::checkConfigParameters ( )

protected

Make sure that the parameter values are within the allowed range.

Definition at line 144 of file CSCAnodeLCTProcessor.cc.

References accel_mode, cms::cuda::assert(), CSCBaseboard::checkConfigParameters(), def_accel_mode, def_drift_delay, def_fifo_pretrig, def_fifo_tbins, def_l1a_window_width, def_nplanes_hit_accel_pattern, def_nplanes_hit_accel_pretrig, def_nplanes_hit_pattern, def_nplanes_hit_pretrig, def_trig_mode, drift_delay, fifo_pretrig, fifo_tbins, l1a_window_width, CSCConstants::LCT_CENTRAL_BX, CSCConstants::MAX_ALCT_TBINS, nplanes_hit_accel_pattern, nplanes_hit_accel_pretrig, nplanes_hit_pattern, nplanes_hit_pretrig, and trig_mode.

Referenced by CSCAnodeLCTProcessor(), and setConfigParameters().

                                                  {
   // Make sure that the parameter values are within the allowed range.
 
   // Max expected values.
   static const unsigned int max_fifo_tbins = 1 << 5;
   static const unsigned int max_fifo_pretrig = 1 << 5;
   static const unsigned int max_drift_delay = 1 << 2;
   static const unsigned int max_nplanes_hit_pretrig = 1 << 3;
   static const unsigned int max_nplanes_hit_pattern = 1 << 3;
   static const unsigned int max_nplanes_hit_accel_pretrig = 1 << 3;
   static const unsigned int max_nplanes_hit_accel_pattern = 1 << 3;
   static const unsigned int max_trig_mode = 1 << 2;
   static const unsigned int max_accel_mode = 1 << 2;
   static const unsigned int max_l1a_window_width = CSCConstants::MAX_ALCT_TBINS;  // 4 bits
 
   // Checks.
   CSCBaseboard::checkConfigParameters(fifo_tbins, max_fifo_tbins, def_fifo_tbins, "fifo_tbins");
   CSCBaseboard::checkConfigParameters(fifo_pretrig, max_fifo_pretrig, def_fifo_pretrig, "fifo_pretrig");
   CSCBaseboard::checkConfigParameters(drift_delay, max_drift_delay, def_drift_delay, "drift_delay");
   CSCBaseboard::checkConfigParameters(
       nplanes_hit_pretrig, max_nplanes_hit_pretrig, def_nplanes_hit_pretrig, "nplanes_hit_pretrig");
   CSCBaseboard::checkConfigParameters(
       nplanes_hit_pattern, max_nplanes_hit_pattern, def_nplanes_hit_pattern, "nplanes_hit_pattern");
   CSCBaseboard::checkConfigParameters(nplanes_hit_accel_pretrig,
                                       max_nplanes_hit_accel_pretrig,
                                       def_nplanes_hit_accel_pretrig,
                                       "nplanes_hit_accel_pretrig");
   CSCBaseboard::checkConfigParameters(nplanes_hit_accel_pattern,
                                       max_nplanes_hit_accel_pattern,
                                       def_nplanes_hit_accel_pattern,
                                       "nplanes_hit_accel_pattern");
   CSCBaseboard::checkConfigParameters(trig_mode, max_trig_mode, def_trig_mode, "trig_mode");
   CSCBaseboard::checkConfigParameters(accel_mode, max_accel_mode, def_accel_mode, "accel_mode");
   CSCBaseboard::checkConfigParameters(l1a_window_width, max_l1a_window_width, def_l1a_window_width, "l1a_window_width");
 
   assert(l1a_window_width / 2 <= CSCConstants::LCT_CENTRAL_BX);
 }

◆ cleanWireContainer()

void CSCAnodeLCTProcessor::cleanWireContainer ( CSCALCTDigi::WireContainer & wireHits ) const

protected

Definition at line 1361 of file CSCAnodeLCTProcessor.cc.

References mps_fire::i, CSCConstants::INVALID_WIREGROUP, and AlCaHLTBitMon_ParallelJobs::p.

Referenced by setWireContainer().

                                                                                       {
   for (auto& p : wireHits) {
     p.erase(std::remove_if(p.begin(), p.end(), [](unsigned i) -> bool { return i == CSCConstants::INVALID_WIREGROUP; }),
             p.end());
   }
 }

◆ clear() [1/2]

void CSCAnodeLCTProcessor::clear ( void )

Clears the LCT containers.

Definition at line 182 of file CSCAnodeLCTProcessor.cc.

References anode_showers_, bestALCT, nano_mu_digi_cff::bx, CSCShowerDigi::clear(), CSCALCTDigi::clear(), lct_list, CSCConstants::MAX_ALCT_TBINS, and secondALCT.

                                  {
   for (int bx = 0; bx < CSCConstants::MAX_ALCT_TBINS; bx++) {
     bestALCT[bx].clear();
     secondALCT[bx].clear();
     anode_showers_[bx].clear();  //?
   }
   lct_list.clear();
 }

◆ clear() [2/2]

void CSCAnodeLCTProcessor::clear	(	const int	wire,
		const int	pattern
	)

protected

Clears the quality for a given wire and pattern if it is a ghost.

Definition at line 191 of file CSCAnodeLCTProcessor.cc.

References CSCConstants::ALCT_ACCELERATOR_PATTERN, CSCConstants::ALCT_COLLISIONA_PATTERN, CSCConstants::ALCT_COLLISIONB_PATTERN, topSingleLeptonDQM_PU_cfi::pattern, quality, and nano_mu_digi_cff::wire.

                                                                   {
   /* Clear the data off of selected pattern */
   if (pattern == CSCConstants::ALCT_ACCELERATOR_PATTERN)
     quality[wire][CSCConstants::ALCT_ACCELERATOR_PATTERN] = -999;
   else {
     quality[wire][CSCConstants::ALCT_COLLISIONA_PATTERN] = -999;
     quality[wire][CSCConstants::ALCT_COLLISIONB_PATTERN] = -999;
   }
 }

◆ dumpConfigParams()

void CSCAnodeLCTProcessor::dumpConfigParams ( ) const

protected

Dump ALCT configuration parameters.

Definition at line 1138 of file CSCAnodeLCTProcessor.cc.

References accel_mode, drift_delay, fifo_pretrig, fifo_tbins, l1a_window_width, LogDebug, nplanes_hit_accel_pattern, nplanes_hit_accel_pretrig, nplanes_hit_pattern, nplanes_hit_pretrig, and trig_mode.

Referenced by CSCAnodeLCTProcessor(), run(), and setConfigParameters().

                                                   {
   std::ostringstream strm;
   strm << "\n";
   strm << "++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n";
   strm << "+                  ALCT configuration parameters:                  +\n";
   strm << "++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n";
   strm << " fifo_tbins   [total number of time bins in DAQ readout] = " << fifo_tbins << "\n";
   strm << " fifo_pretrig [start time of anode raw hits in DAQ readout] = " << fifo_pretrig << "\n";
   strm << " drift_delay  [drift delay after pre-trigger, in 25 ns bins] = " << drift_delay << "\n";
   strm << " nplanes_hit_pretrig [min. number of layers hit for pre-trigger] = " << nplanes_hit_pretrig << "\n";
   strm << " nplanes_hit_pattern [min. number of layers hit for trigger] = " << nplanes_hit_pattern << "\n";
   strm << " nplanes_hit_accel_pretrig [min. number of layers hit for accel."
        << " pre-trig.] = " << nplanes_hit_accel_pretrig << "\n";
   strm << " nplanes_hit_accel_pattern [min. number of layers hit for accel."
        << " trigger] = " << nplanes_hit_accel_pattern << "\n";
   strm << " trig_mode  [enabling/disabling collision/accelerator tracks] = " << trig_mode << "\n";
   strm << " accel_mode [preference to collision/accelerator tracks] = " << accel_mode << "\n";
   strm << " l1a_window_width [L1Accept window width, in 25 ns bins] = " << l1a_window_width << "\n";
   strm << "++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n";
   LogDebug("CSCAnodeLCTProcessor") << strm.str();
 }

◆ dumpDigis()

void CSCAnodeLCTProcessor::dumpDigis ( const std::vector< int > wire[CSCConstants::NUM_LAYERS][CSCConstants::MAX_NUM_WIREGROUPS] ) const

protected

Dump digis on wire groups.

Definition at line 1161 of file CSCAnodeLCTProcessor.cc.

References TauDecayModes::dec, relativeConstraints::empty, LogDebug, LogTrace, CSCConstants::NUM_LAYERS, numWireGroups, CSCBaseboard::theCSCName_, and nano_mu_digi_cff::wire.

Referenced by pulseExtension().

                                                                                              {
   LogDebug("CSCAnodeLCTProcessor") << theCSCName_ << " nWiregroups " << numWireGroups;
 
   std::ostringstream strstrm;
   for (int i_wire = 0; i_wire < numWireGroups; i_wire++) {
     if (i_wire % 10 == 0) {
       if (i_wire < 100)
         strstrm << i_wire / 10;
       else
         strstrm << (i_wire - 100) / 10;
     } else
       strstrm << " ";
   }
   strstrm << "\n";
   for (int i_wire = 0; i_wire < numWireGroups; i_wire++) {
     strstrm << i_wire % 10;
   }
   for (int i_layer = 0; i_layer < CSCConstants::NUM_LAYERS; i_layer++) {
     strstrm << "\n";
     for (int i_wire = 0; i_wire < numWireGroups; i_wire++) {
       if (!wire[i_layer][i_wire].empty()) {
         std::vector<int> bx_times = wire[i_layer][i_wire];
         strstrm << std::hex << bx_times[0] << std::dec;
       } else {
         strstrm << ".";
       }
     }
   }
   LogTrace("CSCAnodeLCTProcessor") << strstrm.str();
 }

◆ encodeHighMultiplicityBits()

void CSCAnodeLCTProcessor::encodeHighMultiplicityBits ( )

protected

Definition at line 1376 of file CSCAnodeLCTProcessor.cc.

References anode_showers_, nano_mu_digi_cff::bx, digiV, spr::find(), mps_fire::i, CSCDetId::iChamberType(), CSCConstants::MAX_ALCT_TBINS, minLayersCentralTBin_, CSCConstants::NUM_LAYERS, showerNumTBins_, findQualityFiles::size, CSCBaseboard::theRing, CSCBaseboard::theStation, CSCBaseboard::theTrigChamber, and thresholds_.

Referenced by run().

                                                       {
   //numer of layer with hits and number of hits for 0-15 BXs
   std::set<unsigned> layersWithHits[CSCConstants::MAX_ALCT_TBINS];
   unsigned hitsInTime[CSCConstants::MAX_ALCT_TBINS];
   // Calculate layers with hits
   for (unsigned bx = 0; bx < CSCConstants::MAX_ALCT_TBINS; bx++) {
     hitsInTime[bx] = 0;
     for (unsigned i_layer = 0; i_layer < CSCConstants::NUM_LAYERS; i_layer++) {
       bool atLeastOneWGHit = false;
       for (const auto& wd : digiV[i_layer]) {
         std::vector<int> bx_times = wd.getTimeBinsOn();
         // there is at least one wiregroup in this bx
         if (std::find(bx_times.begin(), bx_times.end(), bx) != bx_times.end()) {
           hitsInTime[bx] += 1;
           atLeastOneWGHit = true;
         }
       }
       // add this layer to the number of layers hit
       if (atLeastOneWGHit) {
         layersWithHits[bx].insert(i_layer);
       }
     }
   }  //end of full bx loop
 
   // convert station and ring number to index
   // index runs from 2 to 10, subtract 2
   unsigned csc_idx = CSCDetId::iChamberType(theStation, theRing) - 2;
 
   // loose, nominal and tight
   std::vector<unsigned> station_thresholds = {
       thresholds_[csc_idx * 3], thresholds_[csc_idx * 3 + 1], thresholds_[csc_idx * 3 + 2]};
 
   for (unsigned bx = 0; bx < CSCConstants::MAX_ALCT_TBINS; bx++) {
     unsigned minbx = bx >= showerNumTBins_ / 2 ? bx - showerNumTBins_ / 2 : bx;
     unsigned maxbx = bx < CSCConstants::MAX_ALCT_TBINS - showerNumTBins_ / 2 ? bx + showerNumTBins_ / 2
                                                                              : CSCConstants::MAX_ALCT_TBINS - 1;
     unsigned this_hitsInTime = 0;
     for (unsigned mbx = minbx; mbx <= maxbx; mbx++) {
       this_hitsInTime += hitsInTime[mbx];
     }
 
     unsigned this_inTimeHMT = 0;
     // require at least nLayersWithHits for the central time bin
     // do nothing if there are not enough layers with hits
     if (layersWithHits[bx].size() >= minLayersCentralTBin_) {
       // assign the bits
       if (!station_thresholds.empty()) {
         for (int i = station_thresholds.size() - 1; i >= 0; i--) {
           if (this_hitsInTime >= station_thresholds[i]) {
             this_inTimeHMT = i + 1;
             break;
           }
         }
       }
     }
     //ALCT shower construction with showerType_=1, comparatorhits_= 0;
     anode_showers_[bx] = CSCShowerDigi(
         this_inTimeHMT, false, theTrigChamber, bx, CSCShowerDigi::ShowerType::kALCTShower, this_hitsInTime, 0);
   }
 }

◆ getALCTs()

std::vector< CSCALCTDigi > CSCAnodeLCTProcessor::getALCTs ( ) const

Returns vector of all found ALCTs, if any.

Definition at line 1270 of file CSCAnodeLCTProcessor.cc.

References bestALCT, nano_mu_digi_cff::bx, sistrip::SpyUtilities::isValid(), CSCConstants::MAX_ALCT_TBINS, and secondALCT.

Referenced by readoutALCTs(), and run().

                                                             {
   std::vector<CSCALCTDigi> tmpV;
   for (int bx = 0; bx < CSCConstants::MAX_ALCT_TBINS; bx++) {
     if (bestALCT[bx].isValid())
       tmpV.push_back(bestALCT[bx]);
     if (secondALCT[bx].isValid())
       tmpV.push_back(secondALCT[bx]);
   }
   return tmpV;
 }

◆ getAllShower()

std::vector< CSCShowerDigi > CSCAnodeLCTProcessor::getAllShower ( ) const

return vector of CSCShower digi

Definition at line 1294 of file CSCAnodeLCTProcessor.cc.

References anode_showers_, and CSCConstants::MAX_ALCT_TBINS.

                                                                   {
   std::vector<CSCShowerDigi> vshowers(anode_showers_, anode_showers_ + CSCConstants::MAX_ALCT_TBINS);
   return vshowers;
 };

◆ getBestALCT()

CSCALCTDigi CSCAnodeLCTProcessor::getBestALCT ( int bx ) const

Return best/second best ALCTs

Definition at line 1281 of file CSCAnodeLCTProcessor.cc.

References bestALCT, nano_mu_digi_cff::bx, CSCConstants::MAX_CLCT_TBINS, and or.

                                                           {
   if (bx >= CSCConstants::MAX_CLCT_TBINS or bx < 0)
     return CSCALCTDigi();
   return bestALCT[bx];
 }

◆ getDigis() [1/2]

bool CSCAnodeLCTProcessor::getDigis ( const CSCWireDigiCollection * wiredc )

protected

Access routines to wire digis.

Definition at line 391 of file CSCAnodeLCTProcessor.cc.

References digiV, CSCBaseboard::disableME1a_, relativeConstraints::empty, CSCBaseboard::infoV, CSCBaseboard::isME11_, LogTrace, CSCConstants::NUM_LAYERS, CSCBaseboard::theChamber, CSCBaseboard::theCSCName_, CSCBaseboard::theEndcap, CSCBaseboard::theRing, CSCBaseboard::theSector, CSCBaseboard::theStation, CSCBaseboard::theSubsector, and CSCBaseboard::theTrigChamber.

Referenced by run().

                                                                        {
   // Routine for getting digis and filling digiV vector.
   bool hasDigis = false;
 
   // Loop over layers and save wire digis on each one into digiV[layer].
   for (int i_layer = 0; i_layer < CSCConstants::NUM_LAYERS; i_layer++) {
     digiV[i_layer].clear();
 
     CSCDetId detid(theEndcap, theStation, theRing, theChamber, i_layer + 1);
     getDigis(wiredc, detid);
 
     // If this is ME1/1, fetch digis in corresponding ME1/A (ring=4) as well.
     if (isME11_ && !disableME1a_) {
       CSCDetId detid_me1a(theEndcap, theStation, 4, theChamber, i_layer + 1);
       getDigis(wiredc, detid_me1a);
     }
 
     if (!digiV[i_layer].empty()) {
       hasDigis = true;
       if (infoV > 1) {
         LogTrace("CSCAnodeLCTProcessor") << "found " << digiV[i_layer].size() << " wire digi(s) in layer " << i_layer
                                          << " of " << theCSCName_ << " (trig. sector " << theSector << " subsector "
                                          << theSubsector << " id " << theTrigChamber << ")";
         for (const auto& wd : digiV[i_layer]) {
           LogTrace("CSCAnodeLCTProcessor") << "   " << wd;
         }
       }
     }
   }
 
   return hasDigis;
 }

◆ getDigis() [2/2]

void CSCAnodeLCTProcessor::getDigis	(	const CSCWireDigiCollection *	wiredc,
		const CSCDetId &	id
	)

protected

Definition at line 424 of file CSCAnodeLCTProcessor.cc.

References digiV.

                                                                                            {
   CSCWireDigiCollection::Range rwired = wiredc->get(id);
   for (CSCWireDigiCollection::const_iterator digiIt = rwired.first; digiIt != rwired.second; ++digiIt) {
     digiV[id.layer() - 1].push_back(*digiIt);
   }
 }

◆ getSecondALCT()

CSCALCTDigi CSCAnodeLCTProcessor::getSecondALCT ( int bx ) const

Definition at line 1287 of file CSCAnodeLCTProcessor.cc.

References nano_mu_digi_cff::bx, CSCConstants::MAX_CLCT_TBINS, or, and secondALCT.

                                                             {
   if (bx >= CSCConstants::MAX_CLCT_TBINS or bx < 0)
     return CSCALCTDigi();
   return secondALCT[bx];
 }

◆ getTempALCTQuality()

int CSCAnodeLCTProcessor::getTempALCTQuality ( int temp_quality ) const

protectedvirtual

Reimplemented in CSCUpgradeAnodeLCTProcessor.

Definition at line 1351 of file CSCAnodeLCTProcessor.cc.

Referenced by patternDetection().

                                                                    {
   int Q;
   if (temp_quality > 3)
     Q = temp_quality - 3;
   else
     Q = 0;  // quality code 0 is valid!
 
   return Q;
 }

◆ ghostCancellationLogicOneWire()

void CSCAnodeLCTProcessor::ghostCancellationLogicOneWire	(	const int	key_wire,
		int *	ghost_cleared
	)

protectedvirtual

Reimplemented in CSCUpgradeAnodeLCTProcessor.

Definition at line 771 of file CSCAnodeLCTProcessor.cc.

References CSCConstants::ALCT_ACCELERATOR_PATTERN, dt, first_bx, ghost_cancellation_bx_depth, ghost_cancellation_side_quality, CSCBaseboard::infoV, lct_list, LogTrace, AlCaHLTBitMon_ParallelJobs::p, and quality.

Referenced by run().

                                                                                                {
   for (int i_pattern = 0; i_pattern < 2; i_pattern++) {
     ghost_cleared[i_pattern] = 0;
     if (key_wire == 0)
       continue;  //ignore
 
     // Non-empty wire group.
     int qual_this = quality[key_wire][i_pattern];
     if (qual_this > 0) {
       // Previous wire.
       //int qual_prev = (key_wire > 0) ? quality[key_wire-1][i_pattern] : 0;
       //previous ALCTs were pushed to lct_list, stop use the array quality[key_wire-1][i_pattern]
       for (auto& p : lct_list) {
         //ignore whether ALCT is valid or not in ghost cancellation
         //if wiregroup 10, 11, 12 all have trigger and same quality, only wiregroup 10 can keep the trigger
         //this met with firmware
         if (not(p.getKeyWG() == key_wire - 1 and 1 - p.getAccelerator() == i_pattern))
           continue;
 
         bool ghost_cleared_prev = false;
         int qual_prev = p.getQuality();
         int first_bx_prev = p.getBX();
         if (infoV > 1)
           LogTrace("CSCAnodeLCTProcessor")
               << "ghost concellation logic "
               << ((i_pattern == CSCConstants::ALCT_ACCELERATOR_PATTERN) ? "Accelerator" : "Collision") << " key_wire "
               << key_wire << " quality " << qual_this << " bx " << first_bx[key_wire] << " previous key_wire "
               << key_wire - 1 << " quality " << qual_prev << " bx " << first_bx[key_wire - 1];
 
         //int dt = first_bx[key_wire] - first_bx[key_wire-1];
         int dt = first_bx[key_wire] - first_bx_prev;
         // Cancel this wire
         //   1) If the candidate at the previous wire is at the same bx
         //      clock and has better quality (or equal quality - this has
         //      been implemented only in 2004).
         //   2) If the candidate at the previous wire is up to 4 clocks
         //      earlier, regardless of quality.
         if (dt == 0) {
           if (qual_prev >= qual_this)
             ghost_cleared[i_pattern] = 1;
           else if (qual_prev < qual_this)
             ghost_cleared_prev = true;
         } else if (dt > 0 && dt <= ghost_cancellation_bx_depth) {
           if ((!ghost_cancellation_side_quality) || (qual_prev > qual_this))
             ghost_cleared[i_pattern] = 1;
         } else if (dt < 0 && dt * (-1) <= ghost_cancellation_bx_depth) {
           if ((!ghost_cancellation_side_quality) || (qual_prev < qual_this))
             ghost_cleared_prev = true;
         }
 
         if (ghost_cleared[i_pattern] == 1) {
           if (infoV > 1)
             LogTrace("CSCAnodeLCTProcessor")
                 << ((i_pattern == CSCConstants::ALCT_ACCELERATOR_PATTERN) ? "Accelerator" : "Collision")
                 << " pattern ghost cancelled on key_wire " << key_wire << " q=" << qual_this << "  by wire "
                 << key_wire - 1 << " q=" << qual_prev;
           //cancellation for key_wire is done when ALCT is created and pushed to lct_list
         }
 
         if (ghost_cleared_prev) {
           if (infoV > 1)
             LogTrace("CSCAnodeLCTProcessor")
                 << ((i_pattern == CSCConstants::ALCT_ACCELERATOR_PATTERN) ? "Accelerator" : "Collision")
                 << " pattern ghost cancelled on key_wire " << key_wire - 1 << " q=" << qual_prev << "  by wire "
                 << key_wire << " q=" << qual_this;
           p.setValid(0);  //clean prev ALCT
         }
       }
 
     }  // if qual_this > 0
   }    //i_pattern
 }

◆ isBetterALCT()

bool CSCAnodeLCTProcessor::isBetterALCT	(	const CSCALCTDigi &	lhsALCT,
		const CSCALCTDigi &	rhsALCT
	)		const

protected

Definition at line 1016 of file CSCAnodeLCTProcessor.cc.

References accel_mode, CSCALCTDigi::getAccelerator(), CSCALCTDigi::getBX(), CSCALCTDigi::getQuality(), and CSCALCTDigi::isValid().

Referenced by lctSearch().

                                                                                                     {
   bool returnValue = false;
 
   if (lhsALCT.isValid() && !rhsALCT.isValid()) {
     return true;
   }
 
   // ALCTs found at earlier bx times are ranked higher than ALCTs found at
   // later bx times regardless of the quality.
   if (lhsALCT.getBX() < rhsALCT.getBX()) {
     returnValue = true;
   }
   if (lhsALCT.getBX() != rhsALCT.getBX()) {
     return returnValue;
   }
 
   // First check the quality of ALCTs.
   const int qual1 = lhsALCT.getQuality();
   const int qual2 = rhsALCT.getQuality();
   if (qual1 > qual2) {
     returnValue = true;
   }
   // If qualities are the same, check accelerator bits of both ALCTs.
   // If they are not the same, rank according to accel_mode value.
   // If they are the same, keep the track selector assignment.
   //else if (qual1 == qual2 &&
   //         lhsALCT.getAccelerator() != rhsALCT.getAccelerator() &&
   //         quality[lhsALCT.getKeyWG()][1-lhsALCT.getAccelerator()] >
   //         quality[rhsALCT.getKeyWG()][1-rhsALCT.getAccelerator()])
   //  {returnValue = true;}
   else if (qual1 == qual2 && lhsALCT.getAccelerator() != rhsALCT.getAccelerator()) {
     if ((accel_mode == 0 || accel_mode == 1) && rhsALCT.getAccelerator() == 0)
       returnValue = true;
     if ((accel_mode == 2 || accel_mode == 3) && lhsALCT.getAccelerator() == 0)
       returnValue = true;
   }
 
   return returnValue;
 }

◆ lctSearch()

void CSCAnodeLCTProcessor::lctSearch ( )

protected

Definition at line 844 of file CSCAnodeLCTProcessor.cc.

References bestALCT, bestTrackSelector(), nano_mu_digi_cff::bx, CSCALCTDigi::getFullBX(), CSCBaseboard::infoV, isBetterALCT(), sistrip::SpyUtilities::isValid(), CSCConstants::LCT_CENTRAL_BX, lct_list, LogDebug, LogTrace, CSCConstants::MAX_ALCT_TBINS, AlCaHLTBitMon_ParallelJobs::p, qualityControl_, secondALCT, CSCALCTDigi::setTrknmb(), CSCBaseboard::theChamber, CSCBaseboard::theCSCName_, CSCBaseboard::theEndcap, CSCBaseboard::theRing, CSCBaseboard::theSector, CSCBaseboard::theStation, CSCBaseboard::theSubsector, and CSCBaseboard::theTrigChamber.

Referenced by run().

                                      {
   // Best track selector selects two collision and two accelerator ALCTs
   // with the best quality per time bin.
   const std::vector<CSCALCTDigi>& fourBest = bestTrackSelector(lct_list);
 
   if (infoV > 0) {
     int n_alct_all = 0, n_alct = 0;
     for (const auto& p : lct_list) {
       if (p.isValid() && p.getBX() == CSCConstants::LCT_CENTRAL_BX)
         n_alct_all++;
     }
     for (const auto& p : fourBest) {
       if (p.isValid() && p.getBX() == CSCConstants::LCT_CENTRAL_BX)
         n_alct++;
     }
 
     LogTrace("CSCAnodeLCTProcessor") << "alct_count E:" << theEndcap << "S:" << theStation << "R:" << theRing
                                      << "C:" << theChamber << "  all " << n_alct_all << "  found " << n_alct;
   }
 
   // Select two best of four per time bin, based on quality and
   // accel_mode parameter.
   for (const auto& p : fourBest) {
     const int bx = p.getBX();
     if (bx >= CSCConstants::MAX_ALCT_TBINS) {
       if (infoV > 0)
         edm::LogWarning("CSCAnodeLCTProcessor|OutOfTimeALCT")
             << "+++ Bx of ALCT candidate, " << bx << ", exceeds max allowed, " << CSCConstants::MAX_ALCT_TBINS - 1
             << "; skipping it... +++\n";
       continue;
     }
 
     if (isBetterALCT(p, bestALCT[bx])) {
       if (isBetterALCT(bestALCT[bx], secondALCT[bx])) {
         secondALCT[bx] = bestALCT[bx];
       }
       bestALCT[bx] = p;
     } else if (isBetterALCT(p, secondALCT[bx])) {
       secondALCT[bx] = p;
     }
   }
 
   for (int bx = 0; bx < CSCConstants::MAX_ALCT_TBINS; bx++) {
     if (bestALCT[bx].isValid()) {
       bestALCT[bx].setTrknmb(1);
 
       // check if the best ALCT is valid
       qualityControl_->checkValidReadout(bestALCT[bx]);
 
       if (infoV > 0) {
         LogDebug("CSCAnodeLCTProcessor") << bestALCT[bx] << " fullBX = " << bestALCT[bx].getFullBX() << " found in "
                                          << theCSCName_ << " (sector " << theSector << " subsector " << theSubsector
                                          << " trig id. " << theTrigChamber << ")"
                                          << "\n";
       }
       if (secondALCT[bx].isValid()) {
         secondALCT[bx].setTrknmb(2);
 
         // check if the second best ALCT is valid
         qualityControl_->checkValidReadout(secondALCT[bx]);
 
         if (infoV > 0) {
           LogDebug("CSCAnodeLCTProcessor")
               << secondALCT[bx] << " fullBX = " << secondALCT[bx].getFullBX() << " found in " << theCSCName_
               << " (sector " << theSector << " subsector " << theSubsector << " trig id. " << theTrigChamber << ")"
               << "\n";
         }
       }
     }
   }
 }

◆ loadPatternMask()

void CSCAnodeLCTProcessor::loadPatternMask ( )

protected

Load pattern mask defined by configuration into pattern_mask

Definition at line 94 of file CSCAnodeLCTProcessor.cc.

References alct_pattern_, CSCPatternBank::alct_pattern_legacy_, CSCPatternBank::alct_pattern_r1_, narrow_mask_r1, and CSCBaseboard::theRing.

Referenced by CSCAnodeLCTProcessor().

                                            {
   // Load appropriate pattern mask.
   if (narrow_mask_r1 && (theRing == 1 || theRing == 4)) {
     alct_pattern_ = CSCPatternBank::alct_pattern_r1_;
   } else {
     alct_pattern_ = CSCPatternBank::alct_pattern_legacy_;
   }
 }

◆ patternDetection()

bool CSCAnodeLCTProcessor::patternDetection	(	const int	key_wire,
		std::map< int, std::map< int, CSCALCTDigi::WireContainer > > &	hits_in_patterns
	)

protected

Definition at line 626 of file CSCAnodeLCTProcessor.cc.

References funct::abs(), CSCConstants::ALCT_ACCELERATOR_PATTERN, CSCConstants::ALCT_COLLISIONA_PATTERN, CSCConstants::ALCT_COLLISIONB_PATTERN, CSCPatternBank::alct_keywire_offset_, alct_pattern_, CSCConstants::ALCT_PATTERN_WIDTH, drift_delay, first_bx, first_bx_corrected, getTempALCTQuality(), hit_persist, CSCBaseboard::infoV, CSCConstants::INVALID_WIREGROUP, PulseArray::isOneShotHighAtBX(), LogTrace, MESelection, nplanes_hit_accel_pattern, nplanes_hit_pattern, CSCConstants::NUM_ALCT_PATTERNS, CSCConstants::NUM_LAYERS, numWireGroups, AlCaHLTBitMon_ParallelJobs::p, pulse_, quality, AlCaHLTBitMon_QueryRunRegistry::string, and trigMode().

Referenced by run().

                                                                                               {
   bool trigger = false;
   bool hit_layer[CSCConstants::NUM_LAYERS];
   unsigned int temp_quality;
   int this_wire, delta_wire;
   // If nplanes_hit_accel_pattern is 0, the firmware uses the value
   // of nplanes_hit_pattern instead.
   const unsigned int nplanes_hit_pattern_acc =
       (nplanes_hit_accel_pattern != 0) ? nplanes_hit_accel_pattern : nplanes_hit_pattern;
   const unsigned int pattern_thresh[CSCConstants::NUM_ALCT_PATTERNS] = {
       nplanes_hit_pattern_acc, nplanes_hit_pattern, nplanes_hit_pattern};
   const std::string ptn_label[] = {"Accelerator", "CollisionA", "CollisionB"};
 
   for (int i_pattern = 0; i_pattern < CSCConstants::NUM_ALCT_PATTERNS; i_pattern++) {
     temp_quality = 0;
 
     // initialize the hit layers
     for (int i_layer = 0; i_layer < CSCConstants::NUM_LAYERS; i_layer++)
       hit_layer[i_layer] = false;
 
     // clear a single pattern!
     CSCALCTDigi::WireContainer hits_single_pattern;
     hits_single_pattern.clear();
     hits_single_pattern.resize(CSCConstants::NUM_LAYERS);
     for (auto& p : hits_single_pattern) {
       p.resize(CSCConstants::ALCT_PATTERN_WIDTH, CSCConstants::INVALID_WIREGROUP);
     }
 
     double num_pattern_hits = 0., times_sum = 0.;
     std::multiset<int> mset_for_median;
     mset_for_median.clear();
 
     for (int i_layer = 0; i_layer < CSCConstants::NUM_LAYERS; i_layer++) {
       for (int i_wire = 0; i_wire < CSCConstants::ALCT_PATTERN_WIDTH; i_wire++) {
         // check if the hit is valid
         if (alct_pattern_[i_pattern][i_layer][i_wire]) {
           delta_wire = CSCPatternBank::alct_keywire_offset_[MESelection][i_wire];
           this_wire = delta_wire + key_wire;
           if ((this_wire >= 0) && (this_wire < numWireGroups)) {
             // Wait a drift_delay time later and look for layers hit in
             // the pattern.
             if (pulse_.isOneShotHighAtBX(i_layer, this_wire, first_bx[key_wire] + drift_delay)) {
               // store hits in the temporary pattern vector
               hits_single_pattern[i_layer][i_wire] = this_wire;
 
               // If layer has never had a hit before, then increment number
               // of layer hits.
               if (!hit_layer[i_layer]) {
                 temp_quality++;
                 // keep track of which layers already had hits.
                 hit_layer[i_layer] = true;
                 if (infoV > 1)
                   LogTrace("CSCAnodeLCTProcessor")
                       << "bx_time: " << first_bx[key_wire] << " pattern: " << i_pattern << " keywire: " << key_wire
                       << " layer: " << i_layer << " quality: " << temp_quality;
               }
 
               // for averaged time use only the closest WGs around the key WG
               if (abs(delta_wire) < 2) {
                 // find at what bx did pulse on this wire&layer start
                 // use hit_pesrist constraint on how far back we can go
                 int first_bx_layer = first_bx[key_wire] + drift_delay;
                 for (unsigned int dbx = 0; dbx < hit_persist; dbx++) {
                   if (pulse_.isOneShotHighAtBX(i_layer, this_wire, first_bx_layer - 1)) {
                     first_bx_layer--;
                   } else
                     break;
                 }
                 times_sum += (double)first_bx_layer;
                 num_pattern_hits += 1.;
                 mset_for_median.insert(first_bx_layer);
                 if (infoV > 2)
                   LogTrace("CSCAnodeLCTProcessor") << " 1st bx in layer: " << first_bx_layer << " sum bx: " << times_sum
                                                    << " #pat. hits: " << num_pattern_hits;
               }
             }
           }
         }
       }
     }
 
     // calculate median
     const int sz = mset_for_median.size();
     if (sz > 0) {
       std::multiset<int>::iterator im = mset_for_median.begin();
       if (sz > 1)
         std::advance(im, sz / 2 - 1);
       if (sz == 1)
         first_bx_corrected[key_wire] = *im;
       else if ((sz % 2) == 1)
         first_bx_corrected[key_wire] = *(++im);
       else
         first_bx_corrected[key_wire] = ((*im) + (*(++im))) / 2;
 
 #if defined(EDM_ML_DEBUG)
       if (infoV > 1) {
         auto lt = LogTrace("CSCAnodeLCTProcessor")
                   << "bx=" << first_bx[key_wire] << " bx_cor=" << first_bx_corrected[key_wire] << "  bxset=";
         for (im = mset_for_median.begin(); im != mset_for_median.end(); im++) {
           lt << " " << *im;
         }
       }
 #endif
     }
 
     // save the pattern information when a trigger was formed!
     if (temp_quality >= pattern_thresh[i_pattern]) {
       trigger = true;
       hits_in_patterns[key_wire][i_pattern] = hits_single_pattern;
 
       // Quality definition changed on 22 June 2007: it no longer depends
       // on pattern_thresh.
       temp_quality = getTempALCTQuality(temp_quality);
 
       if (i_pattern == CSCConstants::ALCT_ACCELERATOR_PATTERN) {
         // Accelerator pattern
         quality[key_wire][CSCConstants::ALCT_ACCELERATOR_PATTERN] = temp_quality;
       } else {
         // Only one collision pattern (of the best quality) is reported
         if (static_cast<int>(temp_quality) > quality[key_wire][CSCConstants::ALCT_COLLISIONA_PATTERN]) {
           quality[key_wire][CSCConstants::ALCT_COLLISIONA_PATTERN] = temp_quality;   //real quality
           quality[key_wire][CSCConstants::ALCT_COLLISIONB_PATTERN] = i_pattern - 1;  // pattern, left or right
         }
       }
       if (infoV > 1) {
         LogTrace("CSCAnodeLCTProcessor") << "Pattern found; keywire: " << key_wire << " type: " << ptn_label[i_pattern]
                                          << " quality: " << temp_quality << "\n";
       }
     }
   }
   if (infoV > 1 && quality[key_wire][CSCConstants::ALCT_COLLISIONA_PATTERN] > 0) {
     if (quality[key_wire][CSCConstants::ALCT_COLLISIONB_PATTERN] == 0)
       LogTrace("CSCAnodeLCTProcessor") << "Collision Pattern A is chosen"
                                        << "\n";
     else if (quality[key_wire][CSCConstants::ALCT_COLLISIONB_PATTERN] == 1)
       LogTrace("CSCAnodeLCTProcessor") << "Collision Pattern B is chosen"
                                        << "\n";
   }
 
   trigMode(key_wire);
 
   return trigger;
 }

◆ preTrigger()

bool CSCAnodeLCTProcessor::preTrigger	(	const int	key_wire,
		const int	start_bx
	)

protected

Definition at line 559 of file CSCAnodeLCTProcessor.cc.

References CSCPatternBank::alct_keywire_offset_, alct_pattern_, CSCConstants::ALCT_PATTERN_WIDTH, drift_delay, fifo_tbins, first_bx, CSCBaseboard::infoV, PulseArray::isOneShotHighAtBX(), LogTrace, MESelection, nplanes_hit_accel_pretrig, nplanes_hit_pretrig, CSCConstants::NUM_ALCT_PATTERNS, CSCConstants::NUM_LAYERS, numWireGroups, pulse_, and thePreTriggerDigis.

Referenced by run().

                                                                             {
   int nPreTriggers = 0;
 
   unsigned int layers_hit;
   bool hit_layer[CSCConstants::NUM_LAYERS];
   int this_wire;
   // If nplanes_hit_accel_pretrig is 0, the firmware uses the value
   // of nplanes_hit_pretrig instead.
   const unsigned int nplanes_hit_pretrig_acc =
       (nplanes_hit_accel_pretrig != 0) ? nplanes_hit_accel_pretrig : nplanes_hit_pretrig;
   const unsigned int pretrig_thresh[CSCConstants::NUM_ALCT_PATTERNS] = {
       nplanes_hit_pretrig_acc, nplanes_hit_pretrig, nplanes_hit_pretrig};
 
   // Loop over bx times, accelerator and collision patterns to
   // look for pretrigger.
   // Stop drift_delay bx's short of fifo_tbins since at later bx's we will
   // not have a full set of hits to start pattern search anyway.
   unsigned int stop_bx = fifo_tbins - drift_delay;
   for (unsigned int bx_time = start_bx; bx_time < stop_bx; bx_time++) {
     for (int i_pattern = 0; i_pattern < CSCConstants::NUM_ALCT_PATTERNS; i_pattern++) {
       // initialize the hit layers
       for (int i_layer = 0; i_layer < CSCConstants::NUM_LAYERS; i_layer++)
         hit_layer[i_layer] = false;
       layers_hit = 0;
 
       // now run over all layers and wires
       for (int i_layer = 0; i_layer < CSCConstants::NUM_LAYERS; i_layer++) {
         for (int i_wire = 0; i_wire < CSCConstants::ALCT_PATTERN_WIDTH; i_wire++) {
           // check if the hit is valid
           if (alct_pattern_[i_pattern][i_layer][i_wire]) {
             this_wire = CSCPatternBank::alct_keywire_offset_[MESelection][i_wire] + key_wire;
             if ((this_wire >= 0) && (this_wire < numWireGroups)) {
               // Perform bit operation to see if pulse is 1 at a certain bx_time.
               if (pulse_.isOneShotHighAtBX(i_layer, this_wire, bx_time)) {
                 // Store number of layers hit.
                 if (!hit_layer[i_layer]) {
                   hit_layer[i_layer] = true;
                   layers_hit++;
                 }
 
                 // See if number of layers hit is greater than or equal to
                 // pretrig_thresh.
                 if (layers_hit >= pretrig_thresh[i_pattern]) {
                   first_bx[key_wire] = bx_time;
                   if (infoV > 1) {
                     LogTrace("CSCAnodeLCTProcessor") << "Pretrigger was satisfied for wire: " << key_wire
                                                      << " pattern: " << i_pattern << " bx_time: " << bx_time;
                   }
                   // make a new pre-trigger
                   nPreTriggers++;
                   // make a new pre-trigger digi
                   // useful for calculating DAQ rates
                   thePreTriggerDigis.emplace_back(
                       CSCALCTPreTriggerDigi(1, layers_hit - 3, 0, 0, this_wire, bx_time, nPreTriggers));
                   return true;
                 }
               }
             }
           }
         }
       }
     }
   }
   // If the pretrigger was never satisfied, then return false.
   return false;
 }

◆ preTriggerDigis()

std::vector<CSCALCTPreTriggerDigi> CSCAnodeLCTProcessor::preTriggerDigis ( ) const

inline

read out pre-ALCTs

Definition at line 84 of file CSCAnodeLCTProcessor.h.

References thePreTriggerDigis.

84 { return thePreTriggerDigis; }

CSCAnodeLCTProcessor::thePreTriggerDigis

std::vector< CSCALCTPreTriggerDigi > thePreTriggerDigis

Definition: CSCAnodeLCTProcessor.h:126

◆ pulseExtension()

bool CSCAnodeLCTProcessor::pulseExtension ( const std::vector< int > wire[CSCConstants::NUM_LAYERS][CSCConstants::MAX_NUM_WIREGROUPS] )

protected

Definition at line 488 of file CSCAnodeLCTProcessor.cc.

References PulseArray::bitsInPulse(), PulseArray::clear(), dumpDigis(), relativeConstraints::empty, PulseArray::extend(), first_bx, first_bx_corrected, hit_persist, mps_fire::i, CSCBaseboard::infoV, dqmiolumiharvest::j, LogTrace, CSCConstants::NUM_LAYERS, numWireGroups, PulseArray::oneShotAtBX(), pulse_, quality, and nano_mu_digi_cff::wire.

Referenced by run().

                                                                                        {
   bool chamber_empty = true;
   int i_wire, i_layer, digi_num;
 
   const unsigned bits_in_pulse = pulse_.bitsInPulse();
 
   // Clear pulse array.  This array will be used as a bit representation of
   // hit times.  For example: if strip[1][2] has a value of 3, then 1 shifted
   // left 3 will be bit pattern of pulse[1][2].  This would make the pattern
   // look like 0000000000001000.  Then add on additional bits to signify
   // the duration of a signal (hit_persist, formerly bx_width) to simulate
   // the TMB's drift delay.  So for the same pulse[1][2] with a hit_persist
   // of 3 would look like 0000000000111000.  This is similating the digital
   // one-shot in the TMB.
   pulse_.clear();
 
   for (i_wire = 0; i_wire < numWireGroups; i_wire++) {
     first_bx[i_wire] = -999;
     first_bx_corrected[i_wire] = -999;
     for (int j = 0; j < 3; j++)
       quality[i_wire][j] = -999;
   }
 
   for (i_layer = 0; i_layer < CSCConstants::NUM_LAYERS; i_layer++) {
     digi_num = 0;
     for (i_wire = 0; i_wire < numWireGroups; i_wire++) {
       if (!wire[i_layer][i_wire].empty()) {
         std::vector<int> bx_times = wire[i_layer][i_wire];
         for (unsigned int i = 0; i < bx_times.size(); i++) {
           // Check that min and max times are within the allowed range.
           if (bx_times[i] < 0 || bx_times[i] + hit_persist >= bits_in_pulse) {
             if (infoV > 0)
               edm::LogWarning("CSCAnodeLCTProcessor|OutOfTimeDigi")
                   << "+++ BX time of wire digi (wire = " << i_wire << " layer = " << i_layer << ") bx = " << bx_times[i]
                   << " is not within the range (0-" << bits_in_pulse
                   << "] allowed for pulse extension.  Skip this digi! +++\n";
             continue;
           }
 
           // Found at least one in-time digi; set chamber_empty to false
           if (chamber_empty)
             chamber_empty = false;
 
           // make the pulse
           pulse_.extend(i_layer, i_wire, bx_times[i], hit_persist);
 
           // Debug information.
           if (infoV > 1) {
             LogTrace("CSCAnodeLCTProcessor") << "Wire digi: layer " << i_layer << " digi #" << ++digi_num
                                              << " wire group " << i_wire << " time " << bx_times[i];
             if (infoV > 2) {
               std::ostringstream strstrm;
               for (int i = 1; i <= 32; i++) {
                 strstrm << pulse_.oneShotAtBX(i_layer, i_wire, 32 - i);
               }
               LogTrace("CSCAnodeLCTProcessor") << "  Pulse: " << strstrm.str();
             }
           }
         }
       }
     }
   }
 
   if (infoV > 1 && !chamber_empty) {
     dumpDigis(wire);
   }
 
   return chamber_empty;
 }

◆ readoutALCTs()

std::vector< CSCALCTDigi > CSCAnodeLCTProcessor::readoutALCTs ( ) const

Returns vector of ALCTs in the read-out time window, if any.

Definition at line 1195 of file CSCAnodeLCTProcessor.cc.

References nano_mu_digi_cff::bx, early_tbins, fifo_pretrig, getALCTs(), CSCBaseboard::infoV, l1a_window_width, CSCConstants::LCT_CENTRAL_BX, LogDebug, CSCConstants::MAX_ALCT_TBINS, AlCaHLTBitMon_ParallelJobs::p, and qualityControl_.

                                                                 {
   std::vector<CSCALCTDigi> tmpV;
 
   // The number of LCT bins in the read-out is given by the
   // l1a_window_width parameter, but made even by setting the LSB of
   // l1a_window_width to 0.
   const int lct_bins = l1a_window_width;
   static std::atomic<int> late_tbins{early_tbins + lct_bins};
 
   static std::atomic<int> ifois{0};
   if (ifois == 0) {
     if (infoV >= 0 && early_tbins < 0) {
       edm::LogWarning("CSCAnodeLCTProcessor|SuspiciousParameters")
           << "+++ fifo_pretrig = " << fifo_pretrig << "; in-time ALCTs are not getting read-out!!! +++"
           << "\n";
     }
 
     if (late_tbins > CSCConstants::MAX_ALCT_TBINS - 1) {
       if (infoV >= 0)
         edm::LogWarning("CSCAnodeLCTProcessor|SuspiciousParameters")
             << "+++ Allowed range of time bins, [0-" << late_tbins << "] exceeds max allowed, "
             << CSCConstants::MAX_ALCT_TBINS - 1 << " +++\n"
             << "+++ Set late_tbins to max allowed +++\n";
       late_tbins = CSCConstants::MAX_ALCT_TBINS - 1;
     }
     ifois = 1;
   }
 
   // Start from the vector of all found ALCTs and select those within
   // the ALCT*L1A coincidence window.
   const std::vector<CSCALCTDigi>& all_alcts = getALCTs();
   for (const auto& p : all_alcts) {
     if (!p.isValid())
       continue;
 
     int bx = p.getBX();
     // Skip ALCTs found too early relative to L1Accept.
     if (bx <= early_tbins) {
       if (infoV > 1)
         LogDebug("CSCAnodeLCTProcessor") << " Do not report ALCT on keywire " << p.getKeyWG() << ": found at bx " << bx
                                          << ", whereas the earliest allowed bx is " << early_tbins + 1;
       continue;
     }
 
     // Skip ALCTs found too late relative to L1Accept.
     if (bx > late_tbins) {
       if (infoV > 1)
         LogDebug("CSCAnodeLCTProcessor") << " Do not report ALCT on keywire " << p.getKeyWG() << ": found at bx " << bx
                                          << ", whereas the latest allowed bx is " << late_tbins;
       continue;
     }
 
     tmpV.push_back(p);
   }
 
   // shift the BX from 8 to 3
   // ALCTs in real data have the central BX in bin 3
   // which is the middle of the 7BX wide L1A window
   // ALCTs used in the TMB emulator have central BX at bin 8
   // but right before we put emulated ALCTs in the event, we shift the BX
   // by -5 to make sure they are compatible with real data ALCTs!
   for (auto& p : tmpV) {
     p.setBX(p.getBX() - (CSCConstants::LCT_CENTRAL_BX - l1a_window_width / 2));
   }
 
   // do a final check on the ALCTs in readout
   qualityControl_->checkMultiplicityBX(tmpV);
   for (const auto& alct : tmpV) {
     qualityControl_->checkValid(alct);
   }
 
   return tmpV;
 }

◆ readoutShower()

std::vector< CSCShowerDigi > CSCAnodeLCTProcessor::readoutShower ( ) const

Returns shower bits

Definition at line 1300 of file CSCAnodeLCTProcessor.cc.

References anode_showers_, nano_mu_digi_cff::bx, sistrip::SpyUtilities::isValid(), l1a_window_width, CSCConstants::LCT_CENTRAL_BX, maxbx_readout_, l1tnanotables_cff::minBX, and minbx_readout_.

                                                                    {
   unsigned minBXdiff = 2 * l1a_window_width;  //impossible value
   unsigned minBX = 0;
   std::vector<CSCShowerDigi> showerOut;
   for (unsigned bx = minbx_readout_; bx < maxbx_readout_; bx++) {
     unsigned bx_diff = (bx > bx - CSCConstants::LCT_CENTRAL_BX) ? bx - CSCConstants::LCT_CENTRAL_BX
                                                                 : CSCConstants::LCT_CENTRAL_BX - bx;
     if (anode_showers_[bx].isValid() and bx_diff < minBXdiff) {
       minBXdiff = bx_diff;
       minBX = bx;
     }
   }
 
   for (unsigned bx = minbx_readout_; bx < maxbx_readout_; bx++)
     if (bx == minBX)
       showerOut.push_back(anode_showers_[bx]);
   return showerOut;
 }

◆ readWireDigis()

void CSCAnodeLCTProcessor::readWireDigis ( std::vector< int > wire[CSCConstants::NUM_LAYERS][CSCConstants::MAX_NUM_WIREGROUPS] )

protected

Definition at line 431 of file CSCAnodeLCTProcessor.cc.

References digiV, fifo_tbins, mps_fire::i, CSCBaseboard::infoV, LogTrace, CSCConstants::NUM_LAYERS, numWireGroups, and nano_mu_digi_cff::wire.

Referenced by run().

                                                                                  {
   // Loop over all 6 layers.
   for (int i_layer = 0; i_layer < CSCConstants::NUM_LAYERS; i_layer++) {
     // Loop over all digis in the layer and find the wireGroup and bx
     // time for each.
     for (const auto& wd : digiV[i_layer]) {
       int i_wire = wd.getWireGroup() - 1;
       std::vector<int> bx_times = wd.getTimeBinsOn();
 
       // Check that the wires and times are appropriate.
       if (i_wire < 0 || i_wire >= numWireGroups) {
         if (infoV >= 0)
           edm::LogWarning("CSCAnodeLCTProcessor|WrongInput")
               << "+++ Found wire digi with wrong wire number = " << i_wire << " (max wires = " << numWireGroups
               << "); skipping it... +++\n";
         continue;
       }
       // Accept digis in expected time window.  Total number of time
       // bins in DAQ readout is given by fifo_tbins, which thus
       // determines the maximum length of time interval.  Anode raw
       // hits in DAQ readout start (fifo_pretrig - 6) clocks before
       // L1Accept.  If times earlier than L1Accept were recorded, we
       // use them since they can modify the ALCTs found later, via
       // ghost-cancellation logic.
       int last_time = -999;
       if (bx_times.size() == fifo_tbins) {
         wire[i_layer][i_wire].push_back(0);
         wire[i_layer][i_wire].push_back(6);
       } else {
         for (unsigned int i = 0; i < bx_times.size(); i++) {
           // Find rising edge change
           if (i > 0 && bx_times[i] == (bx_times[i - 1] + 1))
             continue;
           if (bx_times[i] < static_cast<int>(fifo_tbins)) {
             if (infoV > 2)
               LogTrace("CSCAnodeLCTProcessor")
                   << "Digi on layer " << i_layer << " wire " << i_wire << " at time " << bx_times[i];
 
             // Finally save times of hit wires.  One shot module will
             // not restart if a new pulse comes before the expiration
             // of the 6-bx period.
             if (last_time < 0 || ((bx_times[i] - last_time) >= 6)) {
               wire[i_layer][i_wire].push_back(bx_times[i]);
               last_time = bx_times[i];
             }
           } else {
             if (infoV > 1)
               LogTrace("CSCAnodeLCTProcessor") << "+++ Skipping wire digi: wire = " << i_wire << " layer = " << i_layer
                                                << ", bx = " << bx_times[i] << " +++";
           }
         }
       }
     }
   }
 }

◆ run() [1/2]

std::vector< CSCALCTDigi > CSCAnodeLCTProcessor::run	(	const CSCWireDigiCollection *	wiredc,
		CSCChamber const *	chamber
	)

Definition at line 201 of file CSCAnodeLCTProcessor.cc.

References CSCBaseboard::cscChamber(), dumpConfigParams(), relativeConstraints::empty, encodeHighMultiplicityBits(), CSCLayer::geometry(), getALCTs(), getDigis(), CSCBaseboard::infoV, CSCChamber::layer(), CSCConstants::MAX_NUM_WIREGROUPS, nplanes_hit_accel_pattern, nplanes_hit_pattern, CSCConstants::NUM_LAYERS, CSCLayerGeometry::numberOfWireGroups(), numWireGroups, or, qualityControl_, readWireDigis(), CSCBaseboard::runPhase2_, CSCBaseboard::theCSCName_, CSCBaseboard::theRing, CSCBaseboard::theSector, CSCBaseboard::theStation, CSCBaseboard::theSubsector, and CSCBaseboard::theTrigChamber.

                                                                                                                   {
   static std::atomic<bool> config_dumped{false};
   if ((infoV > 0 || (runPhase2_)) && !config_dumped) {
     dumpConfigParams();
     config_dumped = true;
   }
 
   // Get the number of wire groups for the given chamber.  Do it only once
   // per chamber.
   if (numWireGroups <= 0 or numWireGroups > CSCConstants::MAX_NUM_WIREGROUPS) {
     if (cscChamber) {
       numWireGroups = cscChamber->layer(1)->geometry()->numberOfWireGroups();
       if (numWireGroups > CSCConstants::MAX_NUM_WIREGROUPS) {
         edm::LogError("CSCAnodeLCTProcessor|SetupError")
             << "+++ Number of wire groups, " << numWireGroups << " found in " << theCSCName_ << " (sector " << theSector
             << " subsector " << theSubsector << " trig id. " << theTrigChamber << ")"
             << " exceeds max expected, " << CSCConstants::MAX_NUM_WIREGROUPS << " +++\n"
             << "+++ CSC geometry looks garbled; no emulation possible +++\n";
         numWireGroups = -1;
       }
     } else {
       edm::LogError("CSCAnodeLCTProcessor|SetupError")
           << "+++ " << theCSCName_ << " (sector " << theSector << " subsector " << theSubsector << " trig id. "
           << theTrigChamber << ")"
           << " is not defined in current geometry! +++\n"
           << "+++ CSC geometry looks garbled; no emulation possible +++\n";
       numWireGroups = -1;
     }
   }
 
   if (numWireGroups <= 0 or (unsigned) numWireGroups > qualityControl_->get_csc_max_wiregroup(theStation, theRing)) {
     edm::LogError("CSCAnodeLCTProcessor|SetupError")
         << "+++ " << theCSCName_ << " (sector " << theSector << " subsector " << theSubsector << " trig id. "
         << theTrigChamber << "):"
         << " numWireGroups = " << numWireGroups << "; ALCT emulation skipped! +++";
     std::vector<CSCALCTDigi> emptyV;
     return emptyV;
   }
 
   // Get wire digis in this chamber from wire digi collection.
   bool hasDigis = getDigis(wiredc);
 
   if (hasDigis) {
     // First get wiregroup times from the wire digis.
     std::vector<int> wireGroupTimes[CSCConstants::NUM_LAYERS][CSCConstants::MAX_NUM_WIREGROUPS];
     readWireDigis(wireGroupTimes);
 
     // Pass an array of wire times on to another run() doing the LCT search.
     // If the number of layers containing digis is smaller than that
     // required to trigger, quit right away.
     const unsigned int min_layers =
         (nplanes_hit_accel_pattern == 0)
             ? nplanes_hit_pattern
             : ((nplanes_hit_pattern <= nplanes_hit_accel_pattern) ? nplanes_hit_pattern : nplanes_hit_accel_pattern);
 
     unsigned int layersHit = 0;
     for (int i_layer = 0; i_layer < CSCConstants::NUM_LAYERS; i_layer++) {
       for (int i_wire = 0; i_wire < numWireGroups; i_wire++) {
         if (!wireGroupTimes[i_layer][i_wire].empty()) {
           layersHit++;
           break;
         }
       }
     }
     if (layersHit >= min_layers)
       run(wireGroupTimes);
     // Get the high multiplicity bits in this chamber
     encodeHighMultiplicityBits();
   }
 
   // Return vector of all found ALCTs.
   return getALCTs();
 }

◆ run() [2/2]

void CSCAnodeLCTProcessor::run ( const std::vector< int > wire[CSCConstants::NUM_LAYERS][CSCConstants::MAX_NUM_WIREGROUPS] )

Definition at line 275 of file CSCAnodeLCTProcessor.cc.

References CSCConstants::ALCT_COLLISIONA_PATTERN, CSCConstants::ALCT_COLLISIONB_PATTERN, nano_mu_digi_cff::bx, drift_delay, fifo_tbins, first_bx, first_bx_corrected, ghostCancellationLogicOneWire(), CSCBaseboard::infoV, PulseArray::initialize(), lct_list, lctSearch(), LogTrace, CSCConstants::MAX_ALCT_TBINS, numWireGroups, patternDetection(), pretrig_extra_deadtime, preTrigger(), pulse_, pulseExtension(), quality, qualityControl_, setWireContainer(), showPatterns(), CSCBaseboard::theRing, CSCBaseboard::theStation, use_corrected_bx, validateGeometry_cfg::valid, and nano_mu_digi_cff::wire.

                                                                                                                 {
   bool trigger = false;
 
   // initialize the pulse array.
   pulse_.initialize(numWireGroups);
 
   // Check if there are any in-time hits and do the pulse extension.
   bool chamber_empty = pulseExtension(wire);
 
   // define a new pattern map
   // for each key wiregroup, and for each pattern, store the 2D collection of fired wiregroup digis
   std::map<int, std::map<int, CSCALCTDigi::WireContainer>> hits_in_patterns;
   hits_in_patterns.clear();
 
   // Only do the rest of the processing if chamber is not empty.
   // Stop drift_delay bx's short of fifo_tbins since at later bx's we will
   // not have a full set of hits to start pattern search anyway.
   unsigned int stop_bx = fifo_tbins - drift_delay;
   if (!chamber_empty) {
     for (int i_wire = 0; i_wire < numWireGroups; i_wire++) {
       // extra check to make sure only valid wires are processed
       const unsigned max_wire = qualityControl_->get_csc_max_wiregroup(theStation, theRing);
       if (unsigned(i_wire) >= max_wire)
         continue;
 
       unsigned int start_bx = 0;
       // Allow for more than one pass over the hits in the time window.
       while (start_bx < stop_bx) {
         if (preTrigger(i_wire, start_bx)) {
           if (infoV > 2)
             showPatterns(i_wire);
           if (patternDetection(i_wire, hits_in_patterns)) {
             trigger = true;
             int ghost_cleared[2] = {0, 0};
             /*
               In older versions of the ALCT emulation, the ghost cancellation was performed after
               the ALCTs were found. In December 2018, it became clear that during the study of data
               and emulation comparison on 2018 data, a small disagreement between data and emulation
               was found. The changes we implemented then allow re-triggering on one wiregroup after
               some dead time once an earlier ALCT was constructed built on this wiregroup. Before this
               commit the ALCT processor would prohibit the wiregroup from triggering in one event after
               an ALCT was found on that wiregroup. In the firwmare, the wiregroup with ALCT is only dead
               for a few BX before it can be triggered by next muon. The implementation of ghost cancellation
               logic was changed to accommodate the re-triggering change while the idea of ghost cancellation
               logic is kept the same.
             */
             ghostCancellationLogicOneWire(i_wire, ghost_cleared);
 
             int bx = (use_corrected_bx) ? first_bx_corrected[i_wire] : first_bx[i_wire];
             if (bx >= CSCConstants::MAX_ALCT_TBINS)
               edm::LogError("CSCAnodeLCTProcessor")
                   << " bx of valid trigger : " << bx << " > max allowed value " << CSCConstants::MAX_ALCT_TBINS;
 
             //acceleration mode
             if (quality[i_wire][0] > 0 and bx < CSCConstants::MAX_ALCT_TBINS) {
               int valid = (ghost_cleared[0] == 0) ? 1 : 0;  //cancelled, valid=0, otherwise it is 1
               CSCALCTDigi newALCT(valid, quality[i_wire][0], 1, 0, i_wire, bx);
 
               // set the wire digis for this pattern
               setWireContainer(newALCT, hits_in_patterns[i_wire][0]);
 
               lct_list.emplace_back(newALCT);
               if (infoV > 1)
                 LogTrace("CSCAnodeLCTProcessor") << "Add one ALCT to list " << lct_list.back();
             }
 
             //collision mode
             if (quality[i_wire][CSCConstants::ALCT_COLLISIONA_PATTERN] > 0 and bx < CSCConstants::MAX_ALCT_TBINS) {
               int valid = (ghost_cleared[CSCConstants::ALCT_COLLISIONA_PATTERN] == 0)
                               ? 1
                               : 0;  //cancelled, valid=0, otherwise it is 1
 
               CSCALCTDigi newALCT(valid,
                                   quality[i_wire][CSCConstants::ALCT_COLLISIONA_PATTERN],
                                   0,
                                   quality[i_wire][CSCConstants::ALCT_COLLISIONB_PATTERN],
                                   i_wire,
                                   bx);
 
               // set the wire digis for this pattern
               setWireContainer(newALCT, hits_in_patterns[i_wire][CSCConstants::ALCT_COLLISIONA_PATTERN]);
 
               lct_list.emplace_back(newALCT);
               if (infoV > 1)
                 LogTrace("CSCAnodeLCTProcessor") << "Add one ALCT to list " << lct_list.back();
             }
 
             //break;
             // Assume that the earliest time when another pre-trigger can
             // occur in case pattern detection failed is bx_pretrigger+4:
             // this seems to match the data.
             start_bx = first_bx[i_wire] + drift_delay + pretrig_extra_deadtime;
           } else {
             //only pretrigger, no trigger ==> no dead time, continue to find next pretrigger
             start_bx = first_bx[i_wire] + 1;
           }
         } else {  //no pretrigger, skip this wiregroup
           break;
         }
       }  // end of while
     }
   }
 
   // Do the rest only if there is at least one trigger candidate.
   if (trigger) {
     /* In Run-1 and Run-2, the ghost cancellation was done after the trigger.
        In the firmware however, the ghost cancellation is done during the trigger
        on each wiregroup in parallel. For Run-3 and beyond, the ghost cancellation is
        implemented per wiregroup earlier in the code. See function
        "ghostCancellationLogicOneWire". There used to be a function ghostCancellationLogic
        call here.
     */
     lctSearch();
   }
 }

◆ setConfigParameters()

void CSCAnodeLCTProcessor::setConfigParameters ( const CSCDBL1TPParameters * conf )

Sets configuration parameters obtained via EventSetup mechanism.

Definition at line 120 of file CSCAnodeLCTProcessor.cc.

                                                                               {
   static std::atomic<bool> config_dumped{false};
 
   fifo_tbins = conf->alctFifoTbins();
   fifo_pretrig = conf->alctFifoPretrig();
   drift_delay = conf->alctDriftDelay();
   nplanes_hit_pretrig = conf->alctNplanesHitPretrig();
   nplanes_hit_pattern = conf->alctNplanesHitPattern();
   nplanes_hit_accel_pretrig = conf->alctNplanesHitAccelPretrig();
   nplanes_hit_accel_pattern = conf->alctNplanesHitAccelPattern();
   trig_mode = conf->alctTrigMode();
   accel_mode = conf->alctAccelMode();
   l1a_window_width = conf->alctL1aWindowWidth();
 
   // Check and print configuration parameters.
   checkConfigParameters();
   if (!config_dumped) {
     dumpConfigParams();
     config_dumped = true;
   }
   minbx_readout_ = CSCConstants::LCT_CENTRAL_BX - l1a_window_width / 2;
   maxbx_readout_ = CSCConstants::LCT_CENTRAL_BX + l1a_window_width / 2;
 }

◆ setDefaultConfigParameters()

void CSCAnodeLCTProcessor::setDefaultConfigParameters ( )

protected

Set default values for configuration parameters.

Definition at line 103 of file CSCAnodeLCTProcessor.cc.

References accel_mode, def_accel_mode, def_drift_delay, def_fifo_pretrig, def_fifo_tbins, def_l1a_window_width, def_nplanes_hit_accel_pattern, def_nplanes_hit_accel_pretrig, def_nplanes_hit_pattern, def_nplanes_hit_pretrig, def_trig_mode, drift_delay, fifo_pretrig, fifo_tbins, l1a_window_width, CSCConstants::LCT_CENTRAL_BX, maxbx_readout_, minbx_readout_, nplanes_hit_accel_pattern, nplanes_hit_accel_pretrig, nplanes_hit_pattern, nplanes_hit_pretrig, and trig_mode.

                                                       {
   // Set default values for configuration parameters.
   fifo_tbins = def_fifo_tbins;
   fifo_pretrig = def_fifo_pretrig;
   drift_delay = def_drift_delay;
   nplanes_hit_pretrig = def_nplanes_hit_pretrig;
   nplanes_hit_pattern = def_nplanes_hit_pattern;
   nplanes_hit_accel_pretrig = def_nplanes_hit_accel_pretrig;
   nplanes_hit_accel_pattern = def_nplanes_hit_accel_pattern;
   trig_mode = def_trig_mode;
   accel_mode = def_accel_mode;
   l1a_window_width = def_l1a_window_width;
   minbx_readout_ = CSCConstants::LCT_CENTRAL_BX - l1a_window_width / 2;
   maxbx_readout_ = CSCConstants::LCT_CENTRAL_BX + l1a_window_width / 2;
 }

◆ setWireContainer()

void CSCAnodeLCTProcessor::setWireContainer	(	CSCALCTDigi &	alct,
		CSCALCTDigi::WireContainer &	wireHits
	)		const

protected

Definition at line 1368 of file CSCAnodeLCTProcessor.cc.

References cleanWireContainer(), and CSCALCTDigi::setHits().

Referenced by run().

                                                                                                        {
   // clean the wire digi container
   cleanWireContainer(wireHits);
 
   // set the hit container
   alct.setHits(wireHits);
 }

◆ showPatterns()

void CSCAnodeLCTProcessor::showPatterns ( const int key_wire )

protected

Definition at line 1322 of file CSCAnodeLCTProcessor.cc.

References CSCPatternBank::alct_keywire_offset_, alct_pattern_, CSCConstants::ALCT_PATTERN_WIDTH, mps_fire::i, LogTrace, MESelection, CSCConstants::NUM_ALCT_PATTERNS, CSCConstants::NUM_LAYERS, numWireGroups, PulseArray::oneShotAtBX(), and pulse_.

Referenced by run().

                                                           {
   /* Method to test the pretrigger */
   for (int i_pattern = 0; i_pattern < CSCConstants::NUM_ALCT_PATTERNS; i_pattern++) {
     std::ostringstream strstrm_header;
     LogTrace("CSCAnodeLCTProcessor") << "\n"
                                      << "Pattern: " << i_pattern << " Key wire: " << key_wire;
     for (int i = 1; i <= 32; i++) {
       strstrm_header << ((32 - i) % 10);
     }
     LogTrace("CSCAnodeLCTProcessor") << strstrm_header.str();
     for (int i_layer = 0; i_layer < CSCConstants::NUM_LAYERS; i_layer++) {
       for (int i_wire = 0; i_wire < CSCConstants::ALCT_PATTERN_WIDTH; i_wire++) {
         // check if the hit is valid
         if (alct_pattern_[i_pattern][i_layer][i_wire]) {
           std::ostringstream strstrm_pulse;
           int this_wire = CSCPatternBank::alct_keywire_offset_[MESelection][i_wire] + key_wire;
           if (this_wire >= 0 && this_wire < numWireGroups) {
             for (int i = 1; i <= 32; i++) {
               strstrm_pulse << pulse_.oneShotAtBX(i_layer, this_wire, 32 - i);
             }
             LogTrace("CSCAnodeLCTProcessor") << strstrm_pulse.str() << " on layer " << i_layer << " wire " << this_wire;
           }
         }
       }
     }
     LogTrace("CSCAnodeLCTProcessor") << "-------------------------------------------";
   }
 }

◆ trigMode()

void CSCAnodeLCTProcessor::trigMode ( const int key_wire )

protected

Definition at line 1056 of file CSCAnodeLCTProcessor.cc.

References CSCConstants::ALCT_ACCELERATOR_PATTERN, CSCConstants::ALCT_COLLISIONA_PATTERN, CSCBaseboard::infoV, LogTrace, quality, and trig_mode.

Referenced by patternDetection().

                                                       {
   switch (trig_mode) {
     default:
     case 0:
       // Enables both collision and accelerator tracks
       break;
     case 1:
       // Disables collision tracks
       if (quality[key_wire][CSCConstants::ALCT_COLLISIONA_PATTERN] > 0) {
         quality[key_wire][CSCConstants::ALCT_COLLISIONA_PATTERN] = 0;
         if (infoV > 1)
           LogTrace("CSCAnodeLCTProcessor") << "trigMode(): collision track " << key_wire << " disabled"
                                            << "\n";
       }
       break;
     case 2:
       // Disables accelerator tracks
       if (quality[key_wire][CSCConstants::ALCT_ACCELERATOR_PATTERN] > 0) {
         quality[key_wire][CSCConstants::ALCT_ACCELERATOR_PATTERN] = 0;
         if (infoV > 1)
           LogTrace("CSCAnodeLCTProcessor") << "trigMode(): accelerator track " << key_wire << " disabled"
                                            << "\n";
       }
       break;
     case 3:
       // Disables collision track if there is an accelerator track found
       // in the same wire group at the same time
       if (quality[key_wire][0] > 0 && quality[key_wire][CSCConstants::ALCT_COLLISIONA_PATTERN] > 0) {
         quality[key_wire][CSCConstants::ALCT_COLLISIONA_PATTERN] = 0;
         if (infoV > 1)
           LogTrace("CSCAnodeLCTProcessor") << "trigMode(): collision track " << key_wire << " disabled"
                                            << "\n";
       }
       break;
   }
 }

Member Data Documentation

◆ accel_mode

unsigned int CSCAnodeLCTProcessor::accel_mode

protected

Definition at line 140 of file CSCAnodeLCTProcessor.h.

Referenced by accelMode(), checkConfigParameters(), CSCAnodeLCTProcessor(), dumpConfigParams(), isBetterALCT(), setConfigParameters(), and setDefaultConfigParameters().

◆ alct_pattern_

CSCPatternBank::LCTPatterns CSCAnodeLCTProcessor::alct_pattern_ = {}

protected

Chosen pattern mask.

Definition at line 177 of file CSCAnodeLCTProcessor.h.

Referenced by loadPatternMask(), patternDetection(), preTrigger(), and showPatterns().

◆ anode_showers_

CSCShowerDigi CSCAnodeLCTProcessor::anode_showers_[CSCConstants::MAX_ALCT_TBINS]

protected

Definition at line 109 of file CSCAnodeLCTProcessor.h.

Referenced by clear(), encodeHighMultiplicityBits(), getAllShower(), and readoutShower().

◆ bestALCT

CSCALCTDigi CSCAnodeLCTProcessor::bestALCT[CSCConstants::MAX_ALCT_TBINS]

protected

Best LCTs in this chamber, as found by the processor. In old ALCT algorithms, up to two best ALCT per Level-1 accept window had been reported. In the ALCT-2006 algorithms, up to two best ALCTs PER EVERY TIME BIN in Level-1 accept window are reported.

Definition at line 102 of file CSCAnodeLCTProcessor.h.

Referenced by clear(), getALCTs(), getBestALCT(), and lctSearch().

◆ def_accel_mode

const unsigned int CSCAnodeLCTProcessor::def_accel_mode = 0

staticprotected

Definition at line 170 of file CSCAnodeLCTProcessor.h.

Referenced by checkConfigParameters(), and setDefaultConfigParameters().

◆ def_drift_delay

const unsigned int CSCAnodeLCTProcessor::def_drift_delay = 2

staticprotected

Definition at line 166 of file CSCAnodeLCTProcessor.h.

Referenced by checkConfigParameters(), and setDefaultConfigParameters().

◆ def_fifo_pretrig

const unsigned int CSCAnodeLCTProcessor::def_fifo_pretrig = 10

staticprotected

Definition at line 165 of file CSCAnodeLCTProcessor.h.

Referenced by checkConfigParameters(), and setDefaultConfigParameters().

◆ def_fifo_tbins

const unsigned int CSCAnodeLCTProcessor::def_fifo_tbins = 16

staticprotected

Default values of configuration parameters.

Definition at line 165 of file CSCAnodeLCTProcessor.h.

Referenced by checkConfigParameters(), and setDefaultConfigParameters().

◆ def_l1a_window_width

const unsigned int CSCAnodeLCTProcessor::def_l1a_window_width = 7

staticprotected

Definition at line 171 of file CSCAnodeLCTProcessor.h.

Referenced by checkConfigParameters(), and setDefaultConfigParameters().

◆ def_nplanes_hit_accel_pattern

const unsigned int CSCAnodeLCTProcessor::def_nplanes_hit_accel_pattern = 4

staticprotected

Definition at line 169 of file CSCAnodeLCTProcessor.h.

Referenced by checkConfigParameters(), and setDefaultConfigParameters().

◆ def_nplanes_hit_accel_pretrig

const unsigned int CSCAnodeLCTProcessor::def_nplanes_hit_accel_pretrig = 2

staticprotected

Definition at line 168 of file CSCAnodeLCTProcessor.h.

Referenced by checkConfigParameters(), and setDefaultConfigParameters().

◆ def_nplanes_hit_pattern

const unsigned int CSCAnodeLCTProcessor::def_nplanes_hit_pattern = 4

staticprotected

Definition at line 167 of file CSCAnodeLCTProcessor.h.

Referenced by checkConfigParameters(), and setDefaultConfigParameters().

◆ def_nplanes_hit_pretrig

const unsigned int CSCAnodeLCTProcessor::def_nplanes_hit_pretrig = 2

staticprotected

Definition at line 167 of file CSCAnodeLCTProcessor.h.

Referenced by checkConfigParameters(), and setDefaultConfigParameters().

◆ def_trig_mode

const unsigned int CSCAnodeLCTProcessor::def_trig_mode = 2

staticprotected

Definition at line 170 of file CSCAnodeLCTProcessor.h.

Referenced by checkConfigParameters(), and setDefaultConfigParameters().

◆ digiV

std::vector<CSCWireDigi> CSCAnodeLCTProcessor::digiV[CSCConstants::NUM_LAYERS]

protected

Definition at line 122 of file CSCAnodeLCTProcessor.h.

Referenced by encodeHighMultiplicityBits(), getDigis(), and readWireDigis().

◆ drift_delay

unsigned int CSCAnodeLCTProcessor::drift_delay

protected

Definition at line 137 of file CSCAnodeLCTProcessor.h.

Referenced by checkConfigParameters(), CSCAnodeLCTProcessor(), dumpConfigParams(), patternDetection(), preTrigger(), run(), setConfigParameters(), and setDefaultConfigParameters().

◆ early_tbins

int CSCAnodeLCTProcessor::early_tbins

protected

Phase2: separate handle for early time bins

Definition at line 146 of file CSCAnodeLCTProcessor.h.

Referenced by CSCAnodeLCTProcessor(), and readoutALCTs().

◆ fifo_pretrig

unsigned int CSCAnodeLCTProcessor::fifo_pretrig

protected

Definition at line 137 of file CSCAnodeLCTProcessor.h.

Referenced by checkConfigParameters(), CSCAnodeLCTProcessor(), dumpConfigParams(), readoutALCTs(), setConfigParameters(), and setDefaultConfigParameters().

◆ fifo_tbins

unsigned int CSCAnodeLCTProcessor::fifo_tbins

protected

Configuration parameters.

Definition at line 137 of file CSCAnodeLCTProcessor.h.

Referenced by checkConfigParameters(), CSCAnodeLCTProcessor(), dumpConfigParams(), preTrigger(), readWireDigis(), run(), setConfigParameters(), and setDefaultConfigParameters().

◆ first_bx

int CSCAnodeLCTProcessor::first_bx[CSCConstants::MAX_NUM_WIREGROUPS]

protected

Definition at line 118 of file CSCAnodeLCTProcessor.h.

Referenced by CSCUpgradeAnodeLCTProcessor::ghostCancellationLogicOneWire(), ghostCancellationLogicOneWire(), patternDetection(), preTrigger(), pulseExtension(), and run().

◆ first_bx_corrected

int CSCAnodeLCTProcessor::first_bx_corrected[CSCConstants::MAX_NUM_WIREGROUPS]

protected

Definition at line 119 of file CSCAnodeLCTProcessor.h.

Referenced by CSCUpgradeAnodeLCTProcessor::ghostCancellationLogicOneWire(), patternDetection(), pulseExtension(), and run().

◆ ghost_cancellation_bx_depth

int CSCAnodeLCTProcessor::ghost_cancellation_bx_depth

protected

Phase2: delta BX time depth for ghostCancellationLogic

Definition at line 149 of file CSCAnodeLCTProcessor.h.

Referenced by CSCAnodeLCTProcessor(), CSCUpgradeAnodeLCTProcessor::ghostCancellationLogicOneWire(), and ghostCancellationLogicOneWire().

◆ ghost_cancellation_side_quality

bool CSCAnodeLCTProcessor::ghost_cancellation_side_quality

protected

Phase2: whether to consider ALCT candidates' qualities while doing ghostCancellationLogic on +-1 wire groups

Definition at line 153 of file CSCAnodeLCTProcessor.h.

Referenced by CSCAnodeLCTProcessor(), CSCUpgradeAnodeLCTProcessor::ghostCancellationLogicOneWire(), and ghostCancellationLogicOneWire().

◆ hit_persist

unsigned int CSCAnodeLCTProcessor::hit_persist

protected

Phase2: hit persistency length

Definition at line 143 of file CSCAnodeLCTProcessor.h.

Referenced by CSCAnodeLCTProcessor(), patternDetection(), and pulseExtension().

◆ l1a_window_width

unsigned int CSCAnodeLCTProcessor::l1a_window_width

protected

Definition at line 140 of file CSCAnodeLCTProcessor.h.

Referenced by checkConfigParameters(), CSCAnodeLCTProcessor(), dumpConfigParams(), readoutALCTs(), readoutShower(), setConfigParameters(), and setDefaultConfigParameters().

◆ lct_list

std::vector<CSCALCTDigi> CSCAnodeLCTProcessor::lct_list

protected

Definition at line 124 of file CSCAnodeLCTProcessor.h.

Referenced by clear(), CSCUpgradeAnodeLCTProcessor::ghostCancellationLogicOneWire(), ghostCancellationLogicOneWire(), lctSearch(), and run().

◆ maxbx_readout_

unsigned CSCAnodeLCTProcessor::maxbx_readout_

protected

Definition at line 134 of file CSCAnodeLCTProcessor.h.

Referenced by CSCAnodeLCTProcessor(), readoutShower(), setConfigParameters(), and setDefaultConfigParameters().

◆ MESelection

int CSCAnodeLCTProcessor::MESelection

protected

Definition at line 116 of file CSCAnodeLCTProcessor.h.

Referenced by CSCAnodeLCTProcessor(), patternDetection(), preTrigger(), and showPatterns().

◆ minbx_readout_

unsigned CSCAnodeLCTProcessor::minbx_readout_

protected

Definition at line 133 of file CSCAnodeLCTProcessor.h.

Referenced by CSCAnodeLCTProcessor(), readoutShower(), setConfigParameters(), and setDefaultConfigParameters().

◆ minLayersCentralTBin_

unsigned CSCAnodeLCTProcessor::minLayersCentralTBin_

protected

Definition at line 132 of file CSCAnodeLCTProcessor.h.

Referenced by CSCAnodeLCTProcessor(), and encodeHighMultiplicityBits().

◆ narrow_mask_r1

bool CSCAnodeLCTProcessor::narrow_mask_r1

protected

Phase2: whether to use narrow pattern mask for the rings close to the beam

Definition at line 162 of file CSCAnodeLCTProcessor.h.

Referenced by CSCAnodeLCTProcessor(), and loadPatternMask().

◆ nplanes_hit_accel_pattern

unsigned int CSCAnodeLCTProcessor::nplanes_hit_accel_pattern

protected

Definition at line 139 of file CSCAnodeLCTProcessor.h.

Referenced by checkConfigParameters(), CSCAnodeLCTProcessor(), dumpConfigParams(), patternDetection(), run(), setConfigParameters(), and setDefaultConfigParameters().

◆ nplanes_hit_accel_pretrig

unsigned int CSCAnodeLCTProcessor::nplanes_hit_accel_pretrig

protected

Definition at line 138 of file CSCAnodeLCTProcessor.h.

Referenced by checkConfigParameters(), CSCAnodeLCTProcessor(), dumpConfigParams(), preTrigger(), setConfigParameters(), and setDefaultConfigParameters().

◆ nplanes_hit_pattern

unsigned int CSCAnodeLCTProcessor::nplanes_hit_pattern

protected

Definition at line 139 of file CSCAnodeLCTProcessor.h.

Referenced by checkConfigParameters(), CSCAnodeLCTProcessor(), dumpConfigParams(), patternDetection(), run(), setConfigParameters(), and setDefaultConfigParameters().

◆ nplanes_hit_pretrig

unsigned int CSCAnodeLCTProcessor::nplanes_hit_pretrig

protected

Definition at line 138 of file CSCAnodeLCTProcessor.h.

Referenced by checkConfigParameters(), CSCAnodeLCTProcessor(), dumpConfigParams(), preTrigger(), setConfigParameters(), and setDefaultConfigParameters().

◆ numWireGroups

int CSCAnodeLCTProcessor::numWireGroups

protected

Definition at line 115 of file CSCAnodeLCTProcessor.h.

Referenced by CSCAnodeLCTProcessor(), dumpDigis(), patternDetection(), preTrigger(), pulseExtension(), readWireDigis(), run(), and showPatterns().

◆ pretrig_extra_deadtime

unsigned int CSCAnodeLCTProcessor::pretrig_extra_deadtime

protected

Phase2: deadtime clocks after pretrigger (extra in addition to drift_delay)

Definition at line 156 of file CSCAnodeLCTProcessor.h.

Referenced by CSCAnodeLCTProcessor(), and run().

◆ pulse_

PulseArray CSCAnodeLCTProcessor::pulse_

protected

Definition at line 107 of file CSCAnodeLCTProcessor.h.

Referenced by patternDetection(), preTrigger(), pulseExtension(), run(), and showPatterns().

◆ quality

int CSCAnodeLCTProcessor::quality[CSCConstants::MAX_NUM_WIREGROUPS][CSCConstants::NUM_ALCT_PATTERNS]

protected

Definition at line 121 of file CSCAnodeLCTProcessor.h.

Referenced by accelMode(), clear(), CSCUpgradeAnodeLCTProcessor::ghostCancellationLogicOneWire(), ghostCancellationLogicOneWire(), patternDetection(), pulseExtension(), run(), and trigMode().

◆ qualityControl_

std::unique_ptr<LCTQualityControl> CSCAnodeLCTProcessor::qualityControl_

protected

Definition at line 174 of file CSCAnodeLCTProcessor.h.

Referenced by CSCAnodeLCTProcessor(), lctSearch(), readoutALCTs(), and run().

◆ secondALCT

CSCALCTDigi CSCAnodeLCTProcessor::secondALCT[CSCConstants::MAX_ALCT_TBINS]

protected

Second best LCTs in this chamber, as found by the processor.

Definition at line 105 of file CSCAnodeLCTProcessor.h.

Referenced by clear(), getALCTs(), getSecondALCT(), and lctSearch().

◆ showerNumTBins_

unsigned CSCAnodeLCTProcessor::showerNumTBins_

protected

Definition at line 131 of file CSCAnodeLCTProcessor.h.

Referenced by CSCAnodeLCTProcessor(), and encodeHighMultiplicityBits().

◆ thePreTriggerDigis

std::vector<CSCALCTPreTriggerDigi> CSCAnodeLCTProcessor::thePreTriggerDigis

protected

Definition at line 126 of file CSCAnodeLCTProcessor.h.

Referenced by preTrigger(), and preTriggerDigis().

◆ thresholds_

std::vector<unsigned> CSCAnodeLCTProcessor::thresholds_

protected

Definition at line 130 of file CSCAnodeLCTProcessor.h.

Referenced by CSCAnodeLCTProcessor(), and encodeHighMultiplicityBits().

◆ trig_mode

unsigned int CSCAnodeLCTProcessor::trig_mode

protected

Definition at line 140 of file CSCAnodeLCTProcessor.h.

Referenced by checkConfigParameters(), CSCAnodeLCTProcessor(), dumpConfigParams(), setConfigParameters(), setDefaultConfigParameters(), and trigMode().

◆ use_corrected_bx

bool CSCAnodeLCTProcessor::use_corrected_bx

protected

Phase2: whether to use corrected_bx instead of pretrigger BX

Definition at line 159 of file CSCAnodeLCTProcessor.h.

Referenced by CSCAnodeLCTProcessor(), CSCUpgradeAnodeLCTProcessor::ghostCancellationLogicOneWire(), and run().

Public Member Functions

Protected Member Functions

Protected Attributes

Static Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ CSCAnodeLCTProcessor()

◆ ~CSCAnodeLCTProcessor()

Member Function Documentation

◆ accelMode()

◆ bestTrackSelector()

◆ checkConfigParameters()

◆ cleanWireContainer()

◆ clear() [1/2]

◆ clear() [2/2]

◆ dumpConfigParams()

◆ dumpDigis()

◆ encodeHighMultiplicityBits()

◆ getALCTs()

◆ getAllShower()

◆ getBestALCT()

◆ getDigis() [1/2]

◆ getDigis() [2/2]

◆ getSecondALCT()

◆ getTempALCTQuality()

◆ ghostCancellationLogicOneWire()

◆ isBetterALCT()

◆ lctSearch()

◆ loadPatternMask()

◆ patternDetection()

◆ preTrigger()

◆ preTriggerDigis()

◆ pulseExtension()

◆ readoutALCTs()

◆ readoutShower()

◆ readWireDigis()

◆ run() [1/2]

◆ run() [2/2]

◆ setConfigParameters()

◆ setDefaultConfigParameters()

◆ setWireContainer()

◆ showPatterns()

◆ trigMode()

Member Data Documentation

◆ accel_mode

◆ alct_pattern_

◆ anode_showers_

◆ bestALCT

◆ def_accel_mode

◆ def_drift_delay

◆ def_fifo_pretrig

◆ def_fifo_tbins

◆ def_l1a_window_width

◆ def_nplanes_hit_accel_pattern

◆ def_nplanes_hit_accel_pretrig

◆ def_nplanes_hit_pattern

◆ def_nplanes_hit_pretrig

◆ def_trig_mode

◆ digiV

◆ drift_delay

◆ early_tbins

◆ fifo_pretrig

◆ fifo_tbins

◆ first_bx

◆ first_bx_corrected

◆ ghost_cancellation_bx_depth

◆ ghost_cancellation_side_quality

◆ hit_persist

◆ l1a_window_width

◆ lct_list

◆ maxbx_readout_

◆ MESelection

◆ minbx_readout_

◆ minLayersCentralTBin_

◆ narrow_mask_r1

◆ nplanes_hit_accel_pattern

◆ nplanes_hit_accel_pretrig

◆ nplanes_hit_pattern

◆ nplanes_hit_pretrig

◆ numWireGroups