Coupled auxiliary value. More...

#include <XFEMMaterialStateMarkerBase.h>

Inheritance diagram for XFEMMaterialStateMarkerBase:

Public Member Functions
	XFEMMaterialStateMarkerBase (const InputParameters &parameters)
	Factory constructor, takes parameters so that all derived classes can be built using the same constructor. More...

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

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

Coupled auxiliary value.

Definition at line 19 of file XFEMMaterialStateMarkerBase.h.

Constructor & Destructor Documentation

◆ XFEMMaterialStateMarkerBase()

XFEMMaterialStateMarkerBase::XFEMMaterialStateMarkerBase ( const InputParameters & parameters )

Factory constructor, takes parameters so that all derived classes can be built using the same constructor.

Definition at line 30 of file XFEMMaterialStateMarkerBase.C.

   : ElementUserObject(parameters),
     _mesh(_subproblem.mesh()),
     _secondary_cracks(getParam<bool>("secondary_cracks"))
 {
   FEProblemBase * fe_problem = dynamic_cast<FEProblemBase *>(&_subproblem);
   if (fe_problem == NULL)
     mooseError("Problem casting _subproblem to FEProblemBase in XFEMMaterialStateMarkerBase");
   _xfem = MooseSharedNamespace::dynamic_pointer_cast<XFEM>(fe_problem->getXFEM());
   if (_xfem == nullptr)
     mooseError("Problem casting to XFEM in XFEMMaterialStateMarkerBase");
   if (isNodal())
     mooseError("XFEMMaterialStateMarkerBase can only be run on an element variable");
  
   if (isParamValid("initiate_on_boundary"))
   {
     std::vector<BoundaryName> initiation_boundary_names =
         getParam<std::vector<BoundaryName>>("initiate_on_boundary");
     _initiation_boundary_ids = _mesh.getBoundaryIDs(initiation_boundary_names, true);
   }
 }

Member Function Documentation

◆ doesElementCrack()

bool XFEMMaterialStateMarkerBase::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 in XFEMRankTwoTensorMarkerUserObject, and XFEMMaterialTensorMarkerUserObject.

Definition at line 167 of file XFEMMaterialStateMarkerBase.C.

 {
   direction(1) = 1.0;
   return true;
 }

Referenced by execute().

◆ execute()

void XFEMMaterialStateMarkerBase::execute ( )

overridevirtual

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

overridevirtual

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

overridevirtual

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 )

overridevirtual

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