Class that handles the coupling between three sub-domains in models where the coupling between the two occurs across the facets of the d- and (d-1)- dimensional domains. More...

#include <dumux/multidomain/facet/couplingmanager.hh>

Inheritance diagram for Dumux::FacetCouplingThreeDomainManager< MDTraits, CouplingMapper, bulkDomainId, facetDomainId, edgeDomainId >:

Description

template<class MDTraits, class CouplingMapper, std::size_t bulkDomainId = 0, std::size_t facetDomainId = 1, std::size_t edgeDomainId = 2>
class Dumux::FacetCouplingThreeDomainManager< MDTraits, CouplingMapper, bulkDomainId, facetDomainId, edgeDomainId >

Template Parameters

MDTraits	The multidomain traits containing the types on all sub-domains
CouplingMapper	Class containing maps on the coupling between dofs of different grids
bulkDomainId	The domain id of the d-dimensional bulk problem
facetDomainId	The domain id of the (d-1)-dimensional problem living on the bulk grid facets
facetDomainId	The domain id of the (d-2)-dimensional problem living on the bulk grid edges

Public Types
template<std::size_t i, std::size_t j>
using	CouplingStencilType = typename std::conditional<(j==edgeDomainId), typename FacetEdgeManager::template CouplingStencilType< i, j >, typename BulkFacetManager::template CouplingStencilType< i, j > >::type
	types used for coupling stencils More...

using	SolutionVector = typename MDTraits::SolutionVector
	the type of the solution vector More...

Public Member Functions
void	init (std::shared_ptr< Problem< bulkId > > bulkProblem, std::shared_ptr< Problem< facetId > > facetProblem, std::shared_ptr< Problem< edgeId > > edgeProblem, std::shared_ptr< CouplingMapper > couplingMapper, const SolutionVector &curSol)
	Initialize the coupling manager. More...

template<class JacobianPattern >
void	extendJacobianPattern (FacetIdType, JacobianPattern &pattern) const

template<class FacetLocalAssembler , class JacobianMatrixDiagBlock , class GridVariables >
void	evalAdditionalDomainDerivatives (FacetIdType, const FacetLocalAssembler &facetLocalAssembler, const typename FacetLocalAssembler::LocalResidual::ElementResidualVector &origResiduals, JacobianMatrixDiagBlock &A, GridVariables &gridVariables)

const CouplingStencilType< bulkId, edgeId > &	couplingStencil (BulkIdType domainI, const Element< bulkId > &element, EdgeIdType domainJ) const
	The coupling stencil of the bulk with the edge domain (empty stencil). More...

const CouplingStencilType< edgeId, bulkId > &	couplingStencil (EdgeIdType domainI, const Element< edgeId > &element, BulkIdType domainJ) const
	The coupling stencil of the edge with the bulk domain (empty stencil). More...

void	updateSolution (const SolutionVector &sol)
	updates the current solution. We have to overload this here to avoid ambiguity and update the solution in both managers More...

template<std::size_t i, std::size_t j, class LocalAssembler , std::enable_if_t<((i==bulkId &&j==edgeId)\|\|((i==edgeId &&j==bulkId))), int > = 0>
LocalAssembler::LocalResidual::ElementResidualVector	evalCouplingResidual (Dune::index_constant< i > domainI, const LocalAssembler &localAssembler, Dune::index_constant< j > domainJ, GridIndexType< j > dofIdxGlobalJ)
	Interface for evaluating the coupling residual between the bulk and the edge domain. This is always zero as coupling only occurs between grids of codimension one. These overloads are provided by the two parent classes. However, we need this overload in order for the overload resolution not to fail. More...

template<class Assembler >
void	bindCouplingContext (FacetIdType, const Element< facetId > &element, const Assembler &assembler)
	Interface for binding the coupling context for the facet domain. In this case we have to bind both the facet -> bulk and the facet -> edge coupling context. More...

template<class FacetLocalAssembler >
void	updateCouplingContext (FacetIdType domainI, const FacetLocalAssembler &facetLocalAssembler, FacetIdType domainJ, GridIndexType< facetId > dofIdxGlobalJ, const PrimaryVariables< facetId > &priVarsJ, unsigned int pvIdxJ)
	Interface for updating the coupling context of the facet domain. In this case we have to update both the facet -> bulk and the facet -> edge coupling context. More...

template<std::size_t i, std::size_t j, class LocalAssembler , std::enable_if_t<((i==bulkId &&j==edgeId)\|\|(i==edgeId &&j==bulkId)), int > = 0>
void	updateCouplingContext (Dune::index_constant< i > domainI, const LocalAssembler &localAssembler, Dune::index_constant< j > domainJ, GridIndexType< j > dofIdxGlobalJ, const PrimaryVariables< j > &priVarsJ, unsigned int pvIdxJ)
	Interface for updating the coupling context between the bulk and the edge domain. We do nothing here because coupling only occurs between grids of codimension one. We have to provide this overload as the overload resolution fails otherwise. More...

template<class FacetLocalAssembler , class UpdatableElementVolVars , class UpdatableFluxVarCache >
void	updateCoupledVariables (FacetIdType domainI, const FacetLocalAssembler &facetLocalAssembler, UpdatableElementVolVars &elemVolVars, UpdatableFluxVarCache &elemFluxVarsCache)
	Interface for updating the local views of the facet domain after updateCouplingContext the coupling context. In this case we have to forward the both managers as the facet domain is a part in both. More...

template<std::size_t id, std::enable_if_t<(id==bulkId\|\|id==facetId), int > = 0>
const Problem< id > &	problem () const
	Return a const reference to bulk or facet problem. More...

template<std::size_t id, std::enable_if_t<(id==bulkId\|\|id==facetId), int > = 0>
Problem< id > &	problem ()
	Return a reference to bulk or facet problem. More...

template<std::size_t id, std::enable_if_t<(id==edgeId), int > = 0>
const Problem< id > &	problem () const
	Return a const reference to edge problem. More...

template<std::size_t id, std::enable_if_t<(id==edgeId), int > = 0>
Problem< id > &	problem ()
	Return a reference to edge problem. More...