MeshCut3DUserObject Class Reference

MeshCut3DUserObject: (1) reads in a mesh describing the crack surface, (2) uses the mesh to do initial cutting of 3D elements, and (3) grows the mesh based on prescribed growth functions. More...

#include <MeshCut3DUserObject.h>

Inheritance diagram for MeshCut3DUserObject:

Public Member Functions
	MeshCut3DUserObject (const InputParameters &parameters)
virtual void	initialSetup () override
virtual void	initialize () override
virtual const std::vector< Point >	getCrackFrontPoints (unsigned int num_crack_front_points) const override
	get a set of points along a crack front from a XFEM GeometricCutUserObject More...
virtual bool	cutElementByGeometry (const Elem *elem, std::vector< Xfem::CutEdge > &cut_edges, std::vector< Xfem::CutNode > &cut_nodes, Real time) const override
	Check to see whether a specified 2D element should be cut based on geometric conditions. More...
virtual bool	cutElementByGeometry (const Elem *elem, std::vector< Xfem::CutFace > &cut_faces, Real time) const override
	Check to see whether a specified 3D element should be cut based on geometric conditions. More...
virtual bool	cutFragmentByGeometry (std::vector< std::vector< Point >> &frag_edges, std::vector< Xfem::CutEdge > &cut_edges, Real time) const override
	Check to see whether a fragment of a 2D element should be cut based on geometric conditions. More...
virtual bool	cutFragmentByGeometry (std::vector< std::vector< Point >> &frag_faces, std::vector< Xfem::CutFace > &cut_faces, Real time) const override
	Check to see whether a fragment of a 3D element should be cut based on geometric conditions. More...
virtual void	execute () override
virtual void	threadJoin (const UserObject &y) override
virtual void	finalize () override
unsigned int	getInterfaceID () const
	Get the interface ID for this cutting object. More...
void	setInterfaceID (unsigned int interface_id)
	Set the interface ID for this cutting object. More...
bool	shouldHealMesh () const
	Should the elements cut by this cutting object be healed in the current time step? More...

Static Public Member Functions
static InputParameters	validParams ()

Protected Member Functions
virtual bool	intersectWithEdge (const Point &p1, const Point &p2, const std::vector< Point > &_vertices, Point &pint) const
	Check if a line intersects with an element. More...
bool	findIntersection (const Point &p1, const Point &p2, const std::vector< Point > &vertices, Point &pint) const
	Find directional intersection along the positive extension of the vector from p1 to p2. More...
bool	isInsideEdge (const Point &p1, const Point &p2, const Point &p) const
	Check if point p is inside the edge p1-p2. More...
Real	getRelativePosition (const Point &p1, const Point &p2, const Point &p) const
	Get the relative position of p from p1. More...
bool	isInsideCutPlane (const std::vector< Point > &_vertices, const Point &p) const
	Check if point p is inside a plane. More...
void	findBoundaryNodes ()
	Find boundary nodes of the cutter mesh This is a simple algorithm simply based on the added angle = 360 degrees Works fine for planar cutting surface for curved cutting surface, need to re-work this subroutine to make it more general. More...
void	findBoundaryEdges ()
	Find boundary edges of the cutter mesh. More...
void	sortBoundaryNodes ()
	Sort boundary nodes to be in the right order along the boundary. More...
Real	findDistance (dof_id_type node1, dof_id_type node2)
	Find distance between two nodes. More...
void	refineBoundary ()
	If boundary nodes are too sparse, add nodes in between. More...
void	findActiveBoundaryNodes ()
	Find all active boundary nodes in the cutter mesh Find boundary nodes that will grow; nodes outside of the structural mesh are inactive. More...
void	findActiveBoundaryDirection ()
	Find growth direction at each active node. More...
void	growFront ()
	Grow the cutter mesh. More...
void	sortFrontNodes ()
	Sort the front nodes. More...
void	findFrontIntersection ()
	Find front-structure intersections. More...
void	refineFront ()
	Refine the mesh at the front. More...
void	triangulation ()
	Create tri3 elements between the new front and the old front. More...
void	joinBoundary ()
	Join active boundaries and inactive boundaries to be the new boundary. More...
void	serialize (std::string &serialized_buffer)
	Methods to pack/unpack the _marked_elems_2d and _marked_elems_3d data into a structure suitable for parallel communication. More...
void	deserialize (std::vector< std::string > &serialized_buffers)

Protected Attributes
std::unique_ptr< MeshBase >	_cut_mesh
	The cutter mesh. More...
const unsigned int	_cut_elem_nnode = 3
	The cutter mesh has triangluar elements only. More...
const unsigned int	_cut_elem_dim = 2
MooseMesh &	_mesh
	The structural mesh. More...
const unsigned int	_elem_dim = 3
	The structural mesh must be 3D only. More...
const Real	_const_intersection = 0.01
	Used to define intersection points. More...
Real	_size_control
	Used for cutter mesh refinement and front advancement. More...
unsigned int	_n_step_growth
	Number of steps to grow the mesh. More...
bool	_stop
	variables to help control the work flow More...
bool	_grow
std::vector< dof_id_type >	_boundary
	Boundary nodes of the cutter mesh. More...
std::set< Xfem::CutEdge >	_boundary_edges
	Edges at the boundary. More...
std::map< dof_id_type, std::vector< dof_id_type > >	_boundary_map
	A map of boundary nodes and their neighbors. More...
std::vector< std::vector< dof_id_type > >	_active_boundary
	Active boundary nodes where growth is allowed. More...
std::vector< std::vector< Point > >	_active_direction
	Growth direction for active boundaries. More...
std::vector< unsigned int >	_inactive_boundary_pos
	Inactive boundary. More...
std::vector< std::vector< dof_id_type > >	_front
	New boundary after growth. More...
const Function &	_func_x
	Parsed functions of front growth. More...
const Function &	_func_y
const Function &	_func_z
std::shared_ptr< XFEM >	_xfem
	Pointer to the XFEM controller object. More...
unsigned int	_interface_id
	Associated interface id. More...
bool	_heal_always
	Heal the mesh. More...
unsigned int	_last_step_initialized
	Time step information needed to advance a 3D crack only at the real beginning of a time step. More...
std::map< unsigned int, std::vector< Xfem::GeomMarkedElemInfo2D > >	_marked_elems_2d
	Containers with information about all 2D and 3D elements marked for cutting by this object. More...
std::map< unsigned int, std::vector< Xfem::GeomMarkedElemInfo3D > >	_marked_elems_3d

Detailed Description

MeshCut3DUserObject: (1) reads in a mesh describing the crack surface, (2) uses the mesh to do initial cutting of 3D elements, and (3) grows the mesh based on prescribed growth functions.

Definition at line 28 of file MeshCut3DUserObject.h.

Constructor & Destructor Documentation

MeshCut3DUserObject()

MeshCut3DUserObject::MeshCut3DUserObject

(

const InputParameters &

parameters

)

Definition at line 44 of file MeshCut3DUserObject.C.

  : GeometricCutUserObject(parameters),
    _mesh(_subproblem.mesh()),
    _n_step_growth(getParam<unsigned int>("n_step_growth")),
    _func_x(getFunction("function_x")),
    _func_y(getFunction("function_y")),
    _func_z(getFunction("function_z"))
{
  _grow = (_n_step_growth == 0 ? 0 : 1);
 
  if (_grow)
  {
    if (!isParamValid("size_control"))
      mooseError("Crack growth needs size control");
 
    _size_control = getParam<Real>("size_control");
  }
 
  // only the xda type is currently supported
  MeshFileName xfem_cut_mesh_file = getParam<MeshFileName>("mesh_file");
  _cut_mesh = libmesh_make_unique<ReplicatedMesh>(_communicator);
  _cut_mesh->read(xfem_cut_mesh_file);
 
  // test element type; only tri3 elements are allowed
  for (const auto & cut_elem : _cut_mesh->element_ptr_range())
  {
    if (cut_elem->n_nodes() != _cut_elem_nnode)
      mooseError("The input cut mesh should include tri elements only!");
    if (cut_elem->dim() != _cut_elem_dim)
      mooseError("The input cut mesh should have 2D elements only!");
  }
}

