#include <MovingLineSegmentCutSetUserObject.h>

Inheritance diagram for MovingLineSegmentCutSetUserObject:

Public Member Functions
	MovingLineSegmentCutSetUserObject (const InputParameters &parameters)

virtual void	initialize () override

virtual void	execute () override

virtual void	finalize () 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 Real	cutFraction (unsigned int cut_num, Real time) const override
	Find the fractional distance along a specified cut line for the current time that is currently active. More...

virtual std::vector< Real >	getCutData () const
	Get the cut location information. 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	threadJoin (const UserObject &y) 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 ()

Public Attributes
const XFEMMovingInterfaceVelocityBase *	_interface_velocity
	Pointer to XFEMMovingInterfaceVelocityBase object. More...

Protected Member Functions
bool	IntersectSegmentWithCutLine (const Point &segment_point1, const Point &segment_point2, const std::pair< Point, Point > &cutting_line_points, const Real &cutting_line_fraction, Real &segment_intersection_fraction) const

Real	crossProduct2D (const Point &point_a, const Point &point_b) const


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::vector< Real >	_cut_data

std::vector< std::pair< Point, Point > >	_cut_line_endpoints

std::vector< std::pair< Real, Real > >	_cut_time_ranges
	Vector of start/end times for each cut segment. More...

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

Definition at line 22 of file MovingLineSegmentCutSetUserObject.h.

Constructor & Destructor Documentation

◆ MovingLineSegmentCutSetUserObject()

MovingLineSegmentCutSetUserObject::MovingLineSegmentCutSetUserObject ( const InputParameters & parameters )

Definition at line 26 of file MovingLineSegmentCutSetUserObject.C.

   : LineSegmentCutSetUserObject(parameters)
 {
 }

Member Function Documentation

◆ crossProduct2D()

Real GeometricCut2DUserObject::crossProduct2D	(	const Point &	point_a,
		const Point &	point_b
	)		const

protectedinherited

Definition at line 196 of file GeometricCut2DUserObject.C.

 {
   return (point_a(0) * point_b(1) - point_b(0) * point_a(1));
 }

Referenced by GeometricCut2DUserObject::IntersectSegmentWithCutLine().

◆ cutElementByGeometry() [1/2]

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

overridevirtualinherited

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 39 of file GeometricCut2DUserObject.C.

 {
   bool cut_elem = false;
  
   for (unsigned int cut = 0; cut < _cut_line_endpoints.size(); ++cut)
   {
     Real fraction = cutFraction(cut, time);
  
     if (fraction > 0.0)
     {
       unsigned int n_sides = elem->n_sides();
  
       for (unsigned int i = 0; i < n_sides; ++i)
       {
         // This returns the lowest-order type of side, which should always
         // be an EDGE2 here because this class is for 2D only.
         std::unique_ptr<const Elem> curr_side = elem->side_ptr(i);
         if (curr_side->type() != EDGE2)
           mooseError("In cutElementByGeometry element side must be EDGE2, but type is: ",
                      libMesh::Utility::enum_to_string(curr_side->type()),
                      " base element type is: ",
                      libMesh::Utility::enum_to_string(elem->type()));
  
         const Node * node1 = curr_side->node_ptr(0);
         const Node * node2 = curr_side->node_ptr(1);
         Real seg_int_frac = 0.0;
  
         if (IntersectSegmentWithCutLine(
                 *node1, *node2, _cut_line_endpoints[cut], fraction, seg_int_frac))
         {
           if (seg_int_frac > Xfem::tol && seg_int_frac < 1.0 - Xfem::tol)
           {
             cut_elem = true;
             Xfem::CutEdge mycut;
             mycut._id1 = node1->id();
             mycut._id2 = node2->id();
             mycut._distance = seg_int_frac;
             mycut._host_side_id = i;
             cut_edges.push_back(mycut);
           }
           else if (seg_int_frac < Xfem::tol)
           {
             cut_elem = true;
             Xfem::CutNode mycut;
             mycut._id = node1->id();
             mycut._host_id = i;
             cut_nodes.push_back(mycut);
           }
         }
       }
     }
   }
   return cut_elem;
 }

