[ransni] Implementation of non-isothermal RANS model with many changes

features
* tests for zeroeqni and zeroeq2cni
* split update() in "classical" update() and updateRANSProperties()
* do not use asImp_() but virtual inheritance
* cleanup

dumux/freeflow/navierstokes/volumevariables.hh

@@ -226,7 +226,7 @@ protected:
  */
 template <class TypeTag>
 class NavierStokesVolumeVariablesImplementation<TypeTag, true>
-: public NavierStokesVolumeVariablesImplementation<TypeTag, false>
+: virtual public NavierStokesVolumeVariablesImplementation<TypeTag, false>
 {
     using ParentType = NavierStokesVolumeVariablesImplementation<TypeTag, false>;
     using Scalar = typename GET_PROP_TYPE(TypeTag, Scalar);

dumux/freeflow/rans/model.hh

@@ -41,7 +41,8 @@
 #include <dumux/discretization/methods.hh>
 #include <dumux/freeflow/properties.hh>
 #include <dumux/freeflow/navierstokes/model.hh>
-#include <dumux/freeflow/nonisothermal/model.hh>
+#include <dumux/freeflow/navierstokes/indices.hh>
+#include <dumux/freeflow/nonisothermal/indices.hh>
 #include <dumux/material/fluidstates/immiscible.hh>
 
 #include "volumevariables.hh"
@@ -79,6 +80,49 @@ private:
 public:
      using type = RANSVtkOutputFields<FVGridGeometry>;
 };
+
+//////////////////////////////////////////////////////////////////
+// Property values for non-isothermal Reynolds-averaged Navier-Stokes model
+//////////////////////////////////////////////////////////////////
+
+//! The type tag for the single-phase, isothermal Reynolds-Averaged Navier-Stokes model
+NEW_TYPE_TAG(RANSNI, INHERITS_FROM(RANS));
+
+//! The model traits of the non-isothermal model
+SET_PROP(RANSNI, ModelTraits)
+{
+private:
+    using GridView = typename GET_PROP_TYPE(TypeTag, FVGridGeometry)::GridView;
+    static constexpr int dim = GridView::dimension;
+    using IsothermalTraits = NavierStokesModelTraits<dim>;
+public:
+    using type = NavierStokesNIModelTraits<IsothermalTraits>;
+};
+
+//! The indices required by the non-isothermal single-phase model
+SET_PROP(RANSNI, Indices)
+{
+private:
+    static constexpr int numEq = GET_PROP_TYPE(TypeTag, ModelTraits)::numEq();
+    static constexpr int dim = GET_PROP_TYPE(TypeTag, GridView)::dimension;
+    using IsothermalIndices = NavierStokesIndices<dim, numEq>;
+public:
+    using type = NavierStokesNonIsothermalIndices<dim, numEq, IsothermalIndices>;
+};
+
+//! The specific non-isothermal vtk output fields
+// SET_PROP(RANSNI, VtkOutputFields)
+// {
+// private:
+//      using FVGridGeometry = typename GET_PROP_TYPE(TypeTag, FVGridGeometry);
+//      using IsothermalFields = NavierStokesVtkOutputFields<FVGridGeometry>;
+// public:
+//      using type = NavierStokesNonIsothermalVtkOutputFields<IsothermalFields>;
+// };
+
+//! Use Fourier's Law as default heat conduction type
+SET_TYPE_PROP(RANSNI, HeatConductionType, FouriersLaw<TypeTag>);
+
 // \}
 }
 

dumux/freeflow/rans/volumevariables.hh

@@ -29,6 +29,7 @@
 #include <dune/common/fmatrix.hh>
 
 #include <dumux/common/properties.hh>
+#include <dumux/common/parameters.hh>
 #include <dumux/material/fluidstates/immiscible.hh>
 #include <dumux/freeflow/navierstokes/volumevariables.hh>
 
@@ -71,31 +72,26 @@ class RANSVolumeVariablesImplementation<TypeTag, false>
     using DimMatrix = Dune::FieldMatrix<Scalar, dimWorld, dimWorld>;
 
 public:
-
-    using FluidState = typename GET_PROP_TYPE(TypeTag, FluidState);
-
     /*!
-     * \brief Update all quantities for a given control volume
+     * \brief Update all turbulent quantities for a given control volume
      *
      * Wall related quantities are stored and the calculateEddyViscosity(...)
      * function of the turbulence model implementation is called.
      *
      * \param elemSol A vector containing all primary variables connected to the element
-     * \param problem The object specifying the problem which ought to
-     *                be simulated
+     * \param problem The object specifying the problem which ought to be simulated
      * \param element An element which contains part of the control volume
      * \param scv The sub-control volume
      */
     template<class ElementSolution>
-    void update(const ElementSolution &elemSol,
-                const Problem &problem,
-                const Element &element,
-                const SubControlVolume& scv)
+    void updateRANSProperties(const ElementSolution &elemSol,
+                              const Problem &problem,
+                              const Element &element,
+                              const SubControlVolume& scv)
     {
         using std::abs;
         using std::max;
         using std::sqrt;
-        ParentType::update(elemSol, problem, element, scv);
 
         // calculate characteristic properties of the turbulent flow
         elementID_ = problem.fvGridGeometry().elementMapper().index(element);
@@ -109,9 +105,10 @@ public:
         uStar_ = sqrt(problem.kinematicViscosity_[wallElementID_]
                       * abs(problem.velocityGradients_[wallElementID_][flowNormalAxis][wallNormalAxis]));
         uStar_ = max(uStar_, 1e-10); // zero values lead to numerical problems in some turbulence models
-        yPlus_ = wallDistance_ * uStar_ / asImp_().kinematicViscosity();
+        yPlus_ = wallDistance_ * uStar_ / kinematicViscosity();
         uPlus_ = velocity_[flowNormalAxis] / uStar_;
-    };
+        dynamicEddyViscosity_ = 0.0; // will be set by the specific RANS implementation
+    }
 
     /*!
      * \brief Return the element ID of the control volume.
@@ -166,9 +163,15 @@ public:
      *        control volume.
      */
     Scalar dynamicEddyViscosity() const
+    { return dynamicEddyViscosity_; }
+
+    /*!
+     * \brief Return the dynamic eddy viscosity \f$\mathrm{[Pa s]}\f$ of the flow within the
+     *        control volume.
+     */
+    void setDynamicEddyViscosity(Scalar value)
     {
-        DUNE_THROW(Dune::NotImplemented,
-                   "The dynamicEddyViscosity() has to specified by the RANS implementation.");
+        dynamicEddyViscosity_ = value;
     }
 
     /*!
@@ -176,30 +179,21 @@ public:
      *        control volume.
      */
     Scalar effectiveViscosity() const
-    { return asImp_().viscosity() + asImp_().dynamicEddyViscosity(); }
+    { return ParentType::viscosity() + dynamicEddyViscosity(); }
 
     /*!
      * \brief Return the kinematic viscosity \f$\mathrm{[m^2/s]}\f$ of the fluid within the
      *        control volume.
      */
     Scalar kinematicViscosity() const
-    { return asImp_().viscosity() / asImp_().density(); }
+    { return ParentType::viscosity() / ParentType::density(); }
 
     /*!
      * \brief Return the kinematic eddy viscosity \f$\mathrm{[Pa s]}\f$ of the flow within the
      *        control volume.
      */
     Scalar kinematicEddyViscosity() const
-    { return asImp_().dynamicEddyViscosity() / asImp_().density(); }
-
-private:
-    //! Returns the implementation of the problem (i.e. static polymorphism)
-    Implementation &asImp_()
-    { return *static_cast<Implementation *>(this); }
-
-    //! \copydoc asImp_()
-    const Implementation &asImp_() const
-    { return *static_cast<const Implementation *>(this); }
+    { return dynamicEddyViscosity() / ParentType::density(); }
 
 protected:
     DimVector velocity_;
@@ -220,49 +214,38 @@ protected:
  */
 template <class TypeTag>
 class RANSVolumeVariablesImplementation<TypeTag, true>
