TrigNavSlimmingMTAlg.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef TRIGNAVSLIMMINGMT_TRIGNAVSLIMMINGMTALG_H
#define TRIGNAVSLIMMINGMT_TRIGNAVSLIMMINGMTALG_H
 
#include "AthenaBaseComps/AthReentrantAlgorithm.h"
 
#include "StoreGate/WriteHandle.h"
#include "StoreGate/ReadHandle.h"
 
#include "TrigCompositeUtils/HLTIdentifier.h"
#include "TrigCompositeUtils/TrigCompositeUtils.h"
#include "TrigCompositeUtils/NavGraph.h"
 
#include "xAODParticleEvent/ParticleContainer.h"
#include "xAODTrigMissingET/TrigMissingETContainer.h"
#include "TrigSteeringEvent/TrigRoiDescriptorCollection.h"
 
#include "TrigDecisionTool/TrigDecisionTool.h"
 
#include "CxxUtils/checker_macros.h"
#include <mutex>

class TrigNavSlimmingMTAlg : public AthReentrantAlgorithm {
public:
  TrigNavSlimmingMTAlg(const std::string& name, ISvcLocator* pSvcLocator);
  virtual StatusCode initialize() override;
  virtual StatusCode execute (const EventContext& ctx) const override;
 
private:
 
  typedef std::map<const TrigCompositeUtils::Decision*, TrigCompositeUtils::Decision*> IOCacheMap;
 
  struct Outputs {
    SG::WriteHandle<TrigRoiDescriptorCollection>* rois;
    SG::WriteHandle<xAOD::ParticleContainer>* particles;
    SG::WriteHandle<xAOD::TrigMissingETContainer>* mets;
    SG::WriteHandle<xAOD::TrigCompositeContainer>* nav;
  };
 
  SG::ReadHandleKey<xAOD::TrigCompositeContainer> m_primaryInputCollection{
    this, "PrimaryInputCollection", "HLTNav_Summary",
    "Input collection containing the HLTPassRaw terminus node of the navigation."};
 
  SG::WriteHandleKey<xAOD::TrigCompositeContainer> m_outputCollection{
    this, "OutputCollection", "HLTNav_Summary_ESDSlimmed",
    "Single output collection containing the slimmed navigation nodes."};
 
  SG::WriteHandleKey<TrigRoiDescriptorCollection> m_outputRepackedROICollectionKey{
    this, "RepackROIsOutputCollection", "HLTNav_RepackedROIs",
    "Single output collection containing any repacked ROIs (use with RepackROIs)."};
 
  SG::WriteHandleKey<xAOD::ParticleContainer> m_outputRepackedFeaturesCollectionKey_Particle{
    this, "RepackFeaturesOutputCollection_Particle", "HLTNav_RepackedFeatures_Particle",
    "Single output collection containing any repacked Particle features (use with RepackFeatures)."};
 
  SG::WriteHandleKey<xAOD::TrigMissingETContainer> m_outputRepackedFeaturesCollectionKey_MET{
    this, "RepackFeaturesOutputCollection_MET", "HLTNav_RepackedFeatures_MET",
    "Single output collection containing any repacked IParticle features (use with RepackFeatures)."};
 
  Gaudi::Property<bool> m_keepFailedBranches{
    this, "KeepFailedBranched", true,
    "Keep nodes which are in branches of the graph which fail selection for all triggers, these are used by T0 monitoring."};
 
  Gaudi::Property<bool> m_keepOnlyFinalFeatures{
    this, "KeepOnlyFinalFeatures", false,
    "Keeps only the final features which accepted a chain. Fine for analysis-use."};
 
  Gaudi::Property<bool> m_removeEmptySteps{
    this, "RemoveEmptySteps", false,
    "Slim away ComboHypo->InputMaker empty step pairs which come from parallel chain alignment (special case: keep if C.H. adds a feature, e.g. BLS). Fine for analysis-use."};
 
  Gaudi::Property<bool> m_propagatePrescaledNode{
    this, "PropagatePrescaledNode", false,
    "Copies the 'HLTPrescaled' node (if it exists) from the input to output navigation collection. If it does not exist, it can be re-created from the xAOD::TriggerDecision"};
 
  Gaudi::Property<bool> m_propagateL1Nodes{
    this, "PropagateL1Nodes", false,
    "Copies the 'L1TAP' and 'L1TAV' nodes (if they exists) from the input to output navigation collection. If they do not exist, they can be re-created from the xAOD::TriggerDecision"};
 
  Gaudi::Property<bool> m_repackROIs{
    this, "RepackROIs", false,
    "Re-pack the target of all 'roi' and 'initialRoI' edges into a single container (WriteHandle defined above)"};
 
  Gaudi::Property<bool> m_repackMET{
    this, "RepackMET", false,
    "Re-pack the target of all 'feature' edges to xAOD::TrigMissingET objects into a single container (WriteHandle defined above)"};
 
