libMesh::TriangulatorInterface::PolygonHole Class Reference

A concrete instantiation of the Hole class that describes polygonal (triangular, square, pentagonal, ...) holes. More...

#include <mesh_triangle_holes.h>

Inheritance diagram for libMesh::TriangulatorInterface::PolygonHole:

Public Member Functions
	PolygonHole (const Point &center, Real radius, unsigned int n_points)
	Constructor specifying the center, radius, and number of points which comprise the hole. More...
virtual unsigned int	n_points () const override
	The number of geometric points which define the hole. More...
virtual Point	point (const unsigned int n) const override
	Return the nth point defining the hole. More...
virtual Point	inside () const override
	Return an (arbitrary) point which lies inside the hole. More...
virtual unsigned int	n_midpoints () const
	The number of geometric midpoints along each of the sides defining the hole. More...
virtual Point	midpoint (const unsigned int, const unsigned int) const
	Return the midpoint m along the side n defining the hole. More...
bool	contains (Point p) const
	Return true iff p lies inside the hole. More...
Real	area () const
	Return the area of the hole. More...
RealGradient	areavec () const
	Return a vector with right-hand-rule orientation and length of twice area() squared. More...
virtual std::vector< unsigned int >	segment_indices () const
	Starting indices of points for a hole with multiple disconnected boundaries. More...
virtual void	set_refine_boundary_allowed (bool refine_bdy_allowed)
	Set whether or not a triangulator is allowed to refine the hole boundary when refining the mesh interior. More...
virtual bool	refine_boundary_allowed () const
	Get whether or not the triangulation is allowed to refine the mesh boundary when refining the interior. More...

Protected Member Functions
std::vector< Real >	find_ray_intersections (Point ray_start, Point ray_target) const
	Helper function for contains(), also useful for MeshedHole::inside() More...
Point	calculate_inside_point () const
	Calculate an inside point based on our boundary. More...

Protected Attributes
bool	_refine_bdy_allowed = true
	Whether to allow boundary refinement. More...

Private Attributes
Point	_center
	(x,y) location of the center of the hole More...
Real	_radius
	circular hole radius More...
unsigned int	_n_points
	number of points used to describe the hole. More...

Detailed Description

A concrete instantiation of the Hole class that describes polygonal (triangular, square, pentagonal, ...) holes.

Definition at line 171 of file mesh_triangle_holes.h.

Constructor & Destructor Documentation

PolygonHole()

libMesh::TriangulatorInterface::PolygonHole::PolygonHole	(	const Point &	center,
		Real	radius,
		unsigned int	n_points
	)

Constructor specifying the center, radius, and number of points which comprise the hole.

The points will all lie on a circle of radius r.

Definition at line 323 of file mesh_triangle_holes.C.

                                                                          :
  _center(center),
  _radius(radius),
  _n_points(n_points_in)
{}

Member Function Documentation

area()

Real libMesh::TriangulatorInterface::Hole::area ( ) const

inherited

Return the area of the hole.

This method currently does not take any higher-order hole geometry into account, but treats the hole as a polygon.

Definition at line 184 of file mesh_triangle_holes.C.

References libMesh::TriangulatorInterface::Hole::areavec(), and libMesh::TypeVector< T >::norm().

Referenced by libMesh::TriangulatorInterface::MeshedHole::MeshedHole(), and MeshTriangulationTest::testTriangleHoleArea().

{
  return this->areavec().norm() / 2;
}

areavec()

RealGradient libMesh::TriangulatorInterface::Hole::areavec ( ) const

inherited

Return a vector with right-hand-rule orientation and length of twice area() squared.

This is useful for determining orientation of non-planar or non-counter-clockwise holes.

This method currently does not take any higher-order hole geometry into account, but treats the hole as a polygon.

Definition at line 190 of file mesh_triangle_holes.C.

References libMesh::TypeVector< T >::cross().

Referenced by libMesh::TriangulatorInterface::Hole::area().

{
  const unsigned int np = this->n_points();

  if (np < 3)
    return 0;

  const Point p0 = this->point(0);

  // Every segment (p_{i-1},p_i) from i=2 on defines a triangle w.r.t.
  // p_0.  Add up the cross products of those triangles.  We'll save
  // the division by 2 and the norm for the end.
  //
  // Your hole points had best be coplanar, but this should work
  // regardless of which plane they're in.  If you're in the XY plane,
  // then the standard counter-clockwise hole point ordering gives you
  // a positive areavec(2);

  RealGradient areavec = 0;

  for (unsigned int i=2; i != np; ++i)
    {
      const Point e_0im = this->point(i-1) - p0,
                  e_0i  = this->point(i) - p0;

      areavec += e_0i.cross(e_0im);
    }

  return areavec;
}

