distributedintersectionentityset.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_GEOMETRY_DISTRIBUTED_INTERSECTION_ENTITY_SET_HH
#define DUMUX_GEOMETRY_DISTRIBUTED_INTERSECTION_ENTITY_SET_HH
 
#include <algorithm>
#include <memory>
#include <utility>
#include <vector>
 
#include <dune/common/timer.hh>
#include <dune/common/iteratorrange.hh>
#include <dune/common/iteratorfacades.hh>
#include <dune/geometry/affinegeometry.hh>
#include <dune/geometry/type.hh>
 
#include <dumux/geometry/distributedboundingboxtree.hh>
#include <dumux/geometry/distributedintersectingentities.hh>
 
namespace Dumux {

template<class DomainEntitySet, class TargetEntitySet>
class DistributedIntersectionEntitySet
{
    using DomainTree = DistributedBoundingBoxTree<DomainEntitySet>;
    using TargetTree = DistributedBoundingBoxTree<TargetEntitySet>;
    using Info = DistributedIntersectionInfo<DomainEntitySet, TargetEntitySet>;
 
public:
    using ctype = typename Info::ctype;
    static constexpr int dimensionworld = Info::dimensionworld;
    using GlobalPosition = typename Info::GlobalPosition;
 
private:
    static constexpr int dimDomain = DomainEntitySet::Entity::Geometry::mydimension;
    static constexpr int dimTarget = TargetEntitySet::Entity::Geometry::mydimension;
    static constexpr int dimIs = std::min(dimDomain, dimTarget);
 
public:
    using Geometry = Dune::AffineGeometry<ctype, dimIs, dimensionworld>;

    class IntersectionEntity
    {
    public:
        IntersectionEntity(const DistributedIntersectionEntitySet& set, const Info& info)
        : set_(set), info_(info) {}

        Geometry geometry() const
        { return Geometry(Dune::GeometryTypes::simplex(dimIs), info_.corners); }

        int domainRank() const { return info_.domainRank; }
        std::size_t domainIndex() const { return info_.domainIndex; }
        int targetRank() const { return info_.targetRank; }
        std::size_t targetIndex() const { return info_.targetIndex; }

        typename DomainEntitySet::Entity domainEntity() const
        { return set_.domainTree_->entitySet().entity(info_.domainIndex); }

        bool targetIsLocal() const
        { return info_.targetRank == set_.targetTree_->rank(); }

        typename TargetEntitySet::Entity targetEntity() const
        { return set_.targetTree_->entitySet().entity(info_.targetIndex); }
 
    private:
        const DistributedIntersectionEntitySet& set_;
        const Info& info_;
    };

    class IntersectionIterator
    : public Dune::ForwardIteratorFacade<IntersectionIterator, const IntersectionEntity, IntersectionEntity>
    {
        using InfoIterator = typename std::vector<Info>::const_iterator;
    public:
        IntersectionIterator(const DistributedIntersectionEntitySet& set, InfoIterator it)
        : set_(&set), it_(it) {}
 
        IntersectionEntity dereference() const
        { return IntersectionEntity(*set_, *it_); }
 
        bool equals(const IntersectionIterator& other) const
        { return it_ == other.it_; }
 
        void increment() { ++it_; }
 
    private:
        const DistributedIntersectionEntitySet* set_;
        InfoIterator it_;
    };
 
    using EntityIterator = IntersectionIterator;

    DistributedIntersectionEntitySet() = default;

    void build(std::shared_ptr<const DomainEntitySet> domainSet,
               std::shared_ptr<const TargetEntitySet> targetSet)
    {
        build(std::make_shared<DomainTree>(domainSet), std::make_shared<TargetTree>(targetSet));
    }

    void build(std::shared_ptr<const DomainTree> domainTree,
               std::shared_ptr<const TargetTree> targetTree)
    {
        domainTree_ = domainTree;
        targetTree_ = targetTree;
 
        Dune::Timer timer;
        intersections_ = intersectingEntities(*domainTree_, *targetTree_);
 
        const auto& comm = domainTree_->comm();
        const std::size_t globalSize = comm.sum(intersections_.size());
        if (comm.rank() == 0)
            std::cout << "Computed " << globalSize << " distributed intersection entities in "
                      << timer.elapsed() << " seconds." << std::endl;
    }

    std::size_t size() const
    { return intersections_.size(); }

    IntersectionIterator ibegin() const
    { return IntersectionIterator(*this, intersections_.begin()); }

    IntersectionIterator iend() const
    { return IntersectionIterator(*this, intersections_.end()); }

    friend Dune::IteratorRange<EntityIterator> intersections(const DistributedIntersectionEntitySet& set)
    { return {set.ibegin(), set.iend()}; }
 
private:
    std::vector<Info> intersections_;
    std::shared_ptr<const DomainTree> domainTree_;
    std::shared_ptr<const TargetTree> targetTree_;
};
 
} // end namespace Dumux
 
#endif