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.
virtual bool	isClonable () const override
	Specify if the algorithm is clonable.
virtual StatusCode	sysExecute (const EventContext &ctx) override
	Execute an algorithm.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
virtual bool	filterPassed (const EventContext &ctx) const
	Get filter decision:
virtual void	setFilterPassed (bool state, const EventContext &ctx) const
	Set filter decision:
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
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.

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
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)
bool	feaToSave (const HLT::TriggerElement::FeatureAccessHelper &fea, const std::string &sgName) 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
std::pair< std::size_t, std::size_t >	getHighestPtObject (const ConvProxy &, const HLT::TrigNavStructure &) const
	Return pair of indices (feature index in proxy->features vector, object index) identifying the highest pT object attached to the proxy.
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
CLID	getExpectedParticleCLID (const std::string &teName) const
	Helper function to determine expected particle CLID based on TE name Returns 0 if no specific type is expected (e.g., for non-physics TEs).
StatusCode	bjetMuChainConfigDecoder (TEIdToChainsMap_t &allTES, TEIdToChainsMap_t &finalTEs, const TrigConf::HLTChain *ptrChain) const
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

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}
CLID	m_ElectronContainerCLID {0}
CLID	m_PhotonContainerCLID {0}
CLID	m_MuonContainerCLID {0}
CLID	m_TauJetContainerCLID {0}
DataObjIDColl	m_extendedExtraObjects
	Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default).
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default).
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 68 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 146 of file Run2ToRun3TrigNavConverterV2.cxx.

                                                                                                          : AthReentrantAlgorithm(name, pSvcLocator)
{
}

~Run2ToRun3TrigNavConverterV2()

Run2ToRun3TrigNavConverterV2::~Run2ToRun3TrigNavConverterV2 ( )

overridevirtual

Definition at line 150 of file Run2ToRun3TrigNavConverterV2.cxx.

{
}

Member Function Documentation

allProxiesConnected()

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

private

Definition at line 1685 of file Run2ToRun3TrigNavConverterV2.cxx.

{
  for (auto p : proxies)
  {
    if (p->children.empty() and p->parents.empty() and not p->runChains.empty())
    {
      ATH_MSG_ERROR("Orphaned proxy, N chains run: " << p->runChains.size());
      return StatusCode::FAILURE;
    }
  }
  ATH_MSG_DEBUG("CHECK OK, no orphaned proxies");
  return StatusCode::SUCCESS;
}

allProxiesHaveChain()

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

private

Definition at line 1671 of file Run2ToRun3TrigNavConverterV2.cxx.

{
  for (auto p : proxies)
  {
    if (p->runChains.empty())
    {
      ATH_MSG_ERROR("Proxy with no chains");
      return StatusCode::FAILURE;
    }
  }
  ATH_MSG_DEBUG("CHECK OK, no proxies w/o a chain");
  return StatusCode::SUCCESS;
}

associateChainsToProxies()

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

private

Definition at line 807 of file Run2ToRun3TrigNavConverterV2.cxx.

{
 
  for (auto &ptrConvProxy : convProxies)
  {
    auto teId = ptrConvProxy->te->getId();
    bool teActive = ptrConvProxy->te->getActiveState();
    auto iter = allTEs.find(teId);
    if (iter != allTEs.end())
    {
      ptrConvProxy->runChains.insert(iter->second.begin(), iter->second.end());
      if (teActive)
      {
        ptrConvProxy->passChains.insert(iter->second.begin(), iter->second.end());
      }
    }
 
    for (auto &objTeIdToChain : allTEs)
    {
      if (teId == objTeIdToChain.first)
      {
        for (auto &chainId : objTeIdToChain.second)
        {
          (ptrConvProxy->runChains).insert(chainId);
        }
        break;
      }
    }
  }
  return StatusCode::SUCCESS;
}

bjetMuChainConfigDecoder()

StatusCode Run2ToRun3TrigNavConverterV2::bjetMuChainConfigDecoder ( TEIdToChainsMap_t & allTES, TEIdToChainsMap_t & finalTEs, const TrigConf::HLTChain * ptrChain ) const

private

Definition at line 686 of file Run2ToRun3TrigNavConverterV2.cxx.

                                                                                                                                                                 {
  HLT::Identifier chainId = HLT::Identifier(ptrChain->name());
 
  std::vector<unsigned int> muons;
  std::vector<unsigned int> jets;
  bool switchedTojets =false;
  for (auto ptrHLTSignature : ptrChain->signatures()) {
    for (auto ptrHLTTE : ptrHLTSignature->outputTEs()) {
      if ( ptrHLTTE->name().find("_mu") == std::string::npos )  {
        switchedTojets = true; 
      }
 
      if ( switchedTojets)
        jets.push_back(ptrHLTTE->id());
      else
        muons.push_back(ptrHLTTE->id());
    }
  }
  ATH_CHECK(not muons.empty());
  ATH_CHECK(not jets.empty());
  std::reverse(std::begin(muons), std::end(muons));
  std::reverse(std::begin(jets), std::end(jets));
  finalTEs[muons[0]].insert(TrigCompositeUtils::createLegName(chainId, 0));
  finalTEs[muons[0]].insert(chainId);
  finalTEs[jets[0]].insert(TrigCompositeUtils::createLegName(chainId, 1));
  finalTEs[jets[0]].insert(chainId);
 
  for ( size_t index = 0; index < std::min(muons.size(), jets.size()); ++index)
    {
      allTEs[muons[index]].insert(TrigCompositeUtils::createLegName(chainId, 0));
      allTEs[muons[index]].insert(chainId);
      allTEs[jets[index]].insert(TrigCompositeUtils::createLegName(chainId, 1));
      allTEs[jets[index]].insert(chainId);
    }
  return StatusCode::SUCCESS;
}

collapseFeaturelessProxies()

StatusCode Run2ToRun3TrigNavConverterV2::collapseFeaturelessProxies ( ConvProxySet_t & convProxies ) const

private

Definition at line 1013 of file Run2ToRun3TrigNavConverterV2.cxx.

{
  // merge proxies bases on the parent child relation (this has to run after feature based collapsing)
  struct ParentChildCharacteristics
  {
    ConvProxy *parent = nullptr;
    ConvProxy *child = nullptr;
    size_t distanceFromParent = 0;
    bool operator<(const ParentChildCharacteristics &rhs) const
    {
      if (parent != rhs.parent)
        return parent < rhs.parent;
      if (child != rhs.child)
        return child < rhs.child;
      return distanceFromParent < rhs.distanceFromParent;
    }
  };
  const size_t beforeCount = convProxies.size();
  std::map<ParentChildCharacteristics, ConvProxySet_t> groupedProxies;
  for (auto proxy : convProxies)
  {
    if (proxy->feaHash == ConvProxy::MissingFEA)
    {
      ATH_MSG_VERBOSE("Featureless proxy to deal with: " << proxy->description());
      /* the canonical case
        merged parent
         / |  | \
        C1 C2 C3 C4 <-- proxies to merge
         \ |  | /
        merged child
      */
      auto hasSomeFeatures = [](const ConvProxy* p){ return p->feaHash != ConvProxy::MissingFEA; };
      if (proxy->children.size() == 1 and
          std::all_of(proxy->children.begin(), proxy->children.end(), hasSomeFeatures ) and
          proxy->parents.size() == 1 and
          std::all_of(proxy->parents.begin(), proxy->parents.end(), hasSomeFeatures )
          )
      {
        ATH_MSG_VERBOSE("Proxy to possibly merge: " << proxy->description());
        groupedProxies[{*(proxy->parents.begin()), *(proxy->children.begin()), 0}].insert(proxy);
        // TODO expand it to cover longer featureless sequences
      }
      else
      {
        ATH_MSG_VERBOSE("Featureless proxy in noncanonical situation " << proxy->description());
        ATH_MSG_VERBOSE("parents ");
        for (auto pp : proxy->parents)
        {
          ATH_MSG_VERBOSE(pp->description());
        }
        ATH_MSG_VERBOSE("children ");
        for (auto cp : proxy->children)
        {
          ATH_MSG_VERBOSE(cp->description());
        }
      }
    }
  }
 
  ATH_CHECK(collapseProxies(convProxies, groupedProxies));
  ATH_MSG_DEBUG("Proxies without features collapsing reduces size from " << beforeCount << " to " << convProxies.size());
  return StatusCode::SUCCESS;
}

collapseFeaturesProxies()

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

private

Definition at line 965 of file Run2ToRun3TrigNavConverterV2.cxx.

{
 
  const size_t beforeCount = convProxies.size();
  std::map<uint64_t, ConvProxySet_t> feaToProxyMap;
  for (auto proxy : convProxies)
  {
    proxy->feaHash = feaToHash(proxy->te->getFeatureAccessHelpers(), proxy->te, run2Nav);
    if (proxy->feaHash != ConvProxy::MissingFEA)
      feaToProxyMap[proxy->feaHash].insert(proxy);
 
    ATH_MSG_VERBOSE("TE " << TrigConf::HLTUtils::hash2string(proxy->te->getId()) << " FEA hash " << proxy->feaHash);
    for (const HLT::TriggerElement::FeatureAccessHelper& fea : proxy->te->getFeatureAccessHelpers())
    {
      ATH_MSG_VERBOSE("FEA: " << fea);
    }
  }
 
  for (auto [feaHash, proxies] : feaToProxyMap)
  {
    auto first = *proxies.begin();
    for (auto p : proxies)
    {
      if (filterFEAs(first->te->getFeatureAccessHelpers(), run2Nav) !=
                        filterFEAs(p->te->getFeatureAccessHelpers(), run2Nav))
      {
        ATH_MSG_ERROR("Proxies grouped by FEA hash have actually distinct features (specific FEAs are different)");
        for (auto id: p->passChains ) ATH_MSG_ERROR("  Chain ID: " << id);
        ATH_MSG_ERROR("  TE ID: " << TrigConf::HLTUtils::hash2string(p->te->getId()));
        for ( auto fea: first->te->getFeatureAccessHelpers() ) {
          ATH_MSG_ERROR("  FEA (reference): " << fea);
        }
        for ( auto fea: p->te->getFeatureAccessHelpers() ) {
          ATH_MSG_ERROR("  FEA (mismatched): " << fea);
        }
 
        return StatusCode::FAILURE;
      }
    }
  }
 
 
  ATH_CHECK(collapseProxies(convProxies, feaToProxyMap));
  ATH_MSG_DEBUG("Proxies with features collapsing reduces size from " << beforeCount << " to " << convProxies.size());
 
  return StatusCode::SUCCESS;
}

collapseProxies()

template<typename MAP>

StatusCode Run2ToRun3TrigNavConverterV2::collapseProxies ( ConvProxySet_t & convProxies, MAP & keyToProxyMap ) const

private

