releases/3.6/a20554_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/extrusion.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, DiscretizationMethods::CCTpfa, referenceSystem>

{

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

    using ParentType = FicksLawImplementation<TypeTag, DiscretizationMethods::CCTpfa, referenceSystem>;


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

    using FVElementGeometry = typename GridGeometry::LocalView;

    using SubControlVolume = typename GridGeometry::SubControlVolume;

    using SubControlVolumeFace = typename GridGeometry::SubControlVolumeFace;

    using Extrusion = Extrusion_t<GridGeometry>;


    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;


    using DiscretizationMethod = DiscretizationMethods::CCTpfa;

    static constexpr DiscretizationMethod discMethod{};


    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 = Extrusion::area(fvGeometry, scvf)

                         *computeTpfaTransmissibility(fvGeometry, 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*Extrusion::area(fvGeometry, scvf)*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*Extrusion::area(fvGeometry, scvf)

                                  *computeTpfaTransmissibility(fvGeometry, 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, DiscretizationMethods::CCTpfa, referenceSystem>

{

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

    using ParentType = FicksLawImplementation<TypeTag, DiscretizationMethods::CCTpfa, referenceSystem>;


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

    using FVElementGeometry = typename GridGeometry::LocalView;

    using SubControlVolume = typename GridGeometry::SubControlVolume;

    using SubControlVolumeFace = typename GridGeometry::SubControlVolumeFace;

    using Extrusion = Extrusion_t<GridGeometry>;


    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;


    using DiscretizationMethod = DiscretizationMethods::CCTpfa;

    static constexpr DiscretizationMethod discMethod{};


    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 = Extrusion::area(fvGeometry, scvf)

                         *computeTpfaTransmissibility(fvGeometry, 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*Extrusion::area(fvGeometry, scvf)*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

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

math.hh
Define some often used mathematical functions.

extrusion.hh
Helper classes to compute the integration elements.

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::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:48

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:863

Dumux
Adaption of the non-isothermal two-phase two-component flow model to problems with CO2.
Definition: adapt.hh:29

Dumux::Extrusion_t
typename Extrusion< T >::type Extrusion_t
Convenience alias for obtaining the extrusion type.
Definition: extrusion.hh:251

Dumux::GetPropType
typename GetProp< TypeTag, Property >::type GetPropType
get the type alias defined in the property
Definition: propertysystem.hh:180

Dumux::DiscretizationMethods::CCTpfa
Definition: method.hh:37

Dumux::FicksLawImplementation
forward declaration of the method-specific implementation
Definition: flux/box/fickslaw.hh:44

Dumux::FicksLawImplementation< TypeTag, DiscretizationMethods::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, DiscretizationMethods::CCTpfa, referenceSystem >::Cache
TpfaFicksLawCache Cache
state the type for the corresponding cache and its filler
Definition: flux/cctpfa/fickslaw.hh:130

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

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

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:163

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:213

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

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

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

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:442

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:398

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.