#include <CSCUpgradeAnodeLCTProcessor.h>

Inheritance diagram for CSCUpgradeAnodeLCTProcessor:

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

	~CSCUpgradeAnodeLCTProcessor () override

Public Member Functions inherited from CSCAnodeLCTProcessor
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

Private Member Functions
int	getTempALCTQuality (int temp_quality) const override

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

Additional Inherited Members
Protected Member Functions inherited from CSCAnodeLCTProcessor
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)

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 inherited from CSCAnodeLCTProcessor
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 inherited from CSCAnodeLCTProcessor
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.

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

Definition at line 16 of file CSCUpgradeAnodeLCTProcessor.h.

Constructor & Destructor Documentation

◆ CSCUpgradeAnodeLCTProcessor()

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

Normal constructor.

Definition at line 3 of file CSCUpgradeAnodeLCTProcessor.cc.

References CSCBaseboard::enableAlctPhase2_, and CSCBaseboard::runPhase2_.

     : CSCAnodeLCTProcessor(endcap, station, sector, subsector, chamber, conf) {
   if (!runPhase2_)
     edm::LogError("CSCUpgradeAnodeLCTProcessor|ConfigError")
         << "+++ Upgrade CSCUpgradeAnodeLCTProcessor constructed while runPhase2_ is not set! +++\n";
 
   if (!enableAlctPhase2_)
     edm::LogError("CSCUpgradeAnodeLCTProcessor|ConfigError")
         << "+++ Upgrade CSCUpgradeAnodeLCTProcessor constructed while enableAlctPhase2_ is not set! +++\n";
 }

◆ ~CSCUpgradeAnodeLCTProcessor()

CSCUpgradeAnodeLCTProcessor::~CSCUpgradeAnodeLCTProcessor ( )

inlineoverride

Default destructor.

Definition at line 27 of file CSCUpgradeAnodeLCTProcessor.h.

27 {};

Member Function Documentation

◆ getTempALCTQuality()

int CSCUpgradeAnodeLCTProcessor::getTempALCTQuality ( int temp_quality ) const

overrideprivatevirtual

Reimplemented from CSCAnodeLCTProcessor.

Definition at line 91 of file CSCUpgradeAnodeLCTProcessor.cc.

References CSCBaseboard::isME21_, CSCBaseboard::runME21ILT_, and CSCBaseboard::runPhase2_.

                                                                           {
   // Quality definition changed on 22 June 2007: it no longer depends
   // on pattern_thresh.
   int Q;
   // hack to run the Phase-II GE2/1-ME2/1 with 3-layer ALCTs
   if (temp_quality == 3 and runPhase2_ and runME21ILT_ and isME21_)
     Q = 1;
   else if (temp_quality > 3)
     Q = temp_quality - 3;
   else
     Q = 0;  // quality code 0 is valid!
 
   return Q;
 }

◆ ghostCancellationLogicOneWire()

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

overrideprivatevirtual

Reimplemented from CSCAnodeLCTProcessor.

Definition at line 19 of file CSCUpgradeAnodeLCTProcessor.cc.

References dt, CSCAnodeLCTProcessor::first_bx, CSCAnodeLCTProcessor::first_bx_corrected, CSCAnodeLCTProcessor::ghost_cancellation_bx_depth, CSCAnodeLCTProcessor::ghost_cancellation_side_quality, CSCBaseboard::infoV, CSCBaseboard::isME21_, CSCAnodeLCTProcessor::lct_list, LogTrace, AlCaHLTBitMon_ParallelJobs::p, CSCAnodeLCTProcessor::quality, CSCBaseboard::runME21ILT_, CSCBaseboard::runPhase2_, and CSCAnodeLCTProcessor::use_corrected_bx.

                                                                                                       {
   for (int i_pattern = 0; i_pattern < 2; i_pattern++) {
     ghost_cleared[i_pattern] = 0;
     if (key_wire == 0)
       continue;
 
     // Non-empty wire group.
     int qual_this = quality[key_wire][i_pattern];
     if (qual_this > 0) {
       if (runPhase2_ and runME21ILT_ and isME21_)
         qual_this = (qual_this & 0x03);
       // Previous wire.
       int dt = -1;
       for (auto& p : lct_list) {
         if (not(p.isValid() and 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 == 0) ? "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];
         if (use_corrected_bx)
           dt = first_bx_corrected[key_wire] - first_bx_prev;
         else
           dt = first_bx[key_wire] - first_bx_prev;
         // hack to run the Phase-II ME2/1, ME3/1 and ME4/1 ILT
         if (runPhase2_ and runME21ILT_ and isME21_)
           qual_prev = (qual_prev & 0x03);
 
         // 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 (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("CSCUpgradeAnodeLCTProcessor")
                 << ((i_pattern == 0) ? "Accelerator" : "Collision") << " pattern ghost cancelled on key_wire "
                 << key_wire << " q=" << qual_this << "  by wire " << key_wire - 1 << " q=" << qual_prev
                 << "  dt=" << dt;
           //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 == 0) ? "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
         }
       }
     }
   }
 }

Public Member Functions

Private Member Functions