libMesh::TriangulatorInterface Class Reference

#include <triangulator_interface.h>

Inheritance diagram for libMesh::TriangulatorInterface:

Classes
class	AffineHole
	A way to translate and/or rotate an existing hole; perhaps to tile it in many places or to put it at an angle that the underlying hole doesn't support. More...
class	ArbitraryHole
	Another concrete instantiation of the hole, this one should be sufficiently general for most non-polygonal purposes. More...
class	Hole
	An abstract class for defining a 2-dimensional hole. More...
class	MeshedHole
	Another concrete instantiation of the hole, as general as ArbitraryHole, but based on an existing 1D or 2D mesh. More...
class	PolygonHole
	A concrete instantiation of the Hole class that describes polygonal (triangular, square, pentagonal, ...) holes. More...
class	Region
	A class for defining a 2-dimensional region for Triangle. More...

Public Types
enum	TriangulationType { GENERATE_CONVEX_HULL = 0 , PSLG = 1 , INVALID_TRIANGULATION_TYPE }
	The TriangulationType is used with the general triangulate function defined below. More...

Public Member Functions
	TriangulatorInterface (UnstructuredMesh &mesh)
	The constructor.
virtual	~TriangulatorInterface ()=default
	Empty destructor.
virtual void	triangulate ()=0
	This is the main public interface for this function.
ElemType &	elem_type ()
	Sets and/or gets the desired element type.
Real &	desired_area ()
	Sets and/or gets the desired triangle area.
virtual void	set_desired_area_function (FunctionBase< Real > *)
	Set a function giving desired triangle area as a function of position.
virtual FunctionBase< Real > *	get_desired_area_function ()
	Get the function giving desired triangle area as a function of position, or nullptr if no such function has been set.
Real &	minimum_angle ()
	Sets and/or gets the minimum desired angle.
TriangulationType &	triangulation_type ()
	Sets and/or gets the desired triangulation type.
bool &	insert_extra_points ()
	Sets and/or gets the flag for inserting add'l points.
void	set_interpolate_boundary_points (int n_points)
	Complicated setter, for compatibility with insert_extra_points()
int	get_interpolate_boundary_points () const
	Complicated getter, for compatibility with insert_extra_points()
virtual void	set_refine_boundary_allowed (bool)
	Set whether or not the triangulation is allowed to refine the mesh boundary when refining the interior.
virtual bool	refine_boundary_allowed () const
	Get whether or not the triangulation is allowed to refine the mesh boundary when refining the interior.
bool &	smooth_after_generating ()
	Sets/gets flag which tells whether to do two steps of Laplace mesh smoothing after generating the grid.
bool &	quiet ()
	Whether not to silence internal messages to stdout.
void	attach_hole_list (const std::vector< Hole * > *holes)
	Attaches a vector of Hole* pointers which will be meshed around.
void	set_verify_hole_boundaries (bool v)
	Verifying that hole boundaries don't cross the outer boundary or each other is something like O(N_bdys^2*N_points_per_bdy^2), so we only do it if requested.
bool	get_verify_hole_boundaries () const
void	set_fixup_tri7_center_nodes (bool v)
	For TRI7 elements, after boundary mid-edge nodes have been snapped to a curved boundary in increase_triangle_order(), the interior node can be repositioned to the curved-mapping image of the reference centroid.
bool	get_fixup_tri7_center_nodes () const
void	attach_boundary_marker (const std::vector< int > *markers)
	Attaches boundary markers.
void	attach_region_list (const std::vector< Region * > *regions)
	Attaches regions for using attribute to set subdomain IDs and better controlling the triangle sizes within the regions.
void	set_auto_area_function (const Parallel::Communicator &comm, const unsigned int num_nearest_pts, const unsigned int power, const Real background_value, const Real background_eff_dist)
	Generate an auto area function based on spacing of boundary points.
bool	has_auto_area_function ()
	Whether or not an auto area function has been set.
FunctionBase< Real > *	get_auto_area_function ()
	Get the auto area function.
void	calculate_auto_desired_area_samples (std::vector< Point > &function_points, std::vector< Real > &function_sizes, const Real &area_factor=1.5)
	The external boundary and all hole boundaries are collected.
void	set_outer_boundary_ids (std::set< std::size_t > bdy_ids)
	A set of ids to allow on the outer boundary loop: interpreted as boundary ids of 2D elements and/or subdomain ids of 1D edges.
const std::set< std::size_t > &	get_outer_boundary_ids () const

Public Attributes
std::vector< std::pair< unsigned int, unsigned int > >	segments
	When constructing a PSLG, if the node numbers do not define the desired boundary segments implicitly through the ordering of the points, you can use the segments vector to specify the segments explicitly, Ex: unit square numbered counter-clockwise starting from origin segments[0] = (0,1) segments[1] = (1,2) segments[2] = (2,3) segments[3] = (3,0) (For the above case you could actually use the implicit ordering!)
std::vector< Point >	segment_midpoints
	When constructing a second-order triangulation from a second-order boundary, we may do the triangulation using first-order elements, in which case we need to save midpoint location data in order to reconstruct curvature along boundaries.
std::vector< Point >	segment_midpoints_keys
	When saving the midpoint location data, we need to save the corresponding segment information too.

Protected Member Functions
void	elems_to_segments ()
	Helper function to create PSLG segments from our other boundary-defining options (1D mesh edges, 2D mesh boundary sides), if no segments already exist.
void	nodes_to_segments (dof_id_type max_node_id)
	Helper function to create PSLG segments from our node ordering, up to the maximum node id, if no segments already exist.
void	insert_any_extra_boundary_points ()
	Helper function to add extra points (midpoints of initial segments) to a PSLG triangulation.
void	increase_triangle_order ()
	Helper function to upconvert Tri3 to any higher order triangle type if requested via _elem_type.
void	fixup_tri7_center_nodes ()
	Helper called at the end of increase_triangle_order() for TRI7 to reposition the interior node to the curved-mapping image of the reference centroid after boundary midpoints have been snapped.
void	verify_quadratic_elements ()
	Helper called at the end of increase_triangle_order() to verify that no boundary-midpoint snap has tangled a quadratic triangle, by sampling the signed element Jacobian at the reference nodes and centroid.
void	verify_holes (const Hole &outer_bdy)
	Helper function to check holes for intersections if requested.
unsigned int	total_hole_points ()
	Helper function to count points in and verify holes.

Protected Attributes
UnstructuredMesh &	_mesh
	Reference to the mesh which is to be created by triangle.
const std::vector< Hole * > *	_holes
	A pointer to a vector of Hole*s.
