XFEMCutElem Class Reference

#include <XFEMCutElem.h>

Inheritance diagram for XFEMCutElem:

Public Member Functions
	XFEMCutElem (Elem *elem, unsigned int n_qpoints, unsigned int n_sides)
	Constructor initializes XFEMCutElem object. More...
virtual	~XFEMCutElem ()
void	setQuadraturePointsAndWeights (const std::vector< Point > &qp_points, const std::vector< Real > &qp_weights)
virtual void	computePhysicalVolumeFraction ()=0
	Computes the volume fraction of the element fragment. More...
Real	getPhysicalVolumeFraction () const
	Returns the volume fraction of the element fragment. More...
virtual void	computePhysicalFaceAreaFraction (unsigned int side)=0
	Computes the surface area fraction of the element side. More...
Real	getPhysicalFaceAreaFraction (unsigned int side) const
	Returns the surface area fraction of the element side. More...
virtual void	computeMomentFittingWeights ()=0
Real	getMomentFittingWeight (unsigned int i_qp) const
virtual Point	getCutPlaneOrigin (unsigned int plane_id, MeshBase *displaced_mesh=nullptr) const =0
virtual Point	getCutPlaneNormal (unsigned int plane_id, MeshBase *displaced_mesh=nullptr) const =0
virtual void	getCrackTipOriginAndDirection (unsigned tip_id, Point &origin, Point &direction) const =0
virtual void	getFragmentFaces (std::vector< std::vector< Point >> &frag_faces, MeshBase *displaced_mesh=nullptr) const =0
virtual const EFAElement *	getEFAElement () const =0
virtual unsigned int	numCutPlanes () const =0
void	getWeightMultipliers (MooseArray< Real > &weights, QBase *qrule, Xfem::XFEM_QRULE xfem_qrule, const MooseArray< Point > &q_points)
void	getFaceWeightMultipliers (MooseArray< Real > &face_weights, QBase *qrule, Xfem::XFEM_QRULE xfem_qrule, const MooseArray< Point > &q_points, unsigned int side)
void	computeXFEMWeights (QBase *qrule, Xfem::XFEM_QRULE xfem_qrule, const MooseArray< Point > &q_points)
	Computes integration weights for the cut element. More...
void	computeXFEMFaceWeights (QBase *qrule, Xfem::XFEM_QRULE xfem_qrule, const MooseArray< Point > &q_points, unsigned int side)
	Computes face integration weights for the cut element side. More...
bool	isPointPhysical (const Point &p) const
virtual void	getIntersectionInfo (unsigned int plane_id, Point &normal, std::vector< Point > &intersectionPoints, MeshBase *displaced_mesh=nullptr) const =0

Protected Member Functions
virtual Point	getNodeCoordinates (EFANode *node, MeshBase *displaced_mesh=nullptr) const =0

Protected Attributes
unsigned int	_n_nodes
unsigned int	_n_qpoints
unsigned int	_n_sides
std::vector< Node * >	_nodes
std::vector< Point >	_qp_points
std::vector< Real >	_qp_weights
Real	_elem_volume
std::vector< Real >	_elem_side_area
Real	_physical_volfrac
std::vector< Real >	_physical_areafrac
bool	_have_weights
std::vector< bool >	_have_face_weights
std::vector< Real >	_new_weights
	quadrature weights from volume fraction and moment fitting More...
std::vector< std::vector< Real > >	_new_face_weights
	face quadrature weights from surface area fraction More...

Detailed Description

Definition at line 29 of file XFEMCutElem.h.

Constructor & Destructor Documentation

XFEMCutElem()

XFEMCutElem::XFEMCutElem	(	Elem *	elem,
		unsigned int	n_qpoints,
		unsigned int	n_sides
	)

Constructor initializes XFEMCutElem object.

Parameters

elem	The element on which XFEMCutElem is built
n_qpoints	The number of quadrature points
n_sides	The number of sides which the element has

