#include <EFAElement2D.h>

Inheritance diagram for EFAElement2D:

Public Member Functions
	EFAElement2D (unsigned int eid, unsigned int n_nodes)

	EFAElement2D (const EFAElement2D *from_elem, bool convert_to_local)

	EFAElement2D (const EFAFace *from_face)

	~EFAElement2D ()

virtual unsigned int	numFragments () const

virtual bool	isPartial () const

virtual void	getNonPhysicalNodes (std::set< EFANode * > &non_physical_nodes) const

virtual void	switchNode (EFANode new_node, EFANode old_node, bool descend_to_parent)

virtual void	switchEmbeddedNode (EFANode new_node, EFANode old_node)

virtual void	updateFragmentNode ()

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

virtual unsigned int	numInteriorNodes () const

bool	overlaysElement (const EFAElement2D *other_elem) const

virtual unsigned int	getNeighborIndex (const EFAElement *neighbor_elem) const

virtual void	clearNeighbors ()

virtual void	setupNeighbors (std::map< EFANode , std::set< EFAElement >> &InverseConnectivityMap)

virtual void	neighborSanityCheck () const

virtual void	initCrackTip (std::set< EFAElement * > &CrackTipElements)

virtual bool	shouldDuplicateForCrackTip (const std::set< EFAElement * > &CrackTipElements)

virtual bool	shouldDuplicateCrackTipSplitElement (const std::set< EFAElement * > &CrackTipElements)

virtual bool	shouldDuplicateForPhantomCorner ()

virtual bool	willCrackTipExtend (std::vector< unsigned int > &split_neighbors) const

virtual bool	isCrackTipElement () const

virtual unsigned int	getNumCuts () const

virtual bool	isFinalCut () const

virtual void	updateFragments (const std::set< EFAElement * > &CrackTipElements, std::map< unsigned int, EFANode * > &EmbeddedNodes)

virtual void	fragmentSanityCheck (unsigned int n_old_frag_edges, unsigned int n_old_frag_cuts) const

virtual void	restoreFragment (const EFAElement *const from_elem)

virtual void	createChild (const std::set< EFAElement * > &CrackTipElements, std::map< unsigned int, EFAElement * > &Elements, std::map< unsigned int, EFAElement * > &newChildElements, std::vector< EFAElement * > &ChildElements, std::vector< EFAElement * > &ParentElements, std::map< unsigned int, EFANode * > &TempNodes)

virtual void	removePhantomEmbeddedNode ()

virtual void	connectNeighbors (std::map< unsigned int, EFANode * > &PermanentNodes, std::map< unsigned int, EFANode * > &TempNodes, std::map< EFANode , std::set< EFAElement >> &InverseConnectivityMap, bool merge_phantom_edges)

virtual void	printElement (std::ostream &ostream)

EFAFragment2D *	getFragment (unsigned int frag_id) const

std::set< EFANode * >	getEdgeNodes (unsigned int edge_id) const

bool	getEdgeNodeParametricCoordinate (EFANode *node, std::vector< double > &para_coor) const

EFAFaceNode *	getInteriorNode (unsigned int interior_node_id) const

void	deleteInteriorNodes ()

unsigned int	numEdges () const

void	setEdge (unsigned int edge_id, EFAEdge *edge)

void	createEdges ()

EFAEdge *	getEdge (unsigned int edge_id) const

EFAEdge *	getFragmentEdge (unsigned int frag_id, unsigned int edge_id) const

std::set< EFANode * >	getPhantomNodeOnEdge (unsigned int edge_id) const

bool	getFragmentEdgeID (unsigned int elem_edge_id, unsigned int &frag_edge_id) const

bool	isEdgePhantom (unsigned int edge_id) const

unsigned int	numEdgeNeighbors (unsigned int edge_id) const

EFAElement2D *	getEdgeNeighbor (unsigned int edge_id, unsigned int neighbor_id) const

unsigned int	getCrackTipSplitElementID () const

bool	fragmentHasTipEdges () const

unsigned int	getTipEdgeID () const

EFANode *	getTipEmbeddedNode () const

bool	edgeContainsTip (unsigned int edge_id) const

bool	fragmentEdgeAlreadyCut (unsigned int ElemEdgeID) const

void	addEdgeCut (unsigned int edge_id, double position, EFANode embedded_node, std::map< unsigned int, EFANode > &EmbeddedNodes, bool add_to_neighbor)

void	addNodeCut (unsigned int node_id, EFANode embedded_permanent_node, std::map< unsigned int, EFANode > &PermanentNodes, std::map< unsigned int, EFANode * > &EmbeddedPermanentNodes)

bool	addFragmentEdgeCut (unsigned int frag_edge_id, double position, std::map< unsigned int, EFANode * > &EmbeddedNodes)

std::vector< EFAFragment2D * >	branchingSplit (std::map< unsigned int, EFANode * > &EmbeddedNodes)

std::vector< EFANode * >	getCommonNodes (const EFAElement2D *other_elem) const

unsigned int	id () const

unsigned int	numNodes () const

void	setNode (unsigned int node_id, EFANode *node)

EFANode *	getNode (unsigned int node_id) const

bool	containsNode (EFANode *node) const

void	printNodes (std::ostream &ostream) const

EFANode *	createLocalNodeFromGlobalNode (const EFANode *global_node) const

EFANode *	getGlobalNodeFromLocalNode (const EFANode *local_node) const

unsigned int	getLocalNodeIndex (EFANode *node) const

void	setCrackTipSplit ()

bool	isCrackTipSplit () const

unsigned int	numCrackTipNeighbors () const

unsigned int	getCrackTipNeighbor (unsigned int index) const

void	addCrackTipNeighbor (EFAElement *neighbor_elem)

EFAElement *	getParent () const

EFAElement *	getChild (unsigned int child_id) const

void	setParent (EFAElement *parent)

unsigned int	numChildren () const

void	addChild (EFAElement *child)

void	clearParentAndChildren ()

void	findGeneralNeighbors (std::map< EFANode , std::set< EFAElement >> &InverseConnectivity)

EFAElement *	getGeneralNeighbor (unsigned int index) const

unsigned int	numGeneralNeighbors () const

Protected Member Functions
void	mergeNodes (EFANode &childNode, EFANode &childOfNeighborNode, EFAElement childOfNeighborElem, std::map< unsigned int, EFANode > &PermanentNodes, std::map< unsigned int, EFANode * > &TempNodes)

Protected Attributes
unsigned int	_id

unsigned int	_num_nodes

std::vector< EFANode * >	_nodes

std::vector< EFANode * >	_local_nodes

EFAElement *	_parent

std::vector< EFAElement * >	_children

bool	_crack_tip_split_element

std::vector< unsigned int >	_crack_tip_neighbors

std::vector< EFAElement * >	_general_neighbors

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

void	setLocalCoordinates ()

Private Attributes
unsigned int	_num_edges

std::vector< EFAEdge * >	_edges

std::vector< EFAFaceNode * >	_interior_nodes

std::vector< std::vector< EFAElement2D * > >	_edge_neighbors

std::vector< EFAFragment2D * >	_fragments

std::vector< EFAPoint >	_local_node_coor

Detailed Description

Definition at line 20 of file EFAElement2D.h.

Constructor & Destructor Documentation

◆ EFAElement2D() [1/3]

EFAElement2D::EFAElement2D	(	unsigned int	eid,
		unsigned int	n_nodes
	)

Definition at line 23 of file EFAElement2D.C.

                                                                  : EFAElement(eid, n_nodes)
 {
   if (n_nodes == 4 || n_nodes == 8 || n_nodes == 9)
     _num_edges = 4;
   else if (n_nodes == 3 || n_nodes == 6)
     _num_edges = 3;
   else
     EFAError("In EFAelement2D the supported element types are QUAD4, QUAD8, QUAD9, TRI3 and TRI6");
   setLocalCoordinates();
   _edges = std::vector<EFAEdge *>(_num_edges, NULL);
   _edge_neighbors =
       std::vector<std::vector<EFAElement2D *>>(_num_edges, std::vector<EFAElement2D *>(1, NULL));
 }

Referenced by createChild().

◆ EFAElement2D() [2/3]

EFAElement2D::EFAElement2D	(	const EFAElement2D *	from_elem,
		bool	convert_to_local
	)

Definition at line 37 of file EFAElement2D.C.

   : EFAElement(from_elem->_id, from_elem->_num_nodes),
     _num_edges(from_elem->_num_edges),
     _edges(_num_edges, NULL),
     _edge_neighbors(_num_edges, std::vector<EFAElement2D *>(1, NULL))
 {
   if (convert_to_local)
   {
     // build local nodes from global nodes
     for (unsigned int i = 0; i < _num_nodes; ++i)
     {
       if (from_elem->_nodes[i]->category() == EFANode::N_CATEGORY_PERMANENT ||
           from_elem->_nodes[i]->category() == EFANode::N_CATEGORY_TEMP ||
           from_elem->_nodes[i]->category() == EFANode::N_CATEGORY_EMBEDDED_PERMANENT)
       {
         _nodes[i] = from_elem->createLocalNodeFromGlobalNode(from_elem->_nodes[i]);
         _local_nodes.push_back(_nodes[i]); // convenient to delete local nodes
       }
       else
         EFAError("In EFAelement2D ",
                  from_elem->id(),
                  " the copy constructor must have from_elem w/ global nodes. node: ",
                  i,
                  " category: ",
                  from_elem->_nodes[i]->category());
     }
  
     // copy edges, fragments and interior nodes from from_elem
     for (unsigned int i = 0; i < _num_edges; ++i)
       _edges[i] = new EFAEdge(*from_elem->_edges[i]);
     for (unsigned int i = 0; i < from_elem->_fragments.size(); ++i)
       _fragments.push_back(new EFAFragment2D(this, true, from_elem, i));
     for (unsigned int i = 0; i < from_elem->_interior_nodes.size(); ++i)
       _interior_nodes.push_back(new EFAFaceNode(*from_elem->_interior_nodes[i]));
  
     // replace all global nodes with local nodes
     for (unsigned int i = 0; i < _num_nodes; ++i)
     {
       if (_nodes[i]->category() == EFANode::N_CATEGORY_LOCAL_INDEX)
         switchNode(
             _nodes[i],
             from_elem->_nodes[i],
             false); // when save to _cut_elem_map, the EFAelement is not a child of any parent
       else
         EFAError("In EFAelement2D copy constructor this elem's nodes must be local");
     }
  
     _local_node_coor = from_elem->_local_node_coor;
   }
   else
     EFAError("this EFAelement2D constructor only converts global nodes to local nodes");
 }

◆ EFAElement2D() [3/3]

EFAElement2D::EFAElement2D ( const EFAFace * from_face )

Definition at line 90 of file EFAElement2D.C.

   : EFAElement(0, from_face->numNodes()),
     _num_edges(from_face->numEdges()),
     _edges(_num_edges, NULL),
     _edge_neighbors(_num_edges, std::vector<EFAElement2D *>(1, NULL))
 {
   for (unsigned int i = 0; i < _num_nodes; ++i)
     _nodes[i] = from_face->getNode(i);
   for (unsigned int i = 0; i < _num_edges; ++i)
     _edges[i] = new EFAEdge(*from_face->getEdge(i));
   for (unsigned int i = 0; i < from_face->numInteriorNodes(); ++i)
     _interior_nodes.push_back(new EFAFaceNode(*from_face->getInteriorNode(i)));
 }

◆ ~EFAElement2D()

EFAElement2D::~EFAElement2D ( )

Definition at line 104 of file EFAElement2D.C.

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

Member Function Documentation

◆ addChild()

void EFAElement::addChild ( EFAElement * child )

inherited

Definition at line 203 of file EFAElement.C.

 {
   _children.push_back(child);
 }

◆ addCrackTipNeighbor()

void EFAElement::addCrackTipNeighbor ( EFAElement * neighbor_elem )

inherited

Definition at line 157 of file EFAElement.C.

 {
   // Find out what side the specified element is on, and add it as a crack tip neighbor
   // element for that side.
   unsigned int neighbor_index = getNeighborIndex(neighbor_elem);
   bool crack_tip_neighbor_exist = false;
   for (unsigned int i = 0; i < _crack_tip_neighbors.size(); ++i)
   {
     if (_crack_tip_neighbors[i] == neighbor_index)
     {
       crack_tip_neighbor_exist = true;
       break;
     }
   }
   if (!crack_tip_neighbor_exist)
     _crack_tip_neighbors.push_back(neighbor_index);
 }

◆ addEdgeCut()

void EFAElement2D::addEdgeCut	(	unsigned int	edge_id,
		double	position,
		EFANode *	embedded_node,
		std::map< unsigned int, EFANode * > &	EmbeddedNodes,
		bool	add_to_neighbor
	)

