1 // SMESH SMDS : implementaion of Salome mesh data structure
3 // Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
6 // This library is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU Lesser General Public
8 // License as published by the Free Software Foundation; either
9 // version 2.1 of the License.
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 // Lesser General Public License for more details.
16 // You should have received a copy of the GNU Lesser General Public
17 // License along with this library; if not, write to the Free Software
18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 // See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
22 #include "utilities.h"
23 #include "SMDS_Mesh.hxx"
24 #include "SMDS_VolumeOfNodes.hxx"
25 #include "SMDS_VolumeOfFaces.hxx"
26 #include "SMDS_FaceOfNodes.hxx"
27 #include "SMDS_Tria3OfNodes.hxx"
28 #include "SMDS_HexahedronOfNodes.hxx"
29 #include "SMDS_FaceOfEdges.hxx"
31 ///////////////////////////////////////////////////////////////////////////////
32 /// Create a new mesh object
33 ///////////////////////////////////////////////////////////////////////////////
34 SMDS_Mesh::SMDS_Mesh()
35 :myNodeIDFactory(new SMDS_MeshElementIDFactory()),
36 myElementIDFactory(new SMDS_MeshElementIDFactory()),
37 myHasConstructionEdges(false), myHasConstructionFaces(false),
38 myHasInverseElements(true)
42 ///////////////////////////////////////////////////////////////////////////////
43 /// Create a new child mesh
44 /// Note that the tree structure of SMDS_Mesh seems to be unused in this version
45 /// (2003-09-08) of SMESH
46 ///////////////////////////////////////////////////////////////////////////////
47 SMDS_Mesh::SMDS_Mesh(SMDS_Mesh * parent)
48 :myParent(parent), myNodeIDFactory(parent->myNodeIDFactory),
49 myElementIDFactory(parent->myElementIDFactory),
50 myHasConstructionEdges(false), myHasConstructionFaces(false),
51 myHasInverseElements(true)
55 ///////////////////////////////////////////////////////////////////////////////
56 ///Create a submesh and add it to the current mesh
57 ///////////////////////////////////////////////////////////////////////////////
59 SMDS_Mesh *SMDS_Mesh::AddSubMesh()
61 SMDS_Mesh *submesh = new SMDS_Mesh(this);
62 myChildren.insert(myChildren.end(), submesh);
66 ///////////////////////////////////////////////////////////////////////////////
67 ///create a MeshNode and add it to the current Mesh
68 ///An ID is automatically assigned to the node.
69 ///@return : The created node
70 ///////////////////////////////////////////////////////////////////////////////
72 SMDS_MeshNode * SMDS_Mesh::AddNode(double x, double y, double z)
74 return AddNodeWithID(x,y,z,myNodeIDFactory->GetFreeID());
77 ///////////////////////////////////////////////////////////////////////////////
78 ///create a MeshNode and add it to the current Mesh
79 ///@param ID : The ID of the MeshNode to create
80 ///@return : The created node or NULL if a node with this ID already exists
81 ///////////////////////////////////////////////////////////////////////////////
82 SMDS_MeshNode * SMDS_Mesh::AddNodeWithID(double x, double y, double z, int ID)
84 // find the MeshNode corresponding to ID
85 const SMDS_MeshElement *node = myNodeIDFactory->MeshElement(ID);
89 SMDS_MeshNode * node=new SMDS_MeshNode(x, y, z);
91 myNodeIDFactory->BindID(ID,node);
98 ///////////////////////////////////////////////////////////////////////////////
99 /// create a MeshEdge and add it to the current Mesh
100 /// @return : The created MeshEdge
101 ///////////////////////////////////////////////////////////////////////////////
103 SMDS_MeshEdge* SMDS_Mesh::AddEdgeWithID(int idnode1, int idnode2, int ID)
105 SMDS_MeshNode * node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1);
106 SMDS_MeshNode * node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2);
107 if((node1==NULL)||(node2==NULL)) return NULL;
108 return AddEdgeWithID(node1, node2, ID);
111 ///////////////////////////////////////////////////////////////////////////////
112 /// create a MeshEdge and add it to the current Mesh
113 /// @return : The created MeshEdge
114 ///////////////////////////////////////////////////////////////////////////////
116 SMDS_MeshEdge* SMDS_Mesh::AddEdge(const SMDS_MeshNode * node1,
117 const SMDS_MeshNode * node2)
119 return AddEdgeWithID(node1, node2, myElementIDFactory->GetFreeID());
122 ///////////////////////////////////////////////////////////////////////////////
123 /// Create a new edge and at it to the mesh
124 /// @param idnode1 ID of the first node
125 /// @param idnode2 ID of the second node
126 /// @param ID ID of the edge to create
127 /// @return The created edge or NULL if an edge with this ID already exists or
128 /// if input nodes are not found.
129 ///////////////////////////////////////////////////////////////////////////////
131 SMDS_MeshEdge* SMDS_Mesh::AddEdgeWithID(const SMDS_MeshNode * n1,
132 const SMDS_MeshNode * n2, int ID)
134 SMDS_MeshNode *node1,*node2;
135 node1=const_cast<SMDS_MeshNode*>(n1);
136 node2=const_cast<SMDS_MeshNode*>(n2);
138 SMDS_MeshEdge * edge=new SMDS_MeshEdge(node1,node2);
139 if(myElementIDFactory->BindID(ID, edge))
141 node1->AddInverseElement(edge);
142 node2->AddInverseElement(edge);
143 myEdges.insert(edge);
153 ///////////////////////////////////////////////////////////////////////////////
154 /// Add a triangle defined by its nodes. An ID is automatically affected to the
156 ///////////////////////////////////////////////////////////////////////////////
158 SMDS_MeshFace* SMDS_Mesh::AddFace(const SMDS_MeshNode * n1,
159 const SMDS_MeshNode * n2,
160 const SMDS_MeshNode * n3)
162 return AddFaceWithID(n1,n2,n3, myElementIDFactory->GetFreeID());
165 ///////////////////////////////////////////////////////////////////////////////
166 /// Add a quadrangle defined by its nodes IDs
167 ///////////////////////////////////////////////////////////////////////////////
169 SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(int idnode1, int idnode2, int idnode3, int ID)
171 SMDS_MeshNode * node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1);
172 SMDS_MeshNode * node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2);
173 SMDS_MeshNode * node3 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode3);
174 if((node1==NULL)||(node2==NULL)||(node3==NULL)) return NULL;
175 return AddFaceWithID(node1, node2, node3, ID);
178 ///////////////////////////////////////////////////////////////////////////////
179 /// Add a quadrangle defined by its nodes
180 ///////////////////////////////////////////////////////////////////////////////
182 SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(
183 const SMDS_MeshNode * n1,
184 const SMDS_MeshNode * n2,
185 const SMDS_MeshNode * n3, int ID)
187 SMDS_MeshNode *node1, *node2, *node3;
188 node1=const_cast<SMDS_MeshNode*>(n1),
189 node2=const_cast<SMDS_MeshNode*>(n2),
190 node3=const_cast<SMDS_MeshNode*>(n3);
191 SMDS_MeshFace * face=createTriangle(node1, node2, node3);
193 if(myElementIDFactory->BindID(ID, face))
195 node1->AddInverseElement(face);
196 node2->AddInverseElement(face);
197 node3->AddInverseElement(face);
207 ///////////////////////////////////////////////////////////////////////////////
208 /// Add a triangle defined by its nodes. An ID is automatically affected to the
210 ///////////////////////////////////////////////////////////////////////////////
212 SMDS_MeshFace* SMDS_Mesh::AddFace(const SMDS_MeshNode * n1,
213 const SMDS_MeshNode * n2,
214 const SMDS_MeshNode * n3,
215 const SMDS_MeshNode * n4)
217 return AddFaceWithID(n1,n2,n3, n4, myElementIDFactory->GetFreeID());
220 ///////////////////////////////////////////////////////////////////////////////
221 /// Add a quadrangle defined by its nodes IDs
222 ///////////////////////////////////////////////////////////////////////////////
224 SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(int idnode1, int idnode2, int idnode3,
227 SMDS_MeshNode *node1, *node2, *node3, *node4;
228 node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1);
229 node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2);
230 node3 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode3);
231 node4 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode4);
232 if((node1==NULL)||(node2==NULL)||(node3==NULL)) return NULL;
233 return AddFaceWithID(node1, node2, node3, node4, ID);
236 ///////////////////////////////////////////////////////////////////////////////
237 /// Add a quadrangle defined by its nodes
238 ///////////////////////////////////////////////////////////////////////////////
240 SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
241 const SMDS_MeshNode * n2, const SMDS_MeshNode * n3,
242 const SMDS_MeshNode * n4, int ID)
244 SMDS_MeshNode *node1, *node2, *node3, *node4;
245 node1=const_cast<SMDS_MeshNode*>(n1),
246 node2=const_cast<SMDS_MeshNode*>(n2),
247 node3=const_cast<SMDS_MeshNode*>(n3);
248 node4=const_cast<SMDS_MeshNode*>(n4);
249 SMDS_MeshFace * face=createQuadrangle(node1, node2, node3, node4);
251 if(myElementIDFactory->BindID(ID, face))
253 node1->AddInverseElement(face);
254 node2->AddInverseElement(face);
255 node3->AddInverseElement(face);
256 node4->AddInverseElement(face);
266 ///////////////////////////////////////////////////////////////////////////////
267 ///Create a new tetrahedron and add it to the mesh.
268 ///@return The created tetrahedron
269 ///////////////////////////////////////////////////////////////////////////////
271 SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
272 const SMDS_MeshNode * n2, const SMDS_MeshNode * n3,
273 const SMDS_MeshNode * n4)
275 int ID = myElementIDFactory->GetFreeID();
276 SMDS_MeshVolume * v = AddVolumeWithID(n1, n2, n3, n4, ID);
277 if(v==NULL) myElementIDFactory->ReleaseID(ID);
281 ///////////////////////////////////////////////////////////////////////////////
282 ///Create a new tetrahedron and add it to the mesh.
283 ///@param ID The ID of the new volume
284 ///@return The created tetrahedron or NULL if an edge with this ID already exists
285 ///or if input nodes are not found.
286 ///////////////////////////////////////////////////////////////////////////////
288 SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(int idnode1, int idnode2,
289 int idnode3, int idnode4, int ID)
291 SMDS_MeshNode *node1, *node2, *node3, *node4;
292 node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1);
293 node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2);
294 node3 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode3);
295 node4 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode4);
296 if((node1==NULL)||(node2==NULL)||(node3==NULL)||(node4=NULL)) return NULL;
297 return AddVolumeWithID(node1, node2, node3, node4, ID);
300 ///////////////////////////////////////////////////////////////////////////////
301 ///Create a new tetrahedron and add it to the mesh.
302 ///@param ID The ID of the new volume
303 ///@return The created tetrahedron
304 ///////////////////////////////////////////////////////////////////////////////
306 SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(
307 const SMDS_MeshNode * n1,
308 const SMDS_MeshNode * n2,
309 const SMDS_MeshNode * n3,
310 const SMDS_MeshNode * n4, int ID)
312 SMDS_MeshNode *node1, *node2, *node3, *node4;
313 node1=const_cast<SMDS_MeshNode*>(n1),
314 node2=const_cast<SMDS_MeshNode*>(n2),
315 node3=const_cast<SMDS_MeshNode*>(n3);
316 node4=const_cast<SMDS_MeshNode*>(n4);
317 SMDS_MeshVolume* volume;
318 if(hasConstructionFaces())
320 SMDS_MeshFace * f1=createTriangle(node1,node2,node3);
321 SMDS_MeshFace * f2=createTriangle(node1,node2,node4);
322 SMDS_MeshFace * f3=createTriangle(node1,node3,node4);
323 SMDS_MeshFace * f4=createTriangle(node2,node3,node4);
324 volume=new SMDS_VolumeOfFaces(f1,f2,f3,f4);
325 myVolumes.insert(volume);
327 else if(hasConstructionEdges())
329 MESSAGE("Error : Not implemented");
334 volume=new SMDS_VolumeOfNodes(node1,node2,node3,node4);
335 myVolumes.insert(volume);
338 if(myElementIDFactory->BindID(ID, volume))
340 node1->AddInverseElement(volume);
341 node2->AddInverseElement(volume);
342 node3->AddInverseElement(volume);
343 node4->AddInverseElement(volume);
348 RemoveVolume(volume);
353 ///////////////////////////////////////////////////////////////////////////////
354 ///Create a new pyramid and add it to the mesh.
355 ///Nodes 1,2,3 and 4 define the base of the pyramid
356 ///@return The created pyramid
357 ///////////////////////////////////////////////////////////////////////////////
359 SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
360 const SMDS_MeshNode * n2, const SMDS_MeshNode * n3,
361 const SMDS_MeshNode * n4, const SMDS_MeshNode * n5)
363 int ID = myElementIDFactory->GetFreeID();
364 SMDS_MeshVolume * v = AddVolumeWithID(n1, n2, n3, n4, n5, ID);
365 if(v==NULL) myElementIDFactory->ReleaseID(ID);
369 ///////////////////////////////////////////////////////////////////////////////
370 ///Create a new pyramid and add it to the mesh.
371 ///Nodes 1,2,3 and 4 define the base of the pyramid
372 ///@param ID The ID of the new volume
373 ///@return The created pyramid or NULL if a pyramid with this ID already exists
374 ///or if input nodes are not found.
375 ///////////////////////////////////////////////////////////////////////////////
377 SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(int idnode1, int idnode2,
378 int idnode3, int idnode4, int idnode5, int ID)
380 SMDS_MeshNode *node1, *node2, *node3, *node4, *node5;
381 node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1);
382 node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2);
383 node3 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode3);
384 node4 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode4);
385 node5 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode5);
386 if((node1==NULL)||(node2==NULL)||(node3==NULL)||(node4=NULL)||
389 return AddVolumeWithID(node1, node2, node3, node4, node5, ID);
392 ///////////////////////////////////////////////////////////////////////////////
393 ///Create a new pyramid and add it to the mesh.
394 ///Nodes 1,2,3 and 4 define the base of the pyramid
395 ///@param ID The ID of the new volume
396 ///@return The created pyramid
397 ///////////////////////////////////////////////////////////////////////////////
399 SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(
400 const SMDS_MeshNode * n1,
401 const SMDS_MeshNode * n2,
402 const SMDS_MeshNode * n3,
403 const SMDS_MeshNode * n4,
404 const SMDS_MeshNode * n5, int ID)
406 SMDS_MeshNode *node1, *node2, *node3, *node4, *node5;
407 node1=const_cast<SMDS_MeshNode*>(n1),
408 node2=const_cast<SMDS_MeshNode*>(n2),
409 node3=const_cast<SMDS_MeshNode*>(n3);
410 node4=const_cast<SMDS_MeshNode*>(n4);
411 node5=const_cast<SMDS_MeshNode*>(n5);
412 SMDS_MeshVolume* volume;
413 if(hasConstructionFaces())
415 SMDS_MeshFace * f1=createQuadrangle(node1,node2,node3,node4);
416 SMDS_MeshFace * f2=createTriangle(node1,node2,node5);
417 SMDS_MeshFace * f3=createTriangle(node2,node3,node5);
418 SMDS_MeshFace * f4=createTriangle(node3,node4,node5);
419 volume=new SMDS_VolumeOfFaces(f1,f2,f3,f4);
420 myVolumes.insert(volume);
422 else if(hasConstructionEdges())
424 MESSAGE("Error : Not implemented");
429 volume=new SMDS_VolumeOfNodes(node1,node2,node3,node4,node5);
430 myVolumes.insert(volume);
433 if(myElementIDFactory->BindID(ID, volume))
435 node1->AddInverseElement(volume);
436 node2->AddInverseElement(volume);
437 node3->AddInverseElement(volume);
438 node4->AddInverseElement(volume);
439 node5->AddInverseElement(volume);
444 RemoveVolume(volume);
449 ///////////////////////////////////////////////////////////////////////////////
450 ///Create a new prism and add it to the mesh.
451 ///Nodes 1,2,3 is a triangle and 1,2,5,4 a quadrangle.
452 ///@return The created prism
453 ///////////////////////////////////////////////////////////////////////////////
455 SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
456 const SMDS_MeshNode * n2, const SMDS_MeshNode * n3,
457 const SMDS_MeshNode * n4, const SMDS_MeshNode * n5,
458 const SMDS_MeshNode * n6)
460 int ID = myElementIDFactory->GetFreeID();
461 SMDS_MeshVolume * v = AddVolumeWithID(n1, n2, n3, n4, n5, n6, ID);
462 if(v==NULL) myElementIDFactory->ReleaseID(ID);
466 ///////////////////////////////////////////////////////////////////////////////
467 ///Create a new prism and add it to the mesh.
468 ///Nodes 1,2,3 is a triangle and 1,2,5,4 a quadrangle.
469 ///@param ID The ID of the new volume
470 ///@return The created prism or NULL if a prism with this ID already exists
471 ///or if input nodes are not found.
472 ///////////////////////////////////////////////////////////////////////////////
474 SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(int idnode1, int idnode2,
475 int idnode3, int idnode4, int idnode5, int idnode6, int ID)
477 SMDS_MeshNode *node1, *node2, *node3, *node4, *node5, *node6;
478 node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1);
479 node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2);
480 node3 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode3);
481 node4 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode4);
482 node5 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode5);
483 node6 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode6);
484 if((node1==NULL)||(node2==NULL)||(node3==NULL)||(node4=NULL)||
485 (node5==NULL)||(node6=NULL))
487 return AddVolumeWithID(node1, node2, node3, node4, node5, node6, ID);
490 ///////////////////////////////////////////////////////////////////////////////
491 ///Create a new prism and add it to the mesh.
492 ///Nodes 1,2,3 is a triangle and 1,2,5,4 a quadrangle.
493 ///@param ID The ID of the new volume
494 ///@return The created prism
495 ///////////////////////////////////////////////////////////////////////////////
497 SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(
498 const SMDS_MeshNode * n1,
499 const SMDS_MeshNode * n2,
500 const SMDS_MeshNode * n3,
501 const SMDS_MeshNode * n4,
502 const SMDS_MeshNode * n5,
503 const SMDS_MeshNode * n6, int ID)
505 SMDS_MeshNode *node1, *node2, *node3, *node4, *node5, *node6;
506 node1=const_cast<SMDS_MeshNode*>(n1),
507 node2=const_cast<SMDS_MeshNode*>(n2),
508 node3=const_cast<SMDS_MeshNode*>(n3);
509 node4=const_cast<SMDS_MeshNode*>(n4);
510 node5=const_cast<SMDS_MeshNode*>(n5);
511 node6=const_cast<SMDS_MeshNode*>(n6);
512 SMDS_MeshVolume* volume;
513 if(hasConstructionFaces())
515 SMDS_MeshFace * f1=createTriangle(node1,node2,node3);
516 SMDS_MeshFace * f2=createTriangle(node4,node5,node6);
517 SMDS_MeshFace * f3=createQuadrangle(node1,node4,node5,node2);
518 SMDS_MeshFace * f4=createQuadrangle(node2,node5,node6,node3);
519 SMDS_MeshFace * f5=createQuadrangle(node3,node6,node4,node1);
520 volume=new SMDS_VolumeOfFaces(f1,f2,f3,f4,f5);
521 myVolumes.insert(volume);
523 else if(hasConstructionEdges())
525 MESSAGE("Error : Not implemented");
530 volume=new SMDS_VolumeOfNodes(node1,node2,node3,node4,node5,node6);
531 myVolumes.insert(volume);
534 if(myElementIDFactory->BindID(ID, volume))
536 node1->AddInverseElement(volume);
537 node2->AddInverseElement(volume);
538 node3->AddInverseElement(volume);
539 node4->AddInverseElement(volume);
540 node5->AddInverseElement(volume);
541 node6->AddInverseElement(volume);
546 RemoveVolume(volume);
551 ///////////////////////////////////////////////////////////////////////////////
552 ///Create a new hexahedron and add it to the mesh.
553 ///Nodes 1,2,3,4 and 5,6,7,8 are quadrangle and 5,1 and 7,3 are an edges.
554 ///@return The created hexahedron
555 ///////////////////////////////////////////////////////////////////////////////
557 SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
558 const SMDS_MeshNode * n2, const SMDS_MeshNode * n3,
559 const SMDS_MeshNode * n4, const SMDS_MeshNode * n5,
560 const SMDS_MeshNode * n6, const SMDS_MeshNode * n7,
561 const SMDS_MeshNode * n8)
563 int ID = myElementIDFactory->GetFreeID();
564 SMDS_MeshVolume * v = AddVolumeWithID(n1, n2, n3, n4, n5, n6, n7, n8, ID);
565 if(v==NULL) myElementIDFactory->ReleaseID(ID);
569 ///////////////////////////////////////////////////////////////////////////////
570 ///Create a new hexahedron and add it to the mesh.
571 ///Nodes 1,2,3,4 and 5,6,7,8 are quadrangle and 5,1 and 7,3 are an edges.
572 ///@param ID The ID of the new volume
573 ///@return The created hexahedron or NULL if an hexahedron with this ID already
574 ///exists or if input nodes are not found.
575 ///////////////////////////////////////////////////////////////////////////////
577 SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(int idnode1, int idnode2,
578 int idnode3, int idnode4, int idnode5, int idnode6, int idnode7,
581 SMDS_MeshNode *node1, *node2, *node3, *node4, *node5, *node6, *node7, *node8;
582 node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1);
583 node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2);
584 node3 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode3);
585 node4 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode4);
586 node5 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode5);
587 node6 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode6);
588 node7 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode7);
589 node8 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode8);
590 if((node1==NULL)||(node2==NULL)||(node3==NULL)||(node4=NULL)||
591 (node5==NULL)||(node6=NULL)||(node7==NULL)||(node8=NULL))
593 return AddVolumeWithID(node1, node2, node3, node4, node5, node6, node7,
597 ///////////////////////////////////////////////////////////////////////////////
598 ///Create a new hexahedron and add it to the mesh.
599 ///Nodes 1,2,3,4 and 5,6,7,8 are quadrangle and 5,1 and 7,3 are an edges.
600 ///@param ID The ID of the new volume
601 ///@return The created prism or NULL if an hexadron with this ID already exists
602 ///or if input nodes are not found.
603 ///////////////////////////////////////////////////////////////////////////////
605 SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(
606 const SMDS_MeshNode * n1,
607 const SMDS_MeshNode * n2,
608 const SMDS_MeshNode * n3,
609 const SMDS_MeshNode * n4,
610 const SMDS_MeshNode * n5,
611 const SMDS_MeshNode * n6,
612 const SMDS_MeshNode * n7,
613 const SMDS_MeshNode * n8, int ID)
615 SMDS_MeshNode *node1, *node2, *node3, *node4, *node5, *node6, *node7, *node8;
616 node1=const_cast<SMDS_MeshNode*>(n1),
617 node2=const_cast<SMDS_MeshNode*>(n2),
618 node3=const_cast<SMDS_MeshNode*>(n3);
619 node4=const_cast<SMDS_MeshNode*>(n4);
620 node5=const_cast<SMDS_MeshNode*>(n5);
621 node6=const_cast<SMDS_MeshNode*>(n6);
622 node7=const_cast<SMDS_MeshNode*>(n7);
623 node8=const_cast<SMDS_MeshNode*>(n8);
624 SMDS_MeshVolume* volume;
625 if(hasConstructionFaces())
627 SMDS_MeshFace * f1=FindFaceOrCreate(node1,node2,node3,node4);
628 SMDS_MeshFace * f2=FindFaceOrCreate(node5,node6,node7,node8);
629 SMDS_MeshFace * f3=FindFaceOrCreate(node1,node4,node8,node5);
630 SMDS_MeshFace * f4=FindFaceOrCreate(node1,node2,node6,node5);
631 SMDS_MeshFace * f5=FindFaceOrCreate(node2,node3,node7,node6);
632 SMDS_MeshFace * f6=FindFaceOrCreate(node3,node4,node8,node7);
633 volume=new SMDS_VolumeOfFaces(f1,f2,f3,f4,f5,f6);
634 myVolumes.insert(volume);
636 else if(hasConstructionEdges())
638 MESSAGE("Error : Not implemented");
643 volume=new SMDS_HexahedronOfNodes(node1,node2,node3,node4,node5,node6,
645 myVolumes.insert(volume);
648 if(myElementIDFactory->BindID(ID, volume))
650 node1->AddInverseElement(volume);
651 node2->AddInverseElement(volume);
652 node3->AddInverseElement(volume);
653 node4->AddInverseElement(volume);
654 node5->AddInverseElement(volume);
655 node6->AddInverseElement(volume);
656 node7->AddInverseElement(volume);
657 node8->AddInverseElement(volume);
662 RemoveVolume(volume);
667 ///////////////////////////////////////////////////////////////////////////////
668 /// Return the node whose ID is 'ID'.
669 ///////////////////////////////////////////////////////////////////////////////
670 const SMDS_MeshNode * SMDS_Mesh::FindNode(int ID) const
672 return (const SMDS_MeshNode *)myNodeIDFactory->MeshElement(ID);
675 ///////////////////////////////////////////////////////////////////////////////
676 ///Create a triangle and add it to the current mesh. This methode do not bind a
677 ///ID to the create triangle.
678 ///////////////////////////////////////////////////////////////////////////////
679 SMDS_MeshFace * SMDS_Mesh::createTriangle(SMDS_MeshNode * node1,
680 SMDS_MeshNode * node2, SMDS_MeshNode * node3)
682 if(hasConstructionEdges())
684 SMDS_MeshEdge *edge1, *edge2, *edge3;
685 edge1=FindEdgeOrCreate(node1,node2);
686 edge2=FindEdgeOrCreate(node2,node3);
687 edge3=FindEdgeOrCreate(node3,node1);
689 SMDS_MeshFace * face = new SMDS_FaceOfEdges(edge1,edge2,edge3);
690 myFaces.insert(face);
695 SMDS_MeshFace * face = new SMDS_Tria3OfNodes(node1,node2,node3);
696 myFaces.insert(face);
701 ///////////////////////////////////////////////////////////////////////////////
702 ///Create a quadrangle and add it to the current mesh. This methode do not bind
703 ///a ID to the create triangle.
704 ///////////////////////////////////////////////////////////////////////////////
705 SMDS_MeshFace * SMDS_Mesh::createQuadrangle(SMDS_MeshNode * node1,
706 SMDS_MeshNode * node2, SMDS_MeshNode * node3, SMDS_MeshNode * node4)
708 if(hasConstructionEdges())
710 SMDS_MeshEdge *edge1, *edge2, *edge3, *edge4;
711 edge1=FindEdgeOrCreate(node1,node2);
712 edge2=FindEdgeOrCreate(node2,node3);
713 edge3=FindEdgeOrCreate(node3,node4);
714 edge4=FindEdgeOrCreate(node4,node1);
716 SMDS_MeshFace * face = new SMDS_FaceOfEdges(edge1,edge2,edge3,edge4);
717 myFaces.insert(face);
722 SMDS_MeshFace * face = new SMDS_FaceOfNodes(node1,node2,node3,node4);
723 myFaces.insert(face);
728 ///////////////////////////////////////////////////////////////////////////////
729 /// Remove a node and all the elements which own this node
730 ///////////////////////////////////////////////////////////////////////////////
732 void SMDS_Mesh::RemoveNode(const SMDS_MeshNode * node)
734 RemoveElement(node, true);
737 ///////////////////////////////////////////////////////////////////////////////
738 /// Remove an edge and all the elements which own this edge
739 ///////////////////////////////////////////////////////////////////////////////
741 void SMDS_Mesh::RemoveEdge(const SMDS_MeshEdge * edge)
743 RemoveElement(edge,true);
746 ///////////////////////////////////////////////////////////////////////////////
747 /// Remove an face and all the elements which own this face
748 ///////////////////////////////////////////////////////////////////////////////
750 void SMDS_Mesh::RemoveFace(const SMDS_MeshFace * face)
752 RemoveElement(face, true);
755 ///////////////////////////////////////////////////////////////////////////////
757 ///////////////////////////////////////////////////////////////////////////////
759 void SMDS_Mesh::RemoveVolume(const SMDS_MeshVolume * volume)
761 RemoveElement(volume, true);
764 //=======================================================================
765 //function : RemoveFromParent
767 //=======================================================================
769 bool SMDS_Mesh::RemoveFromParent()
771 if (myParent==NULL) return false;
772 else return (myParent->RemoveSubMesh(this));
775 //=======================================================================
776 //function : RemoveSubMesh
778 //=======================================================================
780 bool SMDS_Mesh::RemoveSubMesh(const SMDS_Mesh * aMesh)
784 list<SMDS_Mesh *>::iterator itmsh=myChildren.begin();
785 for (; itmsh!=myChildren.end() && !found; itmsh++)
787 SMDS_Mesh * submesh = *itmsh;
788 if (submesh == aMesh)
791 myChildren.erase(itmsh);
799 //=======================================================================
800 //function : FindEdge
802 //=======================================================================
804 const SMDS_MeshEdge* SMDS_Mesh::FindEdge(int idnode1, int idnode2) const
806 const SMDS_MeshNode * node1=FindNode(idnode1);
807 const SMDS_MeshNode * node2=FindNode(idnode2);
808 if((node1==NULL)||(node2==NULL)) return NULL;
809 return FindEdge(node1,node2);
812 ///////////////////////////////////////////////////////////////////////////////
814 ///////////////////////////////////////////////////////////////////////////////
815 //#include "Profiler.h"
816 const SMDS_MeshEdge* SMDS_Mesh::FindEdge(const SMDS_MeshNode * node1,
817 const SMDS_MeshNode * node2) const
819 const SMDS_MeshEdge * toReturn=NULL;
822 SMDS_Iterator<const SMDS_MeshElement *>* it1=node1->edgesIterator();
827 const SMDS_MeshEdge * e=static_cast<const SMDS_MeshEdge *>
829 SMDS_Iterator<const SMDS_MeshElement *>* it2=e->nodesIterator();
832 if(it2->next()->GetID()==node2->GetID())
846 SMDS_MeshEdge* SMDS_Mesh::FindEdgeOrCreate(const SMDS_MeshNode * node1,
847 const SMDS_MeshNode * node2)
849 SMDS_MeshEdge * toReturn=NULL;
850 toReturn=const_cast<SMDS_MeshEdge*>(FindEdge(node1,node2));
853 toReturn=new SMDS_MeshEdge(const_cast<SMDS_MeshNode*>(node1),
854 const_cast<SMDS_MeshNode*>(node2));
855 myEdges.insert(toReturn);
860 //=======================================================================
861 //function : FindFace
863 //=======================================================================
865 const SMDS_MeshFace* SMDS_Mesh::FindFace(int idnode1, int idnode2,
868 const SMDS_MeshNode * node1=FindNode(idnode1);
869 const SMDS_MeshNode * node2=FindNode(idnode2);
870 const SMDS_MeshNode * node3=FindNode(idnode3);
871 const SMDS_MeshFace * face;
872 const SMDS_MeshElement * node;
873 bool node2found, node3found;
874 if((node1==NULL)||(node2==NULL)||(node3==NULL)) return NULL;
876 SMDS_Iterator<const SMDS_MeshElement *>* it1=node1->facesIterator();
879 face=static_cast<const SMDS_MeshFace*>(it1->next());
880 if(face->NbNodes()!=3) continue;
881 SMDS_Iterator<const SMDS_MeshElement *>* it2=face->nodesIterator();
887 if(node->GetID()==idnode2) node2found=true;
888 if(node->GetID()==idnode3) node3found=true;
891 if(node2found&&node3found)
901 //=======================================================================
902 //function : FindFace
904 //=======================================================================
906 const SMDS_MeshFace* SMDS_Mesh::FindFace(int idnode1, int idnode2, int idnode3,
909 const SMDS_MeshNode * node1=FindNode(idnode1);
910 const SMDS_MeshNode * node2=FindNode(idnode2);
911 const SMDS_MeshNode * node3=FindNode(idnode3);
912 const SMDS_MeshNode * node4=FindNode(idnode4);
913 if((node1==NULL)||(node2==NULL)||(node3==NULL)||(node4==NULL)) return NULL;
914 return FindFace(node1, node2, node3, node4);
917 const SMDS_MeshFace* SMDS_Mesh::FindFace(
918 const SMDS_MeshNode *node1,
919 const SMDS_MeshNode *node2,
920 const SMDS_MeshNode *node3,
921 const SMDS_MeshNode *node4) const
923 const SMDS_MeshFace * face;
924 const SMDS_MeshElement * node;
925 bool node2found, node3found, node4found;
926 SMDS_Iterator<const SMDS_MeshElement *>* it1=node1->facesIterator();
929 face=static_cast<const SMDS_MeshFace *>(it1->next());
930 if(face->NbNodes()!=4) continue;
931 SMDS_Iterator<const SMDS_MeshElement *>* it2=face->nodesIterator();
938 if(node->GetID()==node2->GetID()) node2found=true;
939 if(node->GetID()==node3->GetID()) node3found=true;
940 if(node->GetID()==node4->GetID()) node4found=true;
943 if(node2found&&node3found&&node4found)
953 SMDS_MeshFace* SMDS_Mesh::FindFaceOrCreate(
954 const SMDS_MeshNode *node1,
955 const SMDS_MeshNode *node2,
956 const SMDS_MeshNode *node3,
957 const SMDS_MeshNode *node4)
959 SMDS_MeshFace * toReturn=NULL;
960 toReturn=const_cast<SMDS_MeshFace*>(FindFace(node1,node2,node3,node4));
963 toReturn=createQuadrangle(
964 const_cast<SMDS_MeshNode *>(node1),
965 const_cast<SMDS_MeshNode *>(node2),
966 const_cast<SMDS_MeshNode *>(node3),
967 const_cast<SMDS_MeshNode *>(node4)
973 //=======================================================================
974 //function : FindElement
976 //=======================================================================
978 const SMDS_MeshElement* SMDS_Mesh::FindElement(int IDelem) const
980 return myElementIDFactory->MeshElement(IDelem);
983 //=======================================================================
984 //function : DumpNodes
986 //=======================================================================
988 void SMDS_Mesh::DumpNodes() const
990 MESSAGE("dump nodes of mesh : ");
991 SMDS_Iterator<const SMDS_MeshNode *> * itnode=nodesIterator();
992 while(itnode->more()) MESSAGE(itnode->next());
996 //=======================================================================
997 //function : DumpEdges
999 //=======================================================================
1001 void SMDS_Mesh::DumpEdges() const
1003 MESSAGE("dump edges of mesh : ");
1004 SMDS_Iterator<const SMDS_MeshEdge *> * itedge=edgesIterator();
1005 while(itedge->more()) MESSAGE(itedge->next());
1009 //=======================================================================
1010 //function : DumpFaces
1012 //=======================================================================
1014 void SMDS_Mesh::DumpFaces() const
1016 MESSAGE("dump faces of mesh : ");
1017 SMDS_Iterator<const SMDS_MeshFace *> * itface=facesIterator();
1018 while(itface->more()) MESSAGE(itface->next());
1022 //=======================================================================
1023 //function : DumpVolumes
1025 //=======================================================================
1027 void SMDS_Mesh::DumpVolumes() const
1029 MESSAGE("dump volumes of mesh : ");
1030 SMDS_Iterator<const SMDS_MeshVolume *> * itvol=volumesIterator();
1031 while(itvol->more()) MESSAGE(itvol->next());
1035 //=======================================================================
1036 //function : DebugStats
1038 //=======================================================================
1040 void SMDS_Mesh::DebugStats() const
1042 MESSAGE("Debug stats of mesh : ");
1044 MESSAGE("===== NODES ====="<<NbNodes());
1045 MESSAGE("===== EDGES ====="<<NbEdges());
1046 MESSAGE("===== FACES ====="<<NbFaces());
1047 MESSAGE("===== VOLUMES ====="<<NbVolumes());
1049 MESSAGE("End Debug stats of mesh ");
1053 SMDS_Iterator<const SMDS_MeshNode *> * itnode=nodesIterator();
1054 int sizeofnodes = 0;
1055 int sizeoffaces = 0;
1057 while(itnode->more())
1059 const SMDS_MeshNode *node = itnode->next();
1061 sizeofnodes += sizeof(*node);
1063 SMDS_Iterator<const SMDS_MeshElement *> * it=
1064 node->GetInverseElementIterator();
1067 const SMDS_MeshElement *me = it->next();
1068 sizeofnodes += sizeof(me);
1074 SMDS_Iterator<const SMDS_MeshFace*>* itface=facesIterator();
1076 while(itface->more())
1078 const SMDS_MeshElement *face = itface->next();
1079 sizeoffaces += sizeof(*face);
1082 MESSAGE("total size of node elements = " << sizeofnodes);;
1083 MESSAGE("total size of face elements = " << sizeoffaces);;
1089 ///////////////////////////////////////////////////////////////////////////////
1090 /// Return the number of nodes
1091 ///////////////////////////////////////////////////////////////////////////////
1092 int SMDS_Mesh::NbNodes() const
1094 return myNodes.size();
1097 ///////////////////////////////////////////////////////////////////////////////
1098 /// Return the number of edges (including construction edges)
1099 ///////////////////////////////////////////////////////////////////////////////
1100 int SMDS_Mesh::NbEdges() const
1102 return myEdges.size();
1105 ///////////////////////////////////////////////////////////////////////////////
1106 /// Return the number of faces (including construction faces)
1107 ///////////////////////////////////////////////////////////////////////////////
1108 int SMDS_Mesh::NbFaces() const
1110 return myFaces.size();
1113 ///////////////////////////////////////////////////////////////////////////////
1114 /// Return the number of volumes
1115 ///////////////////////////////////////////////////////////////////////////////
1116 int SMDS_Mesh::NbVolumes() const
1118 return myVolumes.size();
1121 ///////////////////////////////////////////////////////////////////////////////
1122 /// Return the number of child mesh of this mesh.
1123 /// Note that the tree structure of SMDS_Mesh seems to be unused in this version
1124 /// (2003-09-08) of SMESH
1125 ///////////////////////////////////////////////////////////////////////////////
1126 int SMDS_Mesh::NbSubMesh() const
1128 return myChildren.size();
1131 ///////////////////////////////////////////////////////////////////////////////
1132 /// Destroy the mesh and all its elements
1133 /// All pointer on elements owned by this mesh become illegals.
1134 ///////////////////////////////////////////////////////////////////////////////
1135 SMDS_Mesh::~SMDS_Mesh()
1139 delete myNodeIDFactory;
1140 delete myElementIDFactory;
1143 list<SMDS_Mesh*>::iterator itc=myChildren.begin();
1144 while(itc!=myChildren.end())
1150 SMDS_Iterator<const SMDS_MeshNode*> * itn=nodesIterator();
1157 set<SMDS_MeshEdge*>::iterator ite=myEdges.begin();
1158 while(ite!=myEdges.end())
1164 set<SMDS_MeshFace*>::iterator itf=myFaces.begin();
1165 while(itf!=myFaces.end())
1171 set<SMDS_MeshVolume*>::iterator itv=myVolumes.begin();
1172 while(itv!=myVolumes.end())
1180 ///////////////////////////////////////////////////////////////////////////////
1181 /// Return true if this mesh create faces with edges.
1182 /// A false returned value mean that faces are created with nodes. A concequence
1183 /// is, iteration on edges (SMDS_Element::edgesIterator) will be unavailable.
1184 ///////////////////////////////////////////////////////////////////////////////
1185 bool SMDS_Mesh::hasConstructionEdges()
1187 return myHasConstructionEdges;
1190 ///////////////////////////////////////////////////////////////////////////////
1191 /// Return true if this mesh create volumes with faces
1192 /// A false returned value mean that volumes are created with nodes or edges.
1193 /// (see hasConstructionEdges)
1194 /// A concequence is, iteration on faces (SMDS_Element::facesIterator) will be
1196 ///////////////////////////////////////////////////////////////////////////////
1197 bool SMDS_Mesh::hasConstructionFaces()
1199 return myHasConstructionFaces;
1202 ///////////////////////////////////////////////////////////////////////////////
1203 /// Return true if nodes are linked to the finit elements, they are belonging to.
1204 /// Currently, It always return true.
1205 ///////////////////////////////////////////////////////////////////////////////
1206 bool SMDS_Mesh::hasInverseElements()
1208 return myHasInverseElements;
1211 ///////////////////////////////////////////////////////////////////////////////
1212 /// Make this mesh creating construction edges (see hasConstructionEdges)
1213 /// @param b true to have construction edges, else false.
1214 ///////////////////////////////////////////////////////////////////////////////
1215 void SMDS_Mesh::setConstructionEdges(bool b)
1217 myHasConstructionEdges=b;
1220 ///////////////////////////////////////////////////////////////////////////////
1221 /// Make this mesh creating construction faces (see hasConstructionFaces)
1222 /// @param b true to have construction faces, else false.
1223 ///////////////////////////////////////////////////////////////////////////////
1224 void SMDS_Mesh::setConstructionFaces(bool b)
1226 myHasConstructionFaces=b;
1229 ///////////////////////////////////////////////////////////////////////////////
1230 /// Make this mesh creating link from nodes to elements (see hasInverseElements)
1231 /// @param b true to link nodes to elements, else false.
1232 ///////////////////////////////////////////////////////////////////////////////
1233 void SMDS_Mesh::setInverseElements(bool b)
1235 if(!b) MESSAGE("Error : inverseElement=false not implemented");
1236 myHasInverseElements=b;
1239 ///////////////////////////////////////////////////////////////////////////////
1240 /// Return an iterator on nodes of the current mesh. Once used this iterator
1241 /// must be free by the caller
1242 ///////////////////////////////////////////////////////////////////////////////
1243 SMDS_Iterator<const SMDS_MeshNode *> * SMDS_Mesh::nodesIterator() const
1245 class MyIterator:public SMDS_Iterator<const SMDS_MeshNode*>
1247 const SetOfNodes& mySet;
1248 SetOfNodes::iterator myIterator;
1250 MyIterator(const SetOfNodes& s):mySet(s)
1252 myIterator=mySet.begin();
1257 return myIterator!=mySet.end();
1260 const SMDS_MeshNode* next()
1262 const SMDS_MeshNode* current=*myIterator;
1267 return new MyIterator(myNodes);
1270 ///////////////////////////////////////////////////////////////////////////////
1271 ///Return an iterator on volumes of the current mesh. Once used this iterator
1272 ///must be free by the caller
1273 ///////////////////////////////////////////////////////////////////////////////
1274 SMDS_Iterator<const SMDS_MeshEdge *> * SMDS_Mesh::edgesIterator() const
1276 class MyIterator:public SMDS_Iterator<const SMDS_MeshEdge*>
1278 const SetOfEdges& mySet;
1279 const SMDS_MeshEdge * myEdge;
1280 SetOfEdges::iterator myIterator;
1282 MyIterator(const SetOfEdges& s):mySet(s)
1284 myIterator=mySet.begin();
1289 while((myIterator!=mySet.end()))
1291 if((*myIterator)->GetID()!=-1)
1298 const SMDS_MeshEdge* next()
1300 const SMDS_MeshEdge* current=*myIterator;
1305 return new MyIterator(myEdges);
1308 ///////////////////////////////////////////////////////////////////////////////
1309 ///Return an iterator on faces of the current mesh. Once used this iterator
1310 ///must be free by the caller
1311 ///////////////////////////////////////////////////////////////////////////////
1312 SMDS_Iterator<const SMDS_MeshFace *> * SMDS_Mesh::facesIterator() const
1314 class MyIterator:public SMDS_Iterator<const SMDS_MeshFace*>
1316 const SetOfFaces& mySet;
1317 set<SMDS_MeshFace*>::iterator myIterator;
1319 MyIterator(const SetOfFaces& s):mySet(s)
1321 myIterator=mySet.begin();
1326 while((myIterator!=mySet.end()))
1328 if((*myIterator)->GetID()!=-1)
1335 const SMDS_MeshFace* next()
1337 const SMDS_MeshFace* current=*myIterator;
1342 return new MyIterator(myFaces);
1345 ///////////////////////////////////////////////////////////////////////////////
1346 ///Return an iterator on volumes of the current mesh. Once used this iterator
1347 ///must be free by the caller
1348 ///////////////////////////////////////////////////////////////////////////////
1349 SMDS_Iterator<const SMDS_MeshVolume *> * SMDS_Mesh::volumesIterator() const
1351 class MyIterator:public SMDS_Iterator<const SMDS_MeshVolume*>
1353 const SetOfVolumes& mySet;
1354 SetOfVolumes::iterator myIterator;
1356 MyIterator(const SetOfVolumes& s):mySet(s)
1358 myIterator=mySet.begin();
1363 return myIterator!=mySet.end();
1366 const SMDS_MeshVolume* next()
1368 const SMDS_MeshVolume* current=*myIterator;
1373 return new MyIterator(myVolumes);
1376 ///////////////////////////////////////////////////////////////////////////////
1377 /// Do intersection of sets (more than 2)
1378 ///////////////////////////////////////////////////////////////////////////////
1379 set<const SMDS_MeshElement*> * intersectionOfSets(
1380 set<const SMDS_MeshElement*> vs[], int numberOfSets)
1382 set<const SMDS_MeshElement*>* rsetA=new set<const SMDS_MeshElement*>(vs[0]);
1383 set<const SMDS_MeshElement*>* rsetB;
1385 for(int i=0; i<numberOfSets-1; i++)
1387 rsetB=new set<const SMDS_MeshElement*>();
1389 rsetA->begin(), rsetA->end(),
1390 vs[i+1].begin(), vs[i+1].end(),
1391 inserter(*rsetB, rsetB->begin()));
1398 ///////////////////////////////////////////////////////////////////////////////
1399 /// Return the list of finit elements owning the given element
1400 ///////////////////////////////////////////////////////////////////////////////
1401 set<const SMDS_MeshElement*> * getFinitElements(const SMDS_MeshElement * element)
1403 int numberOfSets=element->NbNodes();
1404 set<const SMDS_MeshElement*> initSet[numberOfSets];
1406 SMDS_Iterator<const SMDS_MeshElement*> * itNodes=element->nodesIterator();
1409 while(itNodes->more())
1411 const SMDS_MeshNode * n=static_cast<const SMDS_MeshNode*>(itNodes->next());
1412 SMDS_Iterator<const SMDS_MeshElement*> * itFe = n->GetInverseElementIterator();
1414 //initSet[i]=set<const SMDS_MeshElement*>();
1415 while(itFe->more()) initSet[i].insert(itFe->next());
1422 return intersectionOfSets(initSet, numberOfSets);
1425 ///////////////////////////////////////////////////////////////////////////////
1426 /// Return the list of nodes used only by the given elements
1427 ///////////////////////////////////////////////////////////////////////////////
1428 set<const SMDS_MeshElement*> * getExclusiveNodes(
1429 set<const SMDS_MeshElement*>& elements)
1431 set<const SMDS_MeshElement*> * toReturn=new set<const SMDS_MeshElement*>();
1432 set<const SMDS_MeshElement*>::iterator itElements=elements.begin();
1434 while(itElements!=elements.end())
1436 SMDS_Iterator<const SMDS_MeshElement*> * itNodes=
1437 (*itElements)->nodesIterator();
1440 while(itNodes->more())
1442 const SMDS_MeshNode * n=static_cast<const SMDS_MeshNode*>(itNodes->next());
1443 SMDS_Iterator<const SMDS_MeshElement*> * itFe = n->GetInverseElementIterator();
1444 set<const SMDS_MeshElement*> s;
1445 while(itFe->more()) s.insert(itFe->next());
1447 if(s==elements) toReturn->insert(n);
1454 ///////////////////////////////////////////////////////////////////////////////
1455 ///Find the children of an element that are made of given nodes
1456 ///@param setOfChildren The set in which matching children will be inserted
1457 ///@param element The element were to search matching children
1458 ///@param nodes The nodes that the children must have to be selected
1459 ///////////////////////////////////////////////////////////////////////////////
1460 void SMDS_Mesh::addChildrenWithNodes(set<const SMDS_MeshElement*>& setOfChildren,
1461 const SMDS_MeshElement * element, set<const SMDS_MeshElement*>& nodes)
1464 switch(element->GetType())
1467 MESSAGE("Internal Error: This should not append");
1471 SMDS_Iterator<const SMDS_MeshElement*> * itn=element->nodesIterator();
1474 const SMDS_MeshElement * e=itn->next();
1475 if(nodes.find(e)!=nodes.end()) setOfChildren.insert(element);
1481 SMDS_Iterator<const SMDS_MeshElement*> * itn=element->nodesIterator();
1484 const SMDS_MeshElement * e=itn->next();
1485 if(nodes.find(e)!=nodes.end()) setOfChildren.insert(element);
1488 if(hasConstructionEdges())
1490 SMDS_Iterator<const SMDS_MeshElement*>* ite=element->edgesIterator();
1492 addChildrenWithNodes(setOfChildren, ite->next(), nodes);
1496 case SMDSAbs_Volume:
1498 if(hasConstructionFaces())
1500 SMDS_Iterator<const SMDS_MeshElement*> * ite=element->facesIterator();
1502 addChildrenWithNodes(setOfChildren, ite->next(), nodes);
1505 else if(hasConstructionEdges())
1507 SMDS_Iterator<const SMDS_MeshElement*> * ite=element->edgesIterator();
1509 addChildrenWithNodes(setOfChildren, ite->next(), nodes);
1516 ///////////////////////////////////////////////////////////////////////////////
1517 ///@param elem The element to delete
1518 ///@param removenodes if true remaining nodes will be removed
1519 ///////////////////////////////////////////////////////////////////////////////
1520 void SMDS_Mesh::RemoveElement(const SMDS_MeshElement * elem,
1521 const bool removenodes)
1523 set<const SMDS_MeshElement*> * s1=getFinitElements(elem);
1525 set<const SMDS_MeshElement*> * s2=getExclusiveNodes(*s1);
1526 set<const SMDS_MeshElement*> s3;
1527 set<const SMDS_MeshElement*>::iterator it=s1->begin();
1528 while(it!=s1->end())
1530 addChildrenWithNodes(s3, *it ,*s2);
1534 if(elem->GetType()!=SMDSAbs_Node) s3.insert(elem);
1538 switch((*it)->GetType())
1541 MESSAGE("Internal Error: This should not happen");
1544 myEdges.erase(static_cast<SMDS_MeshEdge*>(
1545 const_cast<SMDS_MeshElement*>(*it)));
1548 myFaces.erase(static_cast<SMDS_MeshFace*>(
1549 const_cast<SMDS_MeshElement*>(*it)));
1551 case SMDSAbs_Volume:
1552 myVolumes.erase(static_cast<SMDS_MeshVolume*>(
1553 const_cast<SMDS_MeshElement*>(*it)));
1562 while(it!=s2->end())
1564 myNodes.erase(static_cast<SMDS_MeshNode*>(
1565 const_cast<SMDS_MeshElement*>(*it)));