releases/3.2/a16870_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_DISCRETIZATION_CC_TPFA_FACET_COUPLING_FICKS_LAW_HH

#define DUMUX_DISCRETIZATION_CC_TPFA_FACET_COUPLING_FICKS_LAW_HH


#include <array>

#include <cmath>


#include <dune/common/float_cmp.hh>

#include <dune/common/fvector.hh>


#include <dumux/common/math.hh>

#include <dumux/common/parameters.hh>

#include <dumux/common/properties.hh>


#include <dumux/discretization/method.hh>

#include <dumux/discretization/cellcentered/tpfa/computetransmissibility.hh>


#include <dumux/flux/referencesystemformulation.hh>

#include <dumux/flux/cctpfa/fickslaw.hh>


namespace Dumux {


template<class TypeTag,

         ReferenceSystemFormulation referenceSystem,

         bool isNetwork>

class CCTpfaFacetCouplingFicksLawImpl;


template<class TypeTag, ReferenceSystemFormulation referenceSystem =  ReferenceSystemFormulation::massAveraged>

using CCTpfaFacetCouplingFicksLaw =

      CCTpfaFacetCouplingFicksLawImpl< TypeTag, referenceSystem,

                                       ( int(GetPropType<TypeTag, Properties::GridGeometry>::GridView::dimension)

                                          < int(GetPropType<TypeTag, Properties::GridGeometry>::GridView::dimensionworld) ) >;


template<class TypeTag, ReferenceSystemFormulation referenceSystem>

class CCTpfaFacetCouplingFicksLawImpl<TypeTag, referenceSystem, /*isNetwork*/false>

: public FicksLawImplementation<TypeTag, DiscretizationMethod::cctpfa, referenceSystem>

{

    using Implementation = CCTpfaFacetCouplingFicksLawImpl<TypeTag, referenceSystem, false>;

    using ParentType = FicksLawImplementation<TypeTag, DiscretizationMethod::cctpfa, referenceSystem>;


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

    using FVElementGeometry = typename GridGeometry::LocalView;

    using SubControlVolume = typename GridGeometry::SubControlVolume;

    using SubControlVolumeFace = typename GridGeometry::SubControlVolumeFace;


    using GridView = typename GridGeometry::GridView;

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


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

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

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


    static const int numPhases = ModelTraits::numFluidPhases();

    static const int numComponents = ModelTraits::numFluidComponents();


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

    using ComponentFluxVector = Dune::FieldVector<Scalar, numComponents>;


    class FacetCouplingFicksLawCache

    {

    public:

        using Filler = typename ParentType::Cache::Filler;


        static constexpr int insideTijIdx = 0;

        static constexpr int outsideTijIdx = 1;

        static constexpr int facetTijIdx = 2;


        using DiffusionTransmissibilityContainer = std::array<Scalar, 3>;


        template< class Problem, class ElementVolumeVariables >

        void updateDiffusion(const Problem& problem,

                             const Element& element,

                             const FVElementGeometry& fvGeometry,

                             const ElementVolumeVariables& elemVolVars,

                             const SubControlVolumeFace &scvf,

                             unsigned int phaseIdx,

                             unsigned int compIdx)

        {

            tij_[phaseIdx][compIdx] = Implementation::calculateTransmissibility(problem, element, fvGeometry, elemVolVars, scvf, phaseIdx, compIdx);

        }


        Scalar diffusionTij(unsigned int phaseIdx, unsigned int compIdx) const

        { return tij_[phaseIdx][compIdx][insideTijIdx]; }


        Scalar diffusionTijInside(unsigned int phaseIdx, unsigned int compIdx) const

        { return tij_[phaseIdx][compIdx][insideTijIdx]; }


        Scalar diffusionTijOutside(unsigned int phaseIdx, unsigned int compIdx) const

        { return tij_[phaseIdx][compIdx][outsideTijIdx]; }


        Scalar diffusionTijFacet(unsigned int phaseIdx, unsigned int compIdx) const

        { return tij_[phaseIdx][compIdx][facetTijIdx]; }


    private:

        std::array< std::array<DiffusionTransmissibilityContainer, numComponents>, numPhases> tij_;

    };


public:

    using Cache = FacetCouplingFicksLawCache;


    static const DiscretizationMethod discMethod = DiscretizationMethod::cctpfa;


    static constexpr ReferenceSystemFormulation referenceSystemFormulation()

    { return referenceSystem; }


    template< class Problem, class ElementVolumeVariables, class ElementFluxVarsCache >

    static ComponentFluxVector flux(const Problem& problem,

                                    const Element& element,

                                    const FVElementGeometry& fvGeometry,

                                    const ElementVolumeVariables& elemVolVars,

                                    const SubControlVolumeFace& scvf,

                                    int phaseIdx,

                                    const ElementFluxVarsCache& elemFluxVarsCache)

    {

        if (!problem.couplingManager().isOnInteriorBoundary(element, scvf))

            return ParentType::flux(problem, element, fvGeometry, elemVolVars, scvf, phaseIdx, elemFluxVarsCache);


        ComponentFluxVector componentFlux(0.0);

        for (int compIdx = 0; compIdx < numComponents; compIdx++)

        {

            if(compIdx == FluidSystem::getMainComponent(phaseIdx))

                continue;


            // get inside/outside volume variables

            const auto& fluxVarsCache = elemFluxVarsCache[scvf];

            const auto& insideVolVars = elemVolVars[scvf.insideScvIdx()];

            const auto& facetVolVars = problem.couplingManager().getLowDimVolVars(element, scvf);

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


            // the inside and outside mass/mole fractions fractions

            const Scalar xInside = massOrMoleFraction(insideVolVars, referenceSystem, phaseIdx, compIdx);

            const Scalar xFacet = massOrMoleFraction(facetVolVars, referenceSystem, phaseIdx, compIdx);

            const Scalar xOutside = massOrMoleFraction(outsideVolVars, referenceSystem, phaseIdx, compIdx);


            const Scalar rhoInside = massOrMolarDensity(insideVolVars, referenceSystem, phaseIdx);

            const Scalar rhoFacet = massOrMolarDensity(facetVolVars, referenceSystem, phaseIdx);

            const Scalar rho = 0.5*(rhoInside + rhoFacet);


            componentFlux[compIdx] = fluxVarsCache.diffusionTijInside(phaseIdx, compIdx)*xInside

                                     + fluxVarsCache.diffusionTijFacet(phaseIdx, compIdx)*xFacet;


            if (!scvf.boundary())

                componentFlux[compIdx] += fluxVarsCache.diffusionTijOutside(phaseIdx, compIdx)*xOutside;

            componentFlux[compIdx] *= rho;


            if (BalanceEqOpts::mainComponentIsBalanced(phaseIdx) && !FluidSystem::isTracerFluidSystem())

                componentFlux[FluidSystem::getMainComponent(phaseIdx)] -= componentFlux[compIdx];

        }


        return componentFlux;

    }


    // The flux variables cache has to be bound to an element prior to flux calculations

    // During the binding, the transmissibility will be computed and stored using the method below.

    template< class Problem, class ElementVolumeVariables >

    static typename Cache::DiffusionTransmissibilityContainer

    calculateTransmissibility(const Problem& problem,

                              const Element& element,

                              const FVElementGeometry& fvGeometry,

                              const ElementVolumeVariables& elemVolVars,

                              const SubControlVolumeFace& scvf,

                              unsigned int phaseIdx, unsigned int compIdx)

    {

        typename Cache::DiffusionTransmissibilityContainer tij;

        if (!problem.couplingManager().isCoupled(element, scvf))

        {

            tij[Cache::insideTijIdx] = ParentType::calculateTransmissibility(problem, element, fvGeometry, elemVolVars, scvf, phaseIdx, compIdx);

            return tij;

        }


        static const Scalar xi = getParamFromGroup<Scalar>(problem.paramGroup(), "FacetCoupling.Xi", 1.0);


        const auto insideScvIdx = scvf.insideScvIdx();

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

        const auto& insideVolVars = elemVolVars[insideScvIdx];

        const auto wIn = scvf.area()*computeTpfaTransmissibility(scvf,

                                                                 insideScv,

                                                                 insideVolVars.effectiveDiffusionCoefficient(phaseIdx, phaseIdx, compIdx),

                                                                 insideVolVars.extrusionFactor());


        // proceed depending on the interior BC types used

        const auto iBcTypes = problem.interiorBoundaryTypes(element, scvf);


        // neumann-coupling

        if (iBcTypes.hasOnlyNeumann())

        {

            const auto& facetVolVars = problem.couplingManager().getLowDimVolVars(element, scvf);

            const auto wFacet = 2.0*scvf.area()*insideVolVars.extrusionFactor()

                                   /facetVolVars.extrusionFactor()

                                   *vtmv(scvf.unitOuterNormal(),

                                         facetVolVars.effectiveDiffusionCoefficient(phaseIdx, phaseIdx, compIdx),

                                         scvf.unitOuterNormal());


            // The fluxes across this face and the outside face can be expressed in matrix form:

            // \f$\mathbf{C} \bar{\mathbf{u}} + \mathbf{D} \mathbf{u} + \mathbf{E} \mathbf{u}_\gamma\f$,

            // where \f$\gamma$\f denotes the domain living on the facets and \f$\bar{\mathbf{u}}$\f are

            // intermediate face unknowns in the matrix domain. Equivalently, flux continuity reads:

            // \f$\mathbf{A} \bar{\mathbf{u}} = \mathbf{B} \mathbf{u} + \mathbf{M} \mathbf{u}_\gamma\f$.

            // Combining the two, we can eliminate the intermediate unknowns and compute the transmissibilities

            // that allow the description of the fluxes as functions of the cell and Dirichlet mass/mole fractions only.

            if (!scvf.boundary())

            {

                const auto outsideScvIdx = scvf.outsideScvIdx();

                const auto& outsideVolVars = elemVolVars[outsideScvIdx];

                const auto wOut = -1.0*scvf.area()*computeTpfaTransmissibility(scvf,

                                                                               fvGeometry.scv(outsideScvIdx),

                                                                               outsideVolVars.effectiveDiffusionCoefficient(phaseIdx, phaseIdx, compIdx),

                                                                               outsideVolVars.extrusionFactor());


                if ( !Dune::FloatCmp::eq(xi, 1.0, 1e-6) )

                {

                    // optimized implementation: factorization obtained using sympy

                    // see CCTpfaFacetCouplingDarcysLaw for more details

                    const Scalar factor = wIn * wFacet / ( wIn * wOut * ( 2.0 * xi - 1.0 ) + wFacet * ( xi * ( wIn + wOut ) + wFacet ) );

                    tij[Cache::insideTijIdx]  = factor * ( wOut * xi + wFacet );

                    tij[Cache::outsideTijIdx] = factor * ( wOut * ( 1.0 - xi ) );

                    tij[Cache::facetTijIdx]   = factor * ( - wOut - wFacet );

                }

                else

                {

                    tij[Cache::insideTijIdx] = wFacet*wIn/(wIn+wFacet);

                    tij[Cache::facetTijIdx] = -tij[Cache::insideTijIdx];

                    tij[Cache::outsideTijIdx] = 0.0;

                }

            }

            else

            {

                tij[Cache::insideTijIdx] = wFacet*wIn/(wIn+wFacet);

                tij[Cache::facetTijIdx] = -tij[Cache::insideTijIdx];

                tij[Cache::outsideTijIdx] = 0.0;

            }

        }

        else if (iBcTypes.hasOnlyDirichlet())

        {

            tij[Cache::insideTijIdx] = wIn;

            tij[Cache::outsideTijIdx] = 0.0;

            tij[Cache::facetTijIdx] = -wIn;

        }

        else

            DUNE_THROW(Dune::NotImplemented, "Interior boundary types other than pure Dirichlet or Neumann");


        return tij;

    }

};


template<class TypeTag, ReferenceSystemFormulation referenceSystem>

class CCTpfaFacetCouplingFicksLawImpl<TypeTag, referenceSystem, /*isNetwork*/true>

: public FicksLawImplementation<TypeTag, DiscretizationMethod::cctpfa, referenceSystem>

{

    using Implementation = CCTpfaFacetCouplingFicksLawImpl<TypeTag, referenceSystem, true>;

    using ParentType = FicksLawImplementation<TypeTag, DiscretizationMethod::cctpfa, referenceSystem>;


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

    using FVElementGeometry = typename GridGeometry::LocalView;

    using SubControlVolume = typename GridGeometry::SubControlVolume;

    using SubControlVolumeFace = typename GridGeometry::SubControlVolumeFace;


    using GridView = typename GridGeometry::GridView;

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


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

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

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


    static const int numPhases = ModelTraits::numFluidPhases();

    static const int numComponents = ModelTraits::numFluidComponents();


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

    using ComponentFluxVector = Dune::FieldVector<Scalar, numComponents>;


    class FacetCouplingFicksLawCache

    {

    public:

        using Filler = typename ParentType::Cache::Filler;


        static constexpr int insideTijIdx = 0;

        static constexpr int facetTijIdx = 1;


        using DiffusionTransmissibilityContainer = std::array<Scalar, 2>;


        template< class Problem, class ElementVolumeVariables >

        void updateDiffusion(const Problem& problem,

                             const Element& element,

                             const FVElementGeometry& fvGeometry,

                             const ElementVolumeVariables& elemVolVars,

                             const SubControlVolumeFace &scvf,

                             unsigned int phaseIdx,

                             unsigned int compIdx)

        {

            tij_[phaseIdx][compIdx] = Implementation::calculateTransmissibility(problem, element, fvGeometry, elemVolVars, scvf, phaseIdx, compIdx);

        }


        Scalar diffusionTij(unsigned int phaseIdx, unsigned int compIdx) const

        { return tij_[phaseIdx][compIdx][insideTijIdx]; }


        Scalar diffusionTijInside(unsigned int phaseIdx, unsigned int compIdx) const

        { return tij_[phaseIdx][compIdx][insideTijIdx]; }


        Scalar diffusionTijFacet(unsigned int phaseIdx, unsigned int compIdx) const

        { return tij_[phaseIdx][compIdx][facetTijIdx]; }


    private:

        std::array< std::array<DiffusionTransmissibilityContainer, numComponents>, numPhases> tij_;

    };


public:

    using Cache = FacetCouplingFicksLawCache;


    static const DiscretizationMethod discMethod = DiscretizationMethod::cctpfa;


    static constexpr ReferenceSystemFormulation referenceSystemFormulation()

    { return referenceSystem; }


    template< class Problem, class ElementVolumeVariables, class ElementFluxVarsCache >

    static ComponentFluxVector flux(const Problem& problem,

                                    const Element& element,

                                    const FVElementGeometry& fvGeometry,

                                    const ElementVolumeVariables& elemVolVars,

                                    const SubControlVolumeFace& scvf,

                                    int phaseIdx,

                                    const ElementFluxVarsCache& elemFluxVarsCache)

    {

        if (!problem.couplingManager().isOnInteriorBoundary(element, scvf))

            return ParentType::flux(problem, element, fvGeometry, elemVolVars, scvf, phaseIdx, elemFluxVarsCache);


        ComponentFluxVector componentFlux(0.0);

        for (int compIdx = 0; compIdx < numComponents; compIdx++)

        {

            if(compIdx == FluidSystem::getMainComponent(phaseIdx))

                continue;


            // get inside/outside volume variables

            const auto& fluxVarsCache = elemFluxVarsCache[scvf];

            const auto& insideVolVars = elemVolVars[scvf.insideScvIdx()];

            const auto& facetVolVars = problem.couplingManager().getLowDimVolVars(element, scvf);


            // the inside and outside mass/mole fractions fractions

            const Scalar xInside = massOrMoleFraction(insideVolVars, referenceSystem, phaseIdx, compIdx);

            const Scalar xFacet = massOrMoleFraction(facetVolVars, referenceSystem, phaseIdx, compIdx);


            const Scalar rhoInside = massOrMolarDensity(insideVolVars, referenceSystem, phaseIdx);

            const Scalar rhoFacet = massOrMolarDensity(facetVolVars, referenceSystem, phaseIdx);

            const Scalar rho = 0.5*(rhoInside + rhoFacet);


            componentFlux[compIdx] = rho*(fluxVarsCache.diffusionTijInside(phaseIdx, compIdx)*xInside

                                          + fluxVarsCache.diffusionTijFacet(phaseIdx, compIdx)*xFacet);


            if (BalanceEqOpts::mainComponentIsBalanced(phaseIdx) && !FluidSystem::isTracerFluidSystem())

                componentFlux[FluidSystem::getMainComponent(phaseIdx)] -= componentFlux[compIdx];

        }


        return componentFlux;

    }


    // The flux variables cache has to be bound to an element prior to flux calculations

    // During the binding, the transmissibility will be computed and stored using the method below.

    template< class Problem, class ElementVolumeVariables >

    static typename Cache::DiffusionTransmissibilityContainer

    calculateTransmissibility(const Problem& problem,

                              const Element& element,

                              const FVElementGeometry& fvGeometry,

                              const ElementVolumeVariables& elemVolVars,

                              const SubControlVolumeFace& scvf,

                              unsigned int phaseIdx, unsigned int compIdx)

    {

        typename Cache::DiffusionTransmissibilityContainer tij;

        if (!problem.couplingManager().isCoupled(element, scvf))

        {

            tij[Cache::insideTijIdx] = ParentType::calculateTransmissibility(problem, element, fvGeometry, elemVolVars, scvf, phaseIdx, compIdx);

            return tij;

        }


        static const Scalar xi = getParamFromGroup<Scalar>(problem.paramGroup(), "FacetCoupling.Xi", 1.0);


        // On surface grids only xi = 1.0 can be used, as the coupling condition

        // for xi != 1.0 does not generalize for surface grids where the normal

        // vectors of the inside/outside elements have different orientations.

        if (Dune::FloatCmp::ne(xi, 1.0, 1e-6))

            DUNE_THROW(Dune::InvalidStateException, "Xi != 1.0 cannot be used on surface grids");


        const auto insideScvIdx = scvf.insideScvIdx();

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

        const auto& insideVolVars = elemVolVars[insideScvIdx];

        const auto wIn = scvf.area()*computeTpfaTransmissibility(scvf,

                                                                 insideScv,

                                                                 insideVolVars.effectiveDiffusionCoefficient(phaseIdx, phaseIdx, compIdx),

                                                                 insideVolVars.extrusionFactor());


        // proceed depending on the interior BC types used

        const auto iBcTypes = problem.interiorBoundaryTypes(element, scvf);


        // neumann-coupling

        if (iBcTypes.hasOnlyNeumann())

        {

            // Here we use the square root of the facet extrusion factor

            // as an approximate average distance from scvf ip to facet center

            using std::sqrt;

            const auto& facetVolVars = problem.couplingManager().getLowDimVolVars(element, scvf);

            const auto wFacet = 2.0*scvf.area()*insideVolVars.extrusionFactor()

                                   /sqrt(facetVolVars.extrusionFactor())

                                   *vtmv(scvf.unitOuterNormal(),

                                         facetVolVars.effectiveDiffusionCoefficient(phaseIdx, phaseIdx, compIdx),

                                         scvf.unitOuterNormal());


            tij[Cache::insideTijIdx] = wFacet*wIn/(wIn+wFacet);

            tij[Cache::facetTijIdx] = -tij[Cache::insideTijIdx];

        }

        else if (iBcTypes.hasOnlyDirichlet())

        {

            tij[Cache::insideTijIdx] = wIn;

            tij[Cache::facetTijIdx] = -wIn;

        }

        else

            DUNE_THROW(Dune::NotImplemented, "Interior boundary types other than pure Dirichlet or Neumann");


        return tij;

    }

};


} // end namespace Dumux


