#include <MVAInputEvaluator.h>

Collaboration diagram for CP::MVAInputEvaluator:

Classes
class	MiniEvaluator

Public Types
enum	Input { Pt, Eta, M, D0, ErrD0, Z0, ErrZ0, Phi, ErrPhi, Theta, ErrTheta, QOverP, ErrQOverP, ChiSq, RedChiSq, D0Sig, DZ, ErrDZ, DZSinTheta, ErrDZSinTheta, FitWeight, VxX, ErrVxX, VxY, ErrVxY, VxZ, ErrVxZ }

typedef std::map< std::string, Input >	InputSelectionMap

typedef std::map< std::string, std::unique_ptr< MiniEvaluator > >	InputEvaluatorMap

Public Member Functions
	MVAInputEvaluator ()

	~MVAInputEvaluator ()

void	add (const std::string &name, const MVAInputEvaluator::Input &type)

void	load (const MVAInputEvaluator::InputSelectionMap &selection)

void	eval (const xAOD::TrackParticle &trk, const xAOD::Vertex &vx, const xAOD::EventInfo &evt, std::map< std::string, double > &input) const

void	clear ()

Private Attributes
InputEvaluatorMap	m_evalMap = {}

Detailed Description

Definition at line 19 of file MVAInputEvaluator.h.

Member Typedef Documentation

◆ InputEvaluatorMap

typedef std::map<std::string, std::unique_ptr<MiniEvaluator> > CP::MVAInputEvaluator::InputEvaluatorMap

Definition at line 67 of file MVAInputEvaluator.h.

◆ InputSelectionMap

typedef std::map<std::string, Input> CP::MVAInputEvaluator::InputSelectionMap

Definition at line 65 of file MVAInputEvaluator.h.

Member Enumeration Documentation

◆ Input

enum CP::MVAInputEvaluator::Input

Enumerator
Pt
Eta
M
D0
ErrD0
Z0
ErrZ0
Phi
ErrPhi
Theta
ErrTheta
QOverP
ErrQOverP
ChiSq
RedChiSq
D0Sig
DZ
ErrDZ
DZSinTheta
ErrDZSinTheta
FitWeight
VxX
ErrVxX
VxY
ErrVxY
VxZ
ErrVxZ

Definition at line 33 of file MVAInputEvaluator.h.

              {
     Pt,
     Eta,
     M,
     D0,
     ErrD0,
     Z0,
     ErrZ0,
     Phi,
     ErrPhi,
     Theta,
     ErrTheta,
     QOverP,
     ErrQOverP,
     ChiSq,
     RedChiSq,
     D0Sig,
     DZ,
     ErrDZ,
     DZSinTheta,
     ErrDZSinTheta,
     FitWeight,
     VxX,
     ErrVxX,
     VxY,
     ErrVxY,
     VxZ,
     ErrVxZ
   };

Constructor & Destructor Documentation

◆ MVAInputEvaluator()

CP::MVAInputEvaluator::MVAInputEvaluator ( )

inline

Definition at line 21 of file MVAInputEvaluator.h.

21 {};

◆ ~MVAInputEvaluator()

CP::MVAInputEvaluator::~MVAInputEvaluator ( )

Definition at line 302 of file MVAInputEvaluator.cxx.

                                       {
   clear();
 }

Member Function Documentation

◆ add()

void CP::MVAInputEvaluator::add	(	const std::string &	name,
		const MVAInputEvaluator::Input &	type
	)

