diff --git a/CMakeLists_files.cmake b/CMakeLists_files.cmake
index e71473b51..e1a7a817c 100644
--- a/CMakeLists_files.cmake
+++ b/CMakeLists_files.cmake
@@ -494,6 +494,7 @@ list (APPEND PUBLIC_HEADER_FILES
   opm/simulators/flow/FlowGenericVanguard.hpp
   opm/simulators/flow/FlowMain.hpp
   opm/simulators/flow/FlowProblem.hpp
+  opm/simulators/flow/FlowProblemParameters.hpp
   opm/simulators/flow/FlowProblemProperties.hpp
   opm/simulators/flow/FlowUtils.hpp
   opm/simulators/flow/FlowsData.hpp
diff --git a/opm/simulators/flow/BlackoilModel.hpp b/opm/simulators/flow/BlackoilModel.hpp
index a61f107dd..7bdaee297 100644
--- a/opm/simulators/flow/BlackoilModel.hpp
+++ b/opm/simulators/flow/BlackoilModel.hpp
@@ -79,77 +79,73 @@ struct FlowProblem {
                                     FlowNonLinearSolver, FlowBaseProblem, BlackOilModel>;
 };
 }
-template<class TypeTag>
-struct EnableDebuggingChecks<TypeTag, TTag::FlowProblem> {
-    static constexpr bool value = false;
-};
 // default in flow is to formulate the equations in surface volumes
 template<class TypeTag>
-struct BlackoilConserveSurfaceVolume<TypeTag, TTag::FlowProblem> {
-    static constexpr bool value = true;
-};
-template<class TypeTag>
-struct UseVolumetricResidual<TypeTag, TTag::FlowProblem> {
-    static constexpr bool value = false;
-};
+struct BlackoilConserveSurfaceVolume<TypeTag, TTag::FlowProblem>
+{ static constexpr bool value = true; };
 
 template<class TypeTag>
-struct AquiferModel<TypeTag, TTag::FlowProblem> {
-    using type = BlackoilAquiferModel<TypeTag>;
-};
+struct UseVolumetricResidual<TypeTag, TTag::FlowProblem>
+{ static constexpr bool value = false; };
+
+template<class TypeTag>
+struct AquiferModel<TypeTag, TTag::FlowProblem>
+{ using type = BlackoilAquiferModel<TypeTag>; };
 
 // disable all extensions supported by black oil model. this should not really be
 // necessary but it makes things a bit more explicit
 template<class TypeTag>
-struct EnablePolymer<TypeTag, TTag::FlowProblem> {
-    static constexpr bool value = false;
-};
-template<class TypeTag>
-struct EnableSolvent<TypeTag, TTag::FlowProblem> {
-    static constexpr bool value = false;
-};
-template<class TypeTag>
-struct EnableTemperature<TypeTag, TTag::FlowProblem> {
-    static constexpr bool value = true;
-};
-template<class TypeTag>
-struct EnableEnergy<TypeTag, TTag::FlowProblem> {
-    static constexpr bool value = false;
-};
-template<class TypeTag>
-struct EnableFoam<TypeTag, TTag::FlowProblem> {
-    static constexpr bool value = false;
-};
-template<class TypeTag>
-struct EnableBrine<TypeTag, TTag::FlowProblem> {
-    static constexpr bool value = false;
-};
-template<class TypeTag>
-struct EnableSaltPrecipitation<TypeTag, TTag::FlowProblem> {
-    static constexpr bool value = false;
-};
-template<class TypeTag>
-struct EnableMICP<TypeTag, TTag::FlowProblem> {
-    static constexpr bool value = false;
-};
-template<class TypeTag>
-struct EnableDispersion<TypeTag, TTag::FlowProblem> {
-    static constexpr bool value = false;
-};
+struct EnablePolymer<TypeTag, TTag::FlowProblem>
+{ static constexpr bool value = false; };
 
 template<class TypeTag>
