GlobalLargeRDNNCalibration Class Reference

#include <GlobalLargeRDNNCalibration.h>

Inheritance diagram for GlobalLargeRDNNCalibration:

Collaboration diagram for GlobalLargeRDNNCalibration:

Classes
struct	VarRetriever
	VarRetriever is a generic class to access Jet and/or JetEventInfo variables. More...

Public Member Functions
	GlobalLargeRDNNCalibration ()
	The constructor.
	GlobalLargeRDNNCalibration (const std::string &name)
	The constructor.
	GlobalLargeRDNNCalibration (const std::string &name, TEnv *config, const TString &calibArea, bool dev)
	The constructor, which is used by the JetCalibrationTool.
virtual	~GlobalLargeRDNNCalibration ()
	The destructor.
virtual StatusCode	initialize () override
	Returns the charged fraction of a jet.
virtual void	setUnitsGeV (bool useGeV)
virtual StatusCode	getNominalResolutionData (const xAOD::Jet &, double &) const
virtual StatusCode	getNominalResolutionMC (const xAOD::Jet &, double &) const
void	setLevel (MSG::Level lvl)
	Change the current logging level.
Functions providing the same interface as AthMessaging
bool	msgLvl (const MSG::Level lvl) const
	Test the output level of the object.
MsgStream &	msg () const
	The standard message stream.
MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream.

Protected Member Functions
virtual StatusCode	calibrate (xAOD::Jet &jet, JetEventInfo &) const override
virtual StatusCode	setStartP4 (xAOD::Jet &jet) const

Protected Attributes
double	m_GeV
std::string	m_jetStartScale
std::string	m_name

Private Member Functions
std::vector< float >	getJetFeatures (xAOD::Jet &jet_reco, JetEventInfo &jetEventInfo) const
	Returns a vector of input features for the NN.
void	initMessaging () const
	Initialize our message level and MessageSvc.

Private Attributes
std::vector< TString >	m_NNInputs
std::vector< double >	m_eScales
std::vector< double >	m_NormOffsets
std::vector< double >	m_NormScales
std::string	m_modelFileName
std::vector< VarRetriever * >	m_varretrievers
std::unique_ptr< Ort::Session >	m_session
std::vector< int64_t >	m_input_node_dims
std::vector< const char * >	m_input_node_names
std::vector< int64_t >	m_output_node_dims
std::vector< const char * >	m_output_node_names
TEnv *	m_config {}
std::string	m_calibArea
bool	m_devMode {}
bool	m_noMassCalibBelow40 =false
std::string	m_nm
	Message source name.
boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels).
std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer.
std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level.
std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging).

Detailed Description

Definition at line 32 of file GlobalLargeRDNNCalibration.h.

Constructor & Destructor Documentation

GlobalLargeRDNNCalibration() [1/3]

GlobalLargeRDNNCalibration::GlobalLargeRDNNCalibration

(

)

The constructor.

Constructors.

Note that this doesn't have all the necessary information, so it will not configure things correctly.

Definition at line 188 of file GlobalLargeRDNNCalibration.cxx.

  : JetCalibrationStep::JetCalibrationStep("GlobalLargeRDNNCalibration/GlobalLargeRDNNCalibration"),
    m_config(nullptr), m_calibArea("")
{
}

GlobalLargeRDNNCalibration() [2/3]

GlobalLargeRDNNCalibration::GlobalLargeRDNNCalibration

(

const std::string &

name

)

The constructor.

Note that this doesn't have all the necessary information, so it will not configure things correctly.

Parameters

name	The name of the tool being created

Definition at line 194 of file GlobalLargeRDNNCalibration.cxx.

  : JetCalibrationStep::JetCalibrationStep(name.c_str()),
    m_config(nullptr), m_calibArea("")
{
}

GlobalLargeRDNNCalibration() [3/3]

GlobalLargeRDNNCalibration::GlobalLargeRDNNCalibration	(	const std::string &	name,
		TEnv *	config,
		const TString &	calibArea,
		bool	dev )

The constructor, which is used by the JetCalibrationTool.

Parameters

name	The name of the tool being created
config	The name of the config file for the calibration
jetAlgo	The name of the jet collection
calibAreaTag	The tag for this calibration
dev	A flag for if the calibration is run in development mode

