diff --git a/examples/problems/co2ptflashproblem.hh b/examples/problems/co2ptflashproblem.hh
index f3ba95765..6fadfcd9b 100644
--- a/examples/problems/co2ptflashproblem.hh
+++ b/examples/problems/co2ptflashproblem.hh
@@ -174,42 +174,6 @@ struct LinearSolverAbsTolerance<TypeTag, TTag::CO2PTBaseProblem> {
     static constexpr type value = 0.;
 };
 
-// output
-template <class TypeTag>
-struct VtkWriteFilterVelocities<TypeTag, TTag::CO2PTBaseProblem> {
-    static constexpr bool value = true;
-};
-
-template <class TypeTag>
-struct VtkWritePotentialGradients<TypeTag, TTag::CO2PTBaseProblem> {
-    static constexpr bool value = true;
-};
-
-template <class TypeTag>
-struct VtkWriteTotalMassFractions<TypeTag, TTag::CO2PTBaseProblem> {
-    static constexpr bool value = true;
-};
-
-template <class TypeTag>
-struct VtkWriteTotalMoleFractions<TypeTag, TTag::CO2PTBaseProblem> {
-    static constexpr bool value = true;
-};
-
-template <class TypeTag>
-struct VtkWriteFugacityCoeffs<TypeTag, TTag::CO2PTBaseProblem> {
-    static constexpr bool value = true;
-};
-
-template <class TypeTag>
-struct VtkWriteLiquidMoleFractions<TypeTag, TTag::CO2PTBaseProblem> {
-    static constexpr bool value = true;
-};
-
-template <class TypeTag>
-struct VtkWriteEquilibriumConstants<TypeTag, TTag::CO2PTBaseProblem> {
-    static constexpr bool value = true;
-};
-
 // this is kinds of telling the report step length
 template <class TypeTag>
 struct EpisodeLength<TypeTag, TTag::CO2PTBaseProblem> {
@@ -309,6 +273,34 @@ template <class TypeTag>
 struct NewtonMaxIterations<TypeTag, Properties::TTag::CO2PTBaseProblem>
 { static constexpr int value = 30; };
 
+template <class TypeTag>
+struct VtkWriteEquilibriumConstants<TypeTag, Properties::TTag::CO2PTBaseProblem>
+{ static constexpr bool value = true; };
+
+template <class TypeTag>
+struct VtkWriteFilterVelocities<TypeTag, Properties::TTag::CO2PTBaseProblem>
+{ static constexpr bool value = true; };
+
+template <class TypeTag>
+struct VtkWriteFugacityCoeffs<TypeTag, Properties::TTag::CO2PTBaseProblem>
+{ static constexpr bool value = true; };
+
+template <class TypeTag>
+struct VtkWriteLiquidMoleFractions<TypeTag, Properties::TTag::CO2PTBaseProblem>
+{ static constexpr bool value = true; };
+
+template <class TypeTag>
+struct VtkWritePotentialGradients<TypeTag, Properties::TTag::CO2PTBaseProblem>
+{ static constexpr bool value = true; };
+
+template <class TypeTag>
+struct VtkWriteTotalMassFractions<TypeTag, Properties::TTag::CO2PTBaseProblem>
+{ static constexpr bool value = true; };
+
+template <class TypeTag>
+struct VtkWriteTotalMoleFractions<TypeTag, Properties::TTag::CO2PTBaseProblem>
+{ static constexpr bool value = true; };
+
 } // namespace Opm::Parameters
 
 namespace Opm {
diff --git a/examples/problems/lensproblem.hh b/examples/problems/lensproblem.hh
index 65ba80862..d0a75925a 100644
--- a/examples/problems/lensproblem.hh
+++ b/examples/problems/lensproblem.hh
@@ -175,10 +175,6 @@ struct LensUpperRightZ<TypeTag, TTag::LensBaseProblem>
     static constexpr type value = 1.0;
 };
 
-// By default, include the intrinsic permeability tensor to the VTK output files
-template<class TypeTag>
-struct VtkWriteIntrinsicPermeabilities<TypeTag, TTag::LensBaseProblem> { static constexpr bool value = true; };
-
 } // namespace Opm::Properties
 
 namespace Opm::Parameters {
@@ -247,6 +243,11 @@ template<class TypeTag>
 struct NewtonWriteConvergence<TypeTag, Properties::TTag::LensBaseProblem>
 { static constexpr bool value = false; };
 
+// By default, include the intrinsic permeability tensor to the VTK output files
+template<class TypeTag>
+struct VtkWriteIntrinsicPermeabilities<TypeTag, Properties::TTag::LensBaseProblem>
+{ static constexpr bool value = true; };
+
 } // namespace Opm::Parameters
 
 namespace Opm {
diff --git a/examples/problems/outflowproblem.hh b/examples/problems/outflowproblem.hh
index 665a402fc..b1a355ab6 100644
--- a/examples/problems/outflowproblem.hh
+++ b/examples/problems/outflowproblem.hh
@@ -76,10 +76,6 @@ public:
 template<class TypeTag>
 struct EnableGravity<TypeTag, TTag::OutflowBaseProblem> { static constexpr bool value = false; };
 
-// Also write mass fractions to the output
-template<class TypeTag>
-struct VtkWriteMassFractions<TypeTag, TTag::OutflowBaseProblem> { static constexpr bool value = true; };
-
 } // namespace Opm::Properties
 
 namespace Opm::Parameters {
@@ -105,6 +101,11 @@ struct InitialTimeStepSize<TypeTag, Properties::TTag::OutflowBaseProblem>
     static constexpr type value = 1;
 };
 
+// Also write mass fractions to the output
+template<class TypeTag>
+struct VtkWriteMassFractions<TypeTag, Properties::TTag::OutflowBaseProblem>
+{ static constexpr bool value = true; };
+
 } // namespac Opm::Parameters
 
 namespace Opm {
diff --git a/examples/problems/powerinjectionproblem.hh b/examples/problems/powerinjectionproblem.hh
index 24aa69364..18a639b71 100644
--- a/examples/problems/powerinjectionproblem.hh
+++ b/examples/problems/powerinjectionproblem.hh
@@ -119,10 +119,6 @@ public:
     using type = Opm::EffToAbsLaw<EffectiveLaw>;
 };
 
-// Write out the filter velocities for this problem
-template<class TypeTag>
-struct VtkWriteFilterVelocities<TypeTag, TTag::PowerInjectionBaseProblem> { static constexpr bool value = true; };
-
 // Disable gravity
 template<class TypeTag>
 struct EnableGravity<TypeTag, TTag::PowerInjectionBaseProblem> { static constexpr bool value = false; };
@@ -181,6 +177,11 @@ struct InitialTimeStepSize<TypeTag, Properties::TTag::PowerInjectionBaseProblem>
     static constexpr type value = 1e-3;
 };
 
+// Write out the filter velocities for this problem
+template<class TypeTag>
+struct VtkWriteFilterVelocities<TypeTag, Properties::TTag::PowerInjectionBaseProblem>
+{ static constexpr bool value = true; };
+
 } // namespace Opm::Parameters
 
 namespace Opm {
diff --git a/opm/models/immiscible/immisciblemodel.hh b/opm/models/immiscible/immisciblemodel.hh
index ab414342b..450c3b12f 100644
--- a/opm/models/immiscible/immisciblemodel.hh
+++ b/opm/models/immiscible/immisciblemodel.hh
@@ -129,15 +129,6 @@ public:
     using type = Opm::LiquidPhase<Scalar, Opm::NullComponent<Scalar> >;
 };
 
-// disable output of a few quantities which make sense in a
-// multi-phase but not in a single-phase context
-template<class TypeTag>
-struct VtkWriteSaturations<TypeTag, TTag::ImmiscibleSinglePhaseModel> { static constexpr bool value = false; };
-template<class TypeTag>
-struct VtkWriteMobilities<TypeTag, TTag::ImmiscibleSinglePhaseModel> { static constexpr bool value = false; };
-template<class TypeTag>
-struct VtkWriteRelativePermeabilities<TypeTag, TTag::ImmiscibleSinglePhaseModel> { static constexpr bool value = false; };
-
 /////////////////////
 // set slightly different properties for the two-phase case
 /////////////////////
@@ -173,9 +164,26 @@ public:
     using type = Opm::TwoPhaseImmiscibleFluidSystem<Scalar, WettingPhase, NonwettingPhase>;
 };
 
-
 } // namespace Opm::Properties
 
+namespace Opm::Parameters {
+
+// disable output of a few quantities which make sense in a
+// multi-phase but not in a single-phase context
+template<class TypeTag>
+struct VtkWriteSaturations<TypeTag, Properties::TTag::ImmiscibleSinglePhaseModel>
+{ static constexpr bool value = false; };
+
+template<class TypeTag>
+struct VtkWriteMobilities<TypeTag, Properties::TTag::ImmiscibleSinglePhaseModel>
+{ static constexpr bool value = false; };
+
+template<class TypeTag>
+struct VtkWriteRelativePermeabilities<TypeTag, Properties::TTag::ImmiscibleSinglePhaseModel>
+{ static constexpr bool value = false; };
+
+} // namespace Opm::Parameters
+
 namespace Opm {
 
 /*!
diff --git a/opm/models/io/baseoutputmodule.hh b/opm/models/io/baseoutputmodule.hh
index 81ca8fe2e..f1d93924d 100644
--- a/opm/models/io/baseoutputmodule.hh
+++ b/opm/models/io/baseoutputmodule.hh
@@ -27,24 +27,24 @@
 #ifndef EWOMS_BASE_OUTPUT_MODULE_HH
 #define EWOMS_BASE_OUTPUT_MODULE_HH
 
-#include "baseoutputwriter.hh"
-
-#include <opm/models/utils/parametersystem.hh>
-#include <opm/models/utils/propertysystem.hh>
-#include <opm/models/utils/basicproperties.hh>
-#include <opm/models/common/multiphasebaseproperties.hh>
-#include <opm/models/discretization/common/fvbaseproperties.hh>
-
-#include <dune/istl/bvector.hh>
 #include <dune/common/fvector.hh>
 
+#include <dune/istl/bvector.hh>
+
+#include <opm/models/common/multiphasebaseproperties.hh>
+
+#include <opm/models/discretization/common/fvbaseproperties.hh>
+
+#include <opm/models/io/baseoutputwriter.hh>
+
+#include <opm/models/utils/basicproperties.hh>
+#include <opm/models/utils/parametersystem.hh>
+#include <opm/models/utils/propertysystem.hh>
+
 #include <array>
+#include <cstdio>
 #include <sstream>
 #include <string>
-#include <string_view>
-#include <vector>
-
-#include <cstdio>
 
 namespace Opm::Properties {
 
diff --git a/opm/models/io/vtkblackoilenergymodule.hh b/opm/models/io/vtkblackoilenergymodule.hh
index a3ae4edcb..0ce68f4ad 100644
--- a/opm/models/io/vtkblackoilenergymodule.hh
+++ b/opm/models/io/vtkblackoilenergymodule.hh
@@ -27,49 +27,60 @@
 #ifndef EWOMS_VTK_BLACK_OIL_ENERGY_MODULE_HH
 #define EWOMS_VTK_BLACK_OIL_ENERGY_MODULE_HH
 
-#include "vtkmultiwriter.hh"
-#include "baseoutputmodule.hh"
-
 #include <dune/common/fvector.hh>
 
 #include <opm/material/densead/Math.hpp>
 
-#include <opm/models/discretization/common/fvbaseparameters.hh>
-
-#include <opm/models/utils/propertysystem.hh>
-#include <opm/models/utils/parametersystem.hh>
 #include <opm/models/blackoil/blackoilproperties.hh>
 
-namespace Opm::Properties {
+#include <opm/models/discretization/common/fvbaseparameters.hh>
 
-namespace TTag {
+#include <opm/models/io/baseoutputmodule.hh>
+#include <opm/models/io/vtkmultiwriter.hh>
+
+#include <opm/models/utils/parametersystem.hh>
+#include <opm/models/utils/propertysystem.hh>
+
+namespace Opm::Properties::TTag {
 
 // create new type tag for the VTK multi-phase output
 struct VtkBlackOilEnergy {};
 
-} // namespace TTag
+} // namespace Opm::Properties::TTag
+
+namespace Opm::Parameters {
 
 // create the property tags needed for the energy module
 template<class TypeTag, class MyTypeTag>
-struct VtkWriteRockInternalEnergy { using type = UndefinedProperty; };
+struct VtkWriteRockInternalEnergy { using type = Properties::UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct VtkWriteTotalThermalConductivity { using type = UndefinedProperty; };
+struct VtkWriteTotalThermalConductivity { using type = Properties::UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct VtkWriteFluidInternalEnergies { using type = UndefinedProperty; };
+struct VtkWriteFluidInternalEnergies { using type = Properties::UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct VtkWriteFluidEnthalpies { using type = UndefinedProperty; };
+struct VtkWriteFluidEnthalpies { using type = Properties::UndefinedProperty; };
 
 // set default values for what quantities to output
 template<class TypeTag>
-struct VtkWriteRockInternalEnergy<TypeTag, TTag::VtkBlackOilEnergy> { static constexpr bool value = true; };
-template<class TypeTag>
-struct VtkWriteTotalThermalConductivity<TypeTag, TTag::VtkBlackOilEnergy> { static constexpr bool value = true; };
-template<class TypeTag>
-struct VtkWriteFluidInternalEnergies<TypeTag, TTag::VtkBlackOilEnergy> { static constexpr bool value = true; };
-template<class TypeTag>
-struct VtkWriteFluidEnthalpies<TypeTag, TTag::VtkBlackOilEnergy> { static constexpr bool value = true; };
+struct VtkWriteRockInternalEnergy<TypeTag, Properties::TTag::VtkBlackOilEnergy>
+{ static constexpr bool value = true; };
 
-} // namespace Opm::Properties
+template<class TypeTag>
+struct VtkWriteTotalThermalConductivity<TypeTag, Properties::TTag::VtkBlackOilEnergy>
+{ static constexpr bool value = true; };
+
+template<class TypeTag>
+struct VtkWriteFluidInternalEnergies<TypeTag, Properties::TTag::VtkBlackOilEnergy>
+{ static constexpr bool value = true; };
+
+template<class TypeTag>
+struct VtkWriteFluidEnthalpies<TypeTag, Properties::TTag::VtkBlackOilEnergy>
+{ static constexpr bool value = true; };
+
+} // namespace Opm::Parameters
 
 namespace Opm {
 /*!
@@ -112,15 +123,15 @@ public:
         if (!enableEnergy)
             return;
 
-        Parameters::registerParam<TypeTag, Properties::VtkWriteRockInternalEnergy>
+        Parameters::registerParam<TypeTag, Parameters::VtkWriteRockInternalEnergy>
             ("Include the volumetric internal energy of rock "
              "in the VTK output files");
-        Parameters::registerParam<TypeTag, Properties::VtkWriteTotalThermalConductivity>
+        Parameters::registerParam<TypeTag, Parameters::VtkWriteTotalThermalConductivity>
             ("Include the total thermal conductivity of the medium and the fluids "
              "in the VTK output files");
-        Parameters::registerParam<TypeTag, Properties::VtkWriteFluidInternalEnergies>
+        Parameters::registerParam<TypeTag, Parameters::VtkWriteFluidInternalEnergies>
             ("Include the internal energies of the fluids in the VTK output files");
-        Parameters::registerParam<TypeTag, Properties::VtkWriteFluidEnthalpies>
+        Parameters::registerParam<TypeTag, Parameters::VtkWriteFluidEnthalpies>
             ("Include the enthalpies of the fluids in the VTK output files");
     }
 
@@ -212,25 +223,25 @@ public:
 private:
     static bool rockInternalEnergyOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWriteRockInternalEnergy>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWriteRockInternalEnergy>();
         return val;
     }
 
     static bool totalThermalConductivityOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWriteTotalThermalConductivity>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWriteTotalThermalConductivity>();
         return val;
     }
 
     static bool fluidInternalEnergiesOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWriteFluidInternalEnergies>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWriteFluidInternalEnergies>();
         return val;
     }
 
     static bool fluidEnthalpiesOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWriteFluidEnthalpies>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWriteFluidEnthalpies>();
         return val;
     }
 
diff --git a/opm/models/io/vtkblackoilmicpmodule.hh b/opm/models/io/vtkblackoilmicpmodule.hh
index a557ac5db..ebb95e54a 100644
--- a/opm/models/io/vtkblackoilmicpmodule.hh
+++ b/opm/models/io/vtkblackoilmicpmodule.hh
@@ -27,53 +27,67 @@
 #ifndef EWOMS_VTK_BLACK_OIL_MICP_MODULE_HH
 #define EWOMS_VTK_BLACK_OIL_MICP_MODULE_HH
 
-#include "vtkmultiwriter.hh"
-#include "baseoutputmodule.hh"
-
 #include <dune/common/fvector.hh>
 
 #include <opm/material/densead/Math.hpp>
 
-#include <opm/models/discretization/common/fvbaseparameters.hh>
-
-#include <opm/models/utils/propertysystem.hh>
-#include <opm/models/utils/parametersystem.hh>
 #include <opm/models/blackoil/blackoilproperties.hh>
 
-namespace Opm::Properties {
+#include <opm/models/discretization/common/fvbaseparameters.hh>
 
-namespace TTag {
+#include <opm/models/io/baseoutputmodule.hh>
+#include <opm/models/io/vtkmultiwriter.hh>
+
+#include <opm/models/utils/parametersystem.hh>
+#include <opm/models/utils/propertysystem.hh>
+
+namespace Opm::Properties::TTag {
 
 // create new type tag for the VTK multi-phase output
 struct VtkBlackOilMICP {};
 
-} // namespace TTag
+} // namespace Opm::Properties::TTag
+
+namespace Opm::Parameters {
 
 // create the property tags needed for the MICP output module
 template<class TypeTag, class MyTypeTag>
-struct VtkWriteMicrobialConcentration { using type = UndefinedProperty; };
+struct VtkWriteMicrobialConcentration { using type = Properties::UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct VtkWriteOxygenConcentration { using type = UndefinedProperty; };
+struct VtkWriteOxygenConcentration { using type = Properties::UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct VtkWriteUreaConcentration { using type = UndefinedProperty; };
+struct VtkWriteUreaConcentration { using type = Properties::UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct VtkWriteBiofilmConcentration { using type = UndefinedProperty; };
+struct VtkWriteBiofilmConcentration { using type = Properties::UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct VtkWriteCalciteConcentration { using type = UndefinedProperty; };
+struct VtkWriteCalciteConcentration { using type = Properties::UndefinedProperty; };
 
 // set default values for what quantities to output
 template<class TypeTag>
-struct VtkWriteMicrobialConcentration<TypeTag, TTag::VtkBlackOilMICP> { static constexpr bool value = true; };
-template<class TypeTag>
-struct VtkWriteOxygenConcentration<TypeTag, TTag::VtkBlackOilMICP> { static constexpr bool value = true; };
-template<class TypeTag>
-struct VtkWriteUreaConcentration<TypeTag, TTag::VtkBlackOilMICP> { static constexpr bool value = true; };
-template<class TypeTag>
-struct VtkWriteBiofilmConcentration<TypeTag, TTag::VtkBlackOilMICP> { static constexpr bool value = true; };
-template<class TypeTag>
-struct VtkWriteCalciteConcentration<TypeTag, TTag::VtkBlackOilMICP> { static constexpr bool value = true; };
+struct VtkWriteMicrobialConcentration<TypeTag, Properties::TTag::VtkBlackOilMICP>
+{ static constexpr bool value = true; };
 
-} // namespace Opm::Properties
+template<class TypeTag>
+struct VtkWriteOxygenConcentration<TypeTag, Properties::TTag::VtkBlackOilMICP>
+{ static constexpr bool value = true; };
+
+template<class TypeTag>
+struct VtkWriteUreaConcentration<TypeTag, Properties::TTag::VtkBlackOilMICP>
+{ static constexpr bool value = true; };
+
+template<class TypeTag>
+struct VtkWriteBiofilmConcentration<TypeTag, Properties::TTag::VtkBlackOilMICP>
+{ static constexpr bool value = true; };
+
+template<class TypeTag>
+struct VtkWriteCalciteConcentration<TypeTag, Properties::TTag::VtkBlackOilMICP>
+{ static constexpr bool value = true; };
+
+} // namespace Opm::Parameters
 
 namespace Opm {
 /*!
@@ -113,18 +127,18 @@ public:
         if (!enableMICP)
             return;
 
-        Parameters::registerParam<TypeTag, Properties::VtkWriteMicrobialConcentration>
+        Parameters::registerParam<TypeTag, Parameters::VtkWriteMicrobialConcentration>
             ("Include the concentration of the microbial component in the water phase "
              "in the VTK output files");
-        Parameters::registerParam<TypeTag, Properties::VtkWriteOxygenConcentration>
+        Parameters::registerParam<TypeTag, Parameters::VtkWriteOxygenConcentration>
             ("Include the concentration of the oxygen component in the water phase "
              "in the VTK output files");
-        Parameters::registerParam<TypeTag, Properties::VtkWriteUreaConcentration>
+        Parameters::registerParam<TypeTag, Parameters::VtkWriteUreaConcentration>
             ("Include the concentration of the urea component in the water phase "
              "in the VTK output files");
-        Parameters::registerParam<TypeTag, Properties::VtkWriteBiofilmConcentration>
+        Parameters::registerParam<TypeTag, Parameters::VtkWriteBiofilmConcentration>
             ("Include the biofilm volume fraction in the VTK output files");
-        Parameters::registerParam<TypeTag, Properties::VtkWriteCalciteConcentration>
+        Parameters::registerParam<TypeTag, Parameters::VtkWriteCalciteConcentration>
             ("Include the calcite volume fraction in the VTK output files");
     }
 
@@ -223,31 +237,31 @@ public:
 private:
     static bool microbialConcentrationOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWriteMicrobialConcentration>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWriteMicrobialConcentration>();
         return val;
     }
 
     static bool oxygenConcentrationOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWriteOxygenConcentration>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWriteOxygenConcentration>();
         return val;
     }
 
     static bool ureaConcentrationOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWriteUreaConcentration>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWriteUreaConcentration>();
         return val;
     }
 
     static bool biofilmConcentrationOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWriteBiofilmConcentration>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWriteBiofilmConcentration>();
         return val;
     }
 
     static bool calciteConcentrationOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWriteCalciteConcentration>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWriteCalciteConcentration>();
         return val;
     }
 
@@ -257,6 +271,7 @@ private:
     ScalarBuffer biofilmConcentration_;
     ScalarBuffer calciteConcentration_;
 };
+
 } // namespace Opm
 
 #endif
diff --git a/opm/models/io/vtkblackoilmodule.hh b/opm/models/io/vtkblackoilmodule.hh
index 0e7d9d761..75ed870cd 100644
--- a/opm/models/io/vtkblackoilmodule.hh
+++ b/opm/models/io/vtkblackoilmodule.hh
@@ -41,63 +41,95 @@
 #include <opm/models/utils/parametersystem.hh>
 #include <opm/models/utils/propertysystem.hh>
 
-namespace Opm::Properties {
-
-namespace TTag {
+namespace Opm::Properties::TTag {
 
 // create new type tag for the VTK multi-phase output
 struct VtkBlackOil {};
 
-} // namespace TTag
+} // namespace Opm::Properties::TTag
+
+namespace Opm::Parameters {
 
 // create the property tags needed for the multi phase module
 template<class TypeTag, class MyTypeTag>
-struct VtkWriteGasDissolutionFactor { using type = UndefinedProperty; };
+struct VtkWriteGasDissolutionFactor { using type = Properties::UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct VtkWriteOilVaporizationFactor { using type = UndefinedProperty; };
+struct VtkWriteOilVaporizationFactor { using type = Properties::UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct VtkWriteOilFormationVolumeFactor { using type = UndefinedProperty; };
+struct VtkWriteOilFormationVolumeFactor { using type = Properties::UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct VtkWriteGasFormationVolumeFactor { using type = UndefinedProperty; };
+struct VtkWriteGasFormationVolumeFactor { using type = Properties::UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct VtkWriteWaterFormationVolumeFactor { using type = UndefinedProperty; };
+struct VtkWriteWaterFormationVolumeFactor { using type = Properties::UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct VtkWriteOilSaturationPressure { using type = UndefinedProperty; };
+struct VtkWriteOilSaturationPressure { using type = Properties::UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct VtkWriteGasSaturationPressure { using type = UndefinedProperty; };
+struct VtkWriteGasSaturationPressure { using type = Properties::UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct VtkWriteSaturationRatios { using type = UndefinedProperty; };
+struct VtkWriteSaturationRatios { using type = Properties::UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct VtkWriteSaturatedOilGasDissolutionFactor { using type = UndefinedProperty; };
+struct VtkWriteSaturatedOilGasDissolutionFactor { using type = Properties::UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct VtkWriteSaturatedGasOilVaporizationFactor { using type = UndefinedProperty; };
+struct VtkWriteSaturatedGasOilVaporizationFactor { using type = Properties::UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct VtkWritePrimaryVarsMeaning { using type = UndefinedProperty; };
+struct VtkWritePrimaryVarsMeaning { using type = Properties::UndefinedProperty; };
 
 // set default values for what quantities to output
 template<class TypeTag>
-struct VtkWriteGasDissolutionFactor<TypeTag, TTag::VtkBlackOil> { static constexpr bool value = false; };
+struct VtkWriteGasDissolutionFactor<TypeTag, Properties::TTag::VtkBlackOil>
+{ static constexpr bool value = false; };
+
 template<class TypeTag>
-struct VtkWriteOilVaporizationFactor<TypeTag, TTag::VtkBlackOil> { static constexpr bool value = false; };
+struct VtkWriteOilVaporizationFactor<TypeTag, Properties::TTag::VtkBlackOil>
+{ static constexpr bool value = false; };
+
 template<class TypeTag>
-struct VtkWriteOilFormationVolumeFactor<TypeTag, TTag::VtkBlackOil> { static constexpr bool value = false; };
+struct VtkWriteOilFormationVolumeFactor<TypeTag, Properties::TTag::VtkBlackOil>
+{ static constexpr bool value = false; };
+
 template<class TypeTag>
-struct VtkWriteGasFormationVolumeFactor<TypeTag, TTag::VtkBlackOil> { static constexpr bool value = false; };
+struct VtkWriteGasFormationVolumeFactor<TypeTag, Properties::TTag::VtkBlackOil>
+{ static constexpr bool value = false; };
+
 template<class TypeTag>
-struct VtkWriteWaterFormationVolumeFactor<TypeTag, TTag::VtkBlackOil> { static constexpr bool value = false; };
+struct VtkWriteWaterFormationVolumeFactor<TypeTag, Properties::TTag::VtkBlackOil>
+{ static constexpr bool value = false; };
+
 template<class TypeTag>
-struct VtkWriteOilSaturationPressure<TypeTag, TTag::VtkBlackOil> { static constexpr bool value = false; };
+struct VtkWriteOilSaturationPressure<TypeTag, Properties::TTag::VtkBlackOil>
+{ static constexpr bool value = false; };
+
 template<class TypeTag>
-struct VtkWriteGasSaturationPressure<TypeTag, TTag::VtkBlackOil> { static constexpr bool value = false; };
+struct VtkWriteGasSaturationPressure<TypeTag, Properties::TTag::VtkBlackOil>
+{ static constexpr bool value = false; };
+
 template<class TypeTag>
-struct VtkWriteSaturationRatios<TypeTag, TTag::VtkBlackOil> { static constexpr bool value = false; };
+struct VtkWriteSaturationRatios<TypeTag, Properties::TTag::VtkBlackOil>
+{ static constexpr bool value = false; };
+
 template<class TypeTag>
-struct VtkWriteSaturatedOilGasDissolutionFactor<TypeTag, TTag::VtkBlackOil> { static constexpr bool value = false; };
+struct VtkWriteSaturatedOilGasDissolutionFactor<TypeTag, Properties::TTag::VtkBlackOil>
+{ static constexpr bool value = false; };
+
 template<class TypeTag>
-struct VtkWriteSaturatedGasOilVaporizationFactor<TypeTag, TTag::VtkBlackOil> { static constexpr bool value = false; };
+struct VtkWriteSaturatedGasOilVaporizationFactor<TypeTag, Properties::TTag::VtkBlackOil>
+{ static constexpr bool value = false; };
+
 template<class TypeTag>
-struct VtkWritePrimaryVarsMeaning<TypeTag, TTag::VtkBlackOil> { static constexpr bool value = false; };
-} // namespace Opm::Properties
+struct VtkWritePrimaryVarsMeaning<TypeTag, Properties::TTag::VtkBlackOil>
+{ static constexpr bool value = false; };
+
+} // namespace Opm::Parameters
 
 namespace Opm {
 /*!
@@ -142,36 +174,36 @@ public:
      */
     static void registerParameters()
     {
-        Parameters::registerParam<TypeTag, Properties::VtkWriteGasDissolutionFactor>
+        Parameters::registerParam<TypeTag, Parameters::VtkWriteGasDissolutionFactor>
             ("Include the gas dissolution factor (R_s) of the observed oil "
              "in the VTK output files");
-        Parameters::registerParam<TypeTag, Properties::VtkWriteOilVaporizationFactor>
+        Parameters::registerParam<TypeTag, Parameters::VtkWriteOilVaporizationFactor>
             ("Include the oil vaporization factor (R_v) of the observed gas "
              "in the VTK output files");
-        Parameters::registerParam<TypeTag, Properties::VtkWriteOilFormationVolumeFactor>
+        Parameters::registerParam<TypeTag, Parameters::VtkWriteOilFormationVolumeFactor>
             ("Include the oil formation volume factor (B_o) in the VTK output files");
-        Parameters::registerParam<TypeTag, Properties::VtkWriteGasFormationVolumeFactor>
+        Parameters::registerParam<TypeTag, Parameters::VtkWriteGasFormationVolumeFactor>
             ("Include the gas formation volume factor (B_g) in the "
              "VTK output files");
-        Parameters::registerParam<TypeTag, Properties::VtkWriteWaterFormationVolumeFactor>
+        Parameters::registerParam<TypeTag, Parameters::VtkWriteWaterFormationVolumeFactor>
             ("Include the water formation volume factor (B_w) in the "
              "VTK output files");
-        Parameters::registerParam<TypeTag, Properties::VtkWriteOilSaturationPressure>
+        Parameters::registerParam<TypeTag, Parameters::VtkWriteOilSaturationPressure>
             ("Include the saturation pressure of oil (p_o,sat) in the "
              "VTK output files");
-        Parameters::registerParam<TypeTag, Properties::VtkWriteGasSaturationPressure>
+        Parameters::registerParam<TypeTag, Parameters::VtkWriteGasSaturationPressure>
             ("Include the saturation pressure of gas (p_g,sat) in the "
              "VTK output files");
-        Parameters::registerParam<TypeTag, Properties::VtkWriteSaturatedOilGasDissolutionFactor>
+        Parameters::registerParam<TypeTag, Parameters::VtkWriteSaturatedOilGasDissolutionFactor>
             ("Include the gas dissolution factor (R_s,sat) of gas saturated "
              "oil in the VTK output files");
-        Parameters::registerParam<TypeTag, Properties::VtkWriteSaturatedGasOilVaporizationFactor>
+        Parameters::registerParam<TypeTag, Parameters::VtkWriteSaturatedGasOilVaporizationFactor>
             ("Include the oil vaporization factor (R_v,sat) of oil saturated "
              "gas in the VTK output files");
-        Parameters::registerParam<TypeTag, Properties::VtkWriteSaturationRatios>
+        Parameters::registerParam<TypeTag, Parameters::VtkWriteSaturationRatios>
             ("Write the ratio of the actually and maximum dissolved component of "
              "the mixtures");
-        Parameters::registerParam<TypeTag, Properties::VtkWritePrimaryVarsMeaning>
+        Parameters::registerParam<TypeTag, Parameters::VtkWritePrimaryVarsMeaning>
             ("Include how the primary variables should be interpreted to the "
              "VTK output files");
     }
@@ -345,67 +377,67 @@ public:
 private:
     static bool gasDissolutionFactorOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWriteGasDissolutionFactor>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWriteGasDissolutionFactor>();
         return val;
     }
 
     static bool oilVaporizationFactorOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWriteOilVaporizationFactor>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWriteOilVaporizationFactor>();
         return val;
     }
 
     static bool oilFormationVolumeFactorOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWriteOilFormationVolumeFactor>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWriteOilFormationVolumeFactor>();
         return val;
     }
 
     static bool gasFormationVolumeFactorOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWriteGasFormationVolumeFactor>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWriteGasFormationVolumeFactor>();
         return val;
     }
 
     static bool waterFormationVolumeFactorOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWriteWaterFormationVolumeFactor>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWriteWaterFormationVolumeFactor>();
         return val;
     }
 
     static bool oilSaturationPressureOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWriteOilSaturationPressure>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWriteOilSaturationPressure>();
         return val;
     }
 
     static bool gasSaturationPressureOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWriteGasSaturationPressure>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWriteGasSaturationPressure>();
         return val;
     }
 
     static bool saturatedOilGasDissolutionFactorOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWriteSaturatedOilGasDissolutionFactor>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWriteSaturatedOilGasDissolutionFactor>();
         return val;
     }
 
     static bool saturatedGasOilVaporizationFactorOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWriteSaturatedGasOilVaporizationFactor>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWriteSaturatedGasOilVaporizationFactor>();
         return val;
     }
 
     static bool saturationRatiosOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWriteSaturationRatios>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWriteSaturationRatios>();
         return val;
     }
 
     static bool primaryVarsMeaningOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWritePrimaryVarsMeaning>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWritePrimaryVarsMeaning>();
         return val;
     }
 
