libMesh::TriangulatorInterface::MeshedHole Class Reference

Another concrete instantiation of the hole, as general as ArbitraryHole, but based on an existing 1D or 2D mesh. More...

#include <mesh_triangle_holes.h>

Inheritance diagram for libMesh::TriangulatorInterface::MeshedHole:

Public Member Functions
	MeshedHole (const MeshBase &mesh, std::set< std::size_t > ids={})
	The constructor requires a mesh defining the hole, and optionally boundary+subdomain ids restricting the definition.
virtual unsigned int	n_points () const override
	The number of geometric points which define the hole.
virtual unsigned int	n_midpoints () const override
	The number of geometric midpoints along each of the sides defining the hole.
virtual Point	point (const unsigned int n) const override
	Return the nth point defining the hole.
virtual Point	midpoint (const unsigned int m, const unsigned int n) const override
	Return the midpoint m along the side n defining the hole.
virtual Point	inside () const override
	Return an (arbitrary) point which lies inside the hole.
bool	contains (Point p) const
	Return true iff p lies inside the hole.
Real	area () const
	Return the area of the hole.
RealGradient	areavec () const
	Return a vector with right-hand-rule orientation and length of twice area() squared.
virtual std::vector< unsigned int >	segment_indices () const
	Starting indices of points for a hole with multiple disconnected boundaries.
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.
virtual bool	refine_boundary_allowed () const
	Get whether or not the triangulation is allowed to refine the mesh boundary when refining the interior.

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()
Point	calculate_inside_point () const
	Calculate an inside point based on our boundary.

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

Private Attributes
Point	_center
	An (x,y) location inside the hole.
std::vector< Point >	_points
	The sorted vector of points which makes up the hole.
std::vector< Point >	_midpoints
	The sorted vector of midpoints in between points along the edges of the hole.

Detailed Description

Another concrete instantiation of the hole, as general as ArbitraryHole, but based on an existing 1D or 2D mesh.

If ids are given, 2D edges on a boundary with a listed id or 1D edges in a subdomain with a listed id will define the hole.

If no ids are given, the hole will be defined by all 1D Edge elements and all outward-facing 2D boundary edges.

In either case, the hole definition should give a single connected boundary, topologically a circle. The hole is defined when the MeshedHole is constructed, and ignores any subsequent changes to the input mesh.

Definition at line 343 of file mesh_triangle_holes.h.

Constructor & Destructor Documentation

MeshedHole()

libMesh::TriangulatorInterface::MeshedHole::MeshedHole	(	const MeshBase &	mesh,
		std::set< std::size_t >	ids = {}
	)

The constructor requires a mesh defining the hole, and optionally boundary+subdomain ids restricting the definition.

