DTDDUWords.h

Go to the documentation of this file.

#ifndef DTDigi_DTDDUWords_h
#define DTDigi_DTDDUWords_h

#define WORDCONTROLMASK 0xE0000000
#define WORDCONTROLSHIFT 29
#define WORDTYPEMASK 0x1F000000
#define WORDTYPESHIFT 24

#define ERRORMASK 0x8000
#define ERRORSHIFT 15

#define DEBUG_TYPE_MASK 0xE00000
#define DEBUG_TYPE_SHIFT 21
#define DEBUG_MESSAGE_MASK 0x7FFF
#define CEROS_ID_CEROS_STATUS_MASK 0x1F0000
#define CEROS_ID_CEROS_STATUS_SHIFT 16
#define EV_ID_CEROS_STATUS_MASK 0xFC0
#define EV_ID_CEROS_STATUS_SHIFT 6
#define DONTREAD_CEROS_STATUS_MASK 0x3F
#define CEROS_ID_ROS_STATUS_MASK 0x1F

#define TTC_EVENT_COUNTER_MASK 0xFFFFFF

#define TFF_MASK 0x800000
#define TFF_SHIFT 23
#define TPX_MASK 0x400000
#define TPX_SHIFT 22
#define L1A_FIFO_OCC_MASK 0x3F0000
#define L1A_FIFO_OCC_SHIFT 16
#define EVENT_WORD_COUNT_MASK 0xFFFF

#define ERROR_TYPE_MASK 0xE00000
#define ERROR_TYPE_SHIFT 21
#define ERROR_ROB_ID_MASK 0x1F0000
#define ERROR_ROB_ID_SHIFT 16
#define ERROR_CEROS_ID_MASK 0x3F

#define ROB_ID_MASK 0x1F000000
#define EVENT_ID_MASK 0xFFF000
#define EVENT_ID_SHIFT 12
#define BUNCH_ID_MASK 0xFFF
#define WORD_COUNT_MASK 0xFFF

#define PC_MASK 0x8000000
#define PC_SHIFT 27
#define PAF_MASK 0x4000000
#define PAF_SHIFT 26
#define TDC_ID_MASK 0x3000000
#define TDC_ID_SHIFT 24

#define TDC_CHANNEL_MASK 0xF80000
#define TDC_CHANNEL_SHIFT 19
#define TDC_TIME_MASK 0x7FFFC  // First two bits are excluded
#define TDC_TIME_SHIFT 2

#define TDC_ERROR_MASK 0x7FFF

#define SCFO_MASK 0xFF

#define TRIGGER_WORD_COUNT_MASK 0xFFFF

#define TRIGGER_DATA_MASK 0xFFFF

#define SC_LAT_SHIFT 8
#define SC_LAT_MASK 0x7F

#define SC_NW_MASK 0xFF

#define SC_TRIGGERDLY_MASK 0x7
#define SC_TRIGGERDLY_SHIFT 12
#define SC_BXC_MASK 0xFFF

#include <iostream>
#include <cstdint>

class DTROSWordType {
public:
  DTROSWordType(const uint32_t index) { word_ = index; }

  DTROSWordType() : word_(0){};

  virtual ~DTROSWordType(){};

  enum wordTypes {
    ROSHeader = 1,
    ROSTrailer = 2,
    ROSError = 3,
    GroupHeader = 4,
    GroupTrailer = 5,
    TDCHeader = 6,
    TDCTrailer = 7,
    TDCMeasurement = 8,
    TDCError = 9,
    SCHeader = 10,
    SCTrailer = 11,
    SCData = 12,
    ROSDebug = 13,
    TDCDebug = 14,
    Control = 15
  };

  enum wordTypes type() {
    enum wordTypes wordType = Control;

    // ROS/ROB/SC Headers
    if (((word_ & WORDCONTROLMASK) >> WORDCONTROLSHIFT) == headerControlWord) {
      if (((word_ & WORDTYPEMASK) >> WORDTYPESHIFT) == rosTypeWord)
        wordType = ROSHeader;
      if (((word_ & WORDTYPEMASK) >> WORDTYPESHIFT) == scTypeWord)
        wordType = SCHeader;
      if (((word_ & WORDTYPEMASK) >> WORDTYPESHIFT) < scTypeWord)
        wordType = GroupHeader;
    }

