EFAElement2D Class Reference

#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) const
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
const std::vector< EFANode * > &	getNodes () 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 (const 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 || n_nodes == 7)
    _num_edges = 3;
  else
    EFAError(
        "In EFAelement2D the supported element types are QUAD4, QUAD8, QUAD9, TRI3, TRI6 and TRI7");
  setLocalCoordinates();
  _edges = std::vector<EFAEdge *>(_num_edges, nullptr);
  _edge_neighbors = std::vector<std::vector<EFAElement2D *>>(_num_edges, {nullptr});
}

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, nullptr),
    _edge_neighbors(_num_edges, {nullptr})
{
  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, nullptr),
    _edge_neighbors(_num_edges, {nullptr})
{
  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] = nullptr;
    }
  }
  for (unsigned int i = 0; i < _edges.size(); ++i)
  {
    if (_edges[i])
    {
      delete _edges[i];
      _edges[i] = nullptr;
    }
  }
  for (unsigned int i = 0; i < _interior_nodes.size(); ++i)
  {
    if (_interior_nodes[i])
    {
      delete _interior_nodes[i];
      _interior_nodes[i] = nullptr;
    }
  }
  for (unsigned int i = 0; i < _local_nodes.size(); ++i)
  {
    if (_local_nodes[i])
    {
      delete _local_nodes[i];
      _local_nodes[i] = nullptr;
    }
  }
}

Member Function Documentation

addChild()

void EFAElement::addChild ( EFAElement *  child )

inherited

Definition at line 195 of file EFAElement.C.

{
  _children.push_back(child);
}

addCrackTipNeighbor()

void EFAElement::addCrackTipNeighbor ( EFAElement *  neighbor_elem )

inherited

Definition at line 149 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 1715 of file EFAElement2D.C.

