GCC Code Coverage Report

Directory: ../../../builds/dumux-repositories/
File: dumux/dumux/freeflow/navierstokes/mass/1p/model.hh
Date: 2025-04-12 19:19:20
Exec Total Coverage
Lines: 2 2 100.0%
Functions: 0 0 -%
Branches: 1 2 50.0%
Line Branch Exec Source
1 // -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
2 // vi: set et ts=4 sw=4 sts=4:
3 //
4 // SPDX-FileCopyrightText: Copyright © DuMux Project contributors, see AUTHORS.md in root folder
5 // SPDX-License-Identifier: GPL-3.0-or-later
6 //
7 /*!
8 * \file
9 * \ingroup NavierStokesModel
10 *
11 * \brief A single-phase, isothermal Navier-Stokes model
12 *
13 * This model implements a single-phase, isothermal Navier-Stokes model, solving the <B> momentum balance equation </B>
14 * \f[
15 \frac{\partial (\varrho \textbf{v})}{\partial t} + \nabla \cdot (\varrho \textbf{v} \textbf{v}^{\text{T}}) = \nabla \cdot (\mu (\nabla \textbf{v} + \nabla \textbf{v}^{\text{T}}))
16 - \nabla p + \varrho \textbf{g} - \textbf{f}
17 * \f]
18 * By setting the runtime parameter <code>Problem.EnableInertiaTerms</code> to <code>false</code> the Stokes
19 * equation can be solved. In this case the term
20 * \f[
21 * \nabla \cdot (\varrho \textbf{v} \textbf{v}^{\text{T}})
22 * \f]
23 * is neglected.
24 *
25 * The <B> mass balance equation </B>
26 * \f[
27 \frac{\partial \varrho}{\partial t} + \nabla \cdot (\varrho \textbf{v}) - q = 0
28 * \f]
29 *
30 * closes the system.
31 *
32 */
33
34 #ifndef DUMUX_FREEFLOW_NAVIERSTOKES_1P_MODEL_HH
35 #define DUMUX_FREEFLOW_NAVIERSTOKES_1P_MODEL_HH
36
37 #include <dumux/common/properties.hh>
38 #include <dumux/common/properties/model.hh>
39
40 #include <dumux/material/fluidstates/immiscible.hh>
41
42 #include <dumux/freeflow/spatialparams.hh>
43 #include <dumux/freeflow/navierstokes/iofields.hh>
44 #include <dumux/freeflow/turbulencemodel.hh>
45 #include <dumux/freeflow/navierstokes/energy/model.hh>
46 #include <dumux/freeflow/navierstokes/scalarfluxvariablescachefiller.hh>
47
48 #include <dumux/flux/fourierslaw.hh>
49
50 #include "localresidual.hh"
51 #include "volumevariables.hh"
52 #include "fluxvariables.hh"
53 #include "indices.hh"
54
55 namespace Dumux {
56
57 /*!
58 * \ingroup NavierStokesModel
59 * \brief Traits for the single-phase flow Navier-Stokes mass model
60 */
61 struct NavierStokesMassOnePModelTraits
62 {
63 //! There are as many momentum balance equations as dimensions
64 //! and one mass balance equation.
65 static constexpr int numEq() { return 1; }
66
67 //! The number of phases is 1
68 static constexpr int numFluidPhases() { return 1; }
69
70 //! The number of components is 1
71 static constexpr int numFluidComponents() { return 1; }
72
73 //! Enable advection
74 static constexpr bool enableAdvection() { return true; }
75
76 //! The one-phase one-component model has no molecular diffusion
77 static constexpr bool enableMolecularDiffusion() { return false; }
78
79 //! The model is isothermal
80 static constexpr bool enableEnergyBalance() { return false; }
81
82 //! The model does not include a turbulence model
83 static constexpr bool usesTurbulenceModel() { return false; }
84
85 //! return the type of turbulence model used
86 static constexpr auto turbulenceModel()
87 { return TurbulenceModel::none; }
88
89 //! the indices
90 using Indices = NavierStokesMassOnePIndices;
91 };
92
93 /*!
94 * \ingroup NavierStokesModel
95 * \brief Traits class for the volume variables of the Navier-Stokes model.
96 *
97 * \tparam PV The type used for primary variables
98 * \tparam FSY The fluid system type
99 * \tparam FST The fluid state type
100 * \tparam MT The model traits
101 */
102 template<class PV,
103 class FSY,
104 class FST,
105 class MT>
106 struct NavierStokesMassOnePVolumeVariablesTraits
107 {
108 using PrimaryVariables = PV;
109 using FluidSystem = FSY;
110 using FluidState = FST;
111 using ModelTraits = MT;
112 };
113
114 // \{
115 ///////////////////////////////////////////////////////////////////////////
116 // properties for the single-phase Navier-Stokes model
117 ///////////////////////////////////////////////////////////////////////////
118 namespace Properties {
119
120 //////////////////////////////////////////////////////////////////
121 // Type tags
122 //////////////////////////////////////////////////////////////////
123
124 // Create new type tags
125 namespace TTag {
126 //! The type tag for the single-phase, isothermal Navier-Stokes model
127 struct NavierStokesMassOneP{ using InheritsFrom = std::tuple<ModelProperties>; };
128 struct NavierStokesMassOnePNI{ using InheritsFrom = std::tuple<NavierStokesMassOneP>; };
129 } // end namespace TTag
130
131
132 template<class TypeTag>
133 struct ModelTraits<TypeTag, TTag::NavierStokesMassOneP>
134 { using type = NavierStokesMassOnePModelTraits; };
135
136 /*!
137 * \brief The fluid state which is used by the volume variables to
138 * store the thermodynamic state. This should be chosen
139 * appropriately for the model ((non-)isothermal, equilibrium, ...).
140 * This can be done in the problem.
141 */
142 template<class TypeTag>
143 struct FluidState<TypeTag, TTag::NavierStokesMassOneP>
144 {
145 private:
146 using Scalar = GetPropType<TypeTag, Properties::Scalar>;
147 using FluidSystem = GetPropType<TypeTag, Properties::FluidSystem>;
148 public:
149 using type = Dumux::ImmiscibleFluidState<Scalar, FluidSystem>;
150 };
151
152 //! The local residual
153 template<class TypeTag>
154 struct LocalResidual<TypeTag, TTag::NavierStokesMassOneP>
155 { using type = NavierStokesMassOnePLocalResidual<TypeTag>; };
156
157 //! Set the volume variables property
158 template<class TypeTag>
159 struct VolumeVariables<TypeTag, TTag::NavierStokesMassOneP>
160 {
161 private:
162 using PV = GetPropType<TypeTag, Properties::PrimaryVariables>;
163 using FSY = GetPropType<TypeTag, Properties::FluidSystem>;
164 using FST = GetPropType<TypeTag, Properties::FluidState>;
165 using MT = GetPropType<TypeTag, Properties::ModelTraits>;
166
167 static_assert(FSY::numPhases == MT::numFluidPhases(), "Number of phases mismatch between model and fluid system");
168 static_assert(FST::numPhases == MT::numFluidPhases(), "Number of phases mismatch between model and fluid state");
169 static_assert(!FSY::isMiscible(), "The Navier-Stokes model only works with immiscible fluid systems.");
170
171 using Traits = NavierStokesMassOnePVolumeVariablesTraits<PV, FSY, FST, MT>;
172 public:
173 using type = NavierStokesMassOnePVolumeVariables<Traits>;
174 };
175
176 //! The flux variables
177 template<class TypeTag>
178 struct FluxVariables<TypeTag, TTag::NavierStokesMassOneP>
179 {
180 private:
181 using Problem = GetPropType<TypeTag, Properties::Problem>;
182 using ModelTraits = GetPropType<TypeTag, Properties::ModelTraits>;
183 struct DiffusiveFluxTypes {}; // no diffusion
184 using ElementVolumeVariables = typename GetPropType<TypeTag, Properties::GridVolumeVariables>::LocalView;
185 using ElementFluxVariablesCache = typename GetPropType<TypeTag, Properties::GridFluxVariablesCache>::LocalView;
186 public:
187 using type = NavierStokesMassOnePFluxVariables<
188 Problem, ModelTraits, DiffusiveFluxTypes, ElementVolumeVariables, ElementFluxVariablesCache
189 >;
190 };
191
192 // ! The specific I/O fields
193 template<class TypeTag>
194 struct IOFields<TypeTag, TTag::NavierStokesMassOneP> { using type = NavierStokesIOFields; };
195
196 template<class TypeTag>
197 struct CouplingManager<TypeTag, TTag::NavierStokesMassOneP>
198 {
199 public:
200 using type = struct EmptyCouplingManager {};
201 };
202
203 // Set the default spatial parameters
204 template<class TypeTag>
205 struct SpatialParams<TypeTag, TTag::NavierStokesMassOneP>
206 {
207 using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
208 using Scalar = GetPropType<TypeTag, Properties::Scalar>;
209 using type = FreeFlowDefaultSpatialParams<GridGeometry, Scalar>;
210 };
211 ///////////////////////////////////////////////////////////////////////////
212 // Properties for the non-isothermal single phase model
213 ///////////////////////////////////////////////////////////////////////////
214
215 //! Add temperature to the output
216 template<class TypeTag>
217 struct IOFields<TypeTag, TTag::NavierStokesMassOnePNI>
218 { using type = NavierStokesEnergyIOFields<NavierStokesIOFields>; };
219
220 //! The model traits of the non-isothermal model
221 template<class TypeTag>
222 struct ModelTraits<TypeTag, TTag::NavierStokesMassOnePNI>
223 { using type = NavierStokesEnergyModelTraits<NavierStokesMassOnePModelTraits>; };
224
225 //! Set the volume variables property
226 template<class TypeTag>
227 struct VolumeVariables<TypeTag, TTag::NavierStokesMassOnePNI>
228 {
229 private:
230 using PV = GetPropType<TypeTag, Properties::PrimaryVariables>;
231 using FSY = GetPropType<TypeTag, Properties::FluidSystem>;
232 using FST = GetPropType<TypeTag, Properties::FluidState>;
233 using MT = GetPropType<TypeTag, Properties::ModelTraits>;
234
235 static_assert(FSY::numPhases == MT::numFluidPhases(), "Number of phases mismatch between model and fluid system");
236 static_assert(FST::numPhases == MT::numFluidPhases(), "Number of phases mismatch between model and fluid state");
237 static_assert(!FSY::isMiscible(), "The Navier-Stokes model only works with immiscible fluid systems.");
238
239 using BaseTraits = NavierStokesMassOnePVolumeVariablesTraits<PV, FSY, FST, MT>;
240 using ETCM = GetPropType<TypeTag, Properties::ThermalConductivityModel>;
241 using HCT = GetPropType<TypeTag, Properties::HeatConductionType>;
242 struct NITraits : public BaseTraits
243 {
244 using EffectiveThermalConductivityModel = ETCM;
245 using HeatConductionType = HCT;
246 };
247 public:
248 using type = NavierStokesMassOnePVolumeVariables<NITraits>;
249 };
250
251 //! Use the average for effective conductivities
252 template<class TypeTag>
253 struct ThermalConductivityModel<TypeTag, TTag::NavierStokesMassOnePNI>
254 {
255 struct type
256 {
257 template<class VolVars>
258 210365 static auto effectiveThermalConductivity(const VolVars& volVars)
259 {
260
1/2
✓ Branch 2 taken 3800 times.
✗ Branch 3 not taken.
 539165 return volVars.fluidThermalConductivity();
261 }
262 };
263 };
264
265 template<class TypeTag>
266 struct HeatConductionType<TypeTag, TTag::NavierStokesMassOnePNI>
267 { using type = FouriersLaw<TypeTag>; };
268
269 //! The flux variables
270 template<class TypeTag>
271 struct FluxVariables<TypeTag, TTag::NavierStokesMassOnePNI>
272 {
273 private:
274 using Problem = GetPropType<TypeTag, Properties::Problem>;
275 using ModelTraits = GetPropType<TypeTag, Properties::ModelTraits>;
276
277 struct DiffusiveFluxTypes
278 {
279 using HeatConductionType = GetPropType<TypeTag, Properties::HeatConductionType>;
280 };
281
282 using ElementVolumeVariables = typename GetPropType<TypeTag, Properties::GridVolumeVariables>::LocalView;
283 using ElementFluxVariablesCache = typename GetPropType<TypeTag, Properties::GridFluxVariablesCache>::LocalView;
284
285 public:
286 using type = NavierStokesMassOnePFluxVariables<
287 Problem, ModelTraits, DiffusiveFluxTypes, ElementVolumeVariables, ElementFluxVariablesCache
288 >;
289 };
290
291 template<class TypeTag>
292 struct FluxVariablesCache<TypeTag, TTag::NavierStokesMassOnePNI>
293 {
294 struct type : public GetPropType<TypeTag, Properties::HeatConductionType>::Cache
295 {};
296 };
297
298 template<class TypeTag>
299 struct FluxVariablesCacheFiller<TypeTag, TTag::NavierStokesMassOnePNI>
300 {
301 using Problem = GetPropType<TypeTag, Properties::Problem>;
302 using ModelTraits = GetPropType<TypeTag, Properties::ModelTraits>;
303 static constexpr bool diffusionIsSolDependent = false; // no diffusion;
304 static constexpr bool heatConductionIsSolDependent
305 = getPropValue<TypeTag, Properties::SolutionDependentHeatConduction>();
306
307 using type = FreeFlowScalarFluxVariablesCacheFiller<
308 Problem, ModelTraits, diffusionIsSolDependent, heatConductionIsSolDependent
309 >;
310 };
311
312 template<class TypeTag>
313 struct SolutionDependentHeatConduction<TypeTag, TTag::NavierStokesMassOnePNI>
314 { static constexpr bool value = true; };
315
316 } // end namespace Properties
317 } // end namespace Dumux
318
319 #endif
320