NavigationCore.h

Go to the documentation of this file.

// Emacs -*- c++ -*-
 
/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
 
#ifndef TRIGNAVIGATION_HLTNAVIGATIONCORE_H
#define TRIGNAVIGATION_HLTNAVIGATIONCORE_H
 
#include <stdint.h>
#include <set>
#include <sstream>
#include <iostream>
 
#include "GaudiKernel/ClassID.h"
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/ServiceHandle.h"
 
#include "xAODCore/AuxSelection.h"
#include "AthenaBaseComps/AthAlgTool.h"
#include "AthContainers/OwnershipPolicy.h"
#include "AthContainers/DataVector.h"
#include "StoreGate/StoreGateSvc.h"
 
#include "TrigStorageDefinitions/EDM_TypeInfoMethods.h"
 
#include "TrigNavStructure/TrigNavStructure.h"
#include "TrigNavStructure/ITrigHolderFactory.h"
 
#include "TrigNavigation/Holder.h"
#include "TrigNavigation/TypeProxy.h"
#include "TrigNavigation/TypeMaps.h"
#include "TrigNavigation/TrigFeatureLink.h"
 
 
class StringSerializer;
 
class TrigNavigationThinningSvc;
 
namespace HLT {
  namespace TrigNavTools {
    struct SlimmingHelper;
  }

 
 
  class NavigationCore : public HLT::TrigNavStructure {
    friend class ::TrigNavigationThinningSvc;
    friend struct HLT::TrigNavTools::SlimmingHelper;
  public:
    NavigationCore(const AthAlgTool& logger);
    virtual ~NavigationCore() = default;

    virtual void prepare();
    virtual void reset(bool inFinalize = false);

    virtual bool serialize( std::vector<uint32_t>& output) const;
    bool serialize( std::vector<uint32_t>& output, std::vector<unsigned int>& cuts ) const;
    bool serialize( std::vector<uint32_t>& output, std::vector<unsigned int>& cuts, std::vector<std::pair<CLID, std::string> >& clid_name) const;
    bool serialize_DSonly( std::vector<uint32_t>& output, std::vector<unsigned int>& cuts, std::vector<std::pair<CLID, std::string> >& clid_name) const;
    bool deserialize( const std::vector<uint32_t>& input );

    enum MemoryManagement { ObjectInStoreGate = 1, ObjectToStoreGate = 2, ObjectCreatedByNew = 3 };
 

    template<class T> 
    bool getFeatures( const TriggerElement* te, std::vector< const T*>&  features, const std::string& label="", 
              std::map<const T*, std::string>* labels=0 ) const;
 
    template<class T> 
    bool getFeature( const TriggerElement* te, const T*&  features, const std::string& label="", std::string& sourcelabel = ::HLT::TrigNavStructure::m_unspecifiedLabel) const;
 
    template<class T> 
    bool getFeature( const TriggerElement* te,
                     const ConstDataVector<T>*&  features,
                     const std::string& label="", std::string& sourcelabel = ::HLT::TrigNavStructure::m_unspecifiedLabel) const;
 
    template<class T> 
    const T* featureLink2Object( const TrigFeatureLink& ) const;
 
    template<class T> 
    TrigFeatureLink object2FeatureLink(const TriggerElement* te, const std::string& label,
                       const T* obj) const;
 
 
    template<class C> 
    TrigFeatureLink object2FeatureLink(const TriggerElement* te, const std::string& label,
                       const typename Container2Object<C>::type * obj, 
                       const C* container) const;
 
    //const TriggerElement* te, const T*&  features, const std::string& label="", std::string& sourcelabel = m_unspecifiedLabel);
 
 
    template<class C, class T> 
    bool getFeaturesLinks( const TriggerElement* te, ElementLinkVector<C>& links, const std::string& label="") const;
 
    

    template<class T> 
    bool getRecentFeatures( const TriggerElement* te, 
                std::vector< const T*>&  features, const std::string& label="", 
                std::map<const T*, std::string>* labels=0 ) const;
 
    template<class T> 
    bool getRecentFeature( const TriggerElement* te, 
               const T*&  feature, const std::string& label="", 
               const TriggerElement*& source = ::HLT::TrigNavStructure::m_unspecifiedTE, 
               std::string& sourcelabel = ::HLT::TrigNavStructure::m_unspecifiedLabel ) const;
 
    template<class LinkType> 
    bool getRecentFeatureDataOrElementLink( const TriggerElement* te,
                LinkType& link, const std::string& label="",
                const TriggerElement*& source = ::HLT::TrigNavStructure::m_unspecifiedTE,
                        std::string& sourcelabel = ::HLT::TrigNavStructure::m_unspecifiedLabel) const;
 
    template<class C, class T> 
    bool getRecentFeaturesLinks( const TriggerElement* te,
                ElementLinkVector<C>& links, const std::string& label="" ) const;
 
    template<class C, class T> 
    bool getRecentFeatureLink( const TriggerElement* te,
                   ElementLink<C>& link, const std::string& label="", 
                   const TriggerElement*& source = ::HLT::TrigNavStructure::m_unspecifiedTE, 
                   std::string& sourcelabel = ::HLT::TrigNavStructure::m_unspecifiedLabel ) const;
 
    

 
 
