Run2ToRun3TrigNavConverterV2.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
#ifndef TRIGNAVTOOLS_RUN2TORUN3TRIGNAVCONVERTERV2_H
#define TRIGNAVTOOLS_RUN2TORUN3TRIGNAVCONVERTERV2_H
 
// Framework includes
#include "AthenaBaseComps/AthReentrantAlgorithm.h"
#include "StoreGate/ReadHandleKey.h"
#include "StoreGate/WriteHandleKey.h"
#include "TrigSteeringEvent/Chain.h"
#include "xAODTrigger/TrigNavigation.h"
#include "TrigConfInterfaces/IHLTConfigSvc.h"
#include "GaudiKernel/IClassIDSvc.h"
#include "xAODTrigger/TrigComposite.h"
#include "xAODTrigger/TrigCompositeContainer.h"
#include "TrigCompositeUtils/TrigCompositeUtils.h"
#include "xAODBase/IParticleContainer.h"
#include "TrigNavStructure/Types.h"
#include "TrigNavStructure/TypedHolder.h"
#include "TrigNavStructure/TrigNavStructure.h"
#include "TrigSteeringEvent/TrigRoiDescriptorCollection.h"
#include "TrigDecisionTool/TrigDecisionTool.h"
#include "TrigConfHLTData/HLTSignature.h"
#include "TrigConfHLTData/HLTTriggerElement.h"
#include "TrigConfHLTUtils/HLTUtils.h"
 
// STL includes
#include <string>
#include <set>
#include <map>
 
// class of temporary objects used to integrate informations needed in conversion process
struct ConvProxy
{
  ConvProxy(const HLT::TriggerElement *te);
  bool isChild(const ConvProxy* other ) const; // returns true if the other isn children (any depth) to this node
  bool isParent(const ConvProxy* other ) const;
  bool mergeAllowed(const ConvProxy *other) const;
  void merge(ConvProxy *other); // this will change the also the "other" so it knows it has been merged
  const HLT::TriggerElement *te = nullptr;
  std::vector<HLT::te_id_type> teIDs; // post merging will contain IDs of all merged TEs
 
  std::set<ConvProxy *> children;
  std::set<ConvProxy *> parents;
  std::set<HLT::Identifier> runChains;
  std::set<HLT::Identifier> passChains;
  static const uint64_t MissingFEA = 0;
  uint64_t feaHash = MissingFEA;
 
  std::vector<HLT::TriggerElement::FeatureAccessHelper> features;
  std::vector<HLT::TriggerElement::FeatureAccessHelper> rois;
  std::vector<HLT::TriggerElement::FeatureAccessHelper> tracks;
 
  TrigCompositeUtils::Decision *l1Node{nullptr};
  TrigCompositeUtils::Decision *imNode{nullptr};
  std::vector<TrigCompositeUtils::Decision *> hNode;
  std::string description() const;
};
 
using ConvProxySet_t = std::set<ConvProxy *>;
using TEIdToChainsMap_t = std::map<HLT::te_id_type, std::set<HLT::Identifier>>;

class Run2ToRun3TrigNavConverterV2 : public AthReentrantAlgorithm
{
public:
  Run2ToRun3TrigNavConverterV2(const std::string &name, ISvcLocator *pSvcLocator);
  virtual ~Run2ToRun3TrigNavConverterV2() override;
 
  virtual StatusCode initialize() override;
  virtual StatusCode execute(const EventContext &context) const override;
  virtual StatusCode finalize() override;
 
private:
  // configurable properties & services
  SG::ReadHandleKey<xAOD::TrigNavigation> m_trigNavKey{this, "TrigNavReadKey", "TrigNavigation"};
  PublicToolHandle<Trig::TrigDecisionTool> m_tdt{this, "TrigDecisionTool", "", "When enabled read navigation from TDT/off by default"};
  ServiceHandle<TrigConf::IHLTConfigSvc> m_configSvc{this, "TrigConfigSvc", "TrigConf::xAODConfigSvc/xAODConfigSvc", "Trigger configuration service"};
  ServiceHandle<IClassIDSvc> m_clidSvc{this, "ClassIDSvc", "ClassIDSvc", "Service to translate CLID to class name"};
 
