Ringer::onnx::RingerSelector Class Reference

#include <RingerSelector.h>

Inheritance diagram for Ringer::onnx::RingerSelector:

Collaboration diagram for Ringer::onnx::RingerSelector:

Public Member Functions
	RingerSelector (const std::string &name)
	Standard constructor.
	~RingerSelector ()=default
	Standard destructor.
StatusCode	read_from (const std::string &, AthOnnx::IOnnxRuntimeSvc *)
	read tunings from configuration file
std::vector< std::vector< float > >	prepare_inputs (unsigned barcode, const xAOD::TrigRingerRings *, const xAOD::TrigElectron *) const
	prepare all inputs
float	predict (const xAOD::TrigRingerRings *, const xAOD::TrigElectron *) const
	Calculation of model output.
bool	accept (const xAOD::TrigRingerRings *, float discr, float mu) const
	Accept method.
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.

Private Member Functions
template<typename T>
bool	strtof (const std::string &input, T &f)
	parse tenv string into list with type T
template<typename T>
std::vector< T >	GetValues (const std::string &input, TEnv &env)
	Get the list of values inside of tenv.
std::vector< std::string >	GetPaths (const std::string &input, TEnv &env)
	Get the list of paths inside of tenv.
std::string	GetBasePath (const std::string &path) const
	Get basepath from calib path.
void	initMessaging () const
	Initialize our message level and MessageSvc.

Private Attributes
std::vector< Ringer::onnx::Model >	m_models
	hold all onnx sessions
std::vector< Ringer::onnx::Threshold >	m_thresholds
	hold all thresholds definitions
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 27 of file RingerSelector.h.

Constructor & Destructor Documentation

RingerSelector()

Ringer::onnx::RingerSelector::RingerSelector

(

const std::string &

name

)

Standard constructor.

Definition at line 20 of file RingerSelector.cxx.

                                                       :
      asg::AsgMessaging(name)
    {;}

~RingerSelector()

Ringer::onnx::RingerSelector::~RingerSelector ( )

default

Standard destructor.

Member Function Documentation

accept()

bool Ringer::onnx::RingerSelector::accept	(	const xAOD::TrigRingerRings *	ringsCluster,
		float	discr,
		float	mu ) const

Accept method.

Definition at line 109 of file RingerSelector.cxx.

    {
      float et = ringsCluster->emCluster()->et();
      float eta = std::abs(ringsCluster->emCluster()->eta());
    
      ATH_MSG_DEBUG( "Event et = "<< et << ", eta = " << eta );
      for( auto& cutDef : m_thresholds ){
        if ( et < cutDef.etMin()*Gaudi::Units::GeV || et >= cutDef.etMax()*Gaudi::Units::GeV ) continue;
        if ( eta < cutDef.etaMin() || eta >= cutDef.etaMax() ) continue;
        return cutDef.accept( discr, avgmu );
      }// loop over all thresholds
    
      return false;
    }

GetBasePath()

std::string Ringer::onnx::RingerSelector::GetBasePath ( const std::string & path ) const

private

Get basepath from calib path.

Definition at line 286 of file RingerSelector.cxx.

                                                                     {
      // Get the normalized parent path
      std::string ret = std::filesystem::path(path).parent_path().lexically_normal().string();
      if (!ret.empty() && ret.front()=='/') ret.erase(0, 1);
      return ret;
    }

GetPaths()

std::vector< std::string > Ringer::onnx::RingerSelector::GetPaths ( const std::string & input, TEnv & env )

private

Get the list of paths inside of tenv.

Definition at line 269 of file RingerSelector.cxx.

    {
      std::vector<std::string> CutVector;    
      std::string env_input(env.GetValue(input.c_str(), ""));
      if (!env_input.empty()) {
        std::string::size_type end;
        do {
          end = env_input.find(';');
          CutVector.push_back( env_input.substr(0,end) );
          if (end != std::string::npos) {
            env_input= env_input.substr(end+2);
          }
        } while (end != std::string::npos);     
      }
      return CutVector;
    }

GetValues()

template<typename T>

std::vector< T > Ringer::onnx::RingerSelector::GetValues ( const std::string & input, TEnv & env )

private

Get the list of values inside of tenv.

