CSCAnodeLCTProcessor.h

Go to the documentation of this file.

#ifndef L1Trigger_CSCTriggerPrimitives_CSCAnodeLCTProcessor_h
#define L1Trigger_CSCTriggerPrimitives_CSCAnodeLCTProcessor_h
 
#include "DataFormats/CSCDigi/interface/CSCWireDigiCollection.h"
#include "DataFormats/CSCDigi/interface/CSCALCTDigi.h"
#include "DataFormats/CSCDigi/interface/CSCALCTPreTriggerDigi.h"
#include "CondFormats/CSCObjects/interface/CSCDBL1TPParameters.h"
#include "L1Trigger/CSCTriggerPrimitives/interface/CSCBaseboard.h"
 
#include <vector>
 
class CSCAnodeLCTProcessor : public CSCBaseboard {
public:
  CSCAnodeLCTProcessor(unsigned endcap,
                       unsigned station,
                       unsigned sector,
                       unsigned subsector,
                       unsigned chamber,
                       const edm::ParameterSet& conf);
 
  CSCAnodeLCTProcessor();
 
  void setConfigParameters(const CSCDBL1TPParameters* conf);
 
  void clear();
 
  // This is the main routine for normal running.  It gets wire times
  // from the wire digis and then passes them on to another run() function.
  std::vector<CSCALCTDigi> run(const CSCWireDigiCollection* wiredc);
 
  // This version of the run() function can either be called in a standalone
  // test, being passed the time array, or called by the run() function above.
  // It gets wire times from an input array and then loops over the keywires.
  // All found LCT candidates are sorted and the best two are retained.
  void run(const std::vector<int> wire[CSCConstants::NUM_LAYERS][CSCConstants::MAX_NUM_WIRES]);
 
  std::vector<CSCALCTDigi> readoutALCTs(int nMaxALCTs = CSCConstants::MAX_ALCTS_READOUT) const;
 
  std::vector<CSCALCTDigi> getALCTs(unsigned nMaxALCTs = CSCConstants::MAX_ALCTS_READOUT) const;
 
  std::vector<CSCALCTPreTriggerDigi> preTriggerDigis() const { return thePreTriggerDigis; }
 
  CSCALCTDigi getBestALCT(int bx) const;
  CSCALCTDigi getSecondALCT(int bx) const;
 
  /* encode special bits for high multiplicity triggers */
  unsigned getHighMultiplictyBits() const { return highMultiplicityBits_; }
 
protected:
  CSCALCTDigi bestALCT[CSCConstants::MAX_ALCT_TBINS];
 
  CSCALCTDigi secondALCT[CSCConstants::MAX_ALCT_TBINS];
 
  std::vector<std::vector<CSCALCTDigi> > ALCTContainer_;
 
  bool getDigis(const CSCWireDigiCollection* wiredc);
  void getDigis(const CSCWireDigiCollection* wiredc, const CSCDetId& id);
 
  int numWireGroups;
  int MESelection;
 
  int first_bx[CSCConstants::MAX_NUM_WIRES];
  int first_bx_corrected[CSCConstants::MAX_NUM_WIRES];
  int quality[CSCConstants::MAX_NUM_WIRES][3];
  std::vector<CSCWireDigi> digiV[CSCConstants::NUM_LAYERS];
  unsigned int pulse[CSCConstants::NUM_LAYERS][CSCConstants::MAX_NUM_WIRES];
 
  std::vector<CSCALCTDigi> lct_list;
 
  std::vector<CSCALCTPreTriggerDigi> thePreTriggerDigis;
 
  /* data members for high multiplicity triggers */
  void encodeHighMultiplicityBits();
  unsigned int highMultiplicityBits_;
 
  unsigned int fifo_tbins, fifo_pretrig, drift_delay;
  unsigned int nplanes_hit_pretrig, nplanes_hit_accel_pretrig;
  unsigned int nplanes_hit_pattern, nplanes_hit_accel_pattern;
  unsigned int trig_mode, accel_mode, l1a_window_width;
 
  unsigned int hit_persist;
 
  int early_tbins;
 
