www.mooseframework.org
Public Member Functions | Private Attributes | List of all members
EFAEdge Class Reference

#include <EFAEdge.h>

Public Member Functions

 EFAEdge (EFANode *node1, EFANode *node2)
 
 EFAEdge (const EFAEdge &other_edge)
 
 ~EFAEdge ()
 
std::pair< EFANode *, EFANode * > getSortedNodes () const
 
bool equivalent (const EFAEdge &other) const
 
bool isEmbeddedPermanent () const
 
bool isPartialOverlap (const EFAEdge &other) const
 
bool containsEdge (const EFAEdge &other) const
 
bool getNodeMasters (EFANode *node, std::vector< EFANode *> &master_nodes, std::vector< double > &master_weights) const
 
void addIntersection (double position, EFANode *embedded_node_tmp, EFANode *from_node)
 
void resetIntersection (double position, EFANode *embedded_node_tmp, EFANode *from_node)
 
void copyIntersection (const EFAEdge &other, unsigned int from_node_id)
 
EFANodegetNode (unsigned int index) const
 
EFANodegetInteriorNode () const
 
void setInteriorNode (EFANode *node)
 
void reverseNodes ()
 
bool hasIntersection () const
 
bool hasIntersectionAtPosition (double position, EFANode *from_node) const
 
double getIntersection (unsigned int emb_id, EFANode *from_node) const
 
double distanceFromNode1 (EFANode *node) const
 
bool isEmbeddedNode (const EFANode *node) const
 
unsigned int getEmbeddedNodeIndex (EFANode *node) const
 
unsigned int getEmbeddedNodeIndex (double position, EFANode *from_node) const
 
EFANodegetEmbeddedNode (unsigned int index) const
 
unsigned int numEmbeddedNodes () const
 
void consistencyCheck ()
 
void switchNode (EFANode *new_node, EFANode *old_node)
 
bool containsNode (const EFANode *node) const
 
void removeEmbeddedNodes ()
 
void removeEmbeddedNode (EFANode *node)
 

Private Attributes

EFANode_edge_node1
 
EFANode_edge_node2
 
EFANode_edge_interior_node
 
std::vector< EFANode * > _embedded_nodes
 
std::vector< double > _intersection_x
 

Detailed Description

Definition at line 16 of file EFAEdge.h.

Constructor & Destructor Documentation

◆ EFAEdge() [1/2]

EFAEdge::EFAEdge ( EFANode node1,
EFANode node2 
)

Definition at line 16 of file EFAEdge.C.

16  : _edge_node1(node1), _edge_node2(node2)
17 {
18  _embedded_nodes.clear();
19  _intersection_x.clear();
20  _edge_interior_node = nullptr;
22 }
std::vector< double > _intersection_x
Definition: EFAEdge.h:29
void consistencyCheck()
Definition: EFAEdge.C:347
std::vector< EFANode * > _embedded_nodes
Definition: EFAEdge.h:28
EFANode * _edge_node1
Definition: EFAEdge.h:25
EFANode * _edge_interior_node
Definition: EFAEdge.h:27
EFANode * _edge_node2
Definition: EFAEdge.h:26

◆ EFAEdge() [2/2]

EFAEdge::EFAEdge ( const EFAEdge other_edge)

Definition at line 24 of file EFAEdge.C.

25 {
26  _edge_node1 = other_edge._edge_node1;
27  _edge_node2 = other_edge._edge_node2;
28  _intersection_x = other_edge._intersection_x;
29  _embedded_nodes = other_edge._embedded_nodes;
31 }
std::vector< double > _intersection_x
Definition: EFAEdge.h:29
void consistencyCheck()
Definition: EFAEdge.C:347
std::vector< EFANode * > _embedded_nodes
Definition: EFAEdge.h:28
EFANode * _edge_node1
Definition: EFAEdge.h:25
EFANode * _edge_node2
Definition: EFAEdge.h:26

◆ ~EFAEdge()

EFAEdge::~EFAEdge ( )

Definition at line 33 of file EFAEdge.C.

34 { // in EFAelement's destructor
35 }

Member Function Documentation

◆ addIntersection()

