LundJetOnnxAlg Class Reference

#include <LundJetOnnxAlg.h>

Inheritance diagram for LundJetOnnxAlg:

Collaboration diagram for LundJetOnnxAlg:

Public Member Functions
virtual StatusCode	initialize () override
virtual StatusCode	execute (const EventContext &ctx) const override
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual bool	isClonable () const override
	Specify if the algorithm is clonable.
virtual unsigned int	cardinality () const override
	Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.
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
virtual void	setFilterPassed (bool state, const EventContext &ctx) const
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
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
bool	buildOnnxInputs (const xAOD::Jet &jet, std::vector< float > &out_x_float, std::vector< int64_t > &out_edge_index_int64, std::vector< int64_t > &out_batch_int64, std::vector< int64_t > &out_counts_int64, std::vector< float > &out_Ntrk_float) const
	Helper to build ONNX inputs (batch_size=1)
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
Gaudi::Property< std::string >	m_inputJetContainer
Gaudi::Property< std::string >	m_prefix
Gaudi::Property< float >	m_kTSelection
Gaudi::Property< std::string >	m_scoreName
Gaudi::Property< int >	m_expectedBatchSize
SG::WriteDecorHandleKey< xAOD::JetContainer >	m_validDecorKey
SG::WriteDecorHandleKey< xAOD::JetContainer >	m_scoreDecorKey
Gaudi::Property< float >	m_mean_z { this, "MeanZ", 2.0568479032747313f, "mean z (for normalization)" }
Gaudi::Property< float >	m_std_z { this, "StdZ", 1.4450598054504056f, "std z (for normalization)" }
Gaudi::Property< float >	m_mean_dr { this, "MeanDR", 3.8597358364389427f, "mean dr (for normalization)" }
Gaudi::Property< float >	m_std_dr { this, "StdDR", 2.2748462855901073f, "std dr (for normalization)" }
Gaudi::Property< float >	m_mean_kt { this, "MeanKT", -2.379904791478249f, "mean kt (for normalization)" }
Gaudi::Property< float >	m_std_kt { this, "StdKT", 2.940813577366582f, "std kt (for normalization)" }
Gaudi::Property< float >	m_mean_ntrk { this, "MeanNtrk", 57.588158609500134f, "mean Ntrk" }
Gaudi::Property< float >	m_std_ntrk { this, "StdNtrk", 23.900100132781983f, "std Ntrk" }
std::string	m_resolvedModelPath
Gaudi::Property< std::string >	m_modelPath
std::unique_ptr< Ort::Env >	m_env
std::unique_ptr< Ort::Session >	m_session
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 24 of file LundJetOnnxAlg.h.

Member Typedef Documentation

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Function Documentation

buildOnnxInputs()

bool LundJetOnnxAlg::buildOnnxInputs ( const xAOD::Jet & jet, std::vector< float > & out_x_float, std::vector< int64_t > & out_edge_index_int64, std::vector< int64_t > & out_batch_int64, std::vector< int64_t > & out_counts_int64, std::vector< float > & out_Ntrk_float ) const

private

Helper to build ONNX inputs (batch_size=1)

