Implementation of ONNX model score computation and decoration for Taus (GNTau)

Implement Bertand's suggested solution to vertex variables calculation - which also only has to run once per tau!

Reconstruction/tauRec/python/TauConfigFlags.py

@@ -60,6 +60,9 @@ def createTauConfigFlags():
     # R22 DeepSet tau ID tune without track RNN scores, for now define a second set of flags, but ultimately we'll choose one and drop the other
     tau_cfg.addFlag("Tau.TauJetDeepSetConfig_v2", ["tauid_1p_R22_dpst_noTrackScore.json", "tauid_2p_R22_dpst_noTrackScore.json", "tauid_3p_R22_dpst_noTrackScore.json"])
     tau_cfg.addFlag("Tau.TauJetDeepSetWP_v2", ["model_1p_R22_dpst_noTrackScore.root", "model_2p_R22_dpst_noTrackScore.root", "model_3p_R22_dpst_noTrackScore.root"])
+    # GNTau ID tune file (need to add another version for noAux)
+    tau_cfg.addFlag("Tau.TauGNNConfig", ["GNTau_noAux_simplified.onnx"])
+    tau_cfg.addFlag("Tau.TauGNNWP_v0", ["GNTauNA_flat_model_1p.root", "GNTauNA_flat_model_2p.root", "GNTauNA_flat_model_3p.root"])
 
     # PanTau config flags
     from PanTauAlgs.PanTauConfigFlags import createPanTauConfigFlags

Reconstruction/tauRec/python/TauToolHolder.py

@@ -851,6 +851,54 @@ def TauWPDecoratorJetDeepSetCfg(flags, version=None):
     result.setPrivateTools(myTauWPDecorator)
     return result
 
+def TauGNNEvaluatorCfg(flags):
+    result = ComponentAccumulator()
+    _name = flags.Tau.ActiveConfig.prefix + 'TauGNN'
+
+    TauGNNEvaluator = CompFactory.getComp("TauGNNEvaluator")
+    GNNConf = flags.Tau.TauGNNConfig
+    myTauGNNEvaluator = TauGNNEvaluator(name = _name,
+                                              NetworkFile = GNNConf[0],
+                                              OutputVarname = "GNTauScore",
+                                              OutputPTau = "GNTauProbTau",
+                                              OutputPJet = "GNTauProbJet",
+                                              MaxTracks = 30,
+                                              MaxClusters = 20,
+                                              MaxClusterDR = 15.0,
+                                              VertexCorrection = True,
+                                              DecorateTracks = False,
+                                              InputLayerScalar = "tau_vars",
+                                              InputLayerTracks = "track_vars",
+                                              InputLayerClusters = "cluster_vars",
+                                              NodeNameTau="GN2TauNoAux_pb",
+                                              NodeNameJet="GN2TauNoAux_pu")
+
+    result.setPrivateTools(myTauGNNEvaluator)
+    return result
+
+def TauWPDecoratorGNNCfg(flags):
+    result = ComponentAccumulator()
+    _name = flags.Tau.ActiveConfig.prefix + 'TauWPDecoratorGNN'
+
+    TauWPDecorator = CompFactory.getComp("TauWPDecorator")
+    WPConf = flags.Tau.TauGNNWP_v0
+    decorWPNames = ["GNTauVL_v0", "GNTauL_v0", "GNTauM_v0", "GNTauT_v0"]
+    scoreName = "GNTauScore"
+    newScoreName = "GNTauScoreSigTrans_v0"
+    myTauWPDecorator = TauWPDecorator(name=_name,
+                                      flatteningFile1Prong = WPConf[0],
+                                      flatteningFile2Prong = WPConf[1],
+                                      flatteningFile3Prong = WPConf[2],
+                                      DecorWPNames = decorWPNames,
+                                      DecorWPCutEffs1P = [0.95, 0.85, 0.75, 0.60],
+                                      DecorWPCutEffs2P = [0.95, 0.75, 0.60, 0.45],
+                                      DecorWPCutEffs3P = [0.95, 0.75, 0.60, 0.45],
+                                      ScoreName = scoreName,
+                                      NewScoreName = newScoreName,
+                                      DefineWPs = True)
+    result.setPrivateTools(myTauWPDecorator)
+    return result
+
 def TauEleRNNEvaluatorCfg(flags):
     result = ComponentAccumulator()
     _name = flags.Tau.ActiveConfig.prefix + 'TauEleRNN'

Reconstruction/tauRecTools/CMakeLists.txt

@@ -8,6 +8,7 @@ find_package( Boost )
 find_package( Eigen )
 find_package( ROOT COMPONENTS Core Tree Hist RIO )
 find_package( lwtnn )
+find_package( onnxruntime )
 
 # Optional dependencies.
 set( extra_public_libs )
