#include <EllipseCutUserObject.h>

Inheritance diagram for EllipseCutUserObject:

Public Member Functions
	EllipseCutUserObject (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
virtual bool	intersectWithEdge (const Point &p1, const Point &p2, Point &pint) const

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

Real	getRelativePosition (const Point &p1, const Point &p2, const Point &p) 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

Point	_center

Point	_normal

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

Private Member Functions
virtual bool	isInsideCutPlane (Point p) const override

Private Attributes
std::vector< Point >	_vertices

Point	_unit_vec1

Point	_unit_vec2

Real	_long_axis

Real	_short_axis

Detailed Description

Definition at line 20 of file EllipseCutUserObject.h.

Constructor & Destructor Documentation

◆ EllipseCutUserObject()

EllipseCutUserObject::EllipseCutUserObject ( const InputParameters & parameters )

Definition at line 36 of file EllipseCutUserObject.C.

   : GeometricCut3DUserObject(parameters), _cut_data(getParam<std::vector<Real>>("cut_data"))
 {
   // Set up constant parameters
   const int cut_data_len = 9;
  
   // Throw error if length of cut_data is incorrect
   if (_cut_data.size() != cut_data_len)
     mooseError("Length of EllipseCutUserObject cut_data must be 9");
  
   // Assign cut_data to vars used to construct cuts
   _center = Point(_cut_data[0], _cut_data[1], _cut_data[2]);
   _vertices.push_back(Point(_cut_data[3], _cut_data[4], _cut_data[5]));
   _vertices.push_back(Point(_cut_data[6], _cut_data[7], _cut_data[8]));
  
   std::pair<Point, Point> rays = std::make_pair(_vertices[0] - _center, _vertices[1] - _center);
  
   if (std::abs(rays.first * rays.second) > 1e-6)
     mooseError(
         "EllipseCutUserObject only works on an elliptic cut. Users should provide two points at "
         "the long and short axis.");
  
   _normal = rays.first.cross(rays.second);
   Xfem::normalizePoint(_normal);
  
   std::pair<Real, Real> ray_radii =
       std::make_pair(std::sqrt(rays.first.norm_sq()), std::sqrt(rays.second.norm_sq()));
  
   // Determine which the long and short axes
   if (ray_radii.first > ray_radii.second)
   {
     _unit_vec1 = rays.first;
     _unit_vec2 = rays.second;
     _long_axis = ray_radii.first;
     _short_axis = ray_radii.second;
   }
   else
   {
     _unit_vec1 = rays.second;
     _unit_vec2 = rays.first;
     _long_axis = ray_radii.second;
     _short_axis = ray_radii.first;
   }
  
   Xfem::normalizePoint(_unit_vec1);
   Xfem::normalizePoint(_unit_vec2);
 }

Member Function Documentation

◆ cutElementByGeometry() [1/2]

bool GeometricCut3DUserObject::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 GeometricCut3DUserObject.C.

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

◆ cutElementByGeometry() [2/2]

bool GeometricCut3DUserObject::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 49 of file GeometricCut3DUserObject.C.

 {
   bool cut_elem = false;
  
   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);
  
       Point intersection;
       if (intersectWithEdge(*node1, *node2, intersection))
       {
         cut_edges.push_back(j);
         cut_pos.push_back(getRelativePosition(*node1, *node2, intersection));
       }
     }
  
     if (cut_edges.size() == 2)
     {
       cut_elem = 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 cut_elem;
 }

◆ cutFragmentByGeometry() [1/2]

bool GeometricCut3DUserObject::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 105 of file GeometricCut3DUserObject.C.

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

◆ cutFragmentByGeometry() [2/2]

bool GeometricCut3DUserObject::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 114 of file GeometricCut3DUserObject.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().

◆ getCrackFrontPoints()

const std::vector< Point > EllipseCutUserObject::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 100 of file EllipseCutUserObject.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; };

◆ getRelativePosition()

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

protectedinherited

Definition at line 155 of file GeometricCut3DUserObject.C.

 {
   // get the relative position of p from p1
   Real full_len = (p2 - p1).norm();
   Real len_p1_p = (p - p1).norm();
   return len_p1_p / full_len;
 }

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

◆ intersectWithEdge()

bool GeometricCut3DUserObject::intersectWithEdge	(	const Point &	p1,
		const Point &	p2,
		Point &	pint
	)		const

protectedvirtualinherited

