readparameters.h

Go to the documentation of this file.

/*
 * This file is part of Vlasiator.
 * Copyright 2010-2016 Finnish Meteorological Institute
 *
 * For details of usage, see the COPYING file and read the "Rules of the Road"
 * at http://www.physics.helsinki.fi/vlasiator/
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
#ifndef READPARAMETERS_H
#define READPARAMETERS_H
 
#include <boost/program_options.hpp>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <limits>
#include <mpi.h>
#include <stdint.h>
#include <string>
#include <typeinfo>
#include <vector>
 
#include "common.h"
#include "version.h"
 
class Readparameters {
public:
   Readparameters(int cmdargc, char* cmdargv[]);
   ~Readparameters();

   static void add(const std::string& name, const std::string& desc, const std::string& defValue) {
      int rank;
      MPI_Comm_rank(MPI_COMM_WORLD, &rank);
      if (rank == MASTER_RANK) {
         options[name] = "";
         isOptionParsed[name] = false;
         descriptions->add_options()(
             name.c_str(), boost::program_options::value<std::string>(&(options[name]))->default_value(defValue),
             desc.c_str());
      }
   }
 
   template <typename T> static void add(const std::string& name, const std::string& desc, const T& defValue) {
      int rank;
      MPI_Comm_rank(MPI_COMM_WORLD, &rank);
      if (rank == MASTER_RANK) {
         std::stringstream ss;
 
         static constexpr bool n = (std::is_floating_point<T>::value);
         if (n) {
            ss << std::setprecision(std::numeric_limits<double>::digits10 + 1) << defValue;
         } else {
            ss << defValue;
         }
         options[name] = "";
         isOptionParsed[name] = false;
         descriptions->add_options()(
             name.c_str(), boost::program_options::value<std::string>(&(options[name]))->default_value(ss.str()),
             desc.c_str());
      }
   }

   static void get(const std::string& name, std::string& value) {
      if (options.find(name) != options.end()) { // check if it exists
         value = options[name];
      } else {
         int rank;
         MPI_Comm_rank(MPI_COMM_WORLD, &rank);
         if (rank == MASTER_RANK) {
            std::cerr << __FILE__ << ":" << __LINE__ << " " << name + " not declared using the add() function!" << std::endl;
            MPI_Abort(MPI_COMM_WORLD, 1);
         }
      }
   }
 
   static void get(const std::string& name, std::vector<std::string>& value) {
      if (vectorOptions.find(name) != vectorOptions.end()) { // check if it exists
         value = vectorOptions[name];
      } else {
         int rank;
         MPI_Comm_rank(MPI_COMM_WORLD, &rank);
         if (rank == MASTER_RANK) {
            std::cerr << __FILE__ << ":" << __LINE__ << name + " not declared using the add() function!" << std::endl;
            MPI_Abort(MPI_COMM_WORLD, 1);
         }
      }
   }
 
   template <typename T> static void get(const std::string& name, T& value) {
      std::string sval;
      get(name, sval);
 
      try {
         value = boost::lexical_cast<T>(sval);
      } catch (...) {
         int myRank;
         MPI_Comm_rank(MPI_COMM_WORLD, &myRank);
         if (myRank == MASTER_RANK) {
            std::cerr << __FILE__ << ":" << __LINE__
                      << std::string(" Problems casting ") + name + " " + sval + std::string(" to ") + typeid(T).name()
                      << std::endl;
 
            MPI_Abort(MPI_COMM_WORLD, 1);
         }
      }
   }

   template <typename T> static void get(const std::string& name, std::vector<T>& value) {
      std::vector<std::string> stringValue;
      get(name, stringValue);
 
      for (std::vector<std::string>::iterator i = stringValue.begin(); i != stringValue.end(); ++i) {
         try {
            value.push_back(boost::lexical_cast<T>(*i));
         } catch (...) {
            int myRank;
            MPI_Comm_rank(MPI_COMM_WORLD, &myRank);
            if (myRank == MASTER_RANK) {
               std::cerr << __FILE__ << ":" << __LINE__
                         << std::string(" Problems casting ") + name + *i + std::string(" to ") + typeid(T).name()
                         << std::endl;
 
               MPI_Abort(MPI_COMM_WORLD, 1);
            }
         }
      }
   }
 
   // Determine whether a given variable has been set.
   static bool isSet(const std::string& name) {
      return(options.find(name) != options.end());
   }
 
   static void addComposing(const std::string& name, const std::string& desc);
 
   static void helpMessage();
 
   static bool versionMessage();
 
   static std::string versionInfo();
   
   static std::string configInfo();
 
   static bool parse(const bool needsRunConfig = true, const bool allowUnknown = true);
 
   static bool helpRequested;
 
private:
   static int argc;    
   static char** argv; 
 
   static boost::program_options::options_description* descriptions;
   static boost::program_options::variables_map* variables;
 
   static std::map<std::string, std::string> options;
   static std::map<std::string, bool> isOptionParsed;
   static std::map<std::string, std::vector<std::string>> vectorOptions;
   static std::map<std::string, bool> isVectorOptionParsed;
 
   static std::string global_config_file_name;
   static std::string user_config_file_name;
   static std::string run_config_file_name;
 
   static void addDefaultParameters();
};
 
#endif