releases/3.2/a17131_source.html

// -*- 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 3 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/>.   *

 *****************************************************************************/

#ifndef DUMUX_RICHARDS_LOCAL_RESIDUAL_HH

#define DUMUX_RICHARDS_LOCAL_RESIDUAL_HH


#include <dumux/common/properties.hh>

#include <dumux/common/parameters.hh>

#include <dumux/common/typetraits/typetraits.hh>

#include <dumux/discretization/method.hh>

#include <dumux/flux/referencesystemformulation.hh>


namespace Dumux {


template<class TypeTag>

class RichardsLocalResidual : public GetPropType<TypeTag, Properties::BaseLocalResidual>

{

    using Implementation = GetPropType<TypeTag, Properties::LocalResidual>;


    using ParentType = GetPropType<TypeTag, Properties::BaseLocalResidual>;

    using Scalar = GetPropType<TypeTag, Properties::Scalar>;

    using Problem = GetPropType<TypeTag, Properties::Problem>;

    using NumEqVector = GetPropType<TypeTag, Properties::NumEqVector>;

    using VolumeVariables = GetPropType<TypeTag, Properties::VolumeVariables>;

    using ElementVolumeVariables = typename GetPropType<TypeTag, Properties::GridVolumeVariables>::LocalView;

    using FluxVariables = GetPropType<TypeTag, Properties::FluxVariables>;

    using ElementFluxVariablesCache = typename GetPropType<TypeTag, Properties::GridFluxVariablesCache>::LocalView;

    using FVElementGeometry = typename GetPropType<TypeTag, Properties::GridGeometry>::LocalView;

    using SubControlVolume = typename FVElementGeometry::SubControlVolume;

    using SubControlVolumeFace = typename FVElementGeometry::SubControlVolumeFace;

    using GridView = typename GetPropType<TypeTag, Properties::GridGeometry>::GridView;

    using Element = typename GridView::template Codim<0>::Entity;

    using EnergyLocalResidual = GetPropType<TypeTag, Properties::EnergyLocalResidual>;

    using FluidSystem = GetPropType<TypeTag, Properties::FluidSystem>;

    using Indices = typename GetPropType<TypeTag, Properties::ModelTraits>::Indices;

    // first index for the mass balance

    enum { conti0EqIdx = Indices::conti0EqIdx };


    // phase indices

    enum {

           liquidPhaseIdx = FluidSystem::liquidPhaseIdx,

           gasPhaseIdx = FluidSystem::gasPhaseIdx,

           liquidCompIdx = FluidSystem::liquidCompIdx

    };


    static constexpr bool enableWaterDiffusionInAir

        = getPropValue<TypeTag, Properties::EnableWaterDiffusionInAir>();


    struct InvalidElemSol

    {

        template<class Index>

        double operator[] (const Index i) const

        { static_assert(AlwaysFalse<Index>::value, "Solution-dependent material parameters not supported with analytical differentiation"); return 0.0; }

    };


public:

    using ParentType::ParentType;


    NumEqVector computeStorage(const Problem& problem,

                               const SubControlVolume& scv,

                               const VolumeVariables& volVars) const

    {

        // partial time derivative of the phase mass

        NumEqVector storage(0.0);

        storage[conti0EqIdx] = volVars.porosity()

                               * volVars.density(liquidPhaseIdx)

                               * volVars.saturation(liquidPhaseIdx);


        // for extended Richards we consider water in air

        if (enableWaterDiffusionInAir)

            storage[conti0EqIdx] += volVars.porosity()

                                    * volVars.molarDensity(gasPhaseIdx)

                                    * volVars.moleFraction(gasPhaseIdx, liquidCompIdx)

                                    * FluidSystem::molarMass(liquidCompIdx)

                                    * volVars.saturation(gasPhaseIdx);


        EnergyLocalResidual::fluidPhaseStorage(storage, scv, volVars, liquidPhaseIdx);

        EnergyLocalResidual::fluidPhaseStorage(storage, scv, volVars, gasPhaseIdx);

        EnergyLocalResidual::solidPhaseStorage(storage, scv, volVars);


        return storage;

    }


    NumEqVector computeFlux(const Problem& problem,

                            const Element& element,

                            const FVElementGeometry& fvGeometry,

                            const ElementVolumeVariables& elemVolVars,

                            const SubControlVolumeFace& scvf,

                            const ElementFluxVariablesCache& elemFluxVarsCache) const

