tria_accessor.h

// ---------------------------------------------------------------------
//
// Copyright (C) 1998 - 2018 by the deal.II authors
//
// This file is part of the deal.II library.
//
// The deal.II library is free software; you can use it, redistribute
// it, and/or modify it under the terms of the GNU Lesser General
// Public License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// The full text of the license can be found in the file LICENSE.md at
// the top level directory of deal.II.
//
// ---------------------------------------------------------------------

#ifndef dealii_tria_accessor_h
#define dealii_tria_accessor_h


#include <deal.II/base/config.h>

#include <deal.II/base/bounding_box.h>
#include <deal.II/base/exceptions.h>
#include <deal.II/base/geometry_info.h>
#include <deal.II/base/point.h>

#include <deal.II/grid/cell_id.h>
#include <deal.II/grid/tria_iterator_base.h>
#include <deal.II/grid/tria_iterator_selector.h>

#include <utility>


DEAL_II_NAMESPACE_OPEN

template <int dim, int spacedim>
class Triangulation;
template <typename Accessor>
class TriaRawIterator;
template <typename Accessor>
class TriaIterator;
template <typename Accessor>
class TriaActiveIterator;

template <int dim, int spacedim>
class Manifold;


namespace internal
{
  namespace TriangulationImplementation
  {
    template <int dim>
    class TriaObject;
    template <typename G>
    class TriaObjects;
    struct Implementation;
  } // namespace TriangulationImplementation

  namespace TriaAccessorImplementation
  {
    struct Implementation;

    template <int structdim, int dim>
    struct PresentLevelType
    {
      struct type
      {
        type() = default;

        type(const int level)
        {
          Assert(level == 0, ExcInternalError());
          (void)level; // removes -Wunused-parameter warning in optimized mode
        }

        operator int() const
        {
          return 0;
        }

        void
        operator++() const
        {
          Assert(false, ExcInternalError());
        }

        void
        operator--() const
        {
          Assert(false, ExcInternalError());
        }
      };
    };


    template <int dim>
    struct PresentLevelType<dim, dim>
    {
      using type = int;
    };

  } // namespace TriaAccessorImplementation
} // namespace internal
template <int structdim, int dim, int spacedim>
class TriaAccessor;
template <int dim, int spacedim>
class TriaAccessor<0, dim, spacedim>;
template <int spacedim>
class TriaAccessor<0, 1, spacedim>;

// note: the file tria_accessor.templates.h is included at the end of
// this file.  this includes a lot of templates. originally, this was
// only done in debug mode, but led to cyclic reduction problems and
// so is now on by default.


namespace TriaAccessorExceptions
{
  DeclExceptionMsg(ExcCellNotUsed,
                   "The operation you are attempting can only be performed for "
                   "(cell, face, or edge) iterators that point to valid "
                   "objects. These objects need not necessarily be active, "
                   "i.e., have no children, but they need to be part of a "
                   "triangulation. (The objects pointed to by an iterator "
                   "may -- after coarsening -- also be objects that used "
                   "to be part of a triangulation, but are now no longer "
                   "used. Their memory location may have been retained "
                   "for re-use upon the next mesh refinement, but is "
                   "currently unused.)");
  DeclExceptionMsg(ExcCellNotActive,
                   "The operation you are attempting can only be performed for "
                   "(cell, face, or edge) iterators that point to 'active' "
                   "objects. 'Active' objects are those that do not have "
                   "children (in the case of cells), or that are part of "
                   "an active cell (in the case of faces or edges). However, "
                   "the object on which you are trying the current "
                   "operation is not 'active' in this sense.");
  DeclExceptionMsg(ExcCellHasNoChildren,
                   "The operation you are attempting can only be performed for "
                   "(cell, face, or edge) iterators that have children, "
                   "but the object on which you are trying the current "
                   "operation does not have any.");
  DeclExceptionMsg(ExcCellHasNoParent,
                   "The operation you are attempting can only be performed for "
                   "(cell, face, or edge) iterators that have a parent object, "
                   "but the object on which you are trying the current "
                   "operation does not have one -- i.e., it is on the "
                   "coarsest level of the triangulation.");
  DeclException1(ExcCantSetChildren,
                 int,
                 << "You can only set the child index if the cell does not "
                 << "currently have children registered; or you can clear it. "
                 << "The given index was " << arg1
                 << " (-1 means: clear children).");
  template <typename AccessorType>
  DeclException1(ExcDereferenceInvalidObject,
                 AccessorType,
                 << "You tried to dereference an iterator for which this "
                 << "is not possible. More information on this iterator: "
                 << "index=" << arg1.index() << ", state="
                 << (arg1.state() == IteratorState::valid ?
                       "valid" :
                       (arg1.state() == IteratorState::past_the_end ?
                          "past_the_end" :
                          "invalid")));
  DeclExceptionMsg(ExcCantCompareIterators,
                   "Iterators can only be compared if they point to the same "
                   "triangulation, or if neither of them are associated "
                   "with a triangulation.");
  // TODO: Write documentation!
  DeclException0(ExcNeighborIsCoarser);
  // TODO: Write documentation!
  DeclException0(ExcNeighborIsNotCoarser);
  DeclException0(ExcFacesHaveNoLevel);
  DeclException0(ExcNoPeriodicNeighbor);
  // TODO: Write documentation!
  DeclException1(
    ExcSetOnlyEvenChildren,
    int,
    << "You can only set the child index of an even numbered child."
    << "The number of the child given was " << arg1 << ".");
} // namespace TriaAccessorExceptions


