ATLAS Offline Software
Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
Run2ToRun3TrigNavConverterV2 Class Reference

#include <Run2ToRun3TrigNavConverterV2.h>

Inheritance diagram for Run2ToRun3TrigNavConverterV2:
Collaboration diagram for Run2ToRun3TrigNavConverterV2:

Public Member Functions

 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
 
virtual StatusCode sysInitialize () override
 Override sysInitialize. More...
 
virtual bool isClonable () const override
 Specify if the algorithm is clonable. More...
 
virtual unsigned int cardinality () const override
 Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant. More...
 
virtual StatusCode sysExecute (const EventContext &ctx) override
 Execute an algorithm. More...
 
virtual const DataObjIDColl & extraOutputDeps () const override
 Return the list of extra output dependencies. More...
 
virtual bool filterPassed (const EventContext &ctx) const
 
virtual void setFilterPassed (bool state, const EventContext &ctx) const
 
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 

Protected Member Functions

void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution More...
 
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce (T &h)
 
void extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
 Add StoreName to extra input/output deps as needed. More...
 

Private Types

typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

StatusCode extractTECtoChainMapping (TEIdToChainsMap_t &allTES, TEIdToChainsMap_t &finalTEs) const
 
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 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
 
std::vector< HLT::TriggerElement::FeatureAccessHelper > filterFEAs (const std::vector< HLT::TriggerElement::FeatureAccessHelper > &feaVector, const HLT::TrigNavStructure &navigationDecoder) const
 < both method skip TrigPassBits More...
 
uint64_t feaToHash (const std::vector< HLT::TriggerElement::FeatureAccessHelper > &feaVector, const HLT::TriggerElement *te_ptr, const HLT::TrigNavStructure &navigationDecoder) const
 returns true if this particular feature is to be saved (linked) More...
 
bool feaToSave (const HLT::TriggerElement::FeatureAccessHelper &fea) const
 
bool roiToSave (const HLT::TrigNavStructure &run2Nav, const HLT::TriggerElement::FeatureAccessHelper &fea) const
 
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
 
size_t is2LegTopoChain (const TrigConf::HLTChain *ptrChain) const
 
std::size_t getFeaSize (const ConvProxy &) const
 
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
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Private Attributes

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"}
 
std::mutex m_configUpdateMutex
 
TEIdToChainsMap_t m_allTEIdsToChains
 
TEIdToChainsMap_t m_finalTEIdsToChains
 
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())); }
 
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}
 
DataObjIDColl m_extendedExtraObjects
 Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks. More...
 
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
std::vector< SG::VarHandleKeyArray * > m_vhka
 
bool m_varHandleArraysDeclared
 

Detailed Description

Definition at line 66 of file Run2ToRun3TrigNavConverterV2.h.

Member Typedef Documentation

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::StoreGateSvc_t
privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ Run2ToRun3TrigNavConverterV2()

Run2ToRun3TrigNavConverterV2::Run2ToRun3TrigNavConverterV2 ( const std::string &  name,
ISvcLocator *  pSvcLocator 
)

Definition at line 144 of file Run2ToRun3TrigNavConverterV2.cxx.

144  : AthReentrantAlgorithm(name, pSvcLocator)
145 {
146 }

◆ ~Run2ToRun3TrigNavConverterV2()

Run2ToRun3TrigNavConverterV2::~Run2ToRun3TrigNavConverterV2 ( )
overridevirtual

Definition at line 148 of file Run2ToRun3TrigNavConverterV2.cxx.

149 {
150 }

Member Function Documentation

◆ allProxiesConnected()

StatusCode Run2ToRun3TrigNavConverterV2::allProxiesConnected ( const ConvProxySet_t &  proxies) const
private

Definition at line 1406 of file Run2ToRun3TrigNavConverterV2.cxx.

1407 {
1408  for (auto p : proxies)
1409  {
1410  if (p->children.empty() and p->parents.empty() and not p->runChains.empty())
1411  {
1412  ATH_MSG_ERROR("Orphanted proxy N chains run:" << p->runChains.size());
1413  return StatusCode::FAILURE;
1414  }
1415  }
1416  ATH_MSG_DEBUG("CHECK OK, no orphanted proxies");
1417  return StatusCode::SUCCESS;
1418 }

◆ allProxiesHaveChain()

StatusCode Run2ToRun3TrigNavConverterV2::allProxiesHaveChain ( const ConvProxySet_t &  proxies) const
private

Definition at line 1392 of file Run2ToRun3TrigNavConverterV2.cxx.

1393 {
1394  for (auto p : proxies)
1395  {
1396  if (p->runChains.empty())
1397  {
1398  ATH_MSG_ERROR("Proxy with no chains");
1399  return StatusCode::FAILURE;
1400  }
1401  }
1402  ATH_MSG_DEBUG("CHECK OK, no proxies w/o a chain");
1403  return StatusCode::SUCCESS;
1404 }

◆ associateChainsToProxies()

StatusCode Run2ToRun3TrigNavConverterV2::associateChainsToProxies ( ConvProxySet_t &  convProxies,
const TEIdToChainsMap_t &  allTEs 
) const
private

Definition at line 612 of file Run2ToRun3TrigNavConverterV2.cxx.

613 {
614 
615  for (auto &ptrConvProxy : convProxies)
616  {
617  auto teId = ptrConvProxy->te->getId();
618  bool teActive = ptrConvProxy->te->getActiveState();
619  auto iter = allTEs.find(teId);
620  if (iter != allTEs.end())
621  {
622  ptrConvProxy->runChains.insert(iter->second.begin(), iter->second.end());
623  if (teActive)
624  {
625  ptrConvProxy->passChains.insert(iter->second.begin(), iter->second.end());
626  }
627  }
628 
629  for (auto &objTeIdToChain : allTEs)
630  {
631  if (teId == objTeIdToChain.first)
632  {
633  for (auto &chainId : objTeIdToChain.second)
634  {
635  (ptrConvProxy->runChains).insert(chainId);
636  }
637  break;
638  }
639  }
640  }
641  return StatusCode::SUCCESS;
642 }

◆ cardinality()

unsigned int AthReentrantAlgorithm::cardinality ( ) const
overridevirtualinherited

Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.

Override this to return 0 for reentrant algorithms.

Override this to return 0 for reentrant algorithms.

Definition at line 55 of file AthReentrantAlgorithm.cxx.

56 {
57  return 0;
58 }

◆ collapseFeaturelessProxies()

StatusCode Run2ToRun3TrigNavConverterV2::collapseFeaturelessProxies ( ConvProxySet_t &  convProxies) const
private

Definition at line 799 of file Run2ToRun3TrigNavConverterV2.cxx.

800 {
801  // merge proxies bases on the parent child relation (this has to run after feature based collapsing)
802  struct ParentChildCharacteristics
803  {
804  ConvProxy *parent = nullptr;
805  ConvProxy *child = nullptr;
806  size_t distanceFromParent = 0;
807  bool operator<(const ParentChildCharacteristics &rhs) const
808  {
809  if (parent != rhs.parent)
810  return parent < rhs.parent;
811  if (child != rhs.child)
812  return child < rhs.child;
813  return distanceFromParent < rhs.distanceFromParent;
814  }
815  };
816  const size_t beforeCount = convProxies.size();
817  std::map<ParentChildCharacteristics, ConvProxySet_t> groupedProxies;
818  for (auto proxy : convProxies)
819  {
820  if (proxy->feaHash == ConvProxy::MissingFEA)
821  {
822  ATH_MSG_VERBOSE("Featureless proxy to deal with: " << proxy->description());
823  /* the canonical case
824  merged parent
825  / | | \
826  C1 C2 C3 C4 <-- proxies to merge
827  \ | | /
828  merged child
829  */
830  auto hasSomeFeatures = [](const ConvProxy* p){ return p->feaHash != ConvProxy::MissingFEA; };
831  if (proxy->children.size() == 1 and
832  std::all_of(proxy->children.begin(), proxy->children.end(), hasSomeFeatures ) and
833  proxy->parents.size() == 1 and
834  std::all_of(proxy->parents.begin(), proxy->parents.end(), hasSomeFeatures )
835  )
836  {
837  ATH_MSG_VERBOSE("Proxy to possibly merge: " << proxy->description());
838  groupedProxies[{*(proxy->parents.begin()), *(proxy->children.begin()), 0}].insert(proxy);
839  // TODO expand it to cover longer featureless sequences
840  }
841  else
842  {
843  ATH_MSG_VERBOSE("Featureless proxy in noncanonical situation " << proxy->description());
844  ATH_MSG_VERBOSE("parents ");
845  for (auto pp : proxy->parents)
846  {
847  ATH_MSG_VERBOSE(pp->description());
848  }
849  ATH_MSG_VERBOSE("children ");
850  for (auto cp : proxy->children)
851  {
852  ATH_MSG_VERBOSE(cp->description());
853  }
854  }
855  }
856  }
857 
858  ATH_CHECK(collapseProxies(convProxies, groupedProxies));
859  ATH_MSG_DEBUG("Proxies without features collapsing reduces size from " << beforeCount << " to " << convProxies.size());
860  return StatusCode::SUCCESS;
861 }

◆ collapseFeaturesProxies()

StatusCode Run2ToRun3TrigNavConverterV2::collapseFeaturesProxies ( ConvProxySet_t &  convProxies,
const HLT::TrigNavStructure &  run2Nav 
) const
private

Definition at line 751 of file Run2ToRun3TrigNavConverterV2.cxx.

752 {
753 
754  const size_t beforeCount = convProxies.size();
755  std::map<uint64_t, ConvProxySet_t> feaToProxyMap;
756  for (auto proxy : convProxies)
757  {
758  proxy->feaHash = feaToHash(proxy->te->getFeatureAccessHelpers(), proxy->te, run2Nav);
759  if (proxy->feaHash != ConvProxy::MissingFEA)
760  feaToProxyMap[proxy->feaHash].insert(proxy);
761 
762  ATH_MSG_VERBOSE("TE " << TrigConf::HLTUtils::hash2string(proxy->te->getId()) << " FEA hash " << proxy->feaHash);
763  for (const HLT::TriggerElement::FeatureAccessHelper& fea : proxy->te->getFeatureAccessHelpers())
764  {
765  ATH_MSG_VERBOSE("FEA: " << fea);
766  }
767  }
768 
769  for (auto [feaHash, proxies] : feaToProxyMap)
770  {
771  auto first = *proxies.begin();
772  for (auto p : proxies)
773  {
774  if (filterFEAs(first->te->getFeatureAccessHelpers(), run2Nav) !=
775  filterFEAs(p->te->getFeatureAccessHelpers(), run2Nav))
776  {
777  ATH_MSG_ERROR("Proxies grouped by FEA hash have actually distinct features (specific FEAs are different)");
778  for (auto id: p->passChains ) ATH_MSG_ERROR("... chain id for this proxy " << id);
779  ATH_MSG_ERROR(".... TE id of this proxy: " << TrigConf::HLTUtils::hash2string(p->te->getId()));
780  for ( auto fea: first->te->getFeatureAccessHelpers() ) {
781  ATH_MSG_ERROR("FEA1 " << fea);
782  }
783  for ( auto fea: p->te->getFeatureAccessHelpers() ) {
784  ATH_MSG_ERROR("FEA2 " << fea);
785  }
786 
787  return StatusCode::FAILURE;
788  }
789  }
790  }
791 
792 
793  ATH_CHECK(collapseProxies(convProxies, feaToProxyMap));
794  ATH_MSG_DEBUG("Proxies with features collapsing reduces size from " << beforeCount << " to " << convProxies.size());
795 
796  return StatusCode::SUCCESS;
797 }

◆ collapseProxies()

template<typename MAP >
StatusCode Run2ToRun3TrigNavConverterV2::collapseProxies ( ConvProxySet_t &  convProxies,
MAP &  keyToProxyMap 
) const
private

Definition at line 722 of file Run2ToRun3TrigNavConverterV2.cxx.

723 {
724  // collapse proxies based on the mapping in the map argument(generic) and clean proxiesSet
725  std::vector<ConvProxy *> todelete;
726  for (auto &[key, proxies] : keyToProxyMap)
727  {
728  if (proxies.size() > 1)
729  {
730  ATH_MSG_DEBUG("Merging " << proxies.size() << " similar proxies");
731  for (auto p : proxies)
732  {
733  if (p->mergeAllowed(*proxies.begin()))
734  {
735  (*proxies.begin())->merge(p);
736  todelete.push_back(p);
737  }
738  // TODO consider scanning proxies another time if merge is not allowed, it may be allowed with other proxies here
739  }
740  }
741  }
742  for (auto proxy : todelete)
743  {
744  convProxies.erase(proxy);
745  delete proxy;
746  }
747  // remove from proxies set all elements that are now unassociated (remember to delete after)
748  return StatusCode::SUCCESS;
749 }

◆ createIMHNodes()

StatusCode Run2ToRun3TrigNavConverterV2::createIMHNodes ( ConvProxySet_t &  convProxies,
xAOD::TrigCompositeContainer &  decisions,
const EventContext &  context 
) const
private

Definition at line 996 of file Run2ToRun3TrigNavConverterV2.cxx.

997 {
998  for (auto &proxy : convProxies)
999  {
1000  proxy->imNode = TrigCompositeUtils::newDecisionIn(&decisions, TrigCompositeUtils::inputMakerNodeName()); // IM
1001  for (auto chainId : proxy->runChains)
1002  {
1003  TrigCompositeUtils::addDecisionID(chainId, proxy->imNode);
1004  }
1005  proxy->hNode.push_back(TrigCompositeUtils::newDecisionIn(&decisions, TrigCompositeUtils::hypoAlgNodeName())); // H
1006  for (auto chainId : proxy->passChains)
1007  {
1008  TrigCompositeUtils::addDecisionID(chainId, proxy->hNode.back());
1009  }
1010 
1011  TrigCompositeUtils::linkToPrevious(proxy->hNode.front(), proxy->imNode, context); // H low IM up
1012  }
1013  // connecting current IM to all Hs in parent proxies
1014  for (auto &proxy : convProxies)
1015  {
1016  for (auto &parentProxy : proxy->parents)
1017  {
1018  TrigCompositeUtils::linkToPrevious(proxy->imNode, parentProxy->hNode.front(), context); // IM low H up (in parent)
1019  }
1020  }
1021  ATH_MSG_DEBUG("IM & H nodes made, output nav elements " << decisions.size());
1022  return StatusCode::SUCCESS;
1023 }

