Manager Class Reference

Global list of available variables. More...

#include <Manager.h>

Classes
struct	MetaVar
	A variable taking string arguments returning a variable. More...
struct	ParameterVar
	A variable taking additional floating-point arguments to influence the behaviour. More...
struct	Var
	A variable returning a floating-point value for a given Particle. More...
struct	VarBase
	Base class for information common to all types of variables. More...

Public Types
enum	VariableDataType {   c_double = 0 ,   c_int = 1 ,   c_bool = 2 }
	data type of variables More...
typedef std::variant< double, int, bool >	VarVariant
	NOTE: the python interface is documented manually in analysis/doc/Variables.rst (because we use ROOT to expose this in python rather than boost::python).
typedef std::function< VarVariant(const Particle *)>	FunctionPtr
	functions stored take a const Particle* and return VarVariant.
typedef std::function< VarVariant(const Particle *, const std::vector< double > &)>	ParameterFunctionPtr
	parameter functions stored take a const Particle*, const std::vector<double>& and return VarVariant.
typedef std::function< FunctionPtr(const std::vector< std::string > &)>	MetaFunctionPtr
	meta functions stored take a const std::vector<std::string>& and return a FunctionPtr.
typedef Particle	Object
	Typedef for the cut, that we use Particles as our base objects.

Public Member Functions
const Var *	getVariable (std::string name)
	Get the variable belonging to the given key.
const Var *	getVariable (const std::string &functionName, const std::vector< std::string > &functionArguments)
	Get Meta and Parameter Variables for a function call which is already parsed into name and arguments.
std::vector< const Belle2::Variable::Manager::Var * >	getVariables (const std::vector< std::string > &variables)
	Get variables belonging to the given keys.
bool	addAlias (const std::string &alias, const std::string &variable)
	Add alias Return true if the alias was successfully added.
void	printAliases ()
	Print existing aliases.
void	clearAliases ()
	Clear existing aliases.
std::string	resolveAlias (const std::string &alias)
	Resolve alias Return original variable name.
bool	addCollection (const std::string &collection, const std::vector< std::string > &variables)
	Add collection Return true if the collection was successfully added.
std::vector< std::string >	getCollection (const std::string &collection)
	Get Collection Returns variable names corresponding to the given collection.
std::vector< std::string >	resolveCollections (const std::vector< std::string > &variables)
	Resolve Collection Returns variable names corresponding to the given collection or if it is not a collection just the variable itself.
std::vector< const Belle2::Variable::Manager::VarBase * >	getVariables () const
	Return list of all variables (in order registered).
void	setVariableGroup (const std::string &groupName)
	All variables registered after VARIABLE_GROUP(groupName) will be added to this group.
void	registerVariable (const std::string &name, const Manager::FunctionPtr &f, const std::string &description, const Manager::VariableDataType &v, const std::string &unit="")
	Register a variable.
void	registerVariable (const std::string &name, const Manager::ParameterFunctionPtr &f, const std::string &description, const Manager::VariableDataType &v, const std::string &unit="")
	Register a variable that takes floating-point arguments (see Variable::Manager::ParameterFunctionPtr).
void	registerVariable (const std::string &name, const Manager::MetaFunctionPtr &f, const std::string &description, const Manager::VariableDataType &v)
	Register a meta-variable that takes string arguments and returns a variable(see Variable::Manager::MetaFunctionPtr).
void	deprecateVariable (const std::string &name, bool make_fatal, const std::string &version, const std::string &description)
	Make a variable deprecated.
void	checkDeprecatedVariable (const std::string &name)
	Check if a variable is deprecated.
double	evaluate (const std::string &varName, const Particle *p)
	Evaluate variable 'varName' on given Particle.
std::vector< double >	evaluateVariables (const std::vector< std::string > &varNames, const ParticleList *plist)
	Evaluate each variable in the vector 'varNames' on given ParticleList and return a flattened vector of values.
std::vector< std::string >	getNames () const
	Return list of all variable names (in order registered).
std::vector< std::string >	getAliasNames () const
	Return a list of all variable alias names (in reverse order added).
