libMesh::TriangleInterface Class Reference

A C++ interface between LibMesh and the Triangle library written by J.R. More...

#include <mesh_triangle_interface.h>

Inheritance diagram for libMesh::TriangleInterface:

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
	TriangleInterface (UnstructuredMesh &mesh)
	The constructor.
virtual	~TriangleInterface ()=default
	Empty destructor.
virtual void	triangulate () override
	Internally, this calls Triangle's triangulate routine.
std::string &	extra_flags ()
	Sets and/or gets additional flags to be passed to triangle.
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.

Private Attributes
std::string	_extra_flags
	Additional flags to be passed to triangle.
MeshSerializer	_serializer
	Triangle only operates on serial meshes.

Detailed Description

A C++ interface between LibMesh and the Triangle library written by J.R.

Shewchuk.

Author

John W. Peterson

Date

2011

Definition at line 41 of file mesh_triangle_interface.h.

Member Enumeration Documentation

TriangulationType

enum libMesh::TriangulatorInterface::TriangulationType

inherited

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

TriangleInterface()

libMesh::TriangleInterface::TriangleInterface ( 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 48 of file mesh_triangle_interface.C.

  : TriangulatorInterface(mesh),
    _extra_flags(""),
    _serializer(_mesh)
{}

~TriangleInterface()

virtual libMesh::TriangleInterface::~TriangleInterface ( )

virtualdefault

Empty destructor.

Member Function Documentation

attach_boundary_marker()

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

inlineinherited

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 libMesh::TriangulatorInterface::_markers.

attach_hole_list()

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

inlineinherited

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

Definition at line 255 of file triangulator_interface.h.

{_holes = holes;}

References libMesh::TriangulatorInterface::_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 )

inlineinherited

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 libMesh::TriangulatorInterface::_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  )

inherited

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 libMesh::TriangulatorInterface::_bdy_ids, libMesh::TriangulatorInterface::_holes, libMesh::TriangulatorInterface::_mesh, and libMesh::Real.

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

desired_area()

Real & libMesh::TriangulatorInterface::desired_area ( )

inlineinherited

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 libMesh::TriangulatorInterface::_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 ( )

inlineinherited

Sets and/or gets the desired element type.

Definition at line 164 of file triangulator_interface.h.

{return _elem_type;}

References libMesh::TriangulatorInterface::_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 ( )

protectedinherited

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 libMesh::TriangulatorInterface::_bdy_ids, libMesh::TriangulatorInterface::_holes, libMesh::TriangulatorInterface::_mesh, libMesh::TriangulatorInterface::_verify_hole_boundaries, libMesh::MeshBase::clear_elems(), libMesh::MeshBase::delete_node(), libMesh::make_range(), libMesh::MeshBase::n_elem(), libMesh::MeshBase::node_ptr(), libMesh::TriangulatorInterface::segment_midpoints, libMesh::TriangulatorInterface::segment_midpoints_keys, libMesh::TriangulatorInterface::segments, and libMesh::TriangulatorInterface::verify_holes().

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

extra_flags()

std::string & libMesh::TriangleInterface::extra_flags ( )

inline

Sets and/or gets additional flags to be passed to triangle.

Definition at line 66 of file mesh_triangle_interface.h.

{return _extra_flags;}

References _extra_flags.

fixup_tri7_center_nodes()

void libMesh::TriangulatorInterface::fixup_tri7_center_nodes ( )

protectedinherited

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 libMesh::TriangulatorInterface::_elem_type, libMesh::TriangulatorInterface::_mesh, libMesh::Real, and libMesh::TRI7.

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

get_auto_area_function()

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

inherited

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 libMesh::TriangulatorInterface::_auto_area_function, and libMesh::TriangulatorInterface::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 ( )

inlinevirtualinherited

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

inlineinherited

Definition at line 275 of file triangulator_interface.h.

{return _fixup_tri7_center_nodes;}

References libMesh::TriangulatorInterface::_fixup_tri7_center_nodes.

get_interpolate_boundary_points()

int libMesh::TriangulatorInterface::get_interpolate_boundary_points ( ) const