Definition at line 22 of file XFEMCutElem.C.

  : _n_nodes(elem->n_nodes()),
    _n_qpoints(n_qpoints),
    _n_sides(n_sides),
    _nodes(_n_nodes, nullptr),
    _elem_side_area(n_sides),
    _physical_areafrac(n_sides),
    _have_weights(false),
    _have_face_weights(n_sides),
    _new_face_weights(n_sides)
{
  for (unsigned int i = 0; i < _n_nodes; ++i)
    _nodes[i] = elem->node_ptr(i);

  for (unsigned int i = 0; i < _n_sides; ++i)
  {
    _have_face_weights[i] = false;
    _physical_areafrac[i] = 1.0;
    // TODO: this line does not support RZ/RSpherical geoms
    _elem_side_area[i] = elem->side_ptr(i)->volume();
  }

  // TODO: this line does not support RZ/RSpherical geoms
  _elem_volume = elem->volume();
}

~XFEMCutElem()

XFEMCutElem::~XFEMCutElem ( )

virtual

Definition at line 48 of file XFEMCutElem.C.

{}

Member Function Documentation

computeMomentFittingWeights()

virtual void XFEMCutElem::computeMomentFittingWeights ( )

pure virtual

Implemented in XFEMCutElem2D, and XFEMCutElem3D.

Referenced by computeXFEMWeights().

computePhysicalFaceAreaFraction()

virtual void XFEMCutElem::computePhysicalFaceAreaFraction ( unsigned int  side )

pure virtual

Computes the surface area fraction of the element side.

Parameters

side	The side of the element

Implemented in XFEMCutElem2D, and XFEMCutElem3D.

Referenced by computeXFEMFaceWeights().

computePhysicalVolumeFraction()

virtual void XFEMCutElem::computePhysicalVolumeFraction ( )

pure virtual

Computes the volume fraction of the element fragment.

Implemented in XFEMCutElem2D, and XFEMCutElem3D.

Referenced by computeXFEMWeights(), and XFEM::getPhysicalVolumeFraction().

computeXFEMFaceWeights()

void XFEMCutElem::computeXFEMFaceWeights	(	QBase *	qrule,
		Xfem::XFEM_QRULE	xfem_qrule,
		const MooseArray< Point > &	q_points,
		unsigned int	side
	)

Computes face integration weights for the cut element side.

Parameters

qrule	The standard MOOSE face quadrature rule
xfem_qrule	The integration scheme for the cut element (We use surface area fraction only)
q_points	The quadrature points for the element side
side	The side of the element

Definition at line 92 of file XFEMCutElem.C.

Referenced by getFaceWeightMultipliers().

{
  _new_face_weights[side].clear();
  _new_face_weights[side].resize(qrule->n_points(), 1.0);

  computePhysicalFaceAreaFraction(side);
  Real surffrac = getPhysicalFaceAreaFraction(side);
  for (unsigned qp = 0; qp < qrule->n_points(); ++qp)
    _new_face_weights[side][qp] = surffrac;

  _have_face_weights[side] = true;
}

computeXFEMWeights()

void XFEMCutElem::computeXFEMWeights	(	QBase *	qrule,
		Xfem::XFEM_QRULE	xfem_qrule,
		const MooseArray< Point > &	q_points
	)

Computes integration weights for the cut element.

Parameters

qrule	The standard MOOSE quadrature rule
xfem_qrule	The integration scheme for the cut element
q_points	The quadrature points for the element

Definition at line 109 of file XFEMCutElem.C.

Referenced by getWeightMultipliers().

{
  _new_weights.clear();

  _new_weights.resize(qrule->n_points(), 1.0);

  switch (xfem_qrule)
  {
    case Xfem::VOLFRAC:
    {
      computePhysicalVolumeFraction();
      Real volfrac = getPhysicalVolumeFraction();
      for (unsigned qp = 0; qp < qrule->n_points(); ++qp)
        _new_weights[qp] = volfrac;
      break;
    }
    case Xfem::MOMENT_FITTING:
    {
      // These are the coordinates in parametric coordinates
      _qp_points = qrule->get_points();
      _qp_weights = qrule->get_weights();

      computeMomentFittingWeights();

      // Blend weights from moment fitting and volume fraction to avoid negative weights
      Real alpha = 1.0;
      if (*std::min_element(_new_weights.begin(), _new_weights.end()) < 0.0)
      {
        // One or more of the weights computed by moment fitting is negative.
        // Blend moment and volume fraction weights to keep them nonnegative.
        // Find the largest value of alpha that will keep all of the weights nonnegative.
        for (unsigned int i = 0; i < _n_qpoints; ++i)
        {
          const Real denominator = _physical_volfrac - _new_weights[i];
          if (denominator > 0.0) // Negative values would give a negative value for alpha, which
                                 // must be between 0 and 1.
          {
            const Real alpha_i = _physical_volfrac / denominator;
            if (alpha_i < alpha)
              alpha = alpha_i;
          }
        }
        for (unsigned int i = 0; i < _n_qpoints; ++i)
        {
          _new_weights[i] = alpha * _new_weights[i] + (1.0 - alpha) * _physical_volfrac;
          if (_new_weights[i] < 0.0) // We can end up with small (roundoff) negative weights
            _new_weights[i] = 0.0;
        }
      }
      break;
    }
    case Xfem::DIRECT: // remove q-points outside the partial element's physical domain
    {
      bool nonzero = false;
      for (unsigned qp = 0; qp < qrule->n_points(); ++qp)
      {
        // q_points contains quadrature point locations in physical coordinates
        if (isPointPhysical(q_points[qp]))
        {
          nonzero = true;
          _new_weights[qp] = 1.0;
        }
        else
          _new_weights[qp] = 0.0;
      }
      if (!nonzero)
      {
        // Set the weights to a small value (1e-3) to avoid having DOFs
        // with zeros on the diagonal, which occurs for nodes that are
        // connected to no physical material.
        for (unsigned qp = 0; qp < qrule->n_points(); ++qp)
          _new_weights[qp] = 1e-3;
      }
      break;
    }
    default:
      mooseError("Undefined option for XFEM_QRULE");
  }
  _have_weights = true;
}

getCrackTipOriginAndDirection()

virtual void XFEMCutElem::getCrackTipOriginAndDirection ( unsigned  tip_id, Point &  origin, Point &  direction  ) const

pure virtual

Implemented in XFEMCutElem2D, and XFEMCutElem3D.

Referenced by XFEM::storeCrackTipOriginAndDirection().

getCutPlaneNormal()

virtual Point XFEMCutElem::getCutPlaneNormal ( unsigned int  plane_id, MeshBase *  displaced_mesh = nullptr  ) const

pure virtual

Implemented in XFEMCutElem2D, and XFEMCutElem3D.

Referenced by XFEM::getCutPlane(), and isPointPhysical().

getCutPlaneOrigin()

virtual Point XFEMCutElem::getCutPlaneOrigin ( unsigned int  plane_id, MeshBase *  displaced_mesh = nullptr  ) const

pure virtual

Implemented in XFEMCutElem2D, and XFEMCutElem3D.

Referenced by XFEM::getCutPlane(), and isPointPhysical().

getEFAElement()

virtual const EFAElement* XFEMCutElem::getEFAElement ( ) const

pure virtual

Implemented in XFEMCutElem2D, and XFEMCutElem3D.

Referenced by XFEM::buildEFAMesh(), XFEM::getCutPlane(), XFEM::getPhysicalVolumeFraction(), XFEM::isElemCut(), and XFEM::storeCrackTipOriginAndDirection().

getFaceWeightMultipliers()

void XFEMCutElem::getFaceWeightMultipliers	(	MooseArray< Real > &	face_weights,
		QBase *	qrule,
		Xfem::XFEM_QRULE	xfem_qrule,
		const MooseArray< Point > &	q_points,
		unsigned int	side
	)

Definition at line 77 of file XFEMCutElem.C.

Referenced by XFEM::getXFEMFaceWeights().

{
  if (!_have_face_weights[side])
    computeXFEMFaceWeights(qrule, xfem_qrule, q_points, side);

  face_weights.resize(_new_face_weights[side].size());
  for (unsigned int qp = 0; qp < _new_face_weights[side].size(); ++qp)
    face_weights[qp] = _new_face_weights[side][qp];
}