void EFAEdge::addIntersection ( double  position,
EFANode embedded_node_tmp,
EFANode from_node 
)

Definition at line 132 of file EFAEdge.C.

Referenced by EFAElement2D::addEdgeCut(), EFAElement3D::addFaceEdgeCut(), EFAElement2D::addFragmentEdgeCut(), EFAFragment2D::combineTipEdges(), EFAFace::combineTwoEdges(), and EFAFace::combineWithFace().

133 {
134  _embedded_nodes.push_back(embedded_node_tmp);
135  if (from_node == _edge_node1)
136  _intersection_x.push_back(position);
137  else if (from_node == _edge_node2)
138  _intersection_x.push_back(1.0 - position);
139  else
140  EFAError("In addIntersection from_node does not exist on edge");
141 }
std::vector< double > _intersection_x
Definition: EFAEdge.h:29
std::vector< EFANode * > _embedded_nodes
Definition: EFAEdge.h:28
EFANode * _edge_node1
Definition: EFAEdge.h:25
EFANode * _edge_node2
Definition: EFAEdge.h:26

◆ consistencyCheck()

void EFAEdge::consistencyCheck ( )

Definition at line 347 of file EFAEdge.C.

Referenced by EFAEdge().

348 {
349  bool consistent = true;
353  consistent = false;
357  consistent = false;
358  if (!consistent)
359  EFAError("In consistencyCheck nodes on edge are not consistent");
360  if (_embedded_nodes.size() != _intersection_x.size())
361  EFAError("In consistencyCheck num of emb_nodes must be = num of inters_x");
362 }
std::vector< double > _intersection_x
Definition: EFAEdge.h:29
std::vector< EFANode * > _embedded_nodes
Definition: EFAEdge.h:28
EFANode * _edge_node1
Definition: EFAEdge.h:25
EFANode * _edge_node2
Definition: EFAEdge.h:26
N_CATEGORY category() const
Definition: EFANode.C:42

◆ containsEdge()

bool EFAEdge::containsEdge ( const EFAEdge other) const

Definition at line 65 of file EFAEdge.C.

Referenced by EFAFragment2D::combineTipEdges(), EFAElement3D::getFragmentFaceEdgeID(), EFAFragment2D::isEdgeInterior(), and isPartialOverlap().

66 {
67  return containsNode(other._edge_node1) && containsNode(other._edge_node2);
68 }
EFANode * _edge_node1
Definition: EFAEdge.h:25
bool containsNode(const EFANode *node) const
Definition: EFAEdge.C:379
EFANode * _edge_node2
Definition: EFAEdge.h:26

◆ containsNode()

bool EFAEdge::containsNode ( const EFANode node) const

Definition at line 379 of file EFAEdge.C.

Referenced by containsEdge(), and EFAFace::EFAFace().

380 {
381  return _edge_node1 == node || _edge_node2 == node || isEmbeddedNode(node);
382 }
EFANode * _edge_node1
Definition: EFAEdge.h:25
bool isEmbeddedNode(const EFANode *node) const
Definition: EFAEdge.C:268
EFANode * _edge_node2
Definition: EFAEdge.h:26

◆ copyIntersection()

void EFAEdge::copyIntersection ( const EFAEdge other,
unsigned int  from_node_id 
)

Definition at line 162 of file EFAEdge.C.

Referenced by EFAElement2D::createChild().

163 {
164  _embedded_nodes.clear();
165  _intersection_x.clear();
167  if (from_node_id == 0)
169  else if (from_node_id == 1)
170  {
171  for (unsigned int i = 0; i < other.numEmbeddedNodes(); ++i)
172  _intersection_x.push_back(1.0 - other._intersection_x[i]);
173  }
174  else
175  EFAError("from_node_id out of bounds");
176  if (_embedded_nodes.size() != _intersection_x.size())
177  EFAError("in copyIntersection num emb_nodes must == num of inters_x");
178 }
std::vector< double > _intersection_x
Definition: EFAEdge.h:29
std::vector< EFANode * > _embedded_nodes
Definition: EFAEdge.h:28
unsigned int numEmbeddedNodes() const
Definition: EFAEdge.C:341

◆ distanceFromNode1()

