#include <CSCUpgradeCathodeLCTProcessor.h>

Inheritance diagram for CSCUpgradeCathodeLCTProcessor:

Public Member Functions
	CSCUpgradeCathodeLCTProcessor ()

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

Public Member Functions inherited from CSCCathodeLCTProcessor
void	clear ()

	CSCCathodeLCTProcessor ()

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

CSCCLCTDigi	getBestCLCT (int bx) const

std::vector< CSCCLCTDigi >	getCLCTs (unsigned nMaxCLCTs=CSCConstants::MAX_CLCTS_PER_PROCESSOR) const

CSCCLCTDigi	getSecondCLCT (int bx) const

std::vector< int >	preTriggerBXs () const

std::vector< CSCCLCTPreTriggerDigi >	preTriggerDigis () const

std::vector< CSCCLCTPreTriggerDigi >	preTriggerDigisME1a () const

std::vector< CSCCLCTPreTriggerDigi >	preTriggerDigisME1b () const

std::vector< CSCCLCTDigi >	readoutCLCTs (int nMaxCLCTs=CSCConstants::MAX_CLCTS_READOUT) const

std::vector< CSCCLCTDigi >	readoutCLCTsME1a (int nMaxCLCTs=CSCConstants::MAX_CLCTS_READOUT) const

std::vector< CSCCLCTDigi >	readoutCLCTsME1b (int nMaxCLCTs=CSCConstants::MAX_CLCTS_READOUT) const

std::vector< CSCCLCTDigi >	run (const CSCComparatorDigiCollection *compdc)

void	run (const std::vector< int > halfstrip[CSCConstants::NUM_LAYERS][CSCConstants::NUM_HALF_STRIPS_7CFEBS])

void	setConfigParameters (const CSCDBL1TPParameters *conf)

	~CSCCathodeLCTProcessor () 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

Protected Attributes
bool	busyMap [CSCConstants::NUM_HALF_STRIPS_7CFEBS][CSCConstants::MAX_CLCT_TBINS]

Protected Attributes inherited from CSCCathodeLCTProcessor
unsigned int	best_pid [CSCConstants::NUM_HALF_STRIPS_7CFEBS]

CSCCLCTDigi	bestCLCT [CSCConstants::MAX_CLCT_TBINS]

CSCPatternBank::LCTPatterns	clct_pattern_ = {}

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

unsigned int	drift_delay

int	early_tbins

unsigned int	fifo_pretrig

unsigned int	fifo_tbins

int	first_bx_corrected [CSCConstants::NUM_HALF_STRIPS_7CFEBS]

unsigned int	hit_persist

bool	ispretrig [CSCConstants::NUM_HALF_STRIPS_7CFEBS]

std::array< std::unique_ptr< CSCComparatorCodeLUT >, 5 >	lutpatconv_

std::array< std::unique_ptr< CSCComparatorCodeLUT >, 5 >	lutpos_

std::array< std::unique_ptr< CSCComparatorCodeLUT >, 5 >	lutslope_

unsigned int	min_separation

unsigned int	nhits [CSCConstants::NUM_HALF_STRIPS_7CFEBS]

unsigned int	nplanes_hit_pattern

unsigned int	nplanes_hit_pretrig

int	numCFEBs_

int	numHalfStrips_

int	numStrips_

std::vector< std::string >	patternConversionLUTFiles_

unsigned int	pid_thresh_pretrig

std::vector< std::string >	positionLUTFiles_

std::unique_ptr< LCTQualityControl >	qualityControl_

bool	readout_earliest_2

CSCCLCTDigi	secondCLCT [CSCConstants::MAX_CLCT_TBINS]

std::vector< std::string >	slopeLUTFiles_

int	stagger [CSCConstants::NUM_LAYERS]

int	start_bx_shift

std::vector< int >	thePreTriggerBXs

std::vector< CSCCLCTPreTriggerDigi >	thePreTriggerDigis

unsigned int	tmb_l1a_window_size

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_

Private Member Functions
std::vector< CSCCLCTDigi >	findLCTs (const std::vector< int > halfstrip[CSCConstants::NUM_LAYERS][CSCConstants::NUM_HALF_STRIPS_7CFEBS]) override

bool	preTrigger (const PulseArray pulse, const int start_bx, int &first_bx) override

Private Attributes
unsigned int	clct_state_machine_zone

unsigned int	pretrig_trig_zone

bool	use_corrected_bx