◆ createL1Nodes()

StatusCode Run2ToRun3TrigNavConverterV2::createL1Nodes ( const ConvProxySet_t &  convProxies,
xAOD::TrigCompositeContainer &  decisions,
const EventContext &  context 
) const
private

Definition at line 1141 of file Run2ToRun3TrigNavConverterV2.cxx.

1143 {
1144 
1145  auto makeL1Node = [&decisions, &context](auto firstDecisionNode, auto chainIds)
1146  {
1147  auto L1Node = TrigCompositeUtils::newDecisionIn(&decisions);
1148  L1Node->setName(TrigCompositeUtils::hltSeedingNodeName()); // L1
1149  for (auto chainId : chainIds)
1150  {
1151  TrigCompositeUtils::addDecisionID(chainId, L1Node);
1152  }
1153  TrigCompositeUtils::linkToPrevious(firstDecisionNode, L1Node, context); // IM -> L1
1154 
1155  return L1Node;
1156  };
1157 
1158  for (auto &proxy : convProxies)
1159  {
1160  // associate initial node to filter nodes,
1161  if (proxy->parents.empty())
1162  { // the IM node is initial
1163  proxy->l1Node = makeL1Node(proxy->imNode, TCU::decisionIDs(proxy->imNode)); // not using passChains as there may be additional filtering
1164  }
1165  }
1166 
1167  ATH_MSG_DEBUG("L1 nodes made, output nav elements ");
1168  return StatusCode::SUCCESS;
1169 }

◆ createSFNodes()

StatusCode Run2ToRun3TrigNavConverterV2::createSFNodes ( const ConvProxySet_t &  convProxies,
xAOD::TrigCompositeContainer &  decisions,
const TEIdToChainsMap_t &  finalTEs,
const EventContext &  context 
) const
private

Definition at line 1025 of file Run2ToRun3TrigNavConverterV2.cxx.

1027 {
1028  // make node & link it properly
1029  auto makeSingleSFNode = [&decisions, &context](auto lastDecisionNode, auto chainIds, TrigCompositeUtils::DecisionID idStore = 0)
1030  {
1031  auto sfNode = TrigCompositeUtils::newDecisionIn(&decisions);
1032  sfNode->setName("SF");
1033  TrigCompositeUtils::linkToPrevious(decisions.at(0), sfNode, context);
1034  TrigCompositeUtils::linkToPrevious(sfNode, lastDecisionNode, context);
1035  for (auto chainId : chainIds)
1036  {
1037  if (idStore == 0)
1038  {
1039  TrigCompositeUtils::addDecisionID(chainId, sfNode);
1040  TrigCompositeUtils::addDecisionID(chainId, decisions.at(0));
1041  }
1042  else if (chainId.numeric() == idStore)
1043  {
1044  TrigCompositeUtils::addDecisionID(chainId, sfNode);
1045  TrigCompositeUtils::addDecisionID(chainId, decisions.at(0));
1046  }
1047  }
1048  return sfNode;
1049  };
1050  auto makeSFNodes = [makeSingleSFNode](auto proxy, TrigCompositeUtils::DecisionID idToStore = 0)
1051  {
1052  if (proxy->hNode.empty())
1053  { // nothing has passed, so link to the IM node
1054  // TODO make sure it needs to be done like that
1055  makeSingleSFNode(proxy->imNode, proxy->runChains, idToStore);
1056  }
1057  else
1058  {
1059  // makeSFNode(proxy->hNode[0], TCU::decisionIDs(proxy->hNode[0])); // not using passChains as there may be additional filtering
1060  for (auto &hNode : proxy->hNode)
1061  {
1062  makeSingleSFNode(hNode, proxy->passChains, idToStore); // using passChains
1063  }
1064  }
1065  };
1066 
1067  for (auto proxy : convProxies)
1068  {
1069  // associate terminal nodes to filter nodes,
1070  if (proxy->children.empty())
1071  { // the H modes are terminal
1072  makeSFNodes(proxy);
1073  }
1074  else
1075  {
1076  // likely need more iterations
1077  // nonterminal nodes that are nevertheless terminal for a given chain
1078  std::vector<TCU::DecisionID> toRetain;
1079  for (auto teId : proxy->teIDs)
1080  {
1081  auto whereInMap = terminalIds.find(teId);
1082  if (whereInMap != terminalIds.end())
1083  {
1084  toRetain.insert(toRetain.end(), whereInMap->second.begin(), whereInMap->second.end());
1085  }
1086  }
1087  for (auto chainIdstore : toRetain)
1088  {
1089  makeSFNodes(proxy, chainIdstore);
1090  }
1091  }
1092  }
1093  // associate all nodes designated as final one with the filter nodes
1094 
1095  ATH_MSG_DEBUG("SF nodes made, output nav elements " << decisions.size());
1096  return StatusCode::SUCCESS;
1097 }

◆ cureUnassociatedProxies()

StatusCode Run2ToRun3TrigNavConverterV2::cureUnassociatedProxies ( ConvProxySet_t &  convProxies) const
private

Definition at line 644 of file Run2ToRun3TrigNavConverterV2.cxx.

645 {
646  // propagate up (towards L1) chain IDs if they are not in proxies
647  // technically each proxy looks at the children proxies and inserts from it all unseen chains
648  // procedure is repeated until, no single proxy needs an update (tedious - we may be smarter in future)
649 
650  while (true)
651  {
652  size_t numberOfUpdates = 0;
653  for (auto p : convProxies)
654  {
655  for (auto child : p->children)
656  {
657  size_t startSize = p->runChains.size();
658  p->runChains.insert(std::begin(child->runChains), std::end(child->runChains));
659 
660  if (startSize != p->runChains.size())
661  { // some chain needed to be inserted
662  numberOfUpdates++;
663  // if update was need, it means set of chains that passed need update as well
664  p->passChains.insert(std::begin(child->runChains), std::end(child->runChains));
665  }
666  }
667  }
668  ATH_MSG_DEBUG("Needed to propagate chains from " << numberOfUpdates << " child(ren)");
669  if (numberOfUpdates == 0)
670  {
671  break;
672  }
673  }
674  return StatusCode::SUCCESS;
675 }

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleKeyArrayType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKeyArray>

Definition at line 170 of file AthCommonDataStore.h.

172  {
173  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
174  hndl.value(),
175  hndl.documentation());
176 
177  }

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleKeyType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

158  {
159  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160  hndl.value(),
161  hndl.documentation());
162 
163  }

◆ declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleBase>

Definition at line 184 of file AthCommonDataStore.h.

186  {
187  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
188  hndl.value(),
189  hndl.documentation());
190  }

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  t,
const SG::NotHandleType &   
)
inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

200  {
201  return PBASE::declareProperty(t);
202  }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleBase &  hndl,
const std::string &  doc,
const SG::VarHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

249  {
250  this->declare(hndl.vhKey());
251  hndl.vhKey().setOwner(this);
252 
253  return PBASE::declareProperty(name,hndl,doc);
254  }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleKey &  hndl,
const std::string &  doc,
const SG::VarHandleKeyType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

225  {
226  this->declare(hndl);
227  hndl.setOwner(this);
228 
229  return PBASE::declareProperty(name,hndl,doc);
230  }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleKeyArray &  hndArr,
const std::string &  doc,
const SG::VarHandleKeyArrayType &   
)
inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

263  {
264 
265  // std::ostringstream ost;
266  // ost << Algorithm::name() << " VHKA declareProp: " << name
267  // << " size: " << hndArr.keys().size()
268  // << " mode: " << hndArr.mode()
269  // << " vhka size: " << m_vhka.size()
270  // << "\n";
271  // debug() << ost.str() << endmsg;
272 
273  hndArr.setOwner(this);
274  m_vhka.push_back(&hndArr);
275 
276  Gaudi::Details::PropertyBase* p = PBASE::declareProperty(name, hndArr, doc);
277  if (p != 0) {
278  p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
279  } else {
280  ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray "
281  << name);
282  }
283 
284  return p;
285 
286  }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc,
const SG::NotHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

337  {
338  return PBASE::declareProperty(name, property, doc);
339  }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc = "none" 
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

355  {
356  typedef typename SG::HandleClassifier<T>::type htype;
357  return declareProperty (name, property, doc, htype());
358  }

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( Gaudi::Property< T > &  t)
inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

145  {
146  typedef typename SG::HandleClassifier<T>::type htype;
147  return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
148  }

◆ detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::detStore ( ) const
inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ doCompression()

StatusCode Run2ToRun3TrigNavConverterV2::doCompression ( ConvProxySet_t &  convProxies,
const HLT::TrigNavStructure &  run2Nav 
) const
private

Definition at line 706 of file Run2ToRun3TrigNavConverterV2.cxx.

707 {
708 
709  ATH_CHECK(collapseFeaturesProxies(convProxies, run2Nav));
710  ATH_CHECK(collapseFeaturelessProxies(convProxies));
711  if (m_doSelfValidation)
712  {
713  ATH_CHECK(allProxiesHaveChain(convProxies));
714  ATH_CHECK(allProxiesConnected(convProxies));
715  }
716  ATH_MSG_DEBUG("Compression done");
717 
718  return StatusCode::SUCCESS;
719 }

◆ evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::evtStore ( )
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::evtStore ( ) const
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ execute()

StatusCode Run2ToRun3TrigNavConverterV2::execute ( const EventContext &  context) const
overridevirtual

Definition at line 246 of file Run2ToRun3TrigNavConverterV2.cxx.

247 {
248  // ATH_MSG_INFO("EVENT " << context.evt());
249  // if ( 4 == context.evt() ) return StatusCode::SUCCESS;
250  // ATH_MSG_INFO("EVENT processing " << context.evt());
251 
252  {
253  // configuration reading could not be done before the event loop
254  // it needs to be done only once though
255  std::scoped_lock lock(m_configUpdateMutex);
256  if (m_allTEIdsToChains.empty())
257  ATH_CHECK(extractTECtoChainMapping(const_cast<TEIdToChainsMap_t &>(m_allTEIdsToChains), const_cast<TEIdToChainsMap_t &>(m_finalTEIdsToChains)));
258  }
259 
260  ConvProxySet_t convProxies;
261  HLT::StandaloneNavigation standaloneNav; // needed to keep TEs around, so it is out of the scope where it is filled and referenced
262  const HLT::TrigNavStructure *run2NavigationPtr = nullptr;
263  if (!m_trigNavKey.key().empty())
264  {
265  SG::ReadHandle navReadHandle(m_trigNavKey, context);
266  ATH_CHECK(navReadHandle.isValid());
267  standaloneNav.deserialize(navReadHandle->serialized());
268  run2NavigationPtr = &standaloneNav;
269  }
270  else
271  {
272  run2NavigationPtr = m_tdt->ExperimentalAndExpertMethods().getNavigation();
273  }
274 
275  ATH_CHECK(mirrorTEsStructure(convProxies, *run2NavigationPtr));
276  // printProxies(convProxies, [](auto ){ return true;},
277  // {m_chainIdsPrinter});
278 
279  if (m_doSelfValidation)
280  ATH_CHECK(allProxiesConnected(convProxies));
281 
282  ATH_CHECK(associateChainsToProxies(convProxies, m_allTEIdsToChains));
283  // printProxies(convProxies, [](auto ){ return true;},
284  // {m_chainIdsPrinter});
285 
286  ATH_CHECK(cureUnassociatedProxies(convProxies));
287  ATH_MSG_DEBUG("Proxies to chains mapping done");
288 
289  ATH_CHECK(removeTopologicalProxies(convProxies));
290 
291  if (not m_chainsToSave.empty())
292  {
293  ATH_CHECK(removeUnassociatedProxies(convProxies));
294  printProxies(convProxies, [](auto ){ return true;},
295  {m_chainIdsPrinter});
296  ATH_MSG_DEBUG("Removed proxies to chains that are not converted, remaining number of elements " << convProxies.size());
297  }
298  if (m_doSelfValidation)
299  {
300  ATH_CHECK(allProxiesHaveChain(convProxies));
301  }
302  if (m_doCompression)
303  {
304  ATH_CHECK(doCompression(convProxies, *run2NavigationPtr));
305  // printProxies(convProxies, [](auto ){ return true;},
306  // {m_chainIdsPrinter});
307 
308  }
309 
310  SG::WriteHandle<TrigCompositeUtils::DecisionContainer> outputNavigation = TrigCompositeUtils::createAndStore(m_trigOutputNavKey, context);
311  auto decisionOutput = outputNavigation.ptr();
312  TrigCompositeUtils::newDecisionIn(decisionOutput, TCU::summaryPassNodeName()); // we rely on the fact that the 1st element is the top
313 
314  if (m_doLinkFeatures)
315  {
316  ATH_CHECK(fillRelevantFeatures(convProxies, *run2NavigationPtr));
317  ATH_CHECK(fillRelevantRois(convProxies, *run2NavigationPtr));
318  ATH_CHECK(fillRelevantTracks(convProxies));
319  ATH_MSG_DEBUG("Features to link found");
320  }
321 
322  ATH_CHECK(createIMHNodes(convProxies, *decisionOutput, context));
323  if (m_doSelfValidation)
324  {
325  ATH_CHECK(numberOfHNodesPerProxyNotExcessive(convProxies));
326  }
327 
328  ATH_CHECK(createL1Nodes(convProxies, *decisionOutput, context));
329  ATH_CHECK(linkFeaNode(convProxies, *decisionOutput, *run2NavigationPtr, context));
330  ATH_CHECK(linkRoiNode(convProxies, *run2NavigationPtr));
331  ATH_CHECK(linkTrkNode(convProxies, *run2NavigationPtr));
332  ATH_CHECK(createSFNodes(convProxies, *decisionOutput, m_finalTEIdsToChains, context));
333  ATH_CHECK(updateTerminusNode(*decisionOutput, context));
334  ATH_MSG_DEBUG("Conversion done, from " << convProxies.size() << " elements to " << decisionOutput->size() << " elements");
335 
336  printProxies(convProxies, [](auto ){ return true;},
337  {m_chainIdsPrinter, m_teIDPrinter});
338  ATH_MSG_DEBUG("Resulting nodes");
339  size_t index = 0;
340  for ( auto o: *decisionOutput) {
341  ATH_MSG_DEBUG("Index: " << index << " " << *o);
342  index++;
343  }
344 
345  // dispose temporaries
346  for (auto proxy : convProxies)
347  {
348  delete proxy;
349  }
350 
351  return StatusCode::SUCCESS;
352 }