void	assertValidName (const std::string &name)
	Abort with B2FATAL if name is not a valid name for a variable.

Static Public Member Functions
static Manager &	Instance ()
	get singleton instance.

Private Member Functions
	Manager (const Manager &)
	Copy constructor disabled (not defined).
bool	createVariable (const std::string &name)
	Creates and registers a concrete variable (Var) from a MetaVar, ParameterVar or numeric constant.
bool	createVariable (const std::string &fullname, const std::string &functionName, const std::vector< std::string > &functionArguments)
	Creates and registers a MetaVar, ParameterVar Called by the corresponding getVariable(const std::string&, const std::vector<std::string>&) to register non-existing variables The fullname of the function call is also passed for alias resolving.

Private Attributes
std::string	m_currentGroup
	Group last set via VARIABLE_GROUP().
std::vector< const VarBase * >	m_variablesInRegistrationOrder
	List of variables in registration order.
std::map< std::string, std::string >	m_alias
	List of registered aliases.
std::map< std::string, std::vector< std::string > >	m_collection
	List of registered collections.
std::map< std::string, std::shared_ptr< Var > >	m_variables
	List of registered variables.
std::map< std::string, std::shared_ptr< ParameterVar > >	m_parameter_variables
	List of registered parameter variables.
std::map< std::string, std::shared_ptr< MetaVar > >	m_meta_variables
	List of registered meta variables.
std::map< std::string, std::pair< bool, std::string > >	m_deprecated
	List of deprecated variables.

Detailed Description

Global list of available variables.

Each variable has an associated unique string key through which it can be accessed. The Manager can be used to get an instance of the Variable class for this key. All ordinary variables take a const Particle* and return a double.

List of available variables

To simply get a list of all variables registered in the main analysis library, run basf2 analysis/scripts/variables.py .

Parameter variables

Parameter variables take a const Particle* and a const std::vector<double>&. They return a double. If a Parameter Variable is accessed via the VariableManager::getVariable a ordinary variable is dynamically registered which calls the Parameter variable with the correct parameters.

Meta variables

Meta variables take a const std::vector<std::string>& and return a pointer to a ordinary variable function. If a Meta Variable is accessed via the VariableManager::getVariable a ordinary variable is dynamically registered which calls the function returned by the meta variable.

There are a number of meta-variables that can be combined with existing variables to do more powerful calculations:

abs(varName)

Return absolute value of variable varName.

daughter(N, varName)

Calculate variable varName for Nth daughter

daughterProductOf(varName)

Calculate variable varName for each daughter, and return product of values

daughterSumOf(varName)

Calculate variable varName for each daughter, and return sum of values

extraInfo(extraInfoName)

Return value of extra info 'extraInfoName' from Particle (see Particle::getExtraInfo()).

So, if you wanted to get the momentum of the first daughter, you can use "daughter(1, p)" anywhere where variable names are accepted. Nesting is also possible, e.g. "daughter(1, abs(extraInfo(SignalProbability)))" can be used.

Adding variables

Variables will automatically register themselves when the library that contains them is loaded. They only need to be put in a .cc file, with a call to REGISTER_VARIABLE() in the global scope to set a name and description. Newly registered variables will be added to the group defined by the last call to VARIABLE_GROUP(), please search the list of variables (see 'List of available variables' section) for a matching group before adding your own.

Example:

double particleFlavorType(const Particle* part)
{
  return part->getFlavorType();
}
REGISTER_VARIABLE("flavor", particleFlavorType, "flavor type of decay (0=unflavored, 1=flavored)");

This registers the variable "flavor" with the given function and description. Note that only alphanumeric characters (0-9, a-Z) plus '_' are permitted in variable names.

Variables can then be accessed using getVariable(name) and getVariables().

Python interface

This class is exported to Python, and can be used to use variables in Python basf2 modules:

from variables import variables
 
from ROOT.Math import PxPyPzEVector
someParticle = Belle2.Particle(PxPyPzEVector(1.0, 0, 0, 1.0), 321)
print(variables.evaluate('E', someParticle))

