CMS 3D CMS Logo

List of all members | Public Member Functions | Private Member Functions | Private Attributes
CSCUpgradeCathodeLCTProcessor Class Reference

#include <CSCUpgradeCathodeLCTProcessor.h>

Inheritance diagram for CSCUpgradeCathodeLCTProcessor:
CSCCathodeLCTProcessor CSCBaseboard

Public Member Functions

 CSCUpgradeCathodeLCTProcessor (unsigned endcap, unsigned station, unsigned sector, unsigned subsector, unsigned chamber, const edm::ParameterSet &conf)
 
- Public Member Functions inherited from CSCCathodeLCTProcessor
void clear ()
 
 CSCCathodeLCTProcessor (unsigned endcap, unsigned station, unsigned sector, unsigned subsector, unsigned chamber, const edm::ParameterSet &conf)
 
std::vector< CSCShowerDigigetAllShower () const
 
CSCCLCTDigi getBestCLCT (int bx) const
 
std::vector< CSCCLCTDigigetCLCTs () const
 
CSCCLCTDigi getSecondCLCT (int bx) const
 
std::vector< int > preTriggerBXs () const
 
std::vector< CSCCLCTPreTriggerDigipreTriggerDigis () const
 
std::vector< CSCCLCTDigireadoutCLCTs () const
 
std::vector< CSCShowerDigireadoutShower () const
 
std::vector< CSCCLCTDigirun (const CSCComparatorDigiCollection *compdc)
 
void run (const std::vector< int > halfstrip[CSCConstants::NUM_LAYERS][CSCConstants::MAX_NUM_HALF_STRIPS_RUN2_TRIGGER])
 
void setConfigParameters (const CSCDBL1TPParameters *conf)
 
void setESLookupTables (const CSCL1TPLookupTableCCLUT *conf)
 
 ~CSCCathodeLCTProcessor () override=default
 
- 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
 
CSCDetId id () const
 
void setCSCGeometry (const CSCGeometry *g)
 
virtual ~CSCBaseboard ()=default
 

Private Member Functions

std::vector< CSCCLCTDigifindLCTs (const std::vector< int > halfstrip[CSCConstants::NUM_LAYERS][CSCConstants::MAX_NUM_HALF_STRIPS_RUN2_TRIGGER]) override
 
void markBusyZone (const int bx)
 
void markPreTriggerZone (bool pretrig_zone[CSCConstants::MAX_NUM_HALF_STRIPS_RUN2_TRIGGER]) const
 
bool preTrigger (const int start_bx, int &first_bx) override
 

Private Attributes

bool busyMap_ [CSCConstants::MAX_NUM_HALF_STRIPS_RUN2_TRIGGER][CSCConstants::MAX_CLCT_TBINS]
 
unsigned int clct_state_machine_zone_
 
unsigned int pretrig_trig_zone_
 
bool use_dead_time_zoning_
 

Additional Inherited Members

- Protected Member Functions inherited from CSCCathodeLCTProcessor
void checkConfigParameters ()
 
void cleanComparatorContainer (CSCCLCTDigi &lct) const
 
void clearPreTriggers ()
 
CSCCLCTDigi constructCLCT (const int bx, const unsigned halfstrip_withstagger, const CSCCLCTDigi::ComparatorContainer &hits)
 
CSCCLCTPreTriggerDigi constructPreCLCT (const int bx, const unsigned halfstrip, const unsigned index) const
 
void dumpConfigParams () const
 
void dumpDigis (const std::vector< int > strip[CSCConstants::NUM_LAYERS][CSCConstants::MAX_NUM_HALF_STRIPS_RUN2_TRIGGER]) const
 
void encodeHighMultiplicityBits ()
 
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::MAX_NUM_HALF_STRIPS_RUN2_TRIGGER])
 
bool patternFinding (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::MAX_NUM_HALF_STRIPS_RUN2_TRIGGER])
 
void readComparatorDigis (std::vector< int > halfstrip[CSCConstants::NUM_LAYERS][CSCConstants::MAX_NUM_HALF_STRIPS_RUN2_TRIGGER])
 
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)
 
