TrigCompositeUtils.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef TrigCompositeUtils_TrigCompositeUtils_h
#define TrigCompositeUtils_TrigCompositeUtils_h
 
#include <set>
#include <memory>
#include <functional>
 
#include "AthLinks/ElementLink.h"
#include "AsgDataHandles/WriteHandle.h"
#include "AsgDataHandles/ReadHandle.h"
#include "AsgDataHandles/WriteHandleKey.h"
#include "AsgDataHandles/ReadHandleKey.h"
#include "AsgTools/EventStoreType.h"
#include "AsgMessaging/MsgStream.h"
#include "AsgMessaging/MessageCheck.h"
 
 
#ifdef XAOD_STANDALONE
#include "AsgTools/SgTEvent.h"
#endif
 
#include "AthContainers/AuxElement.h"
#include "xAODTrigger/TrigCompositeContainer.h"
#include "xAODTrigger/TrigCompositeAuxContainer.h"
 
#include "TrigDecisionInterface/Conditions.h"
 
#include "HLTIdentifier.h"
#include "NavGraph.h"
#include "TrigCompositeUtils/LinkInfo.h"
#include "TrigCompositeUtils/IPartCombItr.h"
#include "TrigCompositeUtils/Combinations.h"
#include "TrigConfHLTData/HLTChain.h"
#include "CxxUtils/sgkey_t.h"
 
#define TRIGCOMPUTILS_ENABLE_EARLY_EXIT 1
 
namespace TrigCompositeUtils {
  using sgkey_t = SG::sgkey_t;
 
  // cppcheck-suppress unknownMacro
  ANA_MSG_HEADER (msgRejected)
 
  
  typedef SG::WriteHandle<DecisionContainer> DecisionWriteHandle;
 
  template<class CONT>
    SG::WriteHandle<CONT> createAndStoreNoAux( const SG::WriteHandleKey<CONT>& key, const EventContext& ctx );
 
  template<class CONT, class AUX>
    SG::WriteHandle<CONT> createAndStoreWithAux( const SG::WriteHandleKey<CONT>& key, const EventContext& ctx );
 
  SG::WriteHandle<DecisionContainer> createAndStore( const SG::WriteHandleKey<DecisionContainer>& key, const EventContext& ctx );
 
  void createAndStore( SG::WriteHandle<DecisionContainer>& handle );
 
  Decision* newDecisionIn ( DecisionContainer* dc, const std::string& name = "" );
 
  Decision* newDecisionIn( DecisionContainer* dc, const Decision* dOld, const std::string& name, const EventContext& ctx );
 
  void addDecisionID( DecisionID id,  Decision* d);
 
  void insertDecisionIDs( const Decision* src, Decision* dest );
 
  void insertDecisionIDs( const DecisionIDContainer& src, Decision* dest );
 
  void uniqueDecisionIDs( Decision* dest);
 
      
  void decisionIDs( const Decision* d, DecisionIDContainer& id );
 
  const std::vector<DecisionID>& decisionIDs( const Decision* d ); 
 
  std::vector<DecisionID>& decisionIDs( Decision* d );
 
  
  bool allFailed( const Decision* d );
 
  template<typename T>
  DecisionIDContainer passedDecisionIDs( const Decision* d, const T& required );
 
  bool isAnyIDPassing( const Decision* d,  const DecisionIDContainer& required);
 
  bool passed( DecisionID id, const DecisionIDContainer& );
 
  ElementLink<DecisionContainer> decisionToElementLink(const Decision* d, const EventContext& ctx);
  
  void linkToPrevious(Decision* d, const std::string& previousCollectionKey, size_t previousIndex);
 
  void linkToPrevious(Decision* d, const Decision* dOld, const EventContext& ctx);
 
  bool hasLinkToPrevious(const Decision* d);
 
  const std::vector<ElementLink<DecisionContainer>> getLinkToPrevious(const Decision*);
 
  bool copyLinks(const Decision* src, Decision* dest);
 
  HLT::Identifier createLegName(const HLT::Identifier& chainIdentifier, size_t counter);
 
  HLT::Identifier createLegName(const std::string& name, size_t counter);
 
  HLT::Identifier getIDFromLeg(const HLT::Identifier& legIdentifier);
 
  int32_t getIndexFromLeg(const HLT::Identifier& legIdentifier); 
 