    // ROS/ROB/SC Trailers
    if (((word_ & WORDCONTROLMASK) >> WORDCONTROLSHIFT) == trailerControlWord) {
      if (((word_ & WORDTYPEMASK) >> WORDTYPESHIFT) == rosTypeWord)
        wordType = ROSTrailer;
      if (((word_ & WORDTYPEMASK) >> WORDTYPESHIFT) == scTypeWord)
        wordType = SCTrailer;
      if (((word_ & WORDTYPEMASK) >> WORDTYPESHIFT) < scTypeWord)
        wordType = GroupTrailer;
    }

    // TDC Header
    if (((word_ & WORDCONTROLMASK) >> WORDCONTROLSHIFT) == tdcHeaderControlWord)
      wordType = TDCHeader;

    // TDC Trailer
    if (((word_ & WORDCONTROLMASK) >> WORDCONTROLSHIFT) == tdcTrailerControlWord)
      wordType = TDCTrailer;

    // TDC/SC Data
    if (((word_ & WORDCONTROLMASK) >> WORDCONTROLSHIFT) == tdcDataControlWord) {
      if (((word_ & WORDTYPEMASK) >> WORDTYPESHIFT) == scTypeWord)
        wordType = SCData;
      else
        wordType = TDCMeasurement;
    }

    // Errors
    if (((word_ & WORDCONTROLMASK) >> WORDCONTROLSHIFT) == errorControlWord) {
      if (((word_ & WORDTYPEMASK) >> WORDTYPESHIFT) == rosTypeWord)
        wordType = ROSError;
      if (((word_ & WORDTYPEMASK) >> WORDTYPESHIFT) < scTypeWord)
        wordType = TDCError;
    }

    // ROS Debug
    if (((word_ & WORDCONTROLMASK) >> WORDCONTROLSHIFT) == debugControlWord) {
      if (((word_ & WORDTYPEMASK) >> WORDTYPESHIFT) == rosTypeWord)
        wordType = ROSDebug;
      if (((word_ & WORDTYPEMASK) >> WORDTYPESHIFT) < scTypeWord)
        wordType = TDCDebug;
    }

    return wordType;
  }

  static const uint32_t headerControlWord = 0;
  static const uint32_t trailerControlWord = 1;
  static const uint32_t tdcHeaderControlWord = 2;
  static const uint32_t tdcTrailerControlWord = 3;
  static const uint32_t tdcDataControlWord = 4;
  static const uint32_t errorControlWord = 6;
  static const uint32_t debugControlWord = 7;

  static const uint32_t rosTypeWord = 31;
  static const uint32_t scTypeWord = 25;

private:
  uint32_t word_;
};

class DTROSHeaderWord {
public:
  DTROSHeaderWord() {}

  DTROSHeaderWord(const uint32_t index) : word_(index) {}

  virtual ~DTROSHeaderWord() {}

  int TTCEventCounter() const { return word_ & TTC_EVENT_COUNTER_MASK; }

  static void set(uint32_t& word, int ttc_event_counter) {
    word = DTROSWordType::headerControlWord << WORDCONTROLSHIFT | DTROSWordType::rosTypeWord << WORDTYPESHIFT |
           ttc_event_counter;
  }

private:
  uint32_t word_;
};

class DTROSTrailerWord {
public:
  DTROSTrailerWord() {}

  DTROSTrailerWord(const uint32_t index) : word_(index) {}

  virtual ~DTROSTrailerWord() {}

  int TFF() const { return (word_ & TFF_MASK) >> TFF_SHIFT; }
  int TPX() const { return (word_ & TPX_MASK) >> TPX_SHIFT; }
  int l1AFifoOccupancy() const { return (word_ & L1A_FIFO_OCC_MASK) >> L1A_FIFO_OCC_SHIFT; }
  int EventWordCount() const { return word_ & EVENT_WORD_COUNT_MASK; }