Definition at line 936 of file Run2ToRun3TrigNavConverterV2.cxx.

{
  // collapse proxies based on the mapping in the map argument(generic) and clean proxiesSet
  std::vector<ConvProxy *> todelete;
  for (auto &[key, proxies] : keyToProxyMap)
  {
    if (proxies.size() > 1)
    {
      ATH_MSG_DEBUG("Merging " << proxies.size() << " similar proxies");
      for (auto p : proxies)
      {
        if (p->mergeAllowed(*proxies.begin()))
        {
          (*proxies.begin())->merge(p);
          todelete.push_back(p);
        }
        // TODO consider scanning proxies another time if merge is not allowed, it may be allowed with other proxies here
      }
    }
  }
  for (auto proxy : todelete)
  {
    convProxies.erase(proxy);
    delete proxy;
  }
  // remove from proxies set all elements that are now unassociated (remember to delete after)
  return StatusCode::SUCCESS;
}

createIMHNodes()

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

private

Definition at line 1224 of file Run2ToRun3TrigNavConverterV2.cxx.

{
  // Write the decision IDs of a proxy to a node, SKIPPING the plain chain ID
  // when the proxy also carries a leg ID of that chain. This follows the
  // native Run-3 convention: nodes of a leg carry only the leg ID, the plain
  // chain ID appears on chain-level (combined/terminus) nodes. The feature
  // retrieval (Trig::ChainGroup::features) always includes the plain chain ID
  // in the request - even for leg-restricted requests - so a plain chain ID
  // left on per-leg nodes would match every leg of the chain and pool the
  // features of all legs together (the "cross-leg feature pooling" defect).
  auto addNodeIDs = [](const std::set<HLT::Identifier>& ids, TrigCompositeUtils::Decision* node) {
    std::set<HLT::Identifier> chainsWithLegs;
    for (const HLT::Identifier& id : ids)
    {
      if (TCU::isLegId(id))
        chainsWithLegs.insert(TCU::getIDFromLeg(id));
    }
    for (const HLT::Identifier& id : ids)
    {
      if (!TCU::isLegId(id) && chainsWithLegs.count(id))
        continue;
      TrigCompositeUtils::addDecisionID(id, node);
    }
  };
 
  for (auto &proxy : convProxies)
  {
    proxy->imNode = TrigCompositeUtils::newDecisionIn(&decisions, TrigCompositeUtils::inputMakerNodeName()); // IM
    addNodeIDs(proxy->runChains, proxy->imNode);
    proxy->hNode.push_back(TrigCompositeUtils::newDecisionIn(&decisions, TrigCompositeUtils::hypoAlgNodeName())); // H
    addNodeIDs(proxy->passChains, proxy->hNode.back());
 
    TrigCompositeUtils::linkToPrevious(proxy->hNode.front(), proxy->imNode, context); // H low IM up
  }
  // connecting current IM to all Hs in parent proxies
  for (auto &proxy : convProxies)
  {
    for (auto &parentProxy : proxy->parents)
    {
      TrigCompositeUtils::linkToPrevious(proxy->imNode, parentProxy->hNode.front(), context); // IM low H up (in parent)
    }
  }
  ATH_MSG_DEBUG("IM & H nodes made, output nav elements " << decisions.size());
  return StatusCode::SUCCESS;
}

createL1Nodes()

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

private

Definition at line 1386 of file Run2ToRun3TrigNavConverterV2.cxx.

{
 
  auto makeL1Node = [&decisions, &context](auto firstDecisionNode, auto chainIds)
  {
    auto L1Node = TrigCompositeUtils::newDecisionIn(&decisions);
    L1Node->setName(TrigCompositeUtils::hltSeedingNodeName()); // L1
    for (auto chainId : chainIds)
    {
      TrigCompositeUtils::addDecisionID(chainId, L1Node);
    }
    TrigCompositeUtils::linkToPrevious(firstDecisionNode, L1Node, context); // IM -> L1
 
    return L1Node;
  };
 
  for (auto &proxy : convProxies)
  {
    // associate initial node to filter nodes,
    if (proxy->parents.empty())
    {                                                                             // the IM node is initial
      proxy->l1Node = makeL1Node(proxy->imNode, TCU::decisionIDs(proxy->imNode)); // not using passChains as there may be additional filtering
    }
  }
 
  ATH_MSG_DEBUG("L1 nodes made, output nav elements ");
  return StatusCode::SUCCESS;
}

createSFNodes()

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

private

Definition at line 1270 of file Run2ToRun3TrigNavConverterV2.cxx.

{
  // make node & link it properly
  auto makeSingleSFNode = [&decisions, &context](auto lastDecisionNode, auto chainIds, TrigCompositeUtils::DecisionID idStore = 0)
  {
    auto sfNode = TrigCompositeUtils::newDecisionIn(&decisions);
    sfNode->setName("SF");
    TrigCompositeUtils::linkToPrevious(decisions.at(0), sfNode, context);
    TrigCompositeUtils::linkToPrevious(sfNode, lastDecisionNode, context);
    for (auto chainId : chainIds)
    {
      if (idStore == 0)
    {
      TrigCompositeUtils::addDecisionID(chainId, sfNode);
      TrigCompositeUtils::addDecisionID(chainId, decisions.at(0));
    }
      else if (chainId.numeric() == idStore)
      {
        TrigCompositeUtils::addDecisionID(chainId, sfNode);
        TrigCompositeUtils::addDecisionID(chainId, decisions.at(0));
      }
    }
    return sfNode;
  };
  auto makeSFNodes = [makeSingleSFNode](auto proxy, TrigCompositeUtils::DecisionID idToStore = 0)
  {
      if (proxy->hNode.empty())
      { // nothing has passed, so link to the IM node
        // TODO make sure it needs to be done like that
        makeSingleSFNode(proxy->imNode, proxy->runChains, idToStore);
      }
      else
      {
        // makeSFNode(proxy->hNode[0], TCU::decisionIDs(proxy->hNode[0])); // not using passChains as there may be additional filtering
        for (auto &hNode : proxy->hNode)
        {
          makeSingleSFNode(hNode, proxy->passChains, idToStore); // using passChains
        }
      }
  };
 
  for (auto proxy : convProxies)
  {
    // associate terminal nodes to filter nodes,
    if (proxy->children.empty())
    { // the H modes are terminal
      makeSFNodes(proxy);
    }
    else
    {
      // likely need more iterations
      // nonterminal nodes that are nevertheless terminal for a given chain
      std::vector<TCU::DecisionID> toRetain;
      for (auto teId : proxy->teIDs)
      {
        auto whereInMap = terminalIds.find(teId);
        if (whereInMap != terminalIds.end())
        {
          toRetain.insert(toRetain.end(), whereInMap->second.begin(), whereInMap->second.end());
        }
      }
      for (auto chainIdstore : toRetain)
      {
        makeSFNodes(proxy, chainIdstore);
      }
    }
  }
  // associate all nodes designated as final one with the filter nodes
 
  ATH_MSG_DEBUG("SF nodes made, output nav elements " << decisions.size());
  return StatusCode::SUCCESS;
}

cureUnassociatedProxies()

StatusCode Run2ToRun3TrigNavConverterV2::cureUnassociatedProxies ( ConvProxySet_t & convProxies ) const

private

Definition at line 839 of file Run2ToRun3TrigNavConverterV2.cxx.

{
  // propagate up (towards L1) chain IDs if they are not in proxies
  // technically each proxy looks at the children proxies and inserts from it all unseen chains
  // procedure is repeated until, no single proxy needs an update (tedious - we may be smarter in future)
 
  // Helper: insert the child's IDs into the given set. Across a multi-parent
  // child (e.g. the combined TE of a multi-leg chain, which joins several
  // branches) only chain-level IDs are propagated: propagating LEG IDs there
  // would smear them onto all parent branches and pool the per-leg features.
  auto insertFromChild = [](const ConvProxy& child, std::set<HLT::Identifier>& dest) {
    if (child.parents.size() > 1)
    {
      for (const HLT::Identifier& id : child.runChains)
      {
        if (!TCU::isLegId(id))
          dest.insert(id);
      }
    }
    else
    {
      dest.insert(std::begin(child.runChains), std::end(child.runChains));
    }
  };
 
  while (true)
  {
    size_t numberOfUpdates = 0;
    for (auto p : convProxies)
    {
      for (auto child : p->children)
      {
        size_t startSize = p->runChains.size();
        insertFromChild(*child, p->runChains);
 
        if (startSize != p->runChains.size())
        { // some chain needed to be inserted
          numberOfUpdates++;
          // if update was need, it means set of chains that passed need update as well
          insertFromChild(*child, p->passChains);
        }
      }
    }
    ATH_MSG_DEBUG("Needed to propagate chains from " << numberOfUpdates << " child(ren)");
    if (numberOfUpdates == 0)
    {
      break;
    }
  }
  return StatusCode::SUCCESS;
}

declareGaudiProperty()

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

inlineprivateinherited

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

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareProperty()

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

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.

{ return m_detStore; }

doCompression()

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

private

Definition at line 920 of file Run2ToRun3TrigNavConverterV2.cxx.

{
 
  ATH_CHECK(collapseFeaturesProxies(convProxies, run2Nav));
  ATH_CHECK(collapseFeaturelessProxies(convProxies));
  if (m_doSelfValidation)
  {
    ATH_CHECK(allProxiesHaveChain(convProxies));
    ATH_CHECK(allProxiesConnected(convProxies));
  }
  ATH_MSG_DEBUG("Compression done");
 
  return StatusCode::SUCCESS;
}

evtStore()

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.

{ return m_evtStore; }

execute()

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

overridevirtual

Definition at line 253 of file Run2ToRun3TrigNavConverterV2.cxx.