double EFAEdge::distanceFromNode1 ( EFANode node) const

Definition at line 250 of file EFAEdge.C.

Referenced by EFAElement3D::addFaceEdgeCut(), EFAFragment2D::combineTipEdges(), and EFAElement3D::isPhysicalEdgeCut().

251 {
252  double xi = -100.0;
253  if (_edge_node1 == node)
254  xi = 0.0;
255  else if (_edge_node2 == node)
256  xi = 1.0;
257  else if (isEmbeddedNode(node))
258  {
259  unsigned int embedded_node_id = getEmbeddedNodeIndex(node);
260  xi = _intersection_x[embedded_node_id];
261  }
262  else
263  EFAError("the given node is not found in the current edge");
264  return xi;
265 }
std::vector< double > _intersection_x
Definition: EFAEdge.h:29
unsigned int getEmbeddedNodeIndex(EFANode *node) const
Definition: EFAEdge.C:283
EFANode * _edge_node1
Definition: EFAEdge.h:25
bool isEmbeddedNode(const EFANode *node) const
Definition: EFAEdge.C:268
EFANode * _edge_node2
Definition: EFAEdge.h:26

◆ equivalent()

bool EFAEdge::equivalent ( const EFAEdge other) const

Definition at line 38 of file EFAEdge.C.

Referenced by EFAElement3D::getNeighborEdgeIndex(), and EFAElement2D::shouldDuplicateForPhantomCorner().

39 {
40  if (getSortedNodes() == other.getSortedNodes())
41  {
42  // For cut along the edge case
43  if (isEmbeddedPermanent())
44  return false;
45  return true;
46  }
47 
48  return false;
49 }
std::pair< EFANode *, EFANode * > getSortedNodes() const
Definition: EFAEdge.h:32
bool isEmbeddedPermanent() const
Definition: EFAEdge.C:52

◆ getEmbeddedNode()

EFANode * EFAEdge::getEmbeddedNode ( unsigned int  index) const

Definition at line 332 of file EFAEdge.C.

Referenced by EFAElement3D::addFaceEdgeCut(), EFAElement3D::checkNeighborFaceCut(), and XFEM::markCutEdgesByState().

333 {
334  if (index < _embedded_nodes.size())
335  return _embedded_nodes[index];
336  else
337  EFAError("in getEmbeddedNode index out of bounds");
338 }
std::vector< EFANode * > _embedded_nodes
Definition: EFAEdge.h:28

◆ getEmbeddedNodeIndex() [1/2]

unsigned int EFAEdge::getEmbeddedNodeIndex ( EFANode node) const

Definition at line 283 of file EFAEdge.C.

Referenced by EFAElement3D::addFaceEdgeCut(), EFAElement3D::checkNeighborFaceCut(), distanceFromNode1(), and switchNode().

284 {
285  unsigned int index;
286  bool have_index = false;
287  for (unsigned int i = 0; i < _embedded_nodes.size(); ++i)
288  {
289  if (_embedded_nodes[i] == node)
290  {
291  have_index = true;
292  index = i;
293  break;
294  }
295  }
296  if (!have_index)
297  EFAError("In getEmbeddedNodeIndex, could not find index");
298  return index;
299 }
std::vector< EFANode * > _embedded_nodes
Definition: EFAEdge.h:28

◆ getEmbeddedNodeIndex() [2/2]

unsigned int EFAEdge::getEmbeddedNodeIndex ( double  position,
EFANode from_node 
) const

Definition at line 302 of file EFAEdge.C.