    virtual bool getFeatureAccessors( const TriggerElement* te, class_id_type clid,
                                      const index_or_label_type& index_or_label,
                                      bool only_single_feature,
                                      TriggerElement::FeatureVec& features,
                                      bool travel_backward_recursively,
                                      const TriggerElement*& source = m_unspecifiedTE,
                                      std::string& sourcelabel  = m_unspecifiedLabel) const;
    
 
    virtual bool getFeatureAccessorsSingleTE( const TriggerElement* te, CLID clid,
                          const index_or_label_type& index_or_label,
                          bool only_single_feature,
                          TriggerElement::FeatureVec& features, 
                          const TriggerElement*& source = ::HLT::TrigNavStructure::m_unspecifiedTE,
                          std::string& sourcelabel  = ::HLT::TrigNavStructure::m_unspecifiedLabel) const;
 
      
    template<class T> bool getFeaturesInRoI( const TriggerElement* te,  std::vector<const T*>&  features, 
                         const std::string& label="", std::map<const T*, std::string>* labels=0 ) const;
 

    template<class C, class T> bool getAllFeatures( ElementLinkVector<C>&  features, const std::string& label="" ) const;
 
 

    template<class T, class C> static void registerFeatureContainer();
 
 

    bool merge(const NavigationCore& l2);

    static uint32_t string2hash( const std::string&, const std::string& category="TE" );
 

    void getAllOfType ( const std::string& id, 
            std::vector< HLT::TriggerElement* >& output,
            const bool activeOnly=true) const;
 
    using HLT::TrigNavStructure::getAllOfType;
   
    const AccessProxy* getAccessProxy() const {
      return m_storeGate;
    }
 
    template<class T> HLTNavDetails::Holder<T>* getHolder ( uint16_t subTypeIndex ) const;                             
  protected:
 
    // private stuff of Navigation class
 
 
    bool createHolder ( HLTNavDetails::IHolder*& holder, CLID clid, const std::string& label, uint16_t idx ) const;  
    bool registerHolder ( HLTNavDetails::IHolder* holder );
 
    template<class T> HLTNavDetails::Holder<T>* getHolder ( const std::string& label, uint16_t suggestedIndex ) const; 
 
    HLTNavDetails::IHolder*                     getHolder ( CLID clid, uint16_t subTypeIndex ) const;            
    HLTNavDetails::IHolder*                     getHolder ( CLID clid, const std::string& label ) const;         
 

    bool addOneLevel(std::vector< std::vector<TriggerElement*> >& currentCombs,
                     std::vector< std::vector<std::pair<unsigned int, unsigned int> > >& currentIdxs,
                     unsigned int type,
                     std::vector< std::vector<TriggerElement*> >& newCombs,
                     std::vector< std::vector<std::pair<unsigned int, unsigned int> > >& newIdxs,
                     unsigned int maxResults = 1000, bool onlyActive = 1);
 
 
    IConversionSvc*                        m_serializerSvc;
    StoreGateSvc*                          m_storeGate;
    std::string                            m_objectsKeyPrefix;      
    unsigned                               m_objectsIndexOffset;    
 
 
    ITrigHolderFactory* m_holderfactory;
 
    struct CSPair
    {
      CSPair (CLID clid, const std::string& key, xAOD::AuxSelection&& the_sel)
        : first (clid), second (key), sel (std::move (the_sel))
      {
      }
      CLID first;
      std::string second;
      xAOD::AuxSelection sel;
    };
 
    std::vector<std::string> m_classesToPayloadProperty;              
    std::vector<CSPair>  m_classesToPayload;   
    
    std::vector<std::string> m_classesToPayloadProperty_DSonly;              
    std::vector<CSPair>  m_classesToPayload_DSonly;   
 
    std::vector<std::string> m_classesFromPayloadIgnoreProperty;    
 
    std::vector<std::string> m_classesToPreregisterProperty;             
    std::vector<CSPair> m_classesToPreregister;   
 
    uint16_t nextSubTypeIndex(CLID clid, const std::string&label) const;
 
    bool extractBlob(const std::vector<uint32_t>& input,
             std::vector<uint32_t>::const_iterator& it,
             std::vector<uint32_t>& blob) const ;
 
  private:
    const AthAlgTool& m_logger;
 
    // Adapters so we can use ATH_MSG macros
    MsgStream& msg() const { return m_logger.msg(); }
    MsgStream& msg(const MSG::Level lvl) const { return msg() << lvl; }
    bool msgLvl(const MSG::Level lvl) const { return msg().level() <= lvl; }
 
    HLTNavDetails::IHolder* prepareOneHolder(CLID clid, const std::string& label);
 
    bool serializeWithHolderSection(const std::vector<uint32_t>& holderdata, const std::vector<unsigned int>& holderblobsizes,
                    std::vector<uint32_t>& output,std::vector<unsigned int>& cuts ,std::vector<std::pair<CLID, std::string> >& clid_name) const;
 
    bool serializeHoldersWithoutPayload(const std::vector<HLTNavDetails::IHolder*>& holders, std::vector<uint32_t>& output, std::vector<uint32_t>& holderblobsizes,std::vector<std::pair<CLID, std::string> >& clid_name) const;
 
    bool serializeHoldersWithPayload(const std::vector<CSPair>& payload, std::vector<uint32_t>& output, std::vector<uint32_t>& holderblobsizes,
                     std::vector<std::pair<CLID, std::string> >& clid_name) const;
 
  };
 
  MsgStream& operator<< ( MsgStream& m, const NavigationCore& nav ); //<! printing helper
 
} // eof namespace
 
#endif //#ifndef HLTNAVIGATION_H