ROOTDataset Class Reference

Proivdes a dataset from a ROOT file This is the usually used dataset providing training data to the mva methods. More...

#include <Dataset.h>

Inheritance diagram for ROOTDataset:

Public Member Functions
	ROOTDataset (const GeneralOptions &_general_options)
	Creates a new ROOTDataset.
virtual unsigned int	getNumberOfFeatures () const override
	Returns the number of features in this dataset.
virtual unsigned int	getNumberOfSpectators () const override
	Returns the number of features in this dataset.
virtual unsigned int	getNumberOfEvents () const override
	Returns the number of events in this dataset.
virtual void	loadEvent (unsigned int event) override
	Load the event number iEvent from the TTree.
virtual std::vector< float >	getFeature (unsigned int iFeature) override
	Returns all values of one feature in a std::vector<float>
virtual std::vector< float >	getWeights () override
	Returns all values of of the weights in a std::vector<float>
virtual std::vector< float >	getSpectator (unsigned int iSpectator) override
	Returns all values of one spectator in a std::vector<float>
virtual	~ROOTDataset ()
	Virtual destructor.
virtual float	getSignalFraction ()
	Returns the signal fraction of the whole sample.
virtual unsigned int	getFeatureIndex (const std::string &feature)
	Return index of feature with the given name.
virtual unsigned int	getSpectatorIndex (const std::string &spectator)
	Return index of spectator with the given name.
virtual std::vector< float >	getTargets ()
	Returns all targets.
virtual std::vector< bool >	getSignals ()
	Returns all is Signals.

Public Attributes
GeneralOptions	m_general_options
	GeneralOptions passed to this dataset.
std::vector< float >	m_input
	Contains all feature values of the currently loaded event.
std::vector< float >	m_spectators
	Contains all spectators values of the currently loaded event.
float	m_weight
	Contains the weight of the currently loaded event.
float	m_target
	Contains the target value of the currently loaded event.
bool	m_isSignal
	Defines if the currently loaded event is signal or background.

Protected Types
typedef std::variant< double, float, int, bool >	RootDatasetVarVariant
	Typedef for variable types supported by the mva ROOTDataset, can be one of double, float, int or bool in std::variant.

Protected Attributes
TChain *	m_tree = nullptr
	Pointer to the TChain containing the data.
std::vector< RootDatasetVarVariant >	m_input_variant
	Contains all feature values of the currently loaded event.
std::vector< RootDatasetVarVariant >	m_spectators_variant
	Contains all spectators values of the currently loaded event.
RootDatasetVarVariant	m_weight_variant
	Contains the weight of the currently loaded event.
RootDatasetVarVariant	m_target_variant
	Contains the target value of the currently loaded event.

Private Member Functions
template<class T >
std::vector< float >	getVectorFromTTree (const std::string &variableType, const std::string &branchName, T &memberVariableTarget)
	Returns all values for a specified variableType and branchName.
std::vector< float >	getVectorFromTTreeVariant (const std::string &variableType, const std::string &branchName, RootDatasetVarVariant &memberVariableTarget)
	Returns all values for a specified variableType and branchName.
void	setRootInputType ()
	Tries to infer the data-type of the spectator and feature variables in a root file.
template<class T >
void	setScalarVariableAddress (const std::string &variableType, const std::string &variableName, T &variableTarget)
	sets the branch address for a scalar variable to a given target
void	setScalarVariableAddressVariant (const std::string &variableType, const std::string &variableName, RootDatasetVarVariant &variableTarget)
	sets the branch address for a scalar variable to a given target
template<class T >
void	setVectorVariableAddress (const std::string &variableType, const std::vector< std::string > &variableName, T &variableTargets)
	sets the branch address for a vector variable to a given target
void	setVectorVariableAddressVariant (const std::string &variableType, const std::vector< std::string > &variableName, std::vector< RootDatasetVarVariant > &varVariantTargets)
	sets the branch address for a vector of VarVariant to a given target
void	setTargetRootInputType ()
	Determines the data type of the target variable and sets it to m_target_data_type.
void	setBranchAddresses ()
	Sets the branch addresses of all features, weight and target again.
bool	checkForBranch (TTree *, const std::string &) const
	Checks if the given branchname exists in the TTree.
