HLTResultMT.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef TRIGSTEERINGEVENT_HLTResultMT_H
#define TRIGSTEERINGEVENT_HLTResultMT_H
 
// Trigger includes
#include "TrigSteeringEvent/OnlineErrorCode.h"
 
// Athena includes
#include "AthenaKernel/CLASS_DEF.h"
 
// Gaudi includes
#include "GaudiKernel/StatusCode.h"
 
// TDAQ includes
#include "eformat/Status.h"
#include "eformat/StreamTag.h"
 
// System includes
#include <boost/dynamic_bitset.hpp>
#include <vector>
#include <unordered_map>
#include <utility>
#include <cstdint>
 
namespace HLT {
 
  class HLTResultMT {
  public:
    HLTResultMT(std::vector<eformat::helper::StreamTag> streamTags = {},
                boost::dynamic_bitset<uint32_t> hltPassRawBits = boost::dynamic_bitset<uint32_t>(),
                boost::dynamic_bitset<uint32_t> hltPrescaledBits = boost::dynamic_bitset<uint32_t>(),
                std::unordered_map<uint16_t, std::vector<uint32_t> > data = {});
 
 
    // ------------------------- Public typedefs -------------------------------
 
    using RODMinorVersion = std::pair<uint8_t,uint8_t>;
 
 
    // ------------------------- Stream tags getters/setters -------------------
 
    const std::vector<eformat::helper::StreamTag>& getStreamTags() const;
 
    std::vector<eformat::helper::StreamTag>& getStreamTagsNonConst();
 
    StatusCode setStreamTags(const std::vector<eformat::helper::StreamTag>& streamTags);
 
    StatusCode addStreamTag(const eformat::helper::StreamTag& streamTag);
 
 
    // ------------------------- HLT bits getters/setters ----------------------
 
    const boost::dynamic_bitset<uint32_t>& getHltPassRawBits() const;
 
    const boost::dynamic_bitset<uint32_t>& getHltPrescaledBits() const;
 
    const std::vector<uint32_t>& getHltBitsAsWords() const;
 
    void setHltPassRawBits(const boost::dynamic_bitset<uint32_t>& bitset);
 
    void setHltPrescaledBits(const boost::dynamic_bitset<uint32_t>& bitset);
 
    void setHltBits(const boost::dynamic_bitset<uint32_t>& passRawBitset,
                    const boost::dynamic_bitset<uint32_t>& prescaledBitset);
 
 
    // ------------------------- Serialised data getters/setters ---------------
 
    const std::unordered_map<uint16_t, std::vector<uint32_t> >& getSerialisedData() const;
 
    StatusCode getSerialisedData(const uint16_t moduleId, const std::vector<uint32_t>*& data) const;
 
    void setSerialisedData(std::unordered_map<uint16_t, std::vector<uint32_t> > data);
 
    void addSerialisedData(const uint16_t moduleId, const std::vector<uint32_t>& data);
 
    StatusCode addSerialisedDataWithCheck(const uint16_t moduleId, std::vector<uint32_t> data);
 
 
    // ------------------------- Error codes getters/setters -------------------
    // The event processing status is stored as one bit-mask word corresponding to eformat::helper::Status
    // and n optional error codes. Online HLT framework uses them to store HLT::OnlineErrorCode.
 
    const std::vector<uint32_t>& getStatus() const;
 
    const std::vector<HLT::OnlineErrorCode> getErrorCodes() const;
 
    void setStatus(std::vector<uint32_t> status);
 
    void addErrorCode(const HLT::OnlineErrorCode& errorCode,
                      const eformat::helper::Status& firstStatusWord = {
                        eformat::GenericStatus::DATA_CORRUPTION,
                        eformat::FullEventStatus::PSC_PROBLEM
                      });
 
    const std::vector<uint32_t>& getRobStatus(uint16_t moduleId) const;
 
    // ------------------------- Version getters/setters -----------------------
    // The format of the HLT ByteStream (ROD payload) and the interpretation of the HLT-specific information
    // in the full event header are versioned by the ROD minor version of the HLT ROBFragments
 
    RODMinorVersion getVersion() const;
 
    void setVersion(RODMinorVersion version);
 
 
    // ------------------------- Truncation information ------------------------
 
    const std::set<uint16_t>& getTruncatedModuleIds() const;
 
    void addTruncatedModuleId(const uint16_t moduleId, bool severeTruncation=true);
 
    bool severeTruncation() const { return m_severeTruncation; }
 
    // ------------------------- Extra helper methods --------------------------
    bool isAccepted() const {return !m_streamTags.empty();}
 
  private:
    // ------------------------- Private data members --------------------------
 
    std::vector<eformat::helper::StreamTag> m_streamTags;
 
    boost::dynamic_bitset<uint32_t> m_hltPassRawBits;
    boost::dynamic_bitset<uint32_t> m_hltPrescaledBits;
 
    std::vector<uint32_t> m_hltBitWords;
 
    std::unordered_map<uint16_t, std::vector<uint32_t> > m_data;
 
    std::vector<uint32_t> m_status;
 
    std::unordered_map<uint16_t, std::vector<uint32_t>> m_robStatus;
 
    RODMinorVersion m_version;
 
    std::set<uint16_t> m_truncatedModuleIds;
 
    bool m_severeTruncation{false};
 
    // ------------------------- Private helper methods ------------------------
 
    void updateHltBitWords();
  };
} // namespace HLT
 
std::ostream& operator<<(std::ostream& str, const HLT::HLTResultMT& hltResult);
 
CLASS_DEF(HLT::HLTResultMT, 172156324, 1)
 
#endif // TRIGSTEERINGEVENT_HLTResultMT_H