PFEnergyPredictorTool Class Reference

#include <PFEnergyPredictorTool.h>

Inheritance diagram for PFEnergyPredictorTool:

Collaboration diagram for PFEnergyPredictorTool:

Public Member Functions
	PFEnergyPredictorTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual StatusCode	initialize () override
virtual StatusCode	finalize () override
float	runOnnxInference (std::vector< float > &tensor) const
float	nnEnergyPrediction (const eflowRecTrack *ptr) const
void	NormalizeTensor (std::vector< float > &tensor, size_t limit) 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	sysInitialize () override
	Perform system initialization for an algorithm.
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

Static Public Member Functions
static const InterfaceID &	interfaceID ()

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
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
std::unique_ptr< Ort::Session > m_session	ATLAS_THREAD_SAFE
std::vector< const char * >	m_input_node_names
std::vector< const char * >	m_output_node_names
std::vector< int64_t >	m_input_node_dims
ServiceHandle< AthOnnx::IOnnxRuntimeSvc >	m_svc {this, "ONNXRuntimeSvc", "AthOnnx::OnnxRuntimeSvc", "CaloMuonScoreTool ONNXRuntimeSvc"}
Gaudi::Property< std::string >	m_model_filepath {this, "ModelPath", "////"}
Gaudi::Property< float >	m_cellE_mean {this,"cellE_mean",-2.2852574689444385}
	Normalization constants for the inputs to the onnx model.
Gaudi::Property< float >	m_cellE_std {this,"cellE_std",2.0100506557174946}
Gaudi::Property< float >	m_cellPhi_std {this,"cellPhi_std",0.6916977411859621}
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 16 of file PFEnergyPredictorTool.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

PFEnergyPredictorTool()

PFEnergyPredictorTool::PFEnergyPredictorTool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent )

Definition at line 12 of file PFEnergyPredictorTool.cxx.

                                                                                                                   : AthAlgTool(type, name, parent)
{
 
}

Member Function Documentation

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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; }

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::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

finalize()

StatusCode PFEnergyPredictorTool::finalize ( )

overridevirtual

Definition at line 321 of file PFEnergyPredictorTool.cxx.

{
  return StatusCode::SUCCESS;
}

initialize()

StatusCode PFEnergyPredictorTool::initialize ( )

overridevirtual

Definition at line 18 of file PFEnergyPredictorTool.cxx.