Definition at line 457 of file mesh_triangle_holes.C.

  : _center(std::numeric_limits<Real>::max())
{
  // We'll want to do this on one processor and broadcast to the rest;
  // otherwise we can get out of sync by doing things like using
  // pointers as keys.
  libmesh_parallel_only(mesh.comm());
 
  MeshSerializer serial(const_cast<MeshBase &>(mesh),
                        /* serial */ true, /* only proc 0 */ true);
 
  // Try to keep in sync even if we throw an error on proc 0, so we
  // can examine errors in our unit tests in parallel too.
  std::string error_reported;
 
  auto report_error = [&mesh, &error_reported](std::string er) {
    error_reported = std::move(er);
    mesh.comm().broadcast(error_reported);
    libmesh_error_msg(error_reported);
  };
 
  if (mesh.processor_id() != 0)
    {
      // Make sure proc 0 didn't just fail
      mesh.comm().broadcast(error_reported);
      libmesh_error_msg_if(!error_reported.empty(), error_reported);
 
      // Receive the points proc 0 will send later
      mesh.comm().broadcast(_points);
      mesh.comm().broadcast(_midpoints);
      return;
    }
 
  // We'll find all the line segments first, then stitch them together
  // afterward.  If the line segments come from 2D element sides then
  // we'll label their edge_type as "1" for clockwise orientation
  // around the element or "2" for CCW, to make it easier to detect
  // and scream about cases where we have a disconnected outer
  // boundary.
  std::multimap<const Node *,
                std::pair<const Node *, int>> hole_edge_map;
 
  // If we're looking at higher-order elements, we have mid-edge edge
  // nodes to worry about.  hole_midpoint_map[{m,n}][i] should give us
  // the ith mid-edge node traveling from vertex m to vertex n
  std::map<std::pair<const Node *, const Node *>,
           std::vector<const Node *>> hole_midpoint_map;
 
  std::vector<boundary_id_type> bcids;
 
  const BoundaryInfo & boundary_info = mesh.get_boundary_info();
 
  for (const auto & elem : mesh.active_element_ptr_range())
    {
      if (elem->dim() == 1)
        {
          if (ids.empty() || ids.count(elem->subdomain_id()))
            {
              hole_edge_map.emplace(elem->node_ptr(0),
                                    std::make_pair(elem->node_ptr(1),
                                                   /*edge*/ 0));
              hole_edge_map.emplace(elem->node_ptr(1),
                                    std::make_pair(elem->node_ptr(0),
                                                   /*edge*/ 0));
              if (elem->type() == EDGE3)
                {
                  hole_midpoint_map.emplace(std::make_pair(elem->node_ptr(0),
                                                           elem->node_ptr(1)),
                                            std::vector<const Node *>{elem->node_ptr(2)});
                  hole_midpoint_map.emplace(std::make_pair(elem->node_ptr(1),
                                                           elem->node_ptr(0)),
                                            std::vector<const Node *>{elem->node_ptr(2)});
                }
              else if (elem->type() == EDGE4)
                {
                  hole_midpoint_map.emplace(std::make_pair(elem->node_ptr(0),
                                                           elem->node_ptr(1)),
                                            std::vector<const Node *>{elem->node_ptr(2),
                                                                      elem->node_ptr(3)});
                  hole_midpoint_map.emplace(std::make_pair(elem->node_ptr(1),
                                                           elem->node_ptr(0)),
                                            std::vector<const Node *>{elem->node_ptr(3),
                                                                      elem->node_ptr(2)});
                }
              else
                libmesh_assert_equal_to(elem->default_side_order(), 1);
            }
          continue;
        }
 
      if (elem->dim() == 2)
        {
          const auto ns = elem->n_sides();
          for (auto s : make_range(ns))
            {
              boundary_info.boundary_ids(elem, s, bcids);
 
              bool add_edge = false;
              if (!elem->neighbor_ptr(s) && ids.empty())
                add_edge = true;
 
              if (!add_edge)
                for (auto b : bcids)
                  if (ids.count(b))
                    add_edge = true;
 
              if (add_edge)
                {
                  hole_edge_map.emplace(elem->node_ptr(s),
                                        std::make_pair(elem->node_ptr((s+1)%ns),
                                                       /*counter-CW*/ 2));
                  // Do we really need to support flipped 2D elements?
                  hole_edge_map.emplace(elem->node_ptr((s+1)%ns),
                                        std::make_pair(elem->node_ptr(s),
                                                       /*clockwise*/ 1));
 
                  if (elem->default_side_order() == 2)
                    {
                      hole_midpoint_map.emplace(std::make_pair(elem->node_ptr(s),
                                                               elem->node_ptr((s+1)%ns)),
                                                std::vector<const Node *>{elem->node_ptr(s+ns)});
                      hole_midpoint_map.emplace(std::make_pair(elem->node_ptr((s+1)%ns),
                                                               elem->node_ptr(s)),
                                                std::vector<const Node *>{elem->node_ptr(s+ns)});
                    }
                  else
                    libmesh_assert_equal_to(elem->default_side_order(), 1);
 
                  continue;
                }
            }
        }
    }
 
  if (hole_edge_map.empty())
    report_error("No valid hole edges found in mesh!");
 
  // Function to pull a vector of points out of the map; a loop of
  // edges connecting these points defines a hole boundary.  If the
  // mesh has multiple boundaries (e.g. because it had holes itself),
  // then a random vector will be extracted; this function will be
  // called multiple times so that the various options can be
  // compared.  We choose the largest option.
  auto extract_edge_vector =
    [&report_error, &hole_edge_map, &hole_midpoint_map]() {
    std::tuple<std::vector<const Node *>, std::vector<const Node *>, int>
    hole_points_and_edge_type
      {{hole_edge_map.begin()->first, hole_edge_map.begin()->second.first},
       {}, hole_edge_map.begin()->second.second};
 
    auto & hole_points = std::get<0>(hole_points_and_edge_type);
    auto & midpoint_points = std::get<1>(hole_points_and_edge_type);
    int & edge_type = std::get<2>(hole_points_and_edge_type);
 
    // We won't be needing to search for this edge
    hole_edge_map.erase(hole_points.front());
 
    // Sort the remaining edges into a connected order
    for (const Node * last = hole_points.front(),
                    *    n = hole_points.back();
                         n != hole_points.front();
                      last = n,
                         n = hole_points.back())
      {
        auto [next_it_begin, next_it_end] = hole_edge_map.equal_range(n);
 
        if (std::distance(next_it_begin, next_it_end) != 2)
          report_error("Bad edge topology found by MeshedHole");
 
        const Node * next = nullptr;
        for (const auto & [key, val] : as_range(next_it_begin, next_it_end))
          {
            libmesh_assert_equal_to(key, n);
            libmesh_ignore(key);
            libmesh_assert_not_equal_to(val.first, n);
 
            // Don't go backwards on the edge we just traversed
            if (val.first == last)
              continue;
 
            // We can support mixes of Edge and Tri-side edges, but we
            // can't do proper error detection on flipped triangles.
            if (val.second != edge_type &&
                val.second != 0)
              {
                if (!edge_type)
                  edge_type = val.second;
                else
                  report_error("MeshedHole sees inconsistent triangle orientations on boundary");
              }
            next = val.first;
          }
 
        // We should never hit the same n twice!
        hole_edge_map.erase(next_it_begin, next_it_end);
 
        hole_points.push_back(next);
      }
 
    for (auto i : make_range(hole_points.size()-1))
      {
        const auto & midpoints = hole_midpoint_map[{hole_points[i],hole_points[i+1]}];
        midpoint_points.insert(midpoint_points.end(),
                               midpoints.begin(), midpoints.end());
      }
 
    hole_points.pop_back();
 
    return hole_points_and_edge_type;
  };
 
  /*
   * If it's not obvious which loop we find is really the loop we
   * want, then we should die with a nice error message.
   */
  int n_negative_areas = 0,
      n_positive_areas = 0,
      n_edgeelem_loops = 0;
 
  std::vector<const Node *> outer_hole_points, outer_mid_points;
  int outer_edge_type = -1;
  Real twice_outer_area = 0,
       abs_twice_outer_area = 0;
 
#ifdef DEBUG
  // Area and edge type, for error reporting
  std::vector<std::pair<Real, int>> areas;
#endif
 
  while (!hole_edge_map.empty()) {
    auto [hole_points, mid_points, edge_type] = extract_edge_vector();
 
    if (edge_type == 0)
    {
      ++n_edgeelem_loops;
      if (n_edgeelem_loops > 1)
        report_error("MeshedHole is confused by multiple loops of Edge elements");
      if (n_positive_areas || n_negative_areas)
        report_error("MeshedHole is confused by meshes with both Edge and 2D-side boundaries");
    }
 
    const std::size_t n_hole_points = hole_points.size();
    if (n_hole_points < 3)
      report_error("Loop with only " + std::to_string(n_hole_points) +
                   " hole edges found in mesh!");
 
    Real twice_this_area = 0;
    const Point p0 = *hole_points[0];
    for (unsigned int i=2; i != n_hole_points; ++i)
      {
        const Point e_0im = *hole_points[i-1] - p0,
                    e_0i  = *hole_points[i] - p0;
 
        twice_this_area += e_0i.cross(e_0im)(2);
      }
 
    auto abs_twice_this_area = std::abs(twice_this_area);
 
    if (((twice_this_area > 0) && edge_type == 2) ||
        ((twice_this_area < 0) && edge_type == 1))
      ++n_positive_areas;
    else if (edge_type != 0)
      ++n_negative_areas;
 
#ifdef DEBUG
    areas.push_back({twice_this_area/2,edge_type});
#endif
 
    if (abs_twice_this_area > abs_twice_outer_area)
      {
        twice_outer_area = twice_this_area;
        abs_twice_outer_area = abs_twice_this_area;
        outer_hole_points = std::move(hole_points);
        outer_mid_points = std::move(mid_points);
        outer_edge_type = edge_type;
      }
  }
 
  _points.resize(outer_hole_points.size());
  std::transform(outer_hole_points.begin(),
                 outer_hole_points.end(),
                 _points.begin(),
                 [](const Node * n){ return Point(*n); });
  _midpoints.resize(outer_mid_points.size());
  std::transform(outer_mid_points.begin(),
                 outer_mid_points.end(),
                 _midpoints.begin(),
                 [](const Node * n){ return Point(*n); });
 
  if (!twice_outer_area)
    report_error("Zero-area MeshedHoles are not currently supported");
 
  // We ordered ourselves counter-clockwise?  But a hole is expected
  // to be clockwise, so use the reverse order.
  if (twice_outer_area > 0)
    {
      std::reverse(_points.begin(), _points.end());
 
      // Our midpoints are numbered e.g.
      // (01a)(01b)(12a)(12b)(23a)(23b)(30a)(30b) for points 0123, but
      // if we reverse to get 3210 then we want our midpoints to be
      // (23b)(23a)(12b)(12a)(01b)(01a)(30b)(30a)
      const unsigned int n_midpoints = _midpoints.size() / _points.size();
      auto split_it = _midpoints.end() - n_midpoints;
      std::reverse(_midpoints.begin(), split_it);
      std::reverse(split_it, _midpoints.end());
    }
 
#ifdef DEBUG
  auto print_areas = [areas](){
    libMesh::out << "Found boundary areas:\n";
    static const std::vector<std::string> edgenames {"E","CW","CCW"};
    for (auto area : areas)
      libMesh::out << '(' << edgenames[area.second] << ' ' <<
        area.first << ')';
    libMesh::out << std::endl;
  };
#else
  auto print_areas = [](){};
#endif
 
  if (((twice_outer_area > 0) && outer_edge_type == 2) ||
      ((twice_outer_area < 0) && outer_edge_type == 1))
    {
      if (n_positive_areas > 1)
        {
          print_areas();
          report_error("MeshedHole found " +
                       std::to_string(n_positive_areas) +
                       " counter-clockwise boundaries and cannot choose one!");
        }
 
    }
  else if (outer_edge_type != 0)
    {
      if (n_negative_areas > 1)
        {
          print_areas();
          report_error("MeshedHole found " +
                       std::to_string(n_negative_areas) +
                       " clockwise boundaries and cannot choose one!");
        }
 
    }
 
  // Hey, no errors!  Broadcast that empty string.
  mesh.comm().broadcast(error_reported);
  mesh.comm().broadcast(_points);
  mesh.comm().broadcast(_midpoints);
}

