properties.hh 19 KB
Newer Older
1
2
3
4
5
6
7
// -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
// vi: set et ts=4 sw=4 sts=4:
/*****************************************************************************
 *   See the file COPYING for full copying permissions.                      *
 *                                                                           *
 *   This program is free software: you can redistribute it and/or modify    *
 *   it under the terms of the GNU General Public License as published by    *
8
 *   the Free Software Foundation, either version 3 of the License, or       *
9
10
11
12
13
14
15
16
17
18
19
20
 *   (at your option) any later version.                                     *
 *                                                                           *
 *   This program is distributed in the hope that it will be useful,         *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of          *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the            *
 *   GNU General Public License for more details.                            *
 *                                                                           *
 *   You should have received a copy of the GNU General Public License       *
 *   along with this program.  If not, see <http://www.gnu.org/licenses/>.   *
 *****************************************************************************/
/*!
 * \file
21
 * \ingroup Common
22
 *
23
24
 * \brief _Declares_ all properties used in Dumux.
 * \note Include this to forward declare properties in your headers.
25
26
 */

27
28
29
#ifndef DUMUX_PROPERTIES_HH
#define DUMUX_PROPERTIES_HH

Timo Koch's avatar
Timo Koch committed
30
31
// explicitly guard the include so that the property system
// header doesn't need to be opened and checked all the time
32
#ifndef DUMUX_PROPERTY_SYSTEM_HH
33
#include <dumux/common/properties/propertysystem.hh>
Timo Koch's avatar
Timo Koch committed
34
35
#endif // DUMUX_PROPERTY_SYSTEM_HH