Definition at line 1710 of file EFAElement2D.C.

 {
   EFANode * local_embedded = NULL;
   EFANode * edge_node1 = _edges[edge_id]->getNode(0);
   if (embedded_node) // use the existing embedded node if it was passed in
     local_embedded = embedded_node;
  
   if (_edges[edge_id]->hasIntersectionAtPosition(position, edge_node1) && position > Xfem::tol &&
       position < 1.0 - Xfem::tol)
   {
     unsigned int emb_id = _edges[edge_id]->getEmbeddedNodeIndex(position, edge_node1);
     EFANode * old_emb = _edges[edge_id]->getEmbeddedNode(emb_id);
     if (embedded_node && embedded_node != old_emb)
     {
       EFAError("Attempting to add edge intersection when one already exists with different node.",
                " elem: ",
                _id,
                " edge: ",
                edge_id,
                " position: ",
                position);
     }
     local_embedded = old_emb;
   }
   else // if no cut exists at the input position
   {
     bool add2elem = true;
  
     // check if it is necessary to add cuts to fragment
     unsigned int frag_edge_id = 99999; // the id of the partially overlapping fragment edge
     EFAEdge * frag_edge = NULL;
     EFANode * frag_edge_node1 = NULL;
     double frag_pos = -1.0;
     bool add2frag = false;
  
     if (getFragmentEdgeID(edge_id, frag_edge_id)) // elem edge contains a frag edge
     {
       frag_edge = getFragmentEdge(0, frag_edge_id);
       if (!fragmentEdgeAlreadyCut(edge_id))
       {
         double xi[2] = {-1.0, -1.0}; // relative coords of two frag edge nodes
         xi[0] = _edges[edge_id]->distanceFromNode1(frag_edge->getNode(0));
         xi[1] = _edges[edge_id]->distanceFromNode1(frag_edge->getNode(1));
         if ((position - xi[0]) * (position - xi[1]) <
             0.0) // the cut to be added is within the real part of the edge
         {
           frag_edge_node1 = frag_edge->getNode(0);
           frag_pos = (position - xi[0]) / (xi[1] - xi[0]);
           add2frag = true;
         }
         else                // the emb node to be added is in the phantom part of the elem edge
           add2elem = false; // DO NOT ADD INTERSECT IN THIS CASE
       }
       else
       {
         EFAWarning("attempting to add new cut to a cut fragment edge");
         add2elem = false; // DO NOT ADD INTERSECT IN THIS CASE
       }
     }
  
     // If elem edge has 2 cuts but they have not been restored yet, it's OK because
     // getFragmentEdgeID = false so we won't add anything to the restored fragment.
     // add to elem edge (IMPORTANT to do it AFTER the above fragment check)
     if (add2elem)
     {
       if (!local_embedded) // need to create new embedded node
       {
         unsigned int new_node_id = Efa::getNewID(EmbeddedNodes);
         local_embedded = new EFANode(new_node_id, EFANode::N_CATEGORY_EMBEDDED);
         EmbeddedNodes.insert(std::make_pair(new_node_id, local_embedded));
       }
       _edges[edge_id]->addIntersection(position, local_embedded, edge_node1);
       if (_edges[edge_id]->numEmbeddedNodes() > 2)
         EFAError("element edge can't have >2 embedded nodes");
     }
  
     // add to frag edge
     if (add2frag)
     {
       frag_edge->addIntersection(frag_pos, local_embedded, frag_edge_node1);
       if (frag_edge->numEmbeddedNodes() > 1)
         EFAError("fragment edge can't have >1 embedded nodes");
     }
   } // IF the input embedded node already exists on this elem edge
  
   if (add_to_neighbor)
   {
     for (unsigned int en_iter = 0; en_iter < numEdgeNeighbors(edge_id); ++en_iter)
     {
       EFAElement2D * edge_neighbor = getEdgeNeighbor(edge_id, en_iter);
       unsigned int neighbor_edge_id = edge_neighbor->getNeighborIndex(this);
       if (edge_neighbor->getEdge(neighbor_edge_id)->getNode(0) == edge_node1) // same direction
         EFAError("neighbor edge has the same direction as this edge");
       double neigh_pos = 1.0 - position; // get emb node's postion on neighbor edge
       edge_neighbor->addEdgeCut(neighbor_edge_id, neigh_pos, local_embedded, EmbeddedNodes, false);
     }
   } // If add_to_neighbor required
 }

Referenced by addEdgeCut(), and ElementFragmentAlgorithm::addElemEdgeIntersection().

◆ addFragmentEdgeCut()

bool EFAElement2D::addFragmentEdgeCut	(	unsigned int	frag_edge_id,
		double	position,
		std::map< unsigned int, EFANode * > &	EmbeddedNodes
	)

Definition at line 1837 of file EFAElement2D.C.

 {
   if (_fragments.size() != 1)
     EFAError("Element: ", _id, " should have only 1 fragment in addFragEdgeIntersection");
   EFANode * local_embedded = NULL;
  
   // check if this intersection coincide with any embedded node on this edge
   bool isValidIntersection = true;
   EFAEdge * frag_edge = getFragmentEdge(0, frag_edge_id); // we're considering this edge
   EFANode * edge_node1 = frag_edge->getNode(0);
   EFANode * edge_node2 = frag_edge->getNode(1);
   if ((std::abs(position) < Xfem::tol && edge_node1->category() == EFANode::N_CATEGORY_EMBEDDED) ||
       (std::abs(1.0 - position) < Xfem::tol &&
        edge_node2->category() == EFANode::N_CATEGORY_EMBEDDED))
     isValidIntersection = false;
  
   // TODO: do not allow to cut fragment's node
   if (std::abs(position) < Xfem::tol || std::abs(1.0 - position) < Xfem::tol)
     isValidIntersection = false;
  
   // add valid intersection point to an edge
   if (isValidIntersection)
   {
     if (frag_edge->hasIntersection())
     {
       if (!frag_edge->hasIntersectionAtPosition(position, edge_node1))
         EFAError("Attempting to add fragment edge intersection when one already exists with "
                  "different position.",
                  " elem: ",
                  _id,
                  " edge: ",
                  frag_edge_id,
                  " position: ",
                  position,
                  " old position: ",
                  frag_edge->getIntersection(0, edge_node1));
     }
     else // blank edge - in fact, it can only be a blank element interior edge
     {
       if (!_fragments[0]->isEdgeInterior(frag_edge_id) ||
           _fragments[0]->isSecondaryInteriorEdge(frag_edge_id))
         EFAError("Attemping to add intersection to an invalid fragment edge. Element: ",
                  _id,
                  " fragment_edge: ",
                  frag_edge_id);
  
       // create the embedded node and add it to the fragment's boundary edge
       unsigned int new_node_id = Efa::getNewID(EmbeddedNodes);
       local_embedded = new EFANode(new_node_id, EFANode::N_CATEGORY_EMBEDDED);
       EmbeddedNodes.insert(std::make_pair(new_node_id, local_embedded));
       frag_edge->addIntersection(position, local_embedded, edge_node1);
  
       // save this interior embedded node to FaceNodes
       // TODO: for unstructured elements, the following calution gives you inaccurate position of
       // face nodes
       // must solve this issue for 3D!
       std::vector<double> node1_para_coor(2, 0.0);
       std::vector<double> node2_para_coor(2, 0.0);
       if (getEdgeNodeParametricCoordinate(edge_node1, node1_para_coor) &&
           getEdgeNodeParametricCoordinate(edge_node2, node2_para_coor))
       {
         double xi = (1.0 - position) * node1_para_coor[0] + position * node2_para_coor[0];
         double eta = (1.0 - position) * node1_para_coor[1] + position * node2_para_coor[1];
         _interior_nodes.push_back(new EFAFaceNode(local_embedded, xi, eta));
       }
       else
         EFAError("elem: ", _id, " cannot get the parametric coords of two end embedded nodes");
     }
     // no need to add intersection for neighbor fragment - if this fragment has a
     // neighbor fragment, the neighbor has already been treated in addEdgeIntersection;
     // for an interior edge, there is no neighbor fragment
   }
  
   return isValidIntersection;
 }

Referenced by ElementFragmentAlgorithm::addFragEdgeIntersection().

◆ addNodeCut()

void EFAElement2D::addNodeCut	(	unsigned int	node_id,
		EFANode *	embedded_permanent_node,
		std::map< unsigned int, EFANode * > &	PermanentNodes,
		std::map< unsigned int, EFANode * > &	EmbeddedPermanentNodes
	)

Definition at line 1814 of file EFAElement2D.C.

 {
   EFANode * local_embedded_permanent = NULL;
   EFANode * node = _nodes[node_id];
   if (embedded_permanent_node) // use the existing embedded node if it was passed in
     local_embedded_permanent = embedded_permanent_node;
  
   if (node->category() == EFANode::N_CATEGORY_PERMANENT)
   {
     node->setCategory(EFANode::N_CATEGORY_EMBEDDED_PERMANENT);
     local_embedded_permanent = node;
     EmbeddedPermanentNodes.insert(std::make_pair(node->id(), local_embedded_permanent));
     if (!Efa::deleteFromMap(PermanentNodes, local_embedded_permanent, false))
       EFAError("Attempted to delete node: ",
                local_embedded_permanent->id(),
                " from PermanentNodes, but couldn't find it");
   }
 }

Referenced by ElementFragmentAlgorithm::addElemNodeIntersection().

◆ branchingSplit()

std::vector< EFAFragment2D * > EFAElement2D::branchingSplit ( std::map< unsigned int, EFANode * > & EmbeddedNodes )

Definition at line 1916 of file EFAElement2D.C.

 {
   if (isPartial())
     EFAError("branching is only allowed for an uncut element");
  
   // collect all emb nodes counterclockwise
   std::vector<EFANode *> three_nodes;
   for (unsigned int i = 0; i < _edges.size(); ++i)
   {
     EFANode * node1 = _edges[i]->getNode(0);
     if (_edges[i]->numEmbeddedNodes() == 1)
       three_nodes.push_back(_edges[i]->getEmbeddedNode(0));
     else if (_edges[i]->numEmbeddedNodes() == 2)
     {
       unsigned int id0(
           _edges[i]->getIntersection(0, node1) < _edges[i]->getIntersection(1, node1) ? 0 : 1);
       unsigned int id1 = 1 - id0;
       three_nodes.push_back(_edges[i]->getEmbeddedNode(id0));
       three_nodes.push_back(_edges[i]->getEmbeddedNode(id1));
     }
   }
   if (three_nodes.size() != 3)
     EFAError("three_nodes.size() != 3");
  
   // get the parent coords of the braycenter of the three nodes
   // TODO: may need a better way to compute this "branching point"
   std::vector<double> center_xi(2, 0.0);
   for (unsigned int i = 0; i < 3; ++i)
   {
     std::vector<double> xi_2d(2, 0.0);
     getEdgeNodeParametricCoordinate(three_nodes[i], xi_2d);
     center_xi[0] += xi_2d[0];
     center_xi[1] += xi_2d[1];
   }
   center_xi[0] /= 3.0;
   center_xi[1] /= 3.0;
  
   // create a new interior node for current element
   unsigned int new_node_id = Efa::getNewID(EmbeddedNodes);
   EFANode * new_emb = new EFANode(new_node_id, EFANode::N_CATEGORY_EMBEDDED);
   EmbeddedNodes.insert(std::make_pair(new_node_id, new_emb));
   _interior_nodes.push_back(new EFAFaceNode(new_emb, center_xi[0], center_xi[1]));
  
   // generate the three fragments
   std::vector<EFAFragment2D *> new_fragments;
   for (unsigned int i = 0; i < 3; ++i) // loop over 3 sectors
   {
     EFAFragment2D * new_frag = new EFAFragment2D(this, false, NULL);
     unsigned int iplus1(i < 2 ? i + 1 : 0);
     new_frag->addEdge(new EFAEdge(three_nodes[iplus1], new_emb));
     new_frag->addEdge(new EFAEdge(new_emb, three_nodes[i]));
  
     unsigned int iedge = 0;
     bool add_more_edges = true;
     for (unsigned int j = 0; j < _edges.size(); ++j)
     {
       if (_edges[j]->containsNode(three_nodes[i]))
       {
         if (_edges[j]->containsNode(three_nodes[iplus1]))
         {
           new_frag->addEdge(new EFAEdge(three_nodes[i], three_nodes[iplus1]));
           add_more_edges = false;
         }
         else
         {
           new_frag->addEdge(new EFAEdge(three_nodes[i], _edges[j]->getNode(1)));
         }
         iedge = j;
         break;
       }
     } // j
     while (add_more_edges)
     {
       iedge += 1;
       if (iedge == _edges.size())
         iedge = 0;
       if (_edges[iedge]->containsNode(three_nodes[iplus1]))
       {
         new_frag->addEdge(new EFAEdge(_edges[iedge]->getNode(0), three_nodes[iplus1]));
         add_more_edges = false;
       }
       else
         new_frag->addEdge(new EFAEdge(_edges[iedge]->getNode(0), _edges[iedge]->getNode(1)));
     }
     new_fragments.push_back(new_frag);
   } // i
   return new_fragments;
 }

Referenced by updateFragments().

◆ clearNeighbors()

void EFAElement2D::clearNeighbors ( )

virtual

Implements EFAElement.

Definition at line 459 of file EFAElement2D.C.

 {
   _general_neighbors.clear();
   for (unsigned int edge_iter = 0; edge_iter < _num_edges; ++edge_iter)
     _edge_neighbors[edge_iter] = std::vector<EFAElement2D *>(1, NULL);
 }

◆ clearParentAndChildren()

void EFAElement::clearParentAndChildren ( )

inherited

Definition at line 209 of file EFAElement.C.

 {
   _parent = NULL;
   _children.clear();
 }

Referenced by ElementFragmentAlgorithm::clearAncestry().

◆ connectNeighbors()

void EFAElement2D::connectNeighbors	(	std::map< unsigned int, EFANode * > &	PermanentNodes,
		std::map< unsigned int, EFANode * > &	TempNodes,
		std::map< EFANode , std::set< EFAElement >> &	InverseConnectivityMap,
		bool	merge_phantom_edges
	)

virtual

Implements EFAElement.