Member Function Documentation

cutElementByGeometry() [1/2]

bool MeshCut3DUserObject::cutElementByGeometry ( const Elem *  elem, std::vector< Xfem::CutEdge > &  cut_edges, std::vector< Xfem::CutNode > &  cut_nodes, Real  time  ) const

overridevirtual

Check to see whether a specified 2D element should be cut based on geometric conditions.

Parameters

elem	Pointer to the libMesh element to be considered for cutting
cut_edges	Data structure filled with information about edges to be cut
cut_nodes	Data structure filled with information about nodes to be cut
time	Current simulation time

Returns

bool true if element is to be cut

Implements GeometricCutUserObject.

Definition at line 124 of file MeshCut3DUserObject.C.

{
  mooseError("invalid method for 3D mesh cutting");
  return false;
}

cutElementByGeometry() [2/2]

bool MeshCut3DUserObject::cutElementByGeometry ( const Elem *  elem, std::vector< Xfem::CutFace > &  cut_faces, Real  time  ) const

overridevirtual

Check to see whether a specified 3D element should be cut based on geometric conditions.

Parameters

elem	Pointer to the libMesh element to be considered for cutting
cut_faces	Data structure filled with information about edges to be cut
time	Current simulation time

Returns

bool true if element is to be cut

Implements GeometricCutUserObject.

Definition at line 134 of file MeshCut3DUserObject.C.

{
  bool elem_cut = false;
 
  if (elem->dim() != _elem_dim)
    mooseError("The structural mesh to be cut by a surface mesh must be 3D!");
 
  for (unsigned int i = 0; i < elem->n_sides(); ++i)
  {
    // This returns the lowest-order type of side.
    std::unique_ptr<const Elem> curr_side = elem->side_ptr(i);
    if (curr_side->dim() != 2)
      mooseError("In cutElementByGeometry dimension of side must be 2, but it is ",
                 curr_side->dim());
    unsigned int n_edges = curr_side->n_sides();
 
    std::vector<unsigned int> cut_edges;
    std::vector<Real> cut_pos;
 
    for (unsigned int j = 0; j < n_edges; j++)
    {
      // This returns the lowest-order type of side.
      std::unique_ptr<const Elem> curr_edge = curr_side->side_ptr(j);
      if (curr_edge->type() != EDGE2)
        mooseError("In cutElementByGeometry face edge must be EDGE2, but type is: ",
                   libMesh::Utility::enum_to_string(curr_edge->type()),
                   " base element type is: ",
                   libMesh::Utility::enum_to_string(elem->type()));
      const Node * node1 = curr_edge->node_ptr(0);
      const Node * node2 = curr_edge->node_ptr(1);
 
      for (const auto & cut_elem : _cut_mesh->element_ptr_range())
      {
        std::vector<Point> vertices;
 
        for (auto & node : cut_elem->node_ref_range())
        {
          Point & this_point = node;
          vertices.push_back(this_point);
        }
 
        Point intersection;
        if (intersectWithEdge(*node1, *node2, vertices, intersection))
        {
          cut_edges.push_back(j);
          cut_pos.emplace_back(getRelativePosition(*node1, *node2, intersection));
        }
      }
    }
 
    // if two edges of an element are cut, it is considered as an element being cut
    if (cut_edges.size() == 2)
    {
      elem_cut = true;
      Xfem::CutFace mycut;
      mycut._face_id = i;
      mycut._face_edge.push_back(cut_edges[0]);
      mycut._face_edge.push_back(cut_edges[1]);
      mycut._position.push_back(cut_pos[0]);
      mycut._position.push_back(cut_pos[1]);
      cut_faces.push_back(mycut);
    }
  }
  return elem_cut;
}

cutFragmentByGeometry() [1/2]

bool MeshCut3DUserObject::cutFragmentByGeometry ( std::vector< std::vector< Point >> &  frag_edges, std::vector< Xfem::CutEdge > &  cut_edges, Real  time  ) const

overridevirtual

Check to see whether a fragment of a 2D element should be cut based on geometric conditions.

Parameters

frag_edges	Data structure defining the current fragment to be considered
cut_edges	Data structure filled with information about fragment edges to be cut
time	Current simulation time

Returns

bool true if fragment is to be cut

Implements GeometricCutUserObject.

Definition at line 206 of file MeshCut3DUserObject.C.

{
  mooseError("invalid method for 3D mesh cutting");
  return false;
}

cutFragmentByGeometry() [2/2]

bool MeshCut3DUserObject::cutFragmentByGeometry ( std::vector< std::vector< Point >> &  frag_faces, std::vector< Xfem::CutFace > &  cut_faces, Real  time  ) const

overridevirtual

Check to see whether a fragment of a 3D element should be cut based on geometric conditions.

Parameters

frag_faces	Data structure defining the current fragment to be considered
cut_faces	Data structure filled with information about fragment faces to be cut
time	Current simulation time

Returns

bool true if fragment is to be cut

Implements GeometricCutUserObject.

Definition at line 215 of file MeshCut3DUserObject.C.

{
  // TODO: Need this for branching in 3D
  mooseError("cutFragmentByGeometry not yet implemented for 3D mesh cutting");
  return false;
}

deserialize()

void GeometricCutUserObject::deserialize ( std::vector< std::string > &  serialized_buffers )

protectedinherited

Definition at line 222 of file GeometricCutUserObject.C.

{
  mooseAssert(serialized_buffers.size() == _app.n_processors(),
              "Unexpected size of serialized_buffers: " << serialized_buffers.size());
 
  // The input string stream used for deserialization
  std::istringstream iss;
 
  // Loop over all datastructures for all processors to perfrom the gather operation
  for (unsigned int rank = 0; rank < serialized_buffers.size(); ++rank)
  {
    // skip the current processor (its data is already in the structures)
    if (rank == processor_id())
      continue;
 
    // populate the stream with a new buffer and reset stream state
    iss.clear();
    iss.str(serialized_buffers[rank]);
 
    // Load the communicated data into temporary structures
    std::map<unsigned int, std::vector<Xfem::GeomMarkedElemInfo2D>> other_marked_elems_2d;
    std::map<unsigned int, std::vector<Xfem::GeomMarkedElemInfo3D>> other_marked_elems_3d;
    dataLoad(iss, other_marked_elems_2d, this);
    dataLoad(iss, other_marked_elems_3d, this);
 
    // merge the data in with the current processor's data
    _marked_elems_2d.insert(other_marked_elems_2d.begin(), other_marked_elems_2d.end());
    _marked_elems_3d.insert(other_marked_elems_3d.begin(), other_marked_elems_3d.end());
  }
}

Referenced by GeometricCutUserObject::finalize().

execute()

void GeometricCutUserObject::execute ( )

overridevirtualinherited

Reimplemented in MovingLineSegmentCutSetUserObject.

Definition at line 67 of file GeometricCutUserObject.C.

{
  if (_current_elem->dim() == 2)
  {
    std::vector<Xfem::CutEdge> elem_cut_edges;
    std::vector<Xfem::CutNode> elem_cut_nodes;
    std::vector<Xfem::CutEdge> frag_cut_edges;
    std::vector<std::vector<Point>> frag_edges;
 
    EFAElement2D * EFAElem = _xfem->getEFAElem2D(_current_elem);
 
    // Don't cut again if elem has been already cut twice
    if (!EFAElem->isFinalCut())
    {
      // get fragment edges
      _xfem->getFragmentEdges(_current_elem, EFAElem, frag_edges);
 
      // mark cut edges for the element and its fragment
      bool cut = cutElementByGeometry(_current_elem, elem_cut_edges, elem_cut_nodes, _t);
      if (EFAElem->numFragments() > 0)
        cut |= cutFragmentByGeometry(frag_edges, frag_cut_edges, _t);
 
      if (cut)
      {
        Xfem::GeomMarkedElemInfo2D gmei2d;
        gmei2d._elem_cut_edges = elem_cut_edges;
        gmei2d._elem_cut_nodes = elem_cut_nodes;
        gmei2d._frag_cut_edges = frag_cut_edges;
        gmei2d._frag_edges = frag_edges;
        _marked_elems_2d[_current_elem->id()].push_back(gmei2d);
      }
    }
  }
  else if (_current_elem->dim() == 3)
  {
    std::vector<Xfem::CutFace> elem_cut_faces;
    std::vector<Xfem::CutFace> frag_cut_faces;
    std::vector<std::vector<Point>> frag_faces;
 
    EFAElement3D * EFAElem = _xfem->getEFAElem3D(_current_elem);
 
    // Don't cut again if elem has been already cut twice
    if (!EFAElem->isFinalCut())
    {
      // get fragment edges
      _xfem->getFragmentFaces(_current_elem, EFAElem, frag_faces);
 
      // mark cut faces for the element and its fragment
      bool cut = cutElementByGeometry(_current_elem, elem_cut_faces, _t);
      // TODO: This would be done for branching, which is not yet supported in 3D
      // if (EFAElem->numFragments() > 0)
      //  cut |= cutFragmentByGeometry(frag_faces, frag_cut_faces, _t);
 
      if (cut)
      {
        Xfem::GeomMarkedElemInfo3D gmei3d;
        gmei3d._elem_cut_faces = elem_cut_faces;
        gmei3d._frag_cut_faces = frag_cut_faces;
        gmei3d._frag_faces = frag_faces;
        _marked_elems_3d[_current_elem->id()].push_back(gmei3d);
      }
    }
  }
}

Referenced by MovingLineSegmentCutSetUserObject::execute().

finalize()

void GeometricCutUserObject::finalize ( )

overridevirtualinherited

Reimplemented in MovingLineSegmentCutSetUserObject.

Definition at line 254 of file GeometricCutUserObject.C.

{
  // for single processor runs we do not need to do anything here
  if (_app.n_processors() > 1)
  {
    // create send buffer
    std::string send_buffer;
 
    // create byte buffers for the streams received from all processors
    std::vector<std::string> recv_buffers;
 
    // pack the complex datastructures into the string stream
    serialize(send_buffer);
 
    // broadcast serialized data to and receive from all processors
    _communicator.allgather(send_buffer, recv_buffers);
 
    // unpack the received data and merge it into the local data structures
    deserialize(recv_buffers);
  }
 
  for (const auto & it : _marked_elems_2d)
    for (const auto & gmei : it.second)
      _xfem->addGeomMarkedElem2D(it.first, gmei, _interface_id);
 
  for (const auto & it : _marked_elems_3d)
    for (const auto & gmei : it.second)
      _xfem->addGeomMarkedElem3D(it.first, gmei, _interface_id);
 
  _marked_elems_2d.clear();
  _marked_elems_3d.clear();
}

Referenced by MovingLineSegmentCutSetUserObject::finalize().

findActiveBoundaryDirection()

void MeshCut3DUserObject::findActiveBoundaryDirection ( )

protected

Find growth direction at each active node.

Definition at line 678 of file MeshCut3DUserObject.C.

{
  _active_direction.clear();
 
  for (unsigned int i = 0; i < _active_boundary.size(); ++i)
  {
    std::vector<Point> temp;
    Point dir;
 
    if (_inactive_boundary_pos.size() != 0)
    {
      for (unsigned int j = 0; j < LIBMESH_DIM; ++j)
        dir(j) = 0;
      temp.push_back(dir);
    }
 
    unsigned int i1 = 1;
    unsigned int i2 = _active_boundary[i].size() - 1;
    if (_inactive_boundary_pos.size() == 0)
    {
      i1 = 0;
      i2 = _active_boundary[i].size();
    }
 
    for (unsigned int j = i1; j < i2; ++j)
    {
      Node * this_node = _cut_mesh->node_ptr(_active_boundary[i][j]);
      mooseAssert(this_node, "Node is NULL");
      Point & this_point = *this_node;
 
      dir(0) = _func_x.value(0, this_point);
      dir(1) = _func_y.value(0, this_point);
      dir(2) = _func_z.value(0, this_point);
 
      temp.push_back(dir);
    }
 
    if (_inactive_boundary_pos.size() != 0)
    {
      for (unsigned int j = 0; j < LIBMESH_DIM; ++j)
        dir(j) = 0;
      temp.push_back(dir);
    }
 
    _active_direction.push_back(temp);
  }
 
  Real maxl = 0;
 
  for (unsigned int i = 0; i < _active_direction.size(); ++i)
    for (unsigned int j = 0; j < _active_direction[i].size(); ++j)
    {
      Point pt = _active_direction[i][j];
      Real length = std::sqrt(pt * pt);
      if (length > maxl)
        maxl = length;
    }
 
  for (unsigned int i = 0; i < _active_direction.size(); ++i)
    for (unsigned int j = 0; j < _active_direction[i].size(); ++j)
      _active_direction[i][j] /= maxl;
}

Referenced by initialize().

findActiveBoundaryNodes()

void MeshCut3DUserObject::findActiveBoundaryNodes ( )

protected

Find all active boundary nodes in the cutter mesh Find boundary nodes that will grow; nodes outside of the structural mesh are inactive.

Definition at line 618 of file MeshCut3DUserObject.C.

{
  _active_boundary.clear();
  _inactive_boundary_pos.clear();
 
  std::unique_ptr<PointLocatorBase> pl = _mesh.getPointLocator();
  pl->enable_out_of_mesh_mode();
 
  unsigned int n_boundary = _boundary.size();
 
  // if the node is outside of the structural model, store its position in _boundary to
  // _inactive_boundary_pos
  for (unsigned int j = 0; j < n_boundary; ++j)
  {
    Node * this_node = _cut_mesh->node_ptr(_boundary[j]);
    mooseAssert(this_node, "Node is NULL");
    Point & this_point = *this_node;
 
    const Elem * elem = (*pl)(this_point);
    if (elem == NULL)
      _inactive_boundary_pos.push_back(j);
  }
 
  unsigned int n_inactive_boundary = _inactive_boundary_pos.size();
 
  // all nodes are inactive, stop
  if (n_inactive_boundary == n_boundary)
    _stop = 1;
 
  // find and store active boundary segments in "_active_boundary"
  if (n_inactive_boundary == 0)
    _active_boundary.push_back(_boundary);
  else
  {
    for (unsigned int i = 0; i < n_inactive_boundary - 1; ++i)
    {
      if (_inactive_boundary_pos[i + 1] - _inactive_boundary_pos[i] != 1)
      {
        std::vector<dof_id_type> temp;
        for (unsigned int j = _inactive_boundary_pos[i]; j <= _inactive_boundary_pos[i + 1]; ++j)
        {
          temp.push_back(_boundary[j]);
        }
        _active_boundary.push_back(temp);
      }
    }
    if (_inactive_boundary_pos[n_inactive_boundary - 1] - _inactive_boundary_pos[0] <
        n_boundary - 1)
    {
      std::vector<dof_id_type> temp;
      for (unsigned int j = _inactive_boundary_pos[n_inactive_boundary - 1]; j < n_boundary; ++j)
        temp.push_back(_boundary[j]);
      for (unsigned int j = 0; j <= _inactive_boundary_pos[0]; ++j)
        temp.push_back(_boundary[j]);
      _active_boundary.push_back(temp);
    }
  }
}

Referenced by initialize().

findBoundaryEdges()

void MeshCut3DUserObject::findBoundaryEdges ( )

protected

Find boundary edges of the cutter mesh.

Definition at line 373 of file MeshCut3DUserObject.C.