  Gaudi::Property<bool> m_repackFeatures{
    this, "RepackFeatures", false,
    "Re-pack the target of all 'feature' edges into a small number of containers (WriteHandle defined above)"};
 
  Gaudi::Property<std::vector<std::string>> m_repackFeaturesExclusionList{
    this, "RepackFeaturesExclusionList", {},
    "Optional list of StoreGate key strings. If strings are provided and RepackFeatures is true, then 'feature' edges  "
    "whose StoreGate key is an exact match to an entry on the supplied list will not be re-packed and will be left unchanged"};
 
  Gaudi::Property<std::vector<std::string>> m_edgesToDrop{
    this, "EdgesToDrop", {"view"},
    "Any edges within the set of names will be dropped as part of the thinning"};
 
  Gaudi::Property<std::vector<std::string>> m_nodesToDrop{
    this, "NodesToDrop", {"F"},
    "Any nodes within the set of names will be dropped as part of the thinning and the navigation re-wired around them"};
 
  Gaudi::Property<std::vector<std::string>> m_allOutputContainers{
    this, "AllOutputContainers", {},
    "List of SG keys of all possible output containers at differing verbosity. Used to stop different instances of the alg interfering with each other."};
 
  Gaudi::Property<bool> m_applyChainsFilterToSummaryNodes{
    this, "ApplyChainsFilterToSummaryNodes", true,
    "If the ChainsFilter (if supplied) should be applied to the terminus, express terminus and prescaled nodes. "
    "If set to false, the trigger decision for any chain may be obtained from the navigation at the expense of additional file size."};
 
  Gaudi::Property<std::vector<std::string>> m_chainsFilter{
    this, "ChainsFilter", {},
    "Optional list of HLT chains. If provided, only navigation data corresponding to these chains will be kept. "
    "Matching multiple chains via regular expressions is supported."};
 
  PublicToolHandle<Trig::TrigDecisionTool> m_trigDec{
    this, "TrigDecisionTool", "Trig::TrigDecisionTool/TrigDecisionTool",
    "Trigger Decision Tool, used to apply the ChainsFilter"};
 
  Gaudi::Property<bool> m_runtimeValidation{
    this, "RuntimeValidation", false,
    "Perform additional validation checks on the navigation, and print WARNINGs if anything out of the ordinary is found."};
 
  std::set<std::string> m_allOutputContainersSet; 

  struct CachedChainInfo {
    TrigCompositeUtils::DecisionID chainID;
    std::vector<TrigCompositeUtils::DecisionID> legIDs;
  };
  mutable std::once_flag m_chainIDsCacheFlag ATLAS_THREAD_SAFE;
  mutable std::vector<CachedChainInfo> m_cachedChainInfo ATLAS_THREAD_SAFE; // protected by m_chainIDsCacheFlag
  mutable bool m_chainIDsCacheOK ATLAS_THREAD_SAFE {false}; // protected by m_chainIDsCacheFlag

  StatusCode cacheChainInfo() const;
 

  StatusCode createPresaledGraphNode(Outputs& outputContainers, const TrigCompositeUtils::DecisionIDContainer& chainIDs) const;

  StatusCode createL1GraphNodes(Outputs& outputContainers) const;

  StatusCode inputToOutput(
    const TrigCompositeUtils::Decision* input, 
    TrigCompositeUtils::Decision** output,
    IOCacheMap& cache, 
    Outputs& outputContainers, 
    const TrigCompositeUtils::DecisionIDContainer& chainIDs, 
    const EventContext& ctx) const;

  StatusCode propagateLinks(
    const TrigCompositeUtils::Decision* input, 
    TrigCompositeUtils::Decision* output) const;

  StatusCode propagateDecisionIDs(
    const TrigCompositeUtils::Decision* input,
    TrigCompositeUtils::Decision* output,
    const TrigCompositeUtils::DecisionIDContainer& chainIDs) const;

  StatusCode propagateSeedingRelation(  
    const TrigCompositeUtils::NavGraphNode* inputNode, 
    IOCacheMap& cache,
    const EventContext& ctx) const;

  StatusCode repackLinks(
    TrigCompositeUtils::Decision* output,
    Outputs& outputContainers) const;

  void printIParticleRepackingDebug(
    const TrigCompositeUtils::Decision* output,
    const std::string& when) const;

  std::vector<size_t> lookupHardCodedLegMultiplicities(const std::string& chain) const;

  template< typename COLLECTION >
  StatusCode doRepack(TrigCompositeUtils::Decision* decision,
    SG::WriteHandle<COLLECTION>* writeHandle,
    const std::string& edgeName) const;

  template< typename COLLECTION >
  StatusCode doRepackCopy(const typename COLLECTION::base_value_type* object,
    SG::WriteHandle<COLLECTION>* writeHandle) const;
 
};
 
#include "TrigNavSlimmingMTAlg.icc"
 
#endif // TRIGNAVSLIMMINGMT_TRIGNAVSLIMMINGMTALG_H