- Protected Attributes inherited from CSCCathodeLCTProcessor
unsigned int best_pid [CSCConstants::MAX_NUM_HALF_STRIPS_RUN2_TRIGGER]
 
CSCCLCTDigi bestCLCT [CSCConstants::MAX_CLCT_TBINS]
 
CSCShowerDigi cathode_showers_ [CSCConstants::MAX_CLCT_TBINS]
 
std::unique_ptr< ComparatorCodeLUTcclut_
 
CSCPatternBank::LCTPatterns clct_pattern_ = {}
 
std::vector< CSCComparatorDigidigiV [CSCConstants::NUM_LAYERS]
 
unsigned int drift_delay
 
int early_tbins
 
unsigned int fifo_pretrig
 
unsigned int fifo_tbins
 
unsigned int hit_persist
 
bool ispretrig_ [CSCConstants::MAX_NUM_HALF_STRIPS_RUN2_TRIGGER]
 
unsigned maxbx_readout_
 
unsigned int min_separation
 
unsigned minbx_readout_
 
unsigned minLayersCentralTBin_
 
unsigned int nhits [CSCConstants::MAX_NUM_HALF_STRIPS_RUN2_TRIGGER]
 
unsigned int nplanes_hit_pattern
 
unsigned int nplanes_hit_pretrig
 
int numCFEBs_
 
int numHalfStrips_
 
int numStrips_
 
bool peakCheck_
 
unsigned int pid_thresh_pretrig
 
PulseArray pulse_
 
std::unique_ptr< LCTQualityControlqualityControl_
 
bool readout_earliest_2
 
CSCCLCTDigi secondCLCT [CSCConstants::MAX_CLCT_TBINS]
 
unsigned showerNumTBins_
 
int stagger [CSCConstants::NUM_LAYERS]
 
int start_bx_shift
 
std::vector< int > thePreTriggerBXs
 
std::vector< CSCCLCTPreTriggerDigithePreTriggerDigis
 
std::vector< unsigned > thresholds_
 
unsigned int tmb_l1a_window_size
 
- Protected Attributes inherited from CSCBaseboard
edm::ParameterSet alctParams_
 
edm::ParameterSet clctParams_
 
edm::ParameterSet commonParams_
 
const CSCChambercscChamber_
 
const CSCGeometrycscGeometry_
 
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_
 
edm::ParameterSet showerParams_
 
unsigned theChamber
 
std::string theCSCName_
 
const unsigned theEndcap
 
int theRegion
 
unsigned theRing
 
const unsigned theSector
 
const unsigned theStation
 
const unsigned theSubsector
 
const unsigned theTrigChamber
 
edm::ParameterSet tmbParams_
 
- 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()

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

Normal constructor.

Definition at line 5 of file CSCUpgradeCathodeLCTProcessor.cc.

References clct_state_machine_zone_, CSCBaseboard::clctParams_, edm::ParameterSet::getParameter(), pretrig_trig_zone_, CSCBaseboard::runPhase2_, and use_dead_time_zoning_.

11  : CSCCathodeLCTProcessor(endcap, station, sector, subsector, chamber, conf) {
12  if (!runPhase2_)
13  edm::LogError("CSCUpgradeCathodeLCTProcessor|ConfigError")
14  << "+++ Upgrade CSCUpgradeCathodeLCTProcessor constructed while runPhase2_ is not set! +++\n";
15 
16  // use of localized dead-time zones
17  use_dead_time_zoning_ = clctParams_.getParameter<bool>("useDeadTimeZoning");
18  clct_state_machine_zone_ = clctParams_.getParameter<unsigned int>("clctStateMachineZone");
19 
20  // how far away may trigger happen from pretrigger
21  pretrig_trig_zone_ = clctParams_.getParameter<unsigned int>("clctPretriggerTriggerZone");
22 }
T getParameter(std::string const &) const
Definition: ParameterSet.h:303
CSCCathodeLCTProcessor(unsigned endcap, unsigned station, unsigned sector, unsigned subsector, unsigned chamber, const edm::ParameterSet &conf)
Log< level::Error, false > LogError
edm::ParameterSet clctParams_
Definition: CSCBaseboard.h:84

Member Function Documentation

◆ findLCTs()

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

Reimplemented from CSCCathodeLCTProcessor.