float	castVarVariantToFloat (RootDatasetVarVariant &) const
	Casts a VarVariant which can contain <double,int,bool,float> to float.
void	initialiseVarVariantType (const std::string, RootDatasetVarVariant &)
	Initialises the VarVariant.
void	initialiseVarVariantForBranch (const std::string, RootDatasetVarVariant &)
	Infers the type (double,float,int,bool) from the TTree and initialises the VarVariant with the correct type.

Detailed Description

Proivdes a dataset from a ROOT file This is the usually used dataset providing training data to the mva methods.

Definition at line 349 of file Dataset.h.

Member Typedef Documentation

RootDatasetVarVariant

typedef std::variant<double, float, int, bool> RootDatasetVarVariant

protected

Typedef for variable types supported by the mva ROOTDataset, can be one of double, float, int or bool in std::variant.

Definition at line 406 of file Dataset.h.

Constructor & Destructor Documentation

ROOTDataset()

ROOTDataset ( const GeneralOptions &  _general_options )

explicit

Creates a new ROOTDataset.

Parameters

_general_options

defines the rootfile, treename, branches, ...

Definition at line 316 of file Dataset.cc.

                                                                  : Dataset(general_options)
    {
      m_input_variant.resize(m_general_options.m_variables.size());
      m_spectators_variant.resize(m_general_options.m_spectators.size());
      m_weight_variant = 1.0f;
      m_target_variant = 0.0f;
 
      for (const auto& variable : general_options.m_variables)
        for (const auto& spectator : general_options.m_spectators)
          if (variable == spectator or variable == general_options.m_target_variable or spectator == general_options.m_target_variable) {
            B2ERROR("Interface doesn't support variable more then one time in either spectators, variables or target variable");
            throw std::runtime_error("Interface doesn't support variable more then one time in either spectators, variables or target variable");
          }
 
      std::vector<std::string> filenames;
      for (const auto& filename : m_general_options.m_datafiles) {
        if (std::filesystem::exists(filename)) {
          filenames.push_back(filename);
        } else {
          auto temp = RootIOUtilities::expandWordExpansions(m_general_options.m_datafiles);
          filenames.insert(filenames.end(), temp.begin(), temp.end());
        }
      }
      if (filenames.empty()) {
        B2ERROR("Found no valid filenames in GeneralOptions");
        throw std::runtime_error("Found no valid filenames in GeneralOptions");
      }
 
      //Open TFile
      TDirectory* dir = gDirectory;
      for (const auto& filename : filenames) {
        TFile* f = TFile::Open(filename.c_str(), "READ");
        if (!f or f->IsZombie() or not f->IsOpen()) {
          B2ERROR("Error during open of ROOT file named " << filename);
          throw std::runtime_error("Error during open of ROOT file named " + filename);
        }
        delete f;
      }
      dir->cd();
 
      m_tree = new TChain(m_general_options.m_treename.c_str());
      for (const auto& filename : filenames) {
        //nentries = -1 forces AddFile() to read headers
        if (!m_tree->AddFile(filename.c_str(), -1)) {
          B2ERROR("Error during open of ROOT file named " << filename << " cannot retrieve tree named " <<
                  m_general_options.m_treename);
          throw std::runtime_error("Error during open of ROOT file named " + filename + " cannot retrieve tree named " +
                                   m_general_options.m_treename);
        }
      }
      setRootInputType();
      setBranchAddresses();
    }

~ROOTDataset()

~ROOTDataset ( )

virtual

Virtual destructor.

Definition at line 447 of file Dataset.cc.

    {
      delete m_tree;
      m_tree = nullptr;
    }

Member Function Documentation

castVarVariantToFloat()

float castVarVariantToFloat ( RootDatasetVarVariant &  variant ) const

private

Casts a VarVariant which can contain <double,int,bool,float> to float.

Parameters

variant

the VarVariant to cast

Definition at line 371 of file Dataset.cc.

    {
      if (std::holds_alternative<double>(variant))
        return static_cast<float>(std::get<double>(variant));
      else if (std::holds_alternative<float>(variant))
        return std::get<float>(variant);
      else if (std::holds_alternative<int>(variant))
        return static_cast<float>(std::get<int>(variant));
      else if (std::holds_alternative<bool>(variant))
        return static_cast<float>(std::get<bool>(variant));
      else {
        B2FATAL("Unsupported variable type");
      }
    }

