Commit afe3b361 authored by Dennis Gläser's avatar Dennis Gläser
Browse files

introduce new type tag structure

we now have the following levels of type tags:

- basic numerical model
- linear solver type tag
- discretization scheme-specific type tag
- physics-related type tag (e.g. pmflow)
- problem-specific type tag
parent 6967866b
......@@ -29,7 +29,6 @@
#include <dune/istl/matrixindexset.hh>
#include <dumux/common/timeloop.hh>
#include <dumux/implicit/properties.hh>
#include <dumux/implicit/localresidual.hh>
#include <dumux/discretization/methods.hh>
......@@ -58,7 +57,7 @@ class FVAssembler
using TimeLoop = TimeLoopBase<Scalar>;
static constexpr int dim = GridView::dimension;
static constexpr bool isBox = GET_PROP_VALUE(TypeTag, ImplicitIsBox);
static constexpr bool isBox = GET_PROP_VALUE(TypeTag, DiscretizationMethod) == DiscretizationMethods::Box;
static constexpr int dofCodim = isBox ? dim : 0;
using LocalAssembler = std::conditional_t<isBox, BoxLocalAssembler<TypeTag, diffMethod, isImplicit>,
......@@ -358,7 +357,7 @@ private:
//! Implicit jacobian pattern for cell-centered fv schemes
template<typename T = TypeTag>
std::enable_if_t<!GET_PROP_VALUE(T, ImplicitIsBox), void>
std::enable_if_t<GET_PROP_VALUE(T, DiscretizationMethod) != DiscretizationMethods::Box, void>
setImplicitJacobianPattern_(Dune::MatrixIndexSet& pattern, std::size_t numDofs)
{
for (unsigned int globalI = 0; globalI < numDofs; ++globalI)
......@@ -376,7 +375,7 @@ private:
//! Implicit jacobian pattern for vertex-centered fv schemes
template<typename T = TypeTag>
std::enable_if_t<GET_PROP_VALUE(T, ImplicitIsBox), void>
std::enable_if_t<GET_PROP_VALUE(T, DiscretizationMethod) == DiscretizationMethods::Box, void>
setImplicitJacobianPattern_(Dune::MatrixIndexSet& pattern, std::size_t numDofs)
{
for (const auto& element : elements(fvGridGeometry().gridView()))
......
......@@ -29,10 +29,18 @@
#include <dune/common/parametertree.hh>
#include <dune/common/fvector.hh>
#include <dune/grid/common/mcmgmapper.hh>
#include <dune/istl/bvector.hh>
#include <dune/istl/bcrsmatrix.hh>
#include <dumux/common/balanceequationopts.hh>
#include <dumux/common/propertysystem.hh>
#include <dumux/common/properties.hh>
#include <dumux/common/parameters.hh>
#include <dumux/common/pointsource.hh>
#include <dumux/common/boundarytypes.hh>
#include <dumux/io/defaultvtkoutputfields.hh>
#include <dumux/io/gridcreator.hh>
......@@ -40,150 +48,21 @@ namespace Dumux
{
namespace Properties
{
///////////////////////////////////
// Type tag definitions:
///////////////////////////////////
//! Type tag for all models.
//! Type tag for numeric models.
NEW_TYPE_TAG(NumericModel);
/////////////////////////////////////////////
// Property names which are always available:
/////////////////////////////////////////////
//! Property to specify the type of scalar values.
NEW_PROP_TAG(Scalar);
//! Property which provides a Dune::ParameterTree.
NEW_PROP_TAG(ParameterTree);
//! Property which defines the group that is queried for parameters by default
NEW_PROP_TAG(ModelParameterGroup);
//! Property which defines the group that is queried for parameters by default
NEW_PROP_TAG(ModelDefaultParameters);
//! Property which defines the group that is queried for grid (creator) parameters by default
NEW_PROP_TAG(GridParameterGroup);
//! Property which provides a GridCreator (manages grids)
NEW_PROP_TAG(GridCreator);
//! The DUNE grid type
NEW_PROP_TAG(Grid);
//! The number of equations to solve (equal to number of primary variables)
NEW_PROP_TAG(NumEq);
//! A vector of primary variables
NEW_PROP_TAG(PrimaryVariables);
//! A vector of size number equations that can be used for
//! Neumann fluxes, sources, residuals, ...
NEW_PROP_TAG(NumEqVector);
//! The type of the grid view according to the grid type
NEW_PROP_TAG(GridView);
//! Property to specify the type of a problem which has to be solved
NEW_PROP_TAG(Problem);
//! Property to specify the name of the problem
NEW_PROP_TAG(ProblemName);
//! Property defining the type of the model which is used to solve the problem
NEW_PROP_TAG(Model);
//! Property defining the type of point source used
NEW_PROP_TAG(PointSource);
//! Property defining the class that computes which sub control volume point sources belong to
NEW_PROP_TAG(PointSourceHelper);
//! The grid variables object managing variable data on the grid
NEW_PROP_TAG(GridVariables);
/*!
* \brief Specify the maximum size of a time integration [s].
*
* The default is to not limit the step size.
*/
NEW_PROP_TAG(TimeLoopMaxTimeStepSize);
NEW_PROP_TAG(TimeManagerMaxTimeStepSize);
//! the maximum allowed number of timestep divisions for the
//! Newton solver
NEW_PROP_TAG(TimeLoopMaxTimeStepDivisions);
//! Property to define the output level
NEW_PROP_TAG(VtkOutputLevel);
//! A class helping models to define default vtk output parameters
NEW_PROP_TAG(VtkOutputFields);
//! A class that collects options for the evaluation of the balance eqs
NEW_PROP_TAG(BalanceEqOpts);
///////////////////////////////////
// Default values for properties:
///////////////////////////////////
//! Set the default problem name to dumuxsim
SET_STRING_PROP(NumericModel, ProblemName, "dumuxsim");
//! Set the default type of scalar values to double
SET_TYPE_PROP(NumericModel, Scalar, double);
//! Use the leaf grid view if not defined otherwise
SET_TYPE_PROP(NumericModel, GridView, typename GET_PROP_TYPE(TypeTag, Grid)::LeafGridView);
//! Set the default vector with size number of equations to a field vector
SET_TYPE_PROP(NumericModel, NumEqVector, Dune::FieldVector<typename GET_PROP_TYPE(TypeTag, Scalar),
GET_PROP_VALUE(TypeTag, NumEq) >);
SET_TYPE_PROP(NumericModel, NumEqVector, Dune::FieldVector<typename GET_PROP_TYPE(TypeTag, Scalar), GET_PROP_VALUE(TypeTag, NumEq)>);
//! Set the default primary variable vector to a vector of size of number of equations
SET_TYPE_PROP(NumericModel, PrimaryVariables, typename GET_PROP_TYPE(TypeTag, NumEqVector));
//! use an unlimited time step size by default
SET_SCALAR_PROP(NumericModel, TimeLoopMaxTimeStepSize, std::numeric_limits<typename GET_PROP_TYPE(TypeTag,Scalar)>::max());
SET_SCALAR_PROP(NumericModel, TimeManagerMaxTimeStepSize, std::numeric_limits<typename GET_PROP_TYPE(TypeTag,Scalar)>::max());
//! set number of maximum timestep divisions to 10
SET_INT_PROP(NumericModel, TimeLoopMaxTimeStepDivisions, 10);
//! Set the ParameterTree property
SET_PROP(NumericModel, ParameterTree)
{
typedef Dune::ParameterTree type;
static Dune::ParameterTree &tree()
{
static Dune::ParameterTree obj_;
return obj_;
}
static Dune::ParameterTree &compileTimeParams()
{
static Dune::ParameterTree obj_;
return obj_;
}
static Dune::ParameterTree &runTimeParams()
{
static Dune::ParameterTree obj_;
return obj_;
}
static Dune::ParameterTree &deprecatedRunTimeParams()
{
static Dune::ParameterTree obj_;
return obj_;
}
static Dune::ParameterTree &unusedNewRunTimeParams()
{
static Dune::ParameterTree obj_;
return obj_;
}
};
//! use the global group as default for the model's parameter group
SET_STRING_PROP(NumericModel, ModelParameterGroup, "");
......@@ -193,8 +72,6 @@ SET_PROP(NumericModel, ModelDefaultParameters)
static void defaultParams(Dune::ParameterTree& tree, const std::string& group = "") { }
};
SET_STRING_PROP(NumericModel, GridParameterGroup, "Grid");
//! Use the DgfGridCreator by default
SET_TYPE_PROP(NumericModel, GridCreator, GridCreator<TypeTag>);
......@@ -210,6 +87,47 @@ SET_INT_PROP(NumericModel, VtkOutputLevel, 0);
//! Set the default to a function throwing a NotImplemented error
SET_TYPE_PROP(NumericModel, VtkOutputFields, DefaultVtkOutputFields);
//! Mapper for the grid view's vertices.
#if DUNE_VERSION_NEWER(DUNE_COMMON,2,6)
SET_TYPE_PROP(NumericModel,
VertexMapper,
Dune::MultipleCodimMultipleGeomTypeMapper<typename GET_PROP_TYPE(TypeTag, GridView)>);
#else
SET_TYPE_PROP(NumericModel,
VertexMapper,
Dune::MultipleCodimMultipleGeomTypeMapper<typename GET_PROP_TYPE(TypeTag, GridView),
Dune::MCMGVertexLayout>);
#endif
//! Mapper for the grid view's elements.
#if DUNE_VERSION_NEWER(DUNE_COMMON,2,6)
SET_TYPE_PROP(NumericModel,
ElementMapper,
Dune::MultipleCodimMultipleGeomTypeMapper<typename GET_PROP_TYPE(TypeTag, GridView)>);
#else
SET_TYPE_PROP(NumericModel,
ElementMapper,
Dune::MultipleCodimMultipleGeomTypeMapper<typename GET_PROP_TYPE(TypeTag, GridView),
Dune::MCMGElementLayout>);
#endif
//! The type of a solution for the whole grid at a fixed time
SET_TYPE_PROP(NumericModel, SolutionVector, Dune::BlockVector<typename GET_PROP_TYPE(TypeTag, PrimaryVariables)>);
//! Set the type of a global jacobian matrix from the solution types
SET_PROP(NumericModel, JacobianMatrix)
{
private:
using Scalar = typename GET_PROP_TYPE(TypeTag, Scalar);
enum { numEq = GET_PROP_VALUE(TypeTag, NumEq) };
using MatrixBlock = typename Dune::FieldMatrix<Scalar, numEq, numEq>;
public:
using type = typename Dune::BCRSMatrix<MatrixBlock>;
};
//! Boundary types at a single degree of freedom
SET_TYPE_PROP(NumericModel, BoundaryTypes, BoundaryTypes<GET_PROP_VALUE(TypeTag, NumEq)>);
//! Set the default class for the balance equation options
SET_TYPE_PROP(NumericModel, BalanceEqOpts, BalanceEquationOptions<TypeTag>);
......
......@@ -72,8 +72,7 @@ class FVProblem
using CoordScalar = typename GridView::ctype;
using GlobalPosition = Dune::FieldVector<CoordScalar, dimWorld>;
// TODO get this from the discretization method property
enum { isBox = GET_PROP_VALUE(TypeTag, ImplicitIsBox) };
static constexpr bool isBox = GET_PROP_VALUE(TypeTag, DiscretizationMethod) == DiscretizationMethods::Box;
// using GridAdaptModel = ImplicitGridAdapt<TypeTag, adaptiveGrid>;
......
......@@ -31,6 +31,8 @@
#include <dumux/common/parameters.hh>
#include <dumux/common/propertysystem.hh>
#include <dumux/discretization/methods.hh>
namespace Dumux
{
......@@ -352,11 +354,11 @@ class BoundingBoxTreePointSourceHelper
using FVElementGeometry = typename GET_PROP_TYPE(TypeTag, FVElementGeometry);
using PointSource = typename GET_PROP_TYPE(TypeTag, PointSource);
static const int dim = GridView::dimension;
static const int dimworld = GridView::dimensionworld;
static constexpr int dim = GridView::dimension;
static constexpr int dimworld = GridView::dimensionworld;
enum { isBox = GET_PROP_VALUE(TypeTag, ImplicitIsBox) };
enum { dofCodim = isBox ? dim : 0 };
static constexpr bool isBox = GET_PROP_VALUE(TypeTag, DiscretizationMethod) == DiscretizationMethods::Box;
static constexpr int dofCodim = isBox ? dim : 0;
public:
//! calculate a DOF index to point source map from given vector of point sources
......
// -*- 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 *
* the Free Software Foundation, either version 2 of the License, or *
* (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/>. *
*****************************************************************************/
/*!
* \ingroup Properties
* \file
*
* \brief Collects a list of all used properties
*/
namespace Dumux
{
namespace Properties
{
/////////////////////////////////////////////
// Basic properties of numeric models:
/////////////////////////////////////////////
NEW_PROP_TAG(Scalar); //! Property to specify the type of scalar values.
NEW_PROP_TAG(ModelParameterGroup); //! Property which defines the group that is queried for parameters by default
NEW_PROP_TAG(ModelDefaultParameters); //! Property which defines the group that is queried for parameters by default
NEW_PROP_TAG(GridCreator); //! Property which provides a GridCreator (manages grids)
NEW_PROP_TAG(Grid); //! The DUNE grid type
NEW_PROP_TAG(NumEq); //! The number of equations to solve (equal to number of primary variables)
NEW_PROP_TAG(Indices); //! Enumerations for the numeric model
NEW_PROP_TAG(PrimaryVariables); //! A vector of primary variables
NEW_PROP_TAG(NumEqVector); //! A vector of size number equations that can be used for Neumann fluxes, sources, residuals, ...
NEW_PROP_TAG(GridView); //! The type of the grid view according to the grid type
NEW_PROP_TAG(Problem); //! Property to specify the type of a problem which has to be solved
NEW_PROP_TAG(PointSource); //! Property defining the type of point source used
NEW_PROP_TAG(PointSourceHelper); //! Property defining the class that computes which sub control volume point sources belong to
NEW_PROP_TAG(VtkOutputLevel); //! Property to define the output level
NEW_PROP_TAG(VtkOutputFields); //! A class helping models to define default vtk output parameters
NEW_PROP_TAG(BaseLocalResidual); //! The type of the base class of the local residual (specific to a discretization scheme)
NEW_PROP_TAG(JacobianMatrix); //! Type of the global jacobian matrix
NEW_PROP_TAG(SolutionVector); //! Vector containing all primary variable vector of the grid
NEW_PROP_TAG(BoundaryTypes); //! Stores the boundary types of a single degree of freedom
NEW_PROP_TAG(DiscretizationMethod); //! Property for the used discretization method
NEW_PROP_TAG(VertexMapper); //! mapper for vertices
NEW_PROP_TAG(ElementMapper); //! mapper for elements
NEW_PROP_TAG(BalanceEqOpts); //! A class that collects options for the evaluation of the balance equations
//! The type of the local residual function, i.e. the equation to be solved. Must inherit
//! from the BaseLocalResidual property and fulfill its interfaces.
NEW_PROP_TAG(LocalResidual);
/////////////////////////////////////////////
// Properties used by finite volume schemes:
/////////////////////////////////////////////
NEW_PROP_TAG(ElementBoundaryTypes); //! Stores the boundary types on an element
NEW_PROP_TAG(ElementSolutionVector); //! A vector of primary variables within an element
NEW_PROP_TAG(AssemblyMap); //! Connectivity map (transposed) used for assembling the Jacobian matrix entries
NEW_PROP_TAG(SubControlVolume); //! The type of the sub control volume
NEW_PROP_TAG(SubControlVolumeFace); //! The type of the sub control volume face
NEW_PROP_TAG(FVElementGeometry); //! The type of the local finite volume geometry (iterators over scvs, scvfs)
NEW_PROP_TAG(FVGridGeometry); //! The type of the global finite volume geometry
NEW_PROP_TAG(EnableFVGridGeometryCache); //! specifies if geometric data is saved (faster, but more memory consuming)
NEW_PROP_TAG(VolumeVariables); //! The secondary variables within a sub-control volume
NEW_PROP_TAG(ElementVolumeVariables); //! The type for a local (element/stencil) container for the volume variables
NEW_PROP_TAG(GlobalVolumeVariables); //! The type for a global container for the volume variables
NEW_PROP_TAG(EnableGlobalVolumeVariablesCache); //! If disabled, the volume variables are not stored (reduces memory, but is slower)
NEW_PROP_TAG(FluxVariables); //! Container storing the different types of flux variables
NEW_PROP_TAG(FluxVariablesCache); //! Stores data associated with flux vars
NEW_PROP_TAG(ElementFluxVariablesCache); //! A local vector of flux variable caches per element
NEW_PROP_TAG(GlobalFluxVariablesCache); //! The global vector of flux variable containers
NEW_PROP_TAG(EnableGlobalFluxVariablesCache); //! specifies if data on flux vars should be saved (faster, but more memory consuming)
NEW_PROP_TAG(GridVariables); //! The grid variables object managing variable data on the grid (volvars/fluxvars cache)
////////////////////////////////////////////////////////////////////////////////////////////////////////
// Additional properties used by the cell-centered mpfa schemes:
/////////////////////////////////////////////////////////////////////////////////////////////////////////
NEW_PROP_TAG(MpfaMethod); //! Specifies the mpfa method to be used
NEW_PROP_TAG(MpfaHelper); //! A Helper class depending on the mpfa method and grid dimension
NEW_PROP_TAG(PrimaryInteractionVolume); //! The primary interaction volume type
NEW_PROP_TAG(SecondaryInteractionVolume); //! The secondary interaction volume type used e.g. on the boundaries
////////////////////////////////////////////////////////////
// Properties used by models involving flow in porous media:
////////////////////////////////////////////////////////////
NEW_PROP_TAG(EnergyLocalResidual); //! The local residual of the energy equation
NEW_PROP_TAG(EnableAdvection); //! specifies if advection is considered in the model
NEW_PROP_TAG(AdvectionType); //! The type for the calculation the advective fluxes
NEW_PROP_TAG(SolutionDependentAdvection); //! specifies if the parameters for the advective fluxes depend on the solution
NEW_PROP_TAG(EnableMolecularDiffusion); //! specifies if molecular diffusive fluxes are considered in the model
NEW_PROP_TAG(MolecularDiffusionType); //! The type for the calculation of the molecular diffusion fluxes
NEW_PROP_TAG(SolutionDependentMolecularDiffusion); //! specifies if the parameters for the diffusive fluxes depend on the solution
NEW_PROP_TAG(EnableEnergyBalance); //! Specifies if the model solves an energy equation
NEW_PROP_TAG(HeatConductionType); //! The type for the calculation of the heat conduction fluxes
NEW_PROP_TAG(SolutionDependentHeatConduction); //! specifies if the parameters for the heat conduction fluxes depend on the solution
NEW_PROP_TAG(NumPhases); //! Number of fluid phases in the system
NEW_PROP_TAG(NumComponents); //! Number of fluid phases in the system
NEW_PROP_TAG(SpatialParams); //! The type of the spatial parameters object
NEW_PROP_TAG(FluidSystem); //! The type of the fluid system to use
NEW_PROP_TAG(Fluid); //! The fluid used for the default fluid system
NEW_PROP_TAG(FluidState); //! The type of the fluid state to use
NEW_PROP_TAG(PrimaryVariableSwitch); //! The primary variable switch needed for compositional models
NEW_PROP_TAG(ThermalConductivityModel); //! Model to be used for the calculation of the effective conductivity
NEW_PROP_TAG(VelocityOutput); //! specifies the velocity calculation module to be used
// specify if we evaluate the permeability in the volume (for discontinuous fields)
// or at the scvf center for analytical permeability fields (e.g. convergence studies)
NEW_PROP_TAG(EvaluatePermeabilityAtScvfIP);
}
}
......@@ -23,9 +23,6 @@
#ifndef DUMUX_DISCRETIZATION_BOX_ELEMENT_VOLUMEVARIABLES_HH
#define DUMUX_DISCRETIZATION_BOX_ELEMENT_VOLUMEVARIABLES_HH
#include <dumux/implicit/properties.hh>
#include <dumux/implicit/model.hh>
namespace Dumux
{
......@@ -41,7 +38,6 @@ class BoxElementVolumeVariables
template<class TypeTag>
class BoxElementVolumeVariables<TypeTag,/*enableGlobalVolVarCache*/true>
{
friend ImplicitModel<TypeTag>;
using Problem = typename GET_PROP_TYPE(TypeTag, Problem);
using GridView = typename GET_PROP_TYPE(TypeTag, GridView);
using SolutionVector = typename GET_PROP_TYPE(TypeTag, SolutionVector);
......
......@@ -29,7 +29,6 @@
#include <dumux/common/math.hh>
#include <dumux/common/parameters.hh>
#include <dumux/implicit/properties.hh>
#include <dumux/discretization/methods.hh>
namespace Dumux
......@@ -52,7 +51,6 @@ class FicksLawImplementation<TypeTag, DiscretizationMethods::Box>
{
using Scalar = typename GET_PROP_TYPE(TypeTag, Scalar);
using Problem = typename GET_PROP_TYPE(TypeTag, Problem);
using Model = typename GET_PROP_TYPE(TypeTag, Model);
using FluidSystem = typename GET_PROP_TYPE(TypeTag, FluidSystem);
using VolumeVariables = typename GET_PROP_TYPE(TypeTag, VolumeVariables);
using SubControlVolume = typename GET_PROP_TYPE(TypeTag, SubControlVolume);
......
// -*- 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 *
* the Free Software Foundation, either version 2 of the License, or *
* (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/>. *
*****************************************************************************/
/*!
* \ingroup Properties
* \file
*
* \brief Defines a type tag and some properties for models using the box scheme.
*/
#ifndef DUMUX_BOX_PROPERTIES_HH
#define DUMUX_BOX_PROPERTIES_HH
#include <dumux/discretization/methods.hh>
#include <dumux/discretization/fvproperties.hh>
#include <dumux/implicit/box/elementboundarytypes.hh>
#include <dumux/implicit/box/localresidual.hh>
#include <dumux/discretization/box/subcontrolvolume.hh>
#include <dumux/discretization/box/subcontrolvolumeface.hh>
#include <dumux/discretization/box/globalfluxvariablescache.hh>
#include <dumux/discretization/box/elementfluxvariablescache.hh>
#include <dumux/discretization/box/globalvolumevariables.hh>
#include <dumux/discretization/box/elementvolumevariables.hh>
#include <dumux/discretization/box/fvgridgeometry.hh>
#include <dumux/discretization/box/fvelementgeometry.hh>
namespace Dumux
{
namespace Properties
{
//! Type tag for the box scheme.
NEW_TYPE_TAG(BoxModel, INHERITS_FROM(FiniteVolumeModel));
//! Set the corresponding discretization method property
SET_PROP(BoxModel, DiscretizationMethod)
{
static const DiscretizationMethods value = DiscretizationMethods::Box;
};
//! Set the default for the FVElementGeometry vector
SET_TYPE_PROP(BoxModel, FVGridGeometry, BoxFVGridGeometry<TypeTag, GET_PROP_VALUE(TypeTag, EnableFVGridGeometryCache)>);
//! Set the default for the FVElementGeometry vector
SET_TYPE_PROP(BoxModel, FVElementGeometry, BoxFVElementGeometry<TypeTag, GET_PROP_VALUE(TypeTag, EnableFVGridGeometryCache)>);
//! The sub control volume
SET_PROP(BoxModel, SubControlVolume)
{
private:
using GridView = typename GET_PROP_TYPE(TypeTag, GridView);
using Scalar = typename GridView::ctype;
static const int dim = GridView::dimension;
static const int dimWorld = GridView::dimensionworld;
using ScvGeometry = Dune::MultiLinearGeometry<Scalar, dim, dimWorld>;
using IndexType = typename GridView::IndexSet::IndexType;
public:
using type = BoxSubControlVolume<ScvGeometry, IndexType>;
};
SET_PROP(BoxModel, SubControlVolumeFace)
{
private:
using GridView = typename GET_PROP_TYPE(TypeTag, GridView);
using Scalar = typename GridView::ctype;
static const int dim = GridView::dimension;
static const int dimWorld = GridView::dimensionworld;
using ScvfGeometry = Dune::MultiLinearGeometry<Scalar, dim-1, dimWorld>;
using IndexType = typename GridView::IndexSet::IndexType;
public:
using type = BoxSubControlVolumeFace<ScvfGeometry, IndexType>;
};
//! Set the default for the ElementBoundaryTypes
SET_TYPE_PROP(BoxModel, ElementBoundaryTypes, BoxElementBoundaryTypes<TypeTag>);
//! The global volume variables vector class
SET_TYPE_PROP(BoxModel, GlobalVolumeVariables, BoxGlobalVolumeVariables<TypeTag, GET_PROP_VALUE(TypeTag, EnableGlobalVolumeVariablesCache)>);
//! The element volume variables vector class
SET_TYPE_PROP(BoxModel, ElementVolumeVariables, BoxElementVolumeVariables<TypeTag, GET_PROP_VALUE(TypeTag, EnableGlobalVolumeVariablesCache)>);
//! The global flux variables cache vector class
SET_TYPE_PROP(BoxModel, GlobalFluxVariablesCache, BoxGlobalFluxVariablesCache<TypeTag, GET_PROP_VALUE(TypeTag, EnableGlobalFluxVariablesCache)>);
//! The local flux variables cache vector class
SET_TYPE_PROP(BoxModel, ElementFluxVariablesCache, BoxElementFluxVariablesCache<TypeTag, GET_PROP_VALUE(TypeTag, EnableGlobalFluxVariablesCache)>);
//! Set the BaseLocalResidual to BoxLocalResidual
SET_TYPE_PROP(BoxModel, BaseLocalResidual, BoxLocalResidual<TypeTag>);
} // namespace Properties
} // namespace Dumux
#endif
......@@ -26,7 +26,6 @@
#define DUMUX_CC_CONNECTIVITY_MAP_HH
#include <vector>
#include <dumux/implicit/properties.hh>
namespace Dumux
{
......
......@@ -23,9 +23,6 @@
#ifndef DUMUX_DISCRETIZATION_CC_GLOBAL_VOLUMEVARIABLES_HH
#define DUMUX_DISCRETIZATION_CC_GLOBAL_VOLUMEVARIABLES_HH
#include <dumux/implicit/properties.hh>
#include <dumux/porousmediumflow/compositional/primaryvariableswitch.hh>
namespace Dumux
{
......
......@@ -24,6 +24,7 @@
#ifndef DUMUX_CC_MPFA_CONNECTIVITY_MAP_HH
#define DUMUX_CC_MPFA_CONNECTIVITY_MAP_HH
#include <dumux/discretization/cellcentered/mpfa/methods.hh>
#include <dumux/discretization/cellcentered/connectivitymap.hh>
#include <dumux/discretization/cellcentered/mpfa/generalconnectivitymap.hh>
......
......@@ -25,8 +25,6 @@
#ifndef DUMUX_DISCRETIZATION_CC_MPFA_DARCYS_LAW_HH
#define DUMUX_DISCRETIZATION_CC_MPFA_DARCYS_LAW_HH
#include <dumux/implicit/cellcentered/mpfa/properties.hh>