Definition at line 106 of file CSCUpgradeCathodeLCTProcessor.cc.

References CSCCathodeLCTProcessor::best_pid, busyMap_, CSCCathodeLCTProcessor::clearPreTriggers(), CSCCathodeLCTProcessor::constructCLCT(), CSCCathodeLCTProcessor::drift_delay, CSCCathodeLCTProcessor::dumpDigis(), CSCCathodeLCTProcessor::fifo_tbins, CSCCathodeLCTProcessor::findLCTs(), CSCCLCTDigi::getKeyStrip(), CSCCLCTDigi::getPattern(), CSCCLCTDigi::getQuality(), CSCCLCTDigi::getRun3Pattern(), mps_fire::i, CSCBaseboard::infoV, CSCCLCTDigi::isValid(), dqmiolumiharvest::j, CSCConstants::KEY_CLCT_LAYER, LogTrace, CSCCathodeLCTProcessor::markBusyKeys(), markPreTriggerZone(), CSCConstants::MAX_CLCT_TBINS, CSCConstants::MAX_CLCTS_PER_PROCESSOR, CSCConstants::MAX_NUM_HALF_STRIPS_RUN2_TRIGGER, CSCCathodeLCTProcessor::nhits, CSCCathodeLCTProcessor::nplanes_hit_pattern, CSCCathodeLCTProcessor::numHalfStrips_, CSCCathodeLCTProcessor::patternFinding(), preTrigger(), CSCCathodeLCTProcessor::pulseExtension(), quality, CSCBaseboard::run3_, CSCBaseboard::runPhase2_, CSCCathodeLCTProcessor::stagger, CSCCathodeLCTProcessor::start_bx_shift, and use_dead_time_zoning_.

