parameters.hh

Go to the documentation of this file.

// -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
// vi: set et ts=4 sw=4 sts=4:
/*****************************************************************************
 *   See the file COPYING for full copying permissions.                      *
 *                                                                           *
 *   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 3 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, see <http://www.gnu.org/licenses/>.   *
 *****************************************************************************/
#ifndef DUMUX_PARAMETERS_HH
#define DUMUX_PARAMETERS_HH
 
#include <iostream>
#include <list>
#include <sstream>
#include <unordered_map>
#include <fstream>
 
#include <dune/common/parametertree.hh>
#include <dune/common/parametertreeparser.hh>
#include <dune/common/parallel/mpihelper.hh>
 
#include <dumux/common/exceptions.hh>
#include <dumux/common/defaultusagemessage.hh>
#include <dumux/common/loggingparametertree.hh>
 
namespace Dumux {
 
class Parameters {
 
    using DefaultParams = std::function<void (Dune::ParameterTree&)>;
    using Usage = std::function<void (const char *, const std::string &)>;
 
public:
 
    static void init(int argc, char **argv, const Usage& usage)
    {
        init(argc, argv, [] (Dune::ParameterTree&) {}, "", usage);
    }
 
    static void init(int argc, char **argv,
                    std::string parameterFileName,
                    const Usage& usage = [](const char *, const std::string &){})
    {
        init(argc, argv, [] (Dune::ParameterTree&) {}, parameterFileName, usage);
    }
 
    static void init(int argc, char **argv,
                     const DefaultParams& defaultParams,
                     const Usage& usage)
    {
        init(argc, argv, defaultParams, "", usage);
    }
 
    static void init(int argc, char **argv,
                     const DefaultParams& defaultParams = [] (Dune::ParameterTree&) {},
                     std::string parameterFileName = "",
                     const Usage& usage = [](const char *, const std::string &){})
    {
        const auto& mpiHelper = Dune::MPIHelper::instance(argc, argv);
 
        // check whether the user wanted to see the help message
        for (int i = 1; i < argc; ++i)
        {
            if (std::string("--help") == argv[i] || std::string("-h") == argv[i])
            {
                // return usage message and return;
                if (mpiHelper.rank() == 0)
                    usage(argv[0], defaultUsageMessage(argv[0]));
 
                exit(0);
            }
        }
 
        // apply the default parameters
        defaultParams(defaultParamTree_());
        applyGlobalDefaults_(defaultParamTree_());
 
        // parse paramters from the command line
        const auto commandLineArgs = parseCommandLine(argc, argv);
        mergeTree_(paramTree_(), commandLineArgs);
 
        // overwrite parameter file if one was specified on the command line
        parameterFileName = commandLineArgs.get<std::string>("ParameterFile", parameterFileName);
 
        // otherwise use the default name (executable name + .input)
        if (parameterFileName == "")
        {
            parameterFileName = [&](){
                std::string defaultName = std::string(argv[0]) + ".input";
                std::ifstream pFile(defaultName.c_str());
                if (pFile.is_open())
                    return defaultName;
 
                defaultName = "params.input";
                pFile = std::ifstream(defaultName.c_str());
                if (pFile.is_open())
                    return defaultName;
                else
                    return std::string("");
            }();
 
            // if no parameter file was given and also no default names where found, continue without
            if (parameterFileName == "")
            {
                if (mpiHelper.size() > 1)
                    std::cout << "Rank " << mpiHelper.rank() << ": ";
                std::cout << "No parameter file found. Continuing without parameter file.\n";
 
                return;
            }
            else
            {
                if (mpiHelper.size() > 1)
                    std::cout << "Rank " << mpiHelper.rank() << ": ";
                std::cout << "No parameter file given. "
                          << "Defaulting to '"
                          << parameterFileName
                          << "' for input file.\n";
            }
        }
 
        if (mpiHelper.size() > 1)
            std::cout << "Rank " << mpiHelper.rank() << ": ";
        std::cout << "Reading parameters from file " << parameterFileName << ".\n";
 
        // read parameters from the file without overwriting the command line params
        // because the command line arguments have precedence
        // let Dune do the error checking if the file exists
        Dune::ParameterTreeParser::readINITree(parameterFileName,
                                               paramTree_(),
                                               /*overwrite=*/false);
    }
 