◆ extractTECtoChainMapping()

StatusCode Run2ToRun3TrigNavConverterV2::extractTECtoChainMapping ( TEIdToChainsMap_t &  allTES,
TEIdToChainsMap_t &  finalTEs 
) const
private

Definition at line 398 of file Run2ToRun3TrigNavConverterV2.cxx.

399 {
400 
401  ATH_CHECK(not m_configSvc->chains().empty());
402 
403  // obtain map output TE -> input TE via sequences
404  for (auto ptrChain : m_configSvc->chains())
405  {
406  std::string chainName = ptrChain->name();
407  if (not m_chainsToSave.empty())
408  {
409  auto found = std::find(m_chainsToSave.begin(), m_chainsToSave.end(), chainName);
410  if (found == m_chainsToSave.end())
411  {
412  continue;
413  }
414  }
415  // hack for etcut chains
416  // if we ever need to generalise that it should be moved to separate function
417  std::map<HLT::te_id_type, HLT::te_id_type> etcutReplacementTEs;
418  auto etcutReplacement = [&etcutReplacementTEs](HLT::te_id_type in) { auto out = etcutReplacementTEs.find(in); return (out == etcutReplacementTEs.end() ? in : out->second ); };
419  if ( chainName.find("etcut") != std::string::npos ) {
420  std::set<size_t> positionsOfEtCutLegs;
421  // use heuristics to mention
422  if( std::regex_match(chainName, SpecialCases::egammaDiEtcut) ) {
423  ATH_MSG_DEBUG("EtCut chains hack, chain with two etcut legs ");
424  positionsOfEtCutLegs.insert({0, 1});
425  } else if ( std::regex_match(chainName, SpecialCases::egammaCombinedWithEtcut) ) {
426  ATH_MSG_DEBUG("EtCut chains hack, egamma chain with second etcut leg ");
427  positionsOfEtCutLegs.insert({1});
428  } else if ( std::regex_match(chainName, SpecialCases::egammaEtcut) ) {
429  ATH_MSG_DEBUG("EtCut chains hack, single leg egamma chain");
430  positionsOfEtCutLegs.insert({0});
431  }
432 
433  // pilot pass to fill the replacement map
434  std::map<size_t, HLT::te_id_type> positionToDesiredIDmap;
435  for (auto ptrHLTSignature : ptrChain->signatures()) {
436  size_t position = 0;
437  for (auto ptrHLTTE : ptrHLTSignature->outputTEs()) {
438  if (positionsOfEtCutLegs.count(position) and positionToDesiredIDmap.find(position) != positionToDesiredIDmap.end() ) {
439  etcutReplacementTEs[ptrHLTTE->id()] = positionToDesiredIDmap[position];
440  ATH_MSG_DEBUG("EtCut chains hack, TE " << ptrHLTTE->name() << " will be replaced by: " << TrigConf::HLTUtils::hash2string(positionToDesiredIDmap[position]));
441  } else {
442  if ( ptrHLTTE->name().find("calocalib") != std::string::npos and positionsOfEtCutLegs.count(position) ) { // we have final TE for this leg
443  positionToDesiredIDmap[position] = ptrHLTTE->id();
444  }
445  }
446  position++;
447  }
448  }
449  }
450 
451  // chains with a single leg
452  HLT::Identifier chainId = HLT::Identifier(chainName);
453  ATH_MSG_DEBUG(" CHAIN name " << chainName << " CHAIN Id " << chainId);
454  for (auto ptrHLTSignature : ptrChain->signatures()) {
455  for (auto ptrHLTTE : ptrHLTSignature->outputTEs()) {
456  unsigned int teId = etcutReplacement(ptrHLTTE->id());
457  allTEs[teId].insert(chainId);
458  if (ptrHLTSignature == ptrChain->signatures().back()) {
459  finalTEs[teId].insert(chainId);
460  ATH_MSG_DEBUG("TE will be used to mark final chain decision " << ptrHLTTE->name() << " chain " << chainName );
461  }
462  }
463  }
464  // chains with a multiple legs
465  std::vector<int> multiplicities = ChainNameParser::multiplicities(chainName);
466 
467  // dirty hacks for failing chains parsing
468  if(std::regex_match(chainName, SpecialCases::gammaXeChain))
469  multiplicities={1,1};
470 
471 
472  if ( multiplicities.size() > 1 ) {
473  ATH_MSG_DEBUG(" this " << (is2LegTopoChain(ptrChain) ? "is": "is not") << " topological chain");
474  // the chain structure (in terms of multiplicities) may change along the way
475  // we'll assign legs only to these TEs of the steps that have identical multiplicity pattern
476  // e.g. for the chain: HLT_2g25_loose_g20 the multiplicities are: [2, 1]
477  //
478 
479  // hack for HLT.*tau.*xe.* case
480  if (std::regex_match(chainName, SpecialCases::tauXeChain)) {
481  if (multiplicities.size()==3) multiplicities={1,1};
482  else if (multiplicities.size()==2) multiplicities={1};
483  }
484 
485  ATH_MSG_DEBUG("CHAIN " << chainName << " needs legs: " << multiplicities );
486  std::vector<unsigned int> teIdsLastHealthyStepIds;
487 
488  for (auto ptrHLTSignature : ptrChain->signatures())
489  {
490  std::vector<int> teCounts;
491  std::vector<unsigned int> teIds;
492  unsigned int lastSeenId = 0;
493  for (auto ptrHLTTE : ptrHLTSignature->outputTEs())
494  {
495  if ( lastSeenId != ptrHLTTE->id()) {
496  teCounts.push_back(1);
497  teIds.push_back(ptrHLTTE->id());
498  } else {
499  teCounts.back()++;
500  }
501  lastSeenId = ptrHLTTE->id();
502  }
503 
504  ATH_MSG_DEBUG("TE multiplicities seen in this step " << teCounts);
505  bool multiplicityCounts = multiplicities == teCounts;
506  // hack for HLT.*tau.*xe.* case
507  if(std::regex_match(chainName, SpecialCases::tauXeChain)) multiplicityCounts = true;
508  if ( multiplicityCounts ) {
509  teIdsLastHealthyStepIds = teIds;
510  ATH_MSG_DEBUG("There is a match, will assign chain leg IDs to TEs " << teCounts << " " << teIds);
511  for ( size_t legNumber = 0; legNumber < teIds.size(); ++ legNumber){
512  HLT::Identifier chainLegId = TrigCompositeUtils::createLegName(chainId, legNumber);
513  allTEs[etcutReplacement(teIds[legNumber])].insert(chainLegId);
514  }
515  }
516  }
517  for ( size_t legNumber = 0; legNumber < teIdsLastHealthyStepIds.size(); ++ legNumber ) {
518  HLT::Identifier chainLegId = TrigCompositeUtils::createLegName(chainId, legNumber);
519 
520  ATH_MSG_DEBUG("created leg id " << chainLegId << " that will replace TE ID " << etcutReplacement(teIdsLastHealthyStepIds[legNumber]));
521  finalTEs[etcutReplacement(teIdsLastHealthyStepIds[legNumber])].insert(chainLegId);
522  }
523  }
524 
525  }
526  ATH_MSG_DEBUG("Recognised " << allTEs.size() << " kinds of TEs and among them " << finalTEs.size() << " final types");
527  return StatusCode::SUCCESS;
528 }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase &  ExtraDeps)
protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ extraOutputDeps()

const DataObjIDColl & AthReentrantAlgorithm::extraOutputDeps ( ) const
overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 79 of file AthReentrantAlgorithm.cxx.

80 {
81  // If we didn't find any symlinks to add, just return the collection
82  // from the base class. Otherwise, return the extended collection.
83  if (!m_extendedExtraObjects.empty()) {
84  return m_extendedExtraObjects;
85  }
86  return Algorithm::extraOutputDeps();
87 }

◆ feaToHash()

uint64_t Run2ToRun3TrigNavConverterV2::feaToHash ( const std::vector< HLT::TriggerElement::FeatureAccessHelper > &  feaVector,
const HLT::TriggerElement *  te_ptr,
const HLT::TrigNavStructure &  navigationDecoder 
) const
private

returns true if this particular feature is to be saved (linked)

Definition at line 1354 of file Run2ToRun3TrigNavConverterV2.cxx.

1355 {
1356  // FEA vectors hashing
1357  ATH_MSG_VERBOSE("Calculating FEA hash");
1358  uint64_t hash = 0;
1359  for (auto fea : filterFEAs(feaVector, navigationDecoder))
1360  {
1361  ATH_MSG_VERBOSE("Including FEA in hash CLID: " << fea.getCLID() << " te Id: " << te_ptr->getId());
1362  boost::hash_combine(hash, fea.getCLID());
1363  boost::hash_combine(hash, fea.getIndex().subTypeIndex());
1364  boost::hash_combine(hash, fea.getIndex().objectsBegin());
1365  boost::hash_combine(hash, fea.getIndex().objectsEnd());
1366  }
1367  ATH_MSG_VERBOSE("Obtained FEA hash " << hash);
1368  return hash;
1369 }

◆ feaToSave()

bool Run2ToRun3TrigNavConverterV2::feaToSave ( const HLT::TriggerElement::FeatureAccessHelper &  fea) const
private

Definition at line 1371 of file Run2ToRun3TrigNavConverterV2.cxx.

1372 {
1373  if (m_collectionsToSaveDecoded.find(fea.getCLID()) != m_collectionsToSaveDecoded.end())
1374  {
1375  return true; // feature accepted for saving
1376  }
1377 
1378  return false;
1379 }

◆ fillRelevantFeatures()

StatusCode Run2ToRun3TrigNavConverterV2::fillRelevantFeatures ( ConvProxySet_t &  convProxies,
const HLT::TrigNavStructure &  run2Nav 
) const
private

Definition at line 890 of file Run2ToRun3TrigNavConverterV2.cxx.

891 {
892  // from all FEAs of the associated TE pick those objects that are to be linked
893  for (auto &proxy : convProxies)
894  {
895  if (proxy->te != nullptr)
896  {
897 
898  for (HLT::TriggerElement::FeatureAccessHelper helper : proxy->te->getFeatureAccessHelpers())
899  {
900  auto [sgKey, sgCLID, sgName] = getSgKey(run2Nav, helper);
901  if (sgKey != 0)
902  {
903  if (feaToSave(helper) == true)
904  {
905  proxy->features.push_back(helper);
906  }
907  }
908  }
909  }
910  }
911 
912  return StatusCode::SUCCESS;
913 }

◆ fillRelevantRois()

StatusCode Run2ToRun3TrigNavConverterV2::fillRelevantRois ( ConvProxySet_t &  convProxies,
const HLT::TrigNavStructure &  run2Nav 
) const
private

Definition at line 915 of file Run2ToRun3TrigNavConverterV2.cxx.

916 {
917 
918  // ordered_sorter
919  auto ordered_sorter = [&setRoiName = std::as_const(m_setRoiName)](const std::string &left, const std::string &right) -> bool
920  {
921  return std::find(cbegin(setRoiName), cend(setRoiName), left) < std::find(cbegin(setRoiName), cend(setRoiName), right);
922  };
923 
924  std::map<std::string, HLT::TriggerElement::FeatureAccessHelper, decltype(ordered_sorter)> mp(ordered_sorter);
925 
926  for (auto &proxy : convProxies)
927  {
928  // TODO need check & handling of case when there is more RoIs, now overwriting
929  if (HLT::TrigNavStructure::getRoINodes(proxy->te).size() > 1)
930  ATH_MSG_DEBUG("Several RoIs pointing to a proxy, taking latest one for now");
931 
932  mp.clear();
933 
934  for (const HLT::TriggerElement::FeatureAccessHelper& helper : proxy->te->getFeatureAccessHelpers())
935  {
936  auto [sgKey, sgCLID, sgName] = getSgKey(run2Nav, helper);
937  if (std::find(m_setRoiName.begin(), m_setRoiName.end(), sgName) == m_setRoiName.end())
938  {
939  // do not filter continue;
940  continue;
941  }
942  mp[sgName] = helper;
943  }
944 
945  std::transform(cbegin(mp), cend(mp), back_inserter(proxy->rois),
946  [](const std::map<std::string, HLT::TriggerElement::FeatureAccessHelper>::value_type &p)
947  { return p.second; });
948  }
949 
950  // roiPropagator
951  std::set<const ConvProxy*> visited;
952  std::function<void(std::set<ConvProxy *> &, const std::vector<HLT::TriggerElement::FeatureAccessHelper> &)>
953  roiPropagator = [&](std::set<ConvProxy *> &convProxyChildren, const std::vector<HLT::TriggerElement::FeatureAccessHelper> &roiParent)
954  {
955  for (auto &proxyChild : convProxyChildren)
956  {
957  if ( visited.count(proxyChild) == 1 ) {
958  continue;
959  }
960  visited.insert(proxyChild);
961  if (proxyChild->rois.empty())
962  { // no roi update, copy from parent
963  proxyChild->rois = roiParent;
964  if (proxyChild->children.empty() == false)
965  {
966  roiPropagator(proxyChild->children, roiParent);
967  }
968  }
969  }
970  };
971 
972  for (auto &proxy : convProxies)
973  {
974  roiPropagator(proxy->children, proxy->rois);
975  }
976 
977  return StatusCode::SUCCESS;
978 }

