template_interface.hpp

// FEAT3: Finite Element Analysis Toolbox, Version 3
// Copyright (C) 2010 by Stefan Turek & the FEAT group
// FEAT3 is released under the GNU General Public License version 3,
// see the file 'copyright.txt' in the top level directory for details.
 
#pragma once
 
#include "kernel/geometry/intern/congruency_sampler.hpp"
#include "kernel/geometry/intern/face_index_mapping.hpp"
#include <kernel/geometry/intern/adaptive_mesh_storage.hpp>
#include <kernel/shape.hpp>
 
namespace FEAT::Geometry
{
  template<typename MeshStorage_, typename QueryShape_>
  class MeshQuery
  {
    // This class is in a strange place where it both requires access to
    // low-level details of the adaptive mesh and is part of the public API. To
    // avoid leaking implementation details directly most types are typedefed
    // below. The constructor is marked private to avoid making the mesh storage
    // part of the public API. AdaptiveMesh is marked as a friend to allow it to
    // construct instances of MeshQuery.
    template<
      typename TemplateSet_,
      typename Shape_,
      int num_coords_,
      typename Coord_>
    friend class AdaptiveMesh;
 
    static constexpr int dimension = QueryShape_::dimension;
 
    using MeshStorage = MeshStorage_;
 
    using Topology = typename MeshStorage::template ElementTopologyByDim<dimension>;
 
    using Children = typename MeshStorage::template ElementChildrenByDim<dimension>;
 
    using TemplateSet = typename MeshStorage::TemplateSet;
 
  public:
    using QueryShape = QueryShape_;
 
    using VertexType = typename MeshStorage_::VertexType;
 
    using VertexCoordinateArray = std::array<VertexType, Shape::FaceTraits<QueryShape_, 0>::count>;
 
    template<int dim_>
    using TopologyByDim = typename MeshStorage::template ElementTopologyByDim<dim_>;
 
    template<int dim_>
    using RefByDim = typename MeshStorage::template ElementRefByDim<dim_>;
 
    template<int dim_>
    using OrientedRefByDim = typename MeshStorage::template OrientedElementRefByDim<dim_>;
 
    using OrientedVertex = OrientedRefByDim<0>;
    using OrientedEdge = OrientedRefByDim<1>;
    using OrientedFace = OrientedRefByDim<2>;
 
    using VertexRef = RefByDim<0>;
    using EdgeRef = RefByDim<1>;
    using FaceRef = RefByDim<2>;
    using CellRef = RefByDim<3>;
 
  private:
    MeshStorage& _storage;
    Topology& _topology;
    Children& _children;
 
    MeshQuery(MeshStorage& storage, Topology& topology, Children& children) :
      _storage(storage),
      _topology(topology),
      _children(children)
    {
    }
 
  public:
    MeshQuery() = delete;
 
    VertexCoordinateArray vertex_coordinates() const
    {
      VertexCoordinateArray result;
 
      auto& vertices = _topology.template by_dim<0>();
      for(int i{0}; i < _topology.template size<0>(); i++)
      {
        result[i] = _storage[vertices[i]].vertex;
      }
      return result;
    }
 
    template<int dim_>
    typename TemplateSet::template RefinementTypeByDim<dim_> type(RefByDim<dim_> ref) const
    {
      return _storage[ref].type;
    }
 
    template<int topo_dim_, int entity_dim_>
    int orientation(const TopologyByDim<topo_dim_>& topology, int elem) const
    {
      static_assert(entity_dim_ < topo_dim_);
 
      using TopoShape = typename Shape::FaceTraits<QueryShape, topo_dim_>::ShapeType;
      using EntityShape = typename Shape::FaceTraits<QueryShape, entity_dim_>::ShapeType;
 
      using LocalMapping = Intern::FaceIndexMapping<TopoShape, entity_dim_, 0>;
      using CongruencySampler = Intern::CongruencySampler<EntityShape>;
 
      static constexpr int num_vertices = Shape::FaceTraits<EntityShape, 0>::count;
 
      std::array<RefByDim<0>, num_vertices> local;
      std::array<RefByDim<0>, num_vertices> foreign;
 
      const auto& entity = _storage[topology.template key_by_dim<entity_dim_>(elem)];
 
      for(int i(0); i < num_vertices; i++)
      {
        local[i] = topology.template key_by_dim<0>(LocalMapping::map(elem, i)).key;
        foreign[i] = entity.topology.template key_by_dim<0>(i).key;
      }
 
      int result = CongruencySampler::compare(local.data(), foreign.data());
      if(result == -1)
      {
        for(int i(0); i < num_vertices; ++i)
        {
          for(int j(0); j < num_vertices; ++j)
          {
            std::cout << "Comparing:\n";
            std::cout << "  Local: " << local[i] << "\n";
            std::cout << "  Foreign: " << foreign[j] << "\n";
          }
        }
 
        XABORTM("Invalid orientation found.");
      }
      return result;
    }
 
