config.hpp

Go to the documentation of this file.

#ifndef _PFASST__CONFIG_HPP_
#define _PFASST__CONFIG_HPP_

#include <fstream>
#include <iostream>
#include <string>
#include <map>
using namespace std;

#include <boost/program_options.hpp>
namespace po = boost::program_options;

#ifdef WITH_MPI
  #include <mpi.h>
#endif


namespace pfasst
{
  static constexpr const char* VERSION = "v0.5.0-rc1-48-g4da93b0-dirty";

  namespace config
  {
    int get_rank()
    {
#ifdef WITH_MPI
      int initialized = 0, rank = 0;
      // if we're not running under "mpirun/mpiexec", just assume rank 0.
      MPI_Initialized(&initialized);
      if (initialized) {
        MPI_Comm_rank(MPI_COMM_WORLD, &rank);
      }
      return rank;
#else
      return 0;
#endif
    }

    class options
    {
      public:
        static const size_t LINE_WIDTH = 100;

      private:
        po::options_description all_options;
        map<string, po::options_description> option_groups;
        po::variables_map variables_map;
        vector<string> unrecognized_args;
        bool initialized = false;

        options();
        options(const options&) = delete;
        void operator=(const options&) = delete;

      public:

        static options& get_instance();
        po::variables_map& get_variables_map();
        po::options_description& get_all_options();
        vector<string>& get_unrecognized_args();


        static void add_option(const string& group, const string& option, const string& help);

        template<typename T>
        static void add_option(const string& group, const string& option, const string& help);

        void init();
    };

    template<typename T>
    inline T get_value(const string& name)
    {
      return options::get_instance().get_variables_map()[name].as<T>();
    }

    template<typename T>
    inline T get_value(const string& name, const T& default_val)
    {
      return options::get_instance().get_variables_map().count(name)
              ? options::get_instance().get_variables_map()[name].as<T>() : default_val;
    }

    static string print_help(bool if_no_params = false)
    {
      bool no_params_given = options::get_instance().get_variables_map().empty();

      if (!if_no_params || (if_no_params && no_params_given)) {
        stringstream s;
        s << options::get_instance().get_all_options() << endl;
        s << "Logging options:" << endl
          << "  -v [ --verbose ]       activates maximum verbosity" << endl
          << "  --v=arg                activates verbosity upto verbose level `arg`" << endl
          << "                         (valid range: 0-9)" << endl
          << "  -vmodule=arg           actives verbose logging for specific module" << endl
          << "                         (see [1] for details)" << endl << endl
          << "[1]: https://github.com/easylogging/easyloggingpp#vmodule" << endl;
        return s.str();
      } else {
        return string();
      }
    }

    static inline void read_config_file(const string& file_name)
    {
      ifstream ifs(file_name.c_str(), ios_base::in);
      if (!ifs) {
        throw invalid_argument("Config file '" + file_name + "' not found.");
      } else {
        po::store(po::parse_config_file(ifs, options::get_instance().get_all_options()),
                  options::get_instance().get_variables_map());
        po::notify(options::get_instance().get_variables_map());
      }
    }

    static inline void read_commandline(int argc, char* argv[], bool exit_on_help = true)
    {
      po::parsed_options parsed = po::command_line_parser(argc, argv)
                                    .options(options::get_instance().get_all_options())
                                    .allow_unregistered().run();
      options::get_instance().get_unrecognized_args() = po::collect_unrecognized(parsed.options,
                                                                                 po::exclude_positional);
      po::store(parsed, options::get_instance().get_variables_map());
      po::notify(options::get_instance().get_variables_map());

      if (options::get_instance().get_variables_map().count("input")) {
        string input_file = config::get_value<string>("input");
        read_config_file(input_file);
      }

      if (options::get_instance().get_variables_map().count("help")) {
        if (get_rank() == 0) {
          cout << print_help() << endl;
        }

        if (exit_on_help) {
#ifdef WITH_MPI
          MPI_Finalize();
#endif
          exit(0);
        }
      }
    }

    static inline void init()
    {
      options::add_option        ("Global", "help,h", "display this help message");
      options::add_option        ("Global", "quiet,q", "don't log to stdout");
      options::add_option<string>("Global", "input", "INI file with configuration options");
      options::add_option<string>("Global", "log_prefix", "a prefix for the log files");
      options::add_option        ("Global", "nocolor,c", "disable colorful logging");

      options::add_option<double>("Duration", "dt", "time step size");
      options::add_option<double>("Duration", "tend", "final time of simulation");
      options::add_option<size_t>("Duration", "num_steps", "number time steps");
      options::add_option<size_t>("Duration", "num_iters", "number of iterations");

      options::add_option<size_t>("Quadrature", "num_nodes", "number of quadrature nodes");

      options::add_option<double>("Tolerances", "abs_res_tol", "absolute residual tolerance");
      options::add_option<double>("Tolerances", "rel_res_tol", "relative residual tolerance");

      options::get_instance().init();
    }
  }  // ::pfasst::config
}  // ::pfasst

#include "pfasst/config_impl.hpp"

#endif  // _PFASST__CONFIG_HPP_