#endif

math.hh
Define some often used mathematical functions.

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
DiscretizationMethod
The available discretization methods in Dumux.
Definition: method.hh:37

Dumux::DiscretizationMethod::cctpfa
@ cctpfa

Dumux::computeTpfaTransmissibility
Tensor::field_type computeTpfaTransmissibility(const SubControlVolumeFace &scvf, const SubControlVolume &scv, const Tensor &T, typename SubControlVolume::Traits::Scalar extrusionFactor)
Free function to evaluate the Tpfa transmissibility associated with the flux (in the form of flux = T...
Definition: tpfa/computetransmissibility.hh:47

Dumux::massOrMoleFraction
VolumeVariables::PrimaryVariables::value_type massOrMoleFraction(const VolumeVariables &volVars, ReferenceSystemFormulation referenceSys, const int phaseIdx, const int compIdx)
returns the mass or mole fraction to be used in Fick's law based on the reference system
Definition: referencesystemformulation.hh:66

Dumux::massOrMolarDensity
VolumeVariables::PrimaryVariables::value_type massOrMolarDensity(const VolumeVariables &volVars, ReferenceSystemFormulation referenceSys, const int phaseIdx)
evaluates the density to be used in Fick's law based on the reference system
Definition: referencesystemformulation.hh:55

Dumux::ReferenceSystemFormulation
ReferenceSystemFormulation
The formulations available for Fick's law related to the reference system.
Definition: referencesystemformulation.hh:45

Dumux::vtmv
Dune::DenseMatrix< MAT >::value_type vtmv(const Dune::DenseVector< V1 > &v1, const Dune::DenseMatrix< MAT > &M, const Dune::DenseVector< V2 > &v2)
Evaluates the scalar product of a vector v2, projected by a matrix M, with a vector v1.
Definition: math.hh:840

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::FicksLawImplementation
forward declaration of the method-specific implemetation
Definition: flux/box/fickslaw.hh:43

Dumux::FicksLawImplementation< TypeTag, DiscretizationMethod::cctpfa, referenceSystem >
Fick's law for cell-centered finite volume schemes with two-point flux approximation.
Definition: flux/cctpfa/fickslaw.hh:51

Dumux::FicksLawImplementation< TypeTag, DiscretizationMethod::cctpfa, referenceSystem >::Cache
TpfaFicksLawCache Cache
state the type for the corresponding cache and its filler
Definition: flux/cctpfa/fickslaw.hh:125

Dumux::CCTpfaFacetCouplingFicksLawImpl
Forward declaration of the implementation.
Definition: multidomain/facet/cellcentered/tpfa/fickslaw.hh:49

Dumux::CCTpfaFacetCouplingFicksLawImpl< TypeTag, referenceSystem, false >
Specialization of CCTpfaFacetCouplingFicksLawImpl for dim=dimWorld.
Definition: multidomain/facet/cellcentered/tpfa/fickslaw.hh:70

Dumux::CCTpfaFacetCouplingFicksLawImpl< TypeTag, referenceSystem, false >::flux
static ComponentFluxVector flux(const Problem &problem, const Element &element, const FVElementGeometry &fvGeometry, const ElementVolumeVariables &elemVolVars, const SubControlVolumeFace &scvf, int phaseIdx, const ElementFluxVarsCache &elemFluxVarsCache)
Compute the diffusive fluxes.
Definition: multidomain/facet/cellcentered/tpfa/fickslaw.hh:160

Dumux::CCTpfaFacetCouplingFicksLawImpl< TypeTag, referenceSystem, false >::calculateTransmissibility
static Cache::DiffusionTransmissibilityContainer calculateTransmissibility(const Problem &problem, const Element &element, const FVElementGeometry &fvGeometry, const ElementVolumeVariables &elemVolVars, const SubControlVolumeFace &scvf, unsigned int phaseIdx, unsigned int compIdx)
Definition: multidomain/facet/cellcentered/tpfa/fickslaw.hh:210

Dumux::CCTpfaFacetCouplingFicksLawImpl< TypeTag, referenceSystem, false >::referenceSystemFormulation
static constexpr ReferenceSystemFormulation referenceSystemFormulation()
Return the reference system.
Definition: multidomain/facet/cellcentered/tpfa/fickslaw.hh:155

Dumux::CCTpfaFacetCouplingFicksLawImpl< TypeTag, referenceSystem, true >
Specialization of CCTpfaFacetCouplingFicksLawImpl for dim<dimWorld.
Definition: multidomain/facet/cellcentered/tpfa/fickslaw.hh:308

Dumux::CCTpfaFacetCouplingFicksLawImpl< TypeTag, referenceSystem, true >::referenceSystemFormulation
static constexpr ReferenceSystemFormulation referenceSystemFormulation()
Return the reference system.
Definition: multidomain/facet/cellcentered/tpfa/fickslaw.hh:388

Dumux::CCTpfaFacetCouplingFicksLawImpl< TypeTag, referenceSystem, true >::calculateTransmissibility
static Cache::DiffusionTransmissibilityContainer calculateTransmissibility(const Problem &problem, const Element &element, const FVElementGeometry &fvGeometry, const ElementVolumeVariables &elemVolVars, const SubControlVolumeFace &scvf, unsigned int phaseIdx, unsigned int compIdx)
Definition: multidomain/facet/cellcentered/tpfa/fickslaw.hh:437

Dumux::CCTpfaFacetCouplingFicksLawImpl< TypeTag, referenceSystem, true >::flux
static ComponentFluxVector flux(const Problem &problem, const Element &element, const FVElementGeometry &fvGeometry, const ElementVolumeVariables &elemVolVars, const SubControlVolumeFace &scvf, int phaseIdx, const ElementFluxVarsCache &elemFluxVarsCache)
Compute the diffusive fluxes.
Definition: multidomain/facet/cellcentered/tpfa/fickslaw.hh:393

properties.hh
Declares all properties used in Dumux.

computetransmissibility.hh
Free functions to evaluate the transmissibilities associated with flux evaluations across sub-control...

fickslaw.hh
Fick's law for cell-centered finite volume schemes with two-point flux approximation.