-: public NavierStokesVolumeVariablesImplementation<TypeTag, true>,
-  public RANSVolumeVariablesImplementation<TypeTag, false>
+: virtual public NavierStokesVolumeVariablesImplementation<TypeTag, true>,
+  virtual public RANSVolumeVariablesImplementation<TypeTag, false>
 {
     using ParentTypeNonIsothermal = NavierStokesVolumeVariablesImplementation<TypeTag, true>;
     using ParentTypeIsothermal = RANSVolumeVariablesImplementation<TypeTag, false>;
+    using Implementation = typename GET_PROP_TYPE(TypeTag, VolumeVariables);
     using Scalar = typename GET_PROP_TYPE(TypeTag, Scalar);
     using Problem = typename GET_PROP_TYPE(TypeTag, Problem);
     using FVElementGeometry = typename GET_PROP_TYPE(TypeTag, FVGridGeometry)::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
     using GridView = typename GET_PROP_TYPE(TypeTag, GridView);
     using Element = typename GridView::template Codim<0>::Entity;
-    using FluidSystem = typename GET_PROP_TYPE(TypeTag, FluidSystem);
-    using Indices = typename GET_PROP_TYPE(TypeTag, Indices);
-
-//     static const int temperatureIdx = Indices::temperatureIdx;
 
 public:
-
-    using FluidState = typename GET_PROP_TYPE(TypeTag, FluidState);
-
     /*!
-     * \brief Update all quantities for a given control volume
-     *
-     * \param elemSol A vector containing all primary variables connected to the element
-     * \param problem The object specifying the problem which ought to
-     *                be simulated
-     * \param element An element which contains part of the control volume
-     * \param scv The sub-control volume
+     * \brief Calculates the eddy thermal conductivity \f$\mathrm{[W/(m*K)]}\f$ based
+     *        on the kinematic eddy viscosity and the turbulent prandtl number
      */
-    template<class ElementSolution>
-    void update(const ElementSolution &elemSol,
-                const Problem &problem,
-                const Element &element,
-                const SubControlVolume &scv)
+    void calculateEddyThermalConductivity()
     {
-        ParentTypeIsothermal::update(elemSol, problem, element, scv);
-        ParentTypeNonIsothermal::update(elemSol, problem, element, scv);
-        // TODO: convert eddyViscosity to eddyThermalConductivity
+        static const auto turbulentPrandtlNumber
+            = getParamFromGroup<Scalar>(GET_PROP_VALUE(TypeTag, ModelParameterGroup),
+                                        "RANS.TurbulentPrandtlNumber", 1.0);
+        eddyThermalConductivity_ = ParentTypeIsothermal::kinematicEddyViscosity()
+                                   * ParentTypeIsothermal::density()
+                                   * ParentTypeNonIsothermal::heatCapacity()
+                                   / turbulentPrandtlNumber;
     }
 
     /*!
      * \brief Returns the eddy thermal conductivity \f$\mathrm{[W/(m*K)]}\f$
-     *        of the flow phase in the sub-control volume.
+     *        of the flow in the sub-control volume.
      */
     Scalar eddyThermalConductivity() const
     { return eddyThermalConductivity_; }
@@ -273,7 +256,7 @@ public:
      */
     Scalar effectiveThermalConductivity() const
     {
-        return FluidSystem::thermalConductivity(this->fluidState_)
+        return ParentTypeNonIsothermal::thermalConductivity()
                + eddyThermalConductivity();
     }
 

dumux/freeflow/rans/vtkoutputfields.hh

@@ -63,6 +63,10 @@ public:
         vtk.addVolumeVariable([](const auto& v){ return v.wallDistance(); }, "l_w");
         vtk.addVolumeVariable([](const auto& v){ return v.yPlus(); }, "y^+");
         vtk.addVolumeVariable([](const auto& v){ return v.uPlus(); }, "u^+");
+#if NONISOTHERMAL
+        vtk.addVolumeVariable( [](const auto& v){ return v.temperature(); }, "temperature");
+        vtk.addVolumeVariable( [](const auto& v){ return v.eddyThermalConductivity(); }, "lambda_t");
+#endif
     }
 };
 