Definition at line 200 of file GlobalLargeRDNNCalibration.cxx.

  : JetCalibrationStep::JetCalibrationStep( name.c_str() ),
    m_config(config), m_calibArea(calibArea), m_devMode(dev)
{
}

~GlobalLargeRDNNCalibration()

GlobalLargeRDNNCalibration::~GlobalLargeRDNNCalibration ( )

virtual

The destructor.

Destructor.

Definition at line 207 of file GlobalLargeRDNNCalibration.cxx.

                                                       {
    for(VarRetriever* v: m_varretrievers) delete v;
}

Member Function Documentation

calibrate()

StatusCode GlobalLargeRDNNCalibration::calibrate ( xAOD::Jet & jet, JetEventInfo & jetEventInfo ) const

overrideprotectedvirtual

Implements JetCalibrationStep.

Definition at line 325 of file GlobalLargeRDNNCalibration.cxx.

                                                                                               {
 
    // Set jet initial scale
    xAOD::JetFourMom_t jetStartP4;
    ATH_CHECK( setStartP4(jet) );
    jetStartP4 = jet.jetP4();
 
    // Don't apply calibration for jets with negative or null mass or for one constituent jets
    if(jet.m()<=0 || jet.numConstituents()==1){
        jet.setAttribute<xAOD::JetFourMom_t>("JetDNNCScaleMomentum",jetStartP4);
        return StatusCode::SUCCESS;
    }
 
    // Get input features normalized for jet
    std::vector<float> input_tensor_values = getJetFeatures(jet, jetEventInfo);
    if( msgLvl(MSG::DEBUG) ){
        ATH_MSG_DEBUG("Input tensor values : ");
        for (long unsigned int i=0;i<input_tensor_values.size();i++) ATH_MSG_DEBUG(" " << input_tensor_values[i]);
    }
    ATH_MSG_DEBUG(" start M : " << jetStartP4.M());
 
    // Check for nan or +/- inf values
    int nNan = std::count_if(input_tensor_values.begin(), input_tensor_values.end(), [](float f){return std::isnan(f) || std::isinf(f);});
    if (nNan>0) {
        ATH_MSG_WARNING("Encountered Nan or inf value in input features, will not apply calibration");
        jet.setAttribute<xAOD::JetFourMom_t>("JetDNNCScaleMomentum",jetStartP4);
        return StatusCode::SUCCESS;
    }
 
    // Convert input_tensor_values array to onnx-compatible tensor
    Ort::MemoryInfo memory_info = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeCPU);
    Ort::Value input_tensor = Ort::Value::CreateTensor<float>(  memory_info, 
                                                                input_tensor_values.data(), 
                                                                input_tensor_values.size(), 
                                                                m_input_node_dims.data(), 
                                                                m_input_node_dims.size());
 
    // Make sure we get the same input values in tensor
    std::vector<float> vec(input_tensor.GetTensorMutableData<float>(), input_tensor.GetTensorMutableData<float>() + m_input_node_dims[1]);
    if (vec!=input_tensor_values) {
        ATH_MSG_WARNING("Input tensor after convertion to Ort tensor is not the same as the input vector, will not apply calibration");
        jet.setAttribute<xAOD::JetFourMom_t>("JetDNNCScaleMomentum",jetStartP4);
        return StatusCode::SUCCESS;
    }
 
    // Run inference on input_tensor
    Ort::Session& session ATLAS_THREAD_SAFE = *m_session;
    auto output_tensor =  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());
    if (!output_tensor.front().IsTensor() || output_tensor.size() != m_output_node_names.size() || output_tensor.front().GetTensorTypeAndShapeInfo().GetShape() != m_output_node_dims) {
        ATH_MSG_WARNING("Output tensor does not have the same size as output layer, will not apply calibration");
        jet.setAttribute<xAOD::JetFourMom_t>("JetDNNCScaleMomentum",jetStartP4);
        return StatusCode::SUCCESS;
    }
 
    // Get pointer to output tensor float values
    float* outputE = output_tensor.at(0).GetTensorMutableData<float>();
    // Models with a single output node (e.g. small-R JES-only DNNs) only predict the
    // energy response: there is no mass response to read
    const bool energyOnly = (output_tensor.size() == 1);
    float* outputM = energyOnly ? outputE : output_tensor.at(1).GetTensorMutableData<float>();
 
    // Get predicted calibration factors
    float predRespE = outputE[0];  // first element is predicted response
    float predRespM = outputM[0];
 
    // Print the output predictions for E/M
    ATH_MSG_DEBUG("Output E : " << predRespE);
    ATH_MSG_DEBUG("Output M : " << predRespM);
  
    if (predRespE==0 || predRespM==0) {
        ATH_MSG_WARNING("Predictions give 0 values, will not apply calibration");
        jet.setAttribute<xAOD::JetFourMom_t>("JetDNNCScaleMomentum",jetStartP4);
        return StatusCode::SUCCESS;
    }
    
    // Energy-only models: scale the whole 4-vector by the energy response (so the mass
    // scales with it, without the m > 40 GeV requirement applied to large-R jets below)
    if (energyOnly) {
        const xAOD::JetFourMom_t calibP4 = jetStartP4 * (1. / predRespE);
        jet.setAttribute<xAOD::JetFourMom_t>("JetDNNCScaleMomentum",calibP4);
        jet.setJetP4( calibP4 );
        return StatusCode::SUCCESS;
    }
 
    // Apply calibration to jet p4
    float calibE = jetStartP4.e() / predRespE;
 
    // For mass, only apply calibration if m>40 GeV (if m_noMassCalibBelow40)
    float calibM = jetStartP4.mass();
    if( ! m_noMassCalibBelow40 || (calibM>40000) ){
        calibM /= predRespM;
    }
 
    // Propagate energy and mass calibration to jet pT
    float calibpT = std::sqrt( calibE*calibE - calibM*calibM )/std::cosh( jetStartP4.eta() );
 
    // Build calibrated jet p4
    TLorentzVector TLVjet;
    TLVjet.SetPtEtaPhiM( calibpT, jetStartP4.eta(), jetStartP4.phi(), calibM );
    xAOD::JetFourMom_t calibP4;
    calibP4.SetPxPyPzE( TLVjet.Px(), TLVjet.Py(), TLVjet.Pz(), TLVjet.E() );
 
    // Transfer calibrated jet properties to the Jet object
    jet.setAttribute<xAOD::JetFourMom_t>("JetDNNCScaleMomentum",calibP4);
    jet.setJetP4( calibP4 );
 
    return StatusCode::SUCCESS;
 
}