checkForBranch()

bool checkForBranch ( TTree *  tree, const std::string &  branchname  ) const

private

Checks if the given branchname exists in the TTree.

Parameters

tree
branchname

Definition at line 502 of file Dataset.cc.

    {
      auto branch = tree->GetListOfBranches()->FindObject(branchname.c_str());
      return branch != nullptr;
 
    }

getFeature()

std::vector< float > getFeature ( unsigned int  iFeature )

overridevirtual

Returns all values of one feature in a std::vector<float>

Parameters

iFeature

the position of the feature to return

Reimplemented from Dataset.

Definition at line 424 of file Dataset.cc.

    {
      if (iFeature >= getNumberOfFeatures()) {
        B2ERROR("Feature index " << iFeature << " is out of bounds of given number of features: "
                << getNumberOfFeatures());
      }
      std::string branchName = Belle2::MakeROOTCompatible::makeROOTCompatible(m_general_options.m_variables[iFeature]);
      std::string typeLabel = "features";
      return getVectorFromTTreeVariant(typeLabel, branchName, m_input_variant[iFeature]);
    }

getFeatureIndex()

unsigned int getFeatureIndex ( const std::string &  feature )

virtualinherited

Return index of feature with the given name.

Parameters

feature

name of the feature

Definition at line 50 of file Dataset.cc.

    {
 
      auto it = std::find(m_general_options.m_variables.begin(), m_general_options.m_variables.end(), feature);
      if (it == m_general_options.m_variables.end()) {
        B2ERROR("Unknown feature named " << feature);
        return 0;
      }
      return std::distance(m_general_options.m_variables.begin(), it);
 
    }

getNumberOfEvents()

virtual unsigned int getNumberOfEvents ( ) const

inlineoverridevirtual

Returns the number of events in this dataset.

Implements Dataset.

Definition at line 371 of file Dataset.h.

      {
        return (m_general_options.m_max_events == 0) ? m_tree->GetEntries() : m_general_options.m_max_events;
      }

getNumberOfFeatures()

virtual unsigned int getNumberOfFeatures ( ) const

inlineoverridevirtual

Returns the number of features in this dataset.

Implements Dataset.

Definition at line 361 of file Dataset.h.

{ return m_input.size(); }

getNumberOfSpectators()

virtual unsigned int getNumberOfSpectators ( ) const

inlineoverridevirtual

Returns the number of features in this dataset.

Implements Dataset.

Definition at line 366 of file Dataset.h.

{ return m_spectators.size(); }

getSignalFraction()

float getSignalFraction ( )

virtualinherited

Returns the signal fraction of the whole sample.

Reimplemented in SPlotDataset.

Definition at line 35 of file Dataset.cc.

    {
 
      double signal_weight_sum = 0;
      double weight_sum = 0;
      for (unsigned int i = 0; i < getNumberOfEvents(); ++i) {
        loadEvent(i);
        weight_sum += m_weight;
        if (m_isSignal)
          signal_weight_sum += m_weight;
      }
      return signal_weight_sum / weight_sum;
 
    }

getSignals()

std::vector< bool > getSignals ( )

virtualinherited

Returns all is Signals.

Reimplemented in ReweightingDataset.

Definition at line 122 of file Dataset.cc.

    {
 
      std::vector<bool> result(getNumberOfEvents());
      for (unsigned int iEvent = 0; iEvent < getNumberOfEvents(); ++iEvent) {
        loadEvent(iEvent);
        result[iEvent] = m_isSignal;
      }
      return result;
 
    }

getSpectator()

std::vector< float > getSpectator ( unsigned int  iSpectator )

overridevirtual

Returns all values of one spectator in a std::vector<float>

Parameters

iSpectator

the position of the spectator to return

Reimplemented from Dataset.

Definition at line 435 of file Dataset.cc.

    {
      if (iSpectator >= getNumberOfSpectators()) {
        B2ERROR("Spectator index " << iSpectator << " is out of bounds of given number of spectators: "
                << getNumberOfSpectators());
      }
 
      std::string branchName = Belle2::MakeROOTCompatible::makeROOTCompatible(m_general_options.m_spectators[iSpectator]);
      std::string typeLabel = "spectators";
      return getVectorFromTTreeVariant(typeLabel, branchName, m_spectators_variant[iSpectator]);
    }

