multidomain/facet/cellcentered/tpfa/fourierslaw.hh

Go to the documentation of this file.

// -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
// vi: set et ts=4 sw=4 sts=4:
//
// SPDX-FileCopyrightInfo: Copyright © DuMux Project contributors, see AUTHORS.md in root folder
// SPDX-License-Identifier: GPL-3.0-or-later
//
#ifndef DUMUX_DISCRETIZATION_CC_TPFA_FACET_COUPLING_FOURIERS_LAW_HH
#define DUMUX_DISCRETIZATION_CC_TPFA_FACET_COUPLING_FOURIERS_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/cctpfa/fourierslaw.hh>
 
namespace Dumux {
 
template<class TypeTag,
         bool isNetwork>
class CCTpfaFacetCouplingFouriersLawImpl;
 
template<class TypeTag>
using CCTpfaFacetCouplingFouriersLaw =
      CCTpfaFacetCouplingFouriersLawImpl< TypeTag, ( int(GetPropType<TypeTag, Properties::GridGeometry>::GridView::dimension)
                                                     < int(GetPropType<TypeTag, Properties::GridGeometry>::GridView::dimensionworld) ) >;
 
template<class TypeTag>
class CCTpfaFacetCouplingFouriersLawImpl<TypeTag, /*isNetwork*/false>
: public FouriersLawImplementation<TypeTag, DiscretizationMethods::CCTpfa>
{
    using Implementation = CCTpfaFacetCouplingFouriersLawImpl<TypeTag, false>;
    using ParentType = FouriersLawImplementation<TypeTag, DiscretizationMethods::CCTpfa>;
 
    using Scalar = GetPropType<TypeTag, Properties::Scalar>;
    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;
 
    class FacetCouplingFouriersLawCache
    {
    public:
        using Filler = typename ParentType::Cache::Filler;
 
        static constexpr int insideTijIdx = 0;
        static constexpr int outsideTijIdx = 1;
        static constexpr int facetTijIdx = 2;
 
        using HeatConductionTransmissibilityContainer = std::array<Scalar, 3>;
 
        template< class Problem, class ElementVolumeVariables >
        void updateHeatConduction(const Problem& problem,
                                  const Element& element,
                                  const FVElementGeometry& fvGeometry,
                                  const ElementVolumeVariables& elemVolVars,
                                  const SubControlVolumeFace &scvf)
        {
            tij_ = Implementation::calculateTransmissibility(problem, element, fvGeometry, elemVolVars, scvf);
        }
 
        Scalar heatConductionTij() const
        { return tij_[insideTijIdx]; }
 
        Scalar heatConductionTijInside() const
        { return tij_[insideTijIdx]; }
 
        Scalar heatConductionTijOutside() const
        { return tij_[outsideTijIdx]; }
 
        Scalar heatConductionTijFacet() const
        { return tij_[facetTijIdx]; }
 
    private:
        HeatConductionTransmissibilityContainer tij_;
    };
 
public:
    using Cache = FacetCouplingFouriersLawCache;
 
    using DiscretizationMethod = DiscretizationMethods::CCTpfa;
    static constexpr DiscretizationMethod discMethod{};
 
    template< class Problem, class ElementVolumeVariables, class ElementFluxVarsCache >
    static Scalar flux(const Problem& problem,
                       const Element& element,
                       const FVElementGeometry& fvGeometry,
                       const ElementVolumeVariables& elemVolVars,
                       const SubControlVolumeFace& scvf,
                       const ElementFluxVarsCache& elemFluxVarsCache)
    {
        if (!problem.couplingManager().isOnInteriorBoundary(element, scvf))
            return ParentType::flux(problem, element, fvGeometry, elemVolVars, scvf, elemFluxVarsCache);
 
        // 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 temperatures
        const Scalar tInside = insideVolVars.temperature();
        const Scalar tFacet = facetVolVars.temperature();
        const Scalar tOutside = outsideVolVars.temperature();
 
        Scalar flux = fluxVarsCache.heatConductionTijInside()*tInside
                      + fluxVarsCache.heatConductionTijFacet()*tFacet;
 
        if (!scvf.boundary())
            flux += fluxVarsCache.heatConductionTijOutside()*tOutside;
        return flux;
    }
 
    // 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::HeatConductionTransmissibilityContainer
    calculateTransmissibility(const Problem& problem,
                              const Element& element,
                              const FVElementGeometry& fvGeometry,
                              const ElementVolumeVariables& elemVolVars,
                              const SubControlVolumeFace& scvf)
    {
        typename Cache::HeatConductionTransmissibilityContainer tij;
        if (!problem.couplingManager().isCoupled(element, scvf))
        {
            tij[Cache::insideTijIdx] = ParentType::calculateTransmissibility(problem, element, fvGeometry, elemVolVars, scvf);
            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.effectiveThermalConductivity(),
                                                      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.effectiveThermalConductivity(),
                                         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 temperatures 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.effectiveThermalConductivity(),
                                                               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>
class CCTpfaFacetCouplingFouriersLawImpl<TypeTag, /*isNetwork*/true>
: public FouriersLawImplementation<TypeTag, DiscretizationMethods::CCTpfa>
{
    using Implementation = CCTpfaFacetCouplingFouriersLawImpl<TypeTag, true>;
    using ParentType = FouriersLawImplementation<TypeTag, DiscretizationMethods::CCTpfa>;
 
    using Scalar = GetPropType<TypeTag, Properties::Scalar>;
    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;
 
    class FacetCouplingFouriersLawCache
    {
    public:
        using Filler = typename ParentType::Cache::Filler;
 
        static constexpr int insideTijIdx = 0;
        static constexpr int facetTijIdx = 1;
 
        using HeatConductionTransmissibilityContainer = std::array<Scalar, 2>;
 
        template< class Problem, class ElementVolumeVariables >
        void updateHeatConduction(const Problem& problem,
                                  const Element& element,
                                  const FVElementGeometry& fvGeometry,
                                  const ElementVolumeVariables& elemVolVars,
                                  const SubControlVolumeFace &scvf)
        {
            tij_ = Implementation::calculateTransmissibility(problem, element, fvGeometry, elemVolVars, scvf);
        }
 
        Scalar heatConductionTij() const
        { return tij_[insideTijIdx]; }
 
        Scalar heatConductionTijInside() const
        { return tij_[insideTijIdx]; }
 
        Scalar heatConductionTijFacet() const
        { return tij_[facetTijIdx]; }
 
    private:
        HeatConductionTransmissibilityContainer tij_;
    };
 
public:
    using Cache = FacetCouplingFouriersLawCache;
 
    using DiscretizationMethod = DiscretizationMethods::CCTpfa;
    static constexpr DiscretizationMethod discMethod{};
 
    template< class Problem, class ElementVolumeVariables, class ElementFluxVarsCache >
    static Scalar flux(const Problem& problem,
                       const Element& element,
                       const FVElementGeometry& fvGeometry,
                       const ElementVolumeVariables& elemVolVars,
                       const SubControlVolumeFace& scvf,
                       const ElementFluxVarsCache& elemFluxVarsCache)
    {
        if (!problem.couplingManager().isOnInteriorBoundary(element, scvf))
            return ParentType::flux(problem, element, fvGeometry, elemVolVars, scvf, elemFluxVarsCache);
 
        // get inside/facet volume variables
        const auto& fluxVarsCache = elemFluxVarsCache[scvf];
        const auto& insideVolVars = elemVolVars[scvf.insideScvIdx()];
        const auto& facetVolVars = problem.couplingManager().getLowDimVolVars(element, scvf);
 
        return fluxVarsCache.heatConductionTijInside()*insideVolVars.temperature()
               + fluxVarsCache.heatConductionTijFacet()*facetVolVars.temperature();
    }
 
    // 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::HeatConductionTransmissibilityContainer
    calculateTransmissibility(const Problem& problem,
                              const Element& element,
                              const FVElementGeometry& fvGeometry,
                              const ElementVolumeVariables& elemVolVars,
                              const SubControlVolumeFace& scvf)
    {
        typename Cache::HeatConductionTransmissibilityContainer tij;
        if (!problem.couplingManager().isCoupled(element, scvf))
        {
            tij[Cache::insideTijIdx] = ParentType::calculateTransmissibility(problem, element, fvGeometry, elemVolVars, scvf);
            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.effectiveThermalConductivity(),
                                                      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.effectiveThermalConductivity(),
                                         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