Definition at line 100 of file Manager.h.

Member Typedef Documentation

FunctionPtr

typedef std::function<VarVariant(const Particle*)> FunctionPtr

functions stored take a const Particle* and return VarVariant.

Definition at line 112 of file Manager.h.

MetaFunctionPtr

typedef std::function<FunctionPtr(const std::vector<std::string>&)> MetaFunctionPtr

meta functions stored take a const std::vector<std::string>& and return a FunctionPtr.

Definition at line 116 of file Manager.h.

Object

typedef Particle Object

Typedef for the cut, that we use Particles as our base objects.

Definition at line 118 of file Manager.h.

ParameterFunctionPtr

typedef std::function<VarVariant(const Particle*, const std::vector<double>&)> ParameterFunctionPtr

parameter functions stored take a const Particle*, const std::vector<double>& and return VarVariant.

Definition at line 114 of file Manager.h.

VarVariant

typedef std::variant<double, int, bool> VarVariant

NOTE: the python interface is documented manually in analysis/doc/Variables.rst (because we use ROOT to expose this in python rather than boost::python).

Please also keep that up-to-date with any modifications. Typedef for variable return type, can either be double, int or bool in std::variant

Definition at line 110 of file Manager.h.

Member Enumeration Documentation

VariableDataType

enum VariableDataType

data type of variables

Definition at line 121 of file Manager.h.

                            {
        c_double = 0,
        c_int    = 1,
        c_bool   = 2
      };

Constructor & Destructor Documentation

Manager()

Manager ( )

inlineprivate

Definition at line 278 of file Manager.h.

{};

Member Function Documentation

addAlias()

bool addAlias	(	const std::string &	alias,
		const std::string &	variable
	)

Add alias Return true if the alias was successfully added.

Definition at line 96 of file Manager.cc.

{
 
  assertValidName(alias);
 
  if (m_alias.find(alias) != m_alias.end()) {
    if (variable == m_alias[alias]) { return true; }
    B2WARNING("An alias with the name '" << alias << "' exists and is set to '" << m_alias[alias] << "', setting it to '" << variable <<
              "'. Be aware: only the last alias defined before processing the events will be used!");
    m_alias[alias] = variable;
    return true;
  }
 
  if (m_variables.find(alias) != m_variables.end()) {
    B2ERROR("Variable with the name '" << alias << "' exists already, cannot add it as an alias!");
    return false;
  }
 
  m_alias.insert(std::make_pair(alias, variable));
  return true;
}

addCollection()

bool addCollection	(	const std::string &	collection,
		const std::vector< std::string > &	variables
	)

Add collection Return true if the collection was successfully added.

Definition at line 152 of file Manager.cc.

{
 
  assertValidName(collection);
 
  if (m_collection.find(collection) != m_collection.end()) {
    B2WARNING("Another collection with the name'" << collection << "' is already set! I overwrite it!");
    m_collection[collection] = variables;
    return true;
  }
 
  if (m_variables.find(collection) != m_variables.end()) {
    B2ERROR("Variable with the name '" << collection << "' exists already, won't add it as an collection!");
    return false;
  }
 
  m_collection.insert(std::make_pair(collection, variables));
  return true;
}

assertValidName()

void assertValidName

(

const std::string &

name

)

Abort with B2FATAL if name is not a valid name for a variable.

Definition at line 198 of file Manager.cc.

{
  const static std::regex allowedNameRegex("^[a-zA-Z0-9_]*$");
 
  if (!std::regex_match(name, allowedNameRegex)) {
    B2FATAL("Variable '" << name <<
            "' contains forbidden characters! Only alphanumeric characters plus underscores (_) are allowed for variable names.");
  }
}

checkDeprecatedVariable()

void checkDeprecatedVariable

(

const std::string &

name

)

Check if a variable is deprecated.

If it is marked as deprecated a warning is issued or a B2FATAL aborts the event loop. Which action is taken depends on the depreciation setting.

Definition at line 444 of file Manager.cc.