{
   ATH_MSG_DEBUG("Initializing " << name());
   if(m_model_filepath == "////"){
      ATH_MSG_WARNING("model not provided tool will not work");
      return StatusCode::SUCCESS;
   }
   ATH_CHECK(m_svc.retrieve());
   std::string path  = m_model_filepath;//Add path resolving code
 
   Ort::SessionOptions session_options;
   Ort::AllocatorWithDefaultOptions allocator;
   session_options.SetIntraOpNumThreads(1);
   session_options.SetGraphOptimizationLevel(ORT_ENABLE_BASIC);
   m_session = std::make_unique<Ort::Session>(m_svc->env(), path.c_str(), session_options);
 
    ATH_MSG_INFO("Created ONNX runtime session with model " << path);
 
    size_t num_input_nodes = m_session->GetInputCount();
    m_input_node_names.resize(num_input_nodes);
 
    for (std::size_t i = 0; i < num_input_nodes; i++) {
        // print input node names
        char* input_name = m_session->GetInputNameAllocated(i, allocator).release();
        ATH_MSG_INFO("Input " << i << " : "
                              << " name= " << input_name);
        m_input_node_names[i] = input_name;
        // print input node types
        Ort::TypeInfo type_info = m_session->GetInputTypeInfo(i);
        auto tensor_info = type_info.GetTensorTypeAndShapeInfo();
        ONNXTensorElementDataType type = tensor_info.GetElementType();
        ATH_MSG_INFO("Input " << i << " : "
                              << " type= " << type);
 
        // print input shapes/dims
        m_input_node_dims = tensor_info.GetShape();
        m_input_node_dims[1] = 5430/5;
        ATH_MSG_INFO("Input " << i << " : num_dims= " << m_input_node_dims.size());
        for (std::size_t j = 0; j < m_input_node_dims.size(); j++) {
            if (m_input_node_dims[j] < 0) m_input_node_dims[j] = 1;
            ATH_MSG_INFO("Input " << i << " : dim " << j << "= " << m_input_node_dims[j]);
        }
    }
    
    // output nodes
    std::vector<int64_t> output_node_dims;
    size_t num_output_nodes = m_session->GetOutputCount();
    ATH_MSG_INFO("Have output nodes " << num_output_nodes);
    m_output_node_names.resize(num_output_nodes);
 
    for (std::size_t i = 0; i < num_output_nodes; i++) {
        // print output node names
        char* output_name = m_session->GetOutputNameAllocated(i, allocator).release();
        ATH_MSG_INFO("Output " << i << " : "
                               << " name= " << output_name);
        m_output_node_names[i] = output_name;
 
        Ort::TypeInfo type_info = m_session->GetOutputTypeInfo(i);
        auto tensor_info = type_info.GetTensorTypeAndShapeInfo();
        ONNXTensorElementDataType type = tensor_info.GetElementType();
        ATH_MSG_INFO("Output " << i << " : "
                               << " type= " << type);
 
        // print output shapes/dims
        output_node_dims = tensor_info.GetShape();
        ATH_MSG_INFO("Output " << i << " : num_dims= " << output_node_dims.size());
        for (std::size_t j = 0; j < output_node_dims.size(); j++) {
            if (output_node_dims[j] < 0) output_node_dims[j] = 1;
            ATH_MSG_INFO("Output" << i << " : dim " << j << "= " << output_node_dims[j]);
        }
    }
 
    return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::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.

interfaceID()

const InterfaceID & PFEnergyPredictorTool::interfaceID ( )

inlinestatic

Definition at line 49 of file PFEnergyPredictorTool.h.

{ return IID_PFEnergyPredictorTool; }

msg()

MsgStream & AthCommonMsg< AlgTool >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

nnEnergyPrediction()

float PFEnergyPredictorTool::nnEnergyPrediction

(

const eflowRecTrack *

ptr

)

const

Definition at line 132 of file PFEnergyPredictorTool.cxx.

                                                                             {
 
     constexpr std::array<int,19> calo_numbers{1,2,3,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20};
     constexpr std::array<int,12> fixed_r_numbers = {1,2,3,12,13,14,15,16,17,18,19,20};
     constexpr std::array<double,12> fixed_r_vals = {1532.18, 1723.89, 1923.02, 2450.00, 2995.00, 3630.00, 3215.00,
                                        3630.00, 2246.50, 2450.00, 2870.00, 3480.00
                                       };
     constexpr std::array<int, 7> fixed_z_numbers = {5,6,7,8,9,10,11};
     constexpr std::array<double, 7> fixed_z_vals = {3790.03, 3983.68, 4195.84, 4461.25, 4869.50, 5424.50, 5905.00};
     std::unordered_map<int, double> r_calo_dict;//change to flatmap in c++23
     std::unordered_map<int, double> z_calo_dict;
     for(size_t i=0; i<fixed_r_vals.size(); i++) r_calo_dict[fixed_r_numbers[i]] = fixed_r_vals[i];
     for(size_t i=0; i<fixed_z_numbers.size(); i++) z_calo_dict[fixed_z_numbers[i]] = fixed_z_vals[i];
 
     std::vector<float> inputnn;
     inputnn.assign(5430, 0.0);
     std::vector<eflowRecCluster*> matchedClusters;
     const std::vector<eflowTrackClusterLink*>& links = ptr->getClusterMatches();
 
    std::array<double, 19> etatotal = getEtaTrackCalo(ptr->getTrackCaloPoints());
    std::array<double, 19> phitotal = getPhiTrackCalo(ptr->getTrackCaloPoints());
 
     const std::array<double, 2> track{ptr->getTrack()->eta(), ptr->getTrack()->phi()};
 
     for(auto *clink : links){
        auto *cell = clink->getCluster()->getCluster();
        float clusterE = cell->e()*1e-3;
        float clusterEta = cell->eta();
 
        if (clusterE < 0.0 || clusterE > 1e4f || std::abs(clusterEta) > 2.5) continue;
 
        constexpr bool cutOnR = false;
        if(cutOnR){
            std::array<double, 2> p{clink->getCluster()->getCluster()->eta(), clink->getCluster()->getCluster()->phi()};
            double part1 = p[0] - track[0];
            double part2 = p[1] - track[1];
            while(part1 > M_PI) part1 -= 2*M_PI;
            while(part1 < -M_PI) part1 += 2*M_PI;
            while(part2 > M_PI) part2 -= 2*M_PI;
            while(part2 < -M_PI) part2 += 2*M_PI;
            double R = std::sqrt(part1 * part1 + part2*part2);
            if(R >= 1.2) continue;
        }
 
        matchedClusters.push_back(clink->getCluster());
     }
 
     std::vector<std::array<double, 5>> cells;
 
    const eflowTrackCaloPoints& trackCaloPoints = ptr->getTrackCaloPoints();
    bool trk_bool_em[2] = {false,false};
    std::array<double,2> trk_em_eta = {trackCaloPoints.getEta(eflowCalo::EMB2), trackCaloPoints.getEta(eflowCalo::EME2)};
    std::array<double,2> trk_em_phi = {trackCaloPoints.getPhi(eflowCalo::EMB2), trackCaloPoints.getPhi(eflowCalo::EME2)};
    double eta_ctr;
    double phi_ctr;
    for(int i =0; i<2; i++) {
        trk_bool_em[i] = std::abs(trk_em_eta[i]) < 2.5 && std::abs(trk_em_phi[i]) <= M_PI;
    }
    int nProj_em = (int)trk_bool_em[0] + (int)trk_bool_em[1];
 
    if(nProj_em ==1) {
        eta_ctr = trk_bool_em[0] ? trk_em_eta[0] : trk_em_eta[1];
        phi_ctr = trk_bool_em[0] ? trk_em_phi[0] : trk_em_phi[1];
    } else if(nProj_em==2) {
        eta_ctr = (trk_em_eta[0] + trk_em_eta[1]) / 2.0;
        phi_ctr = (trk_em_phi[0] + trk_em_phi[1]) / 2.0;
    } else {
        eta_ctr = ptr->getTrack()->eta();
        phi_ctr = ptr->getTrack()->phi();
    }
 
 
 
     for(auto *cptr : matchedClusters){
        auto *clustlink = cptr->getCluster();
 
        for(auto it_cell = clustlink->cell_begin(); it_cell != clustlink->cell_end(); it_cell++){
           const CaloCell* cell = (*it_cell);
           float cellE = cell->e()*(it_cell.weight())*1e-3f;
           if(cellE < 0.005) continue;//Cut from ntuple maker
           const auto *theDDE=it_cell->caloDDE();
           double cx=theDDE->x();
           double cy=theDDE->y();
 
           cells.emplace_back( std::array<double, 5> { cellE,
                    theDDE->eta() -  eta_ctr,
                    theDDE->phi() -  phi_ctr,
                    std::hypot(cx,cy), //rperp
                    0.0    } );
        }
     }
 
 
    std::vector<bool> trk_bool(calo_numbers.size(), false);
    std::vector<std::array<double,4>> trk_full(calo_numbers.size());
    for(size_t j=0; j<phitotal.size(); j++) {
        int cnum = calo_numbers[j];
        double eta = etatotal[j];
        double phi = phitotal[j];
        if(std::abs(eta) < 2.5 && std::abs(phi) <= M_PI) {
            trk_bool[j] = true;
            trk_full[j][0] = eta;
            trk_full[j][1] = phi;
            trk_full[j][3] = cnum;
            double rPerp =-99999;
            if(auto itr = r_calo_dict.find(cnum); itr != r_calo_dict.end()) rPerp = itr->second;
            else if(auto itr = z_calo_dict.find(cnum); itr != z_calo_dict.end())
            {
                double z = itr->second;
                if(eta != 0.0){
                   double aeta = std::abs(eta);
                   rPerp = z*2.*std::exp(aeta)/(std::exp(2.0*aeta)-1.0);
                }else rPerp =0.0; //Check if this makes sense
            } else {
                throw std::runtime_error("Calo sample num not found in dicts..");
            }
            trk_full[j][2] = rPerp;
        } else {
            trk_full[j].fill(0.0);
        }
    }
    double trackP = std::abs(1. / ptr->getTrack()->qOverP()) * 1e-3;
    int trk_proj_num = std::accumulate(trk_bool.begin(), trk_bool.end(), 0);
    if(trk_proj_num ==0) {
        trk_proj_num =1;
        std::array<double,5> trk_arr{};
 
        trk_arr[0] = trackP;
        trk_arr[1] = ptr->getTrack()->eta() - eta_ctr;
        trk_arr[2] = ptr->getTrack()->phi() - phi_ctr;
        trk_arr[3] = 1532.18; // just place it in EMB1
        trk_arr[4] = 1.;
 
        cells.emplace_back(trk_arr);
    } else {
        for(size_t i =0; i<calo_numbers.size(); i++) {
            if(!trk_bool[i]) continue;
            std::array<double,5> trk_arr{};
            trk_arr[0]= trackP/double(trk_proj_num);
            trk_arr[1]= trk_full[i][0] - eta_ctr;
            trk_arr[2]= trk_full[i][1] - phi_ctr;
            trk_arr[3]= trk_full[i][2];
            trk_arr[4]= 1.;
 
            cells.emplace_back(trk_arr);
        }
    }
 
    int index = 0;
    for(auto &in : cells){
      std::copy(in.begin(), in.end(), inputnn.begin() + index);
      index+=5;
      if(index >= static_cast<int>(inputnn.size()-4)) {
        ATH_MSG_WARNING("Data exceeded tensor size");
        break;
      }
    }
        
    //Normalization prior to training
    NormalizeTensor(inputnn, cells.size() * 5 );
        
    float predictedEnergy = exp(runOnnxInference(inputnn)) * 1000.0;//Correct to MeV units 
    ATH_MSG_DEBUG("NN Predicted energy " << predictedEnergy);      
    return predictedEnergy;
 
}

NormalizeTensor()

void PFEnergyPredictorTool::NormalizeTensor	(	std::vector< float > &	tensor,
		size_t	limit ) const

Definition at line 299 of file PFEnergyPredictorTool.cxx.

                                                                                        {
    size_t i=0;
    for(i =0;i<limit;i+=5){
      auto &f = inputnn[i+3];
      if(f!= 0.0f) f/= 3630.f;
      auto &e = inputnn[i+0];
      if(e!= 0.0f){
       e = std::log(e);
       e = (e - m_cellE_mean)/m_cellE_std;
      }
      auto &eta = inputnn[i+1];
      if(eta!= 0.0) eta /= 0.7f;
      auto &phi = inputnn[i+2];
      if(phi!= 0.0) phi /= m_cellPhi_std;
    }
    if(i> inputnn.size()){
        ATH_MSG_ERROR("Index exceeded tensor MEMORY CORRUPTION");
    }
}

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::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< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

runOnnxInference()

float PFEnergyPredictorTool::runOnnxInference

(

std::vector< float > &

tensor

)

const

Definition at line 93 of file PFEnergyPredictorTool.cxx.

                                                                            {
    auto memory_info = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault);
    auto input_tensor_size = tensor.size();
 
    Ort::Value input_tensor =
        Ort::Value::CreateTensor<float>(memory_info, tensor.data(), input_tensor_size,
         m_input_node_dims.data(), m_input_node_dims.size());
 
    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());
 
    const float *output_score_array = output_tensors.front().GetTensorData<float>();
 
    // Binary classification - the score is just the first element of the output tensor
    float output_score = output_score_array[0];
 
    return output_score;
}

sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::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< AlgTool > >::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

ATLAS_THREAD_SAFE

std::unique_ptr<Ort::Session> m_session PFEnergyPredictorTool::ATLAS_THREAD_SAFE

private

Definition at line 32 of file PFEnergyPredictorTool.h.

m_cellE_mean

Gaudi::Property<float> PFEnergyPredictorTool::m_cellE_mean {this,"cellE_mean",-2.2852574689444385}

private

Normalization constants for the inputs to the onnx model.

Definition at line 43 of file PFEnergyPredictorTool.h.

{this,"cellE_mean",-2.2852574689444385};

m_cellE_std

Gaudi::Property<float> PFEnergyPredictorTool::m_cellE_std {this,"cellE_std",2.0100506557174946}

private

Definition at line 44 of file PFEnergyPredictorTool.h.

{this,"cellE_std",2.0100506557174946};

m_cellPhi_std

Gaudi::Property<float> PFEnergyPredictorTool::m_cellPhi_std {this,"cellPhi_std",0.6916977411859621}

private

Definition at line 45 of file PFEnergyPredictorTool.h.

{this,"cellPhi_std",0.6916977411859621};

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default).

Definition at line 393 of file AthCommonDataStore.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default).

Definition at line 390 of file AthCommonDataStore.h.