  int32_t getIndexFromLeg(const std::string& name);
 
  std::pair<std::string, int32_t> getNameAndIndexFromLeg(const std::string& name);
 
  bool isLegId(const HLT::Identifier& legIdentifier);
 
  bool isLegId(const std::string& name);
 
  bool isChainId(const HLT::Identifier& chainIdentifier);
 
  bool isChainId(const std::string& name);
    
  const Decision* find(const Decision*, const std::function<bool(const Decision*)>& filter);
 
  class HasObject {
  public:
    HasObject(const std::string& name): m_name(name) {}
    bool operator()(const Decision* ) const;
  private:
    std::string m_name;
  };
 
  class HasObjectCollection {
  public:
    HasObjectCollection(const std::string& name): m_name(name) {}
    bool operator()(const Decision* ) const;
  private:
    std::string m_name;
  };
 
 
  const Decision* getTerminusNode(const DecisionContainer& container);
  const Decision* getTerminusNode(SG::ReadHandle<DecisionContainer>& container); // older signature
 
 
  const Decision* getExpressTerminusNode(const DecisionContainer& container);
 
 
  const Decision* getNodeByName(const DecisionContainer& container, const std::string& nodeName);
  
 
  std::vector<const Decision*> getRejectedDecisionNodes(const asg::EventStoreType* eventStore,
    const EventContext& ctx,
    const std::string& summaryCollectionKey,
    const DecisionIDContainer& ids = {},
    const std::set<std::string>& keysToIgnore = std::set<std::string>());
 
 
  void recursiveGetDecisions(const Decision* node, 
    NavGraph& navGraph, 
    const DecisionIDContainer& ids = {},
    const bool enforceDecisionOnStartNode = true);
 
 
  void recursiveGetDecisionsInternal(const Decision* node, 
    const Decision* comingFrom,
    NavGraph& navGraph,
    std::set<const Decision*>& fullyExploredFrom,
    const DecisionIDContainer& ids,
    const bool enforceDecisionOnNode);
 
 
  void recursiveFlagForThinning(NavGraph& node, 
    const bool keepOnlyFinalFeatures,
    const bool removeEmptySteps,
    const std::vector<std::string>& nodesToDrop);
 
 
  void recursiveFlagForThinningInternal(NavGraphNode* node, 
    bool modeKeep,
    std::set<NavGraphNode*>& fullyExploredFrom,
    const bool keepOnlyFinalFeatures,
    const bool removeEmptySteps,
    const std::vector<std::string>& nodesToDrop);
 
 
  inline const std::string& initialRoIString() { return Decision::s_initialRoIString; }
  inline const std::string& initialRecRoIString() { return Decision::s_initialRecRoIString; }
  inline const std::string& roiString() { return Decision::s_roiString; }
  inline const std::string& viewString() { return Decision::s_viewString; }
  inline const std::string& featureString() { return Decision::s_featureString; }
  inline const std::string& seedString() { return Decision::s_seedString; }
 
  inline const std::string& hltSeedingNodeName() { return Decision::s_hltSeedingNodeNameString; }
  inline const std::string& filterNodeName() { return Decision::s_filterNodeNameString; }
  inline const std::string& inputMakerNodeName() { return Decision::s_inputMakerNodeNameString; }
  inline const std::string& hypoAlgNodeName() { return Decision::s_hypoAlgNodeNameString; }
  inline const std::string& comboHypoAlgNodeName() { return Decision::s_comboHypoAlgNodeNameString; }
  inline const std::string& summaryFilterNodeName() { return Decision::s_summaryFilterNodeNameString; }
  inline const std::string& summaryPassNodeName() { return Decision::s_summaryPassNodeNameString; }
  inline const std::string& summaryPassExpressNodeName() { return Decision::s_summaryPassExpressNodeNameString; }
  inline const std::string& summaryPrescaledNodeName() { return Decision::s_summaryPrescaledNodeNameString; }
 
  template<class CONTAINER>
  void filterLinkVectorByContainerKey(const std::string& containerSGKey, std::vector<ElementLink<CONTAINER>>& vector);
 
  template<class CONTAINER>
  const std::vector< LinkInfo<CONTAINER> > recursiveGetFeaturesOfType( 
    const NavGraph& navGraph, 
    const std::string& containerSGKey = "",
    const unsigned int behaviour = TrigDefs::lastFeatureOfType,
    const std::string& navElementLinkKey = featureString(),
    const DecisionIDContainer& chainIDs = DecisionIDContainer());
 