diff --git a/opm/models/io/vtkblackoilpolymermodule.hh b/opm/models/io/vtkblackoilpolymermodule.hh
index 0da818967..96024d089 100644
--- a/opm/models/io/vtkblackoilpolymermodule.hh
+++ b/opm/models/io/vtkblackoilpolymermodule.hh
@@ -27,57 +27,74 @@
 #ifndef EWOMS_VTK_BLACK_OIL_POLYMER_MODULE_HH
 #define EWOMS_VTK_BLACK_OIL_POLYMER_MODULE_HH
 
-#include "vtkmultiwriter.hh"
-#include "baseoutputmodule.hh"
-
 #include <dune/common/fvector.hh>
 
 #include <opm/material/densead/Math.hpp>
 
-#include <opm/models/discretization/common/fvbaseparameters.hh>
-
-#include <opm/models/utils/propertysystem.hh>
-#include <opm/models/utils/parametersystem.hh>
 #include <opm/models/blackoil/blackoilproperties.hh>
 
-namespace Opm::Properties {
+#include <opm/models/discretization/common/fvbaseparameters.hh>
 
-namespace TTag {
+#include <opm/models/io/baseoutputmodule.hh>
+#include <opm/models/io/vtkmultiwriter.hh>
+
+#include <opm/models/utils/parametersystem.hh>
+#include <opm/models/utils/propertysystem.hh>
+
+namespace Opm::Properties::TTag {
 
 // create new type tag for the VTK multi-phase output
 struct VtkBlackOilPolymer {};
 
-} // namespace TTag
+} // namespace Opm::Properties::TTag
+
+namespace Opm::Parameters {
 
 // create the property tags needed for the polymer output module
 template<class TypeTag, class MyTypeTag>
-struct VtkWritePolymerConcentration { using type = UndefinedProperty; };
+struct VtkWritePolymerConcentration { using type = Properties::UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct VtkWritePolymerDeadPoreVolume { using type = UndefinedProperty; };
+struct VtkWritePolymerDeadPoreVolume { using type = Properties::UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct VtkWritePolymerAdsorption { using type = UndefinedProperty; };
+struct VtkWritePolymerAdsorption { using type = Properties::UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct VtkWritePolymerRockDensity { using type = UndefinedProperty; };
+struct VtkWritePolymerRockDensity { using type = Properties::UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct VtkWritePolymerViscosityCorrection { using type = UndefinedProperty; };
+struct VtkWritePolymerViscosityCorrection { using type = Properties::UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct VtkWriteWaterViscosityCorrection { using type = UndefinedProperty; };
+struct VtkWriteWaterViscosityCorrection { using type = Properties::UndefinedProperty; };
 
 // set default values for what quantities to output
 template<class TypeTag>
-struct VtkWritePolymerConcentration<TypeTag, TTag::VtkBlackOilPolymer> { static constexpr bool value = true; };
-template<class TypeTag>
-struct VtkWritePolymerDeadPoreVolume<TypeTag, TTag::VtkBlackOilPolymer> { static constexpr bool value = true; };
-template<class TypeTag>
-struct VtkWritePolymerViscosityCorrection<TypeTag, TTag::VtkBlackOilPolymer> { static constexpr bool value = true; };
-template<class TypeTag>
-struct VtkWriteWaterViscosityCorrection<TypeTag, TTag::VtkBlackOilPolymer> { static constexpr bool value = true; };
-template<class TypeTag>
-struct VtkWritePolymerRockDensity<TypeTag, TTag::VtkBlackOilPolymer> { static constexpr bool value = true; };
-template<class TypeTag>
-struct VtkWritePolymerAdsorption<TypeTag, TTag::VtkBlackOilPolymer> { static constexpr bool value = true; };
+struct VtkWritePolymerConcentration<TypeTag, Properties::TTag::VtkBlackOilPolymer>
+{ static constexpr bool value = true; };
 
-} // namespace Opm::Properties
+template<class TypeTag>
+struct VtkWritePolymerDeadPoreVolume<TypeTag, Properties::TTag::VtkBlackOilPolymer>
+{ static constexpr bool value = true; };
+
+template<class TypeTag>
+struct VtkWritePolymerViscosityCorrection<TypeTag, Properties::TTag::VtkBlackOilPolymer>
+{ static constexpr bool value = true; };
+
+template<class TypeTag>
+struct VtkWriteWaterViscosityCorrection<TypeTag, Properties::TTag::VtkBlackOilPolymer>
+{ static constexpr bool value = true; };
+
+template<class TypeTag>
+struct VtkWritePolymerRockDensity<TypeTag, Properties::TTag::VtkBlackOilPolymer>
+{ static constexpr bool value = true; };
+
+template<class TypeTag>
+struct VtkWritePolymerAdsorption<TypeTag, Properties::TTag::VtkBlackOilPolymer>
+{ static constexpr bool value = true; };
+
+} // namespace Opm::Parameters
 
 namespace Opm {
 /*!
@@ -117,22 +134,22 @@ public:
         if (!enablePolymer)
             return;
 
-        Parameters::registerParam<TypeTag, Properties::VtkWritePolymerConcentration>
+        Parameters::registerParam<TypeTag, Parameters::VtkWritePolymerConcentration>
             ("Include the concentration of the polymer component in the water phase "
              "in the VTK output files");
-        Parameters::registerParam<TypeTag, Properties::VtkWritePolymerDeadPoreVolume>
+        Parameters::registerParam<TypeTag, Parameters::VtkWritePolymerDeadPoreVolume>
             ("Include the fraction of the \"dead\" pore volume "
              "in the VTK output files");
-        Parameters::registerParam<TypeTag, Properties::VtkWritePolymerRockDensity>
+        Parameters::registerParam<TypeTag, Parameters::VtkWritePolymerRockDensity>
             ("Include the amount of already adsorbed polymer component"
              "in the VTK output files");
-        Parameters::registerParam<TypeTag, Properties::VtkWritePolymerAdsorption>
+        Parameters::registerParam<TypeTag, Parameters::VtkWritePolymerAdsorption>
             ("Include the adsorption rate of the polymer component"
              "in the VTK output files");
-        Parameters::registerParam<TypeTag, Properties::VtkWritePolymerViscosityCorrection>
+        Parameters::registerParam<TypeTag, Parameters::VtkWritePolymerViscosityCorrection>
             ("Include the viscosity correction of the polymer component "
              "in the VTK output files");
-        Parameters::registerParam<TypeTag, Properties::VtkWriteWaterViscosityCorrection>
+        Parameters::registerParam<TypeTag, Parameters::VtkWriteWaterViscosityCorrection>
             ("Include the viscosity correction of the water component "
              "due to polymers in the VTK output files");
     }
@@ -239,37 +256,37 @@ public:
 private:
     static bool polymerConcentrationOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWritePolymerConcentration>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWritePolymerConcentration>();
         return val;
     }
 
     static bool polymerDeadPoreVolumeOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWritePolymerDeadPoreVolume>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWritePolymerDeadPoreVolume>();
         return val;
     }
 
     static bool polymerRockDensityOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWritePolymerRockDensity>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWritePolymerRockDensity>();
         return val;
     }
 
     static bool polymerAdsorptionOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWritePolymerAdsorption>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWritePolymerAdsorption>();
         return val;
     }
 
     static bool polymerViscosityCorrectionOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWritePolymerViscosityCorrection>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWritePolymerViscosityCorrection>();
         return val;
     }
 
     static bool waterViscosityCorrectionOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWritePolymerViscosityCorrection>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWritePolymerViscosityCorrection>();
         return val;
     }
 
diff --git a/opm/models/io/vtkblackoilsolventmodule.hh b/opm/models/io/vtkblackoilsolventmodule.hh
index affc1bc3a..6707c2ddc 100644
--- a/opm/models/io/vtkblackoilsolventmodule.hh
+++ b/opm/models/io/vtkblackoilsolventmodule.hh
@@ -27,51 +27,65 @@
 #ifndef EWOMS_VTK_BLACK_OIL_SOLVENT_MODULE_HH
 #define EWOMS_VTK_BLACK_OIL_SOLVENT_MODULE_HH
 
-#include "vtkmultiwriter.hh"
-#include "baseoutputmodule.hh"
-
 #include <dune/common/fvector.hh>
 
 #include <opm/material/densead/Math.hpp>
 
-#include <opm/models/discretization/common/fvbaseparameters.hh>
-
-#include <opm/models/utils/propertysystem.hh>
-#include <opm/models/utils/parametersystem.hh>
 #include <opm/models/blackoil/blackoilproperties.hh>
 
-namespace Opm::Properties {
+#include <opm/models/discretization/common/fvbaseparameters.hh>
 
-namespace TTag {
+#include <opm/models/io/baseoutputmodule.hh>
+#include <opm/models/io/vtkmultiwriter.hh>
+
+#include <opm/models/utils/parametersystem.hh>
+#include <opm/models/utils/propertysystem.hh>
+
+namespace Opm::Properties::TTag {
 
 // create new type tag for the VTK multi-phase output
 struct VtkBlackOilSolvent {};
 
-} // namespace TTag
+} // namespace Opm::Properties::TTag
+
+namespace Opm::Parameters {
 
 // create the property tags needed for the solvent output module
 template<class TypeTag, class MyTypeTag>
-struct VtkWriteSolventSaturation { using type = UndefinedProperty; };
+struct VtkWriteSolventSaturation { using type = Properties::UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct VtkWriteSolventRsw { using type = UndefinedProperty; };
+struct VtkWriteSolventRsw { using type = Properties::UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct VtkWriteSolventDensity { using type = UndefinedProperty; };
+struct VtkWriteSolventDensity { using type = Properties::UndefinedProperty; };
 template<class TypeTag, class MyTypeTag>
-struct VtkWriteSolventViscosity { using type = UndefinedProperty; };
+
+struct VtkWriteSolventViscosity { using type = Properties::UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct VtkWriteSolventMobility { using type = UndefinedProperty; };
+struct VtkWriteSolventMobility { using type = Properties::UndefinedProperty; };
 
 // set default values for what quantities to output
 template<class TypeTag>
-struct VtkWriteSolventSaturation<TypeTag, TTag::VtkBlackOilSolvent> { static constexpr bool value = true; };
+struct VtkWriteSolventSaturation<TypeTag, Properties::TTag::VtkBlackOilSolvent>
+{ static constexpr bool value = true; };
+
 template<class TypeTag>
-struct VtkWriteSolventRsw<TypeTag, TTag::VtkBlackOilSolvent> { static constexpr bool value = true; };
+struct VtkWriteSolventRsw<TypeTag, Properties::TTag::VtkBlackOilSolvent>
+{ static constexpr bool value = true; };
+
 template<class TypeTag>
-struct VtkWriteSolventDensity<TypeTag, TTag::VtkBlackOilSolvent> { static constexpr bool value = true; };
+struct VtkWriteSolventDensity<TypeTag, Properties::TTag::VtkBlackOilSolvent>
+{ static constexpr bool value = true; };
+
 template<class TypeTag>
-struct VtkWriteSolventViscosity<TypeTag, TTag::VtkBlackOilSolvent> { static constexpr bool value = true; };
+struct VtkWriteSolventViscosity<TypeTag, Properties::TTag::VtkBlackOilSolvent>
+{ static constexpr bool value = true; };
+
 template<class TypeTag>
-struct VtkWriteSolventMobility<TypeTag, TTag::VtkBlackOilSolvent> { static constexpr bool value = true; };
+struct VtkWriteSolventMobility<TypeTag, Properties::TTag::VtkBlackOilSolvent>
+{ static constexpr bool value = true; };
 
 } // namespace Opm::Properties
 
@@ -113,19 +127,19 @@ public:
         if (!enableSolvent)
             return;
 
-        Parameters::registerParam<TypeTag, Properties::VtkWriteSolventSaturation>
+        Parameters::registerParam<TypeTag, Parameters::VtkWriteSolventSaturation>
             ("Include the \"saturation\" of the solvent component "
              "in the VTK output files");
-        Parameters::registerParam<TypeTag, Properties::VtkWriteSolventRsw>
+        Parameters::registerParam<TypeTag, Parameters::VtkWriteSolventRsw>
             ("Include the \"dissolved volume in water\" of the solvent component "
              "in the VTK output files");
-        Parameters::registerParam<TypeTag, Properties::VtkWriteSolventDensity>
+        Parameters::registerParam<TypeTag, Parameters::VtkWriteSolventDensity>
             ("Include the \"density\" of the solvent component "
              "in the VTK output files");
-        Parameters::registerParam<TypeTag, Properties::VtkWriteSolventViscosity>
+        Parameters::registerParam<TypeTag, Parameters::VtkWriteSolventViscosity>
             ("Include the \"viscosity\" of the solvent component "
              "in the VTK output files");
-        Parameters::registerParam<TypeTag, Properties::VtkWriteSolventMobility>
+        Parameters::registerParam<TypeTag, Parameters::VtkWriteSolventMobility>
             ("Include the \"mobility\" of the solvent component "
              "in the VTK output files");
     }
@@ -224,31 +238,31 @@ public:
 private:
     static bool solventSaturationOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWriteSolventSaturation>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWriteSolventSaturation>();
         return val;
     }
 
     static bool solventRswOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWriteSolventRsw>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWriteSolventRsw>();
         return val;
     }
 
     static bool solventDensityOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWriteSolventDensity>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWriteSolventDensity>();
         return val;
     }
 
     static bool solventViscosityOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWriteSolventViscosity>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWriteSolventViscosity>();
         return val;
     }
 
     static bool solventMobilityOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWriteSolventMobility>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWriteSolventMobility>();
         return val;
     }
 
@@ -258,6 +272,7 @@ private:
     ScalarBuffer solventViscosity_;
     ScalarBuffer solventMobility_;
 };
+
 } // namespace Opm
 
 #endif
diff --git a/opm/models/io/vtkcompositionmodule.hh b/opm/models/io/vtkcompositionmodule.hh
index 1b8102b64..ce92e7913 100644
--- a/opm/models/io/vtkcompositionmodule.hh
+++ b/opm/models/io/vtkcompositionmodule.hh
@@ -27,56 +27,75 @@
 #ifndef EWOMS_VTK_COMPOSITION_MODULE_HH
 #define EWOMS_VTK_COMPOSITION_MODULE_HH
 
-#include "vtkmultiwriter.hh"
-#include "baseoutputmodule.hh"
-
 #include <opm/material/common/MathToolbox.hpp>
 
 #include <opm/models/discretization/common/fvbaseparameters.hh>
 
-#include <opm/models/utils/propertysystem.hh>
+#include <opm/models/io/baseoutputmodule.hh>
+#include <opm/models/io/vtkmultiwriter.hh>
+
 #include <opm/models/utils/parametersystem.hh>
+#include <opm/models/utils/propertysystem.hh>
 
-namespace Opm::Properties {
-
-namespace TTag {
+namespace Opm::Properties::TTag {
 
 // create new type tag for the VTK composition output
 struct VtkComposition {};
 
-} // namespace TTag
+} // namespace Opm::Properties::TTag
+
+namespace Opm::Parameters {
 
 // create the property tags needed for the composition module
 template<class TypeTag, class MyTypeTag>
-struct VtkWriteMassFractions { using type = UndefinedProperty; };
+struct VtkWriteMassFractions { using type = Properties::UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct VtkWriteMoleFractions { using type = UndefinedProperty; };
+struct VtkWriteMoleFractions { using type = Properties::UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct VtkWriteTotalMassFractions { using type = UndefinedProperty; };
+struct VtkWriteTotalMassFractions { using type = Properties::UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct VtkWriteTotalMoleFractions { using type = UndefinedProperty; };
+struct VtkWriteTotalMoleFractions { using type = Properties::UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct VtkWriteMolarities { using type = UndefinedProperty; };
+struct VtkWriteMolarities { using type = Properties::UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct VtkWriteFugacities { using type = UndefinedProperty; };
+struct VtkWriteFugacities { using type = Properties::UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct VtkWriteFugacityCoeffs { using type = UndefinedProperty; };
+struct VtkWriteFugacityCoeffs { using type = Properties::UndefinedProperty; };
 
 // set default values for what quantities to output
 template<class TypeTag>
-struct VtkWriteMassFractions<TypeTag, TTag::VtkComposition> { static constexpr bool value = false; };
+struct VtkWriteMassFractions<TypeTag, Properties::TTag::VtkComposition>
+{ static constexpr bool value = false; };
+
 template<class TypeTag>
-struct VtkWriteMoleFractions<TypeTag, TTag::VtkComposition> { static constexpr bool value = true; };
+struct VtkWriteMoleFractions<TypeTag, Properties::TTag::VtkComposition>
+{ static constexpr bool value = true; };
+
 template<class TypeTag>
-struct VtkWriteTotalMassFractions<TypeTag, TTag::VtkComposition> { static constexpr bool value = false; };
+struct VtkWriteTotalMassFractions<TypeTag, Properties::TTag::VtkComposition>
+{ static constexpr bool value = false; };
+
 template<class TypeTag>
-struct VtkWriteTotalMoleFractions<TypeTag, TTag::VtkComposition> { static constexpr bool value = false; };
+struct VtkWriteTotalMoleFractions<TypeTag, Properties::TTag::VtkComposition>
+{ static constexpr bool value = false; };
+
 template<class TypeTag>
-struct VtkWriteMolarities<TypeTag, TTag::VtkComposition> { static constexpr bool value = false; };
+struct VtkWriteMolarities<TypeTag, Properties::TTag::VtkComposition>
+{ static constexpr bool value = false; };
+
 template<class TypeTag>
-struct VtkWriteFugacities<TypeTag, TTag::VtkComposition> { static constexpr bool value = false; };
+struct VtkWriteFugacities<TypeTag, Properties::TTag::VtkComposition>
+{ static constexpr bool value = false; };
+
 template<class TypeTag>
-struct VtkWriteFugacityCoeffs<TypeTag, TTag::VtkComposition> { static constexpr bool value = false; };
+struct VtkWriteFugacityCoeffs<TypeTag, Properties::TTag::VtkComposition>
+{ static constexpr bool value = false; };
 
 } // namespace Opm::Properties
 
@@ -125,19 +144,19 @@ public:
      */
     static void registerParameters()
     {
-        Parameters::registerParam<TypeTag, Properties::VtkWriteMassFractions>
+        Parameters::registerParam<TypeTag, Parameters::VtkWriteMassFractions>
             ("Include mass fractions in the VTK output files");
-        Parameters::registerParam<TypeTag, Properties::VtkWriteMoleFractions>
+        Parameters::registerParam<TypeTag, Parameters::VtkWriteMoleFractions>
             ("Include mole fractions in the VTK output files");
-        Parameters::registerParam<TypeTag, Properties::VtkWriteTotalMassFractions>
+        Parameters::registerParam<TypeTag, Parameters::VtkWriteTotalMassFractions>
             ("Include total mass fractions in the VTK output files");
-        Parameters::registerParam<TypeTag, Properties::VtkWriteTotalMoleFractions>
+        Parameters::registerParam<TypeTag, Parameters::VtkWriteTotalMoleFractions>
             ("Include total mole fractions in the VTK output files");
-        Parameters::registerParam<TypeTag, Properties::VtkWriteMolarities>
+        Parameters::registerParam<TypeTag, Parameters::VtkWriteMolarities>
             ("Include component molarities in the VTK output files");
-        Parameters::registerParam<TypeTag, Properties::VtkWriteFugacities>
+        Parameters::registerParam<TypeTag, Parameters::VtkWriteFugacities>
             ("Include component fugacities in the VTK output files");
-        Parameters::registerParam<TypeTag, Properties::VtkWriteFugacityCoeffs>
+        Parameters::registerParam<TypeTag, Parameters::VtkWriteFugacityCoeffs>
             ("Include component fugacity coefficients in the VTK output files");
     }
 
@@ -258,43 +277,43 @@ public:
 private:
     static bool massFracOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWriteMassFractions>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWriteMassFractions>();
         return val;
     }
 
     static bool moleFracOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWriteMoleFractions>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWriteMoleFractions>();
         return val;
     }
 
     static bool totalMassFracOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWriteTotalMassFractions>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWriteTotalMassFractions>();
         return val;
     }
 
     static bool totalMoleFracOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWriteTotalMoleFractions>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWriteTotalMoleFractions>();
         return val;
     }
 
     static bool molarityOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWriteMolarities>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWriteMolarities>();
         return val;
     }
 
     static bool fugacityOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWriteFugacities>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWriteFugacities>();
         return val;
     }
 
     static bool fugacityCoeffOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWriteFugacityCoeffs>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWriteFugacityCoeffs>();
         return val;
     }
 
