manifold_lib.h

Go to the documentation of this file.

// -----------------------------------------------------------------------------
//
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception OR LGPL-2.1-or-later
// Copyright (C) 2014 - 2025 by the deal.II authors
//
// This file is part of the deal.II library.
//
// Detailed license information governing the source code and contributions
// can be found in LICENSE.md and CONTRIBUTING.md at the top level directory.
//
// -----------------------------------------------------------------------------
 
#ifndef dealii_manifold_lib_h
#define dealii_manifold_lib_h
 
 
#include <deal.II/base/config.h>
 
#include <deal.II/base/function.h>
#include <deal.II/base/function_parser.h>
 
#include <deal.II/grid/manifold.h>
 
#include <boost/signals2/connection.hpp>
 
 
DEAL_II_NAMESPACE_OPEN
 
// forward declaration
namespace internal
{
  namespace MappingQImplementation
  {
    template <int, int>
    class InverseQuadraticApproximation;
  }
} // namespace internal
 
 
template <int dim, int spacedim = dim>
class PolarManifold : public ChartManifold<dim, spacedim, spacedim>
{
public:
  PolarManifold(const Point<spacedim> center = Point<spacedim>());
 
  virtual std::unique_ptr<Manifold<dim, spacedim>>
  clone() const override;
 
  virtual Point<spacedim>
  pull_back(const Point<spacedim> &space_point) const override;
 
  virtual Point<spacedim>
  push_forward(const Point<spacedim> &chart_point) const override;
 
  virtual DerivativeForm<1, spacedim, spacedim>
  push_forward_gradient(const Point<spacedim> &chart_point) const override;
 
  virtual Tensor<1, spacedim>
  normal_vector(
    const typename Triangulation<dim, spacedim>::face_iterator &face,
    const Point<spacedim> &p) const override;
 
  const Point<spacedim> &
  get_center() const;
 
  DEAL_II_DEPRECATED_WITH_COMMENT(
    "Access the center with get_center() instead.")
  const Point<spacedim> center;
 
private:
  const Point<spacedim> p_center;
 
  static Tensor<1, spacedim>
  get_periodicity();
};
 
 
 
template <int dim, int spacedim = dim>
class SphericalManifold : public Manifold<dim, spacedim>
{
public:
  SphericalManifold(const Point<spacedim> center = Point<spacedim>());
 
  virtual std::unique_ptr<Manifold<dim, spacedim>>
  clone() const override;
 
  virtual Point<spacedim>
  get_intermediate_point(const Point<spacedim> &p1,
                         const Point<spacedim> &p2,
                         const double           w) const override;
 
  virtual Tensor<1, spacedim>
  get_tangent_vector(const Point<spacedim> &x1,
                     const Point<spacedim> &x2) const override;
 
  virtual Tensor<1, spacedim>
  normal_vector(
    const typename Triangulation<dim, spacedim>::face_iterator &face,
    const Point<spacedim> &p) const override;
 
  virtual void
  get_normals_at_vertices(
    const typename Triangulation<dim, spacedim>::face_iterator &face,
    typename Manifold<dim, spacedim>::FaceVertexNormals &face_vertex_normals)
    const override;
 
  virtual void
  get_new_points(const ArrayView<const Point<spacedim>> &surrounding_points,
                 const Table<2, double>                 &weights,
                 ArrayView<Point<spacedim>> new_points) const override;
 
  virtual Point<spacedim>
  get_new_point(const ArrayView<const Point<spacedim>> &vertices,
                const ArrayView<const double>          &weights) const override;
 
  const Point<spacedim> &
  get_center() const;
 
  DEAL_II_DEPRECATED_WITH_COMMENT(
    "Access the center with get_center() instead.")
  const Point<spacedim> center;
 
private:
  const Point<spacedim> p_center;
 
  std::pair<double, Tensor<1, spacedim>>
  guess_new_point(const ArrayView<const Tensor<1, spacedim>> &directions,
                  const ArrayView<const double>              &distances,
                  const ArrayView<const double>              &weights) const;
 
  void
  do_get_new_points(const ArrayView<const Point<spacedim>> &surrounding_points,
                    const ArrayView<const double>          &weights,
                    ArrayView<Point<spacedim>>              new_points) const;
 
  const PolarManifold<spacedim> polar_manifold;
};
 
template <int dim, int spacedim = dim>
class CylindricalManifold : public ChartManifold<dim, spacedim, 3>
{
public:
  CylindricalManifold(const unsigned int axis      = 0,
                      const double       tolerance = 1e-10);
 
  CylindricalManifold(const Tensor<1, spacedim> &direction,
                      const Point<spacedim>     &point_on_axis,
                      const double               tolerance = 1e-10);
 