    {

        FluxVariables fluxVars;

        fluxVars.init(problem, element, fvGeometry, elemVolVars, scvf, elemFluxVarsCache);


        NumEqVector flux(0.0);

        // the physical quantities for which we perform upwinding

        auto upwindTerm = [](const auto& volVars)

                          { return volVars.density(liquidPhaseIdx)*volVars.mobility(liquidPhaseIdx); };


        flux[conti0EqIdx] = fluxVars.advectiveFlux(liquidPhaseIdx, upwindTerm);


        // for extended Richards we consider water vapor diffusion in air

        if (enableWaterDiffusionInAir)

        {

            //check for the reference system and adapt units of the diffusive flux accordingly.

            if (FluxVariables::MolecularDiffusionType::referenceSystemFormulation() == ReferenceSystemFormulation::massAveraged)

                flux[conti0EqIdx] += fluxVars.molecularDiffusionFlux(gasPhaseIdx)[liquidCompIdx];

            else

                flux[conti0EqIdx] += fluxVars.molecularDiffusionFlux(gasPhaseIdx)[liquidCompIdx]*FluidSystem::molarMass(liquidCompIdx);

        }


        EnergyLocalResidual::heatConvectionFlux(flux, fluxVars, liquidPhaseIdx);


        EnergyLocalResidual::heatConductionFlux(flux, fluxVars);


        return flux;

    }


    template<class PartialDerivativeMatrix>

    void addStorageDerivatives(PartialDerivativeMatrix& partialDerivatives,

                               const Problem& problem,

                               const Element& element,

                               const FVElementGeometry& fvGeometry,

                               const VolumeVariables& curVolVars,

                               const SubControlVolume& scv) const

    {

        static_assert(!enableWaterDiffusionInAir,

                      "richards/localresidual.hh: Analytic Jacobian not implemented for the water diffusion in air version!");

        static_assert(!FluidSystem::isCompressible(0),

                      "richards/localresidual.hh: Analytic Jacobian only supports incompressible fluids!");


        const auto poreVolume = scv.volume()*curVolVars.porosity();

        static const auto rho = curVolVars.density(0);


        // material law for pc-sw

        const auto& matParams = problem.spatialParams().materialLawParams(element, scv, InvalidElemSol{});


        // partial derivative of storage term w.r.t. p_w

        // d(Sw*rho*phi*V/dt)/dpw = rho*phi*V/dt*dsw/dpw = rho*phi*V/dt*dsw/dpc*dpc/dpw = -rho*phi*V/dt*dsw/dpc

        using MaterialLaw = typename Problem::SpatialParams::MaterialLaw;

        partialDerivatives[conti0EqIdx][0] += -rho*poreVolume/this->timeLoop().timeStepSize()*MaterialLaw::dsw_dpc(matParams, curVolVars.capillaryPressure());

    }


    template<class PartialDerivativeMatrix>

    void addSourceDerivatives(PartialDerivativeMatrix& partialDerivatives,

                              const Problem& problem,

                              const Element& element,

                              const FVElementGeometry& fvGeometry,

                              const VolumeVariables& curVolVars,

                              const SubControlVolume& scv) const

    { /* TODO maybe forward to problem for the user to implement the source derivatives?*/ }


    template<class PartialDerivativeMatrices, class T = TypeTag>

    std::enable_if_t<GetPropType<T, Properties::GridGeometry>::discMethod == DiscretizationMethod::cctpfa, void>

    addFluxDerivatives(PartialDerivativeMatrices& derivativeMatrices,

                       const Problem& problem,

                       const Element& element,

                       const FVElementGeometry& fvGeometry,

                       const ElementVolumeVariables& curElemVolVars,

                       const ElementFluxVariablesCache& elemFluxVarsCache,

                       const SubControlVolumeFace& scvf) const