m_input_node_dims

std::vector<int64_t> PFEnergyPredictorTool::m_input_node_dims

private

Definition at line 38 of file PFEnergyPredictorTool.h.

m_input_node_names

std::vector<const char *> PFEnergyPredictorTool::m_input_node_names

private

Definition at line 34 of file PFEnergyPredictorTool.h.

m_model_filepath

Gaudi::Property<std::string> PFEnergyPredictorTool::m_model_filepath {this, "ModelPath", "////"}

private

Definition at line 40 of file PFEnergyPredictorTool.h.

{this, "ModelPath", "////"};

m_output_node_names

std::vector<const char *> PFEnergyPredictorTool::m_output_node_names

private

Definition at line 36 of file PFEnergyPredictorTool.h.

m_svc

ServiceHandle<AthOnnx::IOnnxRuntimeSvc> PFEnergyPredictorTool::m_svc {this, "ONNXRuntimeSvc", "AthOnnx::OnnxRuntimeSvc", "CaloMuonScoreTool ONNXRuntimeSvc"}

private

Definition at line 39 of file PFEnergyPredictorTool.h.

{this, "ONNXRuntimeSvc", "AthOnnx::OnnxRuntimeSvc", "CaloMuonScoreTool ONNXRuntimeSvc"};

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

The documentation for this class was generated from the following files:

• PFEnergyPredictorTool.h
• PFEnergyPredictorTool.cxx