PXDDAQStatus.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2010 - Belle II Collaboration                             *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: bjoern.spruck@belle2.org                                 *
 * Created: 23.10.2017                                                   *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
 
#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(PXDErrorFlags mask) : m_errorMask(mask), m_critErrorMask(0), m_usable(false) , m_gated(false),
      m_unfiltered(false) {}
 
    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(PXDErrorFlags m) { m_errorMask = m; }
 
    void addErrorMask(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 && !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, 2)
 
  }; // class PXDDAQStatus
 
} // end namespace Belle2