#include <XFEMCutElem3D.h>

Inheritance diagram for XFEMCutElem3D:

Public Member Functions
	XFEMCutElem3D (Elem elem, const EFAElement3D const CEMelem, unsigned int n_qpoints, unsigned int n_sides)
	Constructor initializes XFEMCutElem3D object.

	~XFEMCutElem3D ()

virtual void	computePhysicalVolumeFraction ()
	Computes the volume fraction of the element fragment.

virtual void	computePhysicalFaceAreaFraction (unsigned int side)
	Computes the surface area fraction of the element side.

virtual void	computeMomentFittingWeights ()

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

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

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

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

virtual const EFAElement *	getEFAElement () const

virtual unsigned int	numCutPlanes () const

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

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

Real	getPhysicalVolumeFraction () const
	Returns the volume fraction of the element fragment.

Real	getPhysicalFaceAreaFraction (unsigned int side) const
	Returns the surface area fraction of the element side.

Real	getMomentFittingWeight (unsigned int i_qp) const

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.

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.

bool	isPointPhysical (const Point &p) const

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

std::vector< std::vector< Real > >	_new_face_weights
	face quadrature weights from surface area fraction

Private Member Functions
virtual Point	getNodeCoordinates (EFANode node, MeshBase displaced_mesh=nullptr) const

Private Attributes
EFAElement3D	_efa_elem3d

Detailed Description

Definition at line 24 of file XFEMCutElem3D.h.

Constructor & Destructor Documentation

◆ XFEMCutElem3D()

XFEMCutElem3D::XFEMCutElem3D	(	Elem *	elem,
		const EFAElement3D *const	CEMelem,
		unsigned int	n_qpoints,
		unsigned int	n_sides
	)

Constructor initializes XFEMCutElem3D object.

Parameters

elem	The element on which XFEMCutElem3D is built
CEMelem	The EFAFragment3D object that belongs to XFEMCutElem3D
n_qpoints	The number of quadrature points
n_sides	The number of sides which the element has

Definition at line 23 of file XFEMCutElem3D.C.

  : XFEMCutElem(elem, n_qpoints, n_sides), _efa_elem3d(CEMelem, true)
{
  computePhysicalVolumeFraction();
  computeMomentFittingWeights();
}

◆ ~XFEMCutElem3D()

XFEMCutElem3D::~XFEMCutElem3D ( )

Definition at line 33 of file XFEMCutElem3D.C.

33{}

Member Function Documentation

◆ computeMomentFittingWeights()

void XFEMCutElem3D::computeMomentFittingWeights ( )

virtual

Implements XFEMCutElem.

Definition at line 152 of file XFEMCutElem3D.C.

{
  // TODO: 3D moment fitting method nod coded yet - use volume fraction for now
  _new_weights.resize(_n_qpoints, _physical_volfrac);
}

Referenced by XFEMCutElem3D().

◆ computePhysicalFaceAreaFraction()

void XFEMCutElem3D::computePhysicalFaceAreaFraction ( unsigned int side )

virtual

Computes the surface area fraction of the element side.

Parameters

side	The side of the element

find a fragment surface which is covered by element side

Implements XFEMCutElem.

Definition at line 108 of file XFEMCutElem3D.C.

{
  Real frag_surf = 0.0;
 
  std::vector<std::vector<unsigned int>> frag_face_indices;
  std::vector<EFANode *> frag_nodes;
  _efa_elem3d.getFragment(0)->getNodeInfo(frag_face_indices, frag_nodes);
  int face_num = frag_face_indices.size();
 
  EFAFace * efa_face = _efa_elem3d.getFace(side);
  bool contains_all = true;
 
  for (int i = 0; i < face_num; ++i)
  {
    contains_all = true;
    for (unsigned int j = 0; j < frag_face_indices[i].size(); ++j)
    {
      EFANode * efa_node = frag_nodes[frag_face_indices[i][j]];
      if (!efa_face->containsNode(efa_node))
      {
        contains_all = false;
        break;
      }
    }
 
    if (contains_all)
    {
      for (unsigned int j = 0; j < frag_face_indices[i].size(); ++j)
      {
        unsigned int m = ((j + 1) == frag_face_indices[i].size()) ? 0 : j + 1;
        Point edge_p1 = getNodeCoordinates(frag_nodes[frag_face_indices[i][j]]);
        Point edge_p2 = getNodeCoordinates(frag_nodes[frag_face_indices[i][m]]);
 
        frag_surf += 0.5 * (edge_p1(0) - edge_p2(0)) * (edge_p1(1) + edge_p2(1));
      }
      _physical_areafrac[side] = std::abs(frag_surf) / _elem_side_area[side];
      return;
    }
  }
  _physical_areafrac[side] = 1.0;
}