calculate_inside_point()

Point libMesh::TriangulatorInterface::Hole::calculate_inside_point ( ) const

protectedinherited

Calculate an inside point based on our boundary.

Definition at line 248 of file mesh_triangle_holes.C.

References libMesh::make_range(), and libMesh::Real.

Referenced by libMesh::TriangulatorInterface::ArbitraryHole::ArbitraryHole(), and libMesh::TriangulatorInterface::ArbitraryHole::set_points().

{
  // Start with the vertex average

  // Turns out "I'm a fully compliant C++17 compiler!" doesn't
  // mean "I have a full C++17 standard library!"
  // inside = std::reduce(points.begin(), points.end());
  Point inside = 0;
  for (auto i : make_range(this->n_points()))
    inside += this->point(i);

  inside /= this->n_points();

  // Count the number of intersections with a ray to the right,
  // keep track of how far they are
  Point ray_target = inside + Point(1);
  std::vector<Real> intersection_distances =
    this->find_ray_intersections(inside, ray_target);

  // The vertex average isn't on the interior, and we found no
  // intersections to the right?  Try looking to the left.
  if (!intersection_distances.size())
    {
      ray_target = inside - Point(1);
      intersection_distances =
        this->find_ray_intersections(inside, ray_target);
    }

  // I'd make this an assert, but I'm not 100% confident we can't
  // get here via some kind of FP error on a weird hole shape.
  libmesh_error_msg_if
    (!intersection_distances.size(),
     "Can't find a center for a MeshedHole!");

  if (intersection_distances.size() % 2)
    return inside;

  // The vertex average is outside.  So go from the vertex average to
  // the closest edge intersection, then halfway to the next-closest.

  // Find the nearest first.
  Real min_distance    = std::numeric_limits<Real>::max(),
       second_distance = std::numeric_limits<Real>::max();
  for (Real d : intersection_distances)
    if (d < min_distance)
      {
        second_distance = min_distance;
        min_distance = d;
      }

  const Point ray = ray_target - inside;
  inside += ray * (min_distance + second_distance)/2;

  return inside;
}

contains()

bool libMesh::TriangulatorInterface::Hole::contains ( Point  p ) const

inherited

Return true iff p lies inside the hole.

This method currently does not take any higher-order hole geometry into account, but treats the hole as a polygon.

Definition at line 305 of file mesh_triangle_holes.C.

Referenced by libMesh::TriangulatorInterface::verify_holes().

{
  // Count the number of intersections with a ray to the right,
  // keep track of how far they are
  Point ray_target = p + Point(1);
  std::vector<Real> intersection_distances =
    this->find_ray_intersections(p, ray_target);

  // Odd number of intersections == we're inside
  // Even number == we're outside
  return intersection_distances.size() % 2;
}

find_ray_intersections()

std::vector< Real > libMesh::TriangulatorInterface::Hole::find_ray_intersections ( Point  ray_start, Point  ray_target  ) const

protectedinherited

Helper function for contains(), also useful for MeshedHole::inside()

Definition at line 224 of file mesh_triangle_holes.C.

References libMesh::make_range(), and libMesh::Real.

{
  const auto np = this->n_points();

  std::vector<Real> intersection_distances;

  for (auto i : make_range(np))
    {
      const Point & p0 = this->point(i),
                  & p1 = this->point((i+1)%np),
                  & p2 = this->point((i+2)%np);
      const Real intersection_distance =
        find_intersection(ray_start, ray_target, p0, p1, p2);
      if (intersection_distance >= 0)
        intersection_distances.push_back
          (intersection_distance);
    }

  return intersection_distances;
}

inside()

Point libMesh::TriangulatorInterface::PolygonHole::inside ( ) const

overridevirtual

Return an (arbitrary) point which lies inside the hole.

Implements libMesh::TriangulatorInterface::Hole.

Definition at line 349 of file mesh_triangle_holes.C.

{
  // The center of the hole is definitely inside.
  return _center;
}

midpoint()

virtual Point libMesh::TriangulatorInterface::Hole::midpoint ( const unsigned int  , const unsigned int    ) const

inlinevirtualinherited

Return the midpoint m along the side n defining the hole.

Reimplemented in libMesh::TriangulatorInterface::MeshedHole.

Definition at line 80 of file mesh_triangle_holes.h.

  { libmesh_error(); /* by default holes are polygonal */ }

