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.salome-platform.org/ or email : webmaster.salome@opencascade.com
23 #pragma warning(disable:4786)
26 #include "utilities.h"
27 #include "SMDS_Mesh.hxx"
28 #include "SMDS_VolumeOfNodes.hxx"
29 #include "SMDS_VolumeOfFaces.hxx"
30 #include "SMDS_FaceOfNodes.hxx"
31 #include "SMDS_FaceOfEdges.hxx"
32 #include "SMDS_PolyhedralVolumeOfNodes.hxx"
33 #include "SMDS_PolygonalFaceOfNodes.hxx"
34 #include "SMDS_QuadraticEdge.hxx"
35 #include "SMDS_QuadraticFaceOfNodes.hxx"
36 #include "SMDS_QuadraticVolumeOfNodes.hxx"
42 ///////////////////////////////////////////////////////////////////////////////
43 /// Create a new mesh object
44 ///////////////////////////////////////////////////////////////////////////////
45 SMDS_Mesh::SMDS_Mesh()
47 myNodeIDFactory(new SMDS_MeshElementIDFactory()),
48 myElementIDFactory(new SMDS_MeshElementIDFactory()),
49 myHasConstructionEdges(false), myHasConstructionFaces(false),
50 myHasInverseElements(true)
54 ///////////////////////////////////////////////////////////////////////////////
55 /// Create a new child mesh
56 /// Note that the tree structure of SMDS_Mesh seems to be unused in this version
57 /// (2003-09-08) of SMESH
58 ///////////////////////////////////////////////////////////////////////////////
59 SMDS_Mesh::SMDS_Mesh(SMDS_Mesh * parent)
60 :myParent(parent), myNodeIDFactory(parent->myNodeIDFactory),
61 myElementIDFactory(parent->myElementIDFactory),
62 myHasConstructionEdges(false), myHasConstructionFaces(false),
63 myHasInverseElements(true)
67 ///////////////////////////////////////////////////////////////////////////////
68 ///Create a submesh and add it to the current mesh
69 ///////////////////////////////////////////////////////////////////////////////
71 SMDS_Mesh *SMDS_Mesh::AddSubMesh()
73 SMDS_Mesh *submesh = new SMDS_Mesh(this);
74 myChildren.insert(myChildren.end(), submesh);
78 ///////////////////////////////////////////////////////////////////////////////
79 ///create a MeshNode and add it to the current Mesh
80 ///An ID is automatically assigned to the node.
81 ///@return : The created node
82 ///////////////////////////////////////////////////////////////////////////////
84 SMDS_MeshNode * SMDS_Mesh::AddNode(double x, double y, double z)
86 return SMDS_Mesh::AddNodeWithID(x,y,z,myNodeIDFactory->GetFreeID());
89 ///////////////////////////////////////////////////////////////////////////////
90 ///create a MeshNode and add it to the current Mesh
91 ///@param ID : The ID of the MeshNode to create
92 ///@return : The created node or NULL if a node with this ID already exists
93 ///////////////////////////////////////////////////////////////////////////////
94 SMDS_MeshNode * SMDS_Mesh::AddNodeWithID(double x, double y, double z, int ID)
96 // find the MeshNode corresponding to ID
97 const SMDS_MeshElement *node = myNodeIDFactory->MeshElement(ID);
99 SMDS_MeshNode * node=new SMDS_MeshNode(x, y, z);
101 myNodeIDFactory->BindID(ID,node);
107 ///////////////////////////////////////////////////////////////////////////////
108 /// create a MeshEdge and add it to the current Mesh
109 /// @return : The created MeshEdge
110 ///////////////////////////////////////////////////////////////////////////////
112 SMDS_MeshEdge* SMDS_Mesh::AddEdgeWithID(int idnode1, int idnode2, int ID)
114 SMDS_MeshNode * node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1);
115 SMDS_MeshNode * node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2);
116 if(!node1 || !node2) return NULL;
117 return SMDS_Mesh::AddEdgeWithID(node1, node2, ID);
120 ///////////////////////////////////////////////////////////////////////////////
121 /// create a MeshEdge and add it to the current Mesh
122 /// @return : The created MeshEdge
123 ///////////////////////////////////////////////////////////////////////////////
125 SMDS_MeshEdge* SMDS_Mesh::AddEdge(const SMDS_MeshNode * node1,
126 const SMDS_MeshNode * node2)
128 return SMDS_Mesh::AddEdgeWithID(node1, node2, myElementIDFactory->GetFreeID());
131 ///////////////////////////////////////////////////////////////////////////////
132 /// Create a new edge and at it to the mesh
133 /// @param idnode1 ID of the first node
134 /// @param idnode2 ID of the second node
135 /// @param ID ID of the edge to create
136 /// @return The created edge or NULL if an element with this ID already exists or
137 /// if input nodes are not found.
138 ///////////////////////////////////////////////////////////////////////////////
140 SMDS_MeshEdge* SMDS_Mesh::AddEdgeWithID(const SMDS_MeshNode * n1,
141 const SMDS_MeshNode * n2,
144 if ( !n1 || !n2 ) return 0;
146 SMDS_MeshEdge * edge=new SMDS_MeshEdge(n1,n2);
147 if(myElementIDFactory->BindID(ID, edge)) {
148 SMDS_MeshNode *node1,*node2;
149 node1=const_cast<SMDS_MeshNode*>(n1);
150 node2=const_cast<SMDS_MeshNode*>(n2);
151 node1->AddInverseElement(edge);
152 node2->AddInverseElement(edge);
162 ///////////////////////////////////////////////////////////////////////////////
163 /// Add a triangle defined by its nodes. An ID is automatically affected to the
165 ///////////////////////////////////////////////////////////////////////////////
167 SMDS_MeshFace* SMDS_Mesh::AddFace(const SMDS_MeshNode * n1,
168 const SMDS_MeshNode * n2,
169 const SMDS_MeshNode * n3)
171 return SMDS_Mesh::AddFaceWithID(n1,n2,n3, myElementIDFactory->GetFreeID());
174 ///////////////////////////////////////////////////////////////////////////////
175 /// Add a triangle defined by its nodes IDs
176 ///////////////////////////////////////////////////////////////////////////////
178 SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(int idnode1, int idnode2, int idnode3, int ID)
180 SMDS_MeshNode * node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1);
181 SMDS_MeshNode * node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2);
182 SMDS_MeshNode * node3 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode3);
183 if(!node1 || !node2 || !node3) return NULL;
184 return SMDS_Mesh::AddFaceWithID(node1, node2, node3, ID);
187 ///////////////////////////////////////////////////////////////////////////////
188 /// Add a triangle defined by its nodes
189 ///////////////////////////////////////////////////////////////////////////////
191 SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
192 const SMDS_MeshNode * n2,
193 const SMDS_MeshNode * n3,
196 SMDS_MeshFace * face=createTriangle(n1, n2, n3);
198 if (face && !registerElement(ID, face)) {
199 RemoveElement(face, false);
205 ///////////////////////////////////////////////////////////////////////////////
206 /// Add a quadrangle defined by its nodes. An ID is automatically affected to the
208 ///////////////////////////////////////////////////////////////////////////////
210 SMDS_MeshFace* SMDS_Mesh::AddFace(const SMDS_MeshNode * n1,
211 const SMDS_MeshNode * n2,
212 const SMDS_MeshNode * n3,
213 const SMDS_MeshNode * n4)
215 return SMDS_Mesh::AddFaceWithID(n1,n2,n3, n4, myElementIDFactory->GetFreeID());
218 ///////////////////////////////////////////////////////////////////////////////
219 /// Add a quadrangle defined by its nodes IDs
220 ///////////////////////////////////////////////////////////////////////////////
222 SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(int idnode1,
228 SMDS_MeshNode *node1, *node2, *node3, *node4;
229 node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1);
230 node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2);
231 node3 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode3);
232 node4 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode4);
233 if(!node1 || !node2 || !node3 || !node4) return NULL;
234 return SMDS_Mesh::AddFaceWithID(node1, node2, node3, node4, ID);
237 ///////////////////////////////////////////////////////////////////////////////
238 /// Add a quadrangle defined by its nodes
239 ///////////////////////////////////////////////////////////////////////////////
241 SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
242 const SMDS_MeshNode * n2,
243 const SMDS_MeshNode * n3,
244 const SMDS_MeshNode * n4,
247 SMDS_MeshFace * face=createQuadrangle(n1, n2, n3, n4);
249 if (face && !registerElement(ID, face)) {
250 RemoveElement(face, false);
256 ///////////////////////////////////////////////////////////////////////////////
257 /// Add a triangle defined by its edges. An ID is automatically assigned to the
259 ///////////////////////////////////////////////////////////////////////////////
261 SMDS_MeshFace* SMDS_Mesh::AddFace(const SMDS_MeshEdge * e1,
262 const SMDS_MeshEdge * e2,
263 const SMDS_MeshEdge * e3)
265 if (!hasConstructionEdges())
267 return AddFaceWithID(e1,e2,e3, myElementIDFactory->GetFreeID());
270 ///////////////////////////////////////////////////////////////////////////////
271 /// Add a triangle defined by its edges
272 ///////////////////////////////////////////////////////////////////////////////
274 SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(const SMDS_MeshEdge * e1,
275 const SMDS_MeshEdge * e2,
276 const SMDS_MeshEdge * e3,
279 if (!hasConstructionEdges())
281 if ( !e1 || !e2 || !e3 ) return 0;
283 SMDS_MeshFace * face = new SMDS_FaceOfEdges(e1,e2,e3);
286 if (!registerElement(ID, face)) {
287 RemoveElement(face, false);
293 ///////////////////////////////////////////////////////////////////////////////
294 /// Add a quadrangle defined by its edges. An ID is automatically assigned to the
296 ///////////////////////////////////////////////////////////////////////////////
298 SMDS_MeshFace* SMDS_Mesh::AddFace(const SMDS_MeshEdge * e1,
299 const SMDS_MeshEdge * e2,
300 const SMDS_MeshEdge * e3,
301 const SMDS_MeshEdge * e4)
303 if (!hasConstructionEdges())
305 return AddFaceWithID(e1,e2,e3,e4, myElementIDFactory->GetFreeID());
308 ///////////////////////////////////////////////////////////////////////////////
309 /// Add a quadrangle defined by its edges
310 ///////////////////////////////////////////////////////////////////////////////
312 SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(const SMDS_MeshEdge * e1,
313 const SMDS_MeshEdge * e2,
314 const SMDS_MeshEdge * e3,
315 const SMDS_MeshEdge * e4,
318 if (!hasConstructionEdges())
320 if ( !e1 || !e2 || !e3 || !e4 ) return 0;
321 SMDS_MeshFace * face = new SMDS_FaceOfEdges(e1,e2,e3,e4);
324 if (!registerElement(ID, face))
326 RemoveElement(face, false);
332 ///////////////////////////////////////////////////////////////////////////////
333 ///Create a new tetrahedron and add it to the mesh.
334 ///@return The created tetrahedron
335 ///////////////////////////////////////////////////////////////////////////////
337 SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
338 const SMDS_MeshNode * n2,
339 const SMDS_MeshNode * n3,
340 const SMDS_MeshNode * n4)
342 int ID = myElementIDFactory->GetFreeID();
343 SMDS_MeshVolume * v = SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, ID);
344 if(v==NULL) myElementIDFactory->ReleaseID(ID);
348 ///////////////////////////////////////////////////////////////////////////////
349 ///Create a new tetrahedron and add it to the mesh.
350 ///@param ID The ID of the new volume
351 ///@return The created tetrahedron or NULL if an element with this ID already exists
352 ///or if input nodes are not found.
353 ///////////////////////////////////////////////////////////////////////////////
355 SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(int idnode1,
361 SMDS_MeshNode *node1, *node2, *node3, *node4;
362 node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1);
363 node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2);
364 node3 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode3);
365 node4 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode4);
366 if(!node1 || !node2 || !node3 || !node4) return NULL;
367 return SMDS_Mesh::AddVolumeWithID(node1, node2, node3, node4, ID);
370 ///////////////////////////////////////////////////////////////////////////////
371 ///Create a new tetrahedron and add it to the mesh.
372 ///@param ID The ID of the new volume
373 ///@return The created tetrahedron
374 ///////////////////////////////////////////////////////////////////////////////
376 SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
377 const SMDS_MeshNode * n2,
378 const SMDS_MeshNode * n3,
379 const SMDS_MeshNode * n4,
382 SMDS_MeshVolume* volume = 0;
383 if ( !n1 || !n2 || !n3 || !n4) return volume;
384 if(hasConstructionFaces()) {
385 SMDS_MeshFace * f1=FindFaceOrCreate(n1,n2,n3);
386 SMDS_MeshFace * f2=FindFaceOrCreate(n1,n2,n4);
387 SMDS_MeshFace * f3=FindFaceOrCreate(n1,n3,n4);
388 SMDS_MeshFace * f4=FindFaceOrCreate(n2,n3,n4);
389 volume=new SMDS_VolumeOfFaces(f1,f2,f3,f4);
390 myVolumes.Add(volume);
392 else if(hasConstructionEdges()) {
393 MESSAGE("Error : Not implemented");
397 volume=new SMDS_VolumeOfNodes(n1,n2,n3,n4);
398 myVolumes.Add(volume);
401 if (!registerElement(ID, volume)) {
402 RemoveElement(volume, false);
408 ///////////////////////////////////////////////////////////////////////////////
409 ///Create a new pyramid and add it to the mesh.
410 ///Nodes 1,2,3 and 4 define the base of the pyramid
411 ///@return The created pyramid
412 ///////////////////////////////////////////////////////////////////////////////
414 SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
415 const SMDS_MeshNode * n2,
416 const SMDS_MeshNode * n3,
417 const SMDS_MeshNode * n4,
418 const SMDS_MeshNode * n5)
420 int ID = myElementIDFactory->GetFreeID();
421 SMDS_MeshVolume * v = SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, ID);
422 if(v==NULL) myElementIDFactory->ReleaseID(ID);
426 ///////////////////////////////////////////////////////////////////////////////
427 ///Create a new pyramid and add it to the mesh.
428 ///Nodes 1,2,3 and 4 define the base of the pyramid
429 ///@param ID The ID of the new volume
430 ///@return The created pyramid or NULL if an element with this ID already exists
431 ///or if input nodes are not found.
432 ///////////////////////////////////////////////////////////////////////////////
434 SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(int idnode1,
441 SMDS_MeshNode *node1, *node2, *node3, *node4, *node5;
442 node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1);
443 node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2);
444 node3 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode3);
445 node4 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode4);
446 node5 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode5);
447 if(!node1 || !node2 || !node3 || !node4 || !node5) return NULL;
448 return SMDS_Mesh::AddVolumeWithID(node1, node2, node3, node4, node5, ID);
451 ///////////////////////////////////////////////////////////////////////////////
452 ///Create a new pyramid and add it to the mesh.
453 ///Nodes 1,2,3 and 4 define the base of the pyramid
454 ///@param ID The ID of the new volume
455 ///@return The created pyramid
456 ///////////////////////////////////////////////////////////////////////////////
458 SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
459 const SMDS_MeshNode * n2,
460 const SMDS_MeshNode * n3,
461 const SMDS_MeshNode * n4,
462 const SMDS_MeshNode * n5,
465 SMDS_MeshVolume* volume = 0;
466 if ( !n1 || !n2 || !n3 || !n4 || !n5) return volume;
467 if(hasConstructionFaces()) {
468 SMDS_MeshFace * f1=FindFaceOrCreate(n1,n2,n3,n4);
469 SMDS_MeshFace * f2=FindFaceOrCreate(n1,n2,n5);
470 SMDS_MeshFace * f3=FindFaceOrCreate(n2,n3,n5);
471 SMDS_MeshFace * f4=FindFaceOrCreate(n3,n4,n5);
472 volume=new SMDS_VolumeOfFaces(f1,f2,f3,f4);
473 myVolumes.Add(volume);
475 else if(hasConstructionEdges()) {
476 MESSAGE("Error : Not implemented");
480 volume=new SMDS_VolumeOfNodes(n1,n2,n3,n4,n5);
481 myVolumes.Add(volume);
484 if (!registerElement(ID, volume)) {
485 RemoveElement(volume, false);
491 ///////////////////////////////////////////////////////////////////////////////
492 ///Create a new prism and add it to the mesh.
493 ///Nodes 1,2,3 is a triangle and 1,2,5,4 a quadrangle.
494 ///@return The created prism
495 ///////////////////////////////////////////////////////////////////////////////
497 SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
498 const SMDS_MeshNode * n2,
499 const SMDS_MeshNode * n3,
500 const SMDS_MeshNode * n4,
501 const SMDS_MeshNode * n5,
502 const SMDS_MeshNode * n6)
504 int ID = myElementIDFactory->GetFreeID();
505 SMDS_MeshVolume * v = SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, n6, ID);
506 if(v==NULL) myElementIDFactory->ReleaseID(ID);
510 ///////////////////////////////////////////////////////////////////////////////
511 ///Create a new prism and add it to the mesh.
512 ///Nodes 1,2,3 is a triangle and 1,2,5,4 a quadrangle.
513 ///@param ID The ID of the new volume
514 ///@return The created prism or NULL if an element with this ID already exists
515 ///or if input nodes are not found.
516 ///////////////////////////////////////////////////////////////////////////////
518 SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(int idnode1,
526 SMDS_MeshNode *node1, *node2, *node3, *node4, *node5, *node6;
527 node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1);
528 node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2);
529 node3 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode3);
530 node4 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode4);
531 node5 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode5);
532 node6 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode6);
533 if(!node1 || !node2 || !node3 || !node4 || !node5 || !node6) return NULL;
534 return SMDS_Mesh::AddVolumeWithID(node1, node2, node3, node4, node5, node6, ID);
537 ///////////////////////////////////////////////////////////////////////////////
538 ///Create a new prism and add it to the mesh.
539 ///Nodes 1,2,3 is a triangle and 1,2,5,4 a quadrangle.
540 ///@param ID The ID of the new volume
541 ///@return The created prism
542 ///////////////////////////////////////////////////////////////////////////////
544 SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
545 const SMDS_MeshNode * n2,
546 const SMDS_MeshNode * n3,
547 const SMDS_MeshNode * n4,
548 const SMDS_MeshNode * n5,
549 const SMDS_MeshNode * n6,
552 SMDS_MeshVolume* volume = 0;
553 if ( !n1 || !n2 || !n3 || !n4 || !n5 || !n6) return volume;
554 if(hasConstructionFaces()) {
555 SMDS_MeshFace * f1=FindFaceOrCreate(n1,n2,n3);
556 SMDS_MeshFace * f2=FindFaceOrCreate(n4,n5,n6);
557 SMDS_MeshFace * f3=FindFaceOrCreate(n1,n4,n5,n2);
558 SMDS_MeshFace * f4=FindFaceOrCreate(n2,n5,n6,n3);
559 SMDS_MeshFace * f5=FindFaceOrCreate(n3,n6,n4,n1);
560 volume=new SMDS_VolumeOfFaces(f1,f2,f3,f4,f5);
561 myVolumes.Add(volume);
563 else if(hasConstructionEdges()) {
564 MESSAGE("Error : Not implemented");
568 volume=new SMDS_VolumeOfNodes(n1,n2,n3,n4,n5,n6);
569 myVolumes.Add(volume);
572 if (!registerElement(ID, volume)) {
573 RemoveElement(volume, false);
579 ///////////////////////////////////////////////////////////////////////////////
580 ///Create a new hexahedron and add it to the mesh.
581 ///Nodes 1,2,3,4 and 5,6,7,8 are quadrangle and 5,1 and 7,3 are an edges.
582 ///@return The created hexahedron
583 ///////////////////////////////////////////////////////////////////////////////
585 SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
586 const SMDS_MeshNode * n2,
587 const SMDS_MeshNode * n3,
588 const SMDS_MeshNode * n4,
589 const SMDS_MeshNode * n5,
590 const SMDS_MeshNode * n6,
591 const SMDS_MeshNode * n7,
592 const SMDS_MeshNode * n8)
594 int ID = myElementIDFactory->GetFreeID();
595 SMDS_MeshVolume * v = SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, n6, n7, n8, ID);
596 if(v==NULL) myElementIDFactory->ReleaseID(ID);
600 ///////////////////////////////////////////////////////////////////////////////
601 ///Create a new hexahedron and add it to the mesh.
602 ///Nodes 1,2,3,4 and 5,6,7,8 are quadrangle and 5,1 and 7,3 are an edges.
603 ///@param ID The ID of the new volume
604 ///@return The created hexahedron or NULL if an element with this ID already
605 ///exists or if input nodes are not found.
606 ///////////////////////////////////////////////////////////////////////////////
608 SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(int idnode1,
618 SMDS_MeshNode *node1, *node2, *node3, *node4, *node5, *node6, *node7, *node8;
619 node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1);
620 node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2);
621 node3 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode3);
622 node4 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode4);
623 node5 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode5);
624 node6 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode6);
625 node7 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode7);
626 node8 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode8);
627 if(!node1 || !node2 || !node3 || !node4 || !node5 || !node6 || !node7 || !node8)
629 return SMDS_Mesh::AddVolumeWithID(node1, node2, node3, node4, node5, node6,
633 ///////////////////////////////////////////////////////////////////////////////
634 ///Create a new hexahedron and add it to the mesh.
635 ///Nodes 1,2,3,4 and 5,6,7,8 are quadrangle and 5,1 and 7,3 are an edges.
636 ///@param ID The ID of the new volume
637 ///@return The created prism or NULL if an element with this ID already exists
638 ///or if input nodes are not found.
639 ///////////////////////////////////////////////////////////////////////////////
641 SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
642 const SMDS_MeshNode * n2,
643 const SMDS_MeshNode * n3,
644 const SMDS_MeshNode * n4,
645 const SMDS_MeshNode * n5,
646 const SMDS_MeshNode * n6,
647 const SMDS_MeshNode * n7,
648 const SMDS_MeshNode * n8,
651 SMDS_MeshVolume* volume = 0;
652 if ( !n1 || !n2 || !n3 || !n4 || !n5 || !n6 || !n7 || !n8) return volume;
653 if(hasConstructionFaces()) {
654 SMDS_MeshFace * f1=FindFaceOrCreate(n1,n2,n3,n4);
655 SMDS_MeshFace * f2=FindFaceOrCreate(n5,n6,n7,n8);
656 SMDS_MeshFace * f3=FindFaceOrCreate(n1,n4,n8,n5);
657 SMDS_MeshFace * f4=FindFaceOrCreate(n1,n2,n6,n5);
658 SMDS_MeshFace * f5=FindFaceOrCreate(n2,n3,n7,n6);
659 SMDS_MeshFace * f6=FindFaceOrCreate(n3,n4,n8,n7);
660 volume=new SMDS_VolumeOfFaces(f1,f2,f3,f4,f5,f6);
661 myVolumes.Add(volume);
663 else if(hasConstructionEdges()) {
664 MESSAGE("Error : Not implemented");
668 // volume=new SMDS_HexahedronOfNodes(n1,n2,n3,n4,n5,n6,n7,n8);
669 volume=new SMDS_VolumeOfNodes(n1,n2,n3,n4,n5,n6,n7,n8);
670 myVolumes.Add(volume);
673 if (!registerElement(ID, volume)) {
674 RemoveElement(volume, false);
680 ///////////////////////////////////////////////////////////////////////////////
681 ///Create a new tetrahedron defined by its faces and add it to the mesh.
682 ///@return The created tetrahedron
683 ///////////////////////////////////////////////////////////////////////////////
685 SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshFace * f1,
686 const SMDS_MeshFace * f2,
687 const SMDS_MeshFace * f3,
688 const SMDS_MeshFace * f4)
690 if (!hasConstructionFaces())
692 return AddVolumeWithID(f1,f2,f3,f4, myElementIDFactory->GetFreeID());
695 ///////////////////////////////////////////////////////////////////////////////
696 ///Create a new tetrahedron defined by its faces and add it to the mesh.
697 ///@param ID The ID of the new volume
698 ///@return The created tetrahedron
699 ///////////////////////////////////////////////////////////////////////////////
701 SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshFace * f1,
702 const SMDS_MeshFace * f2,
703 const SMDS_MeshFace * f3,
704 const SMDS_MeshFace * f4,
707 if (!hasConstructionFaces())
709 if ( !f1 || !f2 || !f3 || !f4) return 0;
710 SMDS_MeshVolume * volume = new SMDS_VolumeOfFaces(f1,f2,f3,f4);
711 myVolumes.Add(volume);
713 if (!registerElement(ID, volume)) {
714 RemoveElement(volume, false);
720 ///////////////////////////////////////////////////////////////////////////////
721 ///Create a new pyramid defined by its faces and add it to the mesh.
722 ///@return The created pyramid
723 ///////////////////////////////////////////////////////////////////////////////
725 SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshFace * f1,
726 const SMDS_MeshFace * f2,
727 const SMDS_MeshFace * f3,
728 const SMDS_MeshFace * f4,
729 const SMDS_MeshFace * f5)
731 if (!hasConstructionFaces())
733 return AddVolumeWithID(f1,f2,f3,f4,f5, myElementIDFactory->GetFreeID());
736 ///////////////////////////////////////////////////////////////////////////////
737 ///Create a new pyramid defined by its faces and add it to the mesh.
738 ///@param ID The ID of the new volume
739 ///@return The created pyramid
740 ///////////////////////////////////////////////////////////////////////////////
742 SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshFace * f1,
743 const SMDS_MeshFace * f2,
744 const SMDS_MeshFace * f3,
745 const SMDS_MeshFace * f4,
746 const SMDS_MeshFace * f5,
749 if (!hasConstructionFaces())
751 if ( !f1 || !f2 || !f3 || !f4 || !f5) return 0;
752 SMDS_MeshVolume * volume = new SMDS_VolumeOfFaces(f1,f2,f3,f4,f5);
753 myVolumes.Add(volume);
755 if (!registerElement(ID, volume)) {
756 RemoveElement(volume, false);
762 ///////////////////////////////////////////////////////////////////////////////
763 ///Create a new prism defined by its faces and add it to the mesh.
764 ///@return The created prism
765 ///////////////////////////////////////////////////////////////////////////////
767 SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshFace * f1,
768 const SMDS_MeshFace * f2,
769 const SMDS_MeshFace * f3,
770 const SMDS_MeshFace * f4,
771 const SMDS_MeshFace * f5,
772 const SMDS_MeshFace * f6)
774 if (!hasConstructionFaces())
776 return AddVolumeWithID(f1,f2,f3,f4,f5,f6, myElementIDFactory->GetFreeID());
779 ///////////////////////////////////////////////////////////////////////////////
780 ///Create a new prism defined by its faces and add it to the mesh.
781 ///@param ID The ID of the new volume
782 ///@return The created prism
783 ///////////////////////////////////////////////////////////////////////////////
785 SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshFace * f1,
786 const SMDS_MeshFace * f2,
787 const SMDS_MeshFace * f3,
788 const SMDS_MeshFace * f4,
789 const SMDS_MeshFace * f5,
790 const SMDS_MeshFace * f6,
793 if (!hasConstructionFaces())
795 if ( !f1 || !f2 || !f3 || !f4 || !f5 || !f6) return 0;
796 SMDS_MeshVolume * volume = new SMDS_VolumeOfFaces(f1,f2,f3,f4,f5,f6);
797 myVolumes.Add(volume);
799 if (!registerElement(ID, volume)) {
800 RemoveElement(volume, false);
806 ///////////////////////////////////////////////////////////////////////////////
807 /// Add a polygon defined by its nodes IDs
808 ///////////////////////////////////////////////////////////////////////////////
810 SMDS_MeshFace* SMDS_Mesh::AddPolygonalFaceWithID (std::vector<int> nodes_ids,
813 int nbNodes = nodes_ids.size();
814 std::vector<const SMDS_MeshNode*> nodes (nbNodes);
815 for (int i = 0; i < nbNodes; i++) {
816 nodes[i] = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(nodes_ids[i]);
817 if (!nodes[i]) return NULL;
819 return SMDS_Mesh::AddPolygonalFaceWithID(nodes, ID);
822 ///////////////////////////////////////////////////////////////////////////////
823 /// Add a polygon defined by its nodes
824 ///////////////////////////////////////////////////////////////////////////////
826 SMDS_MeshFace* SMDS_Mesh::AddPolygonalFaceWithID
827 (std::vector<const SMDS_MeshNode*> nodes,
830 SMDS_MeshFace * face;
832 if (hasConstructionEdges())
834 MESSAGE("Error : Not implemented");
839 for ( int i = 0; i < nodes.size(); ++i )
840 if ( !nodes[ i ] ) return 0;
841 face = new SMDS_PolygonalFaceOfNodes(nodes);
845 if (!registerElement(ID, face)) {
846 RemoveElement(face, false);
852 ///////////////////////////////////////////////////////////////////////////////
853 /// Add a polygon defined by its nodes.
854 /// An ID is automatically affected to the created face.
855 ///////////////////////////////////////////////////////////////////////////////
857 SMDS_MeshFace* SMDS_Mesh::AddPolygonalFace (std::vector<const SMDS_MeshNode*> nodes)
859 return SMDS_Mesh::AddPolygonalFaceWithID(nodes, myElementIDFactory->GetFreeID());
862 ///////////////////////////////////////////////////////////////////////////////
863 /// Create a new polyhedral volume and add it to the mesh.
864 /// @param ID The ID of the new volume
865 /// @return The created volume or NULL if an element with this ID already exists
866 /// or if input nodes are not found.
867 ///////////////////////////////////////////////////////////////////////////////
869 SMDS_MeshVolume * SMDS_Mesh::AddPolyhedralVolumeWithID
870 (std::vector<int> nodes_ids,
871 std::vector<int> quantities,
874 int nbNodes = nodes_ids.size();
875 std::vector<const SMDS_MeshNode*> nodes (nbNodes);
876 for (int i = 0; i < nbNodes; i++) {
877 nodes[i] = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(nodes_ids[i]);
878 if (!nodes[i]) return NULL;
880 return SMDS_Mesh::AddPolyhedralVolumeWithID(nodes, quantities, ID);
883 ///////////////////////////////////////////////////////////////////////////////
884 /// Create a new polyhedral volume and add it to the mesh.
885 /// @param ID The ID of the new volume
886 /// @return The created volume
887 ///////////////////////////////////////////////////////////////////////////////
889 SMDS_MeshVolume* SMDS_Mesh::AddPolyhedralVolumeWithID
890 (std::vector<const SMDS_MeshNode*> nodes,
891 std::vector<int> quantities,
894 SMDS_MeshVolume* volume;
895 if (hasConstructionFaces()) {
896 MESSAGE("Error : Not implemented");
898 } else if (hasConstructionEdges()) {
899 MESSAGE("Error : Not implemented");
902 for ( int i = 0; i < nodes.size(); ++i )
903 if ( !nodes[ i ] ) return 0;
904 volume = new SMDS_PolyhedralVolumeOfNodes(nodes, quantities);
905 myVolumes.Add(volume);
908 if (!registerElement(ID, volume)) {
909 RemoveElement(volume, false);
915 ///////////////////////////////////////////////////////////////////////////////
916 /// Create a new polyhedral volume and add it to the mesh.
917 /// @return The created volume
918 ///////////////////////////////////////////////////////////////////////////////
920 SMDS_MeshVolume* SMDS_Mesh::AddPolyhedralVolume
921 (std::vector<const SMDS_MeshNode*> nodes,
922 std::vector<int> quantities)
924 int ID = myElementIDFactory->GetFreeID();
925 SMDS_MeshVolume * v = SMDS_Mesh::AddPolyhedralVolumeWithID(nodes, quantities, ID);
926 if (v == NULL) myElementIDFactory->ReleaseID(ID);
930 ///////////////////////////////////////////////////////////////////////////////
931 /// Registers element with the given ID, maintains inverse connections
932 ///////////////////////////////////////////////////////////////////////////////
933 bool SMDS_Mesh::registerElement(int ID, SMDS_MeshElement * element)
935 if (myElementIDFactory->BindID(ID, element)) {
936 SMDS_ElemIteratorPtr it = element->nodesIterator();
938 SMDS_MeshNode *node = static_cast<SMDS_MeshNode*>
939 (const_cast<SMDS_MeshElement*>(it->next()));
940 node->AddInverseElement(element);
947 ///////////////////////////////////////////////////////////////////////////////
948 /// Return the node whose ID is 'ID'.
949 ///////////////////////////////////////////////////////////////////////////////
950 const SMDS_MeshNode * SMDS_Mesh::FindNode(int ID) const
952 return (const SMDS_MeshNode *)myNodeIDFactory->MeshElement(ID);
955 ///////////////////////////////////////////////////////////////////////////////
956 ///Create a triangle and add it to the current mesh. This methode do not bind a
957 ///ID to the create triangle.
958 ///////////////////////////////////////////////////////////////////////////////
959 SMDS_MeshFace * SMDS_Mesh::createTriangle(const SMDS_MeshNode * node1,
960 const SMDS_MeshNode * node2,
961 const SMDS_MeshNode * node3)
963 if ( !node1 || !node2 || !node3) return 0;
964 if(hasConstructionEdges())
966 SMDS_MeshEdge *edge1, *edge2, *edge3;
967 edge1=FindEdgeOrCreate(node1,node2);
968 edge2=FindEdgeOrCreate(node2,node3);
969 edge3=FindEdgeOrCreate(node3,node1);
971 SMDS_MeshFace * face = new SMDS_FaceOfEdges(edge1,edge2,edge3);
977 SMDS_MeshFace * face = new SMDS_FaceOfNodes(node1,node2,node3);
983 ///////////////////////////////////////////////////////////////////////////////
984 ///Create a quadrangle and add it to the current mesh. This methode do not bind
985 ///a ID to the create triangle.
986 ///////////////////////////////////////////////////////////////////////////////
987 SMDS_MeshFace * SMDS_Mesh::createQuadrangle(const SMDS_MeshNode * node1,
988 const SMDS_MeshNode * node2,
989 const SMDS_MeshNode * node3,
990 const SMDS_MeshNode * node4)
992 if ( !node1 || !node2 || !node3 || !node4 ) return 0;
993 if(hasConstructionEdges())
995 SMDS_MeshEdge *edge1, *edge2, *edge3, *edge4;
996 edge1=FindEdgeOrCreate(node1,node2);
997 edge2=FindEdgeOrCreate(node2,node3);
998 edge3=FindEdgeOrCreate(node3,node4);
999 edge4=FindEdgeOrCreate(node4,node1);
1001 SMDS_MeshFace * face = new SMDS_FaceOfEdges(edge1,edge2,edge3,edge4);
1007 SMDS_MeshFace * face = new SMDS_FaceOfNodes(node1,node2,node3,node4);
1013 ///////////////////////////////////////////////////////////////////////////////
1014 /// Remove a node and all the elements which own this node
1015 ///////////////////////////////////////////////////////////////////////////////
1017 void SMDS_Mesh::RemoveNode(const SMDS_MeshNode * node)
1019 RemoveElement(node, true);
1022 ///////////////////////////////////////////////////////////////////////////////
1023 /// Remove an edge and all the elements which own this edge
1024 ///////////////////////////////////////////////////////////////////////////////
1026 void SMDS_Mesh::RemoveEdge(const SMDS_MeshEdge * edge)
1028 RemoveElement(edge,true);
1031 ///////////////////////////////////////////////////////////////////////////////
1032 /// Remove an face and all the elements which own this face
1033 ///////////////////////////////////////////////////////////////////////////////
1035 void SMDS_Mesh::RemoveFace(const SMDS_MeshFace * face)
1037 RemoveElement(face, true);
1040 ///////////////////////////////////////////////////////////////////////////////
1042 ///////////////////////////////////////////////////////////////////////////////
1044 void SMDS_Mesh::RemoveVolume(const SMDS_MeshVolume * volume)
1046 RemoveElement(volume, true);
1049 //=======================================================================
1050 //function : RemoveFromParent
1052 //=======================================================================
1054 bool SMDS_Mesh::RemoveFromParent()
1056 if (myParent==NULL) return false;
1057 else return (myParent->RemoveSubMesh(this));
1060 //=======================================================================
1061 //function : RemoveSubMesh
1063 //=======================================================================
1065 bool SMDS_Mesh::RemoveSubMesh(const SMDS_Mesh * aMesh)
1069 list<SMDS_Mesh *>::iterator itmsh=myChildren.begin();
1070 for (; itmsh!=myChildren.end() && !found; itmsh++)
1072 SMDS_Mesh * submesh = *itmsh;
1073 if (submesh == aMesh)
1076 myChildren.erase(itmsh);
1083 //=======================================================================
1084 //function : ChangeElementNodes
1086 //=======================================================================
1088 bool SMDS_Mesh::ChangeElementNodes(const SMDS_MeshElement * elem,
1089 const SMDS_MeshNode * nodes[],
1092 // keep current nodes of elem
1093 set<const SMDS_MeshElement*> oldNodes;
1094 SMDS_ElemIteratorPtr itn = elem->nodesIterator();
1096 oldNodes.insert( itn->next() );
1100 switch ( elem->GetType() )
1102 case SMDSAbs_Edge: {
1103 if ( nbnodes == 2 ) {
1104 const SMDS_MeshEdge* edge = dynamic_cast<const SMDS_MeshEdge*>( elem );
1106 Ok = const_cast<SMDS_MeshEdge*>( edge )->ChangeNodes( nodes[0], nodes[1] );
1108 else if ( nbnodes == 3 ) {
1109 const SMDS_QuadraticEdge* edge = dynamic_cast<const SMDS_QuadraticEdge*>( elem );
1111 Ok = const_cast<SMDS_QuadraticEdge*>( edge )->ChangeNodes( nodes[0], nodes[1], nodes[2] );
1115 case SMDSAbs_Face: {
1116 const SMDS_FaceOfNodes* face = dynamic_cast<const SMDS_FaceOfNodes*>( elem );
1118 Ok = const_cast<SMDS_FaceOfNodes*>( face )->ChangeNodes( nodes, nbnodes );
1121 const SMDS_QuadraticFaceOfNodes* QF =
1122 dynamic_cast<const SMDS_QuadraticFaceOfNodes*>( elem );
1124 Ok = const_cast<SMDS_QuadraticFaceOfNodes*>( QF )->ChangeNodes( nodes, nbnodes );
1128 const SMDS_PolygonalFaceOfNodes* face = dynamic_cast<const SMDS_PolygonalFaceOfNodes*>(elem);
1130 Ok = const_cast<SMDS_PolygonalFaceOfNodes*>(face)->ChangeNodes(nodes, nbnodes);
1137 //case SMDSAbs_PolygonalFace: {
1138 // const SMDS_PolygonalFaceOfNodes* face = dynamic_cast<const SMDS_PolygonalFaceOfNodes*>(elem);
1140 // Ok = const_cast<SMDS_PolygonalFaceOfNodes*>(face)->ChangeNodes(nodes, nbnodes);
1144 case SMDSAbs_Volume: {
1145 const SMDS_VolumeOfNodes* vol = dynamic_cast<const SMDS_VolumeOfNodes*>( elem );
1147 Ok = const_cast<SMDS_VolumeOfNodes*>( vol )->ChangeNodes( nodes, nbnodes );
1150 const SMDS_QuadraticVolumeOfNodes* QV = dynamic_cast<const SMDS_QuadraticVolumeOfNodes*>( elem );
1152 Ok = const_cast<SMDS_QuadraticVolumeOfNodes*>( QV )->ChangeNodes( nodes, nbnodes );
1158 MESSAGE ( "WRONG ELEM TYPE");
1161 if ( Ok ) { // update InverseElements
1163 // AddInverseElement to new nodes
1164 for ( int i = 0; i < nbnodes; i++ )
1165 if ( oldNodes.find( nodes[i] ) == oldNodes.end() )
1167 const_cast<SMDS_MeshNode*>( nodes[i] )->AddInverseElement( elem );
1169 // remove from oldNodes a node that remains in elem
1170 oldNodes.erase( nodes[i] );
1173 // RemoveInverseElement from the nodes removed from elem
1174 set<const SMDS_MeshElement*>::iterator it;
1175 for ( it = oldNodes.begin(); it != oldNodes.end(); it++ )
1177 SMDS_MeshNode * n = static_cast<SMDS_MeshNode *>
1178 (const_cast<SMDS_MeshElement *>( *it ));
1179 n->RemoveInverseElement( elem );
1183 //MESSAGE ( "::ChangeNodes() Ok = " << Ok);
1188 //=======================================================================
1189 //function : ChangePolyhedronNodes
1190 //purpose : to change nodes of polyhedral volume
1191 //=======================================================================
1192 bool SMDS_Mesh::ChangePolyhedronNodes (const SMDS_MeshElement * elem,
1193 std::vector<const SMDS_MeshNode*> nodes,
1194 std::vector<int> quantities)
1196 if (elem->GetType() != SMDSAbs_Volume) {
1197 MESSAGE("WRONG ELEM TYPE");
1201 const SMDS_PolyhedralVolumeOfNodes* vol = dynamic_cast<const SMDS_PolyhedralVolumeOfNodes*>(elem);
1206 // keep current nodes of elem
1207 set<const SMDS_MeshElement*> oldNodes;
1208 SMDS_ElemIteratorPtr itn = elem->nodesIterator();
1209 while (itn->more()) {
1210 oldNodes.insert(itn->next());
1214 bool Ok = const_cast<SMDS_PolyhedralVolumeOfNodes*>(vol)->ChangeNodes(nodes, quantities);
1219 // update InverseElements
1221 // AddInverseElement to new nodes
1222 int nbnodes = nodes.size();
1223 for (int i = 0; i < nbnodes; i++) {
1224 if (oldNodes.find(nodes[i]) == oldNodes.end()) {
1226 const_cast<SMDS_MeshNode*>(nodes[i])->AddInverseElement(elem);
1228 // remove from oldNodes a node that remains in elem
1229 oldNodes.erase(nodes[i]);
1233 // RemoveInverseElement from the nodes removed from elem
1234 set<const SMDS_MeshElement*>::iterator it;
1235 for (it = oldNodes.begin(); it != oldNodes.end(); it++) {
1236 SMDS_MeshNode * n = static_cast<SMDS_MeshNode *>
1237 (const_cast<SMDS_MeshElement *>( *it ));
1238 n->RemoveInverseElement(elem);
1245 //=======================================================================
1246 //function : FindEdge
1248 //=======================================================================
1250 const SMDS_MeshEdge* SMDS_Mesh::FindEdge(int idnode1, int idnode2) const
1252 const SMDS_MeshNode * node1=FindNode(idnode1);
1253 const SMDS_MeshNode * node2=FindNode(idnode2);
1254 if((node1==NULL)||(node2==NULL)) return NULL;
1255 return FindEdge(node1,node2);
1258 //#include "Profiler.h"
1259 const SMDS_MeshEdge* SMDS_Mesh::FindEdge(const SMDS_MeshNode * node1,
1260 const SMDS_MeshNode * node2)
1262 if ( !node1 ) return 0;
1263 const SMDS_MeshEdge * toReturn=NULL;
1266 SMDS_ElemIteratorPtr it1=node1->GetInverseElementIterator(SMDSAbs_Edge);
1269 while(it1->more()) {
1270 const SMDS_MeshElement * e = it1->next();
1271 if ( e->NbNodes() == 2 && e->GetNodeIndex( node2 ) >= 0 ) {
1272 toReturn = static_cast<const SMDS_MeshEdge*>( e );
1281 //=======================================================================
1282 //function : FindEdgeOrCreate
1284 //=======================================================================
1286 SMDS_MeshEdge* SMDS_Mesh::FindEdgeOrCreate(const SMDS_MeshNode * node1,
1287 const SMDS_MeshNode * node2)
1289 if ( !node1 || !node2) return 0;
1290 SMDS_MeshEdge * toReturn=NULL;
1291 toReturn=const_cast<SMDS_MeshEdge*>(FindEdge(node1,node2));
1292 if(toReturn==NULL) {
1293 toReturn=new SMDS_MeshEdge(node1,node2);
1294 myEdges.Add(toReturn);
1300 //=======================================================================
1301 //function : FindEdge
1303 //=======================================================================
1305 const SMDS_MeshEdge* SMDS_Mesh::FindEdge(int idnode1, int idnode2,
1308 const SMDS_MeshNode * node1=FindNode(idnode1);
1309 const SMDS_MeshNode * node2=FindNode(idnode2);
1310 const SMDS_MeshNode * node3=FindNode(idnode3);
1311 return FindEdge(node1,node2,node3);
1314 const SMDS_MeshEdge* SMDS_Mesh::FindEdge(const SMDS_MeshNode * node1,
1315 const SMDS_MeshNode * node2,
1316 const SMDS_MeshNode * node3)
1318 if ( !node1 ) return 0;
1319 SMDS_ElemIteratorPtr it1 = node1->GetInverseElementIterator(SMDSAbs_Edge);
1320 while(it1->more()) {
1321 const SMDS_MeshElement * e = it1->next();
1322 if ( e->NbNodes() == 3 &&
1323 e->GetNodeIndex( node2 ) >= 0 &&
1324 e->GetNodeIndex( node3 ) >= 0 ) {
1325 return static_cast<const SMDS_MeshEdge*>( e );
1332 //=======================================================================
1333 //function : FindFace
1335 //=======================================================================
1337 const SMDS_MeshFace* SMDS_Mesh::FindFace(int idnode1, int idnode2,
1340 const SMDS_MeshNode * node1=FindNode(idnode1);
1341 const SMDS_MeshNode * node2=FindNode(idnode2);
1342 const SMDS_MeshNode * node3=FindNode(idnode3);
1343 return FindFace(node1, node2, node3);
1346 const SMDS_MeshFace* SMDS_Mesh::FindFace(const SMDS_MeshNode *node1,
1347 const SMDS_MeshNode *node2,
1348 const SMDS_MeshNode *node3)
1350 if ( !node1 ) return 0;
1351 SMDS_ElemIteratorPtr it1 = node1->GetInverseElementIterator(SMDSAbs_Face);
1352 while(it1->more()) {
1353 const SMDS_MeshElement * e = it1->next();
1354 if ( e->NbNodes() == 3 &&
1355 e->GetNodeIndex( node2 ) >= 0 &&
1356 e->GetNodeIndex( node3 ) >= 0 ) {
1357 return static_cast<const SMDS_MeshFace*>( e );
1363 SMDS_MeshFace* SMDS_Mesh::FindFaceOrCreate(const SMDS_MeshNode *node1,
1364 const SMDS_MeshNode *node2,
1365 const SMDS_MeshNode *node3)
1367 SMDS_MeshFace * toReturn=NULL;
1368 toReturn = const_cast<SMDS_MeshFace*>(FindFace(node1,node2,node3));
1369 if(toReturn==NULL) {
1370 toReturn = createTriangle(node1,node2,node3);
1376 //=======================================================================
1377 //function : FindFace
1379 //=======================================================================
1381 const SMDS_MeshFace* SMDS_Mesh::FindFace(int idnode1, int idnode2,
1382 int idnode3, int idnode4) const
1384 const SMDS_MeshNode * node1=FindNode(idnode1);
1385 const SMDS_MeshNode * node2=FindNode(idnode2);
1386 const SMDS_MeshNode * node3=FindNode(idnode3);
1387 const SMDS_MeshNode * node4=FindNode(idnode4);
1388 return FindFace(node1, node2, node3, node4);
1391 const SMDS_MeshFace* SMDS_Mesh::FindFace(const SMDS_MeshNode *node1,
1392 const SMDS_MeshNode *node2,
1393 const SMDS_MeshNode *node3,
1394 const SMDS_MeshNode *node4)
1396 if ( !node1 ) return 0;
1397 SMDS_ElemIteratorPtr it1 = node1->GetInverseElementIterator(SMDSAbs_Face);
1398 while(it1->more()) {
1399 const SMDS_MeshElement* f = it1->next();
1400 if ( f->NbNodes() == 4 &&
1401 f->GetNodeIndex( node2 ) >= 0 &&
1402 f->GetNodeIndex( node3 ) >= 0 &&
1403 f->GetNodeIndex( node4 ) >= 0 )
1404 return static_cast<const SMDS_MeshFace *>( f );
1409 SMDS_MeshFace* SMDS_Mesh::FindFaceOrCreate(const SMDS_MeshNode *node1,
1410 const SMDS_MeshNode *node2,
1411 const SMDS_MeshNode *node3,
1412 const SMDS_MeshNode *node4)
1414 SMDS_MeshFace * toReturn=NULL;
1415 toReturn=const_cast<SMDS_MeshFace*>(FindFace(node1,node2,node3,node4));
1416 if(toReturn==NULL) {
1417 toReturn=createQuadrangle(node1,node2,node3,node4);
1423 //=======================================================================
1424 //function : FindFace
1425 //purpose :quadratic triangle
1426 //=======================================================================
1428 const SMDS_MeshFace* SMDS_Mesh::FindFace(int idnode1, int idnode2,
1429 int idnode3, int idnode4,
1430 int idnode5, int idnode6) const
1432 const SMDS_MeshNode * node1 = FindNode(idnode1);
1433 const SMDS_MeshNode * node2 = FindNode(idnode2);
1434 const SMDS_MeshNode * node3 = FindNode(idnode3);
1435 const SMDS_MeshNode * node4 = FindNode(idnode4);
1436 const SMDS_MeshNode * node5 = FindNode(idnode5);
1437 const SMDS_MeshNode * node6 = FindNode(idnode6);
1438 return FindFace(node1, node2, node3, node4, node5, node6);
1441 const SMDS_MeshFace* SMDS_Mesh::FindFace(const SMDS_MeshNode *node1,
1442 const SMDS_MeshNode *node2,
1443 const SMDS_MeshNode *node3,
1444 const SMDS_MeshNode *node4,
1445 const SMDS_MeshNode *node5,
1446 const SMDS_MeshNode *node6)
1448 if ( !node1 ) return 0;
1449 SMDS_ElemIteratorPtr it1 = node1->GetInverseElementIterator(SMDSAbs_Face);
1450 while(it1->more()) {
1451 const SMDS_MeshElement* f = it1->next();
1452 if ( f->NbNodes() == 6 &&
1453 f->GetNodeIndex( node2 ) >= 0 &&
1454 f->GetNodeIndex( node3 ) >= 0 &&
1455 f->GetNodeIndex( node4 ) >= 0 &&
1456 f->GetNodeIndex( node5 ) >= 0 &&
1457 f->GetNodeIndex( node6 ) >= 0 )
1458 return static_cast<const SMDS_MeshFace *>( f );
1464 //=======================================================================
1465 //function : FindFace
1466 //purpose : quadratic quadrangle
1467 //=======================================================================
1469 const SMDS_MeshFace* SMDS_Mesh::FindFace(int idnode1, int idnode2,
1470 int idnode3, int idnode4,
1471 int idnode5, int idnode6,
1472 int idnode7, int idnode8) const
1474 const SMDS_MeshNode * node1 = FindNode(idnode1);
1475 const SMDS_MeshNode * node2 = FindNode(idnode2);
1476 const SMDS_MeshNode * node3 = FindNode(idnode3);
1477 const SMDS_MeshNode * node4 = FindNode(idnode4);
1478 const SMDS_MeshNode * node5 = FindNode(idnode5);
1479 const SMDS_MeshNode * node6 = FindNode(idnode6);
1480 const SMDS_MeshNode * node7 = FindNode(idnode7);
1481 const SMDS_MeshNode * node8 = FindNode(idnode8);
1482 return FindFace(node1, node2, node3, node4, node5, node6, node7, node8);
1485 const SMDS_MeshFace* SMDS_Mesh::FindFace(const SMDS_MeshNode *node1,
1486 const SMDS_MeshNode *node2,
1487 const SMDS_MeshNode *node3,
1488 const SMDS_MeshNode *node4,
1489 const SMDS_MeshNode *node5,
1490 const SMDS_MeshNode *node6,
1491 const SMDS_MeshNode *node7,
1492 const SMDS_MeshNode *node8)
1494 if ( !node1 ) return 0;
1495 SMDS_ElemIteratorPtr it1 = node1->GetInverseElementIterator(SMDSAbs_Face);
1496 while(it1->more()) {
1497 const SMDS_MeshElement* f = it1->next();
1498 if ( f->NbNodes() == 8 &&
1499 f->GetNodeIndex( node2 ) >= 0 &&
1500 f->GetNodeIndex( node3 ) >= 0 &&
1501 f->GetNodeIndex( node4 ) >= 0 &&
1502 f->GetNodeIndex( node5 ) >= 0 &&
1503 f->GetNodeIndex( node6 ) >= 0 &&
1504 f->GetNodeIndex( node7 ) >= 0 &&
1505 f->GetNodeIndex( node8 ) >= 0 )
1506 return static_cast<const SMDS_MeshFace *>( f );
1512 //=======================================================================
1513 //function : FindElement
1515 //=======================================================================
1517 const SMDS_MeshElement* SMDS_Mesh::FindElement(int IDelem) const
1519 return myElementIDFactory->MeshElement(IDelem);
1522 //=======================================================================
1523 //function : FindFace
1524 //purpose : find polygon
1525 //=======================================================================
1527 const SMDS_MeshFace* SMDS_Mesh::FindFace (std::vector<int> nodes_ids) const
1529 int nbnodes = nodes_ids.size();
1530 std::vector<const SMDS_MeshNode *> poly_nodes (nbnodes);
1531 for (int inode = 0; inode < nbnodes; inode++) {
1532 const SMDS_MeshNode * node = FindNode(nodes_ids[inode]);
1533 if (node == NULL) return NULL;
1535 return FindFace(poly_nodes);
1538 const SMDS_MeshFace* SMDS_Mesh::FindFace (std::vector<const SMDS_MeshNode *> nodes)
1540 if ( nodes.size() > 2 && nodes[0] ) {
1541 SMDS_ElemIteratorPtr itF = nodes[0]->GetInverseElementIterator(SMDSAbs_Face);
1542 while (itF->more()) {
1543 const SMDS_MeshElement* f = itF->next();
1544 if ( f->NbNodes() == nodes.size() ) {
1545 int ok = true, i = 1;
1546 while ( ok && i < nodes.size() ) {
1547 ok = ( f->GetNodeIndex( nodes[ i++ ] ) >= 0 );
1550 return static_cast<const SMDS_MeshFace *>( f );
1557 //=======================================================================
1558 //function : DumpNodes
1560 //=======================================================================
1562 void SMDS_Mesh::DumpNodes() const
1564 MESSAGE("dump nodes of mesh : ");
1565 SMDS_NodeIteratorPtr itnode=nodesIterator();
1566 while(itnode->more()) MESSAGE(itnode->next());
1569 //=======================================================================
1570 //function : DumpEdges
1572 //=======================================================================
1574 void SMDS_Mesh::DumpEdges() const
1576 MESSAGE("dump edges of mesh : ");
1577 SMDS_EdgeIteratorPtr itedge=edgesIterator();
1578 while(itedge->more()) MESSAGE(itedge->next());
1581 //=======================================================================
1582 //function : DumpFaces
1584 //=======================================================================
1586 void SMDS_Mesh::DumpFaces() const
1588 MESSAGE("dump faces of mesh : ");
1589 SMDS_FaceIteratorPtr itface=facesIterator();
1590 while(itface->more()) MESSAGE(itface->next());
1593 //=======================================================================
1594 //function : DumpVolumes
1596 //=======================================================================
1598 void SMDS_Mesh::DumpVolumes() const
1600 MESSAGE("dump volumes of mesh : ");
1601 SMDS_VolumeIteratorPtr itvol=volumesIterator();
1602 while(itvol->more()) MESSAGE(itvol->next());
1605 //=======================================================================
1606 //function : DebugStats
1608 //=======================================================================
1610 void SMDS_Mesh::DebugStats() const
1612 MESSAGE("Debug stats of mesh : ");
1614 MESSAGE("===== NODES ====="<<NbNodes());
1615 MESSAGE("===== EDGES ====="<<NbEdges());
1616 MESSAGE("===== FACES ====="<<NbFaces());
1617 MESSAGE("===== VOLUMES ====="<<NbVolumes());
1619 MESSAGE("End Debug stats of mesh ");
1623 SMDS_NodeIteratorPtr itnode=nodesIterator();
1624 int sizeofnodes = 0;
1625 int sizeoffaces = 0;
1627 while(itnode->more())
1629 const SMDS_MeshNode *node = itnode->next();
1631 sizeofnodes += sizeof(*node);
1633 SMDS_ElemIteratorPtr it = node->GetInverseElementIterator();
1636 const SMDS_MeshElement *me = it->next();
1637 sizeofnodes += sizeof(me);
1642 SMDS_FaceIteratorPtr itface=facesIterator();
1643 while(itface->more())
1645 const SMDS_MeshElement *face = itface->next();
1646 sizeoffaces += sizeof(*face);
1649 MESSAGE("total size of node elements = " << sizeofnodes);;
1650 MESSAGE("total size of face elements = " << sizeoffaces);;
1655 ///////////////////////////////////////////////////////////////////////////////
1656 /// Return the number of nodes
1657 ///////////////////////////////////////////////////////////////////////////////
1658 int SMDS_Mesh::NbNodes() const
1660 return myNodes.Size();
1663 ///////////////////////////////////////////////////////////////////////////////
1664 /// Return the number of edges (including construction edges)
1665 ///////////////////////////////////////////////////////////////////////////////
1666 int SMDS_Mesh::NbEdges() const
1668 return myEdges.Size();
1671 ///////////////////////////////////////////////////////////////////////////////
1672 /// Return the number of faces (including construction faces)
1673 ///////////////////////////////////////////////////////////////////////////////
1674 int SMDS_Mesh::NbFaces() const
1676 return myFaces.Size();
1679 ///////////////////////////////////////////////////////////////////////////////
1680 /// Return the number of volumes
1681 ///////////////////////////////////////////////////////////////////////////////
1682 int SMDS_Mesh::NbVolumes() const
1684 return myVolumes.Size();
1687 ///////////////////////////////////////////////////////////////////////////////
1688 /// Return the number of child mesh of this mesh.
1689 /// Note that the tree structure of SMDS_Mesh seems to be unused in this version
1690 /// (2003-09-08) of SMESH
1691 ///////////////////////////////////////////////////////////////////////////////
1692 int SMDS_Mesh::NbSubMesh() const
1694 return myChildren.size();
1697 ///////////////////////////////////////////////////////////////////////////////
1698 /// Destroy the mesh and all its elements
1699 /// All pointer on elements owned by this mesh become illegals.
1700 ///////////////////////////////////////////////////////////////////////////////
1701 SMDS_Mesh::~SMDS_Mesh()
1703 list<SMDS_Mesh*>::iterator itc=myChildren.begin();
1704 while(itc!=myChildren.end())
1710 SetOfNodes::Iterator itn(myNodes);
1711 for (; itn.More(); itn.Next())
1714 SetOfEdges::Iterator ite(myEdges);
1715 for (; ite.More(); ite.Next())
1717 SMDS_MeshElement* elem = ite.Value();
1719 myElementIDFactory->ReleaseID(elem->GetID());
1723 SetOfFaces::Iterator itf(myFaces);
1724 for (; itf.More(); itf.Next())
1726 SMDS_MeshElement* elem = itf.Value();
1728 myElementIDFactory->ReleaseID(elem->GetID());
1732 SetOfVolumes::Iterator itv(myVolumes);
1733 for (; itv.More(); itv.Next())
1735 SMDS_MeshElement* elem = itv.Value();
1737 myElementIDFactory->ReleaseID(elem->GetID());
1743 delete myNodeIDFactory;
1744 delete myElementIDFactory;
1748 ///////////////////////////////////////////////////////////////////////////////
1749 /// Return true if this mesh create faces with edges.
1750 /// A false returned value mean that faces are created with nodes. A concequence
1751 /// is, iteration on edges (SMDS_Element::edgesIterator) will be unavailable.
1752 ///////////////////////////////////////////////////////////////////////////////
1753 bool SMDS_Mesh::hasConstructionEdges()
1755 return myHasConstructionEdges;
1758 ///////////////////////////////////////////////////////////////////////////////
1759 /// Return true if this mesh create volumes with faces
1760 /// A false returned value mean that volumes are created with nodes or edges.
1761 /// (see hasConstructionEdges)
1762 /// A concequence is, iteration on faces (SMDS_Element::facesIterator) will be
1764 ///////////////////////////////////////////////////////////////////////////////
1765 bool SMDS_Mesh::hasConstructionFaces()
1767 return myHasConstructionFaces;
1770 ///////////////////////////////////////////////////////////////////////////////
1771 /// Return true if nodes are linked to the finit elements, they are belonging to.
1772 /// Currently, It always return true.
1773 ///////////////////////////////////////////////////////////////////////////////
1774 bool SMDS_Mesh::hasInverseElements()
1776 return myHasInverseElements;
1779 ///////////////////////////////////////////////////////////////////////////////
1780 /// Make this mesh creating construction edges (see hasConstructionEdges)
1781 /// @param b true to have construction edges, else false.
1782 ///////////////////////////////////////////////////////////////////////////////
1783 void SMDS_Mesh::setConstructionEdges(bool b)
1785 myHasConstructionEdges=b;
1788 ///////////////////////////////////////////////////////////////////////////////
1789 /// Make this mesh creating construction faces (see hasConstructionFaces)
1790 /// @param b true to have construction faces, else false.
1791 ///////////////////////////////////////////////////////////////////////////////
1792 void SMDS_Mesh::setConstructionFaces(bool b)
1794 myHasConstructionFaces=b;
1797 ///////////////////////////////////////////////////////////////////////////////
1798 /// Make this mesh creating link from nodes to elements (see hasInverseElements)
1799 /// @param b true to link nodes to elements, else false.
1800 ///////////////////////////////////////////////////////////////////////////////
1801 void SMDS_Mesh::setInverseElements(bool b)
1803 if(!b) MESSAGE("Error : inverseElement=false not implemented");
1804 myHasInverseElements=b;
1807 ///////////////////////////////////////////////////////////////////////////////
1808 /// Return an iterator on nodes of the current mesh factory
1809 ///////////////////////////////////////////////////////////////////////////////
1810 class SMDS_Mesh_MyNodeIterator:public SMDS_NodeIterator
1812 SMDS_ElemIteratorPtr myIterator;
1814 SMDS_Mesh_MyNodeIterator(const SMDS_ElemIteratorPtr& it):myIterator(it)
1819 return myIterator->more();
1822 const SMDS_MeshNode* next()
1824 return static_cast<const SMDS_MeshNode*>(myIterator->next());
1828 SMDS_NodeIteratorPtr SMDS_Mesh::nodesIterator() const
1830 return SMDS_NodeIteratorPtr
1831 (new SMDS_Mesh_MyNodeIterator(myNodeIDFactory->elementsIterator()));
1834 ///////////////////////////////////////////////////////////////////////////////
1835 /// Return an iterator on elements of the current mesh factory
1836 ///////////////////////////////////////////////////////////////////////////////
1837 SMDS_ElemIteratorPtr SMDS_Mesh::elementsIterator() const
1839 return myElementIDFactory->elementsIterator();
1842 ///////////////////////////////////////////////////////////////////////////////
1843 ///Return an iterator on edges of the current mesh.
1844 ///////////////////////////////////////////////////////////////////////////////
1845 class SMDS_Mesh_MyEdgeIterator:public SMDS_EdgeIterator
1847 typedef SMDS_Mesh::SetOfEdges SetOfEdges;
1848 SetOfEdges::Iterator myIterator;
1850 SMDS_Mesh_MyEdgeIterator(const SetOfEdges& s):myIterator(s)
1855 while(myIterator.More())
1857 if(myIterator.Value()->GetID()!=-1)
1864 const SMDS_MeshEdge* next()
1866 const SMDS_MeshEdge* current = myIterator.Value();
1872 SMDS_EdgeIteratorPtr SMDS_Mesh::edgesIterator() const
1874 return SMDS_EdgeIteratorPtr(new SMDS_Mesh_MyEdgeIterator(myEdges));
1877 ///////////////////////////////////////////////////////////////////////////////
1878 ///Return an iterator on faces of the current mesh.
1879 ///////////////////////////////////////////////////////////////////////////////
1880 class SMDS_Mesh_MyFaceIterator:public SMDS_FaceIterator
1882 typedef SMDS_Mesh::SetOfFaces SetOfFaces;
1883 SetOfFaces::Iterator myIterator;
1885 SMDS_Mesh_MyFaceIterator(const SetOfFaces& s):myIterator(s)
1890 while(myIterator.More())
1892 if(myIterator.Value()->GetID()!=-1)
1899 const SMDS_MeshFace* next()
1901 const SMDS_MeshFace* current = myIterator.Value();
1907 SMDS_FaceIteratorPtr SMDS_Mesh::facesIterator() const
1909 return SMDS_FaceIteratorPtr(new SMDS_Mesh_MyFaceIterator(myFaces));
1912 ///////////////////////////////////////////////////////////////////////////////
1913 ///Return an iterator on volumes of the current mesh.
1914 ///////////////////////////////////////////////////////////////////////////////
1915 class SMDS_Mesh_MyVolumeIterator:public SMDS_VolumeIterator
1917 typedef SMDS_Mesh::SetOfVolumes SetOfVolumes;
1918 SetOfVolumes::Iterator myIterator;
1920 SMDS_Mesh_MyVolumeIterator(const SetOfVolumes& s):myIterator(s)
1925 return myIterator.More() != Standard_False;
1928 const SMDS_MeshVolume* next()
1930 const SMDS_MeshVolume* current = myIterator.Value();
1936 SMDS_VolumeIteratorPtr SMDS_Mesh::volumesIterator() const
1938 return SMDS_VolumeIteratorPtr(new SMDS_Mesh_MyVolumeIterator(myVolumes));
1941 ///////////////////////////////////////////////////////////////////////////////
1942 /// Do intersection of sets (more than 2)
1943 ///////////////////////////////////////////////////////////////////////////////
1944 static set<const SMDS_MeshElement*> * intersectionOfSets(
1945 set<const SMDS_MeshElement*> vs[], int numberOfSets)
1947 set<const SMDS_MeshElement*>* rsetA=new set<const SMDS_MeshElement*>(vs[0]);
1948 set<const SMDS_MeshElement*>* rsetB;
1950 for(int i=0; i<numberOfSets-1; i++)
1952 rsetB=new set<const SMDS_MeshElement*>();
1954 rsetA->begin(), rsetA->end(),
1955 vs[i+1].begin(), vs[i+1].end(),
1956 inserter(*rsetB, rsetB->begin()));
1963 ///////////////////////////////////////////////////////////////////////////////
1964 /// Return the list of finit elements owning the given element
1965 ///////////////////////////////////////////////////////////////////////////////
1966 static set<const SMDS_MeshElement*> * getFinitElements(const SMDS_MeshElement * element)
1968 int numberOfSets=element->NbNodes();
1969 set<const SMDS_MeshElement*> *initSet = new set<const SMDS_MeshElement*>[numberOfSets];
1971 SMDS_ElemIteratorPtr itNodes=element->nodesIterator();
1974 while(itNodes->more())
1976 const SMDS_MeshNode * n=static_cast<const SMDS_MeshNode*>(itNodes->next());
1977 SMDS_ElemIteratorPtr itFe = n->GetInverseElementIterator();
1979 //initSet[i]=set<const SMDS_MeshElement*>();
1981 initSet[i].insert(itFe->next());
1985 set<const SMDS_MeshElement*> *retSet=intersectionOfSets(initSet, numberOfSets);
1990 ///////////////////////////////////////////////////////////////////////////////
1991 /// Return the list of nodes used only by the given elements
1992 ///////////////////////////////////////////////////////////////////////////////
1993 static set<const SMDS_MeshElement*> * getExclusiveNodes(
1994 set<const SMDS_MeshElement*>& elements)
1996 set<const SMDS_MeshElement*> * toReturn=new set<const SMDS_MeshElement*>();
1997 set<const SMDS_MeshElement*>::iterator itElements=elements.begin();
1999 while(itElements!=elements.end())
2001 SMDS_ElemIteratorPtr itNodes = (*itElements)->nodesIterator();
2004 while(itNodes->more())
2006 const SMDS_MeshNode * n=static_cast<const SMDS_MeshNode*>(itNodes->next());
2007 SMDS_ElemIteratorPtr itFe = n->GetInverseElementIterator();
2008 set<const SMDS_MeshElement*> s;
2010 s.insert(itFe->next());
2011 if(s==elements) toReturn->insert(n);
2017 ///////////////////////////////////////////////////////////////////////////////
2018 ///Find the children of an element that are made of given nodes
2019 ///@param setOfChildren The set in which matching children will be inserted
2020 ///@param element The element were to search matching children
2021 ///@param nodes The nodes that the children must have to be selected
2022 ///////////////////////////////////////////////////////////////////////////////
2023 void SMDS_Mesh::addChildrenWithNodes(set<const SMDS_MeshElement*>& setOfChildren,
2024 const SMDS_MeshElement * element, set<const SMDS_MeshElement*>& nodes)
2027 switch(element->GetType())
2030 MESSAGE("Internal Error: This should not append");
2034 SMDS_ElemIteratorPtr itn=element->nodesIterator();
2037 const SMDS_MeshElement * e=itn->next();
2038 if(nodes.find(e)!=nodes.end())
2040 setOfChildren.insert(element);
2047 SMDS_ElemIteratorPtr itn=element->nodesIterator();
2050 const SMDS_MeshElement * e=itn->next();
2051 if(nodes.find(e)!=nodes.end())
2053 setOfChildren.insert(element);
2057 if(hasConstructionEdges())
2059 SMDS_ElemIteratorPtr ite=element->edgesIterator();
2061 addChildrenWithNodes(setOfChildren, ite->next(), nodes);
2064 case SMDSAbs_Volume:
2066 if(hasConstructionFaces())
2068 SMDS_ElemIteratorPtr ite=element->facesIterator();
2070 addChildrenWithNodes(setOfChildren, ite->next(), nodes);
2072 else if(hasConstructionEdges())
2074 SMDS_ElemIteratorPtr ite=element->edgesIterator();
2076 addChildrenWithNodes(setOfChildren, ite->next(), nodes);
2082 ///////////////////////////////////////////////////////////////////////////////
2083 ///@param elem The element to delete
2084 ///@param removenodes if true remaining nodes will be removed
2085 ///////////////////////////////////////////////////////////////////////////////
2086 void SMDS_Mesh::RemoveElement(const SMDS_MeshElement * elem,
2087 const bool removenodes)
2089 list<const SMDS_MeshElement *> removedElems;
2090 list<const SMDS_MeshElement *> removedNodes;
2091 RemoveElement( elem, removedElems, removedNodes, removenodes );
2094 ///////////////////////////////////////////////////////////////////////////////
2095 ///@param elem The element to delete
2096 ///@param removedElems contains all removed elements
2097 ///@param removedNodes contains all removed nodes
2098 ///@param removenodes if true remaining nodes will be removed
2099 ///////////////////////////////////////////////////////////////////////////////
2100 void SMDS_Mesh::RemoveElement(const SMDS_MeshElement * elem,
2101 list<const SMDS_MeshElement *>& removedElems,
2102 list<const SMDS_MeshElement *>& removedNodes,
2105 // get finite elements built on elem
2106 set<const SMDS_MeshElement*> * s1;
2107 if (!hasConstructionEdges() && elem->GetType() == SMDSAbs_Edge ||
2108 !hasConstructionFaces() && elem->GetType() == SMDSAbs_Face ||
2109 elem->GetType() == SMDSAbs_Volume)
2111 s1 = new set<const SMDS_MeshElement*>();
2115 s1 = getFinitElements(elem);
2117 // get exclusive nodes (which would become free afterwards)
2118 set<const SMDS_MeshElement*> * s2;
2119 if (elem->GetType() == SMDSAbs_Node) // a node is removed
2121 // do not remove nodes except elem
2122 s2 = new set<const SMDS_MeshElement*>();
2127 s2 = getExclusiveNodes(*s1);
2129 // form the set of finite and construction elements to remove
2130 set<const SMDS_MeshElement*> s3;
2131 set<const SMDS_MeshElement*>::iterator it=s1->begin();
2132 while(it!=s1->end())
2134 addChildrenWithNodes(s3, *it ,*s2);
2138 if(elem->GetType()!=SMDSAbs_Node) s3.insert(elem);
2140 // remove finite and construction elements
2144 // Remove element from <InverseElements> of its nodes
2145 SMDS_ElemIteratorPtr itn=(*it)->nodesIterator();
2148 SMDS_MeshNode * n = static_cast<SMDS_MeshNode *>
2149 (const_cast<SMDS_MeshElement *>(itn->next()));
2150 n->RemoveInverseElement( (*it) );
2153 switch((*it)->GetType())
2156 MESSAGE("Internal Error: This should not happen");
2159 myEdges.Remove(static_cast<SMDS_MeshEdge*>
2160 (const_cast<SMDS_MeshElement*>(*it)));
2163 myFaces.Remove(static_cast<SMDS_MeshFace*>
2164 (const_cast<SMDS_MeshElement*>(*it)));
2166 case SMDSAbs_Volume:
2167 myVolumes.Remove(static_cast<SMDS_MeshVolume*>
2168 (const_cast<SMDS_MeshElement*>(*it)));
2171 //MESSAGE( "SMDS: RM elem " << (*it)->GetID() );
2172 removedElems.push_back( (*it) );
2173 myElementIDFactory->ReleaseID((*it)->GetID());
2178 // remove exclusive (free) nodes
2182 while(it!=s2->end())
2184 //MESSAGE( "SMDS: RM node " << (*it)->GetID() );
2185 myNodes.Remove(static_cast<SMDS_MeshNode*>
2186 (const_cast<SMDS_MeshElement*>(*it)));
2187 myNodeIDFactory->ReleaseID((*it)->GetID());
2188 removedNodes.push_back( (*it) );
2199 ///////////////////////////////////////////////////////////////////////////////
2200 ///@param elem The element to delete
2201 ///////////////////////////////////////////////////////////////////////////////
2202 void SMDS_Mesh::RemoveFreeElement(const SMDS_MeshElement * elem)
2204 SMDSAbs_ElementType aType = elem->GetType();
2205 if (aType == SMDSAbs_Node) {
2206 // only free node can be removed by this method
2207 const SMDS_MeshNode* n = static_cast<const SMDS_MeshNode*>(elem);
2208 SMDS_ElemIteratorPtr itFe = n->GetInverseElementIterator();
2209 if (!itFe->more()) { // free node
2210 myNodes.Remove(const_cast<SMDS_MeshNode*>(n));
2211 myNodeIDFactory->ReleaseID(elem->GetID());
2215 if (hasConstructionEdges() || hasConstructionFaces())
2216 // this methods is only for meshes without descendants
2219 // Remove element from <InverseElements> of its nodes
2220 SMDS_ElemIteratorPtr itn = elem->nodesIterator();
2221 while (itn->more()) {
2222 SMDS_MeshNode * n = static_cast<SMDS_MeshNode *>
2223 (const_cast<SMDS_MeshElement *>(itn->next()));
2224 n->RemoveInverseElement(elem);
2227 // in meshes without descendants elements are always free
2230 myEdges.Remove(static_cast<SMDS_MeshEdge*>
2231 (const_cast<SMDS_MeshElement*>(elem)));
2234 myFaces.Remove(static_cast<SMDS_MeshFace*>
2235 (const_cast<SMDS_MeshElement*>(elem)));
2237 case SMDSAbs_Volume:
2238 myVolumes.Remove(static_cast<SMDS_MeshVolume*>
2239 (const_cast<SMDS_MeshElement*>(elem)));
2244 myElementIDFactory->ReleaseID(elem->GetID());
2250 * Checks if the element is present in mesh.
2251 * Useful to determine dead pointers.
2253 bool SMDS_Mesh::Contains (const SMDS_MeshElement* elem) const
2255 // we should not imply on validity of *elem, so iterate on containers
2256 // of all types in the hope of finding <elem> somewhere there
2257 SMDS_NodeIteratorPtr itn = nodesIterator();
2259 if (elem == itn->next())
2261 SMDS_EdgeIteratorPtr ite = edgesIterator();
2263 if (elem == ite->next())
2265 SMDS_FaceIteratorPtr itf = facesIterator();
2267 if (elem == itf->next())
2269 SMDS_VolumeIteratorPtr itv = volumesIterator();
2271 if (elem == itv->next())
2276 //=======================================================================
2277 //function : MaxNodeID
2279 //=======================================================================
2281 int SMDS_Mesh::MaxNodeID() const
2283 return myNodeIDFactory->GetMaxID();
2286 //=======================================================================
2287 //function : MinNodeID
2289 //=======================================================================
2291 int SMDS_Mesh::MinNodeID() const
2293 return myNodeIDFactory->GetMinID();
2296 //=======================================================================
2297 //function : MaxElementID
2299 //=======================================================================
2301 int SMDS_Mesh::MaxElementID() const
2303 return myElementIDFactory->GetMaxID();
2306 //=======================================================================
2307 //function : MinElementID
2309 //=======================================================================
2311 int SMDS_Mesh::MinElementID() const
2313 return myElementIDFactory->GetMinID();
2316 //=======================================================================
2317 //function : Renumber
2318 //purpose : Renumber all nodes or elements.
2319 //=======================================================================
2321 void SMDS_Mesh::Renumber (const bool isNodes, const int startID, const int deltaID)
2326 SMDS_MeshElementIDFactory * idFactory =
2327 isNodes ? myNodeIDFactory : myElementIDFactory;
2329 // get existing elements in the order of ID increasing
2330 map<int,SMDS_MeshElement*> elemMap;
2331 SMDS_ElemIteratorPtr idElemIt = idFactory->elementsIterator();
2332 while ( idElemIt->more() ) {
2333 SMDS_MeshElement* elem = const_cast<SMDS_MeshElement*>(idElemIt->next());
2334 int id = elem->GetID();
2335 elemMap.insert(map<int,SMDS_MeshElement*>::value_type(id, elem));
2337 // release their ids
2338 map<int,SMDS_MeshElement*>::iterator elemIt = elemMap.begin();
2339 for ( ; elemIt != elemMap.end(); elemIt++ )
2341 int id = (*elemIt).first;
2342 idFactory->ReleaseID( id );
2346 elemIt = elemMap.begin();
2347 for ( ; elemIt != elemMap.end(); elemIt++ )
2349 idFactory->BindID( ID, (*elemIt).second );
2354 //=======================================================================
2355 //function : GetElementType
2356 //purpose : Return type of element or node with id
2357 //=======================================================================
2359 SMDSAbs_ElementType SMDS_Mesh::GetElementType( const int id, const bool iselem ) const
2361 SMDS_MeshElement* elem = 0;
2363 elem = myElementIDFactory->MeshElement( id );
2365 elem = myNodeIDFactory->MeshElement( id );
2369 //throw SALOME_Exception(LOCALIZED ("this element isn't exist"));
2373 return elem->GetType();
2378 //********************************************************************
2379 //********************************************************************
2380 //******** *********
2381 //***** Methods for addition of quadratic elements ******
2382 //******** *********
2383 //********************************************************************
2384 //********************************************************************
2386 //=======================================================================
2387 //function : AddEdgeWithID
2389 //=======================================================================
2390 SMDS_MeshEdge* SMDS_Mesh::AddEdgeWithID(int n1, int n2, int n12, int ID)
2392 return SMDS_Mesh::AddEdgeWithID
2393 ((SMDS_MeshNode*) myNodeIDFactory->MeshElement(n1),
2394 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n2),
2395 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n12),
2399 //=======================================================================
2400 //function : AddEdge
2402 //=======================================================================
2403 SMDS_MeshEdge* SMDS_Mesh::AddEdge(const SMDS_MeshNode* n1,
2404 const SMDS_MeshNode* n2,
2405 const SMDS_MeshNode* n12)
2407 return SMDS_Mesh::AddEdgeWithID(n1, n2, n12, myElementIDFactory->GetFreeID());
2410 //=======================================================================
2411 //function : AddEdgeWithID
2413 //=======================================================================
2414 SMDS_MeshEdge* SMDS_Mesh::AddEdgeWithID(const SMDS_MeshNode * n1,
2415 const SMDS_MeshNode * n2,
2416 const SMDS_MeshNode * n12,
2419 if ( !n1 || !n2 || !n12 ) return 0;
2420 SMDS_QuadraticEdge* edge = new SMDS_QuadraticEdge(n1,n2,n12);
2421 if(myElementIDFactory->BindID(ID, edge)) {
2422 SMDS_MeshNode *node1,*node2, *node12;
2423 node1 = const_cast<SMDS_MeshNode*>(n1);
2424 node2 = const_cast<SMDS_MeshNode*>(n2);
2425 node12 = const_cast<SMDS_MeshNode*>(n12);
2426 node1->AddInverseElement(edge);
2427 node2->AddInverseElement(edge);
2428 node12->AddInverseElement(edge);
2439 //=======================================================================
2440 //function : AddFace
2442 //=======================================================================
2443 SMDS_MeshFace* SMDS_Mesh::AddFace(const SMDS_MeshNode * n1,
2444 const SMDS_MeshNode * n2,
2445 const SMDS_MeshNode * n3,
2446 const SMDS_MeshNode * n12,
2447 const SMDS_MeshNode * n23,
2448 const SMDS_MeshNode * n31)
2450 return SMDS_Mesh::AddFaceWithID(n1,n2,n3,n12,n23,n31,
2451 myElementIDFactory->GetFreeID());
2454 //=======================================================================
2455 //function : AddFaceWithID
2457 //=======================================================================
2458 SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(int n1, int n2, int n3,
2459 int n12,int n23,int n31, int ID)
2461 return SMDS_Mesh::AddFaceWithID
2462 ((SMDS_MeshNode *)myNodeIDFactory->MeshElement(n1) ,
2463 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n2) ,
2464 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n3) ,
2465 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n12),
2466 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n23),
2467 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n31),
2471 //=======================================================================
2472 //function : AddFaceWithID
2474 //=======================================================================
2475 SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
2476 const SMDS_MeshNode * n2,
2477 const SMDS_MeshNode * n3,
2478 const SMDS_MeshNode * n12,
2479 const SMDS_MeshNode * n23,
2480 const SMDS_MeshNode * n31,
2483 if ( !n1 || !n2 || !n3 || !n12 || !n23 || !n31) return 0;
2484 if(hasConstructionEdges()) {
2485 // creation quadratic edges - not implemented
2488 SMDS_QuadraticFaceOfNodes* face =
2489 new SMDS_QuadraticFaceOfNodes(n1,n2,n3,n12,n23,n31);
2492 if (!registerElement(ID, face)) {
2493 RemoveElement(face, false);
2500 //=======================================================================
2501 //function : AddFace
2503 //=======================================================================
2504 SMDS_MeshFace* SMDS_Mesh::AddFace(const SMDS_MeshNode * n1,
2505 const SMDS_MeshNode * n2,
2506 const SMDS_MeshNode * n3,
2507 const SMDS_MeshNode * n4,
2508 const SMDS_MeshNode * n12,
2509 const SMDS_MeshNode * n23,
2510 const SMDS_MeshNode * n34,
2511 const SMDS_MeshNode * n41)
2513 return SMDS_Mesh::AddFaceWithID(n1,n2,n3,n4,n12,n23,n34,n41,
2514 myElementIDFactory->GetFreeID());
2517 //=======================================================================
2518 //function : AddFaceWithID
2520 //=======================================================================
2521 SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(int n1, int n2, int n3, int n4,
2522 int n12,int n23,int n34,int n41, int ID)
2524 return SMDS_Mesh::AddFaceWithID
2525 ((SMDS_MeshNode *)myNodeIDFactory->MeshElement(n1) ,
2526 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n2) ,
2527 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n3) ,
2528 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n4) ,
2529 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n12),
2530 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n23),
2531 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n34),
2532 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n41),
2536 //=======================================================================
2537 //function : AddFaceWithID
2539 //=======================================================================
2540 SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
2541 const SMDS_MeshNode * n2,
2542 const SMDS_MeshNode * n3,
2543 const SMDS_MeshNode * n4,
2544 const SMDS_MeshNode * n12,
2545 const SMDS_MeshNode * n23,
2546 const SMDS_MeshNode * n34,
2547 const SMDS_MeshNode * n41,
2550 if ( !n1 || !n2 || !n3 || !n4 || !n12 || !n23 || !n34 || !n41) return 0;
2551 if(hasConstructionEdges()) {
2552 // creation quadratic edges - not implemented
2554 SMDS_QuadraticFaceOfNodes* face =
2555 new SMDS_QuadraticFaceOfNodes(n1,n2,n3,n4,n12,n23,n34,n41);
2558 if (!registerElement(ID, face)) {
2559 RemoveElement(face, false);
2566 //=======================================================================
2567 //function : AddVolume
2569 //=======================================================================
2570 SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
2571 const SMDS_MeshNode * n2,
2572 const SMDS_MeshNode * n3,
2573 const SMDS_MeshNode * n4,
2574 const SMDS_MeshNode * n12,
2575 const SMDS_MeshNode * n23,
2576 const SMDS_MeshNode * n31,
2577 const SMDS_MeshNode * n14,
2578 const SMDS_MeshNode * n24,
2579 const SMDS_MeshNode * n34)
2581 int ID = myElementIDFactory->GetFreeID();
2582 SMDS_MeshVolume * v = SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n12, n23,
2583 n31, n14, n24, n34, ID);
2584 if(v==NULL) myElementIDFactory->ReleaseID(ID);
2588 //=======================================================================
2589 //function : AddVolumeWithID
2591 //=======================================================================
2592 SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4,
2593 int n12,int n23,int n31,
2594 int n14,int n24,int n34, int ID)
2596 return SMDS_Mesh::AddVolumeWithID
2597 ((SMDS_MeshNode*) myNodeIDFactory->MeshElement(n1) ,
2598 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n2) ,
2599 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n3) ,
2600 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n4) ,
2601 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n12),
2602 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n23),
2603 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n31),
2604 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n14),
2605 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n24),
2606 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n34),
2610 //=======================================================================
2611 //function : AddVolumeWithID
2612 //purpose : 2d order tetrahedron of 10 nodes
2613 //=======================================================================
2614 SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
2615 const SMDS_MeshNode * n2,
2616 const SMDS_MeshNode * n3,
2617 const SMDS_MeshNode * n4,
2618 const SMDS_MeshNode * n12,
2619 const SMDS_MeshNode * n23,
2620 const SMDS_MeshNode * n31,
2621 const SMDS_MeshNode * n14,
2622 const SMDS_MeshNode * n24,
2623 const SMDS_MeshNode * n34,
2626 if ( !n1 || !n2 || !n3 || !n4 || !n12 || !n23 || !n31 || !n14 || !n24 || !n34)
2628 if(hasConstructionFaces()) {
2629 // creation quadratic faces - not implemented
2632 SMDS_QuadraticVolumeOfNodes * volume =
2633 new SMDS_QuadraticVolumeOfNodes(n1,n2,n3,n4,n12,n23,n31,n14,n24,n34);
2634 myVolumes.Add(volume);
2636 if (!registerElement(ID, volume)) {
2637 RemoveElement(volume, false);
2644 //=======================================================================
2645 //function : AddVolume
2647 //=======================================================================
2648 SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
2649 const SMDS_MeshNode * n2,
2650 const SMDS_MeshNode * n3,
2651 const SMDS_MeshNode * n4,
2652 const SMDS_MeshNode * n5,
2653 const SMDS_MeshNode * n12,
2654 const SMDS_MeshNode * n23,
2655 const SMDS_MeshNode * n34,
2656 const SMDS_MeshNode * n41,
2657 const SMDS_MeshNode * n15,
2658 const SMDS_MeshNode * n25,
2659 const SMDS_MeshNode * n35,
2660 const SMDS_MeshNode * n45)
2662 int ID = myElementIDFactory->GetFreeID();
2663 SMDS_MeshVolume * v =
2664 SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, n12, n23, n34, n41,
2665 n15, n25, n35, n45, ID);
2666 if(v==NULL) myElementIDFactory->ReleaseID(ID);
2670 //=======================================================================
2671 //function : AddVolumeWithID
2673 //=======================================================================
2674 SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4, int n5,
2675 int n12,int n23,int n34,int n41,
2676 int n15,int n25,int n35,int n45, int ID)
2678 return SMDS_Mesh::AddVolumeWithID
2679 ((SMDS_MeshNode*) myNodeIDFactory->MeshElement(n1) ,
2680 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n2) ,
2681 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n3) ,
2682 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n4) ,
2683 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n5) ,
2684 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n12),
2685 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n23),
2686 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n34),
2687 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n41),
2688 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n15),
2689 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n25),
2690 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n35),
2691 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n45),
2695 //=======================================================================
2696 //function : AddVolumeWithID
2697 //purpose : 2d order pyramid of 13 nodes
2698 //=======================================================================
2699 SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
2700 const SMDS_MeshNode * n2,
2701 const SMDS_MeshNode * n3,
2702 const SMDS_MeshNode * n4,
2703 const SMDS_MeshNode * n5,
2704 const SMDS_MeshNode * n12,
2705 const SMDS_MeshNode * n23,
2706 const SMDS_MeshNode * n34,
2707 const SMDS_MeshNode * n41,
2708 const SMDS_MeshNode * n15,
2709 const SMDS_MeshNode * n25,
2710 const SMDS_MeshNode * n35,
2711 const SMDS_MeshNode * n45,
2714 if (!n1 || !n2 || !n3 || !n4 || !n5 || !n12 || !n23 ||
2715 !n34 || !n41 || !n15 || !n25 || !n35 || !n45)
2717 if(hasConstructionFaces()) {
2718 // creation quadratic faces - not implemented
2721 SMDS_QuadraticVolumeOfNodes * volume =
2722 new SMDS_QuadraticVolumeOfNodes(n1,n2,n3,n4,n5,n12,n23,
2723 n34,n41,n15,n25,n35,n45);
2724 myVolumes.Add(volume);
2726 if (!registerElement(ID, volume)) {
2727 RemoveElement(volume, false);
2734 //=======================================================================
2735 //function : AddVolume
2737 //=======================================================================
2738 SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
2739 const SMDS_MeshNode * n2,
2740 const SMDS_MeshNode * n3,
2741 const SMDS_MeshNode * n4,
2742 const SMDS_MeshNode * n5,
2743 const SMDS_MeshNode * n6,
2744 const SMDS_MeshNode * n12,
2745 const SMDS_MeshNode * n23,
2746 const SMDS_MeshNode * n31,
2747 const SMDS_MeshNode * n45,
2748 const SMDS_MeshNode * n56,
2749 const SMDS_MeshNode * n64,
2750 const SMDS_MeshNode * n14,
2751 const SMDS_MeshNode * n25,
2752 const SMDS_MeshNode * n36)
2754 int ID = myElementIDFactory->GetFreeID();
2755 SMDS_MeshVolume * v =
2756 SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, n6, n12, n23, n31,
2757 n45, n56, n64, n14, n25, n36, ID);
2758 if(v==NULL) myElementIDFactory->ReleaseID(ID);
2762 //=======================================================================
2763 //function : AddVolumeWithID
2765 //=======================================================================
2766 SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(int n1, int n2, int n3,
2767 int n4, int n5, int n6,
2768 int n12,int n23,int n31,
2769 int n45,int n56,int n64,
2770 int n14,int n25,int n36, int ID)
2772 return SMDS_Mesh::AddVolumeWithID
2773 ((SMDS_MeshNode*) myNodeIDFactory->MeshElement(n1) ,
2774 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n2) ,
2775 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n3) ,
2776 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n4) ,
2777 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n5) ,
2778 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n6) ,
2779 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n12),
2780 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n23),
2781 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n31),
2782 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n45),
2783 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n56),
2784 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n64),
2785 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n14),
2786 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n25),
2787 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n36),
2791 //=======================================================================
2792 //function : AddVolumeWithID
2793 //purpose : 2d order Pentahedron with 15 nodes
2794 //=======================================================================
2795 SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
2796 const SMDS_MeshNode * n2,
2797 const SMDS_MeshNode * n3,
2798 const SMDS_MeshNode * n4,
2799 const SMDS_MeshNode * n5,
2800 const SMDS_MeshNode * n6,
2801 const SMDS_MeshNode * n12,
2802 const SMDS_MeshNode * n23,
2803 const SMDS_MeshNode * n31,
2804 const SMDS_MeshNode * n45,
2805 const SMDS_MeshNode * n56,
2806 const SMDS_MeshNode * n64,
2807 const SMDS_MeshNode * n14,
2808 const SMDS_MeshNode * n25,
2809 const SMDS_MeshNode * n36,
2812 if (!n1 || !n2 || !n3 || !n4 || !n5 || !n6 || !n12 || !n23 ||
2813 !n31 || !n45 || !n56 || !n64 || !n14 || !n25 || !n36)
2815 if(hasConstructionFaces()) {
2816 // creation quadratic faces - not implemented
2819 SMDS_QuadraticVolumeOfNodes * volume =
2820 new SMDS_QuadraticVolumeOfNodes(n1,n2,n3,n4,n5,n6,n12,n23,n31,
2821 n45,n56,n64,n14,n25,n36);
2822 myVolumes.Add(volume);
2824 if (!registerElement(ID, volume)) {
2825 RemoveElement(volume, false);
2832 //=======================================================================
2833 //function : AddVolume
2835 //=======================================================================
2836 SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
2837 const SMDS_MeshNode * n2,
2838 const SMDS_MeshNode * n3,
2839 const SMDS_MeshNode * n4,
2840 const SMDS_MeshNode * n5,
2841 const SMDS_MeshNode * n6,
2842 const SMDS_MeshNode * n7,
2843 const SMDS_MeshNode * n8,
2844 const SMDS_MeshNode * n12,
2845 const SMDS_MeshNode * n23,
2846 const SMDS_MeshNode * n34,
2847 const SMDS_MeshNode * n41,
2848 const SMDS_MeshNode * n56,
2849 const SMDS_MeshNode * n67,
2850 const SMDS_MeshNode * n78,
2851 const SMDS_MeshNode * n85,
2852 const SMDS_MeshNode * n15,
2853 const SMDS_MeshNode * n26,
2854 const SMDS_MeshNode * n37,
2855 const SMDS_MeshNode * n48)
2857 int ID = myElementIDFactory->GetFreeID();
2858 SMDS_MeshVolume * v =
2859 SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, n6, n7, n8, n12, n23, n34, n41,
2860 n56, n67, n78, n85, n15, n26, n37, n48, ID);
2861 if(v==NULL) myElementIDFactory->ReleaseID(ID);
2865 //=======================================================================
2866 //function : AddVolumeWithID
2868 //=======================================================================
2869 SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4,
2870 int n5, int n6, int n7, int n8,
2871 int n12,int n23,int n34,int n41,
2872 int n56,int n67,int n78,int n85,
2873 int n15,int n26,int n37,int n48, int ID)
2875 return SMDS_Mesh::AddVolumeWithID
2876 ((SMDS_MeshNode*) myNodeIDFactory->MeshElement(n1),
2877 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n2),
2878 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n3),
2879 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n4),
2880 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n5),
2881 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n6),
2882 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n7),
2883 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n8),
2884 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n12),
2885 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n23),
2886 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n34),
2887 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n41),
2888 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n56),
2889 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n67),
2890 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n78),
2891 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n85),
2892 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n15),
2893 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n26),
2894 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n37),
2895 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n48),
2899 //=======================================================================
2900 //function : AddVolumeWithID
2901 //purpose : 2d order Hexahedrons with 20 nodes
2902 //=======================================================================
2903 SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
2904 const SMDS_MeshNode * n2,
2905 const SMDS_MeshNode * n3,
2906 const SMDS_MeshNode * n4,
2907 const SMDS_MeshNode * n5,
2908 const SMDS_MeshNode * n6,
2909 const SMDS_MeshNode * n7,
2910 const SMDS_MeshNode * n8,
2911 const SMDS_MeshNode * n12,
2912 const SMDS_MeshNode * n23,
2913 const SMDS_MeshNode * n34,
2914 const SMDS_MeshNode * n41,
2915 const SMDS_MeshNode * n56,
2916 const SMDS_MeshNode * n67,
2917 const SMDS_MeshNode * n78,
2918 const SMDS_MeshNode * n85,
2919 const SMDS_MeshNode * n15,
2920 const SMDS_MeshNode * n26,
2921 const SMDS_MeshNode * n37,
2922 const SMDS_MeshNode * n48,
2925 if (!n1 || !n2 || !n3 || !n4 || !n5 || !n6 || !n7 || !n8 || !n12 || !n23 ||
2926 !n34 || !n41 || !n56 || !n67 || !n78 || !n85 || !n15 || !n26 || !n37 || !n48)
2928 if(hasConstructionFaces()) {
2930 // creation quadratic faces - not implemented
2932 SMDS_QuadraticVolumeOfNodes * volume =
2933 new SMDS_QuadraticVolumeOfNodes(n1,n2,n3,n4,n5,n6,n7,n8,n12,n23,n34,n41,
2934 n56,n67,n78,n85,n15,n26,n37,n48);
2935 myVolumes.Add(volume);
2937 if (!registerElement(ID, volume)) {
2938 RemoveElement(volume, false);