A special namespace for wrapping the standard Triangle API, as well as some helper functions for initializing/destroying the structs triangle uses to communicate. More...

Enumerations
enum	IO_Type { INPUT = 0, OUTPUT = 1, BOTH = 2 }

Functions
void	init (triangulateio &t)
	Initializes the fields of t to nullptr/0 as necessary. More...

void	destroy (triangulateio &t, IO_Type)
	Frees any memory which has been dynamically allocated by Triangle. More...

void	copy_tri_to_mesh (const triangulateio &triangle_data_input, UnstructuredMesh &mesh_output, const ElemType type, const triangulateio *voronoi=nullptr)
	Copies triangulation data computed by triangle from a triangulateio object to a LibMesh mesh. More...

Detailed Description

A special namespace for wrapping the standard Triangle API, as well as some helper functions for initializing/destroying the structs triangle uses to communicate.

Author: John W. Peterson

Date: 2011

Namespace that wraps the Triangle mesh generator's API.

Enumeration Type Documentation

◆ IO_Type

enum libMesh::TriangleWrapper::IO_Type

Enumerator
INPUT
OUTPUT
BOTH

Definition at line 65 of file mesh_triangle_wrapper.h.

              {
   INPUT  = 0,
   OUTPUT = 1,
   BOTH   = 2};

Function Documentation

◆ copy_tri_to_mesh()

void libMesh::TriangleWrapper::copy_tri_to_mesh	(	const triangulateio &	triangle_data_input,
		UnstructuredMesh &	mesh_output,
		const ElemType	type,
		const triangulateio *	voronoi = `nullptr`
	)

Copies triangulation data computed by triangle from a triangulateio object to a LibMesh mesh.

This routine is used internally by the MeshTools::Generation::build_delaunay_square(...) and MeshTools::Generation::build_delaunay_square_with_hole(...) routines.

Definition at line 103 of file mesh_triangle_wrapper.C.

 {
   // Transfer the information into the LibMesh mesh.
   mesh_output.clear();
  
   // Make sure the new Mesh will be 2D
   mesh_output.set_mesh_dimension(2);
  
   // Node information
   for (int i=0, c=0; c<triangle_data_input.numberofpoints; i+=2, ++c)
     {
       // Specify ID when adding point, otherwise, if this is DistributedMesh,
       // it might add points with a non-sequential numbering...
       mesh_output.add_point( Point(triangle_data_input.pointlist[i],
                                    triangle_data_input.pointlist[i+1]),
                              /*id=*/c);
     }
  
   // Element information
   for (int i=0; i<triangle_data_input.numberoftriangles; ++i)
     {
       switch (type)
         {
         case TRI3:
           {
             Elem * elem = mesh_output.add_elem (new Tri3);
  
             for (unsigned int n=0; n<3; ++n)
               elem->set_node(n) = mesh_output.node_ptr(triangle_data_input.trianglelist[i*3 + n]);
  
             // use the first attribute to set the subdomain ID
             if (triangle_data_input.triangleattributelist)
               elem->subdomain_id() =
                 std::round(triangle_data_input.
                            triangleattributelist[i * triangle_data_input.numberoftriangleattributes]);
             break;
           }
  
         case TRI6:
           {
             Elem * elem = mesh_output.add_elem (new Tri6);
  
             // Triangle number TRI6 nodes in a different way to libMesh
             elem->set_node(0) = mesh_output.node_ptr(triangle_data_input.trianglelist[i*6 + 0]);
             elem->set_node(1) = mesh_output.node_ptr(triangle_data_input.trianglelist[i*6 + 1]);
             elem->set_node(2) = mesh_output.node_ptr(triangle_data_input.trianglelist[i*6 + 2]);
             elem->set_node(3) = mesh_output.node_ptr(triangle_data_input.trianglelist[i*6 + 5]);
             elem->set_node(4) = mesh_output.node_ptr(triangle_data_input.trianglelist[i*6 + 3]);
             elem->set_node(5) = mesh_output.node_ptr(triangle_data_input.trianglelist[i*6 + 4]);
  
             // use the first attribute to set the subdomain ID
             if (triangle_data_input.triangleattributelist)
               elem->subdomain_id() =
                 std::round(triangle_data_input.
                            triangleattributelist[i * triangle_data_input.numberoftriangleattributes]);
             break;
           }
  
         default:
           libmesh_error_msg("ERROR: Unrecognized triangular element type.");
         }
     }
  
   // Note: If the input mesh was a parallel one, calling
   // prepare_for_use() now will re-parallelize it by a call to
   // delete_remote_elements()... We do not actually want to
   // reparallelize it here though: the triangulate() function may
   // still do some Mesh smoothing.  The main thing needed (for
   // smoothing) is the neighbor information, so let's just find
   // neighbors...
   //mesh_output.prepare_for_use(/*skip_renumber =*/false);
   mesh_output.find_neighbors();
  
   // set boundary info
   if (voronoi && triangle_data_input.edgemarkerlist)
   {
     BoundaryInfo & boundary_info = mesh_output.get_boundary_info();
     for (int e=0; e<triangle_data_input.numberofedges; ++e)
     {
       if (triangle_data_input.edgemarkerlist[e] != 0)
       {
         int p1 = triangle_data_input.edgelist[e + e];
         int p2 = triangle_data_input.edgelist[e + e + 1];
         int elem_id = voronoi->edgelist[e + e];
         unsigned short int s;
         if (p1 == triangle_data_input.trianglelist[elem_id*3] &&
             p2 == triangle_data_input.trianglelist[elem_id*3 + 1])
           s = 0;
         else if (p1 == triangle_data_input.trianglelist[elem_id*3 + 1] &&
                  p2 == triangle_data_input.trianglelist[elem_id*3 + 2])
           s = 1;
         else if (p1 == triangle_data_input.trianglelist[elem_id*3 + 2] &&
                  p2 == triangle_data_input.trianglelist[elem_id*3])
           s = 2;
         else
           libmesh_error_msg("ERROR: finding element errors for boundary edges.");
  
         boundary_info.add_side(elem_id, s, triangle_data_input.edgemarkerlist[e]);
       }
     }
   }
 }

References libMesh::MeshBase::add_elem(), libMesh::MeshBase::add_point(), libMesh::BoundaryInfo::add_side(), libMesh::MeshBase::clear(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::MeshBase::get_boundary_info(), libMesh::MeshBase::node_ptr(), libMesh::MeshBase::set_mesh_dimension(), libMesh::Elem::set_node(), libMesh::Elem::subdomain_id(), libMesh::TRI3, and libMesh::TRI6.

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

◆ destroy()

void libMesh::TriangleWrapper::destroy	(	triangulateio &	t,
		IO_Type
	)

Frees any memory which has been dynamically allocated by Triangle.

Note: Triangle does not free any memory itself.; It is always safe to call free on a nullptr.; Triangle does shallow-copy (for example) the holelist pointer from the input to output struct without performing a deep copy of the holelist itself. Therefore, double-free will occur without additional care!

Referenced by libMesh::PetscMatrix< libMesh::Number >::set_destroy_mat_on_exit(), and libMesh::TriangleInterface::triangulate().

◆ init()

void libMesh::TriangleWrapper::init ( triangulateio & t )

Initializes the fields of t to nullptr/0 as necessary.

This is helpful for preventing the access of uninitialized memory when working with C, which has no constructors or destructors.

Enumerations