libMesh::ElemCutter Class Reference

This class implements cutting a single element into a collection of subelements. More...

#include <elem_cutter.h>

Public Member Functions
	ElemCutter ()
	Constructor.
	~ElemCutter ()
	Destructor.
bool	is_inside (const Elem &elem, const std::vector< Real > &vertex_distance_func) const
bool	is_outside (const Elem &elem, const std::vector< Real > &vertex_distance_func) const
bool	is_cut (const Elem &elem, const std::vector< Real > &vertex_distance_func) const
void	operator() (const Elem &elem_in, const std::vector< Real > &vertex_distance_func)
	This function implements cutting an element by a signed distance function.
const std::vector< Elem const * > &	inside_elements () const
const std::vector< Elem const * > &	outside_elements () const

Protected Member Functions
void	find_intersection_points (const Elem &elem, const std::vector< Real > &vertex_distance_func)
	Finds the points where the cutting surface intersects the element edges.
void	cut_1D (const Elem &elem, const std::vector< Real > &vertex_distance_func)
	cutting algorithm in 1D.
void	cut_2D (const Elem &elem, const std::vector< Real > &vertex_distance_func)
	cutting algorithm in 2D.
void	cut_3D (const Elem &elem, const std::vector< Real > &vertex_distance_func)
	cutting algorithm in 3D.

Protected Attributes
std::vector< Elem const * >	_inside_elem
std::vector< Elem const * >	_outside_elem
Parallel::Communicator	_comm_self
std::unique_ptr< ReplicatedMesh >	_inside_mesh_2D
std::unique_ptr< TriangleInterface >	_triangle_inside
std::unique_ptr< ReplicatedMesh >	_outside_mesh_2D
std::unique_ptr< TriangleInterface >	_triangle_outside
std::unique_ptr< ReplicatedMesh >	_inside_mesh_3D
std::unique_ptr< TetGenMeshInterface >	_tetgen_inside
std::unique_ptr< ReplicatedMesh >	_outside_mesh_3D
std::unique_ptr< TetGenMeshInterface >	_tetgen_outside
std::vector< Point >	_intersection_pts

Detailed Description

This class implements cutting a single element into a collection of subelements.

This class depends on libmesh's Triangle and Tetgen interfaces, the former of which is only defined if libmesh is configured with –disable-strict-lgpl.

Author

Benjamin S. Kirk

Date

2013

Subdivides a single element using a mesh generator.

Definition at line 61 of file elem_cutter.h.

Constructor & Destructor Documentation

ElemCutter()

libMesh::ElemCutter::ElemCutter

(

)

Constructor.

Initializes pointer data without requiring a full ReplicatedMesh in this header file.

Definition at line 40 of file elem_cutter.C.

                       :
  _inside_mesh_2D(std::make_unique<ReplicatedMesh>(_comm_self,2)),
  _triangle_inside(std::make_unique<TriangleInterface>(*_inside_mesh_2D)),
  _outside_mesh_2D(std::make_unique<ReplicatedMesh>(_comm_self,2)),
  _triangle_outside(std::make_unique<TriangleInterface>(*_outside_mesh_2D)),
  _inside_mesh_3D(std::make_unique<ReplicatedMesh>(_comm_self,3)),
  _tetgen_inside(std::make_unique<TetGenMeshInterface>(*_inside_mesh_3D)),
  _outside_mesh_3D(std::make_unique<ReplicatedMesh>(_comm_self,3)),
  _tetgen_outside(std::make_unique<TetGenMeshInterface>(*_outside_mesh_3D))
{
  cut_cntr = 0;
}

~ElemCutter()

libMesh::ElemCutter::~ElemCutter ( )

default

Destructor.

Member Function Documentation

cut_1D()

void libMesh::ElemCutter::cut_1D ( const Elem &  elem, const std::vector< Real > &  vertex_distance_func  )

protected

cutting algorithm in 1D.

Definition at line 212 of file elem_cutter.C.

{
  libmesh_not_implemented();
}