  template<class CONTAINER>
  void recursiveGetFeaturesOfTypeInternal(
    std::vector< LinkInfo<CONTAINER> >& features, 
    std::set<const NavGraphNode*>& fullyExploredFrom,
    const NavGraphNode* navGraphNode, 
    const std::string& containerSGKey,
    const unsigned int behaviour,
    const std::string& navElementLinkKey,
    const DecisionIDContainer& chainIDs);
 
  template<typename T>
  LinkInfo<T>
  findLink(const Decision* start, 
    const std::string& linkName, 
    const bool suppressMultipleLinksWarning = false);
 
  template<typename T>
  void
  findLinks(const Decision* start, 
    const std::string& linkName,
    std::vector<LinkInfo<T>>& links, 
    unsigned int behaviour = TrigDefs::allFeaturesOfType, 
    std::set<const xAOD::TrigComposite*>* fullyExploredFrom = nullptr);
 
  template<typename T>
  std::vector<LinkInfo<T>>
  findLinks(const Decision* start,
    const std::string& linkName,
    unsigned int behaviour = TrigDefs::allFeaturesOfType);
 
  bool typelessFindLink(const Decision* start, 
    const std::string& linkName,
    sgkey_t& key,
    uint32_t& clid,
    Decision::index_type& index,
    const Decision*& source,
    const bool suppressMultipleLinksWarning = false);
 
  bool typelessFindLink(const NavGraph& subGraph, 
    const std::string& linkName,
    sgkey_t& key,
    uint32_t& clid,
    Decision::index_type& index,
    const Decision*& source,
    const bool suppressMultipleLinksWarning = false);
 
  bool typelessFindLinks(const Decision* start, 
    const std::string& linkName,
    std::vector<sgkey_t>& keyVec,
    std::vector<uint32_t>& clidVec,
    std::vector<Decision::index_type>& indexVec,
    std::vector<const Decision*>& sourceVec,
    const unsigned int behaviour = TrigDefs::allFeaturesOfType, 
    std::set<const Decision*>* fullyExploredFrom = nullptr);
 
  bool typelessFindLinks(const NavGraphNode* start, 
    const std::string& linkName,
    std::vector<sgkey_t>& key,
    std::vector<uint32_t>& clid,
    std::vector<Decision::index_type>& index,
    std::vector<const Decision*>& sourceVec,
    const unsigned int behaviour = TrigDefs::allFeaturesOfType, 
    std::set<const Decision*>* fullyExploredFrom = nullptr);
 
  bool typelessFindLinksCommonLinkCollection(const Decision* start,
    const std::string& linkName,
    std::vector<sgkey_t>& keyVec, 
    std::vector<uint32_t>& clidVec,
    std::vector<Decision::index_type>& indexVec, 
    std::vector<const Decision*>& sourceVec);
 
  Combinations buildCombinations(
    const std::string& chainName,
    const std::vector<LinkInfo<xAOD::IParticleContainer>>& features,
    const std::vector<std::size_t>& legMultiplicities,
    const std::function<bool(const std::vector<LinkInfo<xAOD::IParticleContainer>>&)>& filter);
 
  Combinations buildCombinations(
    const std::string& chainName,
    const std::vector<LinkInfo<xAOD::IParticleContainer>>& features,
    const std::vector<std::size_t>& legMultiplicities,
    FilterType filter = FilterType::UniqueObjects);
 
  Combinations buildCombinations(
    const std::string& chainName,
    const std::vector<LinkInfo<xAOD::IParticleContainer>>& features,
    const TrigConf::HLTChain *chainInfo,
    const std::function<bool(const std::vector<LinkInfo<xAOD::IParticleContainer>>&)>& filter);
 
  Combinations buildCombinations(
    const std::string& chainName,
    const std::vector<LinkInfo<xAOD::IParticleContainer>>& features,
    const TrigConf::HLTChain *chainInfo,
    FilterType filter = FilterType::UniqueObjects);
    
  std::string dump( const Decision*  tc, const std::function< std::string( const Decision* )>& printerFnc );
 
}
 
#include "TrigCompositeUtils/TrigCompositeUtils.icc"
 
#endif // TrigCompositeUtils_TrigCompositeUtils_h