  int ghost_cancellation_bx_depth;
 
  bool ghost_cancellation_side_quality;
 
  unsigned int pretrig_extra_deadtime;
 
  bool use_corrected_bx;
 
  bool narrow_mask_r1;
 
  static const unsigned int def_fifo_tbins, def_fifo_pretrig;
  static const unsigned int def_drift_delay;
  static const unsigned int def_nplanes_hit_pretrig, def_nplanes_hit_pattern;
  static const unsigned int def_nplanes_hit_accel_pretrig;
  static const unsigned int def_nplanes_hit_accel_pattern;
  static const unsigned int def_trig_mode, def_accel_mode;
  static const unsigned int def_l1a_window_width;
 
  int pattern_mask[CSCConstants::NUM_ALCT_PATTERNS][CSCConstants::MAX_WIRES_IN_PATTERN];
 
  void loadPatternMask();
 
  void setDefaultConfigParameters();
 
  void checkConfigParameters();
 
  void clear(const int wire, const int pattern);
 
  /* Gets wire times from the wire digis and fills wire[][] vector */
  void readWireDigis(std::vector<int> wire[CSCConstants::NUM_LAYERS][CSCConstants::MAX_NUM_WIRES]);
 
  /* A pulse array will be used as a bit representation of hit times.
     For example: if a keywire has a bx_time of 3, then 1 shifted
     left 3 will be bit pattern 0000000000001000.  Bits are then added to
     signify the duration of a signal (hit_persist, formerly bx_width).  So
     for the pulse with a hit_persist of 6 will look like 0000000111111000. */
  bool pulseExtension(const std::vector<int> wire[CSCConstants::NUM_LAYERS][CSCConstants::MAX_NUM_WIRES]);
 
  /* Check that there are nplanes_hit_pretrig or more layers hit in collision
     or accelerator patterns for a particular key_wire.  If so, return
     true and the PatternDetection process will start. */
  bool preTrigger(const int key_wire, const int start_bx);
 
  /* See if there is a pattern that satisfies nplanes_hit_pattern number of
     layers hit for either the accelerator or collision patterns.  Use
     the pattern with the best quality. */
  bool patternDetection(const int key_wire);
 
  /* This function looks for LCTs on the previous and next wires.  If one
     exists and it has a better quality and a bx_time up to 4 clocks earlier
     than the present, then the present LCT is cancelled.  The present LCT
     also gets cancelled if it has the same quality as the one on the
     previous wire (this has not been done in 2003 test beam).  The
     cancellation is done separately for collision and accelerator patterns. */
  virtual void ghostCancellationLogic();
 
  virtual void ghostCancellationLogicOneWire(const int key_wire, int* ghost_cleared);
 
  virtual int getTempALCTQuality(int temp_quality) const;
 
  void lctSearch();
  /* Function which enables/disables either collision or accelerator tracks.
     The function uses the trig_mode parameter to decide. */
  void trigMode(const int key_wire);
 
  /* Function which gives a preference either to the collision patterns
     or accelerator patterns.  The function uses the accel_mode parameter
     to decide. */
  void accelMode(const int key_wire);
 
  /* Selects two collision and two accelerator ALCTs per time bin with
     the best quality. */
  std::vector<CSCALCTDigi> bestTrackSelector(const std::vector<CSCALCTDigi>& all_alcts);
 
  /* This method should have been an overloaded > operator, but we
     have to keep it here since need to check values in quality[][]
     array modified according to accel_mode parameter. */
  bool isBetterALCT(const CSCALCTDigi& lhsALCT, const CSCALCTDigi& rhsALCT) const;
 
  void dumpConfigParams() const;
 
  void dumpDigis(const std::vector<int> wire[CSCConstants::NUM_LAYERS][CSCConstants::MAX_NUM_WIRES]) const;
 
  // Check if the ALCT is valid
  void checkValidReadout(const CSCALCTDigi& alct) const;
  void checkValid(const CSCALCTDigi& alct, unsigned max_stubs = CSCConstants::MAX_ALCTS_PER_PROCESSOR) const;
 
  void showPatterns(const int key_wire);
};
 
#endif