dumux/freeflow/rans/zeroeq/model.hh

@@ -41,27 +41,28 @@
 
 namespace Dumux
 {
+namespace Properties {
 
-// \{
 ///////////////////////////////////////////////////////////////////////////
-// properties for the single-phase Reynolds-Averaged Navier-Stokes 0-Eq. model
+// default property values for the isothermal RANS 0-Eq. model
 ///////////////////////////////////////////////////////////////////////////
-namespace Properties {
-
-//////////////////////////////////////////////////////////////////
-// Type tags
-//////////////////////////////////////////////////////////////////
 
 //! The type tag for the single-phase, isothermal Reynolds-Averaged Navier-Stokes 0-Eq. model
 NEW_TYPE_TAG(ZeroEq, INHERITS_FROM(RANS));
 
-///////////////////////////////////////////////////////////////////////////
-// default property values for the isothermal single phase model
-///////////////////////////////////////////////////////////////////////////
-
 //! The volume variables
 SET_TYPE_PROP(ZeroEq, VolumeVariables, ZeroEqVolumeVariables<TypeTag>);
 
+//////////////////////////////////////////////////////////////////
+// default property values for the non-isothermal RANS 0-Eq. model
+//////////////////////////////////////////////////////////////////
+
+//! The type tag for the single-phase, isothermal Reynolds-Averaged Navier-Stokes model
+NEW_TYPE_TAG(ZeroEqNI, INHERITS_FROM(RANSNI));
+
+//! The volume variables
+SET_TYPE_PROP(ZeroEqNI, VolumeVariables, ZeroEqVolumeVariables<TypeTag>);
+
 // \}
 }
 

dumux/freeflow/rans/zeroeq/volumevariables.hh

@@ -53,7 +53,7 @@ using ZeroEqVolumeVariables = ZeroEqVolumeVariablesImplementation<TypeTag, GET_P
  */
 template <class TypeTag>
 class ZeroEqVolumeVariablesImplementation<TypeTag, false>
-: public RANSVolumeVariablesImplementation<TypeTag, false>
+: virtual public RANSVolumeVariablesImplementation<TypeTag, false>
 {
     using ParentType = RANSVolumeVariablesImplementation<TypeTag, false>;
     using Implementation = typename GET_PROP_TYPE(TypeTag, VolumeVariables);
@@ -85,25 +85,44 @@ public:
                 const SubControlVolume& scv)
     {
         ParentType::update(elemSol, problem, element, scv);
+        updateRANSProperties(elemSol, problem, element, scv);
+    }
+
+    /*!
+     * \brief Update all turbulent quantities for a given control volume
+     *
+     * Wall and roughness related quantities are stored. Eddy viscosity is set.
+     *
+     * \param elemSol A vector containing all primary variables connected to the element
+     * \param problem The object specifying the problem which ought to be simulated
+     * \param element An element which contains part of the control volume
+     * \param scv The sub-control volume
+     */
+    template<class ElementSolution>
+    void updateRANSProperties(const ElementSolution &elemSol,
+                              const Problem &problem,
+                              const Element &element,
+                              const SubControlVolume& scv)
+    {
+        ParentType::updateRANSProperties(elemSol, problem, element, scv);
         additionalRoughnessLength_ = problem.additionalRoughnessLength_[this->elementID()];
         yPlusRough_ = wallDistanceRough() * this->uStar() / this->kinematicViscosity();
-        dynamicEddyViscosity_ = calculateEddyViscosity(elemSol, problem, element, scv);
+        calculateEddyViscosity(elemSol, problem, element, scv);
     }
 
     /*!
      * \brief Calculate and set the dynamic eddy viscosity.
      *
      * \param elemSol A vector containing all primary variables connected to the element
-     * \param problem The object specifying the problem which ought to
-     *                be simulated
+     * \param problem The object specifying the problem which ought to be simulated
      * \param element An element which contains part of the control volume
      * \param scv The sub-control volume
      */
     template<class ElementSolution>
-    Scalar calculateEddyViscosity(const ElementSolution &elemSol,
-                                  const Problem &problem,
-                                  const Element &element,
-                                  const SubControlVolume& scv)
+    void calculateEddyViscosity(const ElementSolution &elemSol,
+                                const Problem &problem,
+                                const Element &element,
+                                const SubControlVolume& scv)
     {
         using std::abs;
         using std::exp;
@@ -114,7 +133,7 @@ public:
         unsigned int elementID = problem.fvGridGeometry().elementMapper().index(element);
         unsigned int flowNormalAxis = problem.flowNormalAxis_[elementID];
         unsigned int wallNormalAxis = problem.wallNormalAxis_[elementID];
-        Scalar velGrad = abs(asImp_().velocityGradients()[flowNormalAxis][wallNormalAxis]);
+        Scalar velGrad = abs(ParentType::velocityGradients()[flowNormalAxis][wallNormalAxis]);
 
         if (eddyViscosityModel == EddyViscosityModels::none)
         {
@@ -122,14 +141,14 @@ public:
         }
         else if (eddyViscosityModel == EddyViscosityModels::prandtl)
         {
-            Scalar mixingLength = problem.karmanConstant() * asImp_().wallDistanceRough();
+            Scalar mixingLength = problem.karmanConstant() * wallDistanceRough();
             kinematicEddyViscosity = mixingLength * mixingLength * velGrad;
         }
         else if (eddyViscosityModel == EddyViscosityModels::modifiedVanDriest)
         {
-            Scalar mixingLength = problem.karmanConstant() * asImp_().wallDistanceRough()
-                                  * (1.0 - exp(-asImp_().yPlusRough() / 26.0))
-                                  / sqrt(1.0 - exp(-0.26 * asImp_().yPlusRough()));
+            Scalar mixingLength = problem.karmanConstant() * wallDistanceRough()
+                                  * (1.0 - exp(-yPlusRough() / 26.0))
+                                  / sqrt(1.0 - exp(-0.26 * yPlusRough()));
             kinematicEddyViscosity = mixingLength * mixingLength * velGrad;
         }
         else if (eddyViscosityModel == EddyViscosityModels::baldwinLomax)
@@ -141,7 +160,7 @@ public:
             DUNE_THROW(Dune::NotImplemented,
                        "This eddy viscosity model is not implemented: " << eddyViscosityModel);
         }
-        return kinematicEddyViscosity * asImp_().density();
+        ParentType::setDynamicEddyViscosity(kinematicEddyViscosity * ParentType::density());
     }
 
     /*!
@@ -156,26 +175,9 @@ public:
     Scalar yPlusRough() const
     { return yPlusRough_; }
 
-    /*!
-     * \brief Return the dynamic eddy viscosity \f$\mathrm{[Pa s]}\f$ of the flow within the
-     *        control volume.
-     */
-    Scalar dynamicEddyViscosity() const
-    { return dynamicEddyViscosity_; }
-
-private:
-    //! Returns the implementation of the problem (i.e. static polymorphism)
-    Implementation &asImp_()
-    { return *static_cast<Implementation *>(this); }
-
-    //! \copydoc asImp_()
-    const Implementation &asImp_() const
-    { return *static_cast<const Implementation *>(this); }
-
 protected:
     Scalar additionalRoughnessLength_;
     Scalar yPlusRough_;
-    Scalar dynamicEddyViscosity_;
 };
 
 /*!
@@ -184,8 +186,59 @@ protected:
  */
 template <class TypeTag>
 class ZeroEqVolumeVariablesImplementation<TypeTag, true>