template <int structdim, int dim, int spacedim = dim>
class TriaAccessorBase
{
public:
  static const unsigned int space_dimension = spacedim;

  static const unsigned int dimension = dim;

  static const unsigned int structure_dimension = structdim;

protected:
  using AccessorData = void;

  TriaAccessorBase(const Triangulation<dim, spacedim> *parent = nullptr,
                   const int                           level  = -1,
                   const int                           index  = -1,
                   const AccessorData *                       = nullptr);

  TriaAccessorBase(const TriaAccessorBase &);

  void
  operator=(const TriaAccessorBase *) = delete;

  void
  copy_from(const TriaAccessorBase &);

  TriaAccessorBase &
  operator=(const TriaAccessorBase &);

  bool
  operator<(const TriaAccessorBase &other) const;

protected:
  bool
  operator==(const TriaAccessorBase &) const;

  bool
  operator!=(const TriaAccessorBase &) const;

  void
  operator++();

  void
  operator--();
  ::internal::TriangulationImplementation::TriaObjects<
    ::internal::TriangulationImplementation::TriaObject<structdim>> &
  objects() const;

public:
  using LocalData = void *;

  int
  level() const;

  int
  index() const;

  IteratorState::IteratorStates
  state() const;

  const Triangulation<dim, spacedim> &
  get_triangulation() const;

protected:
  typename ::internal::TriaAccessorImplementation::
    PresentLevelType<structdim, dim>::type present_level;

  int present_index;

  const Triangulation<dim, spacedim> *tria;

private:
  template <typename Accessor>
  friend class TriaRawIterator;
  template <typename Accessor>
  friend class TriaIterator;
  template <typename Accessor>
  friend class TriaActiveIterator;
};



template <int structdim, int dim, int spacedim = dim>
class InvalidAccessor : public TriaAccessorBase<structdim, dim, spacedim>
{
public:
  using AccessorData =
    typename TriaAccessorBase<structdim, dim, spacedim>::AccessorData;

  InvalidAccessor(const Triangulation<dim, spacedim> *parent     = nullptr,
                  const int                           level      = -1,
                  const int                           index      = -1,
                  const AccessorData *                local_data = nullptr);

  InvalidAccessor(const InvalidAccessor &);

  template <typename OtherAccessor>
  InvalidAccessor(const OtherAccessor &);

  void
  copy_from(const InvalidAccessor &);

  bool
  operator==(const InvalidAccessor &) const;
  bool
  operator!=(const InvalidAccessor &) const;

  void
  operator++() const;
  void
  operator--() const;

  bool
  used() const;

  bool
  has_children() const;

  types::manifold_id
  manifold_id() const;

  Point<spacedim> &
  vertex(const unsigned int i) const;