References _midpoints, _points, libMesh::TriangulatorInterface::Hole::area(), libMesh::as_range(), b, libMesh::BoundaryInfo::boundary_ids(), libMesh::Parallel::Communicator::broadcast(), libMesh::ParallelObject::comm(), libMesh::TypeVector< T >::cross(), libMesh::EDGE3, libMesh::EDGE4, libMesh::MeshBase::get_boundary_info(), libMesh::libmesh_ignore(), libMesh::make_range(), mesh, n_midpoints(), libMesh::out, libMesh::ParallelObject::processor_id(), and libMesh::Real.

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 190 of file mesh_triangle_holes.C.

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

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

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

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 196 of file mesh_triangle_holes.C.

{
  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;
}

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

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

calculate_inside_point()

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

protectedinherited

Calculate an inside point based on our boundary.

Definition at line 254 of file mesh_triangle_holes.C.

{
  // 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;
}

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

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

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 311 of file mesh_triangle_holes.C.

{
  // 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;
}

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

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 230 of file mesh_triangle_holes.C.

{
  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;
}

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

inside()

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

overridevirtual

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

Implements libMesh::TriangulatorInterface::Hole.

Definition at line 840 of file mesh_triangle_holes.C.

{
  // This is expensive to compute, so only do it when we first need it
  if (_center(0) == std::numeric_limits<Real>::max())
    _center = this->calculate_inside_point();
 
  return _center;
}