{
  EFANode * local_embedded = nullptr;
  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
    // id of partially overlapping fragment edge
    unsigned int frag_edge_id = std::numeric_limits<unsigned int>::max();
    EFAEdge * frag_edge = nullptr;
    EFANode * frag_edge_node1 = nullptr;
    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 1843 of file EFAElement2D.C.

{
  if (_fragments.size() != 1)
    EFAError("Element: ", _id, " should have only 1 fragment in addFragEdgeIntersection");
  EFANode * local_embedded = nullptr;
 
  // 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 1820 of file EFAElement2D.C.

{
  EFANode * local_embedded_permanent = nullptr;
  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 1922 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, nullptr);
    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 464 of file EFAElement2D.C.

{
  _general_neighbors.clear();
  for (unsigned int edge_iter = 0; edge_iter < _num_edges; ++edge_iter)
    _edge_neighbors[edge_iter] = {nullptr};
}

clearParentAndChildren()

void EFAElement::clearParentAndChildren ( )

inherited

Definition at line 201 of file EFAElement.C.

{
  _parent = nullptr;
  _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 1176 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() != nullptr &&
                    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 (const auto element_node : _nodes)
    if (element_node == node)
      return true;
  return false;
}

Referenced by branchingSplit(), getEdgeNodeParametricCoordinate(), EFAElement3D::getFaceNodeParametricCoordinates(), getMasterInfo(), EFAElement3D::getMasterInfo(), getNonPhysicalNodes(), EFAElement3D::getNonPhysicalNodes(), getPhantomNodeOnEdge(), EFAElement3D::getPhantomNodeOnFace(), getTipEmbeddedNode(), isPartial(), EFAElement3D::isPartial(), 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 990 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 1464 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 = nullptr;
  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(), and EFAElement3D::EFAElement3D().

deleteInteriorNodes()

void EFAElement2D::deleteInteriorNodes

(

)

Definition at line 1444 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 1674 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 ( const std::map< EFANode *, std::set< EFAElement * > > &  InverseConnectivity )

inherited

Definition at line 208 of file EFAElement.C.

{
  _general_neighbors.clear();
  std::set<EFAElement *> patch_elements;
  for (unsigned int inode = 0; inode < _num_nodes; ++inode)
  {
    auto it = inverse_connectivity.find(_nodes[inode]);
    if (it != inverse_connectivity.end())
      patch_elements.insert(it->second.begin(), it->second.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 1695 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 = std::numeric_limits<unsigned int>::max();
    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 1586 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 876 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 174 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 2067 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 140 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 599 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] != nullptr &&
            _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 1480 of file EFAElement2D.C.

{
  return _edges[edge_id];
}

Referenced by addEdgeCut(), EFAFragment2D::combineTipEdges(), XFEMCutElem2D::computePhysicalFaceAreaFraction(), connectNeighbors(), XFEM::correctCrackExtensionDirection(), edgeContainsTip(), EFAFragment2D::EFAFragment2D(), fragmentHasTipEdges(), 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 1577 of file EFAElement2D.C.

{
  if (_edge_neighbors[edge_id][0] != nullptr && 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(), XFEM::cutMeshWithEFA(), neighborSanityCheck(), and printElement().

getEdgeNodeParametricCoordinate()

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

Definition at line 1411 of file EFAElement2D.C.

{
  // get the parametric coords of a node in an element edge
  unsigned int edge_id = std::numeric_limits<unsigned int>::max();
  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 1402 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 1393 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 1486 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 1519 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 = std::numeric_limits<unsigned int>::max();
  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 230 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 1435 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.

{
  for (unsigned int i = 0; i < _num_nodes; ++i)
  {
    if (_nodes[i] == node)
      return i;
  }
  EFAError("In EFAelement::getLocalNodeIndex, cannot find the given node");
}

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

getNodes()

const std::vector< EFANode * > & EFAElement::getNodes ( ) const

inlineinherited

Definition at line 44 of file EFAElement.h.

{ return _nodes; }

getNonPhysicalNodes()

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

virtual

Implements EFAElement.

Definition at line 240 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 786 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 168 of file EFAElement.C.

{
  return _parent;
}

getPhantomNodeOnEdge()

std::set< EFANode * > EFAElement2D::getPhantomNodeOnEdge

(

unsigned int

edge_id

)

const

Definition at line 1495 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 1613 of file EFAElement2D.C.

{
  // if this element is a crack tip element, returns the crack tip edge's ID
  unsigned int tip_edge_id = std::numeric_limits<unsigned int>::max();
  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 1641 of file EFAElement2D.C.

{
  // if this element is a crack tip element, returns the crack tip edge's ID
  EFANode * tip_emb = nullptr;
  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 XFEM::cutMeshWithEFA(), EFAElement3D::EFAElement3D(), ElementFragmentAlgorithm::getElemIdByNodes(), EFAElement3D::getNeighborEdgeIndex(), getNeighborIndex(), EFAElement3D::getNeighborIndex(), printElement(), EFAElement3D::printElement(), ElementFragmentAlgorithm::printMesh(), willCrackTipExtend(), and EFAElement3D::willCrackTipExtend().

initCrackTip()

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

virtual

Implements EFAElement.

Definition at line 561 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 780 of file EFAElement2D.C.

{
  return fragmentHasTipEdges();
}

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

isCrackTipSplit()

bool EFAElement::isCrackTipSplit ( ) const

inherited

Definition at line 128 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 1542 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 796 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 213 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 2012 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 242 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() != nullptr &&
                 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 528 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 != nullptr)
      {
        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 189 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 134 of file EFAElement.C.

{
  return _crack_tip_neighbors.size();
}

numEdgeNeighbors()

unsigned int EFAElement2D::numEdgeNeighbors

(

unsigned int

edge_id

)

const

Definition at line 1568 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(), XFEM::cutMeshWithEFA(), neighborSanityCheck(), printElement(), shouldDuplicateCrackTipSplitElement(), shouldDuplicateForPhantomCorner(), and willCrackTipExtend().

numEdges()

unsigned int EFAElement2D::numEdges

(

)

const

Definition at line 1452 of file EFAElement2D.C.

{
  return _num_edges;
}

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

numFragments()

unsigned int EFAElement2D::numFragments ( ) const

virtual

Implements EFAElement.

Definition at line 207 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 236 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 358 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(), EFAElement3D::printElement(), restoreFragment(), and EFAElement3D::restoreFragment().

overlaysElement()

bool EFAElement2D::overlaysElement

(

const EFAElement2D *

other_elem

)

const

Definition at line 364 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 ) const

virtual

Implements EFAElement.

Definition at line 1317 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 1156 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 949 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 122 of file EFAElement.C.

{
  _crack_tip_split_element = true;
}

setEdge()

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

Definition at line 1458 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
  {
    /*
      TRI7: 2
            o
            | \
            |   \
          5 o     o 4
            |  o    \
            |  6      \
            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);
    }
 
    if (_num_nodes > 6)
    {
      _local_node_coor[6] = EFAPoint(1 / 3., 1 / 3., 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 183 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 472 of file EFAElement2D.C.

{
  findGeneralNeighbors(inverse_connectivity_map);
  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 644 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 620 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 695 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 294 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 267 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(), restoreFragment(), switchEmbeddedNode(), switchNode(), and updateFragmentNode().

updateFragmentNode()

void EFAElement2D::updateFragmentNode ( )

virtual

Implements EFAElement.

Definition at line 1306 of file EFAElement2D.C.

{
  for (unsigned int j = 0; j < _num_nodes; ++j)
  {
    if (_nodes[j]->parent() != nullptr &&
        _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 815 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 734 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

Definition at line 31 of file EFAElement2D.h.

Referenced by addEdgeCut(), branchingSplit(), connectNeighbors(), createChild(), createEdges(), edgeContainsTip(), EFAElement2D(), fragmentHasTipEdges(), getCrackTipSplitElementID(), getEdge(), getEdgeNodeParametricCoordinate(), getEdgeNodes(), getFragmentEdgeID(), getMasterInfo(), getNumCuts(), getPhantomNodeOnEdge(), getTipEdgeID(), getTipEmbeddedNode(), initCrackTip(), isEdgePhantom(), printElement(), removePhantomEmbeddedNode(), restoreFragment(), setEdge(), shouldDuplicateForPhantomCorner(), switchEmbeddedNode(), switchNode(), willCrackTipExtend(), and ~EFAElement2D().

_fragments

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

private

Definition at line 34 of file EFAElement2D.h.

Referenced by addFragmentEdgeCut(), connectNeighbors(), createChild(), edgeContainsTip(), fragmentHasTipEdges(), fragmentSanityCheck(), getFragment(), getFragmentEdge(), getFragmentEdgeID(), getNonPhysicalNodes(), getPhantomNodeOnEdge(), getTipEdgeID(), getTipEmbeddedNode(), isEdgePhantom(), isFinalCut(), isPartial(), numFragments(), printElement(), removePhantomEmbeddedNode(), restoreFragment(), setupNeighbors(), shouldDuplicateCrackTipSplitElement(), shouldDuplicateForCrackTip(), shouldDuplicateForPhantomCorner(), switchEmbeddedNode(), switchNode(), updateFragments(), willCrackTipExtend(), and ~EFAElement2D().

_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

Definition at line 27 of file EFAElement.h.

Referenced by addEdgeCut(), EFAElement3D::addFaceEdgeCut(), addFragmentEdgeCut(), connectNeighbors(), EFAElement3D::connectNeighbors(), fragmentSanityCheck(), EFAElement3D::getNeighborEdgeIndex(), getNeighborIndex(), EFAElement3D::getNeighborIndex(), EFAElement::id(), initCrackTip(), EFAElement3D::initCrackTip(), EFAElement::mergeNodes(), printElement(), EFAElement3D::printElement(), EFAElement::printNodes(), restoreFragment(), EFAElement3D::restoreFragment(), setupNeighbors(), EFAElement3D::setupNeighbors(), updateFragments(), EFAElement3D::updateFragments(), willCrackTipExtend(), and EFAElement3D::willCrackTipExtend().

_interior_nodes

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

private

Definition at line 32 of file EFAElement2D.h.

Referenced by addFragmentEdgeCut(), branchingSplit(), createChild(), deleteInteriorNodes(), 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(), and setLocalCoordinates().

_local_nodes

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

protectedinherited

Definition at line 30 of file EFAElement.h.

Referenced by 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(), EFAElement3D::EFAElement3D(), EFAElement::findGeneralNeighbors(), getCommonNodes(), EFAElement3D::getCommonNodes(), EFAElement::getGlobalNodeFromLocalNode(), EFAElement::getLocalNodeIndex(), getMasterInfo(), EFAElement3D::getMasterInfo(), EFAElement::getNode(), EFAElement::getNodes(), 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

Definition at line 30 of file EFAElement2D.h.

Referenced by clearNeighbors(), connectNeighbors(), createChild(), createEdges(), EFAElement2D(), fragmentHasTipEdges(), getCommonNodes(), getCrackTipSplitElementID(), getEdgeNodeParametricCoordinate(), getMasterInfo(), getNeighborIndex(), getNumCuts(), getTipEdgeID(), getTipEmbeddedNode(), initCrackTip(), isPartial(), mapParametricCoordFrom1Dto2D(), neighborSanityCheck(), numEdges(), overlaysElement(), printElement(), removePhantomEmbeddedNode(), restoreFragment(), setLocalCoordinates(), setupNeighbors(), shouldDuplicateForPhantomCorner(), and switchEmbeddedNode().

_num_nodes

unsigned int EFAElement::_num_nodes

protectedinherited

Definition at line 28 of file EFAElement.h.

Referenced by connectNeighbors(), EFAElement3D::connectNeighbors(), createChild(), EFAElement3D::createChild(), createEdges(), EFAElement3D::createFaces(), EFAElement3D::EFAElement3D(), EFAElement3D::EFAElement3D(), EFAElement::findGeneralNeighbors(), EFAElement::getLocalNodeIndex(), EFAElement3D::getMasterInfo(), EFAElement::numNodes(), printElement(), EFAElement::printNodes(), setLocalCoordinates(), EFAElement3D::setLocalCoordinates(), switchNode(), EFAElement3D::switchNode(), and updateFragmentNode().

_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