{
  _boundary_edges.clear();
 
  std::vector<dof_id_type> corner_elem_id;
  unsigned int counter = 0;
 
  std::vector<dof_id_type> node_id(_cut_elem_nnode);
  std::vector<bool> is_node_on_boundary(_cut_elem_nnode);
 
  for (const auto & cut_elem : _cut_mesh->element_ptr_range())
  {
    for (unsigned int i = 0; i < _cut_elem_nnode; ++i)
    {
      node_id[i] = cut_elem->node_ptr(i)->id();
      is_node_on_boundary[i] = (_boundary_map.find(node_id[i]) != _boundary_map.end());
    }
 
    if (is_node_on_boundary[0] && is_node_on_boundary[1] && is_node_on_boundary[2])
    {
      // this is an element at the corner; all nodes are on the boundary but not all edges are on
      // the boundary
      corner_elem_id.push_back(counter);
    }
    else
    {
      // for other elements, find and store boundary edges
      for (unsigned int i = 0; i < _cut_elem_nnode; ++i)
      {
        // if both nodes on an edge are on the boundary, it is a boundary edge.
        if (is_node_on_boundary[i] && is_node_on_boundary[(i + 1 <= 2) ? i + 1 : 0])
        {
          dof_id_type node1 = node_id[i];
          dof_id_type node2 = node_id[(i + 1 <= 2) ? i + 1 : 0];
          if (node1 > node2)
            std::swap(node1, node2);
 
          Xfem::CutEdge ce;
 
          if (node1 > node2)
            std::swap(node1, node2);
          ce._id1 = node1;
          ce._id2 = node2;
 
          _boundary_edges.insert(ce);
        }
      }
    }
    ++counter;
  }
 
  // loop over edges in corner elements
  // if an edge is shared by two elements, it is not an boundary edge (is_edge_inside = 1)
  for (unsigned int i = 0; i < corner_elem_id.size(); ++i)
  {
    auto elem_it = _cut_mesh->elements_begin();
 
    for (dof_id_type j = 0; j < corner_elem_id[i]; ++j)
      ++elem_it;
    Elem * cut_elem = *elem_it;
 
    for (unsigned int j = 0; j < _cut_elem_nnode; ++j)
    {
      bool is_edge_inside = 0;
 
      dof_id_type node1 = cut_elem->node_ptr(j)->id();
      dof_id_type node2 = cut_elem->node_ptr((j + 1 <= 2) ? j + 1 : 0)->id();
      if (node1 > node2)
        std::swap(node1, node2);
 
      unsigned int counter = 0;
      for (const auto & cut_elem2 : _cut_mesh->element_ptr_range())
      {
        if (counter != corner_elem_id[i])
        {
          for (unsigned int k = 0; k < _cut_elem_nnode; ++k)
          {
            dof_id_type node3 = cut_elem2->node_ptr(k)->id();
            dof_id_type node4 = cut_elem2->node_ptr((k + 1 <= 2) ? k + 1 : 0)->id();
            if (node3 > node4)
              std::swap(node3, node4);
 
            if (node1 == node3 && node2 == node4)
            {
              is_edge_inside = 1;
              goto endloop;
            }
          }
        }
        ++counter;
      }
    endloop:
      if (is_edge_inside == 0)
      {
        // store boundary edges
        Xfem::CutEdge ce;
 
        if (node1 > node2)
          std::swap(node1, node2);
        ce._id1 = node1;
        ce._id2 = node2;
 
        _boundary_edges.insert(ce);
      }
      else
      {
        // this is not a boundary edge; remove it from existing edge list
        for (auto it = _boundary_edges.begin(); it != _boundary_edges.end();)
        {
          if ((*it)._id1 == node1 && (*it)._id2 == node2)
            it = _boundary_edges.erase(it);
          else
            ++it;
        }
      }
    }
  }
}

Referenced by initialSetup().

findBoundaryNodes()

void MeshCut3DUserObject::findBoundaryNodes ( )

protected

Find boundary nodes of the cutter mesh This is a simple algorithm simply based on the added angle = 360 degrees Works fine for planar cutting surface for curved cutting surface, need to re-work this subroutine to make it more general.

Definition at line 331 of file MeshCut3DUserObject.C.

{
  unsigned int n_nodes = _cut_mesh->n_nodes();
  std::vector<Real> angle(n_nodes, 0); // this assumes that the cutter mesh has compressed node id
  std::vector<dof_id_type> node_id(_cut_elem_nnode);
 
  std::vector<Point> vertices(_cut_elem_nnode);
 
  for (const auto & cut_elem : _cut_mesh->element_ptr_range())
  {
    for (unsigned int i = 0; i < _cut_elem_nnode; ++i)
    {
      Node * this_node = cut_elem->node_ptr(i);
      Point & this_point = *this_node;
      vertices[i] = this_point;
      node_id[i] = this_node->id();
    }
 
    for (unsigned int i = 0; i < _cut_elem_nnode; ++i)
      mooseAssert(node_id[i] < n_nodes, "Node ID is out of range");
 
    angle[node_id[0]] += Xfem::angle_rad_3d(&vertices[2](0), &vertices[0](0), &vertices[1](0));
    angle[node_id[1]] += Xfem::angle_rad_3d(&vertices[0](0), &vertices[1](0), &vertices[2](0));
    angle[node_id[2]] += Xfem::angle_rad_3d(&vertices[1](0), &vertices[2](0), &vertices[0](0));
  }
 
  // In each element, angles at three vertices are calculated.  Angles associated with all nodes are
  // evaluated.
  // Interior nodes will have a total angle = 2*pi; otherwise, it is a boundary node
  // This assumes the cutter surface is flat.
  for (const auto & node : _cut_mesh->node_ptr_range())
  {
    dof_id_type id = node->id();
    if (!MooseUtils::relativeFuzzyEqual(angle[id], libMesh::pi * 2))
    {
      std::vector<dof_id_type> neighbors;
      _boundary_map[id] = neighbors;
    }
  }
}

Referenced by initialSetup().

findDistance()

Real MeshCut3DUserObject::findDistance ( dof_id_type  node1, dof_id_type  node2  )

protected

Find distance between two nodes.

Definition at line 553 of file MeshCut3DUserObject.C.

{
  Node * n1 = _cut_mesh->node_ptr(node1);
  mooseAssert(n1 != nullptr, "Node is NULL");
  Node * n2 = _cut_mesh->node_ptr(node2);
  mooseAssert(n2 != nullptr, "Node is NULL");
  Real distance = (*n1 - *n2).norm();
  return distance;
}

Referenced by refineBoundary(), refineFront(), and triangulation().

findFrontIntersection()

void MeshCut3DUserObject::findFrontIntersection ( )

protected

Find front-structure intersections.

Definition at line 790 of file MeshCut3DUserObject.C.

