libMesh::NetGenMeshInterface Class Reference

Class NetGenMeshInterface provides an interface for tetrahedralization of meshes using the NetGen library. More...

#include <mesh_netgen_interface.h>

Inheritance diagram for libMesh::NetGenMeshInterface:

Public Member Functions
	NetGenMeshInterface (UnstructuredMesh &mesh)
	Constructor.
virtual	~NetGenMeshInterface () override=default
	Empty destructor.
virtual void	triangulate () override
	Method invokes NetGen library to compute a tetrahedralization.
Real &	desired_volume ()
	Sets and/or gets the desired tetrahedron volume.
bool &	smooth_after_generating ()
	Sets/gets flag which tells whether to do two steps of Laplace mesh smoothing after generating the grid.
ElemType &	elem_type ()
	Sets and/or gets the desired element type.
void	attach_hole_list (std::unique_ptr< std::vector< std::unique_ptr< UnstructuredMesh > > > holes)
	Attaches a vector of Mesh pointers defining holes which will be meshed around.
void	set_verbosity (unsigned int v)
	Sets a verbosity level, defaulting to 0 (print nothing), to be set as high as 100 (print everything).

Protected Types
enum	SurfaceIntegrity {   NON_TRI3 = 1 , MISSING_NEIGHBOR = 2 , EMPTY_MESH = 3 , MISSING_BACKLINK = 4 ,   BAD_NEIGHBOR_NODES = 5 , NON_ORIENTED = 6 , BAD_NEIGHBOR_LINKS = 7 , DEGENERATE_ELEMENT = 8 ,   DEGENERATE_MESH = 9 }
	Enumeration of possible surface mesh integrity issues. More...

