CSCCathodeLCTProcessor.h

Go to the documentation of this file.

#ifndef L1Trigger_CSCTriggerPrimitives_CSCCathodeLCTProcessor_h
#define L1Trigger_CSCTriggerPrimitives_CSCCathodeLCTProcessor_h
 
#include "DataFormats/CSCDigi/interface/CSCComparatorDigiCollection.h"
#include "DataFormats/CSCDigi/interface/CSCCLCTDigi.h"
#include "DataFormats/CSCDigi/interface/CSCCLCTPreTriggerDigi.h"
#include "L1Trigger/CSCTriggerPrimitives/interface/CSCBaseboard.h"
#include "L1Trigger/CSCTriggerPrimitives/interface/CSCComparatorCodeLUT.h"
#include "L1Trigger/CSCTriggerPrimitives/interface/LCTQualityControl.h"
 
#include <vector>
#include <array>
#include <string>
 
class CSCCathodeLCTProcessor : public CSCBaseboard {
public:
  CSCCathodeLCTProcessor(unsigned endcap,
                         unsigned station,
                         unsigned sector,
                         unsigned subsector,
                         unsigned chamber,
                         const edm::ParameterSet& conf);
 
  CSCCathodeLCTProcessor();
 
  ~CSCCathodeLCTProcessor() override = default;
 
  void setConfigParameters(const CSCDBL1TPParameters* conf);
 
  void clear();
 
  std::vector<CSCCLCTDigi> run(const CSCComparatorDigiCollection* compdc);
 
  void run(const std::vector<int> halfstrip[CSCConstants::NUM_LAYERS][CSCConstants::NUM_HALF_STRIPS_7CFEBS]);
 
  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> getCLCTs(unsigned nMaxCLCTs = CSCConstants::MAX_CLCTS_PER_PROCESSOR) const;
 
  CSCCLCTDigi getBestCLCT(int bx) const;
  CSCCLCTDigi getSecondCLCT(int bx) const;
 
  std::vector<int> preTriggerBXs() const { return thePreTriggerBXs; }
 
  std::vector<CSCCLCTPreTriggerDigi> preTriggerDigis() const { return thePreTriggerDigis; }
  std::vector<CSCCLCTPreTriggerDigi> preTriggerDigisME1a() const;
  std::vector<CSCCLCTPreTriggerDigi> preTriggerDigisME1b() const;
 
protected:
  CSCCLCTDigi bestCLCT[CSCConstants::MAX_CLCT_TBINS];
 
  CSCCLCTDigi secondCLCT[CSCConstants::MAX_CLCT_TBINS];
 
  // unique pointers to the luts
  std::array<std::unique_ptr<CSCComparatorCodeLUT>, 5> lutpos_;
  std::array<std::unique_ptr<CSCComparatorCodeLUT>, 5> lutslope_;
  std::array<std::unique_ptr<CSCComparatorCodeLUT>, 5> lutpatconv_;
 
  bool getDigis(const CSCComparatorDigiCollection* compdc);
  void getDigis(const CSCComparatorDigiCollection* compdc, const CSCDetId& id);
 
  void setDefaultConfigParameters();
 
  void checkConfigParameters();
 
  typedef unsigned int PulseArray[CSCConstants::NUM_LAYERS][CSCConstants::NUM_HALF_STRIPS_7CFEBS];
 
  //---------------- Methods common to all firmware versions ------------------
  // Single-argument version for TMB07 (halfstrip-only) firmware.
  // Takes the comparator & time info and stuffs it into halfstrip vector.
  // Multiple hits on the same strip are allowed.
  void readComparatorDigis(std::vector<int> halfstrip[CSCConstants::NUM_LAYERS][CSCConstants::NUM_HALF_STRIPS_7CFEBS]);
  void pulseExtension(const std::vector<int> time[CSCConstants::NUM_LAYERS][CSCConstants::NUM_HALF_STRIPS_7CFEBS],
                      PulseArray pulse);
 
  //--------------- Functions for post-2007 version of the firmware -----------
  virtual std::vector<CSCCLCTDigi> findLCTs(
      const std::vector<int> halfstrip[CSCConstants::NUM_LAYERS][CSCConstants::NUM_HALF_STRIPS_7CFEBS]);
 
  /* Check all half-strip pattern envelopes simultaneously, on every clock cycle, for a matching pattern */
  virtual bool preTrigger(const PulseArray pulse, const int start_bx, int& first_bx);
 