const std::vector< int > *	_markers
	Boundary markers.
const std::vector< Region * > *	_regions
	A pointer to a vector of Regions*s.
std::set< std::size_t >	_bdy_ids
	A set of ids to allow on the outer boundary loop.
ElemType	_elem_type
	The type of elements to generate.
Real	_desired_area
	The desired area for the elements in the resulting mesh.
Real	_minimum_angle
	Minimum angle in triangles.
TriangulationType	_triangulation_type
	The type of triangulation to perform: choices are: convex hull PSLG.
bool	_insert_extra_points
	Flag which tells whether or not to insert additional nodes before triangulation.
int	_interpolate_boundary_points
	Flag which tells how many additional nodes should be inserted between each pair of original mesh points.
bool	_smooth_after_generating
	Flag which tells whether we should smooth the mesh after it is generated.
bool	_quiet
	Flag which tells if we want to suppress stdout outputs.
bool	_verify_hole_boundaries
	Flag which tells if we want to check hole geometry.
bool	_fixup_tri7_center_nodes
	Flag which tells if we want to relocate TRI7 interior nodes to the curved-mapping centroid after snapping boundary midpoints.
std::unique_ptr< AutoAreaFunction >	_auto_area_function
	The auto area function based on the spacing of boundary points.

Detailed Description

Definition at line 90 of file triangulator_interface.h.

Member Enumeration Documentation

TriangulationType

enum libMesh::TriangulatorInterface::TriangulationType

The TriangulationType is used with the general triangulate function defined below.

Enumerator
GENERATE_CONVEX_HULL	First generate a convex hull from the set of points passed in, and then triangulate this set of points. This is probably the most common type of usage.
PSLG	Triangulate the interior of a Planar Straight Line Graph, which is defined implicitly by the order of the "points" vector: a straight line is assumed to lie between each successive pair of points, with an additional line joining the final and first points. Explicitly telling the triangulator to add additional points may be important for this option.
INVALID_TRIANGULATION_TYPE	Does nothing, used as a "null" value.

Definition at line 111 of file triangulator_interface.h.

    {
      GENERATE_CONVEX_HULL = 0,
 
      PSLG = 1,
 
      INVALID_TRIANGULATION_TYPE
    };

Constructor & Destructor Documentation

TriangulatorInterface()

libMesh::TriangulatorInterface::TriangulatorInterface ( UnstructuredMesh &  mesh )

explicit

The constructor.

A reference to the mesh containing the points which are to be triangulated must be provided. Unless otherwise specified, a convex hull will be computed for the set of input points and the convex hull will be meshed.

Definition at line 112 of file triangulator_interface.C.

  : _mesh(mesh),
    _holes(nullptr),
    _markers(nullptr),
    _regions(nullptr),
    _elem_type(TRI3),
    _desired_area(0.1),
    _minimum_angle(20.0),
    _triangulation_type(GENERATE_CONVEX_HULL),
    _insert_extra_points(false),
    _smooth_after_generating(true),
    _quiet(true),
    _fixup_tri7_center_nodes(false),
    _auto_area_function(nullptr)
{}

~TriangulatorInterface()

virtual libMesh::TriangulatorInterface::~TriangulatorInterface ( )

virtualdefault

Empty destructor.

Member Function Documentation

attach_boundary_marker()

void libMesh::TriangulatorInterface::attach_boundary_marker ( const std::vector< int > *  markers )

inline

Attaches boundary markers.

If segments is set, the number of markers must be equal to the size of segments, otherwise, it is equal to the number of points.

Definition at line 313 of file triangulator_interface.h.

{ _markers = markers; }

References _markers.

attach_hole_list()

void libMesh::TriangulatorInterface::attach_hole_list ( const std::vector< Hole * > *  holes )

inline

Attaches a vector of Hole* pointers which will be meshed around.

Definition at line 255 of file triangulator_interface.h.

{_holes = holes;}

References _holes.

Referenced by libMesh::MeshTools::Generation::build_delaunay_square(), MeshTriangulationTest::testPoly2TriHolesInterpRefined(), MeshTriangulationTest::testPoly2TriRefinementBase(), MeshTriangulationTest::testTriangulatorHolePerturbed(), MeshTriangulationTest::testTriangulatorHoles(), MeshTriangulationTest::testTriangulatorHoleTangentPerturbed(), MeshTriangulationTest::testTriangulatorMeshedHoles(), MeshTriangulationTest::testTriangulatorRoundHole(), and triangulate_domain().

attach_region_list()

void libMesh::TriangulatorInterface::attach_region_list ( const std::vector< Region * > *  regions )

inline

Attaches regions for using attribute to set subdomain IDs and better controlling the triangle sizes within the regions.

Definition at line 319 of file triangulator_interface.h.

{ _regions = regions; }

References _regions.

calculate_auto_desired_area_samples()

void libMesh::TriangulatorInterface::calculate_auto_desired_area_samples	(	std::vector< Point > &	function_points,
		std::vector< Real > &	function_sizes,
		const Real &	area_factor = 1.5
	)

The external boundary and all hole boundaries are collected.

The centroid of each EDGE element is used as the point position and the desired area is calculated as the area of the equilateral triangle with the edge length as the length of the EDGE element times an area_factor (default is 1.5).

Definition at line 631 of file triangulator_interface.C.

{
  // Get the hole mesh of the outer boundary
  // Holes should already be attached if applicable when this function is called
  const TriangulatorInterface::MeshedHole bdry_mh { _mesh, this->_bdy_ids };
  // Collect all the centroid points of the outer boundary segments
  // and the corresponding element sizes
  for (unsigned int i = 0; i < bdry_mh.n_points(); i++)
  {
    function_points.push_back((bdry_mh.point(i) + bdry_mh.point((i + 1) % bdry_mh.n_points())) /
                              Real(2.0));
    function_sizes.push_back(
        (bdry_mh.point(i) - bdry_mh.point((i + 1) % bdry_mh.n_points())).norm());
  }
  // If holes are present, do the same for the hole boundaries
  if(_holes)
    for (const Hole * hole : *_holes)
    {
      for (unsigned int i = 0; i < hole->n_points(); i++)
      {
        function_points.push_back(
            (hole->point(i) + hole->point((i + 1) % hole->n_points())) / Real(2.0));
        function_sizes.push_back(
            (hole->point(i) - hole->point((i + 1) % hole->n_points())).norm());
      }
    }
 
  std::for_each(
      function_sizes.begin(), function_sizes.end(), [&area_factor](Real & a) { a = a * a * area_factor * std::sqrt(3.0) / 4.0; });
 
}

References _bdy_ids, _holes, _mesh, and libMesh::Real.

