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-FileCopyrightInfo: 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 <memory>
#include <dune/grid/common/mcmgmapper.hh>
#include <dune/geometry/multilineargeometry.hh>
#include <dumux/common/entitymap.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;
 
    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)
    {}
 
    enum { dimensionworld = GridView::dimensionworld };
 
    using ctype = typename GridView::ctype;
 
    decltype(auto) size() const
    { return gridView_.size(codim); }
 
    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_;
};
 
template<class GeoType>
class GeometriesEntitySet
{
    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_;
    };
 
public:
    using Entity = EntityWrapper;
 
    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++);
    }
 
    GeometriesEntitySet(const std::vector<typename Entity::Geometry>& geometries)
    {
        std::size_t index = 0;
        for (auto&& g : geometries)
            entities_.emplace_back(g, index++);
    }
 
    GeometriesEntitySet(std::vector<typename Entity::Geometry>&& geometries)
    {
        std::size_t index = 0;
        for (auto&& g : geometries)
            entities_.emplace_back(std::move(g), index++);
    }
 
    enum { 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_;
};
 
} // end namespace Dumux
 
#endif