getSpectatorIndex()

unsigned int getSpectatorIndex ( const std::string &  spectator )

virtualinherited

Return index of spectator with the given name.

Parameters

spectator

name of the spectator

Definition at line 62 of file Dataset.cc.

    {
 
      auto it = std::find(m_general_options.m_spectators.begin(), m_general_options.m_spectators.end(), spectator);
      if (it == m_general_options.m_spectators.end()) {
        B2ERROR("Unknown spectator named " << spectator);
        return 0;
      }
      return std::distance(m_general_options.m_spectators.begin(), it);
 
    }

getTargets()

std::vector< float > getTargets ( )

virtualinherited

Returns all targets.

Reimplemented in RegressionDataSet, and ReweightingDataset.

Definition at line 110 of file Dataset.cc.

    {
 
      std::vector<float> result(getNumberOfEvents());
      for (unsigned int iEvent = 0; iEvent < getNumberOfEvents(); ++iEvent) {
        loadEvent(iEvent);
        result[iEvent] = m_target;
      }
      return result;
 
    }

getVectorFromTTree()

std::vector< float > getVectorFromTTree ( const std::string &  variableType, const std::string &  branchName, T &  memberVariableTarget  )

private

Returns all values for a specified variableType and branchName.

The values are read from a root file. The type is inferred from the given memberVariableTarget name.

Template Parameters

T	type memberVariable of this class which has to be updated (float, double)

Parameters

variableType	defines {feature, weights, spectator, target}
branchName	name of the branch to read
memberVariableTarget	variable the branch address from the root file is set to

Returns

filled vector from a branch, converted to float

Definition at line 469 of file Dataset.cc.

    {
      int nentries = getNumberOfEvents();
      std::vector<float> values(nentries);
 
      // Float or Double to be filled
      T object;
      auto currentTreeNumber = m_tree->GetTreeNumber();
      TBranch* branch = m_tree->GetBranch(branchName.c_str());
      if (not branch) {
        B2ERROR("TBranch for " + variableType + " named '" << branchName.c_str()  << "' does not exist!");
      }
      branch->SetAddress(&object);
      for (int i = 0; i < nentries; ++i) {
        auto entry = m_tree->LoadTree(i);
        if (entry < 0) {
          B2ERROR("Error during loading root tree from chain, error code: " << entry);
        }
        // if current tree changed we have to update the branch
        if (currentTreeNumber != m_tree->GetTreeNumber()) {
          currentTreeNumber = m_tree->GetTreeNumber();
          branch = m_tree->GetBranch(branchName.c_str());
          branch->SetAddress(&object);
        }
        branch->GetEntry(entry);
        values[i] = object;
      }
      // Reset branch to correct input address, just to be sure
      m_tree->SetBranchAddress(branchName.c_str(), &memberVariableTarget);
      return values;
    }

getVectorFromTTreeVariant()

std::vector< float > getVectorFromTTreeVariant ( const std::string &  variableType, const std::string &  branchName, RootDatasetVarVariant &  memberVariableTarget  )

private

Returns all values for a specified variableType and branchName.

The values are read from a root file. The type is inferred from the given memberVariableTarget name.

Parameters

variableType	defines {feature, weights, spectator, target}
branchName	name of the branch to read
memberVariableTarget	variable the branch address from the root file is set to

Returns

filled vector from a branch, converted to float

Definition at line 453 of file Dataset.cc.

    {
      if (std::holds_alternative<double>(memberVariableTarget))
        return getVectorFromTTree(variableType, branchName, std::get<double>(memberVariableTarget));
      else if (std::holds_alternative<float>(memberVariableTarget))
        return getVectorFromTTree(variableType, branchName, std::get<float>(memberVariableTarget));
      else if (std::holds_alternative<int>(memberVariableTarget))
        return getVectorFromTTree(variableType, branchName, std::get<int>(memberVariableTarget));
      else if (std::holds_alternative<bool>(memberVariableTarget))
        return getVectorFromTTree(variableType, branchName, std::get<bool>(memberVariableTarget));
      else
        B2FATAL("Input type of " << variableType << " variable " << branchName << " is not supported");
    }