{
  auto varIter = m_deprecated.find(name);
 
  if (varIter == m_deprecated.end())
    return;
  else {
    bool make_fatal = varIter->second.first;
    std::string message = varIter->second.second;
    if (make_fatal)
      B2FATAL("Variable " << name << " is deprecated. " << message);
    else
      B2WARNING("Variable " << name << " is deprecated. " << message);
  }
}

clearAliases()

void clearAliases

(

)

Clear existing aliases.

Definition at line 118 of file Manager.cc.

{
  m_alias.clear();
}

createVariable() [1/2]

bool createVariable ( const std::string &  fullname, const std::string &  functionName, const std::vector< std::string > &  functionArguments  )

private

Creates and registers a MetaVar, ParameterVar Called by the corresponding getVariable(const std::string&, const std::vector<std::string>&) to register non-existing variables The fullname of the function call is also passed for alias resolving.

Definition at line 297 of file Manager.cc.

{
  // Search function name in parameter variables
  auto parameterIter = m_parameter_variables.find(functionName);
  if (parameterIter != m_parameter_variables.end()) {
 
    std::vector<double> arguments;
    for (auto& arg : functionArguments) {
      double number = 0;
      number = Belle2::convertString<double>(arg);
      arguments.push_back(number);
    }
    auto pfunc = parameterIter->second->function;
    auto func = [pfunc, arguments](const Particle * particle) -> std::variant<double, int, bool> { return pfunc(particle, arguments); };
    m_variables[fullname] = std::make_shared<Var>(fullname, func, parameterIter->second->description, parameterIter->second->group,
                                                  parameterIter->second->variabletype);
    return true;
 
  }
 
  // Search function fullname in meta variables
  auto metaIter = m_meta_variables.find(functionName);
  if (metaIter != m_meta_variables.end()) {
    auto func = metaIter->second->function(functionArguments);
    m_variables[fullname] = std::make_shared<Var>(fullname, func, metaIter->second->description, metaIter->second->group,
                                                  metaIter->second->variabletype);
    return true;
  }
 
  B2FATAL("Encountered bad variable name '" << fullname << "'. Maybe you misspelled it?");
  return false;
}

createVariable() [2/2]

bool createVariable ( const std::string &  name )

private

Creates and registers a concrete variable (Var) from a MetaVar, ParameterVar or numeric constant.

Definition at line 214 of file Manager.cc.

