DTConfigTSPhi.h

Go to the documentation of this file.

//-------------------------------------------------
//
//
//--------------------------------------------------
#ifndef DT_CONFIG_TSPHI_H
#define DT_CONFIG_TSPHI_H

//---------------
// C++ Headers --
//---------------

//----------------------
// Base Class Headers --
//----------------------

//------------------------------------
// Collaborating Class Declarations --
//------------------------------------
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "L1TriggerConfig/DTTPGConfig/interface/BitArray.h"
#include "L1TriggerConfig/DTTPGConfig/interface/DTConfig.h"

//              ---------------------
//              -- Class Interface --
//              ---------------------

class DTConfigTSPhi : public DTConfig {
public:
  static const int NTSSTSM = 7;

  static const int NTSMD = 2;

  static const int NTSSTSMD = 3;

  DTConfigTSPhi(const edm::ParameterSet& ps);

  DTConfigTSPhi(){};

  DTConfigTSPhi(bool debug, unsigned short int tss_buffer[7][31], int ntss, unsigned short int tsm_buffer[9]);

  ~DTConfigTSPhi() override;

  inline bool debug() const { return m_debug; }

  inline int TssMasking(int i) const { return (int)m_tssmsk[i]; }

  inline bool TssHtrigEna(int i) const { return m_tsshte[i]; }

  inline bool TssHtrigEnaCarry() const { return m_tsshte[2]; }

  inline bool TssInOutEna(int i) const { return m_tssnoe[i]; }

  inline bool TssInOutEnaCarry() const { return m_tssnoe[2]; }

  inline bool TssCorrEna(int i) const { return m_tsscce[i]; }

  inline bool TssCorrEnaCarry() const { return m_tsscce[2]; }

  inline int TsmMasking(int i) const { return (int)m_tsmmsk[i]; }

  inline bool TsmHtrigEna(int i) const { return m_tsmhte[i]; }

  inline bool TsmHtrigEnaCarry() const { return m_tsmhte[2]; }

  inline bool TsmInOutEna(int i) const { return m_tsmnoe[i]; }

  inline bool TsmInOutEnaCarry() const { return m_tsmnoe[2]; }

  inline bool TsmCorrEna(int i) const { return m_tsmcce[i]; }

  inline bool TsmCorrEnaCarry() const { return m_tsmcce[2]; }

  inline int TssGhost1Flag() const { return (int)m_tssgs1; }

  inline int TssGhost2Flag() const { return (int)m_tssgs2; }

  inline int TsmGhost1Flag() const { return (int)m_tsmgs1; }

  inline int TsmGhost2Flag() const { return (int)m_tsmgs2; }

  inline bool TssGhost1Corr() const { return m_tsscgs1; }

  inline bool TssGhost2Corr() const { return m_tsscgs2; }

  inline bool TsmGhost1Corr() const { return m_tsmcgs1; }

  inline bool TsmGhost2Corr() const { return m_tsmcgs2; }

  inline int TsmGetCarryFlag() const { return (int)m_tsmhsp; }

  inline bool usedTraco(int i) const { return (bool)m_tstren.element(i - 1); }

  inline BitArray<8> TsmStatus() const { return m_tsmword; };

  // DBSM-doubleTSM
  int TSSinTSMD(int stat, int sect) const;

  // Set Methods
  inline void setDebug(bool debug) { m_debug = debug; }

  void setTssMasking(unsigned short int tssmsk, int i) { m_tssmsk[i - 1] = tssmsk; }

  inline void setTssHtrigEna(bool tsshte, int i) { m_tsshte[i - 1] = tsshte; }

  inline void setTssHtrigEnaCarry(bool tsshte) { m_tsshte[2] = tsshte; }

  inline void setTssInOutEna(bool tssnoe, int i) { m_tssnoe[i - 1] = tssnoe; }

  inline void setTssInOutEnaCarry(bool tssnoe) { m_tssnoe[2] = tssnoe; }

  inline void setTssCorrEna(bool tsscce, int i) { m_tsscce[i - 1] = tsscce; }

  inline void setTssCorrEnaCarry(bool tsscce) { m_tsscce[2] = tsscce; }

  void setTsmMasking(unsigned short int tsmmsk, int i) { m_tsmmsk[i - 1] = tsmmsk; }

  inline void setTsmHtrigEna(bool tsmhte, int i) { m_tsmhte[i - 1] = tsmhte; }

  inline void setTsmHtrigEnaCarry(bool tsmhte) { m_tsmhte[2] = tsmhte; }

  inline void setTsmInOutEna(bool tsmnoe, int i) { m_tsmnoe[i - 1] = tsmnoe; }

  inline void setTsmInOutEnaCarry(bool tsmnoe) { m_tsmnoe[2] = tsmnoe; }

  inline void setTsmCorrEna(bool tsmcce, int i) { m_tsmcce[i - 1] = tsmcce; }

  inline void setTsmCorrEnaCarry(bool tsmcce) { m_tsmcce[2] = tsmcce; }

  inline void setTssGhost1Flag(unsigned short tssgs1) { m_tssgs1 = tssgs1; }

  inline void setTssGhost2Flag(unsigned short tssgs2) { m_tssgs2 = tssgs2; }

  inline void setTsmGhost1Flag(unsigned short tsmgs1) { m_tsmgs1 = tsmgs1; }

  inline void setTsmGhost2Flag(unsigned short tsmgs2) { m_tsmgs2 = tsmgs2; }

  inline void setTssGhost1Corr(bool tsscgs1) { m_tsscgs1 = tsscgs1; }

  inline void setTssGhost2Corr(bool tsscgs2) { m_tsscgs2 = tsscgs2; }

  inline void setTsmGhost1Corr(bool tsmcgs1) { m_tsmcgs1 = tsmcgs1; }

  inline void setTsmGhost2Corr(bool tsmcgs2) { m_tsmcgs2 = tsmcgs2; }

  inline void setTsmCarryFlag(unsigned short tsmhsp) { m_tsmhsp = tsmhsp; }

  inline void setUsedTraco(int i, int val) { m_tstren.set(i, val); }

  inline void setTsmStatus(int i, int val) { m_tsmword.set(i, val); };

  int nValidTSS() const;

  int nValidTSM() const;

  void print() const;

private:
  bool checkMask(unsigned short) const;

  void setDefaults(const edm::ParameterSet& ps);

  bool m_debug;

  // TSS Parameters
  unsigned short int m_tssmsk[2];  // [0]=1st [1]=2nd
  bool m_tsshte[3];                // [0]=1st [1]=2nd [2]=carry
  bool m_tssnoe[3];                // [0]=1st [1]=2nd [2]=carry
  bool m_tsscce[3];                // [0]=1st [1]=2nd [2]=carry
  unsigned short int m_tssgs1;
  unsigned short int m_tssgs2;
  bool m_tsscgs1;
  bool m_tsscgs2;

  //TSM Parameters
  unsigned short int m_tsmmsk[2];  // [0]=1st [1]=2nd
  bool m_tsmhte[3];                // [0]=1st [1]=2nd [2]=carry
  bool m_tsmnoe[3];                // [0]=1st [1]=2nd [2]=carry
  bool m_tsmcce[3];                // [0]=1st [1]=2nd [2]=carry
  unsigned short int m_tsmgs1;
  unsigned short int m_tsmgs2;
  bool m_tsmcgs1;
  bool m_tsmcgs2;
  unsigned short int m_tsmhsp;

  BitArray<24> m_tstren;  // Enabled TRACOs
  BitArray<8> m_tsmword;  // TSM backup mode word
  //unsigned short int m_ntsstsmd;        // nb tss to one of the tsmd (only if back-up mode)

  short int m_ntss;
  short int m_ntsm;
};

#endif