◆ fillRelevantTracks()

StatusCode Run2ToRun3TrigNavConverterV2::fillRelevantTracks ( ConvProxySet_t &  convProxies) const
private

Definition at line 980 of file Run2ToRun3TrigNavConverterV2.cxx.

981 {
982  for (auto &proxy : convProxies)
983  {
984  for (HLT::TriggerElement::FeatureAccessHelper helper : proxy->te->getFeatureAccessHelpers())
985  {
986  if (helper.getCLID() == m_TrackParticleContainerCLID || helper.getCLID() == m_TauTrackContainerCLID)
987  {
988  proxy->tracks.push_back(helper);
989  }
990  }
991  }
992 
993  return StatusCode::SUCCESS;
994 }

◆ filterFEAs()

std::vector< HLT::TriggerElement::FeatureAccessHelper > Run2ToRun3TrigNavConverterV2::filterFEAs ( const std::vector< HLT::TriggerElement::FeatureAccessHelper > &  feaVector,
const HLT::TrigNavStructure &  navigationDecoder 
) const
private

< both method skip TrigPassBits

Definition at line 1332 of file Run2ToRun3TrigNavConverterV2.cxx.

1332  {
1333  std::vector<HLT::TriggerElement::FeatureAccessHelper> out;
1334  for (auto fea : feaVector)
1335  {
1336  if (feaToSkip(fea))
1337  {
1338  ATH_MSG_VERBOSE("Skipping in FEA hash calculation");
1339  continue;
1340  }
1341 
1342  auto [sgKey, sgCLID, sgName] = getSgKey(navigationDecoder, fea);
1343 
1344  if (sgKey == 0)
1345  {
1346  ATH_MSG_VERBOSE("Skipping unrecorded (missing in SG) FEA hash calculation - name in SG: " << sgName << " FEA " << fea);
1347  continue;
1348  }
1349  out.push_back(fea);
1350  }
1351  return out;
1352 }

◆ filterPassed()

virtual bool AthReentrantAlgorithm::filterPassed ( const EventContext &  ctx) const
inlinevirtualinherited

Definition at line 135 of file AthReentrantAlgorithm.h.

135  {
136  return execState( ctx ).filterPassed();
137  }

◆ finalize()

StatusCode Run2ToRun3TrigNavConverterV2::finalize ( )
overridevirtual

Definition at line 241 of file Run2ToRun3TrigNavConverterV2.cxx.

242 {
243  return StatusCode::SUCCESS;
244 }

◆ getFeaSize()

std::size_t Run2ToRun3TrigNavConverterV2::getFeaSize ( const ConvProxy &  proxy) const
private

Definition at line 1171 of file Run2ToRun3TrigNavConverterV2.cxx.

1172 {
1173  size_t feaCount{0};
1174  if (proxy.features.empty())
1175  { // no features
1176  ++feaCount;
1177  }
1178  for (const auto &fea : proxy.features)
1179  {
1180  if (fea.getIndex().objectsBegin() == fea.getIndex().objectsEnd())
1181  {
1182  ++feaCount;
1183  }
1184  for (auto n = fea.getIndex().objectsBegin(); n < fea.getIndex().objectsEnd(); ++n)
1185  {
1186  ++feaCount;
1187  }
1188  }
1189  // 1 means a deafult H node created is enough, no need to expand H nodes
1190  return feaCount;
1191 }

◆ getSgKey()

std::tuple< uint32_t, CLID, std::string > Run2ToRun3TrigNavConverterV2::getSgKey ( const HLT::TrigNavStructure &  navigationDecoder,
const HLT::TriggerElement::FeatureAccessHelper &  helper 
) const
private

Definition at line 1456 of file Run2ToRun3TrigNavConverterV2.cxx.

1457 {
1458  const std::string hltLabel = navigationDecoder.label(helper.getCLID(), helper.getIndex().subTypeIndex());
1459 
1460  const CLID saveCLID = [&](const CLID &clid)
1461  {
1462  if (clid == m_roIDescriptorCLID)
1463  return m_roIDescriptorCollectionCLID;
1464  if (clid == m_TrigEMClusterCLID)
1465  return m_TrigEMClusterContainerCLID;
1466  if (clid == m_TrigRingerRingsCLID)
1467  return m_TrigRingerRingsContainerCLID;
1468  return clid;
1469  }(helper.getCLID());
1470 
1471  std::string type_name;
1472  if (m_clidSvc->getTypeNameOfID(saveCLID, type_name).isFailure())
1473  {
1474  return {0, 0, ""};
1475  }
1476 
1477  const auto sgStringKey = HLTNavDetails::formatSGkey("HLT", type_name, hltLabel);
1478  const bool isAvailable = evtStore()->contains(saveCLID, sgStringKey);
1479  ATH_MSG_DEBUG(" Objects presence " << helper << " " << sgStringKey << (isAvailable ? " present" : " absent"));
1480  if (!isAvailable)
1481  {
1482  return {0, saveCLID, ""};
1483  }
1484 
1485  return {evtStore()->stringToKey(sgStringKey, saveCLID), saveCLID, hltLabel}; // sgKey, sgCLID, sgName
1486 }

◆ initialize()

StatusCode Run2ToRun3TrigNavConverterV2::initialize ( )
overridevirtual

Definition at line 152 of file Run2ToRun3TrigNavConverterV2.cxx.

153 {
154  ATH_CHECK(m_trigOutputNavKey.initialize());
155  ATH_CHECK(m_tdt.empty() != m_trigNavKey.key().empty()); // either of the two has to be enabled but not both
156  if (!m_tdt.empty())
157  {
158  ATH_CHECK(m_tdt.retrieve());
159  ATH_MSG_INFO("Will use Trigger Navigation from TrigDecisionTool");
160  }
161  else
162  {
163  ATH_CHECK(m_trigNavKey.initialize(SG::AllowEmpty));
164  ATH_MSG_INFO("Will use Trigger Navigation decoded from TrigNavigation object");
165  }
166 
167  if (!m_chainsToSave.empty()) {
168  ATH_MSG_DEBUG("Will only save features for these chains " << m_chainsToSave);
169  }
170 
171  ATH_CHECK(m_configSvc.retrieve());
172  ATH_CHECK(m_clidSvc.retrieve());
173 
174  // configured collections can be either just type name, or type#key
175  // decoding takes this into account, if only the type is configured then empty string is places in the decoded lookup map
176  // else CLID + a name is placed
177 
178  for (const auto &name : m_collectionsToSave)
179  {
180  std::string typeName = name;
181  std::string collName;
182  size_t delimeterIndex = name.find('#');
183  if (delimeterIndex != std::string::npos)
184  {
185  ATH_MSG_ERROR("Not support for specific collection name yet");
186  return StatusCode::FAILURE;
187  typeName = name.substr(0, delimeterIndex);
188  collName = name.substr(delimeterIndex + 1);
189  }
190  CLID id{0};
191  ATH_CHECK(m_clidSvc->getIDOfTypeName(typeName, id));
192  ATH_MSG_DEBUG("Will be linking collection type " << typeName << " name (empty==all) " << collName);
193  m_collectionsToSaveDecoded[id].insert(collName);
194  }
195 
196  for (const auto &name : m_roisToSave)
197  {
198  m_setRoiName.push_back(name);
199  }
200 
201  // sanity check, i.e. if there is at least one entry w/o the coll name no other entries are needed for a given clid
202  for (auto [clid, keysSet] : m_collectionsToSaveDecoded)
203  {
204  if (keysSet.size() > 1 and keysSet.count("") != 0)
205  {
206  ATH_MSG_ERROR("Bad configuration for CLID " << clid << " reuested saving of all (empty coll name configures) collections, yet there are also specific keys");
207  return StatusCode::FAILURE;
208  }
209 
210  }
211 
212  bool anyChainBad=false;
213  for ( auto chain: m_chainsToSave ) {
214  if ( chain.find('*') != std::string::npos or chain.find('|') != std::string::npos ) {
215  ATH_MSG_ERROR("Supplied chain name: " << chain << " contains wildcard characters, this is not supported by the conversion tool");
216  anyChainBad=true;
217  }
218  }
219  if ( anyChainBad ) {
220  ATH_MSG_ERROR("Supplied chain names contain wildcard characters, this is not supported by the conversion tool");
221  return StatusCode::FAILURE;
222  }
223  if ( m_chainsToSave.empty() ) {
224  ATH_MSG_INFO("No chains list supplied, the conversion will occur for all chains");
225  }
226 
227  ATH_CHECK(m_clidSvc->getIDOfTypeName("TrigRoiDescriptor", m_roIDescriptorCLID));
228  ATH_CHECK(m_clidSvc->getIDOfTypeName("TrigRoiDescriptorCollection", m_roIDescriptorCollectionCLID));
229  ATH_CHECK(m_clidSvc->getIDOfTypeName("xAOD::TrigRingerRings", m_TrigRingerRingsCLID));
230  ATH_CHECK(m_clidSvc->getIDOfTypeName("xAOD::TrigRingerRingsContainer", m_TrigRingerRingsContainerCLID));
231  ATH_CHECK(m_clidSvc->getIDOfTypeName("xAOD::TrigEMCluster", m_TrigEMClusterCLID));
232  ATH_CHECK(m_clidSvc->getIDOfTypeName("xAOD::TrigEMClusterContainer", m_TrigEMClusterContainerCLID));
233  ATH_CHECK(m_clidSvc->getIDOfTypeName("xAOD::CaloCluster", m_CaloClusterCLID));
234  ATH_CHECK(m_clidSvc->getIDOfTypeName("xAOD::CaloClusterContainer", m_CaloClusterContainerCLID));
235  ATH_CHECK(m_clidSvc->getIDOfTypeName("xAOD::TrackParticleContainer", m_TrackParticleContainerCLID));
236  ATH_CHECK(m_clidSvc->getIDOfTypeName("xAOD::TauTrackContainer", m_TauTrackContainerCLID));
237 
238  return StatusCode::SUCCESS;
239 }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::inputHandles ( ) const
overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ is2LegTopoChain()

size_t Run2ToRun3TrigNavConverterV2::is2LegTopoChain ( const TrigConf::HLTChain *  ptrChain) const
private

Definition at line 354 of file Run2ToRun3TrigNavConverterV2.cxx.

354  {
355  // chains of configs structure
356  // A B
357  // \/
358  // C
359  // where C is the output TE of sequence consuming A & B
360  // sometimes there are an additional leafs
361  // C
362  // |
363  // D
364  if ( not std::regex_match(ptrChain->name(), SpecialCases::isTopo) ) return 0;
365  size_t stepToConsider = 0;
366  const size_t sigsSize = ptrChain->signatures().size();
367  if ( sigsSize < 2 ) return 0;
368  for ( size_t step = sigsSize-1; step > 1; step --) {
369  if ( (ptrChain->signatures()[step-1])->outputTEs().size() == 2 and (ptrChain->signatures()[step])->outputTEs().size() == 1 ) {
370  stepToConsider = step;
371  break;
372  }
373  }
374  if ( stepToConsider == 0 ) return 0; // not a topo
375 
376  //counting is right, need to see now if TEs are connected
377  auto finalTE = (ptrChain->signatures()[stepToConsider])->outputTEs()[0];
378  auto preFinalTEs = (ptrChain->signatures()[stepToConsider-1])->outputTEs();
379 
380  auto finalSeq = m_configSvc->sequences().getSequence(finalTE->id());
381  std::set<HLT::te_id_type> tesInSeq;
382  std::set<HLT::te_id_type> tesInChain;
383 
384  for ( auto te: finalSeq->inputTEs()) {
385  tesInSeq.insert(te->id());
386  }
387 
388  for ( auto te: preFinalTEs) {
389  tesInChain.insert(te->id());
390  }
391 
392  if (tesInSeq == tesInChain) {
393  return stepToConsider;
394  }
395  return 0;
396 }

◆ isClonable()

bool AthReentrantAlgorithm::isClonable ( ) const
overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

Reimplemented in Simulation::BeamEffectsAlg, InDet::SiTrackerSpacePointFinder, InDet::SCT_Clusterization, InDet::SiSPSeededTrackFinder, SCTRawDataProvider, InDet::GNNSeedingTrackMaker, SCT_PrepDataToxAOD, RoIBResultToxAOD, SCT_CablingCondAlgFromCoraCool, SCT_ReadCalibDataTestAlg, SCT_CablingCondAlgFromText, InDet::SiSPGNNTrackMaker, SCT_ReadCalibChipDataTestAlg, SCT_TestCablingAlg, SCT_ConfigurationConditionsTestAlg, ITkPixelCablingAlg, SCTEventFlagWriter, SCT_ConditionsSummaryTestAlg, SCT_ModuleVetoTestAlg, SCT_MonitorConditionsTestAlg, SCT_LinkMaskingTestAlg, SCT_MajorityConditionsTestAlg, SCT_RODVetoTestAlg, SCT_SensorsTestAlg, SCT_TdaqEnabledTestAlg, SCT_SiliconConditionsTestAlg, SCTSiLorentzAngleTestAlg, SCT_ByteStreamErrorsTestAlg, SCT_ConditionsParameterTestAlg, SCT_FlaggedConditionTestAlg, SCT_StripVetoTestAlg, SCT_RawDataToxAOD, and SCTSiPropertiesTestAlg.

Definition at line 44 of file AthReentrantAlgorithm.cxx.

45 {
46  // Reentrant algorithms are clonable.
47  return true;
48 }

◆ linkFeaNode()

