GeneralOptions Class Reference

General options which are shared by all MVA trainings. More...

#include <Options.h>

Inheritance diagram for GeneralOptions:

Public Member Functions
virtual void	load (const boost::property_tree::ptree &pt) override
	Load mechanism (used by Weightfile) to load Options from a xml tree.
virtual void	save (boost::property_tree::ptree &pt) const override
	Save mechanism (used by Weightfile) to store Options in a xml tree.
virtual po::options_description	getDescription () override
	Returns a program options description for all available options.

Public Attributes
std::string	m_method
	Name of the MVA method to use.
std::string	m_identifier
	Identifier containing the finished training.
std::vector< std::string >	m_datafiles
	Name of the datafiles containing the training data.
std::string	m_treename = "ntuple"
	Name of the TTree inside the datafile containing the training data.
std::vector< std::string >	m_variables
	Vector of all variables (branch names) used in the training.
std::vector< std::string >	m_spectators
	Vector of all spectators (branch names) used in the training.
int	m_signal_class = 1
	Signal class which is used as signal in a classification problem.
unsigned int	m_nClasses = 2
	Number of classes in a classification problem.
std::string	m_target_variable = "isSignal"
	Target variable (branch name) defining the target.
std::string	m_weight_variable = "__weight__"
	Weight variable (branch name) defining the weights.
unsigned int	m_max_events = 0
	Maximum number of events to process, 0 means all.

Detailed Description

General options which are shared by all MVA trainings.

Definition at line 62 of file Options.h.

Member Function Documentation

getDescription()

po::options_description getDescription ( )

overridevirtual

Returns a program options description for all available options.

Implements Options.

Definition at line 19 of file Options.cc.

    {
      po::options_description description("General options");
      description.add_options()
      ("help", "print this message")
      ("datafiles", po::value<std::vector<std::string>>(&m_datafiles)->required()->multitoken(),
       "ROOT files containing the training dataset")
      ("treename", po::value<std::string>(&m_treename), "Name of tree in ROOT datafile")
      ("identifier", po::value<std::string>(&m_identifier)->required(), "Identifier of the outputted weightfile")
      ("variables", po::value<std::vector<std::string>>(&m_variables)->required()->multitoken(),
       "feature variables used in the training")
      ("spectators", po::value<std::vector<std::string>>(&m_spectators)->multitoken(),
       "spectator variables used in the training")
      ("target_variable", po::value<std::string>(&m_target_variable),
       "target variable used to distinguish between signal and background, isSignal is used as default.")
      ("signal_class", po::value<int>(&m_signal_class), "integer which identifies signal events")
      ("nClasses", po::value<unsigned int>(&m_nClasses),
       "number of classes under consideration. Must be supplied for multiclass classifications. Not all methods support multiclass classification.")
      ("weight_variable", po::value<std::string>(&m_weight_variable), "weight variable used to weight each event")
      ("max_events", po::value<unsigned int>(&m_max_events), "maximum number of events to process, 0 means all")
      ("method", po::value<std::string>(&m_method)->required(),
       "MVA Method [FastBDT|TMVAClassification|TMVARegression|Python|FANN|]");
      return description;
    }

load()

void load ( const boost::property_tree::ptree &  pt )

overridevirtual

Load mechanism (used by Weightfile) to load Options from a xml tree.

Parameters

pt

xml tree

Implements Options.

Definition at line 44 of file Options.cc.

    {
      m_method = pt.get<std::string>("method");
      m_identifier = pt.get<std::string>("weightfile");
      m_treename = pt.get<std::string>("treename");
      m_target_variable = pt.get<std::string>("target_variable");
      m_weight_variable = pt.get<std::string>("weight_variable");
      m_signal_class = pt.get<int>("signal_class");
      m_max_events = pt.get<unsigned int>("max_events", 0u);
      m_nClasses = pt.get<unsigned int>("nClasses", 2u);
 
      unsigned int numberOfFiles = pt.get<unsigned int>("number_data_files", 0);
      m_datafiles.resize(numberOfFiles);
      for (unsigned int i = 0; i < numberOfFiles; ++i) {
        m_datafiles[i] = pt.get<std::string>(std::string("datafile") + std::to_string(i));
      }
 
      unsigned int numberOfSpectators = pt.get<unsigned int>("number_spectator_variables", 0u);
      m_spectators.resize(numberOfSpectators);
      for (unsigned int i = 0; i < numberOfSpectators; ++i) {
        m_spectators[i] = pt.get<std::string>(std::string("spectator") + std::to_string(i));
      }
 
      auto numberOfFeatures = pt.get<unsigned int>("number_feature_variables");
      m_variables.resize(numberOfFeatures);
      for (unsigned int i = 0; i < numberOfFeatures; ++i) {
        m_variables[i] = pt.get<std::string>(std::string("variable") + std::to_string(i));
      }
    }

save()

void save ( boost::property_tree::ptree &  pt ) const

overridevirtual

Save mechanism (used by Weightfile) to store Options in a xml tree.

Parameters

pt

xml tree

Implements Options.

Definition at line 74 of file Options.cc.

    {
      pt.put("method", m_method);
      pt.put("weightfile", m_identifier);
      pt.put("treename", m_treename);
      pt.put("target_variable", m_target_variable);
      pt.put("weight_variable", m_weight_variable);
      pt.put("signal_class", m_signal_class);
      pt.put("max_events", m_max_events);
      pt.put("nClasses", m_nClasses);
 
      pt.put("number_feature_variables", m_variables.size());
      for (unsigned int i = 0; i < m_variables.size(); ++i) {
        pt.put(std::string("variable") + std::to_string(i), m_variables[i]);
      }
 
      pt.put("number_spectator_variables", m_spectators.size());
      for (unsigned int i = 0; i < m_spectators.size(); ++i) {
        pt.put(std::string("spectator") + std::to_string(i), m_spectators[i]);
      }
 
      pt.put("number_data_files", m_datafiles.size());
      for (unsigned int i = 0; i < m_datafiles.size(); ++i) {
        pt.put(std::string("datafile") + std::to_string(i), m_datafiles[i]);
      }
    }

Member Data Documentation

m_datafiles

std::vector<std::string> m_datafiles

Name of the datafiles containing the training data.

Definition at line 84 of file Options.h.

m_identifier

std::string m_identifier

Identifier containing the finished training.

Definition at line 83 of file Options.h.

m_max_events

unsigned int m_max_events = 0

Maximum number of events to process, 0 means all.

Definition at line 92 of file Options.h.

m_method

std::string m_method

Name of the MVA method to use.

Definition at line 82 of file Options.h.

m_nClasses

unsigned int m_nClasses = 2

Number of classes in a classification problem.

Definition at line 89 of file Options.h.

m_signal_class

int m_signal_class = 1

Signal class which is used as signal in a classification problem.

Definition at line 88 of file Options.h.

m_spectators

std::vector<std::string> m_spectators

Vector of all spectators (branch names) used in the training.

Definition at line 87 of file Options.h.

m_target_variable

std::string m_target_variable = "isSignal"

Target variable (branch name) defining the target.

Definition at line 90 of file Options.h.

m_treename

std::string m_treename = "ntuple"

Name of the TTree inside the datafile containing the training data.

Definition at line 85 of file Options.h.

m_variables

std::vector<std::string> m_variables

Vector of all variables (branch names) used in the training.

Definition at line 86 of file Options.h.

m_weight_variable

std::string m_weight_variable = "__weight__"

Weight variable (branch name) defining the weights.

Definition at line 91 of file Options.h.

---

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

• mva/interface/include/Options.h
• mva/interface/src/Options.cc