HLTResult.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
#pragma once
// emacs -*- c++ -*-
#ifndef TRIGSTEERINGEVENT_HLTResult_H
#define TRIGSTEERINGEVENT_HLTResult_H
 
#include <vector>
#include <map>
#include <string>
#include <set>
#include <stdint.h>
#include "TrigSteeringEvent/Enums.h"
#include "TrigSteeringEvent/GenericResult.h"
 
#ifdef XAOD_STANDALONE
#include "xAODCore/ClassID_traits.h"
#else
#include "GaudiKernel/IClassIDSvc.h"
#endif
 
#include "xAODCore/CLASS_DEF.h"
 
/****************************************************************************************
 * (June 2006; comments on documentation to: Andreas.Hoecker@cern.ch)
 * Oct 2006;  Tomasz.Bold@cern.ch removed most of internal variables, general restructure
 *            removed most of the methods
 * HLTResult implements a GenericResult which is communcated between PSC and HLT.
 *
 ****************************************************************************************/
namespace HLT {
 
  class HLTExtraData;
  
  class HLTResult : public GenericResult {
 
  public:
    friend void swap(HLTResult& lhs, HLTResult& rhs);
  
    HLTResult(); //<! Default ctor
    HLTResult(const HLTResult&); 
    HLTResult(HLTResult&& rhs); 
    HLTResult& operator=(HLTResult rhs); 
    ~HLTResult(); //<! Dtor
 
    virtual inline bool accepted() const { return isAccepted(); }
 
    virtual bool error() const ;
 
    virtual uint32_t error_bits() const ;
 
    bool serialize(std::vector<uint32_t>& output, const unsigned int mod_id);
 
    bool serialize( std::vector<uint32_t>& output );
 
    bool serialize( uint32_t*& output, int& data_size, const int max_size = -1, const unsigned int mod_id = 0 );
 
    bool deserialize( const std::vector<uint32_t>& source );
 
    bool deserialize(  uint32_t* source, const int data_size );
 
    /*
     * @brief ---- Trigger masks ----
     * here fill mask of all chains according to chain counter
     * best would be to send names of all existing signatures,
     * their active/inactive flags, and pass-through/prescale information
     * (need to enumerate chains in configuration)
     * corresponding functions should contain:
     *    trigger-mask for each step
     *    add chain/retrieve chain/serialize/deserialize
     */
 
    uint32_t getHLTResultClassVersion() const { return m_HLTResultClassVersion; }
 
    inline uint32_t   getLvl1Id() const { return m_headerResult[IndEventNumber]; }
 
    inline void       setLvl1Id( uint32_t id ) { m_headerResult[IndEventNumber] = id; }
 
    inline bool      isAccepted() const { return (m_headerResult[IndHLTDecision] == 1 ? true : false); }
 
    inline void      setAccepted( bool acc ) { acc ? (m_headerResult[IndHLTDecision] = 1) : (m_headerResult[IndHLTDecision] = 0); }
 
    inline bool      isPassThrough() const { return m_headerResult[IndPassThrough]; }
    inline void      setPassThrough( bool fa ) { fa ? (m_headerResult[IndPassThrough] = 1) : (m_headerResult[IndPassThrough] = 0) ; }
 
    inline ErrorCode getHLTStatus() const { return  ErrorCode(m_headerResult[IndHLTStatus]); }
    inline void      setHLTStatus( ErrorCode hltStatus ) { m_headerResult[IndHLTStatus] = hltStatus; }
 
    inline ErrorCode getLvlConverterStatus() const { return ErrorCode(m_headerResult[IndLvlConverterStatus]); }
    inline void      setLvlConverterStatus( ErrorCode status ) { m_headerResult[IndLvlConverterStatus] = status; }
 
    inline HLTLevel   getHLTLevel() const { return (HLTLevel)m_headerResult[IndHLTLevelInfo]; }
    inline void       setHLTLevel( HLTLevel hltLevel ) { m_headerResult[IndHLTLevelInfo] = hltLevel; }
    
    inline bool       isValid() const { return (getHLTLevel() != HLT::UNKNOWN); }
 
    inline uint32_t   getNumOfSatisfiedSigs() const { return m_headerResult[IndNumOfSatisfiedSigs]; }
 
