#include <EFAFace.h>

Public Member Functions
	EFAFace (unsigned int n_nodes, unsigned int num_interior_face_nodes=0)

	EFAFace (const EFAFace &other_face)

	EFAFace (const EFAFragment2D *frag)

	~EFAFace ()

unsigned int	numNodes () const

void	setNode (unsigned int node_id, EFANode *node)

EFANode *	getNode (unsigned int node_id) const

void	switchNode (EFANode new_node, EFANode old_node)

bool	getMasterInfo (EFANode node, std::vector< EFANode > &master_nodes, std::vector< double > &master_weights) const

bool	getEdgeNodeParametricCoords (EFANode *node, std::vector< double > &xi_2d) const

bool	getFaceNodeParametricCoords (EFANode *node, std::vector< double > &xi_2d) const

unsigned int	numInteriorNodes () const

void	createNodes ()

unsigned int	numEdges () const

EFAEdge *	getEdge (unsigned int edge_id) const

void	setEdge (unsigned int edge_id, EFAEdge *new_edge)

void	createEdges ()

void	combineTwoEdges (unsigned int edge_id1, unsigned int edge_id2)

void	sortEdges ()

void	reverseEdges ()

bool	isTriOrQuad () const

EFANode *	getInteriorFaceNode (unsigned int i) const

void	setInteriorFaceNode (unsigned int i, EFANode *node)

bool	equivalent (const EFAFace *other_face) const

bool	containsNode (const EFANode *node) const

bool	containsFace (const EFAFace *other_face) const

bool	ownsEdge (const EFAEdge *other_edge) const

void	removeEmbeddedNode (EFANode *emb_node)

std::vector< EFAFace * >	split () const

EFAFace *	combineWithFace (const EFAFace *other_face) const

void	resetEdgeIntersection (const EFAFace *ref_face)

unsigned int	getNumCuts () const

bool	hasIntersection () const

void	copyIntersection (const EFAFace &from_face)

bool	isAdjacent (const EFAFace *other_face) const

unsigned int	adjacentCommonEdge (const EFAFace *other_face) const

bool	hasSameOrientation (const EFAFace *other_face) const

EFAFaceNode *	getInteriorNode (unsigned int index) const

Private Member Functions
void	mapParametricCoordsFrom1DTo2D (unsigned int edge_id, double xi_1d, std::vector< double > &xi_2d) const

Private Attributes
unsigned int	_num_nodes

std::vector< EFANode * >	_nodes

unsigned int	_num_edges

std::vector< EFAEdge * >	_edges

std::vector< EFAFaceNode * >	_interior_nodes

std::vector< EFANode * >	_face_interior_nodes

Detailed Description

Definition at line 19 of file EFAFace.h.

Constructor & Destructor Documentation

◆ EFAFace() [1/3]

EFAFace::EFAFace	(	unsigned int	n_nodes,
		unsigned int	num_interior_face_nodes = `0`
	)

Definition at line 19 of file EFAFace.C.

Referenced by combineWithFace(), and split().

   : _num_nodes(n_nodes),
     _nodes(_num_nodes, nullptr),
     _num_edges(_num_nodes),
     _edges(_num_edges, nullptr),
     _face_interior_nodes(num_interior_face_nodes, nullptr)
 {
 }

◆ EFAFace() [2/3]

EFAFace::EFAFace ( const EFAFace & other_face )

Definition at line 28 of file EFAFace.C.

   : _num_nodes(other_face._num_nodes),
     _nodes(_num_nodes, nullptr),
     _num_edges(_num_nodes),
     _edges(_num_edges, nullptr)
 {
   for (unsigned int k = 0; k < other_face._num_nodes; ++k)
   {
     _nodes[k] = other_face._nodes[k];
     _edges[k] = new EFAEdge(*other_face._edges[k]);
   }
   for (unsigned int k = 0; k < other_face._interior_nodes.size(); ++k)
     _interior_nodes.push_back(new EFAFaceNode(*other_face._interior_nodes[k]));
 }

◆ EFAFace() [3/3]

EFAFace::EFAFace ( const EFAFragment2D * frag )

Definition at line 43 of file EFAFace.C.

   : _num_nodes(frag->numEdges()),
     _nodes(_num_nodes, nullptr),
     _num_edges(_num_nodes),
     _edges(_num_edges, nullptr)
 {
   for (unsigned int k = 0; k < frag->numEdges(); ++k)
   {
     EFANode * node = frag->getEdge(k)->getNode(0);
     unsigned int kprev(k > 0 ? (k - 1) : (frag->numEdges() - 1));
     if (!frag->getEdge(kprev)->containsNode(node))
       node = getEdge(k)->getNode(1);
     _nodes[k] = node;
     _edges[k] = new EFAEdge(*frag->getEdge(k));
   }
 }