bool	use_dead_time_zoning

Additional Inherited Members
Protected Types inherited from CSCCathodeLCTProcessor
enum	CLCT_CompCode { INVALID_HALFSTRIP = 65535 }

enum	CLCT_INDICES { CLCT_PATTERN, CLCT_BEND, CLCT_STRIP, CLCT_BX, CLCT_STRIP_TYPE, CLCT_QUALITY, CLCT_CFEB, CLCT_NUM_QUANTITIES = 7 }

typedef unsigned int	PulseArray[CSCConstants::NUM_LAYERS][CSCConstants::NUM_HALF_STRIPS_7CFEBS]

Protected Member Functions inherited from CSCCathodeLCTProcessor
void	assignPositionCC (const unsigned offset, std::tuple< int16_t, bool, bool > &returnValue) const

int	calculateComparatorCode (const std::array< std::array< int, 3 >, 6 > &halfStripPattern) const

void	checkConfigParameters ()

void	cleanComparatorContainer (CSCCLCTDigi &lct) const

unsigned	convertSlopeToRun2Pattern (const unsigned slope) const

void	dumpConfigParams () const

void	dumpDigis (const std::vector< int > strip[CSCConstants::NUM_LAYERS][CSCConstants::NUM_HALF_STRIPS_7CFEBS]) const

bool	getDigis (const CSCComparatorDigiCollection *compdc)

void	getDigis (const CSCComparatorDigiCollection *compdc, const CSCDetId &id)

void	markBusyKeys (const int best_hstrip, const int best_patid, int quality[CSCConstants::NUM_HALF_STRIPS_7CFEBS])

bool	patternFinding (const PulseArray pulse, const unsigned int bx_time, std::map< int, std::map< int, CSCCLCTDigi::ComparatorContainer > > &hits_in_patterns)

void	pulseExtension (const std::vector< int > time[CSCConstants::NUM_LAYERS][CSCConstants::NUM_HALF_STRIPS_7CFEBS], PulseArray pulse)

void	readComparatorDigis (std::vector< int > halfstrip[CSCConstants::NUM_LAYERS][CSCConstants::NUM_HALF_STRIPS_7CFEBS])

void	runCCLUT (CSCCLCTDigi &digi) const

void	setDefaultConfigParameters ()

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)

Static Protected Attributes inherited from CSCCathodeLCTProcessor
static const unsigned int	def_drift_delay = 2

static const unsigned int	def_fifo_pretrig = 7

static const unsigned int	def_fifo_tbins = 12

static const unsigned int	def_hit_persist = 6

static const unsigned int	def_min_separation = 10

static const unsigned int	def_nplanes_hit_pattern = 4

static const unsigned int	def_nplanes_hit_pretrig = 2

static const unsigned int	def_pid_thresh_pretrig = 2

static const unsigned int	def_tmb_l1a_window_size = 7

Detailed Description

This class simulates the functionality of the cathode LCT card. It is run by the MotherBoard and returns up to two CathodeLCTs. It can be run either in a test mode, where it is passed arrays of halfstrip times, or in normal mode where it determines the time and comparator information from the comparator digis.

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 24 of file CSCUpgradeCathodeLCTProcessor.h.

Constructor & Destructor Documentation

◆ CSCUpgradeCathodeLCTProcessor() [1/2]

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

Normal constructor.

Definition at line 6 of file CSCUpgradeCathodeLCTProcessor.cc.

     : CSCCathodeLCTProcessor(endcap, station, sector, subsector, chamber, conf) {
   if (!runPhase2_)
     edm::LogError("CSCUpgradeCathodeLCTProcessor|ConfigError")
         << "+++ Upgrade CSCUpgradeCathodeLCTProcessor constructed while runPhase2_ is not set! +++\n";
  
   // use of localized dead-time zones
   use_dead_time_zoning = clctParams_.getParameter<bool>("useDeadTimeZoning");
   clct_state_machine_zone = clctParams_.getParameter<unsigned int>("clctStateMachineZone");
  
   // how far away may trigger happen from pretrigger
   pretrig_trig_zone = clctParams_.getParameter<unsigned int>("clctPretriggerTriggerZone");
  
   // whether to calculate bx as corrected_bx instead of pretrigger one
   use_corrected_bx = clctParams_.getParameter<bool>("clctUseCorrectedBx");
 }

