www.mooseframework.org
EFAEdge.C
Go to the documentation of this file.
1 //* This file is part of the MOOSE framework
2 //* https://www.mooseframework.org
3 //*
4 //* All rights reserved, see COPYRIGHT for full restrictions
5 //* https://github.com/idaholab/moose/blob/master/COPYRIGHT
6 //*
7 //* Licensed under LGPL 2.1, please see LICENSE for details
8 //* https://www.gnu.org/licenses/lgpl-2.1.html
9 
10 #include "EFAEdge.h"
11 
12 #include "EFANode.h"
13 #include "EFAError.h"
14 #include "XFEMFuncs.h"
15 
16 EFAEdge::EFAEdge(EFANode * node1, EFANode * node2) : _edge_node1(node1), _edge_node2(node2)
17 {
18  _embedded_nodes.clear();
19  _intersection_x.clear();
20  _edge_interior_node = nullptr;
22 }
23 
24 EFAEdge::EFAEdge(const EFAEdge & other_edge)
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 }
32 
33 EFAEdge::~EFAEdge() // do not delete edge node - they will be deleted
34 { // in EFAelement's destructor
35 }
36 
37 bool
38 EFAEdge::equivalent(const EFAEdge & other) const
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 }
50 
51 bool
53 {
56 }
57 
58 bool
59 EFAEdge::isPartialOverlap(const EFAEdge & other) const
60 {
61  return containsEdge(other) || other.containsEdge(*this);
62 }
63 
64 bool
65 EFAEdge::containsEdge(const EFAEdge & other) const
66 {
67  return containsNode(other._edge_node1) && containsNode(other._edge_node2);
68 }
69 
70 bool
72  std::vector<EFANode *> & master_nodes,
73  std::vector<double> & master_weights) const
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 }
101 
102 // TODO: Saving because I don't want to throw it away, but it needs more work to be used.
103 // bool
104 // EFAEdge::operator < (const edge_t & other) const
105 //{
106 // node_t * this_min_node;
107 // node_t * this_max_node;
108 // node_t * other_min_node;
109 // node_t * other_max_node;
110 //
111 // int this_node1_unique_index = ((int) edge_node1->category + 1) * edge_node1->id;
112 // int this_node2_unique_index = ((int) edge_node2->category + 1) * edge_node2->id;
113 // int other_node1_unique_index = ((int) other.edge_node1->category + 1) * edge_node1->id;
114 // int other_node2_unique_index = ((int) other.edge_node2->category + 1) * edge_node2->id;
115 // int this_min_index = std::min(this_node1_unique_index, this_node2_unique_index);
116 // int other_min_index = std::min(other_node1_unique_index, other_node2_unique_index);
117 //
118 // if (this_min_index < other_min_index)
119 // return true;
120 // else if (this_min_index == other_min_index)
121 // {
122 // int this_max_index = std::max(this_node1_unique_index, this_node2_unique_index);
123 // int other_max_index = std::max(other_node1_unique_index, other_node2_unique_index);
124 //
125 // if (this_max_index < other_max_index)
126 // return true;
127 // }
128 // return false;
129 //}
130 
131 void
132 EFAEdge::addIntersection(double position, EFANode * embedded_node_tmp, EFANode * from_node)
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 }
142 
143 void
144 EFAEdge::resetIntersection(double position, EFANode * embedded_node_tmp, EFANode * from_node)
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 }
160 
161 void
162 EFAEdge::copyIntersection(const EFAEdge & other, unsigned int from_node_id)
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 }
179 
180 EFANode *
181 EFAEdge::getNode(unsigned int index) const
182 {
183  if (index == 0)
184  return _edge_node1;
185  else if (index == 1)
186  return _edge_node2;
187  else
188  EFAError("In getNode index out of bounds");
189 }
190 
191 void
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 }
198 
199 bool
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 }
211 
212 bool
213 EFAEdge::hasIntersectionAtPosition(double position, EFANode * from_node) const
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 }
237 
238 double
239 EFAEdge::getIntersection(unsigned int emb_id, EFANode * from_node) const
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 }
248 
249 double
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 }
266 
267 bool
268 EFAEdge::isEmbeddedNode(const EFANode * node) const
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 }
281 
282 unsigned int
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 }
300 
301 unsigned int
302 EFAEdge::getEmbeddedNodeIndex(double position, EFANode * from_node) const
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 }
330 
331 EFANode *
332 EFAEdge::getEmbeddedNode(unsigned int index) const
333 {
334  if (index < _embedded_nodes.size())
335  return _embedded_nodes[index];
336  else
337  EFAError("in getEmbeddedNode index out of bounds");
338 }
339 
340 unsigned int
342 {
343  return _embedded_nodes.size();
344 }
345 
346 void
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 }
363 
364 void
365 EFAEdge::switchNode(EFANode * new_node, EFANode * old_node)
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 }
377 
378 bool
379 EFAEdge::containsNode(const EFANode * node) const
380 {
381  return _edge_node1 == node || _edge_node2 == node || isEmbeddedNode(node);
382 }
383 
384 void
386 {
387  _embedded_nodes.clear();
388  _intersection_x.clear();
389 }
390 
391 void
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 }
void reverseNodes()
Definition: EFAEdge.C:192
bool getNodeMasters(EFANode *node, std::vector< EFANode *> &master_nodes, std::vector< double > &master_weights) const
Definition: EFAEdge.C:71
EFANode * getEmbeddedNode(unsigned int index) const
Definition: EFAEdge.C:332
bool isPartialOverlap(const EFAEdge &other) const
Definition: EFAEdge.C:59
double getIntersection(unsigned int emb_id, EFANode *from_node) const
Definition: EFAEdge.C:239
void switchNode(EFANode *new_node, EFANode *old_node)
Definition: EFAEdge.C:365
std::vector< double > _intersection_x
Definition: EFAEdge.h:29
std::pair< EFANode *, EFANode * > getSortedNodes() const
Definition: EFAEdge.h:32
void consistencyCheck()
Definition: EFAEdge.C:347
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 > &)
double distanceFromNode1(EFANode *node) const
Definition: EFAEdge.C:250
EFAEdge(EFANode *node1, EFANode *node2)
Definition: EFAEdge.C:16
unsigned int getEmbeddedNodeIndex(EFANode *node) const
Definition: EFAEdge.C:283
~EFAEdge()
Definition: EFAEdge.C:33
bool containsEdge(const EFAEdge &other) const
Definition: EFAEdge.C:65
void resetIntersection(double position, EFANode *embedded_node_tmp, EFANode *from_node)
Definition: EFAEdge.C:144
EFANode * _edge_node1
Definition: EFAEdge.h:25
bool isEmbeddedNode(const EFANode *node) const
Definition: EFAEdge.C:268
EFANode * _edge_interior_node
Definition: EFAEdge.h:27
bool equivalent(const EFAEdge &other) const
Definition: EFAEdge.C:38
static const double tol
Definition: XFEMFuncs.h:21
void copyIntersection(const EFAEdge &other, unsigned int from_node_id)
Definition: EFAEdge.C:162
void removeEmbeddedNodes()
Definition: EFAEdge.C:385
bool hasIntersectionAtPosition(double position, EFANode *from_node) const
Definition: EFAEdge.C:213
bool containsNode(const EFANode *node) const
Definition: EFAEdge.C:379
EFANode * _edge_node2
Definition: EFAEdge.h:26
bool isEmbeddedPermanent() const
Definition: EFAEdge.C:52
unsigned int numEmbeddedNodes() const
Definition: EFAEdge.C:341
void addIntersection(double position, EFANode *embedded_node_tmp, EFANode *from_node)
Definition: EFAEdge.C:132
EFANode * parent() const
Definition: EFANode.C:48
EFANode * getNode(unsigned int index) const
Definition: EFAEdge.C:181
void removeEmbeddedNode(EFANode *node)
Definition: EFAEdge.C:392
N_CATEGORY category() const
Definition: EFANode.C:42