StatusCode Run2ToRun3TrigNavConverterV2::linkFeaNode ( ConvProxySet_t &  convProxies,
xAOD::TrigCompositeContainer &  decisions,
const HLT::TrigNavStructure &  run2Nav,
const EventContext &  context 
) const
private

Definition at line 1193 of file Run2ToRun3TrigNavConverterV2.cxx.

1194 {
1195  // from all FEAs of the associated TE pick those objects that are to be linked
1196  for (const auto &proxy : convProxies)
1197  {
1198  auto feaN = getFeaSize(*proxy);
1199  if (feaN > 1)
1200  { // expand for more H nodes and connect them
1201  while (--feaN)
1202  {
1203  proxy->hNode.push_back(TrigCompositeUtils::newDecisionIn(&decisions, TrigCompositeUtils::hypoAlgNodeName())); // H
1204  for (auto chainId : proxy->passChains) // adding hash values of active chains to expanded H nodes
1205  {
1206  TrigCompositeUtils::addDecisionID(chainId, proxy->hNode.back());
1207  }
1208  // connecting to upeer IM node
1209  TrigCompositeUtils::linkToPrevious(proxy->hNode.back(), proxy->imNode, context); // H low IM up
1210  // connecting created H to IM in children proxies
1211  for (auto &childProxy : proxy->children)
1212  {
1213  TrigCompositeUtils::linkToPrevious(childProxy->imNode, proxy->hNode.back(), context); // IM child H up (just created))
1214  }
1215  }
1216  }
1217 
1218  if (proxy->features.empty())
1219  { // no features attached, self link
1220  ElementLink<xAOD::TrigCompositeContainer> linkToSelf = TrigCompositeUtils::decisionToElementLink(proxy->hNode.front(), context);
1221  proxy->hNode.front()->setObjectLink<xAOD::TrigCompositeContainer>(TrigCompositeUtils::featureString(), linkToSelf);
1222  }
1223 
1224  auto hNodeIter = proxy->hNode.begin();
1225  for (auto &fea : proxy->features)
1226  {
1227  auto [sgKey, sgCLID, sgName] = getSgKey(run2Nav, fea);
1228  if (fea.getIndex().objectsBegin() == fea.getIndex().objectsEnd())
1229  {
1230  ElementLink<xAOD::TrigCompositeContainer> linkToSelf = TrigCompositeUtils::decisionToElementLink(*hNodeIter, context);
1231  (*hNodeIter)->setObjectLink<xAOD::TrigCompositeContainer>(TrigCompositeUtils::featureString(), linkToSelf);
1232  ++hNodeIter;
1233  }
1234  for (auto n = fea.getIndex().objectsBegin(); n < fea.getIndex().objectsEnd(); ++n)
1235  {
1236  // connecting feature
1237  (*hNodeIter)->typelessSetObjectLink(TrigCompositeUtils::featureString(), sgKey, sgCLID, n, n + 1);
1238  ++hNodeIter;
1239  }
1240  }
1241  }
1242 
1243  return StatusCode::SUCCESS;
1244 }

◆ linkRoiNode()

StatusCode Run2ToRun3TrigNavConverterV2::linkRoiNode ( ConvProxySet_t &  convProxies,
const HLT::TrigNavStructure &  run2Nav 
) const
private

Definition at line 1246 of file Run2ToRun3TrigNavConverterV2.cxx.

1247 {
1248  // from all Rois of the associated TE pick those objects that are to be linked
1249  for (auto &proxy : convProxies)
1250  {
1251  for (auto &roi : proxy->rois)
1252  {
1253  auto [sgKey, sgCLID, sgName] = getSgKey(run2Nav, roi);
1254  if (proxy->l1Node)
1255  {
1256  proxy->l1Node->typelessSetObjectLink(TrigCompositeUtils::initialRoIString(), sgKey, sgCLID, roi.getIndex().objectsBegin());
1257  }
1258  if (proxy->rois.empty() == false)
1259  {
1260  proxy->imNode->typelessSetObjectLink(TrigCompositeUtils::roiString(), sgKey, sgCLID, roi.getIndex().objectsBegin());
1261  }
1262  }
1263  }
1264 
1265  return StatusCode::SUCCESS;
1266 }

◆ linkTrkNode()

StatusCode Run2ToRun3TrigNavConverterV2::linkTrkNode ( ConvProxySet_t &  convProxies,
const HLT::TrigNavStructure &  run2Nav 
) const
private

Definition at line 1268 of file Run2ToRun3TrigNavConverterV2.cxx.

1269 {
1270  for (auto &proxy : convProxies)
1271  {
1272  for (auto &trk : proxy->tracks)
1273  {
1274  if (proxy->imNode->hasObjectLink(TrigCompositeUtils::roiString()))
1275  {
1276  try
1277  {
1278  ElementLink<TrigRoiDescriptorCollection> ROIElementLink = proxy->imNode->objectLink<TrigRoiDescriptorCollection>(TrigCompositeUtils::roiString());
1279  if (ROIElementLink.isValid())
1280  {
1281  SG::AuxElement::Decorator<ElementLink<TrigRoiDescriptorCollection>> viewBookkeeper("viewIndex");
1282  auto [sgKey, sgCLID, sgName] = getSgKey(run2Nav, trk);
1283  if (sgCLID == m_TrackParticleContainerCLID || sgCLID == m_TauTrackContainerCLID)
1284  {
1285  const char *tName = sgCLID == m_TrackParticleContainerCLID ? "TEMP_TRACKS" : "TEMP_TAU_TRACKS";
1286  auto d = std::make_unique<TrigCompositeUtils::Decision>();
1287  d->makePrivateStore();
1288  d->typelessSetObjectLink(tName, sgKey, sgCLID, trk.getIndex().objectsBegin());
1289  if (sgCLID == m_TrackParticleContainerCLID)
1290  {
1291  for (const ElementLink<xAOD::TrackParticleContainer> &track : d->objectCollectionLinks<xAOD::TrackParticleContainer>(tName))
1292  {
1293  if (track.isValid())
1294  {
1295  const xAOD::TrackParticle *t = *track;
1296  viewBookkeeper(*t) = ROIElementLink;
1297  }
1298  }
1299  }
1300  if (m_includeTauTrackFeatures == false && sgCLID == m_TauTrackContainerCLID)
1301  {
1302  for (const ElementLink<xAOD::TauTrackContainer> &track : d->objectCollectionLinks<xAOD::TauTrackContainer>(tName))
1303  {
1304  if (track.isValid())
1305  {
1306  const xAOD::TauTrack_v1 *t = *track;
1307  viewBookkeeper(*t) = ROIElementLink;
1308  }
1309  }
1310  }
1311  }
1312  }
1313  } catch (SG::ExcBadForwardLink&) {
1314  ATH_MSG_WARNING("Unable to create an ElementLink into a container with no entries");
1315  }
1316  }
1317  }
1318  }
1319 
1320  return StatusCode::SUCCESS;
1321 }

◆ mirrorTEsStructure()

StatusCode Run2ToRun3TrigNavConverterV2::mirrorTEsStructure ( ConvProxySet_t &  convProxies,
const HLT::TrigNavStructure &  run2Nav 
) const
private

Definition at line 530 of file Run2ToRun3TrigNavConverterV2.cxx.

531 {
532 
533  // iterate over the TEs, for each make the ConvProxy and build connections
534  std::map<const HLT::TriggerElement *, ConvProxy *> teToProxy;
535  ATH_MSG_DEBUG("TrigNavStructure with " << run2Nav.getAllTEs().size() << " TEs acquired");
536  for (auto te : run2Nav.getAllTEs())
537  {
538  // skip event seed node
539  if (HLT::TrigNavStructure::isInitialNode(te))
540  continue;
541  auto proxy = new ConvProxy(te);
542  convProxies.insert(proxy);
543  teToProxy[te] = proxy;
544  // add linking
545  for (auto predecessor : HLT::TrigNavStructure::getDirectPredecessors(te))
546  {
547  ConvProxy *predecessorProxy = teToProxy[predecessor];
548  if (predecessorProxy != nullptr)
549  { // because we skip some
550  proxy->parents.insert(predecessorProxy);
551  predecessorProxy->children.insert(proxy);
552  }
553  }
554  }
555 
556  if (m_doSelfValidation)
557  {
558  int counter = -1;
559  for (auto proxy : convProxies)
560  {
561  counter++;
562  ATH_MSG_DEBUG("Proxy " << counter << " " << proxy->description() << "ptr " << proxy);
563  for (auto p : proxy->children)
564  ATH_MSG_DEBUG("Child ptr " << p);
565  for (auto p : proxy->parents)
566  ATH_MSG_DEBUG("Parent ptr " << p);
567 
568  for (auto p : proxy->parents)
569  {
570  for (auto pp : p->parents)
571  {
572  if (pp == proxy)
573  {
574  ATH_MSG_WARNING("Weird, proxy is in parents list of parents");
575  }
576  }
577  }
578  for (auto c : proxy->children)
579  {
580  for (auto cc : c->children)
581  {
582  if (cc == proxy)
583  {
584  ATH_MSG_WARNING("Weird, proxy is in children list of children");
585  }
586  }
587  }
588  }
589  }
590 
591  ATH_MSG_DEBUG("Created " << convProxies.size() << " proxy objects");
592  return StatusCode::SUCCESS;
593 }

◆ msg() [1/2]

MsgStream& AthCommonMsg< Gaudi::Algorithm >::msg ( ) const
inlineinherited

Definition at line 24 of file AthCommonMsg.h.

24  {
25  return this->msgStream();
26  }

◆ msg() [2/2]

MsgStream& AthCommonMsg< Gaudi::Algorithm >::msg ( const MSG::Level  lvl) const
inlineinherited

Definition at line 27 of file AthCommonMsg.h.

27  {
28  return this->msgStream(lvl);
29  }

◆ msgLvl()

bool AthCommonMsg< Gaudi::Algorithm >::msgLvl ( const MSG::Level  lvl) const
inlineinherited

Definition at line 30 of file AthCommonMsg.h.

30  {
31  return this->msgLevel(lvl);
32  }

◆ noUnconnectedHNodes()

StatusCode Run2ToRun3TrigNavConverterV2::noUnconnectedHNodes ( const xAOD::TrigCompositeContainer &  decisions) const
private

Definition at line 1426 of file Run2ToRun3TrigNavConverterV2.cxx.

1427 {
1428  // build map of all links to H nodes from IMs and FS
1429  std::set<const TrigCompositeUtils::Decision *> linkedHNodes;
1430  for (auto d : decisions)
1431  {
1432  if (d->name() == "IM" or d->name() == "FS")
1433  {
1434  for (auto el : TCU::getLinkToPrevious(d))
1435  {
1436  linkedHNodes.insert(*el); // dereferences to bare pointer
1437  }
1438  }
1439  }
1440  for (auto d : decisions)
1441  {
1442  if (d->name() == "H")
1443  {
1444  if (linkedHNodes.count(d) == 0)
1445  {
1446  ATH_MSG_ERROR("Orphaned H node");
1447  return StatusCode::FAILURE;
1448  }
1449  }
1450  }
1451  ATH_MSG_DEBUG("CHECK OK, all H modes are connected");
1452 
1453  return StatusCode::SUCCESS;
1454 }

◆ numberOfHNodesPerProxyNotExcessive()

StatusCode Run2ToRun3TrigNavConverterV2::numberOfHNodesPerProxyNotExcessive ( const ConvProxySet_t &  ) const
private

Definition at line 1420 of file Run2ToRun3TrigNavConverterV2.cxx.

1421 {
1422  ATH_MSG_DEBUG("CHECK OK, no excessive number of H nodes per proxy");
1423  return StatusCode::SUCCESS;
1424 }

◆ outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::outputHandles ( ) const
overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ printProxies()

void Run2ToRun3TrigNavConverterV2::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
private

Definition at line 596 of file Run2ToRun3TrigNavConverterV2.cxx.

598  {
599  ATH_MSG_DEBUG("Printing proxies");
600  ATH_MSG_DEBUG("" );
601  for ( auto p: proxies) {
602  if ( selector(p) ){
603  ATH_MSG_DEBUG("Proxy " << p->description() );
604  for (auto& printer: printers) {
605  printer(p);
606  }
607  ATH_MSG_DEBUG("" );
608  }
609  }
610 }

◆ removeTopologicalProxies()

StatusCode Run2ToRun3TrigNavConverterV2::removeTopologicalProxies ( ConvProxySet_t &  convProxies) const
private

Definition at line 863 of file Run2ToRun3TrigNavConverterV2.cxx.

864 {
865  for (auto i = std::begin(convProxies); i != std::end(convProxies);)
866  {
867  if ((*i)->parents.size() > 1)
868  {
869  ConvProxy *toDel = *i;
870  // remove it from parents/children
871  for (auto parent : toDel->parents)
872  {
873  parent->children.erase(toDel);
874  }
875  for (auto child : toDel->children)
876  {
877  child->parents.erase(toDel);
878  }
879  delete toDel;
880  i = convProxies.erase(i);
881  }
882  else
883  {
884  ++i;
885  }
886  }
887  return StatusCode::SUCCESS;
888 }

◆ removeUnassociatedProxies()

StatusCode Run2ToRun3TrigNavConverterV2::removeUnassociatedProxies ( ConvProxySet_t &  convProxies) const
private

Definition at line 677 of file Run2ToRun3TrigNavConverterV2.cxx.

678 {
679  // remove proxies that have no chains
680  for (auto i = std::begin(convProxies); i != std::end(convProxies);)
681  {
682  if ((*i)->runChains.empty())
683  {
684  ConvProxy *toDel = *i;
685  // remove it from parents/children
686  for (auto parent : toDel->parents)
687  {
688  parent->children.erase(toDel);
689  }
690  for (auto child : toDel->children)
691  {
692  child->parents.erase(toDel);
693  }
694  delete toDel;
695  i = convProxies.erase(i);
696  }
697  else
698  {
699  ++i;
700  }
701  }
702  ATH_MSG_DEBUG("After eliminating proxies not associated to chainsof intereset left with " << convProxies.size());
703  return StatusCode::SUCCESS;
704 }