107  {
108  // run the original algorithm in case we do not use dead time zoning
110  return CSCCathodeLCTProcessor::findLCTs(halfstrip);
111  }
112 
113  std::vector<CSCCLCTDigi> lctList;
114 
115  // initialize the ispretrig_ before doing pretriggering
117 
118  if (infoV > 1)
119  dumpDigis(halfstrip);
120 
121  // keeps dead-time zones around key halfstrips of triggered CLCTs
123  for (int j = 0; j < CSCConstants::MAX_CLCT_TBINS; j++) {
124  busyMap_[i][j] = false;
125  }
126  }
127 
128  // Fire half-strip one-shots for hit_persist bx's (4 bx's by default).
129  pulseExtension(halfstrip);
130 
131  unsigned int start_bx = start_bx_shift;
132  // Stop drift_delay bx's short of fifo_tbins since at later bx's we will
133  // not have a full set of hits to start pattern search anyway.
134  unsigned int stop_bx = fifo_tbins - drift_delay;
135 
136  // Allow for more than one pass over the hits in the time window.
137  // Do search in every BX
138  while (start_bx < stop_bx) {
139  // temp CLCT objects
140  CSCCLCTDigi tempBestCLCT;
141  CSCCLCTDigi tempSecondCLCT;
142 
143  // All half-strip pattern envelopes are evaluated simultaneously, on every clock cycle.
144  int first_bx = 999;
145 
146  // Check for a pre-trigger. If so, find the first BX when the pre-trigger occurred
147  bool pre_trig = CSCUpgradeCathodeLCTProcessor::preTrigger(start_bx, first_bx);
148 
149  // If any of half-strip envelopes has enough layers hit in it, TMB
150  // will pre-trigger.
151  if (pre_trig) {
152  if (infoV > 1)
153  LogTrace("CSCUpgradeCathodeLCTProcessor")
154  << "..... pretrigger at bx = " << first_bx << "; waiting drift delay .....";
155 
156  // TMB latches LCTs drift_delay clocks after pretrigger.
157  int latch_bx = first_bx + drift_delay;
158 
159  // temporary container to keep track of the hits in the CLCT
160  std::map<int, std::map<int, CSCCLCTDigi::ComparatorContainer> > hits_in_patterns;
161  hits_in_patterns.clear();
162 
163  // We check if there is at least one key half strip for which at least
164  // one pattern id has at least the minimum number of hits
165  bool hits_in_time = patternFinding(latch_bx, hits_in_patterns);
166  if (infoV > 1) {
167  if (hits_in_time) {
168  for (int hstrip = stagger[CSCConstants::KEY_CLCT_LAYER - 1]; hstrip < numHalfStrips_; hstrip++) {
169  if (nhits[hstrip] > 0) {
170  LogTrace("CSCUpgradeCathodeLCTProcessor")
171  << " bx = " << std::setw(2) << latch_bx << " --->"
172  << " halfstrip = " << std::setw(3) << hstrip << " best pid = " << std::setw(2) << best_pid[hstrip]
173  << " nhits = " << nhits[hstrip];
174  }
175  }
176  }
177  }
178 
179  // Quality for sorting.
182  for (int ilct = 0; ilct < CSCConstants::MAX_CLCTS_PER_PROCESSOR; ilct++) {
183  best_halfstrip[ilct] = -1;
184  best_quality[ilct] = 0;
185  }
186 
188 
189  // Calculate quality from pattern id and number of hits, and
190  // simultaneously select best-quality CLCT.
191  if (hits_in_time) {
192  // first, mark half-strip zones around pretriggers
193  // that happened at the current first_bx
194  markPreTriggerZone(pretrig_zone);
195 
196  for (int hstrip = stagger[CSCConstants::KEY_CLCT_LAYER - 1]; hstrip < numHalfStrips_; hstrip++) {
197  /* The bend-direction bit pid[0] is ignored (left and right bends have equal quality).
198  This works both for the Run-2 patterns
199  - PID 2,3: 2 & 14 == 2, 3 & 14 == 2
200  - PID 4,5: 4 & 14 == 4, 3 & 14 == 4
201  - PID 6,7: 6 & 14 == 6, 3 & 14 == 6
202  - PID 8,9: 8 & 14 == 8, 3 & 14 == 8
203  - PID 10: 10 & 14 == 10
204  It also works for the Run-3 patterns:
205  - PID 0,1: 0 & 14 == 0, 1 & 14 == 0
206  - PID 2,3: 2 & 14 == 2, 3 & 14 == 2
207  - PID 4: 4 & 14 == 4
208  */
209  quality[hstrip] = (best_pid[hstrip] & 14) | (nhits[hstrip] << 5);
210  // do not consider halfstrips:
211  // - out of pretrigger-trigger zones
212  // - in busy zones from previous trigger
213  if (quality[hstrip] > best_quality[0] && pretrig_zone[hstrip] && !busyMap_[hstrip][first_bx]) {
214  best_halfstrip[0] = hstrip;
215  best_quality[0] = quality[hstrip];
216  // temporary alias
217  const int best_hs(best_halfstrip[0]);
218  const int best_pat(best_pid[best_hs]);
219  // construct a CLCT if the trigger condition has been met
220  if (best_hs >= 0 && nhits[best_hs] >= nplanes_hit_pattern) {
221  // overwrite the current best CLCT
222  tempBestCLCT = constructCLCT(first_bx, best_hs, hits_in_patterns[best_hs][best_pat]);
223  }
224  }
225  }
226  }
227 
228  // If 1st best CLCT is found, look for the 2nd best.
229  if (best_halfstrip[0] >= 0) {
230  // Get the half-strip of the best CLCT in this BX that was put into the list.
231  // You do need to re-add the any stagger, because the busy keys are based on
232  // the pulse array which takes into account strip stagger!!!
233  const unsigned halfStripBestCLCT(tempBestCLCT.getKeyStrip() + stagger[CSCConstants::KEY_CLCT_LAYER - 1]);
234 
235  // Mark keys near best CLCT as busy by setting their quality to
236  // zero, and repeat the search.
237  //markBusyKeys(best_halfstrip[0], best_pid[best_halfstrip[0]], quality);
238  markBusyKeys(halfStripBestCLCT, best_pid[halfStripBestCLCT], quality);
239 
240  for (int hstrip = stagger[CSCConstants::KEY_CLCT_LAYER - 1]; hstrip < numHalfStrips_; hstrip++) {
241  // we don't have to recalculate the quality for each half-strip
242  if (quality[hstrip] > best_quality[1] && pretrig_zone[hstrip] && !busyMap_[hstrip][first_bx]) {
243  best_halfstrip[1] = hstrip;
244  best_quality[1] = quality[hstrip];
245  // temporary alias
246  const int best_hs(best_halfstrip[1]);
247  const int best_pat(best_pid[best_hs]);
248  // construct a CLCT if the trigger condition has been met
249  if (best_hs >= 0 && nhits[best_hs] >= nplanes_hit_pattern) {
250  // overwrite the current second best CLCT
251  tempSecondCLCT = constructCLCT(first_bx, best_hs, hits_in_patterns[best_hs][best_pat]);
252  }
253  }
254  }
255 
256  // Sort bestCLCT and secondALCT by quality
257  // if qualities are the same, sort by run-2 or run-3 pattern
258  // if qualities and patterns are the same, sort by half strip number
259  bool changeOrder = false;
260 
261  unsigned qualityBest = 0, qualitySecond = 0;
262  unsigned patternBest = 0, patternSecond = 0;
263  unsigned halfStripBest = 0, halfStripSecond = 0;
264 
265  if (tempBestCLCT.isValid() and tempSecondCLCT.isValid()) {
266  qualityBest = tempBestCLCT.getQuality();
267  qualitySecond = tempSecondCLCT.getQuality();
268  if (!run3_) {
269  patternBest = tempBestCLCT.getPattern();
270  patternSecond = tempSecondCLCT.getPattern();
271  } else {
272  patternBest = tempBestCLCT.getRun3Pattern();
273  patternSecond = tempSecondCLCT.getRun3Pattern();
274  }
275  halfStripBest = tempBestCLCT.getKeyStrip();
276  halfStripSecond = tempSecondCLCT.getKeyStrip();
277 
278  if (qualitySecond > qualityBest)
279  changeOrder = true;
280  else if ((qualitySecond == qualityBest) and (int(patternSecond / 2) > int(patternBest / 2)))
281  changeOrder = true;
282  else if ((qualitySecond == qualityBest) and (int(patternSecond / 2) == int(patternBest / 2)) and
283  (halfStripSecond < halfStripBest))
284  changeOrder = true;
285  }
286 
287  CSCCLCTDigi tempCLCT;
288  if (changeOrder) {
289  tempCLCT = tempBestCLCT;
290  tempBestCLCT = tempSecondCLCT;
291  tempSecondCLCT = tempCLCT;
292  }
293 
294  // add the CLCTs to the collection
295  if (tempBestCLCT.isValid()) {
296  lctList.push_back(tempBestCLCT);
297  }
298  if (tempSecondCLCT.isValid()) {
299  lctList.push_back(tempSecondCLCT);
300  }
301  } //find CLCT, end of best_halfstrip[0] >= 0
302  } //pre_trig
303  // The pattern finder runs continuously, so another pre-trigger
304  // could occur already at the next bx.
305  start_bx = first_bx + 1;
306  }
307  return lctList;
308 } // findLCTs -- Phase2 version.
uint16_t getQuality() const
return quality of a pattern (number of layers hit!)
Definition: CSCCLCTDigi.h:56
void pulseExtension(const std::vector< int > time[CSCConstants::NUM_LAYERS][CSCConstants::MAX_NUM_HALF_STRIPS_RUN2_TRIGGER])
uint16_t getKeyStrip(const uint16_t n=2) const
Definition: CSCCLCTDigi.cc:107
bool patternFinding(const unsigned int bx_time, std::map< int, std::map< int, CSCCLCTDigi::ComparatorContainer > > &hits_in_patterns)
void markPreTriggerZone(bool pretrig_zone[CSCConstants::MAX_NUM_HALF_STRIPS_RUN2_TRIGGER]) const
#define LogTrace(id)
unsigned int nhits[CSCConstants::MAX_NUM_HALF_STRIPS_RUN2_TRIGGER]
bool isValid() const
check CLCT validity (1 - valid CLCT)
Definition: CSCCLCTDigi.h:50
void dumpDigis(const std::vector< int > strip[CSCConstants::NUM_LAYERS][CSCConstants::MAX_NUM_HALF_STRIPS_RUN2_TRIGGER]) const
virtual std::vector< CSCCLCTDigi > findLCTs(const std::vector< int > halfstrip[CSCConstants::NUM_LAYERS][CSCConstants::MAX_NUM_HALF_STRIPS_RUN2_TRIGGER])
void markBusyKeys(const int best_hstrip, const int best_patid, int quality[CSCConstants::MAX_NUM_HALF_STRIPS_RUN2_TRIGGER])
bool busyMap_[CSCConstants::MAX_NUM_HALF_STRIPS_RUN2_TRIGGER][CSCConstants::MAX_CLCT_TBINS]
int stagger[CSCConstants::NUM_LAYERS]
uint16_t getPattern() const
return pattern
Definition: CSCCLCTDigi.h:62
uint16_t getRun3Pattern() const
return pattern
Definition: CSCCLCTDigi.h:68
bool preTrigger(const int start_bx, int &first_bx) override
string quality
CSCCLCTDigi constructCLCT(const int bx, const unsigned halfstrip_withstagger, const CSCCLCTDigi::ComparatorContainer &hits)
unsigned int best_pid[CSCConstants::MAX_NUM_HALF_STRIPS_RUN2_TRIGGER]