Definition at line 247 of file RingerSelector.cxx.

    {    
      std::vector<T> CutVector;    
      std::string env_input(env.GetValue(input.c_str(), ""));
      if (!env_input.empty()) {
        std::string::size_type end;
        do {
          end = env_input.find(';');
          T  myValue(0);
          if(strtof(env_input.substr(0,end),myValue)){
            CutVector.push_back(myValue);
          }
          if (end != std::string::npos) {
            env_input= env_input.substr(end+1);
          }
        } while (end != std::string::npos);     
      }
      return CutVector;
    }

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
   }

predict()

float Ringer::onnx::RingerSelector::predict	(	const xAOD::TrigRingerRings *	ringsCluster,
		const xAOD::TrigElectron *	el ) const

Calculation of model output.

Definition at line 126 of file RingerSelector.cxx.

    {
      float et = ringsCluster->emCluster()->et();
      float eta = std::abs(ringsCluster->emCluster()->eta());
 
      // Find the correct model and predict
      for( auto& model : m_models ){
        
        if(et<model.etMin()*Gaudi::Units::GeV   || et  >= model.etMax()*Gaudi::Units::GeV ) continue;
        if(eta<model.etaMin() || eta >= model.etaMax()) continue;
        auto inputs = prepare_inputs( model.barcode(), ringsCluster, el );
        auto output = model.predict( inputs ); // propagate the input throut the model
        ATH_MSG_DEBUG( "The current model predict with output: " << output );
        return output;
      }
 
      ATH_MSG_DEBUG("There is no model available for this cluster.");
      return -999;
    }

prepare_inputs()

std::vector< std::vector< float > > Ringer::onnx::RingerSelector::prepare_inputs	(	unsigned	barcode,
		const xAOD::TrigRingerRings *	ringsCluster,
		const xAOD::TrigElectron *	) const

prepare all inputs

Definition at line 151 of file RingerSelector.cxx.

    {
      std::vector< std::vector< float > > inputs;
 
      // Barcode 0 for all rings normalized by the total energy
      if ( PreprocessingMode == 0 ){ 
        const std::vector<float> rings = ringsCluster->rings();
        std::vector<float> refRings(rings.size());
        refRings.assign(rings.begin(), rings.end());
        float energy=0.0;
        for(auto &ring : refRings ) energy+=ring;
 
        if (energy > 0){
          for(auto &ring : refRings ) ring/=energy;
        }
        
        inputs.push_back( refRings );
 
      // Barcode 1 for half rings normalized by the total energy
      }else if ( PreprocessingMode == 1){
 
        const std::vector<float> rings = ringsCluster->rings();
        std::vector<float> refRings(rings.size());
        refRings.assign(rings.begin(), rings.end());
 
        std::vector<float> halfRings; 
        
        constexpr int PS   = 8;
        constexpr int EM1  = 64;
        constexpr int EM2  = 8;
        constexpr int EM3  = 8;
        constexpr int HAD1 = 4;
        constexpr int HAD2 = 4;
        constexpr int HAD3 = 4;
 
        halfRings.insert(halfRings.end(), refRings.begin(), refRings.begin() + PS/2);
        halfRings.insert(halfRings.end(), refRings.begin() + PS, refRings.begin() + PS + (EM1/2));
        halfRings.insert(halfRings.end(), refRings.begin() + PS + EM1, refRings.begin() + PS + EM1 + (EM2/2));
        halfRings.insert(halfRings.end(), refRings.begin() + PS + EM1 + EM2, refRings.begin() + PS + EM1 + EM2 + (EM3/2));
        halfRings.insert(halfRings.end(), refRings.begin() + PS + EM1 + EM2 + EM3, refRings.begin() + PS + EM1 + EM2 + EM3 + (HAD1/2));
        halfRings.insert(halfRings.end(), refRings.begin() + PS + EM1 + EM2 + EM3 + HAD1, refRings.begin() + PS + EM1 + EM2 + EM3 + HAD1 + (HAD2/2));
        halfRings.insert(halfRings.end(), refRings.begin() + PS + EM1 + EM2 + EM3 + HAD1 + HAD2, refRings.begin() + PS + EM1 + EM2 + EM3 + HAD1 + HAD2 + (HAD3/2));
 
        // concatenate
        float energy=0.0;
        for(auto &ring : halfRings ) energy+=ring;
 
        if (energy > 0){
          for(auto &ring : halfRings ) ring/=energy;
        }
 
        inputs.push_back( halfRings );
      }
 
      return inputs;
    }

read_from()

StatusCode Ringer::onnx::RingerSelector::read_from	(	const std::string &	path,
		AthOnnx::IOnnxRuntimeSvc *	svc )