    {

        static_assert(!enableWaterDiffusionInAir,

                      "richards/localresidual.hh: Analytic Jacobian not implemented for the water diffusion in air version!");

        static_assert(!FluidSystem::isCompressible(0),

                      "richards/localresidual.hh: Analytic Jacobian only supports incompressible fluids!");

        static_assert(!FluidSystem::viscosityIsConstant(0),

                      "richards/localresidual.hh: Analytic Jacobian only supports fluids with constant viscosity!");


        // get references to the two participating vol vars & parameters

        const auto insideScvIdx = scvf.insideScvIdx();

        const auto outsideScvIdx = scvf.outsideScvIdx();

        const auto outsideElement = fvGeometry.gridGeometry().element(outsideScvIdx);

        const auto& insideScv = fvGeometry.scv(insideScvIdx);

        const auto& outsideScv = fvGeometry.scv(outsideScvIdx);

        const auto& insideVolVars = curElemVolVars[insideScvIdx];

        const auto& outsideVolVars = curElemVolVars[outsideScvIdx];

        const auto& insideMaterialParams = problem.spatialParams().materialLawParams(element, insideScv, InvalidElemSol{});

        const auto& outsideMaterialParams = problem.spatialParams().materialLawParams(outsideElement, outsideScv, InvalidElemSol{});


        // some quantities to be reused (rho & mu are constant and thus equal for all cells)

        static const auto rho = insideVolVars.density(0);

        static const auto mu = insideVolVars.viscosity(0);

        static const auto rho_mu = rho/mu;


        // upwind term

        // evaluate the current wetting phase Darcy flux and resulting upwind weights

        using AdvectionType = GetPropType<TypeTag, Properties::AdvectionType>;

        static const Scalar upwindWeight = getParamFromGroup<Scalar>(problem.paramGroup(), "Flux.UpwindWeight");

        const auto flux = AdvectionType::flux(problem, element, fvGeometry, curElemVolVars, scvf, 0, elemFluxVarsCache);

        const auto insideWeight = std::signbit(flux) ? (1.0 - upwindWeight) : upwindWeight;

        const auto outsideWeight = 1.0 - insideWeight;

        const auto upwindTerm = rho*insideVolVars.mobility(0)*insideWeight + rho*outsideVolVars.mobility(0)*outsideWeight;


        // material law derivatives

        const auto insideSw = insideVolVars.saturation(0);

        const auto outsideSw = outsideVolVars.saturation(0);

        const auto insidePc = insideVolVars.capillaryPressure();

        const auto outsidePc = outsideVolVars.capillaryPressure();

        using MaterialLaw = typename Problem::SpatialParams::MaterialLaw;

        const auto dkrw_dsw_inside = MaterialLaw::dkrw_dsw(insideMaterialParams, insideSw);

        const auto dkrw_dsw_outside = MaterialLaw::dkrw_dsw(outsideMaterialParams, outsideSw);

        const auto dsw_dpw_inside = -MaterialLaw::dsw_dpc(insideMaterialParams, insidePc);

        const auto dsw_dpw_outside = -MaterialLaw::dsw_dpc(outsideMaterialParams, outsidePc);


        // the transmissibility

        const auto tij = elemFluxVarsCache[scvf].advectionTij();


        // get references to the two participating derivative matrices

        auto& dI_dI = derivativeMatrices[insideScvIdx];

        auto& dI_dJ = derivativeMatrices[outsideScvIdx];


        // partial derivative of the wetting phase flux w.r.t. pw

        dI_dI[conti0EqIdx][0] += tij*upwindTerm + rho_mu*flux*insideWeight*dkrw_dsw_inside*dsw_dpw_inside;

        dI_dJ[conti0EqIdx][0] += -tij*upwindTerm + rho_mu*flux*outsideWeight*dkrw_dsw_outside*dsw_dpw_outside;

    }


    template<class JacobianMatrix, class T = TypeTag>

    std::enable_if_t<GetPropType<T, Properties::GridGeometry>::discMethod == DiscretizationMethod::box, void>

    addFluxDerivatives(JacobianMatrix& A,

                       const Problem& problem,

                       const Element& element,

                       const FVElementGeometry& fvGeometry,

                       const ElementVolumeVariables& curElemVolVars,

                       const ElementFluxVariablesCache& elemFluxVarsCache,

                       const SubControlVolumeFace& scvf) const