Definition at line 255 of file LundJetOnnxAlg.cxx.

                                                                             {
  // Clear outputs
  out_x_float.clear();
  out_edge_index_int64.clear();
  out_batch_int64.clear();
  out_counts_int64.clear();
  out_Ntrk_float.clear();
 
  auto tryGetVectorFloat = [&](const std::string& baseName, std::vector<float>& out)->bool {
    std::string withPref = m_prefix.value() + baseName;
    if (jet.getAttribute(withPref, out)) {
      ATH_MSG_DEBUG("Found attribute: " << withPref << " (used)");
      return true;
    }
    if (jet.getAttribute(baseName, out)) {
      ATH_MSG_DEBUG("Found attribute: " << baseName << " (used)");
      return true;
    }
    ATH_MSG_DEBUG("Attribute not found: " << withPref << " nor " << baseName);
    return false;
  };
 
  auto tryGetVectorInt = [&](const std::string& baseName, std::vector<int>& out)->bool {
    std::string withPref = m_prefix.value() + baseName;
    if (jet.getAttribute(withPref, out)) {
      ATH_MSG_DEBUG("Found attribute: " << withPref << " (used)");
      return true;
    }
    if (jet.getAttribute(baseName, out)) {
      ATH_MSG_DEBUG("Found attribute: " << baseName << " (used)");
      return true;
    }
    ATH_MSG_DEBUG("Attribute not found: " << withPref << " nor " << baseName);
    return false;
  };
 
  auto tryGetInt = [&](const std::string& baseName, int& out)->bool {
    std::string withPref = m_prefix.value() + baseName;
    if (jet.getAttribute(withPref, out)) {
      ATH_MSG_DEBUG("Found attribute: " << withPref << " (used)");
      return true;
    }
    if (jet.getAttribute(baseName, out)) {
      ATH_MSG_DEBUG("Found attribute: " << baseName << " (used)");
      return true;
    }
    ATH_MSG_DEBUG("Attribute not found: " << withPref << " nor " << baseName);
    return false;
  };
 
  // Read Lund decorations (try prefixed and unprefixed names)
  std::vector<float> lnR, lnkT, z;
  std::vector<int> idp1, idp2;
  int nSplits = 0;
 
  bool ok_lnR  = tryGetVectorFloat("LundAllLnR", lnR);
  bool ok_lnkT = tryGetVectorFloat("LundAllLnKT", lnkT);
  bool ok_z    = tryGetVectorFloat("LundAllZ", z);
  bool ok_idp1 = tryGetVectorInt("LundAllIDP1", idp1);
  bool ok_idp2 = tryGetVectorInt("LundAllIDP2", idp2);
  bool ok_nsp  = tryGetInt("nSplits", nSplits);
 
  if (!(ok_lnR && ok_lnkT && ok_z && ok_idp1 && ok_idp2 && ok_nsp)) {
    ATH_MSG_DEBUG("Missing one or more Lund decorations (lnR/lnkT/z/idp1/idp2/nSplits). Aborting build.");
    return false;
  }
 
  size_t n_nodes = lnR.size();
  if (n_nodes == 0) {
    ATH_MSG_DEBUG("Lund decorations present but zero-length vectors.");
    return false;
  }
 
  // Determine Ntrk: try various attribute names (try prefixed first, then unprefixed)
  float ntrk_f = 0.f;
  int tmp_ntrk_i = 0;
  bool gotNtrk = false;
  // Candidate names commonly used
  std::vector<std::string> ntrkCandidates = { "LRJ_Nconst_Charged", "nTrk", "Ntrk", "NTracks" };
  for (auto &cand : ntrkCandidates) {
    std::string withPref = m_prefix.value() + cand;
    if (jet.getAttribute(withPref, tmp_ntrk_i)) { ntrk_f = static_cast<float>(tmp_ntrk_i); gotNtrk = true; ATH_MSG_DEBUG("Using Ntrk attr: " << withPref); break; }
    if (jet.getAttribute(cand, tmp_ntrk_i)) { ntrk_f = static_cast<float>(tmp_ntrk_i); gotNtrk = true; ATH_MSG_DEBUG("Using Ntrk attr: " << cand); break; }
  }
  if (!gotNtrk) {
    const auto & links = jet.constituentLinks();
    for (size_t i = 0; i < jet.numConstituents(); ++i) {
      const xAOD::IParticle* p = *links[i];
      const xAOD::FlowElement* fe = dynamic_cast<const xAOD::FlowElement*>(p);
      if (fe && fe->isCharged()) ntrk_f += 1.f;
    }
    ATH_MSG_DEBUG("Computed Ntrk from constituents: " << ntrk_f);
  }
 
  // Build node mask based on kTSelection.
  // m_kTSelection is a Gaudi Property<float> — get the value for comparison.
  float kTsel_val = m_kTSelection;
  float ln_kTcut = (kTsel_val > 0.f) ? std::log(std::max(1e-12f, kTsel_val)) : -1e9f;
 
  std::vector<char> mask(n_nodes, 0);
  size_t n_selected = 0;
  for (size_t i = 0; i < n_nodes; ++i) {
    float lnk = lnkT[i];
    if (lnk > ln_kTcut) { mask[i] = 1; ++n_selected; }
    else mask[i] = 0;
  }
 
  if (n_selected < 1) {
    ATH_MSG_DEBUG("No nodes passed kT selection (n_selected=" << n_selected << ").");
    return false;
  }
 
  // Build feature matrix x: [ln(1/dR), ln(kt), ln(1/z)] then standardize
  out_x_float.reserve(n_selected * 3);
  for (size_t i = 0; i < n_nodes; ++i) {
    if (!mask[i]) continue;
    float f_ln1overdR = lnR[i];
    float f_lnkT = lnkT[i];
    float zval = std::max(1e-6f, z[i]);
    float f_ln1overz = -std::log(zval);
 
    float z_std = (f_ln1overz - m_mean_z) / m_std_z;
    float kt_std = (f_lnkT - m_mean_kt) / m_std_kt;
    float dr_std = (f_ln1overdR - m_mean_dr) / m_std_dr;
 
    out_x_float.push_back(dr_std);
    out_x_float.push_back(kt_std);
    out_x_float.push_back(z_std);
  }
 
  // Reindex old->new for masked nodes
  std::vector<int> old2new(n_nodes, -1);
  int new_idx = 0;
  for (size_t i = 0; i < n_nodes; ++i) {
    if (mask[i]) old2new[i] = new_idx++;
  }
 
  // Build edges (only include edges where both endpoints survive)
  for (size_t child = 0; child < n_nodes; ++child) {
    if (!mask[child]) continue;
    int p1 = (child < idp1.size()) ? idp1[child] : -1;
    int p2 = (child < idp2.size()) ? idp2[child] : -1;
    if (p1 >= 0 && p1 < static_cast<int>(n_nodes) && old2new[p1] >= 0) {
      out_edge_index_int64.push_back(static_cast<int64_t>(old2new[p1]));
      out_edge_index_int64.push_back(static_cast<int64_t>(old2new[child]));
      // optionally also add reverse if model expects undirected edges (you did both)
      out_edge_index_int64.push_back(static_cast<int64_t>(old2new[child]));
      out_edge_index_int64.push_back(static_cast<int64_t>(old2new[p1]));
    }
    if (p2 >= 0 && p2 < static_cast<int>(n_nodes) && old2new[p2] >= 0) {
      out_edge_index_int64.push_back(static_cast<int64_t>(old2new[p2]));
      out_edge_index_int64.push_back(static_cast<int64_t>(old2new[child]));
      out_edge_index_int64.push_back(static_cast<int64_t>(old2new[child]));
      out_edge_index_int64.push_back(static_cast<int64_t>(old2new[p2]));
    }
  }
 
  // batch vector: all nodes belong to graph 0
  for (int64_t i = 0; i < new_idx; ++i) out_batch_int64.push_back(0);
 
  // counts: [num_nodes_selected]
  out_counts_int64.push_back(static_cast<int64_t>(new_idx));
 
  // Ntrk: normalize as in Python
  float ntrk_std = (ntrk_f - m_mean_ntrk) / m_std_ntrk;
  //out_Ntrk_float.push_back(ntrk_std);
  const int64_t batch_size = m_expectedBatchSize; // Gaudi::Property
  out_Ntrk_float.reserve(batch_size);
  for (int64_t i = 0; i < batch_size; ++i) {
    out_Ntrk_float.push_back(ntrk_std);
  }
  // Final sanity checks
  if (out_x_float.empty() || out_counts_int64.empty()) {
    ATH_MSG_DEBUG("After masking, nothing to evaluate.");
    return false;
  }
 
  ATH_MSG_DEBUG("Built ONNX input: nodes=" << new_idx
                << " edges=" << (out_edge_index_int64.size()/2)
                << " ntrk=" << ntrk_f);
 
  return true;
}