Definition at line 1171 of file EFAElement2D.C.

 {
   // N.B. "this" must point to a child element that was just created
   if (!_parent)
     EFAError("no parent element for child element ", _id, " in connect_neighbors");
   EFAElement2D * parent2d = dynamic_cast<EFAElement2D *>(_parent);
   if (!parent2d)
     EFAError("cannot dynamic cast to parent2d in connect_neighbors");
  
   // First loop through edges and merge nodes with neighbors as appropriate
   for (unsigned int j = 0; j < _num_edges; ++j)
   {
     for (unsigned int k = 0; k < parent2d->numEdgeNeighbors(j); ++k)
     {
       EFAElement2D * NeighborElem = parent2d->getEdgeNeighbor(j, k);
       unsigned int neighbor_edge_id = NeighborElem->getNeighborIndex(parent2d);
  
       if (_edges[j]->hasIntersection())
       {
         for (unsigned int l = 0; l < NeighborElem->numChildren(); ++l)
         {
           EFAElement2D * childOfNeighborElem =
               dynamic_cast<EFAElement2D *>(NeighborElem->getChild(l));
           if (!childOfNeighborElem)
             EFAError("dynamic cast childOfNeighborElem fails");
  
           // Check to see if the nodes are already merged.  There's nothing else to do in that case.
           EFAEdge * neighborChildEdge = childOfNeighborElem->getEdge(neighbor_edge_id);
           if (_edges[j]->equivalent(*neighborChildEdge))
             continue;
  
           if (_fragments[0]->isConnected(childOfNeighborElem->getFragment(0)))
           {
             unsigned int num_edge_nodes = 2;
             for (unsigned int i = 0; i < num_edge_nodes; ++i)
             {
               unsigned int childNodeIndex = i;
               unsigned int neighborChildNodeIndex = num_edge_nodes - 1 - childNodeIndex;
  
               EFANode * childNode = _edges[j]->getNode(childNodeIndex);
               EFANode * childOfNeighborNode = neighborChildEdge->getNode(neighborChildNodeIndex);
  
               mergeNodes(
                   childNode, childOfNeighborNode, childOfNeighborElem, PermanentNodes, TempNodes);
             }
  
             EFANode * childNode = _edges[j]->getInteriorNode();
             EFANode * childOfNeighborNode = neighborChildEdge->getInteriorNode();
  
             mergeNodes(
                 childNode, childOfNeighborNode, childOfNeighborElem, PermanentNodes, TempNodes);
           }
         } // l, loop over NeighborElem's children
       }
       else // No edge intersection -- optionally merge non-material nodes if they share a common
            // parent
       {
         if (merge_phantom_edges)
         {
           for (unsigned int l = 0; l < NeighborElem->numChildren(); ++l)
           {
             EFAElement2D * childOfNeighborElem =
                 dynamic_cast<EFAElement2D *>(NeighborElem->getChild(l));
             if (!childOfNeighborElem)
               EFAError("dynamic cast childOfNeighborElem fails");
  
             EFAEdge * neighborChildEdge = childOfNeighborElem->getEdge(neighbor_edge_id);
             if (!neighborChildEdge->hasIntersection()) // neighbor edge must NOT have
                                                        // intersection either
             {
               // Check to see if the nodes are already merged.  There's nothing else to do in that
               // case.
               unsigned int num_edge_nodes = 2;
               for (unsigned int i = 0; i < num_edge_nodes; ++i)
               {
                 unsigned int childNodeIndex = i;
                 unsigned int neighborChildNodeIndex = num_edge_nodes - 1 - childNodeIndex;
  
                 EFANode * childNode = _edges[j]->getNode(childNodeIndex);
                 EFANode * childOfNeighborNode = neighborChildEdge->getNode(neighborChildNodeIndex);
  
                 if (childNode->parent() != NULL &&
                     childNode->parent() ==
                         childOfNeighborNode
                             ->parent()) // non-material node and both come from same parent
                   mergeNodes(childNode,
                              childOfNeighborNode,
                              childOfNeighborElem,
                              PermanentNodes,
                              TempNodes);
               } // i
             }
           } // loop over NeighborElem's children
         }   // if (merge_phantom_edges)
       }     // IF edge-j has_intersection()
     }       // k, loop over neighbors on edge j
   }         // j, loop over all edges
  
   // Now do a second loop through edges and convert remaining nodes to permanent nodes.
   // Important: temp nodes are not shared by any neighbor, so no need to switch nodes on neighbors
   for (unsigned int j = 0; j < _num_nodes; ++j)
   {
     EFANode * childNode = _nodes[j];
     if (childNode->category() == EFANode::N_CATEGORY_TEMP)
     {
       // if current child element does not have siblings, and if current temp node is a lone one
       // this temp node should be merged back to its parent permanent node. Otherwise we would have
       // permanent nodes that are not connected to any element
       std::set<EFAElement *> patch_elems = InverseConnectivityMap[childNode->parent()];
       if (parent2d->numFragments() == 1 && patch_elems.size() == 1)
         switchNode(childNode->parent(), childNode, false);
       else
       {
         unsigned int new_node_id = Efa::getNewID(PermanentNodes);
         EFANode * newNode =
             new EFANode(new_node_id, EFANode::N_CATEGORY_PERMANENT, childNode->parent());
         PermanentNodes.insert(std::make_pair(new_node_id, newNode));
         switchNode(newNode, childNode, false);
       }
       if (!Efa::deleteFromMap(TempNodes, childNode))
         EFAError(
             "Attempted to delete node: ", childNode->id(), " from TempNodes, but couldn't find it");
     }
   }
 }

◆ containsNode()

bool EFAElement::containsNode ( EFANode * node ) const

inherited

Definition at line 52 of file EFAElement.C.

 {
   for (unsigned int i = 0; i < _nodes.size(); ++i)
     if (_nodes[i] == node)
       return true;
   return false;
 }

Referenced by branchingSplit(), getEdgeNodeParametricCoordinate(), EFAElement3D::getFaceNodeParametricCoordinates(), getMasterInfo(), EFAElement3D::getMasterInfo(), getNonPhysicalNodes(), EFAElement3D::getNonPhysicalNodes(), getPhantomNodeOnEdge(), EFAElement3D::getPhantomNodeOnFace(), getTipEmbeddedNode(), isPartial(), EFAElement3D::isPartial(), printElement(), removePhantomEmbeddedNode(), EFAElement3D::removePhantomEmbeddedNode(), and EFAElement3D::willCrackTipExtend().

◆ createChild()

void EFAElement2D::createChild	(	const std::set< EFAElement * > &	CrackTipElements,
		std::map< unsigned int, EFAElement * > &	Elements,
		std::map< unsigned int, EFAElement * > &	newChildElements,
		std::vector< EFAElement * > &	ChildElements,
		std::vector< EFAElement * > &	ParentElements,
		std::map< unsigned int, EFANode * > &	TempNodes
	)

virtual

Implements EFAElement.

Definition at line 985 of file EFAElement2D.C.

 {
   if (_children.size() != 0)
     EFAError("Element cannot have existing children in createChildElements");
  
   bool shouldDuplicateForCutNodeElement = false;
   for (unsigned int j = 0; j < _num_nodes; ++j)
   {
     if (_nodes[j]->category() == EFANode::N_CATEGORY_EMBEDDED_PERMANENT)
       shouldDuplicateForCutNodeElement = true;
   }
  
   if (_fragments.size() > 1 || shouldDuplicateForCrackTip(CrackTipElements) ||
       shouldDuplicateForCutNodeElement)
   {
     if (_fragments.size() > 3)
       EFAError("More than 3 fragments not yet supported");
  
     // set up the children
     ParentElements.push_back(this);
     for (unsigned int ichild = 0; ichild < _fragments.size(); ++ichild)
     {
       unsigned int new_elem_id;
       if (newChildElements.size() == 0)
         new_elem_id = Efa::getNewID(Elements);
       else
         new_elem_id = Efa::getNewID(newChildElements);
  
       EFAElement2D * childElem = new EFAElement2D(new_elem_id, this->numNodes());
       newChildElements.insert(std::make_pair(new_elem_id, childElem));
  
       ChildElements.push_back(childElem);
       childElem->setParent(this);
       _children.push_back(childElem);
  
       std::vector<EFAPoint> local_embedded_node_coor;
  
       for (unsigned int i = 0; i < this->getFragment(ichild)->numEdges(); ++i)
       {
         if (this->getFragment(ichild)->isEdgeInterior(i))
         {
           std::vector<EFANode *> master_nodes;
           std::vector<double> master_weights;
  
           for (unsigned int j = 0; j < 2; ++j)
           {
             this->getMasterInfo(
                 this->getFragmentEdge(ichild, i)->getNode(j), master_nodes, master_weights);
             EFAPoint coor(0.0, 0.0, 0.0);
             for (unsigned int k = 0; k < master_nodes.size(); ++k)
             {
               EFANode * local = this->createLocalNodeFromGlobalNode(master_nodes[k]);
               coor += _local_node_coor[local->id()] * master_weights[k];
               delete local;
             }
             local_embedded_node_coor.push_back(coor);
           }
         }
       }
  
       EFAPoint normal(0.0, 0.0, 0.0);
       EFAPoint origin(0.0, 0.0, 0.0);
       EFAPoint normal2(0.0, 0.0, 0.0);
       EFAPoint origin2(0.0, 0.0, 0.0);
  
       if (local_embedded_node_coor.size())
       {
         EFAPoint cut_line = local_embedded_node_coor[1] - local_embedded_node_coor[0];
         normal = EFAPoint(cut_line(1), -cut_line(0), 0.0);
         Xfem::normalizePoint(normal);
         origin = (local_embedded_node_coor[0] + local_embedded_node_coor[1]) * 0.5;
       }
  
       if (local_embedded_node_coor.size() == 4)
       {
         EFAPoint cut_line = local_embedded_node_coor[3] - local_embedded_node_coor[2];
         normal2 = EFAPoint(cut_line(1), -cut_line(0), 0.0);
         Xfem::normalizePoint(normal2);
         origin2 = (local_embedded_node_coor[2] + local_embedded_node_coor[3]) * 0.5;
       }
  
       // get child element's nodes
       for (unsigned int j = 0; j < _num_nodes; ++j)
       {
         EFAPoint p(0.0, 0.0, 0.0);
         p = _local_node_coor[j];
  
         EFAPoint origin_to_point = p - origin;
         EFAPoint origin2_to_point = p - origin2;
  
         if (_fragments.size() == 1 &&
             _nodes[j]->category() == EFANode::N_CATEGORY_EMBEDDED_PERMANENT) // create temp node for
                                                                              // embedded permanent
                                                                              // node
         {
           unsigned int new_node_id = Efa::getNewID(TempNodes);
           EFANode * newNode = new EFANode(new_node_id, EFANode::N_CATEGORY_TEMP, _nodes[j]);
           TempNodes.insert(std::make_pair(new_node_id, newNode));
           childElem->setNode(j, newNode); // be a temp node
         }
         else if (_fragments.size() == 1 && !shouldDuplicateForCrackTip(CrackTipElements))
         {
           childElem->setNode(j, _nodes[j]); // inherit parent's node
         }
         else if (std::abs(origin_to_point * normal) < Xfem::tol &&
                  _fragments.size() > 1) // cut through node case
         {
           unsigned int new_node_id = Efa::getNewID(TempNodes);
           EFANode * newNode = new EFANode(new_node_id, EFANode::N_CATEGORY_TEMP, _nodes[j]);
           TempNodes.insert(std::make_pair(new_node_id, newNode));
           childElem->setNode(j, newNode); // be a temp node
         }
         else if (origin_to_point * normal < Xfem::tol && origin2_to_point * normal2 < Xfem::tol &&
                  (_fragments.size() > 1 || shouldDuplicateForCrackTip(CrackTipElements)))
         {
           childElem->setNode(j, _nodes[j]); // inherit parent's node
         }
         else if (normal.norm() < Xfem::tol && normal2.norm() < Xfem::tol &&
                  _fragments.size() == 1) // cut along edge case
         {
           childElem->setNode(j, _nodes[j]); // inherit parent's node
         }
         else if ((_fragments.size() > 1 ||
                   shouldDuplicateForCrackTip(
                       CrackTipElements))) // parent element's node is not in fragment
         {
           unsigned int new_node_id = Efa::getNewID(TempNodes);
           EFANode * newNode = new EFANode(new_node_id, EFANode::N_CATEGORY_TEMP, _nodes[j]);
           TempNodes.insert(std::make_pair(new_node_id, newNode));
           childElem->setNode(j, newNode); // be a temp node
         }
       }
  
       // get child element's fragments
       EFAFragment2D * new_frag = new EFAFragment2D(childElem, true, this, ichild);
       childElem->_fragments.push_back(new_frag);
  
       // get child element's edges
       for (unsigned int j = 0; j < _num_edges; ++j)
       {
         unsigned int jplus1(j < (_num_edges - 1) ? j + 1 : 0);
         EFAEdge * new_edge = new EFAEdge(childElem->getNode(j), childElem->getNode(jplus1));
         if (_edges[j]->hasIntersection())
           new_edge->copyIntersection(*_edges[j], 0);
         if ((_num_edges == 4 && _num_nodes > 4) || (_num_edges == 3 && _num_nodes > 3))
           new_edge->setInteriorNode(childElem->getNode(_num_edges + j));
         childElem->setEdge(j, new_edge);
       }
       childElem->removePhantomEmbeddedNode(); // IMPORTANT
  
       // inherit old interior nodes
       for (unsigned int j = 0; j < _interior_nodes.size(); ++j)
         childElem->_interior_nodes.push_back(new EFAFaceNode(*_interior_nodes[j]));
     }
   }
   else // num_links == 1 || num_links == 0
     // child is itself - but don't insert into the list of ChildElements!!!
     _children.push_back(this);
 }

◆ createEdges()

void EFAElement2D::createEdges ( )

Definition at line 1459 of file EFAElement2D.C.

 {
   for (unsigned int i = 0; i < _num_edges; ++i)
   {
     unsigned int i_plus1(i < (_num_edges - 1) ? i + 1 : 0);
     EFAEdge * new_edge = new EFAEdge(_nodes[i], _nodes[i_plus1]);
  
     if ((_num_edges == 4 && _num_nodes > 4) || (_num_edges == 3 && _num_nodes > 3))
       new_edge->setInteriorNode(
           _nodes[i + _num_edges]); // '_num_edges' is the offset of interior edge node numbering
  
     _edges[i] = new_edge;
   }
 }

Referenced by ElementFragmentAlgorithm::add2DElement(), and ElementFragmentAlgorithm::add2DElements().

◆ createLocalNodeFromGlobalNode()

EFANode * EFAElement::createLocalNodeFromGlobalNode ( const EFANode * global_node ) const

inherited

Definition at line 70 of file EFAElement.C.

 {
   // Given a global node, create a new local node
   if (global_node->category() != EFANode::N_CATEGORY_PERMANENT &&
       global_node->category() != EFANode::N_CATEGORY_TEMP &&
       global_node->category() != EFANode::N_CATEGORY_EMBEDDED_PERMANENT)
     EFAError("In createLocalNodeFromGlobalNode node is not global");
  
   EFANode * new_local_node = NULL;
   unsigned int inode = 0;
   for (; inode < _nodes.size(); ++inode)
   {
     if (_nodes[inode] == global_node)
     {
       new_local_node = new EFANode(inode, EFANode::N_CATEGORY_LOCAL_INDEX);
       break;
     }
   }
   if (!new_local_node)
     EFAError("In createLocalNodeFromGlobalNode could not find global node");
  
   return new_local_node;
 }

Referenced by createChild(), EFAElement3D::createChild(), EFAElement2D(), and EFAElement3D::EFAElement3D().

◆ deleteInteriorNodes()

void EFAElement2D::deleteInteriorNodes ( )

Definition at line 1439 of file EFAElement2D.C.

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

Referenced by EFAFragment2D::removeInvalidEmbeddedNodes().

◆ edgeContainsTip()

bool EFAElement2D::edgeContainsTip ( unsigned int edge_id ) const

Definition at line 1669 of file EFAElement2D.C.

 {
   bool contains_tip = false;
   if (_fragments.size() == 1)
   {
     unsigned int num_frag_edges = 0; // count how many fragment edges this element edge contains
     if (_edges[edge_id]->hasIntersection())
     {
       for (unsigned int j = 0; j < _fragments[0]->numEdges(); ++j)
       {
         if (_edges[edge_id]->containsEdge(*_fragments[0]->getEdge(j)))
           num_frag_edges += 1;
       } // j
       if (num_frag_edges == 2)
         contains_tip = true;
     }
   }
   return contains_tip;
 }