midpoint()

Point libMesh::TriangulatorInterface::MeshedHole::midpoint ( const unsigned int  , const unsigned int    ) const

overridevirtual

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

Reimplemented from libMesh::TriangulatorInterface::Hole.

Definition at line 830 of file mesh_triangle_holes.C.

{
  const unsigned int n_mid = this->n_midpoints();
  libmesh_assert_less (m, n_mid);
  libmesh_assert_less (n, _points.size());
  return _midpoints[n*n_mid+m];
}

n_midpoints()

unsigned int libMesh::TriangulatorInterface::MeshedHole::n_midpoints ( ) const

overridevirtual

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

Reimplemented from libMesh::TriangulatorInterface::Hole.

Definition at line 816 of file mesh_triangle_holes.C.

{
  libmesh_assert (!(_midpoints.size() % _points.size()));
  return _midpoints.size() / _points.size();
}

References libMesh::libmesh_assert().

Referenced by MeshedHole().

n_points()

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

overridevirtual

The number of geometric points which define the hole.

Implements libMesh::TriangulatorInterface::Hole.

Definition at line 810 of file mesh_triangle_holes.C.

{
  return _points.size();
}

point()

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

overridevirtual

Return the nth point defining the hole.

Implements libMesh::TriangulatorInterface::Hole.