{
  ConstBndElemRange & range = *_mesh.getBoundaryElementRange();
 
  for (unsigned int i = 0; i < _front.size(); ++i)
  {
    if (_front[i].size() >= 2)
    {
      std::vector<Point> pint1;
      std::vector<Point> pint2;
      std::vector<Real> length1;
      std::vector<Real> length2;
 
      Real node_id = _front[i][0];
      Node * this_node = _cut_mesh->node_ptr(node_id);
      mooseAssert(this_node, "Node is NULL");
      Point & p2 = *this_node;
 
      node_id = _front[i][1];
      this_node = _cut_mesh->node_ptr(node_id);
      mooseAssert(this_node, "Node is NULL");
      Point & p1 = *this_node;
 
      node_id = _front[i].back();
      this_node = _cut_mesh->node_ptr(node_id);
      mooseAssert(this_node, "Node is NULL");
      Point & p4 = *this_node;
 
      node_id = _front[i][_front[i].size() - 2];
      this_node = _cut_mesh->node_ptr(node_id);
      mooseAssert(this_node, "Node is NULL");
      Point & p3 = *this_node;
 
      bool do_inter1 = 1;
      bool do_inter2 = 1;
 
      std::unique_ptr<PointLocatorBase> pl = _mesh.getPointLocator();
      pl->enable_out_of_mesh_mode();
      const Elem * elem = (*pl)(p1);
      if (elem == NULL)
        do_inter1 = 0;
      elem = (*pl)(p4);
      if (elem == NULL)
        do_inter2 = 0;
 
      for (const auto & belem : range)
      {
        Point pt;
        std::vector<Point> vertices;
 
        elem = belem->_elem;
        std::unique_ptr<const Elem> curr_side = elem->side_ptr(belem->_side);
        for (unsigned int j = 0; j < curr_side->n_nodes(); ++j)
        {
          const Node * node = curr_side->node_ptr(j);
          const Point & this_point = *node;
          vertices.push_back(this_point);
        }
 
        if (findIntersection(p1, p2, vertices, pt))
        {
          pint1.push_back(pt);
          length1.push_back((pt - p1) * (pt - p1));
        }
        if (findIntersection(p3, p4, vertices, pt))
        {
          pint2.push_back(pt);
          length2.push_back((pt - p3) * (pt - p3));
        }
      }
 
      if (length1.size() != 0 && do_inter1)
      {
        auto it1 = std::min_element(length1.begin(), length1.end());
        Point inter1 = pint1[std::distance(length1.begin(), it1)];
        inter1 += (inter1 - p1) * _const_intersection;
 
        Node * this_node = Node::build(inter1, _cut_mesh->n_nodes()).release();
        _cut_mesh->add_node(this_node);
 
        mooseAssert(_cut_mesh->n_nodes() - 1 > 0, "The cut mesh should have at least one element.");
        unsigned int n = _cut_mesh->n_nodes() - 1;
 
        auto it = _front[i].begin();
        _front[i].insert(it, n);
      }
 
      if (length2.size() != 0 && do_inter2)
      {
        auto it2 = std::min_element(length2.begin(), length2.end());
        Point inter2 = pint2[std::distance(length2.begin(), it2)];
        inter2 += (inter2 - p2) * _const_intersection;
 
        Node * this_node = Node::build(inter2, _cut_mesh->n_nodes()).release();
        _cut_mesh->add_node(this_node);
 
        dof_id_type n = _cut_mesh->n_nodes() - 1;
 
        auto it = _front[i].begin();
        unsigned int m = _front[i].size();
        _front[i].insert(it + m, n);
      }
    }
  }
}

Referenced by initialize().

findIntersection()

bool MeshCut3DUserObject::findIntersection ( const Point &  p1, const Point &  p2, const std::vector< Point > &  vertices, Point &  pint  ) const

protected

Find directional intersection along the positive extension of the vector from p1 to p2.

Definition at line 256 of file MeshCut3DUserObject.C.

{
  bool has_intersection = false;
 
  Plane elem_plane(vertices[0], vertices[1], vertices[2]);
  Point point = vertices[0];
  Point normal = elem_plane.unit_normal(point);
 
  std::array<Real, 3> plane_point = {{point(0), point(1), point(2)}};
  std::array<Real, 3> planenormal = {{normal(0), normal(1), normal(2)}};
  std::array<Real, 3> p_begin = {{p1(0), p1(1), p1(2)}};
  std::array<Real, 3> p_end = {{p2(0), p2(1), p2(2)}};
  std::array<Real, 3> cut_point = {{0.0, 0.0, 0.0}};
 
  if (Xfem::plane_normal_line_exp_int_3d(
          &plane_point[0], &planenormal[0], &p_begin[0], &p_end[0], &cut_point[0]) == 1)
  {
    Point p(cut_point[0], cut_point[1], cut_point[2]);
    Real dotp = ((p - p1) * (p2 - p1)) / ((p2 - p1) * (p2 - p1));
    if (isInsideCutPlane(vertices, p) && dotp > 1)
    {
      pint = p;
      has_intersection = true;
    }
  }
  return has_intersection;
}

Referenced by findFrontIntersection().

getCrackFrontPoints()

const std::vector< Point > MeshCut3DUserObject::getCrackFrontPoints ( unsigned int  ) const

overridevirtual

get a set of points along a crack front from a XFEM GeometricCutUserObject

Returns

A vector which contains all crack front points

Implements CrackFrontPointsProvider.

Definition at line 1085 of file MeshCut3DUserObject.C.

{
  mooseError("getCrackFrontPoints() is not implemented for this object.");
}

getInterfaceID()

unsigned int GeometricCutUserObject::getInterfaceID ( ) const

inlineinherited

Get the interface ID for this cutting object.

Returns

the interface ID

Definition at line 172 of file GeometricCutUserObject.h.

{ return _interface_id; };

getRelativePosition()

Real MeshCut3DUserObject::getRelativePosition ( const Point &  p1, const Point &  p2, const Point &  p  ) const

protected

Get the relative position of p from p1.

Definition at line 296 of file MeshCut3DUserObject.C.

{
  Real full_len = (p2 - p1).norm();
  Real len_p1_p = (p - p1).norm();
  return len_p1_p / full_len;
}

growFront()

void MeshCut3DUserObject::growFront ( )

protected

Grow the cutter mesh.

Definition at line 745 of file MeshCut3DUserObject.C.

{
  _front.clear();
 
  for (unsigned int i = 0; i < _active_boundary.size(); ++i)
  {
    std::vector<dof_id_type> temp;
 
    unsigned int i1 = 1;
    unsigned int i2 = _active_boundary[i].size() - 1;
    if (_inactive_boundary_pos.size() == 0)
    {
      i1 = 0;
      i2 = _active_boundary[i].size();
    }
 
    for (unsigned int j = i1; j < i2; ++j)
    {
      Node * this_node = _cut_mesh->node_ptr(_active_boundary[i][j]);
      mooseAssert(this_node, "Node is NULL");
      Point & this_point = *this_node;
      Point dir = _active_direction[i][j];
 
      Point x;
      for (unsigned int k = 0; k < LIBMESH_DIM; ++k)
        x(k) = this_point(k) + dir(k) * _size_control;
 
      this_node = Node::build(x, _cut_mesh->n_nodes()).release();
      _cut_mesh->add_node(this_node);
 
      dof_id_type id = _cut_mesh->n_nodes() - 1;
      temp.push_back(id);
    }
 
    _front.push_back(temp);
  }
}

Referenced by initialize().

initialize()

void MeshCut3DUserObject::initialize ( )

overridevirtual

Reimplemented from GeometricCutUserObject.

Definition at line 90 of file MeshCut3DUserObject.C.

{
  if (_grow)
  {
    unsigned int timestep = _fe_problem.timeStep();
 
    if (timestep == 1)
      _last_step_initialized = 1;
 
    _stop = 0;
 
    if (timestep > 1 && timestep != _last_step_initialized)
    {
      _last_step_initialized = timestep;
 
      for (unsigned int i = 0; i < _n_step_growth; ++i)
        findActiveBoundaryNodes();
 
      if (_stop != 1)
      {
        findActiveBoundaryDirection();
        growFront();
        sortFrontNodes();
        if (_inactive_boundary_pos.size() != 0)
          findFrontIntersection();
        refineFront();
        triangulation();
        joinBoundary();
      }
    }
  }
}

initialSetup()

void MeshCut3DUserObject::initialSetup ( )

overridevirtual

Definition at line 78 of file MeshCut3DUserObject.C.

{
  if (_grow)
  {
    findBoundaryNodes();
    findBoundaryEdges();
    sortBoundaryNodes();
    refineBoundary();
  }
}

intersectWithEdge()

bool MeshCut3DUserObject::intersectWithEdge ( const Point &  p1, const Point &  p2, const std::vector< Point > &  _vertices, Point &  pint  ) const

protectedvirtual

Check if a line intersects with an element.

Definition at line 225 of file MeshCut3DUserObject.C.