diff --git a/opm/models/io/vtkdiffusionmodule.hh b/opm/models/io/vtkdiffusionmodule.hh
index a9f94a9c3..0515e285c 100644
--- a/opm/models/io/vtkdiffusionmodule.hh
+++ b/opm/models/io/vtkdiffusionmodule.hh
@@ -39,33 +39,40 @@
 #include <opm/models/utils/propertysystem.hh>
 #include <opm/models/utils/parametersystem.hh>
 
-namespace Opm::Properties {
-
-namespace TTag {
+namespace Opm::Properties::TTag {
 
 // create new type tag for the VTK output of the quantities for molecular
 // diffusion
 struct VtkDiffusion {};
 
-} // namespace TTag
+} // namespace Opm::Properties::TTag
+
+namespace Opm::Parameters {
 
 // create the property tags needed for the diffusion module
 template<class TypeTag, class MyTypeTag>
-struct VtkWriteTortuosities { using type = UndefinedProperty; };
+struct VtkWriteTortuosities { using type = Properties::UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct VtkWriteDiffusionCoefficients { using type = UndefinedProperty; };
+struct VtkWriteDiffusionCoefficients { using type = Properties::UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct VtkWriteEffectiveDiffusionCoefficients { using type = UndefinedProperty; };
+struct VtkWriteEffectiveDiffusionCoefficients { using type = Properties::UndefinedProperty; };
 
 // set default values for what quantities to output
 template<class TypeTag>
-struct VtkWriteTortuosities<TypeTag, TTag::VtkDiffusion> { static constexpr bool value = false; };
-template<class TypeTag>
-struct VtkWriteDiffusionCoefficients<TypeTag, TTag::VtkDiffusion> { static constexpr bool value = false; };
-template<class TypeTag>
-struct VtkWriteEffectiveDiffusionCoefficients<TypeTag, TTag::VtkDiffusion> { static constexpr bool value = false; };
+struct VtkWriteTortuosities<TypeTag, Properties::TTag::VtkDiffusion>
+{ static constexpr bool value = false; };
 
-} // namespace Opm::Properties
+template<class TypeTag>
+struct VtkWriteDiffusionCoefficients<TypeTag, Properties::TTag::VtkDiffusion>
+{ static constexpr bool value = false; };
+
+template<class TypeTag>
+struct VtkWriteEffectiveDiffusionCoefficients<TypeTag, Properties::TTag::VtkDiffusion>
+{ static constexpr bool value = false; };
+
+} // namespace Opm::Parameters
 
 namespace Opm {
 /*!
@@ -110,12 +117,12 @@ public:
      */
     static void registerParameters()
     {
-        Parameters::registerParam<TypeTag, Properties::VtkWriteTortuosities>
+        Parameters::registerParam<TypeTag, Parameters::VtkWriteTortuosities>
             ("Include the tortuosity for each phase in the VTK output files");
-        Parameters::registerParam<TypeTag, Properties::VtkWriteDiffusionCoefficients>
+        Parameters::registerParam<TypeTag, Parameters::VtkWriteDiffusionCoefficients>
             ("Include the molecular diffusion coefficients in "
              "the VTK output files");
-        Parameters::registerParam<TypeTag, Properties::VtkWriteEffectiveDiffusionCoefficients>
+        Parameters::registerParam<TypeTag, Parameters::VtkWriteEffectiveDiffusionCoefficients>
             ("Include the effective molecular diffusion "
              "coefficients the medium in the VTK output files");
     }
@@ -186,19 +193,19 @@ public:
 private:
     static bool tortuosityOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWriteTortuosities>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWriteTortuosities>();
         return val;
     }
 
     static bool diffusionCoefficientOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWriteDiffusionCoefficients>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWriteDiffusionCoefficients>();
         return val;
     }
 
     static bool effectiveDiffusionCoefficientOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWriteEffectiveDiffusionCoefficients>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWriteEffectiveDiffusionCoefficients>();
         return val;
     }
 