◆ ~EFAFace()

EFAFace::~EFAFace ( )

Definition at line 60 of file EFAFace.C.

 {
   for (unsigned int i = 0; i < _edges.size(); ++i)
   {
     if (_edges[i])
     {
       delete _edges[i];
       _edges[i] = nullptr;
     }
   }
   for (unsigned int i = 0; i < _interior_nodes.size(); ++i)
   {
     if (_interior_nodes[i])
     {
       delete _interior_nodes[i];
       _interior_nodes[i] = nullptr;
     }
   }
 }

Member Function Documentation

◆ adjacentCommonEdge()

unsigned int EFAFace::adjacentCommonEdge ( const EFAFace * other_face ) const

Definition at line 603 of file EFAFace.C.

Referenced by EFAElement3D::addFaceEdgeCut(), EFAFragment3D::combine_two_faces(), and combineWithFace().

 {
   if (isAdjacent(other_face))
   {
     for (unsigned int i = 0; i < _num_edges; ++i)
       if (other_face->ownsEdge(_edges[i]))
         return i;
   }
   EFAError("this face is not adjacent with other_face");
 }

◆ combineTwoEdges()

void EFAFace::combineTwoEdges	(	unsigned int	edge_id1,
		unsigned int	edge_id2
	)

Definition at line 276 of file EFAFace.C.

Referenced by EFAFragment3D::combine_two_faces().

 {
   if (_edges[edge_id1]->containsNode(_edges[edge_id2]->getNode(0)) ||
       _edges[edge_id1]->containsNode(_edges[edge_id2]->getNode(1)))
   {
     // edge_id1 must precede edge_id2
     unsigned int edge1_next(edge_id1 < (_num_edges - 1) ? edge_id1 + 1 : 0);
     if (edge1_next != edge_id2) // if not, swap
     {
       unsigned int itmp = edge_id1;
       edge_id1 = edge_id2;
       edge_id2 = itmp;
     }
 
     // build new edge and delete old ones
     EFANode * new_node1 = _edges[edge_id1]->getNode(0);
     EFANode * emb_node = _edges[edge_id1]->getNode(1);
     EFANode * new_node2 = _edges[edge_id2]->getNode(1);
     if (emb_node != _edges[edge_id2]->getNode(0))
       EFAError("in combine_two_edges face edges are not correctly set up");
 
     EFAEdge * full_edge = new EFAEdge(new_node1, new_node2);
     full_edge->addIntersection(-1.0, emb_node, new_node1); // dummy intersection_x
 
     delete _edges[edge_id1];
     delete _edges[edge_id2];
     _edges[edge_id1] = full_edge;
     _edges.erase(_edges.begin() + edge_id2);
 
     // update face memeber variables
     _num_edges -= 1;
     _num_nodes -= 1;
     _nodes.resize(_num_nodes, nullptr);
     for (unsigned int k = 0; k < _num_edges; ++k)
       _nodes[k] = _edges[k]->getNode(0);
   }
   else
     EFAError("two edges to be combined are not ajacent to each other");
 }

◆ combineWithFace()

EFAFace * EFAFace::combineWithFace ( const EFAFace * other_face ) const