  virtual std::unique_ptr<Manifold<dim, spacedim>>
  clone() const override;
 
  virtual Point<3>
  pull_back(const Point<spacedim> &space_point) const override;
 
  virtual Point<spacedim>
  push_forward(const Point<3> &chart_point) const override;
 
  virtual DerivativeForm<1, 3, spacedim>
  push_forward_gradient(const Point<3> &chart_point) const override;
 
  virtual Point<spacedim>
  get_new_point(const ArrayView<const Point<spacedim>> &surrounding_points,
                const ArrayView<const double>          &weights) const override;
 
  const Tensor<1, spacedim> &
  get_direction() const;
 
  const Point<spacedim> &
  get_point_on_axis() const;
 
  double
  get_tolerance() const;
 
private:
  const Tensor<1, spacedim> normal_direction;
 
  const Tensor<1, spacedim> direction;
 
  const Point<spacedim> point_on_axis;
 
  const double tolerance;
 
  const Tensor<1, spacedim> dxn;
};
 
template <int dim, int spacedim = dim>
class EllipticalManifold : public ChartManifold<dim, spacedim, spacedim>
{
public:
  EllipticalManifold(const Point<spacedim>     &center,
                     const Tensor<1, spacedim> &major_axis_direction,
                     const double               eccentricity);
 
  virtual std::unique_ptr<Manifold<dim, spacedim>>
  clone() const override;
 
  virtual Point<spacedim>
  pull_back(const Point<spacedim> &space_point) const override;
 
  virtual Point<spacedim>
  push_forward(const Point<spacedim> &chart_point) const override;
 
  virtual DerivativeForm<1, spacedim, spacedim>
  push_forward_gradient(const Point<spacedim> &chart_point) const override;
 
  const Tensor<1, spacedim> &
  get_major_axis_direction() const;
 
  const Point<spacedim> &
  get_center() const;
 
  double
  get_eccentricity() const;
 
private:
  const Tensor<1, spacedim> direction;
 
  const Point<spacedim> center;
 
  const double eccentricity;
 
  const double cosh_u;
  const double sinh_u;
 
  static Tensor<1, spacedim>
  get_periodicity();
};
 
 
template <int dim, int spacedim = dim, int chartdim = dim>
class FunctionManifold : public ChartManifold<dim, spacedim, chartdim>
{
public:
  FunctionManifold(
    const Function<chartdim>  &push_forward_function,
    const Function<spacedim>  &pull_back_function,
    const Tensor<1, chartdim> &periodicity = Tensor<1, chartdim>(),
    const double               tolerance   = 1e-10);
 
  FunctionManifold(
    std::unique_ptr<Function<chartdim>> push_forward,
    std::unique_ptr<Function<spacedim>> pull_back,
    const Tensor<1, chartdim>          &periodicity = Tensor<1, chartdim>(),
    const double                        tolerance   = 1e-10);
 
  FunctionManifold(
    const std::string          push_forward_expression,
    const std::string          pull_back_expression,
    const Tensor<1, chartdim> &periodicity = Tensor<1, chartdim>(),
    const typename FunctionParser<spacedim>::ConstMap =
      typename FunctionParser<spacedim>::ConstMap(),
    const std::string chart_vars =
      FunctionParser<chartdim>::default_variable_names(),
    const std::string space_vars =
      FunctionParser<spacedim>::default_variable_names(),
    const double tolerance = 1e-10,
    const double h         = 1e-8);
 
  virtual ~FunctionManifold() override;
 
  virtual std::unique_ptr<Manifold<dim, spacedim>>
  clone() const override;
 
  virtual Point<spacedim>
  push_forward(const Point<chartdim> &chart_point) const override;
 
  virtual DerivativeForm<1, chartdim, spacedim>
  push_forward_gradient(const Point<chartdim> &chart_point) const override;
 
  virtual Point<chartdim>
  pull_back(const Point<spacedim> &space_point) const override;
 
private:
  const typename FunctionParser<spacedim>::ConstMap const_map;
 
  ObserverPointer<const Function<chartdim>,
                  FunctionManifold<dim, spacedim, chartdim>>
    push_forward_function;
 
  ObserverPointer<const Function<spacedim>,
                  FunctionManifold<dim, spacedim, chartdim>>
    pull_back_function;
 
  const double tolerance;
 
  bool owns_pointers;
 
  const std::string push_forward_expression;
 
  const std::string pull_back_expression;
 
  const std::string chart_vars;
 
  const std::string space_vars;
 
  const double finite_difference_step;
};
 
 
 
template <int dim>
class TorusManifold : public ChartManifold<dim, 3, 3>
{
public:
  static const int chartdim = 3;
  static const int spacedim = 3;
 
  TorusManifold(const double centerline_radius, const double inner_radius);
 
  virtual std::unique_ptr<Manifold<dim, 3>>
  clone() const override;
 
  virtual Point<3>
  pull_back(const Point<3> &p) const override;
 
  virtual Point<3>
  push_forward(const Point<3> &chart_point) const override;
 
  virtual DerivativeForm<1, 3, 3>
  push_forward_gradient(const Point<3> &chart_point) const override;
 
  double
  get_centerline_radius() const;
 
  double
  get_inner_radius() const;
 
private:
  double centerline_radius;
 
  double inner_radius;
};
 
 
 
template <int dim, int spacedim = dim>
class TransfiniteInterpolationManifold : public Manifold<dim, spacedim>
{
public:
  TransfiniteInterpolationManifold();
 
  virtual ~TransfiniteInterpolationManifold() override;
 
  virtual std::unique_ptr<Manifold<dim, spacedim>>
  clone() const override;
 
  void
  initialize(const Triangulation<dim, spacedim> &triangulation);
 
  virtual Point<spacedim>
  get_new_point(const ArrayView<const Point<spacedim>> &surrounding_points,
                const ArrayView<const double>          &weights) const override;
 
  virtual void
  get_new_points(const ArrayView<const Point<spacedim>> &surrounding_points,
                 const Table<2, double>                 &weights,
                 ArrayView<Point<spacedim>> new_points) const override;
 
private:
  std::array<unsigned int, 20>
  get_possible_cells_around_points(
    const ArrayView<const Point<spacedim>> &surrounding_points) const;
 
  typename Triangulation<dim, spacedim>::cell_iterator
  compute_chart_points(
    const ArrayView<const Point<spacedim>> &surrounding_points,
    ArrayView<Point<dim>>                   chart_points) const;
 
  Point<dim>
  pull_back(const typename Triangulation<dim, spacedim>::cell_iterator &cell,
            const Point<spacedim>                                      &p,
            const Point<dim> &initial_guess) const;
 
  Point<spacedim>
  push_forward(const typename Triangulation<dim, spacedim>::cell_iterator &cell,
               const Point<dim> &chart_point) const;
 
  DerivativeForm<1, dim, spacedim>
  push_forward_gradient(
    const typename Triangulation<dim, spacedim>::cell_iterator &cell,
    const Point<dim>                                           &chart_point,
    const Point<spacedim> &pushed_forward_chart_point) const;
 
  const Triangulation<dim, spacedim> *triangulation;
 
  int level_coarse;
 
  std::vector<bool> coarse_cell_is_flat;
 
  FlatManifold<dim> chart_manifold;
 
  std::vector<internal::MappingQImplementation::
                InverseQuadraticApproximation<dim, spacedim>>
    quadratic_approximation;
 
  boost::signals2::connection clear_signal;
};
 
/*----------------------------- inline functions -----------------------------*/
 
template <int dim, int spacedim>
inline const Point<spacedim> &
PolarManifold<dim, spacedim>::get_center() const
{
  return p_center;
}
 
 
 
template <int dim, int spacedim>
inline const Point<spacedim> &
SphericalManifold<dim, spacedim>::get_center() const
{
  return p_center;
}
 
 
 
template <int dim, int spacedim>
inline const Tensor<1, spacedim> &
CylindricalManifold<dim, spacedim>::get_direction() const
{
  return direction;
}
 
 
 
template <int dim, int spacedim>
inline const Point<spacedim> &
CylindricalManifold<dim, spacedim>::get_point_on_axis() const
{
  return point_on_axis;
}
 
 
 
template <int dim, int spacedim>
inline double
CylindricalManifold<dim, spacedim>::get_tolerance() const
{
  return tolerance;
}
 
 
 
template <int dim, int spacedim>
inline const Tensor<1, spacedim> &
EllipticalManifold<dim, spacedim>::get_major_axis_direction() const
{
  return direction;
}
 
 
 
template <int dim, int spacedim>
inline const Point<spacedim> &
EllipticalManifold<dim, spacedim>::get_center() const
{
  return center;
}
 
 
 
template <int dim, int spacedim>
inline double
EllipticalManifold<dim, spacedim>::get_eccentricity() const
{
  return eccentricity;
}
 
 
 
template <int dim>
inline double
TorusManifold<dim>::get_centerline_radius() const
{
  return centerline_radius;
}
 
 
 
template <int dim>
inline double
TorusManifold<dim>::get_inner_radius() const
{
  return inner_radius;
}
 
DEAL_II_NAMESPACE_CLOSE
 
#endif