◆ markBusyZone()

void CSCUpgradeCathodeLCTProcessor::markBusyZone ( const int  bx)
private

Definition at line 337 of file CSCUpgradeCathodeLCTProcessor.cc.

References busyMap_, simKBmtfDigis_cfi::bx, clct_state_machine_zone_, CSCBaseboard::infoV, CSCCathodeLCTProcessor::ispretrig_, CSCConstants::KEY_CLCT_LAYER, LogTrace, CSCCathodeLCTProcessor::numHalfStrips_, and CSCCathodeLCTProcessor::stagger.

Referenced by preTrigger().

337  {
338  for (int hstrip = stagger[CSCConstants::KEY_CLCT_LAYER - 1]; hstrip < numHalfStrips_; hstrip++) {
339  // check if this halfstrip has a pretrigger
340  if (ispretrig_[hstrip]) {
341  // only fixed localized dead time zone is implemented in firmware
342  int min_hstrip = hstrip - clct_state_machine_zone_;
343  int max_hstrip = hstrip + clct_state_machine_zone_;
344  // set the minimum strip
345  if (min_hstrip < stagger[CSCConstants::KEY_CLCT_LAYER - 1])
346  min_hstrip = stagger[CSCConstants::KEY_CLCT_LAYER - 1];
347  // set the maximum strip
348  if (max_hstrip >= numHalfStrips_)
349  max_hstrip = numHalfStrips_ - 1;
350  // mask the busy half-strips for 1 BX after the pretrigger
351  for (int hs = min_hstrip; hs <= max_hstrip; hs++)
352  busyMap_[hs][bx + 1] = true;
353  if (infoV > 1)
354  LogTrace("CSCUpgradeCathodeLCTProcessor")
355  << " marked zone around pretriggerred halfstrip " << hstrip << " as dead zone for pretriggering at bx"
356  << bx + 1 << " halfstrip: [" << min_hstrip << "," << max_hstrip << "]";
357  }
358  }
359 }
#define LogTrace(id)
bool busyMap_[CSCConstants::MAX_NUM_HALF_STRIPS_RUN2_TRIGGER][CSCConstants::MAX_CLCT_TBINS]
int stagger[CSCConstants::NUM_LAYERS]
bool ispretrig_[CSCConstants::MAX_NUM_HALF_STRIPS_RUN2_TRIGGER]