Referenced by get_auto_area_function().

desired_area()

Real & libMesh::TriangulatorInterface::desired_area ( )

inline

Sets and/or gets the desired triangle area.

Set to zero to disable area constraint.

If a desired_area_function is set, then desired_area() should be used to set a minimum desired area; this will reduce "false negatives" by suggesting how finely to sample desired_area_function inside large triangles, where ideally the desired_area_function will be satisfied in the triangle interior and not just at the triangle vertices.

Definition at line 177 of file triangulator_interface.h.

{return _desired_area;}

References _desired_area.

Referenced by libMesh::MeshTools::Generation::build_delaunay_square(), MeshTriangulationTest::commonSettings(), libMesh::Poly2TriTriangulator::insert_refinement_points(), main(), libMesh::Poly2TriTriangulator::should_refine_elem(), MeshTriangulationTest::testPoly2TriRefinementBase(), MeshTriangulationTest::testTriangulatorHolePerturbed(), MeshTriangulationTest::testTriangulatorHoleTangentPerturbed(), MeshTriangulationTest::testTriangulatorInterp(), and triangulate_domain().

elem_type()

ElemType & libMesh::TriangulatorInterface::elem_type ( )

inline

Sets and/or gets the desired element type.

Definition at line 164 of file triangulator_interface.h.

{return _elem_type;}

References _elem_type.

Referenced by libMesh::MeshTools::Generation::build_delaunay_square(), MeshTriangulationTest::testEdge3ToTri6Base(), MeshTriangulationTest::testPoly2TriEdge3ToTri6FlipThrows(), MeshTriangulationTest::testPoly2TriEdge3ToTri7CenterFixup(), and MeshTriangulationTest::testTriangulatorRoundHole().

elems_to_segments()

void libMesh::TriangulatorInterface::elems_to_segments ( )

protected

Helper function to create PSLG segments from our other boundary-defining options (1D mesh edges, 2D mesh boundary sides), if no segments already exist.

Definition at line 155 of file triangulator_interface.C.

{
  // Don't try to override manually specified segments
  if (!this->segments.empty())
    return;
 
  // If we have edges, they should form the polyline with the ordering
  // we want.  Let's turn them into segments for later use, because
  // we're going to delete the original elements to replace with our
  // triangulation.
  if (_mesh.n_elem())
    {
      // Mapping from points to node ids, to back those out from
      // MeshedHole results later
      std::map<Point, dof_id_type> point_id_map;
 
      for (Node * node : _mesh.node_ptr_range())
        {
          // We're not going to support overlapping nodes on the boundary
          libmesh_error_msg_if
            (point_id_map.count(*node),
             "TriangulatorInterface does not support overlapping nodes found at "
             << static_cast<Point&>(*node));
 
          point_id_map.emplace(*node, node->id());
        }
 
      // We don't support directly generating Tri6, so for
      // compatibility with future stitching we need to be working
      // with first-order elements.  Let's get rid of any non-vertex
      // nodes we just added.
      for (Elem * elem : _mesh.element_ptr_range())
        for (auto n : make_range(elem->n_vertices(), elem->n_nodes()))
          point_id_map.erase(elem->point(n));
 
      // We'll steal the ordering calculation from
      // the MeshedHole code
      const TriangulatorInterface::MeshedHole mh { _mesh, this->_bdy_ids };
 
      // If we've specified only a subset of the mesh as our outer
      // boundary, then we may have nodes that don't actually fall
      // inside that boundary.  Triangulator code doesn't like Steiner
      // points that aren't inside the triangulation domain, so we
      // need to get rid of them.
      //
      // Also, if we're using Edge3 elements to define our outer
      // boundary, we're only dealing with their 2 end nodes and we'll
      // need to get rid of their central nodes.
      std::unordered_set<Node *> nodes_to_delete;
 
      for (Elem * elem : _mesh.element_ptr_range())
        for (auto n : make_range(elem->n_vertices(), elem->n_nodes()))
          nodes_to_delete.insert(elem->node_ptr(n));
 
      if (!this->_bdy_ids.empty())
        {
          for (auto & node : _mesh.node_ptr_range())
            if (!mh.contains(*node))
              nodes_to_delete.insert(node);
        }
 
      // And now we're done with elements.  Delete them lest they have
      // dangling pointers to nodes we'll be deleting.
      _mesh.clear_elems();
 
      // Make segments from boundary nodes; also make sure we don't
      // delete them.
      const std::size_t np = mh.n_points();
      for (auto i : make_range(np))
        {
          const Point pt = mh.point(i);
          const dof_id_type id0 = libmesh_map_find(point_id_map, pt);
          nodes_to_delete.erase(_mesh.node_ptr(id0));
          const Point next_pt = mh.point((np+i+1)%np);
          const dof_id_type id1 = libmesh_map_find(point_id_map, next_pt);
          this->segments.emplace_back(id0, id1);
          for (auto m : make_range(mh.n_midpoints()))
          {
            this->segment_midpoints.emplace_back(mh.midpoint(m, i));
            this->segment_midpoints_keys.emplace_back(pt);
          }
        }
 
      for (Node * node : nodes_to_delete)
        _mesh.delete_node(node);
 
      if (this->_verify_hole_boundaries && _holes)
        this->verify_holes(mh);
    }
}

References _bdy_ids, _holes, _mesh, _verify_hole_boundaries, libMesh::MeshBase::clear_elems(), libMesh::MeshBase::delete_node(), libMesh::make_range(), libMesh::MeshBase::n_elem(), libMesh::MeshBase::node_ptr(), segment_midpoints, segment_midpoints_keys, segments, and verify_holes().

Referenced by libMesh::TriangleInterface::triangulate(), and libMesh::Poly2TriTriangulator::triangulate().

fixup_tri7_center_nodes()

void libMesh::TriangulatorInterface::fixup_tri7_center_nodes ( )

protected

Helper called at the end of increase_triangle_order() for TRI7 to reposition the interior node to the curved-mapping image of the reference centroid after boundary midpoints have been snapped.

Safe to call unconditionally for TRI7.

Definition at line 446 of file triangulator_interface.C.

{
  libmesh_assert_equal_to(_elem_type, TRI7);
 
  // Place the interior node at the image of the reference centroid
  // (xi, eta) = (1/3, 1/3) under the curved Tri6 map, using the Tri6
  // shape function values there as weights: -1/9 on the vertices and
  // 4/9 on the mid-edges.  This reduces to the straight-edge centroid
  // when no boundary midpoint has moved.
  static const Real wv = -Real(1)/9;
  static const Real wm =  Real(4)/9;
 
  for (Elem * elem : _mesh.element_ptr_range())
    {
      libmesh_assert_equal_to(elem->n_vertices(), 3);
      libmesh_assert_equal_to(elem->n_nodes(), 7u);
 
      elem->point(6) = wv * (elem->point(0) +
                             elem->point(1) +
                             elem->point(2)) +
                       wm * (elem->point(3) +
                             elem->point(4) +
                             elem->point(5));
    }
}

