#include <CSCUpgradeAnodeLCTProcessor.h>

Inheritance diagram for CSCUpgradeAnodeLCTProcessor:

Public Member Functions
	CSCUpgradeAnodeLCTProcessor ()

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

Public Member Functions inherited from CSCAnodeLCTProcessor
void	clear ()

	CSCAnodeLCTProcessor ()

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

std::vector< CSCALCTDigi >	getALCTs (unsigned nMaxALCTs=CSCConstants::MAX_ALCTS_READOUT) const

CSCALCTDigi	getBestALCT (int bx) const

unsigned	getHighMultiplictyBits () const

CSCALCTDigi	getSecondALCT (int bx) const

std::vector< CSCALCTPreTriggerDigi >	preTriggerDigis () const

std::vector< CSCALCTDigi >	readoutALCTs (int nMaxALCTs=CSCConstants::MAX_ALCTS_READOUT) const

std::vector< CSCALCTDigi >	run (const CSCWireDigiCollection *wiredc)

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

void	setConfigParameters (const CSCDBL1TPParameters *conf)

	~CSCAnodeLCTProcessor () override=default

Public Member Functions inherited from CSCBaseboard
	CSCBaseboard ()

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

std::string	getCSCName () const

void	setCSCGeometry (const CSCGeometry *g)

virtual	~CSCBaseboard ()=default

Private Member Functions
int	getTempALCTQuality (int temp_quality) const override

void	ghostCancellationLogic () override

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

Additional Inherited Members
Protected Types inherited from CSCAnodeLCTProcessor
enum	ALCT_WireInfo { INVALID_WIRE = 65535 }

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_WIRES]) 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_WIRES])

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

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)

Protected Attributes inherited from CSCAnodeLCTProcessor
unsigned int	accel_mode

CSCPatternBank::LCTPatterns	alct_pattern_ = {}

std::vector< std::vector< CSCALCTDigi > >	ALCTContainer_

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_WIRES]

int	first_bx_corrected [CSCConstants::MAX_NUM_WIRES]

int	ghost_cancellation_bx_depth

bool	ghost_cancellation_side_quality

unsigned int	highMultiplicityBits_

unsigned int	hit_persist

unsigned int	l1a_window_width

std::vector< CSCALCTDigi >	lct_list

int	MESelection

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

unsigned int	pulse [CSCConstants::NUM_LAYERS][CSCConstants::MAX_NUM_WIRES]

int	quality [CSCConstants::MAX_NUM_WIRES][3]

std::unique_ptr< LCTQualityControl >	qualityControl_

CSCALCTDigi	secondALCT [CSCConstants::MAX_ALCT_TBINS]

std::vector< CSCALCTPreTriggerDigi >	thePreTriggerDigis

unsigned int	trig_mode

bool	use_corrected_bx

Protected Attributes inherited from CSCBaseboard
edm::ParameterSet	alctParams_

edm::ParameterSet	clctParams_

edm::ParameterSet	commonParams_

const CSCChamber *	cscChamber_

const CSCGeometry *	cscGeometry_

CSCDetId	cscId_

bool	disableME1a_

bool	enableAlctPhase2_

bool	gangedME1a_

int	infoV

bool	isME11_

bool	isME21_

bool	isME31_

bool	isME41_

bool	runCCLUT_

bool	runME11ILT_

bool	runME11Up_

bool	runME21ILT_

bool	runME21Up_

bool	runME31Up_

bool	runME41Up_

bool	runPhase2_

unsigned	theChamber

std::string	theCSCName_

const unsigned	theEndcap

unsigned	theRegion

unsigned	theRing

const unsigned	theSector

const unsigned	theStation

const unsigned	theSubsector

const unsigned	theTrigChamber

edm::ParameterSet	tmbParams_

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() [1/2]

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

Normal constructor.

Definition at line 3 of file CSCUpgradeAnodeLCTProcessor.cc.

     : 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";
 }

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

◆ CSCUpgradeAnodeLCTProcessor() [2/2]

CSCUpgradeAnodeLCTProcessor::CSCUpgradeAnodeLCTProcessor ( )

Default constructor. Used for testing.

Definition at line 19 of file CSCUpgradeAnodeLCTProcessor.cc.

                                                          : CSCAnodeLCTProcessor() {
   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";
 }

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

Member Function Documentation

◆ getTempALCTQuality()

int CSCUpgradeAnodeLCTProcessor::getTempALCTQuality ( int temp_quality ) const

overrideprivatevirtual

