libMesh::TriangleWrapper Namespace Reference

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

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

---

Enumeration Type Documentation

enum libMesh::TriangleWrapper::IO_Type

Enumerator:

INPUT
OUTPUT
BOTH

Definition at line 53 of file mesh_triangle_wrapper.h.

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

---

Function Documentation

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

Copies triangulation data computed by triange 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 102 of file mesh_triangle_wrapper.C.

References libMesh::MeshBase::add_elem(), libMesh::MeshBase::add_point(), libMesh::MeshBase::clear(), libMesh::err, libMesh::UnstructuredMesh::find_neighbors(), libMesh::MeshBase::node_ptr(), libMesh::MeshBase::set_mesh_dimension(), libMesh::Elem::set_node(), libMeshEnums::TRI3, and libMeshEnums::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 ParallelMesh,
        // 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::err << "ERROR: Unrecognized triangular element type." << std::endl;
              libmesh_error();
            }
          }
      }

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

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

Frees any memory which has been dynamically allocated by Triangle. Note the following facts: 1) Triangle does not free any memory itself 2) It is always safe to call free on a NULL pointer.

However, 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().

void libMesh::TriangleWrapper::init

(

triangulateio &

t

)

Initializes the fields of t to NULL/0 as necessary. This is helpful for preventing the access of uninitialized memory when working with C, which has no constructors or destructors.