{
  bool has_intersection = false;
 
  Plane elem_plane(vertices[0], vertices[1], vertices[2]);
  Point point = vertices[0];
  Point normal = elem_plane.unit_normal(point);
 
  std::array<Real, 3> plane_point = {{point(0), point(1), point(2)}};
  std::array<Real, 3> planenormal = {{normal(0), normal(1), normal(2)}};
  std::array<Real, 3> edge_point1 = {{p1(0), p1(1), p1(2)}};
  std::array<Real, 3> edge_point2 = {{p2(0), p2(1), p2(2)}};
  std::array<Real, 3> cut_point = {{0.0, 0.0, 0.0}};
 
  if (Xfem::plane_normal_line_exp_int_3d(
          &plane_point[0], &planenormal[0], &edge_point1[0], &edge_point2[0], &cut_point[0]) == 1)
  {
    Point temp_p(cut_point[0], cut_point[1], cut_point[2]);
    if (isInsideCutPlane(vertices, temp_p) && isInsideEdge(p1, p2, temp_p))
    {
      pint = temp_p;
      has_intersection = true;
    }
  }
  return has_intersection;
}

isInsideCutPlane()

bool MeshCut3DUserObject::isInsideCutPlane ( const std::vector< Point > &  _vertices, const Point &  p  ) const

protected

Check if point p is inside a plane.

Definition at line 304 of file MeshCut3DUserObject.C.

{
  unsigned int n_node = vertices.size();
 
  Plane elem_plane(vertices[0], vertices[1], vertices[2]);
  Point normal = elem_plane.unit_normal(vertices[0]);
 
  bool inside = false;
  unsigned int counter = 0;
 
  for (unsigned int i = 0; i < n_node; ++i)
  {
    unsigned int iplus1 = (i < n_node - 1 ? i + 1 : 0);
    Point middle2p = p - 0.5 * (vertices[i] + vertices[iplus1]);
    const Point side_tang = vertices[iplus1] - vertices[i];
    Point side_norm = side_tang.cross(normal);
    Xfem::normalizePoint(middle2p);
    Xfem::normalizePoint(side_norm);
    if (middle2p * side_norm <= 0.0)
      counter += 1;
  }
  if (counter == n_node)
    inside = true;
  return inside;
}

Referenced by findIntersection(), and intersectWithEdge().

isInsideEdge()

bool MeshCut3DUserObject::isInsideEdge ( const Point &  p1, const Point &  p2, const Point &  p  ) const

protected

Check if point p is inside the edge p1-p2.

Definition at line 288 of file MeshCut3DUserObject.C.

{
  Real dotp1 = (p1 - p) * (p2 - p1);
  Real dotp2 = (p2 - p) * (p2 - p1);
  return (dotp1 * dotp2 <= 0.0);
}

Referenced by intersectWithEdge().

joinBoundary()

void MeshCut3DUserObject::joinBoundary ( )

protected

Join active boundaries and inactive boundaries to be the new boundary.

Definition at line 1045 of file MeshCut3DUserObject.C.

{
  if (_inactive_boundary_pos.size() == 0)
  {
    _boundary = _front[0];
    _boundary.pop_back();
    return;
  }
 
  std::vector<dof_id_type> full_front;
 
  unsigned int size1 = _active_boundary.size();
 
  for (unsigned int i = 0; i < size1; ++i)
  {
    unsigned int size2 = _active_boundary[i].size();
 
    dof_id_type bd1 = _active_boundary[i][size2 - 1];
    dof_id_type bd2 = _active_boundary[i + 1 < size1 ? i + 1 : 0][0];
 
    full_front.insert(full_front.end(), _front[i].begin(), _front[i].end());
 
    auto it1 = std::find(_boundary.begin(), _boundary.end(), bd1);
    unsigned int pos1 = std::distance(_boundary.begin(), it1);
    auto it2 = std::find(_boundary.begin(), _boundary.end(), bd2);
    unsigned int pos2 = std::distance(_boundary.begin(), it2);
 
    if (pos1 <= pos2)
      full_front.insert(full_front.end(), _boundary.begin() + pos1, _boundary.begin() + pos2 + 1);
    else
    {
      full_front.insert(full_front.end(), _boundary.begin() + pos1, _boundary.end());
      full_front.insert(full_front.end(), _boundary.begin(), _boundary.begin() + pos2 + 1);
    }
  }
 
  _boundary = full_front;
}

Referenced by initialize().

refineBoundary()

void MeshCut3DUserObject::refineBoundary ( )

protected

If boundary nodes are too sparse, add nodes in between.

Definition at line 564 of file MeshCut3DUserObject.C.

{
  std::vector<dof_id_type> new_boundary_order(_boundary.begin(), _boundary.end());
 
  mooseAssert(_boundary.size() >= 2, "Boundary should have at least two nodes");
 
  for (unsigned int i = _boundary.size() - 1; i >= 1; --i)
  {
    dof_id_type node1 = _boundary[i - 1];
    dof_id_type node2 = _boundary[i];
 
    Real distance = findDistance(node1, node2);
 
    if (distance > _size_control)
    {
      unsigned int n = static_cast<unsigned int>(distance / _size_control);
      std::array<Real, LIBMESH_DIM> x1;
      std::array<Real, LIBMESH_DIM> x2;
 
      Node * n1 = _cut_mesh->node_ptr(node1);
      mooseAssert(n1 != nullptr, "Node is NULL");
      Point & p1 = *n1;
      Node * n2 = _cut_mesh->node_ptr(node2);
      mooseAssert(n2 != nullptr, "Node is NULL");
      Point & p2 = *n2;
 
      for (unsigned int j = 0; j < LIBMESH_DIM; ++j)
      {
        x1[j] = p1(j);
        x2[j] = p2(j);
      }
 
      for (unsigned int j = 0; j < n; ++j)
      {
        Point x;
        for (unsigned int k = 0; k < LIBMESH_DIM; ++k)
          x(k) = x2[k] - (x2[k] - x1[k]) * (j + 1) / (n + 1);
 
        Node * this_node = Node::build(x, _cut_mesh->n_nodes()).release();
        _cut_mesh->add_node(this_node);
 
        dof_id_type id = _cut_mesh->n_nodes() - 1;
        auto it = new_boundary_order.begin();
        new_boundary_order.insert(it + i, id);
      }
    }
  }
 
  _boundary = new_boundary_order;
  mooseAssert(_boundary.size() > 0, "Boundary should not have zero size");
  _boundary.pop_back();
}

Referenced by initialSetup().

refineFront()

void MeshCut3DUserObject::refineFront ( )

protected

Refine the mesh at the front.

Definition at line 897 of file MeshCut3DUserObject.C.

{
  std::vector<std::vector<dof_id_type>> new_front(_front.begin(), _front.end());
 
  for (unsigned int ifront = 0; ifront < _front.size(); ++ifront)
  {
    unsigned int i1 = _front[ifront].size() - 1;
    if (_inactive_boundary_pos.size() == 0)
      i1 = _front[ifront].size();
 
    for (unsigned int i = i1; i >= 1; --i)
    {
      unsigned int i2 = i;
      if (_inactive_boundary_pos.size() == 0)
        i2 = (i <= _front[ifront].size() - 1 ? i : 0);
 
      dof_id_type node1 = _front[ifront][i - 1];
      dof_id_type node2 = _front[ifront][i2];
      Real distance = findDistance(node1, node2);
 
      if (distance > _size_control)
      {
        unsigned int n = static_cast<int>(distance / _size_control);
        std::array<Real, LIBMESH_DIM> x1;
        std::array<Real, LIBMESH_DIM> x2;
 
        Node * this_node = _cut_mesh->node_ptr(node1);
        mooseAssert(this_node, "Node is NULL");
        Point & p1 = *this_node;
        this_node = _cut_mesh->node_ptr(node2);
        mooseAssert(this_node, "Node is NULL");
        Point & p2 = *this_node;
 
        for (unsigned int j = 0; j < LIBMESH_DIM; ++j)
        {
          x1[j] = p1(j);
          x2[j] = p2(j);
        }
 
        for (unsigned int j = 0; j < n; ++j)
        {
          Point x;
          for (unsigned int k = 0; k < LIBMESH_DIM; ++k)
            x(k) = x2[k] - (x2[k] - x1[k]) * (j + 1) / (n + 1);
 
          Node * this_node = Node::build(x, _cut_mesh->n_nodes()).release();
          _cut_mesh->add_node(this_node);
 
          dof_id_type id = _cut_mesh->n_nodes() - 1;
 
          auto it = new_front[ifront].begin();
          new_front[ifront].insert(it + i, id);
        }
      }
    }
  }
 
  _front = new_front;
}