{
  {
    // configuration reading could not be done before the event loop
    // it needs to be done only once though
    std::scoped_lock lock(m_configUpdateMutex);
    if (m_allTEIdsToChains.empty())
      ATH_CHECK(extractTECtoChainMapping(const_cast<TEIdToChainsMap_t &>(m_allTEIdsToChains), const_cast<TEIdToChainsMap_t &>(m_finalTEIdsToChains)));
  }
 
  ConvProxySet_t convProxies;
  HLT::StandaloneNavigation standaloneNav; // needed to keep TEs around, so it is out of the scope where it is filled and referenced
  const HLT::TrigNavStructure *run2NavigationPtr = nullptr;
  if (!m_trigNavKey.key().empty())
  {
    SG::ReadHandle navReadHandle(m_trigNavKey, context);
    ATH_CHECK(navReadHandle.isValid());
    bool ok = standaloneNav.deserialize(navReadHandle->serialized());
    if (not ok)[[unlikely]]{
      ATH_MSG_ERROR("deserialize returned false");
      return StatusCode::FAILURE;
    }
    run2NavigationPtr = &standaloneNav;
  }
  else
  {
    run2NavigationPtr = m_tdt->ExperimentalAndExpertMethods().getNavigation();
  }
 
  ATH_CHECK(mirrorTEsStructure(convProxies, *run2NavigationPtr));
  // printProxies(convProxies, [](auto ){ return true;},
  //             {m_chainIdsPrinter});
 
  if (m_doSelfValidation)
    ATH_CHECK(allProxiesConnected(convProxies));
 
  ATH_CHECK(associateChainsToProxies(convProxies, m_allTEIdsToChains));
  // printProxies(convProxies, [](auto ){ return true;},
  //             {m_chainIdsPrinter});
 
  ATH_CHECK(cureUnassociatedProxies(convProxies));
  ATH_MSG_DEBUG("Proxies to chains mapping done");
 
  ATH_CHECK(removeTopologicalProxies(convProxies));
 
  if (not m_chainsToSave.empty())
  {
    ATH_CHECK(removeUnassociatedProxies(convProxies));
    printProxies(convProxies, [](auto ){ return true;},
            {m_chainIdsPrinter});
    ATH_MSG_DEBUG("Removed proxies to chains that are not converted, remaining number of elements " << convProxies.size());
  }
  if (m_doSelfValidation)
  {
    ATH_CHECK(allProxiesHaveChain(convProxies));
  }
  if (m_doCompression)
  {
    ATH_CHECK(doCompression(convProxies, *run2NavigationPtr));
    // printProxies(convProxies, [](auto ){ return true;},
    //         {m_chainIdsPrinter});
 
  }
 
  SG::WriteHandle<TrigCompositeUtils::DecisionContainer> outputNavigation = TrigCompositeUtils::createAndStore(m_trigOutputNavKey, context);
  auto decisionOutput = outputNavigation.ptr();
  TrigCompositeUtils::newDecisionIn(decisionOutput, TCU::summaryPassNodeName()); // we rely on the fact that the 1st element is the top
 
  if (m_doLinkFeatures)
  {
    ATH_CHECK(fillRelevantFeatures(convProxies, *run2NavigationPtr));
    ATH_CHECK(fillRelevantRois(convProxies, *run2NavigationPtr));
    ATH_CHECK(fillRelevantTracks(convProxies));
    ATH_MSG_DEBUG("Features to link found");
  }
 
  ATH_CHECK(createIMHNodes(convProxies, *decisionOutput, context));
  if (m_doSelfValidation)
  {
    ATH_CHECK(numberOfHNodesPerProxyNotExcessive(convProxies));
  }
 
  ATH_CHECK(createL1Nodes(convProxies, *decisionOutput, context));
  ATH_CHECK(linkFeaNode(convProxies, *decisionOutput, *run2NavigationPtr, context));
  ATH_CHECK(linkRoiNode(convProxies, *run2NavigationPtr));
  ATH_CHECK(linkTrkNode(convProxies, *run2NavigationPtr));
  ATH_CHECK(createSFNodes(convProxies, *decisionOutput, m_finalTEIdsToChains, context));
  ATH_CHECK(updateTerminusNode(*decisionOutput, context));
  ATH_MSG_DEBUG("Conversion done, from " << convProxies.size() << " elements to " << decisionOutput->size() << " elements");
 
  printProxies(convProxies, [](auto ){ return true;},
              {m_chainIdsPrinter, m_teIDPrinter});
  ATH_MSG_DEBUG("Resulting nodes");
  size_t index = 0;
  for ( auto o: *decisionOutput) {
    ATH_MSG_DEBUG("Index: " << index << " " << *o);
    index++;
  }
 
  // dispose temporaries
  for (auto proxy : convProxies)
  {
    delete proxy;
  }
 
  return StatusCode::SUCCESS;
}

extractTECtoChainMapping()

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

private

Definition at line 405 of file Run2ToRun3TrigNavConverterV2.cxx.

