geometricentityset.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_GEOMETRIC_ENTITY_SET_HH
#define DUMUX_GEOMETRY_GEOMETRIC_ENTITY_SET_HH
 
#include <array>
#include <vector>
#include <memory>
#include <utility>
#include <initializer_list>
 
#include <dune/grid/common/mcmgmapper.hh>
#include <dune/geometry/multilineargeometry.hh>
#include <dumux/common/entitymap.hh>
#include <dumux/geometry/boundingboxgeometry.hh>
 
namespace Dumux {

template <class GridView, int codim = 0, class Mapper = Dune::MultipleCodimMultipleGeomTypeMapper<GridView>>
class GridViewGeometricEntitySet
{
    using EntityMap = Dumux::EntityMap<GridView, codim>;
public:
    using Entity = typename GridView::template Codim<codim>::Entity;
 
    explicit GridViewGeometricEntitySet(const GridView& gridView)
    : GridViewGeometricEntitySet(gridView, Mapper(gridView, Dune::mcmgLayout(Dune::Codim<codim>())))
    {}
 
    GridViewGeometricEntitySet(const GridView& gridView, const Mapper& mapper)
    : gridView_(gridView)
    , mapper_(mapper)
    , entityMap_(std::make_shared<EntityMap>(gridView.grid(), mapper_))
    {}
 
    GridViewGeometricEntitySet(const GridView& gridView,
                               const Mapper& mapper,
                               std::shared_ptr<const EntityMap> entityMap)
    : gridView_(gridView)
    , mapper_(mapper)
    , entityMap_(entityMap)
    {}

    static constexpr int dimensionworld = GridView::dimensionworld;

    using ctype = typename GridView::ctype;

    decltype(auto) size() const
    { return gridView_.size(codim); }

    decltype(auto) comm() const
    { return gridView_.comm(); }

    decltype(auto) begin() const
    { return entities(gridView_, Dune::Codim<codim>()).begin(); }

    decltype(auto) end() const
    { return entities(gridView_, Dune::Codim<codim>()).end(); }

    std::size_t index(const Entity& e) const
    { return mapper_.index(e); }

    Entity entity(std::size_t index) const
    { assert(index < entityMap_->size()); return (*entityMap_)[index]; }
 
private:
    GridView gridView_;
    Mapper mapper_;
    std::shared_ptr<const EntityMap> entityMap_;
};
 
} // end namespace Dumux
 
#ifndef DOXYGEN
namespace Dumux::Detail::GeometricEntity {

template<class GeoType>
class EntityWrapper
{
public:
    using Geometry = GeoType;

    EntityWrapper(const Geometry& geo, const std::size_t index) : geo_(geo), index_(index) {}

    EntityWrapper(Geometry&& geo, const std::size_t index) : geo_(std::move(geo)), index_(index) {}

    const Geometry& geometry() const
    { return geo_; }

    std::size_t index() const
    { return index_; }
 
private:
    Geometry geo_;
    std::size_t index_;
};

template<class ct, int dimworld>
class ProcessEntity
{
public:
    using Geometry = BoundingBoxGeometry<ct, dimworld>;
 
    ProcessEntity(const Geometry& geo, std::size_t index, int rank)
    : geo_(geo), index_(index), rank_(rank) {}

    const Geometry& geometry() const
    { return geo_; }

    std::size_t index() const
    { return index_; }

    int rank() const
    { return rank_; }
 
private:
    Geometry geo_;
    std::size_t index_;
    int rank_;
};
 
} // end namespace Dumux::Detail::GeometricEntity
#endif // DOXYGEN
 
namespace Dumux {

template<class GeoType>
class GeometriesEntitySet
{
public:
    using Entity = Detail::GeometricEntity::EntityWrapper<GeoType>;

    GeometriesEntitySet(std::initializer_list<typename Entity::Geometry>&& geometries)
    {
        std::size_t index = 0;
        // note: std::initializer_list::begin() returns const T*,
        // thus no moving will be performed and only the copying ctor of
        // EntityWrapper can be called
        for (auto&& g : geometries)
            entities_.emplace_back(g, index++);
    }

    explicit GeometriesEntitySet(const std::vector<typename Entity::Geometry>& geometries)
    {
        std::size_t index = 0;
        for (auto&& g : geometries)
            entities_.emplace_back(g, index++);
    }

    explicit GeometriesEntitySet(std::vector<typename Entity::Geometry>&& geometries)
    {
        std::size_t index = 0;
        for (auto&& g : geometries)
            entities_.emplace_back(std::move(g), index++);
    }

    static constexpr int dimensionworld = Entity::Geometry::coorddimension;

    using ctype = typename Entity::Geometry::ctype;

    decltype(auto) size() const
    { return entities_.size(); }

    decltype(auto) begin() const
    { return entities_.begin(); }

    decltype(auto) end() const
    { return entities_.end(); }

    template<class Entity>
    std::size_t index(const Entity& e) const
    { return e.index(); }

    const Entity& entity(std::size_t index) const
    { assert(index < entities_.size()); return entities_[index]; }
 
private:
    std::vector<Entity> entities_;
};

template<class GeoType, std::size_t N>
class FixedSizeGeometriesEntitySet
{
    template<class GT, std::size_t... I>
    FixedSizeGeometriesEntitySet(GT&& gt, std::index_sequence<I...>)
    : entities_{{ Entity(std::get<I>(gt), I)... }}
    { static_assert(sizeof...(I) == N, "Number of geometries must match the size of the entity set"); }
 
public:
    using Entity = Detail::GeometricEntity::EntityWrapper<GeoType>;

    template<class... G>
    FixedSizeGeometriesEntitySet(G&&... g)
    : FixedSizeGeometriesEntitySet(std::forward_as_tuple(std::forward<G>(g)...), std::make_index_sequence<N>{})
    {}

    static constexpr int dimensionworld = Entity::Geometry::coorddimension;

    using ctype = typename Entity::Geometry::ctype;

    constexpr auto size() const
    { return entities_.size(); }

    decltype(auto) begin() const
    { return entities_.begin(); }

    decltype(auto) end() const
    { return entities_.end(); }

    template<class Entity>
    std::size_t index(const Entity& e) const
    { return e.index(); }

    const Entity& entity(std::size_t index) const
    { assert(index < entities_.size()); return entities_[index]; }
 
private:
    std::array<Entity, N> entities_;
};

template<class GeoType>
class SingleGeometryEntitySet
: public FixedSizeGeometriesEntitySet<GeoType, 1>
{
    using ParentType = FixedSizeGeometriesEntitySet<GeoType, 1>;
public:
    using ParentType::ParentType;
};

template<class ct, int dimworld>
class ProcessGeometricEntitySet
{
public:
    using Entity = Detail::GeometricEntity::ProcessEntity<ct, dimworld>;

    static constexpr int dimensionworld = dimworld;

    using ctype = ct;

    explicit ProcessGeometricEntitySet(std::vector<Entity>&& entities)
    : entities_(std::move(entities)) {}

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

    decltype(auto) begin() const
    { return entities_.begin(); }

    decltype(auto) end() const
    { return entities_.end(); }

    std::size_t index(const Entity& e) const
    { return e.index(); }

    const Entity& entity(std::size_t index) const
    { assert(index < entities_.size()); return entities_[index]; }

    int rank(std::size_t index) const
    { assert(index < entities_.size()); return entities_[index].rank(); }
 
private:
    std::vector<Entity> entities_;
};
 
} // end namespace Dumux
 
#endif