projection.hh

// SPDX-FileCopyrightInfo: Copyright © DUNE Project contributors, see file LICENSE.md in module root
// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-GPL-2.0-only-with-dune-grid-glue-exception
#ifndef DUNE_GRIDGLUE_COMMON_PROJECTIONHELPER2_HH
#define DUNE_GRIDGLUE_COMMON_PROJECTIONHELPER2_HH
 
#include <array>
#include <bitset>
#include <tuple>
 
namespace Dune {
namespace GridGlue {
 
template<typename Coordinate>
class Projection
{
public:
  struct EdgeIntersection
  {
    std::array<unsigned, 2> edge;
 
    std::array<Coordinate, 2> local;
  };
 
  constexpr static unsigned dim = Coordinate::dimension;
 
  constexpr static unsigned maxEdgeIntersections = dim == 3 ? 9 : 0;
 
  static_assert(dim == 2 || dim == 3, "Projection only implemented for dim=2 or dim=3");
 
  typedef typename Coordinate::field_type Field;
 
  typedef std::array<Coordinate, dim> Images;
 
  typedef Images Preimages;
 
private:
  const Field m_overlap;
 
  const Field m_max_normal_product;
 
  Field m_epsilon = Field(1e-12);
 
  std::tuple<Images, Preimages> m_images;
 
  std::tuple<std::bitset<dim>, std::bitset<dim> > m_success;
 
  unsigned m_number_of_edge_intersections;
 
  std::array<EdgeIntersection, maxEdgeIntersections> m_edge_intersections;
 
  bool m_projection_valid;
 
  template<typename Corners, typename Normals>
  void doProjection(const std::tuple<Corners&, Corners&>& corners, const std::tuple<Normals&, Normals&>& normals);
 
  template<typename Corners, typename Normals>
  void doInverseProjection(const std::tuple<Corners&, Corners&>& corners, const std::tuple<Normals&, Normals&>& normals);
 
  template<typename Corners, typename Normals>
  void doEdgeIntersection(const std::tuple<Corners&, Corners&>& corners, const std::tuple<Normals&, Normals&>& normals);
 
  template<typename Corners, typename Normals>
  inline bool projectionFeasible(const Coordinate& x, const Coordinate& nx, const Coordinate& px, const Corners& corners, const Normals& normals) const;
 
public:
  Projection(const Field overlap = Field(0), const Field max_normal_product = Field(-0.1));
 
  void epsilon(const Field epsilon);
 
  template<typename Corners, typename Normals>
  void project(const std::tuple<Corners&, Corners&>& corners, const std::tuple<Normals&, Normals&>& normals);
 
  const std::tuple<Images, Preimages>& images() const
    { return m_images; }
 
  const std::tuple<std::bitset<dim>, std::bitset<dim> >& success() const
    { return m_success; }
 
  unsigned numberOfEdgeIntersections() const
    { return m_number_of_edge_intersections; }
 
  const std::array<EdgeIntersection, maxEdgeIntersections>& edgeIntersections() const
    { return m_edge_intersections; }
};
 
} /* namespace GridGlue */
} /* namespace Dune */
 
#include "projection_impl.hh"
 
#endif