{
 
  ATH_CHECK(not m_configSvc->chains().empty());
 
  // obtain map output TE -> input TE via sequences
  for (auto ptrChain : m_configSvc->chains())
  {
    std::string chainName = ptrChain->name();
 
    if (not m_chainsToSave.empty())
    {
      auto found = std::find(m_chainsToSave.begin(), m_chainsToSave.end(), chainName);
      if (found == m_chainsToSave.end())
      {
        continue;
      }
    }
 
    if (std::regex_match(chainName, SpecialCases::bjetMuChain ))  {
      ATH_CHECK(bjetMuChainConfigDecoder(allTEs, finalTEs, ptrChain));
      continue;
    }
 
    // hack for etcut chains
    // if we ever need to generalise that it should be moved to separate function
    std::map<HLT::te_id_type, HLT::te_id_type> etcutReplacementTEs;
    auto etcutReplacement = [&etcutReplacementTEs](HLT::te_id_type in) { auto out = etcutReplacementTEs.find(in);  return (out == etcutReplacementTEs.end() ? in : out->second ); };
    if ( chainName.find("etcut") != std::string::npos ) {
      std::set<size_t> positionsOfEtCutLegs;
      // use heuristics to mention
      if( std::regex_match(chainName, SpecialCases::egammaDiEtcut) ) {
         ATH_MSG_DEBUG("EtCut chains hack, chain with two etcut legs ");
         positionsOfEtCutLegs.insert({0, 1});
      } else if ( std::regex_match(chainName, SpecialCases::egammaCombinedWithEtcut) ) {
         ATH_MSG_DEBUG("EtCut chains hack, egamma chain with second etcut leg ");
         positionsOfEtCutLegs.insert({1});
      } else if ( std::regex_match(chainName, SpecialCases::egammaEtcut) ) {
         ATH_MSG_DEBUG("EtCut chains hack, single leg egamma chain");
         positionsOfEtCutLegs.insert({0});
      }
 
      // pilot pass to fill the replacement map
      std::map<size_t, HLT::te_id_type> positionToDesiredIDmap;
      for (auto ptrHLTSignature : ptrChain->signatures()) {
        size_t position = 0;
        for (auto ptrHLTTE : ptrHLTSignature->outputTEs()) {
          if (positionsOfEtCutLegs.count(position) and positionToDesiredIDmap.find(position) != positionToDesiredIDmap.end() ) {
            etcutReplacementTEs[ptrHLTTE->id()] = positionToDesiredIDmap[position];
            ATH_MSG_DEBUG("EtCut chains hack, TE " << ptrHLTTE->name() << " will be replaced by: " << TrigConf::HLTUtils::hash2string(positionToDesiredIDmap[position]));
          } else {
            if ( ptrHLTTE->name().find("calocalib") != std::string::npos and positionsOfEtCutLegs.count(position) ) { // we have final TE for this leg
              positionToDesiredIDmap[position] =  ptrHLTTE->id();
            }
          }
          position++;
        }
      }
    }
 
    // chains with a single leg
    HLT::Identifier chainId = HLT::Identifier(chainName);
    ATH_MSG_DEBUG(" CHAIN name " << chainName << " CHAIN Id " << chainId);
    for (auto ptrHLTSignature : ptrChain->signatures()) {
      for (auto ptrHLTTE : ptrHLTSignature->outputTEs()) {
        unsigned int teId = etcutReplacement(ptrHLTTE->id());
        allTEs[teId].insert(chainId);
        if (ptrHLTSignature == ptrChain->signatures().back()) {
            finalTEs[teId].insert(chainId);
            ATH_MSG_DEBUG("TE will be used to mark final chain decision " << ptrHLTTE->name() << " chain " << chainName );
        }
      }
    }
    // chains with a multiple legs
    std::vector<int> multiplicities = ChainNameParser::multiplicities(chainName);
 
    // dirty hacks for failing chains parsing
    if(std::regex_match(chainName, SpecialCases::gammaXeChain))
      multiplicities={1,1};
 
    if ( multiplicities.size() > 1 ) {
      ATH_MSG_DEBUG(" this " << (is2LegTopoChain(ptrChain) ? "is": "is not") << " topological chain");
      // the chain structure (in terms of multiplicities) may change along the way
      // we'll assign legs only to these TEs of the steps that have identical multiplicity pattern
      // e.g. for the chain: HLT_2g25_loose_g20 the multiplicities are: [2, 1]
 
      // hack for HLT.*tau.*xe.* case
      if (std::regex_match(chainName, SpecialCases::tauXeChain)) {
          // The Run-2 configuration lacks usable leg multiplicities for these
          // chains. Set them to the chain-name structure: the TDT
          // (Trig::ChainGroup, which follows getLegMultiplicities), the R3
          // matching (which parses the chain name) and the leg assignment
          // below must all agree on the leg structure, otherwise leg-filtered
          // feature retrieval comes back empty. The xe leg keeps its place and
          // simply owns no IParticle features.
          std::vector<size_t> mult_hack(multiplicities.begin(), multiplicities.end());
          ptrChain->set_leg_multiplicities(mult_hack); // HLTChain needs vector<size_t>
      }
 
      // hack for mu2MunoL1Special
      if (std::regex_match(chainName, SpecialCases::mu2MunoL1Special)) {
          std::vector<size_t> mult_hack;
          if (multiplicities.size()==3) mult_hack={1,1};
          else if (multiplicities.size()==2) mult_hack={2}; // HLT_mu11_nomucomb_2mu4noL1_nscan03_L1MU11_2MU6
          ptrChain->set_leg_multiplicities(mult_hack);
          multiplicities.assign(mult_hack.begin(), mult_hack.end());
      }
 
      ATH_MSG_DEBUG("CHAIN " << chainName << " needs legs: " << multiplicities );
 
      if ( multiplicities.size() <= 1 ) {
        ATH_MSG_DEBUG("Chain " << chainName << " has a single effective leg after special-case handling - no leg IDs assigned");
      }
      else {
 
      // Build per-leg name tokens (e.g. "mu14", "tau35") from the chain name.
      // The Run-2 menu does not guarantee that the TEs of a signature step are
      // listed in the leg order of the chain name (e.g. for mu+tau chains the
      // tau TEs come first), so a purely positional leg assignment can swap
      // the legs and - via the chain-ID propagation - pool the features of
      // different legs. Where possible the TE name, which carries the leg
      // token, decides the leg number instead.
      std::vector<std::string> legTokens;
      bool legTokensUsable = true;
      for (const ChainNameParser::LegInfo& legInfo : ChainNameParser::HLTChainInfo(chainName)) {
        if (legInfo.signature.empty() || legInfo.threshold < 0) {
          legTokensUsable = false;
          break;
        }
        legTokens.push_back(legInfo.signature + std::to_string(legInfo.threshold));
      }
      if (legTokens.size() > multiplicities.size()) {
        // special-case handling dropped trailing leg(s) (e.g. the xe leg)
        legTokens.resize(multiplicities.size());
      }
      if (legTokens.size() != multiplicities.size()
          || std::set<std::string>(legTokens.begin(), legTokens.end()).size() != legTokens.size()) {
        // e.g. two legs with an identical token (HLT_mu13_mu13_idperf_Zmumu):
        // fall back to the positional assignment
        legTokensUsable = false;
      }
      ATH_MSG_DEBUG("Semantic leg tokens " << (legTokensUsable ? "usable" : "NOT usable") << ": " << legTokens);
 
      // noL1 legs (e.g. mu8noL1, mu6noL1_nscan03) have no leg token in their
      // TE names: the leg is implemented as a full-scan reconstruction
      // (EF_*_FS*/FSHypo/FStracks TEs) plus a joint "MultiComb" multiplicity
      // hypo TE which decides ALL thresholds at once. Identify such a leg so
      // full-scan TEs can be routed to it by name pattern.
      int noL1Leg = -1;
      int legIndex = 0;
      for (const ChainNameParser::LegInfo& legInfo : ChainNameParser::HLTChainInfo(chainName)) {
        if (legInfo.legName().find("noL1") != std::string::npos) {
          noL1Leg = (noL1Leg == -1) ? legIndex : -2; // -2: more than one noL1 leg -> rule unusable
        }
        ++legIndex;
      }
      if (noL1Leg == -2) noL1Leg = -1; // more than one noL1 leg: the rule is unusable
 
      // Semantic leg for a single TE name:
      //   >= 0 : leg number
      //   -1   : unknown (positional fallback in pattern-matched steps)
      //   -2   : joint/combined decision TE (gets NO leg ID)
      const size_t nLegs = multiplicities.size();
      auto semanticLeg = [&legTokens, legTokensUsable, noL1Leg, nLegs](const std::string& teName) -> int {
        if (teName.find("MultiComb") != std::string::npos)
          return -2; // joint multiplicity hypo of a noL1 chain: chain-level, not a leg
        if (legTokensUsable) {
          int found = -1;
          for (size_t l = 0; l < legTokens.size(); ++l) {
            if (teName.find(legTokens[l]) != std::string::npos) {
              if (found != -1) { found = -1; break; } // ambiguous TE name
              found = static_cast<int>(l);
            }
          }
          if (found >= 0) return found;
        }
        if (noL1Leg >= 0) {
          if (teName.find("_FS") != std::string::npos || teName.find("FSHypo") != std::string::npos
              || teName.find("FStracks") != std::string::npos) {
            return noL1Leg; // full-scan reconstruction TE -> the noL1 leg
          }
          if (nLegs == 2) {
            return 1 - noL1Leg; // two legs, one noL1: everything else is the RoI-seeded leg
          }
        }
        return -1;
      };
 
      // Decide the leg number for each TE of a pattern-matched step: semantic
      // assignment first, remaining TEs distributed over the remaining leg
      // numbers in positional order (the previous behaviour).
      auto assignLegNumbers = [&semanticLeg, nLegs](const std::vector<std::string>& teNames) {
        const size_t n = teNames.size();
        std::vector<int> legOf(n, -1);
        std::vector<bool> legUsed(nLegs, false); // leg numbers range over the CHAIN's legs,
                                                 // not over the TEs of this step (they can
                                                 // differ, e.g. for the tau+xe special case)
        for (size_t pos = 0; pos < n; ++pos) {
          const int l = semanticLeg(teNames[pos]);
          if (l >= 0 && l < static_cast<int>(nLegs) && !legUsed[l]) {
            legOf[pos] = l;
            legUsed[l] = true;
          }
          else if (l == -2) {
            legOf[pos] = -2;
          }
        }
        size_t nextFree = 0;
        for (size_t pos = 0; pos < n; ++pos) {
          if (legOf[pos] != -1) continue;
          while (nextFree < nLegs && legUsed[nextFree]) ++nextFree;
          if (nextFree >= nLegs) break;
          legOf[pos] = static_cast<int>(nextFree);
          legUsed[nextFree] = true;
        }
        return legOf;
      };
 
      // The terminus of each leg (for the SF nodes / per-leg retrieval
      // anchors) is the LAST TE assigned to that leg over the signature steps.
      std::map<int, unsigned int> lastTEofLeg;
 
      for (auto ptrHLTSignature : ptrChain->signatures())
        {
          std::vector<int> teCounts;
          std::vector<unsigned int> teIds;
          std::vector<std::string> teNames;
          unsigned int lastSeenId = 0;
          for (auto ptrHLTTE : ptrHLTSignature->outputTEs())
          {
            if ( lastSeenId != ptrHLTTE->id()) {
              teCounts.push_back(1);
              teIds.push_back(ptrHLTTE->id());
              teNames.push_back(ptrHLTTE->name());
            } else {
              teCounts.back()++;
            }
            lastSeenId = ptrHLTTE->id();
          }
 
          ATH_MSG_DEBUG("TE multiplicities seen in this step " << teCounts << " TEs: " << teNames);
          bool multiplicityCounts = multiplicities == teCounts;
          // hack for HLT.*tau.*xe.* case
          if(std::regex_match(chainName, SpecialCases::tauXeChain)) multiplicityCounts = true;
          if ( multiplicityCounts ) {
            const std::vector<int> legOf = assignLegNumbers(teNames);
            ATH_MSG_DEBUG("There is a match, will assign chain leg IDs to TEs " << teCounts << " " << teIds);
            for ( size_t pos = 0; pos < teIds.size(); ++ pos){
              if (legOf[pos] < 0) continue; // joint-decision TE: stays chain-level
              HLT::Identifier chainLegId = TrigCompositeUtils::createLegName(chainId, legOf[pos]);
              ATH_MSG_DEBUG("  TE " << teNames[pos] << " -> " << chainLegId);
              allTEs[etcutReplacement(teIds[pos])].insert(chainLegId);
              lastTEofLeg[legOf[pos]] = teIds[pos];
            }
          }
          else {
            // Steps whose TE pattern does not match the leg multiplicities
            // (e.g. the interleaved single-TE steps of noL1 chains) still get
            // a leg ID when the TE name identifies the leg unambiguously.
            for ( size_t pos = 0; pos < teIds.size(); ++ pos){
              const int leg = semanticLeg(teNames[pos]);
              if (leg < 0) continue;
              HLT::Identifier chainLegId = TrigCompositeUtils::createLegName(chainId, leg);
              ATH_MSG_DEBUG("  (irregular step) TE " << teNames[pos] << " -> " << chainLegId);
              allTEs[etcutReplacement(teIds[pos])].insert(chainLegId);
              lastTEofLeg[leg] = teIds[pos];
            }
          }
        }
        for (const auto& [legNumber, teId] : lastTEofLeg) {
          HLT::Identifier chainLegId = TrigCompositeUtils::createLegName(chainId, legNumber);
          ATH_MSG_DEBUG("created leg id " << chainLegId << " that will replace TE ID " << etcutReplacement(teId));
          finalTEs[etcutReplacement(teId)].insert(chainLegId);
        }
      } // end of the multi-effective-leg assignment
    }
  }
  ATH_MSG_DEBUG("Recognised " << allTEs.size() << " kinds of TEs and among them " << finalTEs.size() << " final types");
  return StatusCode::SUCCESS;
}

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 & AthCommonAlgorithm< Gaudi::Algorithm >::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 89 of file AthCommonAlgorithm.cxx.

{
  // If we didn't find any symlinks to add, just return the collection
  // from the base class.  Otherwise, return the extended collection.
  if (!m_extendedExtraObjects.empty()) {
    return m_extendedExtraObjects;
  }
  return BaseAlg::extraOutputDeps();
}

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 1606 of file Run2ToRun3TrigNavConverterV2.cxx.

{
  // FEA vectors hashing
  // Filter by expected particle type based on TE name to ensure correct feature type
  std::string teName = TrigConf::HLTUtils::hash2string(te_ptr->getId());
  CLID expectedCLID = getExpectedParticleCLID(teName);
 
  ATH_MSG_VERBOSE("Calculating FEA hash for TE " << teName << " expecting CLID " << expectedCLID);
  uint64_t hash = 0;
  for (auto fea : filterFEAs(feaVector, navigationDecoder))
  {
    const auto & [sgKey, sgCLID, sgName] = getSgKey(navigationDecoder, fea);
 
    // Apply TE-based filtering during hash calculation to prevent wrong merges
    if (expectedCLID != 0 && sgCLID != expectedCLID)
    {
      ATH_MSG_VERBOSE("Skipping FEA with CLID " << sgCLID << " for TE " << teName
                      << " (expected " << expectedCLID << ")");
      continue;
    }
 
    ATH_MSG_VERBOSE("Including FEA in hash CLID: " << fea.getCLID() << " te Id: " << te_ptr->getId());
    boost::hash_combine(hash, fea.getCLID());
    boost::hash_combine(hash, fea.getIndex().subTypeIndex());
    boost::hash_combine(hash, fea.getIndex().objectsBegin());
    boost::hash_combine(hash, fea.getIndex().objectsEnd());
  }
  // Include the originating TE identifier and pointer to ensure that
  // navigation elements stemming from different Trigger Elements do not
  // collapse into a single proxy even if their features are otherwise
  // identical. The TE ID alone is not sufficient, as multiple clones of the
  // same TE share the ID, so we also add the pointer value to the hash.
  boost::hash_combine(hash, te_ptr->getId());
  boost::hash_combine(hash, reinterpret_cast<std::uintptr_t>(te_ptr));
  ATH_MSG_VERBOSE("Obtained FEA hash " << hash);
  return hash;
}

feaToSave()

bool Run2ToRun3TrigNavConverterV2::feaToSave ( const HLT::TriggerElement::FeatureAccessHelper & fea, const std::string & sgName ) const

private

Definition at line 1644 of file Run2ToRun3TrigNavConverterV2.cxx.

{
  auto iter = m_collectionsToSaveDecoded.find(fea.getCLID());
  if (iter != m_collectionsToSaveDecoded.end())
  {
    if ( iter->second.empty() )
      return true; // feature accepted for saving
    ATH_MSG_DEBUG("fea to save CLID: " << fea.getCLID() << ", sgName: " << sgName << " " <<iter->second.size() << " " << iter->second.empty() );
    return iter->second.contains(sgName);
  }
 
  return false;
}

fillRelevantFeatures()

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

private

Definition at line 1104 of file Run2ToRun3TrigNavConverterV2.cxx.

