#include <XFEMCrackGrowthIncrement2DCut.h>

Public Member Functions
	XFEMCrackGrowthIncrement2DCut (Real x0, Real y0, Real x1, Real y1, Real t0, Real t1)

virtual bool	cutElementByCrackGrowthIncrement (const Elem *elem, std::vector< CutEdgeForCrackGrowthIncr > &cut_edges, Real time)

Real	cutCompletionFraction (Real time)

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)

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

Protected Attributes
const std::pair< Real, Real >	_time_range

Private Attributes
const std::pair< Point, Point >	_cut_line_endpoints

Detailed Description

Definition at line 27 of file XFEMCrackGrowthIncrement2DCut.h.

Constructor & Destructor Documentation

◆ XFEMCrackGrowthIncrement2DCut()

XFEMCrackGrowthIncrement2DCut::XFEMCrackGrowthIncrement2DCut	(	Real	x0,
		Real	y0,
		Real	x1,
		Real	y1,
		Real	t0,
		Real	t1
	)

Definition at line 16 of file XFEMCrackGrowthIncrement2DCut.C.

   : _time_range(std::make_pair(t0, t1)),
     _cut_line_endpoints(std::make_pair(Point(x0, y0, 0.0), Point(x1, y1, 0.0)))
 {
 }

Member Function Documentation

◆ crossProduct2D()

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

protected

Definition at line 120 of file XFEMCrackGrowthIncrement2DCut.C.

Referenced by IntersectSegmentWithCutLine().

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

◆ cutCompletionFraction()

Real XFEMCrackGrowthIncrement2DCut::cutCompletionFraction ( Real time )

Definition at line 24 of file XFEMCrackGrowthIncrement2DCut.C.

Referenced by cutElementByCrackGrowthIncrement().

 {
   Real fraction = 0.0;
   if (time >= _time_range.first)
   {
     if (time >= _time_range.second)
       fraction = 1.0;
     else
       fraction = (time - _time_range.first) / (_time_range.second - _time_range.first);
   }
   return fraction;
 }

◆ cutElementByCrackGrowthIncrement()

bool XFEMCrackGrowthIncrement2DCut::cutElementByCrackGrowthIncrement	(	const Elem *	elem,
		std::vector< CutEdgeForCrackGrowthIncr > &	cut_edges,
		Real	time
	)

virtual

Definition at line 38 of file XFEMCrackGrowthIncrement2DCut.C.

Referenced by XFEM::markCutEdgesByState().

 {
   bool cut_elem = false;
 
   Real fraction = cutCompletionFraction(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<Elem> curr_side = elem->side(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->get_node(0);
       const Node * node2 = curr_side->get_node(1);
       Real seg_int_frac = 0.0;
 
       if (IntersectSegmentWithCutLine(*node1, *node2, _cut_line_endpoints, fraction, seg_int_frac))
       {
         cut_elem = true;
         CutEdgeForCrackGrowthIncr mycut;
         mycut._id1 = node1->id();
         mycut._id2 = node2->id();
         mycut._distance = seg_int_frac;
         mycut._host_side_id = i;
         cut_edges.push_back(mycut);
       }
     }
   }
   return cut_elem;
 }

◆ IntersectSegmentWithCutLine()

bool XFEMCrackGrowthIncrement2DCut::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
	)

protected

Definition at line 80 of file XFEMCrackGrowthIncrement2DCut.C.

Referenced by cutElementByCrackGrowthIncrement().

 {
   // 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;
 }