36
37
38
namespace Dumux {
namespace Properties {

39
///////////////////////////////////////
40
// Basic properties of numeric models:
41
///////////////////////////////////////
42
43
44
45
46
47
48
49
50
template<class TypeTag, class MyTypeTag>
struct Scalar { using type = UndefinedProperty; };                 //!< Property to specify the type of scalar values.
template<class TypeTag, class MyTypeTag>
struct ModelDefaultParameters { using type = UndefinedProperty; }; //!< Property which defines the group that is queried for parameters by default
template<class TypeTag, class MyTypeTag>
struct Grid { using type = UndefinedProperty; };                   //!< The DUNE grid type
template<class TypeTag, class MyTypeTag>
struct PrimaryVariables { using type = UndefinedProperty; };       //!< A vector of primary variables
template<class TypeTag, class MyTypeTag>
51
struct [[deprecated("NumEqVector will be removed after 3.4. Implemented in dumux/common/numeqvector.hh instead.")]] NumEqVector { using type = UndefinedProperty; };            //!< A vector of size number equations that can be used for Neumann fluxes, sources, residuals, ...
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
template<class TypeTag, class MyTypeTag>
struct ModelTraits { using type = UndefinedProperty; };            //!< Traits class encapsulating model specifications
template<class TypeTag, class MyTypeTag>
struct BaseModelTraits { using type = UndefinedProperty; };        //!< Model traits to be used as a base for nonisothermal, mineralization ... models
template<class TypeTag, class MyTypeTag>
struct Problem { using type = UndefinedProperty; };                //!< Property to specify the type of a problem which has to be solved
template<class TypeTag, class MyTypeTag>
struct PointSource { using type = UndefinedProperty; };            //!< Property defining the type of point source used
template<class TypeTag, class MyTypeTag>
struct PointSourceHelper { using type = UndefinedProperty; };      //!< Property defining the class that computes which sub control volume point sources belong to
template<class TypeTag, class MyTypeTag>
struct IOFields { using type = UndefinedProperty; };               //!< A class helping models to define input and output fields
template<class TypeTag, class MyTypeTag>
struct BaseLocalResidual { using type = UndefinedProperty; };      //!< The type of the base class of the local residual (specific to a discretization scheme)
template<class TypeTag, class MyTypeTag>
struct JacobianMatrix { using type = UndefinedProperty; };         //!< Type of the global jacobian matrix
template<class TypeTag, class MyTypeTag>
struct SolutionVector { using type = UndefinedProperty; };         //!< Vector containing all primary variable vector of the grid
70

71
72
//! The type of the local residual function, i.e. the equation to be solved. Must inherit
//! from the BaseLocalResidual property and fulfill its interfaces.
73
74
template<class TypeTag, class MyTypeTag>
struct LocalResidual { using type = UndefinedProperty; };
75

Dennis Gläser's avatar
Dennis Gläser committed
76
//! TODO: Remove this property as soon as the decoupled models are integrated
77
78
template<class TypeTag, class MyTypeTag>
struct LinearSolver { using type = UndefinedProperty; };
Dennis Gläser's avatar
Dennis Gläser committed
79

80
81
82
////////////////////////////////////////////////
// Basic properties regarding balance equations
/////////////////////////////////////////////////
83
// TODO: Integrate UseMoles into BalanceEqOpts
84
85
86
87
88
89
template<class TypeTag, class MyTypeTag>
struct UseMoles { using type = UndefinedProperty; };               //!< Property whether to use moles or kg as amount unit for balance equations
template<class TypeTag, class MyTypeTag>
struct ReplaceCompEqIdx { using type = UndefinedProperty; };       //!< The component balance index that should be replaced by the total mass/mole balance
template<class TypeTag, class MyTypeTag>
struct BalanceEqOpts { using type = UndefinedProperty; };          //!< A class that collects options for the evaluation of the balance equations
Dennis Gläser's avatar
Dennis Gläser committed
90

91
92
93
/////////////////////////////////////////////
// Properties used by finite volume schemes:
/////////////////////////////////////////////
94
95
template<class TypeTag, class MyTypeTag>
struct ElementBoundaryTypes { using type = UndefinedProperty; };                //!< Stores the boundary types on an element
96

97
template<class TypeTag, class MyTypeTag>
98
struct GridGeometry { using type = UndefinedProperty; };
99
template <class TypeTag, class MyTypeTag>
100
struct EnableGridGeometryCache { using type = UndefinedProperty; };
101

102
103
104
105
106
107
108
109
110
111
112
template<class TypeTag, class MyTypeTag>
struct VolumeVariables { using type = UndefinedProperty; };                     //!< The secondary variables within a sub-control volume
template<class TypeTag, class MyTypeTag>
struct GridVolumeVariables { using type = UndefinedProperty; };                 //!< The type for a global container for the volume variables
template<class TypeTag, class MyTypeTag>
struct EnableGridVolumeVariablesCache { using type = UndefinedProperty; };      //!< If disabled, the volume variables are not stored (reduces memory, but is slower)
template<class TypeTag, class MyTypeTag>
struct FluxVariables { using type = UndefinedProperty; };                       //!< Container storing the different types of flux variables
template<class TypeTag, class MyTypeTag>
struct FluxVariablesCache { using type = UndefinedProperty; };                  //!< Stores data associated with flux vars
template<class TypeTag, class MyTypeTag>
113
114
struct FluxVariablesCacheFiller { using type = UndefinedProperty; };            //!< The engine behind the global flux cache (how to fill caches for the stencil)
template<class TypeTag, class MyTypeTag>
115
116
117
118
119
struct GridFluxVariablesCache { using type = UndefinedProperty; };              //!< The global vector of flux variable containers
template<class TypeTag, class MyTypeTag>
struct EnableGridFluxVariablesCache { using type = UndefinedProperty; };        //!< specifies if data on flux vars should be saved (faster, but more memory consuming)
template<class TypeTag, class MyTypeTag>
struct GridVariables { using type = UndefinedProperty; };                       //!< The grid variables object managing variable data on the grid (volvars/fluxvars cache)
120

121
/////////////////////////////////////////////////////////////////
122
// Additional properties used by the cell-centered mpfa schemes:
123
/////////////////////////////////////////////////////////////////
124
125
126
127
128
129
template<class TypeTag, class MyTypeTag>
struct PrimaryInteractionVolume { using type = UndefinedProperty; };            //!< The primary interaction volume type
template<class TypeTag, class MyTypeTag>
struct SecondaryInteractionVolume { using type = UndefinedProperty; };          //!< The secondary interaction volume type used e.g. on the boundaries
template<class TypeTag, class MyTypeTag>
struct DualGridNodalIndexSet { using type = UndefinedProperty; };               //!< The type used for the nodal index sets of the dual grid
130

131
/////////////////////////////////////////////////////////////
132
// Properties used by models involving flow in porous media:
133
/////////////////////////////////////////////////////////////
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
template<class TypeTag, class MyTypeTag>
struct EnergyLocalResidual { using type = UndefinedProperty; };                 //!< The local residual of the energy equation
template<class TypeTag, class MyTypeTag>
struct AdvectionType { using type = UndefinedProperty; };                       //!< The type for the calculation the advective fluxes
template<class TypeTag, class MyTypeTag>
struct SolutionDependentAdvection { using type = UndefinedProperty; };          //!< specifies if the parameters for the advective fluxes depend on the solution
template<class TypeTag, class MyTypeTag>
struct MolecularDiffusionType { using type = UndefinedProperty; };              //!< The type for the calculation of the molecular diffusion fluxes
template<class TypeTag, class MyTypeTag>
struct SolutionDependentMolecularDiffusion { using type = UndefinedProperty; }; //!< specifies if the parameters for the diffusive fluxes depend on the solution
template<class TypeTag, class MyTypeTag>
struct HeatConductionType { using type = UndefinedProperty; };                  //!< The type for the calculation of the heat conduction fluxes
template<class TypeTag, class MyTypeTag>
struct SolutionDependentHeatConduction { using type = UndefinedProperty; };     //!< specifies if the parameters for the heat conduction fluxes depend on the solution

template<class TypeTag, class MyTypeTag>
struct SpatialParams { using type = UndefinedProperty; };                       //!< The type of the spatial parameters object
template<class TypeTag, class MyTypeTag>
struct FluidSystem { using type = UndefinedProperty; };                         //!< The type of the fluid system to use
template<class TypeTag, class MyTypeTag>
struct FluidState { using type = UndefinedProperty; };                          //!< The type of the fluid state to use
template<class TypeTag, class MyTypeTag>
struct SolidSystem { using type = UndefinedProperty; };                         //!< The type of the solid system to use
template<class TypeTag, class MyTypeTag>
struct SolidState { using type = UndefinedProperty; };                           //!< The type of the solid state to use
template<class TypeTag, class MyTypeTag>
struct EffectiveDiffusivityModel { using type = UndefinedProperty; };           //!< The employed model for the computation of the effective diffusivity
template<class TypeTag, class MyTypeTag>
struct ThermalConductivityModel { using type = UndefinedProperty; };            //!< Model to be used for the calculation of the effective conductivity
template<class TypeTag, class MyTypeTag>
struct VelocityOutput { using type = UndefinedProperty; };                      //!< specifies the velocity calculation module to be used
template<class TypeTag, class MyTypeTag>
struct Formulation { using type = UndefinedProperty; };                         //!< The formulation of the model
167
// TODO: is this useful? -> everything is a constraint solver just a different type
168
169
template<class TypeTag, class MyTypeTag>
struct UseConstraintSolver { using type = UndefinedProperty; };                 //!< Whether to use a contraint solver for computing the secondary variables
Dennis Gläser's avatar
Dennis Gläser committed
170

171
// When using the box method in a multi-phase context, an interface solver might be necessary
172
173
template<class TypeTag, class MyTypeTag>
struct EnableBoxInterfaceSolver { using type = UndefinedProperty; };
174

175
176
177
//////////////////////////////////////////////////////////////
// Additional properties used by the 2pnc and 2pncmin models:
//////////////////////////////////////////////////////////////
178
179
180
template<class TypeTag, class MyTypeTag>
struct Chemistry { using type = UndefinedProperty; };                           //!< The chemistry class with which solves equlibrium reactions
template<class TypeTag, class MyTypeTag>
181
struct SetMoleFractionsForFirstPhase { using type = UndefinedProperty; };       //!< Set the mole fraction in the wetting or nonwetting phase
182

Katharina Heck's avatar
Katharina Heck committed
183
184
185
//////////////////////////////////////////////////////////////
// Additional properties used by the richards model
//////////////////////////////////////////////////////////////
186
187
template<class TypeTag, class MyTypeTag>
struct EnableWaterDiffusionInAir { using type = UndefinedProperty; }; //!< Property for turning Richards into extended Richards
Katharina Heck's avatar
Katharina Heck committed
188

189
190
191
//////////////////////////////////////////////////////////////
// Additional properties used by the 3pwateroil model:
//////////////////////////////////////////////////////////////
192
193
template<class TypeTag, class MyTypeTag>
struct OnlyGasPhaseCanDisappear { using type = UndefinedProperty; }; //!< reduces the phasestates to threePhases and wnPhaseOnly
194

195
196
197
/////////////////////////////////////////////////////////////
// Properties used by geomechanical models:
/////////////////////////////////////////////////////////////
198
199
template<class TypeTag, class MyTypeTag>
struct StressType { using type = UndefinedProperty; };       //!< The type used for the evaluation of stress tensors and forces
200

201
202
203
/////////////////////////////////////////////////////////////
// Properties used by the staggered-grid discretization method
/////////////////////////////////////////////////////////////
204

205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
template<class TypeTag, class MyTypeTag>
struct NumEqCellCenter { using type = UndefinedProperty; };                     //!< The number of equations for cell-centered dofs
template<class TypeTag, class MyTypeTag>
struct NumEqFace { using type = UndefinedProperty; };                           //!< The number of equations for face dofs
template<class TypeTag, class MyTypeTag>
struct CellCenterSolutionVector { using type = UndefinedProperty; };            //!< The solution vector type for cell-centered dofs
template<class TypeTag, class MyTypeTag>
struct FaceSolutionVector { using type = UndefinedProperty; };                  //!< The solution vector type for face dofs
template<class TypeTag, class MyTypeTag>
struct GridFaceVariables { using type = UndefinedProperty; };                   //!< Global vector containing face-related data
template<class TypeTag, class MyTypeTag>
struct CellCenterPrimaryVariables { using type = UndefinedProperty; };          //!< The primary variables container type for cell-centered dofs
template<class TypeTag, class MyTypeTag>
struct FacePrimaryVariables { using type = UndefinedProperty; };                //!< The primary variables container type for face dofs
template<class TypeTag, class MyTypeTag>
struct IntersectionMapper { using type = UndefinedProperty; };                  //!< Specifies the intersection mapper
template<class TypeTag, class MyTypeTag>
struct StaggeredPrimaryVariables { using type = UndefinedProperty; };           //!< The hybrid primary variables container type
template<class TypeTag, class MyTypeTag>
struct BaseEpsilon { using type = UndefinedProperty; };                         //!< A base epsilon for numerical differentiation, can contain multiple values
template<class TypeTag, class MyTypeTag>
struct FaceVariables { using type = UndefinedProperty; };                       //!< Class containing local face-related data
template<class TypeTag, class MyTypeTag>
struct BoundaryValues { using type = UndefinedProperty; };                      //!< Class containing local boundary data
template<class TypeTag, class MyTypeTag>
struct StaggeredFaceSolution { using type = UndefinedProperty; };               //!< A vector containing the solution for a face (similar to ElementSolution)
template<class TypeTag, class MyTypeTag>
232
struct EnableGridFaceVariablesCache { using type = UndefinedProperty; };        //!< Switch on/off caching of face variables
233
template<class TypeTag, class MyTypeTag>
234
struct UpwindSchemeOrder { using type = UndefinedProperty; };                   //!< Specifies the order of the upwinding scheme (1 == first order, 2 == second order(tvd methods))
235

236
237
238
239
/////////////////////////////////////////////////////////////
// Properties used by the mpnc model
/////////////////////////////////////////////////////////////

240
241
template<class TypeTag, class MyTypeTag>
struct PressureFormulation { using type = UndefinedProperty; }; //! the formulation of the pressure e.g most wetting first
242
243
244
245

/////////////////////////////////////////////////////////////
// Properties used by the nonequilibrium model
/////////////////////////////////////////////////////////////
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
template<class TypeTag, class MyTypeTag>
struct EquilibriumModelTraits { using type = UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct EquilibriumLocalResidual { using type = UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct EquilibriumIndices { using type = UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct EquilibriumIOFields { using type = UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct NumEqBalance { using type = UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct EnableThermalNonEquilibrium { using type = UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct EnableChemicalNonEquilibrium { using type = UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct NumEnergyEqFluid { using type = UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct NumEnergyEqSolid { using type = UndefinedProperty; };

template<class TypeTag, class MyTypeTag>
struct NusseltFormulation { using type = UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct SherwoodFormulation { using type = UndefinedProperty; };
269

270
271
272
273
/////////////////////////////////////////////////////////////
// Properties used by free flow models
/////////////////////////////////////////////////////////////

274
275
template<class TypeTag, class MyTypeTag>
struct NormalizePressure { using type = UndefinedProperty; }; //!<  Returns whether to normalize the pressure term in the momentum balance or not
276
277
template<class TypeTag, class MyTypeTag>
struct ViscousFluxType { using type = UndefinedProperty; };              //!< The type for the calculation of the (turbulent) viscous (momentum) fluxes
278

279
280
281
/////////////////////////////////////////////////////////////
// Properties used by multidomain simulations
/////////////////////////////////////////////////////////////
282
283
template<class TypeTag, class MyTypeTag>
struct CouplingManager { using type = UndefinedProperty; };
284

285
286
287
///////////////////////////////////////
// Basic properties of sequential models:
///////////////////////////////////////
288
289
template<class TypeTag, class MyTypeTag>
struct TimeManager { using type = UndefinedProperty; };
290

291
292
293
} // end namespace Properties
} // end namespace Dumux

294
#endif