    template<int dim_>
    Index topology_size() const
    {
      return Shape::FaceTraits<QueryShape, dim_>::count;
    }
 
    template<int dim_>
    OrientedRefByDim<dim_> topology(Index idx) const
    {
      static_assert(dim_ >= 0, "Invalid shape dimension in MeshQuery::get_from_topology()!");
      static_assert(dim_ <= 3, "Invalid shape dimension in MeshQuery::get_from_topology()!");
 
      return _topology.template key_by_dim<dim_>(idx);
    }
 
    template<int parent_dim_, int child_dim_>
    RefByDim<child_dim_> boundary(Index parent_idx, Index child_idx) const
    {
      static_assert(child_dim_ <= parent_dim_);
      static_assert(child_dim_ >= 0);
 
      auto& parent = _storage[topology<parent_dim_>(parent_idx).key];
      return parent.children.template by_dim<child_dim_>()[child_idx];
    }
 
    template<int dim_>
    RefByDim<dim_> sibling(Index sibling_idx) const
    {
      static_assert(dim_ >= 0, "Invalid shape dimension in MeshQuery::get_from_topology()!");
      static_assert(dim_ <= 3, "Invalid shape dimension in MeshQuery::get_from_topology()!");
 
      return _children.template by_dim<dim_>()[sibling_idx];
    }
  };
 
#ifdef DOXYGEN
  class VertexQuery
  {
    Index num_entities(const MeshQuery& query);
 
    typename MeshQuery_::VertexType_ vertex(const MeshQuery_& query, Index vertex_idx)
  };
 
  /*
   * \brief Template query for vertices.
   *
   * This interface is expected by the AdaptiveMesh for constructing edges,
   * faces, and cells.
   *
   * \author Markus Muegge
   */
  template<int dim_>
  class EntityQuery
  {
    using Topology = typename MeshQuery_::template TopologyByDim<dim_>;
 
    Index num_entities(const MeshQuery& query);
 
    Topology topology(const MeshQuery& query, Index idx)
 
      
      SubdivisionLevelTuple levels(const MeshQuery_& /*query*/, Index edge_idx)
    {
      return {
        _level_spread[_template.template vertex_of<1>(edge_idx, 0)],
        _level_spread[_template.template vertex_of<1>(edge_idx, 1)],
      };
    }
  };
 
  class TemplateSet
  {
  public:
    static constexpr std::uint8_t zero_refinement_type = 0;
    static constexpr std::uint8_t full_refinement_type = 0b11111111;
 
    template<typename Shape_>
    static constexpr bool is_shape_compatible();
 
    template<int template_dim_, int child_dim_>
    static constexpr int max_children();
 
    template<int n>
    static std::uint8_t refinement_type(const Geometry::SubdivisionLevelTuple<n>& levels);
 
    template<typename Mesh_>
    static void convert(const Mesh_& mesh, Geometry::SubdivisionLevels& sdls);
 
    template<int template_dim_, int child_dim_>
    static Index num_children(std::uint8_t type);
 
    template<typename MeshQuery_>
    static TemplateQuery<MeshQuery_, 0> get_query(
      const MeshQuery_& query,
      Geometry::SubdivisionLevelTuple<Shape::FaceTraits<typename MeshQuery_::QueryShape, 0>::count> levels);
 
    static NextQuery advance_query(const MeshQuery_& query, PreviousQuery&& template_query)
 
#endif
  } // namespace FEAT::Geometry