References _elem_type, _mesh, libMesh::Real, and libMesh::TRI7.

Referenced by increase_triangle_order().

get_auto_area_function()

FunctionBase< Real > * libMesh::TriangulatorInterface::get_auto_area_function

(

)

Get the auto area function.

Definition at line 618 of file triangulator_interface.C.

{
  if (!_auto_area_function->initialized())
  {
    // Points and target element sizes for the interpolation
    std::vector<Point> function_points;
    std::vector<Real> function_sizes;
    calculate_auto_desired_area_samples(function_points, function_sizes);
    _auto_area_function->init_mfi(function_points, function_sizes);
  }
  return _auto_area_function.get();
}

References _auto_area_function, and calculate_auto_desired_area_samples().

Referenced by libMesh::Poly2TriTriangulator::should_refine_elem().

get_desired_area_function()

virtual FunctionBase< Real > * libMesh::TriangulatorInterface::get_desired_area_function ( )

inlinevirtual

Get the function giving desired triangle area as a function of position, or nullptr if no such function has been set.

Reimplemented in libMesh::Poly2TriTriangulator.

Definition at line 193 of file triangulator_interface.h.

  { return nullptr; }

get_fixup_tri7_center_nodes()

bool libMesh::TriangulatorInterface::get_fixup_tri7_center_nodes ( ) const

inline

Definition at line 275 of file triangulator_interface.h.

{return _fixup_tri7_center_nodes;}

References _fixup_tri7_center_nodes.

get_interpolate_boundary_points()

int libMesh::TriangulatorInterface::get_interpolate_boundary_points

(

)

const

Complicated getter, for compatibility with insert_extra_points()

Definition at line 143 of file triangulator_interface.C.

{
  // backwards compatibility - someone might have turned this off via
  // the old API
  if (!_insert_extra_points)
    return 0;
 
  return _interpolate_boundary_points;
}

References _insert_extra_points, and _interpolate_boundary_points.

Referenced by insert_any_extra_boundary_points().

get_outer_boundary_ids()

const std::set< std::size_t > & libMesh::TriangulatorInterface::get_outer_boundary_ids ( ) const

inline

Definition at line 371 of file triangulator_interface.h.

{ return _bdy_ids; }

References _bdy_ids.

get_verify_hole_boundaries()

bool libMesh::TriangulatorInterface::get_verify_hole_boundaries ( ) const

inline

Definition at line 264 of file triangulator_interface.h.

{return _verify_hole_boundaries;}

References _verify_hole_boundaries.

has_auto_area_function()

bool libMesh::TriangulatorInterface::has_auto_area_function ( )

inline

Whether or not an auto area function has been set.

Definition at line 348 of file triangulator_interface.h.

{return _auto_area_function != nullptr;}

References _auto_area_function.

Referenced by libMesh::Poly2TriTriangulator::insert_refinement_points(), and libMesh::Poly2TriTriangulator::should_refine_elem().

increase_triangle_order()

void libMesh::TriangulatorInterface::increase_triangle_order ( )

protected

Helper function to upconvert Tri3 to any higher order triangle type if requested via _elem_type.

Should be called at the end of triangulate()

Definition at line 341 of file triangulator_interface.C.

{
  switch (_elem_type)
    {
    case TRI3:
    // Nothing to do if we're not requested to increase order
      return;
    case TRI6:
      _mesh.all_second_order();
      break;
    case TRI7:
      _mesh.all_complete_order();
      break;
    default:
      libmesh_not_implemented();
    }
 
  // If we have any midpoint location data, we'll want to look it up
  // by point.  all_midpoints[{p, m}] will be the mth midpoint
  // location following after point p (when traversing a triangle
  // counter-clockwise)
  std::map<std::pair<Point, unsigned int>, Point> all_midpoints;
  unsigned int n_midpoints =
    this->segment_midpoints.size() / this->segments.size();
  libmesh_assert_equal_to(this->segments.size() * n_midpoints,
                          this->segment_midpoints.size());
  for (auto m : make_range(n_midpoints))
    for (auto i : make_range(this->segments.size()))
      {
        const Point & p = segment_midpoints_keys[i*n_midpoints+m];
        all_midpoints[{p,m}] =
          this->segment_midpoints[i*n_midpoints+m];
      }
 
  if (_holes)
    for (const Hole * hole : *_holes)
      {
        if (!hole->n_midpoints())
          continue;
        if (!n_midpoints)
          n_midpoints = hole->n_midpoints();
        else if (hole->n_midpoints() != n_midpoints)
          libmesh_not_implemented_msg
            ("Differing boundary midpoint counts " <<
             hole->n_midpoints() << " and " << n_midpoints);
 
        // Our inner holes are expected to have points in
        // counter-clockwise order, which is backwards from how we
        // want to traverse them when iterating in counter-clockwise
        // order over a triangle, so we'll need to reverse our maps
        // carefully here.
        const auto n_hole_points = hole->n_points();
        libmesh_assert(n_hole_points);
        for (auto m : make_range(n_midpoints))
          {
            for (auto i : make_range(n_hole_points-1))
              {
                const Point & p = hole->point(i+1);
                all_midpoints[{p,m}] = hole->midpoint(n_midpoints-m-1, i);
              }
            const Point & p = hole->point(0);
            all_midpoints[{p,m}] = hole->midpoint(n_midpoints-m-1, n_hole_points-1);
          }
      }
 
  // The n_midpoints > 1 case is for future proofing, but in the
  // present we have EDGE4 and no TRI10 yet.
  if (n_midpoints > 1)
    libmesh_not_implemented_msg
      ("Cannot construct triangles with more than 1 midpoint per edge");
 
  if (!n_midpoints)
    return;
 
  for (Elem * elem : _mesh.element_ptr_range())
    {
      // This should only be called right after we've finished
      // converting a triangulation to higher order
      libmesh_assert_equal_to(elem->n_vertices(), 3);
      libmesh_assert_not_equal_to(elem->default_order(), FIRST);
 
      for (auto n : make_range(3))
        {
          // Only hole/outer boundary segments need adjusted midpoints
          if (elem->neighbor_ptr(n))
            continue;
 
          const Point & p = elem->point(n);
 
          if (const auto it = all_midpoints.find({p,0});
              it != all_midpoints.end())
            elem->point(n+3) = it->second;
        }
    }
 
  // Moving boundary mid-edge nodes can displace the TRI7 interior node
  // and tangle the element map.  Repositioning the interior node is
  // opt-in (off by default); the validity check always runs.
  if (_elem_type == TRI7 && _fixup_tri7_center_nodes)
    this->fixup_tri7_center_nodes();
 
  this->verify_quadratic_elements();
}