    inline void       setNumOfSatisfiedSigs( uint32_t sigs ) { m_headerResult[IndNumOfSatisfiedSigs] = sigs; }
 
    inline void      setErrorCoordinates( unsigned int chainCounter=0, unsigned int step=0 ) {
      m_headerResult[IndErrorInChain] = chainCounter;  m_headerResult[IndErrorInStep] = step; };
 
    inline void      getErrorCoordinates( unsigned int & chainCounter, unsigned int & step ) const {
      chainCounter = m_headerResult[IndErrorInChain]; step = m_headerResult[IndErrorInStep]; }
 
 
    bool       isCreatedOutsideHLT() const { return (m_headerResult[IndCreatedOutsideHLT] == 0 ? false: true); } // previously "hasBeenCreated"
    void       setCreatedOutsideHLT( bool created ) { created ? (m_headerResult[IndCreatedOutsideHLT] = 1) : (m_headerResult[IndCreatedOutsideHLT] = 0) ; }
 
    
    void       setConfigSuperMasterKey(uint32_t key);
 
    uint32_t    getConfigSuperMasterKey() const;
 
 
    void       setConfigPrescalesKey(uint32_t key);
 
    uint32_t    getConfigPrescalesKey() const;
 
 
    bool       isHLTResultTruncated() const { return (m_headerResult[IndHLTResultTruncated] == 0 ? false : true); }
    void       setHLTResultTruncated( bool truncated) {
      m_headerResult[IndHLTResultTruncated] = truncated ? 1 : 0;
    }
 
    const std::vector<uint32_t>& getNavigationResult() const { return m_navigationResult; }
    const std::vector<uint32_t>& getNavigationResult_DSonly() const { return m_navigationResult_DSonly; }
    const std::vector<uint32_t>& getChainResult     () const { return m_chainsResult; }
    const std::vector<uint32_t>& getExtras() const { return m_extras; }
 
    std::vector<unsigned int>& getNavigationResultCuts() { return m_navigationResultCuts; }
    const std::vector<unsigned int>& getNavigationResultCuts() const { return m_navigationResultCuts; }
     
    std::vector<unsigned int>& getNavigationResultCuts_DSonly() { return m_navigationResultCuts_DSonly; }
    const std::vector<unsigned int>& getNavigationResultCuts_DSonly() const { return m_navigationResultCuts_DSonly; }
 
    std::vector< std::pair <CLID, std::string> >& getNavigationResultIDName() { return m_id_name; }
    const std::vector< std::pair <CLID, std::string> >& getNavigationResultIDName() const { return m_id_name; }
    std::vector< std::pair <CLID, std::string> >& getNavigationResultIDName_DSonly() { return m_id_name_DSonly; }
    const std::vector< std::pair <CLID, std::string> >& getNavigationResultIDName_DSonly() const { return m_id_name_DSonly; }
 
    std::vector<uint32_t>& getNavigationResult() { return m_navigationResult; }
 
    std::vector<uint32_t>& getNavigationResult_DSonly() { return m_navigationResult_DSonly; }
 
    std::vector<uint32_t>& getChainResult     () { return m_chainsResult; }
 
 
    /*
     * @brief gets piece of extra information
     * @warning This method should not be used. Use getExtraData() to modify the payload object.
     */
    std::vector<uint32_t>& getExtras()       { return m_extras; }
 
    std::map<unsigned int, std::set<std::pair<CLID, std::string> > >& getScoutingMap() {return  m_modID_id_name;}
    const std::map<unsigned int, std::set<std::pair<CLID, std::string> > >& getScoutingMap() const {return  m_modID_id_name;}
    
    void  setScoutingMap(const std::map<unsigned int, std::set<std::pair<CLID, std::string> > >& map_modid_clid_name) {m_modID_id_name = map_modid_clid_name;}  
 
    /*
     * @brief Return object representing the extra payload
     */
    HLTExtraData& getExtraData();
 
    /*
     * @brief gets size of the rawResult (in words)
     */
    unsigned int size() const;
 
    /*
     * @brief gets sizes of 3 main parts of the result (in words)
     */
    std::vector<unsigned int> partSizes() const;
 