303 {
304  bool have_index = false;
305  unsigned int index;
306  if (hasIntersection())
307  {
308  double tmp_intersection_x = -1.0; // dist from edge_node1
309  if (from_node == _edge_node1)
310  tmp_intersection_x = position;
311  else if (from_node == _edge_node2)
312  tmp_intersection_x = 1.0 - position;
313  else
314  EFAError("In getEmbeddedNodeIndex, from_node does not exist on edge");
315 
316  for (unsigned int i = 0; i < _embedded_nodes.size(); ++i)
317  {
318  if (std::abs(tmp_intersection_x - _intersection_x[i]) < Xfem::tol)
319  {
320  have_index = true;
321  index = i;
322  break;
323  }
324  }
325  }
326  if (!have_index)
327  EFAError("In getEmbeddedNodeIndex, could not find index");
328  return index;
329 }
std::vector< double > _intersection_x
Definition: EFAEdge.h:29
bool hasIntersection() const
Definition: EFAEdge.C:200
std::vector< EFANode * > _embedded_nodes
Definition: EFAEdge.h:28
ADRealEigenVector< T, D, asd > abs(const ADRealEigenVector< T, D, asd > &)
EFANode * _edge_node1
Definition: EFAEdge.h:25
static const double tol
Definition: XFEMFuncs.h:21
EFANode * _edge_node2
Definition: EFAEdge.h:26

◆ getInteriorNode()

EFANode* EFAEdge::getInteriorNode ( ) const
inline

Definition at line 51 of file EFAEdge.h.

Referenced by EFAElement2D::connectNeighbors().

51 { return _edge_interior_node; };
EFANode * _edge_interior_node
Definition: EFAEdge.h:27

◆ getIntersection()

double EFAEdge::getIntersection ( unsigned int  emb_id,
EFANode from_node 
) const

Definition at line 239 of file EFAEdge.C.

Referenced by EFAElement2D::addFragmentEdgeCut().

240 {
241  if (from_node == _edge_node1)
242  return _intersection_x[emb_id];
243  else if (from_node == _edge_node2)
244  return 1.0 - _intersection_x[emb_id];
245  else
246  EFAError("In getIntersection node not in edge");
247 }
std::vector< double > _intersection_x
Definition: EFAEdge.h:29
EFANode * _edge_node1
Definition: EFAEdge.h:25
EFANode * _edge_node2
Definition: EFAEdge.h:26

◆ getNode()

EFANode * EFAEdge::getNode ( unsigned int  index) const

◆ getNodeMasters()

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

Definition at line 71 of file EFAEdge.C.

74 {
75  master_nodes.clear();
76  master_weights.clear();
77  bool masters_found = false;
78  if (_edge_node1 == node || _edge_node2 == node)
79  {
80  master_nodes.push_back(node);
81  master_weights.push_back(1.0);
82  masters_found = true;
83  }
84  else
85  {
86  for (unsigned int i = 0; i < _embedded_nodes.size(); ++i)
87  {
88  if (_embedded_nodes[i] == node)
89  {
90  master_nodes.push_back(_edge_node1);
91  master_nodes.push_back(_edge_node2);
92  master_weights.push_back(1.0 - _intersection_x[i]);
93  master_weights.push_back(_intersection_x[i]);
94  masters_found = true;
95  break;
96  }
97  }
98  }
99  return masters_found;
100 }
std::vector< double > _intersection_x
Definition: EFAEdge.h:29
std::vector< EFANode * > _embedded_nodes
Definition: EFAEdge.h:28
EFANode * _edge_node1
Definition: EFAEdge.h:25
EFANode * _edge_node2
Definition: EFAEdge.h:26

◆ getSortedNodes()

std::pair<EFANode *, EFANode *> EFAEdge::getSortedNodes ( ) const
inline

Definition at line 32 of file EFAEdge.h.

Referenced by equivalent().

33  {
34  return {std::min(_edge_node1, _edge_node2), std::max(_edge_node1, _edge_node2)};
35  }
EFANode * _edge_node1
Definition: EFAEdge.h:25
EFANode * _edge_node2
Definition: EFAEdge.h:26

◆ hasIntersection()

bool EFAEdge::hasIntersection ( ) const

Definition at line 200 of file EFAEdge.C.

Referenced by EFAElement3D::addFaceEdgeCut(), EFAElement2D::addFragmentEdgeCut(), EFAFragment2D::combineTipEdges(), EFAElement2D::connectNeighbors(), EFAElement2D::fragmentEdgeAlreadyCut(), getEmbeddedNodeIndex(), hasIntersectionAtPosition(), and XFEM::markCutEdgesByState().