  typename ::internal::TriangulationImplementation::
    Iterators<dim, spacedim>::line_iterator
    line(const unsigned int i) const;

  typename ::internal::TriangulationImplementation::
    Iterators<dim, spacedim>::quad_iterator
    quad(const unsigned int i) const;
};



template <int structdim, int dim, int spacedim>
class TriaAccessor : public TriaAccessorBase<structdim, dim, spacedim>
{
public:
  using AccessorData =
    typename TriaAccessorBase<structdim, dim, spacedim>::AccessorData;

  TriaAccessor(const Triangulation<dim, spacedim> *parent     = nullptr,
               const int                           level      = -1,
               const int                           index      = -1,
               const AccessorData *                local_data = nullptr);

  template <int structdim2, int dim2, int spacedim2>
  TriaAccessor(const InvalidAccessor<structdim2, dim2, spacedim2> &);

  template <int structdim2, int dim2, int spacedim2>
  TriaAccessor(const TriaAccessor<structdim2, dim2, spacedim2> &);

  void
  operator=(const TriaAccessor &) = delete;

  bool
  used() const;

  TriaIterator<TriaAccessor<0, dim, spacedim>>
  vertex_iterator(const unsigned int i) const;

  unsigned int
  vertex_index(const unsigned int i) const;

  Point<spacedim> &
  vertex(const unsigned int i) const;

  typename ::internal::TriangulationImplementation::
    Iterators<dim, spacedim>::line_iterator
    line(const unsigned int i) const;

  unsigned int
  line_index(const unsigned int i) const;

  typename ::internal::TriangulationImplementation::
    Iterators<dim, spacedim>::quad_iterator
    quad(const unsigned int i) const;

  unsigned int
  quad_index(const unsigned int i) const;
  bool
  face_orientation(const unsigned int face) const;

  bool
  face_flip(const unsigned int face) const;

  bool
  face_rotation(const unsigned int face) const;

  bool
  line_orientation(const unsigned int line) const;
  bool
  has_children() const;

  unsigned int
  n_children() const;

  unsigned int
  number_of_children() const;

  unsigned int
  max_refinement_depth() const;

  TriaIterator<TriaAccessor<structdim, dim, spacedim>>
  child(const unsigned int i) const;

  TriaIterator<TriaAccessor<structdim, dim, spacedim>>
  isotropic_child(const unsigned int i) const;

  RefinementCase<structdim>
  refinement_case() const;

  int
  child_index(const unsigned int i) const;

  int
  isotropic_child_index(const unsigned int i) const;
  types::boundary_id
  boundary_id() const;

  void
  set_boundary_id(const types::boundary_id) const;

  void
  set_all_boundary_ids(const types::boundary_id) const;

  bool
  at_boundary() const;

  const Manifold<dim, spacedim> &
  get_manifold() const;

  types::manifold_id
  manifold_id() const;

  void
  set_manifold_id(const types::manifold_id) const;

  void
  set_all_manifold_ids(const types::manifold_id) const;

  bool
  user_flag_set() const;

  void
  set_user_flag() const;

  void
  clear_user_flag() const;

  void
  recursively_set_user_flag() const;

  void
  recursively_clear_user_flag() const;

  void
  clear_user_data() const;

  void
  set_user_pointer(void *p) const;

  void
  clear_user_pointer() const;

  void *
  user_pointer() const;

  void
  recursively_set_user_pointer(void *p) const;

  void
  recursively_clear_user_pointer() const;

  void
  set_user_index(const unsigned int p) const;

  void
  clear_user_index() const;

  unsigned int
  user_index() const;

  void
  recursively_set_user_index(const unsigned int p) const;

  void
  recursively_clear_user_index() const;
  double
  diameter() const;

  std::pair<Point<spacedim>, double>
  enclosing_ball() const;

  BoundingBox<spacedim>
  bounding_box() const;

  double
  extent_in_direction(const unsigned int axis) const;

  double
  minimum_vertex_distance() const;

  Point<spacedim>
  intermediate_point(const Point<structdim> &coordinates) const;

  Point<structdim>
  real_to_unit_cell_affine_approximation(const Point<spacedim> &point) const;