inherited

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 libMesh::TriangulatorInterface::_insert_extra_points, and libMesh::TriangulatorInterface::_interpolate_boundary_points.

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

get_outer_boundary_ids()

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

inlineinherited

Definition at line 371 of file triangulator_interface.h.

{ return _bdy_ids; }

References libMesh::TriangulatorInterface::_bdy_ids.

get_verify_hole_boundaries()

bool libMesh::TriangulatorInterface::get_verify_hole_boundaries ( ) const

inlineinherited

Definition at line 264 of file triangulator_interface.h.

{return _verify_hole_boundaries;}

References libMesh::TriangulatorInterface::_verify_hole_boundaries.

has_auto_area_function()

bool libMesh::TriangulatorInterface::has_auto_area_function ( )

inlineinherited

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 libMesh::TriangulatorInterface::_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 ( )

protectedinherited

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 libMesh::TriangulatorInterface::_elem_type, libMesh::TriangulatorInterface::_fixup_tri7_center_nodes, libMesh::TriangulatorInterface::_holes, libMesh::TriangulatorInterface::_mesh, libMesh::MeshBase::all_complete_order(), libMesh::MeshBase::all_second_order(), libMesh::FIRST, libMesh::TriangulatorInterface::fixup_tri7_center_nodes(), libMesh::libmesh_assert(), libMesh::make_range(), libMesh::TriangulatorInterface::segment_midpoints, libMesh::TriangulatorInterface::segment_midpoints_keys, libMesh::TriangulatorInterface::segments, libMesh::TRI3, libMesh::TRI6, libMesh::TRI7, and libMesh::TriangulatorInterface::verify_quadratic_elements().

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

insert_any_extra_boundary_points()

void libMesh::TriangulatorInterface::insert_any_extra_boundary_points ( )

protectedinherited

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 libMesh::TriangulatorInterface::_mesh, libMesh::TriangulatorInterface::_triangulation_type, libMesh::MeshBase::add_point(), libMesh::TriangulatorInterface::get_interpolate_boundary_points(), libMesh::DofObject::id(), libMesh::libmesh_assert(), libMesh::make_range(), libMesh::MeshBase::max_node_id(), libMesh::MeshBase::node_ptr(), libMesh::TriangulatorInterface::PSLG, and libMesh::TriangulatorInterface::segments.

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

insert_extra_points()

bool & libMesh::TriangulatorInterface::insert_extra_points ( )

inlineinherited

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 libMesh::TriangulatorInterface::_insert_extra_points.

minimum_angle()

Real & libMesh::TriangulatorInterface::minimum_angle ( )

inlineinherited

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 libMesh::TriangulatorInterface::_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 )

protectedinherited

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 libMesh::TriangulatorInterface::_holes, libMesh::TriangulatorInterface::_mesh, libMesh::TriangulatorInterface::_triangulation_type, libMesh::TriangulatorInterface::_verify_hole_boundaries, libMesh::DofObject::id(), libMesh::MeshBase::point(), libMesh::TriangulatorInterface::PSLG, libMesh::TriangulatorInterface::segments, and libMesh::TriangulatorInterface::verify_holes().

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

quiet()

bool & libMesh::TriangulatorInterface::quiet ( )

inlineinherited

Whether not to silence internal messages to stdout.

Definition at line 249 of file triangulator_interface.h.

{return _quiet;}

References libMesh::TriangulatorInterface::_quiet.

refine_boundary_allowed()

virtual bool libMesh::TriangulatorInterface::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.

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  )

inherited

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 libMesh::TriangulatorInterface::_auto_area_function.

set_desired_area_function()

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

inlinevirtualinherited

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 )

inlineinherited

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 libMesh::TriangulatorInterface::_fixup_tri7_center_nodes.

Referenced by MeshTriangulationTest::testPoly2TriEdge3ToTri7CenterFixup().

set_interpolate_boundary_points()

void libMesh::TriangulatorInterface::set_interpolate_boundary_points ( int  n_points )

inherited

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 libMesh::TriangulatorInterface::_insert_extra_points, libMesh::TriangulatorInterface::_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 )

inlineinherited

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 libMesh::TriangulatorInterface::_bdy_ids.