201 {
202  bool has = false;
203  if (_edge_node1->parent() != nullptr)
205 
206  if (_edge_node2->parent() != nullptr)
208 
209  return has || _embedded_nodes.size() > 0;
210 }
std::vector< EFANode * > _embedded_nodes
Definition: EFAEdge.h:28
EFANode * _edge_node1
Definition: EFAEdge.h:25
EFANode * _edge_node2
Definition: EFAEdge.h:26
EFANode * parent() const
Definition: EFANode.C:48
N_CATEGORY category() const
Definition: EFANode.C:42

◆ hasIntersectionAtPosition()

bool EFAEdge::hasIntersectionAtPosition ( double  position,
EFANode from_node 
) const

Definition at line 213 of file EFAEdge.C.

Referenced by EFAElement3D::addFaceEdgeCut(), EFAElement2D::addFragmentEdgeCut(), and EFAElement3D::checkNeighborFaceCut().

214 {
215  bool has_int = false;
216  if (hasIntersection())
217  {
218  double tmp_intersection_x = -1.0;
219  if (from_node == _edge_node1)
220  tmp_intersection_x = position;
221  else if (from_node == _edge_node2)
222  tmp_intersection_x = 1.0 - position;
223  else
224  EFAError("In hasIntersectionAtPosition from_node does not exist on edge");
225 
226  for (unsigned int i = 0; i < _embedded_nodes.size(); ++i)
227  {
228  if (std::abs(tmp_intersection_x - _intersection_x[i]) < Xfem::tol)
229  {
230  has_int = true;
231  break;
232  }
233  }
234  }
235  return has_int;
236 }
std::vector< double > _intersection_x
Definition: EFAEdge.h:29
bool hasIntersection() const
Definition: EFAEdge.C:200
std::vector< EFANode * > _embedded_nodes
Definition: EFAEdge.h:28
ADRealEigenVector< T, D, asd > abs(const ADRealEigenVector< T, D, asd > &)
EFANode * _edge_node1
Definition: EFAEdge.h:25
static const double tol
Definition: XFEMFuncs.h:21
EFANode * _edge_node2
Definition: EFAEdge.h:26

◆ isEmbeddedNode()

bool EFAEdge::isEmbeddedNode ( const EFANode node) const

Definition at line 268 of file EFAEdge.C.

Referenced by containsNode(), distanceFromNode1(), and switchNode().

269 {
270  bool is_emb = false;
271  for (unsigned int i = 0; i < _embedded_nodes.size(); ++i)
272  {
273  if (_embedded_nodes[i] == node)
274  {
275  is_emb = true;
276  break;
277  }
278  }
279  return is_emb;
280 }
std::vector< EFANode * > _embedded_nodes
Definition: EFAEdge.h:28

◆ isEmbeddedPermanent()

bool EFAEdge::isEmbeddedPermanent ( ) const

Definition at line 52 of file EFAEdge.C.

Referenced by equivalent().

53 {
56 }
EFANode * _edge_node1
Definition: EFAEdge.h:25
EFANode * _edge_node2
Definition: EFAEdge.h:26
N_CATEGORY category() const
Definition: EFANode.C:42

◆ isPartialOverlap()

bool EFAEdge::isPartialOverlap ( const EFAEdge other) const

Definition at line 59 of file EFAEdge.C.

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

60 {
61  return containsEdge(other) || other.containsEdge(*this);
62 }
bool containsEdge(const EFAEdge &other) const
Definition: EFAEdge.C:65

◆ numEmbeddedNodes()

unsigned int EFAEdge::numEmbeddedNodes ( ) const

Definition at line 341 of file EFAEdge.C.

Referenced by EFAElement2D::addEdgeCut(), EFAElement3D::addFaceEdgeCut(), and copyIntersection().

342 {
343  return _embedded_nodes.size();
344 }
std::vector< EFANode * > _embedded_nodes
Definition: EFAEdge.h:28

◆ removeEmbeddedNode()

void EFAEdge::removeEmbeddedNode ( EFANode node)

Definition at line 392 of file EFAEdge.C.