-: public RANSVolumeVariablesImplementation<TypeTag, true>
-{ };
+: virtual public ZeroEqVolumeVariablesImplementation<TypeTag, false>,
+  virtual public RANSVolumeVariablesImplementation<TypeTag, true>
+{
+    using ParentTypeNonIsothermal = RANSVolumeVariablesImplementation<TypeTag, true>;
+    using ParentTypeIsothermal = ZeroEqVolumeVariablesImplementation<TypeTag, false>;
+    using Implementation = typename GET_PROP_TYPE(TypeTag, VolumeVariables);
+    using Scalar = typename GET_PROP_TYPE(TypeTag, Scalar);
+    using Problem = typename GET_PROP_TYPE(TypeTag, Problem);
+    using FVElementGeometry = typename GET_PROP_TYPE(TypeTag, FVGridGeometry)::LocalView;
+    using SubControlVolume = typename FVElementGeometry::SubControlVolume;
+    using GridView = typename GET_PROP_TYPE(TypeTag, GridView);
+    using Element = typename GridView::template Codim<0>::Entity;
+
+public:
+    /*!
+     * \brief Update all quantities for a given control volume
+     *
+     * \param elemSol A vector containing all primary variables connected to the element
+     * \param problem The object specifying the problem which ought to
+     *                be simulated
+     * \param element An element which contains part of the control volume
+     * \param scv The sub-control volume
+     */
+    template<class ElementSolution>
+    void update(const ElementSolution &elemSol,
+                const Problem &problem,
+                const Element &element,
+                const SubControlVolume &scv)
+    {
+        ParentTypeNonIsothermal::update(elemSol, problem, element, scv);
+        updateRANSProperties(elemSol, problem, element, scv);
+    }
+
+    /*!
+     * \brief Update all turbulent quantities for a given control volume
+     *
+     * Wall and roughness related quantities are stored. Eddy viscosity is set.
+     *
+     * \param elemSol A vector containing all primary variables connected to the element
+     * \param problem The object specifying the problem which ought to be simulated
+     * \param element An element which contains part of the control volume
+     * \param scv The sub-control volume
+     */
+    template<class ElementSolution>
+    void updateRANSProperties(const ElementSolution &elemSol,
+                              const Problem &problem,
+                              const Element &element,
+                              const SubControlVolume& scv)
+    {
+        ParentTypeIsothermal::updateRANSProperties(elemSol, problem, element, scv);
+        ParentTypeNonIsothermal::calculateEddyThermalConductivity();
+    }
+};
 }
 
 #endif