Referenced by operator()().

cut_2D()

void libMesh::ElemCutter::cut_2D ( const Elem &  elem, const std::vector< Real > &  vertex_distance_func  )

protected

cutting algorithm in 2D.

Definition at line 220 of file elem_cutter.C.

{
#ifndef LIBMESH_HAVE_TRIANGLE
 
  // current implementation requires triangle!
  libMesh::err << "ERROR: current libMesh ElemCutter 2D implementation requires\n"
               << "       the \"triangle\" library!\n"
               << std::endl;
  libmesh_not_implemented();
 
#else // OK, LIBMESH_HAVE_TRIANGLE
 
  // std::cout << "Inside cut face element!\n";
 
  libmesh_assert (_inside_mesh_2D.get()  != nullptr);
  libmesh_assert (_outside_mesh_2D.get() != nullptr);
 
  _inside_mesh_2D->clear();
  _outside_mesh_2D->clear();
 
  for (auto v : make_range(elem.n_vertices()))
    {
      if (vertex_distance_func[v] >= 0.)
        _outside_mesh_2D->add_point (elem.point(v));
 
      if (vertex_distance_func[v] <= 0.)
        _inside_mesh_2D->add_point (elem.point(v));
    }
 
  for (const auto & pt : _intersection_pts)
    {
      _inside_mesh_2D->add_point(pt);
      _outside_mesh_2D->add_point(pt);
    }
 
 
  // Customize the variables for the triangulation
  // we will be cutting reference cell, and want as few triangles
  // as possible, so jack this up larger than the area we will be
  // triangulating so we are governed only by accurately defining
  // the boundaries.
  _triangle_inside->desired_area()  = 100.;
  _triangle_outside->desired_area() = 100.;
 
  // allow for small angles
  _triangle_inside->minimum_angle()  = 5.;
  _triangle_outside->minimum_angle() = 5.;
 
  // Turn off Laplacian mesh smoothing after generation.
  _triangle_inside->smooth_after_generating()  = false;
  _triangle_outside->smooth_after_generating() = false;
 
  // Triangulate!
  _triangle_inside->triangulate();
  _triangle_outside->triangulate();
 
  // std::ostringstream name;
 
  // name << "cut_face_"
  //  << cut_cntr++
  //  << ".dat";
  // _inside_mesh_2D->write  ("in_"  + name.str());
  // _outside_mesh_2D->write ("out_" + name.str());
 
  // finally, add the elements to our lists.
  _inside_elem.clear();
  _outside_elem.clear();
 
  for (const auto & el : _inside_mesh_2D->element_ptr_range())
    _inside_elem.push_back (el);
 
  for (const auto & el : _outside_mesh_2D->element_ptr_range())
    _outside_elem.push_back (el);
 
#endif
}

References _inside_elem, _inside_mesh_2D, _intersection_pts, _outside_elem, _outside_mesh_2D, _triangle_inside, _triangle_outside, libMesh::err, libMesh::libmesh_assert(), libMesh::make_range(), libMesh::Elem::n_vertices(), and libMesh::Elem::point().

Referenced by operator()().

cut_3D()

void libMesh::ElemCutter::cut_3D ( const Elem &  elem, const std::vector< Real > &  vertex_distance_func  )

protected

cutting algorithm in 3D.

Definition at line 300 of file elem_cutter.C.

