PXDDAQDHCStatus.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 <pxd/dataobjects/PXDDAQDHEStatus.h>
#include <pxd/dataobjects/PXDErrorFlags.h>
 
namespace Belle2 {
  using Belle2::PXD::PXDError::PXDErrorFlags;
 
 
  class PXDDAQDHCStatus {
  public:
 
    PXDDAQDHCStatus() : m_errorMask(0), m_critErrorMask(0), m_usable(true), m_dhcID(0), m_rawCount(0), m_redCount(0), m_errorinfo(0) {}
 
    PXDDAQDHCStatus(int dhcid, PXDErrorFlags mask) : m_errorMask(mask),
      m_critErrorMask(0), m_usable(true), m_dhcID(dhcid), m_rawCount(0), m_redCount(0), m_errorinfo(0) {}
 
    bool isUsable() const { return m_usable; }
 
    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) == 0;}
 
    unsigned short getDHCID(void) const { return m_dhcID;};
    void setDHCID(int dhcid) {m_dhcID = dhcid;};
 
    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 setEndErrorInfo(uint32_t e) { m_errorinfo = e;};
    uint32_t getEndErrorInfo(void) const { return m_errorinfo;};
 
    void setGatedFlag(uint32_t e) { m_gated_mode = e;};
    bool getGatedFlag(void) const { return m_gated_mode;};
    void setGatedHER(uint32_t e) { m_gated_her = e;};
    bool getGatedHER(void) const { return m_gated_her;};
 
 
    void addDHE(PXDDAQDHEStatus& daqdhe) { m_pxdDHE.push_back(daqdhe);};
 
    template<class ...Args> PXDDAQDHEStatus&  newDHE(Args&& ... params)
    {
      /*return*/ m_pxdDHE.emplace_back(std::forward<Args>(params)...);
      return m_pxdDHE.back();
    }
 
    std::vector<PXDDAQDHEStatus>::iterator begin()  { return m_pxdDHE.begin(); };
    std::vector<PXDDAQDHEStatus>::iterator end()  { return m_pxdDHE.end(); };
 
    std::vector<PXDDAQDHEStatus>::const_iterator cbegin() const { return m_pxdDHE.cbegin(); };
    std::vector<PXDDAQDHEStatus>::const_iterator cend() const { return m_pxdDHE.cend(); };
    PXDDAQDHEStatus& dhe_back()  { return m_pxdDHE.back(); };
    size_t dhe_size() const { return m_pxdDHE.size(); };
 
  private:
    PXDErrorFlags m_errorMask; 
    PXDErrorFlags m_critErrorMask; 
    bool m_usable; 
    unsigned short m_dhcID;
    uint32_t m_rawCount; 
    uint32_t m_redCount; 
    uint32_t m_errorinfo; 
    bool m_gated_mode{false}; 
    bool m_gated_her{false}; 
    std::vector <PXDDAQDHEStatus> m_pxdDHE;
 
    ClassDef(PXDDAQDHCStatus, 4);
 
  }; // class PXDDAQDHCStatus
 
} // end namespace Belle2