TrigCompositeUtils.icc

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
#include "AsgMessaging/MessageCheck.h"
#include <regex>
 
namespace TrigCompositeUtils {
 
  ANA_MSG_HEADER (msgFindLink)
 
  /**
   * @brief Creates and right away records the Container CONT with the key.
   * No Aux store.
   * Returns the WriteHandle. 
   * If possible provide the context that comes via an argument to execute otherwise it will default to looking it up which is slower.
   **/
  template<class CONT>
  SG::WriteHandle<CONT> createAndStoreNoAux( const SG::WriteHandleKey<CONT>& key, const EventContext& ctx ) {
    SG::WriteHandle<CONT> handle( key, ctx );
    auto data = std::make_unique<CONT>() ;
    if (handle.record( std::move( data ) ).isFailure()) {
      throw std::runtime_error( "ERROR in TrigCompositeUtils::createAndStoreNoAux Unable to record " + key.key());
    }
    return handle;
  }
 
  /**
   * @brief Creates and right away records the Container CONT with the key.
   * With Aux store. 
   * Returns the WriteHandle. 
   * If possible provide the context that comes via an argument to execute otherwise it will default to looking it up which is slower.
   **/
  template<class CONT, class AUX>
  SG::WriteHandle<CONT> createAndStoreWithAux( const SG::WriteHandleKey<CONT>& key, const EventContext& ctx ) {
    SG::WriteHandle<CONT> handle( key, ctx );
    auto data = std::make_unique<CONT>() ;
    auto aux = std::make_unique<AUX>() ;
    data->setStore( aux.get() );
    if (handle.record( std::move( data ), std::move( aux )  ).isFailure()) {
      throw std::runtime_error( "ERROR in TrigCompositeUtils::createAndStoreWithAux Unable to record " + key.key());
    }
    return handle;
  }
 
  template<typename T>
  void
  findLinks(const Decision* start, const std::string& linkName, std::vector<LinkInfo<T>>& links, unsigned int behaviour, std::set<const Decision*>* fullyExploredFrom) {
    using namespace msgFindLink;
    std::vector<ElementLink<T>> featureLinks;
    if (start->hasObjectCollectionLinks(linkName, ClassID_traits<T>::ID())) {
      featureLinks = start->objectCollectionLinks<T>(linkName);
    }
    if (start->hasObjectLink(linkName, ClassID_traits<T>::ID())) {
      featureLinks.push_back(start->objectLink<T>(linkName));
    }
    const bool linkFound = (featureLinks.size() > 0);
    const std::vector<DecisionID> &ids = decisionIDs(start);
    for (const ElementLink<T>& featureLink : featureLinks) {
      // Check for duplicates
      bool duplicate = false;
      for (LinkInfo<T> &info : links)
      {
        if (info.link == featureLink) {
          const auto  A = decisionToElementLink(start);
          const auto& B = info.link;
          if (info.source != start 
            && linkName != initialRoIString() // Allow multiple nodes to reference the same initial ROI
            && linkName != roiString()  // Allow multiple nodes to reference the same updated ROI
            && linkName != "l2cbroi"  // Allow multiple nodes to reference the same l2cb ROI (muon specific use case)
            && linkName != viewString()  // Allow multiple nodes to reference the same view instance (i.e. re-use of EventViews)
            && A.dataID().find("_probe") == std::string::npos // Allow re-use if one of the two locations is a tag-and-probe style probe component
            && B.dataID().find("_probe") == std::string::npos
          ) {
            ANA_MSG_WARNING ("Found '" << linkName << "' by multiple paths, but "
              << "the links are coming from different places in the navigation graph. " << std::endl
              << "From A:" << A.dataID() << ":" << A.index() << " Dump:" << std::endl << *start << std::endl
                              << "From B:" << B.dataID() << ":" << B.index() << " Dump:" << std::endl << *(info.source));
          }
          info.decisions.insert(ids.begin(), ids.end());
          duplicate = true;
        }
      }
      if (!duplicate)
        links.emplace_back(start, featureLink);
    }
    // Early exit
    if (linkFound && behaviour == TrigDefs::lastFeatureOfType) {
      return;
    }
    // If not Early Exit, then recurse
    for (const auto& seed : getLinkToPrevious(start)) {
#if TRIGCOMPUTILS_ENABLE_EARLY_EXIT == 1
      if (fullyExploredFrom != nullptr) {
        // We only need to recursivly explore back from each node in the graph once.
        // We can keep a record of nodes which we have already explored, these we can safely skip over.
        if (fullyExploredFrom->count(*seed) == 1) {
          continue;
        }
      }
#endif
      findLinks<T>(*seed, linkName, links, behaviour, fullyExploredFrom);
    }
    // Fully explored this node
    if (fullyExploredFrom != nullptr) {
      fullyExploredFrom->insert(start);
    }
  }
 