◆ markPreTriggerZone()

void CSCUpgradeCathodeLCTProcessor::markPreTriggerZone ( bool  pretrig_zone[CSCConstants::MAX_NUM_HALF_STRIPS_RUN2_TRIGGER]) const
private

Definition at line 310 of file CSCUpgradeCathodeLCTProcessor.cc.

References CSCBaseboard::infoV, CSCCathodeLCTProcessor::ispretrig_, LogTrace, CSCConstants::MAX_NUM_HALF_STRIPS_RUN2_TRIGGER, and pretrig_trig_zone_.

Referenced by findLCTs().

311  {
312  // first reset the pretrigger zone (no pretriggers anywhere in this BX
313  for (int hstrip = 0; hstrip < CSCConstants::MAX_NUM_HALF_STRIPS_RUN2_TRIGGER; hstrip++) {
314  pretrig_zone[hstrip] = false;
315  }
316  // then set the pretrigger zone according to the ispretrig_ array
317  for (int hstrip = 0; hstrip < CSCConstants::MAX_NUM_HALF_STRIPS_RUN2_TRIGGER; hstrip++) {
318  if (ispretrig_[hstrip]) {
319  int min_hs = hstrip - pretrig_trig_zone_;
320  int max_hs = hstrip + pretrig_trig_zone_;
321  // set the minimum strip
322  if (min_hs < 0)
323  min_hs = 0;
324  // set the maximum strip
327  // mark the pre-trigger zone
328  for (int hs = min_hs; hs <= max_hs; hs++)
329  pretrig_zone[hs] = true;
330  if (infoV > 1)
331  LogTrace("CSCUpgradeCathodeLCTProcessor")
332  << " marked pretrigger halfstrip zone [" << min_hs << "," << max_hs << "]";
333  }
334  }
335 }
#define LogTrace(id)
bool ispretrig_[CSCConstants::MAX_NUM_HALF_STRIPS_RUN2_TRIGGER]

