multidomain/couplingmanager.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-FileCopyrightText: Copyright © DuMux Project contributors, see AUTHORS.md in root folder
// SPDX-License-Identifier: GPL-3.0-or-later
//
#ifndef DUMUX_MULTIDOMAIN_COUPLING_MANAGER_HH
#define DUMUX_MULTIDOMAIN_COUPLING_MANAGER_HH
 
#include <memory>
#include <tuple>
#include <vector>
#include <dune/common/exceptions.hh>
#include <dune/common/indices.hh>
#include <dune/common/shared_ptr.hh>
#include <dune/common/hybridutilities.hh>
#include <dune/istl/multitypeblockvector.hh>
 
#include <dumux/assembly/numericepsilon.hh>
#include <dumux/common/properties.hh>
#include <dumux/common/typetraits/typetraits.hh>
 
namespace Dumux {
 
template<class Traits>
class CouplingManager
{
    template<std::size_t id> using SubDomainTypeTag = typename Traits::template SubDomain<id>::TypeTag;
    template<std::size_t id> using PrimaryVariables = GetPropType<SubDomainTypeTag<id>, Properties::PrimaryVariables>;
    template<std::size_t id> using GridView = typename GetPropType<SubDomainTypeTag<id>, Properties::GridGeometry>::GridView;
    template<std::size_t id> using Element = typename GridView<id>::template Codim<0>::Entity;
    template<std::size_t id> using Problem = GetPropType<SubDomainTypeTag<id>, Properties::Problem>;
    template<std::size_t id> using ProblemPtr = const Problem<id> *;
    using ProblemPtrs = typename Traits::template Tuple<ProblemPtr>;
 
    template<std::size_t id>
    using SubSolutionVector
        = std::decay_t<decltype(std::declval<typename Traits::SolutionVector>()[Dune::index_constant<id>()])>;
 
public:
    template<std::size_t i, std::size_t j>
    using CouplingStencilType = std::vector<std::size_t>;
 
    using SolutionVector = typename Traits::SolutionVector;
 
protected:
    using SolutionVectorStorage = typename Traits::template TupleOfSharedPtr<SubSolutionVector>;
 
public:
    CouplingManager()
    {
        using namespace Dune::Hybrid;
        forEach(problems_, [](auto& problem){
            problem = nullptr;
        });
 
        forEach(curSols_, [](auto& solutionVector){
            solutionVector = std::make_shared<typename std::decay_t<decltype(solutionVector)>::element_type>();
        });
    }
 
    // \{
 
    template<std::size_t i, std::size_t j>
    const CouplingStencilType<i, j>& couplingStencil(Dune::index_constant<i> domainI,
                                                     const Element<i>& elementI,
                                                     Dune::index_constant<j> domainJ) const
    {
        static_assert(i != j, "Domain i cannot be coupled to itself!");
        static_assert(AlwaysFalse<Dune::index_constant<i>>::value,
                      "The coupling manager does not implement the couplingStencil() function");
    }
 
    template<std::size_t id, class JacobianPattern>
    void extendJacobianPattern(Dune::index_constant<id> domainI, JacobianPattern& pattern) const
    {}
 
    // \}
 
    // \{
 
    template<std::size_t i, class Assembler>
    void bindCouplingContext(Dune::index_constant<i> domainI,
                             const Element<i>& elementI,
                             const Assembler& assembler)
    {}
 
 
    template<std::size_t i, std::size_t j, class LocalAssemblerI>
    void updateCouplingContext(Dune::index_constant<i> domainI,
                               const LocalAssemblerI& localAssemblerI,
                               Dune::index_constant<j> domainJ,
                               std::size_t dofIdxGlobalJ,
                               const PrimaryVariables<j>& priVarsJ,
                               int pvIdxJ)
    {
        curSol(domainJ)[dofIdxGlobalJ][pvIdxJ] = priVarsJ[pvIdxJ];
    }
 