    static void init(const DefaultParams&  params = [] (Dune::ParameterTree&) {},
                     const DefaultParams& defaultParams = [] (Dune::ParameterTree&) {})
    {
        // apply the parameters
        params(paramTree_());
        // apply the default parameters
        defaultParams(defaultParamTree_());
        applyGlobalDefaults_(defaultParamTree_());
    }
 
    static void init(const std::string& parameterFileName,
                     const DefaultParams& params = [] (Dune::ParameterTree&) {},
                     bool inputFileOverwritesParams = true,
                     const DefaultParams& defaultParams = [] (Dune::ParameterTree&) {})
    {
        // apply the parameters
        params(paramTree_());
 
        // read parameters from the input file
        Dune::ParameterTreeParser::readINITree(parameterFileName, paramTree_(), inputFileOverwritesParams);
 
        // apply the default parameters
        defaultParams(defaultParamTree_());
        applyGlobalDefaults_(defaultParamTree_());
    }
 
    static void print()
    {
        getTree().reportAll();
    }
 
    static Dune::ParameterTree parseCommandLine(int argc, char **argv)
    {
        Dune::ParameterTree commandLineArgs;
        for (int i = 1; i < argc; ++i)
        {
            if (argv[i][0] != '-' && i == 1)
            {
                // try to pass first argument as parameter file
                commandLineArgs["ParameterFile"] = argv[1];
                continue;
            }
 
            if (argv[i][0] != '-')
                DUNE_THROW(ParameterException, "-> Command line argument " << i << " (='" << argv[i] << "') is invalid. <-");
 
            if (i+1 == argc)
                DUNE_THROW(ParameterException, "-> No argument given for parameter '" << argv[i] << "'! <-");
 
            // check for the ParameterFile argument
            if (argv[i]+1 == std::string("ParameterFile")) // +1 removes the '-'
            {
                commandLineArgs["ParameterFile"] = argv[i+1];
                ++i;
            }
 
            // add all other options as key value pairs
            else
            {
                // read a -MyOpt VALUE option
                std::string paramName = argv[i]+1; // +1 removes the '-'
                std::string paramValue = argv[i+1];
                ++i; // In the case of '-MyOpt VALUE' each pair counts as two arguments
 
                // Put the key=value pair into the parameter tree
                commandLineArgs[paramName] = paramValue;
            }
        }
        return commandLineArgs;
    }
 
    [[deprecated("parseCommandLineArguments is deprecated and will be removed after 3.1")]]
    static std::string parseCommandLineArguments(int argc, char **argv,
                                                 std::string parameterFileName = "")
    {
        for (int i = 1; i < argc; ++i)
        {
            if (argv[i][0] != '-' && i == 1)
            {
                // try to pass first argument as parameter file
                parameterFileName = argv[1];
                continue;
            }
 
            if (argv[i][0] != '-')
                DUNE_THROW(ParameterException, "-> Command line argument " << i << " (='" << argv[i] << "') is invalid. <-");
 
            if (i+1 == argc)
                DUNE_THROW(ParameterException, "-> No argument given for parameter '" << argv[i] << "'! <-");
 
            // check for the ParameterFile argument
            if (argv[i]+1 == std::string("ParameterFile")) // +1 removes the '-'
            {
                parameterFileName = argv[i+1];
                ++i;
            }
 
            // add all other options as key value pairs
            else
            {
                // read a -MyOpt VALUE option
                std::string paramName = argv[i]+1; // +1 removes the '-'
                std::string paramValue = argv[i+1];
                ++i; // In the case of '-MyOpt VALUE' each pair counts as two arguments
 
                // Put the key=value pair into the parameter tree
                paramTree_()[paramName] = paramValue;
            }
        }
        return parameterFileName;
    }
 
    static const LoggingParameterTree& getTree()
    {
        static LoggingParameterTree tree(paramTree_(), defaultParamTree_());
        return tree;
    }
 
private:
    static Dune::ParameterTree& paramTree_()
    {
        static Dune::ParameterTree tree;
        return tree;
    }
 
    static Dune::ParameterTree& defaultParamTree_()
    {
        static Dune::ParameterTree tree;
        return tree;
    }
 