Definition at line 449 of file EFAFace.C.

 {
   // combine this face with another adjacent face
   EFAFace * new_face = nullptr;
   if (isAdjacent(other_face))
   {
     unsigned int this_common_edge_id = adjacentCommonEdge(other_face);
     std::vector<EFANode *> common_nodes;
     common_nodes.push_back(_edges[this_common_edge_id]->getNode(0));
     common_nodes.push_back(_edges[this_common_edge_id]->getNode(1));
 
     unsigned int other_common_edge_id = other_face->adjacentCommonEdge(this);
     unsigned int new_n_nodes = _num_edges + other_face->_num_edges - 4;
     EFAFragment2D * new_frag = new EFAFragment2D(nullptr, false, nullptr); // temp fragment
 
     unsigned int this_edge_id0(this_common_edge_id > 0 ? this_common_edge_id - 1
                                                        : _num_edges - 1); // common_nodes[0]
     unsigned int this_edge_id1(this_common_edge_id < (_num_edges - 1) ? this_common_edge_id + 1
                                                                       : 0); // common_nodes[1]
     unsigned int other_edge_id0(
         other_common_edge_id < (other_face->_num_edges - 1) ? other_common_edge_id + 1 : 0);
     unsigned int other_edge_id1(other_common_edge_id > 0 ? other_common_edge_id - 1
                                                          : other_face->_num_edges - 1);
 
     EFAEdge * new_edge0 = new EFAEdge(_edges[this_edge_id0]->getNode(0),
                                       other_face->_edges[other_edge_id0]->getNode(1));
     new_edge0->addIntersection(
         -1.0, common_nodes[0], new_edge0->getNode(0)); // dummy intersection_x
     new_frag->addEdge(new_edge0);                      // common_nodes[0]'s edge
 
     unsigned int other_iedge(other_edge_id0 < (other_face->_num_edges - 1) ? other_edge_id0 + 1
                                                                            : 0);
     while (!other_face->_edges[other_iedge]->equivalent(*other_face->_edges[other_edge_id1]))
     {
       new_frag->addEdge(new EFAEdge(*other_face->_edges[other_iedge]));
       other_iedge += 1;
       if (other_iedge == other_face->_num_edges)
         other_iedge = 0;
     } // loop over other_face's edges
 
     EFAEdge * new_edge1 = new EFAEdge(other_face->_edges[other_edge_id1]->getNode(0),
                                       _edges[this_edge_id1]->getNode(1));
     new_edge1->addIntersection(
         -1.0, common_nodes[1], new_edge1->getNode(0)); // dummy intersection_x
     new_frag->addEdge(new_edge1);
 
     unsigned int this_iedge(this_edge_id1 < (_num_edges - 1) ? this_edge_id1 + 1 : 0);
     while (!_edges[this_iedge]->equivalent(*_edges[this_edge_id0])) // common_nodes[1]'s edge
     {
       new_frag->addEdge(new EFAEdge(*_edges[this_iedge]));
       this_iedge += 1;
       if (this_iedge == _num_edges)
         this_iedge = 0;
     } // loop over this_face's edges
 
     new_face = new EFAFace(new_frag);
     delete new_frag;
     if (new_face->numNodes() != new_n_nodes)
       EFAError("combine_with() sanity check fails");
   }
   return new_face;
 }

◆ containsFace()

bool EFAFace::containsFace ( const EFAFace * other_face ) const

Definition at line 376 of file EFAFace.C.

Referenced by EFAFragment3D::combine_tip_faces(), and EFAFragment3D::isFaceInterior().

 {
   unsigned int counter = 0;
   for (unsigned int i = 0; i < other_face->_num_nodes; ++i)
   {
     if (containsNode(other_face->_nodes[i]))
       counter += 1;
   }
   if (counter == other_face->_num_nodes)
     return true;
   else
     return false;
 }

◆ containsNode()

bool EFAFace::containsNode ( const EFANode * node ) const

Definition at line 362 of file EFAFace.C.

Referenced by combineTwoEdges(), XFEMCutElem3D::computePhysicalFaceAreaFraction(), containsFace(), getEdgeNodeParametricCoords(), getMasterInfo(), and sortEdges().

 {
   for (unsigned int i = 0; i < _num_edges; ++i)
     if (_edges[i]->containsNode(node))
       return true;
 
   for (unsigned int i = 0; i < _interior_nodes.size(); ++i)
     if (_interior_nodes[i]->getNode() == node)
       return true;
 
   return false;
 }

◆ copyIntersection()

void EFAFace::copyIntersection ( const EFAFace & from_face )

Definition at line 577 of file EFAFace.C.

 {
   for (unsigned int i = 0; i < _edges.size(); ++i)
     if (from_face._edges[i]->hasIntersection())
       _edges[i]->copyIntersection(*from_face._edges[i], 0);
 
   if (from_face.numInteriorNodes() > 0)
     _interior_nodes = from_face._interior_nodes;
 }

◆ createEdges()

void EFAFace::createEdges ( )

Definition at line 260 of file EFAFace.C.

 {
   for (unsigned int i = 0; i < _num_nodes; ++i)
   {
     unsigned int i_plus1(i < (_num_nodes - 1) ? i + 1 : 0);
     if (_nodes[i] != nullptr && _nodes[i_plus1] != nullptr)
     {
       EFAEdge * new_edge = new EFAEdge(_nodes[i], _nodes[i_plus1]);
       _edges[i] = new_edge;
     }
     else
       EFAError("EFAface::createEdges requires exsiting _nodes");
   }
 }

◆ createNodes()

void EFAFace::createNodes ( )

Definition at line 242 of file EFAFace.C.

Referenced by EFAFragment3D::connectSubfaces().

 {
   for (unsigned int i = 0; i < _edges.size(); ++i)
   {
     if (_edges[i] != nullptr)
       _nodes[i] = _edges[i]->getNode(0);
     else
       EFAError("in EFAface::createNodes() _edges[i] does not exist");
   }
 }

