#include <TauGNNDataLoader.h>

Inheritance diagram for TauGNNDataLoader:

Collaboration diagram for TauGNNDataLoader:

Classes
struct	Config

Public Member Functions
	TauGNNDataLoader (std::shared_ptr< const FlavorTagInference::SaltModel > salt_model, const Config &config)

	~TauGNNDataLoader ()=default

void	addScalarLoader (const std::string &varName, std::function< float(const xAOD::IParticle *)> loader)

void	addVectorLoader (const std::string &vecName, std::shared_ptr< IConstituentsLoader > loader)

virtual SaltModelData	loadInputs (const xAOD::IParticle *p) const final

void	DumpGnnInputs (const SaltModelInputs &gnn_inputs) const

void	setLevel (MSG::Level lvl)
	Change the current logging level. More...

Public Attributes
SaltModelGraphConfig::GraphConfig	graph_config

std::string	scalarInputName

std::vector< std::pair< std::string, std::function< float(const xAOD::IParticle *)> > >	scalarVarLoaders

std::map< std::string, std::shared_ptr< IConstituentsLoader > >	vectorVarLoaders

Private Types
using	ScalarCalcByRef_t = std::function< bool(const xAOD::TauJet &, float &)>

using	ScalarCalc_t = std::function< float(const xAOD::IParticle *)>

Private Member Functions
ScalarCalc_t	getScalarCalc (const std::string &name) const

void	initMessaging () const
	Initialize our message level and MessageSvc. More...

Private Attributes
std::string	m_nm
	Message source name. More...

boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels) More...

std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer. More...

std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level. More...

std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging) More...

Static Private Attributes
static const std::unordered_map< std::string, ScalarCalcByRef_t >	m_func_map

Detailed Description

Definition at line 57 of file TauGNNDataLoader.h.

Member Typedef Documentation

◆ ScalarCalc_t

using TauGNNDataLoader::ScalarCalc_t = std::function<float(const xAOD::IParticle*)>

private

Definition at line 80 of file TauGNNDataLoader.h.

◆ ScalarCalcByRef_t

using TauGNNDataLoader::ScalarCalcByRef_t = std::function<bool(const xAOD::TauJet &, float &)>

private

Definition at line 79 of file TauGNNDataLoader.h.

Constructor & Destructor Documentation

◆ TauGNNDataLoader()

TauGNNDataLoader::TauGNNDataLoader	(	std::shared_ptr< const FlavorTagInference::SaltModel >	salt_model,
		const Config &	config
	)

Definition at line 10 of file TauGNNDataLoader.cxx.

   :
     FlavorTagInference::SaltModelEDMLoaderBase(salt_model),
     asg::AsgMessaging("TauGNNDataLoader")
   {
     scalarInputName = config.input_layer_scalar;
     const FlavorTagInference::SaltModelGraphConfig::InputNodeConfig* scalar_input_node = nullptr;
     const FlavorTagInference::SaltModelGraphConfig::InputNodeConfig* track_input_node = nullptr;
     const FlavorTagInference::SaltModelGraphConfig::InputNodeConfig* cluster_input_node = nullptr;
     for (const auto &in_node : graph_config.inputs) {
         if (in_node.name == config.input_layer_scalar) {
             scalar_input_node = &in_node;
             ATH_MSG_DEBUG("Found scalar input node: " << in_node.name);
             break;
         }
     }
     for (const auto &in_node : graph_config.input_sequences) {
         if (in_node.name == config.input_layer_tracks) {
             track_input_node = &in_node;
             ATH_MSG_DEBUG("Found track input node: " << in_node.name);
         }
         if (in_node.name == config.input_layer_clusters) {
             cluster_input_node = &in_node;
             ATH_MSG_DEBUG("Found cluster input node: " << in_node.name);
         }
     }
  
     // Fill the variable names of each input layer into the corresponding vector
     if (scalar_input_node) {
         for (const auto &in : scalar_input_node->variables) {
             addScalarLoader(in.name, getScalarCalc(in.name));
         }
     } else {
         ATH_MSG_ERROR("Scalar input node 'tau_vars' not found in the model input configuration");
         throw std::runtime_error("Scalar input node 'tau_vars' not found in the model input configuration");
     }
  
     if (track_input_node) {
         FlavorTagInference::ConstituentsInputConfig trk_config;
         trk_config.name = "tautracks";
         trk_config.output_name = config.input_layer_tracks;
         trk_config.type = FlavorTagInference::ConstituentsType::TAUTRACK;
         trk_config.order = FlavorTagInference::ConstituentsSortOrder::PT_DESCENDING;
         trk_config.max_n_constituents = config.n_max_tracks;
         trk_config.selection = config.trackClassification ? FlavorTagInference::ConstituentsSelection::TAUTRACK_CLASSIFIED : FlavorTagInference::ConstituentsSelection::ALL;
         trk_config.inputs = {};
         for (const auto &in : track_input_node->variables) {
             if (!config.useTRT && (in.name == "eProbabilityHT")) {
                 ATH_MSG_WARNING("Track variable 'eProbabilityHT' requested but useTRT set to false. Using 'eProbabilityHT_noTRT' instead.");
                 trk_config.inputs.push_back({"eProbabilityHT_noTRT", FlavorTagInference::ConstituentsEDMType::CUSTOM_GETTER, false});
                 continue;
             }
             trk_config.inputs.push_back({in.name, FlavorTagInference::ConstituentsEDMType::CUSTOM_GETTER, false});
         }
         addVectorLoader(config.input_layer_tracks, std::make_shared<FlavorTagInference::ConstituentLoaderTauTrack>(trk_config));
     } else {
         ATH_MSG_ERROR("Track input node '" + config.input_layer_tracks + "' not found in the model input configuration");
         throw std::runtime_error("Track input node '" + config.input_layer_tracks + "' not found in the model input configuration");
     }
  
     if (cluster_input_node) {
         FlavorTagInference::ConstituentsInputConfig cls_config;
         cls_config.name = "tauclusters";
         cls_config.output_name = config.input_layer_clusters;
         cls_config.type = FlavorTagInference::ConstituentsType::TAUCLUSTER;
         cls_config.order = FlavorTagInference::ConstituentsSortOrder::PT_DESCENDING;
         cls_config.max_n_constituents = config.n_max_clusters;
         cls_config.selection = FlavorTagInference::ConstituentsSelection::ALL;
         cls_config.inputs = {};
         for (const auto &in : cluster_input_node->variables) {
             cls_config.inputs.push_back({in.name, FlavorTagInference::ConstituentsEDMType::CUSTOM_GETTER, false});
         }
         addVectorLoader(config.input_layer_clusters, std::make_shared<FlavorTagInference::ConstituentLoaderTauCluster>(cls_config, config.max_dr_cluster, config.doVertexCorrection));
     } else {
         ATH_MSG_ERROR("Cluster input node '" + config.input_layer_clusters + "' not found in the model input configuration");
         throw std::runtime_error("Cluster input node '" + config.input_layer_clusters + "' not found in the model input configuration");
     }
 }