Definition at line 306 of file MVAInputEvaluator.cxx.

                                                                                      {
   using Input = MVAInputEvaluator::Input;
   for (const auto& kv : m_evalMap) {
     if (name == kv.first) {
       throw std::runtime_error("ERROR in CP::MVAInputEvaluator::add : input name is already present in map: " + name);
     }
   }
   switch (type) {
     case Input::Pt: {
       m_evalMap[name] = std::make_unique<::Pt>(::Pt());
       break;
     }
     case Input::Eta: {
       m_evalMap[name] = std::make_unique<::Eta>(::Eta());
       break;
     }
     case Input::M: {
       m_evalMap[name] = std::make_unique<::M>(::M());
       break;
     }
     case Input::D0: {
       m_evalMap[name] = std::make_unique<::D0>(::D0());
       break;
     }
     case Input::ErrD0: {
       m_evalMap[name] = std::make_unique<::ErrD0>(::ErrD0());
       break;
     }
     case Input::Z0: {
       m_evalMap[name] = std::make_unique<::Z0>(::Z0());
       break;
     }
     case Input::ErrZ0: {
       m_evalMap[name] = std::make_unique<::ErrZ0>(::ErrZ0());
       break;
     }
     case Input::Phi: {
       m_evalMap[name] = std::make_unique<::Phi>(::Phi());
       break;
     }
     case Input::ErrPhi: {
       m_evalMap[name] = std::make_unique<::ErrPhi>(::ErrPhi());
       break;
     }
     case Input::Theta: {
       m_evalMap[name] = std::make_unique<::Theta>(::Theta());
       break;
     }
     case Input::ErrTheta: {
       m_evalMap[name] = std::make_unique<::ErrTheta>(::ErrTheta());
       break;
     }
     case Input::QOverP: {
       m_evalMap[name] = std::make_unique<::QOverP>(::QOverP());
       break;
     }
     case Input::ErrQOverP: {
       m_evalMap[name] = std::make_unique<::ErrQOverP>(::ErrQOverP());
       break;
     }
     case Input::ChiSq: {
       m_evalMap[name] = std::make_unique<::ChiSq>(::ChiSq());
       break;
     }
     case Input::RedChiSq: {
       m_evalMap[name] = std::make_unique<::RedChiSq>(::RedChiSq());
       break;
     }
     case Input::D0Sig: {
       m_evalMap[name] = std::make_unique<::D0Sig>(::D0Sig());
       break;
     }
     case Input::DZ: {
       m_evalMap[name] = std::make_unique<::DZ>(::DZ());
       break;
     }
     case Input::ErrDZ: {
       m_evalMap[name] = std::make_unique<::ErrDZ>(::ErrDZ());
       break;
     }
     case Input::DZSinTheta: {
       m_evalMap[name] = std::make_unique<::DZSinTheta>(::DZSinTheta());
       break;
     }
     case Input::ErrDZSinTheta: {
       m_evalMap[name] = std::make_unique<::ErrDZSinTheta>(::ErrDZSinTheta());
       break;
     }
     case Input::FitWeight: {
       m_evalMap[name] = std::make_unique<::FitWeight>(::FitWeight());
       break;
     }
     case Input::VxX: {
       m_evalMap[name] = std::make_unique<::VxX>(::VxX());
       break;
     }
     case Input::ErrVxX: {
       m_evalMap[name] = std::make_unique<::ErrVxX>(::ErrVxX());
       break;
     }
     case Input::VxY: {
       m_evalMap[name] = std::make_unique<::VxY>(::VxY());
       break;
     }
     case Input::ErrVxY: {
       m_evalMap[name] = std::make_unique<::ErrVxY>(::ErrVxY());
       break;
     }
     case Input::VxZ: {
       m_evalMap[name] = std::make_unique<::VxZ>(::VxZ());
       break;
     }
     case Input::ErrVxZ: {
       m_evalMap[name] = std::make_unique<::ErrVxZ>(::ErrVxZ());
       break;
     }
     default: {
       throw std::runtime_error("ERROR in CP::MVAInputEvaluator::add : unknown input enum: " + std::to_string(type));
     }
   }
   }

◆ clear()

void CP::MVAInputEvaluator::clear ( )

Definition at line 442 of file MVAInputEvaluator.cxx.

                               {
   m_evalMap.clear();
 }

◆ eval()

void CP::MVAInputEvaluator::eval	(	const xAOD::TrackParticle &	trk,
		const xAOD::Vertex &	vx,
		const xAOD::EventInfo &	evt,
		std::map< std::string, double > &	input
	)		const

Definition at line 435 of file MVAInputEvaluator.cxx.

                                                                                                                                                  {
   input.clear();
   for (const auto& kv : m_evalMap) {
     input[kv.first] = kv.second->eval(trk, vx, evt);
   }
   }

◆ load()

void CP::MVAInputEvaluator::load ( const MVAInputEvaluator::InputSelectionMap & selection )

Definition at line 428 of file MVAInputEvaluator.cxx.

                                                                                 {
   clear();
   for (const auto& kv : selection) {
     add(kv.first, kv.second);
   }
   }

Member Data Documentation

◆ m_evalMap

InputEvaluatorMap CP::MVAInputEvaluator::m_evalMap = {}

private

Definition at line 76 of file MVAInputEvaluator.h.

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

Classes

Public Types

Public Member Functions

Private Attributes