◆ equivalent()

bool EFAFace::equivalent ( const EFAFace * other_face ) const

Definition at line 355 of file EFAFace.C.

Referenced by combineWithFace(), hasSameOrientation(), ownsEdge(), EFAElement3D::shouldDuplicateForPhantomCorner(), and sortEdges().

 {
   return std::is_permutation(
       _nodes.begin(), _nodes.end(), other_face->_nodes.begin(), other_face->_nodes.end());
 }

◆ getEdge()

EFAEdge* EFAFace::getEdge ( unsigned int edge_id ) const

inline

Definition at line 50 of file EFAFace.h.

Referenced by EFAElement3D::addFaceEdgeCut(), EFAElement3D::checkNeighborFaceCut(), EFAFace(), EFAFragment2D::EFAFragment2D(), EFAElement3D::getFragmentFaceEdgeID(), EFAElement3D::getNeighborEdgeIndex(), EFAElement3D::getNeighborFaceEdgeID(), and EFAElement3D::isPhysicalEdgeCut().

50 { return _edges[edge_id]; }

EFAFace::_edges

std::vector< EFAEdge * > _edges

Definition: EFAFace.h:32

◆ getEdgeNodeParametricCoords()

bool EFAFace::getEdgeNodeParametricCoords	(	EFANode *	node,
		std::vector< double > &	xi_2d
	)		const

Definition at line 183 of file EFAFace.C.

Referenced by getFaceNodeParametricCoords().

 {
   // get the parametric coords of a node in an edge
   bool edge_found = false;
   unsigned int edge_id;
   if (!isTriOrQuad())
     EFAError("EFAface::getEdgeNodeParaCoor can only work for quad or tri faces");
 
   for (unsigned int i = 0; i < _num_edges; ++i)
   {
     if (_edges[i]->containsNode(node))
     {
       edge_id = i;
       edge_found = true;
       break;
     }
   }
   if (edge_found)
   {
     double rel_dist = _edges[edge_id]->distanceFromNode1(node);
     double xi_1d = 2.0 * rel_dist - 1.0; // translate to [-1,1] parent coord syst
     mapParametricCoordsFrom1DTo2D(edge_id, xi_1d, xi_2d);
   }
   return edge_found;
 }

◆ getFaceNodeParametricCoords()

bool EFAFace::getFaceNodeParametricCoords	(	EFANode *	node,
		std::vector< double > &	xi_2d
	)		const

Definition at line 210 of file EFAFace.C.

Referenced by resetEdgeIntersection().

 {
   bool node_in_face = false;
   if (!isTriOrQuad())
     EFAError("EFAface::getFaceNodeParaCoor can only work for quad or tri faces");
 
   if (getEdgeNodeParametricCoords(node, xi_2d))
     node_in_face = true;
   else
   {
     for (unsigned int i = 0; i < _interior_nodes.size(); ++i)
     {
       if (_interior_nodes[i]->getNode() == node)
       {
         xi_2d.resize(2, 0.0);
         xi_2d[0] = _interior_nodes[i]->getParametricCoordinates(0);
         xi_2d[1] = _interior_nodes[i]->getParametricCoordinates(1);
         node_in_face = true;
         break;
       }
     } // i
   }
   return node_in_face;
 }

◆ getInteriorFaceNode()

EFANode* EFAFace::getInteriorFaceNode ( unsigned int i ) const

inline

Definition at line 58 of file EFAFace.h.

Referenced by EFAElement3D::connectNeighbors(), and EFAElement3D::getNeighborFaceInteriorNodeID().

58 { return _face_interior_nodes[i]; };

EFAFace::_face_interior_nodes

std::vector< EFANode * > _face_interior_nodes

Definition: EFAFace.h:34

◆ getInteriorNode()

EFAFaceNode * EFAFace::getInteriorNode ( unsigned int index ) const

Definition at line 641 of file EFAFace.C.

 {
   return _interior_nodes[index];
 }

◆ getMasterInfo()

bool EFAFace::getMasterInfo	(	EFANode *	node,
		std::vector< EFANode *> &	master_nodes,
		std::vector< double > &	master_weights
	)		const