◆ ~TauGNNDataLoader()

TauGNNDataLoader::~TauGNNDataLoader ( )

default

Member Function Documentation

◆ addScalarLoader()

void FlavorTagInference::SaltModelEDMLoaderBase::addScalarLoader	(	const std::string &	varName,
		std::function< float(const xAOD::IParticle *)>	loader
	)

inlineinherited

Definition at line 41 of file SaltModelEDMLoaderBase.h.

                                                                                                         {
             scalarVarLoaders.emplace_back(varName, loader);
         }

◆ addVectorLoader()

void FlavorTagInference::SaltModelEDMLoaderBase::addVectorLoader	(	const std::string &	vecName,
		std::shared_ptr< IConstituentsLoader >	loader
	)

inlineinherited

Definition at line 45 of file SaltModelEDMLoaderBase.h.

                                                                                                   {
             vectorVarLoaders.try_emplace(vecName, std::move(loader));
         }

◆ DumpGnnInputs()

void FlavorTagInference::SaltModelEDMLoaderBase::DumpGnnInputs ( const SaltModelInputs & gnn_inputs ) const

inlineinherited

Definition at line 73 of file SaltModelEDMLoaderBase.h.

                                                                     {
             // Implementation for dumping GNN input data
             std::cout << "-------- Dumping GNN Input Data --------" << std::endl;
  
             for (const auto& [name, inputs] : gnn_inputs) {
                 std::cout << "Input Name: " << name << std::endl;
                 std::cout << "  vec floats: ";
                 for (const auto& feature : inputs.first) {
                     std::cout << feature << " ";
                 }
                 std::cout << std::endl;
                 std::cout << "  vec ints  : ";
                 for (const auto& id : inputs.second) {
                     std::cout << id << " ";
                 }
                 std::cout << std::endl;
             }
             std::cout << "---------- END GNN Input Data ----------" << std::endl;
         }

◆ getScalarCalc()

ScalarCalc_t TauGNNDataLoader::getScalarCalc ( const std::string & name ) const

private

Definition at line 91 of file TauGNNDataLoader.cxx.

                                                                         {
     // Retrieve calculator function
     ScalarCalcByRef_t func = nullptr;
     try {
         func = m_func_map.at(name);
     } catch (const std::out_of_range &e) {
         ATH_MSG_ERROR("Variable '" << name << "' not defined");
         throw std::runtime_error("Variable '" + name + "' not defined");
     }
     return [func](const xAOD::IParticle* p) {
         auto tau = dynamic_cast<const xAOD::TauJet*>(p);
         float out;
         if (!tau) {
             throw std::runtime_error("Invalid TauJet pointer");
         }
         auto success = func(*tau, out);
         if (!success) {
             throw std::runtime_error("Error in scalar variable calculation ");
         }
         return out;
     };
 }

