CSCAnodeLCTProcessor.h

Go to the documentation of this file.

#ifndef L1Trigger_CSCTriggerPrimitives_CSCAnodeLCTProcessor_h
#define L1Trigger_CSCTriggerPrimitives_CSCAnodeLCTProcessor_h

#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "DataFormats/CSCDigi/interface/CSCWireDigiCollection.h"
#include "DataFormats/CSCDigi/interface/CSCALCTDigi.h"
#include "CondFormats/CSCObjects/interface/CSCDBL1TPParameters.h"
#include "L1Trigger/CSCCommonTrigger/interface/CSCConstants.h"

#include <vector>

class CSCGeometry;

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

  CSCAnodeLCTProcessor();

  void setConfigParameters(const CSCDBL1TPParameters* conf);

  void clear();

  void setCSCGeometry(const CSCGeometry *g) { csc_g = g; }

  std::vector<CSCALCTDigi> run(const CSCWireDigiCollection* wiredc);

  void run(const std::vector<int> wire[CSCConstants::NUM_LAYERS][CSCConstants::MAX_NUM_WIRES]);

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

  CSCALCTDigi bestALCT[CSCConstants::MAX_ALCT_TBINS];

  CSCALCTDigi secondALCT[CSCConstants::MAX_ALCT_TBINS];

  std::vector<CSCALCTDigi> readoutALCTs();

  std::vector<CSCALCTDigi> getALCTs();

  void setRing(unsigned r) {theRing = r;}

  static const int pattern_envelope[CSCConstants::NUM_ALCT_PATTERNS][CSCConstants::MAX_WIRES_IN_PATTERN];
  static const int pattern_mask_slim[CSCConstants::NUM_ALCT_PATTERNS][CSCConstants::MAX_WIRES_IN_PATTERN];
  static const int pattern_mask_open[CSCConstants::NUM_ALCT_PATTERNS][CSCConstants::MAX_WIRES_IN_PATTERN];
  static const int pattern_mask_r1[CSCConstants::NUM_ALCT_PATTERNS][CSCConstants::MAX_WIRES_IN_PATTERN];
  static const int time_weights[CSCConstants::MAX_WIRES_IN_PATTERN];

 private:
  int infoV;

  const unsigned theEndcap;
  const unsigned theStation;
  const unsigned theSector;
  const unsigned theSubsector;
  const unsigned theTrigChamber;

  const CSCGeometry* csc_g;

  unsigned theRing;

  unsigned theChamber;

  bool isME11;

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

  bool isMTCC;

  bool isTMB07;

  bool isSLHC;

  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;

  bool disableME1a;

  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;

  bool runME21ILT_;

  bool runME3141ILT_;

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

  void readWireDigis(std::vector<int> wire[CSCConstants::NUM_LAYERS][CSCConstants::MAX_NUM_WIRES]);
  bool pulseExtension(const std::vector<int> wire[CSCConstants::NUM_LAYERS][CSCConstants::MAX_NUM_WIRES]);
  bool preTrigger(const int key_wire, const int start_bx);
  bool patternDetection(const int key_wire);
  void ghostCancellationLogic();
  void ghostCancellationLogicSLHC();
  void lctSearch();
  void trigMode(const int key_wire);
  void accelMode(const int key_wire);

  std::vector<CSCALCTDigi>
    bestTrackSelector(const std::vector<CSCALCTDigi>& all_alcts);
  bool isBetterALCT(const CSCALCTDigi& lhsALCT, const CSCALCTDigi& rhsALCT);

  void dumpConfigParams() const;

  void dumpDigis(const std::vector<int> wire[CSCConstants::NUM_LAYERS][CSCConstants::MAX_NUM_WIRES]) const;

  void showPatterns(const int key_wire);
};

#endif