Definition at line 132 of file EFAFace.C.

 {
   // Given a EFAnode, find the element edge or fragment edge that contains it
   // Return its master nodes and weights
   master_nodes.clear();
   master_weights.clear();
   bool masters_found = false;
   for (unsigned int i = 0; i < _num_edges; ++i) // check element exterior edges
   {
     if (_edges[i]->containsNode(node))
     {
       masters_found = _edges[i]->getNodeMasters(node, master_nodes, master_weights);
       if (masters_found)
         break;
       else
         EFAError("In getMasterInfo: cannot find master nodes in element edges");
     }
   }
 
   if (!masters_found) // check element interior embedded nodes
   {
     for (unsigned int i = 0; i < _interior_nodes.size(); ++i)
     {
       if (_interior_nodes[i]->getNode() == node)
       {
         std::vector<double> emb_xi(2, 0.0);
         emb_xi[0] = _interior_nodes[i]->getParametricCoordinates(0);
         emb_xi[1] = _interior_nodes[i]->getParametricCoordinates(1);
         for (unsigned int j = 0; j < _num_nodes; ++j)
         {
           master_nodes.push_back(_nodes[j]);
           double weight = 0.0;
           if (_num_nodes == 4)
             weight = Efa::linearQuadShape2D(j, emb_xi);
           else if (_num_nodes == 3)
             weight = Efa::linearTriShape2D(j, emb_xi);
           else
             EFAError("EFAface::getMasterInfo() only works for quad and tri EFAface");
           master_weights.push_back(weight);
         }
         masters_found = true;
         break;
       }
     }
   }
   return masters_found;
 }

◆ getNode()

EFANode * EFAFace::getNode ( unsigned int node_id ) const

Definition at line 99 of file EFAFace.C.

Referenced by combineTwoEdges(), combineWithFace(), EFAElement3D::connectNeighbors(), containsNode(), EFAElement3D::createChild(), XFEMCutElem3D::getCutPlaneNormal(), XFEMCutElem3D::getCutPlaneOrigin(), getFaceNodeParametricCoords(), XFEM::getFragmentFaces(), XFEMCutElem3D::getIntersectionInfo(), getMasterInfo(), EFAElement3D::getNeighborFaceNodeID(), and removeEmbeddedNode().

 {
   return _nodes[node_id];
 }

◆ getNumCuts()

unsigned int EFAFace::getNumCuts ( ) const

Definition at line 556 of file EFAFace.C.

Referenced by hasIntersection(), and split().

 {
   unsigned int num_cuts = 0;
   for (unsigned int i = 0; i < _edges.size(); ++i)
   {
     if (_edges[i]->hasIntersection())
       num_cuts += _edges[i]->numEmbeddedNodes();
   }
   return num_cuts;
 }

◆ hasIntersection()

bool EFAFace::hasIntersection ( ) const

Definition at line 568 of file EFAFace.C.

Referenced by EFAElement3D::fragmentFaceAlreadyCut(), getNumCuts(), and resetEdgeIntersection().

 {
   if (getNumCuts() > 1)
     return true;
   else
     return false;
 }

◆ hasSameOrientation()

bool EFAFace::hasSameOrientation ( const EFAFace * other_face ) const

Definition at line 615 of file EFAFace.C.

Referenced by EFAElement3D::overlaysElement().

 {
   bool same_order = false;
   if (equivalent(other_face))
   {
     for (unsigned int i = 0; i < other_face->numNodes(); ++i)
     {
       if (other_face->_nodes[i] == _nodes[0])
       {
         unsigned int iplus1(i < (other_face->_num_nodes - 1) ? i + 1 : 0);
         if (other_face->_nodes[iplus1] == _nodes[1])
         {
           same_order = true;
           break;
         }
         else if (other_face->_nodes[iplus1] != _nodes[_num_nodes - 1])
           EFAError("two faces overlap but can't find correct common nodes");
       }
     }
   }
   else
     EFAWarning("in hasSameOrientation two faces does not overlap");
   return same_order;
 }

◆ isAdjacent()

bool EFAFace::isAdjacent ( const EFAFace * other_face ) const

Definition at line 588 of file EFAFace.C.

Referenced by adjacentCommonEdge(), and combineWithFace().

 {
   // two faces are adjacent if they only share one common edge
   unsigned int counter = 0;
   for (unsigned int i = 0; i < _num_edges; ++i)
     if (other_face->ownsEdge(_edges[i]))
       counter += 1;
 
   if (counter == 1)
     return true;
   else
     return false;
 }

◆ isTriOrQuad()

bool EFAFace::isTriOrQuad ( ) const

Definition at line 346 of file EFAFace.C.

Referenced by getEdgeNodeParametricCoords(), and getFaceNodeParametricCoords().

 {
   if (_num_edges == 3 || _num_edges == 4)
     return true;
   else
     return false;
 }

◆ mapParametricCoordsFrom1DTo2D()

void EFAFace::mapParametricCoordsFrom1DTo2D	(	unsigned int	edge_id,
		double	xi_1d,
		std::vector< double > &	xi_2d
	)		const