diff --git a/opm/models/io/vtkdiscretefracturemodule.hh b/opm/models/io/vtkdiscretefracturemodule.hh
index 9285e1f8b..1d8f2e5a9 100644
--- a/opm/models/io/vtkdiscretefracturemodule.hh
+++ b/opm/models/io/vtkdiscretefracturemodule.hh
@@ -27,62 +27,81 @@
 #ifndef EWOMS_VTK_DISCRETE_FRACTURE_MODULE_HH
 #define EWOMS_VTK_DISCRETE_FRACTURE_MODULE_HH
 
-#include "vtkmultiwriter.hh"
-#include "baseoutputmodule.hh"
-
 #include <dune/common/fvector.hh>
 
+#include <opm/material/common/Valgrind.hpp>
+
 #include <opm/models/discretization/common/fvbaseparameters.hh>
 
+#include <opm/models/io/baseoutputmodule.hh>
+#include <opm/models/io/vtkmultiwriter.hh>
+
 #include <opm/models/utils/propertysystem.hh>
 #include <opm/models/utils/parametersystem.hh>
 
-#include <opm/material/common/Valgrind.hpp>
-
 #include <cstdio>
 
-namespace Opm::Properties {
-
-namespace TTag {
+namespace Opm::Properties::TTag {
 
 // create new type tag for the VTK multi-phase output
 struct VtkDiscreteFracture {};
 
-} // namespace TTag
+} // namespace Opm::Properties::TTag
+
+namespace Opm::Parameters {
 
 // create the property tags needed for the multi phase module
 template<class TypeTag, class MyTypeTag>
-struct VtkWriteFractureSaturations { using type = UndefinedProperty; };
+struct VtkWriteFractureSaturations { using type = Properties::UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct VtkWriteFractureMobilities { using type = UndefinedProperty; };
+struct VtkWriteFractureMobilities { using type = Properties::UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct VtkWriteFractureRelativePermeabilities { using type = UndefinedProperty; };
+struct VtkWriteFractureRelativePermeabilities { using type = Properties::UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct VtkWriteFracturePorosity { using type = UndefinedProperty; };
+struct VtkWriteFracturePorosity { using type = Properties::UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct VtkWriteFractureIntrinsicPermeabilities { using type = UndefinedProperty; };
+struct VtkWriteFractureIntrinsicPermeabilities { using type = Properties::UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct VtkWriteFractureFilterVelocities { using type = UndefinedProperty; };
+struct VtkWriteFractureFilterVelocities { using type = Properties::UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct VtkWriteFractureVolumeFraction { using type = UndefinedProperty; };
+struct VtkWriteFractureVolumeFraction { using type = Properties::UndefinedProperty; };
 
 // set default values for what quantities to output
 template<class TypeTag>
-struct VtkWriteFractureSaturations<TypeTag, TTag::VtkDiscreteFracture> { static constexpr bool value = true; };
-template<class TypeTag>
-struct VtkWriteFractureMobilities<TypeTag, TTag::VtkDiscreteFracture> { static constexpr bool value = false; };
-template<class TypeTag>
-struct VtkWriteFractureRelativePermeabilities<TypeTag, TTag::VtkDiscreteFracture> { static constexpr bool value = true; };
-template<class TypeTag>
-struct VtkWriteFracturePorosity<TypeTag, TTag::VtkDiscreteFracture> { static constexpr bool value = true; };
-template<class TypeTag>
-struct VtkWriteFractureIntrinsicPermeabilities<TypeTag, TTag::VtkDiscreteFracture> { static constexpr bool value = false; };
-template<class TypeTag>
-struct VtkWriteFractureFilterVelocities<TypeTag, TTag::VtkDiscreteFracture> { static constexpr bool value = false; };
-template<class TypeTag>
-struct VtkWriteFractureVolumeFraction<TypeTag, TTag::VtkDiscreteFracture> { static constexpr bool value = true; };
+struct VtkWriteFractureSaturations<TypeTag, Properties::TTag::VtkDiscreteFracture>
+{ static constexpr bool value = true; };
 
-} // namespace Opm::Properties
+template<class TypeTag>
+struct VtkWriteFractureMobilities<TypeTag, Properties::TTag::VtkDiscreteFracture>
+{ static constexpr bool value = false; };
+
+template<class TypeTag>
+struct VtkWriteFractureRelativePermeabilities<TypeTag, Properties::TTag::VtkDiscreteFracture>
+{ static constexpr bool value = true; };
+
+template<class TypeTag>
+struct VtkWriteFracturePorosity<TypeTag, Properties::TTag::VtkDiscreteFracture>
+{ static constexpr bool value = true; };
+
+template<class TypeTag>
+struct VtkWriteFractureIntrinsicPermeabilities<TypeTag, Properties::TTag::VtkDiscreteFracture>
+{ static constexpr bool value = false; };
+
+template<class TypeTag>
+struct VtkWriteFractureFilterVelocities<TypeTag, Properties::TTag::VtkDiscreteFracture>
+{ static constexpr bool value = false; };
+
+template<class TypeTag>
+struct VtkWriteFractureVolumeFraction<TypeTag, Properties::TTag::VtkDiscreteFracture>
+{ static constexpr bool value = true; };
+
+} // namespace Opm::Parameters
 
 namespace Opm {
 /*!
@@ -134,20 +153,20 @@ public:
      */
     static void registerParameters()
     {
-        Parameters::registerParam<TypeTag, Properties::VtkWriteFractureSaturations>
+        Parameters::registerParam<TypeTag, Parameters::VtkWriteFractureSaturations>
             ("Include the phase saturations in the VTK output files");
-        Parameters::registerParam<TypeTag, Properties::VtkWriteFractureMobilities>
+        Parameters::registerParam<TypeTag, Parameters::VtkWriteFractureMobilities>
             ("Include the phase mobilities in the VTK output files");
-        Parameters::registerParam<TypeTag, Properties::VtkWriteFractureRelativePermeabilities>
+        Parameters::registerParam<TypeTag, Parameters::VtkWriteFractureRelativePermeabilities>
             ("Include the phase relative permeabilities in the "
              "VTK output files");
-        Parameters::registerParam<TypeTag, Properties::VtkWriteFracturePorosity>
+        Parameters::registerParam<TypeTag, Parameters::VtkWriteFracturePorosity>
             ("Include the porosity in the VTK output files");
-        Parameters::registerParam<TypeTag, Properties::VtkWriteFractureIntrinsicPermeabilities>
+        Parameters::registerParam<TypeTag, Parameters::VtkWriteFractureIntrinsicPermeabilities>
             ("Include the intrinsic permeability in the VTK output files");
-        Parameters::registerParam<TypeTag, Properties::VtkWriteFractureFilterVelocities>
+        Parameters::registerParam<TypeTag, Parameters::VtkWriteFractureFilterVelocities>
             ("Include in the filter velocities of the phases in the VTK output files");
-        Parameters::registerParam<TypeTag, Properties::VtkWriteFractureVolumeFraction>
+        Parameters::registerParam<TypeTag, Parameters::VtkWriteFractureVolumeFraction>
             ("Add the fraction of the total volume which is "
              "occupied by fractures in the VTK output");
     }
@@ -319,43 +338,43 @@ public:
 private:
     static bool saturationOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWriteFractureSaturations>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWriteFractureSaturations>();
         return val;
     }
 
     static bool mobilityOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWriteFractureMobilities>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWriteFractureMobilities>();
         return val;
     }
 
     static bool relativePermeabilityOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWriteFractureRelativePermeabilities>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWriteFractureRelativePermeabilities>();
         return val;
     }
 
     static bool porosityOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWriteFracturePorosity>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWriteFracturePorosity>();
         return val;
     }
 
     static bool intrinsicPermeabilityOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWriteFractureIntrinsicPermeabilities>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWriteFractureIntrinsicPermeabilities>();
         return val;
     }
 
     static bool volumeFractionOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWriteFractureVolumeFraction>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWriteFractureVolumeFraction>();
         return val;
     }
 
     static bool velocityOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWriteFractureFilterVelocities>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWriteFractureFilterVelocities>();
         return val;
     }
 