  Point<spacedim>
  center(const bool respect_manifold             = false,
         const bool interpolate_from_surrounding = false) const;

  Point<spacedim>
  barycenter() const;

  double
  measure() const;

  bool
  is_translation_of(
    const TriaIterator<TriaAccessor<structdim, dim, spacedim>> &o) const;

private:
  void
  set_boundary_id_internal(const types::boundary_id id) const;

  void
  set(const ::internal::TriangulationImplementation::TriaObject<structdim>
        &o) const;

  void
  set_line_orientation(const unsigned int line, const bool orientation) const;

  void
  set_face_orientation(const unsigned int face, const bool orientation) const;

  void
  set_face_flip(const unsigned int face, const bool flip) const;

  void
  set_face_rotation(const unsigned int face, const bool rotation) const;

  void
  set_used_flag() const;

  void
  clear_used_flag() const;

  void
  set_refinement_case(const RefinementCase<structdim> &ref_case) const;

  void
  clear_refinement_case() const;

  void
  set_children(const unsigned int i, const int index) const;

  void
  clear_children() const;

private:
  template <int, int>
  friend class Triangulation;

  friend struct ::internal::TriangulationImplementation::Implementation;
  friend struct ::internal::TriaAccessorImplementation::Implementation;
};



template <int dim, int spacedim>
class TriaAccessor<0, dim, spacedim>
{
public:
  static const unsigned int space_dimension = spacedim;

  static const unsigned int dimension = dim;

  static const unsigned int structure_dimension = 0;

  using AccessorData = void;

  TriaAccessor(const Triangulation<dim, spacedim> *tria,
               const unsigned int                  vertex_index);

  TriaAccessor(const Triangulation<dim, spacedim> *tria  = nullptr,
               const int                           level = 0,
               const int                           index = 0,
               const AccessorData *                      = nullptr);

  template <int structdim2, int dim2, int spacedim2>
  TriaAccessor(const TriaAccessor<structdim2, dim2, spacedim2> &);

  template <int structdim2, int dim2, int spacedim2>
  TriaAccessor(const InvalidAccessor<structdim2, dim2, spacedim2> &);

  IteratorState::IteratorStates
  state() const;

  static int
  level();

  int
  index() const;

  void
  operator++();

  void
  operator--();
  bool
  operator==(const TriaAccessor &) const;

  bool
  operator!=(const TriaAccessor &) const;

  unsigned int
  vertex_index(const unsigned int i = 0) const;

  Point<spacedim> &
  vertex(const unsigned int i = 0) const;

  typename ::internal::TriangulationImplementation::
    Iterators<dim, spacedim>::line_iterator static line(const unsigned int);

  static unsigned int
  line_index(const unsigned int i);

  static typename ::internal::TriangulationImplementation::
    Iterators<dim, spacedim>::quad_iterator
    quad(const unsigned int i);

  static unsigned int
  quad_index(const unsigned int i);

  double
  diameter() const;

  double
  extent_in_direction(const unsigned int axis) const;

  Point<spacedim>
  center(const bool respect_manifold             = false,
         const bool interpolate_from_surrounding = false) const;

  double
  measure() const;
  static bool
  face_orientation(const unsigned int face);

  static bool
  face_flip(const unsigned int face);

  static bool
  face_rotation(const unsigned int face);

  static bool
  line_orientation(const unsigned int line);

  static bool
  has_children();

  static unsigned int
  n_children();

  static unsigned int
  number_of_children();

  static unsigned int
  max_refinement_depth();

  static TriaIterator<TriaAccessor<0, dim, spacedim>>
  child(const unsigned int);

  static TriaIterator<TriaAccessor<0, dim, spacedim>>
  isotropic_child(const unsigned int);

  static RefinementCase<0>
  refinement_case();

  static int
  child_index(const unsigned int i);

  static int
  isotropic_child_index(const unsigned int i);
  bool
  used() const;

protected:
  void
  copy_from(const TriaAccessor &);

  const Triangulation<dim, spacedim> *tria;

  unsigned int global_vertex_index;

private:
  template <typename Accessor>
  friend class TriaRawIterator;
  template <typename Accessor>
  friend class TriaIterator;
  template <typename Accessor>
  friend class TriaActiveIterator;
};



