#include <XFEMMaterialTensorMarkerUserObject.h>

Inheritance diagram for XFEMMaterialTensorMarkerUserObject:

Public Member Functions
	XFEMMaterialTensorMarkerUserObject (const InputParameters &parameters)

virtual	~XFEMMaterialTensorMarkerUserObject ()

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)
	Determine whether the current element should be cut by a new crack. More...

Protected Attributes
MaterialTensorCalculator	_material_tensor_calculator

const MaterialProperty< SymmTensor > &	_tensor

Real	_threshold

bool	_average

Real	_random_range

Detailed Description

Definition at line 21 of file XFEMMaterialTensorMarkerUserObject.h.

Constructor & Destructor Documentation

◆ XFEMMaterialTensorMarkerUserObject()

XFEMMaterialTensorMarkerUserObject::XFEMMaterialTensorMarkerUserObject ( const InputParameters & parameters )

Definition at line 31 of file XFEMMaterialTensorMarkerUserObject.C.

   : XFEMMaterialStateMarkerBase(parameters),
     _material_tensor_calculator(parameters),
     _tensor(getMaterialProperty<SymmTensor>(getParam<std::string>("tensor"))),
     _threshold(getParam<Real>("threshold")),
     _average(getParam<bool>("average")),
     _random_range(getParam<Real>("random_range"))
 {
   setRandomResetFrequency(EXEC_INITIAL);
 }

◆ ~XFEMMaterialTensorMarkerUserObject()

virtual XFEMMaterialTensorMarkerUserObject::~XFEMMaterialTensorMarkerUserObject ( )

inlinevirtual

Definition at line 25 of file XFEMMaterialTensorMarkerUserObject.h.

25 {}

Member Function Documentation

◆ doesElementCrack()

bool XFEMMaterialTensorMarkerUserObject::doesElementCrack ( RealVectorValue & direction )

protectedvirtual

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 44 of file XFEMMaterialTensorMarkerUserObject.C.

 {
   bool does_it_crack = false;
   unsigned int numqp = _qrule->n_points();
 
   Real rnd_mult = (1.0 - _random_range / 2.0) + _random_range * getRandomReal();
 
   if (_average)
   {
     SymmTensor average_tensor;
     for (unsigned int qp = 0; qp < numqp; ++qp)
     {
       average_tensor += _tensor[qp];
     }
     average_tensor *= 1.0 / (Real)numqp;
     Real tensor_quantity =
         _material_tensor_calculator.getTensorQuantity(average_tensor, _q_point[0], direction);
     if (tensor_quantity > _threshold * rnd_mult)
       does_it_crack = true;
   }
   else
   {
     unsigned int max_index = 999999;
     std::vector<Real> tensor_quantities;
     tensor_quantities.reserve(numqp);
     Real max_quantity = 0;
     std::vector<RealVectorValue> directions;
     directions.resize(numqp);
     for (unsigned int qp = 0; qp < numqp; ++qp)
     {
       tensor_quantities[qp] =
           _material_tensor_calculator.getTensorQuantity(_tensor[qp], _q_point[qp], directions[qp]);
       if (directions[qp](0) == 0 && directions[qp](1) == 0 && directions[qp](2) == 0)
       {
         mooseError("Direction has zero length in XFEMMaterialTensorMarkerUserObject");
       }
       if (tensor_quantities[qp] > max_quantity)
       {
         max_quantity = tensor_quantities[qp];
         max_index = qp;
       }
     }
     if (max_quantity > _threshold * rnd_mult)
     {
       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
   }
 }