◆ computePhysicalVolumeFraction()

void XFEMCutElem3D::computePhysicalVolumeFraction ( )

virtual

Computes the volume fraction of the element fragment.

Implements XFEMCutElem.

Definition at line 63 of file XFEMCutElem3D.C.

{
  Real frag_vol = 0.0;
 
  // collect fragment info needed by polyhedron_volume_3d()
  std::vector<std::vector<unsigned int>> frag_face_indices;
  std::vector<EFANode *> frag_nodes;
  _efa_elem3d.getFragment(0)->getNodeInfo(frag_face_indices, frag_nodes);
  int face_num = frag_face_indices.size();
  int node_num = frag_nodes.size();
 
  int order_max = 0;
  int * order = new int[face_num];
  for (int i = 0; i < face_num; ++i)
  {
    if (frag_face_indices[i].size() > (unsigned int)order_max)
      order_max = frag_face_indices[i].size();
    order[i] = frag_face_indices[i].size();
  }
 
  double * coord = new double[3 * node_num];
  for (unsigned int i = 0; i < frag_nodes.size(); ++i)
  {
    Point p = getNodeCoordinates(frag_nodes[i]);
    coord[3 * i + 0] = p(0);
    coord[3 * i + 1] = p(1);
    coord[3 * i + 2] = p(2);
  }
 
  int * node = new int[face_num * order_max];
  Xfem::i4vec_zero(face_num * order_max, node);
  for (int i = 0; i < face_num; ++i)
    for (unsigned int j = 0; j < frag_face_indices[i].size(); ++j)
      node[order_max * i + j] = frag_face_indices[i][j];
 
  // compute fragment volume and volume fraction
  frag_vol = Xfem::polyhedron_volume_3d(coord, order_max, face_num, node, node_num, order);
  _physical_volfrac = frag_vol / _elem_volume;
 
  delete[] order;
  delete[] coord;
  delete[] node;
}

Referenced by XFEMCutElem3D().

◆ computeXFEMFaceWeights()

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

inherited

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.

{
  _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;
}

Referenced by XFEMCutElem::getFaceWeightMultipliers().

◆ computeXFEMWeights()

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

inherited

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.

{
  _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;
}

Referenced by XFEMCutElem::getWeightMultipliers().

◆ getCrackTipOriginAndDirection()

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

virtual

Implements XFEMCutElem.

Definition at line 232 of file XFEMCutElem3D.C.

{
  // TODO: not implemented for 3D
  mooseError("getCrackTipOriginAndDirection not yet implemented for XFEMCutElem3D");
}

◆ getCutPlaneNormal()

Point XFEMCutElem3D::getCutPlaneNormal	(	unsigned int	plane_id,
		MeshBase *	displaced_mesh = `nullptr`
	)		const

virtual

Implements XFEMCutElem.

Definition at line 190 of file XFEMCutElem3D.C.