Referenced by initialize().

serialize()

void GeometricCutUserObject::serialize ( std::string &  serialized_buffer )

protectedinherited

Methods to pack/unpack the _marked_elems_2d and _marked_elems_3d data into a structure suitable for parallel communication.

Definition at line 209 of file GeometricCutUserObject.C.

{
  // stream for serializing the _marked_elems_2d and _marked_elems_3d data structures to a byte
  // stream
  std::ostringstream oss;
  dataStore(oss, _marked_elems_2d, this);
  dataStore(oss, _marked_elems_3d, this);
 
  // Populate the passed in string pointer with the string stream's buffer contents
  serialized_buffer.assign(oss.str());
}

Referenced by GeometricCutUserObject::finalize().

setInterfaceID()

void GeometricCutUserObject::setInterfaceID ( unsigned int  interface_id )

inlineinherited

Set the interface ID for this cutting object.

Parameters

the	interface ID

Definition at line 178 of file GeometricCutUserObject.h.

{ _interface_id = interface_id; };

Referenced by XFEM::addGeometricCut().

shouldHealMesh()

bool GeometricCutUserObject::shouldHealMesh ( ) const

inlineinherited

Should the elements cut by this cutting object be healed in the current time step?

Returns

true if the cut element should be healed

Definition at line 185 of file GeometricCutUserObject.h.

{ return _heal_always; };

sortBoundaryNodes()

void MeshCut3DUserObject::sortBoundaryNodes ( )

protected

Sort boundary nodes to be in the right order along the boundary.

Definition at line 493 of file MeshCut3DUserObject.C.

{
  _boundary.clear();
 
  for (auto it = _boundary_edges.begin(); it != _boundary_edges.end(); ++it)
  {
    dof_id_type node1 = (*it)._id1;
    dof_id_type node2 = (*it)._id2;
 
    mooseAssert(_boundary_map.find(node1) != _boundary_map.end(),
                "_boundary_map does not have this key");
    mooseAssert(_boundary_map.find(node2) != _boundary_map.end(),
                "_boundary_map does not have this key");
 
    _boundary_map.find(node1)->second.push_back(node2);
    _boundary_map.find(node2)->second.push_back(node1);
  }
 
  auto it = _boundary_map.begin();
  while (it != _boundary_map.end())
  {
    if (it->second.size() != 2)
      mooseError(
          "Boundary nodes in the cutter mesh must have exactly two neighbors; this one has: ",
          it->second.size());
    ++it;
  }
 
  auto it2 = _boundary_edges.begin();
  dof_id_type node1 = (*it2)._id1;
  dof_id_type node2 = (*it2)._id2;
  _boundary.push_back(node1);
  _boundary.push_back(node2);
 
  for (unsigned int i = 0; i < _boundary_edges.size() - 1; ++i)
  {
    mooseAssert(_boundary_map.find(node2) != _boundary_map.end(),
                "_boundary_map does not have this key");
 
    dof_id_type node3 = _boundary_map.find(node2)->second[0];
    dof_id_type node4 = _boundary_map.find(node2)->second[1];
 
    if (node3 == node1)
    {
      _boundary.push_back(node4);
      node1 = node2;
      node2 = node4;
    }
    else if (node4 == node1)
    {
      _boundary.push_back(node3);
      node1 = node2;
      node2 = node3;
    }
    else
      mooseError("Discontinuity in cutter boundary");
  }
}

Referenced by initialSetup().

sortFrontNodes()

void MeshCut3DUserObject::sortFrontNodes ( )

protected

Sort the front nodes.

Definition at line 784 of file MeshCut3DUserObject.C.

{
}

Referenced by initialize().

threadJoin()

void GeometricCutUserObject::threadJoin ( const UserObject &  y )

overridevirtualinherited

Definition at line 133 of file GeometricCutUserObject.C.

{
  const GeometricCutUserObject & gcuo = dynamic_cast<const GeometricCutUserObject &>(y);
 
  for (const auto & it : gcuo._marked_elems_2d)
  {
    mooseAssert(_marked_elems_2d.find(it.first) == _marked_elems_2d.end(),
                "Element already inserted in map from a different thread");
    _marked_elems_2d[it.first] = it.second;
  }
  for (const auto & it : gcuo._marked_elems_3d)
  {
    mooseAssert(_marked_elems_3d.find(it.first) == _marked_elems_3d.end(),
                "Element already inserted in map from a different thread");
    _marked_elems_3d[it.first] = it.second;
  }
}

triangulation()

void MeshCut3DUserObject::triangulation ( )

protected

Create tri3 elements between the new front and the old front.

Definition at line 958 of file MeshCut3DUserObject.C.

{
 
  mooseAssert(_active_boundary.size() == _front.size(),
              "_active_boundary and _front should have the same size!");
 
  if (_inactive_boundary_pos.size() == 0)
  {
    _active_boundary[0].push_back(_active_boundary[0][0]);
    _front[0].push_back(_front[0][0]);
  }
 
  // loop over active segments
  for (unsigned int k = 0; k < _front.size(); ++k)
  {
    unsigned int n1 = _active_boundary[k].size();
    unsigned int n2 = _front[k].size();
 
    unsigned int i1 = 0;
    unsigned int i2 = 0;
 
    // stop when all nodes are associated with an element
    while (!(i1 == n1 - 1 && i2 == n2 - 1))
    {
      std::vector<dof_id_type> elem;
 
      dof_id_type p1 = _active_boundary[k][i1]; // node in the old front
      dof_id_type p2 = _front[k][i2];           // node in the new front
 
      if (i1 != n1 - 1 && i2 != n2 - 1)
      {
        dof_id_type p3 = _active_boundary[k][i1 + 1]; // next node in the old front
        dof_id_type p4 = _front[k][i2 + 1];           // next node in the new front
 
        elem.push_back(p1);
        elem.push_back(p2);
 
        Real d1 = findDistance(p1, p4);
        Real d2 = findDistance(p3, p2);
 
        if (d1 < d2)
        {
          elem.push_back(p4);
          i2++;
        }
 
        else
        {
          elem.push_back(p3);
          i1++;
        }
      }
 
      else if (i1 == n1 - 1)
      {
        dof_id_type p4 = _front[k][i2 + 1]; // next node in the new front
 
        elem.push_back(p1);
        elem.push_back(p2);
        elem.push_back(p4);
        i2++;
      }
 
      else if (i2 == n2 - 1)
      {
        dof_id_type p3 = _active_boundary[k][i1 + 1]; // next node in the old front
 
        elem.push_back(p1);
        elem.push_back(p2);
        elem.push_back(p3);
        i1++;
      }
 
      Elem * new_elem = Elem::build(TRI3).release();
 
      for (unsigned int i = 0; i < _cut_elem_nnode; ++i)
      {
        mooseAssert(_cut_mesh->node_ptr(elem[i]) != nullptr, "Node is NULL");
        new_elem->set_node(i) = _cut_mesh->node_ptr(elem[i]);
      }
 
      _cut_mesh->add_elem(new_elem);
    }
  }
}

Referenced by initialize().

validParams()

InputParameters CrackFrontPointsProvider::validParams ( )

staticinherited