getWeights()

std::vector< float > getWeights ( )

overridevirtual

Returns all values of of the weights in a std::vector<float>

Reimplemented from Dataset.

Definition at line 403 of file Dataset.cc.

    {
      std::string branchName = Belle2::MakeROOTCompatible::makeROOTCompatible(m_general_options.m_weight_variable);
      if (branchName.empty()) {
        B2INFO("No TBranch name given for weights. Using 1s as default weights.");
        int nentries = getNumberOfEvents();
        std::vector<float> values(nentries, 1.);
        return values;
      }
      if (branchName == "__weight__") {
        if (!checkForBranch(m_tree, "__weight__")) {
          B2INFO("No default weight branch with name __weight__ found. Using 1s as default weights.");
          int nentries = getNumberOfEvents();
          std::vector<float> values(nentries, 1.);
          return values;
        }
      }
      std::string typeLabel = "weights";
      return getVectorFromTTreeVariant(typeLabel, branchName, m_weight_variant);
    }

initialiseVarVariantForBranch()

void initialiseVarVariantForBranch ( const std::string  branch_name, RootDatasetVarVariant &  varVariantTarget  )

private

Infers the type (double,float,int,bool) from the TTree and initialises the VarVariant with the correct type.

Parameters

branch_name	branch name in the datafile
varVariantTarget	variant to initialise

Definition at line 610 of file Dataset.cc.

    {
      std::string compatible_branch_name = Belle2::MakeROOTCompatible::makeROOTCompatible(branch_name);
      // try the branch as is first then fall back to root safe name.
      if (checkForBranch(m_tree, branch_name.c_str())) {
        TBranch* branch = m_tree->GetBranch(branch_name.c_str());
        TLeaf* leaf = branch->GetLeaf(branch_name.c_str());
        std::string type_name = leaf->GetTypeName();
        initialiseVarVariantType(type_name, varVariantTarget);
      } else if (checkForBranch(m_tree, compatible_branch_name)) {
        TBranch* branch = m_tree->GetBranch(compatible_branch_name.c_str());
        TLeaf* leaf = branch->GetLeaf(compatible_branch_name.c_str());
        std::string type_name = leaf->GetTypeName();
        initialiseVarVariantType(type_name, varVariantTarget);
      }
    }

initialiseVarVariantType()

void initialiseVarVariantType ( const std::string  type, RootDatasetVarVariant &  varVariantTarget  )

private

Initialises the VarVariant.

Parameters

type	defines which alternative to use for the variant {Double_t, Float_t, Int_t, Bool_t}
varVariantTarget	variant to initialise.

Definition at line 593 of file Dataset.cc.

    {
      if (type == "Double_t")
        varVariantTarget = 0.0;
      else if (type == "Float_t")
        varVariantTarget = 0.0f;
      else if (type == "Int_t")
        varVariantTarget = 0;
      else if (type == "Bool_t")
        varVariantTarget = false;
      else {
        B2FATAL("Unknown root input type: " << type);
        throw std::runtime_error("Unknown root input type: " + type);
      }
    }

loadEvent()

void loadEvent ( unsigned int  event )

overridevirtual

Load the event number iEvent from the TTree.

Parameters

event

event number to load

Implements Dataset.

Definition at line 386 of file Dataset.cc.

    {
      if (m_tree->GetEntry(event, 0) == 0) {
        B2ERROR("Error during loading entry from chain");
      }
 
      for (unsigned int i = 0; i < m_input_variant.size(); i++) {
        m_input[i] = castVarVariantToFloat(m_input_variant[i]);
      }
      for (unsigned int i = 0; i < m_spectators_variant.size(); i++) {
        m_spectators[i] = castVarVariantToFloat(m_spectators_variant[i]);
      }
      m_target = castVarVariantToFloat(m_target_variant);
      m_weight = castVarVariantToFloat(m_weight_variant);
      m_isSignal = std::lround(m_target) == m_general_options.m_signal_class;
    }

setBranchAddresses()

void setBranchAddresses ( )

private

Sets the branch addresses of all features, weight and target again.