{
#ifndef LIBMESH_HAVE_TETGEN
 
  // current implementation requires tetgen!
  libMesh::err << "ERROR: current libMesh ElemCutter 3D implementation requires\n"
               << "       the \"tetgen\" library!\n"
               << std::endl;
  libmesh_not_implemented();
 
#else // OK, LIBMESH_HAVE_TETGEN
 
  // std::cout << "Inside cut cell element!\n";
 
  libmesh_assert (_inside_mesh_3D.get()  != nullptr);
  libmesh_assert (_outside_mesh_3D.get() != nullptr);
 
  _inside_mesh_3D->clear();
  _outside_mesh_3D->clear();
 
  for (auto v : make_range(elem.n_vertices()))
    {
      if (vertex_distance_func[v] >= 0.)
        _outside_mesh_3D->add_point (elem.point(v));
 
      if (vertex_distance_func[v] <= 0.)
        _inside_mesh_3D->add_point (elem.point(v));
    }
 
  for (const auto & pt : _intersection_pts)
    {
      _inside_mesh_3D->add_point(pt);
      _outside_mesh_3D->add_point(pt);
    }
 
 
  // Triangulate!
  _tetgen_inside->triangulate_pointset();
  //_inside_mesh_3D->print_info();
  _tetgen_outside->triangulate_pointset();
  //_outside_mesh_3D->print_info();
 
 
  // (below generates some horribly expensive meshes,
  //  but seems immune to the 0 volume problem).
  // _tetgen_inside->pointset_convexhull();
  // _inside_mesh_3D->find_neighbors();
  // _inside_mesh_3D->print_info();
  // _tetgen_inside->triangulate_conformingDelaunayMesh (1.e3, 100.);
  // _inside_mesh_3D->print_info();
 
  // _tetgen_outside->pointset_convexhull();
  // _outside_mesh_3D->find_neighbors();
  // _outside_mesh_3D->print_info();
  // _tetgen_outside->triangulate_conformingDelaunayMesh (1.e3, 100.);
  // _outside_mesh_3D->print_info();
 
  std::ostringstream name;
 
  name << "cut_cell_"
       << cut_cntr++
       << ".dat";
  _inside_mesh_3D->write  ("in_"  + name.str());
  _outside_mesh_3D->write ("out_" + name.str());
 
  // finally, add the elements to our lists.
  _inside_elem.clear();
  _outside_elem.clear();
 
  for (const auto & el : _inside_mesh_3D->element_ptr_range())
    if (el->volume() > std::numeric_limits<Real>::epsilon())
      _inside_elem.push_back (el);
 
  for (const auto & el : _outside_mesh_3D->element_ptr_range())
    if (el->volume() > std::numeric_limits<Real>::epsilon())
      _outside_elem.push_back (el);
 
#endif
}

References _inside_elem, _inside_mesh_3D, _intersection_pts, _outside_elem, _outside_mesh_3D, _tetgen_inside, _tetgen_outside, libMesh::err, libMesh::libmesh_assert(), libMesh::make_range(), libMesh::Elem::n_vertices(), and libMesh::Elem::point().

Referenced by operator()().

find_intersection_points()

void libMesh::ElemCutter::find_intersection_points ( const Elem &  elem, const std::vector< Real > &  vertex_distance_func  )

protected

Finds the points where the cutting surface intersects the element edges.

Definition at line 155 of file elem_cutter.C.

{
  _intersection_pts.clear();
 
  for (auto e : elem.edge_index_range())
    {
      std::unique_ptr<const Elem> edge (elem.build_edge_ptr(e));
 
      // find the element nodes el0, el1 that map
      unsigned int
        el0 = elem.get_node_index(edge->node_ptr(0)),
        el1 = elem.get_node_index(edge->node_ptr(1));
 
      libmesh_assert (elem.is_vertex(el0));
      libmesh_assert (elem.is_vertex(el1));
      libmesh_assert_less (el0, vertex_distance_func.size());
      libmesh_assert_less (el1, vertex_distance_func.size());
 
      const Real
        d0 = vertex_distance_func[el0],
        d1 = vertex_distance_func[el1];
 
      // if this edge has a 0 crossing
      if (d0*d1 < 0.)
        {
          libmesh_assert_not_equal_to (d0, d1);
 
          // then find d_star in [0,1], the
          // distance from el0 to el1 where the 0 lives.
          const Real d_star = d0 / (d0 - d1);
 
 
          // Prevent adding nodes trivially close to existing
          // nodes.
          const Real endpoint_tol = 0.01;
 
          if ( (d_star > endpoint_tol) &&
               (d_star < (1.-endpoint_tol)) )
            {
              const Point x_star = (edge->point(0)*(1-d_star) +
                                    edge->point(1)*d_star);
 
              /*
              std::cout << "adding cut point (d_star, x_star) = "
                        << d_star << " , " << x_star << std::endl;
              */
 
              _intersection_pts.push_back (x_star);
            }
        }
    }
}