393 {
394  unsigned int index = 0;
395  bool node_found = false;
396  for (unsigned int i = 0; i < _embedded_nodes.size(); ++i)
397  {
398  if (_embedded_nodes[i] == node)
399  {
400  index = i;
401  node_found = true;
402  break;
403  }
404  }
405  if (node_found)
406  {
407  _embedded_nodes.erase(_embedded_nodes.begin() + index);
408  _intersection_x.erase(_intersection_x.begin() + index);
409  }
410 }
std::vector< double > _intersection_x
Definition: EFAEdge.h:29
std::vector< EFANode * > _embedded_nodes
Definition: EFAEdge.h:28

◆ removeEmbeddedNodes()

void EFAEdge::removeEmbeddedNodes ( )

Definition at line 385 of file EFAEdge.C.

386 {
387  _embedded_nodes.clear();
388  _intersection_x.clear();
389 }
std::vector< double > _intersection_x
Definition: EFAEdge.h:29
std::vector< EFANode * > _embedded_nodes
Definition: EFAEdge.h:28

◆ resetIntersection()

void EFAEdge::resetIntersection ( double  position,
EFANode embedded_node_tmp,
EFANode from_node 
)

Definition at line 144 of file EFAEdge.C.

145 {
146  for (unsigned int i = 0; i < _embedded_nodes.size(); ++i)
147  {
148  if (_embedded_nodes[i] == embedded_node_tmp)
149  {
150  if (from_node == _edge_node1)
151  _intersection_x[i] = position;
152  else if (from_node == _edge_node2)
153  _intersection_x[i] = 1.0 - position;
154  else
155  EFAError("In resetIntersection from_node does not exist on edge");
156  break;
157  }
158  }
159 }
std::vector< double > _intersection_x
Definition: EFAEdge.h:29
std::vector< EFANode * > _embedded_nodes
Definition: EFAEdge.h:28
EFANode * _edge_node1
Definition: EFAEdge.h:25
EFANode * _edge_node2
Definition: EFAEdge.h:26

◆ reverseNodes()

void EFAEdge::reverseNodes ( )

Definition at line 192 of file EFAEdge.C.

193 {
194  std::swap(_edge_node1, _edge_node2);
195  for (unsigned int i = 0; i < _embedded_nodes.size(); ++i)
196  _intersection_x[i] = 1.0 - _intersection_x[i];
197 }
std::vector< double > _intersection_x
Definition: EFAEdge.h:29
std::vector< EFANode * > _embedded_nodes
Definition: EFAEdge.h:28
EFANode * _edge_node1
Definition: EFAEdge.h:25
EFANode * _edge_node2
Definition: EFAEdge.h:26

◆ setInteriorNode()

void EFAEdge::setInteriorNode ( EFANode node)
inline

Definition at line 52 of file EFAEdge.h.

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

52 { _edge_interior_node = node; };
EFANode * _edge_interior_node
Definition: EFAEdge.h:27

◆ switchNode()

void EFAEdge::switchNode ( EFANode new_node,
EFANode old_node 
)

Definition at line 365 of file EFAEdge.C.

366 {
367  if (_edge_node1 == old_node)
368  _edge_node1 = new_node;
369  else if (_edge_node2 == old_node)
370  _edge_node2 = new_node;
371  else if (isEmbeddedNode(old_node))
372  {
373  unsigned int id = getEmbeddedNodeIndex(old_node);
374  _embedded_nodes[id] = new_node;
375  }
376 }
std::vector< EFANode * > _embedded_nodes
Definition: EFAEdge.h:28
unsigned int getEmbeddedNodeIndex(EFANode *node) const
Definition: EFAEdge.C:283
EFANode * _edge_node1
Definition: EFAEdge.h:25
bool isEmbeddedNode(const EFANode *node) const
Definition: EFAEdge.C:268
EFANode * _edge_node2
Definition: EFAEdge.h:26

Member Data Documentation

◆ _edge_interior_node

EFANode* EFAEdge::_edge_interior_node
private

Definition at line 27 of file EFAEdge.h.

Referenced by EFAEdge(), getInteriorNode(), and setInteriorNode().

◆ _edge_node1

EFANode* EFAEdge::_edge_node1
private

◆ _edge_node2

EFANode* EFAEdge::_edge_node2
private

◆ _embedded_nodes

std::vector<EFANode *> EFAEdge::_embedded_nodes
private

◆ _intersection_x

std::vector<double> EFAEdge::_intersection_x
private

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