References clct_state_machine_zone, CSCBaseboard::clctParams_, edm::ParameterSet::getParameter(), pretrig_trig_zone, CSCBaseboard::runPhase2_, use_corrected_bx, and use_dead_time_zoning.

◆ CSCUpgradeCathodeLCTProcessor() [2/2]

CSCUpgradeCathodeLCTProcessor::CSCUpgradeCathodeLCTProcessor ( )

Default constructor. Used for testing.

Definition at line 28 of file CSCUpgradeCathodeLCTProcessor.cc.

                                                              : CSCCathodeLCTProcessor() {
   if (!runPhase2_)
     edm::LogError("CSCUpgradeCathodeLCTProcessor|ConfigError")
         << "+++ Upgrade CSCUpgradeCathodeLCTProcessor constructed while runPhase2_ is not set! +++\n";
 }

References CSCBaseboard::runPhase2_.

Member Function Documentation

◆ findLCTs()

std::vector< CSCCLCTDigi > CSCUpgradeCathodeLCTProcessor::findLCTs ( const std::vector< int > halfstrip[CSCConstants::NUM_LAYERS][CSCConstants::NUM_HALF_STRIPS_7CFEBS] )

overrideprivatevirtual

busyMap[hstrip][latch_bx] )

Reimplemented from CSCCathodeLCTProcessor.