dumux/freeflow/ransnc/model.hh

@@ -22,7 +22,7 @@
  *
  * \brief A single-phase, multi-component isothermal Navier-Stokes model
  *
- * \copydoc RANSModel
+ * \copydoc Dumux::RANSModel
  *
  * The system is closed by a <B> component mass/mole balance equation </B> for each component \f$\kappa\f$:
  * \f[
@@ -69,14 +69,14 @@ namespace Dumux {
 
 /*!
  * \ingroup RANSModel
- * \brief Traits for the Reynolds-averaged Navier-Stokes multi-component model
+ * \brief Traits for the RANS multi-component model
  */
 template<int dim, int nComp>
 struct RANSNCModelTraits : NavierStokesNCModelTraits<dim, nComp>
 { };
 
 ///////////////////////////////////////////////////////////////////////////
-// properties for the single-phase, multi-component Reynolds-averaged Navier-Stokes model
+// properties for the single-phase, multi-component RANS model
 ///////////////////////////////////////////////////////////////////////////
 namespace Properties {
 
@@ -84,13 +84,10 @@ namespace Properties {
 // Type tags
 //////////////////////////////////////////////////////////////////
 
-//! The type tag for the single-phase, multi-component isothermal Reynolds-averaged Navier-Stokes model
+//! The type tags for the single-phase, multi-component isothermal RANS model
 NEW_TYPE_TAG(RANSNC, INHERITS_FROM(RANS, NavierStokesNC));
 NEW_TYPE_TAG(ZeroEqNC, INHERITS_FROM(ZeroEq, RANSNC));
 
-// //! The type tag for the single-phase, multi-component non-isothermal Reynolds-averaged Navier-Stokes model
-// NEW_TYPE_TAG(RANSNCNI, INHERITS_FROM(RANS, NavierStokesNC));
-
 ///////////////////////////////////////////////////////////////////////////
 // default property values
 ///////////////////////////////////////////////////////////////////////////
@@ -124,9 +121,55 @@ public:
 };
 
 //////////////////////////////////////////////////////////////////////////
-// Property values for non-isothermal multi-component Reynolds-averaged Navier-Stokes model
+// Property values for non-isothermal multi-component RANS model
 //////////////////////////////////////////////////////////////////////////
 
+//! The type tags for the single-phase, multi-component non-isothermal RANS models
+NEW_TYPE_TAG(RANSNCNI, INHERITS_FROM(RANSNI, NavierStokesNC));
+NEW_TYPE_TAG(ZeroEqNCNI, INHERITS_FROM(ZeroEqNI, RANSNCNI));
+
+//! The volume variables
+SET_TYPE_PROP(RANSNCNI, VolumeVariables, RANSNCVolumeVariables<TypeTag>);
+SET_TYPE_PROP(ZeroEqNCNI, SinglePhaseVolumeVariables, ZeroEqVolumeVariables<TypeTag>);
+
+//! The model traits of the non-isothermal model
+SET_PROP(RANSNCNI, ModelTraits)
+{
+private:
+    using GridView = typename GET_PROP_TYPE(TypeTag, FVGridGeometry)::GridView;
+    static constexpr int dim = GridView::dimension;
+    using FluidSystem = typename GET_PROP_TYPE(TypeTag, FluidSystem);
+    static constexpr int numComponents = FluidSystem::numComponents;
+    using IsothermalModelTraits = NavierStokesNCModelTraits<dim, numComponents>;
+public:
+    using type = NavierStokesNIModelTraits<IsothermalModelTraits>;
+};
+
+//! The indices
+SET_PROP(RANSNCNI, Indices)
+{
+private:
+    static constexpr int numEq = GET_PROP_TYPE(TypeTag, ModelTraits)::numEq();
+    static constexpr int dim = GET_PROP_TYPE(TypeTag, GridView)::dimension;
+    static constexpr int phaseIdx = GET_PROP_VALUE(TypeTag, PhaseIdx);
+    static constexpr int replaceCompEqIdx = GET_PROP_VALUE(TypeTag, ReplaceCompEqIdx);
+    using IsothermalIndices = NavierStokesNCIndices<dim, numEq, phaseIdx, replaceCompEqIdx>;
+public:
+    using type = NavierStokesNonIsothermalIndices<dim, numEq, IsothermalIndices>;
+};
+
+//! The specific vtk output fields
+SET_PROP(ZeroEqNCNI, VtkOutputFields)
+{
+private:
+    using FVGridGeometry = typename GET_PROP_TYPE(TypeTag, FVGridGeometry);
+    using FluidSystem = typename GET_PROP_TYPE(TypeTag, FluidSystem);
+    static constexpr int phaseIdx = GET_PROP_VALUE(TypeTag, PhaseIdx);
+    using SinglePhaseVtkOutputFields = RANSVtkOutputFields<FVGridGeometry>;
+public:
+    using type = RANSNCVtkOutputFields<FVGridGeometry, FluidSystem, phaseIdx, SinglePhaseVtkOutputFields>;
+};
+
 // //! The non-isothermal vtk output fields
 // SET_PROP(RANSNCNI, VtkOutputFields)
 // {

dumux/freeflow/ransnc/volumevariables.hh

@@ -38,8 +38,8 @@ namespace Dumux {
  */
 template <class TypeTag>
 class RANSNCVolumeVariables
-      : public GET_PROP_TYPE(TypeTag, SinglePhaseVolumeVariables),
-        public NavierStokesNCVolumeVariables<TypeTag>
+    : virtual public GET_PROP_TYPE(TypeTag, SinglePhaseVolumeVariables),
+      virtual public NavierStokesNCVolumeVariables<TypeTag>
 {
     using ParentTypeSinglePhase = typename GET_PROP_TYPE(TypeTag, SinglePhaseVolumeVariables);
     using ParentTypeCompositional = NavierStokesNCVolumeVariables<TypeTag>;
@@ -54,7 +54,6 @@ class RANSNCVolumeVariables
     static constexpr auto phaseIdx = GET_PROP_VALUE(TypeTag, PhaseIdx);
 
 public:
-
     /*!
      * \brief Update all quantities for a given control volume
      *
@@ -70,12 +69,17 @@ public: