#include <XFEMRankTwoTensorMarkerUserObject.h>

Inheritance diagram for XFEMRankTwoTensorMarkerUserObject:

Public Member Functions
	XFEMRankTwoTensorMarkerUserObject (const InputParameters &parameters)

virtual	~XFEMRankTwoTensorMarkerUserObject ()

virtual void	initialize () override

virtual void	execute () override

virtual void	threadJoin (const UserObject &y) override

virtual void	finalize () override

Protected Member Functions
virtual bool	doesElementCrack (RealVectorValue &direction) override
	Determine whether the current element should be cut by a new crack. More...

Protected Attributes
const MaterialProperty< RankTwoTensor > &	_tensor
	The tensor from which the scalar quantity used as a marking criterion is extracted. More...

MooseEnum	_scalar_type
	The type of scalar to be extracted from the tensor. More...

const Point	_point1
	Points used to define an axis of rotation for some scalar quantities. More...

const Point	_point2

const VariableValue &	_threshold
	Threshold value of the scalar. More...

bool	_average
	Whether to average the value for all quadrature points in an element. More...

const MooseArray< Real > &	_JxW
	Transformed Jacobian weights. More...

const MooseArray< Real > &	_coord

Private Attributes
MooseMesh &	_mesh

std::vector< BoundaryID >	_initiation_boundary_ids

bool	_secondary_cracks

std::shared_ptr< XFEM >	_xfem

std::map< unsigned int, RealVectorValue >	_marked_elems

std::set< unsigned int >	_marked_frags

std::map< unsigned int, unsigned int >	_marked_elem_sides

Detailed Description

Definition at line 22 of file XFEMRankTwoTensorMarkerUserObject.h.

Constructor & Destructor Documentation

◆ XFEMRankTwoTensorMarkerUserObject()

XFEMRankTwoTensorMarkerUserObject::XFEMRankTwoTensorMarkerUserObject ( const InputParameters & parameters )

Definition at line 46 of file XFEMRankTwoTensorMarkerUserObject.C.

   : XFEMMaterialStateMarkerBase(parameters),
     _tensor(getMaterialProperty<RankTwoTensor>(getParam<std::string>("tensor"))),
     _scalar_type(getParam<MooseEnum>("scalar_type")),
     _point1(parameters.get<Point>("point1")),
     _point2(parameters.get<Point>("point2")),
     _threshold(coupledValue("threshold")),
     _average(getParam<bool>("average")),
     _JxW(_assembly.JxW()),
     _coord(_assembly.coordTransformation())
 {
 }

◆ ~XFEMRankTwoTensorMarkerUserObject()

virtual XFEMRankTwoTensorMarkerUserObject::~XFEMRankTwoTensorMarkerUserObject ( )

inlinevirtual

Definition at line 26 of file XFEMRankTwoTensorMarkerUserObject.h.

26 {}

Member Function Documentation

◆ doesElementCrack()

bool XFEMRankTwoTensorMarkerUserObject::doesElementCrack ( RealVectorValue & direction )

overrideprotectedvirtual

Determine whether the current element should be cut by a new crack.

Parameters

direction Normal direction of crack if it is cracked

Returns: bool true if element cracks

Reimplemented from XFEMMaterialStateMarkerBase.

Definition at line 61 of file XFEMRankTwoTensorMarkerUserObject.C.

 {
   bool does_it_crack = false;
   unsigned int numqp = _qrule->n_points();
   Point zero; // Used for checking whether direction is zero
  
   if (_average)
   {
     Real average_threshold = 0.0;
     RankTwoTensor average_tensor;
     Point average_point;
     for (unsigned int qp = 0; qp < numqp; ++qp)
     {
       if (_threshold[qp] <= 0.0)
         mooseError("Threshold must be strictly positive in XFEMRankTwoTensorMarkerUserObject");
       average_threshold += _JxW[qp] * _coord[qp] * _threshold[qp];
       average_tensor += _JxW[qp] * _coord[qp] * _tensor[qp];
       average_point += _JxW[qp] * _coord[qp] * _q_point[qp];
     }
     Point point_dir;
     Real tensor_quantity = RankTwoScalarTools::getQuantity(
         average_tensor, _scalar_type, _point1, _point2, average_point, point_dir);
     if (point_dir.absolute_fuzzy_equals(zero))
       mooseError("Direction has zero length in XFEMRankTwoTensorMarkerUserObject");
     direction = point_dir;
     if (tensor_quantity > average_threshold)
       does_it_crack = true;
   }
   else
   {
     unsigned int max_index = std::numeric_limits<unsigned int>::max();
     Real max_ratio = 0.0;
     std::vector<Point> directions(numqp);
     for (unsigned int qp = 0; qp < numqp; ++qp)
     {
       if (_threshold[qp] <= 0.0)
         mooseError("Threshold must be strictly positive in XFEMRankTwoTensorMarkerUserObject");
       const Real tensor_quantity = RankTwoScalarTools::getQuantity(
           _tensor[qp], _scalar_type, _point1, _point2, _q_point[qp], directions[qp]);
       if (directions[qp].absolute_fuzzy_equals(zero))
         mooseError("Direction has zero length in XFEMRankTwoTensorMarkerUserObject");
       Real ratio = tensor_quantity / _threshold[qp];
       if (ratio > max_ratio)
       {
         max_ratio = ratio;
         max_index = qp;
       }
     }
     if (max_ratio > 1.0)
     {
       if (max_index == std::numeric_limits<unsigned int>::max())
         mooseError("max_index out of bounds in XFEMRankTwoTensorMarkerUserObject");
       does_it_crack = true;
       direction = directions[max_index];
     }
   }
  
   return does_it_crack;
 }