getJetFeatures()

std::vector< float > GlobalLargeRDNNCalibration::getJetFeatures ( xAOD::Jet & jet_reco, JetEventInfo & jetEventInfo ) const

private

Returns a vector of input features for the NN.

Parameters

jet_reco	The jet
jetEventInfo	A set of information about the event and jet

Definition at line 442 of file GlobalLargeRDNNCalibration.cxx.

                                                                                                                {
    // Init input tensor
    std::vector<float> input_tensor_values(m_NNInputs.size());
 
    // Retrieve all input variables from the jet and/or jetEventInfo using our VarRetriever collection:
    for(size_t i=0;i<input_tensor_values.size();i++){
        float v = m_varretrievers[i]->value(jet_reco, jetEventInfo, m_eScales[i]);
        // and perform normalisation :
        input_tensor_values[i] = v*m_NormScales[i] + m_NormOffsets[i];
    }
 
    return input_tensor_values;
}

getNominalResolutionData()

StatusCode JetCalibrationStep::getNominalResolutionData ( const xAOD::Jet & , double &  ) const

virtualinherited

Reimplemented in JetSmearingCorrection.

Definition at line 33 of file JetCalibrationStep.cxx.

                                                                                    {
  ATH_MSG_ERROR("Nominal data resolution requested from a jet calibration step that doesn't define it.");
  return StatusCode::FAILURE;
}

getNominalResolutionMC()

StatusCode JetCalibrationStep::getNominalResolutionMC ( const xAOD::Jet & , double &  ) const

virtualinherited

Reimplemented in JetSmearingCorrection.

Definition at line 38 of file JetCalibrationStep.cxx.

                                                                                  {
  ATH_MSG_ERROR("Nominal MC resolution requested from a jet calibration step that doesn't define it.");
  return StatusCode::FAILURE;
}

