diff --git a/dumux/common/loggingparametertree.hh b/dumux/common/loggingparametertree.hh
index 436e1f6b150df33fd00726da69bcf31e825ebef4..e2babab5d95cdadff74ddd4dd28b0bc022ecf6a7 100644
--- a/dumux/common/loggingparametertree.hh
+++ b/dumux/common/loggingparametertree.hh
@@ -48,8 +48,8 @@ public:
/*
* \brief Create LoggingParameterTree from ParameterTree
*/
- LoggingParameterTree(const Dune::ParameterTree& params)
- : params_(params) {}
+ LoggingParameterTree(const Dune::ParameterTree& params, const Dune::ParameterTree& defaultParams)
+ : params_(params), defaultParams_(defaultParams) {}
/** \brief test for key
*
@@ -181,6 +181,12 @@ public:
usedRuntimeParams_[key] = params_[key];
}
+ else if(defaultParams_.hasKey(key))
+ {
+ // use the default
+ return defaultParams_.template get<T>(key);
+ }
+
return params_.template get<T>(key);
}
@@ -221,6 +227,7 @@ private:
}
const Dune::ParameterTree& params_;
+ const Dune::ParameterTree& defaultParams_;
mutable Dune::ParameterTree usedRuntimeParams_;
};
diff --git a/dumux/common/parameters.hh b/dumux/common/parameters.hh
index f06f2d1c2cca33615b7c768387faa18c83042c16..6b6a07625808a8ebd1568e9f94e2b45e0c5ba380 100644
--- a/dumux/common/parameters.hh
+++ b/dumux/common/parameters.hh
@@ -31,11 +31,15 @@
#include <list>
#include <sstream>
#include <unordered_map>
+#include <fstream>
#include <dune/common/parametertree.hh>
+#include <dune/common/parallel/mpihelper.hh>
#include <dumux/common/propertysystem.hh>
#include <dumux/common/exceptions.hh>
+#include <dumux/common/defaultusagemessage.hh>
+#include <dumux/common/loggingparametertree.hh>
/*!
* \ingroup Parameter
@@ -50,10 +54,8 @@
* GET_PARAM(TypeTag, Scalar, UpwindWeight);
* \endcode
*/
-#define GET_PARAM(TypeTag, ParamType, ParamName) \
- ::Dumux::Parameters::get<TypeTag, \
- ParamType, \
- PTAG_(ParamName)>(#ParamName, #ParamName)
+// #define GET_PARAM(TypeTag, ParamType, ParamName)
+// ::Dumux::template getParam_UsingDeprecatedMacro<ParamType>(std::string(#ParamName), GET_PROP_VALUE(TypeTag, ParamName))
/*!
* \ingroup Parameter
@@ -72,9 +74,8 @@
* \endcode
*/
#define GET_PARAM_FROM_GROUP(TypeTag, ParamType, GroupName, ParamName) \
- ::Dumux::Parameters::get<TypeTag, \
- ParamType, \
- PTAG_(GroupName##ParamName)>(#GroupName#ParamName, #GroupName, #ParamName)
+ ::Dumux::template getParam_UsingDeprecatedMacro<ParamType>(std::string(#GroupName) + "." + std::string(#ParamName), GET_PROP_VALUE(TypeTag, GroupName##ParamName))
+
/*!
* \ingroup Parameter
@@ -89,7 +90,7 @@
* \endcode
*/
#define GET_RUNTIME_PARAM(TypeTag, ParamType, ParamName) \
- ::Dumux::Parameters::getRuntime<TypeTag, ParamType>(#ParamName)
+ ::Dumux::template getParam_UsingDeprecatedMacro<ParamType>(std::string(#ParamName))
/*!
* \ingroup Parameter
@@ -118,7 +119,7 @@
* \endcode
*/
#define GET_RUNTIME_PARAM_CSTRING(TypeTag, ParamType, ParamName) \
- ::Dumux::Parameters::getRuntime<TypeTag, ParamType>(ParamName)
+ ::Dumux::template getParam_UsingDeprecatedMacro<ParamType>(std::string(ParamName))
/*!
* \ingroup Parameter
@@ -136,7 +137,7 @@
* \endcode
*/
#define GET_RUNTIME_PARAM_FROM_GROUP(TypeTag, ParamType, GroupName, ParamName) \
- ::Dumux::Parameters::getRuntime<TypeTag, ParamType>(#GroupName, #ParamName)
+ ::Dumux::template getParam_UsingDeprecatedMacro<ParamType>(std::string(#GroupName) + "." + std::string(#ParamName))
/*!
* \ingroup Parameter
@@ -167,343 +168,173 @@
* \endcode
*/
#define GET_RUNTIME_PARAM_FROM_GROUP_CSTRING(TypeTag, ParamType, GroupName, ParamName) \
- ::Dumux::Parameters::getRuntime<TypeTag, ParamType>(GroupName, #ParamName)
+ ::Dumux::template getParam_UsingDeprecatedMacro<ParamType>(std::string(GroupName) + "." + std::string(#ParamName))
namespace Dumux
{
-namespace Properties
-{
-NEW_PROP_TAG(ParameterTree);
-NEW_PROP_TAG(ModelParameterGroup);
-} // namespace Properties
-
-namespace Parameters {
-
-template <class TypeTag>
-void findUnusedKeys_(std::list<std::string> &unusedParams,
- const Dune::ParameterTree &tree,
- const std::string prefix="")
-{
- typedef typename GET_PROP(TypeTag, ParameterTree) Params;
- const Dune::ParameterTree &rt = Params::runTimeParams();
- const Dune::ParameterTree &drt = Params::deprecatedRunTimeParams();
-
- // loop over all keys of the current tree
- const Dune::ParameterTree::KeyVector &keys =
- tree.getValueKeys();
- for (unsigned int i = 0; i < keys.size(); ++i) {
- std::string canonicalName = prefix + keys[i];
-
- // store keys which were not accessed
- if (!rt.hasKey(canonicalName) && !drt.hasKey(canonicalName))
- {
- unusedParams.push_back(canonicalName);
- }
- }
- // loop over all subtrees
- const Dune::ParameterTree::KeyVector &subKeys =
- tree.getSubKeys();
- for (unsigned int i = 0; i < subKeys.size(); ++i) {
- std::string newPrefix = prefix + subKeys[i] + ".";
-
- findUnusedKeys_<TypeTag>(unusedParams,
- tree.sub(subKeys[i]),
- newPrefix);
- }
+//! The runtime parameter managing class
+class Parameters {
-}
-
-template <class TypeTag>
-bool hasDeprecatedKeys_(const Dune::ParameterTree &tree)
-{
- typedef typename GET_PROP(TypeTag, ParameterTree) Params;
- const Dune::ParameterTree &drt = Params::deprecatedRunTimeParams();
-
- // loop over all keys of the current tree
- const Dune::ParameterTree::KeyVector &keys =
- tree.getValueKeys();
- for (unsigned int i = 0; i < keys.size(); ++i) {
- std::string canonicalName = keys[i];
-
- // check whether the key was accessed
- if (drt.hasKey(canonicalName))
- return true;
- }
- return false;
-}
-
-/*!
- * \ingroup Parameter
- * \brief Print the run- and compile-time parameters.
- */
-template <class TypeTag>
-void print(std::ostream &os = std::cout)
-{
- typedef typename GET_PROP(TypeTag, ParameterTree) Params;
-
- const Dune::ParameterTree &tree = Params::tree();
- const Dune::ParameterTree &rt = Params::runTimeParams();
- const Dune::ParameterTree &ct = Params::compileTimeParams();
- const Dune::ParameterTree &drt = Params::deprecatedRunTimeParams();
- const Dune::ParameterTree &unrt = Params::unusedNewRunTimeParams();
-
- os << "# Run-time specified parameters:" << std::endl;
- rt.report(os);
+public:
- if (hasDeprecatedKeys_<TypeTag>(tree))
+ //! Initialize the parameter tree singletons
+ static void init(int argc, char **argv,
+ std::string parameterFileName = "",
+ void (*usage)(const char *, const std::string &) = [](const char *, const std::string &){})
{
- os << "# DEPRECATED run-time specified parameters:" << std::endl;
- drt.report(os);
- os << "# Replace by:" << std::endl;
- unrt.report(os);
- }
+ const auto& mpiHelper = Dune::MPIHelper::instance(argc, argv);
- os << "# Compile-time specified parameters:" << std::endl;
- ct.report(os);
-
- std::list<std::string> unusedParams;
- findUnusedKeys_<TypeTag>(unusedParams, tree);
-
- if (unusedParams.size() > 0)
- {
- os << "# UNUSED parameters:" << std::endl;
- for (auto it = unusedParams.begin(); it != unusedParams.end(); ++it)
+ // check whether the user wanted to see the help message
+ for (int i = 1; i < argc; ++i)
{
- os << *it << " = \"" << tree.get(*it, "") << "\"" << std::endl;
+ 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);
+ }
}
- }
-}
-
-const char *getString_(const char *foo = 0)
-{ return foo; }
-template <class TypeTag>
-class Param
-{
- typedef typename GET_PROP(TypeTag, ParameterTree) Params;
-public:
- template <class ParamType, class PropTag>
- static const ParamType &get(const char *propertyName,
- const char *groupOrParamName,
- const char *paramNameOrNil = 0)
- {
- static const ParamType &value = retrieve_<ParamType, PropTag>(propertyName, groupOrParamName, paramNameOrNil);
- return value;
- }
-
- template <class ParamType>
- static const ParamType &getRuntime(const char *groupOrParamName,
- const char *paramNameOrNil = 0)
- {
- return retrieveRuntime_<ParamType>(groupOrParamName, paramNameOrNil);
- }
+ // apply the default parameters
+ defaultParameters(defaultParamTree());
-private:
- struct Blubb {
- std::string propertyName;
- std::string paramTypeName;
- std::string groupName;
-
- Blubb &operator=(const Blubb &b)
+ // parse paramters from the command line
+ for (int i = 1; i < argc; ++i)
{
- propertyName = b.propertyName;
- paramTypeName = b.paramTypeName;
- groupName = b.groupName;
- return *this;
+ if (argv[i][0] != '-' && i == 1)
+ {
+ // try to pass first argument as parameter file
+ parameterFileName = argv[1];
+ break;
+ }
+
+ 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;
+ }
}
- };
- template <class ParamType, class PropTag>
- static const ParamType &retrieve_(const char *propertyName,
- const char *groupOrParamName,
- const char *paramNameOrNil = 0)
- {
- const char *paramName, *groupName;
- if (paramNameOrNil && strlen(paramNameOrNil) > 0) {
- groupName = groupOrParamName;
- paramName = paramNameOrNil;
- }
- else {
- groupName = "";
- paramName = groupOrParamName;
+ // otherwise use the default name (executable name + .input)
+ if (parameterFileName == "")
+ {
+ if (mpiHelper.size() > 1)
+ std::cout << "Rank " << mpiHelper.rank() << ": ";
+ std::cout << "No parameter file given. "
+ << "Defaulting to '"
+ << argv[0]
+ << ".input' for input file.\n";
+
+ parameterFileName = std::string(argv[0]) + ".input";
}
- // prefix the parameter name by 'GroupName.'. E.g. 'Newton'
- // and 'WriteConvergence' becomes 'Newton.WriteConvergence'
- // with the default value specified by the
- // 'NewtonWriteConvergence' property. in an INI file this
- // would look like:
- //
- // [Newton]
- // WriteConvergence = true
- std::string canonicalName(paramName);
- if (strlen(groupName) > 0) {
- canonicalName.insert(0, ".");
- canonicalName.insert(0, groupName);
- }
+ // open and check whether the parameter file exists.
+ std::ifstream parameterFile(parameterFileName.c_str());
+ if (!parameterFile.is_open())
+ {
+ if (mpiHelper.size() > 1)
+ std::cout << "Rank " << mpiHelper.rank() << ": ";
+ std::cout << " -> Could not open file '"
+ << parameterFileName
+ << "'. <- \n\n";
- std::string modelParamGroup(GET_PROP_VALUE(TypeTag, ModelParameterGroup));
- // prefix the parameter with the parameter group of the
- // model. this allows things like sub-model specific parameters like
- //
- // [Stokes.Newton]
- // WriteConvergence = false
- // [Darcy.Newton]
- // WriteConvergence = true
- if (modelParamGroup.size()) {
- canonicalName.insert(0, ".");
- canonicalName.insert(0, modelParamGroup);
- }
+ usage(argv[0], defaultUsageMessage(argv[0]));
- static ParamType value;
- // retrieve actual parameter from the parameter tree
- ParamType defaultValue = GET_PROP_VALUE_(TypeTag, PropTag);
- if (!Params::tree().hasKey(canonicalName) && Params::tree().hasKey(paramName))//functionality to catch deprecated params
- {
- value = Params::tree().template get<ParamType>(paramName, defaultValue);
-// std::cout<<"\nWarning: Using the parameter: "<<paramName<<" without group name: "<<groupName<<" is deprecated!"<<"\n\n";
+ DUNE_THROW(ParameterException, "Error opening input file " << parameterFileName << ".");
}
else
- value = Params::tree().template get<ParamType>(canonicalName, defaultValue);
-
- // remember whether the parameter was taken from the parameter
- // tree or the default from the property system was taken.
- Dune::ParameterTree &rt = Params::runTimeParams();
- Dune::ParameterTree &ct = Params::compileTimeParams();
- Dune::ParameterTree &drt = Params::deprecatedRunTimeParams();
- Dune::ParameterTree &unrt = Params::unusedNewRunTimeParams();
- if (Params::tree().hasKey(canonicalName)) {
- rt[canonicalName] = Params::tree()[canonicalName];
- }
- else if (Params::tree().hasKey(paramName))//functionality to catch deprecated params
{
- drt[paramName] = Params::tree()[paramName];
- unrt[canonicalName] = Params::tree()[paramName];
- }
- else {
- std::string s;
- std::ostringstream oss(s);
- oss << defaultValue;
- ct[canonicalName] = oss.str();
+ // read parameters from the file without overwriting the command line params
+ // because the command line arguments have precedence
+ Dune::ParameterTreeParser::readINITree(parameterFileName,
+ paramTree(),
+ /*overwrite=*/false);
}
- return value;
+ parameterFile.close();
}
- template <class ParamType>
- static const ParamType &retrieveRuntime_(const char *groupOrParamName, const char *paramNameOrNil = 0)
+ //! returns the logging parameter tree recording which parameters are used during the simulation
+ static const LoggingParameterTree& getTree()
{
- const char *paramName, *groupName;
- if (paramNameOrNil && paramNameOrNil[0] != '\0') {
- groupName = groupOrParamName;
- paramName = paramNameOrNil;
- }
- else {
- groupName = "";
- paramName = groupOrParamName;
- }
-
- static std::string modelParamGroup(GET_PROP(TypeTag, ModelParameterGroup)::value);
-
- std::string canonicalName(modelParamGroup);
-
- // prefix the parameter with the parameter group of the
- // model. this allows things like sub-model specific parameters like
- //
- // [Stokes.Newton]
- // WriteConvergence = false
- // [Darcy.Newton]
- // WriteConvergence = true
- if (modelParamGroup.size()) {
- canonicalName.push_back('.');
- }
-
- // prefix the parameter name by 'GroupName.'. E.g. 'Newton'
- // and 'WriteConvergence' becomes 'Newton.WriteConvergence'
- // with the default value specified by the
- // 'NewtonWriteConvergence' property. in an INI file this
- // would look like:
- //
- // [Newton]
- // WriteConvergence = true
- if (strlen(groupName) > 0) {
- canonicalName.append(groupName);
- canonicalName.push_back('.');
- }
-
- // append the name of the parameter
- canonicalName.append(paramName);
-
- // cache parameters using a hash_map (Dune::Parameter tree is slow!)
- typedef std::unordered_map<std::string, ParamType> ParamCache;
- static ParamCache paramCache;
- typename ParamCache::iterator it = paramCache.find(canonicalName);
- if (it != paramCache.end())
- return it->second;
-
- it = paramCache.find(paramName);
- if (it != paramCache.end())
- return it->second;
-
- // retrieve actual parameter from the parameter tree
- if (!Params::tree().hasKey(canonicalName) && !Params::tree().hasKey(paramName)) {
- DUNE_THROW(::Dumux::ParameterException,
- "Mandatory parameter '" << canonicalName
- << "' was not specified");
- }
+ static LoggingParameterTree tree(paramTree(), defaultParamTree());
+ return tree;
+ }
- // update the cache
- ParamType value;
- if (!Params::tree().hasKey(canonicalName) && Params::tree().hasKey(paramName))//functionality to catch deprecated params
- {
- value = Params::tree().template get<ParamType>(paramName);
- paramCache[paramName] = value;
+private:
- // remember whether the parameter was taken from the parameter
- // tree or the default from the property system was taken.
- Dune::ParameterTree &drt = Params::deprecatedRunTimeParams();
- Dune::ParameterTree &unrt = Params::unusedNewRunTimeParams();
+ //! the actual internal parameter tree storing all user-specfied runtime parameters
+ static Dune::ParameterTree& paramTree()
+ {
+ static Dune::ParameterTree tree;
+ return tree;
+ }
- drt[paramName] = Params::tree()[paramName];
- unrt[canonicalName] = Params::tree()[paramName];
- return paramCache[paramName];
- }
- else
- {
- value = Params::tree().template get<ParamType>(canonicalName);
- paramCache[canonicalName] = value;
+ //! the parameter tree storing the Dumux global defaults for some parameters
+ static Dune::ParameterTree& defaultParamTree()
+ {
+ static Dune::ParameterTree tree;
+ return tree;
+ }
- // remember whether the parameter was taken from the parameter
- // tree or the default from the property system was taken.
- Dune::ParameterTree &rt = Params::runTimeParams();
+ //! This method puts all default arguments into the parameter tree
+ //! we do this once per simulation on call to Parameters::init();
+ static void defaultParameters(Dune::ParameterTree& params)
+ {
+ // parameters in the problem group
+ params["Problem.EnableGravity"] = "true";
- rt[canonicalName] = Params::tree()[canonicalName];
- return paramCache[canonicalName];
- }
+ // parameters in the newton group
+ params["Newton.TargetSteps"] = "16";
}
};
-template <class TypeTag, class ParamType, class PropTag>
-const ParamType &get(const char *propertyName,
- const char *paramOrGroupName,
- const char *paramNameOrNil = 0)
+enum class ParamLookup {
+ simple, tree
+};
+
+// a free function to get a parameter from the parameter tree singleton
+// e.g. auto endTime = getParam<double>("TimeManager.TEnd");
+template<typename T, typename... Args>
+T getParam(Args&&... args)
{
- return Param<TypeTag>::template get<ParamType, PropTag>(propertyName,
- paramOrGroupName,
- paramNameOrNil);
+ const auto& p = Parameters::getTree();
+ return p.template get<T>(std::forward<Args>(args)... );
}
-template <class TypeTag, class ParamType>
-const ParamType &getRuntime(const char *paramOrGroupName,
- const char *paramNameOrNil = 0)
+template<typename T, typename... Args>
+DUNE_DEPRECATED_MSG("Using preprocessor MACROS for getting parameters is deprecated on next. Please use the new getParam method.")
+T getParam_UsingDeprecatedMacro(Args&&... args)
{
- return Param<TypeTag>::template getRuntime<ParamType>(paramOrGroupName,
- paramNameOrNil);
+ const auto& p = Parameters::getTree();
+ return p.template get<T>(std::forward<Args>(args)... );
}
-} // namespace Parameters
+// a free function to report all parameters stating currently unused ones
+void reportParams()
+{ Parameters::getTree().reportAll(); }
} // namespace Dumux
-
#endif
diff --git a/test/common/parameters/test_loggingparametertree.cc b/test/common/parameters/test_loggingparametertree.cc
index 6af28f63989dad3fb96ad8f55aeee1cbcbe9596b..e1b70c52b5ae8393fa44bff5319ae3cba1a87d29 100644
--- a/test/common/parameters/test_loggingparametertree.cc
+++ b/test/common/parameters/test_loggingparametertree.cc
@@ -5,37 +5,86 @@
#include <dune/common/parallel/mpihelper.hh>
#include <dune/common/exceptions.hh>
+#include <dumux/common/propertysystem.hh>
+#include <dumux/common/parameters.hh>
#include <dumux/common/parameterparser.hh>
-#include <dumux/common/loggingparametertree.hh>
+
+namespace Dumux {
+
+namespace Properties
+{
+NEW_TYPE_TAG(Bla);
+NEW_PROP_TAG(TimeLoopTLEnd);
+NEW_PROP_TAG(Scalar);
+SET_TYPE_PROP(Bla, Scalar, double);
+SET_SCALAR_PROP(Bla, TimeLoopTLEnd, 2.0);
+}
+
+}
int main (int argc, char *argv[]) try
{
+ using namespace Dumux;
+ using TypeTag = TTAG(Bla);
+
// maybe initialize mpi
Dune::MPIHelper::instance(argc, argv);
// parse the input file into the parameter tree
- Dune::ParameterTree tree;
- Dumux::ParameterParser::parseInputFile(argc, argv, tree, "params.input");
+ // Dune::ParameterTree tree;
+ // Dumux::ParameterParser::parseInputFile(argc, argv, tree, "params.input");
+ //
+ // // attach the tree to the logging tree
+ // Dumux::LoggingParameterTree params(tree);
+ //
+ // // use some default parameters
+ // bool DUNE_UNUSED(enableGravity) = params.get<bool>("Problem.EnableGravity", true);
+ //
+ // // use some given parameters
+ // const auto DUNE_UNUSED(cells) = params.get<std::array<int, 2>>("Grid.Cells", {1, 1});
+ // const auto DUNE_UNUSED(tEnd) = params.get<double>("TimeLoop.TEnd");
+ //
+ // // check the unused keys
+ // const auto unused = params.getUnusedKeys();
+ // if (unused.size() != 1)
+ // DUNE_THROW(Dune::InvalidStateException, "There should be exactly one unused key!");
+ // else if (unused[0] != "Grid.Bells")
+ // DUNE_THROW(Dune::InvalidStateException, "Unused key \"Grid.Bells\" not found!");
+ //
+ // params.reportAll();
- // attach the tree to the logging tree
- Dumux::LoggingParameterTree params(tree);
+ Parameters::init(argc, argv, "params.input");
// use some default parameters
- bool DUNE_UNUSED(enableGravity) = params.get<bool>("Problem.EnableGravity", true);
+ bool enableGravity = getParam<bool>("Problem.EnableGravity", false); // used user default
+ std::cout << enableGravity << std::endl;
+ enableGravity = getParam<bool>("Problem.EnableGravity"); // uses the Dumux default value
+ std::cout << enableGravity << std::endl;
// use some given parameters
- const auto DUNE_UNUSED(cells) = params.get<std::array<int, 2>>("Grid.Cells", {1, 1});
- const auto DUNE_UNUSED(tEnd) = params.get<double>("TimeLoop.TEnd");
+ const auto DUNE_UNUSED(cells) = getParam<std::array<int, 2>>("Grid.Cells", std::array<int, 2>{{1, 1}});
+ auto tEnd = getParam<double>("TimeLoop.TEnd");
+ tEnd = getParam<double>("TimeLoop.TEnd", 1.0);
+ // const auto tEnd = getParamFromGroup<double>("Bulk", "TimeLoop.TEnd", 1.0, Parameters::simpleLookup);
+ tEnd = getParamFromGroup<double>("Bulk", "TimeLoop.TEnd", 1.0, ParamLookup::tree);
+ // tEnd = GET_PARAM(TypeTag, double, TimeLoop.TEnd);
+ tEnd = GET_PARAM_FROM_GROUP(TypeTag, double, TimeLoop, TLEnd);
+ std::cout << tEnd << std::endl;
+ tEnd = GET_RUNTIME_PARAM(TypeTag, double, TimeLoop.TEnd);
+ tEnd = GET_RUNTIME_PARAM_CSTRING(TypeTag, double, "TimeLoop.TEnd");
+ tEnd = GET_RUNTIME_PARAM_FROM_GROUP(TypeTag, double, TimeLoop, TEnd);
+ tEnd = GET_RUNTIME_PARAM_FROM_GROUP_CSTRING(TypeTag, double, "TimeLoop", TEnd);
+ std::cout << tEnd << std::endl;
+
+ reportParams();
// check the unused keys
- const auto unused = params.getUnusedKeys();
+ const auto unused = Parameters::getTree().getUnusedKeys();
if (unused.size() != 1)
DUNE_THROW(Dune::InvalidStateException, "There should be exactly one unused key!");
else if (unused[0] != "Grid.Bells")
DUNE_THROW(Dune::InvalidStateException, "Unused key \"Grid.Bells\" not found!");
- params.reportAll();
-
return 0;
}
// //////////////////////////////////