Commit 47f93884 authored by Sina Ackermann's avatar Sina Ackermann Committed by Simon Emmert

[doxygen] Adapt documentation for 2p, 2p1c, 2p2c, 2pnc, 2pncmin models

parent 55a2be36
......@@ -21,6 +21,7 @@
* \ingroup TwoPModel
* \brief copydoc Dumux::BoxMaterialInterfaceParams
*/
#ifndef DUMUX_2P_BOX_MATERIAL_INTERFACE_PARAMS_HH
#define DUMUX_2P_BOX_MATERIAL_INTERFACE_PARAMS_HH
......@@ -35,9 +36,11 @@ namespace Dumux {
* \ingroup TwoPModel
* \brief Class that determines the material with the lowest capillary
* pressure (under fully water-saturated conditions) around the nodes
* of a grid. These parameters are then associated with the global degree
* of freedom. On the basis of these parameters, the saturations in the
* remaining sub-control volumes connected to the vertex can be reconstructed.
* of a grid.
*
* These parameters are then associated with the global degree
* of freedom. On the basis of these parameters, the saturations in the
* remaining sub-control volumes connected to the vertex can be reconstructed.
*/
template<class SpatialParams>
class BoxMaterialInterfaceParams
......@@ -46,7 +49,7 @@ public:
using MaterialLawParams = typename SpatialParams::MaterialLaw::Params;
/*!
* \brief Update the scv -> dofparameter map
* \brief Updates the scv -> dofparameter map
*
* \param fvGridGeometry The finite volume grid geometry
* \param spatialParams Class encapsulating the spatial parameters
......@@ -104,12 +107,12 @@ public:
}
}
//! Return if this scv is connected to a material interface
//! Returns if this scv is connected to a material interface
template<class Scv>
bool isOnMaterialInterface(const Scv& scv) const
{ assert(isUpdated_); return isOnMaterialInterface_[scv.dofIndex()]; }
//! Return the material parameters associated with the dof
//! Returns the material parameters associated with the dof
template<class Scv>
const MaterialLawParams& getDofParams(const Scv& scv) const
{ assert(isUpdated_); return *(dofParams_[scv.dofIndex()]); }
......@@ -120,6 +123,6 @@ private:
std::vector<const MaterialLawParams*> dofParams_;
};
}
} // end namespace Dumux
#endif
......@@ -16,12 +16,12 @@
* 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
* \ingroup TwoPModel
* \brief Defines an enumeration for the formulations accepted by the two-phase model.
*/
#ifndef DUMUX_2P_FORMULATION_INDICES_HH
#define DUMUX_2P_FORMULATION_INDICES_HH
......@@ -37,6 +37,6 @@ enum class TwoPFormulation
p1s0 //!< first phase saturation and second phase pressure as primary variables
};
} // namespace Dumux
} // end namespace Dumux
#endif
......@@ -19,7 +19,7 @@
/*!
* \file
* \ingroup TwoPModel
* \brief Class defining a standard, saturation dependent indicator for grid adaptation
* \brief Class defining a standard, saturation dependent indicator for grid adaptation.
*/
#ifndef DUMUX_TWOP_ADAPTION_INDICATOR_HH
......@@ -36,8 +36,9 @@
namespace Dumux {
/*!\ingroup TwoPModel
* \brief Class defining a standard, saturation dependent indicator for grid adaptation
/*!
* \ingroup TwoPModel
* \brief Class defining a standard, saturation dependent indicator for grid adaptation.
*/
template<class TypeTag>
class TwoPGridAdaptIndicator
......@@ -52,7 +53,8 @@ class TwoPGridAdaptIndicator
enum { saturationIdx = Indices::saturationIdx };
public:
/*! \brief The Constructor
/*!
* \brief The Constructor
*
* \param fvGridGeometry The finite volume grid geometry
* \param paramGroup The parameter group in which to look for runtime parameters first (default is "")
......@@ -115,7 +117,7 @@ public:
Scalar refineTol = 0.05,
Scalar coarsenTol = 0.001)
{
//! reset the indicator to a state that returns false for all elements
//! Reset the indicator to a state that returns false for all elements
refineBound_ = std::numeric_limits<Scalar>::max();
coarsenBound_ = std::numeric_limits<Scalar>::lowest();
maxSaturationDelta_.assign(fvGridGeometry_->gridView().size(0), 0.0);
......@@ -124,32 +126,32 @@ public:
if (minLevel_ >= maxLevel_)
return;
//! check for inadmissible tolerance combination
//! Check for inadmissible tolerance combination
if (coarsenTol > refineTol)
DUNE_THROW(Dune::InvalidStateException, "Refine tolerance must be higher than coarsen tolerance");
//! variables to hold the max/mon saturation values on the leaf
//! Variables to hold the max/mon saturation values on the leaf
Scalar globalMax = std::numeric_limits<Scalar>::lowest();
Scalar globalMin = std::numeric_limits<Scalar>::max();
//! Calculate minimum and maximum saturation
for (const auto& element : elements(fvGridGeometry_->gridView()))
{
//! index of the current leaf-element
//! Index of the current leaf-element
const auto globalIdxI = fvGridGeometry_->elementMapper().index(element);
//! obtain the saturation at the center of the element
//! Obtain the saturation at the center of the element
const auto geometry = element.geometry();
const auto elemSol = elementSolution(element, sol, *fvGridGeometry_);
const Scalar satI = evalSolution(element, geometry, *fvGridGeometry_, elemSol, geometry.center())[saturationIdx];
//! maybe update the global minimum/maximum
//! Maybe update the global minimum/maximum
using std::min;
using std::max;
globalMin = min(satI, globalMin);
globalMax = max(satI, globalMax);
//! calculate maximum delta in saturation for this cell
//! Calculate maximum delta in saturation for this cell
for (const auto& intersection : intersections(fvGridGeometry_->gridView(), element))
{
//! Only consider internal intersections
......@@ -162,7 +164,7 @@ public:
//! Visit intersection only once
if (element.level() > outside.level() || (element.level() == outside.level() && globalIdxI < globalIdxJ))
{
//! obtain saturation in the neighbor
//! Obtain saturation in the neighbor
const auto outsideGeometry = outside.geometry();
const auto elemSolJ = elementSolution(outside, sol, *fvGridGeometry_);
const Scalar satJ = evalSolution(outside, outsideGeometry, *fvGridGeometry_, elemSolJ, outsideGeometry.center())[saturationIdx];
......@@ -176,10 +178,10 @@ public:
}
}
//! compute the maximum delta in saturation
//! Compute the maximum delta in saturation
const auto globalDelta = globalMax - globalMin;
//! compute the refinement/coarsening bounds
//! Compute the refinement/coarsening bounds
refineBound_ = refineTol*globalDelta;
coarsenBound_ = coarsenTol*globalDelta;
......@@ -204,13 +206,14 @@ public:
checkNeighborsRefine_(element);
}
/*! \brief function call operator to return mark
/*!
* \brief function call operator to return mark
*
* \return 1 if an element should be refined
* -1 if an element should be coarsened
* 0 otherwise
* \return 1 if an element should be refined
* -1 if an element should be coarsened
* 0 otherwise
*
* \param element A grid element
* \param element A grid element
*/
int operator() (const Element& element) const
{
......@@ -232,9 +235,9 @@ private:
/*!
* \brief Method ensuring the refinement ratio of 2:1
*
* For any given element, a loop over the neighbors checks if the
* entities refinement would require that any of the neighbors has
* to be refined, too. This is done recursively over all levels of the grid.
* For any given element, a loop over the neighbors checks if the
* entities refinement would require that any of the neighbors has
* to be refined, too. This is done recursively over all levels of the grid.
*
* \param element Element of interest that is to be refined
* \param level level of the refined element: it is at least 1
......
......@@ -21,6 +21,7 @@
* \ingroup TwoPModel
* \brief Performs the transfer of data on a grid from before to after adaptation.
*/
#ifndef DUMUX_TWOP_GRIDDATA_TRANSFER_HH
#define DUMUX_TWOP_GRIDDATA_TRANSFER_HH
......@@ -104,12 +105,13 @@ class TwoPGridDataTransfer : public GridDataTransfer
static_assert(formulation == p0s1 || formulation == p1s0, "Chosen formulation not known to the TwoPGridDataTransfer");
public:
/*! \brief Constructor
/*!
* \brief Constructor
*
* \param problem The DuMuX problem to be solved
* \param fvGridGeometry The finite volume grid geometry
* \param gridVariables The secondary variables on the grid
* \param sol The solution (primary variables) on the grid
* \param problem The DuMuX problem to be solved
* \param fvGridGeometry The finite volume grid geometry
* \param gridVariables The secondary variables on the grid
* \param sol The solution (primary variables) on the grid
*/
TwoPGridDataTransfer(std::shared_ptr<const Problem> problem,
std::shared_ptr<FVGridGeometry> fvGridGeometry,
......@@ -123,12 +125,13 @@ public:
, adaptionMap_(fvGridGeometry->gridView().grid(), 0)
{}
/*! \brief Stores primary variables and additional data
/*!
* \brief Stores primary variables and additional data
*
* To reconstruct the solution in father elements, problem properties might
* need to be accessed. From upper level on downwards, the old solution is stored
* into a container object, before the grid is adapted. Father elements hold averaged
* information from the son cells for the case of the sons being coarsened.
* To reconstruct the solution in father elements, problem properties might
* need to be accessed. From upper level on downwards, the old solution is stored
* into a container object, before the grid is adapted. Father elements hold averaged
* information from the son cells for the case of the sons being coarsened.
*/
void store() override
{
......@@ -185,15 +188,16 @@ public:
}
}
/*! \brief Reconstruct missing primary variables (where elements are created/deleted)
/*!
* \brief Reconstruct missing primary variables (where elements are created/deleted)
*
* To reconstruct the solution in father elements, problem properties might
* need to be accessed.
* Starting from the lowest level, the old solution is mapped on the new grid:
* Where coarsened, new cells get information from old father element.
* Where refined, a new solution is reconstructed from the old father cell,
* and then a new son is created. That is then stored into the general data
* structure (AdaptedValues).
* To reconstruct the solution in father elements, problem properties might
* need to be accessed.
* Starting from the lowest level, the old solution is mapped on the new grid:
* Where coarsened, new cells get information from old father element.
* Where refined, a new solution is reconstructed from the old father cell,
* and then a new son is created. That is then stored into the general data
* structure (AdaptedValues).
*/
void reconstruct() override
{
......@@ -387,14 +391,15 @@ public:
private:
/*! \brief Stores sons entries into father element for averaging
/*!
* \brief Stores sons entries into father element for averaging
*
* Sum up the adaptedValues (sons values) into father element. We store from leaf
* upwards, so sons are stored first, then cells on the next leaf (=fathers)
* can be averaged.
* Sum up the adaptedValues (sons values) into father element. We store from leaf
* upwards, so sons are stored first, then cells on the next leaf (=fathers)
* can be averaged.
*
* \param adaptedValues Container for model-specific values to be adapted
* \param adaptedValuesFather Values to be adapted of father cell
* \param adaptedValues Container for model-specific values to be adapted
* \param adaptedValuesFather Values to be adapted of father cell
*/
static void storeAdaptionValues(AdaptedValues& adaptedValues,
AdaptedValues& adaptedValuesFather)
......
......@@ -22,6 +22,7 @@
* \brief Element-wise calculation of the residual and its derivatives
* for a two-phase, incompressible test problem.
*/
#ifndef DUMUX_2P_INCOMPRESSIBLE_TEST_LOCAL_RESIDUAL_HH
#define DUMUX_2P_INCOMPRESSIBLE_TEST_LOCAL_RESIDUAL_HH
......@@ -73,7 +74,7 @@ public:
using ParentType::ParentType;
/*!
* \brief Add storage derivatives for wetting and non-wetting phase
* \brief Adds storage derivatives for wetting and non-wetting phase
*
* Compute storage derivatives for the wetting and the non-wetting phase with respect to \f$p_w\f$
* and \f$S_n\f$.
......@@ -116,7 +117,7 @@ public:
}
/*!
* \brief Add source derivatives for wetting and non-wetting phase
* \brief Adds source derivatives for wetting and non-wetting phase.
*
* \param partialDerivatives The partial derivatives
* \param problem The problem
......@@ -135,7 +136,7 @@ public:
{ /* TODO maybe forward to problem for the user to implement the source derivatives?*/ }
/*!
* \brief Add flux derivatives for wetting and non-wetting phase for cell-centered FVM using TPFA
* \brief Adds flux derivatives for wetting and non-wetting phase for cell-centered FVM using TPFA
*
* Compute derivatives for the wetting and the non-wetting phase flux with respect to \f$p_w\f$
* and \f$S_n\f$.
......@@ -254,7 +255,7 @@ public:
}
/*!
* \brief Add flux derivatives for wetting and non-wetting phase for box method
* \brief Adds flux derivatives for wetting and non-wetting phase for box method
*
* Compute derivatives for the wetting and the non-wetting phase flux with respect to \f$p_w\f$
* and \f$S_n\f$.
......@@ -414,7 +415,7 @@ public:
}
/*!
* \brief Add cell-centered Dirichlet flux derivatives for wetting and non-wetting phase
* \brief Adds cell-centered Dirichlet flux derivatives for wetting and non-wetting phase
*
* Compute derivatives for the wetting and the non-wetting phase flux with respect to \f$p_w\f$
* and \f$S_n\f$.
......@@ -496,7 +497,7 @@ public:
}
/*!
* \brief Add Robin flux derivatives for wetting and non-wetting phase
* \brief Adds Robin flux derivatives for wetting and non-wetting phase
*
* \param derivativeMatrices The matrices containing the derivatives
* \param problem The problem
......
......@@ -16,12 +16,12 @@
* 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
* \ingroup TwoPModel
* \brief Defines the indices required for the two-phase fully implicit model.
*/
#ifndef DUMUX_2P_INDICES_HH
#define DUMUX_2P_INDICES_HH
......
......@@ -19,8 +19,9 @@
/*!
* \file
* \ingroup TwoPModel
* \brief Adds I/O fields specific to the two-phase model
* \brief Adds I/O fields specific to the two-phase model.
*/
#ifndef DUMUX_TWOP_IO_FIELDS_HH
#define DUMUX_TWOP_IO_FIELDS_HH
......@@ -34,7 +35,7 @@ namespace Dumux {
/*!
* \ingroup TwoPModel
* \brief Adds I/O fields specific to the two-phase model
* \brief Adds I/O fields specific to the two-phase model.
*/
class TwoPIOFields
{
......
......@@ -16,14 +16,13 @@
* 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
* \ingroup TwoPModel
* \brief Adaption of the fully implicit scheme to the two-phase flow model.
*
* This model implements two-phase flow of two immiscible fluids
* \f$\alpha \in \{ w, n \}\f$ using a standard multiphase Darcy
* \f$\alpha \in \{ w, n \}\f$ using a standard multi-phase Darcy
* approach as the equation for the conservation of momentum, i.e.
\f[
v_\alpha = - \frac{k_{r\alpha}}{\mu_\alpha} \textbf{K}
......@@ -133,8 +132,7 @@ class TwoPIOFields;
////////////////////////////////
// properties
////////////////////////////////
namespace Properties
{
namespace Properties {
//////////////////////////////////////////////////////////////////
// Type tags
......
......@@ -21,6 +21,7 @@
* \ingroup TwoPModel
* \brief copydoc Dumux::TwoPScvSaturationReconstruction
*/
#ifndef DUMUX_2P_SCV_SATURATION_RECONSTRUCTION_HH
#define DUMUX_2P_SCV_SATURATION_RECONSTRUCTION_HH
......@@ -31,9 +32,11 @@ namespace Dumux {
/*!
* \ingroup TwoPModel
* \brief Class that computes the non-wetting saturation in an scv from the saturation
* at the global degree of freedom. This is only necessary in conjunction with
* the box scheme where the degrees of freedom lie on material interfaces. There
* the non-wetting phase saturation is generally discontinuous.
* at the global degree of freedom.
*
* This is only necessary in conjunction with the box scheme where the degrees of
* freedom lie on material interfaces. There the non-wetting phase saturation is
* generally discontinuous.
*/
template<DiscretizationMethod M, bool enableReconstruction>
class TwoPScvSaturationReconstruction
......@@ -41,6 +44,7 @@ class TwoPScvSaturationReconstruction
public:
/*!
* \brief Compute the non-wetting phase saturation in an scv
*
* \note In the default case, we don't reconstruct anything. We do
* Reconstruction is only done when using the box method
* and enableReconstruction = true.
......@@ -101,6 +105,6 @@ public:
}
};
}
} // end namespace Dumux
#endif
......@@ -21,23 +21,23 @@
* \ingroup SequentialTwoPModel
* \brief Class including data of one grid cell
*/
#ifndef DUMUX_ELEMENTDATA2P_HH
#define DUMUX_ELEMENTDATA2P_HH
#include "properties.hh"
#include "fluxdata.hh"
namespace Dumux
{
namespace Dumux {
template<class TypeTag>
class FluxData2P;
/*!
* \brief Class including data of one grid cell.
* \ingroup SequentialTwoPModel
* \brief Class including data of one grid cell.
*
* The variables of two-phase flow, which are phase pressures and saturations are stored in this class.
*Further, resulting cell values for constitutive relationships like
* Further, resulting cell values for constitutive relationships like
* mobilities, fractional flow functions and capillary pressure are stored.
* Additionally, data assigned to cell-cell interfaces, so-called flux-data are stored.
*
......@@ -48,10 +48,11 @@ template<class TypeTag, bool enableCompressibility>
class CellData2P;
/*!
* \brief Class including the variables and data of discretized data of the constitutive relations for one grid cell.
* \ingroup SequentialTwoPModel
* \brief Class including the variables and data of discretized data of the constitutive relations for one grid cell.
*
* The variables of two-phase flow, which are phase pressures and saturations are stored in this class.
*Further, resulting cell values for constitutive relationships like
* Further, resulting cell values for constitutive relationships like
* mobilities, fractional flow functions and capillary pressure are stored.
* Additionally, data assigned to cell-cell interfaces, so-called flux-data are stored.
*
......
......@@ -21,17 +21,17 @@
* \ingroup SequentialTwoPModel
* \brief Class including the data of a grid cell needed if an adaptive grid is used.
*/
#ifndef DUMUX_ELEMENTDATA2P_ADAPTIVE_HH
#define DUMUX_ELEMENTDATA2P_ADAPTIVE_HH
#include <dune/grid/utility/persistentcontainer.hh>
#include "celldata.hh"
namespace Dumux
{
namespace Dumux {
/*!
* \brief Class including the data of a grid cell needed if an adaptive grid is used.
* \ingroup SequentialTwoPModel
* \brief Class including the data of a grid cell needed if an adaptive grid is used.
*
* The class provides model-specific functions needed to adapt the stored cell data to a new (adapted) grid.
* Additionally, it provides the storage-infrastructure for explicit front tracking.
......
......@@ -19,8 +19,9 @@
/*!
* \file
* \ingroup SequentialTwoPModel
* \brief Finite Volume discretization of a two-phase flow pressure equation.
* \brief Finite volume discretization of a two-phase flow pressure equation.
*/
#ifndef DUMUX_FVPRESSURE2P_ADAPTIVE_HH
#define DUMUX_FVPRESSURE2P_ADAPTIVE_HH
......@@ -36,8 +37,8 @@
namespace Dumux
{
/*!
* \brief Finite Volume discretization of a two-phase flow pressure equation of the sequential IMPES model.
* \ingroup FVPressure2p
* \ingroup SequentialTwoPModel
* \brief Finite volume discretization of a two-phase flow pressure equation of the sequential IMPES model.
*
* Details see FVPressure2P
*
......@@ -206,7 +207,7 @@ public:
}
/*!
* \brief Constructs a FVPressure2PAdaptive object
* \brief Constructs a FVPressure2PAdaptive object
*
* \param problem A problem class object
*/
......@@ -266,7 +267,7 @@ void FVPressure2PAdaptive<TypeTag>::getFlux(EntryType& entry, const Intersection
{
ParentType::getFlux(entry, intersection, cellData, first);
//add the entry only once in case the VisitFacesOnlyOnce option is enabled!!!
// add the entry only once in case the VisitFacesOnlyOnce option is enabled!!!
if (GET_PROP_VALUE(TypeTag, VisitFacesOnlyOnce) && elementI.level() < elementJ.level())
{
entry = 0.;
......@@ -298,10 +299,10 @@ void FVPressure2PAdaptive<TypeTag>::getFlux(EntryType& entry, const Intersection
Scalar pcI = cellData.capillaryPressure();
Scalar pcJ = cellDataJ.capillaryPressure();
//get face index
// get face index
int isIndexI = intersection.indexInInside();
//get face normal
// get face normal
const Dune::FieldVector<Scalar, dim>& unitOuterNormal = intersection.centerUnitOuterNormal();
// get face area
......@@ -413,7 +414,7 @@ void FVPressure2PAdaptive<TypeTag>::getFlux(EntryType& entry, const Intersection
Scalar potentialWIK = 0;
Scalar potentialNwIK = 0;
//if we are at the very first iteration we can't calculate phase potentials
// if we are at the very first iteration we can't calculate phase potentials
if (!first)
{
// potentials from previous time step no available.
......@@ -460,7 +461,7 @@ void FVPressure2PAdaptive<TypeTag>::getFlux(EntryType& entry, const Intersection
}
}
//do the upwinding of the mobility depending on the phase potentials
// do the upwinding of the mobility depending on the phase potentials
Scalar lambdaWIJ = (potentialWIJ > 0.) ? lambdaWI : lambdaWJ;
lambdaWIJ = (Dune::FloatCmp::eq<Scalar, Dune::FloatCmp::absolute>(potentialWIJ, 0.0, 1.0e-30)) ? 0.5 * (lambdaWI + lambdaWJ) : lambdaWIJ;
Scalar lambdaNwIJ = (potentialNwIJ > 0) ? lambdaNwI : lambdaNwJ;
......@@ -499,20 +500,20 @@ void FVPressure2PAdaptive<TypeTag>::getFlux(EntryType& entry, const Intersection
}
}
//write hanging-node-specific stuff directly into matrix and rhs!
// write hanging-node-specific stuff directly into matrix and rhs!
this->f_[globalIdxI] -= entry[rhs];
this->f_[globalIdxJ] += entry[rhs];
// set diagonal entry
this->A_[globalIdxI][globalIdxI] += entry[matrix];
//set off-diagonal
// set off-diagonal
this->A_[globalIdxI][globalIdxJ] -= entry[matrix];
// set entry for cell J
this->A_[globalIdxJ][globalIdxI] -= entry[matrix];
this->A_[globalIdxJ][globalIdxJ] += entry[matrix];
//set entry to zero -> matrix already written!
// set entry to zero -> matrix already written!
entry = 0.;
// std::cout<<"finished hanging node!\n";
......@@ -525,5 +526,5 @@ void FVPressure2PAdaptive<TypeTag>::getFlux(EntryType& entry, const Intersection
return;
}
}
} // end namespace Dumux
#endif
......@@ -29,19 +29,17 @@
#include <dumux/common/properties/propertysystemmacros.hh>
#include <dumux/porousmediumflow/2p/sequential/diffusion/properties.hh>
namespace Dumux
{
namespace Dumux {
////////////////////////////////
// forward declarations
// Forward declarations
////////////////////////////////
////////////////////////////////
// properties
// Properties
////////////////////////////////
namespace Properties
{
namespace Properties {
//////////////////////////////////////////////////////////////////
// Type tags
//////////////////////////////////////////////////////////////////
......@@ -53,16 +51,14 @@ NEW_TYPE_TAG(FVPressureTwoP, INHERITS_FROM(PressureTwoP));
// Property tags
//////////////////////////////////////////////////////////////////
}
}
} // end namespace Properties
} // end namespace Dumux
#include "velocity.hh"
#include "pressure.hh"
namespace Dumux
{
namespace Properties
{
namespace Dumux {
namespace Properties {
//////////////////////////////////////////////////////////////////
// Properties
//////////////////////////////////////////////////////////////////
......@@ -73,8 +69,7 @@ SET_TYPE_PROP(FVPressureTwoP, PressureModel, FVPressure2P<TypeTag>);
//! Allow assembling algorithm for the pressure matrix to assemble only from one side of a cell-cell interface
SET_BOOL_PROP(FVPressureTwoP, VisitFacesOnlyOnce, true);
}
}
} // end namespace Properties
} // end namespace Dumux
#endif
......@@ -28,19 +28,17 @@
//Dumux-includes
#include <dumux/porousmediumflow/2p/sequential/diffusion/properties.hh>
namespace Dumux
{
namespace Dumux {
////////////////////////////////
// forward declarations
// Forward declarations
////////////////////////////////