{
  // from all FEAs of the associated TE pick those objects that are to be linked
  for (auto &proxy : convProxies)
  {
    if (proxy->te != nullptr)
    {
      // Determine which particle type is expected based on TE name
      // This ensures Run3 retrieves the same object types as Run2
      std::string teName = TrigConf::HLTUtils::hash2string(proxy->te->getId());
      CLID expectedCLID = getExpectedParticleCLID(teName);
 
      ATH_MSG_VERBOSE("TE " << teName << " expects CLID " << expectedCLID);
 
      for (const HLT::TriggerElement::FeatureAccessHelper& helper : proxy->te->getFeatureAccessHelpers())
      {
        auto [sgKey, sgCLID, sgName] = getSgKey(run2Nav, helper);
        if (sgKey != 0)
        {
          if (feaToSave(helper, sgName))
          {
            // If we have a specific expected CLID, only save features matching that type
            if (expectedCLID != 0 && sgCLID != expectedCLID)
            {
              ATH_MSG_VERBOSE("Skipping feature with CLID " << sgCLID << " (name: " << sgName
                              << ") for TE " << teName << " because expected CLID is " << expectedCLID);
              continue;
            }
            proxy->features.push_back(helper);
            ATH_MSG_VERBOSE("Added feature with CLID " << sgCLID << " (name: " << sgName << ") for TE " << teName);
          }
        }
      }
    }
  }
 
  return StatusCode::SUCCESS;
}

fillRelevantRois()

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

private

Definition at line 1143 of file Run2ToRun3TrigNavConverterV2.cxx.

{
 
  // ordered_sorter
  auto ordered_sorter = [&setRoiName = std::as_const(m_setRoiName)](const std::string &left, const std::string &right) -> bool
  {
    return std::find(cbegin(setRoiName), cend(setRoiName), left) < std::find(cbegin(setRoiName), cend(setRoiName), right);
  };
 
  std::map<std::string, HLT::TriggerElement::FeatureAccessHelper, decltype(ordered_sorter)> mp(ordered_sorter);
 
  for (auto &proxy : convProxies)
  {
    // TODO need check & handling of case when there is more RoIs, now overwriting
    if (HLT::TrigNavStructure::getRoINodes(proxy->te).size() > 1)
      ATH_MSG_DEBUG("Several RoIs pointing to a proxy, taking latest one for now");
 
    mp.clear();
 
    for (const HLT::TriggerElement::FeatureAccessHelper& helper : proxy->te->getFeatureAccessHelpers())
    {
      auto [sgKey, sgCLID, sgName] = getSgKey(run2Nav, helper);
      if (std::find(m_setRoiName.begin(), m_setRoiName.end(), sgName) == m_setRoiName.end())
      {
        // do not filter continue;
        continue;
      }
      mp[sgName] = helper;
    }
 
    std::transform(cbegin(mp), cend(mp), back_inserter(proxy->rois),
                   [](const std::map<std::string, HLT::TriggerElement::FeatureAccessHelper>::value_type &p)
                   { return p.second; });
  }
 
  // roiPropagator
  std::set<const ConvProxy*>  visited;
  std::function<void(std::set<ConvProxy *> &, const std::vector<HLT::TriggerElement::FeatureAccessHelper> &)>
   roiPropagator = [&](std::set<ConvProxy *> &convProxyChildren, const std::vector<HLT::TriggerElement::FeatureAccessHelper> &roiParent)
  {
    for (auto &proxyChild : convProxyChildren)
    {
      if ( visited.count(proxyChild) == 1 ) {
        continue;
      }
      visited.insert(proxyChild);
      if (proxyChild->rois.empty())
      { // no roi update, copy from parent
        proxyChild->rois = roiParent;
        if (proxyChild->children.empty() == false)
        {
          roiPropagator(proxyChild->children, roiParent);
        }
      }
    }
  };
 
  for (auto &proxy : convProxies)
  {
    roiPropagator(proxy->children, proxy->rois);
  }
 
  return StatusCode::SUCCESS;
}

fillRelevantTracks()

StatusCode Run2ToRun3TrigNavConverterV2::fillRelevantTracks ( ConvProxySet_t & convProxies ) const

private

Definition at line 1208 of file Run2ToRun3TrigNavConverterV2.cxx.

{
  for (auto &proxy : convProxies)
  {
    for (const HLT::TriggerElement::FeatureAccessHelper& helper : proxy->te->getFeatureAccessHelpers())
    {
      if (helper.getCLID() == m_TrackParticleContainerCLID || helper.getCLID() == m_TauTrackContainerCLID)
      {
        proxy->tracks.push_back(helper);
      }
    }
  }
 
  return StatusCode::SUCCESS;
}

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 1584 of file Run2ToRun3TrigNavConverterV2.cxx.

                                                                                                                                                                                                             {
  std::vector<HLT::TriggerElement::FeatureAccessHelper> out;
  for (auto fea : feaVector)
  {
    if (feaToSkip(fea))
    {
      ATH_MSG_VERBOSE("Skipping in FEA hash calculation");
      continue;
    }
 
    auto [sgKey, sgCLID, sgName] = getSgKey(navigationDecoder, fea);
 
    if (sgKey == 0)
    {
      ATH_MSG_VERBOSE("Skipping unrecorded (missing in SG) FEA hash calculation - name in SG: " << sgName << " FEA " << fea);
      continue;
    }
    out.push_back(fea);
  }
  return out;
}

filterPassed()

virtual bool AthCommonAlgorithm< Gaudi::Algorithm >::filterPassed ( const EventContext & ctx ) const

inlinevirtualinherited

Get filter decision:

Definition at line 93 of file AthCommonAlgorithm.h.

                                                           {
    return execState( ctx ).filterPassed();
  }

finalize()

StatusCode Run2ToRun3TrigNavConverterV2::finalize ( )

overridevirtual

Definition at line 248 of file Run2ToRun3TrigNavConverterV2.cxx.

{
  return StatusCode::SUCCESS;
}

getExpectedParticleCLID()

CLID Run2ToRun3TrigNavConverterV2::getExpectedParticleCLID ( const std::string & teName ) const

private

Helper function to determine expected particle CLID based on TE name Returns 0 if no specific type is expected (e.g., for non-physics TEs).

Definition at line 1808 of file Run2ToRun3TrigNavConverterV2.cxx.

{
  // Determine which particle type is expected based on TE name
  // This mimics the logic from IParticleRetrievalTool::getEGammaTEType()
  // to ensure Run3 retrieves the same object types as Run2
 
  // For egamma TEs, check for specific patterns
  if (teName.find("etcut") != std::string::npos &&
      teName.find("trkcut") == std::string::npos) {
    // etcut chains (without trkcut) use CaloCluster
    return m_CaloClusterContainerCLID;
  }
  else if (teName.rfind("EF_e", 0) == 0) {
    // TE name starts with "EF_e" -> Electron
    return m_ElectronContainerCLID;
  }
  else if (teName.rfind("EF_g", 0) == 0) {
    // TE name starts with "EF_g" -> Photon
    return m_PhotonContainerCLID;
  }
  else if (teName.rfind("EF_mu", 0) == 0 || teName.find("_mu") != std::string::npos) {
    // Muon TEs
    return m_MuonContainerCLID;
  }
  else if (teName.rfind("EF_tau", 0) == 0 || teName.find("_tau") != std::string::npos) {
    // Tau TEs
    return m_TauJetContainerCLID;
  }
 
  // For non-physics TEs or TEs where we don't have a specific expectation,
  // return 0 to indicate all features should be saved
  return 0;
}

getFeaSize()

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

private

Definition at line 1416 of file Run2ToRun3TrigNavConverterV2.cxx.

{
  size_t feaCount{0};
  if (proxy.features.empty())
  { // no features
    ++feaCount;
  }
  for (const auto &fea : proxy.features)
  {
    if (fea.getIndex().objectsBegin() == fea.getIndex().objectsEnd())
    {
      ++feaCount;
    }
    for (auto n = fea.getIndex().objectsBegin(); n < fea.getIndex().objectsEnd(); ++n)
    {
      ++feaCount;
    }
  }
  // 1 means a deafult H node created is enough, no need to expand H nodes
  return feaCount;
}

getHighestPtObject()

std::pair< std::size_t, std::size_t > Run2ToRun3TrigNavConverterV2::getHighestPtObject ( const ConvProxy & proxy, const HLT::TrigNavStructure & run2Nav ) const

private

Return pair of indices (feature index in proxy->features vector, object index) identifying the highest pT object attached to the proxy.

If retrieval fails returns {std::numeric_limits<size_t>::max(), 0}.

Definition at line 1767 of file Run2ToRun3TrigNavConverterV2.cxx.

{
  std::size_t bestFea = std::numeric_limits<std::size_t>::max();
  std::size_t bestObj = 0;
  float bestPt = -1.0;
 
  for (std::size_t i = 0; i < proxy.features.size(); ++i) {
    const auto& fea = proxy.features[i];
    auto [sgKey, sgCLID, sgName] = getSgKey(run2Nav, fea);
    if (!feaToSave(fea, sgName)) {
      continue;
    }
    if (sgKey == 0) continue;
    const std::string* keyStr = evtStore()->keyToString(sgKey, sgCLID);
    if (!keyStr) continue;
    const xAOD::IParticleContainer* cont = nullptr;
    if (evtStore()->retrieve(cont, *keyStr).isFailure()) continue;
    for (auto n = fea.getIndex().objectsBegin(); n < fea.getIndex().objectsEnd(); ++n) {
      if (n >= cont->size()) continue;
      const xAOD::IParticle* p = (*cont)[n];
      if (!p) continue;
      if (p->pt() > bestPt) {
        bestPt = p->pt();
        bestFea = i;
        bestObj = n;
      }
    }
  }
  if (bestFea == std::numeric_limits<std::size_t>::max()) {
    for (std::size_t i = 0; i < proxy.features.size(); ++i) {
      auto [sgKey, sgCLID, sgName] = getSgKey(run2Nav, proxy.features[i]);
      if (!feaToSave(proxy.features[i], sgName)) continue;
      bestFea = i;
      bestObj = proxy.features[i].getIndex().objectsBegin();
      break;
    }
  }
  return {bestFea, bestObj};
}

getSgKey()

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

private

Definition at line 1735 of file Run2ToRun3TrigNavConverterV2.cxx.

{
  const std::string hltLabel = navigationDecoder.label(helper.getCLID(), helper.getIndex().subTypeIndex());
 
  const CLID saveCLID = [&](const CLID &clid)
  {
    if (clid == m_roIDescriptorCLID)
      return m_roIDescriptorCollectionCLID;
    if (clid == m_TrigEMClusterCLID)
      return m_TrigEMClusterContainerCLID;
    if (clid == m_TrigRingerRingsCLID)
      return m_TrigRingerRingsContainerCLID;
    return clid;
  }(helper.getCLID());
 
  std::string type_name;
  if (m_clidSvc->getTypeNameOfID(saveCLID, type_name).isFailure())
  {
    return {0, 0, ""};
  }
 
  const auto sgStringKey = HLTNavDetails::formatSGkey("HLT", type_name, hltLabel);
  const bool isAvailable = evtStore()->contains(saveCLID, sgStringKey);
  ATH_MSG_DEBUG(" Objects presence " << helper << " " << sgStringKey << (isAvailable ? " present" : " absent"));
  if (!isAvailable)
  {
    return {0, saveCLID, ""};
  }
 
  return {evtStore()->stringToKey(sgStringKey, saveCLID), saveCLID, hltLabel}; // sgKey, sgCLID, sgName
}