cardinality()

unsigned int AthCommonReentrantAlgorithm< Gaudi::Algorithm >::cardinality ( ) const

overridevirtualinherited

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

Override this to return 0 for reentrant algorithms.

Definition at line 75 of file AthCommonReentrantAlgorithm.cxx.

{
  return 0;
}

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; }

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 LundJetOnnxAlg::execute ( const EventContext & ctx ) const

overridevirtual

Definition at line 89 of file LundJetOnnxAlg.cxx.

                                                                {
 
  SG::ReadHandle<xAOD::JetContainer> jets(m_inputJetContainer, ctx);
  if (!jets.isValid()) {
    ATH_MSG_ERROR("Failed to retrieve JetContainer: " << m_inputJetContainer);
    return StatusCode::FAILURE;
  }
 
  SG::WriteDecorHandle<xAOD::JetContainer, float> scoreDecor(m_scoreDecorKey, ctx);
  SG::WriteDecorHandle<xAOD::JetContainer, char> validDecor(m_validDecorKey, ctx);
  // ONNX helpers
  Ort::AllocatorWithDefaultOptions allocator;
  auto memory_info =
    Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault);
 
  for (const xAOD::Jet* jptr : *jets) {
 
    const xAOD::Jet& jet = *jptr;
 
    validDecor(*jptr) = 0;
    // ---------------------------
    // Build inputs
    // ---------------------------
    std::vector<float>   x_flat;              // [num_nodes * 3]
    std::vector<int64_t> edge_index_flat;     // [2 * num_edges]
    std::vector<int64_t> batch_vec;            // [num_nodes]
    std::vector<int64_t> counts_vec;           // unused but kept
    std::vector<float>   Ntrk_vec;             // [1]
 
    bool ok = buildOnnxInputs(
                  jet, x_flat, edge_index_flat, batch_vec, counts_vec, Ntrk_vec
                  );
 
    if (!ok) {
      ATH_MSG_DEBUG("Skipping jet: couldn't build inputs");
      continue;
    }
 
    const int64_t num_nodes = batch_vec.size();
 
    if (num_nodes == 0 || x_flat.size() != static_cast<size_t>(num_nodes * 3)) {
      ATH_MSG_WARNING("Inconsistent node inputs");
      continue;
    }
 
    // ---------------------------
    // Create ONNX tensors
    // ---------------------------
    const int64_t min_nodes = 2;
 
    if (num_nodes < min_nodes) {
      ATH_MSG_DEBUG("Skipping jet: num_nodes < 2");
      continue;
    }
    
    const int64_t num_edges = edge_index_flat.size() / 2;
    if (num_edges < 1) {
      ATH_MSG_DEBUG("Skipping jet: no edges in graph");
      continue;
    }
    
    // x : [num_nodes, 3]
    std::vector<int64_t> x_shape = { num_nodes, 3 };
    Ort::Value x_tensor =
      Ort::Value::CreateTensor<float>(
                      memory_info,
                      x_flat.data(),
                      x_flat.size(),
                      x_shape.data(),
                      x_shape.size()
                      );
 
    // edge_index : [2, num_edges]
    std::vector<int64_t> ei_shape = {
      2,
      static_cast<int64_t>(edge_index_flat.size() / 2)
    };
    Ort::Value edge_tensor =
      Ort::Value::CreateTensor<int64_t>(
                    memory_info,
                    edge_index_flat.data(),
                    edge_index_flat.size(),
                    ei_shape.data(),
                    ei_shape.size()
                    );
 
    // batch : [num_nodes]
    std::vector<int64_t> batch_shape = { num_nodes };
    Ort::Value batch_tensor =
      Ort::Value::CreateTensor<int64_t>(
                    memory_info,
                    batch_vec.data(),
                    batch_vec.size(),
                    batch_shape.data(),
                    batch_shape.size()
                    );
 
    // Ntrk : [batch_size]
    std::vector<int64_t> ntrk_shape = {static_cast<int64_t>(Ntrk_vec.size())};
    Ort::Value ntrk_tensor =
      Ort::Value::CreateTensor<float>(
                      memory_info,
                      Ntrk_vec.data(),
                      Ntrk_vec.size(),
                      ntrk_shape.data(),
                      ntrk_shape.size()
                      );
    std::array<Ort::Value, 4> input_tensors = {
      std::move(x_tensor),
      std::move(edge_tensor),
      std::move(batch_tensor),
      std::move(ntrk_tensor)
    };
 
    std::array<const char*, 4> input_names = {
      "x",
      "edge_index",
      "batch",
      "Ntrk"
    };
 
    std::array<const char*, 1> output_names = {
      "output"
    };
 
    // ---------------------------
    // Run inference
    // ---------------------------
    std::vector<Ort::Value> output_tensors;
    try {
      output_tensors = m_session->Run(
                      Ort::RunOptions{nullptr},
                      input_names.data(),
                      input_tensors.data(),
                      input_tensors.size(),
                      output_names.data(),
                      output_names.size()
                      );
    }
    catch (const Ort::Exception& e) {
      ATH_MSG_ERROR("ONNX Runtime exception: " << e.what());
      continue;
    }
 
    // ---------------------------
    // Read output
    // ---------------------------
    if (output_tensors.empty() || !output_tensors.front().IsTensor()) {
      ATH_MSG_WARNING("Invalid output tensor");
      //scoreDecor(*jptr) = -999.f;
      continue;
    }
 
    float* out_data =
      output_tensors.front().GetTensorMutableData<float>();
 
    float score = out_data[0]; // shape [-1,1], batch=1
 
    scoreDecor(*jptr) = score;
    validDecor(*jptr) = 1;
    
    ATH_MSG_DEBUG("Jet decorated with LundNet score = " << score);
  }
 
  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 & AthCommonReentrantAlgorithm< 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 94 of file AthCommonReentrantAlgorithm.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();
}