diff --git a/opm/models/io/vtkenergymodule.hh b/opm/models/io/vtkenergymodule.hh
index 01379406b..868dc873d 100644
--- a/opm/models/io/vtkenergymodule.hh
+++ b/opm/models/io/vtkenergymodule.hh
@@ -27,44 +27,56 @@
 #ifndef EWOMS_VTK_ENERGY_MODULE_HH
 #define EWOMS_VTK_ENERGY_MODULE_HH
 
-#include "vtkmultiwriter.hh"
-#include "baseoutputmodule.hh"
+#include <opm/material/common/MathToolbox.hpp>
+
+#include <opm/models/io/baseoutputmodule.hh>
+#include <opm/models/io/vtkmultiwriter.hh>
 
 #include <opm/models/discretization/common/fvbaseparameters.hh>
 
 #include <opm/models/utils/propertysystem.hh>
 #include <opm/models/utils/parametersystem.hh>
 
-#include <opm/material/common/MathToolbox.hpp>
-
-namespace Opm::Properties {
-
-namespace TTag {
+namespace Opm::Properties::TTag {
 
 // create new type tag for the VTK energy output
 struct VtkEnergy {};
 
-} // namespace TTag
+} // namespace Opm::Properties::TTag
+
+
+namespace Opm::Parameters {
 
 // create the property tags needed for the energy module
 template<class TypeTag, class MyTypeTag>
-struct VtkWriteSolidInternalEnergy { using type = UndefinedProperty; };
+struct VtkWriteInternalEnergies { using type = Properties::UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct VtkWriteThermalConductivity { using type = UndefinedProperty; };
+struct VtkWriteEnthalpies { using type = Properties::UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct VtkWriteInternalEnergies { using type = UndefinedProperty; };
+struct VtkWriteSolidInternalEnergy { using type = Properties::UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct VtkWriteEnthalpies { using type = UndefinedProperty; };
+struct VtkWriteThermalConductivity { using type = Properties::UndefinedProperty; };
+
 
 // set default values for what quantities to output
 template<class TypeTag>
-struct VtkWriteSolidInternalEnergy<TypeTag, TTag::VtkEnergy> { static constexpr bool value = false; };
+struct VtkWriteSolidInternalEnergy<TypeTag, Properties::TTag::VtkEnergy>
+{ static constexpr bool value = false; };
+
 template<class TypeTag>
-struct VtkWriteThermalConductivity<TypeTag, TTag::VtkEnergy> { static constexpr bool value = false; };
+struct VtkWriteThermalConductivity<TypeTag, Properties::TTag::VtkEnergy>
+{ static constexpr bool value = false; };
+
 template<class TypeTag>
-struct VtkWriteInternalEnergies<TypeTag, TTag::VtkEnergy> { static constexpr bool value = false; };
+struct VtkWriteInternalEnergies<TypeTag, Properties::TTag::VtkEnergy>
+{ static constexpr bool value = false; };
+
 template<class TypeTag>
-struct VtkWriteEnthalpies<TypeTag, TTag::VtkEnergy> { static constexpr bool value = false; };
+struct VtkWriteEnthalpies<TypeTag, Properties::TTag::VtkEnergy>
+{ static constexpr bool value = false; };
 
 } // namespace Opm::Properties
 
@@ -113,16 +125,16 @@ public:
      */
     static void registerParameters()
     {
-        Parameters::registerParam<TypeTag, Properties::VtkWriteSolidInternalEnergy>
+        Parameters::registerParam<TypeTag, Parameters::VtkWriteSolidInternalEnergy>
             ("Include the volumetric internal energy of solid"
              "matrix in the VTK output files");
-        Parameters::registerParam<TypeTag, Properties::VtkWriteThermalConductivity>
+        Parameters::registerParam<TypeTag, Parameters::VtkWriteThermalConductivity>
             ("Include the total thermal conductivity of the"
              "medium in the VTK output files");
-        Parameters::registerParam<TypeTag, Properties::VtkWriteEnthalpies>
+        Parameters::registerParam<TypeTag, Parameters::VtkWriteEnthalpies>
             ("Include the specific enthalpy of the phases in "
              "the VTK output files");
-        Parameters::registerParam<TypeTag, Properties::VtkWriteInternalEnergies>
+        Parameters::registerParam<TypeTag, Parameters::VtkWriteInternalEnergies>
             ("Include the specific internal energy of the "
              "phases in the VTK output files");
     }
@@ -196,25 +208,25 @@ public:
 private:
     static bool solidInternalEnergyOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWriteSolidInternalEnergy>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWriteSolidInternalEnergy>();
         return val;
     }
 
     static bool thermalConductivityOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWriteThermalConductivity>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWriteThermalConductivity>();
         return val;
     }
 
     static bool enthalpyOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWriteEnthalpies>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWriteEnthalpies>();
         return val;
     }
 
     static bool internalEnergyOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWriteInternalEnergies>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWriteInternalEnergies>();
         return val;
     }
 
