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 "DataFormats/CSCDigi/interface/CSCShowerDigi.h"
#include "CondFormats/CSCObjects/interface/CSCDBL1TPParameters.h"
#include "L1Trigger/CSCTriggerPrimitives/interface/CSCBaseboard.h"
#include "L1Trigger/CSCTriggerPrimitives/interface/LCTQualityControl.h"
#include "L1Trigger/CSCTriggerPrimitives/interface/PulseArray.h"

#include <vector>

class CSCAnodeLCTProcessor : public CSCBaseboard {
public:
  CSCAnodeLCTProcessor(unsigned endcap,
                       unsigned station,
                       unsigned sector,
                       unsigned subsector,
                       unsigned chamber,
                       const edm::ParameterSet& conf);

  ~CSCAnodeLCTProcessor() override = default;

  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_WIREGROUPS]);

  std::vector<CSCALCTDigi> readoutALCTs() const;

  std::vector<CSCALCTDigi> getALCTs() const;

  std::vector<CSCALCTPreTriggerDigi> preTriggerDigis() const { return thePreTriggerDigis; }

  CSCALCTDigi getBestALCT(int bx) const;
  CSCALCTDigi getSecondALCT(int bx) const;

  /* get special bits for high multiplicity triggers */
  unsigned getInTimeHMT() const { return inTimeHMT_; }
  unsigned getOutTimeHMT() const { return outTimeHMT_; }

  CSCShowerDigi readoutShower() const;

protected:
  CSCALCTDigi bestALCT[CSCConstants::MAX_ALCT_TBINS];

  CSCALCTDigi secondALCT[CSCConstants::MAX_ALCT_TBINS];

  PulseArray pulse_;

  CSCShowerDigi shower_;

  bool getDigis(const CSCWireDigiCollection* wiredc);
  void getDigis(const CSCWireDigiCollection* wiredc, const CSCDetId& id);

  int numWireGroups;
  int MESelection;

  int first_bx[CSCConstants::MAX_NUM_WIREGROUPS];
  int first_bx_corrected[CSCConstants::MAX_NUM_WIREGROUPS];

  int quality[CSCConstants::MAX_NUM_WIREGROUPS][CSCConstants::NUM_ALCT_PATTERNS];
  std::vector<CSCWireDigi> digiV[CSCConstants::NUM_LAYERS];

  std::vector<CSCALCTDigi> lct_list;

  std::vector<CSCALCTPreTriggerDigi> thePreTriggerDigis;

  /* data members for high multiplicity triggers */
  void encodeHighMultiplicityBits(
      const std::vector<int> wire[CSCConstants::NUM_LAYERS][CSCConstants::MAX_NUM_WIREGROUPS]);
  unsigned inTimeHMT_;
  unsigned outTimeHMT_;
  std::vector<unsigned> thresholds_;
  unsigned showerMinInTBin_;
  unsigned showerMaxInTBin_;
  unsigned showerMinOutTBin_;
  unsigned showerMaxOutTBin_;
  unsigned minLayersCentralTBin_;

  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;

  /* quality control */
  std::unique_ptr<LCTQualityControl> qualityControl_;

  CSCPatternBank::LCTPatterns alct_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_WIREGROUPS]);

  /* 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_WIREGROUPS]);

  /* 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,
                        std::map<int, std::map<int, CSCALCTDigi::WireContainer> >& hits_in_patterns);

  // remove the invalid wires from the container
  void cleanWireContainer(CSCALCTDigi::WireContainer& wireHits) const;

  //  set the wire hit container
  void setWireContainer(CSCALCTDigi&, CSCALCTDigi::WireContainer& wireHits) const;

  /* In older versions of the ALCT emulation, the ghost cancellation was performed after
     the ALCTs were found. In December 2018 it became clear that during the study of data
     and emulation comparison on 2018 data, a small disagreement between data and emulation
     was found. The changes we implemented then allow re-triggering on one wiregroup after
     some dead time once an earlier ALCT was constructed built on this wiregroup. Before this
     commit the ALCT processor would prohibit the wiregroup from triggering in one event after
     an ALCT was found on that wiregroup. In the firwmare, the wiregroup with ALCT is only dead
     for a few BX before it can be triggered by next muon. The implementation of ghost cancellation
     logic wqas changed to accommodate the re-triggering change while the idea of the ghost
     cancellation logic is kept the same.
  */
  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_WIREGROUPS]) const;

  void showPatterns(const int key_wire);
};

#endif