◆ preTrigger()

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

Reimplemented from CSCCathodeLCTProcessor.

Definition at line 29 of file CSCUpgradeCathodeLCTProcessor.cc.

References CSCCathodeLCTProcessor::best_pid, busyMap_, CSCCathodeLCTProcessor::clearPreTriggers(), CSCCathodeLCTProcessor::constructPreCLCT(), CSCCathodeLCTProcessor::fifo_tbins, CSCBaseboard::infoV, CSCCathodeLCTProcessor::ispretrig_, CSCConstants::KEY_CLCT_LAYER, LogTrace, markBusyZone(), CSCCathodeLCTProcessor::nhits, CSCCathodeLCTProcessor::nplanes_hit_pretrig, CSCCathodeLCTProcessor::numHalfStrips_, CSCCathodeLCTProcessor::patternFinding(), CSCCathodeLCTProcessor::pid_thresh_pretrig, CSCCathodeLCTProcessor::preTrigger(), CSCBaseboard::runPhase2_, CSCCathodeLCTProcessor::stagger, CSCCathodeLCTProcessor::thePreTriggerDigis, and use_dead_time_zoning_.

Referenced by findLCTs().

29  {
31  return CSCCathodeLCTProcessor::preTrigger(start_bx, first_bx);
32  }
33 
34  if (infoV > 1)
35  LogTrace("CSCUpgradeCathodeLCTProcessor")
36  << "....................PreTrigger, Phase2 version with localized dead time zone...........................";
37 
38  int nPreTriggers = 0;
39 
40  bool pre_trig = false;
41 
42  // Now do a loop over bx times to see (if/when) track goes over threshold
43  for (unsigned int bx_time = start_bx; bx_time < fifo_tbins; bx_time++) {
44  // For any given bunch-crossing, start at the lowest keystrip and look for
45  // the number of separate layers in the pattern for that keystrip that have
46  // pulses at that bunch-crossing time. Do the same for the next keystrip,
47  // etc. Then do the entire process again for the next bunch-crossing, etc
48  // until you find a pre-trigger.
49  std::map<int, std::map<int, CSCCLCTDigi::ComparatorContainer> > hits_in_patterns;
50  hits_in_patterns.clear();
51 
52  bool hits_in_time = patternFinding(bx_time, hits_in_patterns);
53  if (hits_in_time) {
54  for (int hstrip = stagger[CSCConstants::KEY_CLCT_LAYER - 1]; hstrip < numHalfStrips_; hstrip++) {
55  if (infoV > 1) {
56  if (nhits[hstrip] > 0) {
57  LogTrace("CSCUpgradeCathodeLCTProcessor")
58  << " bx = " << std::setw(2) << bx_time << " --->"
59  << " halfstrip = " << std::setw(3) << hstrip << " best pid = " << std::setw(2) << best_pid[hstrip]
60  << " nhits = " << nhits[hstrip];
61  }
62  }
63  // note that ispretrig_ is initialized in findLCT function
64  if (nhits[hstrip] >= nplanes_hit_pretrig && best_pid[hstrip] >= pid_thresh_pretrig &&
65  !busyMap_[hstrip][bx_time]) {
66  pre_trig = true;
67  ispretrig_[hstrip] = true;
68 
69  // write each pre-trigger to output
70  nPreTriggers++;
71  thePreTriggerDigis.push_back(constructPreCLCT(bx_time, hstrip, nPreTriggers));
72  }
73  // busy zone, keep pretriggering, ignore this
74  else if (nhits[hstrip] >= nplanes_hit_pretrig && best_pid[hstrip] >= pid_thresh_pretrig) {
75  ispretrig_[hstrip] = true;
76  if (infoV > 1)
77  LogTrace("CSCUpgradeCathodeLCTProcessor")
78  << " halfstrip " << std::setw(3) << hstrip << " in dead zone and is pretriggerred";
79  }
80  // no pretrigger on this halfstrip, release dead zone
81  else if (nhits[hstrip] < nplanes_hit_pretrig || best_pid[hstrip] < pid_thresh_pretrig) {
82  ispretrig_[hstrip] = false;
83  }
84  } // find all pretriggers
85 
86  // update dead zone
87  markBusyZone(bx_time);
88 
89  if (pre_trig) {
90  first_bx = bx_time; // bx at time of pretrigger
91  return true;
92  }
93  } else {
94  // no pattern found, remove all dead zone
96  }
97  } // end loop over bx times
98 
99  if (infoV > 1)
100  LogTrace("CSCUpgradeCathodeLCTProcessor") << "no pretrigger, returning \n";
101  first_bx = fifo_tbins;
102  return false;
103 } // preTrigger -- Phase2 version.
bool patternFinding(const unsigned int bx_time, std::map< int, std::map< int, CSCCLCTDigi::ComparatorContainer > > &hits_in_patterns)
#define LogTrace(id)
unsigned int nhits[CSCConstants::MAX_NUM_HALF_STRIPS_RUN2_TRIGGER]
CSCCLCTPreTriggerDigi constructPreCLCT(const int bx, const unsigned halfstrip, const unsigned index) const
std::vector< CSCCLCTPreTriggerDigi > thePreTriggerDigis
bool busyMap_[CSCConstants::MAX_NUM_HALF_STRIPS_RUN2_TRIGGER][CSCConstants::MAX_CLCT_TBINS]
int stagger[CSCConstants::NUM_LAYERS]
virtual bool preTrigger(const int start_bx, int &first_bx)
bool ispretrig_[CSCConstants::MAX_NUM_HALF_STRIPS_RUN2_TRIGGER]
unsigned int best_pid[CSCConstants::MAX_NUM_HALF_STRIPS_RUN2_TRIGGER]