◆ 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();
   m_lvl = m_imsg ?
     static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
     MSG::INFO;
 }

◆ loadInputs()

virtual SaltModelData FlavorTagInference::SaltModelEDMLoaderBase::loadInputs ( const xAOD::IParticle * p ) const

inlinefinalvirtualinherited

Definition at line 49 of file SaltModelEDMLoaderBase.h.

                                                                              {
             SaltModelData salt_model_data;
             // loading scalar inputs.
             std::vector<float> scalar_feat;
             for (const auto& varLoader : scalarVarLoaders) {
                 std::string varName = varLoader.first;
                 scalar_feat.push_back(varLoader.second(p));
             }
             std::vector<int64_t> scalar_feat_dim = {1, static_cast<int64_t>(scalar_feat.size())};
             Inputs scalar_inputs(scalar_feat, scalar_feat_dim);
             salt_model_data.gnn_inputs.insert({scalarInputName, scalar_inputs});
  
             //load vector inputs.
             for (auto loader : vectorVarLoaders) {
                 std::string input_name = loader.first;
                 auto [input_data, input_objects] = loader.second->getData(*p);
  
                 salt_model_data.gnn_inputs.insert({input_name, input_data});
                 salt_model_data.num_inputs += input_data.first.size();
                 salt_model_data.constituents[input_name] = input_objects;
             }
             return salt_model_data;
         }

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

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.

◆ graph_config

SaltModelGraphConfig::GraphConfig FlavorTagInference::SaltModelEDMLoaderBase::graph_config

inherited

Definition at line 35 of file SaltModelEDMLoaderBase.h.

◆ m_func_map

const std::unordered_map<std::string, ScalarCalcByRef_t> TauGNNDataLoader::m_func_map

inlinestaticprivate

Initial value:

= {
            {"isolFrac",                  TauScalarVars::isolFrac},
            {"centFrac",                  TauScalarVars::centFrac},
            {"etOverPtLeadTrk",           TauScalarVars::etOverPtLeadTrk},
            {"innerTrkAvgDist",           TauScalarVars::innerTrkAvgDist},
            {"absipSigLeadTrk",           TauScalarVars::absipSigLeadTrk},
            {"SumPtTrkFrac",              TauScalarVars::SumPtTrkFrac},
            {"sumEMCellEtOverLeadTrkPt",  TauScalarVars::sumEMCellEtOverLeadTrkPt},
            {"EMPOverTrkSysP",            TauScalarVars::EMPOverTrkSysP},
            {"ptRatioEflowApprox",        TauScalarVars::ptRatioEflowApprox},
            {"mEflowApprox",              TauScalarVars::mEflowApprox},
            {"dRmax",                     TauScalarVars::dRmax},
            {"trFlightPathSig",           TauScalarVars::trFlightPathSig},
            {"massTrkSys",                TauScalarVars::massTrkSys},
            {"pt",                        TauScalarVars::pt}
        }

Definition at line 82 of file TauGNNDataLoader.h.

◆ m_imsg

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

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

◆ m_lvl

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

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.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_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

◆ scalarInputName

std::string FlavorTagInference::SaltModelEDMLoaderBase::scalarInputName

inherited

Definition at line 36 of file SaltModelEDMLoaderBase.h.

◆ scalarVarLoaders

std::vector<std::pair<std::string , std::function<float(const xAOD::IParticle* )> > > FlavorTagInference::SaltModelEDMLoaderBase::scalarVarLoaders

inherited

Definition at line 37 of file SaltModelEDMLoaderBase.h.

◆ vectorVarLoaders

std::map<std::string , std::shared_ptr<IConstituentsLoader> > FlavorTagInference::SaltModelEDMLoaderBase::vectorVarLoaders

inherited

Definition at line 38 of file SaltModelEDMLoaderBase.h.

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

Classes

Public Member Functions

Public Attributes

Private Types

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Member Typedef Documentation

◆ ScalarCalc_t

◆ ScalarCalcByRef_t

Constructor & Destructor Documentation

◆ TauGNNDataLoader()

◆ ~TauGNNDataLoader()

Member Function Documentation

◆ addScalarLoader()

◆ addVectorLoader()

◆ DumpGnnInputs()

◆ getScalarCalc()

◆ initMessaging()

◆ loadInputs()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ setLevel()

Member Data Documentation

◆ ATLAS_THREAD_SAFE

◆ graph_config

◆ m_func_map

◆ m_imsg

◆ m_lvl

◆ m_msg_tls

◆ m_nm

◆ scalarInputName

◆ scalarVarLoaders

◆ vectorVarLoaders