initialize()

StatusCode Run2ToRun3TrigNavConverterV2::initialize ( )

overridevirtual

Definition at line 154 of file Run2ToRun3TrigNavConverterV2.cxx.

{
  ATH_CHECK(m_trigOutputNavKey.initialize());
  ATH_CHECK(m_tdt.empty() != m_trigNavKey.key().empty()); // either of the two has to be enabled but not both
  if (!m_tdt.empty())
  {
    ATH_CHECK(m_tdt.retrieve());
    ATH_MSG_INFO("Will use Trigger Navigation from TrigDecisionTool");
  }
  else
  {
    ATH_CHECK(m_trigNavKey.initialize(SG::AllowEmpty));
    ATH_MSG_INFO("Will use Trigger Navigation decoded from TrigNavigation object");
  }
 
  if (!m_chainsToSave.empty()) {
    ATH_MSG_DEBUG("Will only save features for these chains " << m_chainsToSave);
  }
 
  ATH_CHECK(m_configSvc.retrieve());
  ATH_CHECK(m_clidSvc.retrieve());
 
  // configured collections can be either just type name, or type#key
  // decoding takes this into account, if only the type is configured then empty string is places in the decoded lookup map
  // else CLID + a name is placed
 
  for (const auto &name : m_collectionsToSave)
  {
    std::string typeName = name;
    std::string collName;
    size_t delimeterIndex = name.find('#');
    if (delimeterIndex != std::string::npos)
    {
      typeName = name.substr(0, delimeterIndex);
      collName = name.substr(delimeterIndex + 1);
    }
    CLID id{0};
    ATH_CHECK(m_clidSvc->getIDOfTypeName(typeName, id));
    ATH_MSG_DEBUG("Will be linking collection type " << typeName << " name (empty==all) " << collName);
    if ( collName.empty() )
      m_collectionsToSaveDecoded[id]; // creates empty set
    else
      m_collectionsToSaveDecoded[id].insert(std::move(collName));
  }
 
  for (const auto &name : m_roisToSave)
  {
    m_setRoiName.push_back(name);
  }
 
  // 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
  for (const auto & [clid, keysSet] : m_collectionsToSaveDecoded)
  {
    if (!keysSet.empty() and keysSet.contains(""))
    {
      ATH_MSG_ERROR("Bad configuration for CLID " << clid << " requested saving of all (empty coll name configures) collections, yet there are also specific keys");
      return StatusCode::FAILURE;
    }
 
  }
 
  bool anyChainBad=false;
  for ( const auto & chain: m_chainsToSave ) {
    if ( chain.contains('*') or chain.contains('|')) {
      ATH_MSG_ERROR("Supplied chain name: " << chain << " contains wildcard characters, this is not supported by the conversion tool");
      anyChainBad=true;
    }
  }
  if ( anyChainBad ) {
    ATH_MSG_ERROR("Supplied chain names contain wildcard characters, this is not supported by the conversion tool");
    return StatusCode::FAILURE;
  }
  if ( m_chainsToSave.empty() ) {
    ATH_MSG_INFO("No chains list supplied, the conversion will occur for all chains");
  }
 
  ATH_CHECK(m_clidSvc->getIDOfTypeName("TrigRoiDescriptor", m_roIDescriptorCLID));
  ATH_CHECK(m_clidSvc->getIDOfTypeName("TrigRoiDescriptorCollection", m_roIDescriptorCollectionCLID));
  ATH_CHECK(m_clidSvc->getIDOfTypeName("xAOD::TrigRingerRings", m_TrigRingerRingsCLID));
  ATH_CHECK(m_clidSvc->getIDOfTypeName("xAOD::TrigRingerRingsContainer", m_TrigRingerRingsContainerCLID));
  ATH_CHECK(m_clidSvc->getIDOfTypeName("xAOD::TrigEMCluster", m_TrigEMClusterCLID));
  ATH_CHECK(m_clidSvc->getIDOfTypeName("xAOD::TrigEMClusterContainer", m_TrigEMClusterContainerCLID));
  ATH_CHECK(m_clidSvc->getIDOfTypeName("xAOD::CaloCluster", m_CaloClusterCLID));
  ATH_CHECK(m_clidSvc->getIDOfTypeName("xAOD::CaloClusterContainer", m_CaloClusterContainerCLID));
  ATH_CHECK(m_clidSvc->getIDOfTypeName("xAOD::TrackParticleContainer", m_TrackParticleContainerCLID));
  ATH_CHECK(m_clidSvc->getIDOfTypeName("xAOD::TauTrackContainer", m_TauTrackContainerCLID));
  ATH_CHECK(m_clidSvc->getIDOfTypeName("xAOD::ElectronContainer", m_ElectronContainerCLID));
  ATH_CHECK(m_clidSvc->getIDOfTypeName("xAOD::PhotonContainer", m_PhotonContainerCLID));
  ATH_CHECK(m_clidSvc->getIDOfTypeName("xAOD::MuonContainer", m_MuonContainerCLID));
  ATH_CHECK(m_clidSvc->getIDOfTypeName("xAOD::TauJetContainer", m_TauJetContainerCLID));
 
  return StatusCode::SUCCESS;
}

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 361 of file Run2ToRun3TrigNavConverterV2.cxx.

                                                                                           {
  // chains of configs structure
  // A  B
  //  \/
  //  C
  // where C is the output TE of sequence consuming A & B
  // sometimes there are an additional leafs
  //  C
  //  |
  //  D
  if ( not std::regex_match(ptrChain->name(), SpecialCases::isTopo) ) return 0;
  size_t stepToConsider = 0;
  const size_t sigsSize = ptrChain->signatures().size();
  if ( sigsSize < 2 ) return 0;
  for ( size_t step = sigsSize-1; step > 1; step --) {
    if ( (ptrChain->signatures()[step-1])->outputTEs().size() == 2 and (ptrChain->signatures()[step])->outputTEs().size() == 1 )  {
      stepToConsider = step;
      break;
    }
  }
  if ( stepToConsider == 0 ) return 0; // not a topo
 
  //counting is right, need to see now if TEs are connected
  auto finalTE = (ptrChain->signatures()[stepToConsider])->outputTEs()[0];
  auto preFinalTEs = (ptrChain->signatures()[stepToConsider-1])->outputTEs();
 
  auto finalSeq =  m_configSvc->sequences().getSequence(finalTE->id());
  std::set<HLT::te_id_type> tesInSeq;
  std::set<HLT::te_id_type> tesInChain;
 
  for ( auto te: finalSeq->inputTEs()) {
     tesInSeq.insert(te->id());
  }
 
  for ( auto te: preFinalTEs) {
     tesInChain.insert(te->id());
  }
 
  if (tesInSeq == tesInChain)  {
    return stepToConsider;
  }
  return 0;
}

isClonable()

virtual bool AthCommonAlgorithm< Gaudi::Algorithm >::isClonable ( ) const

inlineoverridevirtualinherited

Specify if the algorithm is clonable.

Only relevant for non-reentrant algorithms. Actual number of clones needs to be set via the "Cardinality" property.

Reimplemented in AFP_DigiTop, AlgB, AlgT, BCM_Digitization, CscDigitBuilder, CscDigitToCscRDO, G4AtlasAlg, G4RunAlg, HGTD_Digitization, HiveAlgBase, InDet::GNNSeedingTrackMaker, InDet::SCT_Clusterization, InDet::SiSPGNNTrackMaker, InDet::SiSPSeededTrackFinder, InDet::SiTrackerSpacePointFinder, ISF::SimKernelMT, ITk::StripDigitization, ITkPixelCablingAlg, ITkStripCablingAlg, LArHitEMapMaker, LArTTL1Maker, LUCID_DigiTop, LVL1::L1TopoSimulation, MergeCalibHits, MergeGenericMuonSimHitColl, MergeHijingPars, MergeMcEventCollection, MergeTrackRecordCollection, MergeTruthJets, MergeTruthParticles, MuonDigitizer, PileUpMTAlg, PixelDigitization, RoIBResultToxAOD, SCT_ByteStreamErrorsTestAlg, SCT_CablingCondAlgFromCoraCool, SCT_CablingCondAlgFromText, SCT_ConditionsParameterTestAlg, SCT_ConditionsSummaryTestAlg, SCT_ConfigurationConditionsTestAlg, SCT_Digitization, SCT_FlaggedConditionTestAlg, SCT_LinkMaskingTestAlg, SCT_MajorityConditionsTestAlg, SCT_ModuleVetoTestAlg, SCT_MonitorConditionsTestAlg, SCT_PrepDataToxAOD, SCT_RawDataToxAOD, SCT_ReadCalibChipDataTestAlg, SCT_ReadCalibDataTestAlg, SCT_RODVetoTestAlg, SCT_SensorsTestAlg, SCT_SiliconConditionsTestAlg, SCT_StripVetoTestAlg, SCT_TdaqEnabledTestAlg, SCT_TestCablingAlg, SCTEventFlagWriter, SCTRawDataProvider, SCTSiLorentzAngleTestAlg, SCTSiPropertiesTestAlg, SGInputLoader, Simulation::BeamEffectsAlg, TileHitVecToCnt, TileMuonFitter, TilePulseForTileMuonReceiver, TileRawChannelMaker, TRTDigitization, and ZDC_DigiTop.

Definition at line 68 of file AthCommonAlgorithm.h.

                                           {
    return true;
  }

linkFeaNode()

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

private

Definition at line 1438 of file Run2ToRun3TrigNavConverterV2.cxx.