References _intersection_pts, libMesh::Elem::build_edge_ptr(), libMesh::Elem::edge_index_range(), libMesh::Elem::get_node_index(), libMesh::Elem::is_vertex(), libMesh::libmesh_assert(), and libMesh::Real.

Referenced by operator()().

inside_elements()

const std::vector< Elem const * > & libMesh::ElemCutter::inside_elements ( ) const

inline

Returns

A list of general element pieces considered inside the cutting surface. These are subelements whose geometric union defines the spatial domain of the inside portion of the cut element.

Definition at line 117 of file elem_cutter.h.

  { return _inside_elem; }

References _inside_elem.

is_cut()

bool libMesh::ElemCutter::is_cut	(	const Elem &	elem,
		const std::vector< Real > &	vertex_distance_func
	)		const

Returns

true if the element is cut by the interface defined implicitly by the vertex values of the signed vertex_distance_func.

Definition at line 89 of file elem_cutter.C.

{
  libmesh_assert_equal_to (elem.n_vertices(), vertex_distance_func.size());
 
  Real
    vmin = vertex_distance_func.front(),
    vmax = vmin;
 
  for (const auto & val : vertex_distance_func)
    {
      vmin = std::min (vmin, val);
      vmax = std::max (vmax, val);
    }
 
  // if the distance function changes sign, we're cut.
  return (vmin*vmax < 0.);
}

References libMesh::Real.

Referenced by operator()().

is_inside()

bool libMesh::ElemCutter::is_inside	(	const Elem &	elem,
		const std::vector< Real > &	vertex_distance_func
	)		const

Returns

true if the element is completely inside the interface defined implicitly by the vertex values of the signed vertex_distance_func.

Definition at line 59 of file elem_cutter.C.

{
  libmesh_assert_equal_to (elem.n_vertices(), vertex_distance_func.size());
 
  for (const auto & val : vertex_distance_func)
    if (val > 0.)
      return false;
 
  // if the distance function is nonpositive, we are outside
  return true;
}

Referenced by operator()().

is_outside()

bool libMesh::ElemCutter::is_outside	(	const Elem &	elem,
		const std::vector< Real > &	vertex_distance_func
	)		const

Returns

true if the element is completely outside the interface defined implicitly by the vertex values of the signed vertex_distance_func.

Definition at line 74 of file elem_cutter.C.

{
  libmesh_assert_equal_to (elem.n_vertices(), vertex_distance_func.size());
 
  for (const auto & val : vertex_distance_func)
    if (val < 0.)
      return false;
 
  // if the distance function is nonnegative, we are outside
  return true;
}

Referenced by operator()().

operator()()

void libMesh::ElemCutter::operator()	(	const Elem &	elem_in,
		const std::vector< Real > &	vertex_distance_func
	)

This function implements cutting an element by a signed distance function.

The input array vertex_distance_func contains the vertex values of a signed distance function, from which the cutting interface is inferred from the 0 level set. If all vertex values are positive, the element is outside the cutting surface and is not cut. Likewise if all vertex values are negative, the element is inside the cutting surface and is not cut.

Definition at line 110 of file elem_cutter.C.