    static void applyGlobalDefaults_(Dune::ParameterTree& params)
    {
        // global defaults
        Dune::ParameterTree defaultParams;
 
        // parameters in the implicit group
        defaultParams["Flux.UpwindWeight"] = "1.0";
        defaultParams["Implicit.EnableJacobianRecycling"] = "false";
 
        // parameters in the assembly group
        defaultParams["Assembly.NumericDifferenceMethod"] = "1";
 
        // parameters in the linear solver group
        defaultParams["LinearSolver.GMResRestart"] = "10";
        defaultParams["LinearSolver.MaxIterations"] = "250";
        defaultParams["LinearSolver.PreconditionerIterations"] = "1";
        defaultParams["LinearSolver.PreconditionerRelaxation"] = "1.0";
        defaultParams["LinearSolver.ResidualReduction"] = "1e-13";
        defaultParams["LinearSolver.Verbosity"] = "0";
 
        // parameters in the problem group
        defaultParams["Problem.EnableGravity"] = "true";
        defaultParams["Problem.EnableInertiaTerms"] = "true";
 
        // parameters in the Newton group
        // MinSteps = 2 makes Newton more robust if converge criterion is not perfect
        defaultParams["Newton.MinSteps"] = "2";
        defaultParams["Newton.MaxSteps"] = "18";
        defaultParams["Newton.TargetSteps"] = "10";
        defaultParams["Newton.UseLineSearch"] = "false";
        defaultParams["Newton.EnableChop"] = "false";
        defaultParams["Newton.EnableShiftCriterion"] = "true";
        defaultParams["Newton.MaxRelativeShift"] = "1e-8";
        defaultParams["Newton.EnableResidualCriterion"] = "false";
        defaultParams["Newton.ResidualReduction"] = "1e-5";
        defaultParams["Newton.EnableAbsoluteResidualCriterion"] = "false";
        defaultParams["Newton.MaxAbsoluteResidual"] = "1e-5";
        defaultParams["Newton.SatisfyResidualAndShiftCriterion"] = "false";
        defaultParams["Newton.EnablePartialReassembly"] = "false";
 
        // parameters in the time loop group
        defaultParams["TimeLoop.MaxTimeStepSize"] = "1e300";
        defaultParams["TimeLoop.MaxTimeStepDivisions"] = "10";
 
        // parameters in the vtk group
        defaultParams["Vtk.AddVelocity"] = "false";
        defaultParams["Vtk.AddProcessRank"] = "true";
 
        // parameters in the mpfa group
        defaultParams["Mpfa.Q"] = "0.0";
 
        // merge the global default tree but do not overwrite if the parameter already exists
        mergeTree_(params, defaultParams, false);
    }
 
    static void mergeTree_(Dune::ParameterTree& target, const Dune::ParameterTree& source, bool overwrite = true)
    { mergeTreeImpl_(target, source, overwrite, ""); }
 
    static void mergeTreeImpl_(Dune::ParameterTree& target, const Dune::ParameterTree& source, bool overwrite, const std::string& group)
    {
        const auto prefix = group == "" ? "" : group + ".";
        for (const auto& key : source.getValueKeys())
            if (overwrite || !target.hasKey(key))
                target[prefix + key] = source[key];
 
        for (const auto& subKey : source.getSubKeys())
            mergeTreeImpl_(target, source.sub(subKey), overwrite, prefix + subKey);
    }
};
 
[[deprecated("Setting parameters is deprecated and will be removed after 3.1")]]
void setParam(Dune::ParameterTree& params,
              const std::string& group,
              const std::string& key,
              const std::string& value)
{
    if(group == "")
        params[key] = value;
    else
        params[group + "." + key] = value;
}
 
template<typename T, typename... Args>
T getParam(Args&&... args)
{ return Parameters::getTree().template get<T>(std::forward<Args>(args)... ); }
 
template<typename T, typename... Args>
T getParamFromGroup(Args&&... args)
{ return Parameters::getTree().template getFromGroup<T>(std::forward<Args>(args)... ); }
 
inline bool hasParam(const std::string& param)
{ return Parameters::getTree().hasKey(param); }
 
inline bool hasParamInGroup(const std::string& paramGroup, const std::string& param)
{ return Parameters::getTree().hasKeyInGroup(param, paramGroup); }
 
} // namespace Dumux
 
#endif