getFragmentFaces()

virtual void XFEMCutElem::getFragmentFaces ( std::vector< std::vector< Point >> &  frag_faces, MeshBase *  displaced_mesh = nullptr  ) const

pure virtual

Implemented in XFEMCutElem2D, and XFEMCutElem3D.

Referenced by XFEM::getFragmentFaces().

getIntersectionInfo()

virtual void XFEMCutElem::getIntersectionInfo ( unsigned int  plane_id, Point &  normal, std::vector< Point > &  intersectionPoints, MeshBase *  displaced_mesh = nullptr  ) const

pure virtual

Implemented in XFEMCutElem2D, and XFEMCutElem3D.

Referenced by XFEM::getXFEMIntersectionInfo().

getMomentFittingWeight()

Real XFEMCutElem::getMomentFittingWeight

(

unsigned int

i_qp

)

const

getNodeCoordinates()

virtual Point XFEMCutElem::getNodeCoordinates ( EFANode *  node, MeshBase *  displaced_mesh = nullptr  ) const

protectedpure virtual

Implemented in XFEMCutElem2D, and XFEMCutElem3D.

getPhysicalFaceAreaFraction()

Real XFEMCutElem::getPhysicalFaceAreaFraction

(

unsigned int

side

)

const

Returns the surface area fraction of the element side.

Parameters

side	The side of the element

Definition at line 57 of file XFEMCutElem.C.

Referenced by computeXFEMFaceWeights().

{
  return _physical_areafrac[side];
}

getPhysicalVolumeFraction()

Real XFEMCutElem::getPhysicalVolumeFraction

(

)

const

Returns the volume fraction of the element fragment.

Definition at line 51 of file XFEMCutElem.C.

Referenced by computeXFEMWeights(), and XFEM::getPhysicalVolumeFraction().

{
  return _physical_volfrac;
}

getWeightMultipliers()

void XFEMCutElem::getWeightMultipliers	(	MooseArray< Real > &	weights,
		QBase *	qrule,
		Xfem::XFEM_QRULE	xfem_qrule,
		const MooseArray< Point > &	q_points
	)

Definition at line 63 of file XFEMCutElem.C.

Referenced by XFEM::getXFEMWeights().

{
  if (!_have_weights)
    computeXFEMWeights(qrule, xfem_qrule, q_points);

  weights.resize(_new_weights.size());
  for (unsigned int qp = 0; qp < _new_weights.size(); ++qp)
    weights[qp] = _new_weights[qp];
}

isPointPhysical()

bool XFEMCutElem::isPointPhysical

(

const Point &

p

)

const

Definition at line 193 of file XFEMCutElem.C.

Referenced by computeXFEMWeights(), XFEM::healMesh(), and XFEM::isPointInsidePhysicalDomain().

{
  // determine whether the point is inside the physical domain of a partial element
  bool physical_flag = true;
  unsigned int n_cut_planes = numCutPlanes();
  for (unsigned int plane_id = 0; plane_id < n_cut_planes; ++plane_id)
  {
    Point origin = getCutPlaneOrigin(plane_id);
    Point normal = getCutPlaneNormal(plane_id);
    Point origin2qp = p - origin;
    if (origin2qp * normal > 0.0)
    {
      physical_flag = false; // Point outside pysical domain
      break;
    }
  }
  return physical_flag;
}

numCutPlanes()

virtual unsigned int XFEMCutElem::numCutPlanes ( ) const

pure virtual

Implemented in XFEMCutElem2D, and XFEMCutElem3D.

Referenced by isPointPhysical().

setQuadraturePointsAndWeights()

void XFEMCutElem::setQuadraturePointsAndWeights	(	const std::vector< Point > &	qp_points,
		const std::vector< Real > &	qp_weights
	)

Member Data Documentation

_elem_side_area

std::vector<Real> XFEMCutElem::_elem_side_area

protected

Definition at line 49 of file XFEMCutElem.h.

