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 <regex>
 
#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 "SGCore/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,
    CLID& clid,
    Decision::index_type& index,
    const Decision*& source,
    const bool suppressMultipleLinksWarning = false);

  bool typelessFindLink(const NavGraph& subGraph,
    const std::string& linkName,
    sgkey_t& key,
    CLID& 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<CLID>& 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<CLID>& 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<CLID>& 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