14#ifndef DUMUX_MULTIDOMAIN_EMBEDDED_COUPLINGMANAGERBASE_HH 
   15#define DUMUX_MULTIDOMAIN_EMBEDDED_COUPLINGMANAGERBASE_HH 
   21#include <unordered_map> 
   23#include <dune/common/timer.hh> 
   24#include <dune/geometry/quadraturerules.hh> 
   43template<
class MDTraits>
 
   47    template<std::
size_t i> 
using SubDomainTypeTag = 
typename MDTraits::template SubDomain<i>::TypeTag;
 
   52    template<std::
size_t i>
 
   56    template<std::
size_t i>
 
 
   68template<
class MDTraits, 
class Implementation, 
class PSTraits = DefaultPo
intSourceTraits<MDTraits>>
 
   73    using Scalar = 
typename MDTraits::Scalar;
 
   74    static constexpr auto bulkIdx = 
typename MDTraits::template SubDomain<0>::Index();
 
   75    static constexpr auto lowDimIdx = 
typename MDTraits::template SubDomain<1>::Index();
 
   76    using SolutionVector = 
typename MDTraits::SolutionVector;
 
   77    using PointSourceData = 
typename PSTraits::PointSourceData;
 
   80    template<std::
size_t id> 
using PointSource = 
typename PSTraits::template PointSource<id>;
 
   81    template<std::
size_t id> 
using SubDomainTypeTag = 
typename MDTraits::template SubDomain<id>::TypeTag;
 
   85    template<std::
size_t id> 
using GridView = 
typename GridGeometry<id>::GridView;
 
   86    template<std::
size_t id> 
using ElementMapper = 
typename GridGeometry<id>::ElementMapper;
 
   87    template<std::
size_t id> 
using Element = 
typename GridView<id>::template Codim<0>::Entity;
 
   88    template<std::
size_t id> 
using ElementSeed = 
typename GridView<id>::Grid::template Codim<0>::EntitySeed;
 
   90    template<std::
size_t id> 
using CouplingStencil = std::vector<GridIndex<id>>;
 
   92    static constexpr int bulkDim = GridView<bulkIdx>::dimension;
 
   93    static constexpr int lowDimDim = GridView<lowDimIdx>::dimension;
 
   94    static constexpr int dimWorld = GridView<bulkIdx>::dimensionworld;
 
   96    template<std::
size_t id>
 
   97    static constexpr bool isBox()
 
  100    using GlobalPosition = 
typename Element<bulkIdx>::Geometry::GlobalCoordinate;
 
  109    template<std::
size_t id> 
using CouplingStencils = std::unordered_map<GridIndex<id>, CouplingStencil<id>>;
 
  115                                 std::shared_ptr<
const GridGeometry<lowDimIdx>> lowDimGridGeometry)
 
  117        glue_ = std::make_shared<GlueType>();
 
 
  124                                std::shared_ptr<
const GridGeometry<lowDimIdx>> lowDimGridGeometry)
 
 
  134    void init(std::shared_ptr<Problem<bulkIdx>> bulkProblem,
 
  135              std::shared_ptr<Problem<lowDimIdx>> lowDimProblem,
 
  136              const SolutionVector& 
curSol)
 
  139        this->
setSubProblems(std::make_tuple(bulkProblem, lowDimProblem));
 
  141        integrationOrder_ = 
getParam<int>(
"MixedDimension.IntegrationOrder", 1);
 
  142        asImp_().computePointSourceData(integrationOrder_);
 
 
  166    template<std::
size_t i, std::
size_t j>
 
  168                                              const Element<i>& element,
 
  169                                              Dune::index_constant<j> domainJ)
 const 
  171        static_assert(i != j, 
"A domain cannot be coupled to itself!");
 
  173        const auto eIdx = this->
problem(domainI).gridGeometry().elementMapper().index(element);
 
 
  192    template<std::
