setup.h

Go to the documentation of this file.

 
#ifndef SETUP_H 
#define SETUP_H
 
#include "common.h"
#include "factory.h"
#include <boost/program_options.hpp>
#include <boost/any.hpp>
 
enum ParamState {UNSET,DEFAULTED,SET};
 
namespace po = boost::program_options;
namespace pt = boost::property_tree;
 
class Container; 
class PotentialBase;
class WaveFunctionBase;
class ActionBase;
class Path;
class LookupTable;
class MoveBase;
class EstimatorBase;
 
ostream& operator<<(ostream&, const vector<string>&);
 
// ========================================================================  
// Parameters Class
// ========================================================================  
class Parameters {
    public: 
        Parameters() {};
        
        template <typename Ttype> 
           void add(string,string,string);
 
        template <typename Ttype> 
            void add(string,string,string, const Ttype);
 
        template<typename Ttype>
            void set(const string&, const Ttype);
 
        template<typename Ttype>
            void set(const string&, const pt::ptree &);
 
        void setupCommandLine(boost::ptr_map<string,po::options_description>&);
 
        void update(int,char*[],po::options_description&);
 
        void update(const pt::ptree &);
 
        void print();
 
        const po::variables_map& operator()() const {return params;}
        po::variables_map& operator()() { return params;}
 
        const bool operator()(const string & key) const { return !(state.at(key) == UNSET); }
 
        const po::variable_value & operator[](const string & key) const {return params[key];}
        po::variable_value & operator[](const string & key) {return params.at(key);}
 
    private:
 
        using Extractor = map<string, void(*)(const po::variable_value &)>;
 
        po::variables_map params;                 
        map<string, const type_info&> type;       
        map<string,string> pClass;                
        map<string,ParamState> state;             
        map<string,string> shortName;             
        map<string,string> helpMessage;           
        Extractor extract;                        
 
        vector<string> split(const string &, char);
 
        template <typename Ttype> 
            po::typed_value<Ttype, char>* initValue(const string &);
 
        bool getNode(const pt::ptree &xmlParams, pt::ptree &node, const string key) {
            boost::optional<const pt::ptree&> child = xmlParams.get_child_optional(key);
            if (!child)
                return false;
            else
                node = *child; 
            return true;
        }
};
 
/**************************************************************************/
template <typename Ttype> 
void Parameters::add(string _label,string _helpMessage,string _pClass) {
 
    /* 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);
}
 
/**************************************************************************/
template <typename Ttype> 
void Parameters::add(string _label,string _helpMessage,string _pClass, 
        const Ttype _defaultValue) {
 
    /* 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;
}
 
/**************************************************************************/
template<typename Ttype>
void Parameters::set(const string& key, const Ttype val) {
    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;
}
 
/**************************************************************************/
template<typename Ttype>
void Parameters::set(const string& key, const pt::ptree &xml) {
    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;
    }
}
 
/**************************************************************************/
template <typename Ttype> 
po::typed_value<Ttype, char>* Parameters::initValue(const string& key) {
    if (state[key] == DEFAULTED)
        return po::value<Ttype>()->default_value(params[key].as<Ttype>());
    else
        return po::value<Ttype>();
}
 
// ========================================================================  
// Setup Class
// ========================================================================  
class Setup {
    public:
        Setup();
 
        /* Get the options from the command line */
        void getOptions(int, char*[]);
        /* Parse the options and check for errors (needs to be more complete) */
        bool parseOptions();
 
        /* Setup the worldlines */
        bool worldlines();
 
        /* Setup the physical simulation cell */
        Container *cell();
 
        /* Setup the simulation constants */
        void setConstants();
        
        /* Setup the communicator */
        void communicator();
 
        /* Define the random seed */
        uint32 seed(const uint32);
        
        /* Output all options to disk */
        void outputOptions(int, char*[], const uint32, const Container*, const iVec&);
 
        /* Setup the interaction potential */
        PotentialBase * interactionPotential(const Container*);
 
        /* Setup the external potential */
        PotentialBase * externalPotential(const Container*);
    
        /* Setup the trial wave function */
        WaveFunctionBase * waveFunction(const Path &, LookupTable &);
 
        /* Setup the action */
        ActionBase * action(const Path &, LookupTable &, PotentialBase*, PotentialBase *, WaveFunctionBase *);
 
        /* Setup the move array */
        boost::ptr_vector<MoveBase> * moves(Path &, ActionBase *, MTRand &);
 
        /* Setup the estimator array */
        boost::ptr_vector<EstimatorBase> * estimators(Path &, ActionBase *, MTRand &);
        boost::ptr_vector<EstimatorBase> * estimators(boost::ptr_vector<Path> &,
                boost::ptr_vector<ActionBase> &, MTRand&);
 
        Parameters params;                          
 
    private:
        vector<string> interactionPotentialName;    
        vector<string> externalPotentialName;       
        vector<string> waveFunctionName;            
        vector<string> randomGeneratorName;         
        vector<string> actionName;                  
        vector<string> estimatorName;               
        vector<string> moveName;                    
        vector<string> optionClassNames;            
 
        string interactionNames;                    
        string externalNames;                       
        string waveFunctionNames;                   
        string randomGeneratorNames;                
        string actionNames;                         
        string estimatorNames;                      
        string moveNames;                           
 
        /* The factories needed to instantiate objects */
        MoveFactory moveFactory;                    
        EstimatorFactory estimatorFactory;
        MultiEstimatorFactory multiEstimatorFactory;
 
        bool definedCell;                           
 
        boost::ptr_map<string,po::options_description> optionClasses; 
        po::options_description cmdLineOptions;     
 
        void cleanCommandLineOptions(int, char*[], vector<string> &, vector<string> &,
                vector<string>&);
        void update(int,char*[],po::options_description&);
 
        void initParameters();
 
        /* Get a formatted list of xml options */
        string getXMLOptionList(const vector<string> &, const string);  
};
 
#endif