References _elem_type, _fixup_tri7_center_nodes, _holes, _mesh, libMesh::MeshBase::all_complete_order(), libMesh::MeshBase::all_second_order(), libMesh::FIRST, fixup_tri7_center_nodes(), libMesh::libmesh_assert(), libMesh::make_range(), segment_midpoints, segment_midpoints_keys, segments, libMesh::TRI3, libMesh::TRI6, libMesh::TRI7, and verify_quadratic_elements().

Referenced by libMesh::TriangleInterface::triangulate(), and libMesh::Poly2TriTriangulator::triangulate().

insert_any_extra_boundary_points()

void libMesh::TriangulatorInterface::insert_any_extra_boundary_points ( )

protected

Helper function to add extra points (midpoints of initial segments) to a PSLG triangulation.

Definition at line 287 of file triangulator_interface.C.

{
  // If the initial PSLG is really simple, e.g. an L-shaped domain or
  // a square/rectangle, the resulting triangulation may be very
  // "structured" looking.  Sometimes this is a problem if your
  // intention is to work with an "unstructured" looking grid.  We can
  // attempt to work around this limitation by inserting midpoints
  // into the original PSLG.  Inserting additional points into a
  // set of points meant to be a convex hull usually makes less sense.
 
  const int n_interpolated = this->get_interpolate_boundary_points();
  if ((_triangulation_type==PSLG) && n_interpolated)
    {
      // If we were lucky enough to start with contiguous node ids,
      // let's keep them that way.
      dof_id_type nn = _mesh.max_node_id();
 
      std::vector<std::pair<unsigned int, unsigned int>> old_segments =
        std::move(this->segments);
 
      // We expect to have converted any elems and/or nodes into
      // segments by now.
      libmesh_assert(!old_segments.empty());
 
      this->segments.clear();
 
      // Insert a new point on each segment at evenly spaced locations
      // between existing boundary points.
      // np=index into new points vector
      // n =index into original points vector
      for (auto old_segment : old_segments)
        {
          Node * begin_node = _mesh.node_ptr(old_segment.first);
          Node * end_node = _mesh.node_ptr(old_segment.second);
          dof_id_type current_id = begin_node->id();
          for (auto i : make_range(n_interpolated))
            {
              // new points are equispaced along the original segments
              const Point new_point =
                ((n_interpolated-i) * *(Point *)(begin_node) +
                 (i+1) * *(Point *)(end_node)) /
                (n_interpolated + 1);
              Node * next_node = _mesh.add_point(new_point, nn++);
              this->segments.emplace_back(current_id,
                                          next_node->id());
              current_id = next_node->id();
            }
          this->segments.emplace_back(current_id,
                                      end_node->id());
        }
    }
}

References _mesh, _triangulation_type, libMesh::MeshBase::add_point(), get_interpolate_boundary_points(), libMesh::DofObject::id(), libMesh::libmesh_assert(), libMesh::make_range(), libMesh::MeshBase::max_node_id(), libMesh::MeshBase::node_ptr(), PSLG, and segments.

Referenced by libMesh::TriangleInterface::triangulate(), and libMesh::Poly2TriTriangulator::triangulate().

insert_extra_points()

bool & libMesh::TriangulatorInterface::insert_extra_points ( )

inline

Sets and/or gets the flag for inserting add'l points.

Definition at line 210 of file triangulator_interface.h.

{return _insert_extra_points;}

References _insert_extra_points.

minimum_angle()

Real & libMesh::TriangulatorInterface::minimum_angle ( )

inline

Sets and/or gets the minimum desired angle.

Set to zero to disable angle constraint.

Definition at line 200 of file triangulator_interface.h.

{return _minimum_angle;}

References _minimum_angle.

Referenced by MeshTriangulationTest::commonSettings(), libMesh::Poly2TriTriangulator::insert_refinement_points(), and main().

nodes_to_segments()

void libMesh::TriangulatorInterface::nodes_to_segments ( dof_id_type  max_node_id )

protected

Helper function to create PSLG segments from our node ordering, up to the maximum node id, if no segments already exist.

Definition at line 248 of file triangulator_interface.C.

{
  // Don't try to override manually specified segments, or try to add
  // segments if we're doing a convex hull
  if (!this->segments.empty() || _triangulation_type != PSLG)
    return;
 
  for (auto node_it = _mesh.nodes_begin(),
       node_end = _mesh.nodes_end();
       node_it != node_end;)
    {
      Node * node = *node_it;
 
      // If we're out of boundary nodes, the rest are going to be
      // Steiner points or hole points
      if (node->id() >= max_node_id)
        break;
 
      ++node_it;
 
      Node * next_node = (node_it == node_end) ?
        *_mesh.nodes_begin() : *node_it;
 
      this->segments.emplace_back(node->id(), next_node->id());
    }
 
  if (this->_verify_hole_boundaries && _holes)
    {
      std::vector<Point> outer_pts;
      for (auto segment : this->segments)
        outer_pts.push_back(_mesh.point(segment.first));
 
      ArbitraryHole ah(outer_pts);
      this->verify_holes(ah);
    }
}

References _holes, _mesh, _triangulation_type, _verify_hole_boundaries, libMesh::DofObject::id(), libMesh::MeshBase::point(), PSLG, segments, and verify_holes().

Referenced by libMesh::TriangleInterface::triangulate(), and libMesh::Poly2TriTriangulator::triangulate().

quiet()

bool & libMesh::TriangulatorInterface::quiet ( )

inline

Whether not to silence internal messages to stdout.

Definition at line 249 of file triangulator_interface.h.

{return _quiet;}

References _quiet.

refine_boundary_allowed()

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

inlinevirtual

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

True by default.

Reimplemented in libMesh::Poly2TriTriangulator.

Definition at line 237 of file triangulator_interface.h.

  { return true; }

set_auto_area_function()

void libMesh::TriangulatorInterface::set_auto_area_function	(	const Parallel::Communicator &	comm,
		const unsigned int	num_nearest_pts,
		const unsigned int	power,
		const Real	background_value,
		const Real	background_eff_dist
	)

Generate an auto area function based on spacing of boundary points.

The external boundary as well as the hole boundaries are taken into consideration to generate the auto area function based on inverse distance interpolation. For each EDGE element on these boundaries, its centroid (midpoint) is used as the point position and the desired area is calculated as 1.5 times of the area of the equilateral triangle with the edge length as the length of the EDGE element. For a given position, the inverse distance interpolation only considers a number of nearest points (set by num_nearest_pts) to calculate the desired area. The weight of the value at each point is calculated as 1/distance^power.

In addition to these conventional inverse distance interpolation features, a concept of "background value" and "background effective distance" is introduced. The background value belongs to a virtual point located at a constant distance (background effective distance) from the given position. The weight of the value at this virtual point is calculated as 1/background_effective_distance^power. Effectively, the background value is the value when the given position is far away from the boundary points.

Definition at line 609 of file triangulator_interface.C.

{
   _auto_area_function = std::make_unique<AutoAreaFunction>(comm, num_nearest_pts, power, background_value, background_eff_dist);
}

References _auto_area_function.

set_desired_area_function()

virtual void libMesh::TriangulatorInterface::set_desired_area_function ( FunctionBase< Real > *  )

inlinevirtual

Set a function giving desired triangle area as a function of position.

Set this to nullptr to disable position-dependent area constraint (falling back on desired_area()).

This may not be implemented in all subclasses.

Reimplemented in libMesh::Poly2TriTriangulator.

Definition at line 186 of file triangulator_interface.h.

  { libmesh_not_implemented(); }

set_fixup_tri7_center_nodes()

void libMesh::TriangulatorInterface::set_fixup_tri7_center_nodes ( bool  v )

inline

For TRI7 elements, after boundary mid-edge nodes have been snapped to a curved boundary in increase_triangle_order(), the interior node can be repositioned to the curved-mapping image of the reference centroid.

This is off by default; enable it only if the consuming code wants the relocated interior node.

Definition at line 273 of file triangulator_interface.h.

{_fixup_tri7_center_nodes = v;}

References _fixup_tri7_center_nodes.

Referenced by MeshTriangulationTest::testPoly2TriEdge3ToTri7CenterFixup().

set_interpolate_boundary_points()

void libMesh::TriangulatorInterface::set_interpolate_boundary_points

(

int

n_points

)

Complicated setter, for compatibility with insert_extra_points()

Definition at line 129 of file triangulator_interface.C.

{
  // Maybe we'll reserve a meaning for negatives later?
  libmesh_assert(n_points >= 0);
 
  _interpolate_boundary_points = n_points;
 
  // backwards compatibility - someone (including us) might want to
  // query this via the old API.
  _insert_extra_points = n_points;
}

References _insert_extra_points, _interpolate_boundary_points, and libMesh::libmesh_assert().

Referenced by MeshTriangulationTest::testTriangulatorInterp().

set_outer_boundary_ids()

void libMesh::TriangulatorInterface::set_outer_boundary_ids ( std::set< std::size_t >  bdy_ids )

inline

A set of ids to allow on the outer boundary loop: interpreted as boundary ids of 2D elements and/or subdomain ids of 1D edges.

If this is empty, then the outer boundary may be constructed from boundary edges of any id!

Definition at line 370 of file triangulator_interface.h.

{ _bdy_ids = std::move(bdy_ids); }

References _bdy_ids.

Referenced by MeshTriangulationTest::testHalfDomain().

set_refine_boundary_allowed()

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

inlinevirtual

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

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

This may not be implemented in all subclasses.

Reimplemented in libMesh::Poly2TriTriangulator.

Definition at line 230 of file triangulator_interface.h.

  { libmesh_not_implemented(); }

set_verify_hole_boundaries()

void libMesh::TriangulatorInterface::set_verify_hole_boundaries ( bool  v )

inline

Verifying that hole boundaries don't cross the outer boundary or each other is something like O(N_bdys^2*N_points_per_bdy^2), so we only do it if requested.

Definition at line 262 of file triangulator_interface.h.

{_verify_hole_boundaries = v;}

References _verify_hole_boundaries.

Referenced by MeshTriangulationTest::commonSettings().

smooth_after_generating()

bool & libMesh::TriangulatorInterface::smooth_after_generating ( )

inline

Sets/gets flag which tells whether to do two steps of Laplace mesh smoothing after generating the grid.

Definition at line 244 of file triangulator_interface.h.

{return _smooth_after_generating;}

References _smooth_after_generating.

Referenced by MeshTriangulationTest::commonSettings(), and triangulate_domain().

total_hole_points()

unsigned int libMesh::TriangulatorInterface::total_hole_points ( )

protected

Helper function to count points in and verify holes.

Definition at line 585 of file triangulator_interface.C.

{
  // If the holes vector is non-nullptr (and non-empty) we need to determine
  // the number of additional points which the holes will add to the
  // triangulation.
  // Note that the number of points is always equal to the number of segments
  // that form the holes.
  unsigned int n_hole_points = 0;
 
  if (_holes)
    for (const auto & hole : *_holes)
    {
      n_hole_points += hole->n_points();
      // A hole at least has one enclosure.
      // Points on enclosures are ordered so that we can add segments implicitly.
      // Elements in segment_indices() indicates the starting points of all enclosures.
      // The last element in segment_indices() is the number of total points.
      libmesh_assert_greater(hole->segment_indices().size(), 1);
      libmesh_assert_equal_to(hole->segment_indices().back(), hole->n_points());
    }
 
  return n_hole_points;
}

References _holes.

Referenced by libMesh::TriangleInterface::triangulate().

triangulate()

virtual void libMesh::TriangulatorInterface::triangulate ( )

pure virtual

This is the main public interface for this function.

Implemented in libMesh::TriangleInterface, and libMesh::Poly2TriTriangulator.

Referenced by MeshTriangulationTest::testEdge3ToTri6Base(), MeshTriangulationTest::testTriangulatorBase(), MeshTriangulationTest::testTriangulatorHolePerturbed(), MeshTriangulationTest::testTriangulatorHoles(), MeshTriangulationTest::testTriangulatorHoleTangentPerturbed(), MeshTriangulationTest::testTriangulatorInterp(), MeshTriangulationTest::testTriangulatorMeshedHoles(), and MeshTriangulationTest::testTriangulatorRoundHole().

triangulation_type()

TriangulationType & libMesh::TriangulatorInterface::triangulation_type ( )

inline

Sets and/or gets the desired triangulation type.

Definition at line 205 of file triangulator_interface.h.

{return _triangulation_type;}

References _triangulation_type.

Referenced by libMesh::MeshTools::Generation::build_delaunay_square(), MeshTriangulationTest::commonSettings(), main(), and triangulate_domain().