@@ -28,12 +29,12 @@ atlas_add_library( tauRecToolsLib
    tauRecTools/*.h Root/*.cxx tauRecTools/lwtnn/*.h Root/lwtnn/*.cxx
    PUBLIC_HEADERS tauRecTools
    INCLUDE_DIRS ${Boost_INCLUDE_DIRS} ${EIGEN_INCLUDE_DIRS}
-   ${LWTNN_INCLUDE_DIRS} ${ROOT_INCLUDE_DIRS}
+   ${LWTNN_INCLUDE_DIRS} ${ROOT_INCLUDE_DIRS} ${ONNXRUNTIME_INCLUDE_DIRS}
    LINK_LIBRARIES ${Boost_LIBRARIES} ${EIGEN_LIBRARIES} ${LWTNN_LIBRARIES}
-   ${ROOT_LIBRARIES}
+   ${ROOT_LIBRARIES} ${ONNXRUNTIME_LIBRARIES}
    CxxUtils AthLinks AsgMessagingLib AsgDataHandlesLib AsgTools xAODCaloEvent
    xAODEventInfo xAODJet xAODParticleEvent xAODPFlow xAODTau xAODTracking xAODEventShape
-   MVAUtils ${extra_public_libs}
+   MVAUtils FlavorTagDiscriminants ${extra_public_libs}
    PRIVATE_LINK_LIBRARIES CaloGeoHelpers FourMomUtils PathResolver )
 
 atlas_add_dictionary( tauRecToolsDict
@@ -46,5 +47,5 @@ if( NOT XAOD_STANDALONE )
       INCLUDE_DIRS ${Boost_INCLUDE_DIRS}
       LINK_LIBRARIES ${Boost_LIBRARIES} AsgTools AsgMessagingLib xAODBase
       xAODCaloEvent xAODJet xAODPFlow xAODTau FourMomUtils tauRecToolsLib PFlowUtilsLib
-      ${extra_private_libs} )
+      FlavorTagDiscriminants ${extra_private_libs} )
 endif()

Reconstruction/tauRecTools/Root/TauGNN.cxx

+/*
+  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "tauRecTools/TauGNN.h"
+#include "FlavorTagDiscriminants/OnnxUtil.h"
+#include "PathResolver/PathResolver.h"
+
+#include <algorithm>
+#include <fstream>
+
+#include "lwtnn/LightweightGraph.hh"
+#include "lwtnn/Exceptions.hh"
+//#include "lwtnn/parse_json.hh"
+
+#include "tauRecTools/TauGNNUtils.h"
+
+TauGNN::TauGNN(const std::string &nnFile, const Config &config):
+    asg::AsgMessaging("TauGNN"),
+    m_onnxUtil(nullptr)
+  {
+    //==================================================//
+    // This part is ported from FTagDiscriminant GNN.cxx//
+    //==================================================//
+
+    m_onnxUtil = std::make_shared<FlavorTagDiscriminants::OnnxUtil>(nnFile);
+
+    // get the configuration of the model outputs
+    FlavorTagDiscriminants::OnnxUtil::OutputConfig gnn_output_config = m_onnxUtil->getOutputConfig();
+    
+    //Let's see the output!
+    for (const auto& out_node: gnn_output_config) {
+        if(out_node.type==FlavorTagDiscriminants::OnnxOutput::OutputType::FLOAT) ATH_MSG_INFO("Found output FLOAT node named:" << out_node.name);
+        if(out_node.type==FlavorTagDiscriminants::OnnxOutput::OutputType::VECCHAR) ATH_MSG_INFO("Found output VECCHAR node named:" << out_node.name);
+        if(out_node.type==FlavorTagDiscriminants::OnnxOutput::OutputType::VECFLOAT) ATH_MSG_INFO("Found output VECFLOAT node named:" << out_node.name);
+    }
+
+    //Get model config (for inputs)
+    auto lwtnn_config = m_onnxUtil->getLwtConfig();
+    
+    //===================================================//
+    // This part is ported from tauRecTools TauJetRNN.cxx//
+    //===================================================//
+
+    // Search for input layer names specified in 'config'
+    auto node_is_scalar = [&config](const lwt::InputNodeConfig &in_node) {
+        return in_node.name == config.input_layer_scalar;
+    };
+    auto node_is_track = [&config](const lwt::InputNodeConfig &in_node) {
+        return in_node.name == config.input_layer_tracks;
+    };
+    auto node_is_cluster = [&config](const lwt::InputNodeConfig &in_node) {
+        return in_node.name == config.input_layer_clusters;
+    };
+
+    auto scalar_node = std::find_if(lwtnn_config.inputs.cbegin(),
+                                    lwtnn_config.inputs.cend(),
+                                    node_is_scalar);
+
+    auto track_node = std::find_if(lwtnn_config.input_sequences.cbegin(),
+                                   lwtnn_config.input_sequences.cend(),
+                                   node_is_track);
+
+    auto cluster_node = std::find_if(lwtnn_config.input_sequences.cbegin(),
+                                     lwtnn_config.input_sequences.cend(),
+                                     node_is_cluster);
+
+    // Check which input layers were found
+    auto has_scalar_node = scalar_node != lwtnn_config.inputs.cend();
+    auto has_track_node = track_node != lwtnn_config.input_sequences.cend();
+    auto has_cluster_node = cluster_node != lwtnn_config.input_sequences.cend();
+    if(!has_scalar_node) ATH_MSG_WARNING("No scalar node with name "<<config.input_layer_scalar<<" found!");
+    if(!has_track_node) ATH_MSG_WARNING("No track node with name "<<config.input_layer_tracks<<" found!");
+    if(!has_cluster_node) ATH_MSG_WARNING("No cluster node with name "<<config.input_layer_clusters<<" found!");
+    
+    // Fill the variable names of each input layer into the corresponding vector
+    if (has_scalar_node) {
+        for (const auto &in : scalar_node->variables) {
+            std::string name = in.name;
+            m_scalarCalc_inputs.push_back(name);
+        }
+    }
+
+    if (has_track_node) {
+        for (const auto &in : track_node->variables) {
+            std::string name = in.name;
+            m_trackCalc_inputs.push_back(name);
+        }
+    }
+
+    if (has_cluster_node) {
+        for (const auto &in : cluster_node->variables) {
+            std::string name = in.name;
+            m_clusterCalc_inputs.push_back(name);
+        }
+    }
+    // Load the variable calculator
+    m_var_calc = TauGNNUtils::get_calculator(m_scalarCalc_inputs, m_trackCalc_inputs, m_clusterCalc_inputs);
+    ATH_MSG_INFO("TauGNN object initialized successfully!");
+}
+
+TauGNN::~TauGNN() {}
+
+std::tuple<
+    std::map<std::string, float>,
+    std::map<std::string, std::vector<char>>,
+    std::map<std::string, std::vector<float>> >
+TauGNN::compute(const xAOD::TauJet &tau,
+                         const std::vector<const xAOD::TauTrack *> &tracks,
+                         const std::vector<xAOD::CaloVertexedTopoCluster> &clusters) const {
+    InputMap scalarInputs;
+    InputSequenceMap vectorInputs;
+    std::map<std::string, input_pair> gnn_input;
+    ATH_MSG_DEBUG("Starting compute...");
+    //Prepare input variables
+    if (!calculateInputVariables(tau, tracks, clusters, scalarInputs, vectorInputs)) {
+        ATH_MSG_FATAL("Failed calculateInputVariables");
+        throw StatusCode::FAILURE;
+    }
+
+    // Add TauJet-level features to the input
+    std::vector<float> tau_feats;
+    for (const auto &varname : m_scalarCalc_inputs) {
+        tau_feats.push_back(static_cast<float>(scalarInputs[m_config.input_layer_scalar][varname]));
+    }
+    std::vector<int64_t> tau_feats_dim = {1, static_cast<int64_t>(tau_feats.size())};
+    input_pair tau_info (tau_feats, tau_feats_dim);
+    gnn_input.insert({"tau_vars", tau_info});
+
+    //Add track-level features to the input
+    std::vector<float> trk_feats;
+    int num_nodes=static_cast<int>(vectorInputs[m_config.input_layer_tracks][m_trackCalc_inputs.at(0)].size());
+    int num_node_vars=static_cast<int>(m_trackCalc_inputs.size());
+    trk_feats.resize(num_nodes * num_node_vars);
+    int var_idx=0;
+    for (const auto &varname : m_trackCalc_inputs) {
+        for (int node_idx=0; node_idx<num_nodes; node_idx++){    
+            trk_feats.at(node_idx*num_node_vars + var_idx)
+              = static_cast<float>(vectorInputs[m_config.input_layer_tracks][varname].at(node_idx));
+        }
+        var_idx++;
+    }
+    std::vector<int64_t> trk_feats_dim = {num_nodes, num_node_vars};
+    input_pair trk_info (trk_feats, trk_feats_dim);
+    gnn_input.insert({"track_vars", trk_info});
+    
+    //Add cluster-level features to the input
+    std::vector<float> cls_feats;
+    num_nodes=static_cast<int>(vectorInputs[m_config.input_layer_clusters][m_clusterCalc_inputs.at(0)].size());
+    num_node_vars=static_cast<int>(m_clusterCalc_inputs.size());
+    cls_feats.resize(num_nodes * num_node_vars);
+    var_idx=0;
+    for (const auto &varname : m_clusterCalc_inputs) {
+        for (int node_idx=0; node_idx<num_nodes; node_idx++){    
+            cls_feats.at(node_idx*num_node_vars + var_idx)
+              = static_cast<float>(vectorInputs[m_config.input_layer_clusters][varname].at(node_idx));
+        }
+        var_idx++;
+    }
+    std::vector<int64_t> cls_feats_dim = {num_nodes, num_node_vars};
+    input_pair cls_info (cls_feats, cls_feats_dim);
+    gnn_input.insert({"cluster_vars", cls_info});    
+
+    //RUN THE INFERENCE!!!
+    ATH_MSG_DEBUG("Prepared inputs, running inference...");
+    auto [out_f, out_vc, out_vf] = m_onnxUtil->runInference(gnn_input);
+    ATH_MSG_DEBUG("Finished compute!");
+    return std::make_tuple(out_f, out_vc, out_vf);
+}
+
+bool TauGNN::calculateInputVariables(const xAOD::TauJet &tau,
+                  const std::vector<const xAOD::TauTrack *> &tracks,
+                  const std::vector<xAOD::CaloVertexedTopoCluster> &clusters,
+                  std::map<std::string, std::map<std::string, double>>& scalarInputs,
+                  std::map<std::string, std::map<std::string, std::vector<double>>>& vectorInputs) const {
+    scalarInputs.clear();
+    vectorInputs.clear();
+    // Populate input (sequence) map with input variables
+    for (const auto &varname : m_scalarCalc_inputs) {
+        if (!m_var_calc->compute(varname, tau,
+                                 scalarInputs[m_config.input_layer_scalar][varname])) {
+            ATH_MSG_WARNING("Error computing '" << varname
+                            << "' returning default");
+            return false;
+        }
+    }
+
+    for (const auto &varname : m_trackCalc_inputs) {
+        if (!m_var_calc->compute(varname, tau, tracks,
+                                 vectorInputs[m_config.input_layer_tracks][varname])) {
+            ATH_MSG_WARNING("Error computing '" << varname
+                            << "' returning default");
+            return false;
+        }
+    }
+
+    for (const auto &varname : m_clusterCalc_inputs) {
+        if (!m_var_calc->compute(varname, tau, clusters,
+                                 vectorInputs[m_config.input_layer_clusters][varname])) {
+            ATH_MSG_WARNING("Error computing '" << varname
+                            << "' returning default");
+            return false;
+        }
+    }
+    return true;
+}

Reconstruction/tauRecTools/Root/TauGNNEvaluator.cxx

+/*
+  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "tauRecTools/TauGNNEvaluator.h"
+#include "tauRecTools/TauGNN.h"
+#include "tauRecTools/HelperFunctions.h"
+
+#include "PathResolver/PathResolver.h"
+
+#include <algorithm>
+
+
+TauGNNEvaluator::TauGNNEvaluator(const std::string &name): 
+  TauRecToolBase(name),
+  m_net(nullptr){
+    
+  declareProperty("NetworkFile", m_weightfile = "");
+  declareProperty("OutputVarname", m_output_varname = "GNTauScore");
+  declareProperty("OutputPTau", m_output_ptau = "GNTauProbTau");
+  declareProperty("OutputPJet", m_output_pjet = "GNTauProbJet");
+  declareProperty("MaxTracks", m_max_tracks = 30);
+  declareProperty("MaxClusters", m_max_clusters = 20);
+  declareProperty("MaxClusterDR", m_max_cluster_dr = 1.0f);
+  declareProperty("VertexCorrection", m_doVertexCorrection = true);
+  declareProperty("DecorateTracks", m_decorateTracks = false);
+  declareProperty("TrackClassification", m_doTrackClassification = true);
+
+  // Naming conventions for the network weight files:
+  declareProperty("InputLayerScalar", m_input_layer_scalar = "tau_vars");
+  declareProperty("InputLayerTracks", m_input_layer_tracks = "track_vars");
+  declareProperty("InputLayerClusters", m_input_layer_clusters = "cluster_vars");
+  declareProperty("NodeNameTau", m_outnode_tau = "GN2TauNoAux_pb");
+  declareProperty("NodeNameJet", m_outnode_jet = "GN2TauNoAux_pu");
+  }
+
+TauGNNEvaluator::~TauGNNEvaluator() {}
+
+StatusCode TauGNNEvaluator::initialize() {
+  ATH_MSG_INFO("Initializing TauGNNEvaluator");
+  
+  std::string weightfile("");
+
+  // Use PathResolver to search for the weight files
+  if (!m_weightfile.empty()) {
+    weightfile = find_file(m_weightfile);
+    if (weightfile.empty()) {
+      ATH_MSG_ERROR("Could not find network weights: " << m_weightfile);
+      return StatusCode::FAILURE;
+    } else {
+      ATH_MSG_INFO("Using network config: " << weightfile);
+    }
+  }
+
+  // Set the layer and node names in the weight file
+  TauGNN::Config config;
+  config.input_layer_scalar = m_input_layer_scalar;
+  config.input_layer_tracks = m_input_layer_tracks;
+  config.input_layer_clusters = m_input_layer_clusters;
+  config.output_node_tau = m_outnode_tau;
+  config.output_node_jet = m_outnode_jet;
+
+  // Load the weights and create the network
+  if (!weightfile.empty()) {
+    m_net = std::make_unique<TauGNN>(weightfile, config);
+    if (!m_net) {
+      ATH_MSG_ERROR("No network configured.");
+      return StatusCode::FAILURE;
+    }
+  }
+
+  return StatusCode::SUCCESS;
+}
+
+StatusCode TauGNNEvaluator::execute(xAOD::TauJet &tau) const {
+  // Output variable Decorators
+  const SG::AuxElement::Accessor<float> output(m_output_varname);
+  const SG::AuxElement::Accessor<float> out_ptau(m_output_ptau);
+  const SG::AuxElement::Accessor<float> out_pjet(m_output_pjet);
+  const SG::AuxElement::Decorator<char> out_trkclass("GNTau_TrackClass");
+  // Set default score and overwrite later
+  output(tau) = -1111.0f;
+  out_ptau(tau) = -1111.0f;
+  out_pjet(tau) = -1111.0f;
+  //Skip execution for low-pT taus to save resources
+  if(tau.pt()<13000) {
+    return StatusCode::SUCCESS;
+  }
+
+  // Get input objects
+  std::vector<const xAOD::TauTrack *> tracks;
+  ATH_CHECK(get_tracks(tau, tracks));
+  std::vector<xAOD::CaloVertexedTopoCluster> clusters;
+  ATH_CHECK(get_clusters(tau, clusters));
+
+  // Truncate tracks
+  int numTracksMax = std::min(m_max_tracks, tracks.size());
+  std::vector<const xAOD::TauTrack *> trackVec(tracks.begin(), tracks.begin()+numTracksMax);
+  // Evaluate networks
+  if (m_net) {
+    auto [out_f, out_vc, out_vf] = m_net->compute(tau, trackVec, clusters);
+    output(tau)=std::log10(1/(1-out_f.at(m_outnode_tau)));
+    out_ptau(tau)=out_f.at(m_outnode_tau);
+    out_pjet(tau)=out_f.at(m_outnode_jet);
+    if (m_decorateTracks){
+      for(unsigned int i=0;i<tracks.size();i++){
+        if(i<out_vc.at("track_class").size()){out_trkclass(*tracks.at(i))=out_vc.at("track_class").at(i);}
+        else{out_trkclass(*tracks.at(i))='9';} //Dummy value for tracks outside range of out_vc
+      }
+    }
+  }
+  
+  return StatusCode::SUCCESS;
+}
+
+const TauGNN* TauGNNEvaluator::get_gnn() const {
+  return m_net.get();
+}
+
+
+StatusCode TauGNNEvaluator::get_tracks(const xAOD::TauJet &tau, std::vector<const xAOD::TauTrack *> &out) const {
+  std::vector<const xAOD::TauTrack*> tracks = tau.allTracks();
+
+  // Skip unclassified tracks:
+  // - the track is a LRT and classifyLRT = false
+  // - the track is not among the MaxNtracks highest-pt tracks in the track classifier
+  // - track classification is not run (trigger)
+  if(m_doTrackClassification) {
+    std::vector<const xAOD::TauTrack*>::iterator it = tracks.begin();
+    while(it != tracks.end()) {
+      if((*it)->flag(xAOD::TauJetParameters::unclassified)) {
+  it = tracks.erase(it);
+      }
+      else {
+	++it;
+      }
+    }
+  }
+
+  // Sort by descending pt
+  auto cmp_pt = [](const xAOD::TauTrack *lhs, const xAOD::TauTrack *rhs) {
+    return lhs->pt() > rhs->pt();
+  };
+  std::sort(tracks.begin(), tracks.end(), cmp_pt);
+  out = std::move(tracks);
+
+  return StatusCode::SUCCESS;
+}
+
+StatusCode TauGNNEvaluator::get_clusters(const xAOD::TauJet &tau, std::vector<xAOD::CaloVertexedTopoCluster> &clusters) const {
+
+  TLorentzVector tauAxis = tauRecTools::getTauAxis(tau, m_doVertexCorrection);
+
+  std::vector<xAOD::CaloVertexedTopoCluster> vertexedClusterList = tau.vertexedClusters();
+  for (const xAOD::CaloVertexedTopoCluster& vertexedCluster : vertexedClusterList) {
+    TLorentzVector clusterP4 = vertexedCluster.p4();
+    if (clusterP4.DeltaR(tauAxis) > m_max_cluster_dr) continue;
+      
+    clusters.push_back(vertexedCluster);
+  }
+
+  // Sort by descending et
+  auto et_cmp = [](const xAOD::CaloVertexedTopoCluster& lhs,
+		   const xAOD::CaloVertexedTopoCluster& rhs) {
+    return lhs.p4().Et() > rhs.p4().Et();
+  };
+  std::sort(clusters.begin(), clusters.end(), et_cmp);
+
+  // Truncate clusters
+  if (clusters.size() > m_max_clusters) {
+    clusters.resize(m_max_clusters, clusters[0]);
+  }
+
+  return StatusCode::SUCCESS;
+}

Reconstruction/tauRecTools/src/components/tauRecTools_entries.cxx

@@ -25,6 +25,7 @@
 #include "tauRecTools/TauWPDecorator.h"
 #include "tauRecTools/TauIDVarCalculator.h"
 #include "tauRecTools/TauJetRNNEvaluator.h"
+#include "tauRecTools/TauGNNEvaluator.h"
 #include "tauRecTools/TauDecayModeNNClassifier.h"
 #include "tauRecTools/TauVertexedClusterDecorator.h"
 #include "tauRecTools/TauAODSelector.h"
@@ -59,6 +60,7 @@ DECLARE_COMPONENT( TauPi0Selector )
 DECLARE_COMPONENT( TauWPDecorator )
 DECLARE_COMPONENT( TauIDVarCalculator )
 DECLARE_COMPONENT( TauJetRNNEvaluator )
+DECLARE_COMPONENT( TauGNNEvaluator )
 DECLARE_COMPONENT( TauDecayModeNNClassifier )
 DECLARE_COMPONENT( TauVertexedClusterDecorator )
 DECLARE_COMPONENT( TauAODSelector )

Reconstruction/tauRecTools/tauRecTools/TauGNN.h

+/*
+  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef TAURECTOOLS_TAUGNN_H
+#define TAURECTOOLS_TAUGNN_H
+
+#include "xAODTau/TauJet.h"
+#include "xAODCaloEvent/CaloVertexedTopoCluster.h"
+
+#include "AsgMessaging/AsgMessaging.h"
+
+#include "FlavorTagDiscriminants/OnnxUtil.h"
+
+#include <memory>
+#include <string>
+#include <map>
+
+// Forward declaration
+namespace lwt {
+    class LightweightGraph;
+}
+
+namespace TauGNNUtils {
+    class GNNVarCalc;
+}
+
+namespace FlavorTagDiscriminants{
+    class OnnxUtil;
+}
+
+/**
+ * @brief Wrapper around ONNXUtil to compute the output score of a model
+ *
+ *   Configures the network and computes the network outputs given the input
+ *   objects. Retrieval of input variables is handled internally.
+ *
+ * @author N.M. Tamir
+ *
+ */
+class TauGNN : public asg::AsgMessaging {
+public:
+    // Configuration of the weight file structure
+    struct Config {
+        std::string input_layer_scalar;
+        std::string input_layer_tracks;
+        std::string input_layer_clusters;
+        std::string output_node_tau;
+        std::string output_node_jet;
+    };
+    std::shared_ptr<const FlavorTagDiscriminants::OnnxUtil> m_onnxUtil;
+public:
+    TauGNN(const std::string &nnFile, const Config &config);
+    ~TauGNN();
+
+    // Output the OnnxUtil tuple 
+    std::tuple<
+        std::map<std::string, float>,
+        std::map<std::string, std::vector<char>>,
+        std::map<std::string, std::vector<float>> > 
+    compute(const xAOD::TauJet &tau,
+                  const std::vector<const xAOD::TauTrack *> &tracks,
+                  const std::vector<xAOD::CaloVertexedTopoCluster> &clusters) const;
+
+    // Compute all input variables and store them in the maps that are passed by reference
+    bool calculateInputVariables(const xAOD::TauJet &tau,
+                  const std::vector<const xAOD::TauTrack *> &tracks,
+                  const std::vector<xAOD::CaloVertexedTopoCluster> &clusters,
+                  std::map<std::string, std::map<std::string, double>>& scalarInputs,
+                  std::map<std::string, std::map<std::string, std::vector<double>>>& vectorInputs) const;
+
+    // Getter for the variable calculator
+    const TauGNNUtils::GNNVarCalc* variable_calculator() const {
+        return m_var_calc.get();
+    }
+
+    explicit operator bool() const {
+        return static_cast<bool>(m_graph);
+    }
+
+    //Make the output config transparent to external tools
+    FlavorTagDiscriminants::OnnxUtil::OutputConfig gnn_output_config;
+
+private:
+    using input_pair = FlavorTagDiscriminants::input_pair;
+    // Abbreviations for lwtnn
+    using VariableMap = std::map<std::string, double>;
+    using VectorMap = std::map<std::string, std::vector<double>>;
+
+    using InputMap = std::map<std::string, VariableMap>;
+    using InputSequenceMap = std::map<std::string, VectorMap>;
+
+private:
+    const Config m_config;
+    std::unique_ptr<const lwt::LightweightGraph> m_graph;
+
+    // Names of the input variables
+    std::vector<std::string> m_scalar_inputs;
+    std::vector<std::string> m_track_inputs;
+    std::vector<std::string> m_cluster_inputs;
+    // Names passed to the variable calculator
+    std::vector<std::string> m_scalarCalc_inputs;
+    std::vector<std::string> m_trackCalc_inputs;
+    std::vector<std::string> m_clusterCalc_inputs;
+
+    // Variable calculator to calculate input variables on the fly
+    std::unique_ptr<TauGNNUtils::GNNVarCalc> m_var_calc;
+};
+
+#endif // TAURECTOOLS_TAUGNN_H

Reconstruction/tauRecTools/tauRecTools/TauGNNEvaluator.h

+/*
+  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef TAURECTOOLS_TAUGNNEVALUATOR_H
+#define TAURECTOOLS_TAUGNNEVALUATOR_H
+
+#include "tauRecTools/TauRecToolBase.h"
+
+#include "xAODTau/TauJet.h"
+#include "xAODCaloEvent/CaloVertexedTopoCluster.h"
+
+#include <memory>
+
+class TauGNN;
+
+/**
+ * @brief Tool to calculate tau identification score from .onnx inputs
+ *
+ *   The network configuration is supplied in .onnx format. 
+ *   Currently runs on a prongness-inclusive model 
+ *   Based off of TauJetRNNEvaluator.h format!
+ * @author N.M. Tamir
+ *
+ */
+class TauGNNEvaluator : public TauRecToolBase {
+public:
+    ASG_TOOL_CLASS2(TauGNNEvaluator, TauRecToolBase, ITauToolBase)
+
+    TauGNNEvaluator(const std::string &name = "TauGNNEvaluator");
+    virtual ~TauGNNEvaluator();
+
+    virtual StatusCode initialize() override;
+    virtual StatusCode execute(xAOD::TauJet &tau) const override;
+    // Getter for the underlying RNN implementation
+    const TauGNN* get_gnn() const;
+
+    // Selects tracks to be used as input to the network
+    StatusCode get_tracks(const xAOD::TauJet &tau,
+                          std::vector<const xAOD::TauTrack *> &out) const;
+
+    // Selects clusters to be used as input to the network
+    StatusCode get_clusters(const xAOD::TauJet &tau,
+                            std::vector<xAOD::CaloVertexedTopoCluster> &out) const;
+
+private:
+    std::string m_output_varname;
+    std::string m_output_ptau;
+    std::string m_output_pjet;
+    std::string m_weightfile;
+    std::size_t m_max_tracks;
+    std::size_t m_max_clusters;
+    float m_max_cluster_dr;
+    bool m_doVertexCorrection;
+    bool m_doTrackClassification;
+    bool m_decorateTracks;
+
+    // Configuration of the network file
+    std::string m_input_layer_scalar;
+    std::string m_input_layer_tracks;
+    std::string m_input_layer_clusters;
+    std::string m_outnode_tau;
+    std::string m_outnode_jet;
+
+    // Wrappers for lwtnn
+    std::unique_ptr<TauGNN> m_net; //!
+};
+
+#endif // TAURECTOOLS_TAUGNNEVALUATOR_H

Reconstruction/tauRecTools/tauRecTools/TauGNNUtils.h

+/*
+  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef TAURECTOOLS_TAUGNNUTILS_H
+#define TAURECTOOLS_TAUGNNUTILS_H
+
+#include "xAODTau/TauJet.h"
+#include "xAODCaloEvent/CaloVertexedTopoCluster.h"
+#include "xAODEventInfo/EventInfo.h"
+#include "xAODTracking/VertexContainer.h"
+#include "AsgTools/AsgTool.h"
+#include "AsgMessaging/AsgMessaging.h"
+#include <unordered_map>
+
+
+namespace TauGNNUtils {
+
+/**
+ * @brief Tool to calculate input variables for the GNN-based tau identification
+ *
+ *   Used to calculate input variables for (onnx)GNN-based tau identification on
+ *   the fly by providing a mapping between variable names (strings) and
+ *   functions to calculate these variables.
+ *
+ * @author C. Deutsch
+ * @author W. Davey
+ * @author N.M. Tamir
+ *
+ */
+class GNNVarCalc : public asg::AsgMessaging {
+public:
+    // Pointers to calculator functions
+    using ScalarCalc = bool (*)(const xAOD::TauJet &, double &);
+
+    using TrackCalc = bool (*)(const xAOD::TauJet &, const xAOD::TauTrack &,
+                               double &);
+
+    using ClusterCalc = bool (*)(const xAOD::TauJet &,
+                                 const xAOD::CaloVertexedTopoCluster &, double &);
+
+public:
+    GNNVarCalc();
+    ~GNNVarCalc() = default;
+
+    // Methods to compute the output (vector) based on the variable name
+
+    // Computes high-level ID variables
+    bool compute(const std::string &name, const xAOD::TauJet &tau, double &out) const;
+
+    // Computes track variables
+    bool compute(const std::string &name, const xAOD::TauJet &tau,
+                 const std::vector<const xAOD::TauTrack *> &tracks,
+                 std::vector<double> &out) const;
+
+    // Computes cluster variables
+    bool compute(const std::string &name, const xAOD::TauJet &tau,
+                 const std::vector<xAOD::CaloVertexedTopoCluster> &clusters,
+                 std::vector<double> &out) const;
+
+    // Methods to insert calculator functions into the lookup table
+    void insert(const std::string &name, ScalarCalc func, const std::vector<std::string>& scalar_vars);
+    void insert(const std::string &name, TrackCalc func, const std::vector<std::string>& track_vars);
+    void insert(const std::string &name, ClusterCalc func, const std::vector<std::string>& cluster_vars);
+
+private:
+    // Lookup tables
+    std::unordered_map<std::string, ScalarCalc> m_scalar_map;
+    std::unordered_map<std::string, TrackCalc> m_track_map;
+    std::unordered_map<std::string, ClusterCalc> m_cluster_map;
+};
+
+// Factory function to create a variable calculator populated with default
+// variables
+std::unique_ptr<GNNVarCalc> get_calculator(const std::vector<std::string>& scalar_vars,
+					const std::vector<std::string>& track_vars,
+					const std::vector<std::string>& cluster_vars);
+
+
+namespace Variables {
+
+// Functions to calculate (scalar) input variables
+// Returns a status code indicating success
+bool absEta(const xAOD::TauJet &tau, double &out);
+
+bool centFrac(const xAOD::TauJet &tau, double &out);
+
+bool isolFrac(const xAOD::TauJet &tau, double &out); 
+
+bool etOverPtLeadTrk(const xAOD::TauJet &tau, double &out);
+
+bool innerTrkAvgDist(const xAOD::TauJet &tau, double &out);
+
+bool absipSigLeadTrk(const xAOD::TauJet &tau, double &out);
+
+bool sumEMCellEtOverLeadTrkPt(const xAOD::TauJet &tau, double &out);
+
+bool SumPtTrkFrac(const xAOD::TauJet &tau, double &out);
+
+bool EMPOverTrkSysP(const xAOD::TauJet &tau, double &out);
+
+bool ptRatioEflowApprox(const xAOD::TauJet &tau, double &out);
+
+bool mEflowApprox(const xAOD::TauJet &tau, double &out);
+
+bool dRmax(const xAOD::TauJet &tau, double &out);
+
+bool trFlightPathSig(const xAOD::TauJet &tau, double &out);
+
+bool massTrkSys(const xAOD::TauJet &tau, double &out);
+
+bool pt(const xAOD::TauJet &tau, double &out);
+
+bool pt_tau_log(const xAOD::TauJet &tau, double &out);
+
+bool ptDetectorAxis(const xAOD::TauJet &tau, double &out);
+
+bool ptIntermediateAxis(const xAOD::TauJet &tau, double &out);
+
+//functions to calculate input variables needed for the eVeto RNN
+bool ptJetSeed_log             (const xAOD::TauJet &tau, double &out);
+bool absleadTrackEta           (const xAOD::TauJet &tau, double &out);
+bool leadTrackDeltaEta         (const xAOD::TauJet &tau, double &out);
+bool leadTrackDeltaPhi         (const xAOD::TauJet &tau, double &out);
+bool leadTrackProbNNorHT       (const xAOD::TauJet &tau, double &out);
+bool EMFracFixed               (const xAOD::TauJet &tau, double &out);
+bool etHotShotWinOverPtLeadTrk (const xAOD::TauJet &tau, double &out);
+bool hadLeakFracFixed          (const xAOD::TauJet &tau, double &out);
+bool PSFrac                    (const xAOD::TauJet &tau, double &out);
+bool ClustersMeanCenterLambda  (const xAOD::TauJet &tau, double &out);
+bool ClustersMeanEMProbability (const xAOD::TauJet &tau, double &out);
+bool ClustersMeanFirstEngDens  (const xAOD::TauJet &tau, double &out);
+bool ClustersMeanPresamplerFrac(const xAOD::TauJet &tau, double &out);
+bool ClustersMeanSecondLambda  (const xAOD::TauJet &tau, double &out);
+bool EMPOverTrkSysP            (const xAOD::TauJet &tau, double &out);
+
+
+namespace Track {
+
+// Functions to calculate input variables for each track
+// Returns a status code indicating success
+
+bool pt_log(
+    const xAOD::TauJet &tau, const xAOD::TauTrack &track, double &out);
+
+bool trackPt(
+    const xAOD::TauJet& tau, const xAOD::TauTrack &track, double &out);
+
+bool trackEta(
+    const xAOD::TauJet& tau, const xAOD::TauTrack &track, double &out);
+
+bool trackPhi(
+    const xAOD::TauJet& tau, const xAOD::TauTrack &track, double &out);
+    
+bool pt_tau_log(
+    const xAOD::TauJet &tau, const xAOD::TauTrack &track, double &out);
+
+bool pt_jetseed_log(
+    const xAOD::TauJet &tau, const xAOD::TauTrack &track, double &out);
+
+bool d0_abs_log(
+    const xAOD::TauJet &tau, const xAOD::TauTrack &track, double &out);
+
+bool z0sinThetaTJVA_abs_log(
+    const xAOD::TauJet &tau, const xAOD::TauTrack &track, double &out);
+
+bool z0sinthetaTJVA(
+    const xAOD::TauJet& tau, const xAOD::TauTrack &track, double &out);
+
+bool z0sinthetaSigTJVA(
+    const xAOD::TauJet& tau, const xAOD::TauTrack &track, double &out);
+
+bool d0TJVA(
+    const xAOD::TauJet& tau, const xAOD::TauTrack &track, double &out);
+
+bool d0SigTJVA(
+    const xAOD::TauJet& tau, const xAOD::TauTrack &track, double &out);
+
+bool dEta(
+    const xAOD::TauJet &tau, const xAOD::TauTrack &track, double &out);
+
+bool dPhi(
+    const xAOD::TauJet &tau, const xAOD::TauTrack &track, double &out);
+
+bool nInnermostPixelHits(
+    const xAOD::TauJet &tau, const xAOD::TauTrack &track, double &out);
+
+bool nPixelHits(
+    const xAOD::TauJet &tau, const xAOD::TauTrack &track, double &out);
+
+bool nSCTHits(
+    const xAOD::TauJet &tau, const xAOD::TauTrack &track, double &out);
+
+// trigger variants
+bool nIBLHitsAndExp (
+    const xAOD::TauJet &tau, const xAOD::TauTrack &track, double &out);
+
+bool nPixelHitsPlusDeadSensors (
+    const xAOD::TauJet &tau, const xAOD::TauTrack &track, double &out);
+
+bool nSCTHitsPlusDeadSensors (
+    const xAOD::TauJet &tau, const xAOD::TauTrack &track, double &out);
+
+bool eProbabilityHT(
+    const xAOD::TauJet &tau, const xAOD::TauTrack &track, double &out);
+
+bool eProbabilityNN(
+    const xAOD::TauJet &tau, const xAOD::TauTrack &track, double &out);
+
+bool eProbabilityNNorHT(
+    const xAOD::TauJet &tau, const xAOD::TauTrack &track, double &out);
+
+bool chargedScoreRNN(
+    const xAOD::TauJet &tau, const xAOD::TauTrack &track, double &out);
+
+bool isolationScoreRNN(
+    const xAOD::TauJet &tau, const xAOD::TauTrack &track, double &out);
+
+bool conversionScoreRNN(
+    const xAOD::TauJet &tau, const xAOD::TauTrack &track, double &out);
+
+bool fakeScoreRNN(
+    const xAOD::TauJet &tau, const xAOD::TauTrack &track, double &out);
+
+//Extension - variables for GNTau
+bool numberOfInnermostPixelLayerHits(const xAOD::TauJet& tau, const xAOD::TauTrack &track, double &out);
+bool numberOfPixelHits(const xAOD::TauJet& tau, const xAOD::TauTrack &track, double &out);
+bool numberOfPixelSharedHits(const xAOD::TauJet& tau, const xAOD::TauTrack &track, double &out);
+bool numberOfPixelDeadSensors(const xAOD::TauJet& tau, const xAOD::TauTrack &track, double &out);
+bool numberOfSCTHits(const xAOD::TauJet& tau, const xAOD::TauTrack &track, double &out);
+bool numberOfSCTSharedHits(const xAOD::TauJet& tau, const xAOD::TauTrack &track, double &out);
+bool numberOfSCTDeadSensors(const xAOD::TauJet& tau, const xAOD::TauTrack &track, double &out);
+bool numberOfTRTHighThresholdHits(const xAOD::TauJet& tau, const xAOD::TauTrack &track, double &out);
+bool numberOfTRTHits(const xAOD::TauJet& tau, const xAOD::TauTrack &track, double &out);
+bool nSiHits(const xAOD::TauJet& tau, const xAOD::TauTrack &track, double &out);
+bool expectInnermostPixelLayerHit(const xAOD::TauJet& tau, const xAOD::TauTrack &track, double &out);
+bool expectNextToInnermostPixelLayerHit(const xAOD::TauJet& tau, const xAOD::TauTrack &track, double &out);
+bool numberOfContribPixelLayers(const xAOD::TauJet& tau, const xAOD::TauTrack &track, double &out);
+bool numberOfPixelHoles(const xAOD::TauJet& tau, const xAOD::TauTrack &track, double &out);
+bool d0_old(const xAOD::TauJet& tau, const xAOD::TauTrack &track, double &out);
+bool qOverP(const xAOD::TauJet& tau, const xAOD::TauTrack &track, double &out);
+bool theta(const xAOD::TauJet& tau, const xAOD::TauTrack &track, double &out);
+bool z0TJVA(const xAOD::TauJet& tau, const xAOD::TauTrack &track, double &out);
+bool charge(const xAOD::TauJet& tau, const xAOD::TauTrack &track, double &out);
+bool dz0_TV_PV0(const xAOD::TauJet& tau, const xAOD::TauTrack &track, double &out);
+bool log_sumpt_TV(const xAOD::TauJet& tau, const xAOD::TauTrack &track, double &out);
+bool log_sumpt2_TV(const xAOD::TauJet& tau, const xAOD::TauTrack &track, double &out);
+bool log_sumpt_PV0(const xAOD::TauJet& tau, const xAOD::TauTrack &track, double &out);
+bool log_sumpt2_PV0(const xAOD::TauJet& tau, const xAOD::TauTrack &track, double &out);
+
+} // namespace Track
+
+
+namespace Cluster {
+
+// Functions to calculate input variables for each cluster
+// Returns a status code indicating success
+
+bool et_log(
+    const xAOD::TauJet &tau, const xAOD::CaloVertexedTopoCluster &cluster, double &out);
+
+bool pt_tau_log(
+    const xAOD::TauJet &tau, const xAOD::CaloVertexedTopoCluster &cluster, double &out);
+
+bool pt_jetseed_log(
+    const xAOD::TauJet &tau, const xAOD::CaloVertexedTopoCluster &cluster, double &out);
+
+bool dEta(
+    const xAOD::TauJet &tau, const xAOD::CaloVertexedTopoCluster &cluster, double &out);
+
+bool dPhi(
+    const xAOD::TauJet &tau, const xAOD::CaloVertexedTopoCluster &cluster, double &out);
+
+bool SECOND_R(
+    const xAOD::TauJet &tau, const xAOD::CaloVertexedTopoCluster &cluster, double &out);
+
+bool SECOND_LAMBDA(
+    const xAOD::TauJet &tau, const xAOD::CaloVertexedTopoCluster &cluster, double &out);
+
+bool CENTER_LAMBDA(
+    const xAOD::TauJet &tau, const xAOD::CaloVertexedTopoCluster &cluster, double &out);
+
+bool SECOND_LAMBDAOverClustersMeanSecondLambda(
+    const xAOD::TauJet &tau, const xAOD::CaloVertexedTopoCluster &cluster, double &out);
+
+bool CENTER_LAMBDAOverClustersMeanCenterLambda(
+    const xAOD::TauJet &tau, const xAOD::CaloVertexedTopoCluster &cluster, double &out);
+
+bool FirstEngDensOverClustersMeanFirstEngDens(
+    const xAOD::TauJet &tau, const xAOD::CaloVertexedTopoCluster &cluster, double &out);
+
+//Extension - Variables for GNTau
+bool e(
+    const xAOD::TauJet &tau, const xAOD::CaloVertexedTopoCluster &cluster, double &out);
+
+bool et(
+    const xAOD::TauJet &tau, const xAOD::CaloVertexedTopoCluster &cluster, double &out);
+
+bool FIRST_ENG_DENS(
+    const xAOD::TauJet &tau, const xAOD::CaloVertexedTopoCluster &cluster, double &out);
+
+bool EM_PROBABILITY(
+    const xAOD::TauJet &tau, const xAOD::CaloVertexedTopoCluster &cluster, double &out);
+
+bool CENTER_MAG(
+    const xAOD::TauJet &tau, const xAOD::CaloVertexedTopoCluster &cluster, double &out);
+} // namespace Cluster
+} // namespace Variables
+} // namespace TauJetGNNUtils
+
+#endif // TAURECTOOLS_TAUGNNUTILS_H