{
  Point normal(0.0, 0.0, 0.0);
  std::vector<std::vector<EFANode *>> cut_plane_nodes;
  for (unsigned int i = 0; i < _efa_elem3d.getFragment(0)->numFaces(); ++i)
  {
    if (_efa_elem3d.getFragment(0)->isFaceInterior(i))
    {
      EFAFace * face = _efa_elem3d.getFragment(0)->getFace(i);
      std::vector<EFANode *> node_line;
      for (unsigned int j = 0; j < face->numNodes(); ++j)
        node_line.push_back(face->getNode(j));
      cut_plane_nodes.push_back(node_line);
    }
  }
  if (cut_plane_nodes.size() == 0)
    mooseError("no cut plane found in this element");
  if (plane_id < cut_plane_nodes.size()) // valid plane_id
  {
    std::vector<Point> cut_plane_points;
    for (unsigned int i = 0; i < cut_plane_nodes[plane_id].size(); ++i)
      cut_plane_points.push_back(getNodeCoordinates(cut_plane_nodes[plane_id][i], displaced_mesh));
 
    Point center(0.0, 0.0, 0.0);
    for (unsigned int i = 0; i < cut_plane_points.size(); ++i)
      center += cut_plane_points[i];
    center /= cut_plane_points.size();
 
    for (unsigned int i = 0; i < cut_plane_points.size(); ++i)
    {
      unsigned int iplus1 = i < cut_plane_points.size() - 1 ? i + 1 : 0;
      Point ray1 = cut_plane_points[i] - center;
      Point ray2 = cut_plane_points[iplus1] - center;
      normal += ray1.cross(ray2);
    }
    normal /= cut_plane_points.size();
  }
  Xfem::normalizePoint(normal);
  return normal;
}

Referenced by getIntersectionInfo().

◆ getCutPlaneOrigin()

Point XFEMCutElem3D::getCutPlaneOrigin	(	unsigned int	plane_id,
		MeshBase *	displaced_mesh = `nullptr`
	)		const

virtual

Implements XFEMCutElem.

Definition at line 159 of file XFEMCutElem3D.C.

{
  Point orig(0.0, 0.0, 0.0);
  std::vector<std::vector<EFANode *>> cut_plane_nodes;
  for (unsigned int i = 0; i < _efa_elem3d.getFragment(0)->numFaces(); ++i)
  {
    if (_efa_elem3d.getFragment(0)->isFaceInterior(i))
    {
      EFAFace * face = _efa_elem3d.getFragment(0)->getFace(i);
      std::vector<EFANode *> node_line;
      for (unsigned int j = 0; j < face->numNodes(); ++j)
        node_line.push_back(face->getNode(j));
      cut_plane_nodes.push_back(node_line);
    }
  }
  if (cut_plane_nodes.size() == 0)
    mooseError("no cut plane found in this element");
  if (plane_id < cut_plane_nodes.size()) // valid plane_id
  {
    std::vector<Point> cut_plane_points;
    for (unsigned int i = 0; i < cut_plane_nodes[plane_id].size(); ++i)
      cut_plane_points.push_back(getNodeCoordinates(cut_plane_nodes[plane_id][i], displaced_mesh));
 
    for (unsigned int i = 0; i < cut_plane_points.size(); ++i)
      orig += cut_plane_points[i];
    orig /= cut_plane_points.size();
  }
  return orig;
}

◆ getEFAElement()

const EFAElement * XFEMCutElem3D::getEFAElement ( ) const

virtual

Implements XFEMCutElem.

Definition at line 249 of file XFEMCutElem3D.C.

{
  return &_efa_elem3d;
}

◆ getFaceWeightMultipliers()

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

inherited

Definition at line 77 of file XFEMCutElem.C.

{
  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];
}

Referenced by XFEM::getXFEMFaceWeights().

◆ getFragmentFaces()

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

virtual

Implements XFEMCutElem.

Definition at line 241 of file XFEMCutElem3D.C.

{
  // TODO: not implemented for 3D
  mooseError("getFragmentFaces not yet implemented for XFEMCutElem3D");
}

◆ getIntersectionInfo()

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

virtual

Implements XFEMCutElem.

Definition at line 265 of file XFEMCutElem3D.C.

