PXDDAQDHEStatus.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2010 - Belle II Collaboration                             *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: bjoern.spruck@belle2.org                                 *
 * Created: Dez 2017                                                   *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
 
#pragma once
 
#include <vxd/dataobjects/VxdID.h>
#include <pxd/dataobjects/PXDDAQDHPStatus.h>
#include <pxd/dataobjects/PXDErrorFlags.h>
 
 
namespace Belle2 {
  typedef std::tuple<uint8_t, uint16_t, uint8_t> PXDDAQDHPComMode;
  using Belle2::PXD::PXDError::PXDErrorFlags;
  using Belle2::PXD::PXDError::EPXDErrMask;
 
  class PXDDAQDHEStatus {
  public:
 
    PXDDAQDHEStatus() : m_errorMask(0), m_critErrorMask(0), m_usable(true), m_sensorID(0), m_dheID(0), m_triggerGate(0), m_frameNr(0),
      m_dhp_found_mask(0),
      m_rawCount(0), m_redCount(0), m_errorinfo(0) {}
 
    PXDDAQDHEStatus(VxdID id, int dheid, PXDErrorFlags mask, unsigned short tg,
                    unsigned short fn) : m_errorMask(mask), m_critErrorMask(0), m_usable(true), m_sensorID(id), m_dheID(dheid),
      m_triggerGate(tg), m_frameNr(fn), m_dhp_found_mask(0), m_rawCount(0), m_redCount(0), m_errorinfo(0)
    {}
 
    bool isUsable() const { return m_usable; }
 
    void markUnusable() { m_usable = false; m_errorMask |= EPXDErrMask::c_UNUSABLE_DATA;}
 
    void setErrorMask(PXDErrorFlags m) { m_errorMask = m; }
 
    PXDErrorFlags getErrorMask(void) const { return m_errorMask; }
 
    void setCritErrorMask(PXDErrorFlags m) { m_critErrorMask = m; }
 
    PXDErrorFlags getCritErrorMask(void) const { return m_critErrorMask; }
 
    void Decide(void) {m_usable = (m_errorMask & m_critErrorMask) == 0ull && (m_errorMask & EPXDErrMask::c_UNUSABLE_DATA) == 0ull;}
 
    void setDHEID(VxdID id, int dheid) { m_sensorID = id; m_dheID = dheid;};
    unsigned short getDHEID(void) const { return  m_dheID;};
    VxdID getSensorID(void) const { return m_sensorID;};
 
    void setCounters(uint32_t raw, uint32_t red) {m_rawCount = raw; m_redCount = red;};
    void getCounters(uint32_t& raw, uint32_t& red) const { raw = m_rawCount; red = m_redCount;};
    uint32_t getRawCnt(void) const { return m_rawCount;};
    uint32_t getRedCnt(void) const { return m_redCount;};
    void setTriggerGate(unsigned int tg) { m_triggerGate = tg;};
    unsigned short getTriggerGate(void) const { return  m_triggerGate;};
    unsigned short getStartRow(void) const { return  m_triggerGate * 4;};
    void setFrameNr(unsigned int fn) { m_frameNr = fn;};
    unsigned short getFrameNr(void) const { return  m_frameNr;};
 
 
    unsigned short getDHPFoundMask(void) { return m_dhp_found_mask;};
    void setDHPFoundMask(unsigned short dhpmask) { m_dhp_found_mask = dhpmask;};
 
    void setEndErrorInfo(uint32_t e) { m_errorinfo = e;};
    uint32_t getEndErrorInfo(void) const { return m_errorinfo;};
 
    void addDHP(PXDDAQDHPStatus& daqdhp) { m_pxdDHP.push_back(daqdhp);};
 
    template<class ...Args> PXDDAQDHPStatus&  newDHP(Args&& ... params)
    {
      /*return*/ m_pxdDHP.emplace_back(std::forward<Args>(params)...);
      return m_pxdDHP.back();
    }
 
    std::vector<PXDDAQDHPStatus>::iterator begin()  { return m_pxdDHP.begin(); };
    std::vector<PXDDAQDHPStatus>::iterator end()  { return m_pxdDHP.end(); };
 
    std::vector<PXDDAQDHPStatus>::const_iterator cbegin() const { return m_pxdDHP.cbegin(); };
    std::vector<PXDDAQDHPStatus>::const_iterator cend() const { return m_pxdDHP.cend(); };
    PXDDAQDHPStatus& dhp_back()  { return m_pxdDHP.back(); };
    size_t dhp_size() const { return m_pxdDHP.size(); };
 
    auto addCM(PXDDAQDHPComMode& daqcm) { return m_commode.push_back(daqcm);};
 
    std::vector<PXDDAQDHPComMode>::iterator cm_begin()  { return m_commode.begin(); };
    std::vector<PXDDAQDHPComMode>::iterator cm_end()  { return m_commode.end(); };
    PXDDAQDHPComMode& cm_back()  { return m_commode.back(); };
    size_t cm_size() const { return m_commode.size(); };
    int get_cm_dhp(int i) const { return std::get<0>(m_commode[i]); };
    int get_cm_row(int i) const { return std::get<1>(m_commode[i]); };
    int get_cm_value(int i) const { return std::get<2>(m_commode[i]); };
 
  private:
    PXDErrorFlags m_errorMask; 
    PXDErrorFlags m_critErrorMask; 
    bool m_usable; 
    unsigned short m_sensorID;
    unsigned short m_dheID;
    unsigned short m_triggerGate; 
    unsigned short m_frameNr; 
    unsigned short m_dhp_found_mask; 
    uint32_t m_rawCount; 
    uint32_t m_redCount; 
    uint32_t m_errorinfo; 
    std::vector< PXDDAQDHPStatus> m_pxdDHP;
 
    std::vector < PXDDAQDHPComMode> m_commode;
 
    ClassDef(PXDDAQDHEStatus, 7);
 
  }; // class PXDDAQDHEStatus
 
} // end namespace Belle2