Definition at line 124 of file GeometricCut3DUserObject.C.

 {
   bool has_intersection = false;
   double plane_point[3] = {_center(0), _center(1), _center(2)};
   double plane_normal[3] = {_normal(0), _normal(1), _normal(2)};
   double edge_point1[3] = {p1(0), p1(1), p1(2)};
   double edge_point2[3] = {p2(0), p2(1), p2(2)};
   double cut_point[3] = {0.0, 0.0, 0.0};
  
   if (Xfem::plane_normal_line_exp_int_3d(
           plane_point, plane_normal, edge_point1, edge_point2, cut_point) == 1)
   {
     Point temp_p(cut_point[0], cut_point[1], cut_point[2]);
     if (isInsideCutPlane(temp_p) && isInsideEdge(p1, p2, temp_p))
     {
       pint = temp_p;
       has_intersection = true;
     }
   }
   return has_intersection;
 }

◆ isInsideCutPlane()

bool EllipseCutUserObject::isInsideCutPlane ( Point p ) const

overrideprivatevirtual

Implements GeometricCut3DUserObject.

Definition at line 85 of file EllipseCutUserObject.C.

 {
   Point ray = p - _center;
   if (std::abs(ray * _normal) < 1e-6)
   {
     std::pair<Real, Real> xy_loc = std::make_pair(ray * _unit_vec1, ray * _unit_vec2);
  
     if (std::sqrt(xy_loc.first * xy_loc.first / (_long_axis * _long_axis) +
                   xy_loc.second * xy_loc.second / (_short_axis * _short_axis)) < 1)
       return true;
   }
   return false;
 }

◆ isInsideEdge()

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

protectedinherited

Definition at line 147 of file GeometricCut3DUserObject.C.

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

Referenced by GeometricCut3DUserObject::intersectWithEdge().

◆ 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

◆ _center

Point GeometricCut3DUserObject::_center

protectedinherited

Definition at line 42 of file GeometricCut3DUserObject.h.

Referenced by CircleCutUserObject::CircleCutUserObject(), EllipseCutUserObject(), CircleCutUserObject::getCrackFrontPoints(), GeometricCut3DUserObject::intersectWithEdge(), CircleCutUserObject::isInsideCutPlane(), isInsideCutPlane(), and RectangleCutUserObject::RectangleCutUserObject().

◆ _cut_data

std::vector<Real> EllipseCutUserObject::_cut_data

protected

Definition at line 29 of file EllipseCutUserObject.h.

Referenced by EllipseCutUserObject().

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

◆ _long_axis

Real EllipseCutUserObject::_long_axis

private

Definition at line 35 of file EllipseCutUserObject.h.

Referenced by EllipseCutUserObject(), and isInsideCutPlane().

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

◆ _normal

Point GeometricCut3DUserObject::_normal

protectedinherited

Definition at line 43 of file GeometricCut3DUserObject.h.

Referenced by CircleCutUserObject::CircleCutUserObject(), EllipseCutUserObject(), CircleCutUserObject::getCrackFrontPoints(), GeometricCut3DUserObject::intersectWithEdge(), RectangleCutUserObject::isInsideCutPlane(), CircleCutUserObject::isInsideCutPlane(), isInsideCutPlane(), and RectangleCutUserObject::RectangleCutUserObject().

◆ _short_axis

Real EllipseCutUserObject::_short_axis

private

Definition at line 36 of file EllipseCutUserObject.h.

Referenced by EllipseCutUserObject(), and isInsideCutPlane().

◆ _unit_vec1

Point EllipseCutUserObject::_unit_vec1

private

Definition at line 33 of file EllipseCutUserObject.h.

Referenced by EllipseCutUserObject(), and isInsideCutPlane().

◆ _unit_vec2

Point EllipseCutUserObject::_unit_vec2

private

Definition at line 34 of file EllipseCutUserObject.h.

Referenced by EllipseCutUserObject(), and isInsideCutPlane().

◆ _vertices

std::vector<Point> EllipseCutUserObject::_vertices

private

Definition at line 32 of file EllipseCutUserObject.h.

Referenced by EllipseCutUserObject().

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

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ EllipseCutUserObject()

Member Function Documentation

◆ cutElementByGeometry() [1/2]

◆ cutElementByGeometry() [2/2]

◆ cutFragmentByGeometry() [1/2]

◆ cutFragmentByGeometry() [2/2]

◆ deserialize()

◆ execute()

◆ finalize()

◆ getCrackFrontPoints()

◆ getInterfaceID()

◆ getRelativePosition()

◆ initialize()

◆ intersectWithEdge()

◆ isInsideCutPlane()

◆ isInsideEdge()

◆ serialize()

◆ setInterfaceID()

◆ shouldHealMesh()

◆ threadJoin()

◆ validParams()

Member Data Documentation

◆ _center

◆ _cut_data

◆ _heal_always

◆ _interface_id

◆ _last_step_initialized

◆ _long_axis

◆ _marked_elems_2d

◆ _marked_elems_3d

◆ _normal

◆ _short_axis

◆ _unit_vec1

◆ _unit_vec2

◆ _vertices

◆ _xfem