Protected Member Functions
std::set< SurfaceIntegrity >	check_hull_integrity () const
	This function checks the integrity of the current set of elements in the Mesh to see if they comprise a topological manifold that (if it's also geometrically valid) would define valid boundary for a tetrahedralized volume.
std::set< SurfaceIntegrity >	improve_hull_integrity ()
	This function checks the integrity of the current set of elements in the Mesh, and corrects what it can.
void	process_hull_integrity_result (const std::set< SurfaceIntegrity > &result) const
	This function prints an informative message and throws an exception based on the output of the check_hull_integrity() function.
void	delete_2D_hull_elements ()
	Delete original convex hull elements from the Mesh after performing a Delaunay tetrahedralization.
void	increase_tet_order ()
	Converts all linear tet elements to the type requested by _elem_type, if that type differs from TET4.

Static Protected Member Functions
static BoundingBox	volume_to_surface_mesh (UnstructuredMesh &mesh)
	Remove volume elements from the given mesh, after converting their outer boundary faces to surface elements.

Protected Attributes
MeshSerializer	_serializer
	Tetgen only operates on serial meshes.
unsigned int	_verbosity
	verbosity setting
Real	_desired_volume
	The desired volume for the elements in the resulting mesh.
bool	_smooth_after_generating
	Flag which tells whether we should smooth the mesh after it is generated.
ElemType	_elem_type
	The exact type of tetrahedra we intend to construct.
UnstructuredMesh &	_mesh
	Local reference to the mesh we are working with.
std::unique_ptr< std::vector< std::unique_ptr< UnstructuredMesh > > >	_holes
	A pointer to a vector of meshes each defining a hole.

Detailed Description

Class NetGenMeshInterface provides an interface for tetrahedralization of meshes using the NetGen library.

For information about TetGen cf. NetGen github repository.

Author

Roy H. Stogner

Date

2024

Definition at line 52 of file mesh_netgen_interface.h.

Member Enumeration Documentation

SurfaceIntegrity

enum libMesh::MeshTetInterface::SurfaceIntegrity

protectedinherited

Enumeration of possible surface mesh integrity issues.

Enumerator
NON_TRI3
MISSING_NEIGHBOR
EMPTY_MESH
MISSING_BACKLINK
BAD_NEIGHBOR_NODES
NON_ORIENTED
BAD_NEIGHBOR_LINKS
DEGENERATE_ELEMENT
DEGENERATE_MESH

Definition at line 124 of file mesh_tet_interface.h.

                        {
    NON_TRI3 = 1,           // a non-TRI3 element is found
    MISSING_NEIGHBOR = 2,   // an element with a nullptr-neighbor is found
    EMPTY_MESH = 3,         // the mesh is empty
    MISSING_BACKLINK = 4,   // an element neighbor isn't linked back to it
    BAD_NEIGHBOR_NODES = 5, // an element neighbor isn't linked to expected nodes
    NON_ORIENTED = 6,       // an element neighbor has inconsistent orientation
    BAD_NEIGHBOR_LINKS = 7, // an element neighbor has other inconsistent links
    DEGENERATE_ELEMENT = 8, // an element has zero area
    DEGENERATE_MESH = 9     // the mesh clearly bounds zero volume
  };

Constructor & Destructor Documentation

NetGenMeshInterface()

libMesh::NetGenMeshInterface::NetGenMeshInterface ( UnstructuredMesh &  mesh )

explicit

Constructor.

Takes a reference to the mesh containing the triangulated surface which is to be tetrahedralized.

Definition at line 78 of file mesh_netgen_interface.C.

                                                                 :
  MeshTetInterface(mesh),
  _serializer(mesh)
{
}

~NetGenMeshInterface()

virtual libMesh::NetGenMeshInterface::~NetGenMeshInterface ( )

overridevirtualdefault

Empty destructor.

Member Function Documentation

attach_hole_list()

void libMesh::MeshTetInterface::attach_hole_list ( std::unique_ptr< std::vector< std::unique_ptr< UnstructuredMesh > > >  holes )

inherited

Attaches a vector of Mesh pointers defining holes which will be meshed around.

We use unique_ptr here because we expect that we may need to modify these meshes internally.

Definition at line 127 of file mesh_tet_interface.C.

{
  _holes = std::move(holes);
}

References libMesh::MeshTetInterface::_holes.

Referenced by MeshTetTest::testHole(), and MeshTetTest::testSphereShell().

check_hull_integrity()

std::set< MeshTetInterface::SurfaceIntegrity > libMesh::MeshTetInterface::check_hull_integrity ( ) const

protectedinherited

This function checks the integrity of the current set of elements in the Mesh to see if they comprise a topological manifold that (if it's also geometrically valid) would define valid boundary for a tetrahedralized volume.

Named check_hull_integrity() for backward compatibility, but now accepts non-convex manifolds.

Returns

a set of enums describing problems found, or an empty set if no problems are found.

Definition at line 341 of file mesh_tet_interface.C.

{
  // Check for easy return: if the Mesh is empty (i.e. if
  // somebody called triangulate_conformingDelaunayMesh on
  // a Mesh with no elements, then hull integrity check must
  // fail...
  if (_mesh.n_elem() == 0)
    return {EMPTY_MESH};
 
  std::set<MeshTetInterface::SurfaceIntegrity> returnval;
 
  const BoundingBox bb = MeshTools::create_bounding_box(this->_mesh);
  const Point extents = bb.max() - bb.min();
  if (extents(0) == 0 ||
      extents(1) == 0 ||
      extents(2) == 0)
    returnval.insert(DEGENERATE_MESH);
 
  // Figure a area to use for relative tolerances when detecting
  // degenerate elements
  const Real ref_area = std::abs(extents(0) * extents(1)) +
                        std::abs(extents(0) * extents(2)) +
                        std::abs(extents(1) * extents(2));
 
  struct TriChecker {
    std::set<MeshTetInterface::SurfaceIntegrity> my_returnval;
    const Real my_ref_area;
    const unsigned int my_verbosity;
 
    TriChecker (Real ref_area, unsigned int verbosity) :
      my_returnval(), my_ref_area(ref_area),
      my_verbosity(verbosity) {}
    TriChecker (TriChecker & other, Threads::split) :
      my_returnval(), my_ref_area(other.my_ref_area),
      my_verbosity(other.my_verbosity) {}
 
    void operator()(const ConstElemRange & range) {
 
      for (const Elem * elem : range)
        {
          // Check for proper element type
          if (elem->type() != TRI3)
            {
              if (my_verbosity >= 50)
                std::cerr << "Non-Tri3: " << elem->get_info() << std::endl;
              my_returnval.insert(NON_TRI3);
            }
 
          // Make sure it's a decent element.
          if (elem->volume() < my_ref_area * TOLERANCE * TOLERANCE)
            {
              if (my_verbosity >= 50)
                std::cerr << "Degenerate element: " << elem->get_info() << std::endl;
              my_returnval.insert(DEGENERATE_ELEMENT);
            }
 
          for (auto s : elem->side_index_range())
            {
              const Elem * const neigh = elem->neighbor_ptr(s);
 
              if (neigh == nullptr)
                {
                  if (my_verbosity >= 50)
                    std::cerr << "Element missing neighbor " << s << ": " << elem->get_info() << std::endl;
                  my_returnval.insert(MISSING_NEIGHBOR);
                  continue;
                }
 
              // Make sure our neighbor points back to us
              const unsigned int nn = neigh->which_neighbor_am_i(elem);
 
              if (nn >= 3)
                {
                  if (my_verbosity >= 50)
                    std::cerr << "Element missing backlink " << s << ": " << elem->get_info() << std::endl;
                  my_returnval.insert(MISSING_BACKLINK);
                  continue;
                }
 
              // Our neighbor should have the same the edge nodes we do on
              // the neighboring edgei
              const Node * const n1 = elem->node_ptr(s);
              const Node * const n2 = elem->node_ptr((s+1)%3);
 
              const unsigned int i1 = neigh->local_node(n1->id());
              const unsigned int i2 = neigh->local_node(n2->id());
              if (i1 >= 3 || i2 >= 3)
                {
                  if (my_verbosity >= 50)
                    std::cerr << "Element with bad neighbor " << s << " nodes: " << elem->get_info() << std::endl;
                  my_returnval.insert(BAD_NEIGHBOR_NODES);
                  continue;
                }
 
              // It should have those edge nodes in the opposite order
              // (because they have the same orientation we do)
              if ((i2 + 1)%3 != i1)
                {
                  if (my_verbosity >= 50)
                    std::cerr << "Element orientation mismatch with neighbor " << s << ": " << elem->get_info() << std::endl;
                  my_returnval.insert(NON_ORIENTED);
                  continue;
                }
 
              // And it should have those edge nodes in the expected
              // places relative to its neighbor link
              if (i2 != nn)
                {
                  if (my_verbosity >= 50)
                    std::cerr << "Element with bad links on neighbor " << s << ": " << elem->get_info() << std::endl;
                  my_returnval.insert(BAD_NEIGHBOR_LINKS);
                  continue;
                }
            }
        }
    }
 
    void join(TriChecker & other) {
      my_returnval.merge(other.my_returnval);
    }
  };
 
  TriChecker checker (ref_area, this->_verbosity);
 
  Threads::parallel_reduce
    (this->_mesh.active_local_element_stored_range(), checker);
 
  // Join problems found in threaded loop
  returnval.merge(checker.my_returnval);
 
  // Join problems found on other ranks
  std::set<char> int_set;
  std::transform
    (returnval.begin(), returnval.end(),
     std::inserter<std::set<char>>(int_set, int_set.end()),
     [](SurfaceIntegrity i){return int(i);});
  _mesh.comm().set_union(int_set);
  std::transform
    (int_set.begin(), int_set.end(),
     std::inserter<std::set<SurfaceIntegrity>>(returnval, returnval.end()),
     [](int i){return SurfaceIntegrity(i);});
 
  return returnval;
}

References libMesh::MeshTetInterface::_mesh, libMesh::MeshTetInterface::_verbosity, libMesh::MeshBase::active_local_element_stored_range(), libMesh::ParallelObject::comm(), libMesh::MeshTools::create_bounding_box(), libMesh::MeshTetInterface::DEGENERATE_MESH, libMesh::MeshTetInterface::EMPTY_MESH, libMesh::Elem::get_info(), libMesh::DofObject::id(), libMesh::Elem::local_node(), libMesh::BoundingBox::max(), libMesh::BoundingBox::min(), libMesh::MeshBase::n_elem(), libMesh::Elem::neighbor_ptr(), libMesh::Elem::node_ptr(), libMesh::Threads::parallel_reduce(), libMesh::Real, libMesh::Parallel::Communicator::set_union(), libMesh::Elem::side_index_range(), libMesh::TOLERANCE, libMesh::TRI3, libMesh::Elem::type(), libMesh::Elem::volume(), and libMesh::Elem::which_neighbor_am_i().

Referenced by libMesh::MeshTetInterface::improve_hull_integrity().

delete_2D_hull_elements()

void libMesh::MeshTetInterface::delete_2D_hull_elements ( )

protectedinherited

Delete original convex hull elements from the Mesh after performing a Delaunay tetrahedralization.

Definition at line 685 of file mesh_tet_interface.C.

{
  for (auto & elem : this->_mesh.element_ptr_range())
    {
      // Check for proper element type. Yes, we legally delete elements while
      // iterating over them because no entries from the underlying container
      // are actually erased.
      if (elem->type() == TRI3)
        _mesh.delete_elem(elem);
    }
 
  // We just removed any boundary info associated with hull element
  // edges, so let's update the boundary id caches.
  this->_mesh.get_boundary_info().regenerate_id_sets();
}

References libMesh::MeshTetInterface::_mesh, libMesh::MeshBase::delete_elem(), libMesh::MeshBase::get_boundary_info(), libMesh::BoundaryInfo::regenerate_id_sets(), libMesh::TRI3, and libMesh::Elem::type().

Referenced by libMesh::TetGenMeshInterface::triangulate_conformingDelaunayMesh_carvehole().

desired_volume()

Real & libMesh::MeshTetInterface::desired_volume ( )

inlineinherited

Sets and/or gets the desired tetrahedron volume.

Set to zero to disable volume constraint.

Definition at line 68 of file mesh_tet_interface.h.

{return _desired_volume;}

References libMesh::MeshTetInterface::_desired_volume.

Referenced by main(), and MeshTetTest::testSphereShell().

elem_type()

ElemType & libMesh::MeshTetInterface::elem_type ( )

inlineinherited

Sets and/or gets the desired element type.

This should be a Tet type.

Definition at line 81 of file mesh_tet_interface.h.

{return _elem_type;}

References libMesh::MeshTetInterface::_elem_type.

Referenced by MeshTetTest::testNetGenQuadratic(), MeshTetTest::testNetGenQuadraticCurved(), MeshTetTest::testNetGenTet14(), and MeshTetTest::testNetGenTet14Curved().

improve_hull_integrity()

std::set< MeshTetInterface::SurfaceIntegrity > libMesh::MeshTetInterface::improve_hull_integrity ( )

protectedinherited

This function checks the integrity of the current set of elements in the Mesh, and corrects what it can.

Returns

A set of SurfaceIntegrity codes from check_hull_integrity() if there are problems it can't fix, or an empty set otherwise.

Definition at line 488 of file mesh_tet_interface.C.

{
  // We don't really do anything parallel here, but we aspire to.
  libmesh_parallel_only(this->_mesh.comm());
 
  std::set<MeshTetInterface::SurfaceIntegrity> integrityproblems =
    this->check_hull_integrity();
 
  // If we have no problem, or a problem we can't fix, we're done.
  if (integrityproblems.empty() ||
      integrityproblems.count(NON_TRI3) ||
      integrityproblems.count(EMPTY_MESH))
    return integrityproblems;
 
  // Possibly the user gave us an unprepared mesh with missing or bad
  // neighbor links?
  if (integrityproblems.count(MISSING_NEIGHBOR) ||
      integrityproblems.count(MISSING_BACKLINK) ||
      integrityproblems.count(BAD_NEIGHBOR_LINKS))
  {
    this->_mesh.find_neighbors();
    integrityproblems = this->check_hull_integrity();
  }
 
  // If find_neighbors() doesn't fix these, I give up.
  if (integrityproblems.count(MISSING_NEIGHBOR) ||
      integrityproblems.count(MISSING_BACKLINK) ||
      integrityproblems.count(BAD_NEIGHBOR_LINKS))
    return integrityproblems;
 
  // find_neighbors() might have fixed everything
  if (integrityproblems.empty())
    return integrityproblems;
 
  // A non-oriented (but orientable!) surface is the only thing we
  // shouldn't have fixed or given up on by now.
  libmesh_assert_equal_to(integrityproblems.size(), 1);
  libmesh_assert_equal_to(integrityproblems.count(NON_ORIENTED), 1);
 
  // We need one known-good triangle to start from.  We'll pick the
  // most-negative-x normal among the triangles on the most-negative-x
  // point.
 
  // We'll just implement this in serial for now.
  MeshSerializer mesh_serializer(this->_mesh);
 
  // I don't see why we'd need boundary info here, but maybe we'll
  // want to preserve edge/node conditions eventually?
  BoundaryInfo & bi = this->_mesh.get_boundary_info();
 
  const Node * lowest_point = (*this->_mesh.elements_begin())->node_ptr(0);
 
  // Index by ids, not pointers, for consistency in parallel
  std::unordered_set<dof_id_type> attached_elements;
 
  for (Elem * elem : this->_mesh.element_ptr_range())
    {
      for (const Node & node : elem->node_ref_range())
        {
          if (node(0) < (*lowest_point)(0))
            {
              lowest_point = &node;
              attached_elements.clear();
            }
          if (&node == lowest_point)
            attached_elements.insert(elem->id());
        }
    }
 
  Elem * best_elem = nullptr;
  Real best_abs_normal_0 = 0;
 
  for (dof_id_type id : attached_elements)
    {
      Elem * elem = this->_mesh.elem_ptr(id);
      const Point e01 = elem->point(1) - elem->point(0);
      const Point e02 = elem->point(2) - elem->point(0);
      const Point normal = e01.cross(e02).unit();
      const Real abs_normal_0 = std::abs(normal(0));
 
      if (!best_elem || abs_normal_0 > best_abs_normal_0)
        {
          best_elem = elem;
          best_abs_normal_0 = abs_normal_0;
 
          // Make sure that element is actually a good one, by
          // flipping it if it's not.
          if (abs_normal_0 == normal(0))
            elem->flip(&bi);
        }
    }
 
  // Now flood-fill from that element to get a consistent orientation
  // for the others.
  std::unordered_set<dof_id_type> frontier_elements{best_elem->id()},
                                  finished_elements{};
 
  while (!frontier_elements.empty())
    {
      const dof_id_type elem_id = *frontier_elements.begin();
      Elem & elem = this->_mesh.elem_ref(elem_id);
      for (auto s : elem.side_index_range())
        {
          Elem * neigh = elem.neighbor_ptr(s);
          libmesh_assert(neigh);
          libmesh_assert_less(neigh->which_neighbor_am_i(&elem), 3);
 
          const Node * const n1 = elem.node_ptr(s);
          const Node * const n2 = elem.node_ptr((s+1)%3);
          const unsigned int i1 = neigh->local_node(n1->id());
          const unsigned int i2 = neigh->local_node(n2->id());
          libmesh_assert_less(i1, 3);
          libmesh_assert_less(i2, 3);
 
          const dof_id_type neigh_id = neigh->id();
 
          const bool frontier_neigh = frontier_elements.count(neigh_id);
          const bool finished_neigh = finished_elements.count(neigh_id);
 
          // Are we flipped?
          if ((i2 + 1)%3 != i1)
            {
              // Are we a Moebius strip???  We give up.
              if (frontier_neigh || finished_neigh)
                return integrityproblems;
 
              neigh->flip(&bi);
            }
 
          if (!frontier_neigh && !finished_neigh)
            frontier_elements.insert(neigh_id);
        }
 
      finished_elements.insert(elem_id);
      frontier_elements.erase(elem_id);
    }
 
  this->_mesh.find_neighbors();
 
  libmesh_assert(this->check_hull_integrity().empty());
 
  return {};
}

References libMesh::MeshTetInterface::_mesh, libMesh::MeshTetInterface::BAD_NEIGHBOR_LINKS, libMesh::MeshTetInterface::check_hull_integrity(), libMesh::ParallelObject::comm(), libMesh::TypeVector< T >::cross(), libMesh::MeshBase::elem_ptr(), libMesh::MeshBase::elem_ref(), libMesh::MeshTetInterface::EMPTY_MESH, libMesh::UnstructuredMesh::find_neighbors(), libMesh::Elem::flip(), libMesh::MeshBase::get_boundary_info(), libMesh::DofObject::id(), libMesh::libmesh_assert(), libMesh::Elem::local_node(), libMesh::MeshTetInterface::MISSING_BACKLINK, libMesh::MeshTetInterface::MISSING_NEIGHBOR, libMesh::Elem::neighbor_ptr(), libMesh::Elem::node_ptr(), libMesh::Elem::node_ref_range(), libMesh::MeshTetInterface::NON_ORIENTED, libMesh::MeshTetInterface::NON_TRI3, libMesh::Elem::point(), libMesh::Real, libMesh::Elem::side_index_range(), and libMesh::Elem::which_neighbor_am_i().

Referenced by triangulate(), and libMesh::TetGenMeshInterface::triangulate_conformingDelaunayMesh_carvehole().

increase_tet_order()

void libMesh::MeshTetInterface::increase_tet_order ( )

protectedinherited

Converts all linear tet elements to the type requested by _elem_type, if that type differs from TET4.

Definition at line 703 of file mesh_tet_interface.C.

{
  switch (_elem_type)
    {
    case TET4:
      return;
    case TET10:
      _mesh.all_second_order();
      break;
    case TET14:
      _mesh.all_complete_order();
      break;
    default:
      libmesh_not_implemented();
    }
}

References libMesh::MeshTetInterface::_elem_type, libMesh::MeshTetInterface::_mesh, libMesh::MeshBase::all_complete_order(), libMesh::MeshBase::all_second_order(), libMesh::TET10, libMesh::TET14, and libMesh::TET4.

Referenced by triangulate().

process_hull_integrity_result()

void libMesh::MeshTetInterface::process_hull_integrity_result ( const std::set< SurfaceIntegrity > &  result ) const

protectedinherited

This function prints an informative message and throws an exception based on the output of the check_hull_integrity() function.

It is a separate function so that you can check hull integrity without exiting or catching an exception if desired.

Definition at line 633 of file mesh_tet_interface.C.

{
  std::ostringstream err_msg;
 
  if (result.empty()) // success
    return;
 
  err_msg << "Error! Conforming Delaunay mesh tetrahedralization requires a convex hull." << std::endl;
 
  if (result.count(NON_TRI3))
    {
      err_msg << "At least one non-Tri3 element was found in the input boundary mesh.  ";
      err_msg << "Our constrained Delaunay tetrahedralization boundary must be a triangulation of Tri3 elements." << std::endl;
    }
  if (result.count(MISSING_NEIGHBOR))
    {
      err_msg << "At least one triangle without three neighbors was found in the input boundary mesh.  ";
      err_msg << "A constrained Delaunay tetrahedralization boundary must be a triangular manifold without boundary." << std::endl;
    }
  if (result.count(EMPTY_MESH))
    {
      err_msg << "The input boundary mesh was empty!" << std::endl;
      err_msg << "Our constrained Delaunay tetrahedralization boundary must be a triangulation of Tri3 elements." << std::endl;
    }
  if (result.count(MISSING_BACKLINK))
    {
      err_msg << "At least one triangle neighbor without a return neighbor link was found in the input boundary mesh.  ";
      err_msg << "A constrained Delaunay tetrahedralization boundary must be a conforming and non-adaptively-refined mesh." << std::endl;
    }
  if (result.count(BAD_NEIGHBOR_NODES))
    {
      err_msg << "At least one triangle neighbor without expected node links was found in the input boundary mesh.  ";
      err_msg << "A constrained Delaunay tetrahedralization boundary must be a conforming and non-adaptively-refined mesh." << std::endl;
    }
  if (result.count(NON_ORIENTED))
    {
      err_msg << "At least one triangle neighbor with an inconsistent orientation was found in the input boundary mesh.  ";
      err_msg << "A constrained Delaunay tetrahedralization boundary must be an oriented Tri3 mesh." << std::endl;
    }
  if (result.count(BAD_NEIGHBOR_LINKS))
    err_msg << "At least one triangle neighbor with inconsistent node and neighbor links was found in the input boundary mesh." << std::endl;
  if (result.count(DEGENERATE_ELEMENT))
    err_msg << "At least one input triangle is degenerate, with near-zero area relative to the manifold." << std::endl;
  if (result.count(DEGENERATE_MESH))
    err_msg << "The input mesh is degenerate, with zero thickness in at least one direction." << std::endl;
 
  libmesh_error_msg(err_msg.str());
}

References libMesh::MeshTetInterface::BAD_NEIGHBOR_LINKS, libMesh::MeshTetInterface::BAD_NEIGHBOR_NODES, libMesh::MeshTetInterface::DEGENERATE_ELEMENT, libMesh::MeshTetInterface::DEGENERATE_MESH, libMesh::MeshTetInterface::EMPTY_MESH, libMesh::MeshTetInterface::MISSING_BACKLINK, libMesh::MeshTetInterface::MISSING_NEIGHBOR, libMesh::MeshTetInterface::NON_ORIENTED, and libMesh::MeshTetInterface::NON_TRI3.

Referenced by triangulate(), and libMesh::TetGenMeshInterface::triangulate_conformingDelaunayMesh_carvehole().

set_verbosity()

void libMesh::MeshTetInterface::set_verbosity ( unsigned int  v )

inlineinherited

Sets a verbosity level, defaulting to 0 (print nothing), to be set as high as 100 (print everything).

For verbosity >= 50, print all detected surface mesh integrity issues as they're found. Subclasses may add other output at other verbosity levels.

Definition at line 214 of file mesh_tet_interface.h.

{
  this->_verbosity = v;
}

References libMesh::MeshTetInterface::_verbosity.

Referenced by MeshTetTest::testNetGen().

smooth_after_generating()

bool & libMesh::MeshTetInterface::smooth_after_generating ( )

inlineinherited

Sets/gets flag which tells whether to do two steps of Laplace mesh smoothing after generating the grid.

False by default (for compatibility with old TetGenMeshInterface behavior).

Definition at line 75 of file mesh_tet_interface.h.

{return _smooth_after_generating;}

References libMesh::MeshTetInterface::_smooth_after_generating.

triangulate()

void libMesh::NetGenMeshInterface::triangulate ( )

overridevirtual

Method invokes NetGen library to compute a tetrahedralization.

Implements libMesh::MeshTetInterface.

Definition at line 86 of file mesh_netgen_interface.C.

{
  using namespace nglib;
 
  LOG_SCOPE("triangulate()", "NetGenMeshInterface");
 
  if (_elem_type != TET4 &&
      _elem_type != TET10 &&
      _elem_type != TET14)
    libmesh_not_implemented();
 
  // We're hoping to do volume_to_surface_mesh in parallel at least,
  // but then we'll need to serialize any hole meshes to rank 0 so it
  // can use them in serial.
 
  // If the user wants higher-order output, record midpoints from any
  // quadratic boundary elements before stripping them to TRI3 for
  // NetGen.  We key by sorted position pairs (not node IDs) so that
  // outer mesh and hole mesh node namespaces cannot conflict.
  std::map<std::pair<Point,Point>, Point> edge_midpoints;
 
  // TRI7 boundary faces additionally carry a face-centroid node (local index
  // 6) that TET14 output reproduces (its faces are TRI7).  Record those too,
  // keyed by the sorted triple of the face's three corner positions so the
  // key is independent of node id and rotation.
  std::map<std::array<Point,3>, Point> face_centroids;
 
  auto record_and_strip =
    [&edge_midpoints, &face_centroids](UnstructuredMesh & m)
    {
      bool has_quadratic = false;
      for (const auto & elem : m.element_ptr_range())
        {
          if (elem->type() != TRI6 && elem->type() != TRI7) continue;
          has_quadratic = true;
          // TRI6/TRI7: edge e runs node[e]→node[(e+1)%3], midpoint=node[e+3]
          for (auto e : make_range(3u))
            {
              const Point & pa = elem->point(e);
              const Point & pb = elem->point((e+1)%3);
              auto key = pa < pb
                ? std::make_pair(pa,pb) : std::make_pair(pb,pa);
              edge_midpoints[key] = elem->point(e+3);
            }
          // TRI7: node 6 is the face-centroid node.
          if (elem->type() == TRI7)
            {
              std::array<Point,3> corners =
                {elem->point(0), elem->point(1), elem->point(2)};
              std::sort(corners.begin(), corners.end());
              face_centroids[corners] = elem->point(6);
            }
        }
      if (has_quadratic)
        m.all_first_order();
    };
 
  const BoundingBox mesh_bb =
    MeshTetInterface::volume_to_surface_mesh(this->_mesh);
 
  if (_elem_type != TET4)
    record_and_strip(this->_mesh);
 
  std::vector<MeshSerializer> hole_serializers;
  if (_holes)
    for (std::unique_ptr<UnstructuredMesh> & hole : *_holes)
      {
        const BoundingBox hole_bb =
          MeshTetInterface::volume_to_surface_mesh(*hole);
 
        if (_elem_type != TET4)
          record_and_strip(*hole);
 
        libmesh_error_msg_if
          (!mesh_bb.contains(hole_bb),
           "Found hole with bounding box " << hole_bb <<
           "\nextending outside of mesh bounding box " << mesh_bb);
 
        hole_serializers.emplace_back
          (*hole, /* need_serial */ true,
           /* serial_only_needed_on_proc_0 */ true);
      }
 
  // Increasing the element order (all_second_order()/all_complete_order()
  // via increase_tet_order()) performs collective MPI communication, so it
  // must run on every rank in lockstep -- it cannot run on rank 0 alone
  // while the other ranks wait in broadcast().  We therefore broadcast
  // NetGen's TET4 result first, then increase the order and restore the
  // curved-boundary midpoints identically on all ranks.  This mirrors what
  // the 2D interfaces do (see TriangulatorInterface::increase_triangle_order,
  // which is likewise called on all ranks).  edge_midpoints was built while
  // the mesh was serialized on every rank, so it is identical everywhere and
  // this post-broadcast fixup is deterministic.
  auto increase_order_and_restore_midpoints =
    [this, &edge_midpoints, &face_centroids]()
    {
      if (_elem_type == TET4)
        return;
 
      // find_neighbors() is needed before all_second_order() can place
      // shared edge midpoints correctly.
      this->_mesh.find_neighbors();
 
      // Refresh the cached element dimensions.  We just replaced the 2D
      // TRI3 surface elements with 3D TET4 volume elements, but the mesh's
      // cached dimension is still that of the original surface (2).
      // all_second_order()/all_complete_order() derive the per-element
      // unique_id reservation width from mesh_dimension(): a stale value of
      // 2 reserves only 9-4=5 slots per element, too few for the 6 new edge
      // nodes of a TET10, so adjacent elements' unique_id ranges overlap and
      // collide.  cache_elem_data() recomputes the dimension to 3 (reserving
      // 27-8=19 slots) before the order increase runs.
      this->_mesh.cache_elem_data();
 
      this->increase_tet_order();
 
      // Move auto-placed geometric midpoints to the recorded positions,
      // preserving any curvature from the original quadratic boundary.
      if (!edge_midpoints.empty() || !face_centroids.empty())
        for (Elem * elem : _mesh.element_ptr_range())
          for (auto s : elem->side_index_range())
            {
              if (elem->neighbor_ptr(s)) continue;
 
              // build_side_ptr() returns a TRI6 (TET10) or TRI7 (TET14)
              // whose node pointers reference the actual mesh nodes; point()
              // assignments update mesh node coordinates in place.
              auto side = elem->build_side_ptr(s);
              for (auto e : make_range(3u))
                {
                  const Point & pa = side->point(e);
                  const Point & pb = side->point((e+1)%3);
                  auto key = pa < pb
                    ? std::make_pair(pa,pb) : std::make_pair(pb,pa);
                  if (auto it = edge_midpoints.find(key);
                      it != edge_midpoints.end())
                    side->point(e+3) = it->second;
                }
 
              // TRI7 faces (TET14 output) also carry a face-centroid node
              // at local index 6; restore its recorded curved position.
              if (side->type() == TRI7)
                {
                  std::array<Point,3> corners =
                    {side->point(0), side->point(1), side->point(2)};
                  std::sort(corners.begin(), corners.end());
                  if (auto it = face_centroids.find(corners);
                      it != face_centroids.end())
                    side->point(6) = it->second;
                }
            }
    };
 
  // This should probably only be done on rank 0, but the API is
  // designed with the hope that we'll parallelize it eventually
  auto integrity = this->improve_hull_integrity();
  this->process_hull_integrity_result(integrity);
 
  // If we're not rank 0, we're just going to wait for rank 0 to call
  // Netgen, then receive its data afterward, we're not going to hope
  // that Netgen does the exact same thing on every processor.
  if (this->_mesh.processor_id() != 0)
    {
      // We don't need our holes anymore.  Delete their serializers
      // first to avoid dereferencing dangling pointers.
      hole_serializers.clear();
      if (_holes)
        _holes->clear();
 
      // Receive the TET4 mesh data rank 0 will send later.
      MeshCommunication().broadcast(this->_mesh);
 
      // If we got an empty mesh here then our tetrahedralization
      // failed.
      libmesh_error_msg_if (!this->_mesh.n_elem(),
                            "NetGen failed to generate any tetrahedra");
 
      // Increase the element order collectively, in lockstep with rank 0.
      increase_order_and_restore_midpoints();
 
      this->_mesh.prepare_for_use();
      return;
    }
 
  Ng_Meshing_Parameters params;
 
  Ng_SetNumThreads(cast_int<int>(libMesh::n_threads()));
 
  // Override any default parameters we might need to, to avoid
  // inserting nodes we don't want.
  params.uselocalh = false;
  params.minh = 0;
  params.elementsperedge = 1;
  params.elementspercurve = 1;
  params.closeedgeenable = false;
  params.closeedgefact = 0;
  params.minedgelenenable = false;
  params.minedgelen = 0;
 
  // Try to get a no-extra-nodes mesh if we're asked to, or try to
  // translate our desired volume into NetGen terms otherwise.
  //
  // Spoiler alert: all we can do is try; NetGen uses a marching front
  // algorithm that can insert extra nodes despite all my best
  // efforts.
  if (_desired_volume == 0) // shorthand for "no refinement"
    {
      params.maxh = std::numeric_limits<double>::max();
      params.fineness = 0; // "coarse" in the docs
      params.grading = 1;  // "aggressive local grading" to avoid smoothing??
 
      // Turning off optimization steps avoids another opportunity for
      // Netgen to try to add more nodes.
      params.optsteps_3d = 0;
    }
  else
    params.maxh = double(std::pow(_desired_volume, 1./3.));
 
  // Keep track of how NetGen copies of nodes map back to our original
  // nodes, so we can connect new elements to nodes correctly.
  std::unordered_map<int, dof_id_type> ng_to_libmesh_id;
 
  auto handle_ng_result = [](Ng_Result result) {
    static const std::vector<std::string> result_types =
      {"Netgen error", "Netgen success", "Netgen surface input error",
       "Netgen volume failure", "Netgen STL input error",
       "Netgen surface failure", "Netgen file not found"};
 
    if (result+1 >= 0 &&
        std::size_t(result+1) < result_types.size())
      libmesh_error_msg_if
        (result, "Ng_GenerateVolumeMesh failed: " <<
         result_types[result+1]);
    else
      libmesh_error_msg
        ("Ng_GenerateVolumeMesh failed with an unknown error code");
  };
 
  // Keep track of what boundary ids we want to assign to each new
  // triangle.  We'll give the outer boundary BC 0, and give holes ids
  // starting from 1.
  // We key on sorted tuples of node ids to identify a side.
  std::unordered_map<std::array<dof_id_type,3>,
                     boundary_id_type, libMesh::hash> side_boundary_id;
 
  auto insert_id = []
    (std::array<dof_id_type,3> & array,
     dof_id_type n_id)
  {
    libmesh_assert_less(n_id, DofObject::invalid_id);
    unsigned int i=0;
    while (array[i] < n_id)
      ++i;
    while (i < 3)
      std::swap(array[i++], n_id);
  };
 
  WrappedNgMesh ngmesh;
 
  // Create surface mesh in the WrappedNgMesh
  {
    // NetGen appears to use ONE-BASED numbering for its nodes, and
    // since it doesn't return an id when adding nodes we'll have to
    // track the numbering ourselves.
    int ng_id = 1;
 
    auto create_surface_component =
      [this, &ng_id, &ng_to_libmesh_id, &ngmesh, &side_boundary_id, &insert_id]
      (UnstructuredMesh & srcmesh, bool hole_mesh,
       boundary_id_type bcid)
    {
      LOG_SCOPE("create_surface_component()", "NetGenMeshInterface");
 
      // Keep track of what nodes we've already added to the Netgen
      // mesh vs what nodes we need to add.  We'll keep track by id,
      // not by point location.  I don't know if Netgen can handle
      // multiple nodes with the same point location, but if they can
      // it's not going to be *us* who breaks that feature.
      std::unordered_map<dof_id_type, int> libmesh_to_ng_id;
 
      // Keep track of what nodes we've already added to the main
      // mesh from a hole mesh.
      std::unordered_map<dof_id_type, dof_id_type> hole_to_main_mesh_id;
 
      // Use a separate array for passing points to NetGen, just in case
      // we're not using double-precision ourselves.
      std::array<double, 3> point_val;
 
      // And an array for element vertices
      std::array<int, 3> elem_nodes;
 
      for (const auto * elem : srcmesh.element_ptr_range())
        {
          // If someone has triangles we can't triangulate, we have a
          // problem
          if (elem->type() == TRI6 ||
              elem->type() == TRI7)
            libmesh_not_implemented_msg
              ("Netgen tetrahedralization currently only supports TRI3 boundaries");
 
          // If someone has non-triangles, let's just ignore them.
          if (elem->type() != TRI3)
            continue;
 
          std::array<dof_id_type,3> sorted_ids =
            {DofObject::invalid_id, DofObject::invalid_id,
             DofObject::invalid_id};
 
          for (int ni : make_range(3))
            {
              // Just using the "invert_trigs" option in NetGen params
              // doesn't work for me, so we'll have to have properly
              // oriented the tris earlier.
              auto & elem_node = hole_mesh ? elem_nodes[2-ni] : elem_nodes[ni];
 
              const Node & n = elem->node_ref(ni);
              auto n_id = n.id();
              if (hole_mesh)
                {
                  if (auto it = hole_to_main_mesh_id.find(n_id);
                      it != hole_to_main_mesh_id.end())
                    {
                      n_id = it->second;
                    }
                  else
                    {
                      Node * n_new = this->_mesh.add_point(n);
                      const dof_id_type n_new_id = n_new->id();
                      hole_to_main_mesh_id.emplace(n_id, n_new_id);
                      n_id = n_new_id;
                    }
                }
 
              if (auto it = libmesh_to_ng_id.find(n_id);
                  it != libmesh_to_ng_id.end())
                {
                  const int existing_ng_id = it->second;
                  elem_node = existing_ng_id;
                }
              else
                {
                  for (auto i : make_range(3))
                    point_val[i] = double(n(i));
 
                  Ng_AddPoint(ngmesh, point_val.data());
 
                  ng_to_libmesh_id[ng_id] = n_id;
                  libmesh_to_ng_id[n_id] = ng_id;
                  elem_node = ng_id;
                  ++ng_id;
                }
 
              insert_id(sorted_ids, n_id);
            }
 
          side_boundary_id[sorted_ids] = bcid;
 
          Ng_AddSurfaceElement(ngmesh, NG_TRIG, elem_nodes.data());
        }
    };
 
    // Number the outer boundary 0, and the holes starting from 1
    boundary_id_type bcid = 0;
 
    create_surface_component(this->_mesh, false, bcid);
 
    if (_holes)
      for (const std::unique_ptr<UnstructuredMesh> & h : *_holes)
        create_surface_component(*h, true, ++bcid);
  }
 
  {
    LOG_SCOPE("Ng_GenerateVolumeMesh()", "NetGenMeshInterface");
 
    auto result = Ng_GenerateVolumeMesh(ngmesh, &params);
    handle_ng_result(result);
  }
 
  const int n_elem = Ng_GetNE(ngmesh);
 
  // If Netgen fails us, we're likely to get n_elem <= 0.  This is a
  // common enough failure from bad setups that I want to make sure
  // it's thrown in parallel so as to not desynchronize any unit tests
  // that trigger it.  So we'll broadcast the empty mesh to indicate
  // the problem and enable throwing exceptions in parallel.
  if (n_elem <= 0)
    {
      this->_mesh.clear();
      MeshCommunication().broadcast(this->_mesh);
      libmesh_error_msg ("NetGen failed to generate any tetrahedra");
    }
 
  const dof_id_type n_points = Ng_GetNP(ngmesh);
  const dof_id_type old_nodes = this->_mesh.n_nodes();
 
  // Netgen may have generated new interior nodes
  if (n_points != old_nodes)
    {
      std::array<double, 3> point_val;
 
      // We should only be getting new nodes if we asked for them
      if (!_desired_volume)
        {
          std::cout <<
            "NetGen output " << n_points <<
            " points when we gave it " <<
            old_nodes << " and disabled refinement\n" <<
            "If new interior points are acceptable in your mesh, please set\n" <<
            "a non-zero desired_volume to indicate that.  If new interior\n" <<
            "points are not acceptable in your mesh, you may need a different\n" <<
            "(non-advancing-front?) mesh generator." << std::endl;
          libmesh_error();
        }
      else
        for (auto i : make_range(old_nodes, n_points))
          {
            // i+1 since ng uses ONE-BASED numbering
            Ng_GetPoint (ngmesh, i+1, point_val.data());
            const Point p(point_val[0], point_val[1], point_val[2]);
            Node * n_new = this->_mesh.add_point(p);
            const dof_id_type n_new_id = n_new->id();
            ng_to_libmesh_id[i+1] = n_new_id;
          }
    }
 
  for (auto * elem : this->_mesh.element_ptr_range())
    this->_mesh.delete_elem(elem);
 
  BoundaryInfo * bi = & this->_mesh.get_boundary_info();
 
  for (auto i : make_range(n_elem))
  {
    // Enough data to return even a Tet10 without a segfault if nglib
    // went nuts
    int ngnodes[11];
 
    // i+1 since we must be 1-based with these ids too...
    Ng_Volume_Element_Type ngtype =
      Ng_GetVolumeElement(ngmesh, i+1, ngnodes);
 
    // But really nglib shouldn't go nuts
    libmesh_assert(ngtype == NG_TET);
    libmesh_ignore(ngtype);
 
    auto elem = this->_mesh.add_elem(Elem::build_with_id(TET4, i));
    for (auto n : make_range(4))
      {
        const dof_id_type node_id =
          libmesh_map_find(ng_to_libmesh_id, ngnodes[n]);
        elem->set_node(n, this->_mesh.node_ptr(node_id));
      }
 
    // NetGen and we disagree about node numbering orientation
    elem->orient(bi);
 
    for (auto s : make_range(4))
      {
        std::array<dof_id_type,3> sorted_ids =
          {DofObject::invalid_id, DofObject::invalid_id,
           DofObject::invalid_id};
 
        std::vector<unsigned int> nos = elem->nodes_on_side(s);
        for (auto n : nos)
          insert_id(sorted_ids, elem->node_id(n));
 
        if (auto it = side_boundary_id.find(sorted_ids);
            it != side_boundary_id.end())
          bi->add_side(elem, s, it->second);
      }
  }
 
  // We don't need our holes anymore.  Delete their serializers
  // first to avoid dereferencing dangling pointers.
  hole_serializers.clear();
  if (_holes)
    _holes->clear();
 
  // Send NetGen's TET4 result to the other ranks, then increase the element
  // order collectively on all ranks together.  increase_tet_order() performs
  // collective communication, so it must not run on rank 0 alone -- doing so
  // would deadlock against the other ranks waiting in broadcast() above.
  MeshCommunication().broadcast(this->_mesh);
  increase_order_and_restore_midpoints();
  this->_mesh.prepare_for_use();
}

References libMesh::MeshTetInterface::_desired_volume, libMesh::MeshTetInterface::_elem_type, libMesh::MeshTetInterface::_holes, libMesh::MeshTetInterface::_mesh, libMesh::MeshBase::add_elem(), libMesh::MeshBase::add_point(), libMesh::BoundaryInfo::add_side(), libMesh::MeshCommunication::broadcast(), libMesh::Elem::build_with_id(), libMesh::MeshBase::cache_elem_data(), libMesh::MeshBase::clear(), libMesh::BoundingBox::contains(), libMesh::MeshBase::delete_elem(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::MeshBase::get_boundary_info(), libMesh::DofObject::id(), libMesh::MeshTetInterface::improve_hull_integrity(), libMesh::MeshTetInterface::increase_tet_order(), libMesh::DofObject::invalid_id, libMesh::libmesh_assert(), libMesh::libmesh_ignore(), libMesh::make_range(), libMesh::MeshBase::n_elem(), libMesh::MeshBase::n_nodes(), libMesh::n_threads(), libMesh::MeshBase::node_ptr(), libMesh::MeshBase::prepare_for_use(), libMesh::MeshTetInterface::process_hull_integrity_result(), libMesh::ParallelObject::processor_id(), libMesh::TET10, libMesh::TET14, libMesh::TET4, libMesh::TRI3, libMesh::TRI6, libMesh::TRI7, and libMesh::MeshTetInterface::volume_to_surface_mesh().

Referenced by main(), MeshTetTest::testNetGenQuadratic(), MeshTetTest::testNetGenQuadraticCurved(), MeshTetTest::testNetGenTet14(), and MeshTetTest::testNetGenTet14Curved().

volume_to_surface_mesh()

BoundingBox libMesh::MeshTetInterface::volume_to_surface_mesh ( UnstructuredMesh &  mesh )

staticprotectedinherited

Remove volume elements from the given mesh, after converting their outer boundary faces to surface elements.

Returns the bounding box of the mesh; this is useful for detecting misplaced holes later.

Definition at line 134 of file mesh_tet_interface.C.

{
  // If we've been handed an unprepared mesh then we need to be made
  // aware of that and fix that; we're relying on neighbor pointers.
  libmesh_assert(MeshTools::valid_is_prepared(mesh));
 
  if (!mesh.is_prepared())
    mesh.prepare_for_use();
 
  // We'll return a bounding box for use by subclasses in basic sanity checks.
  BoundingBox surface_bb;
 
  // First convert all volume boundaries to surface elements; this
  // gives us a manifold bounding the mesh, though it may not be a
  // connected manifold even if the volume mesh was connected.
  {
    // Make sure ids are in sync and valid on a DistributedMesh
    const dof_id_type max_orig_id = mesh.max_elem_id();
#ifdef LIBMESH_ENABLE_UNIQUE_ID
    const unique_id_type max_unique_id = mesh.parallel_max_unique_id();
#endif
 
    // Change this if we add arbitrary polyhedra...
    const dof_id_type max_sides = 6;
 
    std::unordered_set<Elem *> elems_to_delete;
 
    std::vector<std::unique_ptr<Elem>> elems_to_add;
 
    // Convert all faces to surface elements
    for (auto * elem : mesh.active_element_ptr_range())
      {
        libmesh_error_msg_if (elem->dim() < 2,
          "Cannot use meshes with 0D or 1D elements to define a volume");
 
        // If we've already got 2D elements then those are (part of)
        // our surface.
        if (elem->dim() == 2)
          continue;
 
        // 3D elements will be removed after we've extracted their
        // surface faces.
        elems_to_delete.insert(elem);
 
        for (auto s : make_range(elem->n_sides()))
          {
            // If there's a neighbor on this side then there's not a
            // boundary
            if (elem->neighbor_ptr(s))
              {
                // We're not supporting AMR meshes here yet
                if (elem->level() != elem->neighbor_ptr(s)->level())
                  libmesh_not_implemented_msg
                    ("Tetrahedralizaton of adapted meshes is not currently supported");
                continue;
              }
 
            elems_to_add.push_back(elem->build_side_ptr(s));
            Elem * side_elem = elems_to_add.back().get();
 
            // Wipe the interior_parent before it can become a
            // dangling pointer later
            side_elem->set_interior_parent(nullptr);
 
            // If the mesh is replicated then its automatic id
            // setting is fine.  If not, then we need unambiguous ids
            // independent of element traversal.
            if (!mesh.is_replicated())
              {
                side_elem->set_id(max_orig_id + max_sides*elem->id() + s);
#ifdef LIBMESH_ENABLE_UNIQUE_ID
                side_elem->set_unique_id(max_unique_id + max_sides*elem->id() + s);
#endif
              }
          }
      }
 
    // If the mesh is replicated then its automatic neighbor finding
    // is fine.  If not, then we need to insert them ourselves, but
    // it's easy because we can use the fact (from our implementation
    // above) that our new elements have no parents or children, plus
    // the fact (from the tiny fraction of homology I understand) that
    // a manifold boundary is a manifold with no boundary.
    //
    // See UnstructuredMesh::find_neighbors() for more explanation of
    // (a more complicated version of) the algorithm here.
    if (!mesh.is_replicated())
      {
        typedef dof_id_type                     key_type;
        typedef std::pair<Elem *, unsigned char> val_type;
        typedef std::unordered_multimap<key_type, val_type> map_type;
        map_type side_to_elem_map;
 
        std::unique_ptr<Elem> my_side, their_side;
 
        for (auto & elem : elems_to_add)
          {
            for (auto s : elem->side_index_range())
              {
                if (elem->neighbor_ptr(s))
                  continue;
                const dof_id_type key = elem->low_order_key(s);
                auto bounds = side_to_elem_map.equal_range(key);
                if (bounds.first != bounds.second)
                  {
                    elem->side_ptr(my_side, s);
                    while (bounds.first != bounds.second)
                      {
                        Elem * potential_neighbor = bounds.first->second.first;
                        const unsigned int ns = bounds.first->second.second;
                        potential_neighbor->side_ptr(their_side, ns);
                        if (*my_side == *their_side)
                          {
                            elem->set_neighbor(s, potential_neighbor);
                            potential_neighbor->set_neighbor(ns, elem.get());
                            side_to_elem_map.erase (bounds.first);
                            break;
                          }
                        ++bounds.first;
                      }
 
                    if (!elem->neighbor_ptr(s))
                      side_to_elem_map.emplace
                        (key, std::make_pair(elem.get(), cast_int<unsigned char>(s)));
                  }
              }
          }
 
        // At this point we *should* have a match for everything, so
        // anything we don't have a match for is remote.
        for (auto & elem : elems_to_add)
          for (auto s : elem->side_index_range())
            if (!elem->neighbor_ptr(s))
              elem->set_neighbor(s, const_cast<RemoteElem*>(remote_elem));
      }
 
    // Remove volume and edge elements
    for (Elem * elem : elems_to_delete)
      mesh.delete_elem(elem);
 
    // Add the new elements outside the loop so we don't risk
    // invalidating iterators.
    for (auto & elem : elems_to_add)
      mesh.add_elem(std::move(elem));
  }
 
  // Fix up neighbor pointers, element counts, etc.
  mesh.prepare_for_use();
 
  // We're making tets; we need to start with tris
  MeshTools::Modification::all_tri(mesh);
 
  // Partition surface into connected components.  At this point I'm
  // finally going to give up and serialize, because at least we got
  // from 3D down to 2D first, and because I don't want to have to
  // turn flood_component into a while loop with a parallel sync in
  // the middle, and because we do have to serialize *eventually*
  // anyways unless we get a parallel tetrahedralizer backend someday.
  MeshSerializer mesh_serializer(mesh);
 
  std::vector<std::unordered_set<Elem *>> components;
  std::unordered_set<Elem *> in_component;
 
  for (auto * elem : mesh.element_ptr_range())
    if (!in_component.count(elem))
      components.emplace_back(flood_component(in_component, elem));
 
  const std::unordered_set<Elem *> * biggest_component = nullptr;
  Real biggest_six_vol = 0;
  for (const auto & component : components)
    {
      Real six_vol = six_times_signed_volume(component);
      if (std::abs(six_vol) > std::abs(biggest_six_vol))
        {
          biggest_six_vol = six_vol;
          biggest_component = &component;
        }
    }
 
  if (!biggest_component)
    libmesh_error_msg("No non-zero-volume component found among " <<
                      components.size() << " boundary components");
 
  for (const auto & component : components)
    if (&component != biggest_component)
      {
        for (Elem * elem: component)
          mesh.delete_elem(elem);
      }
    else
      {
        for (Elem * elem: component)
          {
            if (biggest_six_vol < 0)
              elem->flip(&mesh.get_boundary_info());
 
            for (auto & node : elem->node_ref_range())
              surface_bb.union_with(node);
          }
      }
 
  mesh.prepare_for_use();
 
  return surface_bb;
}

References libMesh::MeshBase::add_elem(), libMesh::MeshTools::Modification::all_tri(), libMesh::Elem::build_side_ptr(), libMesh::MeshBase::delete_elem(), libMesh::Elem::dim(), libMesh::Elem::flip(), libMesh::MeshBase::get_boundary_info(), libMesh::DofObject::id(), libMesh::MeshBase::is_prepared(), libMesh::MeshBase::is_replicated(), libMesh::Elem::level(), libMesh::libmesh_assert(), libMesh::Elem::low_order_key(), libMesh::make_range(), libMesh::MeshBase::max_elem_id(), mesh, libMesh::Elem::n_sides(), libMesh::Elem::neighbor_ptr(), libMesh::Elem::node_ref_range(), libMesh::MeshBase::parallel_max_unique_id(), libMesh::MeshBase::prepare_for_use(), libMesh::Real, libMesh::remote_elem, libMesh::DofObject::set_id(), libMesh::Elem::set_interior_parent(), libMesh::Elem::set_neighbor(), libMesh::DofObject::set_unique_id(), libMesh::Elem::side_index_range(), libMesh::Elem::side_ptr(), libMesh::BoundingBox::union_with(), and libMesh::MeshTools::valid_is_prepared().

Referenced by triangulate().

Member Data Documentation

_desired_volume

Real libMesh::MeshTetInterface::_desired_volume

protectedinherited

The desired volume for the elements in the resulting mesh.

Unlimited (indicated by 0) by default

Definition at line 184 of file mesh_tet_interface.h.

Referenced by libMesh::MeshTetInterface::desired_volume(), triangulate(), and libMesh::TetGenMeshInterface::triangulate_pointset().

_elem_type

ElemType libMesh::MeshTetInterface::_elem_type

protectedinherited

The exact type of tetrahedra we intend to construct.

Definition at line 195 of file mesh_tet_interface.h.

Referenced by libMesh::MeshTetInterface::elem_type(), libMesh::MeshTetInterface::increase_tet_order(), and triangulate().

_holes

std::unique_ptr<std::vector<std::unique_ptr<UnstructuredMesh> > > libMesh::MeshTetInterface::_holes

protectedinherited

A pointer to a vector of meshes each defining a hole.

If this is nullptr, there are no holes!

Definition at line 206 of file mesh_tet_interface.h.

Referenced by libMesh::MeshTetInterface::attach_hole_list(), and triangulate().

_mesh

UnstructuredMesh& libMesh::MeshTetInterface::_mesh

protectedinherited

Local reference to the mesh we are working with.

Definition at line 200 of file mesh_tet_interface.h.

Referenced by libMesh::TetGenMeshInterface::assign_nodes_to_elem(), libMesh::MeshTetInterface::check_hull_integrity(), libMesh::MeshTetInterface::delete_2D_hull_elements(), libMesh::TetGenMeshInterface::fill_pointlist(), libMesh::MeshTetInterface::improve_hull_integrity(), libMesh::MeshTetInterface::increase_tet_order(), libMesh::TetGenMeshInterface::pointset_convexhull(), triangulate(), libMesh::TetGenMeshInterface::triangulate_conformingDelaunayMesh_carvehole(), and libMesh::TetGenMeshInterface::triangulate_pointset().

_serializer

MeshSerializer libMesh::NetGenMeshInterface::_serializer

protected

Tetgen only operates on serial meshes.

Definition at line 78 of file mesh_netgen_interface.h.

_smooth_after_generating

bool libMesh::MeshTetInterface::_smooth_after_generating

protectedinherited

Flag which tells whether we should smooth the mesh after it is generated.

False by default.

Definition at line 190 of file mesh_tet_interface.h.

Referenced by libMesh::TetGenMeshInterface::pointset_convexhull(), libMesh::MeshTetInterface::smooth_after_generating(), libMesh::TetGenMeshInterface::triangulate_conformingDelaunayMesh_carvehole(), and libMesh::TetGenMeshInterface::triangulate_pointset().

_verbosity

unsigned int libMesh::MeshTetInterface::_verbosity

protectedinherited

verbosity setting

Definition at line 110 of file mesh_tet_interface.h.

Referenced by libMesh::MeshTetInterface::check_hull_integrity(), and libMesh::MeshTetInterface::set_verbosity().

---

The documentation for this class was generated from the following files:

• include/mesh/mesh_netgen_interface.h
• src/mesh/mesh_netgen_interface.C