  static void set(uint32_t& word, int tff, int tpx, int l1a_fifo_occ, int event_word_count) {
    word = DTROSWordType::trailerControlWord << WORDCONTROLSHIFT | DTROSWordType::rosTypeWord << WORDTYPESHIFT |
           tff << TFF_SHIFT | tpx << TPX_SHIFT | l1a_fifo_occ << L1A_FIFO_OCC_SHIFT | event_word_count;
  }

private:
  uint32_t word_;
};

class DTROSErrorWord {
public:
  DTROSErrorWord() {}

  DTROSErrorWord(const uint32_t index) : word_(index) {}

  virtual ~DTROSErrorWord() {}

  int errorType() const { return (word_ & ERROR_TYPE_MASK) >> ERROR_TYPE_SHIFT; }
  int robID() const { return (word_ & ERROR_ROB_ID_MASK) >> ERROR_ROB_ID_SHIFT; }
  int cerosID() const { return errorType() == 4 ? (word_ & ERROR_CEROS_ID_MASK) : 0; }

  static void set(uint32_t& word, int error_type, int rob_id) {
    word = DTROSWordType::errorControlWord << WORDCONTROLSHIFT | DTROSWordType::rosTypeWord << WORDTYPESHIFT |
           error_type << ERROR_TYPE_SHIFT | rob_id << ERROR_ROB_ID_SHIFT | 1 << ERRORSHIFT;
  }

private:
  uint32_t word_;
};

class DTROSDebugWord {
public:
  DTROSDebugWord() {}

  DTROSDebugWord(const uint32_t index) : word_(index) {}

  virtual ~DTROSDebugWord() {}

  int debugType() const { return (word_ & DEBUG_TYPE_MASK) >> DEBUG_TYPE_SHIFT; }
  int debugMessage() const { return (word_ & DEBUG_MESSAGE_MASK); }
  int cerosIdCerosStatus() const {
    return debugType() == 3 ? (word_ & CEROS_ID_CEROS_STATUS_MASK) >> CEROS_ID_CEROS_STATUS_SHIFT : 0;
  }
  int evIdMis() const { return debugType() == 3 ? (word_ & EV_ID_CEROS_STATUS_MASK) >> EV_ID_CEROS_STATUS_SHIFT : 0; }
  int dontRead() const { return debugType() == 3 ? (word_ & DONTREAD_CEROS_STATUS_MASK) : 0; }
  int cerosIdRosStatus() const { return debugType() == 4 ? (word_ & CEROS_ID_ROS_STATUS_MASK) : 0; }

  static void set(uint32_t& word,  //CB FIXME do we need setters for DEBUG Types 3 and 4?
                  int debug_type) {
    word = DTROSWordType::debugControlWord << WORDCONTROLSHIFT | DTROSWordType::rosTypeWord << WORDTYPESHIFT |
           debug_type << DEBUG_TYPE_SHIFT | 504 << 15;  // TEMPORARY
  }

  static void set(uint32_t& word, int debug_type, int ceros_id) {
    word = DTROSWordType::debugControlWord << WORDCONTROLSHIFT | DTROSWordType::rosTypeWord << WORDTYPESHIFT |
           debug_type << DEBUG_TYPE_SHIFT | ceros_id << CEROS_ID_CEROS_STATUS_SHIFT | 1 << 15;
  }

private:
  uint32_t word_;
};

class DTROBHeaderWord {
public:
  DTROBHeaderWord() {}

  DTROBHeaderWord(const uint32_t index) : word_(index) {}

  virtual ~DTROBHeaderWord() {}

  int robID() const { return (word_ & ROB_ID_MASK) >> WORDTYPESHIFT; }
  int eventID() const { return (word_ & EVENT_ID_MASK) >> EVENT_ID_SHIFT; }
  int bunchID() const { return (word_ & BUNCH_ID_MASK); }

  static void set(uint32_t& word, int rob_id, int event_id, int bunch_id) {
    word = DTROSWordType::headerControlWord << WORDCONTROLSHIFT | rob_id << WORDTYPESHIFT | event_id << EVENT_ID_SHIFT |
           bunch_id;
  }

private:
  uint32_t word_;
};

class DTROBTrailerWord {
public:
  DTROBTrailerWord() {}