filterPassed()

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

inlinevirtualinherited

Definition at line 96 of file AthCommonReentrantAlgorithm.h.

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

initialize()

StatusCode LundJetOnnxAlg::initialize ( )

overridevirtual

Definition at line 25 of file LundJetOnnxAlg.cxx.

                                      {
 
  ATH_MSG_INFO("Initializing LundJetOnnxAlg");
 
  ATH_MSG_INFO("Loading ONNX model from: " << m_modelPath);
  // -------------------------
  // Create ONNX Runtime session
  // -------------------------
  Ort::SessionOptions sessionOptions;
  sessionOptions.SetIntraOpNumThreads(1);
  sessionOptions.SetGraphOptimizationLevel(ORT_ENABLE_BASIC);
 
  // Recommended in Athena to reduce memory usage
  sessionOptions.DisableCpuMemArena();
 
  m_env = std::make_unique<Ort::Env>(
    ORT_LOGGING_LEVEL_WARNING,
    "LundNetGNN"
  );
  m_resolvedModelPath =
    PathResolver::find_file(m_modelPath, "DATAPATH");
 
  if (m_resolvedModelPath.empty()) {
    ATH_MSG_ERROR("Could not resolve ONNX model path: " << m_modelPath);
    return StatusCode::FAILURE;
  }
  
  try {
    m_session = std::make_unique<Ort::Session>(
                           *m_env,
                           m_resolvedModelPath.c_str(),   // ← ahora es estable
                           sessionOptions
                           );
  } catch (const Ort::Exception& e) {
    ATH_MSG_ERROR("Failed to create ONNX Runtime session: " << e.what());
    return StatusCode::FAILURE;
  }
 
  ATH_MSG_INFO("ONNX Runtime session successfully created");
 
  // -------------------------
  // Decorations
  // -------------------------
  ATH_MSG_INFO("InputJetContainer: " << m_inputJetContainer);
  ATH_MSG_INFO("Prefix: '" << m_prefix << "'");
  ATH_MSG_INFO("kT selection: " << m_kTSelection);
  std::string decorFull =
    m_inputJetContainer.value() + "." +
    m_prefix.value() +
    m_scoreName.value();
  std::string validDecorFull =
    m_inputJetContainer.value() + "." +
    m_prefix.value() +
    "LundNetValid";
  
  m_scoreDecorKey = decorFull;
  m_validDecorKey = validDecorFull;
  ATH_CHECK(m_scoreDecorKey.initialize());
  ATH_CHECK(m_validDecorKey.initialize());
  ATH_MSG_INFO("Will write decoration: " << decorFull);
 
  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.

isClonable()

bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::isClonable ( ) const

overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

Reimplemented in InDet::GNNSeedingTrackMaker, InDet::SCT_Clusterization, InDet::SiSPGNNTrackMaker, InDet::SiSPSeededTrackFinder, InDet::SiTrackerSpacePointFinder, ITkPixelCablingAlg, ITkStripCablingAlg, RoIBResultToxAOD, SCT_ByteStreamErrorsTestAlg, SCT_CablingCondAlgFromCoraCool, SCT_CablingCondAlgFromText, SCT_ConditionsParameterTestAlg, SCT_ConditionsSummaryTestAlg, SCT_ConfigurationConditionsTestAlg, 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, and Simulation::BeamEffectsAlg.

Definition at line 68 of file AthCommonReentrantAlgorithm.cxx.

{
  // Reentrant algorithms are clonable.
  return true;
}

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);
  }

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.

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();
  }