◆ execute()

void XFEMMaterialStateMarkerBase::execute ( )

overridevirtualinherited

Definition at line 62 of file XFEMMaterialStateMarkerBase.C.

 {
   RealVectorValue direction;
   bool isCut = _xfem->isElemCut(_current_elem);
   bool isCTE = _xfem->isElemAtCrackTip(_current_elem);
   bool isOnBoundary = false;
   unsigned int boundarySide = 99999;
   unsigned int _current_eid = _current_elem->id();
   std::map<unsigned int, RealVectorValue>::iterator mit;
   mit = _marked_elems.find(_current_eid);
  
   for (unsigned int i = 0; i < _initiation_boundary_ids.size(); ++i)
   {
     if (_mesh.isBoundaryElem(_current_eid, _initiation_boundary_ids[i]))
     {
       isOnBoundary = true;
       boundarySide = _mesh.sideWithBoundaryID(_current_elem, _initiation_boundary_ids[i]);
     }
   }
  
   if (isCTE && doesElementCrack(direction))
   {
     if (mit != _marked_elems.end())
     {
       mooseError("ERROR: element ", _current_eid, " already marked for crack growth.");
     }
     _marked_elems[_current_eid] = direction;
   }
   else if (isOnBoundary && doesElementCrack(direction))
   {
     if (mit != _marked_elems.end())
     {
       mooseError("ERROR: element ", _current_eid, " already marked for crack growth.");
     }
     _marked_elems[_current_eid] = direction;
     _marked_elem_sides[_current_eid] = boundarySide;
   }
   else if (isCut && _secondary_cracks && doesElementCrack(direction))
   {
     if (mit != _marked_elems.end())
     {
       mooseError("ERROR: element ", _current_eid, " already marked for crack growth.");
     }
     _marked_elems[_current_eid] = direction;
     _marked_frags.insert(_current_eid);
   }
 }

◆ finalize()

void XFEMMaterialStateMarkerBase::finalize ( )

overridevirtualinherited

Definition at line 138 of file XFEMMaterialStateMarkerBase.C.

 {
   _communicator.set_union(_marked_elems);
   _communicator.set_union(_marked_frags);
   _communicator.set_union(_marked_elem_sides);
  
   _xfem->clearStateMarkedElems();
   std::map<unsigned int, RealVectorValue>::iterator mit;
   for (mit = _marked_elems.begin(); mit != _marked_elems.end(); ++mit)
   {
     if (_marked_elem_sides.find(mit->first) != _marked_elem_sides.end())
     {
       _xfem->addStateMarkedElem(mit->first, mit->second, _marked_elem_sides[mit->first]);
     }
     else if (_marked_frags.find(mit->first) != _marked_frags.end())
     {
       _xfem->addStateMarkedFrag(mit->first, mit->second);
     }
     else
     {
       _xfem->addStateMarkedElem(mit->first, mit->second);
     }
   }
   _marked_elems.clear();
   _marked_frags.clear();
   _marked_elem_sides.clear();
 }

◆ initialize()

void XFEMMaterialStateMarkerBase::initialize ( )

overridevirtualinherited

Definition at line 53 of file XFEMMaterialStateMarkerBase.C.

 {
   _marked_elems.clear();
   _marked_frags
       .clear(); // mark the fragment which has secondary crack growing from the primary crack
   _marked_elem_sides.clear();
 }

◆ threadJoin()

void XFEMMaterialStateMarkerBase::threadJoin ( const UserObject & y )

overridevirtualinherited

Definition at line 111 of file XFEMMaterialStateMarkerBase.C.

 {
   const XFEMMaterialStateMarkerBase & xmuo = dynamic_cast<const XFEMMaterialStateMarkerBase &>(y);
  
   for (std::map<unsigned int, RealVectorValue>::const_iterator mit = xmuo._marked_elems.begin();
        mit != xmuo._marked_elems.end();
        ++mit)
   {
     _marked_elems[mit->first] = mit->second; // TODO do error checking for duplicates here too
   }
  
   for (std::set<unsigned int>::const_iterator mit = xmuo._marked_frags.begin();
        mit != xmuo._marked_frags.end();
        ++mit)
   {
     _marked_frags.insert(*mit); // TODO do error checking for duplicates here too
   }
  
   for (std::map<unsigned int, unsigned int>::const_iterator mit = xmuo._marked_elem_sides.begin();
        mit != xmuo._marked_elem_sides.end();
        ++mit)
   {
     _marked_elem_sides[mit->first] = mit->second; // TODO do error checking for duplicates here too
   }
 }