diff --git a/opm/models/io/vtkmultiphasemodule.hh b/opm/models/io/vtkmultiphasemodule.hh
index a8b947769..5417b19e4 100644
--- a/opm/models/io/vtkmultiphasemodule.hh
+++ b/opm/models/io/vtkmultiphasemodule.hh
@@ -42,66 +42,100 @@
 
 #include <cstdio>
 
-namespace Opm::Properties {
-
-namespace TTag {
+namespace Opm::Properties::TTag {
 
 // create new type tag for the VTK multi-phase output
 struct VtkMultiPhase {};
 
-} // namespace TTag
+} // namespace Opm::Properties::TTag
+
+namespace Opm::Parameters {
 
 // create the property tags needed for the multi phase module
 template<class TypeTag, class MyTypeTag>
-struct VtkWriteExtrusionFactor { using type = UndefinedProperty; };
+struct VtkWriteExtrusionFactor { using type = Properties::UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct VtkWritePressures { using type = UndefinedProperty; };
+struct VtkWritePressures { using type = Properties::UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct VtkWriteDensities { using type = UndefinedProperty; };
+struct VtkWriteDensities { using type = Properties::UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct VtkWriteSaturations { using type = UndefinedProperty; };
+struct VtkWriteSaturations { using type = Properties::UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct VtkWriteMobilities { using type = UndefinedProperty; };
+struct VtkWriteMobilities { using type = Properties::UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct VtkWriteRelativePermeabilities { using type = UndefinedProperty; };
+struct VtkWriteRelativePermeabilities { using type = Properties::UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct VtkWriteViscosities { using type = UndefinedProperty; };
+struct VtkWriteViscosities { using type = Properties::UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct VtkWriteAverageMolarMasses { using type = UndefinedProperty; };
+struct VtkWriteAverageMolarMasses { using type = Properties::UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct VtkWritePorosity { using type = UndefinedProperty; };
+struct VtkWritePorosity { using type = Properties::UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct VtkWriteIntrinsicPermeabilities { using type = UndefinedProperty; };
+struct VtkWriteIntrinsicPermeabilities { using type = Properties::UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct VtkWritePotentialGradients { using type = UndefinedProperty; };
+struct VtkWritePotentialGradients { using type = Properties::UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct VtkWriteFilterVelocities { using type = UndefinedProperty; };
+struct VtkWriteFilterVelocities { using type = Properties::UndefinedProperty; };
 
 // set default values for what quantities to output
 template<class TypeTag>
-struct VtkWriteExtrusionFactor<TypeTag, TTag::VtkMultiPhase> { static constexpr bool value = false; };
+struct VtkWriteExtrusionFactor<TypeTag, Properties::TTag::VtkMultiPhase>
+{ static constexpr bool value = false; };
+
 template<class TypeTag>
-struct VtkWritePressures<TypeTag, TTag::VtkMultiPhase> { static constexpr bool value = true; };
+struct VtkWritePressures<TypeTag, Properties::TTag::VtkMultiPhase>
+{ static constexpr bool value = true; };
+
 template<class TypeTag>
-struct VtkWriteDensities<TypeTag, TTag::VtkMultiPhase> { static constexpr bool value = true; };
+struct VtkWriteDensities<TypeTag, Properties::TTag::VtkMultiPhase>
+{ static constexpr bool value = true; };
+
 template<class TypeTag>
-struct VtkWriteSaturations<TypeTag, TTag::VtkMultiPhase> { static constexpr bool value = true; };
+struct VtkWriteSaturations<TypeTag, Properties::TTag::VtkMultiPhase>
+{ static constexpr bool value = true; };
+
 template<class TypeTag>
-struct VtkWriteMobilities<TypeTag, TTag::VtkMultiPhase> { static constexpr bool value = false; };
+struct VtkWriteMobilities<TypeTag, Properties::TTag::VtkMultiPhase>
+{ static constexpr bool value = false; };
+
 template<class TypeTag>
-struct VtkWriteRelativePermeabilities<TypeTag, TTag::VtkMultiPhase> { static constexpr bool value = true; };
+struct VtkWriteRelativePermeabilities<TypeTag, Properties::TTag::VtkMultiPhase>
+{ static constexpr bool value = true; };
+
 template<class TypeTag>
-struct VtkWriteViscosities<TypeTag, TTag::VtkMultiPhase> { static constexpr bool value = false; };
+struct VtkWriteViscosities<TypeTag, Properties::TTag::VtkMultiPhase>
+{ static constexpr bool value = false; };
+
 template<class TypeTag>
-struct VtkWriteAverageMolarMasses<TypeTag, TTag::VtkMultiPhase> { static constexpr bool value = false; };
+struct VtkWriteAverageMolarMasses<TypeTag, Properties::TTag::VtkMultiPhase>
+{ static constexpr bool value = false; };
+
 template<class TypeTag>
-struct VtkWritePorosity<TypeTag, TTag::VtkMultiPhase> { static constexpr bool value = true; };
+struct VtkWritePorosity<TypeTag, Properties::TTag::VtkMultiPhase>
+{ static constexpr bool value = true; };
+
 template<class TypeTag>
-struct VtkWriteIntrinsicPermeabilities<TypeTag, TTag::VtkMultiPhase> { static constexpr bool value = false; };
+struct VtkWriteIntrinsicPermeabilities<TypeTag, Properties::TTag::VtkMultiPhase>
+{ static constexpr bool value = false; };
+
 template<class TypeTag>
-struct VtkWritePotentialGradients<TypeTag, TTag::VtkMultiPhase> { static constexpr bool value = false; };
+struct VtkWritePotentialGradients<TypeTag, Properties::TTag::VtkMultiPhase>
+{ static constexpr bool value = false; };
+
 template<class TypeTag>
-struct VtkWriteFilterVelocities<TypeTag, TTag::VtkMultiPhase> { static constexpr bool value = false; };
+struct VtkWriteFilterVelocities<TypeTag, Properties::TTag::VtkMultiPhase>
+{ static constexpr bool value = false; };
 
 } // namespace Opm::Properties
 
@@ -163,29 +197,29 @@ public:
      */
     static void registerParameters()
     {
-        Parameters::registerParam<TypeTag, Properties::VtkWriteExtrusionFactor>
+        Parameters::registerParam<TypeTag, Parameters::VtkWriteExtrusionFactor>
             ("Include the extrusion factor of the degrees of freedom into the VTK output files");
-        Parameters::registerParam<TypeTag, Properties::VtkWritePressures>
+        Parameters::registerParam<TypeTag, Parameters::VtkWritePressures>
             ("Include the phase pressures in the VTK output files");
-        Parameters::registerParam<TypeTag, Properties::VtkWriteDensities>
+        Parameters::registerParam<TypeTag, Parameters::VtkWriteDensities>
             ("Include the phase densities in the VTK output files");
-        Parameters::registerParam<TypeTag, Properties::VtkWriteSaturations>
+        Parameters::registerParam<TypeTag, Parameters::VtkWriteSaturations>
             ("Include the phase saturations in the VTK output files");
-        Parameters::registerParam<TypeTag, Properties::VtkWriteMobilities>
+        Parameters::registerParam<TypeTag, Parameters::VtkWriteMobilities>
             ("Include the phase mobilities in the VTK output files");
-        Parameters::registerParam<TypeTag, Properties::VtkWriteRelativePermeabilities>
+        Parameters::registerParam<TypeTag, Parameters::VtkWriteRelativePermeabilities>
             ("Include the phase relative permeabilities in the VTK output files");
-        Parameters::registerParam<TypeTag, Properties::VtkWriteViscosities>
+        Parameters::registerParam<TypeTag, Parameters::VtkWriteViscosities>
             ("Include component phase viscosities in the VTK output files");
-        Parameters::registerParam<TypeTag, Properties::VtkWriteAverageMolarMasses>
+        Parameters::registerParam<TypeTag, Parameters::VtkWriteAverageMolarMasses>
             ("Include the average phase mass in the VTK output files");
-        Parameters::registerParam<TypeTag, Properties::VtkWritePorosity>
+        Parameters::registerParam<TypeTag, Parameters::VtkWritePorosity>
             ("Include the porosity in the VTK output files");
-        Parameters::registerParam<TypeTag, Properties::VtkWriteIntrinsicPermeabilities>
+        Parameters::registerParam<TypeTag, Parameters::VtkWriteIntrinsicPermeabilities>
             ("Include the intrinsic permeability in the VTK output files");
-        Parameters::registerParam<TypeTag, Properties::VtkWriteFilterVelocities>
+        Parameters::registerParam<TypeTag, Parameters::VtkWriteFilterVelocities>
             ("Include in the filter velocities of the phases the VTK output files");
-        Parameters::registerParam<TypeTag, Properties::VtkWritePotentialGradients>
+        Parameters::registerParam<TypeTag, Parameters::VtkWritePotentialGradients>
             ("Include the phase pressure potential gradients in the VTK output files");
     }
 
@@ -419,73 +453,73 @@ public:
 private:
     static bool extrusionFactorOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWriteExtrusionFactor>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWriteExtrusionFactor>();
         return val;
     }
 
     static bool pressureOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWritePressures>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWritePressures>();
         return val;
     }
 
     static bool densityOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWriteDensities>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWriteDensities>();
         return val;
     }
 
     static bool saturationOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWriteSaturations>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWriteSaturations>();
         return val;
     }
 
     static bool mobilityOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWriteMobilities>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWriteMobilities>();
         return val;
     }
 
     static bool relativePermeabilityOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWriteRelativePermeabilities>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWriteRelativePermeabilities>();
         return val;
     }
 
     static bool viscosityOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWriteViscosities>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWriteViscosities>();
         return val;
     }
 
     static bool averageMolarMassOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWriteAverageMolarMasses>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWriteAverageMolarMasses>();
         return val;
     }
 
     static bool porosityOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWritePorosity>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWritePorosity>();
         return val;
     }
 
     static bool intrinsicPermeabilityOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWriteIntrinsicPermeabilities>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWriteIntrinsicPermeabilities>();
         return val;
     }
 
     static bool velocityOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWriteFilterVelocities>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWriteFilterVelocities>();
         return val;
     }
 
     static bool potentialGradientOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWritePotentialGradients>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWritePotentialGradients>();
         return val;
     }
 