size_t i, std::
size_t j, 
class LocalAssemblerI>
 
  194                                        const LocalAssemblerI& localAssemblerI,
 
  195                                        Dune::index_constant<j> domainJ,
 
  196                                        std::size_t dofIdxGlobalJ)
 
  198        static_assert(i != j, 
"A domain cannot be coupled to itself!");
 
  200        typename LocalAssemblerI::LocalResidual::ElementResidualVector residual;
 
  202        const auto& element = localAssemblerI.element();
 
  203        const auto& fvGeometry = localAssemblerI.fvGeometry();
 
  204        const auto& curElemVolVars = localAssemblerI.curElemVolVars();
 
  206        residual.resize(fvGeometry.numScv());
 
  207        for (
const auto& scv : scvs(fvGeometry))
 
  209            auto couplingSource = this->
problem(domainI).scvPointSources(element, fvGeometry, curElemVolVars, scv);
 
  210            couplingSource += this->
problem(domainI).source(element, fvGeometry, curElemVolVars, scv);
 
  211            couplingSource *= -GridGeometry<i>::Extrusion::volume(fvGeometry, scv)*curElemVolVars[scv].extrusionFactor();
 
  212            residual[scv.indexInElement()] = couplingSource;
 
 
  233        std::cout << 
"Initializing the point sources..." << std::endl;
 
  243        const auto& bulkGridGeometry = this->
problem(bulkIdx).gridGeometry();
 
  244        const auto& lowDimGridGeometry = this->
problem(lowDimIdx).gridGeometry();
 
  249        pointSourceData_.reserve(this->
glue().size());
 
  250        averageDistanceToBulkCell_.reserve(this->
glue().size());
 
  251        for (
const auto& is : intersections(this->
glue()))
 
  254            const auto& inside = is.targetEntity(0);
 
  256            const auto intersectionGeometry = is.geometry();
 
  259            const auto& quad = Dune::QuadratureRules<Scalar, lowDimDim>::rule(intersectionGeometry.type(), order);
 
  260            const std::size_t lowDimElementIdx = lowDimGridGeometry.elementMapper().index(inside);
 
  263            for (
auto&& qp : quad)
 
  266                for (std::size_t outsideIdx = 0; outsideIdx < is.numDomainNeighbors(); ++outsideIdx)
 
  268                    const auto& outside = is.domainEntity(outsideIdx);
 
  269                    const std::size_t bulkElementIdx = bulkGridGeometry.elementMapper().index(outside);
 
  272                    const auto globalPos = intersectionGeometry.global(qp.position());
 
  274                    const auto qpweight = qp.weight();
 
  275                    const auto ie = intersectionGeometry.integrationElement(qp.position());
 
  276                    pointSources(bulkIdx).emplace_back(globalPos, 
id, qpweight, ie, bulkElementIdx);
 
  277                    pointSources(bulkIdx).back().setEmbeddings(is.numDomainNeighbors());
 
  278                    pointSources(lowDimIdx).emplace_back(globalPos, 
id, qpweight, ie, lowDimElementIdx);
 
  279                    pointSources(lowDimIdx).back().setEmbeddings(is.numDomainNeighbors());
 
  283                    PointSourceData psData;
 
  285                    if constexpr (isBox<lowDimIdx>())
 
  287                        using ShapeValues = std::vector<Dune::FieldVector<Scalar, 1> >;
 
  288                        const auto lowDimGeometry = this->
problem(lowDimIdx).gridGeometry().element(lowDimElementIdx).geometry();
 
  289                        ShapeValues shapeValues;
 
  290                        this->
getShapeValues(lowDimIdx, this->
problem(lowDimIdx).gridGeometry(), lowDimGeometry, globalPos, shapeValues);
 
  291                        psData.addLowDimInterpolation(shapeValues, this->
vertexIndices(lowDimIdx, lowDimElementIdx), lowDimElementIdx);
 
  295                        psData.addLowDimInterpolation(lowDimElementIdx);
 
  299                    if constexpr (isBox<bulkIdx>())
 
  301                        using ShapeValues = std::vector<Dune::FieldVector<Scalar, 1> >;
 
  302                        const auto bulkGeometry = this->
problem(bulkIdx).gridGeometry().element(bulkElementIdx).geometry();
 
  303                        ShapeValues shapeValues;
 
  304                        this->
