#include <LineSegmentCutUserObject.h>

Inheritance diagram for LineSegmentCutUserObject:

Public Member Functions
	LineSegmentCutUserObject (const InputParameters &parameters)

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	initialize () override

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

virtual Real	cutFraction (unsigned int cut_num, Real time) const
	Find the fractional distance along a specified cut line for the current time that is currently active. 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::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 20 of file LineSegmentCutUserObject.h.

Constructor & Destructor Documentation

◆ LineSegmentCutUserObject()

LineSegmentCutUserObject::LineSegmentCutUserObject ( const InputParameters & parameters )

Definition at line 33 of file LineSegmentCutUserObject.C.

   : GeometricCut2DUserObject(parameters), _cut_data(getParam<std::vector<Real>>("cut_data"))
 {
   // Set up constant parameters
   const int cut_data_len = 4;
  
   // Throw error if length of cut_data is incorrect
   if (_cut_data.size() != cut_data_len)
     mooseError("Length of LineSegmentCutUserObject cut_data must be 4");
  
   // Assign scale and translate parameters
   std::pair<Real, Real> scale;
   if (isParamValid("cut_scale"))
   {
     auto vec_scale = getParam<std::vector<Real>>("cut_scale");
     scale = std::make_pair(vec_scale[0], vec_scale[1]);
   }
   else
   {
     scale = std::make_pair(1.0, 1.0);
   }
  
   std::pair<Real, Real> trans;
   if (isParamValid("cut_translate"))
   {
     auto vec_trans = getParam<std::vector<Real>>("cut_translate");
     trans = std::make_pair(vec_trans[0], vec_trans[1]);
   }
   else
   {
     trans = std::make_pair(0.0, 0.0);
   }
  
   // Assign translated and scaled cut_data to vars used to construct cuts
   Real x0 = (_cut_data[0] + trans.first) * scale.first;
   Real y0 = (_cut_data[1] + trans.second) * scale.second;
   Real x1 = (_cut_data[2] + trans.first) * scale.first;
   Real y1 = (_cut_data[3] + trans.second) * scale.second;
  
   _cut_line_endpoints.push_back(std::make_pair(Point(x0, y0, 0.0), Point(x1, y1, 0.0)));
  
   if (_cut_line_endpoints.size() != _cut_time_ranges.size())
     mooseError("Number of start/end times must match number of cut line endpoint sets");
 }

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 GeometricCut2DUserObject::cutFraction	(	unsigned int	cut_num,
		Real	time
	)		const

protectedvirtualinherited

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 in MovingLineSegmentCutSetUserObject.

Definition at line 202 of file GeometricCut2DUserObject.C.

 {
   mooseAssert(_cut_time_ranges.size() > cut_num,
               "cut_num is outside the bounds of _cut_time_ranges");
  
   Real fraction = 0.0;
  
   if (time >= _cut_time_ranges[cut_num].first)
   {
     if (time >= _cut_time_ranges[cut_num].second)
       fraction = 1.0;
     else
     {
       Real denominator = _cut_time_ranges[cut_num].second - _cut_time_ranges[cut_num].first;
       if (MooseUtils::absoluteFuzzyEqual(denominator, 0.0))
         mooseError("time_start_cut and time_end_cut cannot have the same value");
       fraction = (time - _cut_time_ranges[cut_num].first) / denominator;
     }
   }
   return fraction;
 }

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

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

◆ getCrackFrontPoints()

const std::vector< Point > LineSegmentCutUserObject::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 79 of file LineSegmentCutUserObject.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.

172 { return _interface_id; };

◆ initialize()

void GeometricCutUserObject::initialize ( )

overridevirtualinherited

Reimplemented in MeshCut3DUserObject, and MovingLineSegmentCutSetUserObject.

Definition at line 60 of file GeometricCutUserObject.C.

 {
   _marked_elems_2d.clear();
   _marked_elems_3d.clear();
 }

◆ 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> LineSegmentCutUserObject::_cut_data

protected

Definition at line 29 of file LineSegmentCutUserObject.h.

Referenced by LineSegmentCutUserObject().

◆ _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(), MovingLineSegmentCutSetUserObject::execute(), LineSegmentCutSetUserObject::LineSegmentCutSetUserObject(), and 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().

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

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

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ LineSegmentCutUserObject()

Member Function Documentation

◆ crossProduct2D()

◆ cutElementByGeometry() [1/2]

◆ cutElementByGeometry() [2/2]

◆ cutFraction()

◆ cutFragmentByGeometry() [1/2]

◆ cutFragmentByGeometry() [2/2]

◆ deserialize()

◆ execute()

◆ finalize()

◆ getCrackFrontPoints()

◆ getInterfaceID()

◆ initialize()

◆ IntersectSegmentWithCutLine()

◆ serialize()

◆ setInterfaceID()

◆ shouldHealMesh()

◆ threadJoin()

◆ validParams()

Member Data Documentation

◆ _cut_data

◆ _cut_line_endpoints

◆ _cut_time_ranges

◆ _heal_always

◆ _interface_id

◆ _last_step_initialized

◆ _marked_elems_2d

◆ _marked_elems_3d

◆ _xfem