Definition at line 15 of file CrackFrontPointsProvider.C.

{
  InputParameters params = ElementUserObject::validParams();
  params.addClassDescription("Base class for a class that can provide a set of points along a "
                             "crack front. The virtual functions must be overridden by a derived "
                             "class to provide this functionality.");
  return params;
}

Member Data Documentation

_active_boundary

std::vector<std::vector<dof_id_type> > MeshCut3DUserObject::_active_boundary

protected

Active boundary nodes where growth is allowed.

Definition at line 89 of file MeshCut3DUserObject.h.

Referenced by findActiveBoundaryDirection(), findActiveBoundaryNodes(), growFront(), joinBoundary(), and triangulation().

_active_direction

std::vector<std::vector<Point> > MeshCut3DUserObject::_active_direction

protected

Growth direction for active boundaries.

Definition at line 92 of file MeshCut3DUserObject.h.

Referenced by findActiveBoundaryDirection(), and growFront().

_boundary

std::vector<dof_id_type> MeshCut3DUserObject::_boundary

protected

Boundary nodes of the cutter mesh.

Definition at line 80 of file MeshCut3DUserObject.h.

Referenced by findActiveBoundaryNodes(), joinBoundary(), refineBoundary(), and sortBoundaryNodes().

_boundary_edges

std::set<Xfem::CutEdge> MeshCut3DUserObject::_boundary_edges

protected

Edges at the boundary.

Definition at line 83 of file MeshCut3DUserObject.h.

Referenced by findBoundaryEdges(), and sortBoundaryNodes().

_boundary_map

std::map<dof_id_type, std::vector<dof_id_type> > MeshCut3DUserObject::_boundary_map

protected

A map of boundary nodes and their neighbors.

Definition at line 86 of file MeshCut3DUserObject.h.

Referenced by findBoundaryEdges(), findBoundaryNodes(), and sortBoundaryNodes().

_const_intersection

const Real MeshCut3DUserObject::_const_intersection = 0.01

protected

Used to define intersection points.

Definition at line 67 of file MeshCut3DUserObject.h.

Referenced by findFrontIntersection().

_cut_elem_dim

const unsigned int MeshCut3DUserObject::_cut_elem_dim = 2

protected

Definition at line 58 of file MeshCut3DUserObject.h.

Referenced by MeshCut3DUserObject().

_cut_elem_nnode

const unsigned int MeshCut3DUserObject::_cut_elem_nnode = 3

protected

The cutter mesh has triangluar elements only.

Definition at line 57 of file MeshCut3DUserObject.h.

Referenced by findBoundaryEdges(), findBoundaryNodes(), MeshCut3DUserObject(), and triangulation().

_cut_mesh

std::unique_ptr<MeshBase> MeshCut3DUserObject::_cut_mesh

protected

The cutter mesh.

Definition at line 54 of file MeshCut3DUserObject.h.

Referenced by findActiveBoundaryDirection(), findActiveBoundaryNodes(), findBoundaryEdges(), findBoundaryNodes(), findDistance(), findFrontIntersection(), growFront(), MeshCut3DUserObject(), refineBoundary(), refineFront(), and triangulation().

_elem_dim

const unsigned int MeshCut3DUserObject::_elem_dim = 3

protected

The structural mesh must be 3D only.

Definition at line 64 of file MeshCut3DUserObject.h.

_front

std::vector<std::vector<dof_id_type> > MeshCut3DUserObject::_front

protected

New boundary after growth.

Definition at line 98 of file MeshCut3DUserObject.h.

Referenced by findFrontIntersection(), growFront(), joinBoundary(), refineFront(), and triangulation().

_func_x

const Function& MeshCut3DUserObject::_func_x

protected

Parsed functions of front growth.

Definition at line 203 of file MeshCut3DUserObject.h.

Referenced by findActiveBoundaryDirection().

_func_y

const Function& MeshCut3DUserObject::_func_y

protected

Definition at line 204 of file MeshCut3DUserObject.h.

Referenced by findActiveBoundaryDirection().

_func_z

const Function& MeshCut3DUserObject::_func_z

protected

Definition at line 205 of file MeshCut3DUserObject.h.

Referenced by findActiveBoundaryDirection().

_grow

bool MeshCut3DUserObject::_grow

protected

Definition at line 77 of file MeshCut3DUserObject.h.

Referenced by initialize(), initialSetup(), and MeshCut3DUserObject().

_heal_always

bool GeometricCutUserObject::_heal_always

protectedinherited

Heal the mesh.

Definition at line 195 of file GeometricCutUserObject.h.

_inactive_boundary_pos

std::vector<unsigned int> MeshCut3DUserObject::_inactive_boundary_pos

protected

Inactive boundary.

Definition at line 95 of file MeshCut3DUserObject.h.

Referenced by findActiveBoundaryDirection(), findActiveBoundaryNodes(), growFront(), initialize(), joinBoundary(), refineFront(), and triangulation().

_interface_id

unsigned int GeometricCutUserObject::_interface_id

protectedinherited

Associated interface id.

Definition at line 192 of file GeometricCutUserObject.h.

Referenced by GeometricCutUserObject::finalize(), and GeometricCutUserObject::GeometricCutUserObject().

_last_step_initialized

unsigned int GeometricCutUserObject::_last_step_initialized

protectedinherited

Time step information needed to advance a 3D crack only at the real beginning of a time step.

Definition at line 198 of file GeometricCutUserObject.h.

Referenced by initialize().

_marked_elems_2d

std::map<unsigned int, std::vector<Xfem::GeomMarkedElemInfo2D> > GeometricCutUserObject::_marked_elems_2d

protectedinherited

Containers with information about all 2D and 3D elements marked for cutting by this object.

Definition at line 201 of file GeometricCutUserObject.h.

Referenced by GeometricCutUserObject::deserialize(), GeometricCutUserObject::execute(), GeometricCutUserObject::finalize(), GeometricCutUserObject::initialize(), GeometricCutUserObject::serialize(), and GeometricCutUserObject::threadJoin().

_marked_elems_3d

std::map<unsigned int, std::vector<Xfem::GeomMarkedElemInfo3D> > GeometricCutUserObject::_marked_elems_3d

protectedinherited

Definition at line 202 of file GeometricCutUserObject.h.

Referenced by GeometricCutUserObject::deserialize(), GeometricCutUserObject::execute(), GeometricCutUserObject::finalize(), GeometricCutUserObject::initialize(), GeometricCutUserObject::serialize(), and GeometricCutUserObject::threadJoin().

_mesh

MooseMesh& MeshCut3DUserObject::_mesh

protected

The structural mesh.

Definition at line 61 of file MeshCut3DUserObject.h.

Referenced by findActiveBoundaryNodes(), and findFrontIntersection().

_n_step_growth

unsigned int MeshCut3DUserObject::_n_step_growth

protected

Number of steps to grow the mesh.

Definition at line 73 of file MeshCut3DUserObject.h.

Referenced by initialize(), and MeshCut3DUserObject().

_size_control

Real MeshCut3DUserObject::_size_control

protected

Used for cutter mesh refinement and front advancement.

Definition at line 70 of file MeshCut3DUserObject.h.

Referenced by growFront(), MeshCut3DUserObject(), refineBoundary(), and refineFront().

_stop

bool MeshCut3DUserObject::_stop

protected

variables to help control the work flow

Definition at line 76 of file MeshCut3DUserObject.h.

Referenced by findActiveBoundaryNodes(), and initialize().

_xfem

std::shared_ptr<XFEM> GeometricCutUserObject::_xfem

protectedinherited

Pointer to the XFEM controller object.

Definition at line 185 of file GeometricCutUserObject.h.

Referenced by GeometricCutUserObject::execute(), GeometricCutUserObject::finalize(), and GeometricCutUserObject::GeometricCutUserObject().

---

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

• xfem/include/userobjects/MeshCut3DUserObject.h
• xfem/src/userobjects/MeshCut3DUserObject.C