read tunings from configuration file

Definition at line 26 of file RingerSelector.cxx.

    {
 
      std::string configFile = PathResolverFindCalibFile( path );
      std::string basepath = GetBasePath( path );
 
      ATH_MSG_INFO( "Loading all tunings configs from " << configFile );
      ATH_MSG_INFO( "Basepath is "<< basepath);
 
      if (configFile.empty()){
         ATH_MSG_ERROR( "Could not locate the config file: " << configFile);
         return StatusCode::FAILURE; 
      }
 
      // Read configuration file
      TEnv env(configFile.c_str());
   
 
      // Retrieve all models
      {
        // Retrieve the size
        unsigned size = env.GetValue( "Model__size" , 0 );
        auto PreprocessingMode = GetValues<int>( "Model__barcode", env); // select the input preprocessing mode
          
        // Retrieve Et bins
        auto etmin = GetValues<float>( "Model__etmin", env );
        auto etmax  = GetValues<float>( "Model__etmax", env );
        
        // Retrieve Eta bins
        auto etamin = GetValues<float>( "Model__etamin", env );
        auto etamax  = GetValues<float>( "Model__etamax", env );
        
        // Retreive all ONNX model file paths
        auto model_paths = GetPaths( "Model__path", env );
 
        // Loop over all models
        for ( unsigned idx = 0; idx < size; ++idx )
        {
          std::string modelPath = PathResolverFindCalibFile( basepath+"/"+model_paths[idx] );
          ATH_MSG_DEBUG( "Reading Onnx model from: " << modelPath );
          auto model = Ringer::onnx::Model( modelPath, svc, etmin[idx], etmax[idx], etamin[idx], etamax[idx], PreprocessingMode[idx]) ;
          // Compile the model
          model.compile();
          m_models.push_back(model);
        }
      }
 
      // Retrieve all thresholds
      {
        // Retrieve the size
         unsigned size = env.GetValue( "Threshold__size" , 0);
         auto max_avgmu = GetValues<float>( "Threshold__MaxAverageMu", env );
         
         // Retrieve Et bins
         auto etmin = GetValues<float>( "Threshold__etmin", env );
         auto etmax = GetValues<float>( "Threshold__etmax", env );
         // Retrieve Eta bins
         auto etamin  = GetValues<float>( "Threshold__etamin", env );
         auto etamax  = GetValues<float>( "Threshold__etamax", env );
         // Retrieve slopes
         auto slopes = GetValues<float>( "Threshold__slope", env );
         // Retrieve offsets
         auto offsets = GetValues<float>("Threshold__offset", env );
 
         for ( unsigned idx = 0; idx <size; ++idx ){
           m_thresholds.push_back( Ringer::onnx::Threshold(
                                     etmin[idx],
                                     etmax[idx],
                                     etamin[idx],
                                     etamax[idx],
                                     slopes[idx],
                                     offsets[idx],
                                     max_avgmu[idx])
                                 );
          }
      }
 
      return StatusCode::SUCCESS;
    }

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

strtof()

template<typename T>

bool Ringer::onnx::RingerSelector::strtof ( const std::string & input, T & f )

private

parse tenv string into list with type T

Definition at line 216 of file RingerSelector.cxx.

    {  
      int diff = 0 ;
      std::string tmp = input;
      std::string::size_type first(0);
      std::string::size_type last(0);
      first = ( input.find('#') ) ;
 
      //if we do not find a comment character "#" we are fine
      if (first == std::string::npos) {
        std::istringstream buffer (tmp);
        buffer>>f;
        return true;
      } 
      
      //if we have found comment character check if it is inlined between two "#"
      last = (input.find('#',first+1) );
      //if nor error
      if (last == std::string::npos) {
        return false;
      }
      //else if between two "#" remove this part 
      diff = last - first ;
      tmp= tmp.erase(first,diff+1);
      std::istringstream buffer (tmp);
      buffer>>f;
      return true;
    }

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_imsg

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

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

{ nullptr };

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_models

std::vector< Ringer::onnx::Model > Ringer::onnx::RingerSelector::m_models

private

hold all onnx sessions

Definition at line 66 of file RingerSelector.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.

m_thresholds

std::vector< Ringer::onnx::Threshold > Ringer::onnx::RingerSelector::m_thresholds

private

hold all thresholds definitions

Definition at line 68 of file RingerSelector.h.

---

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

• RingerSelector.h
• RingerSelector.cxx