  Gaudi::Property<bool> m_doSelfValidation{this, "doSelfValidation", false, "Run consistency checks after stages of conversion (slows down the alg)"};
  Gaudi::Property<bool> m_doCompression{this, "doCompression", false, "Collapse navigation elements to save ouput space"};
  Gaudi::Property<bool> m_doLinkFeatures{this, "doLinkFeatures", true, "Add links to objects, setting it false makes sense when running tests"};
  Gaudi::Property<bool> m_includeTauTrackFeatures{this, "addTauTracks", false, "Add Tau Track collection as feature element"};
  Gaudi::Property<size_t> m_hNodesPerProxyThreshold{this, "hNodesPerProxyThreshhold", 15, "Limit number of H nodes per TE (if exceeded conversion results in an error)"};
  Gaudi::Property<std::vector<std::string>> m_chainsToSave{this, "Chains", {}, "If not specified, all chains are handled"};
  Gaudi::Property<std::vector<std::string>> m_collectionsToSave{this, "Collections", {}};
  Gaudi::Property<std::vector<std::string>> m_roisToSave{this, "Rois", {}};
 
  SG::WriteHandleKey<xAOD::TrigCompositeContainer> m_trigOutputNavKey{this, "OutputNavKey", "HLTNav_R2ToR3Summary"};
 
  StatusCode extractTECtoChainMapping(TEIdToChainsMap_t &allTES, TEIdToChainsMap_t &finalTEs) const;
  mutable std::mutex m_configUpdateMutex;
  TEIdToChainsMap_t m_allTEIdsToChains, m_finalTEIdsToChains;
 
  StatusCode mirrorTEsStructure(ConvProxySet_t &, const HLT::TrigNavStructure &run2Nav) const;
 
  StatusCode associateChainsToProxies(ConvProxySet_t &, const TEIdToChainsMap_t &) const;
 
  StatusCode cureUnassociatedProxies(ConvProxySet_t &) const;
 
  StatusCode removeUnassociatedProxies(ConvProxySet_t &) const;
 
  StatusCode doCompression(ConvProxySet_t &convProxies, const HLT::TrigNavStructure &run2Nav) const;
 
  StatusCode collapseFeaturesProxies(ConvProxySet_t &convProxies, const HLT::TrigNavStructure &run2Nav) const;
 
  StatusCode collapseFeaturelessProxies(ConvProxySet_t &) const;
 
  StatusCode removeTopologicalProxies(ConvProxySet_t & ) const;
 
  template <typename MAP>
  StatusCode collapseProxies(ConvProxySet_t &, MAP &) const;
 
  // StatusCode fillRelevantFeatures(ConvProxySet_t& convProxies) const;
  StatusCode fillRelevantFeatures(ConvProxySet_t &convProxies, const HLT::TrigNavStructure &run2Nav) const;
  StatusCode fillRelevantTracks(ConvProxySet_t &convProxies) const;
  StatusCode fillRelevantRois(ConvProxySet_t &convProxies, const HLT::TrigNavStructure &run2Nav) const;
 
  StatusCode createIMHNodes(ConvProxySet_t &, xAOD::TrigCompositeContainer &, const EventContext &) const;
  StatusCode createL1Nodes(const ConvProxySet_t &convProxies, xAOD::TrigCompositeContainer &decisions, const EventContext &context) const;
  StatusCode createSFNodes(const ConvProxySet_t &, xAOD::TrigCompositeContainer &, const TEIdToChainsMap_t &finalTEs, const EventContext &context) const;
  StatusCode updateTerminusNode(xAOD::TrigCompositeContainer &, const EventContext &context) const;
 
  StatusCode linkFeaNode(ConvProxySet_t &convProxies, xAOD::TrigCompositeContainer &, const HLT::TrigNavStructure &run2Nav, const EventContext &context) const;
  StatusCode linkRoiNode(ConvProxySet_t &convProxies, const HLT::TrigNavStructure &run2Nav) const;
  StatusCode linkTrkNode(ConvProxySet_t &convProxies, const HLT::TrigNavStructure &run2Nav) const;
 