    {

        static_assert(!enableWaterDiffusionInAir,

                      "richards/localresidual.hh: Analytic Jacobian not implemented for the water diffusion in air version!");

        static_assert(!FluidSystem::isCompressible(0),

                      "richards/localresidual.hh: Analytic Jacobian only supports incompressible fluids!");

        static_assert(!FluidSystem::viscosityIsConstant(0),

                      "richards/localresidual.hh: Analytic Jacobian only supports fluids with constant viscosity!");


        // get references to the two participating vol vars & parameters

        const auto insideScvIdx = scvf.insideScvIdx();

        const auto outsideScvIdx = scvf.outsideScvIdx();

        const auto& insideScv = fvGeometry.scv(insideScvIdx);

        const auto& outsideScv = fvGeometry.scv(outsideScvIdx);

        const auto& insideVolVars = curElemVolVars[insideScvIdx];

        const auto& outsideVolVars = curElemVolVars[outsideScvIdx];

        const auto& insideMaterialParams = problem.spatialParams().materialLawParams(element, insideScv, InvalidElemSol{});

        const auto& outsideMaterialParams = problem.spatialParams().materialLawParams(element, outsideScv, InvalidElemSol{});


        // some quantities to be reused (rho & mu are constant and thus equal for all cells)

        static const auto rho = insideVolVars.density(0);

        static const auto mu = insideVolVars.viscosity(0);

        static const auto rho_mu = rho/mu;


        // upwind term

        // evaluate the current wetting phase Darcy flux and resulting upwind weights

        using AdvectionType = GetPropType<TypeTag, Properties::AdvectionType>;

        static const Scalar upwindWeight = getParamFromGroup<Scalar>(problem.paramGroup(), "Flux.UpwindWeight");

        const auto flux = AdvectionType::flux(problem, element, fvGeometry, curElemVolVars, scvf, 0, elemFluxVarsCache);

        const auto insideWeight = std::signbit(flux) ? (1.0 - upwindWeight) : upwindWeight;

        const auto outsideWeight = 1.0 - insideWeight;

        const auto upwindTerm = rho*insideVolVars.mobility(0)*insideWeight + rho*outsideVolVars.mobility(0)*outsideWeight;


        // material law derivatives

        const auto insideSw = insideVolVars.saturation(0);

        const auto outsideSw = outsideVolVars.saturation(0);

        const auto insidePc = insideVolVars.capillaryPressure();

        const auto outsidePc = outsideVolVars.capillaryPressure();

        using MaterialLaw = typename Problem::SpatialParams::MaterialLaw;

        const auto dkrw_dsw_inside = MaterialLaw::dkrw_dsw(insideMaterialParams, insideSw);

        const auto dkrw_dsw_outside = MaterialLaw::dkrw_dsw(outsideMaterialParams, outsideSw);

        const auto dsw_dpw_inside = -MaterialLaw::dsw_dpc(insideMaterialParams, insidePc);

        const auto dsw_dpw_outside = -MaterialLaw::dsw_dpc(outsideMaterialParams, outsidePc);


        // so far it was the same as for tpfa

        // the transmissibilities (flux derivatives with respect to all pw-dofs on the element)

        const auto ti = AdvectionType::calculateTransmissibilities(

            problem, element, fvGeometry, curElemVolVars, scvf, elemFluxVarsCache[scvf]

        );


        // get the rows of the jacobian matrix for the inside/outside scv

        auto& dI_dJ_inside = A[insideScv.dofIndex()];

        auto& dI_dJ_outside = A[outsideScv.dofIndex()];


        // add the partial derivatives w.r.t all scvs in the element

        for (const auto& scvJ : scvs(fvGeometry))

        {

            // the transmissibily associated with the scvJ

            const auto& tj = ti[scvJ.indexInElement()];

            const auto globalJ = scvJ.dofIndex();


            // partial derivative of the wetting phase flux w.r.t. p_w

            dI_dJ_inside[globalJ][conti0EqIdx][0] += tj*upwindTerm;

            dI_dJ_outside[globalJ][conti0EqIdx][0] += -tj*upwindTerm;

        }


        const auto upwindContributionInside = rho_mu*flux*insideWeight*dkrw_dsw_inside*dsw_dpw_inside;

        const auto upwindContributionOutside = rho_mu*flux*outsideWeight*dkrw_dsw_outside*dsw_dpw_outside;


        // additional constribution of the upwind term only for inside and outside dof

        A[insideScv.dofIndex()][insideScv.dofIndex()][conti0EqIdx][0] += upwindContributionInside;

        A[insideScv.dofIndex()][outsideScv.dofIndex()][conti0EqIdx][0] += upwindContributionOutside;


        A[outsideScv.dofIndex()][insideScv.dofIndex()][conti0EqIdx][0] -= upwindContributionInside;

        A[outsideScv.dofIndex()][outsideScv.dofIndex()][conti0EqIdx][0] -= upwindContributionOutside;

    }


    template<class PartialDerivativeMatrices>