Reimplemented from CSCAnodeLCTProcessor.

Definition at line 193 of file CSCUpgradeAnodeLCTProcessor.cc.

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

References CSCBaseboard::isME21_, class-composition::Q, CSCBaseboard::runME21ILT_, and CSCBaseboard::runPhase2_.

◆ ghostCancellationLogic()

void CSCUpgradeAnodeLCTProcessor::ghostCancellationLogic ( )

overrideprivatevirtual

Reimplemented from CSCAnodeLCTProcessor.

Definition at line 29 of file CSCUpgradeAnodeLCTProcessor.cc.

                                                          {
   int ghost_cleared[CSCConstants::MAX_NUM_WIRES][2];
  
   for (int key_wire = 0; key_wire < numWireGroups; key_wire++) {
     for (int i_pattern = 0; i_pattern < 2; i_pattern++) {
       ghost_cleared[key_wire][i_pattern] = 0;
  
       // 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;
         int qual_prev = (key_wire > 0) ? quality[key_wire - 1][i_pattern] : 0;
         if (qual_prev > 0) {
           if (use_corrected_bx)
             dt = first_bx_corrected[key_wire] - first_bx_corrected[key_wire - 1];
           else
             dt = first_bx[key_wire] - first_bx[key_wire - 1];
           // 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[key_wire][i_pattern] = 1;
           } else if (dt > 0 && dt <= ghost_cancellation_bx_depth) {
             if ((!ghost_cancellation_side_quality) || (qual_prev > qual_this))
               ghost_cleared[key_wire][i_pattern] = 1;
           }
         }
  
         // Next wire.
         // Skip this step if this wire is already declared "ghost".
         if (ghost_cleared[key_wire][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;
           continue;
         }
  
         dt = -1;
         int qual_next = (key_wire < numWireGroups - 1) ? quality[key_wire + 1][i_pattern] : 0;
         if (qual_next > 0) {
           if (use_corrected_bx)
             dt = first_bx_corrected[key_wire] - first_bx_corrected[key_wire + 1];
           else
             dt = first_bx[key_wire] - first_bx[key_wire + 1];
           // hack to run the Phase-II ME2/1, ME3/1 and ME4/1 ILT
           if (runPhase2_ and runME21ILT_ and isME21_)
             qual_next = (qual_next & 0x03);
           // Same cancellation logic as for the previous wire.
           if (dt == 0) {
             if (qual_next >= qual_this)
               ghost_cleared[key_wire][i_pattern] = 1;
           } else if (dt > 0 && dt <= ghost_cancellation_bx_depth) {
             if ((!ghost_cancellation_side_quality) || (qual_next >= qual_this))
               ghost_cleared[key_wire][i_pattern] = 1;
           }
         }
         if (ghost_cleared[key_wire][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_next
                 << "  dt=" << dt;
           continue;
         }
       }
     }
   }
  
   // All cancellation is done in parallel, so wiregroups do not know what
   // their neighbors are cancelling.
   for (int key_wire = 0; key_wire < numWireGroups; key_wire++) {
     for (int i_pattern = 0; i_pattern < 2; i_pattern++) {
       if (ghost_cleared[key_wire][i_pattern] > 0) {
         clear(key_wire, i_pattern);
       }
     }
   }
 }

References CSCAnodeLCTProcessor::clear(), dt, CSCAnodeLCTProcessor::first_bx, CSCAnodeLCTProcessor::first_bx_corrected, CSCAnodeLCTProcessor::ghost_cancellation_bx_depth, CSCAnodeLCTProcessor::ghost_cancellation_side_quality, CSCBaseboard::infoV, CSCBaseboard::isME21_, LogTrace, CSCConstants::MAX_NUM_WIRES, CSCAnodeLCTProcessor::numWireGroups, CSCAnodeLCTProcessor::quality, CSCBaseboard::runME21ILT_, CSCBaseboard::runPhase2_, and CSCAnodeLCTProcessor::use_corrected_bx.

◆ ghostCancellationLogicOneWire()

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

overrideprivatevirtual

Reimplemented from CSCAnodeLCTProcessor.

Definition at line 121 of file CSCUpgradeAnodeLCTProcessor.cc.

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

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.

Public Member Functions

Private Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ CSCUpgradeAnodeLCTProcessor() [1/2]

◆ CSCUpgradeAnodeLCTProcessor() [2/2]

Member Function Documentation

◆ getTempALCTQuality()

◆ ghostCancellationLogic()

◆ ghostCancellationLogicOneWire()