Loading [MathJax]/extensions/tex2jax.js
ATLAS Offline Software
All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
JSSMLTool.cxx
Go to the documentation of this file.
1 // Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
2 
3 // Local include(s).
5 
6 // Framework include(s).
8 
9 // ROOT includes
10 #include "TSystem.h"
11 #include "TH2D.h"
12 
13 namespace AthONNX {
14 
15  //*******************************************************************
16  // for reading jet images
17  std::vector<float> JSSMLTool::ReadJetImagePixels( std::vector<TH2D> Images ) const //function to load test images
18  {
19 
20  int n_rows = m_nPixelsX;
21  int n_cols = m_nPixelsY;
22  int n_colors = m_nPixelsZ;
23 
24  std::vector<float> input_tensor_values(n_rows*n_cols*n_colors);
25 
26  for(int iRow=0; iRow<n_rows; ++iRow){
27  for(int iColumn=0; iColumn<n_cols; ++iColumn){
28  for(int iColor=0; iColor<n_colors; ++iColor){
29  input_tensor_values[ (n_colors*n_cols*iRow) + iColumn*n_colors + iColor] = Images[iColor].GetBinContent(iRow+1, iColumn+1);
30  }
31  }
32  }
33 
34  return input_tensor_values;
35  }
36 
37  //********************************************************************************
38  // for reading DNN inputs
39  std::vector<float> JSSMLTool::ReadJSSInputs(std::map<std::string, double> JSSVars) const //function to load test images
40  {
41 
42  std::vector<float> input_tensor_values(m_nvars);
43 
44  // apply features scaling
45  for(const auto & var : JSSVars){
46  double mean = m_scaler.find(var.first)->second[0];
47  double std = m_scaler.find(var.first)->second[1];
48  JSSVars[var.first] = (var.second - mean) / std;
49  }
50 
51  // then dump it to a vector
52  for(int v=0; v<m_nvars; ++v){
53  std::string name = m_JSSInputMap.find(v)->second;
54  input_tensor_values[v] = JSSVars[name];
55  }
56 
57  return input_tensor_values;
58  }
59 
60  //********************************************************************************
61  // for reading jet labels for DNN
62  // this can be extended in case of multi-class models
63  std::vector<int> JSSMLTool::ReadOutputLabels() const
64  {
65  std::vector<int> output_tensor_values(1);
66 
67  output_tensor_values[0] = 1;
68 
69  return output_tensor_values;
70  }
71 
72  // constructor ---
73  JSSMLTool::JSSMLTool(const std::string& name):
74  AsgTool(name)
75  {
76  declareProperty("ModelPath", m_modelFileName);
77  declareProperty("nPixelsX", m_nPixelsX);
78  declareProperty("nPixelsY", m_nPixelsY);
79  declareProperty("nPixelsZ", m_nPixelsZ);
80  }
81 
82  // initialize ---
84 
85  // Access the service.
86  // Find the model file.
87  ATH_MSG_INFO( "Using model file: " << m_modelFileName );
88 
89  // Set up the ONNX Runtime session.
90  Ort::SessionOptions sessionOptions;
91  sessionOptions.SetIntraOpNumThreads( 1 );
92  sessionOptions.SetGraphOptimizationLevel( ORT_ENABLE_BASIC );
93  Ort::AllocatorWithDefaultOptions allocator;
94  m_env = std::make_unique< Ort::Env >(ORT_LOGGING_LEVEL_WARNING, "");
95  m_session = std::make_unique< Ort::Session >( *m_env,
96  m_modelFileName.c_str(),
97  sessionOptions );
98 
99  ATH_MSG_INFO( "Created the ONNX Runtime session" );
100 
101  m_num_input_nodes = m_session->GetInputCount();
103 
104  for( std::size_t i = 0; i < m_num_input_nodes; i++ ) {
105  // print input node names
106  char* input_name = m_session->GetInputNameAllocated(i, allocator).release();
107  ATH_MSG_DEBUG("Input "<<i<<" : "<<" name = "<<input_name);
108  m_input_node_names[i] = input_name;
109  // print input node types
110  Ort::TypeInfo type_info = m_session->GetInputTypeInfo(i);
111  auto tensor_info = type_info.GetTensorTypeAndShapeInfo();
112  ONNXTensorElementDataType type = tensor_info.GetElementType();
113  ATH_MSG_DEBUG("Input "<<i<<" : "<<" type = "<<type);
114 
115  // print input shapes/dims
116  m_input_node_dims = tensor_info.GetShape();
117  ATH_MSG_DEBUG("Input "<<i<<" : num_dims = "<<m_input_node_dims.size());
118  for (std::size_t j = 0; j < m_input_node_dims.size(); j++){
119  if(m_input_node_dims[j]<0)
120  m_input_node_dims[j] =1;
121  ATH_MSG_DEBUG("Input"<<i<<" : dim "<<j<<" = "<<m_input_node_dims[j]);
122  }
123  }
124 
125  m_num_output_nodes = m_session->GetOutputCount();
127 
128  for( std::size_t i = 0; i < m_num_output_nodes; i++ ) {
129  // print output node names
130  char* output_name = m_session->GetOutputNameAllocated(i, allocator).release();
131  ATH_MSG_DEBUG("Output "<<i<<" : "<<" name = "<<output_name);
132  m_output_node_names[i] = output_name;
133 
134  Ort::TypeInfo type_info = m_session->GetOutputTypeInfo(i);
135  auto tensor_info = type_info.GetTensorTypeAndShapeInfo();
136  ONNXTensorElementDataType type = tensor_info.GetElementType();
137  ATH_MSG_DEBUG("Output "<<i<<" : "<<" type = "<<type);
138 
139  // print output shapes/dims
140  m_output_node_dims = tensor_info.GetShape();
141  ATH_MSG_INFO("Output "<<i<<" : num_dims = "<<m_output_node_dims.size());
142  for (std::size_t j = 0; j < m_output_node_dims.size(); j++){
143  if(m_output_node_dims[j]<0)
144  m_output_node_dims[j] =1;
145  ATH_MSG_INFO("Output"<<i<<" : dim "<<j<<" = "<<m_output_node_dims[j]);
146  }
147  }
148 
149  // Return gracefully.
150  return StatusCode::SUCCESS;
151  } // end initialize ---
152 
153  // constituents image based
154  double JSSMLTool::retrieveConstituentsScore(std::vector<TH2D> Images) const {
155 
156  //*************************************************************************
157  // Score the model using sample data, and inspect values
158 
159  // preparing container to hold input data
160  size_t input_tensor_size = m_nPixelsX*m_nPixelsY*m_nPixelsZ;
161  std::vector<float> input_tensor_values(input_tensor_size);
162 
163  // loading input data
164  input_tensor_values = ReadJetImagePixels(Images);
165 
166  // preparing container to hold output data
167  int testSample = 0;
168  std::vector<int> output_tensor_values_ = ReadOutputLabels();
169  int output_tensor_values = output_tensor_values_[testSample];
170 
171  // create input tensor object from data values
172  auto memory_info = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault);
173  Ort::Value input_tensor = Ort::Value::CreateTensor<float>(memory_info, input_tensor_values.data(), input_tensor_size, m_input_node_dims.data(), m_input_node_dims.size());
174  assert(input_tensor.IsTensor());
175 
176  auto output_tensors = m_session->Run(Ort::RunOptions{nullptr}, m_input_node_names.data(), &input_tensor, m_input_node_names.size(), m_output_node_names.data(), m_output_node_names.size());
177  assert(output_tensors.size() == 1 && output_tensors.front().IsTensor());
178 
179  // Get pointer to output tensor float values
180  float* floatarr = output_tensors.front().GetTensorMutableData<float>();
181  int arrSize = sizeof(*floatarr)/sizeof(floatarr[0]);
182 
183  // show true label for the test input
184  ATH_MSG_DEBUG("Label for the input test data = "<<output_tensor_values);
185  float ConstScore = -999;
186  int max_index = 0;
187  for (int i = 0; i < arrSize; i++){
188  ATH_MSG_VERBOSE("Score for class "<<i<<" = "<<floatarr[i]<<std::endl);
189  if (ConstScore<floatarr[i]){
190  ConstScore = floatarr[i];
191  max_index = i;
192  }
193  }
194  ATH_MSG_DEBUG("Class: "<<max_index<<" has the highest score: "<<floatarr[max_index]);
195 
196  return ConstScore;
197 
198  } // end retrieve CNN score ----
199 
200  // constituents transformer based
201  double JSSMLTool::retrieveConstituentsScore(std::vector<std::vector<float>> constituents) const {
202 
203  // the format of the packed constituents is:
204  // constituents.size() ---> 4, for example, (m pT, eta, phi)
205  // constituents.at(0) ---> number of constituents
206  // the packing can be done for any kind of low level inputs
207  // i.e. PFO/UFO constituents, topo-towers, tracks, etc
208  // they can be concatened one after the other in case of multiple inputs
209 
210  //*************************************************************************
211  // Score the model using sample data, and inspect values
212  // loading input data
213 
214  std::vector<int> output_tensor_values_ = ReadOutputLabels();
215 
216  int testSample = 0;
217 
218  //preparing container to hold output data
219  int output_tensor_values = output_tensor_values_[testSample];
220 
221  // prepare the inputs
222  auto memory_info = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault);
223  std::vector<Ort::Value> input_tensors;
224  for (long unsigned int i=0; i<constituents.size(); i++) {
225 
226  // test
227  std::vector<int64_t> const_dim = {1, static_cast<int64_t>(constituents.at(i).size())};
228 
229  input_tensors.push_back(Ort::Value::CreateTensor<float>(
230  memory_info,
231  constituents.at(i).data(), constituents.at(i).size(), const_dim.data(), const_dim.size()
232  )
233  );
234  }
235 
236  auto output_tensors = m_session->Run(Ort::RunOptions{nullptr}, m_input_node_names.data(), input_tensors.data(), m_input_node_names.size(), m_output_node_names.data(), m_output_node_names.size());
237  assert(output_tensors.size() == 1 && output_tensors.front().IsTensor());
238 
239  // Get pointer to output tensor float values
240  float* floatarr = output_tensors.front().GetTensorMutableData<float>();
241  int arrSize = sizeof(*floatarr)/sizeof(floatarr[0]);
242 
243  // show true label for the test input
244  ATH_MSG_DEBUG("Label for the input test data = "<<output_tensor_values);
245  float ConstScore = -999;
246  int max_index = 0;
247  for (int i = 0; i < arrSize; i++){
248  ATH_MSG_VERBOSE("Score for class "<<i<<" = "<<floatarr[i]<<std::endl);
249  ATH_MSG_VERBOSE(" +++ Score for class "<<i<<" = "<<floatarr[i]<<std::endl);
250  if (ConstScore<floatarr[i]){
251  ConstScore = floatarr[i];
252  max_index = i;
253  }
254  }
255  ATH_MSG_DEBUG("Class: "<<max_index<<" has the highest score: "<<floatarr[max_index]);
256 
257  return ConstScore;
258 
259  } // end retrieve constituents score ----
260 
261  // constituents transformer based with const/inter variables
262  double JSSMLTool::retrieveConstituentsScore(std::vector<std::vector<float>> constituents, std::vector<std::vector<std::vector<float>>> interactions) const {
263 
264  // the format of the constituents/interaction variables is:
265  // constituents ---> (nConstituents + nTowers, 7)
266  // interactions ---> (i, j, 4), with i, j in {nConstituents + nTowers}
267  // the packing can be done for any kind of low level inputs
268  // i.e. PFO/UFO constituents, topo-towers, tracks, etc
269  // they can be concatened one after the other in case of multiple inputs
270 
271  //*************************************************************************
272  // Score the model using sample data, and inspect values
273  // loading input data
274 
275  std::vector<int> output_tensor_values_ = ReadOutputLabels();
276 
277  int testSample = 0;
278 
279  //preparing container to hold output data
280  int output_tensor_values = output_tensor_values_[testSample];
281 
282  // prepare the inputs
283  auto memory_info = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault);
284  std::vector<Ort::Value> input_tensors;
285 
286  // unroll the inputs
287  std::vector<float> constituents_values; //(constituents.size()*7);
288  for (long unsigned int i=0; i<constituents.size(); i++) {
289  for (long unsigned int j=0; j<7; j++) {
290  constituents_values.push_back(constituents.at(i).at(j));
291  }
292  }
293 
294  std::vector<float> interactions_values; //(interactions.size()*interactions.size()*4);
295  for (long unsigned int i=0; i<interactions.size(); i++) {
296  for (long unsigned int k=0; k<interactions.size(); k++) {
297  for (long unsigned int j=0; j<4; j++) {
298  interactions_values.push_back(interactions.at(i).at(k).at(j));
299  }
300  }
301  }
302 
303  std::vector<int64_t> const_dim = {1, static_cast<int64_t>(constituents.size()), 7};
304  input_tensors.push_back(Ort::Value::CreateTensor<float>(
305  memory_info,
306  constituents_values.data(), constituents_values.size(), const_dim.data(), const_dim.size()
307  )
308  );
309 
310  std::vector<int64_t> inter_dim = {1, static_cast<int64_t>(constituents.size()), static_cast<int64_t>(constituents.size()), 4};
311  input_tensors.push_back(Ort::Value::CreateTensor<float>(
312  memory_info,
313  interactions_values.data(), interactions_values.size(), inter_dim.data(), inter_dim.size()
314  )
315  );
316 
317  auto output_tensors = m_session->Run(Ort::RunOptions{nullptr}, m_input_node_names.data(), input_tensors.data(), m_input_node_names.size(), m_output_node_names.data(), m_output_node_names.size());
318  assert(output_tensors.size() == 1 && output_tensors.front().IsTensor());
319 
320  // Get pointer to output tensor float values
321  float* floatarr = output_tensors.front().GetTensorMutableData<float>();
322  int arrSize = sizeof(*floatarr)/sizeof(floatarr[0]);
323 
324  // show true label for the test input
325  ATH_MSG_DEBUG("Label for the input test data = "<<output_tensor_values);
326  float ConstScore = -999;
327  int max_index = 0;
328  for (int i = 0; i < arrSize; i++){
329  ATH_MSG_VERBOSE("Score for class "<<i<<" = "<<floatarr[i]<<std::endl);
330  ATH_MSG_VERBOSE(" +++ Score for class "<<i<<" = "<<floatarr[i]<<std::endl);
331  if (ConstScore<floatarr[i]){
332  ConstScore = floatarr[i];
333  max_index = i;
334  }
335  }
336  ATH_MSG_DEBUG("Class: "<<max_index<<" has the highest score: "<<floatarr[max_index]);
337 
338  return ConstScore;
339 
340  } // end retrieve constituents score ----
341 
342 
343  // dedicated DisCo/DNN method ---
344  double JSSMLTool::retrieveHighLevelScore(std::map<std::string, double> JSSVars) const {
345 
346  //*************************************************************************
347  // Score the model using sample data, and inspect values
348 
349  //preparing container to hold input data
350  size_t input_tensor_size = m_nvars;
351  std::vector<float> input_tensor_values(m_nvars);
352 
353  // loading input data
354  input_tensor_values = ReadJSSInputs(JSSVars);
355 
356  // preparing container to hold output data
357  int testSample = 0;
358  std::vector<int> output_tensor_values_ = ReadOutputLabels();
359  int output_tensor_values = output_tensor_values_[testSample];
360 
361  // create input tensor object from data values
362  auto memory_info = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault);
363 
364  // we need a multiple tensor input structure for DisCo model
365  Ort::Value input1 = Ort::Value::CreateTensor<float>(memory_info, const_cast<float*>(input_tensor_values.data()), input_tensor_size, m_input_node_dims.data(), m_input_node_dims.size());
366  std::vector<float> empty = {1.};
367  Ort::Value input2 = Ort::Value::CreateTensor<float>(memory_info, empty.data(), 1, m_input_node_dims.data(), m_input_node_dims.size());
368  Ort::Value input3 = Ort::Value::CreateTensor<float>(memory_info, empty.data(), 1, m_input_node_dims.data(), m_input_node_dims.size());
369  Ort::Value input4 = Ort::Value::CreateTensor<float>(memory_info, empty.data(), 1, m_input_node_dims.data(), m_input_node_dims.size());
370  std::vector<Ort::Value> input_tensor;
371  std::vector<int64_t> aaa = {1, m_nvars};
372  input_tensor.emplace_back(
373  Ort::Value::CreateTensor<float>(memory_info, input_tensor_values.data(), input_tensor_size, aaa.data(), aaa.size())
374  );
375  input_tensor.emplace_back(
376  Ort::Value::CreateTensor<float>(memory_info, input_tensor_values.data(), input_tensor_size, m_input_node_dims.data(), m_input_node_dims.size())
377  );
378  input_tensor.emplace_back(
379  Ort::Value::CreateTensor<float>(memory_info, input_tensor_values.data(), input_tensor_size, m_input_node_dims.data(), m_input_node_dims.size())
380  );
381  input_tensor.emplace_back(
382  Ort::Value::CreateTensor<float>(memory_info, input_tensor_values.data(), input_tensor_size, m_input_node_dims.data(), m_input_node_dims.size())
383  );
384 
385  auto output_tensors = m_session->Run(Ort::RunOptions{nullptr}, m_input_node_names.data(), input_tensor.data(), m_input_node_names.size(), m_output_node_names.data(), m_output_node_names.size());
386  assert(output_tensors.size() == 1 && output_tensors.front().IsTensor());
387 
388  // Get pointer to output tensor float values
389  float* floatarr = output_tensors.front().GetTensorMutableData<float>();
390  int arrSize = sizeof(*floatarr)/sizeof(floatarr[0]);
391 
392  // show true label for the test input
393  ATH_MSG_DEBUG("Label for the input test data = "<<output_tensor_values);
394  float HLScore = -999;
395  int max_index = 0;
396  for (int i = 0; i < arrSize; i++){
397  ATH_MSG_VERBOSE("Score for class "<<i<<" = "<<floatarr[i]<<std::endl);
398  if (HLScore<floatarr[i]){
399  HLScore = floatarr[i];
400  max_index = i;
401  }
402  }
403  ATH_MSG_DEBUG("Class: "<<max_index<<" has the highest score: "<<floatarr[max_index]);
404 
405  return HLScore;
406 
407  } // end retrieve HighLevel score ----
408 
409  // extra methods
410  StatusCode JSSMLTool::SetScaler(std::map<std::string, std::vector<double>> scaler){
411  m_scaler = scaler;
412 
413  // ToDo:
414  // this will have an overriding config as property
415  m_JSSInputMap = {
416  {0,"pT"}, {1,"CNN"}, {2,"D2"}, {3,"nTracks"}, {4,"ZCut12"},
417  {5,"Tau1_wta"}, {6,"Tau2_wta"}, {7,"Tau3_wta"},
418  {8,"KtDR"}, {9,"Split12"}, {10,"Split23"},
419  {11,"ECF1"}, {12,"ECF2"}, {13,"ECF3"},
420  {14,"Angularity"}, {15,"FoxWolfram0"}, {16,"FoxWolfram2"},
421  {17,"Aplanarity"}, {18,"PlanarFlow"}, {19,"Qw"},
422  };
423  m_nvars = m_JSSInputMap.size();
424 
425  return StatusCode::SUCCESS;
426  }
427 
428 } // namespace AthONNX
AthONNX::JSSMLTool::m_nPixelsX
int m_nPixelsX
Definition: JSSMLTool.h:95
beamspotnt.var
var
Definition: bin/beamspotnt.py:1394
AthONNX::JSSMLTool::SetScaler
StatusCode SetScaler(std::map< std::string, std::vector< double >> scaler) override
Definition: JSSMLTool.cxx:410
AthONNX::JSSMLTool::m_nPixelsY
int m_nPixelsY
Definition: JSSMLTool.h:95
mean
void mean(std::vector< double > &bins, std::vector< double > &values, const std::vector< std::string > &files, const std::string &histname, const std::string &tplotname, const std::string &label="")
Definition: dependence.cxx:254
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
AthONNX::JSSMLTool::m_num_output_nodes
size_t m_num_output_nodes
Definition: JSSMLTool.h:91
AthONNX::JSSMLTool::m_modelFileName
std::string m_modelFileName
Name of the model file to load.
Definition: JSSMLTool.h:80
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
xAOD::scaler
setOverV setNumU setNumY setODFibSel setYDetCS setYLhcCS setXRPotCS setXStatCS setXBeamCS scaler
Definition: ALFAData_v1.cxx:66
AthONNX::JSSMLTool::JSSMLTool
JSSMLTool(const std::string &name)
Definition: JSSMLTool.cxx:73
AthONNX::JSSMLTool::m_env
std::unique_ptr< Ort::Env > m_env
Definition: JSSMLTool.h:72
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
python.CaloAddPedShiftConfig.type
type
Definition: CaloAddPedShiftConfig.py:42
AthONNX::JSSMLTool::m_input_node_names
std::vector< const char * > m_input_node_names
Definition: JSSMLTool.h:87
AthONNX::JSSMLTool::ReadOutputLabels
std::vector< int > ReadOutputLabels() const
Definition: JSSMLTool.cxx:63
JSSMLTool.h
skel.input1
tuple input1
Definition: skel.GENtoEVGEN.py:771
DeMoLib.iColor
int iColor
NEWSYSTEM defects if system == "NEWSYSTEM": partitions["color"] = {} partitions["list"] = partitions[...
Definition: DeMoLib.py:1067
lumiFormat.i
int i
Definition: lumiFormat.py:85
AthONNX::JSSMLTool::m_output_node_names
std::vector< const char * > m_output_node_names
Definition: JSSMLTool.h:92
AthONNX::JSSMLTool::m_scaler
std::map< std::string, std::vector< double > > m_scaler
Definition: JSSMLTool.h:74
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
AthONNX::JSSMLTool::m_nvars
int m_nvars
Definition: JSSMLTool.h:97
AthONNX::JSSMLTool::m_input_node_dims
std::vector< int64_t > m_input_node_dims
Definition: JSSMLTool.h:85
AthONNX::JSSMLTool::m_nPixelsZ
int m_nPixelsZ
Definition: JSSMLTool.h:95
AthONNX::JSSMLTool::m_JSSInputMap
std::map< int, std::string > m_JSSInputMap
Definition: JSSMLTool.h:75
AthONNX::JSSMLTool::initialize
virtual StatusCode initialize() override
Function initialising the tool.
Definition: JSSMLTool.cxx:83
AthONNX::JSSMLTool::ReadJSSInputs
std::vector< float > ReadJSSInputs(std::map< std::string, double > JSSVars) const
Definition: JSSMLTool.cxx:39
PathResolver.h
AthONNX::JSSMLTool::m_output_node_dims
std::vector< int64_t > m_output_node_dims
Definition: JSSMLTool.h:90
AthONNX
Definition: IJSSMLTool.h:23
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
python.PyAthena.v
v
Definition: PyAthena.py:154
AthONNX::JSSMLTool::m_session
std::unique_ptr< Ort::Session > m_session
Definition: JSSMLTool.h:71
AthONNX::JSSMLTool::m_num_input_nodes
size_t m_num_input_nodes
Definition: JSSMLTool.h:86
AthONNX::JSSMLTool::retrieveConstituentsScore
virtual double retrieveConstituentsScore(std::vector< TH2D > Images) const override
Function executing the tool for a single event.
Definition: JSSMLTool.cxx:154
AthONNX::JSSMLTool::retrieveHighLevelScore
virtual double retrieveHighLevelScore(std::map< std::string, double > JSSVars) const override
Definition: JSSMLTool.cxx:344
fitman.k
k
Definition: fitman.py:528
AthONNX::JSSMLTool::ReadJetImagePixels
std::vector< float > ReadJetImagePixels(std::vector< TH2D > Images) const
Definition: JSSMLTool.cxx:17