{
  std::match_results<std::string::const_iterator> results;
 
  // Check if name is a simple number
  if (std::regex_match(name, results, std::regex("^([0-9]+\\.?[0-9]*)$"))) {
    float float_number = std::stof(results[1]);
    auto func = [float_number](const Particle*) -> double {
      return float_number;
    };
    m_variables[name] = std::make_shared<Var>(name, func, std::string("Returns number ") + name);
    return true;
  }
 
  // Check if name is a function call
  if (std::regex_match(name, results, std::regex("^([a-zA-Z0-9_]*)\\((.*)\\)$"))) {
 
    std::string functionName = results[1];
    boost::algorithm::trim(functionName);
    std::vector<std::string> functionArguments = splitOnDelimiterAndConserveParenthesis(results[2], ',', '(', ')');
    for (auto& str : functionArguments) {
      boost::algorithm::trim(str);
    }
 
    // Search function name in parameter variables
    auto parameterIter = m_parameter_variables.find(functionName);
    if (parameterIter != m_parameter_variables.end()) {
 
      std::vector<double> arguments;
      for (auto& arg : functionArguments) {
        double number = 0;
        number = Belle2::convertString<double>(arg);
        arguments.push_back(number);
      }
      auto pfunc = parameterIter->second->function;
      auto func = [pfunc, arguments](const Particle * particle) -> VarVariant { return pfunc(particle, arguments); };
      m_variables[name] = std::make_shared<Var>(name, func, parameterIter->second->description, parameterIter->second->group,
                                                parameterIter->second->variabletype);
      return true;
 
    }
 
    // Search function name in meta variables
    auto metaIter = m_meta_variables.find(functionName);
    if (metaIter != m_meta_variables.end()) {
      auto func = metaIter->second->function(functionArguments);
      m_variables[name] = std::make_shared<Var>(name, func, metaIter->second->description, metaIter->second->group,
                                                metaIter->second->variabletype);
      return true;
    }
  }
  // Try Formula registration with python parser if variable is not a simple identifier (else we get a infinite loop)
  if (not std::regex_match(name, std::regex("^[a-zA-Z_][a-zA-Z_0-9]*$")) and not name.empty()) {
    Py_Initialize();
    try {
      // Import parser
      py::object b2parser_namespace = py::import("b2parser");
      // Parse Expression
      py::tuple expression_tuple = py::extract<boost::python::tuple>(b2parser_namespace.attr("parse_expression")(name));
      try {
        // Compile ExpressionNode
        std::shared_ptr<const AbstractExpressionNode<Belle2::Variable::Manager>> expression_node =
              NodeFactory::compile_expression_node<Belle2::Variable::Manager>(expression_tuple);
        // Create lambda capturing the ExpressionNode
        Variable::Manager::FunctionPtr func = [expression_node](const Particle * object) -> VarVariant {
          return expression_node->evaluate(object);
        };
        // Put new variable into set of variables
        m_variables[name] = std::make_shared<Var>(name, func, std::string("Returns expression ") + name);
        return true;
      } catch (std::runtime_error& exception) {
        B2FATAL("Encountered bad variable name '" << name << "'. Maybe you misspelled it?");
      }
    } catch (py::error_already_set&) {
      PyErr_Print();
      B2FATAL("Parsing error for formula: '" << name << "'");
    }
  }
 
  B2FATAL("Encountered bad variable name '" << name << "'. Maybe you misspelled it?");
  return false;
}

deprecateVariable()

void deprecateVariable	(	const std::string &	name,
		bool	make_fatal,
		const std::string &	version,
		const std::string &	description
	)

Make a variable deprecated.

Definition at line 401 of file Manager.cc.

{
  auto varIter = m_deprecated.find(name);
  if (varIter == m_deprecated.end())
    m_deprecated.insert(std::make_pair(name, std::make_pair(make_fatal, description)));
  else
    B2FATAL("There seem to be two calls to deprecate the variable: Please remove one.");
 
  auto mapIter = m_variables.find(name);
  if (mapIter != m_variables.end()) {
    if (make_fatal) {
      mapIter->second.get()->extendDescriptionString("\n\n.. warning:: ");
    } else {
      mapIter->second.get()->extendDescriptionString("\n\n.. note:: ");
    }
    mapIter->second.get()->extendDescriptionString(".. deprecated:: " + version + "\n " + description);
  } else {
    auto parMapIter = m_parameter_variables.find(name);
    if (parMapIter != m_parameter_variables.end()) {
      if (make_fatal) {
        parMapIter->second.get()->extendDescriptionString("\n\n.. warning:: ");
      } else {
        parMapIter->second.get()->extendDescriptionString("\n\n.. note:: ");
      }
      parMapIter->second.get()->extendDescriptionString(".. deprecated:: " + version + "\n " + description);
    } else {
      auto metaMapIter = m_meta_variables.find(name);
      if (metaMapIter != m_meta_variables.end()) {
        if (make_fatal) {
          metaMapIter->second.get()->extendDescriptionString("\n\n.. warning:: ");
        } else {
          metaMapIter->second.get()->extendDescriptionString("\n\n.. note:: ");
        }
        metaMapIter->second.get()->extendDescriptionString(".. deprecated:: " + version + "\n " + description);
      } else {
        B2FATAL("The variable '" << name << "' is not registered so it makes no sense to try to deprecate it.");
      }
    }
  }
 
}

evaluate()

double evaluate	(	const std::string &	varName,
		const Particle *	p
	)

Evaluate variable 'varName' on given Particle.

Mainly provided for the Python interface. For performance critical code, it is recommended to use getVariable() once and keep the Var* pointer around.

Throws exception if variable isn't found. Assumes 'p' is != NULL.