Definition at line 563 of file Dataset.cc.

    {
      // Deactivate all branches by default
      m_tree->SetBranchStatus("*", false);
 
      if (!m_general_options.m_weight_variable.empty()) {
        if (m_general_options.m_weight_variable == "__weight__") {
          if (checkForBranch(m_tree, "__weight__")) {
            m_tree->SetBranchStatus("__weight__", true);
            std::string typeLabel_weight = "weight";
            std::string weight_string =  "__weight__";
            setScalarVariableAddressVariant(typeLabel_weight, weight_string, m_weight_variant);
          } else {
            m_weight_variant = 1.0f;
          }
        } else {
          std::string typeLabel_weight = "weight";
          setScalarVariableAddressVariant(typeLabel_weight, m_general_options.m_weight_variable, m_weight_variant);
        }
      }
 
      std::string typeLabel_target = "target";
      setScalarVariableAddressVariant(typeLabel_target, m_general_options.m_target_variable, m_target_variant);
      std::string typeLabel_feature = "feature";
      setVectorVariableAddressVariant(typeLabel_feature, m_general_options.m_variables, m_input_variant);
      std::string typeLabel_spectator = "spectator";
      setVectorVariableAddressVariant(typeLabel_spectator, m_general_options.m_spectators, m_spectators_variant);
    }

setRootInputType()

void setRootInputType ( )

private

Tries to infer the data-type of the spectator and feature variables in a root file.

Definition at line 627 of file Dataset.cc.

    {
      // set target variable
      initialiseVarVariantForBranch(m_general_options.m_target_variable, m_target_variant);
 
      // set feature variables
      for (unsigned int i = 0; i < m_general_options.m_variables.size(); i++) {
        auto variable = m_general_options.m_variables[i];
        initialiseVarVariantForBranch(m_general_options.m_variables[i], m_input_variant[i]);
      }
 
      // set spectator variables
      for (unsigned int i = 0; i < m_general_options.m_spectators.size(); i++) {
        auto variable = m_general_options.m_spectators[i];
        initialiseVarVariantForBranch(m_general_options.m_spectators[i], m_spectators_variant[i]);
      }
 
      // set weight variable - bit more tricky as we allow it to not be set or to not be present.
      if (m_general_options.m_weight_variable.empty()) {
        m_weight_variant = 1.0f;
        B2INFO("No weight variable provided. The weight will be set to 1.");
      } else {
        if (m_general_options.m_weight_variable == "__weight__") {
          if (checkForBranch(m_tree, "__weight__")) {
            m_tree->SetBranchStatus("__weight__", true);
            initialiseVarVariantForBranch("__weight__", m_weight_variant);
          } else {
            B2INFO("Couldn't find default weight feature named __weight__, all weights will be 1. Consider setting the "
                   "weight variable to an empty string if you don't need it.");
            m_weight_variant = 1.0f;
          }
        } else {
          initialiseVarVariantForBranch(m_general_options.m_weight_variable, m_weight_variant);
        }
      }
    }

setScalarVariableAddress()

void setScalarVariableAddress ( const std::string &  variableType, const std::string &  variableName, T &  variableTarget  )

private

sets the branch address for a scalar variable to a given target

Template Parameters

T	target type (float, double)

Parameters

variableType	defines {feature, weights, spectator, target}
variableName	name of the variable, usually defined in general_options
variableTarget	variable, the address is set to

Definition at line 510 of file Dataset.cc.

    {
      if (not variableName.empty()) {
        if (checkForBranch(m_tree, variableName)) {
          m_tree->SetBranchStatus(variableName.c_str(), true);
          m_tree->SetBranchAddress(variableName.c_str(), &variableTarget);
        } else {
          if (checkForBranch(m_tree, Belle2::MakeROOTCompatible::makeROOTCompatible(variableName))) {
            m_tree->SetBranchStatus(Belle2::MakeROOTCompatible::makeROOTCompatible(variableName).c_str(), true);
            m_tree->SetBranchAddress(Belle2::MakeROOTCompatible::makeROOTCompatible(variableName).c_str(), &variableTarget);
          } else {
            B2ERROR("Couldn't find given " << variableType << " variable named " << variableName <<
                    " (I tried also using MakeROOTCompatible::makeROOTCompatible)");
            throw std::runtime_error("Couldn't find given " + variableType + " variable named " + variableName +
                                     " (I tried also using MakeROOTCompatible::makeROOTCompatible)");
          }
        }
      }
    }

