TileDQstatus.h

Go to the documentation of this file.

// This file's extension implies that it's C, but it's really -*- C++ -*-.
/*
  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
*/
/*
 */
 
 
#ifndef TILEEVENT_TILEDQSTATUS_H
#define TILEEVENT_TILEDQSTATUS_H
 
 
#include "AthenaKernel/CLASS_DEF.h"
#include <vector>
 
 
class TileDQstatusTool;
class TileRawChannelCollection;
class TileDigitsContainer;
class MsgStream;
 


* @class TileDQstatus
* @brief Class that holds Data Quality fragment information and provides functions to extract the data quality status for channels
*        Checks for the following types of errors stored in the Data Quality fragment:
*           - Global CRC
*           - ROD CRC
*           - Front End CRC
*           - BCID Mismatch
*           - Header Format
*           - Header Parity
*           - Sample Format 
*           - Sample Parity
*           - Single Strobe
*           - Double Strobe
*
* Also holds a few other pieces of information, such as trigger type,
* calibration mode, and CIS parameters.
*/
class TileDQstatus
{
  friend class TileDQstatusTool;
 
public:

  TileDQstatus();

  inline bool   isFilled        ()              const           { return m_isFilled; }
  inline bool   isBiGain        ()              const           { return m_isBiGain; }
  inline bool   nonZeroCounter  ()              const           { return m_counter;  }
  bool          isAdcDQgood     (int partition, int drawer, int ch, int gain) const;
  bool          isChanDQgood    (int partition, int drawer, int ch) const;
  static int    isChEmpty       (int partition, int drawer, int ch);
  inline int checkEmptyEvent(int partition, int drawer, int dmu) const {
    return (m_EmptyEventArray[partition][drawer][dmu][0]+((m_EmptyEventArray[partition][drawer][dmu][1]) << 1));
  }
  
  inline int checkGlobalErr(int partition, int drawer, int gain) const {
    return m_GlobalCRCErrArray[partition][drawer][gain];
  }

  inline int checkGlobalCRCErr(int partition, int drawer, int gain) const {
    return m_GlobalCRCErrArray[partition][drawer][gain] & 1;
  }

  inline int checkROD_CRCErr(int partition, int drawer, int dmu, int gain) const {
    return (1 - ((m_ROD_DMUmaskArray[partition][drawer][gain] >> dmu) & 1));
  }

  inline int checkFE_CRCErr(int partition, int drawer, int dmu, int gain) const {
      return (1 - ((m_FE_DMUmaskArray[partition][drawer][gain] >> dmu) & 1)); 
  }

  inline int checkBCIDErr(int partition, int drawer, int dmu, int gain) const {
      return ((m_BCIDErrArray[partition][drawer][gain] & 0x2) && m_checkDigi) 
          ? this->checkBCIDErrDetail(partition,drawer,dmu,gain) :
          ((m_BCIDErrArray[partition][drawer][gain] >> dmu) & 1);
  }

  inline int checkBCIDErrDetail(int partition, int drawer, int dmu, int gain) const {
      return (m_BCIDErrArrayDetail[partition][drawer][gain] >> dmu) & 1;
  }

  inline int checkHeaderFormatErr(int partition, int drawer, int dmu, int gain) const {
    return (m_HeaderFormatErrArray[partition][drawer][gain] >> dmu) & 1;
  }

  inline int checkHeaderParityErr(int partition, int drawer, int dmu, int gain) const {
    return (m_HeaderParityErrArray[partition][drawer][gain] >> dmu) & 1;
  }

  inline int checkSampleFormatErr(int partition, int drawer, int dmu, int gain) const {
    return (m_SampleFormatErrArray[partition][drawer][gain] >> dmu) & 1;
  }

  inline int checkSampleParityErr(int partition, int drawer, int dmu, int gain) const {
    return (m_SampleParityErrArray[partition][drawer][gain] >> dmu) & 1;
  }

