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

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.

Referenced by libMesh::LaspackLinearSolver< T >::adjoint_solve(), libMesh::PetscLinearSolver< T >::adjoint_solve(), libMesh::SlepcEigenSolver< T >::attach_deflation_space(), libMesh::PetscDiffSolver::init(), libMesh::LaspackVector< T >::init(), libMesh::DistributedVector< T >::init(), libMesh::EigenSparseVector< T >::init(), libMesh::PetscVector< T >::init(), libMesh::EpetraVector< T >::init(), libMesh::EigenSparseLinearSolver< T >::solve(), libMesh::LaspackLinearSolver< T >::solve(), libMesh::NoxNonlinearSolver< T >::solve(), libMesh::PetscDiffSolver::solve(), libMesh::AztecLinearSolver< T >::solve(), libMesh::PetscNonlinearSolver< T >::solve(), libMesh::PetscLinearSolver< T >::solve(), libMesh::SlepcEigenSolver< T >::solve_generalized(), libMesh::SlepcEigenSolver< T >::solve_standard(), libMesh::TriangleInterface::triangulate(), libMesh::LaspackMatrix< T >::update_sparsity_pattern(), and libMesh::EpetraMatrix< T >::update_sparsity_pattern().