initialize()

StatusCode GlobalLargeRDNNCalibration::initialize ( )

overridevirtual

Returns the charged fraction of a jet.

Parameters

name	The name of the tool being created

Implements JetCalibrationStep.

Definition at line 212 of file GlobalLargeRDNNCalibration.cxx.

                                                 {
    ATH_MSG_DEBUG("Initializing tool");
    if ( !m_config ) { ATH_MSG_FATAL("Config file not specified. Aborting."); return StatusCode::FAILURE; }
 
    // Get list of input features
    m_NNInputs = JetCalibUtils::Vectorize( m_config->GetValue("DNNC.Inputs","") );
    // Now build a VarRetriever for each of the input features 
    m_varretrievers.resize(m_NNInputs.size());
    ATH_MSG_DEBUG("DNN inputs");
    for (long unsigned int i=0;i<m_NNInputs.size();i++) {
        m_varretrievers[i] = buildVarRetriever( m_NNInputs[i].Data() );
        ATH_MSG_DEBUG("  " << m_NNInputs[i]);
    }
 
    // Get normalization constants for input features
    m_eScales = JetCalibUtils::VectorizeD( m_config->GetValue("DNNC.EScales","") );
    m_NormOffsets = JetCalibUtils::VectorizeD( m_config->GetValue("DNNC.NormOffsets","") );
    m_NormScales = JetCalibUtils::VectorizeD( m_config->GetValue("DNNC.NormScales","") );
        
    if (m_eScales.size()!=m_NNInputs.size() || m_NormOffsets.size()!=m_NNInputs.size() || m_NormScales.size()!=m_NNInputs.size()) {
        ATH_MSG_FATAL("Misconfiguration of config file : not same number of offset/scale parameters and number of features. Will exit");
        return StatusCode::FAILURE;
    }
 
    if( msgLvl(MSG::DEBUG) ){
        ATH_MSG_DEBUG("m_NormOffsets size : " << m_NormOffsets.size());
        ATH_MSG_DEBUG("m_NormOffsets");
        for (long unsigned int i=0;i<m_NormOffsets.size();i++) {
        ATH_MSG_DEBUG("  " << m_NormOffsets[i]);
        }
        ATH_MSG_DEBUG("m_NormScales size : " << m_NormScales.size());
        ATH_MSG_DEBUG("m_NormScales");
        for (long unsigned int i=0;i<m_NormScales.size();i++) {
        ATH_MSG_DEBUG("  " << m_NormScales[i]);
        }
    }
    
    // Get DNN config file
    m_modelFileName = m_config->GetValue("DNNC.ONNXInput","");
    m_noMassCalibBelow40 = m_config->GetValue("DNNC.NoMassCalibBelow40", 1);
    std::string modelPath = "";
    if (m_devMode) {
        modelPath="JetCalibTools/"+m_modelFileName;
    } else {
        modelPath="JetCalibTools/"+m_calibArea+"CalibrationConfigs/"+m_modelFileName;
    }
    const std::string fullModelPath = PathResolverFindCalibFile( modelPath ); // Full path
    ATH_MSG_INFO("Using ONNX model : " << m_modelFileName );
    ATH_MSG_INFO("resolved in: " << fullModelPath);
 
    // Set up the ONNX Runtime session.
    m_session = CreateORTSession(fullModelPath);
    ATH_MSG_DEBUG( "ONNX Runtime session succesfully created" );
 
 
    /************************** Input Nodes *****************************/
    /*********************************************************************/
    std::tuple<std::vector<int64_t>, std::vector<const char*> > inputInfo = GetInputNodeInfo(m_session);
    m_input_node_dims = std::get<0>(inputInfo);
    m_input_node_names = std::get<1>(inputInfo);
 
    if( msgLvl(MSG::DEBUG) ){
        for( std::size_t i = 0; i < m_input_node_names.size(); i++ ) {
            // print input node names
            ATH_MSG_DEBUG("Input "<<i<<" : "<<" name= "<<m_input_node_names[i]);
            
            // print input shapes/dims
            ATH_MSG_DEBUG("Input "<<i<<" : num_dims= "<<m_input_node_dims.size());
            for (std::size_t j = 0; j < m_input_node_dims.size(); j++){
                ATH_MSG_DEBUG("Input "<<i<<" : dim "<<j<<"= "<<m_input_node_dims[j]);
            }
        }
    }
 
    /************************** Output Nodes *****************************/
    /*********************************************************************/
    std::tuple<std::vector<int64_t>, std::vector<const char*> > outputInfo = GetOutputNodeInfo(m_session);
    m_output_node_dims = std::get<0>(outputInfo);
    m_output_node_names = std::get<1>(outputInfo);
 
    if( msgLvl(MSG::DEBUG) ){
        for( std::size_t i = 0; i < m_output_node_names.size(); i++ ) {
            // print input node names
            ATH_MSG_DEBUG("Output "<<i<<" : "<<" name= "<<m_output_node_names[i]);
 
            // print input shapes/dims
            ATH_MSG_DEBUG("Output "<<i<<" : num_dims= "<<m_output_node_dims.size());
            for (std::size_t j = 0; j < m_output_node_dims.size(); j++){
                ATH_MSG_DEBUG("Output "<<i<<" : dim "<<j<<"= "<<m_output_node_dims[j]);
            }
        }
    }
 
    /**************************************************************************************
    * m_input_node_dims[0] = -1; -1 needs to be replaced by the batch size; for no batch --> 1 
    * m_input_node_dims[1] should be equal to m_NNInputs.size()
    ****************************************************************************************/
    m_input_node_dims[0] = 1;
    m_output_node_dims[0] = 1;
 
    if (m_NNInputs.size()!=(long unsigned int)m_input_node_dims[1]) {
        ATH_MSG_FATAL("DNN input features not the same size as in config, will exit");
        return StatusCode::FAILURE;
    }
 
    // Set jet starting scale
    m_jetStartScale = "JetConstitScaleMomentum";
 
    return StatusCode::SUCCESS;
}

