Commit 921a3b36 authored by Simon Emmert's avatar Simon Emmert

[doxygen] Adapt documentation in 2p2c sequential

parent b9b3d5c6
......@@ -18,7 +18,7 @@
*****************************************************************************/
/*!
* \file
* \ingroup SequentialTwoPModel
* \ingroup SequentialTwoPTwoCModel
* \brief Defines the properties required for the adaptive sequential 2p2c models.
*/
#ifndef DUMUX_2P2CADAPTIVE_PROPERTIES_HH
......@@ -28,8 +28,7 @@
#include <dumux/porousmediumflow/2p2c/sequential/properties.hh>
#include <dumux/porousmediumflow/sequential/cellcentered/mpfa/properties.hh>
namespace Dumux
{
namespace Dumux {
//****** forward declarations ******//
template<class TypeTag>
......@@ -42,8 +41,7 @@ class FV2dTransport2P2CAdaptive;
////////////////////////////////
// properties
////////////////////////////////
namespace Properties
{
namespace Properties {
//////////////////////////////////////////////////////////////////
// Type tags
......@@ -78,6 +76,7 @@ SET_TYPE_PROP(SequentialTwoPTwoCAdaptive, PressureModel, FV2dPressure2P2CAdaptiv
/*!
* \ingroup SequentialTwoPTwoCModel
* \brief Missing indices to the mpfa2p model.
*
* Compositional adaptive models use the 2p implementation with mpfa to
......@@ -96,6 +95,6 @@ struct SequentialTwoPTwoCIndicesAdaptive : public SequentialTwoPTwoCIndices<Type
// \}
}
} // end namespace Dumux
#endif
......@@ -18,7 +18,7 @@
*****************************************************************************/
/*!
* \file
* \ingroup SequentialTwoPModel
* \ingroup SequentialTwoPTwoCModel
* \brief Storage container for discretized data of the constitutive relations for one element
*/
......@@ -30,7 +30,7 @@
namespace Dumux {
/*!
* \ingroup SequentialTwoPModel
* \ingroup SequentialTwoPTwoCModel
* \brief Storage container for discretized data of the constitutive relations for one element
*
* This class stores all cell-centered (FV-Scheme) values for sequential compositional two-phase flow
......@@ -38,7 +38,7 @@ namespace Dumux {
* fluidstate, so the CellData contains the fluidstate object for the current element.
* At the moment, the compositional model does not use fluxVariables that are stored on the interfaces.
*
* @tparam TypeTag The Type Tag
* \tparam TypeTag The Type Tag
*/
template<class TypeTag>
class CellData2P2C
......@@ -111,23 +111,28 @@ public:
/*! \name Acess to primary variables */
//@{
/*! Acess to the phase pressure
* @param phaseIdx index of the Phase
/*!
* \brief Acess to the phase pressure
* \param phaseIdx index of the Phase
*/
Scalar pressure(int phaseIdx)
{
return fluidState_->pressure(phaseIdx);
}
/*! Acess to the phase pressure
* @param phaseIdx index of the Phase
/*!
* \brief Acess to the phase pressure
* \param phaseIdx index of the Phase
*/
const Scalar pressure(int phaseIdx) const
{
return fluidState_->pressure(phaseIdx);
}
/*! Modify the phase pressure
* @param phaseIdx index of the Phase
* @param value Value to be stored
/*!
* \brief Modify the phase pressure
* \param phaseIdx index of the Phase
* \param value Value to be stored
*/
void setPressure(int phaseIdx, Scalar value)
{
......@@ -146,6 +151,7 @@ public:
{
return massConcentration_[compIdx];
}
//! \copydoc CellData2P2C::totalConcentration()
const Scalar massConcentration(int compIdx) const
{
......@@ -155,13 +161,14 @@ public:
/*!
* \brief Sets the total mass concentration of a component \f$\mathrm{[kg/m^3]}\f$.
*
* @param compIdx index of the Component
* @param value Value to be stored
* \param compIdx index of the Component
* \param value Value to be stored
*/
void setTotalConcentration(int compIdx, Scalar value)
{
massConcentration_[compIdx] = value;
}
//! \copydoc CellData2P2C::setTotalConcentration()
void setMassConcentration(int compIdx, Scalar value)
{
......@@ -170,7 +177,7 @@ public:
/*!
* \brief Calculate the total mass concentration of a component \f$\mathrm{[kg/m^3]}\f$
* for a given porosity (within the initialization procedure).
* @param porosity Porosity
* \param porosity Porosity
*/
void calculateMassConcentration(Scalar porosity)
{
......@@ -186,26 +193,28 @@ public:
/*! \name Acess to secondary variables */
//@{
//! Return phase mobilities
/*
/*!
* \brief Return phase mobilities
* @param phaseIdx index of the Phase
*/
const Scalar& mobility(int phaseIdx) const
{
return mobility_[phaseIdx];
}
//! Set phase mobilities
/*
* @param phaseIdx index of the Phase
* @param value Value to be stored
/*!
* \brief Set phase mobilities
* \param phaseIdx index of the Phase
* \param value Value to be stored
*/
void setMobility(int phaseIdx, Scalar value)
{
mobility_[phaseIdx]=value;
}
//! Return the volume error [-].
/** This quantity stands for the deviation of real fluid volume
/*!
* \brief Return the volume error [-].
* This quantity stands for the deviation of real fluid volume
* to available pore space.
* \f$ \epsilon = v_{real} - \phi\f$.
*/
......@@ -213,14 +222,16 @@ public:
{
return volumeError_;
}
//! Return the volume error [-].
const Scalar& volumeError() const
{
return volumeError_;
}
//! Return the error Correction
/** This quantifies the damped error that actually
/*!
* \brief Return the error Correction
* This quantifies the damped error that actually
* entered the pressure equation: Damped Error
* from last time-step times last time step size
*/
......@@ -228,42 +239,46 @@ public:
{
return errorCorrection_;
}
//! Return the error Correction
const Scalar& errorCorrection() const
{
return errorCorrection_;
}
//! Return the derivative of specific volume w.r.t. pressure
/**
/*!
* \brief Return the derivative of specific volume w.r.t. pressure
* For details, see description of FVPressureCompositional<TypeTag>::volumeDerivatives()
*/
Scalar& dv_dp()
{
return dv_dp_;
}
//! Return the derivative of specific volume w.r.t. pressure
const Scalar& dv_dp() const
{
return dv_dp_;
}
//! Return the derivative of spec. volume w.r.t. change of mass
/**
/*!
* \brief Return the derivative of spec. volume w.r.t. change of mass
* For details, see description of FVPressureCompositional<TypeTag>::volumeDerivatives()
* @param compIdx index of the Component
* \param compIdx index of the Component
*/
Scalar& dv(int compIdx)
{
return dv_[compIdx];
}
//! \copydoc dv()
const Scalar& dv(int compIdx) const
{
return dv_[compIdx];
}
//! Return cell perimeter (as weithing function)
/*
/*!
* \brief Return cell perimeter (as weithing function)
* The cell perimeter is used in combination with the face Area as a
* weighting of the volume integral in the pressure equation.
*/
......@@ -346,9 +361,10 @@ public:
return *fluidState_;
}
//! Allows manipulation of the cells fluid state
/** Fluidstate is stored as a pointer, initialized as a null-pointer.
* Enshure that if no FluidState is present, a new one is created.
/*!
* \brief Allows manipulation of the cells fluid state
* Fluidstate is stored as a pointer, initialized as a null-pointer.
* Ensure that if no FluidState is present, a new one is created.
*/
FluidState& manipulateFluidState()
{
......@@ -381,18 +397,21 @@ public:
//!\copydoc wasRefined()
const bool& wasRefined() const
{ return wasRefined_;}
//! Indicates if current cell is the upwind cell for a given interface
/* @param indexInInside Local face index seen from current cell
* @param phaseIdx The index of the phase
/*!
* \brief Indicates if current cell is the upwind cell for a given interface
* \param indexInInside Local face index seen from current cell
* \param phaseIdx The index of the phase
*/
const bool& isUpwindCell(int indexInInside, int phaseIdx) const
{
return fluxData_.isUpwindCell(indexInInside, phaseIdx);
}
//! Specifies if current cell is the upwind cell for a given interface
/* @param indexInInside Local face index seen from current cell
* @param phaseIdx The index of the phase
* @param value Value: true (->outflow) or false (-> inflow)
/*!
* \brief Specifies if current cell is the upwind cell for a given interface
* \param indexInInside Local face index seen from current cell
* \param phaseIdx The index of the phase
* \param value Value: true (->outflow) or false (-> inflow)
*/
void setUpwindCell(int indexInInside, int phaseIdx, bool value)
{
......
......@@ -18,7 +18,7 @@
*****************************************************************************/
/*!
* \file
* \ingroup SequentialTwoPModel
* \ingroup SequentialTwoPTwoCModel
* \brief Class including the variables and data of discretized data of the constitutive relations for one element
*/
#ifndef DUMUX_ELEMENTDATA2P2C_ADAPTIVE_HH
......@@ -32,7 +32,7 @@
namespace Dumux {
/*!
* \ingroup SequentialTwoPModel
* \ingroup SequentialTwoPTwoCModel
* \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.
......@@ -73,8 +73,8 @@ private:
int upwindError_[numPhases];
public:
//! A container for all necessary variables to map an old solution to a new grid
/**
/*!
* \brief A container for all necessary variables to map an old solution to a new grid
* If the primary variables (pressure, total concentrations) are mapped to a new grid,
* the secondary variables can be calulated. For the mapping between sons and father, it
* is in addition necessary to know about how many sons live in each father ("count").
......@@ -115,13 +115,13 @@ public:
upwindError_[i] = 0;
}
//! stores leaf cell primary variables to transfer to new indexing
/**
/*!
* \brief Stores leaf cell primary variables to transfer to new indexing
* Stores values to be adapted from the current CellData objects into
* the adaptation container in order to be mapped on a new grid.
*
* @param adaptedValues Container for model-specific values to be adapted
* @param element The element to be stored
* \param adaptedValues Container for model-specific values to be adapted
* \param element The element to be stored
*/
void storeAdaptionValues(AdaptedValues& adaptedValues, const Element& element)
{
......@@ -137,15 +137,15 @@ public:
adaptedValues.fluxData_=this->fluxData();
}
//! adds cell information to father element for possible averaging / coarsening
/**
/*!
* \brief Adds cell information to father element for possible averaging / coarsening
* 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 fatherElement The element of the father
* \param adaptedValues Container for model-specific values to be adapted
* \param adaptedValuesFather Values to be adapted of father cell
* \param fatherElement The element of the father
*/
static void storeAdaptionValues(AdaptedValues& adaptedValues,
AdaptedValues& adaptedValuesFather,
......@@ -170,16 +170,17 @@ public:
using std::max;
adaptedValuesFather.subdomain = max(adaptedValuesFather.subdomain, adaptedValues.subdomain);
}
//! Set adapted values in CellData
/**
/*!
* \brief Set adapted values in CellData
* This methods stores reconstructed values into the cellData object, by
* this setting a newly mapped solution to the storage container of the
* sequential models.
* In new cells, update estimate does not give meaningful results. We therefore
* copy volume derivatives from old time step, and indicate that those are already availabe.
*
* @param adaptedValues Container for model-specific values to be adapted
* @param element The element where things are stored.
* \param adaptedValues Container for model-specific values to be adapted
* \param element The element where things are stored.
*/
void setAdaptionValues(AdaptedValues& adaptedValues, const Element& element)
{
......@@ -211,16 +212,17 @@ public:
else
this->volumeDerivativesAvailable(false); // recalculate volume derivatives
}
//! Reconstructs sons entries from data of father cell
/**
/*!
* \brief Reconstructs sons entries from data of father cell
* Reconstructs an new solution from a father cell into for a newly
* generated son cell. The new cell is stored into the global
* adaptationMap.
*
* @param adaptationMap Global map storing all values to be adapted
* @param father Entity Pointer to the father cell
* @param son Entity Pointer to the newly created son cell
* @param problem The problem
* \param adaptationMap Global map storing all values to be adapted
* \param father Entity Pointer to the father cell
* \param son Entity Pointer to the newly created son cell
* \param problem The problem
*/
static void reconstructAdaptionValues(Dune::PersistentContainer<Grid, AdaptedValues>& adaptationMap,
const Element& father, const Element& son, const Problem& problem)
......@@ -276,5 +278,5 @@ public:
}
};
}
} // end namespace Dumux
#endif
......@@ -18,10 +18,9 @@
*****************************************************************************/
/*!
* \file
* \ingroup SequentialTwoPModel
* \ingroup SequentialTwoPTwoCModel
* \brief Storage container for discretized data for multi-physics models.
*/
#ifndef DUMUX_ELEMENTDATA2P2C_MULTYPHYSICS_HH
#define DUMUX_ELEMENTDATA2P2C_MULTYPHYSICS_HH
......@@ -29,10 +28,9 @@
#include "properties.hh"
#include "celldata.hh"
namespace Dumux {
/*!
* \ingroup SequentialTwoPModel
* \ingroup SequentialTwoPTwoCModel
* \brief Storage container for discretized data for multiphysics models.
*
* For multi-physics models, we divide the model in separate sub-domains. Being a cell-based
......@@ -40,7 +38,7 @@ namespace Dumux {
* fluidState can be stored in cells being in the simpler subdomain.
* Hence, acess functions either direct to the full fluidstate, or to the simple fluidstate.
*
* @tparam TypeTag The Type Tag
* \tparam TypeTag The Type Tag
*/
template<class TypeTag>
class CellData2P2CMultiPhysics : public CellData2P2C<TypeTag>
......@@ -112,22 +110,28 @@ public:
// functions returning the vectors of secondary variables
//////////////////////////////////////////////////////////////
//! Return subdomain information
/** Acess function to store subdomain information
/*!
* \brief Return subdomain information
*
* Acess function to store subdomain information
*/
int& subdomain()
{
return subdomain_;
}
//! Return subdomain information
/** Acess function to get subdomain information
/*!
* \brief Return subdomain information
*
* Acess function to get subdomain information
*/
const int& subdomain() const
{
return subdomain_;
}
//! Specify subdomain information and fluidStateType
/** This function is only called if
/*!
* \brief Specify subdomain information and fluidStateType
*/
void setSubdomainAndFluidStateType(int index)
{
......@@ -262,12 +266,13 @@ public:
//@}
//! Set a simple fluidstate for a cell in the simple domain
/** Uses a simplified fluidstate with less storage capacity
/*!
* \brief Set a simple fluidstate for a cell in the simple domain
* Uses a simplified fluidstate with less storage capacity
* and functionality.
* Makes shure the fluidStateType_ flag is set appropriately in this
* cell.
* @param simpleFluidState A fluidstate storing a 1p2c mixture
* \param simpleFluidState A fluidstate storing a 1p2c mixture
*/
void setSimpleFluidState(SimpleFluidState& simpleFluidState)
{
......@@ -288,8 +293,11 @@ public:
simpleFluidState_ = std::make_shared<SimpleFluidState>();
return *simpleFluidState_;
}
//! Allows manipulation of the complex fluid state
/** Fluidstate is stored as a pointer, initialized as a null-pointer.
/*!
* \brief Allows manipulation of the complex fluid state
*
* Fluidstate is stored as a pointer, initialized as a null-pointer.
* Enshure that if no FluidState is present, a new one is created.
* Also enshure that we are in the complex subdomain.
*/
......@@ -318,5 +326,5 @@ public:
};
}
} // end namespace Dumux
#endif
......@@ -18,19 +18,17 @@
*****************************************************************************/
/*!
* \file
* \ingroup SequentialTwoPModel
* \ingroup SequentialTwoPTwoCModel
* \brief Class including the variables and data of discretized data of the constitutive relations.
*/
#ifndef DUMUX_FLUXDATA2P2C_HH
#define DUMUX_FLUXDATA2P2C_HH
#include <dumux/porousmediumflow/sequential/properties.hh>
namespace Dumux {
/*!
* \ingroup SequentialTwoPModel
* \ingroup SequentialTwoPTwoCModel
* \brief Class including the variables and data of discretized data of the constitutive relations.
*
* The variables of two-phase flow, which are one pressure and one saturation are stored in this class.
......@@ -38,7 +36,7 @@ namespace Dumux {
* as well as discretized data of constitutive relationships like mobilities, fractional flow functions
* and capillary pressure. Thus, they have to be calculated just once in every time step or every iteration step.
*
* @tparam TypeTag The Type Tag
* \tparam TypeTag The Type Tag
*/
template<class TypeTag>
class FluxData2P2C
......@@ -85,7 +83,8 @@ public:
velocity_[phaseIdx][fIdx] = 0.0;
}
/*! \brief Returns the phase velocity vector at a cell-cell interface
/*!
* \brief Returns the phase velocity vector at a cell-cell interface
*
* \param phaseIdx Index of a fluid phase
* \param indexInInside Index of the cell-cell interface in this cell
......@@ -95,7 +94,8 @@ public:
return velocity_[phaseIdx][indexInInside];
}
/*! \brief Returns the phase velocity vector at a cell-cell interface
/*!
* \brief Returns the phase velocity vector at a cell-cell interface
*
* \param phaseIdx Index of a fluid phase
* \param indexInInside Index of the cell-cell interface in this cell
......@@ -105,7 +105,8 @@ public:
return velocity_[phaseIdx][indexInInside];
}
/*! \brief Sets the phase velocity vector at a cell-cell interface
/*!
* \brief Sets the phase velocity vector at a cell-cell interface
*
* \param phaseIdx Index of a fluid phase
* \param indexInInside Index of the cell-cell interface in this cell
......@@ -116,7 +117,8 @@ public:
velocity_[phaseIdx][indexInInside] = velocity;
}
/*! \brief Returns the total velocity vector at a cell-cell interface
/*!
* \brief Returns the total velocity vector at a cell-cell interface
*
* \param indexInInside Index of the cell-cell interface in this cell
*/
......@@ -126,7 +128,8 @@ public:
+ velocity_[nPhaseIdx][indexInInside];
}
/*! \brief Returns the total velocity vector at a cell-cell interface
/*!
* \brief Returns the total velocity vector at a cell-cell interface
*
* \param indexInInside Index of the cell-cell interface in this cell
*/
......@@ -146,18 +149,23 @@ public:
{
return isUpwindCell_.size();
}
//! functions returning upwind information
/* @param indexInInside The local inside index of the intersection
* @param equationIdx The equation index
/*!
* \brief Functions returning upwind information
*
* \param indexInInside The local inside index of the intersection
* \param equationIdx The equation index
*/
const bool& isUpwindCell(int indexInInside, int equationIdx) const
{
return isUpwindCell_[indexInInside][equationIdx];
}
//! Sets the upwind information
/* @param indexInInside The local inside index of the intersection
* @param equationIdx The equation index
* @value value set true or false
/*!
* \brief Sets the upwind information
*
* \param indexInInside The local inside index of the intersection
* \param equationIdx The equation index
* \param value set true or false
*/
void setUpwindCell(int indexInInside, int equationIdx, bool value)
{
......@@ -173,5 +181,5 @@ public:
};
}
} // end namespace Dumux
#endif
......@@ -16,6 +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 SequentialTwoPTwoCModel
* \brief Finite Volume Diffusion Model
* \author Benjamin Faigle, Bernd Flemisch, Jochen Fritz, Markus Wolff
*/
#ifndef DUMUX_FV2DPRESSURE2P2C_ADAPTIVE_HH
#define DUMUX_FV2DPRESSURE2P2C_ADAPTIVE_HH
......@@ -34,16 +40,12 @@
#include <dumux/common/math.hh>
#include <dumux/io/vtkmultiwriter.hh>
/**
* @file
* @brief Finite Volume Diffusion Model
* @author Benjamin Faigle, Bernd Flemisch, Jochen Fritz, Markus Wolff
*/
namespace Dumux {
namespace Dumux
{
//! The finite volume model for the solution of the compositional pressure equation
/*! \ingroup Adaptive2p2c
/*!
* \ingroup SequentialTwoPTwoCModel
* \brief The finite volume model for the solution of the compositional pressure equation
*
* Provides a Finite Volume implementation for the pressure equation of a compressible
* system with two components. An IMPES-like method is used for the sequential
* solution of the problem. Diffusion is neglected, capillarity can be regarded.
......
......@@ -18,7 +18,7 @@
*****************************************************************************/
/*!
* \file
* \ingroup SequentialTwoPModel
* \ingroup SequentialTwoPTwoCModel
* \brief Finite volume discretization of the component transport equation.
*/
#ifndef DUMUX_FV2DTRANSPORT2P2C_ADAPTIVE_HH
......@@ -35,7 +35,7 @@
namespace Dumux {
/*!
* \ingroup SequentialTwoPModel
* \ingroup SequentialTwoPTwoCModel
* \brief Compositional Transport step in a Finite Volume discretization for a adaptive 2D-grid
*
* The finite volume model for the solution of the transport equation for compositional
......@@ -102,8 +102,9 @@ public:
void getMpfaFlux(Dune::FieldVector<Scalar, 2>&, Dune::FieldVector<Scalar, 2>&,
const IntersectionIterator&, CellData&);
//! Constructs a FV2dTransport2P2CAdaptive object
/*!
* \brief Constructs a FV2dTransport2P2CAdaptive object
*
* The compositional transport scheme can not be applied with a global pressure / total velocity
* formulation. This is a 2D-specific implementation! In case of 3d, use the class
* FV3dTransport2P2CAdaptive
......@@ -128,24 +129,24 @@ protected:
static const int pressureType = GET_PROP_VALUE(TypeTag, PressureFormulation);
};
//! \brief Calculate the update vector and determine timestep size
/*!
* This method calculates the update vector \f$ u \f$ of the discretized equation
* \f[
C^{\kappa , new} = C^{\kappa , old} + u,
* \f]
* where \f$ u = \sum_{\gamma} \boldsymbol{v}_{\alpha} * \varrho_{\alpha} * X^{\kappa}_{\alpha} * \boldsymbol{n} * A_{\gamma} \f$,
* \f$ \boldsymbol{n} \f$ is the face normal and \f$ A_{\gamma} \f$ is the face area of face \f$ \gamma \f$.
* \brief Calculate the update vector and determine timestep size
*
* In addition to the \a update vector, the recommended time step size \a dt is calculated
* employing a CFL condition. This method uses a standard \a Tpfa method for regular fluxes,
* and a \a MPFA can be used near hanging nodes.
* The lengths of the vectors are resized to agree with the current grid resolution.
* This method calculates the update vector \f$ u \f$ of the discretized equation
* \f[
C^{\kappa , new} = C^{\kappa , old} + u,
* \f]
* where \f$ u = \sum_{\gamma} \boldsymbol{v}_{\alpha} * \varrho_{\alpha} * X^{\kappa}_{\alpha} * \boldsymbol{n} * A_{\gamma} \f$,
* \f$ \boldsymbol{n} \f$ is the face normal and \f$ A_{\gamma} \f$ is the face area of face \f$ \gamma \f$.
* In addition to the \a update vector, the recommended time step size \a dt is calculated
* employing a CFL condition. This method uses a standard \a Tpfa method for regular fluxes,
* and a \a MPFA can be used near hanging nodes.
* The lengths of the vectors are resized to agree with the current grid resolution.
*
* \param t Current simulation time \f$\mathrm{[s]}\f$
* \param[out] dt Time step size \f$\mathrm{[s]}\f$
* \param[out] updateVec Update vector, or update estimate for secants, resp. Here in \f$\mathrm{[kg/m^3]}\f$
* \param impet Flag that determines if it is a real impet step or an update estimate for volume derivatives
* \param t Current simulation time \f$\mathrm{[s]}\f$
* \param[out] dt Time step size \f$\mathrm{[s]}\f$
* \param[out] updateVec Update vector, or update estimate for secants, resp. Here in \f$\mathrm{[kg/m^3]}\f$
* \param impet Flag that determines if it is a real impet step or an update estimate for volume derivatives
*/
template<class TypeTag>
void FV2dTransport2P2CAdaptive<TypeTag>::update(const Scalar t, Scalar& dt, TransportSolutionType& updateVec, bool impet)
......@@ -325,8 +326,10 @@ void FV2dTransport2P2CAdaptive<TypeTag>::update(const Scalar t, Scalar& dt, Tran
return;
}
//! Compute flux over an irregular interface using a \a mpfa method
/** A mpfa l-method is applied to calculate fluxes near hanging nodes, using:
/*!
* \brief Compute flux over an irregular interface using a \a mpfa method
*
* A mpfa l-method is applied to calculate fluxes near hanging nodes, using:
* \f[