#include <CSCUpgradeAnodeLCTProcessor.h>

Inheritance diagram for CSCUpgradeAnodeLCTProcessor:

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

	CSCUpgradeAnodeLCTProcessor ()

Public Member Functions inherited from CSCAnodeLCTProcessor
void	clear ()

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

	CSCAnodeLCTProcessor ()

std::vector< CSCALCTDigi >	getALCTs ()

std::vector< CSCALCTDigi >	readoutALCTs ()

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)

Public Member Functions inherited from CSCBaseboard
	CSCBaseboard (unsigned endcap, unsigned station, unsigned sector, unsigned subsector, unsigned chamber, const edm::ParameterSet &conf)

	CSCBaseboard ()

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
Public Attributes inherited from CSCAnodeLCTProcessor
CSCALCTDigi	bestALCT [CSCConstants::MAX_ALCT_TBINS]

CSCALCTDigi	secondALCT [CSCConstants::MAX_ALCT_TBINS]

Static Public Attributes inherited from CSCAnodeLCTProcessor
static const int	pattern_envelope [CSCConstants::NUM_ALCT_PATTERNS][CSCConstants::MAX_WIRES_IN_PATTERN]

static const int	pattern_mask_open [CSCConstants::NUM_ALCT_PATTERNS][CSCConstants::MAX_WIRES_IN_PATTERN]

static const int	pattern_mask_r1 [CSCConstants::NUM_ALCT_PATTERNS][CSCConstants::MAX_WIRES_IN_PATTERN]

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

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)

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	showPatterns (const int key_wire)

void	trigMode (const int key_wire)

Protected Attributes inherited from CSCAnodeLCTProcessor
unsigned int	accel_mode

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

int	pattern_mask [CSCConstants::NUM_ALCT_PATTERNS][CSCConstants::MAX_WIRES_IN_PATTERN]

unsigned int	pretrig_extra_deadtime

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

int	quality [CSCConstants::MAX_NUM_WIRES][3]

unsigned int	trig_mode

bool	use_corrected_bx

Protected Attributes inherited from CSCBaseboard
unsigned int	alctClctOffset_

edm::ParameterSet	alctParams_

edm::ParameterSet	clctParams_

edm::ParameterSet	commonParams_

const CSCChamber *	cscChamber_

const CSCGeometry *	cscGeometry_

CSCDetId	cscId_

bool	disableME1a_

bool	enableAlctSLHC_

bool	gangedME1a_

int	infoV

bool	isME11_

bool	isSLHC_

bool	runME11ILT_

bool	runME11Up_

bool	runME21ILT_

bool	runME21Up_

bool	runME31Up_

bool	runME41Up_

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::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.

References CSCBaseboard::enableAlctSLHC_, and CSCBaseboard::isSLHC_.

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

CSCUpgradeAnodeLCTProcessor::CSCUpgradeAnodeLCTProcessor ( )

Default constructor. Used for testing.

Definition at line 16 of file CSCUpgradeAnodeLCTProcessor.cc.

References CSCBaseboard::enableAlctSLHC_, and CSCBaseboard::isSLHC_.

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

Member Function Documentation

int CSCUpgradeAnodeLCTProcessor::getTempALCTQuality ( int temp_quality ) const

overrideprivatevirtual

Reimplemented from CSCAnodeLCTProcessor.

Definition at line 202 of file CSCUpgradeAnodeLCTProcessor.cc.

References CSCBaseboard::isSLHC_, or, class-composition::Q, CSCBaseboard::runME21ILT_, CSCBaseboard::runME31Up_, and CSCBaseboard::runME41Up_.

 {
   // 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 isSLHC_ and (runME21ILT_ or runME31Up_ or runME41Up_)) Q = 4;
   else if (temp_quality > 3) Q = temp_quality - 3;
   else                  Q = 0; // quality code 0 is valid!
 
   return Q;
 }

void CSCUpgradeAnodeLCTProcessor::ghostCancellationLogic ( )

overrideprivatevirtual

Reimplemented from CSCAnodeLCTProcessor.

Definition at line 26 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 (isSLHC_ and (runME21ILT_ or runME31Up_ or runME41Up_))
           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 (isSLHC_ and (runME21ILT_ or runME31Up_ or runME41Up_))
             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 (isSLHC_ and (runME21ILT_ or runME31Up_ or runME41Up_))
             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);
       }
     }
   }
 }

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

overrideprivatevirtual

Reimplemented from CSCAnodeLCTProcessor.

Definition at line 123 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::isSLHC_, CSCAnodeLCTProcessor::lct_list, LogTrace, or, AlCaHLTBitMon_ParallelJobs::p, CSCAnodeLCTProcessor::quality, CSCBaseboard::runME21ILT_, CSCBaseboard::runME31Up_, CSCBaseboard::runME41Up_, 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 (isSLHC_ and (runME21ILT_ or runME31Up_ or runME41Up_))
           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 (isSLHC_ and (runME21ILT_ or runME31Up_ or runME41Up_))
             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

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation