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