private

Definition at line 647 of file EFAFace.C.

Referenced by getEdgeNodeParametricCoords().

 {
   // given the 1D parent coord of a point in an 2D element edge, translate it to 2D para coords
   xi_2d.resize(2, 0.0);
   if (_num_edges == 4)
   {
     if (edge_id == 0)
     {
       xi_2d[0] = xi_1d;
       xi_2d[1] = -1.0;
     }
     else if (edge_id == 1)
     {
       xi_2d[0] = 1.0;
       xi_2d[1] = xi_1d;
     }
     else if (edge_id == 2)
     {
       xi_2d[0] = -xi_1d;
       xi_2d[1] = 1.0;
     }
     else if (edge_id == 3)
     {
       xi_2d[0] = -1.0;
       xi_2d[1] = -xi_1d;
     }
     else
       EFAError("edge_id out of bounds");
   }
   else if (_num_edges == 3)
   {
     if (edge_id == 0)
     {
       xi_2d[0] = 0.5 * (1.0 - xi_1d);
       xi_2d[1] = 0.5 * (1.0 + xi_1d);
     }
     else if (edge_id == 1)
     {
       xi_2d[0] = 0.0;
       xi_2d[1] = 0.5 * (1.0 - xi_1d);
     }
     else if (edge_id == 2)
     {
       xi_2d[0] = 0.5 * (1.0 + xi_1d);
       xi_2d[1] = 0.0;
     }
     else
       EFAError("edge_id out of bounds");
   }
   else
     EFAError("the EFAface::mapParametricCoordsFrom1DTo2D only works for quad and tri faces");
 }

◆ numEdges()

unsigned int EFAFace::numEdges ( ) const

inline

Definition at line 49 of file EFAFace.h.

Referenced by EFAFragment2D::EFAFragment2D(), EFAElement3D::getFragmentFaceEdgeID(), EFAElement3D::getNeighborEdgeIndex(), and EFAElement3D::getNeighborFaceEdgeID().

49 { return _edges.size(); }

EFAFace::_edges

std::vector< EFAEdge * > _edges

Definition: EFAFace.h:32

◆ numInteriorNodes()

unsigned int EFAFace::numInteriorNodes ( ) const

Definition at line 236 of file EFAFace.C.

Referenced by copyIntersection().

 {
   return _interior_nodes.size();
 }

◆ numNodes()

unsigned int EFAFace::numNodes ( ) const

Definition at line 87 of file EFAFace.C.

Referenced by combineWithFace(), EFAElement3D::createChild(), XFEMCutElem3D::getCutPlaneNormal(), XFEMCutElem3D::getCutPlaneOrigin(), XFEM::getFragmentFaces(), XFEMCutElem3D::getIntersectionInfo(), EFAElement3D::getNeighborFaceNodeID(), and hasSameOrientation().

 {
   return _nodes.size();
 }

◆ ownsEdge()

bool EFAFace::ownsEdge ( const EFAEdge * other_edge ) const

Definition at line 391 of file EFAFace.C.

Referenced by adjacentCommonEdge(), and isAdjacent().

 {
   for (unsigned int i = 0; i < _edges.size(); ++i)
     if (_edges[i]->equivalent(*other_edge))
       return true;
   return false;
 }

◆ removeEmbeddedNode()

void EFAFace::removeEmbeddedNode ( EFANode * emb_node )

Definition at line 400 of file EFAFace.C.

 {
   for (unsigned int i = 0; i < _num_edges; ++i)
     _edges[i]->removeEmbeddedNode(emb_node);
 
   unsigned int index = 0;
   bool node_found = false;
   for (unsigned int i = 0; i < _interior_nodes.size(); ++i)
   {
     if (_interior_nodes[i]->getNode() == emb_node)
     {
       node_found = true;
       index = i;
       break;
     }
   }
   if (node_found)
   {
     delete _interior_nodes[index];
     _interior_nodes.erase(_interior_nodes.begin() + index);
   }
 }

◆ resetEdgeIntersection()

void EFAFace::resetEdgeIntersection ( const EFAFace * ref_face )

Definition at line 513 of file EFAFace.C.