◆ renounce()

std::enable_if_t<std::is_void_v<std::result_of_t<decltype(&T::renounce)(T)> > && !std::is_base_of_v<SG::VarHandleKeyArray, T> && std::is_base_of_v<Gaudi::DataHandle, T>, void> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::renounce ( T &  h)
inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

381  {
382  h.renounce();
383  PBASE::renounce (h);
384  }

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::renounceArray ( SG::VarHandleKeyArray &  handlesArray)
inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364  {
365  handlesArray.renounce();
366  }

◆ roiToSave()

bool Run2ToRun3TrigNavConverterV2::roiToSave ( const HLT::TrigNavStructure &  run2Nav,
const HLT::TriggerElement::FeatureAccessHelper &  fea 
) const
private

Definition at line 1381 of file Run2ToRun3TrigNavConverterV2.cxx.

1382 {
1383  auto [sgKey, sgCLID, sgName] = getSgKey(run2Nav, roi);
1384  if (std::find(m_setRoiName.begin(), m_setRoiName.end(), sgName) != m_setRoiName.end())
1385  {
1386  return true;
1387  }
1388 
1389  return false;
1390 }

◆ setFilterPassed()

virtual void AthReentrantAlgorithm::setFilterPassed ( bool  state,
const EventContext &  ctx 
) const
inlinevirtualinherited

Definition at line 139 of file AthReentrantAlgorithm.h.

139  {
140  execState( ctx ).setFilterPassed( state );
141  }

◆ sysExecute()

StatusCode AthReentrantAlgorithm::sysExecute ( const EventContext &  ctx)
overridevirtualinherited

Execute an algorithm.

We override this in order to work around an issue with the Algorithm base class storing the event context in a member variable that can cause crashes in MT jobs.

Definition at line 67 of file AthReentrantAlgorithm.cxx.

68 {
69  return Gaudi::Algorithm::sysExecute (ctx);
70 }

◆ sysInitialize()

StatusCode AthReentrantAlgorithm::sysInitialize ( )
overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >.

Reimplemented in InputMakerBase, and HypoBase.

Definition at line 96 of file AthReentrantAlgorithm.cxx.

96  {
97  StatusCode sc=AthCommonDataStore<AthCommonMsg<Gaudi::Algorithm>>::sysInitialize();
98 
99  if (sc.isFailure()) {
100  return sc;
101  }
102 
103  ServiceHandle<ICondSvc> cs("CondSvc",name());
104  for (auto h : outputHandles()) {
105  if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
106  // do this inside the loop so we don't create the CondSvc until needed
107  if ( cs.retrieve().isFailure() ) {
108  ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
109  return StatusCode::SUCCESS;
110  }
111  if (cs->regHandle(this,*h).isFailure()) {
112  sc = StatusCode::FAILURE;
113  ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
114  << " with CondSvc");
115  }
116  }
117  }
118  return sc;
119 }

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::sysStart ( )
overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ updateTerminusNode()

StatusCode Run2ToRun3TrigNavConverterV2::updateTerminusNode ( xAOD::TrigCompositeContainer &  decisions,
const EventContext &  context 
) const
private

Definition at line 1099 of file Run2ToRun3TrigNavConverterV2.cxx.

1100 {
1101  // Check that only ChainIDs (not LegIDs) are present in the terminus "HLTPassRaw" node.
1102  // Check that only chains which pass the event are included.
1103  TCU::Decision* terminus = decisions.at(0);
1104  ATH_CHECK( terminus->name() == TCU::summaryPassNodeName() );
1105  TCU::DecisionIDContainer currentIDs;
1106  TCU::DecisionIDContainer filteredIDs;
1107  TCU::decisionIDs(terminus, currentIDs); // Extract, std::vector -> std::set
1108  for (const TCU::DecisionID id : currentIDs)
1109  {
1110  const TCU::DecisionID idToCheck = ( TCU::isLegId(id) ? TCU::getIDFromLeg( HLT::Identifier(id) ).numeric() : id );
1111  const std::string chainName = HLT::Identifier(idToCheck).name();
1112  // Sanity check
1113  if (!m_chainsToSave.empty())
1114  {
1115  if (std::find(m_chainsToSave.begin(), m_chainsToSave.end(), chainName) == m_chainsToSave.end())
1116  {
1117  ATH_MSG_ERROR("Navigation information for chain " << chainName << " in "
1118  << TCU::summaryPassNodeName() << " but this chain wasn't on the list of chains to save");
1119  return StatusCode::FAILURE;
1120  }
1121  }
1122  if (m_tdt->isPassed(chainName))
1123  {
1124  filteredIDs.insert(idToCheck);
1125  }
1126  }
1127  terminus->setDecisions( std::vector<TCU::DecisionID>() ); // decisions.clear(), but via the xAOD setter function
1128  TCU::insertDecisionIDs(filteredIDs, terminus); // Insert, std::set -> std::vector
1129  ATH_MSG_VERBOSE("After filtering out leg IDs and checking isPassed, "
1130  "the terminus node goes from " << currentIDs.size() << " to " << filteredIDs.size() << " chain IDs.");
1131  if (msgLvl(MSG::VERBOSE))
1132  {
1133  for (const TCU::DecisionID id : filteredIDs)
1134  {
1135  ATH_MSG_VERBOSE(" -- Retained passing ID: " << HLT::Identifier(id));
1136  }
1137  }
1138  return StatusCode::SUCCESS;
1139 }

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase &  )
inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

308  {
309  // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310  // << " size: " << m_vhka.size() << endmsg;
311  for (auto &a : m_vhka) {
312  std::vector<SG::VarHandleKey*> keys = a->keys();
313  for (auto k : keys) {
314  k->setOwner(this);
315  }
316  }
317  }

Member Data Documentation

◆ m_allTEIdsToChains

TEIdToChainsMap_t Run2ToRun3TrigNavConverterV2::m_allTEIdsToChains
private

Definition at line 96 of file Run2ToRun3TrigNavConverterV2.h.

◆ m_CaloClusterCLID

CLID Run2ToRun3TrigNavConverterV2::m_CaloClusterCLID {0}
private

Definition at line 179 of file Run2ToRun3TrigNavConverterV2.h.

◆ m_CaloClusterContainerCLID

CLID Run2ToRun3TrigNavConverterV2::m_CaloClusterContainerCLID {0}
private

Definition at line 180 of file Run2ToRun3TrigNavConverterV2.h.

◆ m_chainIdsPrinter

std::function<void(const ConvProxy*)> Run2ToRun3TrigNavConverterV2::m_chainIdsPrinter = [&](const ConvProxy* p){ for (auto id: p->passChains ) ATH_MSG_DEBUG("chain id " << id); }
private

Definition at line 148 of file Run2ToRun3TrigNavConverterV2.h.

◆ m_chainsToSave

Gaudi::Property<std::vector<std::string> > Run2ToRun3TrigNavConverterV2::m_chainsToSave {this, "Chains", {}, "If not specified, all chains are handled"}
private

Definition at line 88 of file Run2ToRun3TrigNavConverterV2.h.

◆ m_clidSvc

ServiceHandle<IClassIDSvc> Run2ToRun3TrigNavConverterV2::m_clidSvc {this, "ClassIDSvc", "ClassIDSvc", "Service to translate CLID to class name"}
private

Definition at line 81 of file Run2ToRun3TrigNavConverterV2.h.

◆ m_collectionsToSave

Gaudi::Property<std::vector<std::string> > Run2ToRun3TrigNavConverterV2::m_collectionsToSave {this, "Collections", {}}
private

Definition at line 89 of file Run2ToRun3TrigNavConverterV2.h.

◆ m_collectionsToSaveDecoded

std::map<CLID, std::set<std::string> > Run2ToRun3TrigNavConverterV2::m_collectionsToSaveDecoded
private

Definition at line 169 of file Run2ToRun3TrigNavConverterV2.h.

◆ m_configSvc

ServiceHandle<TrigConf::IHLTConfigSvc> Run2ToRun3TrigNavConverterV2::m_configSvc {this, "TrigConfigSvc", "TrigConf::xAODConfigSvc/xAODConfigSvc", "Trigger configuration service"}
private

Definition at line 80 of file Run2ToRun3TrigNavConverterV2.h.

◆ m_configUpdateMutex

std::mutex Run2ToRun3TrigNavConverterV2::m_configUpdateMutex
mutableprivate

Definition at line 95 of file Run2ToRun3TrigNavConverterV2.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore
privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_doCompression

Gaudi::Property<bool> Run2ToRun3TrigNavConverterV2::m_doCompression {this, "doCompression", false, "Collapse navigation elements to save ouput space"}
private

Definition at line 84 of file Run2ToRun3TrigNavConverterV2.h.

◆ m_doLinkFeatures

Gaudi::Property<bool> Run2ToRun3TrigNavConverterV2::m_doLinkFeatures {this, "doLinkFeatures", true, "Add links to objects, setting it false makes sense when running tests"}
private

Definition at line 85 of file Run2ToRun3TrigNavConverterV2.h.

◆ m_doSelfValidation

Gaudi::Property<bool> Run2ToRun3TrigNavConverterV2::m_doSelfValidation {this, "doSelfValidation", false, "Run consistency checks after stages of conversion (slows down the alg)"}
private

Definition at line 83 of file Run2ToRun3TrigNavConverterV2.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore
privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthReentrantAlgorithm::m_extendedExtraObjects
privateinherited

Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.

Empty if no symlinks were found.

Definition at line 153 of file AthReentrantAlgorithm.h.

◆ m_finalTEIdsToChains

TEIdToChainsMap_t Run2ToRun3TrigNavConverterV2::m_finalTEIdsToChains
private

Definition at line 96 of file Run2ToRun3TrigNavConverterV2.h.

◆ m_hNodesPerProxyThreshold

Gaudi::Property<size_t> Run2ToRun3TrigNavConverterV2::m_hNodesPerProxyThreshold {this, "hNodesPerProxyThreshhold", 15, "Limit number of H nodes per TE (if exceeded conversion results in an error)"}
private

Definition at line 87 of file Run2ToRun3TrigNavConverterV2.h.

◆ m_includeTauTrackFeatures

Gaudi::Property<bool> Run2ToRun3TrigNavConverterV2::m_includeTauTrackFeatures {this, "addTauTracks", false, "Add Tau Track collection as feature element"}
private

Definition at line 86 of file Run2ToRun3TrigNavConverterV2.h.

◆ m_roIDescriptorCLID

CLID Run2ToRun3TrigNavConverterV2::m_roIDescriptorCLID {0}
private

Definition at line 173 of file Run2ToRun3TrigNavConverterV2.h.

◆ m_roIDescriptorCollectionCLID

CLID Run2ToRun3TrigNavConverterV2::m_roIDescriptorCollectionCLID {0}
private

Definition at line 174 of file Run2ToRun3TrigNavConverterV2.h.

◆ m_roisToSave

Gaudi::Property<std::vector<std::string> > Run2ToRun3TrigNavConverterV2::m_roisToSave {this, "Rois", {}}
private

Definition at line 90 of file Run2ToRun3TrigNavConverterV2.h.

◆ m_setRoiName

std::vector<std::string> Run2ToRun3TrigNavConverterV2::m_setRoiName
private

Definition at line 171 of file Run2ToRun3TrigNavConverterV2.h.

◆ m_TauTrackContainerCLID

CLID Run2ToRun3TrigNavConverterV2::m_TauTrackContainerCLID {0}
private

Definition at line 182 of file Run2ToRun3TrigNavConverterV2.h.

◆ m_tdt

PublicToolHandle<Trig::TrigDecisionTool> Run2ToRun3TrigNavConverterV2::m_tdt {this, "TrigDecisionTool", "", "When enabled read navigation from TDT/off by default"}
private

Definition at line 79 of file Run2ToRun3TrigNavConverterV2.h.

◆ m_teIDPrinter

std::function<void(const ConvProxy*)> Run2ToRun3TrigNavConverterV2::m_teIDPrinter = [&](const ConvProxy* p){ ATH_MSG_DEBUG("TE id " << TrigConf::HLTUtils::hash2string(p->te->getId())); }
private

Definition at line 149 of file Run2ToRun3TrigNavConverterV2.h.

◆ m_TrackParticleContainerCLID

CLID Run2ToRun3TrigNavConverterV2::m_TrackParticleContainerCLID {0}
private

Definition at line 181 of file Run2ToRun3TrigNavConverterV2.h.

◆ m_TrigEMClusterCLID

CLID Run2ToRun3TrigNavConverterV2::m_TrigEMClusterCLID {0}
private

Definition at line 177 of file Run2ToRun3TrigNavConverterV2.h.

◆ m_TrigEMClusterContainerCLID

CLID Run2ToRun3TrigNavConverterV2::m_TrigEMClusterContainerCLID {0}
private

Definition at line 178 of file Run2ToRun3TrigNavConverterV2.h.

◆ m_trigNavKey

SG::ReadHandleKey<xAOD::TrigNavigation> Run2ToRun3TrigNavConverterV2::m_trigNavKey {this, "TrigNavReadKey", "TrigNavigation"}
private

Definition at line 78 of file Run2ToRun3TrigNavConverterV2.h.

◆ m_trigOutputNavKey

SG::WriteHandleKey<xAOD::TrigCompositeContainer> Run2ToRun3TrigNavConverterV2::m_trigOutputNavKey {this, "OutputNavKey", "HLTNav_R2ToR3Summary"}
private

Definition at line 92 of file Run2ToRun3TrigNavConverterV2.h.

◆ m_TrigRingerRingsCLID

CLID Run2ToRun3TrigNavConverterV2::m_TrigRingerRingsCLID {0}
private

Definition at line 175 of file Run2ToRun3TrigNavConverterV2.h.

◆ m_TrigRingerRingsContainerCLID