-struct WellModel<TypeTag, TTag::FlowProblem> {
-    using type = BlackoilWellModel<TypeTag>;
-};
+struct EnableSolvent<TypeTag, TTag::FlowProblem>
+{ static constexpr bool value = false; };
+
 template<class TypeTag>
-struct LinearSolverSplice<TypeTag, TTag::FlowProblem> {
-    using type = TTag::FlowIstlSolver;
-};
+struct EnableTemperature<TypeTag, TTag::FlowProblem>
+{ static constexpr bool value = true; };
+
+template<class TypeTag>
+struct EnableEnergy<TypeTag, TTag::FlowProblem>
+{ static constexpr bool value = false; };
+
+template<class TypeTag>
+struct EnableFoam<TypeTag, TTag::FlowProblem>
+{ static constexpr bool value = false; };
+
+template<class TypeTag>
+struct EnableBrine<TypeTag, TTag::FlowProblem>
+{ static constexpr bool value = false; };
+
+template<class TypeTag>
+struct EnableSaltPrecipitation<TypeTag, TTag::FlowProblem>
+{ static constexpr bool value = false; };
+
+template<class TypeTag>
+struct EnableMICP<TypeTag, TTag::FlowProblem>
+{ static constexpr bool value = false; };
+
+template<class TypeTag>
+struct EnableDispersion<TypeTag, TTag::FlowProblem>
+{ static constexpr bool value = false; };
+
+template<class TypeTag>
+struct WellModel<TypeTag, TTag::FlowProblem>
+{ using type = BlackoilWellModel<TypeTag>; };
+
+template<class TypeTag>
+struct LinearSolverSplice<TypeTag, TTag::FlowProblem>
+{ using type = TTag::FlowIstlSolver; };
 
 } // namespace Opm::Properties
 
 namespace Opm::Parameters {
 
+template<class TypeTag>
+struct EnableDebuggingChecks<TypeTag, Properties::TTag::FlowProblem>
+{ static constexpr bool value = false; };
+
 template<class TypeTag>
 struct OutputDir<TypeTag, Properties::TTag::FlowProblem>
 { static constexpr auto value = ""; };
diff --git a/opm/simulators/flow/FlowMain.hpp b/opm/simulators/flow/FlowMain.hpp
index bdfc10823..83dfeeefb 100644
--- a/opm/simulators/flow/FlowMain.hpp
+++ b/opm/simulators/flow/FlowMain.hpp
@@ -154,7 +154,7 @@ namespace Opm {
 
             // the default eWoms checkpoint/restart mechanism does not work with flow
             Parameters::hideParam<TypeTag, Parameters::RestartTime>();
-            Parameters::hideParam<TypeTag, Properties::RestartWritingInterval>();
+            Parameters::hideParam<TypeTag, Parameters::RestartWritingInterval>();
             // hide all vtk related it is not currently possible to do this dependet on if the vtk writing is used
             //if(not(Parameters::get<TypeTag,Properties::EnableVtkOutput>())){
                 Parameters::hideParam<TypeTag, Parameters::VtkWriteOilFormationVolumeFactor>();
diff --git a/opm/simulators/flow/FlowProblem.hpp b/opm/simulators/flow/FlowProblem.hpp
index dcade9404..86c1f399f 100644
--- a/opm/simulators/flow/FlowProblem.hpp
+++ b/opm/simulators/flow/FlowProblem.hpp
@@ -228,20 +228,20 @@ public:
 #endif
         Parameters::registerParam<TypeTag, Properties::EclOutputDoublePrecision>
             ("Tell the output writer to use double precision. Useful for 'perfect' restarts");
-        Parameters::registerParam<TypeTag, Properties::RestartWritingInterval>
+        Parameters::registerParam<TypeTag, Parameters::RestartWritingInterval>
             ("The frequencies of which time steps are serialized to disk");
-        Parameters::registerParam<TypeTag, Properties::EnableDriftCompensation>
+        Parameters::registerParam<TypeTag, Parameters::EnableDriftCompensation>
             ("Enable partial compensation of systematic mass losses via "
              "the source term of the next time step");
-        Parameters::registerParam<TypeTag, Properties::OutputMode>
+        Parameters::registerParam<TypeTag, Parameters::OutputMode>
             ("Specify which messages are going to be printed. "
              "Valid values are: none, log, all (default)");
-        Parameters::registerParam<TypeTag, Properties::NumPressurePointsEquil>
+        Parameters::registerParam<TypeTag, Parameters::NumPressurePointsEquil>
             ("Number of pressure points (in each direction) in tables used for equilibration");
-        Parameters::hideParam<TypeTag, Properties::NumPressurePointsEquil>(); // Users will typically not need to modify this parameter..
-        Parameters::registerParam<TypeTag, Properties::ExplicitRockCompaction>
+        Parameters::hideParam<TypeTag, Parameters::NumPressurePointsEquil>(); // Users will typically not need to modify this parameter..
+        Parameters::registerParam<TypeTag, Parameters::ExplicitRockCompaction>
             ("Use pressure from end of the last time step when evaluating rock compaction");
-        Parameters::hideParam<TypeTag, Properties::ExplicitRockCompaction>(); // Users will typically not need to modify this parameter..
+        Parameters::hideParam<TypeTag, Parameters::ExplicitRockCompaction>(); // Users will typically not need to modify this parameter..
     }
 
 
@@ -311,7 +311,7 @@ public:
         damarisWriter_ = std::make_unique<DamarisWriterType>(simulator);
         enableDamarisOutput_ = Parameters::get<TypeTag, Parameters::EnableDamarisOutput>();
 #endif
-        enableDriftCompensation_ = Parameters::get<TypeTag, Properties::EnableDriftCompensation>();
+        enableDriftCompensation_ = Parameters::get<TypeTag, Parameters::EnableDriftCompensation>();
 
         enableEclOutput_ = Parameters::get<TypeTag, Properties::EnableEclOutput>();
 
@@ -323,14 +323,14 @@ public:
         // 1. Command line value (--num-pressure-points-equil=N)
         // 2. EQLDIMS item 2
         // Default value is defined in opm-common/src/opm/input/eclipse/share/keywords/000_Eclipse100/E/EQLDIMS
-        if (Parameters::isSet<TypeTag, Properties::NumPressurePointsEquil>())
+        if (Parameters::isSet<TypeTag, Parameters::NumPressurePointsEquil>())
         {
-            this->numPressurePointsEquil_ = Parameters::get<TypeTag, Properties::NumPressurePointsEquil>();
+            this->numPressurePointsEquil_ = Parameters::get<TypeTag, Parameters::NumPressurePointsEquil>();
         } else {
             this->numPressurePointsEquil_ = simulator.vanguard().eclState().getTableManager().getEqldims().getNumDepthNodesP();
         }
 
-        explicitRockCompaction_ = Parameters::get<TypeTag, Properties::ExplicitRockCompaction>();
+        explicitRockCompaction_ = Parameters::get<TypeTag, Parameters::ExplicitRockCompaction>();
 
 
         RelpermDiagnostics relpermDiagnostics;
@@ -649,7 +649,7 @@ public:
         OPM_TIMEBLOCK(endTimeStep);
 
 #ifndef NDEBUG
-        if constexpr (getPropValue<TypeTag, Properties::EnableDebuggingChecks>()) {
+        if constexpr (getPropValue<TypeTag, Parameters::EnableDebuggingChecks>()) {
             // in debug mode, we don't care about performance, so we check
             // if the model does the right thing (i.e., the mass change
             // inside the whole reservoir must be equivalent to the fluxes
diff --git a/opm/simulators/flow/FlowProblemParameters.hpp b/opm/simulators/flow/FlowProblemParameters.hpp
new file mode 100644
index 000000000..ab3f80099
--- /dev/null
+++ b/opm/simulators/flow/FlowProblemParameters.hpp
@@ -0,0 +1,63 @@
+// -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+// vi: set et ts=4 sw=4 sts=4:
+/*
+  This file is part of the Open Porous Media project (OPM).
+
+  OPM 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.
+
+  OPM 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 OPM.  If not, see <http://www.gnu.org/licenses/>.
+
+  Consult the COPYING file in the top-level source directory of this
+  module for the precise wording of the license and the list of
+  copyright holders.
+*/
+/*!
+ * \file
+ *
+ * \copydoc Opm::FlowProblem
+ */
+#ifndef OPM_FLOW_PROBLEM_PARAMETERS_HPP
+#define OPM_FLOW_PROBLEM_PARAMETERS_HPP
+
+#include <opm/models/utils/propertysystem.hh>
+
+namespace Opm::Parameters {
+
+// Enable the additional checks even if compiled in debug mode (i.e., with the NDEBUG
+// macro undefined). Next to a slightly better performance, this also eliminates some
+// print statements in debug mode.
+template<class TypeTag, class MyTypeTag>
+struct EnableDebuggingChecks { using type = Properties::UndefinedProperty; };
+
+// Enable partial compensation of systematic mass losses via the source term of the next time
+// step
+template<class TypeTag, class MyTypeTag>
+struct EnableDriftCompensation { using type = Properties::UndefinedProperty; };
+
+// implicit or explicit pressure in rock compaction
+template<class TypeTag, class MyTypeTag>
+struct ExplicitRockCompaction { using type = Properties::UndefinedProperty; };
+
+// Parameterize equilibration accuracy
+template<class TypeTag, class MyTypeTag>
+struct NumPressurePointsEquil { using type = Properties::UndefinedProperty; };
+
+template<class TypeTag, class MyTypeTag>
+struct OutputMode { using type = Properties::UndefinedProperty; };
+
+// The number of time steps skipped between writing two consequtive restart files
+template<class TypeTag, class MyTypeTag>
+struct RestartWritingInterval { using type = Properties::UndefinedProperty; };
+
+} // namespace Opm::Parameters
+
+#endif // OPM_FLOW_PROBLEM_PARAMETERS_HPP
diff --git a/opm/simulators/flow/FlowProblemProperties.hpp b/opm/simulators/flow/FlowProblemProperties.hpp
index de2bacc6c..392263244 100644
--- a/opm/simulators/flow/FlowProblemProperties.hpp
+++ b/opm/simulators/flow/FlowProblemProperties.hpp
@@ -40,6 +40,7 @@
 #include <opm/simulators/flow/CpGridVanguard.hpp>
 #include <opm/simulators/flow/DummyGradientCalculator.hpp>
 #include <opm/simulators/flow/EclWriter.hpp>
+#include <opm/simulators/flow/FlowProblemParameters.hpp>
 #include <opm/simulators/flow/FIBlackoilModel.hpp>
 #include <opm/simulators/flow/NewTranFluxModule.hpp>
 #include <opm/simulators/flow/OutputBlackoilModule.hpp>
@@ -61,113 +62,62 @@ namespace Opm::Properties {
 namespace TTag {
 
 struct FlowBaseProblem {
-  using InheritsFrom = std::tuple<VtkTracer, OutputBlackOil, CpGridVanguard>;
+    using InheritsFrom = std::tuple<VtkTracer, OutputBlackOil, CpGridVanguard>;
 };
+
 }
 
-// The class which deals with wells
+// The class which deals with ECL aquifers
 template<class TypeTag, class MyTypeTag>
-struct WellModel {
-    using type = UndefinedProperty;
-};
-
-// The number of time steps skipped between writing two consequtive restart files
-template<class TypeTag, class MyTypeTag>
-struct RestartWritingInterval {
-    using type = UndefinedProperty;
-};
-
-// Enable partial compensation of systematic mass losses via the source term of the next time
-// step
-template<class TypeTag, class MyTypeTag>
-struct EnableDriftCompensation {
-    using type = UndefinedProperty;
-};
-
-// Enable the additional checks even if compiled in debug mode (i.e., with the NDEBUG
-// macro undefined). Next to a slightly better performance, this also eliminates some
-// print statements in debug mode.
-template<class TypeTag, class MyTypeTag>
-struct EnableDebuggingChecks {
-    using type = UndefinedProperty;
-};
-
-// if thermal flux boundaries are enabled an effort is made to preserve the initial
-// thermal gradient specified via the TEMPVD keyword
-template<class TypeTag, class MyTypeTag>
-struct EnableThermalFluxBoundaries {
-    using type = UndefinedProperty;
-};
+struct AquiferModel { using type = UndefinedProperty; };
 
 // Specify whether API tracking should be enabled (replaces PVT regions).
 // TODO: This is not yet implemented
 template<class TypeTag, class MyTypeTag>
-struct EnableApiTracking {
-    using type = UndefinedProperty;
-};
+struct EnableApiTracking { using type = UndefinedProperty; };
 
-// The class which deals with ECL aquifers
+// if thermal flux boundaries are enabled an effort is made to preserve the initial
+// thermal gradient specified via the TEMPVD keyword
 template<class TypeTag, class MyTypeTag>
-struct AquiferModel {
-    using type = UndefinedProperty;
-};
+struct EnableThermalFluxBoundaries { using type = UndefinedProperty; };
 
+// The class which deals with wells
 template<class TypeTag, class MyTypeTag>
-struct OutputMode {
-    using type = UndefinedProperty;
-};
-// Parameterize equilibration accuracy
-template<class TypeTag, class MyTypeTag>
-struct NumPressurePointsEquil {
-    using type = UndefinedProperty;
-};
-// implicit or explicit pressure in rock compaction
-template<class TypeTag, class MyTypeTag>
-struct ExplicitRockCompaction {
-    using type = UndefinedProperty;
-};
-
-
+struct WellModel { using type = UndefinedProperty; };
 
 // Set the problem property
 template<class TypeTag>
-struct Problem<TypeTag, TTag::FlowBaseProblem> {
-    using type = FlowProblem<TypeTag>;
-};
+struct Problem<TypeTag, TTag::FlowBaseProblem>
+{ using type = FlowProblem<TypeTag>; };
 
 template<class TypeTag>
-struct Model<TypeTag, TTag::FlowBaseProblem> {
-    using type = FIBlackOilModel<TypeTag>;
-};
+struct Model<TypeTag, TTag::FlowBaseProblem>
+{ using type = FIBlackOilModel<TypeTag>; };
 
 // Select the element centered finite volume method as spatial discretization
 template<class TypeTag>
-struct SpatialDiscretizationSplice<TypeTag, TTag::FlowBaseProblem> {
-    using type = TTag::EcfvDiscretization;
-};
+struct SpatialDiscretizationSplice<TypeTag, TTag::FlowBaseProblem>
+{ using type = TTag::EcfvDiscretization; };
 
 // use automatic differentiation to linearize the system of PDEs
 template<class TypeTag>
-struct LocalLinearizerSplice<TypeTag, TTag::FlowBaseProblem> {
-    using type = TTag::AutoDiffLocalLinearizer;
-};
+struct LocalLinearizerSplice<TypeTag, TTag::FlowBaseProblem>
+{ using type = TTag::AutoDiffLocalLinearizer; };
 
 template<class TypeTag>
-struct BaseDiscretizationType<TypeTag, TTag::FlowBaseProblem> {
-    using type = FvBaseDiscretizationNoAdapt<TypeTag>;
-};
+struct BaseDiscretizationType<TypeTag, TTag::FlowBaseProblem>
+{ using type = FvBaseDiscretizationNoAdapt<TypeTag>; };
 
 template<class TypeTag>
-struct DiscreteFunction<TypeTag, TTag::FlowBaseProblem> {
+struct DiscreteFunction<TypeTag, TTag::FlowBaseProblem>
+{
     using BaseDiscretization = FvBaseDiscretization<TypeTag>;
     using type = typename BaseDiscretization::BlockVectorWrapper;
 };
 
 template<class TypeTag>
 struct GridView<TypeTag, TTag::FlowBaseProblem>
-{
-    using type = typename GetPropType<TypeTag, Properties::Grid>::LeafGridView;
-};
+{ using type = typename GetPropType<TypeTag, Properties::Grid>::LeafGridView; };
 
 // Set the material law for fluid fluxes
 template<class TypeTag>
@@ -240,149 +190,99 @@ struct AquiferModel<TypeTag, TTag::FlowBaseProblem> {
 
 // Enable diffusion
 template<class TypeTag>
-struct EnableDiffusion<TypeTag, TTag::FlowBaseProblem> {
-    static constexpr bool value = true;
-};
+struct EnableDiffusion<TypeTag, TTag::FlowBaseProblem>
+{ static constexpr bool value = true; };
 
 // Enable dispersion
 template<class TypeTag>
-struct EnableDispersion<TypeTag, TTag::FlowBaseProblem> {
-    static constexpr bool value = false;
-};
+struct EnableDispersion<TypeTag, TTag::FlowBaseProblem>
+{ static constexpr bool value = false; };
 
 // only write the solutions for the report steps to disk
 template<class TypeTag>
-struct EnableWriteAllSolutions<TypeTag, TTag::FlowBaseProblem> {
-    static constexpr bool value = false;
-};
+struct EnableWriteAllSolutions<TypeTag, TTag::FlowBaseProblem>
+{ static constexpr bool value = false; };
 
 // disable API tracking
 template<class TypeTag>
-struct EnableApiTracking<TypeTag, TTag::FlowBaseProblem> {
-    static constexpr bool value = false;
-};
+struct EnableApiTracking<TypeTag, TTag::FlowBaseProblem>
+{ static constexpr bool value = false; };
 
 // ... but enable the ECL output by default
 template<class TypeTag>
-struct EnableEclOutput<TypeTag,TTag::FlowBaseProblem> {
-    static constexpr bool value = true;
-};
+struct EnableEclOutput<TypeTag,TTag::FlowBaseProblem>
+{ static constexpr bool value = true; };
 
 // If available, write the ECL output in a non-blocking manner
 template<class TypeTag>
-struct EnableAsyncEclOutput<TypeTag, TTag::FlowBaseProblem> {
-    static constexpr bool value = true;
-};
+struct EnableAsyncEclOutput<TypeTag, TTag::FlowBaseProblem>
+{ static constexpr bool value = true; };
 
 // Write ESMRY file for fast loading of summary data
 template<class TypeTag>
-struct EnableEsmry<TypeTag, TTag::FlowBaseProblem> {
-    static constexpr bool value = false;
-};
+struct EnableEsmry<TypeTag, TTag::FlowBaseProblem>
+{ static constexpr bool value = false; };
 
 // By default, use single precision for the ECL formated results
 template<class TypeTag>
-struct EclOutputDoublePrecision<TypeTag, TTag::FlowBaseProblem> {
-    static constexpr bool value = false;
-};
+struct EclOutputDoublePrecision<TypeTag, TTag::FlowBaseProblem>
+{ static constexpr bool value = false; };
 
 // Use the "velocity module" which uses the Eclipse "NEWTRAN" transmissibilities
 template<class TypeTag>
-struct FluxModule<TypeTag, TTag::FlowBaseProblem> {
-    using type = NewTranFluxModule<TypeTag>;
-};
+struct FluxModule<TypeTag, TTag::FlowBaseProblem>
+{ using type = NewTranFluxModule<TypeTag>; };
 
 // Use the dummy gradient calculator in order not to do unnecessary work.
 template<class TypeTag>
-struct GradientCalculator<TypeTag, TTag::FlowBaseProblem> {
-    using type = DummyGradientCalculator<TypeTag>;
-};
-
-// The frequency of writing restart (*.ers) files. This is the number of time steps
-// between writing restart files
-template<class TypeTag>
-struct RestartWritingInterval<TypeTag, TTag::FlowBaseProblem> {
-    static constexpr int value = 0xffffff; // disable
-};
-
-// Drift compensation is an experimental feature, i.e., systematic errors in the
-// conservation quantities are only compensated for
-// as default if experimental mode is enabled.
-template<class TypeTag>
-struct EnableDriftCompensation<TypeTag, TTag::FlowBaseProblem> {
-    static constexpr bool value = true;
-};
-
-// By default, we enable the debugging checks if we're compiled in debug mode
-template<class TypeTag>
-struct EnableDebuggingChecks<TypeTag, TTag::FlowBaseProblem> {
-    static constexpr bool value = true;
-};
+struct GradientCalculator<TypeTag, TTag::FlowBaseProblem>
+{ using type = DummyGradientCalculator<TypeTag>; };
 
 // store temperature (but do not conserve energy, as long as EnableEnergy is false)
 template<class TypeTag>
-struct EnableTemperature<TypeTag, TTag::FlowBaseProblem> {
-    static constexpr bool value = true;
-};
+struct EnableTemperature<TypeTag, TTag::FlowBaseProblem>
+{ static constexpr bool value = true; };
 
 template<class TypeTag>
-struct EnableMech<TypeTag, TTag::FlowBaseProblem> {
-    static constexpr bool value = false;
-};
+struct EnableMech<TypeTag, TTag::FlowBaseProblem>
+{ static constexpr bool value = false; };
+
 // disable all extensions supported by black oil model. this should not really be
 // necessary but it makes things a bit more explicit
 template<class TypeTag>
-struct EnablePolymer<TypeTag, TTag::FlowBaseProblem> {
-    static constexpr bool value = false;
-};
+struct EnablePolymer<TypeTag, TTag::FlowBaseProblem>
+{ static constexpr bool value = false; };
+
 template<class TypeTag>
-struct EnableSolvent<TypeTag, TTag::FlowBaseProblem> {
-    static constexpr bool value = false;
-};
+struct EnableSolvent<TypeTag, TTag::FlowBaseProblem>
+{ static constexpr bool value = false; };
+
 template<class TypeTag>
-struct EnableEnergy<TypeTag, TTag::FlowBaseProblem> {
-    static constexpr bool value = false;
-};
+struct EnableEnergy<TypeTag, TTag::FlowBaseProblem>
+{ static constexpr bool value = false; };
+
 template<class TypeTag>
-struct EnableFoam<TypeTag, TTag::FlowBaseProblem> {
-    static constexpr bool value = false;
-};
+struct EnableFoam<TypeTag, TTag::FlowBaseProblem>
+{ static constexpr bool value = false; };
+
 template<class TypeTag>
-struct EnableExtbo<TypeTag, TTag::FlowBaseProblem> {
-    static constexpr bool value = false;
-};
+struct EnableExtbo<TypeTag, TTag::FlowBaseProblem>
+{ static constexpr bool value = false; };
+
 template<class TypeTag>
-struct EnableMICP<TypeTag, TTag::FlowBaseProblem> {
-    static constexpr bool value = false;
-};
+struct EnableMICP<TypeTag, TTag::FlowBaseProblem>
+{ static constexpr bool value = false; };
 
 // disable thermal flux boundaries by default
 template<class TypeTag>
-struct EnableThermalFluxBoundaries<TypeTag, TTag::FlowBaseProblem> {
-    static constexpr bool value = false;
-};
+struct EnableThermalFluxBoundaries<TypeTag, TTag::FlowBaseProblem>
+{ static constexpr bool value = false; };
 
 // By default, simulators derived from the FlowBaseProblem are production simulators,
 // i.e., experimental features must be explicitly enabled at compile time
 template<class TypeTag>
-struct EnableExperiments<TypeTag, TTag::FlowBaseProblem> {
-    static constexpr bool value = false;
-};
-
-template<class TypeTag>
-struct OutputMode<TypeTag, TTag::FlowBaseProblem> {
-    static constexpr auto value = "all";
-};
-// Parameterize equilibration accuracy
-template<class TypeTag>
-struct NumPressurePointsEquil<TypeTag, TTag::FlowBaseProblem> {
-    static constexpr int value = ParserKeywords::EQLDIMS::DEPTH_NODES_P::defaultValue;
-};
-// By default, use implicit pressure in rock compaction
-template<class TypeTag>
-struct ExplicitRockCompaction<TypeTag, TTag::FlowBaseProblem> {
-    static constexpr bool value = false;
-};
+struct EnableExperiments<TypeTag, TTag::FlowBaseProblem>
+{ static constexpr bool value = false; };
 
 } // namespace Opm::Properties
 
@@ -471,6 +371,18 @@ struct DamarisLimitVariables<TypeTag, Properties::TTag::FlowBaseProblem>
 { static constexpr auto value = ""; };
 #endif
 
+// By default, we enable the debugging checks if we're compiled in debug mode
+template<class TypeTag>
+struct EnableDebuggingChecks<TypeTag, Properties::TTag::FlowBaseProblem>
+{ static constexpr bool value = true; };
+
+// Drift compensation is an experimental feature, i.e., systematic errors in the
+// conservation quantities are only compensated for
+// as default if experimental mode is enabled.
+template<class TypeTag>
+struct EnableDriftCompensation<TypeTag, Properties::TTag::FlowBaseProblem>
+{ static constexpr bool value = true; };
+
 // Enable gravity
 template<class TypeTag>
 struct EnableGravity<TypeTag, Properties::TTag::FlowBaseProblem>
@@ -504,6 +416,11 @@ struct EndTime<TypeTag, Properties::TTag::FlowBaseProblem>
     static constexpr type value = 1e100;
 };
 
+// By default, use implicit pressure in rock compaction
+template<class TypeTag>
+struct ExplicitRockCompaction<TypeTag, Properties::TTag::FlowBaseProblem>
+{ static constexpr bool value = false; };
+
 // The default for the initial time step size of the simulation [s].
 //
 // The chosen value means that the size of the first time step is the
@@ -524,11 +441,26 @@ struct NewtonTolerance<TypeTag, Properties::TTag::FlowBaseProblem>
     static constexpr type value = 1e-2;
 };
 
+// Parameterize equilibration accuracy
+template<class TypeTag>
+struct NumPressurePointsEquil<TypeTag, Properties::TTag::FlowBaseProblem>
+{ static constexpr int value = ParserKeywords::EQLDIMS::DEPTH_NODES_P::defaultValue; };
+
 // The default location for the ECL output files
 template<class TypeTag>
 struct OutputDir<TypeTag, Properties::TTag::FlowBaseProblem>
 { static constexpr auto value = "."; };
 
+template<class TypeTag>
+struct OutputMode<TypeTag, Properties::TTag::FlowBaseProblem>
+{ static constexpr auto value = "all"; };
+
+// The frequency of writing restart (*.ers) files. This is the number of time steps
+// between writing restart files
+template<class TypeTag>
+struct RestartWritingInterval<TypeTag, Properties::TTag::FlowBaseProblem>
+{ static constexpr int value = 0xffffff; }; // disable
+
 } // namespace Opm::Parameters
 
 #endif // OPM_FLOW_PROBLEM_PROPERTIES_HPP
diff --git a/opm/simulators/flow/Main.hpp b/opm/simulators/flow/Main.hpp
index bcee463f2..c9c37a000 100644
--- a/opm/simulators/flow/Main.hpp
+++ b/opm/simulators/flow/Main.hpp
@@ -415,7 +415,7 @@ private:
         try {
             this->readDeck(deckFilename,
                            outputDir,
-                           Parameters::get<PreTypeTag, Properties::OutputMode>(),
+                           Parameters::get<PreTypeTag, Parameters::OutputMode>(),
                            !Parameters::get<PreTypeTag, Parameters::SchedRestart>(),
                            Parameters::get<PreTypeTag, Parameters::EnableLoggingFalloutWarning>(),
                            Parameters::get<PreTypeTag, Parameters::ParsingStrictness>(),