Referenced by fragmentEdgeAlreadyCut().

◆ findGeneralNeighbors()

void EFAElement::findGeneralNeighbors ( std::map< EFANode *, std::set< EFAElement * >> & InverseConnectivity )

inherited

Definition at line 216 of file EFAElement.C.

 {
   _general_neighbors.clear();
   std::set<EFAElement *> patch_elements;
   for (unsigned int inode = 0; inode < _num_nodes; ++inode)
   {
     std::set<EFAElement *> this_node_connected_elems = InverseConnectivity[_nodes[inode]];
     patch_elements.insert(this_node_connected_elems.begin(), this_node_connected_elems.end());
   }
  
   std::set<EFAElement *>::iterator eit2;
   for (eit2 = patch_elements.begin(); eit2 != patch_elements.end(); ++eit2)
   {
     EFAElement * neigh_elem = *eit2;
     if (neigh_elem != this)
       _general_neighbors.push_back(neigh_elem);
   }
 }

Referenced by setupNeighbors(), and EFAElement3D::setupNeighbors().

◆ fragmentEdgeAlreadyCut()

bool EFAElement2D::fragmentEdgeAlreadyCut ( unsigned int ElemEdgeID ) const

Definition at line 1690 of file EFAElement2D.C.

 {
   // when marking cuts, check if the corresponding frag edge already has been cut
   bool has_cut = false;
   if (edgeContainsTip(ElemEdgeID))
     has_cut = true;
   else
   {
     unsigned int FragEdgeID = 99999;
     if (getFragmentEdgeID(ElemEdgeID, FragEdgeID))
     {
       EFAEdge * frag_edge = getFragmentEdge(0, FragEdgeID);
       if (frag_edge->hasIntersection())
         has_cut = true;
     }
   }
   return has_cut;
 }

Referenced by addEdgeCut().

◆ fragmentHasTipEdges()

bool EFAElement2D::fragmentHasTipEdges ( ) const

Definition at line 1581 of file EFAElement2D.C.

 {
   bool has_tip_edges = false;
   if (_fragments.size() == 1)
   {
     for (unsigned int i = 0; i < _num_edges; ++i)
     {
       unsigned int num_frag_edges = 0; // count how many fragment edges this element edge contains
       if (_edges[i]->hasIntersection())
       {
         for (unsigned int j = 0; j < _fragments[0]->numEdges(); ++j)
         {
           if (_edges[i]->containsEdge(*_fragments[0]->getEdge(j)))
             num_frag_edges += 1;
         } // j
         if (num_frag_edges == 2)
         {
           has_tip_edges = true;
           break;
         }
       }
     } // i
   }
   return has_tip_edges;
 }

Referenced by isCrackTipElement().

◆ fragmentSanityCheck()

void EFAElement2D::fragmentSanityCheck	(	unsigned int	n_old_frag_edges,
		unsigned int	n_old_frag_cuts
	)		const

virtual

Implements EFAElement.

Definition at line 871 of file EFAElement2D.C.

 {
   if (n_old_frag_cuts > 3)
     EFAError("Sanity check: in element ", _id, " frag has more than 3 cut edges");
  
   // count permanent and embedded nodes for new fragments
   std::vector<unsigned int> num_emb;
   std::vector<unsigned int> num_perm;
   std::vector<unsigned int> num_emb_perm;
   for (unsigned int i = 0; i < _fragments.size(); ++i)
   {
     num_emb.push_back(0);
     num_perm.push_back(0);
     num_emb_perm.push_back(0);
     std::set<EFANode *> perm_nodes;
     std::set<EFANode *> emb_nodes;
     std::set<EFANode *> emb_perm_nodes;
     for (unsigned int j = 0; j < _fragments[i]->numEdges(); ++j)
     {
       for (unsigned int k = 0; k < 2; ++k)
       {
         EFANode * temp_node = _fragments[i]->getEdge(j)->getNode(k);
         if (temp_node->category() == EFANode::N_CATEGORY_PERMANENT)
           perm_nodes.insert(temp_node);
         else if (temp_node->category() == EFANode::N_CATEGORY_EMBEDDED)
           emb_nodes.insert(temp_node);
         else if (temp_node->category() == EFANode::N_CATEGORY_EMBEDDED_PERMANENT)
           emb_perm_nodes.insert(temp_node);
         else
           EFAError("Invalid node category");
       }
     }
     num_perm[i] = perm_nodes.size();
     num_emb[i] = emb_nodes.size();
     num_emb_perm[i] = emb_perm_nodes.size();
   }
  
   // TODO: For cut-node case, how to check fragment sanity
   for (unsigned int i = 0; i < _fragments.size(); ++i)
     if (num_emb_perm[i] != 0)
       return;
  
   unsigned int n_interior_nodes = numInteriorNodes();
   if (n_interior_nodes > 0 && n_interior_nodes != 1)
     EFAError("After update_fragments this element has ", n_interior_nodes, " interior nodes");
  
   if (n_old_frag_cuts == 0)
   {
     if (_fragments.size() != 1 || _fragments[0]->numEdges() != n_old_frag_edges)
       EFAError("Incorrect link size for element with 0 cuts");
   }
   else if (n_old_frag_cuts == 1) // crack tip case
   {
     if (_fragments.size() != 1 || _fragments[0]->numEdges() != n_old_frag_edges + 1)
       EFAError("Incorrect link size for element with 1 cut");
   }
   else if (n_old_frag_cuts == 2)
   {
     if (_fragments.size() != 2 ||
         (_fragments[0]->numEdges() + _fragments[1]->numEdges()) != n_old_frag_edges + 4)
       EFAError("Incorrect link size for element with 2 cuts");
   }
   else if (n_old_frag_cuts == 3)
   {
     if (_fragments.size() != 3 || (_fragments[0]->numEdges() + _fragments[1]->numEdges() +
                                    _fragments[2]->numEdges()) != n_old_frag_edges + 9)
       EFAError("Incorrect link size for element with 3 cuts");
   }
   else
     EFAError("Unexpected number of old fragment cuts");
 }

Referenced by updateFragments().

◆ getChild()

EFAElement * EFAElement::getChild ( unsigned int child_id ) const

inherited

Definition at line 182 of file EFAElement.C.

 {
   if (child_id < _children.size())
     return _children[child_id];
   else
     EFAError("child_id out of bounds");
 }

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

◆ getCommonNodes()

std::vector< EFANode * > EFAElement2D::getCommonNodes ( const EFAElement2D * other_elem ) const

Definition at line 2061 of file EFAElement2D.C.

 {
   std::set<EFANode *> e1nodes(_nodes.begin(),
                               _nodes.begin() + _num_edges); // only account for corner nodes
   std::set<EFANode *> e2nodes(other_elem->_nodes.begin(), other_elem->_nodes.begin() + _num_edges);
   std::vector<EFANode *> common_nodes = Efa::getCommonElems(e1nodes, e2nodes);
   return common_nodes;
 }

Referenced by overlaysElement(), and setupNeighbors().

◆ getCrackTipNeighbor()

unsigned int EFAElement::getCrackTipNeighbor ( unsigned int index ) const

inherited

Definition at line 148 of file EFAElement.C.

 {
   if (index < _crack_tip_neighbors.size())
     return _crack_tip_neighbors[index];
   else
     EFAError("in getCrackTipNeighbor index out of bounds");
 }

◆ getCrackTipSplitElementID()

unsigned int EFAElement2D::getCrackTipSplitElementID ( ) const

Definition at line 594 of file EFAElement2D.C.

 {
   if (isCrackTipElement())
   {
     for (unsigned int edge_iter = 0; edge_iter < _num_edges; ++edge_iter)
     {
       if ((_edge_neighbors[edge_iter].size() == 2) && (_edges[edge_iter]->hasIntersection()))
       {
         if (_edge_neighbors[edge_iter][0] != NULL &&
             _edge_neighbors[edge_iter][0]->isCrackTipSplit())
         {
           return _edge_neighbors[edge_iter][0]->id();
         }
       }
     }
   }
   EFAError("In getCrackTipSplitElementID could not find element id");
   return 0;
 }

Referenced by XFEM::storeCrackTipOriginAndDirection().

◆ getEdge()

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

Definition at line 1475 of file EFAElement2D.C.

 {
   return _edges[edge_id];
 }

Referenced by addEdgeCut(), EFAFragment2D::combineTipEdges(), XFEMCutElem2D::computePhysicalFaceAreaFraction(), connectNeighbors(), XFEM::correctCrackExtensionDirection(), edgeContainsTip(), EFAFragment2D::EFAFragment2D(), fragmentHasTipEdges(), getFragmentEdge(), getFragmentEdgeID(), getTipEdgeID(), getTipEmbeddedNode(), EFAFragment2D::isEdgeInterior(), isEdgePhantom(), XFEM::markCutEdgesByState(), and shouldDuplicateForPhantomCorner().

◆ getEdgeNeighbor()

EFAElement2D * EFAElement2D::getEdgeNeighbor	(	unsigned int	edge_id,
		unsigned int	neighbor_id
	)		const

Definition at line 1572 of file EFAElement2D.C.

 {
   if (_edge_neighbors[edge_id][0] != NULL && neighbor_id < _edge_neighbors[edge_id].size())
     return _edge_neighbors[edge_id][neighbor_id];
   else
     EFAError("edge neighbor does not exist");
 }

Referenced by addEdgeCut(), connectNeighbors(), neighborSanityCheck(), and printElement().

◆ getEdgeNodeParametricCoordinate()

bool EFAElement2D::getEdgeNodeParametricCoordinate	(	EFANode *	node,
		std::vector< double > &	para_coor
	)		const

Definition at line 1406 of file EFAElement2D.C.

 {
   // get the parametric coords of a node in an element edge
   unsigned int edge_id = 99999;
   bool edge_found = false;
   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
     mapParametricCoordFrom1Dto2D(edge_id, xi_1d, para_coor);
   }
   return edge_found;
 }

Referenced by addFragmentEdgeCut(), and branchingSplit().

◆ getEdgeNodes()

std::set< EFANode * > EFAElement2D::getEdgeNodes ( unsigned int edge_id ) const

Definition at line 1397 of file EFAElement2D.C.

 {
   std::set<EFANode *> edge_nodes;
   edge_nodes.insert(_edges[edge_id]->getNode(0));
   edge_nodes.insert(_edges[edge_id]->getNode(1));
   return edge_nodes;
 }

Referenced by setupNeighbors(), and shouldDuplicateCrackTipSplitElement().

◆ getFragment()

EFAFragment2D * EFAElement2D::getFragment ( unsigned int frag_id ) const

Definition at line 1388 of file EFAElement2D.C.

 {
   if (frag_id < _fragments.size())
     return _fragments[frag_id];
   else
     EFAError("frag_id out of bounds");
 }

Referenced by XFEMCutElem2D::computePhysicalFaceAreaFraction(), XFEMCutElem2D::computePhysicalVolumeFraction(), connectNeighbors(), createChild(), EFAFragment2D::EFAFragment2D(), XFEMCutElem2D::getCrackTipOriginAndDirection(), XFEMCutElem2D::getCutPlaneNormal(), XFEMCutElem2D::getCutPlaneOrigin(), XFEM::getFragmentEdges(), XFEMCutElem2D::getFragmentFaces(), XFEMCutElem2D::getIntersectionInfo(), XFEMCutElem2D::getPhysicalQuadraturePoints(), XFEM::markCutEdgesByGeometry(), XFEM::markCutEdgesByState(), XFEMCutElem2D::numCutPlanes(), setupNeighbors(), and willCrackTipExtend().

◆ getFragmentEdge()

EFAEdge * EFAElement2D::getFragmentEdge	(	unsigned int	frag_id,
		unsigned int	edge_id
	)		const

Definition at line 1481 of file EFAElement2D.C.

 {
   if (frag_id < _fragments.size())
     return _fragments[frag_id]->getEdge(edge_id);
   else
     EFAError("frag_id out of bounds in get_frag_edge()");
 }

Referenced by addEdgeCut(), addFragmentEdgeCut(), XFEMCutElem2D::computePhysicalFaceAreaFraction(), XFEMCutElem2D::computePhysicalVolumeFraction(), createChild(), EFAFragment2D::EFAFragment2D(), fragmentEdgeAlreadyCut(), XFEMCutElem2D::getCrackTipOriginAndDirection(), XFEMCutElem2D::getCutPlaneNormal(), XFEMCutElem2D::getCutPlaneOrigin(), XFEM::getFragmentEdges(), XFEMCutElem2D::getFragmentFaces(), XFEMCutElem2D::getIntersectionInfo(), XFEM::markCutEdgesByState(), and printElement().

◆ getFragmentEdgeID()

bool EFAElement2D::getFragmentEdgeID	(	unsigned int	elem_edge_id,
		unsigned int &	frag_edge_id
	)		const

Definition at line 1514 of file EFAElement2D.C.

 {
   // find the fragment edge that is contained by given element edge
   // N.B. if the elem edge contains two frag edges, this method will only return
   // the first frag edge ID
   bool frag_edge_found = false;
   frag_edge_id = 99999;
   if (_fragments.size() == 1)
   {
     for (unsigned int j = 0; j < _fragments[0]->numEdges(); ++j)
     {
       if (_edges[elem_edge_id]->containsEdge(*_fragments[0]->getEdge(j)))
       {
         frag_edge_id = j;
         frag_edge_found = true;
         break;
       }
     }
   }
   return frag_edge_found;
 }

Referenced by addEdgeCut(), and fragmentEdgeAlreadyCut().

◆ getGeneralNeighbor()

EFAElement * EFAElement::getGeneralNeighbor ( unsigned int index ) const

inherited

Definition at line 236 of file EFAElement.C.

 {
   return _general_neighbors[index];
 }

Referenced by switchNode(), and EFAElement3D::switchNode().

◆ getGlobalNodeFromLocalNode()

EFANode * EFAElement::getGlobalNodeFromLocalNode ( const EFANode * local_node ) const

inherited

Definition at line 95 of file EFAElement.C.

 {
   // Given a local node, find the global node corresponding to that node
   if (local_node->category() != EFANode::N_CATEGORY_LOCAL_INDEX)
     EFAError("In getGlobalNodeFromLocalNode node passed in is not local");
  
   EFANode * global_node = _nodes[local_node->id()];
  
   if (global_node->category() != EFANode::N_CATEGORY_PERMANENT &&
       global_node->category() != EFANode::N_CATEGORY_TEMP)
     EFAError("In getGlobalNodeFromLocalNode, the node stored by the element is not global");
  
   return global_node;
 }

◆ getInteriorNode()

EFAFaceNode * EFAElement2D::getInteriorNode ( unsigned int interior_node_id ) const

Definition at line 1430 of file EFAElement2D.C.

 {
   if (interior_node_id < _interior_nodes.size())
     return _interior_nodes[interior_node_id];
   else
     EFAError("interior_node_id out of bounds");
 }

Referenced by EFAFragment2D::isSecondaryInteriorEdge().

◆ getLocalNodeIndex()

unsigned int EFAElement::getLocalNodeIndex ( EFANode * node ) const

inherited

Definition at line 111 of file EFAElement.C.

 {
   unsigned int local_node_id = 99999;
   bool found_local_node = false;
   for (unsigned int i = 0; i < _num_nodes; ++i)
   {
     if (_nodes[i] == node)
     {
       found_local_node = true;
       local_node_id = i;
       break;
     }
   }
   if (!found_local_node)
     EFAError("In EFAelement::getLocalNodeIndex, cannot find the given node");
   return local_node_id;
 }

Referenced by XFEM::getEFANodeCoords().

◆ getMasterInfo()

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

virtual

Implements EFAElement.

Definition at line 300 of file EFAElement2D.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_edges; ++j)
         {
           master_nodes.push_back(_nodes[j]);
           double weight = 0.0;
           if (_num_edges == 4)
             weight = Efa::linearQuadShape2D(j, emb_xi);
           else if (_num_edges == 3)
             weight = Efa::linearTriShape2D(j, emb_xi);
           else
             EFAError("unknown 2D element");
           master_weights.push_back(weight);
         }
         masters_found = true;
         break;
       }
     }
   }
  
   if (!masters_found)
     EFAError("In EFAelement2D::getMaterInfo, cannot find the given EFAnode");
 }

Referenced by createChild(), and XFEMCutElem2D::getNodeCoordinates().

◆ getNeighborIndex()

unsigned int EFAElement2D::getNeighborIndex ( const EFAElement * neighbor_elem ) const

virtual

Implements EFAElement.

Definition at line 447 of file EFAElement2D.C.

 {
   for (unsigned int i = 0; i < _num_edges; ++i)
     for (unsigned int j = 0; j < _edge_neighbors[i].size(); ++j)
       if (_edge_neighbors[i][j] == neighbor_elem)
         return i;
  
   EFAError(
       "in get_neighbor_index() element: ", _id, " does not have neighbor: ", neighbor_elem->id());
 }

Referenced by addEdgeCut(), and connectNeighbors().

◆ getNode()

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

inherited

Definition at line 46 of file EFAElement.C.

 {
   return _nodes[node_id];
 }

Referenced by EFAElement3D::addFaceEdgeCut(), branchingSplit(), ElementFragmentAlgorithm::clearAncestry(), createChild(), getEdgeNodes(), ElementFragmentAlgorithm::getElemIdByNodes(), getMasterInfo(), EFAElement3D::getMasterInfo(), EFAElement3D::getNeighborFaceNodeID(), getPhantomNodeOnEdge(), EFAElement3D::getPhantomNodeOnFace(), getTipEmbeddedNode(), EFAElement3D::getTipEmbeddedNodes(), and overlaysElement().

◆ getNonPhysicalNodes()

void EFAElement2D::getNonPhysicalNodes ( std::set< EFANode * > & non_physical_nodes ) const

virtual

Implements EFAElement.

Definition at line 235 of file EFAElement2D.C.

 {
   // Any nodes that don't belong to any fragment are non-physical
   // First add all nodes in the element to the set
   for (unsigned int i = 0; i < _nodes.size(); ++i)
     non_physical_nodes.insert(_nodes[i]);
  
   // Now delete any nodes that are contained in fragments
   std::set<EFANode *>::iterator sit;
   for (sit = non_physical_nodes.begin(); sit != non_physical_nodes.end();)
   {
     bool erased = false;
     for (unsigned int i = 0; i < _fragments.size(); ++i)
     {
       if (_fragments[i]->containsNode(*sit))
       {
         non_physical_nodes.erase(sit++);
         erased = true;
         break;
       }
     }
     if (!erased)
       ++sit;
   }
 }

Referenced by shouldDuplicateCrackTipSplitElement().

◆ getNumCuts()

unsigned int EFAElement2D::getNumCuts ( ) const

virtual

Implements EFAElement.

Definition at line 781 of file EFAElement2D.C.

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

Referenced by restoreFragment().

◆ getParent()

EFAElement * EFAElement::getParent ( ) const

inherited

Definition at line 176 of file EFAElement.C.

 {
   return _parent;
 }

◆ getPhantomNodeOnEdge()

std::set< EFANode * > EFAElement2D::getPhantomNodeOnEdge ( unsigned int edge_id ) const

Definition at line 1490 of file EFAElement2D.C.

 {
   std::set<EFANode *> phantom_nodes;
   if (_fragments.size() > 0)
   {
     for (unsigned int j = 0; j < 2; ++j) // loop ove 2 edge nodes
     {
       bool node_in_frag = false;
       for (unsigned int k = 0; k < _fragments.size(); ++k)
       {
         if (_fragments[k]->containsNode(_edges[edge_id]->getNode(j)))
         {
           node_in_frag = true;
           break;
         }
       }
       if (!node_in_frag)
         phantom_nodes.insert(_edges[edge_id]->getNode(j));
     }
   }
   return phantom_nodes;
 }

Referenced by shouldDuplicateForPhantomCorner().

◆ getTipEdgeID()

unsigned int EFAElement2D::getTipEdgeID ( ) const

Definition at line 1608 of file EFAElement2D.C.

 {
   // if this element is a crack tip element, returns the crack tip edge's ID
   unsigned int tip_edge_id = 99999;
   if (_fragments.size() == 1) // crack tip element with a partial fragment saved
   {
     for (unsigned int i = 0; i < _num_edges; ++i)
     {
       unsigned int num_frag_edges = 0; // count how many fragment edges this element edge contains
       if (_edges[i]->hasIntersection())
       {
         for (unsigned int j = 0; j < _fragments[0]->numEdges(); ++j)
         {
           if (_edges[i]->containsEdge(*_fragments[0]->getEdge(j)))
             num_frag_edges += 1;
         }
         if (num_frag_edges == 2) // element edge contains two fragment edges
         {
           tip_edge_id = i;
           break;
         }
       }
     }
   }
   return tip_edge_id;
 }

Referenced by XFEM::markCutEdgesByState().

◆ getTipEmbeddedNode()

EFANode * EFAElement2D::getTipEmbeddedNode ( ) const

Definition at line 1636 of file EFAElement2D.C.

 {
   // if this element is a crack tip element, returns the crack tip edge's ID
   EFANode * tip_emb = NULL;
   if (_fragments.size() == 1) // crack tip element with a partial fragment saved
   {
     for (unsigned int i = 0; i < _num_edges; ++i)
     {
       std::vector<EFAEdge *> frag_edges; // count how many fragment edges this element edge contains
       if (_edges[i]->hasIntersection())
       {
         for (unsigned int j = 0; j < _fragments[0]->numEdges(); ++j)
         {
           if (_edges[i]->containsEdge(*_fragments[0]->getEdge(j)))
             frag_edges.push_back(_fragments[0]->getEdge(j));
         }                           // j
         if (frag_edges.size() == 2) // element edge contains two fragment edges
         {
           if (frag_edges[1]->containsNode(frag_edges[0]->getNode(1)))
             tip_emb = frag_edges[0]->getNode(1);
           else if (frag_edges[1]->containsNode(frag_edges[0]->getNode(0)))
             tip_emb = frag_edges[0]->getNode(0);
           else
             EFAError("Common node can't be found between 2 tip frag edges");
           break;
         }
       }
     }
   }
   return tip_emb;
 }

Referenced by XFEM::markCutEdgesByState(), and XFEM::storeCrackTipOriginAndDirection().

◆ id()

unsigned int EFAElement::id ( ) const

inherited

Definition at line 28 of file EFAElement.C.

 {
   return _id;
 }

Referenced by EFAElement2D(), EFAElement3D::EFAElement3D(), ElementFragmentAlgorithm::getElemIdByNodes(), EFAElement3D::getNeighborEdgeIndex(), getNeighborIndex(), EFAElement3D::getNeighborIndex(), printElement(), EFAElement3D::printElement(), willCrackTipExtend(), and EFAElement3D::willCrackTipExtend().

◆ initCrackTip()

void EFAElement2D::initCrackTip ( std::set< EFAElement * > & CrackTipElements )

virtual

Implements EFAElement.

Definition at line 556 of file EFAElement2D.C.

 {
   if (isCrackTipElement())
   {
     CrackTipElements.insert(this);
     for (unsigned int edge_iter = 0; edge_iter < _num_edges; ++edge_iter)
     {
       if ((_edge_neighbors[edge_iter].size() == 2) && (_edges[edge_iter]->hasIntersection()))
       {
         // Neither neighbor overlays current element.  We are on the uncut element ahead of the tip.
         // Flag neighbors as crack tip split elements and add this element as their crack tip
         // neighbor.
         if (_edge_neighbors[edge_iter][0]->overlaysElement(this) ||
             _edge_neighbors[edge_iter][1]->overlaysElement(this))
           EFAError("Element has a neighbor that overlays itself");
  
         // Make sure the current elment hasn't been flagged as a tip element
         if (_crack_tip_split_element)
           EFAError("crack_tip_split_element already flagged.  In elem: ",
                    _id,
                    " flags: ",
                    _crack_tip_split_element,
                    " ",
                    _edge_neighbors[edge_iter][0]->isCrackTipSplit(),
                    " ",
                    _edge_neighbors[edge_iter][1]->isCrackTipSplit());
  
         _edge_neighbors[edge_iter][0]->setCrackTipSplit();
         _edge_neighbors[edge_iter][1]->setCrackTipSplit();
  
         _edge_neighbors[edge_iter][0]->addCrackTipNeighbor(this);
         _edge_neighbors[edge_iter][1]->addCrackTipNeighbor(this);
       }
     } // edge_iter
   }
 }

◆ isCrackTipElement()

bool EFAElement2D::isCrackTipElement ( ) const

virtual

Implements EFAElement.

Definition at line 775 of file EFAElement2D.C.

 {
   return fragmentHasTipEdges();
 }

Referenced by getCrackTipSplitElementID(), initCrackTip(), and shouldDuplicateForCrackTip().

◆ isCrackTipSplit()

bool EFAElement::isCrackTipSplit ( ) const

inherited

Definition at line 136 of file EFAElement.C.

 {
   return _crack_tip_split_element;
 }

Referenced by getCrackTipSplitElementID(), initCrackTip(), and EFAElement3D::initCrackTip().

◆ isEdgePhantom()

bool EFAElement2D::isEdgePhantom ( unsigned int edge_id ) const

Definition at line 1537 of file EFAElement2D.C.

 {
   bool is_phantom = false;
   if (_fragments.size() > 0)
   {
     bool contain_frag_edge = false;
     for (unsigned int i = 0; i < _fragments.size(); ++i)
     {
       for (unsigned int j = 0; j < _fragments[i]->numEdges(); ++j)
       {
         if (_edges[edge_id]->containsEdge(*_fragments[i]->getEdge(j)))
         {
           contain_frag_edge = true;
           break;
         }
       } // j
       if (contain_frag_edge)
         break;
     } // i
     if (!contain_frag_edge)
       is_phantom = true;
   }
   return is_phantom;
 }

Referenced by XFEM::correctCrackExtensionDirection(), XFEM::markCutEdgesByGeometry(), and XFEM::markCutEdgesByState().

◆ isFinalCut()

bool EFAElement2D::isFinalCut ( ) const

virtual

Implements EFAElement.

Definition at line 791 of file EFAElement2D.C.

 {
   // if an element has been cut twice its fragment must have two interior edges
   bool cut_twice = false;
   if (_fragments.size() > 0)
   {
     unsigned int num_interior_edges = 0;
     for (unsigned int i = 0; i < _fragments[0]->numEdges(); ++i)
     {
       if (_fragments[0]->isEdgeInterior(i))
         num_interior_edges += 1;
     }
     if (num_interior_edges == 2)
       cut_twice = true;
   }
   return cut_twice;
 }

Referenced by GeometricCutUserObject::execute(), and XFEM::markCutEdgesByState().

◆ isPartial()

bool EFAElement2D::isPartial ( ) const

virtual

Implements EFAElement.

Definition at line 208 of file EFAElement2D.C.

 {
   bool partial = false;
   if (_fragments.size() > 0)
   {
     for (unsigned int i = 0; i < _num_edges; ++i)
     {
       bool node_in_frag = false;
       for (unsigned int j = 0; j < _fragments.size(); ++j)
       {
         if (_fragments[j]->containsNode(_nodes[i]))
         {
           node_in_frag = true;
           break;
         }
       } // j
       if (!node_in_frag)
       {
         partial = true;
         break;
       }
     } // i
   }
   return partial;
 }

Referenced by branchingSplit(), XFEMCutElem2D::computeMomentFittingWeights(), and updateFragments().

◆ mapParametricCoordFrom1Dto2D()

void EFAElement2D::mapParametricCoordFrom1Dto2D	(	unsigned int	edge_id,
		double	xi_1d,
		std::vector< double > &	para_coor
	)		const

private

Definition at line 2006 of file EFAElement2D.C.

 {
   para_coor.resize(2, 0.0);
   if (_num_edges == 4)
   {
     if (edge_id == 0)
     {
       para_coor[0] = xi_1d;
       para_coor[1] = -1.0;
     }
     else if (edge_id == 1)
     {
       para_coor[0] = 1.0;
       para_coor[1] = xi_1d;
     }
     else if (edge_id == 2)
     {
       para_coor[0] = -xi_1d;
       para_coor[1] = 1.0;
     }
     else if (edge_id == 3)
     {
       para_coor[0] = -1.0;
       para_coor[1] = -xi_1d;
     }
     else
       EFAError("edge_id out of bounds");
   }
   else if (_num_edges == 3)
   {
     if (edge_id == 0)
     {
       para_coor[0] = 0.5 * (1.0 - xi_1d);
       para_coor[1] = 0.5 * (1.0 + xi_1d);
     }
     else if (edge_id == 1)
     {
       para_coor[0] = 0.0;
       para_coor[1] = 0.5 * (1.0 - xi_1d);
     }
     else if (edge_id == 2)
     {
       para_coor[0] = 0.5 * (1.0 + xi_1d);
       para_coor[1] = 0.0;
     }
     else
       EFAError("edge_id out of bounds");
   }
   else
     EFAError("unknown element for 2D");
 }