  inline int checkMemoryParityErr(int partition, int drawer, int dmu, int gain) const {
    return (m_MemoryParityErrArray[partition][drawer][gain] >> dmu) & 1;
  }

  inline int checkSingleStrobeErr(int partition, int drawer, int dmu, int gain) const {
    return (m_SingleStrobeErrArray[partition][drawer][gain] >> dmu) & 1;
  }

  inline int checkDoubleStrobeErr(int partition, int drawer, int dmu, int gain) const {
    return (m_DoubleStrobeErrArray[partition][drawer][gain] >> dmu) & 1;
  }


  bool incompleteDigits() const { return m_incompleteDigits;}
  void setIncompleteDigits (bool incomplete);

  uint32_t      calibMode()  const { return m_calibMode; }
  void setCalibMode (uint32_t calibMode);

  const uint32_t* cispar()  const { return m_cispar; }
  uint32_t* cispar();
  
  int            trigType()  const { return m_trigType; }
  void setTrigType (int trigType);
 
  uint32_t RODBCID() const   {return m_BCID;}
 
 
protected:

  void setFilled(bool filled) {m_isFilled=filled;}
  void setBiGain(bool biGain) {m_isBiGain=biGain;}
  void setAllGood();
  void setRODBCID(uint32_t BCID)   {m_BCID=BCID;}
  inline void setEmptyEvent(int partition, int drawer, int dmu, int gain, int isEmpty) {
    m_EmptyEventArray[partition][drawer][dmu][gain]=isEmpty;
    m_counter+=isEmpty;
  }

  void fillArrays(const TileRawChannelCollection * coll,
                  const TileDigitsContainer* digitsCnt, int gain, unsigned short fragBCID);
  void fillBCIDErrDetail(const TileDigitsContainer* digitsCnt,
                         int frag, int gain);
  void fillTrips(unsigned int partition, const std::vector<float>& trips, double* rndmVec,
                 MsgStream& msg);
 
 private:
  bool  m_isFilled;
  bool  m_isBiGain;
  bool  m_checkDigi;
  uint32_t   m_BCID;
  int   m_counter;
  short m_EmptyEventArray     [5][64][16][2];
  short m_GlobalCRCErrArray   [5][64][2];
  short m_FE_DMUmaskArray     [5][64][2];
  short m_ROD_DMUmaskArray    [5][64][2];
  short m_BCIDErrArray        [5][64][2];
  short m_BCIDErrArrayDetail  [5][64][2];
  short m_HeaderFormatErrArray[5][64][2];
  short m_HeaderParityErrArray[5][64][2];
  short m_SampleFormatErrArray[5][64][2];
  short m_SampleParityErrArray[5][64][2];
  short m_MemoryParityErrArray[5][64][2];
  short m_SingleStrobeErrArray[5][64][2];
  short m_DoubleStrobeErrArray[5][64][2];

  bool m_incompleteDigits;

  uint32_t m_calibMode;

  uint32_t m_cispar[110];

  int m_trigType;
 
  static const int s_ch2dmuLB[48];
  static const int s_ch2dmuEB[48];
  static const int s_ch2dmuEBspecial[48];
};
 
 
// if PMT does not exist, returns 1 
// if DMU does not exist, returns 2
__attribute__((always_inline)) inline
int TileDQstatus::isChEmpty(int partition, int drawer, int ch) {
  
  switch (partition) {
    case 1:
      return s_ch2dmuLB[ch];
    case 2:
      return s_ch2dmuLB[ch];    
    case 3:
      return (drawer != 14) ? s_ch2dmuEB[ch] : s_ch2dmuEBspecial[ch];
    case 4:
      return (drawer != 17) ? s_ch2dmuEB[ch] : s_ch2dmuEBspecial[ch];
    default:
      return 0;
  }  
}
 
 
CLASS_DEF (TileDQstatus, 221767675, 0)
 
 
#endif // not TILEEVENT_TILEDQSTATUS_H