Definition at line 137 of file CSCUpgradeCathodeLCTProcessor.cc.

                                                                                                 {
   // run the original algorithm in case we do not use dead time zoning
   if (runPhase2_ and !use_dead_time_zoning) {
     return CSCCathodeLCTProcessor::findLCTs(halfstrip);
   }
  
   std::vector<CSCCLCTDigi> lctList;
  
   // initialize the ispretrig before doing pretriggering
   for (int hstrip = stagger[CSCConstants::KEY_CLCT_LAYER - 1]; hstrip < numHalfStrips_; hstrip++) {
     ispretrig[hstrip] = false;
   }
  
   if (infoV > 1)
     dumpDigis(halfstrip);
  
   // keeps dead-time zones around key halfstrips of triggered CLCTs
   for (int i = 0; i < CSCConstants::NUM_HALF_STRIPS_7CFEBS; i++) {
     for (int j = 0; j < CSCConstants::MAX_CLCT_TBINS; j++) {
       busyMap[i][j] = false;
     }
   }
  
   std::vector<CSCCLCTDigi> lctListBX;
  
   unsigned int pulse[CSCConstants::NUM_LAYERS][CSCConstants::NUM_HALF_STRIPS_7CFEBS];
  
   // Fire half-strip one-shots for hit_persist bx's (4 bx's by default).
   pulseExtension(halfstrip, pulse);
  
   unsigned int start_bx = start_bx_shift;
   // 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;
  
   // Allow for more than one pass over the hits in the time window.
   // Do search in every BX
   while (start_bx < stop_bx) {
     lctListBX.clear();
  
     // All half-strip pattern envelopes are evaluated simultaneously, on every clock cycle.
     int first_bx = 999;
     bool pre_trig = CSCUpgradeCathodeLCTProcessor::preTrigger(pulse, start_bx, first_bx);
  
     // If any of half-strip envelopes has enough layers hit in it, TMB
     // will pre-trigger.
     if (pre_trig) {
       if (infoV > 1)
         LogTrace("CSCUpgradeCathodeLCTProcessor")
             << "..... pretrigger at bx = " << first_bx << "; waiting drift delay .....";
  
       // TMB latches LCTs drift_delay clocks after pretrigger.
       int latch_bx = first_bx + drift_delay;
  
       std::map<int, std::map<int, CSCCLCTDigi::ComparatorContainer> > hits_in_patterns;
       hits_in_patterns.clear();
  
       bool hits_in_time = patternFinding(pulse, latch_bx, hits_in_patterns);
       if (infoV > 1) {
         if (hits_in_time) {
           for (int hstrip = stagger[CSCConstants::KEY_CLCT_LAYER - 1]; hstrip < numHalfStrips_; hstrip++) {
             if (nhits[hstrip] > 0) {
               LogTrace("CSCUpgradeCathodeLCTProcessor")
                   << " bx = " << std::setw(2) << latch_bx << " --->"
                   << " halfstrip = " << std::setw(3) << hstrip << " best pid = " << std::setw(2) << best_pid[hstrip]
                   << " nhits = " << nhits[hstrip];
             }
           }
         }
       }
  
       // 2 possible LCTs per CSC x 7 LCT quantities per BX
       int keystrip_data[CSCConstants::MAX_CLCTS_PER_PROCESSOR][CLCT_NUM_QUANTITIES] = {{0}};
  
       // Quality for sorting.
       int quality[CSCConstants::NUM_HALF_STRIPS_7CFEBS];
       int best_halfstrip[CSCConstants::MAX_CLCTS_PER_PROCESSOR], best_quality[CSCConstants::MAX_CLCTS_PER_PROCESSOR];
       for (int ilct = 0; ilct < CSCConstants::MAX_CLCTS_PER_PROCESSOR; ilct++) {
         best_halfstrip[ilct] = -1;
         best_quality[ilct] = 0;
       }
  
       bool pretrig_zone[CSCConstants::NUM_HALF_STRIPS_7CFEBS];
  
       // Calculate quality from pattern id and number of hits, and
       // simultaneously select best-quality LCT.
       if (hits_in_time) {
         // first, mark half-strip zones around pretriggers
         // that happened at the current first_bx
         for (int hstrip = 0; hstrip < CSCConstants::NUM_HALF_STRIPS_7CFEBS; hstrip++)
           pretrig_zone[hstrip] = false;
         for (int hstrip = 0; hstrip < CSCConstants::NUM_HALF_STRIPS_7CFEBS; hstrip++) {
           if (ispretrig[hstrip]) {
             int min_hs = hstrip - pretrig_trig_zone;
             int max_hs = hstrip + pretrig_trig_zone;
             if (min_hs < 0)
               min_hs = 0;
             if (max_hs > CSCConstants::NUM_HALF_STRIPS_7CFEBS - 1)
               max_hs = CSCConstants::NUM_HALF_STRIPS_7CFEBS - 1;
             for (int hs = min_hs; hs <= max_hs; hs++)
               pretrig_zone[hs] = true;
             if (infoV > 1)
               LogTrace("CSCUpgradeCathodeLCTProcessor")
                   << " marked pretrigger halfstrip zone [" << min_hs << "," << max_hs << "]";
           }
         }
  
         for (int hstrip = stagger[CSCConstants::KEY_CLCT_LAYER - 1]; hstrip < numHalfStrips_; hstrip++) {
           // The bend-direction bit pid[0] is ignored (left and right bends have equal quality).
           quality[hstrip] = (best_pid[hstrip] & 14) | (nhits[hstrip] << 5);
           // do not consider halfstrips:
           //   - out of pretrigger-trigger zones
           //   - in busy zones from previous trigger
           if (quality[hstrip] > best_quality[0] && pretrig_zone[hstrip] && !busyMap[hstrip][first_bx])
           {
             best_halfstrip[0] = hstrip;
             best_quality[0] = quality[hstrip];
             if (infoV > 1) {
               LogTrace("CSCUpgradeCathodeLCTProcessor")
                   << " 1st CLCT: halfstrip = " << std::setw(3) << hstrip << " quality = " << std::setw(3)
                   << quality[hstrip] << " best halfstrip = " << std::setw(3) << best_halfstrip[0]
                   << " best quality = " << std::setw(3) << best_quality[0];
             }
           }
         }
       }
  
       // If 1st best CLCT is found, look for the 2nd best.
       if (best_halfstrip[0] >= 0) {
         // Mark keys near best CLCT as busy by setting their quality to zero, and repeat the search.
         markBusyKeys(best_halfstrip[0], best_pid[best_halfstrip[0]], quality);
  
         for (int hstrip = stagger[CSCConstants::KEY_CLCT_LAYER - 1]; hstrip < numHalfStrips_; hstrip++) {
           if (quality[hstrip] > best_quality[1] && pretrig_zone[hstrip] && !busyMap[hstrip][first_bx])
           {
             best_halfstrip[1] = hstrip;
             best_quality[1] = quality[hstrip];
             if (infoV > 1) {
               LogTrace("CSCUpgradeCathodeLCTProcessor")
                   << " 2nd CLCT: halfstrip = " << std::setw(3) << hstrip << " quality = " << std::setw(3)
                   << quality[hstrip] << " best halfstrip = " << std::setw(3) << best_halfstrip[1]
                   << " best quality = " << std::setw(3) << best_quality[1];
             }
           }
         }
  
         // Pattern finder.
         //bool ptn_trig = false;
         for (int ilct = 0; ilct < CSCConstants::MAX_CLCTS_PER_PROCESSOR; ilct++) {
           int best_hs = best_halfstrip[ilct];
           if (best_hs >= 0 && nhits[best_hs] >= nplanes_hit_pattern) {
             int bx = first_bx;
             int fbx = first_bx_corrected[best_hs];
             if (use_corrected_bx) {
               bx = fbx;
               fbx = first_bx;
             }
             //ptn_trig = true;
             keystrip_data[ilct][CLCT_PATTERN] = best_pid[best_hs];
             keystrip_data[ilct][CLCT_BEND] =
                 clct_pattern_[best_pid[best_hs]][CSCConstants::NUM_LAYERS - 1][CSCConstants::CLCT_PATTERN_WIDTH];
             // Remove stagger if any.
             keystrip_data[ilct][CLCT_STRIP] = best_hs - stagger[CSCConstants::KEY_CLCT_LAYER - 1];
             keystrip_data[ilct][CLCT_BX] = bx;
             keystrip_data[ilct][CLCT_STRIP_TYPE] = 1;  // obsolete
             keystrip_data[ilct][CLCT_QUALITY] = nhits[best_hs];
             keystrip_data[ilct][CLCT_CFEB] = keystrip_data[ilct][CLCT_STRIP] / CSCConstants::NUM_HALF_STRIPS_PER_CFEB;
             int halfstrip_in_cfeb = keystrip_data[ilct][CLCT_STRIP] -
                                     CSCConstants::NUM_HALF_STRIPS_PER_CFEB * keystrip_data[ilct][CLCT_CFEB];
  
             CSCCLCTDigi thisLCT(1,
                                 keystrip_data[ilct][CLCT_QUALITY],
                                 keystrip_data[ilct][CLCT_PATTERN],
                                 keystrip_data[ilct][CLCT_STRIP_TYPE],
                                 keystrip_data[ilct][CLCT_BEND],
                                 halfstrip_in_cfeb,
                                 keystrip_data[ilct][CLCT_CFEB],
                                 keystrip_data[ilct][CLCT_BX]);
             if (infoV > 1) {
               LogTrace("CSCCathodeLCTProcessor") << " Final selection: ilct " << ilct << " " << thisLCT << std::endl;
             }
             thisLCT.setFullBX(fbx);
  
             // get the comparator hits for this pattern
             const auto& compHits = hits_in_patterns[best_hs][keystrip_data[ilct][CLCT_PATTERN]];
  
             // set the hit collection
             thisLCT.setHits(compHits);
  
             // do the CCLUT procedures
             if (runCCLUT_) {
               runCCLUT(thisLCT);
             }
  
             // purge the comparator digi collection from the obsolete "65535" entries...
             cleanComparatorContainer(thisLCT);
  
             // put the CLCT into the collection
             lctList.push_back(thisLCT);
             lctListBX.push_back(thisLCT);
           }
         }
  
       }  //find CLCT, end of best_halfstrip[0] >= 0
     }    //pre_trig
     // The pattern finder runs continuously, so another pre-trigger
     // could occur already at the next bx.
     start_bx = first_bx + 1;
   }
  
   return lctList;
 }  // findLCTs -- Phase2 version.