diff --git a/opm/models/io/vtkphasepresencemodule.hh b/opm/models/io/vtkphasepresencemodule.hh
index a0c4e8dea..9a62eaf4c 100644
--- a/opm/models/io/vtkphasepresencemodule.hh
+++ b/opm/models/io/vtkphasepresencemodule.hh
@@ -27,31 +27,32 @@
 #ifndef EWOMS_VTK_PHASE_PRESENCE_MODULE_HH
 #define EWOMS_VTK_PHASE_PRESENCE_MODULE_HH
 
-#include "vtkmultiwriter.hh"
-#include "baseoutputmodule.hh"
-
 #include <opm/models/discretization/common/fvbaseparameters.hh>
 
+#include <opm/models/io/baseoutputmodule.hh>
+#include <opm/models/io/vtkmultiwriter.hh>
+
 #include <opm/models/utils/parametersystem.hh>
 #include <opm/models/utils/propertysystem.hh>
 
-namespace Opm::Properties {
-
-namespace TTag {
+namespace Opm::Properties::TTag {
 
 // create new type tag for the VTK primary variables output
 struct VtkPhasePresence {};
 
-} // namespace TTag
+} // namespace Opm::Properties::TTag
+
+namespace Opm::Parameters {
 
 // create the property tags needed for the primary variables module
 template<class TypeTag, class MyTypeTag>
-struct VtkWritePhasePresence { using type = UndefinedProperty; };
+struct VtkWritePhasePresence { using type = Properties::UndefinedProperty; };
 
 template<class TypeTag>
-struct VtkWritePhasePresence<TypeTag, TTag::VtkPhasePresence> { static constexpr bool value = false; };
+struct VtkWritePhasePresence<TypeTag, Properties::TTag::VtkPhasePresence>
+{ static constexpr bool value = false; };
 
-} // namespace Opm::Properties
+} // namespace Opm::Parameters
 
 namespace Opm {
 /*!
@@ -85,7 +86,7 @@ public:
      */
     static void registerParameters()
     {
-        Parameters::registerParam<TypeTag, Properties::VtkWritePhasePresence>
+        Parameters::registerParam<TypeTag, Parameters::VtkWritePhasePresence>
             ("Include the phase presence pseudo primary "
              "variable in the VTK output files");
     }
@@ -135,7 +136,7 @@ public:
 private:
     static bool phasePresenceOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWritePhasePresence>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWritePhasePresence>();
         return val;
     }
 
diff --git a/opm/models/io/vtkprimaryvarsmodule.hh b/opm/models/io/vtkprimaryvarsmodule.hh
index 558009d15..4c06212e1 100644
--- a/opm/models/io/vtkprimaryvarsmodule.hh
+++ b/opm/models/io/vtkprimaryvarsmodule.hh
@@ -35,29 +35,36 @@
 #include <opm/models/utils/parametersystem.hh>
 #include <opm/models/utils/propertysystem.hh>
 
-namespace Opm::Properties {
-
-namespace TTag {
+namespace Opm::Properties::TTag {
 
 // create new type tag for the VTK primary variables output
 struct VtkPrimaryVars {};
 
-} // namespace TTag
+} // namespace Opm::Properties::TTag
+
+namespace Opm::Parameters {
 
 // create the property tags needed for the primary variables module
 template<class TypeTag, class MyTypeTag>
-struct VtkWritePrimaryVars { using type = UndefinedProperty; };
+struct VtkWritePrimaryVars { using type = Properties::UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct VtkWriteProcessRank { using type = UndefinedProperty; };
+struct VtkWriteProcessRank { using type = Properties::UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct VtkWriteDofIndex { using type = UndefinedProperty; };
+struct VtkWriteDofIndex { using type = Properties::UndefinedProperty; };
 
 template<class TypeTag>
-struct VtkWritePrimaryVars<TypeTag, TTag::VtkPrimaryVars> { static constexpr bool value = false; };
+struct VtkWritePrimaryVars<TypeTag, Properties::TTag::VtkPrimaryVars>
+{ static constexpr bool value = false; };
+
 template<class TypeTag>
-struct VtkWriteProcessRank<TypeTag, TTag::VtkPrimaryVars> { static constexpr bool value = false; };
+struct VtkWriteProcessRank<TypeTag, Properties::TTag::VtkPrimaryVars>
+{ static constexpr bool value = false; };
+
 template<class TypeTag>
-struct VtkWriteDofIndex<TypeTag, TTag::VtkPrimaryVars> { static constexpr bool value = false; };
+struct VtkWriteDofIndex<TypeTag, Properties::TTag::VtkPrimaryVars>
+{ static constexpr bool value = false; };
 
 } // namespace Opm::Properties
 
@@ -95,11 +102,11 @@ public:
      */
     static void registerParameters()
     {
-        Parameters::registerParam<TypeTag, Properties::VtkWritePrimaryVars>
+        Parameters::registerParam<TypeTag, Parameters::VtkWritePrimaryVars>
             ("Include the primary variables into the VTK output files");
-        Parameters::registerParam<TypeTag, Properties::VtkWriteProcessRank>
+        Parameters::registerParam<TypeTag, Parameters::VtkWriteProcessRank>
             ("Include the MPI process rank into the VTK output files");
-        Parameters::registerParam<TypeTag, Properties::VtkWriteDofIndex>
+        Parameters::registerParam<TypeTag, Parameters::VtkWriteDofIndex>
             ("Include the index of the degrees of freedom into the VTK output files");
     }
 
@@ -170,17 +177,17 @@ public:
 private:
     static bool primaryVarsOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWritePrimaryVars>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWritePrimaryVars>();
         return val;
     }
     static bool processRankOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWriteProcessRank>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWriteProcessRank>();
         return val;
     }
     static bool dofIndexOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWriteDofIndex>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWriteDofIndex>();
         return val;
     }
 
diff --git a/opm/models/io/vtkptflashmodule.hh b/opm/models/io/vtkptflashmodule.hh
index 543e63ac2..c0baad6e5 100644
--- a/opm/models/io/vtkptflashmodule.hh
+++ b/opm/models/io/vtkptflashmodule.hh
@@ -37,28 +37,32 @@
 #include <opm/models/utils/propertysystem.hh>
 #include <opm/models/utils/parametersystem.hh>
 
-namespace Opm::Properties {
-
-namespace TTag {
+namespace Opm::Properties::TTag {
 
 // create new type tag for the VTK PTFlash output
 struct VtkPTFlash {};
 
-} // namespace TTag
+} // namespace Opm::Properties::TTag
+
+namespace Opm::Parameters {
 
 // create the property tags needed for the composition module
 template<class TypeTag, class MyTypeTag>
-struct VtkWriteLiquidMoleFractions { using type = UndefinedProperty; };
+struct VtkWriteLiquidMoleFractions { using type = Properties::UndefinedProperty; };
+
 template<class TypeTag, class MyTypeTag>
-struct VtkWriteEquilibriumConstants { using type = UndefinedProperty; };
+struct VtkWriteEquilibriumConstants { using type = Properties::UndefinedProperty; };
 
 // set default values for what quantities to output
 template<class TypeTag>
-struct VtkWriteLiquidMoleFractions<TypeTag, TTag::VtkPTFlash> { static constexpr bool value = false; };
-template<class TypeTag>
-struct VtkWriteEquilibriumConstants<TypeTag, TTag::VtkPTFlash> { static constexpr bool value = false; };
+struct VtkWriteLiquidMoleFractions<TypeTag, Properties::TTag::VtkPTFlash>
+{ static constexpr bool value = false; };
 
-} // namespace Opm::Properties
+template<class TypeTag>
+struct VtkWriteEquilibriumConstants<TypeTag, Properties::TTag::VtkPTFlash>
+{ static constexpr bool value = false; };
+
+} // namespace Opm::Parameters
 
 namespace Opm {
 
@@ -101,9 +105,9 @@ public:
      */
     static void registerParameters()
     {
-        Parameters::registerParam<TypeTag, Properties::VtkWriteLiquidMoleFractions>
+        Parameters::registerParam<TypeTag, Parameters::VtkWriteLiquidMoleFractions>
             ("Include liquid mole fractions (L) in the VTK output files");
-        Parameters::registerParam<TypeTag, Properties::VtkWriteEquilibriumConstants>
+        Parameters::registerParam<TypeTag, Parameters::VtkWriteEquilibriumConstants>
             ("Include equilibrium constants (K) in the VTK output files");
     }
 
@@ -164,13 +168,13 @@ public:
 private:
     static bool LOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWriteLiquidMoleFractions>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWriteLiquidMoleFractions>();
         return val;
     }
 
     static bool equilConstOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWriteEquilibriumConstants>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWriteEquilibriumConstants>();
         return val;
     }
 
diff --git a/opm/models/io/vtktemperaturemodule.hh b/opm/models/io/vtktemperaturemodule.hh
index d6c26b5ff..28ff584d3 100644
--- a/opm/models/io/vtktemperaturemodule.hh
+++ b/opm/models/io/vtktemperaturemodule.hh
@@ -27,34 +27,35 @@
 #ifndef EWOMS_VTK_TEMPERATURE_MODULE_HH
 #define EWOMS_VTK_TEMPERATURE_MODULE_HH
 
-#include "vtkmultiwriter.hh"
-#include "baseoutputmodule.hh"
+#include <opm/material/common/MathToolbox.hpp>
 
 #include <opm/models/discretization/common/fvbaseparameters.hh>
 
+#include <opm/models/io/baseoutputmodule.hh>
+#include <opm/models/io/vtkmultiwriter.hh>
+
 #include <opm/models/utils/parametersystem.hh>
 #include <opm/models/utils/propertysystem.hh>
 
-#include <opm/material/common/MathToolbox.hpp>
-
-namespace Opm::Properties {
-
-namespace TTag {
+namespace Opm::Properties::TTag {
 
 // create new type tag for the VTK temperature output
 struct VtkTemperature {};
 
-} // namespace TTag
+} // namespace Opm::Properties::TTag
+
+namespace Opm::Parameters {
 
 // create the property tags needed for the temperature module
 template<class TypeTag, class MyTypeTag>
-struct VtkWriteTemperature { using type = UndefinedProperty; };
+struct VtkWriteTemperature { using type = Properties::UndefinedProperty; };
 
 // set default values for what quantities to output
 template<class TypeTag>
-struct VtkWriteTemperature<TypeTag, TTag::VtkTemperature> { static constexpr bool value = true; };
+struct VtkWriteTemperature<TypeTag, Properties::TTag::VtkTemperature>
+{ static constexpr bool value = true; };
 
-} // namespace Opm::Properties
+} // namespace Opm::Parameters
 
 namespace Opm {
 
@@ -90,7 +91,7 @@ public:
      */
     static void registerParameters()
     {
-        Parameters::registerParam<TypeTag, Properties::VtkWriteTemperature>
+        Parameters::registerParam<TypeTag, Parameters::VtkWriteTemperature>
             ("Include the temperature in the VTK output files");
     }
 
@@ -141,7 +142,7 @@ public:
 private:
     static bool temperatureOutput_()
     {
-        static bool val = Parameters::get<TypeTag, Properties::VtkWriteTemperature>();
+        static bool val = Parameters::get<TypeTag, Parameters::VtkWriteTemperature>();
         return val;
     }