  /* For a given clock cycle, check each half-strip if a pattern matches */
  bool patternFinding(const PulseArray pulse,
                      const unsigned int bx_time,
                      std::map<int, std::map<int, CSCCLCTDigi::ComparatorContainer> >& hits_in_patterns);
 
  // enum used in the comparator code logic
  enum CLCT_CompCode { INVALID_HALFSTRIP = 65535 };
 
  void cleanComparatorContainer(CSCCLCTDigi& lct) const;
 
  /* Mark the half-strips around the best half-strip as busy */
  void markBusyKeys(const int best_hstrip, const int best_patid, int quality[CSCConstants::NUM_HALF_STRIPS_7CFEBS]);
 
  //--------------------------- Auxiliary methods -----------------------------
  void dumpConfigParams() const;
 
  void dumpDigis(const std::vector<int> strip[CSCConstants::NUM_LAYERS][CSCConstants::NUM_HALF_STRIPS_7CFEBS]) const;
 
  // --------Functions for the comparator code algorith for Run-3 ---------//
  //calculates the id based on location of hits
  int calculateComparatorCode(const std::array<std::array<int, 3>, 6>& halfStripPattern) const;
 
  // sets the 1/4 and 1/8 strip bits given a floating point position offset
  void assignPositionCC(const unsigned offset, std::tuple<int16_t, bool, bool>& returnValue) const;
 
  // runs the CCLUT procedure
  void runCCLUT(CSCCLCTDigi& digi) const;
 
  unsigned convertSlopeToRun2Pattern(const unsigned slope) const;
  //--------------------------- Member variables -----------------------------
 
  /* best pattern Id for a given half-strip */
  unsigned int best_pid[CSCConstants::NUM_HALF_STRIPS_7CFEBS];
 
  /* number of layers hit on a given half-strip */
  unsigned int nhits[CSCConstants::NUM_HALF_STRIPS_7CFEBS];
 
  int first_bx_corrected[CSCConstants::NUM_HALF_STRIPS_7CFEBS];
 
  /* does a given half-strip have a pre-trigger? */
  bool ispretrig[CSCConstants::NUM_HALF_STRIPS_7CFEBS];
 
  // actual LUT used
  CSCPatternBank::LCTPatterns clct_pattern_ = {};
 
  // we use these next ones to address the various bits inside the array that's
  // used to make the cathode LCTs.
  enum CLCT_INDICES {
    CLCT_PATTERN,
    CLCT_BEND,
    CLCT_STRIP,
    CLCT_BX,
    CLCT_STRIP_TYPE,
    CLCT_QUALITY,
    CLCT_CFEB,
    CLCT_NUM_QUANTITIES = 7
  };
 
  /* number of strips used in this processor */
  int numStrips_;
  int numCFEBs_;
  int numHalfStrips_;
 
  /* Is the layer in the chamber staggered? */
  int stagger[CSCConstants::NUM_LAYERS];
 
  std::vector<CSCComparatorDigi> digiV[CSCConstants::NUM_LAYERS];
  std::vector<int> thePreTriggerBXs;
  std::vector<CSCCLCTPreTriggerDigi> thePreTriggerDigis;
 
  unsigned int fifo_tbins, fifo_pretrig;  // only for test beam mode.
  unsigned int hit_persist, drift_delay;
  unsigned int nplanes_hit_pretrig, nplanes_hit_pattern;
  unsigned int pid_thresh_pretrig, min_separation;
  unsigned int tmb_l1a_window_size;
 
  int start_bx_shift;
 
  int early_tbins;
 
  bool readout_earliest_2;
 
  static const unsigned int def_fifo_tbins, def_fifo_pretrig;
  static const unsigned int def_hit_persist, def_drift_delay;
  static const unsigned int def_nplanes_hit_pretrig;
  static const unsigned int def_nplanes_hit_pattern;
  static const unsigned int def_pid_thresh_pretrig, def_min_separation;
  static const unsigned int def_tmb_l1a_window_size;
 
  std::vector<std::string> positionLUTFiles_;
  std::vector<std::string> slopeLUTFiles_;
  std::vector<std::string> patternConversionLUTFiles_;
 
  /* quality control */
  std::unique_ptr<LCTQualityControl> qualityControl_;
};
 
#endif