libMesh::TriangleWrapper Namespace Reference

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.
void	destroy (triangulateio &t, IO_Type)
	Frees any memory which has been dynamically allocated by Triangle.
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.

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 57 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 105 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(Elem::build(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(Elem::build(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 == " << Utility::enum_to_string(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::Elem::build(), libMesh::MeshBase::clear(), libMesh::Utility::enum_to_string(), 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::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.

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