Referenced by EFAFragment3D::combine_two_faces().

 {
   // set up correct edge intersections based on the reference face
   // the reference face must contain the edge of this face that is to be set up
   // the reference face must be an element face
   for (unsigned int j = 0; j < _num_edges; ++j)
   {
     if (_edges[j]->hasIntersection())
     {
       if (_edges[j]->numEmbeddedNodes() > 1)
         EFAError("frag face edge can only have 1 emb node at this point");
 
       EFANode * edge_node1 = _edges[j]->getNode(0);
       EFANode * edge_node2 = _edges[j]->getNode(1);
       EFANode * emb_node = _edges[j]->getEmbeddedNode(0);
       double inters_x = _edges[j]->getIntersection(0, edge_node1);
       if (std::abs(inters_x + 1.0) < 1.0e-4) // invalid intersection found
       {
         std::vector<double> node1_xi2d(2, 0.0);
         std::vector<double> node2_xi2d(2, 0.0);
         std::vector<double> emb_xi2d(2, 0.0);
         if (ref_face->getFaceNodeParametricCoords(edge_node1, node1_xi2d) &&
             ref_face->getFaceNodeParametricCoords(edge_node2, node2_xi2d) &&
             ref_face->getFaceNodeParametricCoords(emb_node, emb_xi2d))
         {
           // TODO: this is not correct for unstructured elements. Need a fix
           double dist2node1 =
               std::sqrt((emb_xi2d[0] - node1_xi2d[0]) * (emb_xi2d[0] - node1_xi2d[0]) +
                         (emb_xi2d[1] - node1_xi2d[1]) * (emb_xi2d[1] - node1_xi2d[1]));
           double full_dist =
               std::sqrt((node2_xi2d[0] - node1_xi2d[0]) * (node2_xi2d[0] - node1_xi2d[0]) +
                         (node2_xi2d[1] - node1_xi2d[1]) * (node2_xi2d[1] - node1_xi2d[1]));
           inters_x = dist2node1 / full_dist;
         }
         else
           EFAError("reference face does not contain the edge with invalid inters");
         _edges[j]->resetIntersection(inters_x, emb_node, edge_node1);
       }
     }
   }
 }

◆ reverseEdges()

void EFAFace::reverseEdges ( )

Definition at line 337 of file EFAFace.C.

Referenced by EFAFragment3D::connectSubfaces().

 {
   // reverse the orientation of the face
   for (unsigned int i = 0; i < _edges.size(); ++i)
     _edges[i]->reverseNodes();
   std::reverse(_edges.begin(), _edges.end());
 }

◆ setEdge()

void EFAFace::setEdge	(	unsigned int	edge_id,
		EFAEdge *	new_edge
	)

Definition at line 254 of file EFAFace.C.

Referenced by EFAFragment3D::connectSubfaces().

 {
   _edges[edge_id] = new_edge;
 }

◆ setInteriorFaceNode()

void EFAFace::setInteriorFaceNode	(	unsigned int	i,
		EFANode *	node
	)

Definition at line 81 of file EFAFace.C.

 {
   _face_interior_nodes[i] = node;
 }

◆ setNode()

void EFAFace::setNode	(	unsigned int	node_id,
		EFANode *	node
	)

Definition at line 93 of file EFAFace.C.

 {
   _nodes[node_id] = node;
 }

◆ sortEdges()

void EFAFace::sortEdges ( )

Definition at line 317 of file EFAFace.C.

Referenced by EFAFragment3D::connectSubfaces().

 {
   std::vector<EFAEdge *> ordered_edges(_num_edges, nullptr);
   ordered_edges[0] = _edges[0];
   for (unsigned int i = 1; i < _num_edges; ++i)
   {
     EFAEdge * last_edge = ordered_edges[i - 1];
     for (unsigned int j = 0; j < _num_edges; ++j)
     {
       if (!_edges[j]->equivalent(*last_edge) && _edges[j]->containsNode(last_edge->getNode(1)))
       {
         ordered_edges[i] = _edges[j];
         break;
       }
     } // j
   }   // i
   _edges = ordered_edges;
 }

◆ split()

std::vector< EFAFace * > EFAFace::split ( ) const

Definition at line 424 of file EFAFace.C.

 {
   std::vector<EFAFace *> new_faces;
   if (getNumCuts() > 0)
   {
     // construct a fragment from this face
     EFAFragment2D * frag_tmp = new EFAFragment2D(nullptr, this);
     std::vector<EFAFragment2D *> new_frags_tmp = frag_tmp->split();
 
     // copy new_frags to new_faces
     for (unsigned int i = 0; i < new_frags_tmp.size(); ++i)
       new_faces.push_back(new EFAFace(new_frags_tmp[i]));
 
     // delete frag_tmp and new_frags
     delete frag_tmp;
     for (unsigned int i = 0; i < new_frags_tmp.size(); ++i)
       delete new_frags_tmp[i];
   }
   else
     new_faces.push_back(new EFAFace(*this));
 
   return new_faces;
 }

◆ switchNode()

void EFAFace::switchNode	(	EFANode *	new_node,
		EFANode *	old_node
	)