initMessaging()

void AthMessaging::initMessaging ( ) const

privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

{
  m_imsg = Athena::getMessageSvc();
  // If user did not set an explicit level, set a default
  if (m_lvl == MSG::NIL) {
    m_lvl = m_imsg ?
      static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
      MSG::INFO;
  }
}

msg() [1/2]

MsgStream & asg::AsgMessaging::msg ( ) const

inherited

The standard message stream.

Returns

A reference to the default message stream of this object.

Definition at line 49 of file AsgMessaging.cxx.

                                      {
#ifndef XAOD_STANDALONE
      return ::AthMessaging::msg();
#else // not XAOD_STANDALONE
      return m_msg;
#endif // not XAOD_STANDALONE
   }

msg() [2/2]

MsgStream & asg::AsgMessaging::msg ( const MSG::Level lvl ) const

inherited

The standard message stream.

Parameters

lvl	The message level to set the stream to

Returns

A reference to the default message stream, set to level "lvl"

Definition at line 57 of file AsgMessaging.cxx.

                                                          {
#ifndef XAOD_STANDALONE
      return ::AthMessaging::msg( lvl );
#else // not XAOD_STANDALONE
      m_msg << lvl;
      return m_msg;
#endif // not XAOD_STANDALONE
   }

msgLvl()

bool asg::AsgMessaging::msgLvl ( const MSG::Level lvl ) const

inherited

Test the output level of the object.

Parameters

lvl	The message level to test against

Returns

boolean Indicting if messages at given level will be printed

true If messages at level "lvl" will be printed

Definition at line 41 of file AsgMessaging.cxx.

                                                       {
#ifndef XAOD_STANDALONE
      return ::AthMessaging::msgLvl( lvl );
#else // not XAOD_STANDALONE
      return m_msg.msgLevel( lvl );
#endif // not XAOD_STANDALONE
   }

setLevel()

void AthMessaging::setLevel ( MSG::Level lvl )

inherited

Change the current logging level.

Use this rather than msg().setLevel() for proper operation with MT.

Definition at line 28 of file AthMessaging.cxx.

{
  m_lvl = lvl;
}

setStartP4()

StatusCode JetCalibrationStep::setStartP4 ( xAOD::Jet & jet ) const

protectedvirtualinherited

