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