Definition at line 477 of file Manager.cc.

{
  const Var* var = getVariable(varName);
  if (!var) {
    throw std::runtime_error("Variable::Manager::evaluate(): variable '" + varName + "' not found!");
  }
 
  if (var->variabletype == Variable::Manager::VariableDataType::c_double)
    return std::get<double>(var->function(p));
  else if (var->variabletype == Variable::Manager::VariableDataType::c_int)
    return (double)std::get<int>(var->function(p));
  else if (var->variabletype == Variable::Manager::VariableDataType::c_bool)
    return (double)std::get<bool>(var->function(p));
  else return std::numeric_limits<double>::quiet_NaN();
}

evaluateVariables()

std::vector< double > evaluateVariables	(	const std::vector< std::string > &	varNames,
		const ParticleList *	plist
	)

Evaluate each variable in the vector 'varNames' on given ParticleList and return a flattened vector of values.

Throws exception if one of the variables isn't found. Assumes 'plist' is != NULL.

Definition at line 493 of file Manager.cc.

{
  std::vector<double> values;
  values.reserve(varNames.size() * plist->getListSize());
  for (size_t iPart = 0; iPart < plist->getListSize(); ++iPart) {
    const Particle* p = plist->getParticle(iPart);
    for (size_t iVar = 0; iVar < varNames.size(); ++iVar)
      values.push_back(evaluate(varNames[iVar], p));
  }
  return values;
}

getAliasNames()

std::vector< std::string > getAliasNames

(

)

const

Return a list of all variable alias names (in reverse order added).

Definition at line 470 of file Manager.cc.

{
  std::vector<std::string> names;
  for (auto al : m_alias) names.push_back(al.first);
  return names;
}

getCollection()

std::vector< std::string > getCollection

(

const std::string &

collection

)

Get Collection Returns variable names corresponding to the given collection.

Definition at line 173 of file Manager.cc.

{
 
  return m_collection[collection];
 
}

getNames()

std::vector< std::string > getNames

(

)

const

Return list of all variable names (in order registered).

Definition at line 461 of file Manager.cc.

{
  std::vector<std::string> names;
  for (const VarBase* var : m_variablesInRegistrationOrder) {
    names.push_back(var->name);
  }
  return names;
}

getVariable() [1/2]

const Variable::Manager::Var * getVariable	(	const std::string &	functionName,
		const std::vector< std::string > &	functionArguments
	)

Get Meta and Parameter Variables for a function call which is already parsed into name and arguments.

Used by FunctionNode because there we already have the MetaVariable in parsed form

Returns NULL if name not found

Definition at line 32 of file Manager.cc.

{
  // Combine to full name for alias resolving
  std::string fullname = functionName + "(" + boost::algorithm::join(functionArguments, ", ") + ")";
 
  // resolve aliases. Aliases might point to other aliases so we need to keep a
  // set of what we have seen so far to avoid running into infinite loops
  std::set<std::string> aliasesSeen;
  for (auto aliasIter = m_alias.find(fullname); aliasIter != m_alias.end(); aliasIter = m_alias.find(fullname)) {
    const auto [it, added] = aliasesSeen.insert(fullname);
    if (!added) {
      B2FATAL("Encountered a loop in the alias definitions between the aliases "
              << boost::algorithm::join(aliasesSeen, ", "));
    }
    fullname = aliasIter->second;
  }
  auto mapIter = m_variables.find(fullname);
  if (mapIter == m_variables.end()) {
    if (!createVariable(fullname, functionName, functionArguments)) return nullptr;
    mapIter = m_variables.find(fullname);
    if (mapIter == m_variables.end()) return nullptr;
  }
  return mapIter->second.get();
}

getVariable() [2/2]

const Variable::Manager::Var * getVariable

(

std::string

name

)

Get the variable belonging to the given key.

Returns NULL if name not found.

Definition at line 58 of file Manager.cc.

