Commit 4bd282f2 authored by Thomas Fetzer's avatar Thomas Fetzer
Browse files

[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
parent 5d391e77
......@@ -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);
......
......@@ -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>);
// \}
}
......
......@@ -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();
}
......
......@@ -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
}
};
......
......@@ -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>);
// \}
}
......
......@@ -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
......@@ -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)
// {
......
<
......@@ -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: