CSCDCCFormatStatusDigi.h

Go to the documentation of this file.

#ifndef CSCDCCFormatStatusDigi_CSCDCCFormatStatusDigi_h
#define CSCDCCFormatStatusDigi_CSCDCCFormatStatusDigi_h


/*
 * =====================================================================================
 *
 *       Filename:  CSCDCCFormatStatusDigi.h
 *
 *    Description:  CSC DCC Format error, status and payload flags for a single DCC
 *
 *        Version:  1.0
 *        Created:  02/12/2009 03:22:34 PM
 *       Revision:  none
 *       Compiler:  gcc
 *
 *         Author:  Valdas Rapsevicius (VR), valdas.rapsevicius@cern.ch,
 *                  Victor Barashko (VB), victor.barashko@cern.ch
 *        Company:  CERN, CH
 *
 * =====================================================================================
 */


#include "DataFormats/MuonDetId/interface/CSCDetId.h"
#include <set>
#include <map>
#include <algorithm>
#include <iosfwd>


typedef int32_t DCCIdType;

typedef int16_t DDUIdType;

typedef int32_t CSCIdType;

typedef uint32_t ExaminerMaskType;
typedef uint32_t ExaminerStatusType;

enum FormatErrorFlag {
  ANY_ERRORS                                          = 0,
  DDU_TRAILER_MISSING                                 = 1,
  DDU_HEADER_MISSING                                  = 2,
  DDU_CRC_ERROR                                       = 3,
  DDU_WORD_COUNT_ERROR                                = 4,
  DMB_TRAILER_MISSING                                 = 5,
  DMB_HEADER_MISSING                                  = 6,
  ALCT_TRAILER_MISSING                                = 7,
  ALCT_HEADER_MISSING                                 = 8,
  ALCT_WORD_COUNT_ERROR                               = 9,
  ALCT_CRC_ERROR                                      = 10,
  ALCT_TRAILER_BIT_ERROR                              = 11,
  TMB_TRAILER_MISSING                                 = 12,
  TMB_HEADER_MISSING                                  = 13,
  TMB_WORD_COUNT_ERROR                                = 14,
  TMB_CRC_ERROR                                       = 15,
  CFEB_WORD_COUNT_PER_SAMPLE_ERROR                    = 16,
  CFEB_SAMPLE_COUNT_ERROR                             = 17,
  CFEB_CRC_ERROR                                      = 18,
  DDU_EVENT_SIZE_LIMIT_ERROR                          = 19,
  C_WORDS                                             = 20,
  ALCT_DAV_ERROR                                      = 21,
  TMB_DAV_ERROR                                       = 22,
  CFEB_DAV_ERROR                                      = 23,
  DMB_ACTIVE_ERROR                                    = 24,
  DCC_TRAILER_MISSING                                 = 25,
  DCC_HEADER_MISSING                                  = 26,
  DMB_DAV_VS_DMB_ACTIVE_MISMATCH_ERROR                = 27,
  EXTRA_WORDS_BETWEEN_DDU_HEADER_AND_FIRST_DMB_HEADER = 28
};

enum CSCPayloadFlag {
  CFEB1_ACTIVE = 0,
  CFEB2_ACTIVE = 1,
  CFEB3_ACTIVE = 2,
  CFEB4_ACTIVE = 3,
  CFEB5_ACTIVE = 4,
  ALCT_DAV     = 5,
  TMB_DAV      = 6,
  CFEB1_DAV    = 7,
  CFEB2_DAV    = 8,
  CFEB3_DAV    = 9,
  CFEB4_DAV    = 10,
  CFEB5_DAV    = 11
};

enum CSCStatusFlag {
  ALCT_FIFO_FULL           = 0,
  TMB_FIFO_FULL            = 1,
  CFEB1_FIFO_FULL          = 2,
  CFEB2_FIFO_FULL          = 3,
  CFEB3_FIFO_FULL          = 4,
  CFEB4_FIFO_FULL          = 5,
  CFEB5_FIFO_FULL          = 6,
  ALCT_START_TIMEOUT       = 7,
  TMB_START_TIMEOUT        = 8,
  CFEB1_START_TIMEOUT      = 9,
  CFEB2_START_TIMEOUT      = 10,
  CFEB3_START_TIMEOUT      = 11,
  CFEB4_START_TIMEOUT      = 12,
  CFEB5_START_TIMEOUT      = 13,
  ALCT_END_TIMEOUT         = 14,
  TMB_END_TIMEOUT          = 15,
  CFEB1_END_TIMEOUT        = 16,
  CFEB2_END_TIMEOUT        = 17,
  CFEB3_END_TIMEOUT        = 18,
  CFEB4_END_TIMEOUT        = 19,
  CFEB5_END_TIMEOUT        = 20,
  CFEB_ACTIVE_DAV_MISMATCH = 21,
  B_WORDS_FOUND            = 22
};
    
template <class TKey, class TVal>
bool nextInMap(uint32_t& it, TKey& key, const std::map<TKey, TVal>& m) { 
  uint32_t c = 0;
  typename std::map<TKey, TVal>::const_iterator itr = m.begin();
  while (itr != m.end()) {
    if (c == it) {
      it++;
      key = itr->first;
      return true;
    }
    itr++;
    c++;
  }
  return false;
}

template <class TKey, class TVal>
std::set<TKey> getKeysList(const std::map<TKey, TVal>& m)
{
  std::set<TKey> keys;
  typename std::map<TKey, TVal>::const_iterator itr;
  for (itr  = m.begin(); itr != m.end(); ++itr) {
     keys.insert(itr->first);
  }
  return keys;
}

class CSCDCCFormatStatusDigi {

 private:

  ExaminerMaskType fDCC_MASK;

  ExaminerMaskType fCSC_MASK;

  DCCIdType DCCId;

  ExaminerStatusType fDDU_SUMMARY_ERRORS;

  std::map<DDUIdType, ExaminerStatusType> mDDU_ERRORS;
  std::map<CSCIdType, ExaminerStatusType> mCSC_ERRORS;
  std::map<CSCIdType, ExaminerStatusType> mCSC_PAYLOADS;
  std::map<CSCIdType, ExaminerStatusType> mCSC_STATUS;

 protected:

  CSCIdType makeCSCId(const uint16_t crateId, const uint16_t dmbId) const
    { return ( (CSCIdType(crateId&0xFF)<<4) | (dmbId&0xF) ); }

  void init() {
    fDDU_SUMMARY_ERRORS = 0;
    fCSC_MASK = 0;
    fDCC_MASK = 0;
    mDDU_ERRORS.clear();
    mCSC_ERRORS.clear();
    mCSC_PAYLOADS.clear();
    mCSC_STATUS.clear();
  }

 public:

  CSCDCCFormatStatusDigi(const DCCIdType DCCId_, 
             const ExaminerMaskType fDCC_MASK_,
             const ExaminerMaskType fCSC_MASK_,
             const ExaminerStatusType fDDU_SUMMARY_ERRORS_,
             const std::map<DDUIdType, ExaminerStatusType>& mDDU_ERRORS_,
             const std::map<CSCIdType, ExaminerStatusType>& mCSC_ERRORS_,
             const std::map<CSCIdType, ExaminerStatusType>& mCSC_PAYLOADS_,
             const std::map<CSCIdType, ExaminerStatusType>& mCSC_STATUS_): DCCId(DCCId_) 
    {
      init();
      setDCCExaminerInfo(fDCC_MASK_, fCSC_MASK_, fDDU_SUMMARY_ERRORS_, mDDU_ERRORS_, mCSC_ERRORS_, mCSC_PAYLOADS_, mCSC_STATUS_);
    }


  CSCDCCFormatStatusDigi(const DCCIdType DCCId_): DCCId(DCCId_) {init();}


  CSCDCCFormatStatusDigi (): DCCId(0) {init();}


  void setDCCExaminerInfo(const ExaminerMaskType fDCC_MASK_,
                         const ExaminerMaskType fCSC_MASK_,
                         const ExaminerStatusType fDDU_SUMMARY_ERRORS_,
                         const std::map<DDUIdType, ExaminerStatusType>& mDDU_ERRORS_,
                         const std::map<CSCIdType, ExaminerStatusType>& mCSC_ERRORS_,
                         const std::map<CSCIdType, ExaminerStatusType>& mCSC_PAYLOADS_, 
                         const std::map<CSCIdType, ExaminerStatusType>& mCSC_STATUS_);

#ifdef DEBUG

  void setDCCId(DCCIdType id) { DCCId = id; }
  void setDCCMask(ExaminerMaskType mask) { fDCC_MASK = mask; }
  void setCSCMask(ExaminerMaskType mask) { fCSC_MASK = mask; }
  void setDDUSummaryErrors(ExaminerStatusType status) { fDDU_SUMMARY_ERRORS = status; }
  void setDDUErrors(DDUIdType DDUId, ExaminerStatusType status )  {
    std::map<DDUIdType,ExaminerStatusType>::const_iterator item = mDDU_ERRORS.find(DDUId);
    if( item != mDDU_ERRORS.end() ) mDDU_ERRORS[DDUId] = status; else mDDU_ERRORS.insert(std::make_pair(DDUId, status));
  }
  void setCSCErrors(CSCIdType CSCId, ExaminerStatusType status )  {
    std::map<CSCIdType,ExaminerStatusType>::const_iterator item = mCSC_ERRORS.find(CSCId);
    if( item != mCSC_ERRORS.end() ) mCSC_ERRORS[CSCId] = status; else mCSC_ERRORS.insert(std::make_pair(CSCId, status));
  }
  void setCSCPayload(CSCIdType CSCId, ExaminerStatusType status )  {
    std::map<CSCIdType,ExaminerStatusType>::const_iterator item = mCSC_PAYLOADS.find(CSCId);
    if( item != mCSC_PAYLOADS.end() ) mCSC_PAYLOADS[CSCId] = status; else mCSC_PAYLOADS.insert(std::make_pair(CSCId, status));
  }
  void setCSCStatus(CSCIdType CSCId, ExaminerStatusType status )  {
    std::map<CSCIdType,ExaminerStatusType>::const_iterator item = mCSC_STATUS.find(CSCId);
    if( item != mCSC_STATUS.end() ) mCSC_STATUS[CSCId] = status; else mCSC_STATUS.insert(std::make_pair(CSCId, status));
  }

#endif

  std::set<DDUIdType> getListOfDDUs() const {
    return getKeysList(mDDU_ERRORS);
  }

  std::set<CSCIdType> getListOfCSCs() const {
    return getKeysList(mCSC_PAYLOADS);
  }
    
  std::set<CSCIdType> getListOfCSCsWithErrors() const {
    return getKeysList(mCSC_ERRORS);
  }

  bool nextCSCWithError(uint32_t& iterator, CSCIdType& CSCId) const {
    return nextInMap(iterator, CSCId, mCSC_ERRORS);
  }

  bool nextCSCWithStatus(uint32_t& iterator, CSCIdType& CSCId) const {
    return nextInMap(iterator, CSCId, mCSC_STATUS);
  }

  bool nextCSCWithPayload(uint32_t& iterator, CSCIdType& CSCId) const {
    return nextInMap(iterator, CSCId, mCSC_PAYLOADS);
  }

  ExaminerStatusType getDDUSummaryErrors() const { return fDDU_SUMMARY_ERRORS; }