Referenced by MeshTriangulationTest::testHalfDomain().

set_refine_boundary_allowed()

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

inlinevirtualinherited

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 )

inlineinherited

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 libMesh::TriangulatorInterface::_verify_hole_boundaries.

Referenced by MeshTriangulationTest::commonSettings().

smooth_after_generating()

bool & libMesh::TriangulatorInterface::smooth_after_generating ( )

inlineinherited

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 libMesh::TriangulatorInterface::_smooth_after_generating.

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

total_hole_points()

unsigned int libMesh::TriangulatorInterface::total_hole_points ( )

protectedinherited

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 libMesh::TriangulatorInterface::_holes.

Referenced by triangulate().

triangulate()

void libMesh::TriangleInterface::triangulate ( )

overridevirtual

Internally, this calls Triangle's triangulate routine.

Implements libMesh::TriangulatorInterface.

Definition at line 58 of file mesh_triangle_interface.C.

{
  // Will the triangulation have holes?
  const bool have_holes = ((_holes != nullptr) && (!_holes->empty()));
 
  unsigned int n_hole_points = this->total_hole_points();
 
  // If we have no explicit segments defined, we may get them from
  // mesh elements
  this->elems_to_segments();
 
  // If we're doing PSLG without segments, construct them from all our
  // mesh nodes
  this->nodes_to_segments(_mesh.max_node_id());
 
  // Insert additional new points in between existing boundary points,
  // if that is requested and reasonable
  this->insert_any_extra_boundary_points();
 
  // Regardless of whether we added additional points, the set of points to
  // triangulate is now sitting in the mesh.
 
  // Triangle data structure for the mesh
  TriangleWrapper::triangulateio initial;
  TriangleWrapper::triangulateio final;
  TriangleWrapper::triangulateio voronoi;
 
  // Pseudo-Constructor for the triangle io structs
  TriangleWrapper::init(initial);
  TriangleWrapper::init(final);
  TriangleWrapper::init(voronoi);
 
  initial.numberofpoints = _mesh.n_nodes() + n_hole_points;
  initial.pointlist      = static_cast<REAL*>(std::malloc(initial.numberofpoints * 2 * sizeof(REAL)));
 
  if (_triangulation_type==PSLG)
    {
      // Implicit segment ordering: One segment per point, including hole points
      if (this->segments.empty())
        initial.numberofsegments = initial.numberofpoints;
 
      // User-defined segment ordering: One segment per entry in the segments vector
      else
        initial.numberofsegments = this->segments.size() + n_hole_points;
    }
 
  else if (_triangulation_type==GENERATE_CONVEX_HULL)
    initial.numberofsegments = n_hole_points; // One segment for each hole point
 
  // Allocate space for the segments (2 int per segment)
  if (initial.numberofsegments > 0)
    {
      initial.segmentlist = static_cast<int *> (std::malloc(initial.numberofsegments * 2 * sizeof(int)));
      if (_markers)
        initial.segmentmarkerlist = static_cast<int *> (std::malloc(initial.numberofsegments * sizeof(int)));
    }
 
 
  // Copy all the holes' points and segments into the triangle struct.
 
  // The hole_offset is a constant offset into the points vector which points
  // past the end of the last hole point added.
  unsigned int hole_offset=0;
 
  if (have_holes)
    for (const auto & hole : *_holes)
      {
        for (unsigned int ctr=0, h=0, i=0, hsism=hole->segment_indices().size()-1; i<hsism; ++i)
          {
            unsigned int begp = hole_offset + hole->segment_indices()[i];
            unsigned int endp = hole->segment_indices()[i+1];
 
            for (; h<endp; ctr+=2, ++h)
              {
                Point p = hole->point(h);
 
                const unsigned int index0 = 2*hole_offset+ctr;
                const unsigned int index1 = 2*hole_offset+ctr+1;
 
                // Save the x,y locations in the triangle struct.
                initial.pointlist[index0] = p(0);
                initial.pointlist[index1] = p(1);
 
                // Set the points which define the segments
                initial.segmentlist[index0] = hole_offset+h;
                initial.segmentlist[index1] = (h == endp - 1) ? begp : hole_offset + h + 1; // wrap around
                if (_markers)
                  // 1 is reserved for boundaries of holes
                  initial.segmentmarkerlist[hole_offset+h] = 1;
              }
          }
 
        // Update the hole_offset for the next hole
        hole_offset += hole->n_points();
      }
 
 
  // Copy all the non-hole points and segments into the triangle struct.
  std::vector<unsigned int> libmesh_id_to_pointlist_index(_mesh.max_node_id());
  {
    dof_id_type ctr=0;
    for (auto & node : _mesh.node_ptr_range())
      {
        dof_id_type index = 2*hole_offset + ctr;
 
        // Set x,y values in pointlist
        initial.pointlist[index] = (*node)(0);
        initial.pointlist[index+1] = (*node)(1);
        libmesh_id_to_pointlist_index[node->id()] = ctr/2;
 
        // If the user requested a PSLG, the non-hole points are also segments
        if (_triangulation_type==PSLG)
          {
            // Use implicit ordering to define segments
            if (this->segments.empty())
              {
                dof_id_type n = ctr/2; // ctr is always even
                initial.segmentlist[index] = hole_offset+n;
                initial.segmentlist[index+1] = (n==_mesh.n_nodes()-1) ? hole_offset : hole_offset+n+1; // wrap around
                if (_markers)
                  initial.segmentmarkerlist[hole_offset + n] = (*_markers)[n];
              }
          }
 
        ctr +=2;
      }
  }
 
 
  // If the user provided it, use his ordering to define the segments
  for (std::size_t ctr=0, s=0, ss=this->segments.size(); s<ss; ctr+=2, ++s)
    {
      const unsigned int index0 = 2*hole_offset+ctr;
      const unsigned int index1 = 2*hole_offset+ctr+1;
 
      initial.segmentlist[index0] = hole_offset +
        libmesh_id_to_pointlist_index[this->segments[s].first];
      initial.segmentlist[index1] = hole_offset +
        libmesh_id_to_pointlist_index[this->segments[s].second];
      if (_markers)
        initial.segmentmarkerlist[hole_offset + s] = (*_markers)[s];
    }
 
 
 
  // Tell the input struct about the holes
  if (have_holes)
    {
      initial.numberofholes = _holes->size();
      initial.holelist      = static_cast<REAL*>(std::malloc(initial.numberofholes * 2 * sizeof(REAL)));
      for (std::size_t i=0, ctr=0, hs=_holes->size(); i<hs; ++i, ctr+=2)
        {
          Point inside_point = (*_holes)[i]->inside();
          initial.holelist[ctr]   = inside_point(0);
          initial.holelist[ctr+1] = inside_point(1);
        }
    }
 
  if (_regions)
    {
      initial.numberofregions = _regions->size();
      initial.regionlist      = static_cast<REAL*>(std::malloc(initial.numberofregions * 4 * sizeof(REAL)));
      for (std::size_t i=0, ctr=0, rs=_regions->size(); i<rs; ++i, ctr+=4)
        {
          Point inside_point = (*_regions)[i]->inside();
          initial.regionlist[ctr]   = inside_point(0);
          initial.regionlist[ctr+1] = inside_point(1);
          initial.regionlist[ctr+2] = (*_regions)[i]->attribute();
          initial.regionlist[ctr+3] = (*_regions)[i]->max_area();
        }
    }
 
  // Set the triangulation flags.
  // c ~ enclose convex hull with segments
  // z ~ use zero indexing
  // B ~ Suppresses boundary markers in the output
  // Q ~ run in "quiet" mode
  // p ~ Triangulates a Planar Straight Line Graph
  //     If the `p' switch is used, `segmentlist' must point to a list of
  //     segments, `numberofsegments' must be properly set, and
  //     `segmentmarkerlist' must either be set to nullptr (in which case all
  //     markers default to zero), or must point to a list of markers.
  // D ~ Conforming Delaunay: use this switch if you want all triangles
  //     in the mesh to be Delaunay, and not just constrained Delaunay
  // q ~  Quality mesh generation with no angles smaller than 20 degrees.
  //      An alternate minimum angle may be specified after the q
  // a ~ Imposes a maximum triangle area constraint.
  // -P  Suppresses the output .poly file. Saves disk space, but you lose the ability to maintain
  //     constraining segments on later refinements of the mesh.
  // -e  Outputs (to an .edge file) a list of edges of the triangulation.
  // -v  Outputs the Voronoi diagram associated with the triangulation.
  // Create the flag strings, depends on element type
  std::ostringstream flags;
 
  // Default flags always used
  flags << "z";
 
  if (_quiet)
    flags << "QP";
  else
    flags << "V";
 
  if (_markers)
    flags << "ev";
 
  // Flags which are specific to the type of triangulation
  switch (_triangulation_type)
    {
    case GENERATE_CONVEX_HULL:
      {
        flags << "c";
        break;
      }
 
    case PSLG:
      {
        flags << "p";
        break;
      }
 
    case INVALID_TRIANGULATION_TYPE:
      libmesh_error_msg("ERROR: INVALID_TRIANGULATION_TYPE selected!");
 
    default:
      libmesh_error_msg("Unrecognized _triangulation_type");
    }
 
 
  // Flags specific to the type of element
  switch (_elem_type)
    {
    case TRI3:
      {
        // do nothing.
        break;
      }
 
    case TRI6:
      {
        flags << "o2";
        break;
      }
 
    default:
      libmesh_error_msg("ERROR: Unrecognized triangular element type == " << Utility::enum_to_string(_elem_type));
    }
 
 
  // If we do have holes and the user asked to GENERATE_CONVEX_HULL,
  // need to add the p flag so the triangulation respects those segments.
  if ((_triangulation_type==GENERATE_CONVEX_HULL) && (have_holes))
    flags << "p";
 
  // Finally, add the area constraint
  if (_desired_area > TOLERANCE)
    flags << "a" << std::fixed << _desired_area;
 
  // add minimum angle constraint
  if (_minimum_angle > TOLERANCE)
    flags << "q" << std::fixed << _minimum_angle;
 
  if (_regions)
    flags << "Aa";
 
  // add user provided extra flags
  if (_extra_flags.size() > 0)
    flags << _extra_flags;
 
  // Refine the initial output to conform to the area constraint
  if (_markers)
  {
    // need Voronoi to generate boundary information
    TriangleWrapper::triangulate(const_cast<char *>(flags.str().c_str()),
                                 &initial,
                                 &final,
                                 &voronoi);
 
    // Send the information computed by Triangle to the Mesh.
    TriangleWrapper::copy_tri_to_mesh(final,
                                      _mesh,
                                      _elem_type,
                                      &voronoi);
  }
  else
  {
    TriangleWrapper::triangulate(const_cast<char *>(flags.str().c_str()),
                                 &initial,
                                 &final,
                                 nullptr);
    // Send the information computed by Triangle to the Mesh.
    TriangleWrapper::copy_tri_to_mesh(final,
                                      _mesh,
                                      _elem_type);
  }
 
 
  _mesh.set_mesh_dimension(2);
 
  // The user might have requested TRI6 or higher instead of TRI3.  If
  // so then we'll need to get our neighbor pointers in order ahead of
  // time for increase_triangle_order() to use.
  if (_elem_type != TRI3)
    {
      _mesh.find_neighbors();
      this->increase_triangle_order();
    }
 
  // To the naked eye, a few smoothing iterations usually looks better,
  // so we do this by default unless the user says not to.
  if (this->_smooth_after_generating)
    LaplaceMeshSmoother(_mesh, 2).smooth();
 
  // Clean up.
  TriangleWrapper::destroy(initial,      TriangleWrapper::INPUT);
  TriangleWrapper::destroy(final,        TriangleWrapper::OUTPUT);
  TriangleWrapper::destroy(voronoi,      TriangleWrapper::OUTPUT);
 
  // Prepare the mesh for use before returning.  This ensures (among
  // other things) that it is partitioned and therefore users can
  // iterate over local elements, etc.
  _mesh.prepare_for_use();
}