{
  // from all FEAs of the associated TE pick those objects that are to be linked
  for (const auto &proxy : convProxies)
  {
    auto [bestFeaIdx, bestObjIdx] = getHighestPtObject(*proxy, run2Nav);
 
    auto feaN = getFeaSize(*proxy);
    if (feaN > 1)
    { // expand for more H nodes and connect them
      while (--feaN)
      {
        proxy->hNode.push_back(TrigCompositeUtils::newDecisionIn(&decisions, TrigCompositeUtils::hypoAlgNodeName())); // H
        for (auto chainId : proxy->passChains) // adding hash values of active chains to expanded H nodes
         {
            TrigCompositeUtils::addDecisionID(chainId, proxy->hNode.back());
         }
        // connecting to upeer IM node
        TrigCompositeUtils::linkToPrevious(proxy->hNode.back(), proxy->imNode, context); // H low IM up
        // connecting created H to IM in children proxies
        for (auto &childProxy : proxy->children)
        {
          TrigCompositeUtils::linkToPrevious(childProxy->imNode, proxy->hNode.back(), context); // IM child H up (just created))
        }
      }
    }
 
    if (proxy->features.empty())
    { // no features attached, self link
      ElementLink<xAOD::TrigCompositeContainer> linkToSelf = TrigCompositeUtils::decisionToElementLink(proxy->hNode.front(), context);
      proxy->hNode.front()->setObjectLink<xAOD::TrigCompositeContainer>(TrigCompositeUtils::featureString(), linkToSelf);
    }
 
    auto hNodeIter = proxy->hNode.begin();
    for (std::size_t feaIdx = 0; feaIdx < proxy->features.size(); ++feaIdx)
    {
      auto &fea = proxy->features[feaIdx];
      auto [sgKey, sgCLID, sgName] = getSgKey(run2Nav, fea);
      // link to itself when lined collection has size 0
      if (fea.getIndex().objectsBegin() == fea.getIndex().objectsEnd())
      {
        ElementLink<xAOD::TrigCompositeContainer> linkToSelf = TrigCompositeUtils::decisionToElementLink(*hNodeIter, context);
        (*hNodeIter)->setObjectLink<xAOD::TrigCompositeContainer>(TrigCompositeUtils::featureString(), linkToSelf);
        ++hNodeIter;
      }
      for (auto n = fea.getIndex().objectsBegin(); n < fea.getIndex().objectsEnd(); ++n)
      {
        // connecting feature or subfeature
        const std::string& linkName = (feaIdx == bestFeaIdx && n == bestObjIdx) ?
                                       TrigCompositeUtils::featureString() : "subfeature";
        (*hNodeIter)->typelessSetObjectLink(linkName, sgKey, sgCLID, n, n + 1);
        ++hNodeIter;
      }
    }
  }
 
  return StatusCode::SUCCESS;
}

linkRoiNode()

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

private

Definition at line 1497 of file Run2ToRun3TrigNavConverterV2.cxx.

{
  // from all Rois of the associated TE pick those objects that are to be linked
  for (auto &proxy : convProxies)
  {
    for (auto &roi : proxy->rois)
    {
      auto [sgKey, sgCLID, sgName] = getSgKey(run2Nav, roi);
      if (proxy->l1Node)
      {
        proxy->l1Node->typelessSetObjectLink(TrigCompositeUtils::initialRoIString(), sgKey, sgCLID, roi.getIndex().objectsBegin());
      }
      if (proxy->rois.empty() == false)
      {
        proxy->imNode->typelessSetObjectLink(TrigCompositeUtils::roiString(), sgKey, sgCLID, roi.getIndex().objectsBegin());
      }
    }
  }
 
  return StatusCode::SUCCESS;
}

linkTrkNode()

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

private

Definition at line 1519 of file Run2ToRun3TrigNavConverterV2.cxx.

{
  for (auto &proxy : convProxies)
  {
    for (auto &trk : proxy->tracks)
    {
      if (proxy->imNode->hasObjectLink(TrigCompositeUtils::roiString()))
      {
        try
        {
          ElementLink<TrigRoiDescriptorCollection> ROIElementLink = proxy->imNode->objectLink<TrigRoiDescriptorCollection>(TrigCompositeUtils::roiString());
          if (ROIElementLink.isValid())
          {
            static const SG::Decorator<ElementLink<TrigRoiDescriptorCollection>> viewBookkeeper("viewIndex");
            const auto & [sgKey, sgCLID, sgName] = getSgKey(run2Nav, trk);
            if (sgCLID == m_TrackParticleContainerCLID || sgCLID == m_TauTrackContainerCLID)
            {
              const char *tName = (sgCLID == m_TrackParticleContainerCLID) ? "TEMP_TRACKS" : "TEMP_TAU_TRACKS";
              const std::string tNameStr{tName};
              auto d = std::make_unique<TrigCompositeUtils::Decision>();
              d->makePrivateStore();
              d->typelessSetObjectLink(tName, sgKey, sgCLID, trk.getIndex().objectsBegin());
              if (sgCLID == m_TrackParticleContainerCLID)
              {
                for (const ElementLink<xAOD::TrackParticleContainer> &track : d->objectCollectionLinks<xAOD::TrackParticleContainer>(tNameStr))
                {
                  if (track.isValid())
                  {
                    const xAOD::TrackParticle *t = *track;
                    viewBookkeeper(*t) = ROIElementLink;
                  }
                }
              }
              if (m_includeTauTrackFeatures == false && sgCLID == m_TauTrackContainerCLID)
              {
                for (const ElementLink<xAOD::TauTrackContainer> &track : d->objectCollectionLinks<xAOD::TauTrackContainer>(tNameStr))
                {
                  if (track.isValid())
                  {
                    const xAOD::TauTrack_v1 *t = *track;
                    viewBookkeeper(*t) = ROIElementLink;
                  }
                }
              }
            }
          }
        } catch (SG::ExcBadForwardLink&) {
          ATH_MSG_WARNING("Unable to create an ElementLink into a container with no entries");
        }
      }
    }
  }
 
  return StatusCode::SUCCESS;
}

mirrorTEsStructure()

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

private

Definition at line 725 of file Run2ToRun3TrigNavConverterV2.cxx.

{
 
  // iterate over the TEs, for each make the ConvProxy and build connections
  std::map<const HLT::TriggerElement *, ConvProxy *> teToProxy;
  ATH_MSG_DEBUG("TrigNavStructure with " << run2Nav.getAllTEs().size() << " TEs acquired");
  for (auto te : run2Nav.getAllTEs())
  {
    // skip event seed node
    if (HLT::TrigNavStructure::isInitialNode(te))
      continue;
    auto proxy = new ConvProxy(te);
    convProxies.insert(proxy);
    teToProxy[te] = proxy;
    // add linking
    for (auto predecessor : HLT::TrigNavStructure::getDirectPredecessors(te))
    {
      ConvProxy *predecessorProxy = teToProxy[predecessor];
      if (predecessorProxy != nullptr)
      { // because we skip some
        proxy->parents.insert(predecessorProxy);
        predecessorProxy->children.insert(proxy);
      }
    }
  }
 
  if (m_doSelfValidation)
  {
    int counter = -1;
    for (auto proxy : convProxies)
    {
      counter++;
      ATH_MSG_DEBUG("Proxy " << counter << " " << proxy->description() << "ptr " << proxy);
      for (auto p : proxy->children)
        ATH_MSG_DEBUG("Child ptr " << p);
      for (auto p : proxy->parents)
        ATH_MSG_DEBUG("Parent ptr " << p);
 
      for (auto p : proxy->parents)
      {
        for (auto pp : p->parents)
        {
          if (pp == proxy)
          {
            ATH_MSG_WARNING("Weird, proxy is in parents list of parents");
          }
        }
      }
      for (auto c : proxy->children)
      {
        for (auto cc : c->children)
        {
          if (cc == proxy)
          {
            ATH_MSG_WARNING("Weird, proxy is in children list of children");
          }
        }
      }
    }
  }
 
  ATH_MSG_DEBUG("Created " << convProxies.size() << " proxy objects");
  return StatusCode::SUCCESS;
}

msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

noUnconnectedHNodes()

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

private

Definition at line 1705 of file Run2ToRun3TrigNavConverterV2.cxx.

{
  // build map of all links to H nodes from IMs and FS
  std::set<const TrigCompositeUtils::Decision *> linkedHNodes;
  for (auto d : decisions)
  {
    if (d->name() == "IM" or d->name() == "FS")
    {
      for (auto el : TCU::getLinkToPrevious(d))
      {
        linkedHNodes.insert(*el); // dereferences to bare pointer
      }
    }
  }
  for (auto d : decisions)
  {
    if (d->name() == "H")
    {
      if (linkedHNodes.count(d) == 0)
      {
        ATH_MSG_ERROR("Orphaned H node");
        return StatusCode::FAILURE;
      }
    }
  }
  ATH_MSG_DEBUG("CHECK OK, all H modes are connected");
 
  return StatusCode::SUCCESS;
}

numberOfHNodesPerProxyNotExcessive()

StatusCode Run2ToRun3TrigNavConverterV2::numberOfHNodesPerProxyNotExcessive ( const ConvProxySet_t & ) const

private

Definition at line 1699 of file Run2ToRun3TrigNavConverterV2.cxx.

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

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 791 of file Run2ToRun3TrigNavConverterV2.cxx.

                                                                                                                      {
  ATH_MSG_DEBUG("Printing proxies");
  ATH_MSG_DEBUG("" );
  for ( auto p: proxies) {
    if ( selector(p) ){
      ATH_MSG_DEBUG("Proxy " << p->description() );
      for (auto& printer: printers) {
        printer(p);
      }
      ATH_MSG_DEBUG("" );
    }
  }
}

removeTopologicalProxies()

StatusCode Run2ToRun3TrigNavConverterV2::removeTopologicalProxies ( ConvProxySet_t & convProxies ) const

private

Definition at line 1077 of file Run2ToRun3TrigNavConverterV2.cxx.

{
 for (auto i = std::begin(convProxies); i != std::end(convProxies);)
  {
    if ((*i)->parents.size() > 1)
    {
      ConvProxy *toDel = *i;
      // remove it from parents/children
      for (auto parent : toDel->parents)
      {
          parent->children.erase(toDel);
      }
      for (auto child : toDel->children)
      {
        child->parents.erase(toDel);
      }
      delete toDel;
      i = convProxies.erase(i);
    }
    else
    {
      ++i;
    }
  }
  return StatusCode::SUCCESS;
}

removeUnassociatedProxies()

StatusCode Run2ToRun3TrigNavConverterV2::removeUnassociatedProxies ( ConvProxySet_t & convProxies ) const

private

Definition at line 891 of file Run2ToRun3TrigNavConverterV2.cxx.

{
  // remove proxies that have no chains
  for (auto i = std::begin(convProxies); i != std::end(convProxies);)
  {
    if ((*i)->runChains.empty())
    {
      ConvProxy *toDel = *i;
      // remove it from parents/children
      for (auto parent : toDel->parents)
      {
          parent->children.erase(toDel);
      }
      for (auto child : toDel->children)
      {
        child->parents.erase(toDel);
      }
      delete toDel;
      i = convProxies.erase(i);
    }
    else
    {
      ++i;
    }
  }
  ATH_MSG_DEBUG("After eliminating proxies not associated to chainsof intereset left with " << convProxies.size());
  return StatusCode::SUCCESS;
}

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.

  {
    h.renounce();
    PBASE::renounce (h);
  }

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.

                                                          {
    handlesArray.renounce();
  }

roiToSave()

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

private

Definition at line 1660 of file Run2ToRun3TrigNavConverterV2.cxx.