{
  intersectionPoints.clear();
  std::vector<std::vector<EFANode *>> cut_plane_nodes;
  for (unsigned int i = 0; i < _efa_elem3d.getFragment(0)->numFaces(); ++i)
  {
    if (_efa_elem3d.getFragment(0)->isFaceInterior(i))
    {
      EFAFace * face = _efa_elem3d.getFragment(0)->getFace(i);
      std::vector<EFANode *> node_line;
      for (unsigned int j = 0; j < face->numNodes(); ++j)
        node_line.push_back(face->getNode(j));
      cut_plane_nodes.push_back(node_line);
    }
  }
  if (cut_plane_nodes.size() == 0)
    mooseError("No cut plane found in this element");
 
  if (plane_id < cut_plane_nodes.size()) // valid plane_id
  {
    intersectionPoints.resize(cut_plane_nodes[plane_id].size());
    for (unsigned int i = 0; i < cut_plane_nodes[plane_id].size(); ++i)
      intersectionPoints[i] = getNodeCoordinates(cut_plane_nodes[plane_id][i], displaced_mesh);
  }
 
  normal = getCutPlaneNormal(plane_id, displaced_mesh);
}

◆ getMomentFittingWeight()

Real XFEMCutElem::getMomentFittingWeight ( unsigned int i_qp ) const

inherited

◆ getNodeCoordinates()

Point XFEMCutElem3D::getNodeCoordinates	(	EFANode *	node,
		MeshBase *	displaced_mesh = `nullptr`
	)		const

privatevirtual

Implements XFEMCutElem.

Definition at line 36 of file XFEMCutElem3D.C.

{
  Point node_coor(0.0, 0.0, 0.0);
  std::vector<EFANode *> master_nodes;
  std::vector<Point> master_points;
  std::vector<double> master_weights;
 
  _efa_elem3d.getMasterInfo(CEMnode, master_nodes, master_weights);
  for (unsigned int i = 0; i < master_nodes.size(); ++i)
  {
    if (master_nodes[i]->category() == EFANode::N_CATEGORY_LOCAL_INDEX)
    {
      Node * node = _nodes[master_nodes[i]->id()];
      if (displaced_mesh)
        node = displaced_mesh->node_ptr(node->id());
      Point node_p((*node)(0), (*node)(1), (*node)(2));
      master_points.push_back(node_p);
    }
    else
      mooseError("master nodes must be local");
  }
  for (unsigned int i = 0; i < master_nodes.size(); ++i)
    node_coor += master_weights[i] * master_points[i];
  return node_coor;
}

Referenced by computePhysicalFaceAreaFraction(), computePhysicalVolumeFraction(), getCutPlaneNormal(), getCutPlaneOrigin(), and getIntersectionInfo().

◆ getPhysicalFaceAreaFraction()

Real XFEMCutElem::getPhysicalFaceAreaFraction ( unsigned int side ) const

inherited

Returns the surface area fraction of the element side.

Parameters

side	The side of the element

Definition at line 57 of file XFEMCutElem.C.

{
  return _physical_areafrac[side];
}

Referenced by XFEMCutElem::computeXFEMFaceWeights().

◆ getPhysicalVolumeFraction()

Real XFEMCutElem::getPhysicalVolumeFraction ( ) const

inherited

Returns the volume fraction of the element fragment.

Definition at line 51 of file XFEMCutElem.C.

{
  return _physical_volfrac;
}

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

◆ getWeightMultipliers()

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

inherited

Definition at line 63 of file XFEMCutElem.C.

{
  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];
}

Referenced by XFEM::getXFEMWeights().

◆ isPointPhysical()

bool XFEMCutElem::isPointPhysical ( const Point & p ) const

inherited

Definition at line 193 of file XFEMCutElem.C.

{
  // 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;
}

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

◆ numCutPlanes()

unsigned int XFEMCutElem3D::numCutPlanes ( ) const

virtual

Implements XFEMCutElem.

Definition at line 255 of file XFEMCutElem3D.C.

{
  unsigned int counter = 0;
  for (unsigned int i = 0; i < _efa_elem3d.getFragment(0)->numFaces(); ++i)
    if (_efa_elem3d.getFragment(0)->isFaceInterior(i))
      counter += 1;
  return counter;
}

◆ setQuadraturePointsAndWeights()

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

inherited

Member Data Documentation

◆ _efa_elem3d

EFAElement3D XFEMCutElem3D::_efa_elem3d

private