setFilterPassed()

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

inlinevirtualinherited

Definition at line 100 of file AthCommonReentrantAlgorithm.h.

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

sysExecute()

StatusCode AthCommonReentrantAlgorithm< 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.

Definition at line 85 of file AthCommonReentrantAlgorithm.cxx.

{
  return BaseAlg::sysExecute (ctx);
}

sysInitialize()

StatusCode AthCommonReentrantAlgorithm< 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 HypoBase, and InputMakerBase.

Definition at line 61 of file AthCommonReentrantAlgorithm.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.

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_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_env

std::unique_ptr<Ort::Env> LundJetOnnxAlg::m_env

private

Definition at line 79 of file LundJetOnnxAlg.h.

m_evtStore

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

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_expectedBatchSize

Gaudi::Property<int> LundJetOnnxAlg::m_expectedBatchSize

private

Initial value:

{
    this,
    "ExpectedBatchSize",
    1,
    "Batch size expected by the ONNX model (from training/export)"
  }

Definition at line 50 of file LundJetOnnxAlg.h.

                                        {
    this,
    "ExpectedBatchSize",
    1,
    "Batch size expected by the ONNX model (from training/export)"
  };

m_extendedExtraObjects

DataObjIDColl AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects

privateinherited

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

Empty if no symlinks were found.