    template<std::size_t i, class LocalAssemblerI, class UpdatableElementVars, class UpdatableFluxVarCache>
    void updateCoupledVariables(Dune::index_constant<i> domainI,
                                const LocalAssemblerI& localAssemblerI,
                                UpdatableElementVars& elemVars,
                                UpdatableFluxVarCache& elemFluxVarsCache)
    {}
 
    template<std::size_t i, class LocalAssemblerI, class UpdatableElementVars>
    void updateCoupledVariables(Dune::index_constant<i> domainI,
                                const LocalAssemblerI& localAssemblerI,
                                UpdatableElementVars& elemVars)
    {}
 
    void updateSolution(const SolutionVector& curSol)
    {
        using namespace Dune::Hybrid;
        forEach(integralRange(Dune::Hybrid::size(curSols_)), [&](const auto id)
        {
            // copy external solution into object stored in this class
            *std::get<id>(curSols_) = curSol[id];
        });
    }
 
    // \}
 
    template<std::size_t i, std::size_t j, class LocalAssemblerI>
    decltype(auto) evalCouplingResidual(Dune::index_constant<i> domainI,
                                        const LocalAssemblerI& localAssemblerI,
                                        Dune::index_constant<j> domainJ,
                                        std::size_t dofIdxGlobalJ) const
    {
        return localAssemblerI.evalLocalResidual();
    }
 
    template<std::size_t i, class LocalAssemblerI, class JacobianMatrixDiagBlock, class GridVariables>
    void evalAdditionalDomainDerivatives(Dune::index_constant<i> domainI,
                                         const LocalAssemblerI& localAssemblerI,
                                         const typename LocalAssemblerI::LocalResidual::ElementResidualVector& origResiduals,
                                         JacobianMatrixDiagBlock& A,
                                         GridVariables& gridVariables)
    {}
 
    template<std::size_t i>
    decltype(auto) numericEpsilon(Dune::index_constant<i>,
                                  const std::string& paramGroup) const
    {
        constexpr auto numEq = PrimaryVariables<i>::dimension;
        return NumericEpsilon<typename Traits::Scalar, numEq>(paramGroup);
    }
 
    template<typename... SubProblems>
    void setSubProblems(const std::tuple<std::shared_ptr<SubProblems>...>& problems)
    {
        using namespace Dune::Hybrid;
        forEach(integralRange(size(problems_)), [&](const auto i)
        { setSubProblem(std::get<i>(problems), i); });
    }
 
    template<class SubProblem, std::size_t i>
    void setSubProblem(std::shared_ptr<SubProblem> problem, Dune::index_constant<i> domainIdx)
    { std::get<i>(problems_) = problem.get(); }
 
    template<std::size_t i>
    const Problem<i>& problem(Dune::index_constant<i> domainIdx) const
    {
        const Problem<i>* p = std::get<i>(problems_);
        assert(p && "The problem pointer is invalid. Use setSubProblems() before calling this function");
        return *p;
    }
 
protected:
    void attachSolution(const SolutionVectorStorage& curSol)
    {
        using namespace Dune::Hybrid;
        forEach(integralRange(Dune::Hybrid::size(curSols_)), [&](const auto id)
        {
            // do not take ownership of the external pointer's object
            std::get<id>(curSols_) = Dune::stackobject_to_shared_ptr(*std::get<id>(curSol));
        });
    }
 
    template<std::size_t i>
    SubSolutionVector<i>& curSol(Dune::index_constant<i> domainIdx)
    { return *std::get<i>(curSols_); }
 
    template<std::size_t i>
    const SubSolutionVector<i>& curSol(Dune::index_constant<i> domainIdx) const
    { return *std::get<i>(curSols_); }
 
private:
    SolutionVectorStorage curSols_;
 
    ProblemPtrs problems_;
};
 
} // end namespace Dumux
 
#endif