verify_holes()

void libMesh::TriangulatorInterface::verify_holes ( const Hole &  outer_bdy )

protected

Helper function to check holes for intersections if requested.

Definition at line 560 of file triangulator_interface.C.

{
  for (const Hole * hole : *_holes)
    {
      for (const Hole * hole2 : *_holes)
        {
          if (hole == hole2)
            continue;
 
          for (auto i : make_range(hole2->n_points()))
            if (hole->contains(hole2->point(i)))
              libmesh_error_msg
                ("Found point " << hole2->point(i) <<
                 " on one hole boundary and another's interior");
        }
 
      for (auto i : make_range(hole->n_points()))
        if (!outer_bdy.contains(hole->point(i)))
          libmesh_error_msg
            ("Found point " << hole->point(i) <<
             " on hole boundary but outside outer boundary");
    }
}

References _holes, libMesh::TriangulatorInterface::Hole::contains(), and libMesh::make_range().

Referenced by elems_to_segments(), and nodes_to_segments().

verify_quadratic_elements()

void libMesh::TriangulatorInterface::verify_quadratic_elements ( )

protected

Helper called at the end of increase_triangle_order() to verify that no boundary-midpoint snap has tangled a quadratic triangle, by sampling the signed element Jacobian at the reference nodes and centroid.

Errors out with a diagnostic naming the bad element and side if the Jacobian is non-positive.

Definition at line 473 of file triangulator_interface.C.

{
  if (_elem_type != TRI6 && _elem_type != TRI7)
    return;
 
  // Once fixup_tri7_center_nodes() has placed node 6, the TRI6 and TRI7
  // mappings coincide and this Tri6 formula serves both.
  static const Real xi_samples[7]  = {Real(0),   Real(1),   Real(0),
                                      Real(1)/2, Real(1)/2, Real(0),
                                      Real(1)/3};
  static const Real eta_samples[7] = {Real(0),   Real(0),   Real(1),
                                      Real(0),   Real(1)/2, Real(1)/2,
                                      Real(1)/3};
 
  for (Elem * elem : _mesh.element_ptr_range())
    {
      libmesh_assert_equal_to(elem->n_vertices(), 3);
      libmesh_assert_greater_equal(elem->n_nodes(), 6u);
 
      const Point & x0 = elem->point(0);
      const Point & x1 = elem->point(1);
      const Point & x2 = elem->point(2);
      const Point & x3 = elem->point(3);
      const Point & x4 = elem->point(4);
      const Point & x5 = elem->point(5);
 
      // Tri6 mapping derivative coefficients (see Tri6::volume()):
      // dx/dxi = xi*a1 + eta*b1 + c1, dx/deta = xi*b1 + eta*b2 + c2.
      const Point a1 =  4*x0 + 4*x1 - 8*x3;
      const Point b1 =  4*x0 - 4*x3 + 4*x4 - 4*x5;
      const Point c1 = -3*x0 - 1*x1 + 4*x3;
      const Point b2 =  4*x0 + 4*x2 - 8*x5;
      const Point c2 = -3*x0 - 1*x2 + 4*x5;
 
      // Scale the tolerance by the straight-edge triangle area, which
      // is strictly positive for the valid TRI3 poly2tri input.
      const Real ref_area = 0.5 * cross_norm(x1 - x0, x2 - x0);
      const Real jac_tol = TOLERANCE * ref_area;
 
      Real min_jac = std::numeric_limits<Real>::max();
      unsigned int worst_sample = 0;
      for (unsigned int s = 0; s != 7; ++s)
        {
          const Real xi  = xi_samples[s];
          const Real eta = eta_samples[s];
          const Point dxi  = xi*a1 + eta*b1 + c1;
          const Point deta = xi*b1 + eta*b2 + c2;
          // z-component of the cross product; the elements are planar.
          const Real jac = dxi(0)*deta(1) - dxi(1)*deta(0);
          if (jac < min_jac)
            {
              min_jac = jac;
              worst_sample = s;
            }
        }
 
      if (min_jac > jac_tol)
        continue;
 
      // Build a diagnostic naming every snapped boundary side on this
      // element so the user can immediately see which curved-boundary
      // input caused the tangle.
      std::ostringstream sides;
      for (unsigned int n = 0; n != 3; ++n)
        if (!elem->neighbor_ptr(n))
          {
            const Point straight =
              0.5 * (elem->point(n) + elem->point((n+1) % 3));
            sides << " (boundary side " << n
                  << ": straight midpoint " << straight
                  << ", snapped midpoint " << elem->point(n+3) << ")";
          }
 
      libmesh_error_msg(
        "TriangulatorInterface: snapping a boundary midpoint produced a "
        "tangled quadratic triangle (element " << elem->id()
        << ", non-positive Jacobian " << min_jac
        << " at reference sample (" << xi_samples[worst_sample] << ", "
        << eta_samples[worst_sample] << "); reference triangle area "
        << ref_area << ")." << sides.str()
        << " Refine the boundary discretization so that recorded "
        "midpoints lie closer to their straight-line midpoints, "
        "then retry.");
    }
}

References _elem_type, _mesh, libMesh::cross_norm(), libMesh::Real, libMesh::TOLERANCE, libMesh::TRI6, and libMesh::TRI7.

Referenced by increase_triangle_order().

Member Data Documentation

_auto_area_function

std::unique_ptr<AutoAreaFunction> libMesh::TriangulatorInterface::_auto_area_function

protected

The auto area function based on the spacing of boundary points.

Definition at line 518 of file triangulator_interface.h.

Referenced by get_auto_area_function(), has_auto_area_function(), and set_auto_area_function().

_bdy_ids

std::set<std::size_t> libMesh::TriangulatorInterface::_bdy_ids

protected

A set of ids to allow on the outer boundary loop.

Definition at line 452 of file triangulator_interface.h.

Referenced by calculate_auto_desired_area_samples(), elems_to_segments(), get_outer_boundary_ids(), and set_outer_boundary_ids().

_desired_area

Real libMesh::TriangulatorInterface::_desired_area

protected

The desired area for the elements in the resulting mesh.

Definition at line 463 of file triangulator_interface.h.

Referenced by desired_area(), and libMesh::TriangleInterface::triangulate().

_elem_type

ElemType libMesh::TriangulatorInterface::_elem_type

protected

The type of elements to generate.

(Defaults to TRI3).

Definition at line 458 of file triangulator_interface.h.

Referenced by elem_type(), fixup_tri7_center_nodes(), increase_triangle_order(), libMesh::TriangleInterface::triangulate(), libMesh::Poly2TriTriangulator::triangulate(), and verify_quadratic_elements().