References libMesh::TriangulatorInterface::_desired_area, libMesh::TriangulatorInterface::_elem_type, _extra_flags, libMesh::TriangulatorInterface::_holes, libMesh::TriangulatorInterface::_markers, libMesh::TriangulatorInterface::_mesh, libMesh::TriangulatorInterface::_minimum_angle, libMesh::TriangulatorInterface::_quiet, libMesh::TriangulatorInterface::_regions, libMesh::TriangulatorInterface::_smooth_after_generating, libMesh::TriangulatorInterface::_triangulation_type, libMesh::TriangleWrapper::copy_tri_to_mesh(), libMesh::TriangleWrapper::destroy(), libMesh::TriangulatorInterface::elems_to_segments(), libMesh::Utility::enum_to_string(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::TriangulatorInterface::GENERATE_CONVEX_HULL, libMesh::TriangulatorInterface::increase_triangle_order(), libMesh::TriangleWrapper::init(), libMesh::TriangleWrapper::INPUT, libMesh::TriangulatorInterface::insert_any_extra_boundary_points(), libMesh::TriangulatorInterface::INVALID_TRIANGULATION_TYPE, libMesh::MeshBase::max_node_id(), libMesh::MeshBase::n_nodes(), libMesh::TriangulatorInterface::nodes_to_segments(), libMesh::TriangleWrapper::OUTPUT, libMesh::MeshBase::prepare_for_use(), libMesh::TriangulatorInterface::PSLG, libMesh::TriangulatorInterface::segments, libMesh::MeshBase::set_mesh_dimension(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::TOLERANCE, libMesh::TriangulatorInterface::total_hole_points(), libMesh::TRI3, and libMesh::TRI6.

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

triangulation_type()

TriangulationType & libMesh::TriangulatorInterface::triangulation_type ( )

inlineinherited

Sets and/or gets the desired triangulation type.

Definition at line 205 of file triangulator_interface.h.

{return _triangulation_type;}

References libMesh::TriangulatorInterface::_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 )

protectedinherited

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 libMesh::TriangulatorInterface::_holes, libMesh::TriangulatorInterface::Hole::contains(), and libMesh::make_range().

Referenced by libMesh::TriangulatorInterface::elems_to_segments(), and libMesh::TriangulatorInterface::nodes_to_segments().

verify_quadratic_elements()

void libMesh::TriangulatorInterface::verify_quadratic_elements ( )

protectedinherited

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 libMesh::TriangulatorInterface::_elem_type, libMesh::TriangulatorInterface::_mesh, libMesh::cross_norm(), libMesh::Real, libMesh::TOLERANCE, libMesh::TRI6, and libMesh::TRI7.

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

Member Data Documentation

_auto_area_function

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

protectedinherited

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

Definition at line 518 of file triangulator_interface.h.

Referenced by libMesh::TriangulatorInterface::get_auto_area_function(), libMesh::TriangulatorInterface::has_auto_area_function(), and libMesh::TriangulatorInterface::set_auto_area_function().

_bdy_ids

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

protectedinherited

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

Definition at line 452 of file triangulator_interface.h.

Referenced by libMesh::TriangulatorInterface::calculate_auto_desired_area_samples(), libMesh::TriangulatorInterface::elems_to_segments(), libMesh::TriangulatorInterface::get_outer_boundary_ids(), and libMesh::TriangulatorInterface::set_outer_boundary_ids().

_desired_area

Real libMesh::TriangulatorInterface::_desired_area

protectedinherited

The desired area for the elements in the resulting mesh.

Definition at line 463 of file triangulator_interface.h.

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

_elem_type

ElemType libMesh::TriangulatorInterface::_elem_type

protectedinherited

The type of elements to generate.

(Defaults to TRI3).

Definition at line 458 of file triangulator_interface.h.

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

_extra_flags

std::string libMesh::TriangleInterface::_extra_flags

private

Additional flags to be passed to triangle.

Definition at line 72 of file mesh_triangle_interface.h.

Referenced by extra_flags(), and triangulate().

_fixup_tri7_center_nodes

bool libMesh::TriangulatorInterface::_fixup_tri7_center_nodes

protectedinherited

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 libMesh::TriangulatorInterface::get_fixup_tri7_center_nodes(), libMesh::TriangulatorInterface::increase_triangle_order(), and libMesh::TriangulatorInterface::set_fixup_tri7_center_nodes().

_holes

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

protectedinherited

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 libMesh::TriangulatorInterface::attach_hole_list(), libMesh::TriangulatorInterface::calculate_auto_desired_area_samples(), libMesh::TriangulatorInterface::elems_to_segments(), libMesh::TriangulatorInterface::increase_triangle_order(), libMesh::Poly2TriTriangulator::insert_refinement_points(), libMesh::Poly2TriTriangulator::is_refine_boundary_allowed(), libMesh::TriangulatorInterface::nodes_to_segments(), libMesh::TriangulatorInterface::total_hole_points(), triangulate(), libMesh::Poly2TriTriangulator::triangulate_current_points(), and libMesh::TriangulatorInterface::verify_holes().

_insert_extra_points

bool libMesh::TriangulatorInterface::_insert_extra_points

protectedinherited

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 libMesh::TriangulatorInterface::get_interpolate_boundary_points(), libMesh::TriangulatorInterface::insert_extra_points(), and libMesh::TriangulatorInterface::set_interpolate_boundary_points().

_interpolate_boundary_points

int libMesh::TriangulatorInterface::_interpolate_boundary_points

protectedinherited

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 libMesh::TriangulatorInterface::get_interpolate_boundary_points(), and libMesh::TriangulatorInterface::set_interpolate_boundary_points().

_markers

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

protectedinherited

Boundary markers.

Definition at line 441 of file triangulator_interface.h.

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

_mesh

UnstructuredMesh& libMesh::TriangulatorInterface::_mesh

protectedinherited

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

Definition at line 430 of file triangulator_interface.h.

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

_minimum_angle

Real libMesh::TriangulatorInterface::_minimum_angle

protectedinherited

Minimum angle in triangles.

Definition at line 468 of file triangulator_interface.h.

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

_quiet

bool libMesh::TriangulatorInterface::_quiet

protectedinherited

Flag which tells if we want to suppress stdout outputs.

Definition at line 502 of file triangulator_interface.h.

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

_regions

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

protectedinherited

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 libMesh::TriangulatorInterface::attach_region_list(), triangulate(), and libMesh::Poly2TriTriangulator::triangulate().

_serializer

MeshSerializer libMesh::TriangleInterface::_serializer

private

Triangle only operates on serial meshes.

Definition at line 77 of file mesh_triangle_interface.h.

_smooth_after_generating

bool libMesh::TriangulatorInterface::_smooth_after_generating

protectedinherited

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 libMesh::TriangulatorInterface::smooth_after_generating(), triangulate(), and libMesh::Poly2TriTriangulator::triangulate().

_triangulation_type

TriangulationType libMesh::TriangulatorInterface::_triangulation_type

protectedinherited

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

Definition at line 475 of file triangulator_interface.h.

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

_verify_hole_boundaries

bool libMesh::TriangulatorInterface::_verify_hole_boundaries

protectedinherited

Flag which tells if we want to check hole geometry.

Definition at line 507 of file triangulator_interface.h.

Referenced by libMesh::TriangulatorInterface::elems_to_segments(), libMesh::TriangulatorInterface::get_verify_hole_boundaries(), libMesh::TriangulatorInterface::nodes_to_segments(), and libMesh::TriangulatorInterface::set_verify_hole_boundaries().

segment_midpoints

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

inherited

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 libMesh::TriangulatorInterface::elems_to_segments(), and libMesh::TriangulatorInterface::increase_triangle_order().

segment_midpoints_keys

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

inherited

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 libMesh::TriangulatorInterface::elems_to_segments(), and libMesh::TriangulatorInterface::increase_triangle_order().

segments

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

inherited

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 libMesh::TriangulatorInterface::elems_to_segments(), libMesh::TriangulatorInterface::increase_triangle_order(), libMesh::TriangulatorInterface::insert_any_extra_boundary_points(), libMesh::Poly2TriTriangulator::insert_refinement_points(), libMesh::TriangulatorInterface::nodes_to_segments(), MeshTriangulationTest::testTriangulatorSegments(), triangulate(), and libMesh::Poly2TriTriangulator::triangulate_current_points().

---

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

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