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"
#include "boost/cstdint.hpp"

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

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

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

  void  setTssMasking(unsigned short int tssmsk, int i);
 
  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);
  
  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); };

  void print() const ;

  private:

  bool checkMask(unsigned short);

  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)

};

#endif