Referenced by getEdgeNodeParametricCoordinate().

◆ mergeNodes()

void EFAElement::mergeNodes	(	EFANode *&	childNode,
		EFANode *&	childOfNeighborNode,
		EFAElement *	childOfNeighborElem,
		std::map< unsigned int, EFANode * > &	PermanentNodes,
		std::map< unsigned int, EFANode * > &	TempNodes
	)

protectedinherited

Definition at line 248 of file EFAElement.C.

 {
   // Important: this must be run only on child elements that were just created
   if (!_parent)
     EFAError("no getParent element for child element ", _id, " in mergeNodes");
  
   EFAElement * childElem = this;
   if (childNode != childOfNeighborNode)
   {
     if (childNode->category() == EFANode::N_CATEGORY_PERMANENT)
     {
       if (childOfNeighborNode->category() == EFANode::N_CATEGORY_PERMANENT)
       {
         if (childOfNeighborNode->parent() == childNode) // merge into childNode
         {
           childOfNeighborElem->switchNode(childNode, childOfNeighborNode, true);
           if (!Efa::deleteFromMap(PermanentNodes, childOfNeighborNode))
           {
             EFAError("Attempted to delete node: ",
                      childOfNeighborNode->id(),
                      " from PermanentNodes, but couldn't find it");
           }
           childOfNeighborNode = childNode;
         }
         else if (childNode->parent() == childOfNeighborNode) // merge into childOfNeighborNode
         {
           childElem->switchNode(childOfNeighborNode, childNode, true);
           if (!Efa::deleteFromMap(PermanentNodes, childNode))
           {
             EFAError("Attempted to delete node: ",
                      childNode->id(),
                      " from PermanentNodes, but couldn't find it");
           }
           childNode = childOfNeighborNode;
         }
         else if (childNode->parent() != NULL &&
                  childNode->parent() == childOfNeighborNode->parent())
         {
           // merge into childNode if both nodes are child permanent
           childOfNeighborElem->switchNode(childNode, childOfNeighborNode, true);
           if (!Efa::deleteFromMap(PermanentNodes,
                                   childOfNeighborNode)) // delete childOfNeighborNode
           {
             EFAError("Attempted to delete node: ",
                      childOfNeighborNode->id(),
                      " from PermanentNodes, but couldn't find it");
           }
           childOfNeighborNode = childNode;
         }
         else
         {
           EFAError("Attempting to merge nodes: ",
                    childNode->id(),
                    " and ",
                    childOfNeighborNode->id(),
                    " but both are permanent themselves");
         }
       }
       else
       {
         if (childOfNeighborNode->parent() != childNode &&
             childOfNeighborNode->parent() != childNode->parent())
         {
           EFAError("Attempting to merge nodes ",
                    childOfNeighborNode->idCatString(),
                    " and ",
                    childNode->idCatString(),
                    " but neither the 2nd node nor its parent is parent of the 1st");
         }
         childOfNeighborElem->switchNode(childNode, childOfNeighborNode, true);
         if (!Efa::deleteFromMap(TempNodes, childOfNeighborNode))
           EFAError("Attempted to delete node: ",
                    childOfNeighborNode->id(),
                    " from TempNodes, but couldn't find it");
         childOfNeighborNode = childNode;
       }
     }
     else if (childOfNeighborNode->category() == EFANode::N_CATEGORY_PERMANENT)
     {
       if (childNode->parent() != childOfNeighborNode &&
           childNode->parent() != childOfNeighborNode->parent())
       {
         EFAError("Attempting to merge nodes ",
                  childNode->id(),
                  " and ",
                  childOfNeighborNode->id(),
                  " but neither the 2nd node nor its parent is parent of the 1st");
       }
       childElem->switchNode(childOfNeighborNode, childNode, true);
       if (!Efa::deleteFromMap(TempNodes, childNode))
         EFAError(
             "Attempted to delete node: ", childNode->id(), " from TempNodes, but couldn't find it");
       childNode = childOfNeighborNode;
     }
     else // both nodes are temporary -- create new permanent node and delete temporary nodes
     {
       unsigned int new_node_id = Efa::getNewID(PermanentNodes);
       EFANode * newNode =
           new EFANode(new_node_id, EFANode::N_CATEGORY_PERMANENT, childNode->parent());
       PermanentNodes.insert(std::make_pair(new_node_id, newNode));
  
       childOfNeighborElem->switchNode(newNode, childOfNeighborNode, true);
       childElem->switchNode(newNode, childNode, true);
  
       if (childNode->parent() != childOfNeighborNode->parent())
       {
         EFAError("Attempting to merge nodes ",
                  childNode->id(),
                  " and ",
                  childOfNeighborNode->id(),
                  " but they don't share a common parent");
       }
  
       if (!Efa::deleteFromMap(TempNodes, childOfNeighborNode))
         EFAError("Attempted to delete node: ",
                  childOfNeighborNode->id(),
                  " from TempNodes, but couldn't find it");
       if (!Efa::deleteFromMap(TempNodes, childNode))
         EFAError(
             "Attempted to delete node: ", childNode->id(), " from TempNodes, but couldn't find it");
       childOfNeighborNode = newNode;
       childNode = newNode;
     }
   }
 }

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

◆ neighborSanityCheck()

void EFAElement2D::neighborSanityCheck ( ) const

virtual

Implements EFAElement.

Definition at line 523 of file EFAElement2D.C.

 {
   for (unsigned int edge_iter = 0; edge_iter < _num_edges; ++edge_iter)
   {
     for (unsigned int en_iter = 0; en_iter < _edge_neighbors[edge_iter].size(); ++en_iter)
     {
       EFAElement2D * neigh_elem = _edge_neighbors[edge_iter][en_iter];
       if (neigh_elem != NULL)
       {
         bool found_neighbor = false;
         for (unsigned int edge_iter2 = 0; edge_iter2 < neigh_elem->numEdges(); ++edge_iter2)
         {
           for (unsigned int en_iter2 = 0; en_iter2 < neigh_elem->numEdgeNeighbors(edge_iter2);
                ++en_iter2)
           {
             if (neigh_elem->getEdgeNeighbor(edge_iter2, en_iter2) == this)
             {
               if ((en_iter2 > 1) && (en_iter > 1))
                 EFAError(
                     "Element and neighbor element cannot both have >1 neighbors on a common edge");
               found_neighbor = true;
               break;
             }
           }
         }
         if (!found_neighbor)
           EFAError("Neighbor element doesn't recognize current element as neighbor");
       }
     }
   }
 }

◆ numChildren()

unsigned int EFAElement::numChildren ( ) const

inherited

Definition at line 197 of file EFAElement.C.

 {
   return _children.size();
 }

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

◆ numCrackTipNeighbors()

unsigned int EFAElement::numCrackTipNeighbors ( ) const

inherited

Definition at line 142 of file EFAElement.C.

 {
   return _crack_tip_neighbors.size();
 }

◆ numEdgeNeighbors()

unsigned int EFAElement2D::numEdgeNeighbors ( unsigned int edge_id ) const

Definition at line 1563 of file EFAElement2D.C.

 {
   unsigned int num_neighbors = 0;
   if (_edge_neighbors[edge_id][0])
     num_neighbors = _edge_neighbors[edge_id].size();
   return num_neighbors;
 }

Referenced by addEdgeCut(), connectNeighbors(), neighborSanityCheck(), printElement(), shouldDuplicateCrackTipSplitElement(), shouldDuplicateForPhantomCorner(), and willCrackTipExtend().

◆ numEdges()

unsigned int EFAElement2D::numEdges ( ) const

Definition at line 1447 of file EFAElement2D.C.

 {
   return _num_edges;
 }

Referenced by EFAFragment2D::combineTipEdges(), XFEM::correctCrackExtensionDirection(), EFAFragment2D::EFAFragment2D(), EFAFragment2D::isEdgeInterior(), XFEM::markCutEdgesByState(), neighborSanityCheck(), overlaysElement(), printElement(), shouldDuplicateCrackTipSplitElement(), and shouldDuplicateForPhantomCorner().

◆ numFragments()

unsigned int EFAElement2D::numFragments ( ) const

virtual

Implements EFAElement.

Definition at line 202 of file EFAElement2D.C.

 {
   return _fragments.size();
 }

Referenced by ElementFragmentAlgorithm::addElemNodeIntersection(), connectNeighbors(), EFAFragment2D::EFAFragment2D(), GeometricCutUserObject::execute(), XFEM::getFragmentEdges(), XFEM::markCutEdgesByState(), restoreFragment(), setupNeighbors(), shouldDuplicateCrackTipSplitElement(), shouldDuplicateForPhantomCorner(), and willCrackTipExtend().

◆ numGeneralNeighbors()

unsigned int EFAElement::numGeneralNeighbors ( ) const

inherited

Definition at line 242 of file EFAElement.C.

 {
   return _general_neighbors.size();
 }

Referenced by switchNode(), and EFAElement3D::switchNode().

◆ numInteriorNodes()

unsigned int EFAElement2D::numInteriorNodes ( ) const

virtual

Implements EFAElement.

Definition at line 353 of file EFAElement2D.C.

 {
   return _interior_nodes.size();
 }

Referenced by fragmentSanityCheck(), EFAFragment2D::isSecondaryInteriorEdge(), and EFAFragment2D::removeInvalidEmbeddedNodes().

◆ numNodes()

unsigned int EFAElement::numNodes ( ) const

inherited

Definition at line 34 of file EFAElement.C.

 {
   return _num_nodes;
 }

Referenced by ElementFragmentAlgorithm::clearAncestry(), createChild(), EFAElement3D::createChild(), ElementFragmentAlgorithm::getElemIdByNodes(), overlaysElement(), restoreFragment(), and EFAElement3D::restoreFragment().

◆ overlaysElement()

bool EFAElement2D::overlaysElement ( const EFAElement2D * other_elem ) const

Definition at line 359 of file EFAElement2D.C.

 {
   bool overlays = false;
  
   if (other_elem->numEdges() != _num_edges)
     return overlays;
  
   std::vector<EFANode *> common_nodes = getCommonNodes(other_elem);
  
   // Find indices of common nodes
   if (common_nodes.size() == 2)
   {
     std::vector<EFANode *> common_nodes_vec(common_nodes.begin(), common_nodes.end());
  
     unsigned int e1n1idx = _num_edges + 1;
     unsigned int e1n2idx = _num_edges + 1;
     for (unsigned int i = 0; i < _num_edges; ++i)
     {
       if (_nodes[i] == common_nodes_vec[0])
       {
         e1n1idx = i;
       }
       else if (_nodes[i] == common_nodes_vec[1])
       {
         e1n2idx = i;
       }
     }
  
     if (e1n1idx > _num_edges || e1n2idx > _num_edges)
       EFAError("in overlays_elem() couldn't find common node");
  
     bool e1ascend = false;
     unsigned int e1n1idx_plus1(e1n1idx < (_num_edges - 1) ? e1n1idx + 1 : 0);
     unsigned int e1n1idx_minus1(e1n1idx > 0 ? e1n1idx - 1 : _num_edges - 1);
     if (e1n2idx == e1n1idx_plus1)
     {
       e1ascend = true;
     }
     else
     {
       if (e1n2idx != e1n1idx_minus1)
         EFAError("in overlays_elem() common nodes must be adjacent to each other");
     }
  
     unsigned int e2n1idx = _num_edges + 1;
     unsigned int e2n2idx = _num_edges + 1;
     for (unsigned int i = 0; i < _num_edges; ++i)
     {
       if (other_elem->getNode(i) == common_nodes_vec[0])
       {
         e2n1idx = i;
       }
       else if (other_elem->getNode(i) == common_nodes_vec[1])
       {
         e2n2idx = i;
       }
     }
     if (e2n1idx > other_elem->numNodes() || e2n2idx > other_elem->numNodes())
       EFAError("in overlays_elem() couldn't find common node");
  
     bool e2ascend = false;
     unsigned int e2n1idx_plus1(e2n1idx < (_num_edges - 1) ? e2n1idx + 1 : 0);
     unsigned int e2n1idx_minus1(e2n1idx > 0 ? e2n1idx - 1 : _num_edges - 1);
     if (e2n2idx == e2n1idx_plus1)
     {
       e2ascend = true;
     }
     else
     {
       if (e2n2idx != e2n1idx_minus1)
         EFAError("in overlays_elem() common nodes must be adjacent to each other");
     }
  
     // if indices both ascend or descend, they overlay
     if ((e1ascend && e2ascend) || (!e1ascend && !e2ascend))
     {
       overlays = true;
     }
   }
   else if (common_nodes.size() > 2)
   {
     // TODO: We probably need more error checking here.
     overlays = true;
   }
   return overlays;
 }

Referenced by initCrackTip(), and setupNeighbors().

◆ printElement()

void EFAElement2D::printElement ( std::ostream & ostream )

virtual

Implements EFAElement.

Definition at line 1312 of file EFAElement2D.C.

 {
   ostream << std::setw(4);
   ostream << _id << " | ";
   for (unsigned int j = 0; j < _num_nodes; ++j)
   {
     ostream << std::setw(5) << _nodes[j]->idCatString();
   }
  
   ostream << "  | ";
   for (unsigned int j = 0; j < _num_edges; ++j)
   {
     ostream << std::setw(4);
     if (_edges[j]->hasIntersection())
     {
       if (_edges[j]->numEmbeddedNodes() > 1)
       {
         ostream << "[";
         for (unsigned int k = 0; k < _edges[j]->numEmbeddedNodes(); ++k)
         {
           ostream << _edges[j]->getEmbeddedNode(k)->id();
           if (k == _edges[j]->numEmbeddedNodes() - 1)
             ostream << "]";
           else
             ostream << " ";
         }
       }
       else
         ostream << _edges[j]->getEmbeddedNode(0)->id() << " ";
     }
     else
       ostream << "  -- ";
   }
   ostream << "  | ";
   for (unsigned int j = 0; j < _num_edges; ++j)
   {
     if (numEdgeNeighbors(j) > 1)
     {
       ostream << "[";
       for (unsigned int k = 0; k < numEdgeNeighbors(j); ++k)
       {
         ostream << getEdgeNeighbor(j, k)->id();
         if (k == numEdgeNeighbors(j) - 1)
           ostream << "]";
         else
           ostream << " ";
       }
       ostream << " ";
     }
     else
     {
       ostream << std::setw(4);
       if (numEdgeNeighbors(j) == 1)
         ostream << getEdgeNeighbor(j, 0)->id() << " ";
       else
         ostream << "  -- ";
     }
   }
   ostream << "  | ";
   for (unsigned int j = 0; j < _fragments.size(); ++j)
   {
     ostream << std::setw(4);
     ostream << " " << j << " | ";
     for (unsigned int k = 0; k < _fragments[j]->numEdges(); ++k)
     {
       EFANode * prt_node = getFragmentEdge(j, k)->getNode(0);
       unsigned int kprev(k > 0 ? k - 1 : _fragments[j]->numEdges() - 1);
       if (!getFragmentEdge(j, kprev)->containsNode(prt_node))
         prt_node = getFragmentEdge(j, k)->getNode(1);
       ostream << std::setw(5) << prt_node->idCatString();
     }
   }
   ostream << std::endl;
 }

