diff --git a/opm/simulators/flow/FlowMain.hpp b/opm/simulators/flow/FlowMain.hpp
index f218fa249..9d2fdf838 100644
--- a/opm/simulators/flow/FlowMain.hpp
+++ b/opm/simulators/flow/FlowMain.hpp
@@ -128,7 +128,7 @@ namespace Opm {
             registerAllParameters_<TypeTag>(/*finalizeRegistration=*/false);
 
             // hide the parameters unused by flow. TODO: this is a pain to maintain
-            Parameters::hideParam<TypeTag, Properties::EnableGravity>();
+            Parameters::hideParam<TypeTag, Parameters::EnableGravity>();
             Parameters::hideParam<TypeTag, Parameters::EnableGridAdaptation>();
 
             // this parameter is actually used in eWoms, but the flow well model
diff --git a/opm/simulators/flow/FlowProblem.hpp b/opm/simulators/flow/FlowProblem.hpp
index f3d289ddc..dc628e97e 100644
--- a/opm/simulators/flow/FlowProblem.hpp
+++ b/opm/simulators/flow/FlowProblem.hpp
@@ -392,7 +392,7 @@ public:
         // disables gravity, else the standard value of the gravity constant at sea level
         // on earth is used
         this->gravity_ = 0.0;
-        if (Parameters::get<TypeTag, Properties::EnableGravity>())
+        if (Parameters::get<TypeTag, Parameters::EnableGravity>())
             this->gravity_[dim - 1] = 9.80665;
         if (!eclState.getInitConfig().hasGravity())
             this->gravity_[dim - 1] = 0.0;
diff --git a/opm/simulators/flow/FlowProblemProperties.hpp b/opm/simulators/flow/FlowProblemProperties.hpp
index adf251a0d..4fee1aa6d 100644
--- a/opm/simulators/flow/FlowProblemProperties.hpp
+++ b/opm/simulators/flow/FlowProblemProperties.hpp
@@ -238,12 +238,6 @@ struct AquiferModel<TypeTag, TTag::FlowBaseProblem> {
     using type = BaseAquiferModel<TypeTag>;
 };
 
-// Enable gravity
-template<class TypeTag>
-struct EnableGravity<TypeTag, TTag::FlowBaseProblem> {
-    static constexpr bool value = true;
-};
-
 // Enable diffusion
 template<class TypeTag>
 struct EnableDiffusion<TypeTag, TTag::FlowBaseProblem> {
@@ -471,10 +465,10 @@ struct ExplicitRockCompaction<TypeTag, TTag::FlowBaseProblem> {
 
 namespace Opm::Parameters {
 
-// Disable the VTK output by default for this problem ...
+// Enable gravity
 template<class TypeTag>
-struct EnableVtkOutput<TypeTag, Properties::TTag::FlowBaseProblem>
-{ static constexpr bool value = false; };
+struct EnableGravity<TypeTag, Properties::TTag::FlowBaseProblem>
+{ static constexpr bool value = true; };
 
 // the cache for intensive quantities can be used for ECL problems and also yields a
 // decent speedup...
@@ -487,6 +481,11 @@ template<class TypeTag>
 struct EnableStorageCache<TypeTag, Properties::TTag::FlowBaseProblem>
 { static constexpr bool value = true; };
 
+// Disable the VTK output by default for this problem ...
+template<class TypeTag>
+struct EnableVtkOutput<TypeTag, Properties::TTag::FlowBaseProblem>
+{ static constexpr bool value = false; };
+
 // The default for the end time of the simulation [s]
 //
 // By default, stop it after the universe will probably have stopped
diff --git a/opm/simulators/linalg/FlowLinearSolverParameters.hpp b/opm/simulators/linalg/FlowLinearSolverParameters.hpp
index bad8e1cb2..fff4b467e 100644
--- a/opm/simulators/linalg/FlowLinearSolverParameters.hpp
+++ b/opm/simulators/linalg/FlowLinearSolverParameters.hpp
@@ -26,376 +26,360 @@
 
 #include <opm/simulators/linalg/MILU.hpp>
 
+#include <opm/simulators/linalg/linalgparameters.hh>
 #include <opm/simulators/linalg/linalgproperties.hh>
 #include <opm/models/utils/parametersystem.hh>
 
 namespace Opm {
+
 template <class TypeTag>
 class ISTLSolverBda;
+
 template <class TypeTag>
 class ISTLSolver;
+
 }
 
-
-
 namespace Opm::Properties {
 
 namespace TTag {
+
 struct FlowIstlSolverParams {};
+
 }
 
 template<class TypeTag, class MyTypeTag>
-struct LinearSolverReduction {
-    using type = UndefinedProperty;
-};
+struct LinearSolverReduction { using type = UndefinedProperty; };
 
 template<class TypeTag, class MyTypeTag>
-struct RelaxedLinearSolverReduction {
-    using type = UndefinedProperty;
-};
+struct RelaxedLinearSolverReduction { using type = UndefinedProperty; };
 
 template<class TypeTag, class MyTypeTag>
-struct LinearSolverMaxIter {
-    using type = UndefinedProperty;
-};
+struct LinearSolverMaxIter { using type = UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct LinearSolverRestart {
-    using type = UndefinedProperty;
-};
-//
-// LinearSolverVerbosity defined in opm-models
-//
+struct LinearSolverRestart { using type = UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct IluRelaxation {
-    using type = UndefinedProperty;
-};
+struct IluRelaxation { using type = UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct IluFillinLevel {
-    using type = UndefinedProperty;
-};
+struct IluFillinLevel { using type = UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct MiluVariant {
-    using type = UndefinedProperty;
-};
+struct MiluVariant { using type = UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct IluRedblack {
-    using type = UndefinedProperty;
-};
+struct IluRedblack { using type = UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct IluReorderSpheres {
-    using type = UndefinedProperty;
-};
+struct IluReorderSpheres { using type = UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct UseGmres {
-    using type = UndefinedProperty;
-};
+struct UseGmres { using type = UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct LinearSolverIgnoreConvergenceFailure{
-    using type = UndefinedProperty;
-};
+struct LinearSolverIgnoreConvergenceFailure { using type = UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct ScaleLinearSystem {
-    using type = UndefinedProperty;
-};
+struct ScaleLinearSystem { using type = UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct LinearSolver {
-    using type = UndefinedProperty;
-};
+struct LinearSolver { using type = UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct LinearSolverPrintJsonDefinition {
-    using type = UndefinedProperty;
-};
+struct LinearSolverPrintJsonDefinition { using type = UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct CprReuseSetup {
-    using type = UndefinedProperty;
-};
+struct CprReuseSetup { using type = UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct CprReuseInterval {
-    using type = UndefinedProperty;
-};
+struct CprReuseInterval { using type = UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct AcceleratorMode {
-    using type = UndefinedProperty;
-};
+struct AcceleratorMode { using type = UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct BdaDeviceId {
-    using type = UndefinedProperty;
-};
+struct BdaDeviceId { using type = UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct OpenclPlatformId {
-    using type = UndefinedProperty;
-};
+struct OpenclPlatformId { using type = UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct OpenclIluParallel {
-    using type = UndefinedProperty;
-};
+struct OpenclIluParallel { using type = UndefinedProperty; };
+
 template<class TypeTag>
-struct LinearSolverReduction<TypeTag, TTag::FlowIstlSolverParams> {
+struct LinearSolverReduction<TypeTag, TTag::FlowIstlSolverParams>
+{
     using type = GetPropType<TypeTag, Scalar>;
     static constexpr type value = 1e-2;
 };
+
 template<class TypeTag>
-struct RelaxedLinearSolverReduction<TypeTag, TTag::FlowIstlSolverParams> {
+struct RelaxedLinearSolverReduction<TypeTag, TTag::FlowIstlSolverParams>
+{
     using type = GetPropType<TypeTag, Scalar>;
     static constexpr type value = 1e-2;
 };
+
 template<class TypeTag>
-struct LinearSolverMaxIter<TypeTag, TTag::FlowIstlSolverParams> {
-    static constexpr int value = 200;
-};
+struct LinearSolverMaxIter<TypeTag, TTag::FlowIstlSolverParams>
+{ static constexpr int value = 200; };
+
 template<class TypeTag>
-struct LinearSolverRestart<TypeTag, TTag::FlowIstlSolverParams> {
-    static constexpr int value = 40;
-};
+struct LinearSolverRestart<TypeTag, TTag::FlowIstlSolverParams>
+{ static constexpr int value = 40; };
+
 template<class TypeTag>
-struct LinearSolverVerbosity<TypeTag, TTag::FlowIstlSolverParams> {
-    static constexpr int value = 0;
-};
-template<class TypeTag>
-struct IluRelaxation<TypeTag, TTag::FlowIstlSolverParams> {
+struct IluRelaxation<TypeTag, TTag::FlowIstlSolverParams>
+{
     using type = GetPropType<TypeTag, Scalar>;
     static constexpr type value = 0.9;
 };
+
 template<class TypeTag>
-struct IluFillinLevel<TypeTag, TTag::FlowIstlSolverParams> {
-    static constexpr int value = 0;
-};
+struct IluFillinLevel<TypeTag, TTag::FlowIstlSolverParams>
+{ static constexpr int value = 0; };
+
 template<class TypeTag>
-struct MiluVariant<TypeTag, TTag::FlowIstlSolverParams> {
-    static constexpr auto value = "ILU";
-};
+struct MiluVariant<TypeTag, TTag::FlowIstlSolverParams>
+{ static constexpr auto value = "ILU"; };
+
 template<class TypeTag>
-struct IluRedblack<TypeTag, TTag::FlowIstlSolverParams> {
-    static constexpr bool value = false;
-};
+struct IluRedblack<TypeTag, TTag::FlowIstlSolverParams>
+{ static constexpr bool value = false; };
+
 template<class TypeTag>
-struct IluReorderSpheres<TypeTag, TTag::FlowIstlSolverParams> {
-    static constexpr bool value = false;
-};
+struct IluReorderSpheres<TypeTag, TTag::FlowIstlSolverParams>
+{ static constexpr bool value = false; };
+
 template<class TypeTag>
-struct UseGmres<TypeTag, TTag::FlowIstlSolverParams> {
-    static constexpr bool value = false;
-};
+struct UseGmres<TypeTag, TTag::FlowIstlSolverParams>
+{ static constexpr bool value = false; };
+
 template<class TypeTag>
-struct LinearSolverIgnoreConvergenceFailure<TypeTag, TTag::FlowIstlSolverParams> {
-    static constexpr bool value = false;
-};
+struct LinearSolverIgnoreConvergenceFailure<TypeTag, TTag::FlowIstlSolverParams>
+{ static constexpr bool value = false; };
+
 template<class TypeTag>
-struct ScaleLinearSystem<TypeTag, TTag::FlowIstlSolverParams> {
-    static constexpr bool value = false;
-};
+struct ScaleLinearSystem<TypeTag, TTag::FlowIstlSolverParams>
+{ static constexpr bool value = false; };
+
 template<class TypeTag>
-struct LinearSolver<TypeTag, TTag::FlowIstlSolverParams> {
-    static constexpr auto value = "ilu0";
-};
+struct LinearSolver<TypeTag, TTag::FlowIstlSolverParams>
+{ static constexpr auto value = "ilu0"; };
+
 template<class TypeTag>
-struct LinearSolverPrintJsonDefinition<TypeTag, TTag::FlowIstlSolverParams> {
-    static constexpr auto value = true;
-};
+struct LinearSolverPrintJsonDefinition<TypeTag, TTag::FlowIstlSolverParams>
+{ static constexpr auto value = true; };
+
 template<class TypeTag>
-struct CprReuseSetup<TypeTag, TTag::FlowIstlSolverParams> {
-    static constexpr int value = 4;
-};
+struct CprReuseSetup<TypeTag, TTag::FlowIstlSolverParams>
+{ static constexpr int value = 4; };
+
 template<class TypeTag>
-struct CprReuseInterval<TypeTag, TTag::FlowIstlSolverParams> {
-    static constexpr int value = 30;
-};
+struct CprReuseInterval<TypeTag, TTag::FlowIstlSolverParams>
+{ static constexpr int value = 30; };
+
 template<class TypeTag>
-struct AcceleratorMode<TypeTag, TTag::FlowIstlSolverParams> {
-    static constexpr auto value = "none";
-};
+struct AcceleratorMode<TypeTag, TTag::FlowIstlSolverParams>
+{ static constexpr auto value = "none"; };
+
 template<class TypeTag>
-struct BdaDeviceId<TypeTag, TTag::FlowIstlSolverParams> {
-    static constexpr int value = 0;
-};
+struct BdaDeviceId<TypeTag, TTag::FlowIstlSolverParams>
+{ static constexpr int value = 0; };
+
 template<class TypeTag>
-struct OpenclPlatformId<TypeTag, TTag::FlowIstlSolverParams> {
-    static constexpr int value = 0;
-};
+struct OpenclPlatformId<TypeTag, TTag::FlowIstlSolverParams>
+{ static constexpr int value = 0; };
+
 template<class TypeTag>
-struct OpenclIluParallel<TypeTag, TTag::FlowIstlSolverParams> {
-    static constexpr bool value = true; // note: false should only be used in debug
-};
+struct OpenclIluParallel<TypeTag, TTag::FlowIstlSolverParams>
+{  static constexpr bool value = true; }; // note: false should only be used in debug
 
 // Set the backend to be used.
 template<class TypeTag>
-struct LinearSolverBackend<TypeTag, TTag::FlowIstlSolverParams> {
+struct LinearSolverBackend<TypeTag, TTag::FlowIstlSolverParams>
+{
 #if COMPILE_BDA_BRIDGE
     using type = ISTLSolverBda<TypeTag>;
 #else
     using type = ISTLSolver<TypeTag>;
 #endif
 };
+
 } // namespace Opm::Properties
 
-namespace Opm
+namespace Opm::Parameters {
+
+template<class TypeTag>
+struct LinearSolverVerbosity<TypeTag, Properties::TTag::FlowIstlSolverParams>
+{ static constexpr int value = 0; };
+
+} // namespace Opm::Properties
+
+namespace Opm {
+
+/// This class carries all parameters for the NewtonIterationBlackoilInterleaved class.
+struct FlowLinearSolverParameters
 {
+    double linear_solver_reduction_;
+    double relaxed_linear_solver_reduction_;
+    int    linear_solver_maxiter_;
+    int    linear_solver_restart_;
+    int    linear_solver_verbosity_;
+    double ilu_relaxation_;
+    int    ilu_fillin_level_;
+    MILU_VARIANT   ilu_milu_;
+    bool   ilu_redblack_;
+    bool   ilu_reorder_sphere_;
+    bool   newton_use_gmres_;
+    bool   ignoreConvergenceFailure_;
+    bool scale_linear_system_;
+    std::string linsolver_;
+    bool linear_solver_print_json_definition_;
+    int cpr_reuse_setup_;
+    int cpr_reuse_interval_;
+    std::string accelerator_mode_;
+    int bda_device_id_;
+    int opencl_platform_id_;
+    bool opencl_ilu_parallel_;
 
-
-    /// This class carries all parameters for the NewtonIterationBlackoilInterleaved class.
-    struct FlowLinearSolverParameters
+    template <class TypeTag>
+    void init(bool cprRequestedInDataFile)
     {
-        double linear_solver_reduction_;
-        double relaxed_linear_solver_reduction_;
-        int    linear_solver_maxiter_;
-        int    linear_solver_restart_;
-        int    linear_solver_verbosity_;
-        double ilu_relaxation_;
-        int    ilu_fillin_level_;
-        MILU_VARIANT   ilu_milu_;
-        bool   ilu_redblack_;
-        bool   ilu_reorder_sphere_;
-        bool   newton_use_gmres_;
-        bool   ignoreConvergenceFailure_;
-        bool scale_linear_system_;
-        std::string linsolver_;
-        bool linear_solver_print_json_definition_;
-        int cpr_reuse_setup_;
-        int cpr_reuse_interval_;
-        std::string accelerator_mode_;
-        int bda_device_id_;
-        int opencl_platform_id_;
-        bool opencl_ilu_parallel_;
+        // TODO: these parameters have undocumented non-trivial dependencies
+        linear_solver_reduction_ = Parameters::get<TypeTag, Properties::LinearSolverReduction>();
+        relaxed_linear_solver_reduction_ = Parameters::get<TypeTag, Properties::RelaxedLinearSolverReduction>();
+        linear_solver_maxiter_ = Parameters::get<TypeTag, Properties::LinearSolverMaxIter>();
+        linear_solver_restart_ = Parameters::get<TypeTag, Properties::LinearSolverRestart>();
+        linear_solver_verbosity_ = Parameters::get<TypeTag, Parameters::LinearSolverVerbosity>();
+        ilu_relaxation_ = Parameters::get<TypeTag, Properties::IluRelaxation>();
+        ilu_fillin_level_ = Parameters::get<TypeTag, Properties::IluFillinLevel>();
+        ilu_milu_ = convertString2Milu(Parameters::get<TypeTag, Properties::MiluVariant>());
+        ilu_redblack_ = Parameters::get<TypeTag, Properties::IluRedblack>();
+        ilu_reorder_sphere_ = Parameters::get<TypeTag, Properties::IluReorderSpheres>();
+        newton_use_gmres_ = Parameters::get<TypeTag, Properties::UseGmres>();
+        ignoreConvergenceFailure_ = Parameters::get<TypeTag, Properties::LinearSolverIgnoreConvergenceFailure>();
+        scale_linear_system_ = Parameters::get<TypeTag, Properties::ScaleLinearSystem>();
+        linsolver_ = Parameters::get<TypeTag, Properties::LinearSolver>();
+        linear_solver_print_json_definition_ = Parameters::get<TypeTag, Properties::LinearSolverPrintJsonDefinition>();
+        cpr_reuse_setup_  = Parameters::get<TypeTag, Properties::CprReuseSetup>();
+        cpr_reuse_interval_  = Parameters::get<TypeTag, Properties::CprReuseInterval>();
 
-        template <class TypeTag>
-        void init(bool cprRequestedInDataFile)
-        {
-            // TODO: these parameters have undocumented non-trivial dependencies
-            linear_solver_reduction_ = Parameters::get<TypeTag, Properties::LinearSolverReduction>();
-            relaxed_linear_solver_reduction_ = Parameters::get<TypeTag, Properties::RelaxedLinearSolverReduction>();
-            linear_solver_maxiter_ = Parameters::get<TypeTag, Properties::LinearSolverMaxIter>();
-            linear_solver_restart_ = Parameters::get<TypeTag, Properties::LinearSolverRestart>();
-            linear_solver_verbosity_ = Parameters::get<TypeTag, Properties::LinearSolverVerbosity>();
-            ilu_relaxation_ = Parameters::get<TypeTag, Properties::IluRelaxation>();
-            ilu_fillin_level_ = Parameters::get<TypeTag, Properties::IluFillinLevel>();
-            ilu_milu_ = convertString2Milu(Parameters::get<TypeTag, Properties::MiluVariant>());
-            ilu_redblack_ = Parameters::get<TypeTag, Properties::IluRedblack>();
-            ilu_reorder_sphere_ = Parameters::get<TypeTag, Properties::IluReorderSpheres>();
-            newton_use_gmres_ = Parameters::get<TypeTag, Properties::UseGmres>();
-            ignoreConvergenceFailure_ = Parameters::get<TypeTag, Properties::LinearSolverIgnoreConvergenceFailure>();
-            scale_linear_system_ = Parameters::get<TypeTag, Properties::ScaleLinearSystem>();
+        if (!Parameters::isSet<TypeTag, Properties::LinearSolver>() && cprRequestedInDataFile) {
+            linsolver_ = "cpr";
+        } else {
             linsolver_ = Parameters::get<TypeTag, Properties::LinearSolver>();
-            linear_solver_print_json_definition_ = Parameters::get<TypeTag, Properties::LinearSolverPrintJsonDefinition>();
-            cpr_reuse_setup_  = Parameters::get<TypeTag, Properties::CprReuseSetup>();
-            cpr_reuse_interval_  = Parameters::get<TypeTag, Properties::CprReuseInterval>();
-
-            if (!Parameters::isSet<TypeTag, Properties::LinearSolver>() && cprRequestedInDataFile) {
-                linsolver_ = "cpr";
-            } else {
-                linsolver_ = Parameters::get<TypeTag, Properties::LinearSolver>();
-            }
-
-            accelerator_mode_ = Parameters::get<TypeTag, Properties::AcceleratorMode>();
-            bda_device_id_ = Parameters::get<TypeTag, Properties::BdaDeviceId>();
-            opencl_platform_id_ = Parameters::get<TypeTag, Properties::OpenclPlatformId>();
-            opencl_ilu_parallel_ = Parameters::get<TypeTag, Properties::OpenclIluParallel>();
         }
 
-        template <class TypeTag>
-        static void registerParameters()
-        {
-            Parameters::registerParam<TypeTag, Properties::LinearSolverReduction>
-                ("The minimum reduction of the residual which the linear solver must achieve");
-            Parameters::registerParam<TypeTag, Properties::RelaxedLinearSolverReduction>
-                ("The minimum reduction of the residual which the linear solver need to "
-                 "achieve for the solution to be accepted");
-            Parameters::registerParam<TypeTag, Properties::LinearSolverMaxIter>
-                ("The maximum number of iterations of the linear solver");
-            Parameters::registerParam<TypeTag, Properties::LinearSolverRestart>
-                ("The number of iterations after which GMRES is restarted");
-            Parameters::registerParam<TypeTag, Properties::LinearSolverVerbosity>
-                ("The verbosity level of the linear solver (0: off, 2: all)");
-            Parameters::registerParam<TypeTag, Properties::IluRelaxation>
-                ("The relaxation factor of the linear solver's ILU preconditioner");
-            Parameters::registerParam<TypeTag, Properties::IluFillinLevel>
-                ("The fill-in level of the linear solver's ILU preconditioner");
-            Parameters::registerParam<TypeTag, Properties::MiluVariant>
-                ("Specify which variant of the modified-ILU preconditioner ought to be used. "
-                 "Possible variants are: ILU (default, plain ILU), "
-                 "MILU_1 (lump diagonal with dropped row entries), "
-                 "MILU_2 (lump diagonal with the sum of the absolute values of the dropped row entries), "
-                 "MILU_3 (if diagonal is positive add sum of dropped row entries, otherwise subtract them), "
-                 "MILU_4 (if diagonal is positive add sum of dropped row entries, otherwise do nothing");
-            Parameters::registerParam<TypeTag, Properties::IluRedblack>
-                ("Use red-black partitioning for the ILU preconditioner");
-            Parameters::registerParam<TypeTag, Properties::IluReorderSpheres>
-                ("Whether to reorder the entries of the matrix in the red-black "
-                 "ILU preconditioner in spheres starting at an edge. "
-                 "If false the original ordering is preserved in each color. "
-                 "Otherwise why try to ensure D4 ordering (in a 2D structured grid, "
-                 "the diagonal elements are consecutive).");
-            Parameters::registerParam<TypeTag, Properties::UseGmres>
-                ("Use GMRES as the linear solver");
-            Parameters::registerParam<TypeTag, Properties::LinearSolverIgnoreConvergenceFailure>
-                ("Continue with the simulation like nothing happened "
-                 "after the linear solver did not converge");
-            Parameters::registerParam<TypeTag, Properties::ScaleLinearSystem>
-                ("Scale linear system according to equation scale and primary variable types");
-            Parameters::registerParam<TypeTag, Properties::LinearSolver>
-                ("Configuration of solver. Valid options are: ilu0 (default), "
-                 "dilu, cprw, cpr (an alias for cprw), cpr_quasiimpes, "
-                 "cpr_trueimpes, cpr_trueimpesanalytic, amg or hybrid (experimental). "
-                 "Alternatively, you can request a configuration to be read from a "
-                 "JSON file by giving the filename here, ending with '.json.'");
-            Parameters::registerParam<TypeTag, Properties::LinearSolverPrintJsonDefinition>
-                ("Write the JSON definition of the linear solver setup to the DBG file.");
-            Parameters::registerParam<TypeTag, Properties::CprReuseSetup>
-                ("Reuse preconditioner setup. Valid options are "
-                 "0: recreate the preconditioner for every linear solve, "
-                 "1: recreate once every timestep, "
-                 "2: recreate if last linear solve took more than 10 iterations, "
-                 "3: never recreate, "
-                 "4: recreated every CprReuseInterval");
-            Parameters::registerParam<TypeTag, Properties::CprReuseInterval>
-                ("Reuse preconditioner interval. Used when CprReuseSetup is set to 4, "
-                 "then the preconditioner will be fully recreated instead of reused "
-                 "every N linear solve, where N is this parameter.");
-            Parameters::registerParam<TypeTag, Properties::AcceleratorMode>
-                ("Choose a linear solver, usage: "
-                 "'--accelerator-mode=[none|cusparse|opencl|amgcl|rocalution|rocsparse]'");
-            Parameters::registerParam<TypeTag, Properties::BdaDeviceId>
-                ("Choose device ID for cusparseSolver or openclSolver, "
-                 "use 'nvidia-smi' or 'clinfo' to determine valid IDs");
-            Parameters::registerParam<TypeTag, Properties::OpenclPlatformId>
-                ("Choose platform ID for openclSolver, use 'clinfo' "
-                 "to determine valid platform IDs");
-            Parameters::registerParam<TypeTag, Properties::OpenclIluParallel>
-                ("Parallelize ILU decomposition and application on GPU");
-        }
+        accelerator_mode_ = Parameters::get<TypeTag, Properties::AcceleratorMode>();
+        bda_device_id_ = Parameters::get<TypeTag, Properties::BdaDeviceId>();
+        opencl_platform_id_ = Parameters::get<TypeTag, Properties::OpenclPlatformId>();
+        opencl_ilu_parallel_ = Parameters::get<TypeTag, Properties::OpenclIluParallel>();
+    }
 
-        FlowLinearSolverParameters() { reset(); }
+    template <class TypeTag>
+    static void registerParameters()
+    {
+        Parameters::registerParam<TypeTag, Properties::LinearSolverReduction>
+            ("The minimum reduction of the residual which the linear solver must achieve");
+        Parameters::registerParam<TypeTag, Properties::RelaxedLinearSolverReduction>
+            ("The minimum reduction of the residual which the linear solver need to "
+             "achieve for the solution to be accepted");
+        Parameters::registerParam<TypeTag, Properties::LinearSolverMaxIter>
+            ("The maximum number of iterations of the linear solver");
+        Parameters::registerParam<TypeTag, Properties::LinearSolverRestart>
+            ("The number of iterations after which GMRES is restarted");
+        Parameters::registerParam<TypeTag, Parameters::LinearSolverVerbosity>
+            ("The verbosity level of the linear solver (0: off, 2: all)");
+        Parameters::registerParam<TypeTag, Properties::IluRelaxation>
+            ("The relaxation factor of the linear solver's ILU preconditioner");
+        Parameters::registerParam<TypeTag, Properties::IluFillinLevel>
+            ("The fill-in level of the linear solver's ILU preconditioner");
+        Parameters::registerParam<TypeTag, Properties::MiluVariant>
+            ("Specify which variant of the modified-ILU preconditioner ought to be used. "
+             "Possible variants are: ILU (default, plain ILU), "
+             "MILU_1 (lump diagonal with dropped row entries), "
+             "MILU_2 (lump diagonal with the sum of the absolute values of the dropped row entries), "
+             "MILU_3 (if diagonal is positive add sum of dropped row entries, otherwise subtract them), "
+             "MILU_4 (if diagonal is positive add sum of dropped row entries, otherwise do nothing");
+        Parameters::registerParam<TypeTag, Properties::IluRedblack>
+            ("Use red-black partitioning for the ILU preconditioner");
+        Parameters::registerParam<TypeTag, Properties::IluReorderSpheres>
+            ("Whether to reorder the entries of the matrix in the red-black "
+             "ILU preconditioner in spheres starting at an edge. "
+             "If false the original ordering is preserved in each color. "
+             "Otherwise why try to ensure D4 ordering (in a 2D structured grid, "
+             "the diagonal elements are consecutive).");
+        Parameters::registerParam<TypeTag, Properties::UseGmres>
+            ("Use GMRES as the linear solver");
+        Parameters::registerParam<TypeTag, Properties::LinearSolverIgnoreConvergenceFailure>
+            ("Continue with the simulation like nothing happened "
+             "after the linear solver did not converge");
+        Parameters::registerParam<TypeTag, Properties::ScaleLinearSystem>
+            ("Scale linear system according to equation scale and primary variable types");
+        Parameters::registerParam<TypeTag, Properties::LinearSolver>
+            ("Configuration of solver. Valid options are: ilu0 (default), "
+             "dilu, cprw, cpr (an alias for cprw), cpr_quasiimpes, "
+             "cpr_trueimpes, cpr_trueimpesanalytic, amg or hybrid (experimental). "
+             "Alternatively, you can request a configuration to be read from a "
+             "JSON file by giving the filename here, ending with '.json.'");
+        Parameters::registerParam<TypeTag, Properties::LinearSolverPrintJsonDefinition>
+            ("Write the JSON definition of the linear solver setup to the DBG file.");
+        Parameters::registerParam<TypeTag, Properties::CprReuseSetup>
+            ("Reuse preconditioner setup. Valid options are "
+             "0: recreate the preconditioner for every linear solve, "
+             "1: recreate once every timestep, "
+             "2: recreate if last linear solve took more than 10 iterations, "
+             "3: never recreate, "
+             "4: recreated every CprReuseInterval");
+        Parameters::registerParam<TypeTag, Properties::CprReuseInterval>
+            ("Reuse preconditioner interval. Used when CprReuseSetup is set to 4, "
+             "then the preconditioner will be fully recreated instead of reused "
+             "every N linear solve, where N is this parameter.");
+        Parameters::registerParam<TypeTag, Properties::AcceleratorMode>
+            ("Choose a linear solver, usage: "
+             "'--accelerator-mode=[none|cusparse|opencl|amgcl|rocalution|rocsparse]'");
+        Parameters::registerParam<TypeTag, Properties::BdaDeviceId>
+            ("Choose device ID for cusparseSolver or openclSolver, "
+             "use 'nvidia-smi' or 'clinfo' to determine valid IDs");
+        Parameters::registerParam<TypeTag, Properties::OpenclPlatformId>
+            ("Choose platform ID for openclSolver, use 'clinfo' "
+             "to determine valid platform IDs");
+        Parameters::registerParam<TypeTag, Properties::OpenclIluParallel>
+            ("Parallelize ILU decomposition and application on GPU");
+    }
 
-        // set default values
-        void reset()
-        {
-            relaxed_linear_solver_reduction_ = 1e-2;
-            linear_solver_reduction_  = 1e-2;
-            linear_solver_maxiter_    = 200;
-            linear_solver_restart_    = 40;
-            linear_solver_verbosity_  = 0;
-            ilu_relaxation_           = 0.9;
-            ilu_fillin_level_         = 0;
-            ilu_milu_                 = MILU_VARIANT::ILU;
-            ilu_redblack_             = false;
-            ilu_reorder_sphere_       = false;
-            newton_use_gmres_         = false;
-            ignoreConvergenceFailure_ = false;
-            scale_linear_system_      = false;
-            linsolver_                = "ilu0";
-            linear_solver_print_json_definition_ = true;
-            cpr_reuse_setup_          = 4;
-            cpr_reuse_interval_       = 30;
-            accelerator_mode_         = "none";
-            bda_device_id_            = 0;
-            opencl_platform_id_       = 0;
-            opencl_ilu_parallel_      = true;
-        }
-    };
+    FlowLinearSolverParameters() { reset(); }
 
+    // set default values
+    void reset()
+    {
+        relaxed_linear_solver_reduction_ = 1e-2;
+        linear_solver_reduction_  = 1e-2;
+        linear_solver_maxiter_    = 200;
+        linear_solver_restart_    = 40;
+        linear_solver_verbosity_  = 0;
+        ilu_relaxation_           = 0.9;
+        ilu_fillin_level_         = 0;
+        ilu_milu_                 = MILU_VARIANT::ILU;
+        ilu_redblack_             = false;
+        ilu_reorder_sphere_       = false;
+        newton_use_gmres_         = false;
+        ignoreConvergenceFailure_ = false;
+        scale_linear_system_      = false;
+        linsolver_                = "ilu0";
+        linear_solver_print_json_definition_ = true;
+        cpr_reuse_setup_          = 4;
+        cpr_reuse_interval_       = 30;
+        accelerator_mode_         = "none";
+        bda_device_id_            = 0;
+        opencl_platform_id_       = 0;
+        opencl_ilu_parallel_      = true;
+    }
+};
 
 } // namespace Opm
 
-
-
-
 #endif // OPM_FLOWLINEARSOLVERPARAMETERS_HEADER_INCLUDED