  DTROBTrailerWord(const uint32_t index) : word_(index) {}

  virtual ~DTROBTrailerWord() {}

  int robID() const { return (word_ & ROB_ID_MASK) >> WORDTYPESHIFT; }
  int eventID() const { return (word_ & EVENT_ID_MASK) >> EVENT_ID_SHIFT; }
  int wordCount() const { return (word_ & WORD_COUNT_MASK); }

  static void set(uint32_t& word, int rob_id, int event_id, int word_count) {
    word = DTROSWordType::trailerControlWord << WORDCONTROLSHIFT | rob_id << WORDTYPESHIFT |
           event_id << EVENT_ID_SHIFT | word_count;
  }

private:
  uint32_t word_;
};

class DTTDCHeaderWord {
public:
  DTTDCHeaderWord() {}

  DTTDCHeaderWord(const uint32_t index) : word_(index) {}

  virtual ~DTTDCHeaderWord() {}

  int PC() const { return (word_ & PC_MASK) >> PC_SHIFT; }
  int PAF() const { return (word_ & PAF_MASK) >> PAF_SHIFT; }
  int HU() const { return (word_ & PAF_MASK) >> PAF_SHIFT; }  
  int tdcID() const { return (word_ & TDC_ID_MASK) >> TDC_ID_SHIFT; }
  int eventID() const { return (word_ & EVENT_ID_MASK) >> EVENT_ID_SHIFT; }
  int bunchID() const { return (word_ & BUNCH_ID_MASK); }

  static void set(uint32_t& word, int pc, int paf, int hu, int tdc_id, int event_id, int bunch_id) {
    word = DTROSWordType::tdcHeaderControlWord << WORDCONTROLSHIFT | pc << PC_SHIFT | paf << PAF_SHIFT |
           hu << PAF_SHIFT | tdc_id << TDC_ID_SHIFT | event_id << EVENT_ID_SHIFT | bunch_id;
  }

private:
  uint32_t word_;
};

class DTTDCTrailerWord {
public:
  DTTDCTrailerWord() {}

  DTTDCTrailerWord(const uint32_t index) : word_(index) {}

  virtual ~DTTDCTrailerWord() {}

  int PC() const { return (word_ & PC_MASK) >> PC_SHIFT; }
  int PAF() const { return (word_ & PAF_MASK) >> PAF_SHIFT; }
  int HU() const { return (word_ & PAF_MASK) >> PAF_SHIFT; }  
  int tdcID() const { return (word_ & TDC_ID_MASK) >> TDC_ID_SHIFT; }
  int eventID() const { return (word_ & EVENT_ID_MASK) >> EVENT_ID_SHIFT; }
  int wordCount() const { return (word_ & WORD_COUNT_MASK); }

  static void set(uint32_t& word, int pc, int paf, int hu, int tdc_id, int event_id, int word_count) {
    word = DTROSWordType::tdcTrailerControlWord << WORDCONTROLSHIFT | pc << PC_SHIFT | paf << PAF_SHIFT |
           hu << PAF_SHIFT | tdc_id << TDC_ID_SHIFT | event_id << EVENT_ID_SHIFT | word_count;
  }

private:
  uint32_t word_;
};

class DTTDCMeasurementWord {
public:
  DTTDCMeasurementWord() {}

  DTTDCMeasurementWord(const uint32_t index) : word_(index) {}

  virtual ~DTTDCMeasurementWord() {}

  int PC() const { return (word_ & PC_MASK) >> PC_SHIFT; }
  int PAF() const { return (word_ & PAF_MASK) >> PAF_SHIFT; }
  int HU() const { return (word_ & PAF_MASK) >> PAF_SHIFT; }  
  int tdcID() const { return (word_ & TDC_ID_MASK) >> TDC_ID_SHIFT; }
  int tdcChannel() const { return (word_ & TDC_CHANNEL_MASK) >> TDC_CHANNEL_SHIFT; }
  int tdcTime() const { return (word_ & TDC_TIME_MASK) >> TDC_TIME_SHIFT; }