{
  auto [sgKey, sgCLID, sgName] = getSgKey(run2Nav, roi);
  if (std::find(m_setRoiName.begin(), m_setRoiName.end(), sgName) != m_setRoiName.end())
  {
    return true;
  }
 
  return false;
}

setFilterPassed()

virtual void AthCommonAlgorithm< Gaudi::Algorithm >::setFilterPassed ( bool state, const EventContext & ctx ) const

inlinevirtualinherited

Set filter decision:

Reimplemented in AthFilterAlgorithm.

Definition at line 99 of file AthCommonAlgorithm.h.

                                                                            {
    execState( ctx ).setFilterPassed( state );
  }

sysExecute()

StatusCode AthCommonAlgorithm< Gaudi::Algorithm >::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.

Reimplemented in AthAnalysisAlgorithm.

Definition at line 80 of file AthCommonAlgorithm.cxx.

{
  return BaseAlg::sysExecute (ctx);
}

sysInitialize()

StatusCode AthCommonAlgorithm< Gaudi::Algorithm >::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 AthAnalysisAlgorithm, AthFilterAlgorithm, AthHistogramAlgorithm, HypoBase, InputMakerBase, and PyAthena::Alg.

Definition at line 60 of file AthCommonAlgorithm.cxx.

                                                      {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<BaseAlg>>::sysInitialize();
 
  if (sc.isFailure()) {
    return sc;
  }
  
  ServiceHandle<ICondSvc> cs("CondSvc",name());
  for (auto h : outputHandles()) {
    if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
      // do this inside the loop so we don't create the CondSvc until needed
      if ( cs.retrieve().isFailure() ) {
        ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
        return StatusCode::SUCCESS;
      }      
      if (cs->regHandle(this,*h).isFailure()) {
        sc = StatusCode::FAILURE;
        ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
                      << " with CondSvc");
      }
    }
  }
  return sc;  
}

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 1344 of file Run2ToRun3TrigNavConverterV2.cxx.

{
  // Check that only ChainIDs (not LegIDs) are present in the terminus "HLTPassRaw" node.
  // Check that only chains which pass the event are included.
  TCU::Decision* terminus = decisions.at(0);
  ATH_CHECK( terminus->name() == TCU::summaryPassNodeName() );
  TCU::DecisionIDContainer currentIDs;
  TCU::DecisionIDContainer filteredIDs;
  TCU::decisionIDs(terminus, currentIDs); // Extract, std::vector -> std::set
  for (const TCU::DecisionID id : currentIDs)
  {
    const TCU::DecisionID idToCheck = ( TCU::isLegId(id) ? TCU::getIDFromLeg( HLT::Identifier(id) ).numeric() : id );
    const std::string chainName = HLT::Identifier(idToCheck).name();
    // Sanity check
    if (!m_chainsToSave.empty())
    {
      if (std::find(m_chainsToSave.begin(), m_chainsToSave.end(), chainName) == m_chainsToSave.end())
      {
        ATH_MSG_ERROR("Navigation information for chain " << chainName << " in "
          << TCU::summaryPassNodeName() << " but this chain wasn't on the list of chains to save");
        return StatusCode::FAILURE;
      }
    }
    if (m_tdt->isPassed(chainName, TrigDefs::Physics | TrigDefs::allowResurrectedDecision))
    {
      filteredIDs.insert(idToCheck);
    }
  }
  terminus->setDecisions( std::vector<TCU::DecisionID>() ); // decisions.clear(), but via the xAOD setter function
  TCU::insertDecisionIDs(filteredIDs, terminus); // Insert, std::set -> std::vector
  ATH_MSG_VERBOSE("After filtering out leg IDs and checking isPassed, "
    "the terminus node goes from " << currentIDs.size() << " to " << filteredIDs.size() << " chain IDs.");
  if (msgLvl(MSG::VERBOSE))
  {
    for (const TCU::DecisionID id : filteredIDs)
    {
      ATH_MSG_VERBOSE(" -- Retained passing ID: " << HLT::Identifier(id));
    }
  }
  return StatusCode::SUCCESS;
}

updateVHKA()

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

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_allTEIdsToChains

TEIdToChainsMap_t Run2ToRun3TrigNavConverterV2::m_allTEIdsToChains

private

Definition at line 98 of file Run2ToRun3TrigNavConverterV2.h.

m_CaloClusterCLID

CLID Run2ToRun3TrigNavConverterV2::m_CaloClusterCLID {0}

private

Definition at line 187 of file Run2ToRun3TrigNavConverterV2.h.

{0};

m_CaloClusterContainerCLID

CLID Run2ToRun3TrigNavConverterV2::m_CaloClusterContainerCLID {0}

private

Definition at line 188 of file Run2ToRun3TrigNavConverterV2.h.

{0};

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 150 of file Run2ToRun3TrigNavConverterV2.h.

{ for (auto id: p->passChains ) ATH_MSG_DEBUG("chain id " << id); };

m_chainsToSave

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

private

Definition at line 90 of file Run2ToRun3TrigNavConverterV2.h.

{this, "Chains", {}, "If not specified, all chains are handled"};

m_clidSvc

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

private

Definition at line 83 of file Run2ToRun3TrigNavConverterV2.h.

{this, "ClassIDSvc", "ClassIDSvc", "Service to translate CLID to class name"};

m_collectionsToSave

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

private

Definition at line 91 of file Run2ToRun3TrigNavConverterV2.h.

{this, "Collections", {}};

m_collectionsToSaveDecoded

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

private

Definition at line 177 of file Run2ToRun3TrigNavConverterV2.h.

m_configSvc

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

private

Definition at line 82 of file Run2ToRun3TrigNavConverterV2.h.

{this, "TrigConfigSvc", "TrigConf::xAODConfigSvc/xAODConfigSvc", "Trigger configuration service"};

m_configUpdateMutex

std::mutex Run2ToRun3TrigNavConverterV2::m_configUpdateMutex

mutableprivate

Definition at line 97 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 86 of file Run2ToRun3TrigNavConverterV2.h.

{this, "doCompression", false, "Collapse navigation elements to save ouput space"};

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 87 of file Run2ToRun3TrigNavConverterV2.h.

{this, "doLinkFeatures", true, "Add links to objects, setting it false makes sense when running tests"};

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 85 of file Run2ToRun3TrigNavConverterV2.h.

{this, "doSelfValidation", false, "Run consistency checks after stages of conversion (slows down the alg)"};

m_ElectronContainerCLID

CLID Run2ToRun3TrigNavConverterV2::m_ElectronContainerCLID {0}

private

Definition at line 191 of file Run2ToRun3TrigNavConverterV2.h.

{0};

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 AthCommonAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects

privateinherited

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

Empty if no symlinks were found.

Definition at line 108 of file AthCommonAlgorithm.h.

m_finalTEIdsToChains

TEIdToChainsMap_t Run2ToRun3TrigNavConverterV2::m_finalTEIdsToChains

private

Definition at line 98 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 89 of file Run2ToRun3TrigNavConverterV2.h.

{this, "hNodesPerProxyThreshhold", 15, "Limit number of H nodes per TE (if exceeded conversion results in an error)"};

m_includeTauTrackFeatures

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

private

Definition at line 88 of file Run2ToRun3TrigNavConverterV2.h.

{this, "addTauTracks", false, "Add Tau Track collection as feature element"};

m_MuonContainerCLID

CLID Run2ToRun3TrigNavConverterV2::m_MuonContainerCLID {0}

private

Definition at line 193 of file Run2ToRun3TrigNavConverterV2.h.

{0};

m_PhotonContainerCLID

CLID Run2ToRun3TrigNavConverterV2::m_PhotonContainerCLID {0}

private

Definition at line 192 of file Run2ToRun3TrigNavConverterV2.h.

{0};

m_roIDescriptorCLID

CLID Run2ToRun3TrigNavConverterV2::m_roIDescriptorCLID {0}

private

Definition at line 181 of file Run2ToRun3TrigNavConverterV2.h.

{0};

m_roIDescriptorCollectionCLID

CLID Run2ToRun3TrigNavConverterV2::m_roIDescriptorCollectionCLID {0}

private

Definition at line 182 of file Run2ToRun3TrigNavConverterV2.h.

{0};

m_roisToSave

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

private

Definition at line 92 of file Run2ToRun3TrigNavConverterV2.h.

{this, "Rois", {}};

m_setRoiName

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

private

Definition at line 179 of file Run2ToRun3TrigNavConverterV2.h.

m_TauJetContainerCLID

CLID Run2ToRun3TrigNavConverterV2::m_TauJetContainerCLID {0}

private

Definition at line 194 of file Run2ToRun3TrigNavConverterV2.h.

{0};

m_TauTrackContainerCLID

CLID Run2ToRun3TrigNavConverterV2::m_TauTrackContainerCLID {0}

private

Definition at line 190 of file Run2ToRun3TrigNavConverterV2.h.

{0};

m_tdt

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

private

Definition at line 81 of file Run2ToRun3TrigNavConverterV2.h.

{this, "TrigDecisionTool", "", "When enabled read navigation from TDT/off by default"};

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 151 of file Run2ToRun3TrigNavConverterV2.h.

{ ATH_MSG_DEBUG("TE id " << TrigConf::HLTUtils::hash2string(p->te->getId())); };

m_TrackParticleContainerCLID

CLID Run2ToRun3TrigNavConverterV2::m_TrackParticleContainerCLID {0}

private

Definition at line 189 of file Run2ToRun3TrigNavConverterV2.h.

{0};

m_TrigEMClusterCLID

CLID Run2ToRun3TrigNavConverterV2::m_TrigEMClusterCLID {0}

private

Definition at line 185 of file Run2ToRun3TrigNavConverterV2.h.

{0};

m_TrigEMClusterContainerCLID

CLID Run2ToRun3TrigNavConverterV2::m_TrigEMClusterContainerCLID {0}

private

Definition at line 186 of file Run2ToRun3TrigNavConverterV2.h.

{0};

m_trigNavKey

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

private

Definition at line 80 of file Run2ToRun3TrigNavConverterV2.h.

{this, "TrigNavReadKey", "TrigNavigation"};

m_trigOutputNavKey

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

private

Definition at line 94 of file Run2ToRun3TrigNavConverterV2.h.

{this, "OutputNavKey", "HLTNav_R2ToR3Summary"};

m_TrigRingerRingsCLID

CLID Run2ToRun3TrigNavConverterV2::m_TrigRingerRingsCLID {0}

private

Definition at line 183 of file Run2ToRun3TrigNavConverterV2.h.

{0};

m_TrigRingerRingsContainerCLID

CLID Run2ToRun3TrigNavConverterV2::m_TrigRingerRingsContainerCLID {0}

private

Definition at line 184 of file Run2ToRun3TrigNavConverterV2.h.

{0};

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.h
• Run2ToRun3TrigNavConverterV2.cxx