GeometricCutUserObject Class Reference

#include <GeometricCutUserObject.h>

Inheritance diagram for GeometricCutUserObject:

Public Member Functions
	GeometricCutUserObject (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
virtual bool	cutElementByGeometry (const Elem *elem, std::vector< Xfem::CutEdge > &cut_edges, std::vector< Xfem::CutNode > &cut_nodes, Real time) const =0
	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 =0
	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 =0
	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 =0
	Check to see whether a fragment of a 3D element should be cut based on geometric conditions. More...
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...
virtual const std::vector< Point >	getCrackFrontPoints (unsigned int) const =0
	get a set of points along a crack front from a XFEM GeometricCutUserObject More...

Static Public Member Functions
static InputParameters	validParams ()

Protected Member Functions
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::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

Detailed Description

Definition at line 106 of file GeometricCutUserObject.h.

Constructor & Destructor Documentation

GeometricCutUserObject()

GeometricCutUserObject::GeometricCutUserObject

(

const InputParameters &

parameters

)

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

Definition at line 39 of file GeometricCutUserObject.C.

  : CrackFrontPointsProvider(parameters), _heal_always(getParam<bool>("heal_always"))
{
  _xfem = MooseSharedNamespace::dynamic_pointer_cast<XFEM>(_fe_problem.getXFEM());
  if (_xfem == nullptr)
    mooseError("Problem casting to XFEM in GeometricCutUserObject");
 
  _xfem->addGeometricCut(this);
 
  auto new_xfem_epl = std::make_shared<XFEMElementPairLocator>(_xfem, _interface_id);
  _fe_problem.geomSearchData().addElementPairLocator(_interface_id, new_xfem_epl);
 
  if (_fe_problem.getDisplacedProblem() != NULL)
  {
    auto new_xfem_epl2 = std::make_shared<XFEMElementPairLocator>(_xfem, _interface_id, true);
    _fe_problem.getDisplacedProblem()->geomSearchData().addElementPairLocator(_interface_id,
                                                                              new_xfem_epl2);
  }
}

Member Function Documentation

cutElementByGeometry() [1/2]

virtual bool GeometricCutUserObject::cutElementByGeometry ( const Elem *  elem, std::vector< Xfem::CutEdge > &  cut_edges, std::vector< Xfem::CutNode > &  cut_nodes, Real  time  ) const

pure virtual

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

Implemented in MeshCut3DUserObject, GeometricCut3DUserObject, GeometricCut2DUserObject, and LevelSetCutUserObject.

Referenced by execute().

cutElementByGeometry() [2/2]

virtual bool GeometricCutUserObject::cutElementByGeometry ( const Elem *  elem, std::vector< Xfem::CutFace > &  cut_faces, Real  time  ) const

pure virtual

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

Implemented in MeshCut3DUserObject, GeometricCut3DUserObject, GeometricCut2DUserObject, and LevelSetCutUserObject.

cutFragmentByGeometry() [1/2]

virtual bool GeometricCutUserObject::cutFragmentByGeometry ( std::vector< std::vector< Point >> &  frag_edges, std::vector< Xfem::CutEdge > &  cut_edges, Real  time  ) const

pure virtual

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

Implemented in MeshCut3DUserObject, GeometricCut3DUserObject, GeometricCut2DUserObject, and LevelSetCutUserObject.

Referenced by execute().

cutFragmentByGeometry() [2/2]

virtual bool GeometricCutUserObject::cutFragmentByGeometry ( std::vector< std::vector< Point >> &  frag_faces, std::vector< Xfem::CutFace > &  cut_faces, Real  time  ) const

pure virtual

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

Implemented in MeshCut3DUserObject, GeometricCut3DUserObject, GeometricCut2DUserObject, and LevelSetCutUserObject.

deserialize()

void GeometricCutUserObject::deserialize ( std::vector< std::string > &  serialized_buffers )

protected

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

execute()

void GeometricCutUserObject::execute ( )

overridevirtual

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

overridevirtual

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

virtual const std::vector<Point> CrackFrontPointsProvider::getCrackFrontPoints ( unsigned int  ) const

pure virtualinherited

get a set of points along a crack front from a XFEM GeometricCutUserObject

Returns

A vector which contains all crack front points

Implemented in LevelSetCutUserObject, MeshCut3DUserObject, MovingLineSegmentCutSetUserObject, LineSegmentCutSetUserObject, CircleCutUserObject, EllipseCutUserObject, LineSegmentCutUserObject, and RectangleCutUserObject.

Referenced by CrackFrontDefinition::initialSetup().

getInterfaceID()

unsigned int GeometricCutUserObject::getInterfaceID ( ) const

inline

Get the interface ID for this cutting object.

Returns

the interface ID

Definition at line 172 of file GeometricCutUserObject.h.

{ return _interface_id; };

initialize()

void GeometricCutUserObject::initialize ( )

overridevirtual

Reimplemented in MeshCut3DUserObject, and MovingLineSegmentCutSetUserObject.

Definition at line 60 of file GeometricCutUserObject.C.

{
  _marked_elems_2d.clear();
  _marked_elems_3d.clear();
}

serialize()

void GeometricCutUserObject::serialize ( std::string &  serialized_buffer )

protected

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

setInterfaceID()

void GeometricCutUserObject::setInterfaceID ( unsigned int  interface_id )

inline

Set the interface ID for this cutting object.

Parameters

the	interface ID

Definition at line 178 of file GeometricCutUserObject.h.

{ _interface_id = interface_id; };

Referenced by XFEM::addGeometricCut().

shouldHealMesh()

bool GeometricCutUserObject::shouldHealMesh ( ) const

inline

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.

{ return _heal_always; };

threadJoin()

void GeometricCutUserObject::threadJoin ( const UserObject &  y )

overridevirtual

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

_heal_always

bool GeometricCutUserObject::_heal_always

protected

Heal the mesh.

Definition at line 195 of file GeometricCutUserObject.h.

_interface_id

unsigned int GeometricCutUserObject::_interface_id

protected

Associated interface id.

Definition at line 192 of file GeometricCutUserObject.h.

Referenced by finalize(), and GeometricCutUserObject().

_last_step_initialized

unsigned int GeometricCutUserObject::_last_step_initialized

protected

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

_marked_elems_2d

std::map<unsigned int, std::vector<Xfem::GeomMarkedElemInfo2D> > GeometricCutUserObject::_marked_elems_2d

protected

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 deserialize(), execute(), finalize(), initialize(), serialize(), and threadJoin().

_marked_elems_3d

std::map<unsigned int, std::vector<Xfem::GeomMarkedElemInfo3D> > GeometricCutUserObject::_marked_elems_3d

protected

Definition at line 202 of file GeometricCutUserObject.h.

Referenced by deserialize(), execute(), finalize(), initialize(), serialize(), and threadJoin().

_xfem

std::shared_ptr<XFEM> GeometricCutUserObject::_xfem

protected

Pointer to the XFEM controller object.

Definition at line 185 of file GeometricCutUserObject.h.

Referenced by execute(), finalize(), and GeometricCutUserObject().

---

The documentation for this class was generated from the following files:

• xfem/include/userobjects/GeometricCutUserObject.h
• xfem/src/userobjects/GeometricCutUserObject.C