  ExaminerStatusType getDDUErrors(const DDUIdType DDUId) const {
    std::map<DDUIdType,ExaminerStatusType>::const_iterator item = mDDU_ERRORS.find(DDUId);
    if( item != mDDU_ERRORS.end() ) return item->second; else return 0;
  }


  ExaminerStatusType getCSCErrors(const CSCIdType CSCId) const {
    std::map<CSCIdType,ExaminerStatusType>::const_iterator item = mCSC_ERRORS.find(CSCId);
    if( item != mCSC_ERRORS.end() ) return item->second; else return 0;
  } 

  ExaminerStatusType getCSCErrors(const uint16_t crateId, const uint16_t dmbId) const
    { return getCSCErrors( makeCSCId(crateId, dmbId) ); }


  ExaminerStatusType getCSCPayload(const CSCIdType CSCId) const {
    std::map<CSCIdType,ExaminerStatusType>::const_iterator item = mCSC_PAYLOADS.find(CSCId);
    if( item != mCSC_PAYLOADS.end() ) return item->second; else return 0;
  }

  ExaminerStatusType getCSCPayload(const uint16_t crateId, const uint16_t dmbId) const
    { return getCSCPayload( makeCSCId(crateId, dmbId) ); }


  ExaminerStatusType getCSCStatus(const CSCIdType CSCId) const {
    std::map<CSCIdType,ExaminerStatusType>::const_iterator item = mCSC_STATUS.find(CSCId);
    if( item != mCSC_STATUS.end() ) return item->second; else return 0;
  }

  ExaminerStatusType getCSCStatus(const uint16_t crateId, const uint16_t dmbId) const
    { return getCSCStatus( makeCSCId(crateId, dmbId) ); }


  /* 
   * Return FED/DCC Id
   */
  DCCIdType getDCCId() const { return DCCId; }

  ExaminerMaskType getDCCMask() const { return fDCC_MASK; }

  ExaminerMaskType getCSCMask() const { return fCSC_MASK; }
    
  bool getDDUSummaryFlag(const FormatErrorFlag flag) const 
    { return ( (fDDU_SUMMARY_ERRORS & ExaminerStatusType(0x1<<flag) ) != 0); }
  bool getDDUErrorFlag(const DDUIdType DDUId, const FormatErrorFlag flag) const
    { return ( (getDDUErrors(DDUId) & ExaminerStatusType(0x1<<flag) ) != 0); }

  bool getCSCErrorFlag(const CSCIdType CSCId, const FormatErrorFlag flag) const
    { return ( (getCSCErrors(CSCId) & ExaminerStatusType(0x1<<flag) ) != 0); }

  bool getCSCErrorFlag(const uint16_t crateId, const uint16_t dmbId, const FormatErrorFlag flag) const
    { return ( (getCSCErrors(crateId, dmbId) & ExaminerStatusType(0x1<<flag) ) != 0); }

  bool getCSCPayloadFlag(const CSCIdType CSCId, const CSCPayloadFlag flag) const
    { return ( (getCSCPayload(CSCId) & ExaminerStatusType(0x1<<flag) ) != 0); }

  bool getCSCPayloadFlag(const uint16_t crateId, const uint16_t dmbId, const CSCPayloadFlag flag) const
    { return ( (getCSCPayload(crateId,dmbId) & ExaminerStatusType(0x1<<flag) ) != 0); }

  bool getCSCStatusFlag(const CSCIdType CSCId, const CSCStatusFlag flag) const
    { return ( (getCSCStatus(CSCId) & ExaminerStatusType(0x1<<flag) ) != 0); }

  bool getCSCStatusFlag(const uint16_t crateId, const uint16_t dmbId, const CSCStatusFlag flag) const
    { return ( (getCSCStatus(crateId, dmbId) & ExaminerStatusType(0x1<<flag) ) != 0); }

  void print() const;
 

};


std::ostream & operator<<(std::ostream & o, const CSCDCCFormatStatusDigi& digi);

#endif