setScalarVariableAddressVariant()

void setScalarVariableAddressVariant ( const std::string &  variableType, const std::string &  variableName, RootDatasetVarVariant &  variableTarget  )

private

sets the branch address for a scalar variable to a given target

Parameters

variableType	defines {feature, weights, spectator, target}
variableName	name of the variable, usually defined in general_options
variableTarget	variable, the address is set to

Definition at line 531 of file Dataset.cc.

    {
      if (std::holds_alternative<double>(varVariantTarget))
        setScalarVariableAddress(variableType, variableName, std::get<double>(varVariantTarget));
      else if (std::holds_alternative<float>(varVariantTarget))
        setScalarVariableAddress(variableType, variableName, std::get<float>(varVariantTarget));
      else if (std::holds_alternative<int>(varVariantTarget))
        setScalarVariableAddress(variableType, variableName, std::get<int>(varVariantTarget));
      else if (std::holds_alternative<bool>(varVariantTarget))
        setScalarVariableAddress(variableType, variableName, std::get<bool>(varVariantTarget));
      else
        B2FATAL("Variable type for branch " << variableName <<  " not supported!");
    }

setVectorVariableAddress()

void setVectorVariableAddress ( const std::string &  variableType, const std::vector< std::string > &  variableName, T &  variableTargets  )

private

sets the branch address for a vector variable to a given target

Template Parameters

T	target type (std::vector<float>, std::vector<double>)

Parameters

variableType	defines {feature, weights, spectator, target}
variableName	names of the variable, usually defined in general_options
variableTargets	variables, the address is set to

Definition at line 547 of file Dataset.cc.

    {
      for (unsigned int i = 0; i < variableNames.size(); ++i)
        ROOTDataset::setScalarVariableAddress(variableType, variableNames[i], variableTargets[i]);
    }

setVectorVariableAddressVariant()

void setVectorVariableAddressVariant ( const std::string &  variableType, const std::vector< std::string > &  variableName, std::vector< RootDatasetVarVariant > &  varVariantTargets  )

private

sets the branch address for a vector of VarVariant to a given target

Parameters

variableType	defines {feature, weights, spectator, target}
variableName	names of the variable, usually defined in general_options
varVariantTargets	variables, the address is set to

Definition at line 555 of file Dataset.cc.

    {
      for (unsigned int i = 0; i < variableNames.size(); ++i) {
        ROOTDataset::setScalarVariableAddressVariant(variableType, variableNames[i], varVariantTargets[i]);
      }
    }

Member Data Documentation

m_general_options

GeneralOptions m_general_options

inherited

GeneralOptions passed to this dataset.

Definition at line 122 of file Dataset.h.

m_input

std::vector<float> m_input

inherited

Contains all feature values of the currently loaded event.

Definition at line 123 of file Dataset.h.

m_input_variant

std::vector<RootDatasetVarVariant> m_input_variant

protected

Contains all feature values of the currently loaded event.

Definition at line 409 of file Dataset.h.

m_isSignal

bool m_isSignal

inherited

Defines if the currently loaded event is signal or background.

Definition at line 127 of file Dataset.h.

m_spectators

std::vector<float> m_spectators

inherited

Contains all spectators values of the currently loaded event.

Definition at line 124 of file Dataset.h.

m_spectators_variant

std::vector<RootDatasetVarVariant> m_spectators_variant

protected

Contains all spectators values of the currently loaded event.

Definition at line 411 of file Dataset.h.

m_target

float m_target

inherited

Contains the target value of the currently loaded event.

Definition at line 126 of file Dataset.h.

m_target_variant

RootDatasetVarVariant m_target_variant

protected

Contains the target value of the currently loaded event.

Definition at line 413 of file Dataset.h.

m_tree

TChain* m_tree = nullptr

protected

Pointer to the TChain containing the data.

Definition at line 408 of file Dataset.h.

m_weight

float m_weight

inherited

Contains the weight of the currently loaded event.

Definition at line 125 of file Dataset.h.

m_weight_variant

RootDatasetVarVariant m_weight_variant

protected

Contains the weight of the currently loaded event.

Definition at line 412 of file Dataset.h.

---

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

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