{
  // resolve aliases. Aliases might point to other aliases so we need to keep a
  // set of what we have seen so far to avoid running into infinite loops
  std::set<std::string> aliasesSeen;
  for (auto aliasIter = m_alias.find(name); aliasIter != m_alias.end(); aliasIter = m_alias.find(name)) {
    const auto [it, added] = aliasesSeen.insert(name);
    if (!added) {
      B2FATAL("Encountered a loop in the alias definitions between the aliases "
              << boost::algorithm::join(aliasesSeen, ", "));
    }
    name = aliasIter->second;
  }
  auto mapIter = m_variables.find(name);
  if (mapIter == m_variables.end()) {
    if (!createVariable(name)) return nullptr;
    mapIter = m_variables.find(name);
    if (mapIter == m_variables.end()) return nullptr;
  }
  return mapIter->second.get();
}

getVariables() [1/2]

std::vector< const Belle2::Variable::Manager::VarBase * > getVariables ( ) const

inline

Return list of all variables (in order registered).

Definition at line 229 of file Manager.h.

{ return m_variablesInRegistrationOrder; }

getVariables() [2/2]

std::vector< const Variable::Manager::Var * > getVariables

(

const std::vector< std::string > &

variables

)

Get variables belonging to the given keys.

Definition at line 80 of file Manager.cc.

{
 
  std::vector<const Variable::Manager::Var*> variable_pointers;
  for (auto& variable : variables) {
    const Var* x = getVariable(variable);
    if (x == nullptr) {
      B2WARNING("Couldn't find variable " << variable << " via the Variable::Manager. Check the name!");
    }
    variable_pointers.push_back(x);
  }
  return variable_pointers;
 
}

Instance()

Variable::Manager & Instance ( )

static

get singleton instance.

Definition at line 26 of file Manager.cc.

{
  static Variable::Manager v;
  return v;
}

printAliases()

void printAliases

(

)

Print existing aliases.

Definition at line 123 of file Manager.cc.

{
  long unsigned int longest_alias_size = 0;
  for (const auto& a : m_alias) {
    if (a.first.length() > longest_alias_size) {
      longest_alias_size = a.first.length();
    }
  }
  B2INFO("=====================================");
  B2INFO("The following aliases are registered:");
  for (const auto& a : m_alias) {
    B2INFO(std::string(a.first, 0, longest_alias_size) << std::string(longest_alias_size - a.first.length(),
           ' ') << " --> " << a.second);
  }
  B2INFO("=====================================");
}

registerVariable() [1/3]

void registerVariable	(	const std::string &	name,
		const Manager::FunctionPtr &	f,
		const std::string &	description,
		const Manager::VariableDataType &	v,
		const std::string &	unit = ""
	)

Register a variable.

Definition at line 332 of file Manager.cc.

{
  if (!f) {
    B2FATAL("No function provided for variable '" << name << "'.");
  }
 
  assertValidName(name);
 
  auto mapIter = m_variables.find(name);
  if (mapIter == m_variables.end()) {
 
    auto var = std::make_shared<Var>(name, f, description, m_currentGroup, variabletype);
    B2DEBUG(19, "Registered Variable " << name);
    m_variables[name] = var;
    m_variablesInRegistrationOrder.push_back(var.get());
    if (!unit.empty()) {
      var.get()->extendDescriptionString(":Unit: " + unit);
    }
  } else {
    B2FATAL("A variable named '" << name << "' was already registered! Note that all variables need a unique name!");
  }
}

registerVariable() [2/3]

void registerVariable	(	const std::string &	name,
		const Manager::MetaFunctionPtr &	f,
		const std::string &	description,
		const Manager::VariableDataType &	v
	)

Register a meta-variable that takes string arguments and returns a variable(see Variable::Manager::MetaFunctionPtr).

Definition at line 381 of file Manager.cc.

{
  if (!f) {
    B2FATAL("No function provided for variable '" << name << "'.");
  }
 
  auto mapIter = m_meta_variables.find(name);
  if (mapIter == m_meta_variables.end()) {
    auto var = std::make_shared<MetaVar>(name, f, description, m_currentGroup, variabletype);
    std::string rawName = name.substr(0, name.find('('));
    assertValidName(rawName);
    B2DEBUG(19, "Registered meta Variable " << rawName);
    m_meta_variables[rawName] = var;
    m_variablesInRegistrationOrder.push_back(var.get());
  } else {
    B2FATAL("A variable named '" << name << "' was already registered! Note that all variables need a unique name!");
  }
}

