ContextGeometry.hpp

#pragma once

#include <optional>
#include <type_traits>

#include <dune/common/typetraits.hh>
#include <dune/geometry/type.hh>

namespace AMDiS
{
  namespace Impl
  {
    template <class E, class = std::void_t<>>
    struct ContextTypes
    {
      using Entity = E;
      using LocalGeometry = typename E::Geometry;
    };

    // specialization for intersections
    template <class I>
    struct ContextTypes<I, std::void_t<decltype(std::declval<I>().inside())>>
    {
      using Entity = typename I::Entity;
      using LocalGeometry = typename I::LocalGeometry;
    };

  } // end namespace Impl



  template <class LC>
  struct ContextGeometry
  {
    using ContextType = Impl::ContextTypes<LC>;

  public:
    using LocalContext = LC;
    using Element = typename ContextType::Entity;
    using Geometry = typename Element::Geometry;
    using LocalGeometry = typename ContextType::LocalGeometry;

    using IsEntity = std::is_same<Element, LocalContext>;

    enum {
      dim = Geometry::mydimension,    //< the dimension of the grid element
      dow = Geometry::coorddimension  //< the dimension of the world
    };

    ContextGeometry(LocalContext const& localContext, Element const& element, Geometry const& geometry)
      : localContext_(&localContext)
      , element_(&element)
      , geometry_(&geometry)
    {}

  public:
    Element const& element() const
    {
      return *element_;
    }

    LocalContext const& localContext() const
    {
      return *localContext_;
    }

    Geometry const& geometry() const
    {
      return *geometry_;
    }

    LocalGeometry const& localGeometry() const
    {
      return localGeometry_impl(IsEntity{});
    }


  public:

    template <class Coordinate>
    decltype(auto) local(Coordinate const& p) const
    {
      return local_impl(p, IsEntity{});
    }

    template <class Coordinate>
    decltype(auto) global(Coordinate const& p) const
    {
      return geometry_->global(p);
    }

    Dune::GeometryType type() const
    {
      return localContext_->type();
    }

    template <class Coordinate>
    auto integrationElement(Coordinate const& p) const
    {
      return localGeometry().integrationElement(p);
    }

  private: // implementation detail

    // position for elements
    template <class Coordinate>
    Coordinate const& local_impl(Coordinate const& p, std::true_type) const
    {
      return p;
    }

    // position for intersection
    template <class Coordinate>
    auto local_impl(Coordinate const& p, std::false_type) const
    {
      return localGeometry().global(p);
    }

    // local-geometry is the same as geometry
    Geometry const& localGeometry_impl(std::true_type) const
    {
      return *geometry_;
    }

    // local-geometry of intersection in inside element
    LocalGeometry const& localGeometry_impl(std::false_type) const
    {
      if (!localGeometry_)
        localGeometry_.emplace(localContext_->geometryInInside());

      return *localGeometry_;
    }

  private:
    LocalContext const* localContext_;
    Element const* element_;
    Geometry const* geometry_;

    // The localGeometry may be constructed only if needed
    mutable std::optional<LocalGeometry> localGeometry_;
  };

} // end namespace AMDiS