{
  libmesh_assert_equal_to (vertex_distance_func.size(), elem.n_vertices());
 
  _inside_elem.clear();
  _outside_elem.clear();
 
  // check for quick return?
  {
    // completely outside?
    if (this->is_outside(elem, vertex_distance_func))
      {
        //std::cout << "element completely outside\n";
        _outside_elem.push_back(& elem);
        return;
      }
 
    // completely inside?
    else if (this->is_inside(elem, vertex_distance_func))
      {
        //std::cout << "element completely inside\n";
        _inside_elem.push_back(&elem);
        return;
      }
 
    libmesh_assert (this->is_cut (elem, vertex_distance_func));
  }
 
  // we now know we are in a cut element, find the intersecting points.
  this->find_intersection_points (elem, vertex_distance_func);
 
  // and then dispatch the proper method
  switch (elem.dim())
    {
    case 1: this->cut_1D(elem, vertex_distance_func); break;
    case 2: this->cut_2D(elem, vertex_distance_func); break;
    case 3: this->cut_3D(elem, vertex_distance_func); break;
    default: libmesh_error_msg("Invalid element dimension: " << elem.dim());
    }
}

References _inside_elem, _outside_elem, cut_1D(), cut_2D(), cut_3D(), libMesh::Elem::dim(), find_intersection_points(), is_cut(), is_inside(), is_outside(), libMesh::libmesh_assert(), and libMesh::Elem::n_vertices().

outside_elements()

const std::vector< Elem const * > & libMesh::ElemCutter::outside_elements ( ) const

inline

Returns

A list of general element pieces considered outside the cutting surface. These are subelements whose geometric union defines the spatial domain of the outside portion of the cut element.

Definition at line 125 of file elem_cutter.h.

  { return _outside_elem; }

References _outside_elem.

Member Data Documentation

_comm_self

Parallel::Communicator libMesh::ElemCutter::_comm_self

protected

Definition at line 158 of file elem_cutter.h.

_inside_elem

std::vector<Elem const *> libMesh::ElemCutter::_inside_elem

protected

Definition at line 155 of file elem_cutter.h.

Referenced by cut_2D(), cut_3D(), inside_elements(), and operator()().

_inside_mesh_2D

std::unique_ptr<ReplicatedMesh> libMesh::ElemCutter::_inside_mesh_2D

protected

Definition at line 160 of file elem_cutter.h.

Referenced by cut_2D().

_inside_mesh_3D

std::unique_ptr<ReplicatedMesh> libMesh::ElemCutter::_inside_mesh_3D

protected

Definition at line 166 of file elem_cutter.h.

Referenced by cut_3D().

_intersection_pts

std::vector<Point> libMesh::ElemCutter::_intersection_pts

protected

Definition at line 172 of file elem_cutter.h.

Referenced by cut_2D(), cut_3D(), and find_intersection_points().

_outside_elem

std::vector<Elem const *> libMesh::ElemCutter::_outside_elem

protected

Definition at line 156 of file elem_cutter.h.

Referenced by cut_2D(), cut_3D(), operator()(), and outside_elements().

_outside_mesh_2D

std::unique_ptr<ReplicatedMesh> libMesh::ElemCutter::_outside_mesh_2D

protected

Definition at line 163 of file elem_cutter.h.

Referenced by cut_2D().

_outside_mesh_3D

std::unique_ptr<ReplicatedMesh> libMesh::ElemCutter::_outside_mesh_3D

protected

Definition at line 169 of file elem_cutter.h.

Referenced by cut_3D().

_tetgen_inside

std::unique_ptr<TetGenMeshInterface> libMesh::ElemCutter::_tetgen_inside

protected

Definition at line 167 of file elem_cutter.h.

Referenced by cut_3D().

_tetgen_outside

std::unique_ptr<TetGenMeshInterface> libMesh::ElemCutter::_tetgen_outside

protected

Definition at line 170 of file elem_cutter.h.

Referenced by cut_3D().

_triangle_inside

std::unique_ptr<TriangleInterface> libMesh::ElemCutter::_triangle_inside

protected

Definition at line 161 of file elem_cutter.h.

Referenced by cut_2D().

_triangle_outside

std::unique_ptr<TriangleInterface> libMesh::ElemCutter::_triangle_outside

protected

Definition at line 164 of file elem_cutter.h.

Referenced by cut_2D().

---

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

• include/geom/elem_cutter.h
• src/geom/elem_cutter.C