Definition at line 41 of file XFEMCutElem3D.h.

Referenced by computePhysicalFaceAreaFraction(), computePhysicalVolumeFraction(), getCutPlaneNormal(), getCutPlaneOrigin(), getEFAElement(), getIntersectionInfo(), getNodeCoordinates(), and numCutPlanes().

◆ _elem_side_area

std::vector<Real> XFEMCutElem::_elem_side_area

protectedinherited

Definition at line 49 of file XFEMCutElem.h.

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

◆ _elem_volume

Real XFEMCutElem::_elem_volume

protectedinherited

Definition at line 48 of file XFEMCutElem.h.

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

◆ _have_face_weights

std::vector<bool> XFEMCutElem::_have_face_weights

protectedinherited

Definition at line 53 of file XFEMCutElem.h.

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

◆ _have_weights

bool XFEMCutElem::_have_weights

protectedinherited

Definition at line 52 of file XFEMCutElem.h.

Referenced by XFEMCutElem::computeXFEMWeights(), and XFEMCutElem::getWeightMultipliers().

◆ _n_nodes

unsigned int XFEMCutElem::_n_nodes

protectedinherited

Definition at line 42 of file XFEMCutElem.h.

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

◆ _n_qpoints

unsigned int XFEMCutElem::_n_qpoints

protectedinherited

Definition at line 43 of file XFEMCutElem.h.

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

◆ _n_sides

unsigned int XFEMCutElem::_n_sides

protectedinherited

Definition at line 44 of file XFEMCutElem.h.

Referenced by XFEMCutElem::XFEMCutElem().

◆ _new_face_weights

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

protectedinherited

face quadrature weights from surface area fraction

Definition at line 57 of file XFEMCutElem.h.

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

◆ _new_weights

std::vector<Real> XFEMCutElem::_new_weights

protectedinherited

quadrature weights from volume fraction and moment fitting

Definition at line 55 of file XFEMCutElem.h.

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

◆ _nodes

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

protectedinherited

Definition at line 45 of file XFEMCutElem.h.

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

◆ _physical_areafrac

std::vector<Real> XFEMCutElem::_physical_areafrac

protectedinherited

Definition at line 51 of file XFEMCutElem.h.

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

◆ _physical_volfrac

Real XFEMCutElem::_physical_volfrac

protectedinherited

Definition at line 50 of file XFEMCutElem.h.

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

◆ _qp_points

std::vector<Point> XFEMCutElem::_qp_points

protectedinherited

Definition at line 46 of file XFEMCutElem.h.

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

◆ _qp_weights

std::vector<Real> XFEMCutElem::_qp_weights

protectedinherited

Definition at line 47 of file XFEMCutElem.h.

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

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

xfem/include/base/XFEMCutElem3D.h
xfem/src/base/XFEMCutElem3D.C

Public Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ XFEMCutElem3D()

◆ ~XFEMCutElem3D()

Member Function Documentation

◆ computeMomentFittingWeights()

◆ computePhysicalFaceAreaFraction()

◆ computePhysicalVolumeFraction()

◆ computeXFEMFaceWeights()

◆ computeXFEMWeights()

◆ getCrackTipOriginAndDirection()

◆ getCutPlaneNormal()

◆ getCutPlaneOrigin()

◆ getEFAElement()

◆ getFaceWeightMultipliers()

◆ getFragmentFaces()

◆ getIntersectionInfo()

◆ getMomentFittingWeight()

◆ getNodeCoordinates()

◆ getPhysicalFaceAreaFraction()

◆ getPhysicalVolumeFraction()

◆ getWeightMultipliers()

◆ isPointPhysical()

◆ numCutPlanes()

◆ setQuadraturePointsAndWeights()

Member Data Documentation

◆ _efa_elem3d

◆ _elem_side_area

◆ _elem_volume

◆ _have_face_weights

◆ _have_weights

◆ _n_nodes

◆ _n_qpoints

◆ _n_sides

◆ _new_face_weights

◆ _new_weights

◆ _nodes

◆ _physical_areafrac

◆ _physical_volfrac

◆ _qp_points

◆ _qp_weights