Member Data Documentation

◆ busyMap_

bool CSCUpgradeCathodeLCTProcessor::busyMap_[CSCConstants::MAX_NUM_HALF_STRIPS_RUN2_TRIGGER][CSCConstants::MAX_CLCT_TBINS]
private

Definition at line 51 of file CSCUpgradeCathodeLCTProcessor.h.

Referenced by findLCTs(), markBusyZone(), and preTrigger().

◆ clct_state_machine_zone_

unsigned int CSCUpgradeCathodeLCTProcessor::clct_state_machine_zone_
private

Definition at line 58 of file CSCUpgradeCathodeLCTProcessor.h.

Referenced by CSCUpgradeCathodeLCTProcessor(), and markBusyZone().

◆ pretrig_trig_zone_

unsigned int CSCUpgradeCathodeLCTProcessor::pretrig_trig_zone_
private

VK: allow triggers only in +-pretrig_trig_zone around pretriggers

Definition at line 61 of file CSCUpgradeCathodeLCTProcessor.h.

Referenced by CSCUpgradeCathodeLCTProcessor(), and markPreTriggerZone().

◆ use_dead_time_zoning_

bool CSCUpgradeCathodeLCTProcessor::use_dead_time_zoning_
private

VK: use of localized dead-time zones

Definition at line 54 of file CSCUpgradeCathodeLCTProcessor.h.

Referenced by CSCUpgradeCathodeLCTProcessor(), findLCTs(), and preTrigger().