PXDDAQStatus.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#pragma once
 
#include <pxd/dataobjects/PXDDAQPacketStatus.h>
#include <TObject.h>
#include <pxd/dataobjects/PXDErrorFlags.h>
 
namespace Belle2 {
  using Belle2::PXD::PXDError::PXDErrorFlags;
 
  class PXDDAQStatus : public TObject {
  public:
 
    PXDDAQStatus() : m_errorMask(0), m_critErrorMask(0), m_usable(false), m_gated(false), m_unfiltered(false) {}
 
    explicit PXDDAQStatus(const PXDErrorFlags& mask) : m_errorMask(mask), m_critErrorMask(0), m_usable(false), m_gated(false),
      m_unfiltered(false) {}
 
    virtual ~PXDDAQStatus() {};
 
    const PXDDAQDHEStatus* findDHE(const VxdID& id) const;
 
    bool isUsable() const { return m_usable; }
 
    void setUnfiltered(bool b) { m_unfiltered = b; }
 
    bool isUnfiltered() const { return m_unfiltered; }
 
    void setGated(bool b) { m_gated = b; }
 
    bool isGated() const { return m_gated; }
 
    void setErrorMask(const PXDErrorFlags& mask) { m_errorMask = mask; }
 
    void addErrorMask(const PXDErrorFlags& mask) { m_errorMask |= mask; }
 
    PXDErrorFlags getErrorMask(void) const { return m_errorMask; }
 
    void setCritErrorMask(const PXDErrorFlags& mask) { m_critErrorMask = mask; }
 
    PXDErrorFlags getCritErrorMask(void) const { return m_critErrorMask; }
 
    void Decide(void) {m_usable = (m_errorMask & m_critErrorMask) == PXDErrorFlags(0) && !m_gated;}
 
    void addPacket(PXDDAQPacketStatus& daqpktstat) {m_pxdPacket.push_back(daqpktstat);};
 
    template<class ...Args> PXDDAQPacketStatus& newPacket(Args&& ... params)
    {
      /*return*/ m_pxdPacket.emplace_back(std::forward<Args>(params)...);
      return m_pxdPacket.back();
    }
 
    std::map <VxdID, bool> getUsable() const;
 
 
    std::vector<PXDDAQPacketStatus>::iterator begin() { return m_pxdPacket.begin(); };
    std::vector<PXDDAQPacketStatus>::iterator end() { return m_pxdPacket.end(); };
 
    std::vector<PXDDAQPacketStatus>::const_iterator cbegin() const { return m_pxdPacket.cbegin(); };
    std::vector<PXDDAQPacketStatus>::const_iterator cend() const { return m_pxdPacket.cend(); };
    PXDDAQPacketStatus& pkt_back() { return m_pxdPacket.back(); };
    size_t pkt_size() const { return m_pxdPacket.size(); };
 
  private:
    PXDErrorFlags m_errorMask; 
    PXDErrorFlags m_critErrorMask; 
    bool m_usable; 
    bool m_gated; 
    bool m_unfiltered; 
    std::vector <PXDDAQPacketStatus> m_pxdPacket;
 
    ClassDef(PXDDAQStatus, 3)
 
  }; // class PXDDAQStatus
 
} // end namespace Belle2