Definition at line 823 of file mesh_triangle_holes.C.

{
  libmesh_assert_less (n, _points.size());
  return _points[n];
}

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.

  { return _refine_bdy_allowed; }

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

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

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.

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

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

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.

  { _refine_bdy_allowed = refine_bdy_allowed; }

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

Referenced by MeshTriangulationTest::testPoly2TriHolesInteriorRefinedBase().

Member Data Documentation

_center

Point libMesh::TriangulatorInterface::MeshedHole::_center

mutableprivate

An (x,y) location inside the hole.

Cached because this is too expensive to compute for an arbitrary input mesh unless we need it for Triangle.

Definition at line 370 of file mesh_triangle_holes.h.

_midpoints

std::vector<Point> libMesh::TriangulatorInterface::MeshedHole::_midpoints

private

The sorted vector of midpoints in between points along the edges of the hole.

For a hole with m midpoints per edge, between _points[n] and _points[n+1] lies _midpoints[n*m] through _midpoints[n*m+m-1]

Definition at line 383 of file mesh_triangle_holes.h.

Referenced by MeshedHole().

_points

std::vector<Point> libMesh::TriangulatorInterface::MeshedHole::_points

private

The sorted vector of points which makes up the hole.

Definition at line 375 of file mesh_triangle_holes.h.

Referenced by MeshedHole().

_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