Definition at line 114 of file AthCommonReentrantAlgorithm.h.

m_inputJetContainer

Gaudi::Property<std::string> LundJetOnnxAlg::m_inputJetContainer

private

Initial value:

{
    this, "InputJetContainer", "AntiKt10UFO",
    "Name of input jet container"
  }

Definition at line 32 of file LundJetOnnxAlg.h.

                                              {
    this, "InputJetContainer", "AntiKt10UFO",
    "Name of input jet container"
  };

m_kTSelection

Gaudi::Property<float> LundJetOnnxAlg::m_kTSelection

private

Initial value:

{
    this, "kTSelection", -1000.f,
    "kT cut to apply (same meaning as kT_Cut in python loader)"
  }

Definition at line 40 of file LundJetOnnxAlg.h.

                                    {
    this, "kTSelection", -1000.f,
    "kT cut to apply (same meaning as kT_Cut in python loader)"
  };

m_mean_dr

Gaudi::Property<float> LundJetOnnxAlg::m_mean_dr { this, "MeanDR", 3.8597358364389427f, "mean dr (for normalization)" }

private

Definition at line 66 of file LundJetOnnxAlg.h.

{ this, "MeanDR", 3.8597358364389427f, "mean dr (for normalization)" };

m_mean_kt

Gaudi::Property<float> LundJetOnnxAlg::m_mean_kt { this, "MeanKT", -2.379904791478249f, "mean kt (for normalization)" }

private

Definition at line 68 of file LundJetOnnxAlg.h.

{ this, "MeanKT", -2.379904791478249f, "mean kt (for normalization)" };

m_mean_ntrk

Gaudi::Property<float> LundJetOnnxAlg::m_mean_ntrk { this, "MeanNtrk", 57.588158609500134f, "mean Ntrk" }

private

Definition at line 70 of file LundJetOnnxAlg.h.

{ this, "MeanNtrk", 57.588158609500134f, "mean Ntrk" };