n_midpoints()

virtual unsigned int libMesh::TriangulatorInterface::Hole::n_midpoints ( ) const

inlinevirtualinherited

The number of geometric midpoints along each of the sides defining the hole.

Reimplemented in libMesh::TriangulatorInterface::MeshedHole.

Definition at line 70 of file mesh_triangle_holes.h.

{ return 0; }

n_points()

unsigned int libMesh::TriangulatorInterface::PolygonHole::n_points ( ) const

overridevirtual

The number of geometric points which define the hole.

Implements libMesh::TriangulatorInterface::Hole.

Definition at line 332 of file mesh_triangle_holes.C.

{
  return _n_points;
}

point()

Point libMesh::TriangulatorInterface::PolygonHole::point ( const unsigned int  n ) const

overridevirtual

Return the nth point defining the hole.

Implements libMesh::TriangulatorInterface::Hole.

Definition at line 338 of file mesh_triangle_holes.C.

References libMesh::pi, and libMesh::Real.

{
  // The nth point lies at the angle theta = 2 * pi * n / _n_points
  const Real theta = static_cast<Real>(n) * 2.0 * libMesh::pi / static_cast<Real>(_n_points);

  return Point(_center(0) + _radius*std::cos(theta), // x=r*cos(theta)
               _center(1) + _radius*std::sin(theta), // y=r*sin(theta)
               0.);
}

refine_boundary_allowed()

virtual bool libMesh::TriangulatorInterface::Hole::refine_boundary_allowed ( ) const

inlinevirtualinherited

Get whether or not the triangulation is allowed to refine the mesh boundary when refining the interior.

True by default.

Definition at line 140 of file mesh_triangle_holes.h.

References libMesh::TriangulatorInterface::Hole::_refine_bdy_allowed.

Referenced by libMesh::Poly2TriTriangulator::is_refine_boundary_allowed(), and MeshTriangulationTest::testPoly2TriHolesInteriorRefinedBase().

  { return _refine_bdy_allowed; }

segment_indices()

virtual std::vector<unsigned int> libMesh::TriangulatorInterface::Hole::segment_indices ( ) const

inlinevirtualinherited

Starting indices of points for a hole with multiple disconnected boundaries.

Reimplemented in libMesh::TriangulatorInterface::ArbitraryHole.

Definition at line 118 of file mesh_triangle_holes.h.

References libMesh::TriangulatorInterface::Hole::n_points().

  {
    // default to only one enclosing boundary
    std::vector<unsigned int> seg;
    seg.push_back(0);
    seg.push_back(n_points());
    return seg;
  }

set_refine_boundary_allowed()

virtual void libMesh::TriangulatorInterface::Hole::set_refine_boundary_allowed ( bool  refine_bdy_allowed )

inlinevirtualinherited

Set whether or not a triangulator is allowed to refine the hole boundary when refining the mesh interior.

This is true by default, but may be set to false to make the hole boundary more predictable (and so easier to stitch to other meshes) later.

Definition at line 133 of file mesh_triangle_holes.h.

References libMesh::TriangulatorInterface::Hole::_refine_bdy_allowed.

Referenced by MeshTriangulationTest::testPoly2TriHolesInteriorRefinedBase().

  { _refine_bdy_allowed = refine_bdy_allowed; }

Member Data Documentation

_center

Point libMesh::TriangulatorInterface::PolygonHole::_center

private

(x,y) location of the center of the hole

Definition at line 191 of file mesh_triangle_holes.h.

_n_points

unsigned int libMesh::TriangulatorInterface::PolygonHole::_n_points

private

number of points used to describe the hole.

The actual points can be generated knowing the center and radius. For example, n_points=3 would generate a triangular hole.

Definition at line 203 of file mesh_triangle_holes.h.

_radius

Real libMesh::TriangulatorInterface::PolygonHole::_radius

private

circular hole radius

Definition at line 196 of file mesh_triangle_holes.h.

_refine_bdy_allowed

bool libMesh::TriangulatorInterface::Hole::_refine_bdy_allowed = true

protectedinherited

Whether to allow boundary refinement.

True by default; specified here so we can use the default constructor.

Definition at line 160 of file mesh_triangle_holes.h.

Referenced by libMesh::TriangulatorInterface::Hole::refine_boundary_allowed(), and libMesh::TriangulatorInterface::Hole::set_refine_boundary_allowed().

---

The documentation for this class was generated from the following files:

• include/mesh/mesh_triangle_holes.h
• src/mesh/mesh_triangle_holes.C