◆ cutElementByGeometry() [2/2]

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

overridevirtualinherited

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 98 of file GeometricCut2DUserObject.C.

 {
   mooseError("Invalid method: must use vector of element edges for 2D mesh cutting");
   return false;
 }

◆ cutFraction()

Real MovingLineSegmentCutSetUserObject::cutFraction	(	unsigned int	cut_num,
		Real	time
	)		const

overridevirtual

Find the fractional distance along a specified cut line for the current time that is currently active.

Used for time-based propagation along a line

Parameters

cut_num	Index of the cut being queried
time	Current simulation time

Returns: Current fractional distance

Reimplemented from GeometricCut2DUserObject.

Definition at line 110 of file MovingLineSegmentCutSetUserObject.C.

 {
   return 1;
 }

◆ cutFragmentByGeometry() [1/2]

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

overridevirtualinherited

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 107 of file GeometricCut2DUserObject.C.

 {
   bool cut_frag = false;
  
   for (unsigned int cut = 0; cut < _cut_line_endpoints.size(); ++cut)
   {
     Real fraction = cutFraction(cut, time);
  
     if (fraction > 0.0)
     {
       unsigned int n_sides = frag_edges.size();
  
       for (unsigned int i = 0; i < n_sides; ++i)
       {
         Real seg_int_frac = 0.0;
  
         if (IntersectSegmentWithCutLine(frag_edges[i][0],
                                         frag_edges[i][1],
                                         _cut_line_endpoints[cut],
                                         fraction,
                                         seg_int_frac))
         {
           cut_frag = true;
           Xfem::CutEdge mycut;
           mycut._id1 = i;
           mycut._id2 = (i < (n_sides - 1) ? (i + 1) : 0);
           mycut._distance = seg_int_frac;
           mycut._host_side_id = i;
           cut_edges.push_back(mycut);
         }
       }
     }
   }
   return cut_frag;
 }

◆ cutFragmentByGeometry() [2/2]

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