◆ printNodes()

void EFAElement::printNodes ( std::ostream & ostream ) const

inherited

Definition at line 61 of file EFAElement.C.

 {
   ostream << "***** nodes for element " << _id << " *****" << std::endl;
   for (unsigned int i = 0; i < _num_nodes; ++i)
     ostream << "addr " << _nodes[i] << ", ID " << _nodes[i]->idCatString() << ", category "
             << _nodes[i]->category() << std::endl;
 }

◆ removePhantomEmbeddedNode()

void EFAElement2D::removePhantomEmbeddedNode ( )

virtual

Implements EFAElement.

Definition at line 1151 of file EFAElement2D.C.

 {
   // remove the embedded nodes on edge that are not inside the real part
   if (_fragments.size() > 0)
   {
     for (unsigned int i = 0; i < _num_edges; ++i)
     {
       std::vector<EFANode *> nodes_to_delete;
       for (unsigned int j = 0; j < _edges[i]->numEmbeddedNodes(); ++j)
       {
         if (!_fragments[0]->containsNode(_edges[i]->getEmbeddedNode(j)))
           nodes_to_delete.push_back(_edges[i]->getEmbeddedNode(j));
       }
       for (unsigned int j = 0; j < nodes_to_delete.size(); ++j)
         _edges[i]->removeEmbeddedNode(nodes_to_delete[j]);
     } // i
   }
 }

Referenced by createChild().

◆ restoreFragment()

void EFAElement2D::restoreFragment ( const EFAElement *const from_elem )

virtual

Implements EFAElement.

Definition at line 944 of file EFAElement2D.C.

 {
   const EFAElement2D * from_elem2d = dynamic_cast<const EFAElement2D *>(from_elem);
   if (!from_elem2d)
     EFAError("from_elem is not of EFAelement2D type");
  
   // restore fragments
   if (_fragments.size() != 0)
     EFAError("in restoreFragmentInfo elements must not have any pre-existing fragments");
   for (unsigned int i = 0; i < from_elem2d->numFragments(); ++i)
     _fragments.push_back(new EFAFragment2D(this, true, from_elem2d, i));
  
   // restore interior nodes
   if (_interior_nodes.size() != 0)
     EFAError("in restoreFragmentInfo elements must not have any pre-exsiting interior nodes");
   for (unsigned int i = 0; i < from_elem2d->_interior_nodes.size(); ++i)
     _interior_nodes.push_back(new EFAFaceNode(*from_elem2d->_interior_nodes[i]));
  
   // restore edge intersections
   if (getNumCuts() != 0)
     EFAError("In restoreEdgeIntersection: edge cuts already exist in element ", _id);
   for (unsigned int i = 0; i < _num_edges; ++i)
   {
     if (from_elem2d->_edges[i]->hasIntersection())
       _edges[i]->copyIntersection(*from_elem2d->_edges[i], 0);
     if (_edges[i]->numEmbeddedNodes() > 2)
       EFAError("elem ", _id, " has an edge with >2 cuts");
   }
  
   // replace all local nodes with global nodes
   for (unsigned int i = 0; i < from_elem2d->numNodes(); ++i)
   {
     if (from_elem2d->_nodes[i]->category() == EFANode::N_CATEGORY_LOCAL_INDEX)
       switchNode(
           _nodes[i], from_elem2d->_nodes[i], false); // EFAelement is not a child of any parent
     else
       EFAError("In restoreFragmentInfo all of from_elem's nodes must be local");
   }
 }

◆ setCrackTipSplit()

void EFAElement::setCrackTipSplit ( )

inherited

Definition at line 130 of file EFAElement.C.

 {
   _crack_tip_split_element = true;
 }

◆ setEdge()

void EFAElement2D::setEdge	(	unsigned int	edge_id,
		EFAEdge *	edge
	)

Definition at line 1453 of file EFAElement2D.C.

 {
   _edges[edge_id] = edge;
 }

Referenced by createChild().

◆ setLocalCoordinates()

void EFAElement2D::setLocalCoordinates ( )

private

Definition at line 141 of file EFAElement2D.C.

 {
   if (_num_edges == 4)
   {
     /*
                 3     6     2
     QUAD9(QUAD8): o-----o-----o
                   |           |
                   |     8     |
                 7 o     o     o 5
                   |           |
                   |           |
                   o-----o-----o
                   0     4     1
  
     */
     _local_node_coor.resize(_num_nodes);
     _local_node_coor[0] = EFAPoint(0.0, 0.0, 0.0);
     _local_node_coor[1] = EFAPoint(1.0, 0.0, 0.0);
     _local_node_coor[2] = EFAPoint(1.0, 1.0, 0.0);
     _local_node_coor[3] = EFAPoint(0.0, 1.0, 0.0);
  
     if (_num_nodes > 4)
     {
       _local_node_coor[4] = EFAPoint(0.5, 0.0, 0.0);
       _local_node_coor[5] = EFAPoint(1.0, 0.5, 0.0);
       _local_node_coor[6] = EFAPoint(0.5, 1.0, 0.0);
       _local_node_coor[7] = EFAPoint(0.0, 0.5, 0.0);
     }
  
     if (_num_nodes > 8)
       _local_node_coor[8] = EFAPoint(0.5, 0.5, 0.0);
   }
   else
   {
     /*
       TRI6: 2
             o
             | \
             |   \
           5 o     o 4
             |       \
             |         \
             o-----o-----o
             0     3     1
     */
     _local_node_coor.resize(_num_nodes);
     _local_node_coor[0] = EFAPoint(0.0, 0.0, 0.0);
     _local_node_coor[1] = EFAPoint(1.0, 0.0, 0.0);
     _local_node_coor[2] = EFAPoint(0.0, 1.0, 0.0);
  
     if (_num_nodes > 3)
     {
       _local_node_coor[3] = EFAPoint(0.5, 0.0, 0.0);
       _local_node_coor[4] = EFAPoint(0.5, 0.5, 0.0);
       _local_node_coor[5] = EFAPoint(0.0, 0.5, 0.0);
     }
   }
 }

Referenced by EFAElement2D().

◆ setNode()

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

inherited

Definition at line 40 of file EFAElement.C.

 {
   _nodes[node_id] = node;
 }

Referenced by ElementFragmentAlgorithm::add2DElement(), ElementFragmentAlgorithm::add2DElements(), ElementFragmentAlgorithm::add3DElement(), createChild(), EFAElement3D::createChild(), and EFAElement3D::createFaces().

◆ setParent()

void EFAElement::setParent ( EFAElement * parent )

inherited

Definition at line 191 of file EFAElement.C.

 {
   _parent = parent;
 }

Referenced by createChild(), and EFAElement3D::createChild().

◆ setupNeighbors()

void EFAElement2D::setupNeighbors ( std::map< EFANode *, std::set< EFAElement * >> & InverseConnectivityMap )

virtual

Implements EFAElement.

Definition at line 467 of file EFAElement2D.C.

 {
   findGeneralNeighbors(InverseConnectivityMap);
   for (unsigned int eit2 = 0; eit2 < _general_neighbors.size(); ++eit2)
   {
     EFAElement2D * neigh_elem = dynamic_cast<EFAElement2D *>(_general_neighbors[eit2]);
     if (!neigh_elem)
       EFAError("neighbor_elem is not of EFAelement2D type");
  
     std::vector<EFANode *> common_nodes = getCommonNodes(neigh_elem);
     if (common_nodes.size() >= 2)
     {
       for (unsigned int edge_iter = 0; edge_iter < _num_edges; ++edge_iter)
       {
         std::set<EFANode *> edge_nodes = getEdgeNodes(edge_iter);
         bool is_edge_neighbor = false;
  
         // Must share nodes on this edge
         if (Efa::numCommonElems(edge_nodes, common_nodes) == 2 && (!overlaysElement(neigh_elem)))
         {
           // Fragments must match up.
           if ((_fragments.size() > 1) || (neigh_elem->numFragments() > 1))
             EFAError("in updateEdgeNeighbors: Cannot have more than 1 fragment");
           else if ((_fragments.size() == 1) && (neigh_elem->numFragments() == 1))
           {
             if (_fragments[0]->isConnected(neigh_elem->getFragment(0)))
               is_edge_neighbor = true;
           }
           else // If there are no fragments to match up, consider them neighbors
             is_edge_neighbor = true;
         }
  
         if (is_edge_neighbor)
         {
           if (_edge_neighbors[edge_iter][0])
           {
             if (_edge_neighbors[edge_iter].size() > 1)
             {
               EFAError("Element ",
                        _id,
                        " already has 2 edge neighbors: ",
                        _edge_neighbors[edge_iter][0]->id(),
                        " ",
                        _edge_neighbors[edge_iter][1]->id());
             }
             _edge_neighbors[edge_iter].push_back(neigh_elem);
           }
           else
             _edge_neighbors[edge_iter][0] = neigh_elem;
         }
       }
     }
   }
 }

◆ shouldDuplicateCrackTipSplitElement()

bool EFAElement2D::shouldDuplicateCrackTipSplitElement ( const std::set< EFAElement * > & CrackTipElements )

virtual

Implements EFAElement.

Definition at line 639 of file EFAElement2D.C.

 {
   // Determine whether element at crack tip should be duplicated.  It should be duplicated
   // if the crack will extend into the next element, or if it has a non-physical node
   // connected to a face where a crack terminates, but will extend.
  
   bool should_duplicate = false;
   if (_fragments.size() == 1)
   {
     std::vector<unsigned int> split_neighbors;
     if (willCrackTipExtend(split_neighbors))
       should_duplicate = true;
     else
     {
       // The element may not be at the crack tip, but could have a non-physical node
       // connected to a crack tip face (on a neighbor element) that will be split.  We need to
       // duplicate in that case as well.
       std::set<EFANode *> non_physical_nodes;
       getNonPhysicalNodes(non_physical_nodes);
  
       for (unsigned int eit = 0; eit < _general_neighbors.size(); ++eit)
       {
         EFAElement2D * neigh_elem = dynamic_cast<EFAElement2D *>(_general_neighbors[eit]);
         if (!neigh_elem)
           EFAError("general elem is not of type EFAelement2D");
  
         // check if a general neighbor is an old crack tip element and will be split
         std::set<EFAElement *>::iterator sit;
         sit = CrackTipElements.find(neigh_elem);
         if (sit != CrackTipElements.end() && neigh_elem->numFragments() > 1)
         {
           for (unsigned int i = 0; i < neigh_elem->numEdges(); ++i)
           {
             std::set<EFANode *> neigh_edge_nodes = neigh_elem->getEdgeNodes(i);
             if (neigh_elem->numEdgeNeighbors(i) == 2 &&
                 Efa::numCommonElems(neigh_edge_nodes, non_physical_nodes) > 0)
             {
               should_duplicate = true;
               break;
             }
           } // i
         }
         if (should_duplicate)
           break;
       } // eit
     }
   } // IF one fragment
   return should_duplicate;
 }

Referenced by shouldDuplicateForCrackTip().

◆ shouldDuplicateForCrackTip()

bool EFAElement2D::shouldDuplicateForCrackTip ( const std::set< EFAElement * > & CrackTipElements )

virtual

Implements EFAElement.

Definition at line 615 of file EFAElement2D.C.

 {
   // This method is called in createChildElements()
   // Only duplicate when
   // 1) currElem will be a NEW crack tip element
   // 2) currElem is a crack tip split element at last time step and the tip will extend
   // 3) currElem is the neighbor of a to-be-second-split element which has another neighbor
   //    sharing a phantom node with currElem
   bool should_duplicate = false;
   if (_fragments.size() == 1)
   {
     std::set<EFAElement *>::iterator sit;
     sit = CrackTipElements.find(this);
     if (sit == CrackTipElements.end() && isCrackTipElement())
       should_duplicate = true;
     else if (shouldDuplicateCrackTipSplitElement(CrackTipElements))
       should_duplicate = true;
     else if (shouldDuplicateForPhantomCorner())
       should_duplicate = true;
   }
   return should_duplicate;
 }

Referenced by createChild().

◆ shouldDuplicateForPhantomCorner()

bool EFAElement2D::shouldDuplicateForPhantomCorner ( )

virtual

Implements EFAElement.

Definition at line 690 of file EFAElement2D.C.

 {
   // if a partial element will be split for a second time and it has two neighbor elements
   // sharing one phantom node with the aforementioned partial element, then the two neighbor
   // elements should be duplicated
   bool should_duplicate = false;
   if (_fragments.size() == 1 && (!_crack_tip_split_element))
   {
     for (unsigned int i = 0; i < _num_edges; ++i)
     {
       std::set<EFANode *> phantom_nodes = getPhantomNodeOnEdge(i);
       if (phantom_nodes.size() > 0 && numEdgeNeighbors(i) == 1)
       {
         EFAElement2D * neighbor_elem = _edge_neighbors[i][0];
         if (neighbor_elem->numFragments() > 1) // neighbor will be split
         {
           for (unsigned int j = 0; j < neighbor_elem->numEdges(); ++j)
           {
             if (!neighbor_elem->getEdge(j)->equivalent(*_edges[i]) &&
                 neighbor_elem->numEdgeNeighbors(j) > 0)
             {
               std::set<EFANode *> neigh_phantom_nodes = neighbor_elem->getPhantomNodeOnEdge(j);
               if (Efa::numCommonElems(phantom_nodes, neigh_phantom_nodes) > 0)
               {
                 should_duplicate = true;
                 break;
               }
             }
           } // j
         }
       }
       if (should_duplicate)
         break;
     } // i
   }
   return should_duplicate;
 }