  static void set(uint32_t& word, int pc, int paf, int hu, int tdc_id, int tdc_channel, int tdc_time) {
    word = DTROSWordType::tdcDataControlWord << WORDCONTROLSHIFT | pc << PC_SHIFT | paf << PAF_SHIFT | hu << PAF_SHIFT |
           tdc_id << TDC_ID_SHIFT | tdc_channel << TDC_CHANNEL_SHIFT | tdc_time;
  }

private:
  uint32_t word_;
};

class DTTDCErrorWord {
public:
  DTTDCErrorWord() {}

  DTTDCErrorWord(const uint32_t index) : word_(index) {}

  virtual ~DTTDCErrorWord() {}

  int PC() const { return (word_ & PC_MASK) >> PC_SHIFT; }
  int PAF() const { return (word_ & PAF_MASK) >> PAF_SHIFT; }
  int HU() const { return (word_ & PAF_MASK) >> PAF_SHIFT; }  
  int tdcID() const { return (word_ & TDC_ID_MASK) >> TDC_ID_SHIFT; }
  int tdcError() const { return (word_ & TDC_ERROR_MASK); }

  static void set(uint32_t& word, int pc, int paf, int hu, int tdc_id, int tdc_error) {
    word = DTROSWordType::errorControlWord << WORDCONTROLSHIFT | pc << PC_SHIFT | paf << PAF_SHIFT | hu << PAF_SHIFT |
           tdc_id << TDC_ID_SHIFT | 0 << ERRORSHIFT | tdc_error;
  }

private:
  uint32_t word_;
};

class DTLocalTriggerHeaderWord {
public:
  DTLocalTriggerHeaderWord() {}

  DTLocalTriggerHeaderWord(const uint32_t index) : word_(index) {}

  virtual ~DTLocalTriggerHeaderWord() {}

  int eventID() const { return (word_ & EVENT_ID_MASK) >> EVENT_ID_SHIFT; }
  int SCFO() const { return (word_ & SCFO_MASK); }

  static void set(uint32_t& word, int event_id, int scfo) {
    word = DTROSWordType::headerControlWord << WORDCONTROLSHIFT | DTROSWordType::scTypeWord << WORDTYPESHIFT |
           event_id << EVENT_ID_SHIFT | scfo;
  }

private:
  uint32_t word_;
};

class DTLocalTriggerTrailerWord {
public:
  DTLocalTriggerTrailerWord() {}

  DTLocalTriggerTrailerWord(const uint32_t index) : word_(index) {}

  virtual ~DTLocalTriggerTrailerWord() {}

  int wordCount() const { return (word_ & TRIGGER_WORD_COUNT_MASK); }

  static void set(uint32_t& word, int word_count) {
    word =
        DTROSWordType::trailerControlWord << WORDCONTROLSHIFT | DTROSWordType::scTypeWord << WORDTYPESHIFT | word_count;
  }

private:
  uint32_t word_;
};

class DTLocalTriggerDataWord {
public:
  DTLocalTriggerDataWord() {}

  DTLocalTriggerDataWord(const uint32_t index) : word_(index) {}

  virtual ~DTLocalTriggerDataWord() {}

  int SCData() const { return (word_ & TRIGGER_DATA_MASK); }

  int getBits(int first) const {
    return first == 1 ? ((word_ & TRIGGER_DATA_MASK) >> 8) : ((word_ & TRIGGER_DATA_MASK) & 0xFF);
  }

  //int hasTrigger(int first) const { return (getBits(first) & 0x40) >> 6; }
  int hasTrigger(int first) const { return (trackQuality(first) != 7 ? 1 : 0); }
  int trackQuality(int first) const { return (getBits(first) & 0xE) >> 1; }

  static void set(uint32_t& word, int sc_data) {
    word = DTROSWordType::tdcDataControlWord << WORDCONTROLSHIFT | DTROSWordType::scTypeWord << WORDTYPESHIFT | sc_data;
  }

private:
  uint32_t word_;
};

class DTDDUFirstStatusWord {
public:
  DTDDUFirstStatusWord() {}

  DTDDUFirstStatusWord(const unsigned char index) : word_(index) {}

  virtual ~DTDDUFirstStatusWord() {}