registerVariable() [3/3]

void registerVariable	(	const std::string &	name,
		const Manager::ParameterFunctionPtr &	f,
		const std::string &	description,
		const Manager::VariableDataType &	v,
		const std::string &	unit = ""
	)

Register a variable that takes floating-point arguments (see Variable::Manager::ParameterFunctionPtr).

Definition at line 357 of file Manager.cc.

{
  if (!f) {
    B2FATAL("No function provided for variable '" << name << "'.");
  }
 
  auto mapIter = m_parameter_variables.find(name);
  if (mapIter == m_parameter_variables.end()) {
    auto var = std::make_shared<ParameterVar>(name, f, description, m_currentGroup, variabletype);
    std::string rawName = name.substr(0, name.find('('));
    assertValidName(rawName);
    B2DEBUG(19, "Registered parameter Variable " << rawName);
    m_parameter_variables[rawName] = var;
    m_variablesInRegistrationOrder.push_back(var.get());
    if (!unit.empty()) {
      var.get()->extendDescriptionString(":Unit: " + unit);
    }
  } else {
    B2FATAL("A variable named '" << name << "' was already registered! Note that all variables need a unique name!");
  }
}

resolveAlias()

std::string resolveAlias

(

const std::string &

alias

)

Resolve alias Return original variable name.

Definition at line 140 of file Manager.cc.

{
 
  assertValidName(alias);
 
  if (m_alias.find(alias) == m_alias.end()) {
    return alias;
  } else {
    return m_alias[alias];
  }
}

resolveCollections()

std::vector< std::string > resolveCollections

(

const std::vector< std::string > &

variables

)

Resolve Collection Returns variable names corresponding to the given collection or if it is not a collection just the variable itself.

Definition at line 180 of file Manager.cc.

{
 
  std::vector<std::string> temp;
 
  for (const auto& var : variables) {
    auto it = m_collection.find(var);
    if (it != m_collection.end()) {
      temp.insert(temp.end(), it->second.begin(), it->second.end());
    } else {
      temp.push_back(var);
    }
  }
  return temp;
 
}

setVariableGroup()

void setVariableGroup

(

const std::string &

groupName

)

All variables registered after VARIABLE_GROUP(groupName) will be added to this group.

Definition at line 209 of file Manager.cc.

{
  m_currentGroup = groupName;
}

Member Data Documentation

m_alias

std::map<std::string, std::string> m_alias

private

List of registered aliases.

Definition at line 300 of file Manager.h.

m_collection

std::map<std::string, std::vector<std::string> > m_collection

private

List of registered collections.

Definition at line 302 of file Manager.h.

m_currentGroup

std::string m_currentGroup

private

Group last set via VARIABLE_GROUP().

Definition at line 294 of file Manager.h.

m_deprecated

std::map<std::string, std::pair<bool, std::string> > m_deprecated

private

List of deprecated variables.

Definition at line 310 of file Manager.h.

m_meta_variables

std::map<std::string, std::shared_ptr<MetaVar> > m_meta_variables

private

List of registered meta variables.

Definition at line 308 of file Manager.h.

m_parameter_variables

std::map<std::string, std::shared_ptr<ParameterVar> > m_parameter_variables

private

List of registered parameter variables.

Definition at line 306 of file Manager.h.

m_variables

std::map<std::string, std::shared_ptr<Var> > m_variables

private

List of registered variables.

Definition at line 304 of file Manager.h.

m_variablesInRegistrationOrder

std::vector<const VarBase*> m_variablesInRegistrationOrder

private

List of variables in registration order.

Definition at line 297 of file Manager.h.

---

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

• analysis/VariableManager/include/Manager.h
• analysis/VariableManager/src/Manager.cc