_fixup_tri7_center_nodes

bool libMesh::TriangulatorInterface::_fixup_tri7_center_nodes

protected

Flag which tells if we want to relocate TRI7 interior nodes to the curved-mapping centroid after snapping boundary midpoints.

Definition at line 513 of file triangulator_interface.h.

Referenced by get_fixup_tri7_center_nodes(), increase_triangle_order(), and set_fixup_tri7_center_nodes().

_holes

const std::vector<Hole*>* libMesh::TriangulatorInterface::_holes

protected

A pointer to a vector of Hole*s.

If this is nullptr, there are no holes!

Definition at line 436 of file triangulator_interface.h.

Referenced by attach_hole_list(), calculate_auto_desired_area_samples(), elems_to_segments(), increase_triangle_order(), libMesh::Poly2TriTriangulator::insert_refinement_points(), libMesh::Poly2TriTriangulator::is_refine_boundary_allowed(), nodes_to_segments(), total_hole_points(), libMesh::TriangleInterface::triangulate(), libMesh::Poly2TriTriangulator::triangulate_current_points(), and verify_holes().

_insert_extra_points

bool libMesh::TriangulatorInterface::_insert_extra_points

protected

Flag which tells whether or not to insert additional nodes before triangulation.

This can sometimes be used to "de-regularize" the resulting triangulation.

This flag is supported for backwards compatibility; setting _interpolate_boundary_points = 1 is equivalent.

Definition at line 485 of file triangulator_interface.h.

Referenced by get_interpolate_boundary_points(), insert_extra_points(), and set_interpolate_boundary_points().

_interpolate_boundary_points

int libMesh::TriangulatorInterface::_interpolate_boundary_points

protected

Flag which tells how many additional nodes should be inserted between each pair of original mesh points.

Definition at line 491 of file triangulator_interface.h.

Referenced by get_interpolate_boundary_points(), and set_interpolate_boundary_points().

_markers

const std::vector<int>* libMesh::TriangulatorInterface::_markers

protected

Boundary markers.

Definition at line 441 of file triangulator_interface.h.

Referenced by attach_boundary_marker(), libMesh::TriangleInterface::triangulate(), and libMesh::Poly2TriTriangulator::triangulate().

_mesh

UnstructuredMesh& libMesh::TriangulatorInterface::_mesh

protected

Reference to the mesh which is to be created by triangle.

Definition at line 430 of file triangulator_interface.h.

Referenced by calculate_auto_desired_area_samples(), elems_to_segments(), fixup_tri7_center_nodes(), increase_triangle_order(), insert_any_extra_boundary_points(), libMesh::Poly2TriTriangulator::insert_refinement_points(), nodes_to_segments(), libMesh::TriangleInterface::triangulate(), libMesh::Poly2TriTriangulator::triangulate(), libMesh::Poly2TriTriangulator::triangulate_current_points(), and verify_quadratic_elements().

_minimum_angle

Real libMesh::TriangulatorInterface::_minimum_angle

protected

Minimum angle in triangles.

Definition at line 468 of file triangulator_interface.h.

Referenced by minimum_angle(), and libMesh::TriangleInterface::triangulate().

_quiet

bool libMesh::TriangulatorInterface::_quiet

protected

Flag which tells if we want to suppress stdout outputs.

Definition at line 502 of file triangulator_interface.h.

Referenced by quiet(), and libMesh::TriangleInterface::triangulate().

_regions

const std::vector<Region*>* libMesh::TriangulatorInterface::_regions

protected

A pointer to a vector of Regions*s.

If this is nullptr, there are no regions!

Definition at line 447 of file triangulator_interface.h.

Referenced by attach_region_list(), libMesh::TriangleInterface::triangulate(), and libMesh::Poly2TriTriangulator::triangulate().

_smooth_after_generating

bool libMesh::TriangulatorInterface::_smooth_after_generating

protected

Flag which tells whether we should smooth the mesh after it is generated.

True by default.

Definition at line 497 of file triangulator_interface.h.

Referenced by smooth_after_generating(), libMesh::TriangleInterface::triangulate(), and libMesh::Poly2TriTriangulator::triangulate().

_triangulation_type

TriangulationType libMesh::TriangulatorInterface::_triangulation_type

protected

The type of triangulation to perform: choices are: convex hull PSLG.

Definition at line 475 of file triangulator_interface.h.

Referenced by insert_any_extra_boundary_points(), nodes_to_segments(), libMesh::TriangleInterface::triangulate(), libMesh::Poly2TriTriangulator::triangulate(), and triangulation_type().

_verify_hole_boundaries

bool libMesh::TriangulatorInterface::_verify_hole_boundaries

protected

Flag which tells if we want to check hole geometry.

Definition at line 507 of file triangulator_interface.h.

Referenced by elems_to_segments(), get_verify_hole_boundaries(), nodes_to_segments(), and set_verify_hole_boundaries().

segment_midpoints

std::vector<Point> libMesh::TriangulatorInterface::segment_midpoints

When constructing a second-order triangulation from a second-order boundary, we may do the triangulation using first-order elements, in which case we need to save midpoint location data in order to reconstruct curvature along boundaries.

Definition at line 298 of file triangulator_interface.h.

Referenced by elems_to_segments(), and increase_triangle_order().

segment_midpoints_keys

std::vector<Point> libMesh::TriangulatorInterface::segment_midpoints_keys

When saving the midpoint location data, we need to save the corresponding segment information too.

Here the first point of the segment is saved so that it can be used as a key to find the corresponding segment midpoint.

Definition at line 306 of file triangulator_interface.h.

Referenced by elems_to_segments(), and increase_triangle_order().

segments

std::vector<std::pair<unsigned int, unsigned int> > libMesh::TriangulatorInterface::segments

When constructing a PSLG, if the node numbers do not define the desired boundary segments implicitly through the ordering of the points, you can use the segments vector to specify the segments explicitly, Ex: unit square numbered counter-clockwise starting from origin segments[0] = (0,1) segments[1] = (1,2) segments[2] = (2,3) segments[3] = (3,0) (For the above case you could actually use the implicit ordering!)

Definition at line 290 of file triangulator_interface.h.

Referenced by elems_to_segments(), increase_triangle_order(), insert_any_extra_boundary_points(), libMesh::Poly2TriTriangulator::insert_refinement_points(), nodes_to_segments(), MeshTriangulationTest::testTriangulatorSegments(), libMesh::TriangleInterface::triangulate(), and libMesh::Poly2TriTriangulator::triangulate_current_points().

---

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

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