    void addCCDirichletFluxDerivatives(PartialDerivativeMatrices& derivativeMatrices,

                                       const Problem& problem,

                                       const Element& element,

                                       const FVElementGeometry& fvGeometry,

                                       const ElementVolumeVariables& curElemVolVars,

                                       const ElementFluxVariablesCache& elemFluxVarsCache,

                                       const SubControlVolumeFace& scvf) const

    {

        static_assert(!enableWaterDiffusionInAir,

                      "richards/localresidual.hh: Analytic Jacobian not implemented for the water diffusion in air version!");

        static_assert(!FluidSystem::isCompressible(0),

                      "richards/localresidual.hh: Analytic Jacobian only supports incompressible fluids!");

        static_assert(!FluidSystem::viscosityIsConstant(0),

                      "richards/localresidual.hh: Analytic Jacobian only supports fluids with constant viscosity!");


        // get references to the two participating vol vars & parameters

        const auto insideScvIdx = scvf.insideScvIdx();

        const auto& insideScv = fvGeometry.scv(insideScvIdx);

        const auto& insideVolVars = curElemVolVars[insideScvIdx];

        const auto& outsideVolVars = curElemVolVars[scvf.outsideScvIdx()];

        const auto& insideMaterialParams = problem.spatialParams().materialLawParams(element, insideScv, InvalidElemSol{});


        // some quantities to be reused (rho & mu are constant and thus equal for all cells)

        static const auto rho = insideVolVars.density(0);

        static const auto mu = insideVolVars.viscosity(0);

        static const auto rho_mu = rho/mu;


        // upwind term

        // evaluate the current wetting phase Darcy flux and resulting upwind weights

        using AdvectionType = GetPropType<TypeTag, Properties::AdvectionType>;

        static const Scalar upwindWeight = getParamFromGroup<Scalar>(problem.paramGroup(), "Flux.UpwindWeight");

        const auto flux = AdvectionType::flux(problem, element, fvGeometry, curElemVolVars, scvf, 0, elemFluxVarsCache);

        const auto insideWeight = std::signbit(flux) ? (1.0 - upwindWeight) : upwindWeight;

        const auto outsideWeight = 1.0 - insideWeight;

        const auto upwindTerm = rho*insideVolVars.mobility(0)*insideWeight + rho*outsideVolVars.mobility(0)*outsideWeight;


        // material law derivatives

        const auto insideSw = insideVolVars.saturation(0);

        const auto insidePc = insideVolVars.capillaryPressure();

        using MaterialLaw = typename Problem::SpatialParams::MaterialLaw;

        const auto dkrw_dsw_inside = MaterialLaw::dkrw_dsw(insideMaterialParams, insideSw);

        const auto dsw_dpw_inside = -MaterialLaw::dsw_dpc(insideMaterialParams, insidePc);


        // the transmissibility

        const auto tij = elemFluxVarsCache[scvf].advectionTij();


        // partial derivative of the wetting phase flux w.r.t. pw

        derivativeMatrices[insideScvIdx][conti0EqIdx][0] += tij*upwindTerm + rho_mu*flux*insideWeight*dkrw_dsw_inside*dsw_dpw_inside;

    }


    template<class PartialDerivativeMatrices>

    void addRobinFluxDerivatives(PartialDerivativeMatrices& derivativeMatrices,

                                 const Problem& problem,

                                 const Element& element,

                                 const FVElementGeometry& fvGeometry,

                                 const ElementVolumeVariables& curElemVolVars,

                                 const ElementFluxVariablesCache& elemFluxVarsCache,

                                 const SubControlVolumeFace& scvf) const

    { /* TODO maybe forward to problem for the user to implement the Robin derivatives?*/ }


private:

    Implementation *asImp_()

    { return static_cast<Implementation *> (this); }


    const Implementation *asImp_() const

    { return static_cast<const Implementation *> (this); }

};


} // end namespace Dumux


#endif

typetraits.hh

parameters.hh
The infrastructure to retrieve run-time parameters from Dune::ParameterTrees.

method.hh
The available discretization methods in Dumux.

referencesystemformulation.hh
The reference frameworks and formulations available for splitting total fluxes into a advective and d...

Dumux::DiscretizationMethod::box
@ box

Dumux::DiscretizationMethod::cctpfa
@ cctpfa

Dumux::ReferenceSystemFormulation::massAveraged
@ massAveraged

Dumux
Definition: adapt.hh:29