Referenced by XFEMCutElem2D::computePhysicalFaceAreaFraction(), XFEMCutElem3D::computePhysicalFaceAreaFraction(), and XFEMCutElem().

_elem_volume

Real XFEMCutElem::_elem_volume

protected

Definition at line 48 of file XFEMCutElem.h.

Referenced by XFEMCutElem2D::computePhysicalVolumeFraction(), XFEMCutElem3D::computePhysicalVolumeFraction(), and XFEMCutElem().

_have_face_weights

std::vector<bool> XFEMCutElem::_have_face_weights

protected

Definition at line 53 of file XFEMCutElem.h.

Referenced by computeXFEMFaceWeights(), getFaceWeightMultipliers(), and XFEMCutElem().

_have_weights

bool XFEMCutElem::_have_weights

protected

Definition at line 52 of file XFEMCutElem.h.

Referenced by computeXFEMWeights(), and getWeightMultipliers().

_n_nodes

unsigned int XFEMCutElem::_n_nodes

protected

Definition at line 42 of file XFEMCutElem.h.

Referenced by XFEMCutElem2D::computeMomentFittingWeights(), and XFEMCutElem().

_n_qpoints

unsigned int XFEMCutElem::_n_qpoints

protected

Definition at line 43 of file XFEMCutElem.h.

Referenced by XFEMCutElem2D::computeMomentFittingWeights(), XFEMCutElem3D::computeMomentFittingWeights(), and computeXFEMWeights().

_n_sides

unsigned int XFEMCutElem::_n_sides

protected

Definition at line 44 of file XFEMCutElem.h.

Referenced by XFEMCutElem().

_new_face_weights

std::vector<std::vector<Real> > XFEMCutElem::_new_face_weights

protected

face quadrature weights from surface area fraction

Definition at line 57 of file XFEMCutElem.h.

Referenced by computeXFEMFaceWeights(), and getFaceWeightMultipliers().

_new_weights

std::vector<Real> XFEMCutElem::_new_weights

protected

quadrature weights from volume fraction and moment fitting

Definition at line 55 of file XFEMCutElem.h.

Referenced by XFEMCutElem2D::computeMomentFittingWeights(), XFEMCutElem3D::computeMomentFittingWeights(), computeXFEMWeights(), and getWeightMultipliers().

_nodes

std::vector<Node *> XFEMCutElem::_nodes

protected

Definition at line 45 of file XFEMCutElem.h.

Referenced by XFEMCutElem2D::computeMomentFittingWeights(), XFEMCutElem3D::getNodeCoordinates(), XFEMCutElem2D::getNodeCoordinates(), and XFEMCutElem().

_physical_areafrac

std::vector<Real> XFEMCutElem::_physical_areafrac

protected

Definition at line 51 of file XFEMCutElem.h.

Referenced by XFEMCutElem2D::computePhysicalFaceAreaFraction(), XFEMCutElem3D::computePhysicalFaceAreaFraction(), getPhysicalFaceAreaFraction(), and XFEMCutElem().

_physical_volfrac

Real XFEMCutElem::_physical_volfrac

protected

Definition at line 50 of file XFEMCutElem.h.

Referenced by XFEMCutElem2D::computeMomentFittingWeights(), XFEMCutElem3D::computeMomentFittingWeights(), XFEMCutElem3D::computePhysicalVolumeFraction(), XFEMCutElem2D::computePhysicalVolumeFraction(), computeXFEMWeights(), and getPhysicalVolumeFraction().

_qp_points

std::vector<Point> XFEMCutElem::_qp_points

protected

Definition at line 46 of file XFEMCutElem.h.

Referenced by computeXFEMWeights(), and XFEMCutElem2D::solveMomentFitting().

_qp_weights

std::vector<Real> XFEMCutElem::_qp_weights

protected

Definition at line 47 of file XFEMCutElem.h.

Referenced by computeXFEMWeights(), and XFEMCutElem2D::solveMomentFitting().

---

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

• xfem/include/base/XFEMCutElem.h
• xfem/src/base/XFEMCutElem.C