m_mean_z

Gaudi::Property<float> LundJetOnnxAlg::m_mean_z { this, "MeanZ", 2.0568479032747313f, "mean z (for normalization)" }

private

Definition at line 64 of file LundJetOnnxAlg.h.

{ this, "MeanZ", 2.0568479032747313f, "mean z (for normalization)" };

m_modelPath

Gaudi::Property<std::string> LundJetOnnxAlg::m_modelPath

private

Initial value:

{
      this,
      "ModelPath",
      "",
      "Path to the ONNX model"
    }

Definition at line 73 of file LundJetOnnxAlg.h.

                                      {
      this,
      "ModelPath",
      "",
      "Path to the ONNX model"
    };

m_prefix

Gaudi::Property<std::string> LundJetOnnxAlg::m_prefix

private

Initial value:

{
    this, "Prefix", "",
    "Prefix used by LundVariablesTool decorations"
  }

Definition at line 36 of file LundJetOnnxAlg.h.

                                   {
    this, "Prefix", "",
    "Prefix used by LundVariablesTool decorations"
  };

m_resolvedModelPath

std::string LundJetOnnxAlg::m_resolvedModelPath

private

Definition at line 72 of file LundJetOnnxAlg.h.

m_scoreDecorKey

SG::WriteDecorHandleKey<xAOD::JetContainer> LundJetOnnxAlg::m_scoreDecorKey

private

Initial value:

{
    this, "ScoreDecorKey", "", "Score decoration key"
  }

Definition at line 60 of file LundJetOnnxAlg.h.

                                                         {
    this, "ScoreDecorKey", "", "Score decoration key"
  };

m_scoreName

Gaudi::Property<std::string> LundJetOnnxAlg::m_scoreName

private

Initial value:

{
    this, "ScoreDecoration", "LundNetScore",
    "Name of the decoration (without container prefix). Final decoration will be <container>.<prefix><ScoreDecoration>"
  }

Definition at line 45 of file LundJetOnnxAlg.h.

                                      {
    this, "ScoreDecoration", "LundNetScore",
    "Name of the decoration (without container prefix). Final decoration will be <container>.<prefix><ScoreDecoration>"
  };

m_session

std::unique_ptr<Ort::Session> LundJetOnnxAlg::m_session

private

Definition at line 80 of file LundJetOnnxAlg.h.

m_std_dr

Gaudi::Property<float> LundJetOnnxAlg::m_std_dr { this, "StdDR", 2.2748462855901073f, "std dr (for normalization)" }

private

Definition at line 67 of file LundJetOnnxAlg.h.

{ this, "StdDR", 2.2748462855901073f, "std dr (for normalization)" };

m_std_kt

Gaudi::Property<float> LundJetOnnxAlg::m_std_kt { this, "StdKT", 2.940813577366582f, "std kt (for normalization)" }

private

Definition at line 69 of file LundJetOnnxAlg.h.

{ this, "StdKT", 2.940813577366582f, "std kt (for normalization)" };

m_std_ntrk

Gaudi::Property<float> LundJetOnnxAlg::m_std_ntrk { this, "StdNtrk", 23.900100132781983f, "std Ntrk" }

private

Definition at line 71 of file LundJetOnnxAlg.h.

{ this, "StdNtrk", 23.900100132781983f, "std Ntrk" };

m_std_z

Gaudi::Property<float> LundJetOnnxAlg::m_std_z { this, "StdZ", 1.4450598054504056f, "std z (for normalization)" }

private

Definition at line 65 of file LundJetOnnxAlg.h.

{ this, "StdZ", 1.4450598054504056f, "std z (for normalization)" };

m_validDecorKey

SG::WriteDecorHandleKey<xAOD::JetContainer> LundJetOnnxAlg::m_validDecorKey

private

Initial value:

{
    this, "ValidDecor", "", "Valid LundNet inference"
  }

Definition at line 56 of file LundJetOnnxAlg.h.

                                                         {
    this, "ValidDecor", "", "Valid LundNet inference"
  };

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:

• LundJetOnnxAlg.h
• LundJetOnnxAlg.cxx