  template<typename T>
  std::vector<LinkInfo<T>>
  findLinks(const Decision* start, const std::string& linkName, unsigned int behaviour) {
    std::vector<LinkInfo<T>> links;
    std::set<const Decision*> fullyExploredFrom;
    findLinks(start, linkName, links, behaviour, &fullyExploredFrom);
    return links;
  }
 
  template<typename T>
  LinkInfo<T>
  findLink(const Decision* start, const std::string& linkName, const bool suppressMultipleLinksWarning) {
    using namespace msgFindLink;
    // We use findLink in cases where there is only one link to be found, or if there are multiple then we 
    // only want the most recent.
    // Hence we can supply TrigDefs::lastFeatureOfType.                                                         /--> parent3(link)
    // We can still have more then one link found if there is a branch in the navigation. E.g. start --> parent1 --> parent2(link)
    // If both parent2 and parent3 posessed an admisable ElementLink, then the warning below will trigger, and only one of the
    // links will be returned (whichever of parent2 or parent3 happened to be the first seed of parent1).
    std::vector<LinkInfo<T>> links = findLinks<T>(start, linkName, TrigDefs::lastFeatureOfType);
    if (links.size() > 1 && !suppressMultipleLinksWarning) {
      ANA_MSG_WARNING (links.size() << " links found for " << linkName
                       << " returning the first link, consider using findLinks.");
    }
    if (links.size() > 0) {
      return links.at(0);
    }
    return LinkInfo<T>(); // invalid link
  }
 
 
  template<class CONTAINER>
  void filterLinkVectorByContainerKey(const std::string& containerSGKey, std::vector<ElementLink<CONTAINER>>& vector) {
    if (containerSGKey.empty()) {
      return;
    }
    auto it = std::remove_if(vector.begin(), vector.end(), [&](const ElementLink<CONTAINER>& el) {
    return  !std::regex_match( el.dataID(), std::regex(containerSGKey) );
      });
    // Collection has been re-ordered to put the bad elements at the end
    vector.erase(it, vector.end());
  }
 
 
  template<class CONTAINER>
  const std::vector< LinkInfo<CONTAINER> > recursiveGetFeaturesOfType(
    const NavGraph& navGraph,
    const std::string& containerSGKey,
    const bool lastFeatureOfType,
    const std::string& navElementLinkKey,
    const DecisionIDContainer& chainIDs) {
 
    std::vector< LinkInfo<CONTAINER> > features; // The return vector
    std::set<const NavGraphNode*> fullyExploredFrom; // Lets us navigate more efficiently
 
    // For each starting point through the navigation for a given chain-group
    for (const NavGraphNode* finalNode : navGraph.finalNodes()) {
      recursiveGetFeaturesOfTypeInternal<CONTAINER>(features,
        fullyExploredFrom,
        finalNode,
        containerSGKey,
        lastFeatureOfType,
        navElementLinkKey,
        chainIDs);
    }
 
    return features;
  }
 
 
  template<class CONTAINER>
  void recursiveGetFeaturesOfTypeInternal(
    std::vector< LinkInfo<CONTAINER> >& features, 
    std::set<const NavGraphNode*>& fullyExploredFrom,
    const NavGraphNode* navGraphNode, 
    const std::string& containerSGKey,
    const bool lastFeatureOfType,
    const std::string& navElementLinkKey,
    const DecisionIDContainer& chainIDs) {
 
 
 
    const Decision* decisionObj = navGraphNode->node();
    const Decision* decisionObjChild = (navGraphNode->children().size() == 1 ? navGraphNode->children().at(0)->node() : nullptr);
    const std::vector<DecisionID> &ids = decisionIDs(decisionObj);
    std::vector<ElementLink<CONTAINER>> featureLinks;
 
    // Look up what named links are available in the Decision Object
    std::vector<std::string> availableLinkNames;
    if (navElementLinkKey == "") { 
      const std::vector<std::string> getSingleLinkNames = decisionObj->getObjectNames<CONTAINER>();
      const std::vector<std::string> getCollectionLinkNames = decisionObj->getObjectCollectionNames<CONTAINER>();
      std::copy(getSingleLinkNames.begin(), getSingleLinkNames.end(), std::back_inserter(availableLinkNames));
      std::copy(getCollectionLinkNames.begin(), getCollectionLinkNames.end(), std::back_inserter(availableLinkNames));
    } else { // Just looking for an explicitly named feature
      availableLinkNames.push_back( navElementLinkKey );
    }
 
    // Fetch the named links that we're interested in
    for (const std::string& featureNameToGet : availableLinkNames) {
      // This try block protects against ExcCLIDMismatch throws from
      // features which do not derive from IParticle, when an IParticle interface is requested.
#ifndef XAOD_STANDALONE
      try {
#endif
        // Slices may have added link collections. These links may have been to objects in different containers.
        if (decisionObj->hasObjectCollectionLinks(featureNameToGet, ClassID_traits< CONTAINER >::ID())) {
          std::vector<ElementLink<CONTAINER>> collectionLinks = decisionObj->objectCollectionLinks<CONTAINER>( featureNameToGet );
          filterLinkVectorByContainerKey<CONTAINER>(containerSGKey, collectionLinks);
          std::copy(collectionLinks.begin(), collectionLinks.end(), std::back_inserter(featureLinks));
        }
#ifndef XAOD_STANDALONE
      } catch (SG::ExcCLIDMismatch&) {
        // This is in place to catch the exception caused by non-IParticle features when an IParticle interface is requested.
        // We're fine to catch this silently and cary on looking at the next Decision object in the graph
      }
      try {
#endif
        // Slices may have added single links. Note: the framework-specified "feature" link is always a single link.
        if (decisionObj->hasObjectLink(featureNameToGet, ClassID_traits< CONTAINER >::ID())) {
          std::vector<ElementLink<CONTAINER>> singleEntryVector; // Filtering function operates on a vector
          singleEntryVector.push_back( decisionObj->objectLink<CONTAINER>( featureNameToGet ) );
          filterLinkVectorByContainerKey<CONTAINER>(containerSGKey, singleEntryVector);
          std::copy(singleEntryVector.begin(), singleEntryVector.end(), std::back_inserter(featureLinks));
        }
#ifndef XAOD_STANDALONE
      } catch (SG::ExcCLIDMismatch&) {
        // Silently. As above.
      }
#endif
    }
 
    // Check if the Decsision object is active for a specific set of Chains-of-interest (as supplied by the TDT)
    ActiveState state = ActiveState::UNSET;
    if (chainIDs.size() > 0) {
      // If we were given a list of chains to consider then we start assuming none passed this decisionObj
      state = ActiveState::INACTIVE;
      for (DecisionID id : chainIDs) {
        if (std::count(decisionObj->decisions().begin(), decisionObj->decisions().end(), id) == 1) {
          state = ActiveState::ACTIVE;
          break;
        }
      }
      // But consider also the ComboHypo, this will have run immidiately after the Hypo and could have failed this chain due to combinatorics.
      // This statement will only activate for the case that we are looking for "feature" edges (which is the default).
      if (state == ActiveState::ACTIVE && decisionObjChild && decisionObjChild->name() == comboHypoAlgNodeName()) {
        state = ActiveState::INACTIVE;
        for (DecisionID id : chainIDs) {
          if (std::count(decisionObjChild->decisions().begin(), decisionObjChild->decisions().end(), id) == 1) {
            state = ActiveState::ACTIVE;
            break;
          }
        }
      } 
    }
    
    // Copy the fetched links into the return vector
    for (const ElementLink<CONTAINER>& featureLink : featureLinks) {
      typename std::vector<LinkInfo<CONTAINER>>::iterator vecIt = std::find_if(features.begin(), features.end(), [&](const auto& li) { return li.link == featureLink; } );
      if (vecIt == features.end()) {
        // Link did not already exist - add it to the output
        features.emplace_back( decisionObj, featureLink, state);
      } else {
        // Link already existed - if the link's state in the return vector is INACTIVE but is ACTIVE here,
        // then we need to change it to ACTIVE as this denotes one-or-more of the requested chains were active for the object.
        if (vecIt->state == ActiveState::INACTIVE and state == ActiveState::ACTIVE) {
          vecIt->state = ActiveState::ACTIVE;
        }
        // Update the set of passed IDs
        vecIt->decisions.insert(ids.begin(), ids.end());
      }
    }
 
    // Stop processing this path through the navigation if the lastFeatureOfType flag is set
    if (featureLinks.size() && lastFeatureOfType) {
      return;
    }
 
    // Recurse to decisionObj's seeds
    for (const NavGraphNode* seedNavNode : navGraphNode->seeds()) {
#if TRIGCOMPUTILS_ENABLE_EARLY_EXIT == 1
      if (fullyExploredFrom.count(seedNavNode) == 1) {
        continue; // Already explored down from here
      }
#endif
      recursiveGetFeaturesOfTypeInternal<CONTAINER>(features,
        fullyExploredFrom,
        seedNavNode,
        containerSGKey,
        lastFeatureOfType,
        navElementLinkKey,
        chainIDs);
    }
 
    // If we encounter this node again in the future, we don't need to explore it again as it's now fully explored.
 
    fullyExploredFrom.insert( navGraphNode );
    return;
  }
 
 
  template<typename T>
  DecisionIDContainer passedDecisionIDs( const Decision* d, const T& required ) {
    DecisionIDContainer passed;
    for ( DecisionID id : decisionIDs( d ) ) {
      if ( required.find(id) != required.end() ) {
        passed.insert(id);
      }
    }
    return passed;
  }
 
}