Definition at line 21 of file JetCalibrationStep.cxx.

                                                            {
  xAOD::JetFourMom_t tmp;
  if ( m_jetStartScale.compare("Default") == 0 ) {
    return StatusCode::SUCCESS;
  } else if ( jet.getAttribute<xAOD::JetFourMom_t>(m_jetStartScale.c_str(),tmp) ) {
    jet.setJetP4(tmp);
    return StatusCode::SUCCESS;
  }
  ATH_MSG_WARNING("Jet does not have the requested momentum state: " << m_jetStartScale);
  return StatusCode::FAILURE;
}

setUnitsGeV()

virtual void JetCalibrationStep::setUnitsGeV ( bool useGeV )

inlinevirtualinherited

Definition at line 28 of file JetCalibrationStep.h.

{ if (useGeV) m_GeV=1; else m_GeV=1000; }

Member Data Documentation

ATLAS_THREAD_SAFE

std::atomic_flag m_initialized AthMessaging::ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT

mutableprivateinherited

Messaging initialized (initMessaging).

Definition at line 141 of file AthMessaging.h.

m_calibArea

std::string GlobalLargeRDNNCalibration::m_calibArea

private

Definition at line 103 of file GlobalLargeRDNNCalibration.h.

m_config

TEnv* GlobalLargeRDNNCalibration::m_config {}

private

Definition at line 102 of file GlobalLargeRDNNCalibration.h.

{};

m_devMode

bool GlobalLargeRDNNCalibration::m_devMode {}

private

Definition at line 104 of file GlobalLargeRDNNCalibration.h.

{};

m_eScales

std::vector<double> GlobalLargeRDNNCalibration::m_eScales

private

Definition at line 89 of file GlobalLargeRDNNCalibration.h.

m_GeV

double JetCalibrationStep::m_GeV

protectedinherited

Definition at line 38 of file JetCalibrationStep.h.

m_imsg

std::atomic<IMessageSvc*> AthMessaging::m_imsg { nullptr }

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

{ nullptr };

m_input_node_dims

std::vector<int64_t> GlobalLargeRDNNCalibration::m_input_node_dims

private

Definition at line 97 of file GlobalLargeRDNNCalibration.h.

m_input_node_names

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

private

Definition at line 98 of file GlobalLargeRDNNCalibration.h.

m_jetStartScale

std::string JetCalibrationStep::m_jetStartScale

protectedinherited

Definition at line 39 of file JetCalibrationStep.h.

m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

{ MSG::NIL };

m_modelFileName

std::string GlobalLargeRDNNCalibration::m_modelFileName

private

Definition at line 92 of file GlobalLargeRDNNCalibration.h.

m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls

mutableprivateinherited

MsgStream instance (a std::cout like with print-out levels).

Definition at line 132 of file AthMessaging.h.

m_name

std::string JetCalibrationStep::m_name

protectedinherited

Definition at line 40 of file JetCalibrationStep.h.

m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

m_NNInputs

std::vector<TString> GlobalLargeRDNNCalibration::m_NNInputs

private

Definition at line 88 of file GlobalLargeRDNNCalibration.h.

m_noMassCalibBelow40

bool GlobalLargeRDNNCalibration::m_noMassCalibBelow40 =false

private

Definition at line 106 of file GlobalLargeRDNNCalibration.h.

m_NormOffsets

std::vector<double> GlobalLargeRDNNCalibration::m_NormOffsets

private

Definition at line 90 of file GlobalLargeRDNNCalibration.h.

m_NormScales

std::vector<double> GlobalLargeRDNNCalibration::m_NormScales

private

Definition at line 91 of file GlobalLargeRDNNCalibration.h.

m_output_node_dims

std::vector<int64_t> GlobalLargeRDNNCalibration::m_output_node_dims

private

Definition at line 99 of file GlobalLargeRDNNCalibration.h.

m_output_node_names

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

private

Definition at line 100 of file GlobalLargeRDNNCalibration.h.

m_session

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

private

Definition at line 96 of file GlobalLargeRDNNCalibration.h.

m_varretrievers

std::vector<VarRetriever*> GlobalLargeRDNNCalibration::m_varretrievers

private

Definition at line 94 of file GlobalLargeRDNNCalibration.h.

---

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

• GlobalLargeRDNNCalibration.h
• GlobalLargeRDNNCalibration.cxx