Referenced by shouldDuplicateForCrackTip().

◆ switchEmbeddedNode()

void EFAElement2D::switchEmbeddedNode	(	EFANode *	new_node,
		EFANode *	old_node
	)

virtual

Implements EFAElement.

Definition at line 289 of file EFAElement2D.C.

 {
   for (unsigned int i = 0; i < _num_edges; ++i)
     _edges[i]->switchNode(new_emb_node, old_emb_node);
   for (unsigned int i = 0; i < _interior_nodes.size(); ++i)
     _interior_nodes[i]->switchNode(new_emb_node, old_emb_node);
   for (unsigned int i = 0; i < _fragments.size(); ++i)
     _fragments[i]->switchNode(new_emb_node, old_emb_node);
 }

◆ switchNode()

void EFAElement2D::switchNode	(	EFANode *	new_node,
		EFANode *	old_node,
		bool	descend_to_parent
	)

virtual

Implements EFAElement.

Definition at line 262 of file EFAElement2D.C.

 {
   // We are not switching any embedded nodes here
   for (unsigned int i = 0; i < _num_nodes; ++i)
   {
     if (_nodes[i] == old_node)
       _nodes[i] = new_node;
   }
   for (unsigned int i = 0; i < _fragments.size(); ++i)
     _fragments[i]->switchNode(new_node, old_node);
  
   for (unsigned int i = 0; i < _edges.size(); ++i)
     _edges[i]->switchNode(new_node, old_node);
  
   if (_parent && descend_to_parent)
   {
     _parent->switchNode(new_node, old_node, false);
     for (unsigned int i = 0; i < _parent->numGeneralNeighbors(); ++i)
     {
       EFAElement * neigh_elem = _parent->getGeneralNeighbor(i); // generalized neighbor element
       for (unsigned int k = 0; k < neigh_elem->numChildren(); ++k)
         neigh_elem->getChild(k)->switchNode(new_node, old_node, false);
     }
   }
 }

Referenced by connectNeighbors(), EFAElement2D(), restoreFragment(), switchEmbeddedNode(), and updateFragmentNode().

◆ updateFragmentNode()

void EFAElement2D::updateFragmentNode ( )

virtual

Implements EFAElement.

Definition at line 1301 of file EFAElement2D.C.

 {
   for (unsigned int j = 0; j < _num_nodes; ++j)
   {
     if (_nodes[j]->parent() != NULL &&
         _nodes[j]->parent()->category() == EFANode::N_CATEGORY_EMBEDDED_PERMANENT)
       switchNode(_nodes[j], _nodes[j]->parent(), false);
   }
 }

◆ updateFragments()

void EFAElement2D::updateFragments	(	const std::set< EFAElement * > &	CrackTipElements,
		std::map< unsigned int, EFANode * > &	EmbeddedNodes
	)

virtual

Implements EFAElement.

Definition at line 810 of file EFAElement2D.C.

 {
   // combine the crack-tip edges in a fragment to a single intersected edge
   std::set<EFAElement *>::iterator sit;
   sit = CrackTipElements.find(this);
   if (sit != CrackTipElements.end()) // curr_elem is a crack tip element
   {
     if (_fragments.size() == 1)
       _fragments[0]->combineTipEdges();
     else
       EFAError("crack tip elem ", _id, " must have 1 fragment");
   }
  
   // if a fragment only has 1 intersection which is in an interior edge
   // remove this embedded node (MUST DO THIS AFTER combine_tip_edges())
   if (_fragments.size() == 1)
     _fragments[0]->removeInvalidEmbeddedNodes(EmbeddedNodes);
  
   // for an element with no fragment, create one fragment identical to the element
   if (_fragments.size() == 0)
     _fragments.push_back(new EFAFragment2D(this, true, this));
   if (_fragments.size() != 1)
     EFAError("Element ", _id, " must have 1 fragment at this point");
  
   // count fragment's cut edges
   unsigned int num_cut_frag_edges = _fragments[0]->getNumCuts();
   unsigned int num_cut_nodes = _fragments[0]->getNumCutNodes();
   unsigned int num_frag_edges = _fragments[0]->numEdges();
   if (num_cut_frag_edges > 3)
     EFAError("In element ", _id, " there are more than 2 cut fragment edges");
  
   if (num_cut_frag_edges == 0 && num_cut_nodes == 0)
   {
     if (!isPartial()) // delete the temp frag for an uncut elem
     {
       delete _fragments[0];
       _fragments.clear();
     }
     // Element has already been cut. Don't recreate fragments because we
     // would create multiple fragments to cover the entire element and
     // lose the information about what part of this element is physical.
     return;
   }
  
   // split one fragment into one, two or three new fragments
   std::vector<EFAFragment2D *> new_frags;
   if (num_cut_frag_edges == 3)
     new_frags = branchingSplit(EmbeddedNodes);
   else
     new_frags = _fragments[0]->split();
  
   delete _fragments[0]; // delete the old fragment
   _fragments.clear();
   for (unsigned int i = 0; i < new_frags.size(); ++i)
     _fragments.push_back(new_frags[i]);
  
   fragmentSanityCheck(num_frag_edges, num_cut_frag_edges);
 }

◆ willCrackTipExtend()

bool EFAElement2D::willCrackTipExtend ( std::vector< unsigned int > & split_neighbors ) const

virtual

Implements EFAElement.

Definition at line 729 of file EFAElement2D.C.

 {
   // Determine whether the current element is a crack tip element for which the crack will
   // extend into the next element.
   // N.B. this is called at the beginning of createChildElements
   bool will_extend = false;
   if (_fragments.size() == 1 && _crack_tip_split_element)
   {
     for (unsigned int i = 0; i < _crack_tip_neighbors.size(); ++i)
     {
       unsigned int neigh_idx = _crack_tip_neighbors[i];
       if (numEdgeNeighbors(neigh_idx) != 1)
         EFAError("in will_crack_tip_extend() element: ",
                  _id,
                  " has: ",
                  _edge_neighbors[neigh_idx].size(),
                  " on edge: ",
                  neigh_idx);
  
       EFAElement2D * neighbor_elem = _edge_neighbors[neigh_idx][0];
       if (neighbor_elem->numFragments() > 2)
         EFAError("in will_crack_tip_extend() element: ",
                  neighbor_elem->id(),
                  " has: ",
                  neighbor_elem->numFragments(),
                  " fragments");
       else if (neighbor_elem->numFragments() == 2)
       {
         EFAFragment2D * frag1 = neighbor_elem->getFragment(0);
         EFAFragment2D * frag2 = neighbor_elem->getFragment(1);
         std::vector<EFANode *> neigh_cut_nodes = frag1->getCommonNodes(frag2);
         if (neigh_cut_nodes.size() != 2)
           EFAError("2 frags in a elem does not share 2 common nodes");
         if (_edges[neigh_idx]->isEmbeddedNode(neigh_cut_nodes[0]) ||
             _edges[neigh_idx]->isEmbeddedNode(neigh_cut_nodes[1]))
         {
           split_neighbors.push_back(neigh_idx);
           will_extend = true;
         }
       }
     } // i
   }
   return will_extend;
 }

Referenced by shouldDuplicateCrackTipSplitElement().

Member Data Documentation

◆ _children

std::vector<EFAElement *> EFAElement::_children

protectedinherited

Definition at line 32 of file EFAElement.h.

Referenced by EFAElement::addChild(), EFAElement::clearParentAndChildren(), createChild(), EFAElement3D::createChild(), EFAElement::getChild(), and EFAElement::numChildren().

◆ _crack_tip_neighbors

std::vector<unsigned int> EFAElement::_crack_tip_neighbors

protectedinherited

Definition at line 34 of file EFAElement.h.

Referenced by EFAElement::addCrackTipNeighbor(), EFAElement::getCrackTipNeighbor(), EFAElement::numCrackTipNeighbors(), willCrackTipExtend(), and EFAElement3D::willCrackTipExtend().

◆ _crack_tip_split_element

bool EFAElement::_crack_tip_split_element

protectedinherited

Definition at line 33 of file EFAElement.h.

Referenced by initCrackTip(), EFAElement3D::initCrackTip(), EFAElement::isCrackTipSplit(), EFAElement::setCrackTipSplit(), shouldDuplicateForPhantomCorner(), EFAElement3D::shouldDuplicateForPhantomCorner(), willCrackTipExtend(), and EFAElement3D::willCrackTipExtend().

◆ _edge_neighbors

std::vector<std::vector<EFAElement2D *> > EFAElement2D::_edge_neighbors

private

Definition at line 33 of file EFAElement2D.h.

Referenced by clearNeighbors(), EFAElement2D(), getCrackTipSplitElementID(), getEdgeNeighbor(), getNeighborIndex(), initCrackTip(), neighborSanityCheck(), numEdgeNeighbors(), setupNeighbors(), shouldDuplicateForPhantomCorner(), and willCrackTipExtend().

◆ _edges

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

private

◆ _fragments

std::vector<EFAFragment2D *> EFAElement2D::_fragments

private

◆ _general_neighbors

std::vector<EFAElement *> EFAElement::_general_neighbors

protectedinherited

Definition at line 36 of file EFAElement.h.

Referenced by clearNeighbors(), EFAElement3D::clearNeighbors(), EFAElement::findGeneralNeighbors(), EFAElement::getGeneralNeighbor(), EFAElement::numGeneralNeighbors(), setupNeighbors(), EFAElement3D::setupNeighbors(), shouldDuplicateCrackTipSplitElement(), and EFAElement3D::shouldDuplicateCrackTipSplitElement().

◆ _id

unsigned int EFAElement::_id

protectedinherited

◆ _interior_nodes

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

private

Definition at line 32 of file EFAElement2D.h.

Referenced by addFragmentEdgeCut(), branchingSplit(), createChild(), deleteInteriorNodes(), EFAElement2D(), getInteriorNode(), getMasterInfo(), numInteriorNodes(), restoreFragment(), switchEmbeddedNode(), and ~EFAElement2D().

◆ _local_node_coor

std::vector<EFAPoint> EFAElement2D::_local_node_coor

private

Definition at line 35 of file EFAElement2D.h.

Referenced by createChild(), EFAElement2D(), and setLocalCoordinates().

◆ _local_nodes

std::vector<EFANode *> EFAElement::_local_nodes

protectedinherited

Definition at line 30 of file EFAElement.h.

Referenced by EFAElement2D(), EFAElement3D::EFAElement3D(), ~EFAElement2D(), and EFAElement3D::~EFAElement3D().

◆ _nodes

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

protectedinherited

Definition at line 29 of file EFAElement.h.

Referenced by addNodeCut(), connectNeighbors(), EFAElement3D::connectNeighbors(), EFAElement::containsNode(), createChild(), EFAElement3D::createChild(), createEdges(), EFAElement3D::createFaces(), EFAElement::createLocalNodeFromGlobalNode(), EFAElement2D(), EFAElement3D::EFAElement3D(), EFAElement::findGeneralNeighbors(), getCommonNodes(), EFAElement3D::getCommonNodes(), EFAElement::getGlobalNodeFromLocalNode(), EFAElement::getLocalNodeIndex(), getMasterInfo(), EFAElement3D::getMasterInfo(), EFAElement::getNode(), getNonPhysicalNodes(), EFAElement3D::getNonPhysicalNodes(), isPartial(), EFAElement3D::isPartial(), overlaysElement(), printElement(), EFAElement::printNodes(), restoreFragment(), EFAElement3D::restoreFragment(), EFAElement::setNode(), switchNode(), EFAElement3D::switchNode(), and updateFragmentNode().

◆ _num_edges

unsigned int EFAElement2D::_num_edges

private

◆ _num_nodes

unsigned int EFAElement::_num_nodes

protectedinherited

◆ _parent

EFAElement* EFAElement::_parent

protectedinherited

Definition at line 31 of file EFAElement.h.

Referenced by EFAElement::clearParentAndChildren(), connectNeighbors(), EFAElement3D::connectNeighbors(), EFAElement::getParent(), EFAElement::mergeNodes(), EFAElement::setParent(), switchNode(), and EFAElement3D::switchNode().

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

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

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ EFAElement2D() [1/3]

◆ EFAElement2D() [2/3]

◆ EFAElement2D() [3/3]

◆ ~EFAElement2D()

Member Function Documentation

◆ addChild()

◆ addCrackTipNeighbor()

◆ addEdgeCut()

◆ addFragmentEdgeCut()

◆ addNodeCut()

◆ branchingSplit()

◆ clearNeighbors()

◆ clearParentAndChildren()

◆ connectNeighbors()

◆ containsNode()

◆ createChild()

◆ createEdges()

◆ createLocalNodeFromGlobalNode()

◆ deleteInteriorNodes()

◆ edgeContainsTip()

◆ findGeneralNeighbors()

◆ fragmentEdgeAlreadyCut()

◆ fragmentHasTipEdges()

◆ fragmentSanityCheck()

◆ getChild()

◆ getCommonNodes()

◆ getCrackTipNeighbor()

◆ getCrackTipSplitElementID()

◆ getEdge()

◆ getEdgeNeighbor()

◆ getEdgeNodeParametricCoordinate()

◆ getEdgeNodes()

◆ getFragment()

◆ getFragmentEdge()

◆ getFragmentEdgeID()

◆ getGeneralNeighbor()

◆ getGlobalNodeFromLocalNode()

◆ getInteriorNode()

◆ getLocalNodeIndex()

◆ getMasterInfo()

◆ getNeighborIndex()

◆ getNode()

◆ getNonPhysicalNodes()

◆ getNumCuts()

◆ getParent()

◆ getPhantomNodeOnEdge()

◆ getTipEdgeID()

◆ getTipEmbeddedNode()

◆ id()

◆ initCrackTip()

◆ isCrackTipElement()

◆ isCrackTipSplit()

◆ isEdgePhantom()

◆ isFinalCut()

◆ isPartial()

◆ mapParametricCoordFrom1Dto2D()

◆ mergeNodes()

◆ neighborSanityCheck()

◆ numChildren()

◆ numCrackTipNeighbors()

◆ numEdgeNeighbors()

◆ numEdges()

◆ numFragments()

◆ numGeneralNeighbors()

◆ numInteriorNodes()

◆ numNodes()

◆ overlaysElement()

◆ printElement()

◆ printNodes()

◆ removePhantomEmbeddedNode()

◆ restoreFragment()

◆ setCrackTipSplit()

◆ setEdge()