Definition at line 105 of file EFAFace.C.

 {
   bool is_face_node = true;
   for (unsigned int i = 0; i < _num_nodes; ++i)
   {
     if (_nodes[i] == old_node)
     {
       _nodes[i] = new_node;
       is_face_node = false;
     }
   }
   if (is_face_node)
   {
     for (unsigned int i = 0; i < _face_interior_nodes.size(); ++i)
       if (_face_interior_nodes[i] == old_node)
         _face_interior_nodes[i] = new_node;
   }
   else
   {
     for (unsigned int i = 0; i < _edges.size(); ++i)
       _edges[i]->switchNode(new_node, old_node);
     for (unsigned int i = 0; i < _interior_nodes.size(); ++i)
       _interior_nodes[i]->switchNode(new_node, old_node);
   }
 }

Member Data Documentation

◆ _edges

std::vector<EFAEdge *> EFAFace::_edges

private

Definition at line 32 of file EFAFace.h.

Referenced by adjacentCommonEdge(), combineTwoEdges(), combineWithFace(), containsNode(), copyIntersection(), createEdges(), createNodes(), EFAFace(), getEdge(), getEdgeNodeParametricCoords(), getMasterInfo(), getNumCuts(), isAdjacent(), numEdges(), ownsEdge(), removeEmbeddedNode(), resetEdgeIntersection(), reverseEdges(), setEdge(), sortEdges(), switchNode(), and ~EFAFace().

◆ _face_interior_nodes

std::vector<EFANode *> EFAFace::_face_interior_nodes

private

Definition at line 34 of file EFAFace.h.

Referenced by getInteriorFaceNode(), setInteriorFaceNode(), and switchNode().

◆ _interior_nodes

std::vector<EFAFaceNode *> EFAFace::_interior_nodes

private

Definition at line 33 of file EFAFace.h.

Referenced by containsNode(), copyIntersection(), EFAFace(), getFaceNodeParametricCoords(), getInteriorNode(), getMasterInfo(), numInteriorNodes(), removeEmbeddedNode(), switchNode(), and ~EFAFace().

◆ _nodes

std::vector<EFANode *> EFAFace::_nodes

private

Definition at line 30 of file EFAFace.h.

Referenced by combineTwoEdges(), containsFace(), createEdges(), createNodes(), EFAFace(), equivalent(), getMasterInfo(), getNode(), hasSameOrientation(), numNodes(), setNode(), and switchNode().

◆ _num_edges

unsigned int EFAFace::_num_edges

private

Definition at line 31 of file EFAFace.h.

Referenced by adjacentCommonEdge(), combineTwoEdges(), combineWithFace(), containsNode(), getEdgeNodeParametricCoords(), getMasterInfo(), isAdjacent(), isTriOrQuad(), mapParametricCoordsFrom1DTo2D(), removeEmbeddedNode(), resetEdgeIntersection(), and sortEdges().

◆ _num_nodes

unsigned int EFAFace::_num_nodes

private

Definition at line 29 of file EFAFace.h.

Referenced by combineTwoEdges(), containsFace(), createEdges(), EFAFace(), getMasterInfo(), hasSameOrientation(), and switchNode().

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

xfem/include/efa/EFAFace.h
xfem/src/efa/EFAFace.C

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ EFAFace() [1/3]

◆ EFAFace() [2/3]

◆ EFAFace() [3/3]

◆ ~EFAFace()

Member Function Documentation

◆ adjacentCommonEdge()

◆ combineTwoEdges()

◆ combineWithFace()

◆ containsFace()

◆ containsNode()

◆ copyIntersection()

◆ createEdges()

◆ createNodes()

◆ equivalent()

◆ getEdge()

◆ getEdgeNodeParametricCoords()

◆ getFaceNodeParametricCoords()

◆ getInteriorFaceNode()

◆ getInteriorNode()

◆ getMasterInfo()

◆ getNode()

◆ getNumCuts()

◆ hasIntersection()

◆ hasSameOrientation()

◆ isAdjacent()

◆ isTriOrQuad()

◆ mapParametricCoordsFrom1DTo2D()

◆ numEdges()

◆ numInteriorNodes()

◆ numNodes()

◆ ownsEdge()

◆ removeEmbeddedNode()

◆ resetEdgeIntersection()

◆ reverseEdges()

◆ setEdge()

◆ setInteriorFaceNode()

◆ setNode()

◆ sortEdges()

◆ split()

◆ switchNode()

Member Data Documentation

◆ _edges

◆ _face_interior_nodes

◆ _interior_nodes

◆ _nodes

◆ _num_edges

◆ _num_nodes