  // helpers
  std::vector<HLT::TriggerElement::FeatureAccessHelper> filterFEAs(const std::vector<HLT::TriggerElement::FeatureAccessHelper> &feaVector, const HLT::TrigNavStructure &navigationDecoder) const;
  // produces summary of attached objects (FEAs) in a form of a hash
  uint64_t feaToHash(const std::vector<HLT::TriggerElement::FeatureAccessHelper> &feaVector, const HLT::TriggerElement *te_ptr, const HLT::TrigNavStructure &navigationDecoder) const;

  bool feaToSave(const HLT::TriggerElement::FeatureAccessHelper &fea, const std::string& sgName) const;
 
  bool roiToSave(const HLT::TrigNavStructure &run2Nav, const HLT::TriggerElement::FeatureAccessHelper &fea) const;
 
  // debugging aid, prints selected proxies
  void printProxies(const ConvProxySet_t& proxies,
                    std::function<bool(const ConvProxy*)> selector=[](const ConvProxy*){return true;},
                    const std::vector<std::function<void(const ConvProxy*)>>& printers={}) const;
 
  // useful printers
  std::function<void(const ConvProxy*)> m_chainIdsPrinter = [&](const ConvProxy* p){ for (auto id: p->passChains ) ATH_MSG_DEBUG("chain id " << id); };
  std::function<void(const ConvProxy*)> m_teIDPrinter = [&](const ConvProxy* p){ ATH_MSG_DEBUG("TE id " << TrigConf::HLTUtils::hash2string(p->te->getId())); };
 
  // return 0 if it is not tpological, else the step before topo merge
  size_t is2LegTopoChain(const TrigConf::HLTChain* ptrChain ) const;
 
 
  std::size_t getFeaSize(const ConvProxy &) const;

  std::pair<std::size_t, std::size_t> getHighestPtObject(const ConvProxy&,
                                                         const HLT::TrigNavStructure&) const;
 
  // self validators
  // they return failure if something is not ok
  StatusCode allProxiesHaveChain(const ConvProxySet_t &) const;
 
  StatusCode allProxiesConnected(const ConvProxySet_t &) const;
 
  StatusCode numberOfHNodesPerProxyNotExcessive(const ConvProxySet_t &) const;
 
  StatusCode noUnconnectedHNodes(const xAOD::TrigCompositeContainer &) const;
 
  std::tuple<uint32_t, CLID, std::string> getSgKey(const HLT::TrigNavStructure &navigationDecoder, const HLT::TriggerElement::FeatureAccessHelper &helper) const;
 
  std::map<CLID, std::set<std::string>> m_collectionsToSaveDecoded;
 
  std::vector<std::string> m_setRoiName;
 
  CLID m_roIDescriptorCLID{0};
  CLID m_roIDescriptorCollectionCLID{0};
  CLID m_TrigRingerRingsCLID{0};
  CLID m_TrigRingerRingsContainerCLID{0};
  CLID m_TrigEMClusterCLID{0};
  CLID m_TrigEMClusterContainerCLID{0};
  CLID m_CaloClusterCLID{0};
  CLID m_CaloClusterContainerCLID{0};
  CLID m_TrackParticleContainerCLID{0};
  CLID m_TauTrackContainerCLID{0};
  CLID m_ElectronContainerCLID{0};
  CLID m_PhotonContainerCLID{0};
  CLID m_MuonContainerCLID{0};
  CLID m_TauJetContainerCLID{0};

  CLID getExpectedParticleCLID(const std::string& teName) const;
 
  // special cases that need separate method
  // this is to cover chains like this one: HLT_mu4_j15_boffperf_split_dr05_dz02
  // it's description in the TrigConfigSvc looks like it is 1 leg chain while in fact it is a two leg chain with jet +mu
  // a special configuration decoding is used to restore multiplicity of 2
  StatusCode bjetMuChainConfigDecoder(TEIdToChainsMap_t &allTES, TEIdToChainsMap_t &finalTEs, const TrigConf::HLTChain* ptrChain) const;
 
 
};
 
#endif // TRIGNAVTOOLS_RUN2TORUN3TRIGNAVCONVERTERV2_H