    bool isEmpty() const;
 
    // std::vector<std::pair<unsigned int, std::string> > getSatisfiedSigs();
 
    void listOfModIDs(std::vector<unsigned int>& mod_ids) const;
 
    std::vector<unsigned int> listOfModIDs() const;
    
 
  private:
    friend class HLTResultCnv_p1;
 
    enum InitBits { IndHLTResultClassVersion = 0,
            IndEventNumber,        
            IndHLTDecision,        
            IndPassThrough,        
            IndHLTStatus,          
            IndLvlConverterStatus, 
            IndHLTLevelInfo,       
            IndNumOfSatisfiedSigs, 
            IndErrorInChain,       
            IndErrorInStep,        
            IndCreatedOutsideHLT,  
            IndHLTResultTruncated, 
            IndConfigSuperMasterKey, 
            IndConfigPrescalesKey,   
            IndNumOfFixedBit       
    };
 
    using CutPairs = std::vector<std::pair<unsigned int, unsigned int>>;
    using CutPairVecs = std::pair<CutPairs, CutPairs>;
 
    /*
     * Serialize the regular result
     */
    bool serialize_regular(uint32_t*& output,
                           int& data_size,
                           int max_size);
 
    /*
     * Serialize the DS result corresponding to the given mod_id
     */
    bool serialize_DS(uint32_t*& output,
                      int& data_size,
                      int max_size,
                      unsigned int mod_id);
 
    /*
     * Bootstrap the serialization by serializing an initial portion of the end
     * result which is common to both regular and DS results
     */
    bool serialize_bootstrap(uint32_t*& output,
                             int& data_size,
                             bool& truncating,
                             int max_size,
                             unsigned int estimated_size);
 
    /*
     * Serialize the body of the regular result, that is, everything after the
     * bootstrap part
     */
    bool serialize_body_regular(uint32_t* output,
                                int& data_size,
                                unsigned int umax_size,
                                bool truncating) const;
 
    /*
     * Serialize the body of a DS result, that is, everything after the
     * bootstrap part
     */
    bool serialize_body_DS(uint32_t* output,
                           int& data_size,
                           unsigned int max_size,
                           unsigned int nav_size,
                           const CutPairVecs& dscuts,
                           bool truncating) const;
 
    /*
     * Serialize the navigation part of the regular result
     */
    bool serialize_navigation_reg(uint32_t* output,
                                  int& data_size,
                                  unsigned int umax_size,
                                  bool truncating) const;
 
    /*
     * Serialize the navigation part of a DS result
     */
    bool serialize_navigation_DS(uint32_t* output,
                                 int& data_size,
                                 unsigned int umax_size,
                                 unsigned int nav_size,
                                 const CutPairVecs& dscuts,
                                 bool truncating) const;
 
    /*
     * Update serialized extra data
     */
    void updateExtras();
 
    unsigned int estimateSize() const;
 
    static unsigned int calc_total_size_DS(unsigned int ds_nav_size);
 
    CutPairVecs findDSCuts(unsigned int) const;
 
    bool unpackFromStorable(const std::vector<uint32_t>& raw);
 
    static const uint32_t m_HLTResultClassVersion;
 
    std::vector<uint32_t>             m_headerResult;      
    std::vector<uint32_t>             m_chainsResult;      
    std::vector<uint32_t>             m_navigationResult;  
    std::vector<uint32_t>             m_navigationResult_DSonly;  
    std::vector<uint32_t>             m_extras;            
 
    std::vector< std::pair < CLID, std::string > >     m_id_name;
    
    std::vector< std::pair < CLID, std::string > >     m_id_name_DSonly;
    
    std::map<unsigned int, std::set<std::pair<CLID, std::string> > > m_modID_id_name; // map from rob module ID to class ID and collection name
 
    std::vector<unsigned int> m_navigationResultCuts;
 
    std::vector<unsigned int> m_navigationResultCuts_DSonly;
 
    HLTExtraData* m_extraData;     
 
  };
  
  void swap(HLTResult& lhs, HLTResult& rhs);
 
} // end namespace
 
CLASS_DEF(HLT::HLTResult, 107385089, 1)
 
#endif