Namespace that wraps the Triangle mesh generator's API. More...

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

Functions
void	init (triangulateio &t)

void	destroy (triangulateio &t, IO_Type)

void	copy_tri_to_mesh (const triangulateio &triangle_data_input, UnstructuredMesh &mesh_output, const ElemType type)

Detailed Description

Namespace that wraps the Triangle mesh generator's API.

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

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
	)

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.

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

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

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

◆ 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::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