template <int spacedim>
class TriaAccessor<0, 1, spacedim>
{
public:
  static const unsigned int space_dimension = spacedim;

  static const unsigned int dimension = 1;

  static const unsigned int structure_dimension = 0;

  using AccessorData = void;

  enum VertexKind
  {
    left_vertex,
    interior_vertex,
    right_vertex
  };

  TriaAccessor(const Triangulation<1, spacedim> *tria,
               const VertexKind                  vertex_kind,
               const unsigned int                vertex_index);

  TriaAccessor(const Triangulation<1, spacedim> *tria = nullptr,
               const int                              = 0,
               const int                              = 0,
               const AccessorData *                   = nullptr);

  template <int structdim2, int dim2, int spacedim2>
  TriaAccessor(const TriaAccessor<structdim2, dim2, spacedim2> &);

  template <int structdim2, int dim2, int spacedim2>
  TriaAccessor(const InvalidAccessor<structdim2, dim2, spacedim2> &);

  void
  copy_from(const TriaAccessor &);

  static IteratorState::IteratorStates
  state();

  static int
  level();

  int
  index() const;

  void
  operator++() const;

  void
  operator--() const;
  bool
  operator==(const TriaAccessor &) const;

  bool
  operator!=(const TriaAccessor &) const;

  unsigned int
  vertex_index(const unsigned int i = 0) const;

  Point<spacedim> &
  vertex(const unsigned int i = 0) const;

  Point<spacedim>
  center() const;

  typename ::internal::TriangulationImplementation::
    Iterators<1, spacedim>::line_iterator static line(const unsigned int);

  static unsigned int
  line_index(const unsigned int i);

  static typename ::internal::TriangulationImplementation::
    Iterators<1, spacedim>::quad_iterator
    quad(const unsigned int i);

  static unsigned int
  quad_index(const unsigned int i);

  bool
  at_boundary() const;

  types::boundary_id
  boundary_id() const;

  const Manifold<1, spacedim> &
  get_manifold() const;

  types::manifold_id
  manifold_id() const;


  static bool
  face_orientation(const unsigned int face);

  static bool
  face_flip(const unsigned int face);

  static bool
  face_rotation(const unsigned int face);

  static bool
  line_orientation(const unsigned int line);

  static bool
  has_children();

  static unsigned int
  n_children();

  static unsigned int
  number_of_children();

  static unsigned int
  max_refinement_depth();

  static TriaIterator<TriaAccessor<0, 1, spacedim>>
  child(const unsigned int);

  static TriaIterator<TriaAccessor<0, 1, spacedim>>
  isotropic_child(const unsigned int);

  static RefinementCase<0>
  refinement_case();

  static int
  child_index(const unsigned int i);

  static int
  isotropic_child_index(const unsigned int i);
  void
  set_boundary_id(const types::boundary_id);

  void
  set_manifold_id(const types::manifold_id);

  void
  set_all_boundary_ids(const types::boundary_id);

  void
  set_all_manifold_ids(const types::manifold_id);
  bool
  used() const;

protected:
  const Triangulation<1, spacedim> *tria;

  VertexKind vertex_kind;

  unsigned int global_vertex_index;
};



template <int dim, int spacedim = dim>
class CellAccessor : public TriaAccessor<dim, dim, spacedim>
{
public:
  using AccessorData = typename TriaAccessor<dim, dim, spacedim>::AccessorData;

  using Container = Triangulation<dim, spacedim>;

  CellAccessor(const Triangulation<dim, spacedim> *parent     = nullptr,
               const int                           level      = -1,
               const int                           index      = -1,
               const AccessorData *                local_data = nullptr);

  CellAccessor(const TriaAccessor<dim, dim, spacedim> &cell_accessor);

  template <int structdim2, int dim2, int spacedim2>
  CellAccessor(const InvalidAccessor<structdim2, dim2, spacedim2> &);

  template <int structdim2, int dim2, int spacedim2>
  CellAccessor(const TriaAccessor<structdim2, dim2, spacedim2> &);