Dumux::GetPropType
typename Properties::Detail::GetPropImpl< TypeTag, Property >::type::type GetPropType
get the type alias defined in the property (equivalent to old macro GET_PROP_TYPE(....
Definition: propertysystem.hh:149

Dumux::AlwaysFalse
Template which always yields a false value.
Definition: typetraits.hh:37

Dumux::RichardsLocalResidual
Element-wise calculation of the Jacobian matrix for problems using the Richards fully implicit models...
Definition: porousmediumflow/richards/localresidual.hh:44

Dumux::RichardsLocalResidual::addSourceDerivatives
void addSourceDerivatives(PartialDerivativeMatrix &partialDerivatives, const Problem &problem, const Element &element, const FVElementGeometry &fvGeometry, const VolumeVariables &curVolVars, const SubControlVolume &scv) const
Adds source derivatives for wetting and non-wetting phase.
Definition: porousmediumflow/richards/localresidual.hh:220

Dumux::RichardsLocalResidual::addCCDirichletFluxDerivatives
void addCCDirichletFluxDerivatives(PartialDerivativeMatrices &derivativeMatrices, const Problem &problem, const Element &element, const FVElementGeometry &fvGeometry, const ElementVolumeVariables &curElemVolVars, const ElementFluxVariablesCache &elemFluxVarsCache, const SubControlVolumeFace &scvf) const
Adds cell-centered Dirichlet flux derivatives for wetting and non-wetting phase.
Definition: porousmediumflow/richards/localresidual.hh:418

Dumux::RichardsLocalResidual::computeStorage
NumEqVector computeStorage(const Problem &problem, const SubControlVolume &scv, const VolumeVariables &volVars) const
Evaluates the rate of change of all conservation quantites (e.g. phase mass) within a sub-control vol...
Definition: porousmediumflow/richards/localresidual.hh:98

Dumux::RichardsLocalResidual::addStorageDerivatives
void addStorageDerivatives(PartialDerivativeMatrix &partialDerivatives, const Problem &problem, const Element &element, const FVElementGeometry &fvGeometry, const VolumeVariables &curVolVars, const SubControlVolume &scv) const
Adds the storage derivative.
Definition: porousmediumflow/richards/localresidual.hh:183

Dumux::RichardsLocalResidual::computeFlux
NumEqVector computeFlux(const Problem &problem, const Element &element, const FVElementGeometry &fvGeometry, const ElementVolumeVariables &elemVolVars, const SubControlVolumeFace &scvf, const ElementFluxVariablesCache &elemFluxVarsCache) const
Evaluates the mass flux over a face of a sub control volume.
Definition: porousmediumflow/richards/localresidual.hh:135

Dumux::RichardsLocalResidual::addFluxDerivatives
std::enable_if_t< GetPropType< T, Properties::GridGeometry >::discMethod==DiscretizationMethod::cctpfa, void > addFluxDerivatives(PartialDerivativeMatrices &derivativeMatrices, const Problem &problem, const Element &element, const FVElementGeometry &fvGeometry, const ElementVolumeVariables &curElemVolVars, const ElementFluxVariablesCache &elemFluxVarsCache, const SubControlVolumeFace &scvf) const
Adds flux derivatives for wetting and non-wetting phase for cell-centered FVM using TPFA.
Definition: porousmediumflow/richards/localresidual.hh:244

Dumux::RichardsLocalResidual::addRobinFluxDerivatives
void addRobinFluxDerivatives(PartialDerivativeMatrices &derivativeMatrices, const Problem &problem, const Element &element, const FVElementGeometry &fvGeometry, const ElementVolumeVariables &curElemVolVars, const ElementFluxVariablesCache &elemFluxVarsCache, const SubControlVolumeFace &scvf) const
Adds Robin flux derivatives for wetting and non-wetting phase.
Definition: porousmediumflow/richards/localresidual.hh:481

Dumux::RichardsLocalResidual::addFluxDerivatives
std::enable_if_t< GetPropType< T, Properties::GridGeometry >::discMethod==DiscretizationMethod::box, void > addFluxDerivatives(JacobianMatrix &A, const Problem &problem, const Element &element, const FVElementGeometry &fvGeometry, const ElementVolumeVariables &curElemVolVars, const ElementFluxVariablesCache &elemFluxVarsCache, const SubControlVolumeFace &scvf) const
Adds flux derivatives for box method.
Definition: porousmediumflow/richards/localresidual.hh:320

properties.hh
Declares all properties used in Dumux.