CLID Run2ToRun3TrigNavConverterV2::m_TrigRingerRingsContainerCLID {0}
private

Definition at line 176 of file Run2ToRun3TrigNavConverterV2.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_varHandleArraysDeclared
privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_vhka
privateinherited

Definition at line 398 of file AthCommonDataStore.h.

The documentation for this class was generated from the following files:
Run2ToRun3TrigNavConverterV2::fillRelevantTracks
StatusCode fillRelevantTracks(ConvProxySet_t &convProxies) const
Definition: Run2ToRun3TrigNavConverterV2.cxx:980
operator<
bool operator<(const DataVector< T > &a, const DataVector< T > &b)
Vector ordering relation.
Run2ToRun3TrigNavConverterV2::m_roIDescriptorCLID
CLID m_roIDescriptorCLID
Definition: Run2ToRun3TrigNavConverterV2.h:173
Run2ToRun3TrigNavConverterV2::collapseProxies
StatusCode collapseProxies(ConvProxySet_t &, MAP &) const
Definition: Run2ToRun3TrigNavConverterV2.cxx:722
Run2ToRun3TrigNavConverterV2::m_trigNavKey
SG::ReadHandleKey< xAOD::TrigNavigation > m_trigNavKey
Definition: Run2ToRun3TrigNavConverterV2.h:78
TrigConf::TrigConfData::name
const std::string & name() const
Definition: TrigConfData.h:22
Run2ToRun3TrigNavConverterV2::fillRelevantRois
StatusCode fillRelevantRois(ConvProxySet_t &convProxies, const HLT::TrigNavStructure &run2Nav) const
Definition: Run2ToRun3TrigNavConverterV2.cxx:915
Run2ToRun3TrigNavConverterV2::createL1Nodes
StatusCode createL1Nodes(const ConvProxySet_t &convProxies, xAOD::TrigCompositeContainer &decisions, const EventContext &context) const
Definition: Run2ToRun3TrigNavConverterV2.cxx:1141
StateLessPT_NewConfig.proxy
proxy
Definition: StateLessPT_NewConfig.py:392
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
runLayerRecalibration.chain
chain
Definition: runLayerRecalibration.py:175
TrigCompositeUtils::DecisionID
unsigned int DecisionID
Definition: TrigComposite_v1.h:27
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
find
std::string find(const std::string &s)
return a remapped string
Definition: hcg.cxx:135
HLT::TrigNavStructure::label
std::string label(class_id_type clid, const index_or_label_type &sti_or_label) const
Definition: TrigNavStructure.cxx:775
HLT::Identifier::numeric
TrigCompositeUtils::DecisionID numeric() const
numeric ID
Definition: TrigCompositeUtils/TrigCompositeUtils/HLTIdentifier.h:47
TrigCompositeUtils::hltSeedingNodeName
const std::string & hltSeedingNodeName()
Definition: TrigCompositeUtilsRoot.cxx:894
Run2ToRun3TrigNavConverterV2::linkRoiNode
StatusCode linkRoiNode(ConvProxySet_t &convProxies, const HLT::TrigNavStructure &run2Nav) const
Definition: Run2ToRun3TrigNavConverterV2.cxx:1246
Run2ToRun3TrigNavConverterV2::updateTerminusNode
StatusCode updateTerminusNode(xAOD::TrigCompositeContainer &, const EventContext &context) const
Definition: Run2ToRun3TrigNavConverterV2.cxx:1099
TrigCompositeUtils::newDecisionIn
Decision * newDecisionIn(DecisionContainer *dc, const std::string &name)
Helper method to create a Decision object, place it in the container and return a pointer to it.
Definition: TrigCompositeUtilsRoot.cxx:46
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
index
Definition: index.py:1
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
Run2ToRun3TrigNavConverterV2::allProxiesConnected
StatusCode allProxiesConnected(const ConvProxySet_t &) const
Definition: Run2ToRun3TrigNavConverterV2.cxx:1406
hist_file_dump.d
d
Definition: hist_file_dump.py:137
xAOD::teId
teId
Definition: L2StandAloneMuon_v1.cxx:323
TrigCompositeUtils::hypoAlgNodeName
const std::string & hypoAlgNodeName()
Definition: TrigCompositeUtilsRoot.cxx:906
Run2ToRun3TrigNavConverterV2::m_configSvc
ServiceHandle< TrigConf::IHLTConfigSvc > m_configSvc
Definition: Run2ToRun3TrigNavConverterV2.h:80
Run2ToRun3TrigNavConverterV2::m_configUpdateMutex
std::mutex m_configUpdateMutex
Definition: Run2ToRun3TrigNavConverterV2.h:95
Run2ToRun3TrigNavConverterV2::removeUnassociatedProxies
StatusCode removeUnassociatedProxies(ConvProxySet_t &) const
Definition: Run2ToRun3TrigNavConverterV2.cxx:677
TrigCompositeUtils::addDecisionID
void addDecisionID(DecisionID id, Decision *d)
Appends the decision (given as ID) to the decision object.
Definition: TrigCompositeUtilsRoot.cxx:61
Run2ToRun3TrigNavConverterV2::getSgKey
std::tuple< uint32_t, CLID, std::string > getSgKey(const HLT::TrigNavStructure &navigationDecoder, const HLT::TriggerElement::FeatureAccessHelper &helper) const
Definition: Run2ToRun3TrigNavConverterV2.cxx:1456
ConvProxy::MissingFEA
static const uint64_t MissingFEA
Definition: Run2ToRun3TrigNavConverterV2.h:46
AthCommonDataStore::renounce
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce(T &h)
Definition: AthCommonDataStore.h:380
Run2ToRun3TrigNavConverterV2::m_collectionsToSave
Gaudi::Property< std::vector< std::string > > m_collectionsToSave
Definition: Run2ToRun3TrigNavConverterV2.h:89
PlotCalibFromCool.begin
begin
Definition: PlotCalibFromCool.py:94
python.TrigCompositeUtils.isLegId
def isLegId(chainName)
Definition: DecisionHandling/python/TrigCompositeUtils.py:18
HLT::TriggerElement::getId
te_id_type getId() const
reset internals.
Definition: TrigNavStructure/TrigNavStructure/TriggerElement.h:43
Run2ToRun3TrigNavConverterV2::m_trigOutputNavKey
SG::WriteHandleKey< xAOD::TrigCompositeContainer > m_trigOutputNavKey
Definition: Run2ToRun3TrigNavConverterV2.h:92
HLT::TriggerElement::FeatureAccessHelper::getCLID
class_id_type getCLID() const
Class ID of object.
Definition: TrigNavStructure/TrigNavStructure/TriggerElement.h:208
python.AthDsoLogger.out
out
Definition: AthDsoLogger.py:71
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
TrigCompositeUtils::insertDecisionIDs
void insertDecisionIDs(const Decision *src, Decision *dest)
Appends the decision IDs of src to the dest decision object.
Definition: TrigCompositeUtilsRoot.cxx:80
Run2ToRun3TrigNavConverterV2::m_roisToSave
Gaudi::Property< std::vector< std::string > > m_roisToSave
Definition: Run2ToRun3TrigNavConverterV2.h:90
AthCommonMsg< Gaudi::Algorithm >::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition: AthCommonMsg.h:30
Run2ToRun3TrigNavConverterV2::m_TrigRingerRingsCLID
CLID m_TrigRingerRingsCLID
Definition: Run2ToRun3TrigNavConverterV2.h:175
TrigCompositeUtils::createAndStore
SG::WriteHandle< DecisionContainer > createAndStore(const SG::WriteHandleKey< DecisionContainer > &key, const EventContext &ctx)
Creates and right away records the DecisionContainer with the key.
Definition: TrigCompositeUtilsRoot.cxx:30
Run2ToRun3TrigNavConverterV2::m_setRoiName
std::vector< std::string > m_setRoiName
Definition: Run2ToRun3TrigNavConverterV2.h:171
TrigConf::HLTChain::signatures
const std::vector< HLTSignature * > & signatures() const
Definition: TrigConfHLTData/TrigConfHLTData/HLTChain.h:109
xAOD::TrigComposite_v1::setDecisions
void setDecisions(const std::vector< TrigCompositeUtils::DecisionID > &decisions)
Set positive HLT chain decisions associated with this TrigComposite. Navigation use.
Run2ToRun3TrigNavConverterV2::m_collectionsToSaveDecoded
std::map< CLID, std::set< std::string > > m_collectionsToSaveDecoded
Definition: Run2ToRun3TrigNavConverterV2.h:169
HLTNavDetails::formatSGkey
std::string formatSGkey(const std::string &prefix, const std::string &containername, const std::string &label)
declaration of formatting function.
Definition: Holder.cxx:122
Run2ToRun3TrigNavConverterV2::m_TauTrackContainerCLID
CLID m_TauTrackContainerCLID
Definition: Run2ToRun3TrigNavConverterV2.h:182
Run2ToRun3TrigNavConverterV2::m_tdt
PublicToolHandle< Trig::TrigDecisionTool > m_tdt
Definition: Run2ToRun3TrigNavConverterV2.h:79
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
Run2ToRun3TrigNavConverterV2::m_chainIdsPrinter
std::function< void(const ConvProxy *)> m_chainIdsPrinter
Definition: Run2ToRun3TrigNavConverterV2.h:148
Run2ToRun3TrigNavConverterV2::m_allTEIdsToChains
TEIdToChainsMap_t m_allTEIdsToChains
Definition: Run2ToRun3TrigNavConverterV2.h:96
HLT::TrigNavStructure
Definition: TrigNavStructure.h:40
SpecialCases::egammaDiEtcut
const std::regex egammaDiEtcut
Definition: SpecialCases.h:9
SpecialCases::gammaXeChain
const std::regex gammaXeChain
Definition: SpecialCases.h:8
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
mergePhysValFiles.end
end
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:93
ConvProxy::children
std::set< ConvProxy * > children
Definition: Run2ToRun3TrigNavConverterV2.h:42
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
ExpressionParsing::isAvailable
bool isAvailable(const T_Aux &cont, SG::auxid_t auxid)
Run2ToRun3TrigNavConverterV2::feaToHash
uint64_t feaToHash(const std::vector< HLT::TriggerElement::FeatureAccessHelper > &feaVector, const HLT::TriggerElement *te_ptr, const HLT::TrigNavStructure &navigationDecoder) const
returns true if this particular feature is to be saved (linked)
Definition: Run2ToRun3TrigNavConverterV2.cxx:1354
Run2ToRun3TrigNavConverterV2::m_roIDescriptorCollectionCLID
CLID m_roIDescriptorCollectionCLID
Definition: Run2ToRun3TrigNavConverterV2.h:174
runBeamSpotCalibration.helper
helper
Definition: runBeamSpotCalibration.py:112
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
Run2ToRun3TrigNavConverterV2::createSFNodes
StatusCode createSFNodes(const ConvProxySet_t &, xAOD::TrigCompositeContainer &, const TEIdToChainsMap_t &finalTEs, const EventContext &context) const
Definition: Run2ToRun3TrigNavConverterV2.cxx:1025
AthCommonDataStore
Definition: AthCommonDataStore.h:52
AthReentrantAlgorithm::AthReentrantAlgorithm
AthReentrantAlgorithm()
Default constructor:
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
Run2ToRun3TrigNavConverterV2::filterFEAs
std::vector< HLT::TriggerElement::FeatureAccessHelper > filterFEAs(const std::vector< HLT::TriggerElement::FeatureAccessHelper > &feaVector, const HLT::TrigNavStructure &navigationDecoder) const
< both method skip TrigPassBits
Definition: Run2ToRun3TrigNavConverterV2.cxx:1332
Run2ToRun3TrigNavConverterV2::extractTECtoChainMapping
StatusCode extractTECtoChainMapping(TEIdToChainsMap_t &allTES, TEIdToChainsMap_t &finalTEs) const
Definition: Run2ToRun3TrigNavConverterV2.cxx:398
HLT::TrigNavStructure::getDirectPredecessors
static const std::vector< TriggerElement * > & getDirectPredecessors(const TriggerElement *te)
returns list of direct predecessors (nodes seeding me)
Definition: TrigNavStructure.cxx:120
SG::Decorator
Helper class to provide type-safe access to aux data.
Definition: Decorator.h:58
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
lumiFormat.i
int i
Definition: lumiFormat.py:92
TrigCompositeUtils::initialRoIString
const std::string & initialRoIString()
Definition: TrigCompositeUtilsRoot.cxx:870
TrigCompositeUtils::getLinkToPrevious
const std::vector< ElementLink< DecisionContainer > > getLinkToPrevious(const Decision *d)
returns links to previous decision object 'seed'
Definition: TrigCompositeUtilsRoot.cxx:156
beamspotman.n
n
Definition: beamspotman.py:731
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
SG::WriteHandle::ptr
pointer_type ptr()
Dereference the pointer.
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
SpecialCases::isTopo
const std::regex isTopo
Definition: SpecialCases.h:12
Run2ToRun3TrigNavConverterV2::linkTrkNode
StatusCode linkTrkNode(ConvProxySet_t &convProxies, const HLT::TrigNavStructure &run2Nav) const
Definition: Run2ToRun3TrigNavConverterV2.cxx:1268
Run2ToRun3TrigNavConverterV2::createIMHNodes
StatusCode createIMHNodes(ConvProxySet_t &, xAOD::TrigCompositeContainer &, const EventContext &) const
Definition: Run2ToRun3TrigNavConverterV2.cxx:996
Amg::transform
Amg::Vector3D transform(Amg::Vector3D &v, Amg::Transform3D &tr)
Transform a point from a Trasformation3D.
Definition: GeoPrimitivesHelpers.h:156
Run2ToRun3TrigNavConverterV2::m_includeTauTrackFeatures
Gaudi::Property< bool > m_includeTauTrackFeatures
Definition: Run2ToRun3TrigNavConverterV2.h:86
Run2ToRun3TrigNavConverterV2::m_TrigEMClusterContainerCLID
CLID m_TrigEMClusterContainerCLID
Definition: Run2ToRun3TrigNavConverterV2.h:178
TEIdToChainsMap_t
std::map< HLT::te_id_type, std::set< HLT::Identifier > > TEIdToChainsMap_t
Definition: Run2ToRun3TrigNavConverterV2.h:60
TrigCompositeUtils::decisionToElementLink
ElementLink< DecisionContainer > decisionToElementLink(const Decision *d, const EventContext &ctx)
Takes a raw pointer to a Decision and returns an ElementLink to the Decision.
Definition: TrigCompositeUtilsRoot.cxx:122
test_pyathena.parent
parent
Definition: test_pyathena.py:15
plotIsoValidation.el
el
Definition: plotIsoValidation.py:197
xAOD::uint64_t
uint64_t
Definition: EventInfo_v1.cxx:123
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
xAOD::TrigComposite_v1
Class used to describe composite objects in the HLT.
Definition: TrigComposite_v1.h:52
DataVector
Derived DataVector<T>.
Definition: DataVector.h:581
CLID
uint32_t CLID
The Class ID type.
Definition: Event/xAOD/xAODCore/xAODCore/ClassID_traits.h:47
HLT::Identifier
Definition: TrigCompositeUtils/TrigCompositeUtils/HLTIdentifier.h:20
xAOD::decisions
decisions
Definition: TrigComposite_v1.cxx:81
AthReentrantAlgorithm::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
Definition: AthReentrantAlgorithm.h:153
Run2ToRun3TrigNavConverterV2::removeTopologicalProxies
StatusCode removeTopologicalProxies(ConvProxySet_t &) const
Definition: Run2ToRun3TrigNavConverterV2.cxx:863
SpecialCases::egammaEtcut
const std::regex egammaEtcut
Definition: SpecialCases.h:10
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
Run2ToRun3TrigNavConverterV2::feaToSave
bool feaToSave(const HLT::TriggerElement::FeatureAccessHelper &fea) const
Definition: Run2ToRun3TrigNavConverterV2.cxx:1371
TrigCompositeUtils::featureString
const std::string & featureString()
Definition: TrigCompositeUtilsRoot.cxx:886
ChainNameParser::multiplicities
std::vector< int > multiplicities(const std::string &chain)
Definition: ChainNameParser.cxx:202
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
Run2ToRun3TrigNavConverterV2::collapseFeaturesProxies
StatusCode collapseFeaturesProxies(ConvProxySet_t &convProxies, const HLT::TrigNavStructure &run2Nav) const
Definition: Run2ToRun3TrigNavConverterV2.cxx:751
id
SG::auxid_t id
Definition: Control/AthContainers/Root/debug.cxx:194
Run2ToRun3TrigNavConverterV2::m_finalTEIdsToChains
TEIdToChainsMap_t m_finalTEIdsToChains
Definition: Run2ToRun3TrigNavConverterV2.h:96
HLT::StandaloneNavigation
Definition: StandaloneNavigation.h:14
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:195
Run2ToRun3TrigNavConverterV2::m_doCompression
Gaudi::Property< bool > m_doCompression
Definition: Run2ToRun3TrigNavConverterV2.h:84
AthReentrantAlgorithm::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthReentrantAlgorithm.cxx:96
ConvProxySet_t
std::set< ConvProxy * > ConvProxySet_t
Definition: Run2ToRun3TrigNavConverterV2.h:59
Run2ToRun3TrigNavConverterV2::associateChainsToProxies
StatusCode associateChainsToProxies(ConvProxySet_t &, const TEIdToChainsMap_t &) const
Definition: Run2ToRun3TrigNavConverterV2.cxx:612
TrigConf::HLTUtils::hash2string
static const std::string hash2string(HLTHash, const std::string &category="TE")
hash function translating identifiers into names (via internal dictionary)
TrigCompositeUtils::summaryPassNodeName
const std::string & summaryPassNodeName()
Definition: TrigCompositeUtilsRoot.cxx:918
LArNewCalib_PedestalAutoCorr.cp
cp
Definition: LArNewCalib_PedestalAutoCorr.py:175
Run2ToRun3TrigNavConverterV2::m_doLinkFeatures
Gaudi::Property< bool > m_doLinkFeatures
Definition: Run2ToRun3TrigNavConverterV2.h:85
Run2ToRun3TrigNavConverterV2::getFeaSize
std::size_t getFeaSize(const ConvProxy &) const
Definition: Run2ToRun3TrigNavConverterV2.cxx:1171
Run2ToRun3TrigNavConverterV2::numberOfHNodesPerProxyNotExcessive
StatusCode numberOfHNodesPerProxyNotExcessive(const ConvProxySet_t &) const
Definition: Run2ToRun3TrigNavConverterV2.cxx:1420
TrigCompositeUtils::createLegName
HLT::Identifier createLegName(const HLT::Identifier &chainIdentifier, size_t counter)
Generate the HLT::Identifier which corresponds to a specific leg of a given chain.
Definition: TrigCompositeUtilsRoot.cxx:166
Run2ToRun3TrigNavConverterV2::allProxiesHaveChain
StatusCode allProxiesHaveChain(const ConvProxySet_t &) const
Definition: Run2ToRun3TrigNavConverterV2.cxx:1392
HLT::TrigNavStructure::getRoINodes
static const std::vector< TriggerElement * > & getRoINodes(const TriggerElement *somenode)
gets all RoI type nodes seeding indirectly this TriggerElement
Definition: TrigNavStructure.cxx:73
Run2ToRun3TrigNavConverterV2::fillRelevantFeatures
StatusCode fillRelevantFeatures(ConvProxySet_t &convProxies, const HLT::TrigNavStructure &run2Nav) const
Definition: Run2ToRun3TrigNavConverterV2.cxx:890
xAOD::TrigComposite_v1::name
const std::string & name() const
Get a human-readable name for the object.
SG::WriteHandle
Definition: StoreGate/StoreGate/WriteHandle.h:76
HLT::TrigNavStructure::getAllTEs
std::vector< TriggerElement * > & getAllTEs()
access needed by slimming tools.
Definition: TrigNavStructure.cxx:376
TrigCompositeUtils::linkToPrevious
void linkToPrevious(Decision *d, const std::string &previousCollectionKey, size_t previousIndex)
Links to the previous object, location of previous 'seed' decision supplied by hand.
Definition: TrigCompositeUtilsRoot.cxx:139
Run2ToRun3TrigNavConverterV2::collapseFeaturelessProxies
StatusCode collapseFeaturelessProxies(ConvProxySet_t &) const
Definition: Run2ToRun3TrigNavConverterV2.cxx:799
Run2ToRun3TrigNavConverterV2::m_CaloClusterCLID
CLID m_CaloClusterCLID
Definition: Run2ToRun3TrigNavConverterV2.h:179
HLT::TrigNavStructure::isInitialNode
static bool isInitialNode(const TriggerElement *te)
queries if node is an initial one
Definition: TrigNavStructure.cxx:501
a
TList * a
Definition: liststreamerinfos.cxx:10
TrigCompositeUtils::DecisionIDContainer
std::set< DecisionID > DecisionIDContainer
Definition: TrigComposite_v1.h:28
python.selector.AtlRunQuerySelectorLhcOlc.selector
selector
Definition: AtlRunQuerySelectorLhcOlc.py:611
h
CondAlgsOpts.found
int found
Definition: CondAlgsOpts.py:101
CaloCondBlobAlgs_fillNoiseFromASCII.hash
dictionary hash
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:109
HLT::TriggerElement::FeatureAccessHelper
the FeatureAccessHelper is a class used to keep track of features attached to this TE.
Definition: TrigNavStructure/TrigNavStructure/TriggerElement.h:192
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
TrigRoiDescriptorCollection
Definition: TrigRoiDescriptorCollection.h:21
xAOD::TauTrack_v1
Definition: TauTrack_v1.h:27
HLT::StandaloneNavigation::deserialize
virtual bool deserialize(const std::vector< uint32_t > &input)
Definition: StandaloneNavigation.cxx:88
Run2ToRun3TrigNavConverterV2::is2LegTopoChain
size_t is2LegTopoChain(const TrigConf::HLTChain *ptrChain) const
Definition: Run2ToRun3TrigNavConverterV2.cxx:354
DeMoScan.first
bool first
Definition: DeMoScan.py:534
Run2ToRun3TrigNavConverterV2::mirrorTEsStructure
StatusCode mirrorTEsStructure(ConvProxySet_t &, const HLT::TrigNavStructure &run2Nav) const
Definition: Run2ToRun3TrigNavConverterV2.cxx:530
python.TriggerAPI.TriggerAPISession.chainName
chainName
Definition: TriggerAPISession.py:353
Run2ToRun3TrigNavConverterV2::m_clidSvc
ServiceHandle< IClassIDSvc > m_clidSvc
Definition: Run2ToRun3TrigNavConverterV2.h:81
TrigCompositeUtils::decisionIDs
void decisionIDs(const Decision *d, DecisionIDContainer &destination)
Extracts DecisionIDs stored in the Decision object.
Definition: TrigCompositeUtilsRoot.cxx:67
Run2ToRun3TrigNavConverterV2::doCompression
StatusCode doCompression(ConvProxySet_t &convProxies, const HLT::TrigNavStructure &run2Nav) const
Definition: Run2ToRun3TrigNavConverterV2.cxx:706
python.utility.LHE.merge
def merge(input_file_pattern, output_file)
Merge many input LHE files into a single output file.
Definition: LHE.py:17
HLT::Identifier::name
std::string name() const
reports human redable name if it is enabled or, empty string
Definition: HLTIdentifier.cxx:14
Run2ToRun3TrigNavConverterV2::m_CaloClusterContainerCLID
CLID m_CaloClusterContainerCLID
Definition: Run2ToRun3TrigNavConverterV2.h:180
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:616
ConvProxy
Definition: Run2ToRun3TrigNavConverterV2.h:33
LArCellBinning.step
step
Definition: LArCellBinning.py:158
feaToSkip
bool feaToSkip(const HLT::TriggerElement::FeatureAccessHelper &fea)
Definition: Run2ToRun3TrigNavConverterV2.cxx:1324
ReadCalibFromCool.typeName
typeName
Definition: ReadCalibFromCool.py:477
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
SpecialCases::tauXeChain
const std::regex tauXeChain
Definition: SpecialCases.h:14
Run2ToRun3TrigNavConverterV2::printProxies
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
Definition: Run2ToRun3TrigNavConverterV2.cxx:596
TrigCompositeUtils::roiString
const std::string & roiString()
Definition: TrigCompositeUtilsRoot.cxx:878
Run2ToRun3TrigNavConverterV2::linkFeaNode
StatusCode linkFeaNode(ConvProxySet_t &convProxies, xAOD::TrigCompositeContainer &, const HLT::TrigNavStructure &run2Nav, const EventContext &context) const
Definition: Run2ToRun3TrigNavConverterV2.cxx:1193
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:790
Run2ToRun3TrigNavConverterV2::m_TrigRingerRingsContainerCLID
CLID m_TrigRingerRingsContainerCLID
Definition: Run2ToRun3TrigNavConverterV2.h:176
Run2ToRun3TrigNavConverterV2::cureUnassociatedProxies
StatusCode cureUnassociatedProxies(ConvProxySet_t &) const
Definition: Run2ToRun3TrigNavConverterV2.cxx:644
TrigCompositeUtils::getIDFromLeg
HLT::Identifier getIDFromLeg(const HLT::Identifier &legIdentifier)
Generate the HLT::Identifier which corresponds to the chain name from the leg name.
Definition: TrigCompositeUtilsRoot.cxx:180
xAOD::track
@ track
Definition: TrackingPrimitives.h:512
xAOD::TrackParticle_v1
Class describing a TrackParticle.
Definition: TrackParticle_v1.h:43
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
python.Constants.VERBOSE
int VERBOSE
Definition: Control/AthenaCommon/python/Constants.py:14
Run2ToRun3TrigNavConverterV2::m_teIDPrinter
std::function< void(const ConvProxy *)> m_teIDPrinter
Definition: Run2ToRun3TrigNavConverterV2.h:149
ConvProxy::parents
std::set< ConvProxy * > parents
Definition: Run2ToRun3TrigNavConverterV2.h:43
test_pyathena.counter
counter
Definition: test_pyathena.py:15
SG::AllowEmpty
@ AllowEmpty
Definition: StoreGate/StoreGate/VarHandleKey.h:30
Run2ToRun3TrigNavConverterV2::m_TrigEMClusterCLID
CLID m_TrigEMClusterCLID
Definition: Run2ToRun3TrigNavConverterV2.h:177
python.compressB64.c
def c
Definition: compressB64.py:93
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
Run2ToRun3TrigNavConverterV2::m_chainsToSave
Gaudi::Property< std::vector< std::string > > m_chainsToSave
Definition: Run2ToRun3TrigNavConverterV2.h:88
Run2ToRun3TrigNavConverterV2::m_TrackParticleContainerCLID
CLID m_TrackParticleContainerCLID
Definition: Run2ToRun3TrigNavConverterV2.h:181
SpecialCases::egammaCombinedWithEtcut
const std::regex egammaCombinedWithEtcut
Definition: SpecialCases.h:11
TrigCompositeUtils::inputMakerNodeName
const std::string & inputMakerNodeName()
Definition: TrigCompositeUtilsRoot.cxx:902
fitman.k
k
Definition: fitman.py:528
python.handimod.cc
int cc
Definition: handimod.py:523
Run2ToRun3TrigNavConverterV2::m_doSelfValidation
Gaudi::Property< bool > m_doSelfValidation
Definition: Run2ToRun3TrigNavConverterV2.h:83
ServiceHandle< ICondSvc >
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
HLT::te_id_type
uint32_t te_id_type
Definition: Trigger/TrigEvent/TrigNavStructure/TrigNavStructure/Types.h:11
Generated on Fri Jul 5 2024 21:57:22 for ATLAS Offline Software by   doxygen 1.8.18