◆ preTrigger()

bool CSCUpgradeCathodeLCTProcessor::preTrigger	(	const PulseArray	pulse,
		const int	start_bx,
		int &	first_bx
	)

overrideprivatevirtual

Reimplemented from CSCCathodeLCTProcessor.

Definition at line 39 of file CSCUpgradeCathodeLCTProcessor.cc.

                                                                                                         {
   if (runPhase2_ and !use_dead_time_zoning) {
     return CSCCathodeLCTProcessor::preTrigger(pulse, start_bx, first_bx);
   }
  
   if (infoV > 1)
     LogTrace("CSCUpgradeCathodeLCTProcessor")
         << "....................PreTrigger, Phase2 version with localized dead time zone...........................";
  
   int nPreTriggers = 0;
  
   bool pre_trig = false;
   int delta_hs = clct_state_machine_zone;  //dead time zone
  
   // Now do a loop over bx times to see (if/when) track goes over threshold
   for (unsigned int bx_time = start_bx; bx_time < fifo_tbins; bx_time++) {
     // For any given bunch-crossing, start at the lowest keystrip and look for
     // the number of separate layers in the pattern for that keystrip that have
     // pulses at that bunch-crossing time.  Do the same for the next keystrip,
     // etc.  Then do the entire process again for the next bunch-crossing, etc
     // until you find a pre-trigger.
     std::map<int, std::map<int, CSCCLCTDigi::ComparatorContainer> > hits_in_patterns;
     hits_in_patterns.clear();
  
     bool hits_in_time = patternFinding(pulse, bx_time, hits_in_patterns);
     if (hits_in_time) {
       for (int hstrip = stagger[CSCConstants::KEY_CLCT_LAYER - 1]; hstrip < numHalfStrips_; hstrip++) {
         if (infoV > 1) {
           if (nhits[hstrip] > 0) {
             LogTrace("CSCUpgradeCathodeLCTProcessor")
                 << " bx = " << std::setw(2) << bx_time << " --->"
                 << " halfstrip = " << std::setw(3) << hstrip << " best pid = " << std::setw(2) << best_pid[hstrip]
                 << " nhits = " << nhits[hstrip];
           }
         }
         //ispretrig[hstrip] = false; it is initialzed in findLCT
         if (nhits[hstrip] >= nplanes_hit_pretrig && best_pid[hstrip] >= pid_thresh_pretrig &&
             !busyMap[hstrip][bx_time]) {
           pre_trig = true;
           ispretrig[hstrip] = true;
  
           // write each pre-trigger to output
           nPreTriggers++;
           const int bend =
               clct_pattern_[best_pid[hstrip]][CSCConstants::NUM_LAYERS - 1][CSCConstants::CLCT_PATTERN_WIDTH];
           const int halfstrip = hstrip % CSCConstants::NUM_HALF_STRIPS_PER_CFEB;
           const int cfeb = hstrip / CSCConstants::NUM_HALF_STRIPS_PER_CFEB;
           thePreTriggerDigis.push_back(CSCCLCTPreTriggerDigi(
               1, nhits[hstrip], best_pid[hstrip], 1, bend, halfstrip, cfeb, bx_time, nPreTriggers, 0));
  
         } else if (nhits[hstrip] >= nplanes_hit_pretrig &&
                    best_pid[hstrip] >= pid_thresh_pretrig) {  //busy zone, keep pretriggering,ignore this
           ispretrig[hstrip] = true;
           if (infoV > 1)
             LogTrace("CSCUpgradeCathodeLCTProcessor")
                 << " halfstrip " << std::setw(3) << hstrip << " in dead zone and is pretriggerred";
         } else if (nhits[hstrip] < nplanes_hit_pretrig || best_pid[hstrip] < pid_thresh_pretrig) {
           // not pretriggered anyone, release dead zone
           ispretrig[hstrip] = false;
         }
       }  // find all pretriggers
  
       //update dead zone
       for (int hstrip = stagger[CSCConstants::KEY_CLCT_LAYER - 1]; hstrip < numHalfStrips_; hstrip++) {
         if (ispretrig[hstrip]) {
           int min_hstrip = hstrip - delta_hs;  //only fixed localized dead time zone is implemented
           int max_hstrip = hstrip + delta_hs;
           if (min_hstrip < stagger[CSCConstants::KEY_CLCT_LAYER - 1])
             min_hstrip = stagger[CSCConstants::KEY_CLCT_LAYER - 1];
           if (max_hstrip >= numHalfStrips_)
             max_hstrip = numHalfStrips_ - 1;
           for (int hs = min_hstrip; hs <= max_hstrip; hs++)
             busyMap[hs][bx_time + 1] = true;
           if (infoV > 1)
             LogTrace("CSCUpgradeCathodeLCTProcessor")
                 << " marked zone around pretriggerred halfstrip " << hstrip << " as dead zone for pretriggering at bx"
                 << bx_time + 1 << " halfstrip: [" << min_hstrip << "," << max_hstrip << "]";
         }
       }
       if (pre_trig) {
         first_bx = bx_time;  // bx at time of pretrigger
         return true;
       }
     } else  //no pattern found, remove all dead time zone
       for (int hstrip = stagger[CSCConstants::KEY_CLCT_LAYER - 1]; hstrip < numHalfStrips_; hstrip++) {
         if (ispretrig[hstrip])
           ispretrig[hstrip] = false;  //dead zone is gone by default
       }
  
   }  // end loop over bx times
  
   if (infoV > 1)
     LogTrace("CSCUpgradeCathodeLCTProcessor") << "no pretrigger, returning \n";
   first_bx = fifo_tbins;
   return false;
 }  // preTrigger -- Phase2 version.