getShapeValues(bulkIdx, this->
problem(bulkIdx).gridGeometry(), bulkGeometry, globalPos, shapeValues);
 
  305                        psData.addBulkInterpolation(shapeValues, this->
vertexIndices(bulkIdx, bulkElementIdx), bulkElementIdx);
 
  309                        psData.addBulkInterpolation(bulkElementIdx);
 
  320                    if (isBox<bulkIdx>())
 
  322                        const auto& vertices = this->
vertexIndices(bulkIdx, bulkElementIdx);
 
  324                                                                                   vertices.begin(), vertices.end());
 
  328                        this->
couplingStencils(lowDimIdx)[lowDimElementIdx].push_back(bulkElementIdx);
 
  333                    if (isBox<lowDimIdx>())
 
  335                        const auto& vertices = this->
vertexIndices(lowDimIdx, lowDimElementIdx);
 
  337                                                                               vertices.begin(), vertices.end());
 
  342                        this->
couplingStencils(bulkIdx)[bulkElementIdx].push_back(lowDimElementIdx);
 
  349        using namespace Dune::Hybrid;
 
  350        forEach(integralRange(std::integral_constant<std::size_t, MDTraits::numSubDomains>{}), [&](
const auto domainIdx)
 
  354                std::sort(stencil.second.begin(), stencil.second.end());
 
  355                stencil.second.erase(std::unique(stencil.second.begin(), stencil.second.end()), stencil.second.end());
 
  359        std::cout << 
"took " << watch.elapsed() << 
" seconds." << std::endl;
 
 
  369    { 
return pointSourceData_[id]; }
 
 
  372    template<std::
size_t id>
 
  373    const GridView<id>& 
gridView(Dune::index_constant<id> domainIdx)
 const 
  374    { 
return this->
problem(domainIdx).gridGeometry().gridView(); }
 
 
  378    { 
return pointSourceData_[id].interpolateBulk(this->
curSol(bulkIdx)); }
 
 
  382    { 
return pointSourceData_[id].interpolateLowDim(this->
curSol(lowDimIdx)); }
 
 
  386    { 
return averageDistanceToBulkCell_[id]; }
 
 
  390    { 
return std::get<bulkIdx>(pointSources_); }
 
 
  394    { 
return std::get<lowDimIdx>(pointSources_); }
 
 
  397    template<std::
size_t i>
 
  398    const std::vector<PointSource<i>>& 
pointSources(Dune::index_constant<i> dom)
 const 
  399    { 
return std::get<i>(pointSources_); }
 
 
  402    template<std::
size_t i>
 
  404    { 
return std::get<i>(couplingStencils_); }
 
 
  408    { 
return pointSourceData_; }
 
 
  411    template<std::
size_t i>
 
  412    const CouplingStencil<i>& 
emptyStencil(Dune::index_constant<i> dom)
 const 
  413    { 
return std::get<i>(emptyStencil_); }
 
 
  420    template<std::
size_t i>
 
  421    auto& 
curSol(Dune::index_constant<i> domainIdx)
 
 
  429    template<std::
size_t i>
 
  430    const auto& 
curSol(Dune::index_constant<i> domainIdx)
 const 
 
  441        const auto& bulkGG = 
asImp_().problem(bulkIdx).gridGeometry();
 
  442        const auto& lowDimGG = 
asImp_().problem(lowDimIdx).gridGeometry();
 
  444        auto connectedElementsBulk = Detail::computeConnectedElements(bulkGG);
 
  445        auto connectedElementsLowDim = Detail::computeConnectedElements(lowDimGG);
 
  449        for (
const auto& element : elements(bulkGG.gridView()))
 
  451            const auto eIdx = bulkGG.elementMapper().index(element);
 
  455                const auto& elems = connectedElementsBulk[dofIdx];
 
  456                if (std::find(elems.begin(), elems.end(), eIdx) == elems.end())
 
  457                    connectedElementsBulk[dofIdx].push_back(eIdx);
 
  464        std::array<std::vector<std::vector<std::size_t>>, 2> connectedElementsCoupling;
 
  466        using namespace Dune::Hybrid;
 
  467        forEach(integralRange(Dune::index_constant<MDTraits::numSubDomains>{}), [&](
const auto i)
 
  469            connectedElementsCoupling[i()].resize(
asImp_().
problem(i).gridGeometry().numDofs());
 
  470            forEach(integralRange(Dune::index_constant<MDTraits::numSubDomains>{}), [&](
const auto j)
 
  472                if constexpr (i != j)
 
  476                        const auto eIdx = 
asImp_().problem(j).gridGeometry().elementMapper().index(element);
 
  479                            const auto& elems = connectedElementsCoupling[i()][dofIdx];
 
  480                            if (std::find(elems.begin(), elems.end(), eIdx) == elems.end())
 
  481                                connectedElementsCoupling[i()][dofIdx].push_back(eIdx);
 
  488        forEach(integralRange(Dune::index_constant<MDTraits::numSubDomains>{}), [&](
const auto i)
 
  490            const auto& gg = 
asImp_().problem(i).gridGeometry();
 
  492            std::vector<int> colors(gg.gridView().size(0), -1);
 
  495            std::vector<int> neighborColors; neighborColors.reserve(200);
 
  496            std::vector<bool> colorUsed; colorUsed.reserve(200);
 
  498            auto& elementSets = std::get<i>(elementSets_);
 
  499            const auto& connectedElements = std::get<i>(std::tie(connectedElementsBulk, connectedElementsLowDim));
 
  501            for (
const auto& element : elements(gg.gridView()))
 
  504                neighborColors.clear();
 
  505                Detail::addNeighborColors(gg, element, colors, connectedElements, neighborColors);
 
  507                if constexpr (i == bulkIdx)
 
  512                    const auto eIdx = bulkGG.elementMapper().index(element);
 
  515                        for (
const auto nIdx : connectedElementsBulk[dofIdx])
 
  516                            neighborColors.push_back(colors[nIdx]);
 
  520                forEach(integralRange(Dune::index_constant<MDTraits::numSubDomains>{}), [&](
const auto j)
 
  522                    if constexpr (i != j)
 
  526                            for (
auto eIdx : connectedElementsCoupling[j][dofIdx])
 
  527                                neighborColors.push_back(colors[eIdx]);
 
  532                const auto color = Detail::smallestAvailableColor(neighborColors, colorUsed);
 
  535                colors[gg.elementMapper().index(element)] = color;
 
  538                if (color < elementSets.size())
 
  539                    elementSets[color].push_back(element.seed());
 
  541                    elementSets.push_back(std::vector<ElementSeed<i>>{ element.seed() });
 
  545        std::cout << Fmt::format(
"Colored in {} seconds:\n", timer.elapsed());
 
  546        forEach(integralRange(Dune::index_constant<MDTraits::numSubDomains>{}), [&](
const auto i)
 
  548            std::cout << Fmt::format(
 
  549                "-- {} elements in subdomain {} with {} colors\n",
 
  551                i(), std::get<i>(elementSets_).size()
 
 
  562    template<std::
size_t i, 
class AssembleElementFunc>
 
  565        if (std::get<i>(elementSets_).empty())
 
  566            DUNE_THROW(Dune::InvalidStateException, 
"Call computeColorsForAssembly before assembling in parallel!");
 
  572        const auto& grid = this->
problem(domainId).gridGeometry().gridView().grid();
 
  573        for (
const auto& elements : std::get<i>(elementSets_))
 
  577                const auto element = grid.entity(elements[n]);
 
  578                assembleElement(element);
 
 
  589    { 
return asImp_().emptyStencil(bulkIdx); }
 
 
  595    template<std::
size_t id>
 
  599        if constexpr (isBox<domainIdx>())
 
  602            for (
const auto& element : elements(
gridView(domainIdx)))
 
  604                constexpr int dim = GridView<domainIdx>::dimension;
 
  605                const auto eIdx = this->
problem(domainIdx).gridGeometry().elementMapper().index(element);
 
  606                this->
vertexIndices(domainIdx, eIdx).resize(element.subEntities(dim));
 
  607                for (
int i = 0; i < element.subEntities(dim); ++i)
 
  608                    this->
vertexIndices(domainIdx, eIdx)[i] = this->
problem(domainIdx).gridGeometry().vertexMapper().subIndex(element, i, dim);
 
 
  614    template<std::
size_t i, 
class FVGG, 
class Geometry, 
class ShapeValues>
 
  615    void getShapeValues(Dune::index_constant<i> domainI, 
const FVGG& gridGeometry, 
const Geometry& geo, 
const GlobalPosition& globalPos, ShapeValues& shapeValues)
 
  619            const auto ipLocal = geo.local(globalPos);
 
  620            const auto& localBasis = this->
problem(domainI).gridGeometry().feCache().get(geo.type()).localBasis();
 
  621            localBasis.evaluateFunction(ipLocal, shapeValues);
 
  624            DUNE_THROW(Dune::InvalidStateException, 
"Shape values requested for other discretization than box!");
 
 
  636        pointSourceData_.clear();
 
  637        averageDistanceToBulkCell_.clear();
 
 
  645        const auto& bulkGridGeometry = this->
problem(bulkIdx).gridGeometry();
 
  646        const auto& lowDimGridGeometry = this->
problem(lowDimIdx).gridGeometry();
 
  649        glue_->build(bulkGridGeometry.boundingBoxTree(), lowDimGridGeometry.boundingBoxTree());
 
 
  654    { 
return pointSourceData_; }
 
 
  658    { 
return averageDistanceToBulkCell_; }
 
 
  661    template<std::
size_t i>
 
  663    { 
return std::get<i>(pointSources_); }
 
 
  666    template<std::
size_t i>
 
  668    { 
return std::get<i>(couplingStencils_); }
 
 
  671    template<std::
size_t i>
 
  672    std::vector<GridIndex<i>>& 
vertexIndices(Dune::index_constant<i> dom, GridIndex<i> eIdx)
 
  673    { 
return std::get<i>(vertexIndices_)[eIdx]; }
 
 
  676    template<std::
size_t i>
 
  677    std::vector<std::vector<GridIndex<i>>>& 
vertexIndices(Dune::index_constant<i> dom)
 
  678    { 
return std::get<i>(vertexIndices_); }
 
 
  685    { 
return *
static_cast<Implementation *
>(
this); }
 
 
  689    { 
return *
static_cast<const Implementation *
>(
this); }
 
 
  697    std::tuple<std::vector<PointSource<bulkIdx>>, std::vector<PointSource<lowDimIdx>>> pointSources_;
 
  698    std::vector<PointSourceData> pointSourceData_;
 
  699    std::vector<Scalar> averageDistanceToBulkCell_;
 
  702    std::tuple<std::vector<std::vector<GridIndex<bulkIdx>>>,
 
  703               std::vector<std::vector<GridIndex<lowDimIdx>>>> vertexIndices_;
 
  705    std::tuple<CouplingStencil<bulkIdx>, CouplingStencil<lowDimIdx>> emptyStencil_;
 
  708    std::shared_ptr<GlueType> glue_;
 
  711    int integrationOrder_ = 1;
 
  715        std::deque<std::vector<ElementSeed<bulkIdx>>>,
 
  716        std::deque<std::vector<ElementSeed<lowDimIdx>>>
 
 
void setSubProblems(const std::tuple< std::shared_ptr< SubProblems >... > &problems)
Definition multidomain/couplingmanager.hh:275
const Problem< i > & problem(Dune::index_constant< i > domainIdx) const
Definition multidomain/couplingmanager.hh:297
SubSolutionVector< i > & curSol(Dune::index_constant< i > domainIdx)
Definition multidomain/couplingmanager.hh:326
void updateSolution(const SolutionVector &curSol)
Definition multidomain/couplingmanager.hh:207
CouplingManager()
Definition multidomain/couplingmanager.hh:70
std::vector< GridIndex< i > > & vertexIndices(Dune::index_constant< i > dom, GridIndex< i > eIdx)
Return a reference to the vertex indices.
Definition couplingmanagerbase.hh:672
Scalar averageDistance(std::size_t id) const
return the average distance to the coupled bulk cell center
Definition couplingmanagerbase.hh:385
Implementation & asImp_()
Returns the implementation of the problem (i.e. static polymorphism)
Definition couplingmanagerbase.hh:684
const std::vector< PointSource< i > > & pointSources(Dune::index_constant< i > dom) const
Return the point source if domain i.
Definition couplingmanagerbase.hh:398
const CouplingStencil< bulkIdx > & extendedSourceStencil(std::size_t eIdx) const
Definition couplingmanagerbase.hh:588
CircleAveragePointSourceTraits< MDTraits > PointSourceTraits
Definition couplingmanagerbase.hh:107
EmbeddedCouplingManagerBase(std::shared_ptr< const GridGeometry< bulkIdx > > bulkGridGeometry, std::shared_ptr< const GridGeometry< lowDimIdx > > lowDimGridGeometry)
Constructor.
Definition couplingmanagerbase.hh:123
const CouplingStencils< i > & couplingStencils(Dune::index_constant< i > dom) const
Return reference to bulk coupling stencil member of domain i.
Definition couplingmanagerbase.hh:403
void updateAfterGridAdaption(std::shared_ptr< const GridGeometry< bulkIdx > > bulkGridGeometry, std::shared_ptr< const GridGeometry< lowDimIdx > > lowDimGridGeometry)
call this after grid adaption
Definition couplingmanagerbase.hh:114
const GridView< id > & gridView(Dune::index_constant< id > domainIdx) const
Return a reference to the bulk problem.
Definition couplingmanagerbase.hh:373
std::unordered_map< GridIndex< id >, CouplingStencil< id > > CouplingStencils
Definition couplingmanagerbase.hh:109
const Implementation & asImp_() const
Returns the implementation of the problem (i.e. static polymorphism)
Definition couplingmanagerbase.hh:688
std::vector< Scalar > & averageDistanceToBulkCell()
Return reference to average distances to bulk cell.
Definition couplingmanagerbase.hh:657
const auto & curSol(Dune::index_constant< i > domainIdx) const
the solution vector of the subproblem
Definition couplingmanagerbase.hh:430
const CouplingStencil< i > & emptyStencil(Dune::index_constant< i > dom) const
Return a reference to an empty stencil.
Definition couplingmanagerbase.hh:412
const std::vector< PointSource< bulkIdx > > & bulkPointSources() const
Return reference to bulk point sources.
Definition couplingmanagerbase.hh:389
auto & curSol(Dune::index_constant< i > domainIdx)
Definition couplingmanagerbase.hh:421
const PointSourceData & pointSourceData(std::size_t id) const
Methods to be accessed by the subproblems.
Definition couplingmanagerbase.hh:368
std::vector< std::vector< GridIndex< i > > > & vertexIndices(Dune::index_constant< i > dom)
Return a reference to the vertex indices container.
Definition couplingmanagerbase.hh:677
void glueGrids()
compute the intersections between the two grids
Definition couplingmanagerbase.hh:643
MDTraits MultiDomainTraits
Definition couplingmanagerbase.hh:105
void computePointSourceData(std::size_t order=1, bool verbose=false)
Definition couplingmanagerbase.hh:228
std::vector< PointSourceData > & pointSourceData()
Return reference to point source data vector member.
Definition couplingmanagerbase.hh:653
const CouplingStencil< j > & couplingStencil(Dune::index_constant< i > domainI, const Element< i > &element, Dune::index_constant< j > domainJ) const
Methods to be accessed by the assembly.
Definition couplingmanagerbase.hh:167
PrimaryVariables< lowDimIdx > lowDimPriVars(std::size_t id) const
Return data for a low dim point source with the identifier id.
Definition couplingmanagerbase.hh:381
void getShapeValues(Dune::index_constant< i > domainI, const FVGG &gridGeometry, const Geometry &geo, const GlobalPosition &globalPos, ShapeValues &shapeValues)
compute the shape function for a given point and geometry
Definition couplingmanagerbase.hh:615
const std::vector< PointSource< lowDimIdx > > & lowDimPointSources() const
Return reference to low dim point sources.
Definition couplingmanagerbase.hh:393
void assembleMultithreaded(Dune::index_constant< i > domainId, AssembleElementFunc &&assembleElement) const
Execute assembly kernel in parallel.
Definition couplingmanagerbase.hh:563
void clear()
Clear all internal data members.
Definition couplingmanagerbase.hh:628
void computeColorsForAssembly()
Compute colors for multithreaded assembly.
Definition couplingmanagerbase.hh:436
const GlueType & glue() const
Definition couplingmanagerbase.hh:680
decltype(auto) evalCouplingResidual(Dune::index_constant< i > domainI, const LocalAssemblerI &localAssemblerI, Dune::index_constant< j > domainJ, std::size_t dofIdxGlobalJ)
evaluates the element residual of a coupled element of domain i which depends on the variables at the...
Definition couplingmanagerbase.hh:193
void init(std::shared_ptr< Problem< bulkIdx > > bulkProblem, std::shared_ptr< Problem< lowDimIdx > > lowDimProblem, const SolutionVector &curSol)
Methods to be accessed by main.
Definition couplingmanagerbase.hh:134
CouplingStencils< i > & couplingStencils(Dune::index_constant< i > dom)
Return reference to bulk coupling stencil member of domain i.
Definition couplingmanagerbase.hh:667
std::vector< PointSource< i > > & pointSources(Dune::index_constant< i > dom)
Return the point source if domain i.
Definition couplingmanagerbase.hh:662
PrimaryVariables< bulkIdx > bulkPriVars(std::size_t id) const
Return data for a bulk point source with the identifier id.
Definition couplingmanagerbase.hh:377
void precomputeVertexIndices(Dune::index_constant< id > domainIdx)
computes the vertex indices per element for the box method
Definition couplingmanagerbase.hh:596
std::size_t idCounter_
Definition couplingmanagerbase.hh:692
const std::vector< PointSourceData > & pointSourceData() const
Return reference to point source data vector member.
Definition couplingmanagerbase.hh:407
A helper class calculating a DOF-index to point source map.
Definition integrationpointsource.hh:100
An integration point source class with an identifier to attach data and a quadrature weight and integ...
Definition integrationpointsource.hh:33
A point source data class used for integration in multidimensional models.
Definition pointsourcedata.hh:31
Coloring schemes for shared-memory-parallel assembly.
Defines all properties used in Dumux.
Helper functions for distance queries.
A class glueing two grids of potentially different dimension geometrically. Intersections are compute...
typename NumEqVectorTraits< PrimaryVariables >::type NumEqVector
A vector with the same size as numbers of equations This is the default implementation and has to be ...
Definition numeqvector.hh:34
static Geometry::ctype averageDistancePointGeometry(const typename Geometry::GlobalCoordinate &p, const Geometry &geometry, std::size_t integrationOrder=2)
Compute the average distance from a point to a geometry by integration.
Definition distance.hh:29
IntersectionEntitySet< GridViewGeometricEntitySet< DomainGridView, 0, DomainMapper >, GridViewGeometricEntitySet< TargetGridView, 0, TargetMapper > > MultiDomainGlue
A convenience alias for the IntersectionEntitySet of two GridViewGeometricEntitySets.
Definition glue.hh:28
void parallelFor(const std::size_t count, const FunctorType &functor)
A parallel for loop (multithreading)
Definition parallel_for.hh:160
T getParam(Args &&... args)
A free function to get a parameter from the parameter tree singleton.
Definition parameters.hh:139
typename GetProp< TypeTag, Property >::type GetPropType
get the type alias defined in the property
Definition propertysystem.hh:296
An integration point source class, i.e. sources located at a single point in space associated with a ...
Algorithms that finds which geometric entities intersect.
The available discretization methods in Dumux.
The interface of the coupling manager for multi domain problems.
A linear system assembler (residual and Jacobian) for finite volume schemes with multiple domains.
constexpr Box box
Definition method.hh:147
A helper to deduce a vector with the same size as numbers of equations.
Parallel for loop (multithreading)
Data associated with a point source.
the default point source traits
Definition couplingmanagerbase.hh:45
Dumux::PointSourceData< MDTraits > PointSourceData
export the point source data type
Definition couplingmanagerbase.hh:60
IntegrationPointSourceHelper PointSourceHelper
export the point source helper type for domain i
Definition couplingmanagerbase.hh:57
IntegrationPointSource< typename GridGeometry< i >::GlobalCoordinate, NumEqVector< i > > PointSource
export the point source type for domain i
Definition couplingmanagerbase.hh:53
Structure to define the index types used for grid and local indices.
Definition indextraits.hh:26