  int channelEnabled() const { return (word_ & 0x1); }
  int timeout() const { return (word_ & 0x2) >> 1; }
  int eventTrailerLost() const { return (word_ & 0x4) >> 2; }
  int opticalFiberSignalLost() const { return (word_ & 0x8) >> 3; }
  int tlkPropagationError() const { return (word_ & 0x10) >> 4; }
  int tlkPatternError() const { return (word_ & 0x20) >> 5; }
  int tlkSignalLost() const { return (word_ & 0x40) >> 6; }
  int errorFromROS() const { return (word_ & 0x80) >> 7; }

private:
  unsigned char word_;
};

class DTDDUSecondStatusWord {
public:
  DTDDUSecondStatusWord() {}

  DTDDUSecondStatusWord(const uint32_t index) : word_(index) {}

  virtual ~DTDDUSecondStatusWord() {}

  int l1AIDError() const { return (word_ & 0x1); }
  int bxIDError() const { return (word_ & 0x2) >> 1; }
  int fifoFull() const { return (word_ & 0x1C) >> 2; }
  int inputFifoFull() const { return (word_ & 0xE0) >> 5; }
  int fifoAlmostFull() const { return (word_ & 0x700) >> 8; }
  int inputFifoAlmostFull() const { return (word_ & 0x3800) >> 11; }
  int outputFifoFull() const { return (word_ & 0x4000) >> 14; }
  int outputFifoAlmostFull() const { return (word_ & 0x8000) >> 15; }
  int rosList() const { return (word_ & 0xFFF0000) >> 16; }
  int warningROSPAF() const { return (word_ & 0x10000000) >> 28; }
  int busyROSPAF() const { return (word_ & 0x20000000) >> 29; }
  int outOfSynchROSError() const { return (word_ & 0x40000000) >> 30; }

  //   int fifoAlmostEmpty() const { return (word_ & 0x1C000) >> 14; }
  //   int inputFifoAlmostEmpty() const { return (word_ & 0xE0000) >> 17; }
  //   int outputFifoFull() const { return (word_ & 0x100000) >> 20; }
  //   int outputFifoAlmostFull() const { return (word_ & 0x200000) >> 21; }
  //   int outputFifoAlmostEmpty() const { return (word_ & 0x400000) >> 22; }

private:
  uint32_t word_;
};

class DTLocalTriggerSectorCollectorHeaderWord {
public:
  DTLocalTriggerSectorCollectorHeaderWord() {}

  DTLocalTriggerSectorCollectorHeaderWord(const uint32_t index) : word_(index) {}

  virtual ~DTLocalTriggerSectorCollectorHeaderWord() {}

  int Latency() const { return ((word_ >> SC_LAT_SHIFT) & SC_LAT_MASK); }
  int NumberOf16bitWords() const { return (word_ & SC_NW_MASK); }

  static void set(uint32_t& word, int lat, int nw) {
    word = DTROSWordType::headerControlWord << WORDCONTROLSHIFT | DTROSWordType::scTypeWord << WORDTYPESHIFT |
           (lat & SC_LAT_MASK) << SC_LAT_SHIFT | (nw & SC_NW_MASK);
  }

private:
  uint32_t word_;
};

class DTLocalTriggerSectorCollectorSubHeaderWord {
public:
  DTLocalTriggerSectorCollectorSubHeaderWord() {}

  DTLocalTriggerSectorCollectorSubHeaderWord(const uint32_t index) : word_(index) {}

  virtual ~DTLocalTriggerSectorCollectorSubHeaderWord() {}

  int TriggerDelay() const { return ((word_ >> SC_TRIGGERDLY_SHIFT) & SC_TRIGGERDLY_MASK); }
  int LocalBunchCounter() const { return (word_ & SC_BXC_MASK); }

  static void set(uint32_t& word, int trigdly, int bxcount) {
    word = DTROSWordType::headerControlWord << WORDCONTROLSHIFT | DTROSWordType::scTypeWord << WORDTYPESHIFT |
           (trigdly & SC_TRIGGERDLY_MASK) << SC_TRIGGERDLY_SHIFT | (bxcount & SC_BXC_MASK);
  }

private:
  uint32_t word_;
};

#endif