  void
  operator=(const CellAccessor<dim, spacedim> &) = delete;

  TriaIterator<CellAccessor<dim, spacedim>>
  child(const unsigned int i) const;

  TriaIterator<TriaAccessor<dim - 1, dim, spacedim>>
  face(const unsigned int i) const;

  unsigned int
  face_index(const unsigned int i) const;

  TriaIterator<CellAccessor<dim, spacedim>>
  neighbor_child_on_subface(const unsigned int face_no,
                            const unsigned int subface_no) const;

  TriaIterator<CellAccessor<dim, spacedim>>
  neighbor(const unsigned int i) const;

  int
  neighbor_index(const unsigned int i) const;

  int
  neighbor_level(const unsigned int i) const;

  unsigned int
  neighbor_of_neighbor(const unsigned int neighbor) const;

  bool
  neighbor_is_coarser(const unsigned int neighbor) const;

  std::pair<unsigned int, unsigned int>
  neighbor_of_coarser_neighbor(const unsigned int neighbor) const;

  unsigned int
  neighbor_face_no(const unsigned int neighbor) const;

  static bool
  is_level_cell();

  bool
  has_periodic_neighbor(const unsigned int i) const;

  TriaIterator<CellAccessor<dim, spacedim>>
  periodic_neighbor(const unsigned int i) const;

  TriaIterator<CellAccessor<dim, spacedim>>
  neighbor_or_periodic_neighbor(const unsigned int i) const;

  TriaIterator<CellAccessor<dim, spacedim>>
  periodic_neighbor_child_on_subface(const unsigned int face_no,
                                     const unsigned int subface_no) const;

  std::pair<unsigned int, unsigned int>
  periodic_neighbor_of_coarser_periodic_neighbor(const unsigned face_no) const;

  int
  periodic_neighbor_index(const unsigned int i) const;

  int
  periodic_neighbor_level(const unsigned int i) const;

  unsigned int
  periodic_neighbor_of_periodic_neighbor(const unsigned int i) const;

  unsigned int
  periodic_neighbor_face_no(const unsigned int i) const;

  bool
  periodic_neighbor_is_coarser(const unsigned int i) const;

  bool
  at_boundary(const unsigned int i) const;

  bool
  at_boundary() const;

  bool
  has_boundary_lines() const;
  RefinementCase<dim>
  refine_flag_set() const;

  void
  set_refine_flag(const RefinementCase<dim> ref_case =
                    RefinementCase<dim>::isotropic_refinement) const;

  void
  clear_refine_flag() const;

  bool
  flag_for_face_refinement(
    const unsigned int             face_no,
    const RefinementCase<dim - 1> &face_refinement_case =
      RefinementCase<dim - 1>::isotropic_refinement) const;

  bool
  flag_for_line_refinement(const unsigned int line_no) const;

  ::internal::SubfaceCase<dim>
  subface_case(const unsigned int face_no) const;

  bool
  coarsen_flag_set() const;

  void
  set_coarsen_flag() const;

  void
  clear_coarsen_flag() const;
  types::material_id
  material_id() const;

  void
  set_material_id(const types::material_id new_material_id) const;

  void
  recursively_set_material_id(const types::material_id new_material_id) const;
  types::subdomain_id
  subdomain_id() const;

  void
  set_subdomain_id(const types::subdomain_id new_subdomain_id) const;

  types::subdomain_id
  level_subdomain_id() const;

  void
  set_level_subdomain_id(
    const types::subdomain_id new_level_subdomain_id) const;


  void
  recursively_set_subdomain_id(
    const types::subdomain_id new_subdomain_id) const;
  bool
  direction_flag() const;

  unsigned int
  active_cell_index() const;

  int
  parent_index() const;

  TriaIterator<CellAccessor<dim, spacedim>>
  parent() const;

  bool
  active() const;

  bool
  is_locally_owned() const;

  bool
  is_locally_owned_on_level() const;

  bool
  is_ghost() const;

  bool
  is_artificial() const;

  bool
  point_inside(const Point<spacedim> &p) const;

  void
  set_neighbor(const unsigned int                               i,
               const TriaIterator<CellAccessor<dim, spacedim>> &pointer) const;

  CellId
  id() const;

  DeclException0(ExcRefineCellNotActive);
  DeclException0(ExcCellFlaggedForRefinement);
  DeclException0(ExcCellFlaggedForCoarsening);

protected:
  unsigned int
  neighbor_of_neighbor_internal(const unsigned int neighbor) const;

  template <int dim_, int spacedim_>
  bool
  point_inside_codim(const Point<spacedim_> &p) const;



private:
  void
  set_active_cell_index(const unsigned int active_cell_index);

  void
  set_parent(const unsigned int parent_index);

  void
  set_direction_flag(const bool new_direction_flag) const;

  template <int, int>
  friend class Triangulation;

  friend struct ::internal::TriangulationImplementation::Implementation;
};



/* ----- declaration of explicit specializations and general templates ----- */


template <int structdim, int dim, int spacedim>
template <typename OtherAccessor>
InvalidAccessor<structdim, dim, spacedim>::InvalidAccessor(
  const OtherAccessor &)
{
  Assert(false,
         ExcMessage("You are attempting an illegal conversion between "
                    "iterator/accessor types. The constructor you call "
                    "only exists to make certain template constructs "
                    "easier to write as dimension independent code but "
                    "the conversion is not valid in the current context."));
}



template <int structdim, int dim, int spacedim>
template <int structdim2, int dim2, int spacedim2>
TriaAccessor<structdim, dim, spacedim>::TriaAccessor(
  const InvalidAccessor<structdim2, dim2, spacedim2> &)
{
  Assert(false,
         ExcMessage("You are attempting an illegal conversion between "
                    "iterator/accessor types. The constructor you call "
                    "only exists to make certain template constructs "
                    "easier to write as dimension independent code but "
                    "the conversion is not valid in the current context."));
}



template <int dim, int spacedim>
template <int structdim2, int dim2, int spacedim2>
CellAccessor<dim, spacedim>::CellAccessor(
  const InvalidAccessor<structdim2, dim2, spacedim2> &)
{
  Assert(false,
         ExcMessage("You are attempting an illegal conversion between "
                    "iterator/accessor types. The constructor you call "
                    "only exists to make certain template constructs "
                    "easier to write as dimension independent code but "
                    "the conversion is not valid in the current context."));
}



template <int structdim, int dim, int spacedim>
template <int structdim2, int dim2, int spacedim2>
TriaAccessor<structdim, dim, spacedim>::TriaAccessor(
  const TriaAccessor<structdim2, dim2, spacedim2> &)
{
  Assert(false,
         ExcMessage("You are attempting an illegal conversion between "
                    "iterator/accessor types. The constructor you call "
                    "only exists to make certain template constructs "
                    "easier to write as dimension independent code but "
                    "the conversion is not valid in the current context."));
}



template <int dim, int spacedim>
template <int structdim2, int dim2, int spacedim2>
CellAccessor<dim, spacedim>::CellAccessor(
  const TriaAccessor<structdim2, dim2, spacedim2> &)
{
  Assert(false,
         ExcMessage("You are attempting an illegal conversion between "
                    "iterator/accessor types. The constructor you call "
                    "only exists to make certain template constructs "
                    "easier to write as dimension independent code but "
                    "the conversion is not valid in the current context."));
}


#ifndef DOXYGEN

template <>
bool
CellAccessor<1, 1>::point_inside(const Point<1> &) const;
template <>
bool
CellAccessor<2, 2>::point_inside(const Point<2> &) const;
template <>
bool
CellAccessor<3, 3>::point_inside(const Point<3> &) const;
template <>
bool
CellAccessor<1, 2>::point_inside(const Point<2> &) const;
template <>
bool
CellAccessor<1, 3>::point_inside(const Point<3> &) const;
template <>
bool
CellAccessor<2, 3>::point_inside(const Point<3> &) const;
// -------------------------------------------------------------------

template <>
void
TriaAccessor<3, 3, 3>::set_all_manifold_ids(const types::manifold_id) const;

#endif // DOXYGEN

DEAL_II_NAMESPACE_CLOSE

// include more templates in debug and optimized mode
#include "tria_accessor.templates.h"

#endif