CSCUpgradeAnodeLCTProcessor Class Reference

#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)
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 Member Functions inherited from CSCAnodeLCTProcessor
void	accelMode (const int key_wire)
std::vector< CSCALCTDigi >	bestTrackSelector (const std::vector< CSCALCTDigi > &all_alcts)
void	checkConfigParameters ()
void	checkValid (const CSCALCTDigi &alct, unsigned max_stubs=CSCConstants::MAX_ALCTS_PER_PROCESSOR) const
void	checkValidReadout (const CSCALCTDigi &alct) 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)
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 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
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
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]
CSCALCTDigi	secondALCT [CSCConstants::MAX_ALCT_TBINS]
std::vector< CSCALCTPreTriggerDigi >	thePreTriggerDigis
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	isME21_
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() [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 (!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";
}

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

CSCUpgradeAnodeLCTProcessor() [2/2]

CSCUpgradeAnodeLCTProcessor::CSCUpgradeAnodeLCTProcessor

(

)

Default constructor. Used for testing.

Definition at line 19 of file CSCUpgradeAnodeLCTProcessor.cc.

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

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

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 isSLHC_ 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_, CSCBaseboard::isSLHC_, class-composition::Q, and CSCBaseboard::runME21ILT_.

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 (isSLHC_ 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 (isSLHC_ 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 (isSLHC_ 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_, CSCBaseboard::isSLHC_, LogTrace, CSCConstants::MAX_NUM_WIRES, CSCAnodeLCTProcessor::numWireGroups, CSCAnodeLCTProcessor::quality, CSCBaseboard::runME21ILT_, 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 (isSLHC_ 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 (isSLHC_ 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_, CSCBaseboard::isSLHC_, CSCAnodeLCTProcessor::lct_list, LogTrace, AlCaHLTBitMon_ParallelJobs::p, CSCAnodeLCTProcessor::quality, CSCBaseboard::runME21ILT_, and CSCAnodeLCTProcessor::use_corrected_bx.