overridevirtualinherited

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 146 of file GeometricCut2DUserObject.C.

 {
   mooseError("Invalid method: must use vector of element edges for 2D 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 MovingLineSegmentCutSetUserObject::execute ( )

overridevirtual

Reimplemented from GeometricCutUserObject.

Definition at line 55 of file MovingLineSegmentCutSetUserObject.C.

 {
   std::vector<Real> cut_data_copy = _cut_data;
  
   const int line_cut_data_len = 6;
  
   if (_cut_data.size() % line_cut_data_len != 0)
     mooseError("Length of MovingLineSegmentCutSetUserObject cut_data must be a multiple of 6.");
  
   unsigned int num_cuts = _cut_data.size() / line_cut_data_len;
  
   if (_t_step > 1)
   {
     for (unsigned int i = 1; i < _interface_velocity->numberPoints(); ++i)
     {
       cut_data_copy[(i - 1) * line_cut_data_len + 0] +=
           _interface_velocity->computeMovingInterfaceVelocity((i - 1)) * _dt;
       cut_data_copy[(i - 1) * line_cut_data_len + 2] +=
           _interface_velocity->computeMovingInterfaceVelocity(i) * _dt;
     }
   }
  
   _cut_line_endpoints.clear();
   for (unsigned int i = 0; i < num_cuts; ++i)
   {
     Real x0 = cut_data_copy[i * line_cut_data_len + 0];
     Real y0 = cut_data_copy[i * line_cut_data_len + 1];
     Real x1 = cut_data_copy[i * line_cut_data_len + 2];
     Real y1 = cut_data_copy[i * line_cut_data_len + 3];
     _cut_line_endpoints.push_back(std::make_pair(Point(x0, y0, 0.0), Point(x1, y1, 0.0)));
   }
  
   GeometricCutUserObject::execute();
 }

◆ finalize()

void MovingLineSegmentCutSetUserObject::finalize ( )

overridevirtual

Reimplemented from GeometricCutUserObject.

Definition at line 91 of file MovingLineSegmentCutSetUserObject.C.

 {
   const int line_cut_data_len = 6;
  
   if (_t_step > 1)
   {
     for (unsigned int i = 1; i < _interface_velocity->numberPoints(); ++i)
     {
       _cut_data[(i - 1) * line_cut_data_len + 0] +=
           _interface_velocity->computeMovingInterfaceVelocity((i - 1)) * _dt;
       _cut_data[(i - 1) * line_cut_data_len + 2] +=
           _interface_velocity->computeMovingInterfaceVelocity(i) * _dt;
     }
   }
  
   GeometricCutUserObject::finalize();
 }

◆ getCrackFrontPoints()

const std::vector< Point > MovingLineSegmentCutSetUserObject::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

Reimplemented from LineSegmentCutSetUserObject.

Definition at line 33 of file MovingLineSegmentCutSetUserObject.C.

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

◆ getCutData()

virtual std::vector<Real> LineSegmentCutSetUserObject::getCutData ( ) const

inlinevirtualinherited

Get the cut location information.

Definition at line 32 of file LineSegmentCutSetUserObject.h.

32 { return _cut_data; };

Referenced by LineSegmentLevelSetAux::compute(), and PointValueAtXFEMInterface::execute().

◆ 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.

172 { return _interface_id; };

◆ initialize()

void MovingLineSegmentCutSetUserObject::initialize ( )

overridevirtual

Reimplemented from GeometricCutUserObject.

Definition at line 40 of file MovingLineSegmentCutSetUserObject.C.

 {
   const UserObject * uo =
       &(_fe_problem.getUserObjectBase(getParam<UserObjectName>("interface_velocity")));
  
   if (dynamic_cast<const XFEMMovingInterfaceVelocityBase *>(uo) == nullptr)
     mooseError("UserObject casting to XFEMMovingInterfaceVelocityBase in "
                "MovingLineSegmentCutSetUserObject");
  
   _interface_velocity = dynamic_cast<const XFEMMovingInterfaceVelocityBase *>(uo);
  
   const_cast<XFEMMovingInterfaceVelocityBase *>(_interface_velocity)->initialize();
 }

◆ IntersectSegmentWithCutLine()

bool GeometricCut2DUserObject::IntersectSegmentWithCutLine	(	const Point &	segment_point1,
		const Point &	segment_point2,
		const std::pair< Point, Point > &	cutting_line_points,
		const Real &	cutting_line_fraction,
		Real &	segment_intersection_fraction
	)		const

protectedinherited

Definition at line 155 of file GeometricCut2DUserObject.C.

 {
   // Use the algorithm described here to determine whether a line segment is intersected
   // by a cutting line, and to compute the fraction along that line where the intersection
   // occurs:
   // http://stackoverflow.com/questions/563198/how-do-you-detect-where-two-line-segments-intersect
  
   bool cut_segment = false;
   Point seg_dir = segment_point2 - segment_point1;
   Point cut_dir = cutting_line_points.second - cutting_line_points.first;
   Point cut_start_to_seg_start = segment_point1 - cutting_line_points.first;
  
   Real cut_dir_cross_seg_dir = crossProduct2D(cut_dir, seg_dir);
  
   if (std::abs(cut_dir_cross_seg_dir) > Xfem::tol)
   {
     // Fraction of the distance along the cutting segment where it intersects the edge segment
     Real cut_int_frac = crossProduct2D(cut_start_to_seg_start, seg_dir) / cut_dir_cross_seg_dir;
  
     if (cut_int_frac >= 0.0 && cut_int_frac <= cutting_line_fraction)
     { // Cutting segment intersects the line of the edge segment, but the intersection point may
       // be
       // outside the segment
       Real int_frac = crossProduct2D(cut_start_to_seg_start, cut_dir) / cut_dir_cross_seg_dir;
       if (int_frac >= 0.0 &&
           int_frac <= 1.0) // TODO: revisit end cases for intersections with corners
       {
         cut_segment = true;
         segment_intersection_fraction = int_frac;
       }
     }
   }
   return cut_segment;
 }

Referenced by GeometricCut2DUserObject::cutElementByGeometry(), and GeometricCut2DUserObject::cutFragmentByGeometry().

◆ 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.

178 { _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.

185 { return _heal_always; };

◆ 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;
   }
 }

◆ 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

◆ _cut_data

std::vector<Real> LineSegmentCutSetUserObject::_cut_data

protectedinherited

Definition at line 32 of file LineSegmentCutSetUserObject.h.

Referenced by execute(), finalize(), LineSegmentCutSetUserObject::getCutData(), and LineSegmentCutSetUserObject::LineSegmentCutSetUserObject().

◆ _cut_line_endpoints

std::vector<std::pair<Point, Point> > GeometricCut2DUserObject::_cut_line_endpoints

protectedinherited

Definition at line 41 of file GeometricCut2DUserObject.h.

Referenced by GeometricCut2DUserObject::cutElementByGeometry(), GeometricCut2DUserObject::cutFragmentByGeometry(), execute(), LineSegmentCutSetUserObject::LineSegmentCutSetUserObject(), and LineSegmentCutUserObject::LineSegmentCutUserObject().

◆ _cut_time_ranges

std::vector<std::pair<Real, Real> > GeometricCut2DUserObject::_cut_time_ranges

protectedinherited

Vector of start/end times for each cut segment.

Definition at line 61 of file GeometricCut2DUserObject.h.

Referenced by GeometricCut2DUserObject::cutFraction(), GeometricCut2DUserObject::GeometricCut2DUserObject(), LineSegmentCutSetUserObject::LineSegmentCutSetUserObject(), and LineSegmentCutUserObject::LineSegmentCutUserObject().

◆ _heal_always

bool GeometricCutUserObject::_heal_always

protectedinherited

Heal the mesh.

Definition at line 195 of file GeometricCutUserObject.h.

◆ _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().

◆ _interface_velocity

const XFEMMovingInterfaceVelocityBase* MovingLineSegmentCutSetUserObject::_interface_velocity

Pointer to XFEMMovingInterfaceVelocityBase object.

Definition at line 40 of file MovingLineSegmentCutSetUserObject.h.

Referenced by execute(), finalize(), and initialize().

◆ _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 MeshCut3DUserObject::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().

◆ _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/MovingLineSegmentCutSetUserObject.h
xfem/src/userobjects/MovingLineSegmentCutSetUserObject.C

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ MovingLineSegmentCutSetUserObject()

Member Function Documentation

◆ crossProduct2D()

◆ cutElementByGeometry() [1/2]

◆ cutElementByGeometry() [2/2]

◆ cutFraction()

◆ cutFragmentByGeometry() [1/2]

◆ cutFragmentByGeometry() [2/2]

◆ deserialize()

◆ execute()

◆ finalize()

◆ getCrackFrontPoints()

◆ getCutData()

◆ getInterfaceID()

◆ initialize()

◆ IntersectSegmentWithCutLine()

◆ serialize()

◆ setInterfaceID()

◆ shouldHealMesh()

◆ threadJoin()

◆ validParams()

Member Data Documentation

◆ _cut_data

◆ _cut_line_endpoints

◆ _cut_time_ranges

◆ _heal_always

◆ _interface_id

◆ _interface_velocity

◆ _last_step_initialized

◆ _marked_elems_2d

◆ _marked_elems_3d

◆ _xfem