Parameters Class Reference

Simulation Parameters. More...

#include <setup.h>

Public Member Functions
template<typename Ttype >
void	add (string, string, string)
	Add a parameter to the map without a default value. More...
template<typename Ttype >
void	add (string, string, string, const Ttype)
	Add a parameter to the map with a default value. More...
template<typename Ttype >
void	set (const string &, const Ttype)
	Set a parameter from a value. More...
template<typename Ttype >
void	set (const string &, const pt::ptree &)
	Set a parameter from an xml node. More...
void	setupCommandLine (boost::ptr_map< string, po::options_description > &)
	Insert options into the options_description data structure to be read from the command line. More...
void	update (int, char *[], po::options_description &)
	Update parameters from command line. More...
void	update (const pt::ptree &)
	Update parameters from an xml file.
void	print ()
	print out the parameter map More...
const po::variables_map &	operator() () const
	Parameters() returns the full map.
po::variables_map &	operator() ()
const bool	operator() (const string &key) const
	Parmaters(key) returns the existence of a parameter.
const po::variable_value &	operator[] (const string &key) const
	Parmaters[key] returns the variable value at key.
po::variable_value &	operator[] (const string &key)

Detailed Description

Simulation Parameters.

See also

http://stackoverflow.com/questions/7174781/boost-program-options-notifier-for-options-with-no-value in the future to change default value of no value options to be bool

Definition at line 44 of file setup.h.

Member Function Documentation

add() [1/2]

template<typename Ttype >

void Parameters::add	(	string	_label,
		string	_helpMessage,
		string	_pClass
	)

Add a parameter to the map without a default value.

Initialize a parameter in the map.

Parameters

_label	longName,shortName where shortName is optional
_helpMessage	a command line help message
_pClass	the class of parameter

Definition at line 125 of file setup.h.

                                                                     {
 
    /* We break the label up at a possible comma and store the short-name in a
     * map*/
    vector<string> label = split(_label,',');
    string key = label[0];
    if (label.size() > 1) 
        shortName.emplace(key,label[1]);
    else 
        shortName.emplace(key,"");
 
    /* Add the help message to a map */
    helpMessage.emplace(key,_helpMessage);
 
    /* Add the parameter class to a map */
    pClass.emplace(key,_pClass);
 
    /* Add the type to the appropriate map */
    type.emplace(pair<string,const type_info&>(key,typeid(Ttype)));
 
    /* Stores the function signature to print an element */
    extract.emplace(pair<string,void(*)(const po::variable_value &)>
            (key,[](const po::variable_value& v) {cout << v.as<Ttype>();}));
 
    /* Initialize the parameter state */
    state.emplace(key,UNSET);
 
    /* Insert an empty parameter */
    params.insert(make_pair(key, po::variable_value())); 
 
    /* update the parameters map */
    po::notify(params);
}

add() [2/2]

template<typename Ttype >

void Parameters::add	(	string	_label,
		string	_helpMessage,
		string	_pClass,
		const Ttype	_defaultValue
	)

Add a parameter to the map with a default value.

Initialize a parameter in the map with a default value.

Parameters

_label	longName,shortName where shortName is optional
_helpMessage	a command line help message
_pClass	the class of parameter
_defaultValue	the default value of the parameter

Definition at line 168 of file setup.h.

                                   {
 
    /* We perform a standard initialization */
    add<Ttype>(_label,_helpMessage,_pClass);
 
    /* Get the long name */
    vector<string> label = split(_label,',');
    string key = label[0];
 
    /* Insert the default value into the parameter map */
    set<Ttype>(key,_defaultValue);
 
    /* Set the parameter state */
    state.at(key) = DEFAULTED;
}

print()

void Parameters::print

(

)

print out the parameter map

Print all values in a parameter map.

See also

http://stackoverflow.com/questions/21008893/boost-program-options-iterate-over-variables-map

Definition at line 75 of file setup.cpp.

                       {
 
    for(auto const& par : params ) {
        if (!par.second.empty()) {
            string key = par.first;
            cout << key << ":\t";
            if (type.at(key) == typeid(bool))
                cout << params.count(key);
            else
                extract[par.first](par.second);
            cout << endl;
        }
    }
}

set() [1/2]

template<typename Ttype >

void Parameters::set	(	const string &	key,
		const pt::ptree &	xml
	)

Set a parameter from an xml node.

Set the value of a parameter in the map from an xml node.

Parameters

key	name of the parameter
xml	node

Definition at line 216 of file setup.h.

                                                          {
    if (!xml.count(key))
        return;
 
    /* command line overrides xml file */
    if (state[key] == UNSET || state[key] == DEFAULTED) {
        set<Ttype>(key,xml.get<Ttype>(key));
        state[key] = SET;
    }
}

set() [2/2]

template<typename Ttype >

void Parameters::set	(	const string &	key,
		const Ttype	val
	)

Set a parameter from a value.

Set the value of a parameter in the map from a value.

Parameters

key	name of the parameter
val	value of the parameter

Definition at line 192 of file setup.h.

                                                       {
    if (params.count(key)) {
        po::variables_map::iterator it(params.find(key));
        po::variable_value & v(it->second);
        v.value() = val;
    }
    else {
        params.insert(std::make_pair(key, po::variable_value(val, false)));
        po::notify(params);
 
        /* insert the type */
        type.emplace(pair<string,const type_info&>(key,typeid(Ttype)));
    }
 
    state[key] = SET;
}

Here is the caller graph for this function:

setupCommandLine()

void Parameters::setupCommandLine

(

boost::ptr_map< string, po::options_description > &

_options

)

Insert options into the options_description data structure to be read from the command line.

Insert all parameters into a pointer map of options.

At present we can accept bool, double, int, uint32, string and vector<string> options. This needs to be modified for each new option data type.

Definition at line 97 of file setup.cpp.

                                                                                       {
 
    /* We iterate through the parameters map */
    for (auto & par : params) {
 
        /* get the key */
        string key = par.first;
 
        /* Get the correct option class */
        po::options_description &option = _options[pClass[key]];
 
        /* construct a command line label out of the long and short name */
        string label = key;
        if (shortName[key] != "")
            label += "," + shortName[key];
 
        /* insert the option for each possible data type */
        if (type.at(key) == typeid(bool))
            option.add_options()(label.c_str(),helpMessage[key].c_str());
            /* option.add_options()(label.c_str(),po::bool_switch()->default_value(false),helpMessage[key].c_str()); */
        else if (type.at(key) == typeid(double))
            option.add_options()(label.c_str(),initValue<double>(key),helpMessage[key].c_str());
        else if (type.at(key) == typeid(int))
            option.add_options()(label.c_str(),initValue<int>(key),helpMessage[key].c_str());
        else if (type.at(key) == typeid(uint32))
            option.add_options()(label.c_str(),initValue<uint32>(key),helpMessage[key].c_str());
        else if (type.at(key) == typeid(string))
            option.add_options()(label.c_str(),initValue<string>(key),helpMessage[key].c_str());
        else if (type.at(key) == typeid(vector<string>)) {
 
            if (state[key] == DEFAULTED) {
                /* a temporary copy of the vector of strings */
                vector<string> ops = par.second.as<vector<string>>();
                option.add_options()(label.c_str(), po::value<vector<string>>()->
                        default_value(ops, getList(ops))->composing(), helpMessage[key].c_str());
            }
            else
                option.add_options()(label.c_str(), 
                        po::value<vector<string>>()->composing(), helpMessage[key].c_str());
        }
        else
            cerr << "insertOption Failed to find a valid type.";
    }
}

Here is the caller graph for this function:

update()

void Parameters::update	(	int	argc,
		char *	argv[],
		po::options_description &	cmdLineOptions
	)

Update parameters from command line.

Update the state of all parameters.

We check both the commmand line options as well as any parameters specified in an XML file. The command line takes precedence.

!!NB!! XML options needed to be correctly sorted in the file or they will be ignored. This should be fixed to exit gracefully with an error message.

Definition at line 151 of file setup.cpp.

                                                                                     {
 
    /* create a temporary parameter map */
    po::variables_map cmdparams;                    
 
    /* Get the values from the command line */
    po::store(po::parse_command_line(argc, argv, cmdLineOptions), cmdparams);
    po::notify(cmdparams);
    
    /* Now we go through our local parameter map and adjust values, keeping in
     * mind that we store boolean values */
    for (auto & par : params) {
 
        /* get the key and value */
        string key = par.first;
        auto &val = par.second;
 
        /* If the parameter exists, copy it over */
        if (cmdparams.count(key)) {
 
            val = cmdparams[key];
 
            /* update the state */
            if (cmdparams[key].empty())
                state[key] = UNSET; 
            else if (cmdparams[key].defaulted())
                state[key] = DEFAULTED;
            else
                state[key] = SET;
            }
    }
 
    /* Now we load a potential xml file from disk. It is optional so we use a
     * try/catch. */
    if (!params["param_file"].empty()) {
 
        try {
            pt::ptree xmlParams;                        
            pt::read_xml(params["param_file"].as<string>(),xmlParams);
            xmlParams = xmlParams.get_child("pimc");
 
            /* Go through our local parameter map and determine what needs to be
             * set from the xml file */
            for (auto & par : params) {
 
                /* get the key */
                string key = par.first;
 
                /* the parameter class string */
                string paramClass = pClass[key] + "_parameters";
 
                /* Get a clean xml node */
                pt::ptree xml;
                if (getNode(xmlParams,xml,paramClass)) {
 
                    if (type.at(key) == typeid(bool)){
                        set<bool>(key,xml);
                    }
                    else if (type.at(key) == typeid(double)) {
                        set<double>(key,xml);
                    }
                    else if (type.at(key) == typeid(int)) {
                        set<int>(key,xml);
                    }
                    else if (type.at(key) == typeid(uint32)) {
                        set<uint32>(key,xml);
                    }
                    else if (type.at(key) == typeid(string)) {
                        set<string>(key,xml);
                    }
                    else if (type.at(key) == typeid(vector<string>)) {
 
                        string pluralKey = key + "s";
                        if (xml.count(pluralKey) != 0) {
 
                            /* a temporary copy of the vector of strings */
                            vector<string> ops;
 
                            /* get the options */
                            for (auto const &opName : xml.get_child(pluralKey)) 
                                ops.push_back(opName.second.data());
 
                            /* update the parameter */
                            set<vector<string>>(key,ops);
                            state[key] = SET;
                        }
                    }
                    else
                        cerr << "xmlInsertOption Failed to find a valid type.";
                } //if getNode
            } //for par
 
        }
        catch(...) {
            cerr << "Cannot read parameter file: " << params["param_file"].as<string>() << endl;
        }
    }
}

Here is the caller graph for this function:

---

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

• include/setup.h
• src/setup.cpp