1 // Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
3 // Copyright (C) 2003-2007 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, or (at your option) any later version.
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 // SMESH SMDS : implementation of Salome mesh data structure
26 #pragma warning(disable:4786)
29 #include "SMDS_FaceOfEdges.hxx"
30 #include "SMDS_FaceOfNodes.hxx"
31 #include "SMDS_Mesh.hxx"
32 #include "SMDS_PolygonalFaceOfNodes.hxx"
33 #include "SMDS_PolyhedralVolumeOfNodes.hxx"
34 #include "SMDS_QuadraticEdge.hxx"
35 #include "SMDS_QuadraticFaceOfNodes.hxx"
36 #include "SMDS_QuadraticVolumeOfNodes.hxx"
37 #include "SMDS_SetIterator.hxx"
38 #include "SMDS_SpacePosition.hxx"
39 #include "SMDS_UnstructuredGrid.hxx"
40 #include "SMDS_VolumeOfFaces.hxx"
41 #include "SMDS_VolumeOfNodes.hxx"
43 #include "utilities.h"
45 #include <vtkUnstructuredGrid.h>
46 #include <vtkUnstructuredGridWriter.h>
47 #include <vtkUnsignedCharArray.h>
49 #include <vtkCellLinks.h>
50 #include <vtkIdList.h>
59 #if !defined WIN32 && !defined __APPLE__
60 #include <sys/sysinfo.h>
63 // number of added entities to check memory after
64 #define CHECKMEMORY_INTERVAL 100000
66 vector<SMDS_Mesh*> SMDS_Mesh::_meshList = vector<SMDS_Mesh*>();
67 int SMDS_Mesh::chunkSize = 1024;
70 //================================================================================
72 * \brief Raise an exception if free memory (ram+swap) too low
73 * \param doNotRaise - if true, suppres exception, just return free memory size
74 * \retval int - amount of available memory in MB or negative number in failure case
76 //================================================================================
78 int SMDS_Mesh::CheckMemory(const bool doNotRaise) throw (std::bad_alloc)
80 #if !defined WIN32 && !defined __APPLE__
82 int err = sysinfo( &si );
86 const unsigned long Mbyte = 1024 * 1024;
88 static int limit = -1;
90 int status = system("SMDS_MemoryLimit"); // it returns lower limit of free RAM
92 limit = WEXITSTATUS(status);
95 double factor = ( si.totalswap == 0 ) ? 0.1 : 0.2;
96 limit = int(( factor * si.totalram * si.mem_unit ) / Mbyte );
101 limit = int ( limit * 1.5 );
102 MESSAGE ( "SMDS_Mesh::CheckMemory() memory limit = " << limit << " MB" );
105 // compute separately to avoid overflow
107 ( si.freeram * si.mem_unit ) / Mbyte +
108 ( si.freeswap * si.mem_unit ) / Mbyte;
109 //cout << "freeMb = " << freeMb << " limit = " << limit << endl;
111 if ( freeMb > limit )
112 return freeMb - limit;
117 MESSAGE ("SMDS_Mesh::CheckMemory() throws as free memory too low: " << freeMb <<" MB" );
118 throw std::bad_alloc();
124 ///////////////////////////////////////////////////////////////////////////////
125 /// Create a new mesh object
126 ///////////////////////////////////////////////////////////////////////////////
127 SMDS_Mesh::SMDS_Mesh():
128 myNodePool(0), myVolumePool(0), myFacePool(0), myEdgePool(0), myBallPool(0),
130 myNodeIDFactory(new SMDS_MeshNodeIDFactory()),
131 myElementIDFactory(new SMDS_MeshElementIDFactory()),
132 myModified(false), myModifTime(0), myCompactTime(0),
133 myHasConstructionEdges(false), myHasConstructionFaces(false),
134 myHasInverseElements(true),
135 xmin(0), xmax(0), ymin(0), ymax(0), zmin(0), zmax(0)
137 myMeshId = _meshList.size(); // --- index of the mesh to push back in the vector
138 myNodeIDFactory->SetMesh(this);
139 myElementIDFactory->SetMesh(this);
140 _meshList.push_back(this);
141 myNodePool = new ObjectPool<SMDS_MeshNode>(SMDS_Mesh::chunkSize);
142 myEdgePool = new ObjectPool<SMDS_VtkEdge>(SMDS_Mesh::chunkSize);
143 myFacePool = new ObjectPool<SMDS_VtkFace>(SMDS_Mesh::chunkSize);
144 myVolumePool = new ObjectPool<SMDS_VtkVolume>(SMDS_Mesh::chunkSize);
145 myBallPool = new ObjectPool<SMDS_BallElement>(SMDS_Mesh::chunkSize);
149 //myCellIdSmdsToVtk.clear();
150 myCellIdVtkToSmds.clear();
151 myGrid = SMDS_UnstructuredGrid::New();
152 myGrid->setSMDS_mesh(this);
153 myGrid->Initialize();
155 vtkPoints* points = vtkPoints::New();
156 // bug "21125: EDF 1233 SMESH: Degrardation of precision in a test case for quadratic conversion"
157 // Use double type for storing coordinates of nodes instead of float.
158 points->SetDataType(VTK_DOUBLE);
159 points->SetNumberOfPoints(0 /*SMDS_Mesh::chunkSize*/);
160 myGrid->SetPoints( points );
162 //myGrid->BuildLinks();
165 // initialize static maps in SMDS_MeshCell, to be thread-safe
168 SMDS_MeshCell::toVtkType( SMDSEntity_Node );
169 SMDS_MeshCell::toVtkOrder( SMDSEntity_Node );
170 SMDS_MeshCell::reverseSmdsOrder( SMDSEntity_Node );
171 SMDS_MeshCell::interlacedSmdsOrder( SMDSEntity_Node );
172 SMDS_MeshCell::toSmdsType( VTK_VERTEX );
173 SMDS_MeshCell::fromVtkOrder( SMDSEntity_Node );
177 ///////////////////////////////////////////////////////////////////////////////
178 /// Create a new child mesh
179 /// Note that the tree structure of SMDS_Mesh seems to be unused in this version
180 /// (2003-09-08) of SMESH
181 ///////////////////////////////////////////////////////////////////////////////
182 SMDS_Mesh::SMDS_Mesh(SMDS_Mesh * parent):
183 myNodePool(parent->myNodePool),
184 myVolumePool(parent->myVolumePool),
185 myFacePool(parent->myFacePool),
186 myEdgePool(parent->myEdgePool),
187 myBallPool(parent->myBallPool),
188 myParent(parent), myNodeIDFactory(parent->myNodeIDFactory),
189 myElementIDFactory(parent->myElementIDFactory),
190 myHasConstructionEdges(false), myHasConstructionFaces(false),
191 myHasInverseElements(true)
195 ///////////////////////////////////////////////////////////////////////////////
196 ///Create a submesh and add it to the current mesh
197 ///////////////////////////////////////////////////////////////////////////////
199 SMDS_Mesh *SMDS_Mesh::AddSubMesh()
201 SMDS_Mesh *submesh = new SMDS_Mesh(this);
202 myChildren.insert(myChildren.end(), submesh);
206 ///////////////////////////////////////////////////////////////////////////////
207 ///create a MeshNode and add it to the current Mesh
208 ///An ID is automatically assigned to the node.
209 ///@return : The created node
210 ///////////////////////////////////////////////////////////////////////////////
212 SMDS_MeshNode * SMDS_Mesh::AddNode(double x, double y, double z)
214 return SMDS_Mesh::AddNodeWithID(x,y,z,myNodeIDFactory->GetFreeID());
217 ///////////////////////////////////////////////////////////////////////////////
218 ///create a MeshNode and add it to the current Mesh
219 ///@param ID : The ID of the MeshNode to create
220 ///@return : The created node or NULL if a node with this ID already exists
221 ///////////////////////////////////////////////////////////////////////////////
222 SMDS_MeshNode * SMDS_Mesh::AddNodeWithID(double x, double y, double z, int ID)
224 // find the MeshNode corresponding to ID
225 const SMDS_MeshElement *node = myNodeIDFactory->MeshElement(ID);
229 MESSAGE("=============> Bad Node Id: " << ID);
230 ID = myNodeIDFactory->GetFreeID();
232 myNodeIDFactory->adjustMaxId(ID);
233 SMDS_MeshNode * node = myNodePool->getNew();
234 node->init(ID, myMeshId, 0, x, y, z);
236 if (ID >= (int)myNodes.size())
238 myNodes.resize(ID+SMDS_Mesh::chunkSize, 0);
239 // MESSAGE(" ------------------ myNodes resize " << ID << " --> " << ID+SMDS_Mesh::chunkSize);
242 myNodeIDFactory->BindID(ID,node);
245 this->adjustBoundingBox(x, y, z);
251 ///////////////////////////////////////////////////////////////////////////////
252 /// create a Mesh0DElement and add it to the current Mesh
253 /// @return : The created Mesh0DElement
254 ///////////////////////////////////////////////////////////////////////////////
255 SMDS_Mesh0DElement* SMDS_Mesh::Add0DElementWithID(int idnode, int ID)
257 SMDS_MeshNode * node = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode);
258 if (!node) return NULL;
259 return SMDS_Mesh::Add0DElementWithID(node, ID);
262 ///////////////////////////////////////////////////////////////////////////////
263 /// create a Mesh0DElement and add it to the current Mesh
264 /// @return : The created Mesh0DElement
265 ///////////////////////////////////////////////////////////////////////////////
266 SMDS_Mesh0DElement* SMDS_Mesh::Add0DElement(const SMDS_MeshNode * node)
268 return SMDS_Mesh::Add0DElementWithID(node, myElementIDFactory->GetFreeID());
271 ///////////////////////////////////////////////////////////////////////////////
272 /// Create a new Mesh0DElement and at it to the mesh
273 /// @param idnode ID of the node
274 /// @param ID ID of the 0D element to create
275 /// @return The created 0D element or NULL if an element with this
276 /// ID already exists or if input node is not found.
277 ///////////////////////////////////////////////////////////////////////////////
278 SMDS_Mesh0DElement* SMDS_Mesh::Add0DElementWithID(const SMDS_MeshNode * n, int ID)
282 if (Nb0DElements() % CHECKMEMORY_INTERVAL == 0) CheckMemory();
283 //MESSAGE("Add0DElementWithID" << ID)
284 SMDS_Mesh0DElement * el0d = new SMDS_Mesh0DElement(n);
285 if (myElementIDFactory->BindID(ID, el0d)) {
286 //SMDS_MeshNode *node = const_cast<SMDS_MeshNode*>(n);
287 //node->AddInverseElement(el0d);// --- fait avec BindID
288 adjustmyCellsCapacity(ID);
290 myInfo.myNb0DElements++;
298 ///////////////////////////////////////////////////////////////////////////////
299 /// create a Ball and add it to the current Mesh
300 /// @return : The created Ball
301 ///////////////////////////////////////////////////////////////////////////////
302 SMDS_BallElement* SMDS_Mesh::AddBallWithID(int idnode, double diameter, int ID)
304 SMDS_MeshNode * node = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode);
305 if (!node) return NULL;
306 return SMDS_Mesh::AddBallWithID(node, diameter, ID);
309 ///////////////////////////////////////////////////////////////////////////////
310 /// create a Ball and add it to the current Mesh
311 /// @return : The created Ball
312 ///////////////////////////////////////////////////////////////////////////////
313 SMDS_BallElement* SMDS_Mesh::AddBall(const SMDS_MeshNode * node, double diameter)
315 return SMDS_Mesh::AddBallWithID(node, diameter, myElementIDFactory->GetFreeID());
318 ///////////////////////////////////////////////////////////////////////////////
319 /// Create a new Ball and at it to the mesh
320 /// @param idnode ID of the node
321 // @param diameter ball diameter
322 /// @param ID ID of the 0D element to create
323 /// @return The created 0D element or NULL if an element with this
324 /// ID already exists or if input node is not found.
325 ///////////////////////////////////////////////////////////////////////////////
326 SMDS_BallElement* SMDS_Mesh::AddBallWithID(const SMDS_MeshNode * n, double diameter, int ID)
330 if (NbBalls() % CHECKMEMORY_INTERVAL == 0) CheckMemory();
332 SMDS_BallElement *ball = myBallPool->getNew();
333 ball->init(n->getVtkId(), diameter, this);
334 if (!this->registerElement(ID,ball))
336 this->myGrid->GetCellTypesArray()->SetValue(ball->getVtkId(), VTK_EMPTY_CELL);
337 myBallPool->destroy(ball);
340 adjustmyCellsCapacity(ID);
346 ///////////////////////////////////////////////////////////////////////////////
347 /// create a MeshEdge and add it to the current Mesh
348 /// @return : The created MeshEdge
349 ///////////////////////////////////////////////////////////////////////////////
351 SMDS_MeshEdge* SMDS_Mesh::AddEdgeWithID(int idnode1, int idnode2, int ID)
353 SMDS_MeshNode * node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1);
354 SMDS_MeshNode * node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2);
355 if(!node1 || !node2) return NULL;
356 return SMDS_Mesh::AddEdgeWithID(node1, node2, ID);
359 ///////////////////////////////////////////////////////////////////////////////
360 /// create a MeshEdge and add it to the current Mesh
361 /// @return : The created MeshEdge
362 ///////////////////////////////////////////////////////////////////////////////
364 SMDS_MeshEdge* SMDS_Mesh::AddEdge(const SMDS_MeshNode * node1,
365 const SMDS_MeshNode * node2)
367 return SMDS_Mesh::AddEdgeWithID(node1, node2, myElementIDFactory->GetFreeID());
370 ///////////////////////////////////////////////////////////////////////////////
371 /// Create a new edge and at it to the mesh
372 /// @param idnode1 ID of the first node
373 /// @param idnode2 ID of the second node
374 /// @param ID ID of the edge to create
375 /// @return The created edge or NULL if an element with this ID already exists or
376 /// if input nodes are not found.
377 ///////////////////////////////////////////////////////////////////////////////
379 SMDS_MeshEdge* SMDS_Mesh::AddEdgeWithID(const SMDS_MeshNode * n1,
380 const SMDS_MeshNode * n2,
383 if ( !n1 || !n2 ) return 0;
384 SMDS_MeshEdge * edge = 0;
386 // --- retrieve nodes ID
387 vector<vtkIdType> nodeIds;
389 nodeIds.push_back(n1->getVtkId());
390 nodeIds.push_back(n2->getVtkId());
392 SMDS_VtkEdge *edgevtk = myEdgePool->getNew();
393 edgevtk->init(nodeIds, this);
394 if (!this->registerElement(ID,edgevtk))
396 this->myGrid->GetCellTypesArray()->SetValue(edgevtk->getVtkId(), VTK_EMPTY_CELL);
397 myEdgePool->destroy(edgevtk);
401 adjustmyCellsCapacity(ID);
405 // if (edge && !registerElement(ID, edge))
407 // RemoveElement(edge, false);
413 ///////////////////////////////////////////////////////////////////////////////
414 /// Add a triangle defined by its nodes. An ID is automatically affected to the
416 ///////////////////////////////////////////////////////////////////////////////
418 SMDS_MeshFace* SMDS_Mesh::AddFace(const SMDS_MeshNode * n1,
419 const SMDS_MeshNode * n2,
420 const SMDS_MeshNode * n3)
422 return SMDS_Mesh::AddFaceWithID(n1,n2,n3, myElementIDFactory->GetFreeID());
425 ///////////////////////////////////////////////////////////////////////////////
426 /// Add a triangle defined by its nodes IDs
427 ///////////////////////////////////////////////////////////////////////////////
429 SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(int idnode1, int idnode2, int idnode3, int ID)
431 SMDS_MeshNode * node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1);
432 SMDS_MeshNode * node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2);
433 SMDS_MeshNode * node3 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode3);
434 if(!node1 || !node2 || !node3) return NULL;
435 return SMDS_Mesh::AddFaceWithID(node1, node2, node3, ID);
438 ///////////////////////////////////////////////////////////////////////////////
439 /// Add a triangle defined by its nodes
440 ///////////////////////////////////////////////////////////////////////////////
442 SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
443 const SMDS_MeshNode * n2,
444 const SMDS_MeshNode * n3,
447 //MESSAGE("AddFaceWithID " << ID)
448 SMDS_MeshFace * face=createTriangle(n1, n2, n3, ID);
450 // if (face && !registerElement(ID, face)) {
451 // RemoveElement(face, false);
457 ///////////////////////////////////////////////////////////////////////////////
458 /// Add a quadrangle defined by its nodes. An ID is automatically affected to the
460 ///////////////////////////////////////////////////////////////////////////////
462 SMDS_MeshFace* SMDS_Mesh::AddFace(const SMDS_MeshNode * n1,
463 const SMDS_MeshNode * n2,
464 const SMDS_MeshNode * n3,
465 const SMDS_MeshNode * n4)
467 return SMDS_Mesh::AddFaceWithID(n1,n2,n3, n4, myElementIDFactory->GetFreeID());
470 ///////////////////////////////////////////////////////////////////////////////
471 /// Add a quadrangle defined by its nodes IDs
472 ///////////////////////////////////////////////////////////////////////////////
474 SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(int idnode1,
480 SMDS_MeshNode *node1, *node2, *node3, *node4;
481 node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1);
482 node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2);
483 node3 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode3);
484 node4 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode4);
485 if(!node1 || !node2 || !node3 || !node4) return NULL;
486 return SMDS_Mesh::AddFaceWithID(node1, node2, node3, node4, ID);
489 ///////////////////////////////////////////////////////////////////////////////
490 /// Add a quadrangle defined by its nodes
491 ///////////////////////////////////////////////////////////////////////////////
493 SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
494 const SMDS_MeshNode * n2,
495 const SMDS_MeshNode * n3,
496 const SMDS_MeshNode * n4,
499 //MESSAGE("AddFaceWithID " << ID);
500 SMDS_MeshFace * face=createQuadrangle(n1, n2, n3, n4, ID);
502 // if (face && !registerElement(ID, face)) {
503 // RemoveElement(face, false);
509 ///////////////////////////////////////////////////////////////////////////////
510 /// Add a triangle defined by its edges. An ID is automatically assigned to the
512 ///////////////////////////////////////////////////////////////////////////////
514 SMDS_MeshFace* SMDS_Mesh::AddFace(const SMDS_MeshEdge * e1,
515 const SMDS_MeshEdge * e2,
516 const SMDS_MeshEdge * e3)
518 if (!hasConstructionEdges())
520 //MESSAGE("AddFaceWithID");
521 return AddFaceWithID(e1,e2,e3, myElementIDFactory->GetFreeID());
524 ///////////////////////////////////////////////////////////////////////////////
525 /// Add a triangle defined by its edges
526 ///////////////////////////////////////////////////////////////////////////////
528 SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(const SMDS_MeshEdge * e1,
529 const SMDS_MeshEdge * e2,
530 const SMDS_MeshEdge * e3,
533 if (!hasConstructionEdges())
535 if ( !e1 || !e2 || !e3 ) return 0;
537 if ( NbFaces() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
539 SMDS_MeshFace * face = new SMDS_FaceOfEdges(e1,e2,e3);
540 adjustmyCellsCapacity(ID);
542 myInfo.myNbTriangles++;
544 if (!registerElement(ID, face)) {
545 registerElement(myElementIDFactory->GetFreeID(), face);
546 //RemoveElement(face, false);
552 ///////////////////////////////////////////////////////////////////////////////
553 /// Add a quadrangle defined by its edges. An ID is automatically assigned to the
555 ///////////////////////////////////////////////////////////////////////////////
557 SMDS_MeshFace* SMDS_Mesh::AddFace(const SMDS_MeshEdge * e1,
558 const SMDS_MeshEdge * e2,
559 const SMDS_MeshEdge * e3,
560 const SMDS_MeshEdge * e4)
562 if (!hasConstructionEdges())
564 return AddFaceWithID(e1,e2,e3,e4, myElementIDFactory->GetFreeID());
567 ///////////////////////////////////////////////////////////////////////////////
568 /// Add a quadrangle defined by its edges
569 ///////////////////////////////////////////////////////////////////////////////
571 SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(const SMDS_MeshEdge * e1,
572 const SMDS_MeshEdge * e2,
573 const SMDS_MeshEdge * e3,
574 const SMDS_MeshEdge * e4,
577 if (!hasConstructionEdges())
579 if ( !e1 || !e2 || !e3 || !e4 ) return 0;
580 if ( NbFaces() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
581 SMDS_MeshFace * face = new SMDS_FaceOfEdges(e1,e2,e3,e4);
582 adjustmyCellsCapacity(ID);
584 myInfo.myNbQuadrangles++;
586 if (!registerElement(ID, face))
588 registerElement(myElementIDFactory->GetFreeID(), face);
589 //RemoveElement(face, false);
595 ///////////////////////////////////////////////////////////////////////////////
596 ///Create a new tetrahedron and add it to the mesh.
597 ///@return The created tetrahedron
598 ///////////////////////////////////////////////////////////////////////////////
600 SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
601 const SMDS_MeshNode * n2,
602 const SMDS_MeshNode * n3,
603 const SMDS_MeshNode * n4)
605 int ID = myElementIDFactory->GetFreeID();
606 SMDS_MeshVolume * v = SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, ID);
607 if(v==NULL) myElementIDFactory->ReleaseID(ID);
611 ///////////////////////////////////////////////////////////////////////////////
612 ///Create a new tetrahedron and add it to the mesh.
613 ///@param ID The ID of the new volume
614 ///@return The created tetrahedron or NULL if an element with this ID already exists
615 ///or if input nodes are not found.
616 ///////////////////////////////////////////////////////////////////////////////
618 SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(int idnode1,
624 SMDS_MeshNode *node1, *node2, *node3, *node4;
625 node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1);
626 node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2);
627 node3 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode3);
628 node4 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode4);
629 if(!node1 || !node2 || !node3 || !node4) return NULL;
630 return SMDS_Mesh::AddVolumeWithID(node1, node2, node3, node4, ID);
633 ///////////////////////////////////////////////////////////////////////////////
634 ///Create a new tetrahedron and add it to the mesh.
635 ///@param ID The ID of the new volume
636 ///@return The created tetrahedron
637 ///////////////////////////////////////////////////////////////////////////////
639 SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
640 const SMDS_MeshNode * n2,
641 const SMDS_MeshNode * n3,
642 const SMDS_MeshNode * n4,
645 SMDS_MeshVolume* volume = 0;
646 if ( !n1 || !n2 || !n3 || !n4) return volume;
647 if ( NbVolumes() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
648 if(hasConstructionFaces()) {
649 SMDS_MeshFace * f1=FindFaceOrCreate(n1,n2,n3);
650 SMDS_MeshFace * f2=FindFaceOrCreate(n1,n2,n4);
651 SMDS_MeshFace * f3=FindFaceOrCreate(n1,n3,n4);
652 SMDS_MeshFace * f4=FindFaceOrCreate(n2,n3,n4);
653 volume=new SMDS_VolumeOfFaces(f1,f2,f3,f4);
654 adjustmyCellsCapacity(ID);
655 myCells[ID] = volume;
658 else if(hasConstructionEdges()) {
662 // --- retrieve nodes ID
664 myNodeIds[0] = n1->getVtkId();
665 myNodeIds[1] = n3->getVtkId(); // order SMDS-->VTK
666 myNodeIds[2] = n2->getVtkId();
667 myNodeIds[3] = n4->getVtkId();
669 SMDS_VtkVolume *volvtk = myVolumePool->getNew();
670 volvtk->init(myNodeIds, this);
671 if (!this->registerElement(ID,volvtk))
673 this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL);
674 myVolumePool->destroy(volvtk);
678 adjustmyCellsCapacity(ID);
679 myCells[ID] = volume;
683 // if (!registerElement(ID, volume)) {
684 // RemoveElement(volume, false);
690 ///////////////////////////////////////////////////////////////////////////////
691 ///Create a new pyramid and add it to the mesh.
692 ///Nodes 1,2,3 and 4 define the base of the pyramid
693 ///@return The created pyramid
694 ///////////////////////////////////////////////////////////////////////////////
696 SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
697 const SMDS_MeshNode * n2,
698 const SMDS_MeshNode * n3,
699 const SMDS_MeshNode * n4,
700 const SMDS_MeshNode * n5)
702 int ID = myElementIDFactory->GetFreeID();
703 SMDS_MeshVolume * v = SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, ID);
704 if(v==NULL) myElementIDFactory->ReleaseID(ID);
708 ///////////////////////////////////////////////////////////////////////////////
709 ///Create a new pyramid and add it to the mesh.
710 ///Nodes 1,2,3 and 4 define the base of the pyramid
711 ///@param ID The ID of the new volume
712 ///@return The created pyramid or NULL if an element with this ID already exists
713 ///or if input nodes are not found.
714 ///////////////////////////////////////////////////////////////////////////////
716 SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(int idnode1,
723 SMDS_MeshNode *node1, *node2, *node3, *node4, *node5;
724 node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1);
725 node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2);
726 node3 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode3);
727 node4 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode4);
728 node5 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode5);
729 if(!node1 || !node2 || !node3 || !node4 || !node5) return NULL;
730 return SMDS_Mesh::AddVolumeWithID(node1, node2, node3, node4, node5, ID);
733 ///////////////////////////////////////////////////////////////////////////////
734 ///Create a new pyramid and add it to the mesh.
735 ///Nodes 1,2,3 and 4 define the base of the pyramid
736 ///@param ID The ID of the new volume
737 ///@return The created pyramid
738 ///////////////////////////////////////////////////////////////////////////////
740 SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
741 const SMDS_MeshNode * n2,
742 const SMDS_MeshNode * n3,
743 const SMDS_MeshNode * n4,
744 const SMDS_MeshNode * n5,
747 SMDS_MeshVolume* volume = 0;
748 if ( !n1 || !n2 || !n3 || !n4 || !n5) return volume;
749 if ( NbVolumes() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
750 if(hasConstructionFaces()) {
751 SMDS_MeshFace * f1=FindFaceOrCreate(n1,n2,n3,n4);
752 SMDS_MeshFace * f2=FindFaceOrCreate(n1,n2,n5);
753 SMDS_MeshFace * f3=FindFaceOrCreate(n2,n3,n5);
754 SMDS_MeshFace * f4=FindFaceOrCreate(n3,n4,n5);
755 volume=new SMDS_VolumeOfFaces(f1,f2,f3,f4);
756 adjustmyCellsCapacity(ID);
757 myCells[ID] = volume;
758 myInfo.myNbPyramids++;
760 else if(hasConstructionEdges()) {
764 // --- retrieve nodes ID
766 myNodeIds[0] = n1->getVtkId();
767 myNodeIds[1] = n4->getVtkId();
768 myNodeIds[2] = n3->getVtkId();
769 myNodeIds[3] = n2->getVtkId();
770 myNodeIds[4] = n5->getVtkId();
772 SMDS_VtkVolume *volvtk = myVolumePool->getNew();
773 volvtk->init(myNodeIds, this);
774 if (!this->registerElement(ID,volvtk))
776 this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL);
777 myVolumePool->destroy(volvtk);
781 adjustmyCellsCapacity(ID);
782 myCells[ID] = volume;
783 myInfo.myNbPyramids++;
786 // if (!registerElement(ID, volume)) {
787 // RemoveElement(volume, false);
793 ///////////////////////////////////////////////////////////////////////////////
794 ///Create a new prism and add it to the mesh.
795 ///Nodes 1,2,3 is a triangle and 1,2,5,4 a quadrangle.
796 ///@return The created prism
797 ///////////////////////////////////////////////////////////////////////////////
799 SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
800 const SMDS_MeshNode * n2,
801 const SMDS_MeshNode * n3,
802 const SMDS_MeshNode * n4,
803 const SMDS_MeshNode * n5,
804 const SMDS_MeshNode * n6)
806 int ID = myElementIDFactory->GetFreeID();
807 SMDS_MeshVolume * v = SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, n6, ID);
808 if(v==NULL) myElementIDFactory->ReleaseID(ID);
812 ///////////////////////////////////////////////////////////////////////////////
813 ///Create a new prism and add it to the mesh.
814 ///Nodes 1,2,3 is a triangle and 1,2,5,4 a quadrangle.
815 ///@param ID The ID of the new volume
816 ///@return The created prism or NULL if an element with this ID already exists
817 ///or if input nodes are not found.
818 ///////////////////////////////////////////////////////////////////////////////
820 SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(int idnode1,
828 SMDS_MeshNode *node1, *node2, *node3, *node4, *node5, *node6;
829 node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1);
830 node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2);
831 node3 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode3);
832 node4 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode4);
833 node5 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode5);
834 node6 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode6);
835 if(!node1 || !node2 || !node3 || !node4 || !node5 || !node6) return NULL;
836 return SMDS_Mesh::AddVolumeWithID(node1, node2, node3, node4, node5, node6, ID);
839 ///////////////////////////////////////////////////////////////////////////////
840 ///Create a new prism and add it to the mesh.
841 ///Nodes 1,2,3 is a triangle and 1,2,5,4 a quadrangle.
842 ///@param ID The ID of the new volume
843 ///@return The created prism
844 ///////////////////////////////////////////////////////////////////////////////
846 SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
847 const SMDS_MeshNode * n2,
848 const SMDS_MeshNode * n3,
849 const SMDS_MeshNode * n4,
850 const SMDS_MeshNode * n5,
851 const SMDS_MeshNode * n6,
854 SMDS_MeshVolume* volume = 0;
855 if ( !n1 || !n2 || !n3 || !n4 || !n5 || !n6) return volume;
856 if ( NbVolumes() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
857 if(hasConstructionFaces()) {
858 SMDS_MeshFace * f1=FindFaceOrCreate(n1,n2,n3);
859 SMDS_MeshFace * f2=FindFaceOrCreate(n4,n5,n6);
860 SMDS_MeshFace * f3=FindFaceOrCreate(n1,n4,n5,n2);
861 SMDS_MeshFace * f4=FindFaceOrCreate(n2,n5,n6,n3);
862 SMDS_MeshFace * f5=FindFaceOrCreate(n3,n6,n4,n1);
863 volume=new SMDS_VolumeOfFaces(f1,f2,f3,f4,f5);
864 adjustmyCellsCapacity(ID);
865 myCells[ID] = volume;
868 else if(hasConstructionEdges()) {
872 // --- retrieve nodes ID
874 myNodeIds[0] = n1->getVtkId();
875 myNodeIds[1] = n2->getVtkId();
876 myNodeIds[2] = n3->getVtkId();
877 myNodeIds[3] = n4->getVtkId();
878 myNodeIds[4] = n5->getVtkId();
879 myNodeIds[5] = n6->getVtkId();
881 SMDS_VtkVolume *volvtk = myVolumePool->getNew();
882 volvtk->init(myNodeIds, this);
883 if (!this->registerElement(ID,volvtk))
885 this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL);
886 myVolumePool->destroy(volvtk);
890 adjustmyCellsCapacity(ID);
891 myCells[ID] = volume;
895 // if (!registerElement(ID, volume)) {
896 // RemoveElement(volume, false);
902 ///////////////////////////////////////////////////////////////////////////////
903 ///Create a new hexagonal prism and add it to the mesh.
904 ///@return The created prism
905 ///////////////////////////////////////////////////////////////////////////////
907 SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
908 const SMDS_MeshNode * n2,
909 const SMDS_MeshNode * n3,
910 const SMDS_MeshNode * n4,
911 const SMDS_MeshNode * n5,
912 const SMDS_MeshNode * n6,
913 const SMDS_MeshNode * n7,
914 const SMDS_MeshNode * n8,
915 const SMDS_MeshNode * n9,
916 const SMDS_MeshNode * n10,
917 const SMDS_MeshNode * n11,
918 const SMDS_MeshNode * n12)
920 int ID = myElementIDFactory->GetFreeID();
921 SMDS_MeshVolume * v = SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, n6,
922 n7, n8, n9, n10, n11, n12,
924 if(v==NULL) myElementIDFactory->ReleaseID(ID);
928 ///////////////////////////////////////////////////////////////////////////////
929 ///Create a new hexagonal prism and add it to the mesh.
930 ///@param ID The ID of the new volume
931 ///@return The created prism or NULL if an element with this ID already exists
932 ///or if input nodes are not found.
933 ///////////////////////////////////////////////////////////////////////////////
935 SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(int idnode1,
949 SMDS_MeshNode *node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1);
950 SMDS_MeshNode *node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2);
951 SMDS_MeshNode *node3 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode3);
952 SMDS_MeshNode *node4 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode4);
953 SMDS_MeshNode *node5 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode5);
954 SMDS_MeshNode *node6 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode6);
955 SMDS_MeshNode *node7 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode7);
956 SMDS_MeshNode *node8 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode8);
957 SMDS_MeshNode *node9 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode9);
958 SMDS_MeshNode *node10 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode10);
959 SMDS_MeshNode *node11 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode11);
960 SMDS_MeshNode *node12 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode12);
961 return SMDS_Mesh::AddVolumeWithID(node1, node2, node3, node4, node5, node6,
962 node7, node8, node9, node10, node11, node12,
966 ///////////////////////////////////////////////////////////////////////////////
967 ///Create a new hexagonal prism and add it to the mesh.
968 ///@param ID The ID of the new volume
969 ///@return The created prism
970 ///////////////////////////////////////////////////////////////////////////////
972 SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
973 const SMDS_MeshNode * n2,
974 const SMDS_MeshNode * n3,
975 const SMDS_MeshNode * n4,
976 const SMDS_MeshNode * n5,
977 const SMDS_MeshNode * n6,
978 const SMDS_MeshNode * n7,
979 const SMDS_MeshNode * n8,
980 const SMDS_MeshNode * n9,
981 const SMDS_MeshNode * n10,
982 const SMDS_MeshNode * n11,
983 const SMDS_MeshNode * n12,
986 SMDS_MeshVolume* volume = 0;
987 if(!n1 || !n2 || !n3 || !n4 || !n5 || !n6 ||
988 !n7 || !n8 || !n9 || !n10 || !n11 || !n12 )
990 if ( NbVolumes() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
991 if(hasConstructionFaces()) {
994 else if(hasConstructionEdges()) {
998 // --- retrieve nodes ID
999 myNodeIds.resize(12);
1000 myNodeIds[0] = n1->getVtkId();
1001 myNodeIds[1] = n6->getVtkId();
1002 myNodeIds[2] = n5->getVtkId();
1003 myNodeIds[3] = n4->getVtkId();
1004 myNodeIds[4] = n3->getVtkId();
1005 myNodeIds[5] = n2->getVtkId();
1007 myNodeIds[6] = n7->getVtkId();
1008 myNodeIds[7] = n12->getVtkId();
1009 myNodeIds[8] = n11->getVtkId();
1010 myNodeIds[9] = n10->getVtkId();
1011 myNodeIds[10] = n9->getVtkId();
1012 myNodeIds[11] = n8->getVtkId();
1014 SMDS_VtkVolume *volvtk = myVolumePool->getNew();
1015 volvtk->init(myNodeIds, this);
1016 if (!this->registerElement(ID,volvtk))
1018 this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL);
1019 myVolumePool->destroy(volvtk);
1023 adjustmyCellsCapacity(ID);
1024 myCells[ID] = volume;
1025 myInfo.myNbHexPrism++;
1031 ///////////////////////////////////////////////////////////////////////////////
1032 ///Create a new hexahedron and add it to the mesh.
1033 ///Nodes 1,2,3,4 and 5,6,7,8 are quadrangle and 5,1 and 7,3 are an edges.
1034 ///@return The created hexahedron
1035 ///////////////////////////////////////////////////////////////////////////////
1037 SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
1038 const SMDS_MeshNode * n2,
1039 const SMDS_MeshNode * n3,
1040 const SMDS_MeshNode * n4,
1041 const SMDS_MeshNode * n5,
1042 const SMDS_MeshNode * n6,
1043 const SMDS_MeshNode * n7,
1044 const SMDS_MeshNode * n8)
1046 int ID = myElementIDFactory->GetFreeID();
1047 SMDS_MeshVolume * v = SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, n6, n7, n8, ID);
1048 if(v==NULL) myElementIDFactory->ReleaseID(ID);
1052 ///////////////////////////////////////////////////////////////////////////////
1053 ///Create a new hexahedron and add it to the mesh.
1054 ///Nodes 1,2,3,4 and 5,6,7,8 are quadrangle and 5,1 and 7,3 are an edges.
1055 ///@param ID The ID of the new volume
1056 ///@return The created hexahedron or NULL if an element with this ID already
1057 ///exists or if input nodes are not found.
1058 ///////////////////////////////////////////////////////////////////////////////
1060 SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(int idnode1,
1070 SMDS_MeshNode *node1, *node2, *node3, *node4, *node5, *node6, *node7, *node8;
1071 node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1);
1072 node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2);
1073 node3 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode3);
1074 node4 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode4);
1075 node5 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode5);
1076 node6 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode6);
1077 node7 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode7);
1078 node8 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode8);
1079 if(!node1 || !node2 || !node3 || !node4 || !node5 || !node6 || !node7 || !node8)
1081 return SMDS_Mesh::AddVolumeWithID(node1, node2, node3, node4, node5, node6,
1085 ///////////////////////////////////////////////////////////////////////////////
1086 ///Create a new hexahedron and add it to the mesh.
1087 ///Nodes 1,2,3,4 and 5,6,7,8 are quadrangle and 5,1 and 7,3 are an edges.
1088 ///@param ID The ID of the new volume
1089 ///@return The created prism or NULL if an element with this ID already exists
1090 ///or if input nodes are not found.
1091 ///////////////////////////////////////////////////////////////////////////////
1093 SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
1094 const SMDS_MeshNode * n2,
1095 const SMDS_MeshNode * n3,
1096 const SMDS_MeshNode * n4,
1097 const SMDS_MeshNode * n5,
1098 const SMDS_MeshNode * n6,
1099 const SMDS_MeshNode * n7,
1100 const SMDS_MeshNode * n8,
1103 SMDS_MeshVolume* volume = 0;
1104 if ( !n1 || !n2 || !n3 || !n4 || !n5 || !n6 || !n7 || !n8) return volume;
1105 if ( NbVolumes() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
1106 if(hasConstructionFaces()) {
1107 SMDS_MeshFace * f1=FindFaceOrCreate(n1,n2,n3,n4);
1108 SMDS_MeshFace * f2=FindFaceOrCreate(n5,n6,n7,n8);
1109 SMDS_MeshFace * f3=FindFaceOrCreate(n1,n4,n8,n5);
1110 SMDS_MeshFace * f4=FindFaceOrCreate(n1,n2,n6,n5);
1111 SMDS_MeshFace * f5=FindFaceOrCreate(n2,n3,n7,n6);
1112 SMDS_MeshFace * f6=FindFaceOrCreate(n3,n4,n8,n7);
1113 volume=new SMDS_VolumeOfFaces(f1,f2,f3,f4,f5,f6);
1114 adjustmyCellsCapacity(ID);
1115 myCells[ID] = volume;
1118 else if(hasConstructionEdges()) {
1122 // --- retrieve nodes ID
1123 myNodeIds.resize(8);
1124 myNodeIds[0] = n1->getVtkId();
1125 myNodeIds[1] = n4->getVtkId();
1126 myNodeIds[2] = n3->getVtkId();
1127 myNodeIds[3] = n2->getVtkId();
1128 myNodeIds[4] = n5->getVtkId();
1129 myNodeIds[5] = n8->getVtkId();
1130 myNodeIds[6] = n7->getVtkId();
1131 myNodeIds[7] = n6->getVtkId();
1133 SMDS_VtkVolume *volvtk = myVolumePool->getNew();
1134 volvtk->init(myNodeIds, this);
1135 if (!this->registerElement(ID,volvtk))
1137 this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL);
1138 myVolumePool->destroy(volvtk);
1142 adjustmyCellsCapacity(ID);
1143 myCells[ID] = volume;
1147 // if (!registerElement(ID, volume)) {
1148 // RemoveElement(volume, false);
1154 ///////////////////////////////////////////////////////////////////////////////
1155 ///Create a new tetrahedron defined by its faces and add it to the mesh.
1156 ///@return The created tetrahedron
1157 ///////////////////////////////////////////////////////////////////////////////
1159 SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshFace * f1,
1160 const SMDS_MeshFace * f2,
1161 const SMDS_MeshFace * f3,
1162 const SMDS_MeshFace * f4)
1164 if (!hasConstructionFaces())
1166 return AddVolumeWithID(f1,f2,f3,f4, myElementIDFactory->GetFreeID());
1169 ///////////////////////////////////////////////////////////////////////////////
1170 ///Create a new tetrahedron defined by its faces and add it to the mesh.
1171 ///@param ID The ID of the new volume
1172 ///@return The created tetrahedron
1173 ///////////////////////////////////////////////////////////////////////////////
1175 SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshFace * f1,
1176 const SMDS_MeshFace * f2,
1177 const SMDS_MeshFace * f3,
1178 const SMDS_MeshFace * f4,
1181 if (!hasConstructionFaces())
1183 if ( !f1 || !f2 || !f3 || !f4) return 0;
1184 if ( NbVolumes() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
1185 SMDS_MeshVolume * volume = new SMDS_VolumeOfFaces(f1,f2,f3,f4);
1186 adjustmyCellsCapacity(ID);
1187 myCells[ID] = volume;
1188 myInfo.myNbTetras++;
1190 if (!registerElement(ID, volume)) {
1191 registerElement(myElementIDFactory->GetFreeID(), volume);
1192 //RemoveElement(volume, false);
1198 ///////////////////////////////////////////////////////////////////////////////
1199 ///Create a new pyramid defined by its faces and add it to the mesh.
1200 ///@return The created pyramid
1201 ///////////////////////////////////////////////////////////////////////////////
1203 SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshFace * f1,
1204 const SMDS_MeshFace * f2,
1205 const SMDS_MeshFace * f3,
1206 const SMDS_MeshFace * f4,
1207 const SMDS_MeshFace * f5)
1209 if (!hasConstructionFaces())
1211 return AddVolumeWithID(f1,f2,f3,f4,f5, myElementIDFactory->GetFreeID());
1214 ///////////////////////////////////////////////////////////////////////////////
1215 ///Create a new pyramid defined by its faces and add it to the mesh.
1216 ///@param ID The ID of the new volume
1217 ///@return The created pyramid
1218 ///////////////////////////////////////////////////////////////////////////////
1220 SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshFace * f1,
1221 const SMDS_MeshFace * f2,
1222 const SMDS_MeshFace * f3,
1223 const SMDS_MeshFace * f4,
1224 const SMDS_MeshFace * f5,
1227 if (!hasConstructionFaces())
1229 if ( !f1 || !f2 || !f3 || !f4 || !f5) return 0;
1230 if ( NbVolumes() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
1231 SMDS_MeshVolume * volume = new SMDS_VolumeOfFaces(f1,f2,f3,f4,f5);
1232 adjustmyCellsCapacity(ID);
1233 myCells[ID] = volume;
1234 myInfo.myNbPyramids++;
1236 if (!registerElement(ID, volume)) {
1237 registerElement(myElementIDFactory->GetFreeID(), volume);
1238 //RemoveElement(volume, false);
1244 ///////////////////////////////////////////////////////////////////////////////
1245 ///Create a new prism defined by its faces and add it to the mesh.
1246 ///@return The created prism
1247 ///////////////////////////////////////////////////////////////////////////////
1249 SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshFace * f1,
1250 const SMDS_MeshFace * f2,
1251 const SMDS_MeshFace * f3,
1252 const SMDS_MeshFace * f4,
1253 const SMDS_MeshFace * f5,
1254 const SMDS_MeshFace * f6)
1256 if (!hasConstructionFaces())
1258 return AddVolumeWithID(f1,f2,f3,f4,f5,f6, myElementIDFactory->GetFreeID());
1261 ///////////////////////////////////////////////////////////////////////////////
1262 ///Create a new prism defined by its faces and add it to the mesh.
1263 ///@param ID The ID of the new volume
1264 ///@return The created prism
1265 ///////////////////////////////////////////////////////////////////////////////
1267 SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshFace * f1,
1268 const SMDS_MeshFace * f2,
1269 const SMDS_MeshFace * f3,
1270 const SMDS_MeshFace * f4,
1271 const SMDS_MeshFace * f5,
1272 const SMDS_MeshFace * f6,
1275 if (!hasConstructionFaces())
1277 if ( !f1 || !f2 || !f3 || !f4 || !f5 || !f6) return 0;
1278 if ( NbVolumes() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
1279 SMDS_MeshVolume * volume = new SMDS_VolumeOfFaces(f1,f2,f3,f4,f5,f6);
1280 adjustmyCellsCapacity(ID);
1281 myCells[ID] = volume;
1282 myInfo.myNbPrisms++;
1284 if (!registerElement(ID, volume)) {
1285 registerElement(myElementIDFactory->GetFreeID(), volume);
1286 //RemoveElement(volume, false);
1292 ///////////////////////////////////////////////////////////////////////////////
1293 /// Add a polygon defined by its nodes IDs
1294 ///////////////////////////////////////////////////////////////////////////////
1296 SMDS_MeshFace* SMDS_Mesh::AddPolygonalFaceWithID (const vector<int> & nodes_ids,
1299 int nbNodes = nodes_ids.size();
1300 vector<const SMDS_MeshNode*> nodes (nbNodes);
1301 for (int i = 0; i < nbNodes; i++) {
1302 nodes[i] = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(nodes_ids[i]);
1303 if (!nodes[i]) return NULL;
1305 return SMDS_Mesh::AddPolygonalFaceWithID(nodes, ID);
1308 ///////////////////////////////////////////////////////////////////////////////
1309 /// Add a polygon defined by its nodes
1310 ///////////////////////////////////////////////////////////////////////////////
1313 SMDS_Mesh::AddPolygonalFaceWithID (const vector<const SMDS_MeshNode*> & nodes,
1316 SMDS_MeshFace * face;
1318 if ( NbFaces() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
1319 if (hasConstructionEdges())
1325 myNodeIds.resize( nodes.size() );
1326 for ( size_t i = 0; i < nodes.size(); ++i )
1327 myNodeIds[i] = nodes[i]->getVtkId();
1329 SMDS_VtkFace *facevtk = myFacePool->getNew();
1330 facevtk->initPoly(myNodeIds, this);
1331 if (!this->registerElement(ID,facevtk))
1333 this->myGrid->GetCellTypesArray()->SetValue(facevtk->getVtkId(), VTK_EMPTY_CELL);
1334 myFacePool->destroy(facevtk);
1339 adjustmyCellsCapacity(ID);
1341 myInfo.myNbPolygons++;
1347 ///////////////////////////////////////////////////////////////////////////////
1348 /// Add a polygon defined by its nodes.
1349 /// An ID is automatically affected to the created face.
1350 ///////////////////////////////////////////////////////////////////////////////
1352 SMDS_MeshFace* SMDS_Mesh::AddPolygonalFace (const vector<const SMDS_MeshNode*> & nodes)
1354 return SMDS_Mesh::AddPolygonalFaceWithID(nodes, myElementIDFactory->GetFreeID());
1357 ///////////////////////////////////////////////////////////////////////////////
1358 /// Add a quadratic polygon defined by its nodes IDs
1359 ///////////////////////////////////////////////////////////////////////////////
1361 SMDS_MeshFace* SMDS_Mesh::AddQuadPolygonalFaceWithID (const vector<int> & nodes_ids,
1364 vector<const SMDS_MeshNode*> nodes( nodes_ids.size() );
1365 for ( size_t i = 0; i < nodes.size(); i++) {
1366 nodes[i] = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(nodes_ids[i]);
1367 if (!nodes[i]) return NULL;
1369 return SMDS_Mesh::AddQuadPolygonalFaceWithID(nodes, ID);
1372 ///////////////////////////////////////////////////////////////////////////////
1373 /// Add a quadratic polygon defined by its nodes
1374 ///////////////////////////////////////////////////////////////////////////////
1377 SMDS_Mesh::AddQuadPolygonalFaceWithID (const vector<const SMDS_MeshNode*> & nodes,
1380 SMDS_MeshFace * face;
1382 if ( NbFaces() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
1383 if (hasConstructionEdges())
1389 myNodeIds.resize( nodes.size() );
1390 for ( size_t i = 0; i < nodes.size(); ++i )
1391 myNodeIds[i] = nodes[i]->getVtkId();
1393 SMDS_VtkFace *facevtk = myFacePool->getNew();
1394 facevtk->initQuadPoly(myNodeIds, this);
1395 if (!this->registerElement(ID,facevtk))
1397 this->myGrid->GetCellTypesArray()->SetValue(facevtk->getVtkId(), VTK_EMPTY_CELL);
1398 myFacePool->destroy(facevtk);
1402 adjustmyCellsCapacity(ID);
1404 myInfo.myNbQuadPolygons++;
1409 ///////////////////////////////////////////////////////////////////////////////
1410 /// Add a quadratic polygon defined by its nodes.
1411 /// An ID is automatically affected to the created face.
1412 ///////////////////////////////////////////////////////////////////////////////
1414 SMDS_MeshFace* SMDS_Mesh::AddQuadPolygonalFace (const vector<const SMDS_MeshNode*> & nodes)
1416 return SMDS_Mesh::AddQuadPolygonalFaceWithID(nodes, myElementIDFactory->GetFreeID());
1419 ///////////////////////////////////////////////////////////////////////////////
1420 /// Create a new polyhedral volume and add it to the mesh.
1421 /// @param ID The ID of the new volume
1422 /// @return The created volume or NULL if an element with this ID already exists
1423 /// or if input nodes are not found.
1424 ///////////////////////////////////////////////////////////////////////////////
1426 SMDS_MeshVolume * SMDS_Mesh::AddPolyhedralVolumeWithID
1427 (const vector<int> & nodes_ids,
1428 const vector<int> & quantities,
1431 int nbNodes = nodes_ids.size();
1432 vector<const SMDS_MeshNode*> nodes (nbNodes);
1433 for (int i = 0; i < nbNodes; i++) {
1434 nodes[i] = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(nodes_ids[i]);
1435 if (!nodes[i]) return NULL;
1437 return SMDS_Mesh::AddPolyhedralVolumeWithID(nodes, quantities, ID);
1440 ///////////////////////////////////////////////////////////////////////////////
1441 /// Create a new polyhedral volume and add it to the mesh.
1442 /// @param ID The ID of the new volume
1443 /// @return The created volume
1444 ///////////////////////////////////////////////////////////////////////////////
1447 SMDS_Mesh::AddPolyhedralVolumeWithID (const vector<const SMDS_MeshNode*>& nodes,
1448 const vector<int> & quantities,
1451 SMDS_MeshVolume* volume = 0;
1452 if ( nodes.empty() || quantities.empty() )
1454 if ( NbVolumes() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
1455 if (hasConstructionFaces())
1459 else if (hasConstructionEdges())
1465 //#ifdef VTK_HAVE_POLYHEDRON
1466 myNodeIds.resize( nodes.size() );
1467 for ( size_t i = 0; i < nodes.size(); ++i )
1468 myNodeIds[i] = nodes[i]->getVtkId();
1470 SMDS_VtkVolume *volvtk = myVolumePool->getNew();
1471 volvtk->initPoly(myNodeIds, quantities, this);
1472 if (!this->registerElement(ID, volvtk))
1474 this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL);
1475 myVolumePool->destroy(volvtk);
1480 // for ( int i = 0; i < nodes.size(); ++i )
1481 // if ( !nodes[ i ] ) return 0;
1482 // volume = new SMDS_PolyhedralVolumeOfNodes(nodes, quantities);
1484 adjustmyCellsCapacity(ID);
1485 myCells[ID] = volume;
1486 myInfo.myNbPolyhedrons++;
1489 //#ifndef VTK_HAVE_POLYHEDRON
1490 // if (!registerElement(ID, volume))
1492 // registerElement(myElementIDFactory->GetFreeID(), volume);
1493 // //RemoveElement(volume, false);
1500 ///////////////////////////////////////////////////////////////////////////////
1501 /// Create a new polyhedral volume and add it to the mesh.
1502 /// @return The created volume
1503 ///////////////////////////////////////////////////////////////////////////////
1505 SMDS_MeshVolume* SMDS_Mesh::AddPolyhedralVolume
1506 (const vector<const SMDS_MeshNode*> & nodes,
1507 const vector<int> & quantities)
1509 int ID = myElementIDFactory->GetFreeID();
1510 SMDS_MeshVolume * v = SMDS_Mesh::AddPolyhedralVolumeWithID(nodes, quantities, ID);
1511 if (v == NULL) myElementIDFactory->ReleaseID(ID);
1515 SMDS_MeshVolume* SMDS_Mesh::AddVolumeFromVtkIds(const std::vector<vtkIdType>& vtkNodeIds)
1517 int ID = myElementIDFactory->GetFreeID();
1518 SMDS_MeshVolume * v = SMDS_Mesh::AddVolumeFromVtkIdsWithID(vtkNodeIds, ID);
1519 if (v == NULL) myElementIDFactory->ReleaseID(ID);
1523 SMDS_MeshVolume* SMDS_Mesh::AddVolumeFromVtkIdsWithID(const std::vector<vtkIdType>& vtkNodeIds, const int ID)
1525 SMDS_VtkVolume *volvtk = myVolumePool->getNew();
1526 volvtk->init(vtkNodeIds, this);
1527 if (!this->registerElement(ID,volvtk))
1529 this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL);
1530 myVolumePool->destroy(volvtk);
1533 adjustmyCellsCapacity(ID);
1534 myCells[ID] = volvtk;
1535 vtkIdType aVtkType = volvtk->GetVtkType();
1539 myInfo.myNbTetras++;
1542 myInfo.myNbPyramids++;
1545 myInfo.myNbPrisms++;
1547 case VTK_HEXAHEDRON:
1550 case VTK_QUADRATIC_TETRA:
1551 myInfo.myNbQuadTetras++;
1553 case VTK_QUADRATIC_PYRAMID:
1554 myInfo.myNbQuadPyramids++;
1556 case VTK_QUADRATIC_WEDGE:
1557 myInfo.myNbQuadPrisms++;
1559 case VTK_QUADRATIC_HEXAHEDRON:
1560 myInfo.myNbQuadHexas++;
1562 //#ifdef VTK_HAVE_POLYHEDRON
1563 case VTK_POLYHEDRON:
1564 myInfo.myNbPolyhedrons++;
1568 myInfo.myNbPolyhedrons++;
1574 SMDS_MeshFace* SMDS_Mesh::AddFaceFromVtkIds(const std::vector<vtkIdType>& vtkNodeIds)
1576 int ID = myElementIDFactory->GetFreeID();
1577 SMDS_MeshFace * f = SMDS_Mesh::AddFaceFromVtkIdsWithID(vtkNodeIds, ID);
1578 if (f == NULL) myElementIDFactory->ReleaseID(ID);
1582 SMDS_MeshFace* SMDS_Mesh::AddFaceFromVtkIdsWithID(const std::vector<vtkIdType>& vtkNodeIds, const int ID)
1584 SMDS_VtkFace *facevtk = myFacePool->getNew();
1585 facevtk->init(vtkNodeIds, this);
1586 if (!this->registerElement(ID,facevtk))
1588 this->myGrid->GetCellTypesArray()->SetValue(facevtk->getVtkId(), VTK_EMPTY_CELL);
1589 myFacePool->destroy(facevtk);
1592 adjustmyCellsCapacity(ID);
1593 myCells[ID] = facevtk;
1594 vtkIdType aVtkType = facevtk->GetVtkType();
1598 myInfo.myNbTriangles++;
1601 myInfo.myNbQuadrangles++;
1603 case VTK_QUADRATIC_TRIANGLE:
1604 myInfo.myNbQuadTriangles++;
1606 case VTK_QUADRATIC_QUAD:
1607 myInfo.myNbQuadQuadrangles++;
1609 case VTK_BIQUADRATIC_QUAD:
1610 myInfo.myNbBiQuadQuadrangles++;
1612 case VTK_BIQUADRATIC_TRIANGLE:
1613 myInfo.myNbBiQuadTriangles++;
1616 myInfo.myNbPolygons++;
1619 myInfo.myNbPolygons++;
1624 ///////////////////////////////////////////////////////////////////////////////
1625 /// Registers element with the given ID, maintains inverse connections
1626 ///////////////////////////////////////////////////////////////////////////////
1627 bool SMDS_Mesh::registerElement(int ID, SMDS_MeshElement* element)
1629 if ((ID >=0) && (ID < (int)myCells.size()) && myCells[ID]) // --- already bound
1631 MESSAGE(" ------------------ already bound "<< ID << " " << myCells[ID]->getVtkId());
1636 element->myMeshId = myMeshId;
1638 SMDS_MeshCell *cell = dynamic_cast<SMDS_MeshCell*>(element);
1640 int vtkId = cell->getVtkId();
1642 vtkId = myElementIDFactory->SetInVtkGrid(element);
1644 if (vtkId >= (int)myCellIdVtkToSmds.size()) // --- resize local vector
1646 myCellIdVtkToSmds.resize(vtkId + SMDS_Mesh::chunkSize, -1);
1648 myCellIdVtkToSmds[vtkId] = ID;
1650 myElementIDFactory->updateMinMax(ID);
1654 //=======================================================================
1655 //function : MoveNode
1657 //=======================================================================
1659 void SMDS_Mesh::MoveNode(const SMDS_MeshNode *n, double x, double y, double z)
1661 SMDS_MeshNode * node=const_cast<SMDS_MeshNode*>(n);
1662 node->setXYZ(x,y,z);
1665 ///////////////////////////////////////////////////////////////////////////////
1666 /// Return the node whose SMDS ID is 'ID'.
1667 ///////////////////////////////////////////////////////////////////////////////
1668 const SMDS_MeshNode * SMDS_Mesh::FindNode(int ID) const
1670 if (ID < 1 || ID >= (int)myNodes.size())
1674 return (const SMDS_MeshNode *)myNodes[ID];
1677 ///////////////////////////////////////////////////////////////////////////////
1678 /// Return the node whose VTK ID is 'vtkId'.
1679 ///////////////////////////////////////////////////////////////////////////////
1680 const SMDS_MeshNode * SMDS_Mesh::FindNodeVtk(int vtkId) const
1682 // TODO if needed use mesh->nodeIdFromVtkToSmds
1683 if ( vtkId < 0 || vtkId+1 >= (int) myNodes.size() )
1685 MESSAGE("------------------------------------------------------------------------- ");
1686 MESSAGE("---------------------------- bad VTK ID " << vtkId << " " << myNodes.size());
1687 MESSAGE("------------------------------------------------------------------------- ");
1690 return (const SMDS_MeshNode *)myNodes[vtkId+1];
1693 ///////////////////////////////////////////////////////////////////////////////
1694 ///Create a triangle and add it to the current mesh. This method do not bind an
1695 ///ID to the create triangle.
1696 ///////////////////////////////////////////////////////////////////////////////
1697 SMDS_MeshFace * SMDS_Mesh::createTriangle(const SMDS_MeshNode * node1,
1698 const SMDS_MeshNode * node2,
1699 const SMDS_MeshNode * node3,
1702 if ( !node1 || !node2 || !node3) return 0;
1703 if ( NbFaces() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
1704 if(hasConstructionEdges())
1706 SMDS_MeshEdge *edge1, *edge2, *edge3;
1707 edge1=FindEdgeOrCreate(node1,node2);
1708 edge2=FindEdgeOrCreate(node2,node3);
1709 edge3=FindEdgeOrCreate(node3,node1);
1711 //int ID = myElementIDFactory->GetFreeID(); // -PR- voir si on range cet element
1712 SMDS_MeshFace * face = new SMDS_FaceOfEdges(edge1,edge2,edge3);
1713 adjustmyCellsCapacity(ID);
1715 myInfo.myNbTriangles++;
1720 // --- retrieve nodes ID
1721 myNodeIds.resize(3);
1722 myNodeIds[0] = node1->getVtkId();
1723 myNodeIds[1] = node2->getVtkId();
1724 myNodeIds[2] = node3->getVtkId();
1726 SMDS_MeshFace * face = 0;
1727 SMDS_VtkFace *facevtk = myFacePool->getNew();
1728 facevtk->init(myNodeIds, this); // put in vtkUnstructuredGrid
1729 if (!this->registerElement(ID,facevtk))
1731 this->myGrid->GetCellTypesArray()->SetValue(facevtk->getVtkId(), VTK_EMPTY_CELL);
1732 myFacePool->destroy(facevtk);
1736 adjustmyCellsCapacity(ID);
1738 myInfo.myNbTriangles++;
1743 ///////////////////////////////////////////////////////////////////////////////
1744 ///Create a quadrangle and add it to the current mesh. This methode do not bind
1745 ///a ID to the create triangle.
1746 ///////////////////////////////////////////////////////////////////////////////
1747 SMDS_MeshFace * SMDS_Mesh::createQuadrangle(const SMDS_MeshNode * node1,
1748 const SMDS_MeshNode * node2,
1749 const SMDS_MeshNode * node3,
1750 const SMDS_MeshNode * node4,
1753 if ( !node1 || !node2 || !node3 || !node4 ) return 0;
1754 if ( NbFaces() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
1755 if(hasConstructionEdges())
1757 SMDS_MeshEdge *edge1, *edge2, *edge3, *edge4;
1758 edge1=FindEdgeOrCreate(node1,node2);
1759 edge2=FindEdgeOrCreate(node2,node3);
1760 edge3=FindEdgeOrCreate(node3,node4);
1761 edge4=FindEdgeOrCreate(node4,node1);
1763 SMDS_MeshFace * face = new SMDS_FaceOfEdges(edge1,edge2,edge3,edge4);
1764 adjustmyCellsCapacity(ID);
1766 myInfo.myNbQuadrangles++;
1771 // --- retrieve nodes ID
1772 myNodeIds.resize(4);
1773 myNodeIds[0] = node1->getVtkId();
1774 myNodeIds[1] = node2->getVtkId();
1775 myNodeIds[2] = node3->getVtkId();
1776 myNodeIds[3] = node4->getVtkId();
1778 SMDS_MeshFace * face = 0;
1779 SMDS_VtkFace *facevtk = myFacePool->getNew();
1780 facevtk->init(myNodeIds, this);
1781 if (!this->registerElement(ID,facevtk))
1783 this->myGrid->GetCellTypesArray()->SetValue(facevtk->getVtkId(), VTK_EMPTY_CELL);
1784 myFacePool->destroy(facevtk);
1788 adjustmyCellsCapacity(ID);
1790 myInfo.myNbQuadrangles++;
1795 ///////////////////////////////////////////////////////////////////////////////
1796 /// Remove a node and all the elements which own this node
1797 ///////////////////////////////////////////////////////////////////////////////
1799 void SMDS_Mesh::RemoveNode(const SMDS_MeshNode * node)
1801 RemoveElement(node, true);
1804 ///////////////////////////////////////////////////////////////////////////////
1805 /// Remove an edge and all the elements which own this edge
1806 ///////////////////////////////////////////////////////////////////////////////
1808 void SMDS_Mesh::Remove0DElement(const SMDS_Mesh0DElement * elem0d)
1810 RemoveElement(elem0d,true);
1813 ///////////////////////////////////////////////////////////////////////////////
1814 /// Remove an edge and all the elements which own this edge
1815 ///////////////////////////////////////////////////////////////////////////////
1817 void SMDS_Mesh::RemoveEdge(const SMDS_MeshEdge * edge)
1819 RemoveElement(edge,true);
1822 ///////////////////////////////////////////////////////////////////////////////
1823 /// Remove an face and all the elements which own this face
1824 ///////////////////////////////////////////////////////////////////////////////
1826 void SMDS_Mesh::RemoveFace(const SMDS_MeshFace * face)
1828 RemoveElement(face, true);
1831 ///////////////////////////////////////////////////////////////////////////////
1833 ///////////////////////////////////////////////////////////////////////////////
1835 void SMDS_Mesh::RemoveVolume(const SMDS_MeshVolume * volume)
1837 RemoveElement(volume, true);
1840 //=======================================================================
1841 //function : RemoveFromParent
1843 //=======================================================================
1845 bool SMDS_Mesh::RemoveFromParent()
1847 if (myParent==NULL) return false;
1848 else return (myParent->RemoveSubMesh(this));
1851 //=======================================================================
1852 //function : RemoveSubMesh
1854 //=======================================================================
1856 bool SMDS_Mesh::RemoveSubMesh(const SMDS_Mesh * aMesh)
1860 list<SMDS_Mesh *>::iterator itmsh=myChildren.begin();
1861 for (; itmsh!=myChildren.end() && !found; itmsh++)
1863 SMDS_Mesh * submesh = *itmsh;
1864 if (submesh == aMesh)
1867 myChildren.erase(itmsh);
1874 //=======================================================================
1875 //function : ChangeElementNodes
1877 //=======================================================================
1879 bool SMDS_Mesh::ChangeElementNodes(const SMDS_MeshElement * element,
1880 const SMDS_MeshNode * nodes[],
1883 // keep current nodes of elem
1884 set<const SMDS_MeshNode*> oldNodes( element->begin_nodes(), element->end_nodes() );
1888 SMDS_MeshCell* cell = dynamic_cast<SMDS_MeshCell*>((SMDS_MeshElement*) element);
1891 Ok = cell->vtkOrder(nodes, nbnodes);
1892 Ok = cell->ChangeNodes(nodes, nbnodes);
1895 if ( Ok ) { // update InverseElements
1897 set<const SMDS_MeshNode*>::iterator it;
1899 // AddInverseElement to new nodes
1900 for ( int i = 0; i < nbnodes; i++ ) {
1901 it = oldNodes.find( nodes[i] );
1902 if ( it == oldNodes.end() )
1904 const_cast<SMDS_MeshNode*>( nodes[i] )->AddInverseElement( cell );
1906 // remove from oldNodes a node that remains in elem
1907 oldNodes.erase( it );
1909 // RemoveInverseElement from the nodes removed from elem
1910 for ( it = oldNodes.begin(); it != oldNodes.end(); it++ )
1912 SMDS_MeshNode * n = const_cast<SMDS_MeshNode *>( *it );
1913 n->RemoveInverseElement( cell );
1920 //=======================================================================
1921 //function : ChangePolyhedronNodes
1922 //purpose : to change nodes of polyhedral volume
1923 //=======================================================================
1924 bool SMDS_Mesh::ChangePolyhedronNodes (const SMDS_MeshElement * elem,
1925 const vector<const SMDS_MeshNode*>& nodes,
1926 const vector<int> & quantities)
1928 if (elem->GetType() != SMDSAbs_Volume) {
1929 MESSAGE("WRONG ELEM TYPE");
1933 const SMDS_VtkVolume* vol = dynamic_cast<const SMDS_VtkVolume*>(elem);
1938 // keep current nodes of elem
1939 set<const SMDS_MeshElement*> oldNodes;
1940 SMDS_ElemIteratorPtr itn = elem->nodesIterator();
1941 while (itn->more()) {
1942 oldNodes.insert(itn->next());
1946 // TODO remove this function
1947 //bool Ok = const_cast<SMDS_VtkVolume*>(vol)->ChangeNodes(nodes, quantities);
1953 // update InverseElements
1955 // AddInverseElement to new nodes
1956 int nbnodes = nodes.size();
1957 set<const SMDS_MeshElement*>::iterator it;
1958 for (int i = 0; i < nbnodes; i++) {
1959 it = oldNodes.find(nodes[i]);
1960 if (it == oldNodes.end()) {
1962 const_cast<SMDS_MeshNode*>(nodes[i])->AddInverseElement(elem);
1964 // remove from oldNodes a node that remains in elem
1969 // RemoveInverseElement from the nodes removed from elem
1970 for (it = oldNodes.begin(); it != oldNodes.end(); it++) {
1971 SMDS_MeshNode * n = static_cast<SMDS_MeshNode *>
1972 (const_cast<SMDS_MeshElement *>( *it ));
1973 n->RemoveInverseElement(elem);
1980 //=======================================================================
1981 //function : Find0DElement
1983 //=======================================================================
1984 const SMDS_Mesh0DElement* SMDS_Mesh::Find0DElement(int idnode) const
1986 const SMDS_MeshNode * node = FindNode(idnode);
1987 if(node == NULL) return NULL;
1988 return Find0DElement(node);
1991 const SMDS_Mesh0DElement* SMDS_Mesh::Find0DElement(const SMDS_MeshNode * node)
1993 if (!node) return 0;
1994 const SMDS_Mesh0DElement* toReturn = NULL;
1995 SMDS_ElemIteratorPtr it1 = node->GetInverseElementIterator(SMDSAbs_0DElement);
1996 while (it1->more() && (toReturn == NULL)) {
1997 const SMDS_MeshElement* e = it1->next();
1998 if (e->NbNodes() == 1) {
1999 toReturn = static_cast<const SMDS_Mesh0DElement*>(e);
2005 //=======================================================================
2006 //function : FindBall
2008 //=======================================================================
2010 const SMDS_BallElement* SMDS_Mesh::FindBall(int idnode) const
2012 const SMDS_MeshNode * node = FindNode(idnode);
2013 if(node == NULL) return NULL;
2014 return FindBall(node);
2017 const SMDS_BallElement* SMDS_Mesh::FindBall(const SMDS_MeshNode * node)
2019 if (!node) return 0;
2020 const SMDS_BallElement* toReturn = NULL;
2021 SMDS_ElemIteratorPtr it1 = node->GetInverseElementIterator(SMDSAbs_Ball);
2022 while (it1->more() && (toReturn == NULL)) {
2023 const SMDS_MeshElement* e = it1->next();
2024 if (e->GetGeomType() == SMDSGeom_BALL)
2025 toReturn = static_cast<const SMDS_BallElement*>(e);
2030 //=======================================================================
2031 //function : Find0DElementOrCreate
2033 //=======================================================================
2034 //SMDS_Mesh0DElement* SMDS_Mesh::Find0DElementOrCreate(const SMDS_MeshNode * node)
2036 // if (!node) return 0;
2037 // SMDS_Mesh0DElement * toReturn = NULL;
2038 // toReturn = const_cast<SMDS_Mesh0DElement*>(Find0DElement(node));
2039 // if (toReturn == NULL) {
2040 // //if (my0DElements.Extent() % CHECKMEMORY_INTERVAL == 0) CheckMemory();
2041 // toReturn = new SMDS_Mesh0DElement(node);
2042 // my0DElements.Add(toReturn);
2043 // myInfo.myNb0DElements++;
2049 //=======================================================================
2050 //function : FindEdge
2052 //=======================================================================
2054 const SMDS_MeshEdge* SMDS_Mesh::FindEdge(int idnode1, int idnode2) const
2056 const SMDS_MeshNode * node1=FindNode(idnode1);
2057 const SMDS_MeshNode * node2=FindNode(idnode2);
2058 if((node1==NULL)||(node2==NULL)) return NULL;
2059 return FindEdge(node1,node2);
2062 //#include "Profiler.h"
2063 const SMDS_MeshEdge* SMDS_Mesh::FindEdge(const SMDS_MeshNode * node1,
2064 const SMDS_MeshNode * node2)
2066 if ( !node1 ) return 0;
2067 const SMDS_MeshEdge * toReturn=NULL;
2070 SMDS_ElemIteratorPtr it1=node1->GetInverseElementIterator(SMDSAbs_Edge);
2073 while(it1->more()) {
2074 const SMDS_MeshElement * e = it1->next();
2075 if ( e->NbNodes() == 2 && e->GetNodeIndex( node2 ) >= 0 ) {
2076 toReturn = static_cast<const SMDS_MeshEdge*>( e );
2085 //=======================================================================
2086 //function : FindEdgeOrCreate
2088 //=======================================================================
2090 SMDS_MeshEdge* SMDS_Mesh::FindEdgeOrCreate(const SMDS_MeshNode * node1,
2091 const SMDS_MeshNode * node2)
2093 if ( !node1 || !node2) return 0;
2094 SMDS_MeshEdge * toReturn=NULL;
2095 toReturn=const_cast<SMDS_MeshEdge*>(FindEdge(node1,node2));
2096 if(toReturn==NULL) {
2097 if ( NbEdges() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
2098 int ID = myElementIDFactory->GetFreeID(); // -PR- voir si on range cet element
2099 adjustmyCellsCapacity(ID);
2100 myNodeIds.resize(2);
2101 myNodeIds[0] = node1->getVtkId();
2102 myNodeIds[1] = node2->getVtkId();
2104 SMDS_VtkEdge *edgevtk = myEdgePool->getNew();
2105 edgevtk->init(myNodeIds, this);
2106 if (!this->registerElement(ID,edgevtk))
2108 this->myGrid->GetCellTypesArray()->SetValue(edgevtk->getVtkId(), VTK_EMPTY_CELL);
2109 myEdgePool->destroy(edgevtk);
2113 myCells[ID] = toReturn;
2120 //=======================================================================
2121 //function : FindEdge
2123 //=======================================================================
2125 const SMDS_MeshEdge* SMDS_Mesh::FindEdge(int idnode1, int idnode2,
2128 const SMDS_MeshNode * node1=FindNode(idnode1);
2129 const SMDS_MeshNode * node2=FindNode(idnode2);
2130 const SMDS_MeshNode * node3=FindNode(idnode3);
2131 return FindEdge(node1,node2,node3);
2134 const SMDS_MeshEdge* SMDS_Mesh::FindEdge(const SMDS_MeshNode * node1,
2135 const SMDS_MeshNode * node2,
2136 const SMDS_MeshNode * node3)
2138 if ( !node1 ) return 0;
2139 SMDS_ElemIteratorPtr it1 = node1->GetInverseElementIterator(SMDSAbs_Edge);
2140 while(it1->more()) {
2141 const SMDS_MeshElement * e = it1->next();
2142 if ( e->NbNodes() == 3 ) {
2143 SMDS_ElemIteratorPtr it2 = e->nodesIterator();
2144 while(it2->more()) {
2145 const SMDS_MeshElement* n = it2->next();
2155 return static_cast<const SMDS_MeshEdge *> (e);
2162 //=======================================================================
2163 //function : FindFace
2165 //=======================================================================
2167 const SMDS_MeshFace* SMDS_Mesh::FindFace(int idnode1, int idnode2,
2170 const SMDS_MeshNode * node1=FindNode(idnode1);
2171 const SMDS_MeshNode * node2=FindNode(idnode2);
2172 const SMDS_MeshNode * node3=FindNode(idnode3);
2173 return FindFace(node1, node2, node3);
2176 const SMDS_MeshFace* SMDS_Mesh::FindFace(const SMDS_MeshNode *node1,
2177 const SMDS_MeshNode *node2,
2178 const SMDS_MeshNode *node3)
2180 if ( !node1 ) return 0;
2181 SMDS_ElemIteratorPtr it1 = node1->GetInverseElementIterator(SMDSAbs_Face);
2182 while(it1->more()) {
2183 const SMDS_MeshElement * e = it1->next();
2184 if ( e->NbNodes() == 3 ) {
2185 SMDS_ElemIteratorPtr it2 = e->nodesIterator();
2186 while(it2->more()) {
2187 const SMDS_MeshElement* n = it2->next();
2197 return static_cast<const SMDS_MeshFace *> (e);
2203 SMDS_MeshFace* SMDS_Mesh::FindFaceOrCreate(const SMDS_MeshNode *node1,
2204 const SMDS_MeshNode *node2,
2205 const SMDS_MeshNode *node3)
2207 SMDS_MeshFace * toReturn=NULL;
2208 toReturn = const_cast<SMDS_MeshFace*>(FindFace(node1,node2,node3));
2209 if(toReturn==NULL) {
2210 int ID = myElementIDFactory->GetFreeID();
2211 toReturn = createTriangle(node1,node2,node3, ID);
2217 //=======================================================================
2218 //function : FindFace
2220 //=======================================================================
2222 const SMDS_MeshFace* SMDS_Mesh::FindFace(int idnode1, int idnode2,
2223 int idnode3, int idnode4) const
2225 const SMDS_MeshNode * node1=FindNode(idnode1);
2226 const SMDS_MeshNode * node2=FindNode(idnode2);
2227 const SMDS_MeshNode * node3=FindNode(idnode3);
2228 const SMDS_MeshNode * node4=FindNode(idnode4);
2229 return FindFace(node1, node2, node3, node4);
2232 const SMDS_MeshFace* SMDS_Mesh::FindFace(const SMDS_MeshNode *node1,
2233 const SMDS_MeshNode *node2,
2234 const SMDS_MeshNode *node3,
2235 const SMDS_MeshNode *node4)
2237 if ( !node1 ) return 0;
2238 SMDS_ElemIteratorPtr it1 = node1->GetInverseElementIterator(SMDSAbs_Face);
2239 while(it1->more()) {
2240 const SMDS_MeshElement * e = it1->next();
2241 if ( e->NbNodes() == 4 ) {
2242 SMDS_ElemIteratorPtr it2 = e->nodesIterator();
2243 while(it2->more()) {
2244 const SMDS_MeshElement* n = it2->next();
2255 return static_cast<const SMDS_MeshFace *> (e);
2261 SMDS_MeshFace* SMDS_Mesh::FindFaceOrCreate(const SMDS_MeshNode *node1,
2262 const SMDS_MeshNode *node2,
2263 const SMDS_MeshNode *node3,
2264 const SMDS_MeshNode *node4)
2266 SMDS_MeshFace * toReturn=NULL;
2267 toReturn=const_cast<SMDS_MeshFace*>(FindFace(node1,node2,node3,node4));
2268 if(toReturn==NULL) {
2269 int ID = myElementIDFactory->GetFreeID();
2270 toReturn=createQuadrangle(node1,node2,node3,node4,ID);
2276 //=======================================================================
2277 //function : FindFace
2278 //purpose :quadratic triangle
2279 //=======================================================================
2281 const SMDS_MeshFace* SMDS_Mesh::FindFace(int idnode1, int idnode2,
2282 int idnode3, int idnode4,
2283 int idnode5, int idnode6) const
2285 const SMDS_MeshNode * node1 = FindNode(idnode1);
2286 const SMDS_MeshNode * node2 = FindNode(idnode2);
2287 const SMDS_MeshNode * node3 = FindNode(idnode3);
2288 const SMDS_MeshNode * node4 = FindNode(idnode4);
2289 const SMDS_MeshNode * node5 = FindNode(idnode5);
2290 const SMDS_MeshNode * node6 = FindNode(idnode6);
2291 return FindFace(node1, node2, node3, node4, node5, node6);
2294 const SMDS_MeshFace* SMDS_Mesh::FindFace(const SMDS_MeshNode *node1,
2295 const SMDS_MeshNode *node2,
2296 const SMDS_MeshNode *node3,
2297 const SMDS_MeshNode *node4,
2298 const SMDS_MeshNode *node5,
2299 const SMDS_MeshNode *node6)
2301 if ( !node1 ) return 0;
2302 SMDS_ElemIteratorPtr it1 = node1->GetInverseElementIterator(SMDSAbs_Face);
2303 while(it1->more()) {
2304 const SMDS_MeshElement * e = it1->next();
2305 if ( e->NbNodes() == 6 ) {
2306 SMDS_ElemIteratorPtr it2 = e->nodesIterator();
2307 while(it2->more()) {
2308 const SMDS_MeshElement* n = it2->next();
2321 return static_cast<const SMDS_MeshFace *> (e);
2328 //=======================================================================
2329 //function : FindFace
2330 //purpose : quadratic quadrangle
2331 //=======================================================================
2333 const SMDS_MeshFace* SMDS_Mesh::FindFace(int idnode1, int idnode2,
2334 int idnode3, int idnode4,
2335 int idnode5, int idnode6,
2336 int idnode7, int idnode8) const
2338 const SMDS_MeshNode * node1 = FindNode(idnode1);
2339 const SMDS_MeshNode * node2 = FindNode(idnode2);
2340 const SMDS_MeshNode * node3 = FindNode(idnode3);
2341 const SMDS_MeshNode * node4 = FindNode(idnode4);
2342 const SMDS_MeshNode * node5 = FindNode(idnode5);
2343 const SMDS_MeshNode * node6 = FindNode(idnode6);
2344 const SMDS_MeshNode * node7 = FindNode(idnode7);
2345 const SMDS_MeshNode * node8 = FindNode(idnode8);
2346 return FindFace(node1, node2, node3, node4, node5, node6, node7, node8);
2349 const SMDS_MeshFace* SMDS_Mesh::FindFace(const SMDS_MeshNode *node1,
2350 const SMDS_MeshNode *node2,
2351 const SMDS_MeshNode *node3,
2352 const SMDS_MeshNode *node4,
2353 const SMDS_MeshNode *node5,
2354 const SMDS_MeshNode *node6,
2355 const SMDS_MeshNode *node7,
2356 const SMDS_MeshNode *node8)
2358 if ( !node1 ) return 0;
2359 SMDS_ElemIteratorPtr it1 = node1->GetInverseElementIterator(SMDSAbs_Face);
2360 while(it1->more()) {
2361 const SMDS_MeshElement * e = it1->next();
2362 if ( e->NbNodes() == 8 ) {
2363 SMDS_ElemIteratorPtr it2 = e->nodesIterator();
2364 while(it2->more()) {
2365 const SMDS_MeshElement* n = it2->next();
2380 return static_cast<const SMDS_MeshFace *> (e);
2387 //=======================================================================
2388 //function : FindElement
2390 //=======================================================================
2392 const SMDS_MeshElement* SMDS_Mesh::FindElement(int IDelem) const
2394 if ( IDelem <= 0 || IDelem >= (int)myCells.size() )
2398 return myCells[IDelem];
2401 //=======================================================================
2402 //function : FindFace
2403 //purpose : find polygon
2404 //=======================================================================
2406 const SMDS_MeshFace* SMDS_Mesh::FindFace (const vector<int>& nodes_ids) const
2408 int nbnodes = nodes_ids.size();
2409 vector<const SMDS_MeshNode *> poly_nodes (nbnodes);
2410 for (int inode = 0; inode < nbnodes; inode++) {
2411 const SMDS_MeshNode * node = FindNode(nodes_ids[inode]);
2412 if (node == NULL) return NULL;
2413 poly_nodes[inode] = node;
2415 return FindFace(poly_nodes);
2418 const SMDS_MeshFace* SMDS_Mesh::FindFace (const vector<const SMDS_MeshNode *>& nodes)
2420 return (const SMDS_MeshFace*) FindElement( nodes, SMDSAbs_Face );
2424 //================================================================================
2426 * \brief Return element based on all given nodes
2427 * \param nodes - node of element
2428 * \param type - type of element
2429 * \param noMedium - true if medium nodes of quadratic element are not included in <nodes>
2430 * \retval const SMDS_MeshElement* - found element or NULL
2432 //================================================================================
2434 const SMDS_MeshElement* SMDS_Mesh::FindElement (const vector<const SMDS_MeshNode *>& nodes,
2435 const SMDSAbs_ElementType type,
2436 const bool noMedium)
2438 if ( nodes.size() > 0 && nodes[0] )
2440 SMDS_ElemIteratorPtr itF = nodes[0]->GetInverseElementIterator(type);
2443 const SMDS_MeshElement* e = itF->next();
2444 int nbNodesToCheck = noMedium ? e->NbCornerNodes() : e->NbNodes();
2445 if ( nbNodesToCheck == (int)nodes.size() )
2447 for ( size_t i = 1; e && i < nodes.size(); ++i )
2449 int nodeIndex = e->GetNodeIndex( nodes[ i ]);
2450 if ( nodeIndex < 0 || nodeIndex >= nbNodesToCheck )
2461 //================================================================================
2463 * \brief Return elements including all given nodes
2464 * \param [in] nodes - nodes to find elements around
2465 * \param [out] foundElems - the found elements
2466 * \param [in] type - type of elements to find
2467 * \return int - a number of found elements
2469 //================================================================================
2471 int SMDS_Mesh::GetElementsByNodes(const std::vector<const SMDS_MeshNode *>& nodes,
2472 std::vector<const SMDS_MeshElement *>& foundElems,
2473 const SMDSAbs_ElementType type)
2475 // chose a node with minimal number of inverse elements
2476 const SMDS_MeshNode* n0 = nodes[0];
2477 int minNbInverse = n0 ? n0->NbInverseElements( type ) : 1000;
2478 for ( size_t i = 1; i < nodes.size(); ++i )
2479 if ( nodes[i] && nodes[i]->NbInverseElements( type ) < minNbInverse )
2482 minNbInverse = n0->NbInverseElements( type );
2488 foundElems.reserve( minNbInverse );
2489 SMDS_ElemIteratorPtr eIt = n0->GetInverseElementIterator( type );
2490 while ( eIt->more() )
2492 const SMDS_MeshElement* e = eIt->next();
2493 bool includeAll = true;
2494 for ( size_t i = 0; i < nodes.size() && includeAll; ++i )
2495 if ( nodes[i] != n0 && e->GetNodeIndex( nodes[i] ) < 0 )
2498 foundElems.push_back( e );
2501 return foundElems.size();
2504 //=======================================================================
2505 //function : DumpNodes
2507 //=======================================================================
2509 void SMDS_Mesh::DumpNodes() const
2511 SMDS_NodeIteratorPtr itnode=nodesIterator();
2512 while(itnode->more()) ; //MESSAGE(itnode->next());
2515 //=======================================================================
2516 //function : Dump0DElements
2518 //=======================================================================
2519 void SMDS_Mesh::Dump0DElements() const
2521 SMDS_ElemIteratorPtr it0d = elementsIterator(SMDSAbs_0DElement);
2522 while(it0d->more()) ; //MESSAGE(it0d->next());
2525 //=======================================================================
2526 //function : DumpEdges
2528 //=======================================================================
2530 void SMDS_Mesh::DumpEdges() const
2532 SMDS_EdgeIteratorPtr itedge=edgesIterator();
2533 while(itedge->more()) ; //MESSAGE(itedge->next());
2536 //=======================================================================
2537 //function : DumpFaces
2539 //=======================================================================
2541 void SMDS_Mesh::DumpFaces() const
2543 SMDS_FaceIteratorPtr itface=facesIterator();
2544 while(itface->more()) ; //MESSAGE(itface->next());
2547 //=======================================================================
2548 //function : DumpVolumes
2550 //=======================================================================
2552 void SMDS_Mesh::DumpVolumes() const
2554 SMDS_VolumeIteratorPtr itvol=volumesIterator();
2555 while(itvol->more()) ; //MESSAGE(itvol->next());
2558 //=======================================================================
2559 //function : DebugStats
2561 //=======================================================================
2563 void SMDS_Mesh::DebugStats() const
2565 MESSAGE("Debug stats of mesh : ");
2567 MESSAGE("===== NODES ====="<<NbNodes());
2568 MESSAGE("===== 0DELEMS ====="<<Nb0DElements());
2569 MESSAGE("===== EDGES ====="<<NbEdges());
2570 MESSAGE("===== FACES ====="<<NbFaces());
2571 MESSAGE("===== VOLUMES ====="<<NbVolumes());
2573 MESSAGE("End Debug stats of mesh ");
2577 SMDS_NodeIteratorPtr itnode=nodesIterator();
2578 int sizeofnodes = 0;
2579 int sizeoffaces = 0;
2581 while(itnode->more())
2583 const SMDS_MeshNode *node = itnode->next();
2585 sizeofnodes += sizeof(*node);
2587 SMDS_ElemIteratorPtr it = node->GetInverseElementIterator();
2590 const SMDS_MeshElement *me = it->next();
2591 sizeofnodes += sizeof(me);
2595 SMDS_FaceIteratorPtr itface=facesIterator();
2596 while(itface->more())
2598 const SMDS_MeshElement *face = itface->next();
2599 sizeoffaces += sizeof(*face);
2602 MESSAGE("total size of node elements = " << sizeofnodes);;
2603 MESSAGE("total size of face elements = " << sizeoffaces);;
2608 ///////////////////////////////////////////////////////////////////////////////
2609 /// Return the number of nodes
2610 ///////////////////////////////////////////////////////////////////////////////
2611 int SMDS_Mesh::NbNodes() const
2613 return myInfo.NbNodes();
2616 ///////////////////////////////////////////////////////////////////////////////
2617 /// Return the number of elements
2618 ///////////////////////////////////////////////////////////////////////////////
2619 int SMDS_Mesh::NbElements() const
2621 return myInfo.NbElements();
2623 ///////////////////////////////////////////////////////////////////////////////
2624 /// Return the number of 0D elements
2625 ///////////////////////////////////////////////////////////////////////////////
2626 int SMDS_Mesh::Nb0DElements() const
2628 return myInfo.Nb0DElements();
2631 ///////////////////////////////////////////////////////////////////////////////
2632 /// Return the number of 0D elements
2633 ///////////////////////////////////////////////////////////////////////////////
2634 int SMDS_Mesh::NbBalls() const
2636 return myInfo.NbBalls();
2639 ///////////////////////////////////////////////////////////////////////////////
2640 /// Return the number of edges (including construction edges)
2641 ///////////////////////////////////////////////////////////////////////////////
2642 int SMDS_Mesh::NbEdges() const
2644 return myInfo.NbEdges();
2647 ///////////////////////////////////////////////////////////////////////////////
2648 /// Return the number of faces (including construction faces)
2649 ///////////////////////////////////////////////////////////////////////////////
2650 int SMDS_Mesh::NbFaces() const
2652 return myInfo.NbFaces();
2655 ///////////////////////////////////////////////////////////////////////////////
2656 /// Return the number of volumes
2657 ///////////////////////////////////////////////////////////////////////////////
2658 int SMDS_Mesh::NbVolumes() const
2660 return myInfo.NbVolumes();
2663 ///////////////////////////////////////////////////////////////////////////////
2664 /// Return the number of child mesh of this mesh.
2665 /// Note that the tree structure of SMDS_Mesh is unused in SMESH
2666 ///////////////////////////////////////////////////////////////////////////////
2667 int SMDS_Mesh::NbSubMesh() const
2669 return myChildren.size();
2672 ///////////////////////////////////////////////////////////////////////////////
2673 /// Destroy the mesh and all its elements
2674 /// All pointer on elements owned by this mesh become illegals.
2675 ///////////////////////////////////////////////////////////////////////////////
2676 SMDS_Mesh::~SMDS_Mesh()
2678 list<SMDS_Mesh*>::iterator itc=myChildren.begin();
2679 while(itc!=myChildren.end())
2687 delete myNodeIDFactory;
2688 delete myElementIDFactory;
2692 SMDS_ElemIteratorPtr eIt = elementsIterator();
2693 while ( eIt->more() )
2695 const SMDS_MeshElement *elem = eIt->next();
2696 myElementIDFactory->ReleaseID(elem->GetID(), elem->getVtkId());
2698 SMDS_NodeIteratorPtr itn = nodesIterator();
2701 const SMDS_MeshNode *node = itn->next();
2702 ((SMDS_MeshNode*)node)->SetPosition(SMDS_SpacePosition::originSpacePosition());
2703 myNodeIDFactory->ReleaseID(node->GetID(), node->getVtkId());
2709 delete myVolumePool;
2715 //================================================================================
2717 * \brief Clear all data
2719 //================================================================================
2721 void SMDS_Mesh::Clear()
2725 SMDS_ElemIteratorPtr eIt = elementsIterator();
2726 while ( eIt->more() )
2728 const SMDS_MeshElement *elem = eIt->next();
2729 myElementIDFactory->ReleaseID(elem->GetID(), elem->getVtkId());
2731 SMDS_NodeIteratorPtr itn = nodesIterator();
2734 const SMDS_MeshNode *node = itn->next();
2735 myNodeIDFactory->ReleaseID(node->GetID(), node->getVtkId());
2740 myNodeIDFactory->Clear();
2741 myElementIDFactory->Clear();
2744 myVolumePool->clear();
2745 myFacePool->clear();
2746 myEdgePool->clear();
2747 myBallPool->clear();
2749 clearVector( myCells );
2750 clearVector( myCellIdVtkToSmds );
2752 SMDS_NodeIteratorPtr itn = nodesIterator();
2755 SMDS_MeshNode *node = (SMDS_MeshNode*)(itn->next());
2756 node->SetPosition(SMDS_SpacePosition::originSpacePosition());
2757 //myNodePool->destroy(node);
2759 myNodePool->clear();
2760 clearVector( myNodes );
2762 list<SMDS_Mesh*>::iterator itc=myChildren.begin();
2763 while(itc!=myChildren.end())
2774 myGrid->Initialize();
2776 vtkPoints* points = vtkPoints::New();
2777 // rnv: to fix bug "21125: EDF 1233 SMESH: Degrardation of precision in a test case for quadratic conversion"
2778 // using double type for storing coordinates of nodes instead float.
2779 points->SetDataType(VTK_DOUBLE);
2780 points->SetNumberOfPoints( 0 );
2781 myGrid->SetPoints( points );
2783 myGrid->DeleteLinks();
2786 ///////////////////////////////////////////////////////////////////////////////
2787 /// Return true if this mesh create faces with edges.
2788 /// A false returned value mean that faces are created with nodes. A concequence
2789 /// is, iteration on edges (SMDS_Element::edgesIterator) will be unavailable.
2790 ///////////////////////////////////////////////////////////////////////////////
2791 bool SMDS_Mesh::hasConstructionEdges()
2793 return myHasConstructionEdges;
2796 ///////////////////////////////////////////////////////////////////////////////
2797 /// Return true if this mesh create volumes with faces
2798 /// A false returned value mean that volumes are created with nodes or edges.
2799 /// (see hasConstructionEdges)
2800 /// A concequence is, iteration on faces (SMDS_Element::facesIterator) will be
2802 ///////////////////////////////////////////////////////////////////////////////
2803 bool SMDS_Mesh::hasConstructionFaces()
2805 return myHasConstructionFaces;
2808 ///////////////////////////////////////////////////////////////////////////////
2809 /// Return true if nodes are linked to the finit elements, they are belonging to.
2810 /// Currently, It always return true.
2811 ///////////////////////////////////////////////////////////////////////////////
2812 bool SMDS_Mesh::hasInverseElements()
2814 return myHasInverseElements;
2817 ///////////////////////////////////////////////////////////////////////////////
2818 /// Make this mesh creating construction edges (see hasConstructionEdges)
2819 /// @param b true to have construction edges, else false.
2820 ///////////////////////////////////////////////////////////////////////////////
2821 void SMDS_Mesh::setConstructionEdges(bool b)
2823 myHasConstructionEdges=b;
2826 ///////////////////////////////////////////////////////////////////////////////
2827 /// Make this mesh creating construction faces (see hasConstructionFaces)
2828 /// @param b true to have construction faces, else false.
2829 ///////////////////////////////////////////////////////////////////////////////
2830 void SMDS_Mesh::setConstructionFaces(bool b)
2832 myHasConstructionFaces=b;
2835 ///////////////////////////////////////////////////////////////////////////////
2836 /// Make this mesh creating link from nodes to elements (see hasInverseElements)
2837 /// @param b true to link nodes to elements, else false.
2838 ///////////////////////////////////////////////////////////////////////////////
2839 void SMDS_Mesh::setInverseElements(bool b)
2841 if(!b) MESSAGE("Error : inverseElement=false not implemented");
2842 myHasInverseElements=b;
2847 //================================================================================
2849 * \brief Iterator on elements in id increasing order
2851 //================================================================================
2853 template <typename ELEM=const SMDS_MeshElement*>
2854 class IdSortedIterator : public SMDS_Iterator<ELEM>
2856 SMDS_MeshElementIDFactory& myIDFact;
2857 int myID, myMaxID, myNbFound, myTotalNb;
2858 SMDSAbs_ElementType myType;
2862 IdSortedIterator(const SMDS_MeshElementIDFactory& fact,
2863 const SMDSAbs_ElementType type, // SMDSAbs_All NOT allowed!!!
2865 :myIDFact( const_cast<SMDS_MeshElementIDFactory&>(fact) ),
2866 myID(1), myMaxID( myIDFact.GetMaxID() ),myNbFound(0), myTotalNb( totalNb ),
2878 ELEM current = myElem;
2880 for ( myElem = 0; !myElem && myNbFound < myTotalNb && myID <= myMaxID; ++myID )
2881 if ((myElem = (ELEM) myIDFact.MeshElement( myID ))
2882 && myElem->GetType() != myType )
2885 myNbFound += bool(myElem);
2891 //================================================================================
2893 * \brief Iterator on vector of elements, possibly being resized while iteration
2895 //================================================================================
2897 template<typename RETURN_VALUE,
2898 typename VECTOR_VALUE=SMDS_MeshCell*,
2899 typename VALUE_FILTER=SMDS::NonNullFilter<VECTOR_VALUE> >
2900 class ElemVecIterator: public SMDS_Iterator<RETURN_VALUE>
2902 const std::vector<VECTOR_VALUE>& _vector;
2905 VALUE_FILTER _filter;
2907 ElemVecIterator(const std::vector<VECTOR_VALUE>& vec,
2908 const VALUE_FILTER& filter=VALUE_FILTER() )
2909 :_vector( vec ), _index(0), _more( !vec.empty() ), _filter( filter )
2911 if ( _more && !_filter( _vector[ _index ]))
2918 virtual RETURN_VALUE next()
2920 if ( !_more ) return NULL;
2921 VECTOR_VALUE current = _vector[ _index ];
2923 while ( !_more && ++_index < _vector.size() )
2924 _more = _filter( _vector[ _index ]);
2925 return (RETURN_VALUE) current;
2930 ///////////////////////////////////////////////////////////////////////////////
2931 /// Return an iterator on nodes of the current mesh factory
2932 ///////////////////////////////////////////////////////////////////////////////
2934 SMDS_NodeIteratorPtr SMDS_Mesh::nodesIterator(bool idInceasingOrder) const
2936 // naturally always sorted by ID
2937 typedef ElemVecIterator<const SMDS_MeshNode*, SMDS_MeshNode*> TIterator;
2938 return SMDS_NodeIteratorPtr( new TIterator(myNodes));
2941 SMDS_ElemIteratorPtr SMDS_Mesh::elementGeomIterator(SMDSAbs_GeometryType type) const
2943 // naturally always sorted by ID
2944 typedef ElemVecIterator
2945 < const SMDS_MeshElement*, SMDS_MeshCell*, SMDS_MeshElement::GeomFilter > TIterator;
2946 return SMDS_ElemIteratorPtr
2947 (new TIterator(myCells, SMDS_MeshElement::GeomFilter( type )));
2950 SMDS_ElemIteratorPtr SMDS_Mesh::elementEntityIterator(SMDSAbs_EntityType type) const
2952 if ( type == SMDSEntity_Node )
2954 typedef ElemVecIterator<const SMDS_MeshElement*, SMDS_MeshNode*> TIterator;
2955 return SMDS_ElemIteratorPtr( new TIterator(myNodes));
2957 // naturally always sorted by ID
2958 typedef ElemVecIterator
2959 < const SMDS_MeshElement*, SMDS_MeshCell*, SMDS_MeshElement::EntityFilter > TIterator;
2960 return SMDS_ElemIteratorPtr
2961 (new TIterator(myCells, SMDS_MeshElement::EntityFilter( type )));
2964 ///////////////////////////////////////////////////////////////////////////////
2965 /// Return an iterator on elements of the current mesh factory
2966 ///////////////////////////////////////////////////////////////////////////////
2967 SMDS_ElemIteratorPtr SMDS_Mesh::elementsIterator(SMDSAbs_ElementType type) const
2969 // naturally always sorted by ID
2973 return SMDS_ElemIteratorPtr (new ElemVecIterator<const SMDS_MeshElement*>(myCells));
2976 return SMDS_ElemIteratorPtr
2977 ( new ElemVecIterator<const SMDS_MeshElement*, SMDS_MeshNode*>( myNodes ));
2980 typedef ElemVecIterator
2981 < const SMDS_MeshElement*, SMDS_MeshCell*, SMDS_MeshElement::TypeFilter > TIterator;
2982 return SMDS_ElemIteratorPtr (new TIterator(myCells, SMDS_MeshElement::TypeFilter( type )));
2984 return SMDS_ElemIteratorPtr();
2987 ///////////////////////////////////////////////////////////////////////////////
2988 ///Return an iterator on edges of the current mesh.
2989 ///////////////////////////////////////////////////////////////////////////////
2991 SMDS_EdgeIteratorPtr SMDS_Mesh::edgesIterator(bool idInceasingOrder) const
2993 // naturally always sorted by ID
2994 typedef ElemVecIterator
2995 < const SMDS_MeshEdge*, SMDS_MeshCell*, SMDS_MeshElement::TypeFilter > TIterator;
2996 return SMDS_EdgeIteratorPtr
2997 (new TIterator(myCells, SMDS_MeshElement::TypeFilter( SMDSAbs_Edge )));
3000 ///////////////////////////////////////////////////////////////////////////////
3001 ///Return an iterator on faces of the current mesh.
3002 ///////////////////////////////////////////////////////////////////////////////
3004 SMDS_FaceIteratorPtr SMDS_Mesh::facesIterator(bool idInceasingOrder) const
3006 // naturally always sorted by ID
3007 typedef ElemVecIterator
3008 < const SMDS_MeshFace*, SMDS_MeshCell*, SMDS_MeshElement::TypeFilter > TIterator;
3009 return SMDS_FaceIteratorPtr
3010 (new TIterator(myCells, SMDS_MeshElement::TypeFilter( SMDSAbs_Face )));
3013 ///////////////////////////////////////////////////////////////////////////////
3014 ///Return an iterator on volumes of the current mesh.
3015 ///////////////////////////////////////////////////////////////////////////////
3017 SMDS_VolumeIteratorPtr SMDS_Mesh::volumesIterator(bool idInceasingOrder) const
3019 // naturally always sorted by ID
3020 typedef ElemVecIterator
3021 < const SMDS_MeshVolume*, SMDS_MeshCell*, SMDS_MeshElement::TypeFilter > TIterator;
3022 return SMDS_VolumeIteratorPtr
3023 (new TIterator(myCells, SMDS_MeshElement::TypeFilter( SMDSAbs_Volume )));
3026 ///////////////////////////////////////////////////////////////////////////////
3027 /// Do intersection of sets (more than 2)
3028 ///////////////////////////////////////////////////////////////////////////////
3029 static set<const SMDS_MeshElement*> * intersectionOfSets(
3030 set<const SMDS_MeshElement*> vs[], int numberOfSets)
3032 set<const SMDS_MeshElement*>* rsetA=new set<const SMDS_MeshElement*>(vs[0]);
3033 set<const SMDS_MeshElement*>* rsetB;
3035 for(int i=0; i<numberOfSets-1; i++)
3037 rsetB=new set<const SMDS_MeshElement*>();
3039 rsetA->begin(), rsetA->end(),
3040 vs[i+1].begin(), vs[i+1].end(),
3041 inserter(*rsetB, rsetB->begin()));
3048 ///////////////////////////////////////////////////////////////////////////////
3049 /// Return the list of finite elements owning the given element: elements
3050 /// containing all the nodes of the given element, for instance faces and
3051 /// volumes containing a given edge.
3052 ///////////////////////////////////////////////////////////////////////////////
3053 static set<const SMDS_MeshElement*> * getFinitElements(const SMDS_MeshElement * element)
3055 int numberOfSets=element->NbNodes();
3056 set<const SMDS_MeshElement*> *initSet = new set<const SMDS_MeshElement*>[numberOfSets];
3058 SMDS_ElemIteratorPtr itNodes=element->nodesIterator();
3061 while ( itNodes->more() )
3063 const SMDS_MeshElement* node = itNodes->next();
3065 const SMDS_MeshNode * n=static_cast<const SMDS_MeshNode*>(node);
3066 SMDS_ElemIteratorPtr itFe = n->GetInverseElementIterator();
3068 while ( itFe->more() )
3070 const SMDS_MeshElement* elem = itFe->next();
3072 initSet[i].insert(elem);
3077 set<const SMDS_MeshElement*> *retSet = intersectionOfSets( initSet, numberOfSets );
3082 ///////////////////////////////////////////////////////////////////////////////
3083 /// Return the list of nodes used only by the given elements
3084 ///////////////////////////////////////////////////////////////////////////////
3085 static set<const SMDS_MeshElement*> * getExclusiveNodes(set<const SMDS_MeshElement*>& elements)
3087 set<const SMDS_MeshElement*> * toReturn=new set<const SMDS_MeshElement*>();
3088 set<const SMDS_MeshElement*>::iterator itElements=elements.begin();
3090 while(itElements!=elements.end())
3092 SMDS_ElemIteratorPtr itNodes = (*itElements)->nodesIterator();
3095 while(itNodes->more())
3097 const SMDS_MeshNode * n=static_cast<const SMDS_MeshNode*>(itNodes->next());
3098 SMDS_ElemIteratorPtr itFe = n->GetInverseElementIterator();
3099 set<const SMDS_MeshElement*> s;
3101 s.insert(itFe->next());
3102 if(s==elements) toReturn->insert(n);
3108 ///////////////////////////////////////////////////////////////////////////////
3109 ///Find the children of an element that are made of given nodes
3110 ///@param setOfChildren The set in which matching children will be inserted
3111 ///@param element The element were to search matching children
3112 ///@param nodes The nodes that the children must have to be selected
3113 ///////////////////////////////////////////////////////////////////////////////
3114 void SMDS_Mesh::addChildrenWithNodes(set<const SMDS_MeshElement*>& setOfChildren,
3115 const SMDS_MeshElement * element,
3116 set<const SMDS_MeshElement*>& nodes)
3118 switch(element->GetType())
3121 MESSAGE("Internal Error: This should not happen");
3123 case SMDSAbs_0DElement:
3130 SMDS_ElemIteratorPtr itn=element->nodesIterator();
3133 const SMDS_MeshElement * e=itn->next();
3134 if(nodes.find(e)!=nodes.end())
3136 setOfChildren.insert(element);
3143 SMDS_ElemIteratorPtr itn=element->nodesIterator();
3146 const SMDS_MeshElement * e=itn->next();
3147 if(nodes.find(e)!=nodes.end())
3149 setOfChildren.insert(element);
3153 if(hasConstructionEdges())
3155 SMDS_ElemIteratorPtr ite=element->edgesIterator();
3157 addChildrenWithNodes(setOfChildren, ite->next(), nodes);
3160 case SMDSAbs_Volume:
3162 if(hasConstructionFaces())
3164 SMDS_ElemIteratorPtr ite=element->facesIterator();
3166 addChildrenWithNodes(setOfChildren, ite->next(), nodes);
3168 else if(hasConstructionEdges())
3170 SMDS_ElemIteratorPtr ite=element->edgesIterator();
3172 addChildrenWithNodes(setOfChildren, ite->next(), nodes);
3175 case SMDSAbs_NbElementTypes:
3176 case SMDSAbs_All: break;
3180 ///////////////////////////////////////////////////////////////////////////////
3181 ///@param elem The element to delete
3182 ///@param removenodes if true remaining nodes will be removed
3183 ///////////////////////////////////////////////////////////////////////////////
3184 void SMDS_Mesh::RemoveElement(const SMDS_MeshElement * elem,
3185 const bool removenodes)
3187 list<const SMDS_MeshElement *> removedElems;
3188 list<const SMDS_MeshElement *> removedNodes;
3189 RemoveElement( elem, removedElems, removedNodes, removenodes );
3192 ///////////////////////////////////////////////////////////////////////////////
3193 ///@param elem The element to delete
3194 ///@param removedElems to be filled with all removed elements
3195 ///@param removedNodes to be filled with all removed nodes
3196 ///@param removenodes if true remaining nodes will be removed
3197 ///////////////////////////////////////////////////////////////////////////////
3198 void SMDS_Mesh::RemoveElement(const SMDS_MeshElement * elem,
3199 list<const SMDS_MeshElement *>& removedElems,
3200 list<const SMDS_MeshElement *>& removedNodes,
3203 // get finite elements built on elem
3204 set<const SMDS_MeshElement*> * s1;
3205 if ( (elem->GetType() == SMDSAbs_0DElement)
3206 || ((elem->GetType() == SMDSAbs_Edge) && !hasConstructionEdges())
3207 || ((elem->GetType() == SMDSAbs_Face) && !hasConstructionFaces())
3208 || (elem->GetType() == SMDSAbs_Volume) )
3210 s1 = new set<const SMDS_MeshElement*> ();
3214 s1 = getFinitElements(elem);
3216 // get exclusive nodes (which would become free afterwards)
3217 set<const SMDS_MeshElement*> * s2;
3218 if (elem->GetType() == SMDSAbs_Node) // a node is removed
3220 // do not remove nodes except elem
3221 s2 = new set<const SMDS_MeshElement*> ();
3226 s2 = getExclusiveNodes(*s1);
3228 // form the set of finite and construction elements to remove
3229 set<const SMDS_MeshElement*> s3;
3230 set<const SMDS_MeshElement*>::iterator it = s1->begin();
3231 while (it != s1->end())
3233 addChildrenWithNodes(s3, *it, *s2);
3237 if (elem->GetType() != SMDSAbs_Node)
3240 // remove finite and construction elements
3242 while (it != s3.end())
3244 // Remove element from <InverseElements> of its nodes
3245 SMDS_ElemIteratorPtr itn = (*it)->nodesIterator();
3248 SMDS_MeshNode * n = static_cast<SMDS_MeshNode *> (const_cast<SMDS_MeshElement *> (itn->next()));
3249 n->RemoveInverseElement((*it));
3251 int IdToRemove = (*it)->GetID();
3252 int vtkid = (*it)->getVtkId();
3253 switch ((*it)->GetType())
3256 MYASSERT("Internal Error: This should not happen");
3258 case SMDSAbs_0DElement:
3259 if (IdToRemove >= 0)
3261 myCells[IdToRemove] = 0; // -PR- ici ou dans myElementIDFactory->ReleaseID ?
3264 removedElems.push_back((*it));
3265 myElementIDFactory->ReleaseID(IdToRemove, vtkid);
3269 if (IdToRemove >= 0)
3271 myCells[IdToRemove] = 0;
3272 myInfo.RemoveEdge(*it);
3274 removedElems.push_back((*it));
3275 myElementIDFactory->ReleaseID(IdToRemove, vtkid);
3276 if (const SMDS_VtkEdge* vtkElem = dynamic_cast<const SMDS_VtkEdge*>(*it))
3277 myEdgePool->destroy((SMDS_VtkEdge*) vtkElem);
3279 ((SMDS_MeshElement*) *it)->init( 0, -1, -1 ); // avoid reuse
3284 if (IdToRemove >= 0)
3286 myCells[IdToRemove] = 0;
3287 myInfo.RemoveFace(*it);
3289 removedElems.push_back((*it));
3290 myElementIDFactory->ReleaseID(IdToRemove, vtkid);
3291 if (const SMDS_VtkFace* vtkElem = dynamic_cast<const SMDS_VtkFace*>(*it))
3292 myFacePool->destroy((SMDS_VtkFace*) vtkElem);
3294 ((SMDS_MeshElement*) *it)->init( 0, -1, -1 ); // avoid reuse
3298 case SMDSAbs_Volume:
3299 if (IdToRemove >= 0)
3301 myCells[IdToRemove] = 0;
3302 myInfo.RemoveVolume(*it);
3304 removedElems.push_back((*it));
3305 myElementIDFactory->ReleaseID(IdToRemove, vtkid);
3306 if (const SMDS_VtkVolume* vtkElem = dynamic_cast<const SMDS_VtkVolume*>(*it))
3307 myVolumePool->destroy((SMDS_VtkVolume*) vtkElem);
3309 ((SMDS_MeshElement*) *it)->init( 0, -1, -1 ); // avoid reuse
3314 if (IdToRemove >= 0)
3316 myCells[IdToRemove] = 0;
3319 removedElems.push_back((*it));
3320 myElementIDFactory->ReleaseID(IdToRemove, vtkid);
3321 if (const SMDS_BallElement* vtkElem = dynamic_cast<const SMDS_BallElement*>(*it))
3322 myBallPool->destroy(const_cast<SMDS_BallElement*>( vtkElem ));
3324 ((SMDS_MeshElement*) *it)->init( 0, -1, -1 ); // avoid reuse
3329 case SMDSAbs_All: // avoid compilation warning
3330 case SMDSAbs_NbElementTypes: break;
3334 this->myGrid->GetCellTypesArray()->SetValue(vtkid, VTK_EMPTY_CELL);
3339 // remove exclusive (free) nodes
3343 while (it != s2->end())
3345 int IdToRemove = (*it)->GetID();
3346 if (IdToRemove >= 0)
3348 myNodes[IdToRemove] = 0;
3351 myNodeIDFactory->ReleaseID((*it)->GetID(), (*it)->getVtkId());
3352 removedNodes.push_back((*it));
3353 if (const SMDS_MeshNode* vtkElem = dynamic_cast<const SMDS_MeshNode*>(*it))
3355 ((SMDS_MeshNode*)vtkElem)->SetPosition(SMDS_SpacePosition::originSpacePosition());
3356 myNodePool->destroy((SMDS_MeshNode*) vtkElem);
3369 ///////////////////////////////////////////////////////////////////////////////
3370 ///@param elem The element to delete
3371 ///////////////////////////////////////////////////////////////////////////////
3372 void SMDS_Mesh::RemoveFreeElement(const SMDS_MeshElement * elem)
3374 int elemId = elem->GetID();
3375 int vtkId = elem->getVtkId();
3376 SMDSAbs_ElementType aType = elem->GetType();
3377 SMDS_MeshElement* todest = (SMDS_MeshElement*)(elem);
3378 if ( aType == SMDSAbs_Node )
3380 // only free node can be removed by this method
3381 const SMDS_MeshNode* n = static_cast<SMDS_MeshNode*>(todest);
3382 if ( n->NbInverseElements() == 0 ) { // free node
3383 myNodes[elemId] = 0;
3385 ((SMDS_MeshNode*) n)->SetPosition(SMDS_SpacePosition::originSpacePosition());
3386 ((SMDS_MeshNode*) n)->SMDS_MeshElement::init( 0, -1, -1 ); // avoid reuse
3387 myNodePool->destroy(static_cast<SMDS_MeshNode*>(todest));
3388 myNodeIDFactory->ReleaseID(elemId, vtkId);
3393 if (hasConstructionEdges() || hasConstructionFaces())
3394 // this methods is only for meshes without descendants
3397 // Remove element from <InverseElements> of its nodes
3398 SMDS_ElemIteratorPtr itn = elem->nodesIterator();
3399 while (itn->more()) {
3400 SMDS_MeshNode * n = static_cast<SMDS_MeshNode *>
3401 (const_cast<SMDS_MeshElement *>(itn->next()));
3402 n->RemoveInverseElement(elem);
3405 // in meshes without descendants elements are always free
3407 case SMDSAbs_0DElement:
3408 myCells[elemId] = 0;
3409 myInfo.remove(elem);
3414 myCells[elemId] = 0;
3415 myInfo.RemoveEdge(elem);
3416 myEdgePool->destroy(static_cast<SMDS_VtkEdge*>(todest));
3419 myCells[elemId] = 0;
3420 myInfo.RemoveFace(elem);
3421 myFacePool->destroy(static_cast<SMDS_VtkFace*>(todest));
3423 case SMDSAbs_Volume:
3424 myCells[elemId] = 0;
3425 myInfo.RemoveVolume(elem);
3426 myVolumePool->destroy(static_cast<SMDS_VtkVolume*>(todest));
3429 myCells[elemId] = 0;
3430 myInfo.remove(elem);
3431 myBallPool->destroy(static_cast<SMDS_BallElement*>(todest));
3436 myElementIDFactory->ReleaseID(elemId, vtkId);
3438 this->myGrid->GetCellTypesArray()->SetValue(vtkId, VTK_EMPTY_CELL);
3439 // --- to do: keep vtkid in a list of reusable cells
3442 ((SMDS_MeshElement*) elem)->init( 0, -1, -1 ); // avoid reuse
3447 * Checks if the element is present in mesh.
3448 * Useful to determine dead pointers.
3450 bool SMDS_Mesh::Contains (const SMDS_MeshElement* elem) const
3452 // we should not rely on validity of *elem, so iterate on containers
3453 // of all types in the hope of finding <elem> somewhere there
3454 SMDS_NodeIteratorPtr itn = nodesIterator();
3456 if (elem == itn->next())
3458 SMDS_ElemIteratorPtr ite = elementsIterator();
3460 if (elem == ite->next())
3465 //=======================================================================
3466 //function : MaxNodeID
3468 //=======================================================================
3470 int SMDS_Mesh::MaxNodeID() const
3472 return myNodeIDFactory->GetMaxID();
3475 //=======================================================================
3476 //function : MinNodeID
3478 //=======================================================================
3480 int SMDS_Mesh::MinNodeID() const
3482 return myNodeIDFactory->GetMinID();
3485 //=======================================================================
3486 //function : MaxElementID
3488 //=======================================================================
3490 int SMDS_Mesh::MaxElementID() const
3492 return myElementIDFactory->GetMaxID();
3495 //=======================================================================
3496 //function : MinElementID
3498 //=======================================================================
3500 int SMDS_Mesh::MinElementID() const
3502 return myElementIDFactory->GetMinID();
3505 //=======================================================================
3506 //function : Renumber
3507 //purpose : Renumber all nodes or elements.
3508 //=======================================================================
3510 void SMDS_Mesh::Renumber (const bool isNodes, const int startID, const int deltaID)
3515 SMDS_MeshNodeIDFactory * idFactory =
3516 isNodes ? myNodeIDFactory : myElementIDFactory;
3518 // get existing elements in the order of ID increasing
3519 map<int,SMDS_MeshElement*> elemMap;
3520 SMDS_ElemIteratorPtr idElemIt = idFactory->elementsIterator();
3521 while ( idElemIt->more() ) {
3522 SMDS_MeshElement* elem = const_cast<SMDS_MeshElement*>(idElemIt->next());
3523 int id = elem->GetID();
3524 elemMap.insert(map<int,SMDS_MeshElement*>::value_type(id, elem));
3526 // release their ids
3527 map<int,SMDS_MeshElement*>::iterator elemIt = elemMap.begin();
3529 // for ( ; elemIt != elemMap.end(); elemIt++ )
3531 // int id = (*elemIt).first;
3532 // idFactory->ReleaseID( id );
3536 elemIt = elemMap.begin();
3537 for ( ; elemIt != elemMap.end(); elemIt++ )
3539 idFactory->BindID( ID, (*elemIt).second );
3544 //=======================================================================
3545 //function : GetElementType
3546 //purpose : Return type of element or node with id
3547 //=======================================================================
3549 SMDSAbs_ElementType SMDS_Mesh::GetElementType( const int id, const bool iselem ) const
3551 SMDS_MeshElement* elem = 0;
3553 elem = myElementIDFactory->MeshElement( id );
3555 elem = myNodeIDFactory->MeshElement( id );
3559 //throw SALOME_Exception(LOCALIZED ("this element isn't exist"));
3563 return elem->GetType();
3568 //********************************************************************
3569 //********************************************************************
3570 //******** *********
3571 //***** Methods for addition of quadratic elements ******
3572 //******** *********
3573 //********************************************************************
3574 //********************************************************************
3576 //=======================================================================
3577 //function : AddEdgeWithID
3579 //=======================================================================
3580 SMDS_MeshEdge* SMDS_Mesh::AddEdgeWithID(int n1, int n2, int n12, int ID)
3582 return SMDS_Mesh::AddEdgeWithID
3583 ((SMDS_MeshNode*) myNodeIDFactory->MeshElement(n1),
3584 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n2),
3585 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n12),
3589 //=======================================================================
3590 //function : AddEdge
3592 //=======================================================================
3593 SMDS_MeshEdge* SMDS_Mesh::AddEdge(const SMDS_MeshNode* n1,
3594 const SMDS_MeshNode* n2,
3595 const SMDS_MeshNode* n12)
3597 return SMDS_Mesh::AddEdgeWithID(n1, n2, n12, myElementIDFactory->GetFreeID());
3600 //=======================================================================
3601 //function : AddEdgeWithID
3603 //=======================================================================
3604 SMDS_MeshEdge* SMDS_Mesh::AddEdgeWithID(const SMDS_MeshNode * n1,
3605 const SMDS_MeshNode * n2,
3606 const SMDS_MeshNode * n12,
3609 if ( !n1 || !n2 || !n12 ) return 0;
3611 // --- retrieve nodes ID
3612 myNodeIds.resize(3);
3613 myNodeIds[0] = n1->getVtkId();
3614 myNodeIds[1] = n2->getVtkId();
3615 myNodeIds[2] = n12->getVtkId();
3617 SMDS_MeshEdge * edge = 0;
3618 SMDS_VtkEdge *edgevtk = myEdgePool->getNew();
3619 edgevtk->init(myNodeIds, this);
3620 if (!this->registerElement(ID,edgevtk))
3622 this->myGrid->GetCellTypesArray()->SetValue(edgevtk->getVtkId(), VTK_EMPTY_CELL);
3623 myEdgePool->destroy(edgevtk);
3627 adjustmyCellsCapacity(ID);
3629 myInfo.myNbQuadEdges++;
3631 // if (!registerElement(ID, edge)) {
3632 // RemoveElement(edge, false);
3640 //=======================================================================
3641 //function : AddFace
3643 //=======================================================================
3644 SMDS_MeshFace* SMDS_Mesh::AddFace(const SMDS_MeshNode * n1,
3645 const SMDS_MeshNode * n2,
3646 const SMDS_MeshNode * n3,
3647 const SMDS_MeshNode * n12,
3648 const SMDS_MeshNode * n23,
3649 const SMDS_MeshNode * n31)
3651 return SMDS_Mesh::AddFaceWithID(n1,n2,n3,n12,n23,n31,
3652 myElementIDFactory->GetFreeID());
3655 //=======================================================================
3656 //function : AddFaceWithID
3658 //=======================================================================
3659 SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(int n1, int n2, int n3,
3660 int n12,int n23,int n31, int ID)
3662 return SMDS_Mesh::AddFaceWithID
3663 ((SMDS_MeshNode *)myNodeIDFactory->MeshElement(n1) ,
3664 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n2) ,
3665 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n3) ,
3666 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n12),
3667 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n23),
3668 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n31),
3672 //=======================================================================
3673 //function : AddFaceWithID
3675 //=======================================================================
3676 SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
3677 const SMDS_MeshNode * n2,
3678 const SMDS_MeshNode * n3,
3679 const SMDS_MeshNode * n12,
3680 const SMDS_MeshNode * n23,
3681 const SMDS_MeshNode * n31,
3684 if ( !n1 || !n2 || !n3 || !n12 || !n23 || !n31) return 0;
3685 if(hasConstructionEdges()) {
3686 // creation quadratic edges - not implemented
3691 // --- retrieve nodes ID
3692 myNodeIds.resize(6);
3693 myNodeIds[0] = n1->getVtkId();
3694 myNodeIds[1] = n2->getVtkId();
3695 myNodeIds[2] = n3->getVtkId();
3696 myNodeIds[3] = n12->getVtkId();
3697 myNodeIds[4] = n23->getVtkId();
3698 myNodeIds[5] = n31->getVtkId();
3700 SMDS_MeshFace * face = 0;
3701 SMDS_VtkFace *facevtk = myFacePool->getNew();
3702 facevtk->init(myNodeIds, this);
3703 if (!this->registerElement(ID,facevtk))
3705 this->myGrid->GetCellTypesArray()->SetValue(facevtk->getVtkId(), VTK_EMPTY_CELL);
3706 myFacePool->destroy(facevtk);
3710 adjustmyCellsCapacity(ID);
3712 myInfo.myNbQuadTriangles++;
3714 // if (!registerElement(ID, face)) {
3715 // RemoveElement(face, false);
3723 //=======================================================================
3724 //function : AddFace
3726 //=======================================================================
3727 SMDS_MeshFace* SMDS_Mesh::AddFace(const SMDS_MeshNode * n1,
3728 const SMDS_MeshNode * n2,
3729 const SMDS_MeshNode * n3,
3730 const SMDS_MeshNode * n12,
3731 const SMDS_MeshNode * n23,
3732 const SMDS_MeshNode * n31,
3733 const SMDS_MeshNode * nCenter)
3735 return SMDS_Mesh::AddFaceWithID(n1,n2,n3,n12,n23,n31,nCenter,
3736 myElementIDFactory->GetFreeID());
3739 //=======================================================================
3740 //function : AddFaceWithID
3742 //=======================================================================
3743 SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(int n1, int n2, int n3,
3744 int n12,int n23,int n31, int nCenter, int ID)
3746 return SMDS_Mesh::AddFaceWithID
3747 ((SMDS_MeshNode *)myNodeIDFactory->MeshElement(n1) ,
3748 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n2) ,
3749 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n3) ,
3750 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n12),
3751 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n23),
3752 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n31),
3753 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(nCenter),
3757 //=======================================================================
3758 //function : AddFaceWithID
3760 //=======================================================================
3761 SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
3762 const SMDS_MeshNode * n2,
3763 const SMDS_MeshNode * n3,
3764 const SMDS_MeshNode * n12,
3765 const SMDS_MeshNode * n23,
3766 const SMDS_MeshNode * n31,
3767 const SMDS_MeshNode * nCenter,
3770 if ( !n1 || !n2 || !n3 || !n12 || !n23 || !n31 || !nCenter) return 0;
3771 if(hasConstructionEdges()) {
3772 // creation quadratic edges - not implemented
3777 // --- retrieve nodes ID
3778 myNodeIds.resize(7);
3779 myNodeIds[0] = n1->getVtkId();
3780 myNodeIds[1] = n2->getVtkId();
3781 myNodeIds[2] = n3->getVtkId();
3782 myNodeIds[3] = n12->getVtkId();
3783 myNodeIds[4] = n23->getVtkId();
3784 myNodeIds[5] = n31->getVtkId();
3785 myNodeIds[6] = nCenter->getVtkId();
3787 SMDS_MeshFace * face = 0;
3788 SMDS_VtkFace *facevtk = myFacePool->getNew();
3789 facevtk->init(myNodeIds, this);
3790 if (!this->registerElement(ID,facevtk))
3792 this->myGrid->GetCellTypesArray()->SetValue(facevtk->getVtkId(), VTK_EMPTY_CELL);
3793 myFacePool->destroy(facevtk);
3797 adjustmyCellsCapacity(ID);
3799 myInfo.myNbBiQuadTriangles++;
3801 // if (!registerElement(ID, face)) {
3802 // RemoveElement(face, false);
3810 //=======================================================================
3811 //function : AddFace
3813 //=======================================================================
3814 SMDS_MeshFace* SMDS_Mesh::AddFace(const SMDS_MeshNode * n1,
3815 const SMDS_MeshNode * n2,
3816 const SMDS_MeshNode * n3,
3817 const SMDS_MeshNode * n4,
3818 const SMDS_MeshNode * n12,
3819 const SMDS_MeshNode * n23,
3820 const SMDS_MeshNode * n34,
3821 const SMDS_MeshNode * n41)
3823 return SMDS_Mesh::AddFaceWithID(n1,n2,n3,n4,n12,n23,n34,n41,
3824 myElementIDFactory->GetFreeID());
3827 //=======================================================================
3828 //function : AddFaceWithID
3830 //=======================================================================
3831 SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(int n1, int n2, int n3, int n4,
3832 int n12,int n23,int n34,int n41, int ID)
3834 return SMDS_Mesh::AddFaceWithID
3835 ((SMDS_MeshNode *)myNodeIDFactory->MeshElement(n1) ,
3836 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n2) ,
3837 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n3) ,
3838 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n4) ,
3839 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n12),
3840 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n23),
3841 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n34),
3842 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n41),
3846 //=======================================================================
3847 //function : AddFaceWithID
3849 //=======================================================================
3850 SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
3851 const SMDS_MeshNode * n2,
3852 const SMDS_MeshNode * n3,
3853 const SMDS_MeshNode * n4,
3854 const SMDS_MeshNode * n12,
3855 const SMDS_MeshNode * n23,
3856 const SMDS_MeshNode * n34,
3857 const SMDS_MeshNode * n41,
3860 if ( !n1 || !n2 || !n3 || !n4 || !n12 || !n23 || !n34 || !n41) return 0;
3861 if(hasConstructionEdges()) {
3862 // creation quadratic edges - not implemented
3867 // --- retrieve nodes ID
3868 myNodeIds.resize(8);
3869 myNodeIds[0] = n1->getVtkId();
3870 myNodeIds[1] = n2->getVtkId();
3871 myNodeIds[2] = n3->getVtkId();
3872 myNodeIds[3] = n4->getVtkId();
3873 myNodeIds[4] = n12->getVtkId();
3874 myNodeIds[5] = n23->getVtkId();
3875 myNodeIds[6] = n34->getVtkId();
3876 myNodeIds[7] = n41->getVtkId();
3878 SMDS_MeshFace * face = 0;
3879 SMDS_VtkFace *facevtk = myFacePool->getNew();
3880 facevtk->init(myNodeIds, this);
3881 if (!this->registerElement(ID,facevtk))
3883 this->myGrid->GetCellTypesArray()->SetValue(facevtk->getVtkId(), VTK_EMPTY_CELL);
3884 myFacePool->destroy(facevtk);
3888 adjustmyCellsCapacity(ID);
3890 myInfo.myNbQuadQuadrangles++;
3892 // if (!registerElement(ID, face)) {
3893 // RemoveElement(face, false);
3900 //=======================================================================
3901 //function : AddFace
3903 //=======================================================================
3904 SMDS_MeshFace* SMDS_Mesh::AddFace(const SMDS_MeshNode * n1,
3905 const SMDS_MeshNode * n2,
3906 const SMDS_MeshNode * n3,
3907 const SMDS_MeshNode * n4,
3908 const SMDS_MeshNode * n12,
3909 const SMDS_MeshNode * n23,
3910 const SMDS_MeshNode * n34,
3911 const SMDS_MeshNode * n41,
3912 const SMDS_MeshNode * nCenter)
3914 return SMDS_Mesh::AddFaceWithID(n1,n2,n3,n4,n12,n23,n34,n41,nCenter,
3915 myElementIDFactory->GetFreeID());
3918 //=======================================================================
3919 //function : AddFaceWithID
3921 //=======================================================================
3922 SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(int n1, int n2, int n3, int n4,
3923 int n12,int n23,int n34,int n41, int nCenter, int ID)
3925 return SMDS_Mesh::AddFaceWithID
3926 ((SMDS_MeshNode *)myNodeIDFactory->MeshElement(n1) ,
3927 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n2) ,
3928 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n3) ,
3929 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n4) ,
3930 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n12),
3931 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n23),
3932 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n34),
3933 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n41),
3934 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(nCenter),
3938 //=======================================================================
3939 //function : AddFaceWithID
3941 //=======================================================================
3942 SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
3943 const SMDS_MeshNode * n2,
3944 const SMDS_MeshNode * n3,
3945 const SMDS_MeshNode * n4,
3946 const SMDS_MeshNode * n12,
3947 const SMDS_MeshNode * n23,
3948 const SMDS_MeshNode * n34,
3949 const SMDS_MeshNode * n41,
3950 const SMDS_MeshNode * nCenter,
3953 if ( !n1 || !n2 || !n3 || !n4 || !n12 || !n23 || !n34 || !n41 || !nCenter) return 0;
3954 if(hasConstructionEdges()) {
3955 // creation quadratic edges - not implemented
3960 // --- retrieve nodes ID
3961 myNodeIds.resize(9);
3962 myNodeIds[0] = n1->getVtkId();
3963 myNodeIds[1] = n2->getVtkId();
3964 myNodeIds[2] = n3->getVtkId();
3965 myNodeIds[3] = n4->getVtkId();
3966 myNodeIds[4] = n12->getVtkId();
3967 myNodeIds[5] = n23->getVtkId();
3968 myNodeIds[6] = n34->getVtkId();
3969 myNodeIds[7] = n41->getVtkId();
3970 myNodeIds[8] = nCenter->getVtkId();
3972 SMDS_MeshFace * face = 0;
3973 SMDS_VtkFace *facevtk = myFacePool->getNew();
3974 facevtk->init(myNodeIds, this);
3975 if (!this->registerElement(ID,facevtk))
3977 this->myGrid->GetCellTypesArray()->SetValue(facevtk->getVtkId(), VTK_EMPTY_CELL);
3978 myFacePool->destroy(facevtk);
3982 adjustmyCellsCapacity(ID);
3984 myInfo.myNbBiQuadQuadrangles++;
3986 // if (!registerElement(ID, face)) {
3987 // RemoveElement(face, false);
3995 //=======================================================================
3996 //function : AddVolume
3998 //=======================================================================
3999 SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
4000 const SMDS_MeshNode * n2,
4001 const SMDS_MeshNode * n3,
4002 const SMDS_MeshNode * n4,
4003 const SMDS_MeshNode * n12,
4004 const SMDS_MeshNode * n23,
4005 const SMDS_MeshNode * n31,
4006 const SMDS_MeshNode * n14,
4007 const SMDS_MeshNode * n24,
4008 const SMDS_MeshNode * n34)
4010 int ID = myElementIDFactory->GetFreeID();
4011 SMDS_MeshVolume * v = SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n12, n23,
4012 n31, n14, n24, n34, ID);
4013 if(v==NULL) myElementIDFactory->ReleaseID(ID);
4017 //=======================================================================
4018 //function : AddVolumeWithID
4020 //=======================================================================
4021 SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4,
4022 int n12,int n23,int n31,
4023 int n14,int n24,int n34, int ID)
4025 return SMDS_Mesh::AddVolumeWithID
4026 ((SMDS_MeshNode*) myNodeIDFactory->MeshElement(n1) ,
4027 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n2) ,
4028 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n3) ,
4029 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n4) ,
4030 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n12),
4031 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n23),
4032 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n31),
4033 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n14),
4034 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n24),
4035 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n34),
4039 //=======================================================================
4040 //function : AddVolumeWithID
4041 //purpose : 2d order tetrahedron of 10 nodes
4042 //=======================================================================
4043 SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
4044 const SMDS_MeshNode * n2,
4045 const SMDS_MeshNode * n3,
4046 const SMDS_MeshNode * n4,
4047 const SMDS_MeshNode * n12,
4048 const SMDS_MeshNode * n23,
4049 const SMDS_MeshNode * n31,
4050 const SMDS_MeshNode * n14,
4051 const SMDS_MeshNode * n24,
4052 const SMDS_MeshNode * n34,
4055 if ( !n1 || !n2 || !n3 || !n4 || !n12 || !n23 || !n31 || !n14 || !n24 || !n34)
4057 if(hasConstructionFaces()) {
4058 // creation quadratic faces - not implemented
4061 // --- retrieve nodes ID
4062 myNodeIds.resize(10);
4063 myNodeIds[0] = n1->getVtkId();
4064 myNodeIds[1] = n3->getVtkId();
4065 myNodeIds[2] = n2->getVtkId();
4066 myNodeIds[3] = n4->getVtkId();
4068 myNodeIds[4] = n31->getVtkId();
4069 myNodeIds[5] = n23->getVtkId();
4070 myNodeIds[6] = n12->getVtkId();
4072 myNodeIds[7] = n14->getVtkId();
4073 myNodeIds[8] = n34->getVtkId();
4074 myNodeIds[9] = n24->getVtkId();
4076 SMDS_VtkVolume *volvtk = myVolumePool->getNew();
4077 volvtk->init(myNodeIds, this);
4078 if (!this->registerElement(ID,volvtk))
4080 this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL);
4081 myVolumePool->destroy(volvtk);
4084 adjustmyCellsCapacity(ID);
4085 myCells[ID] = volvtk;
4086 myInfo.myNbQuadTetras++;
4088 // if (!registerElement(ID, volvtk)) {
4089 // RemoveElement(volvtk, false);
4096 //=======================================================================
4097 //function : AddVolume
4099 //=======================================================================
4100 SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
4101 const SMDS_MeshNode * n2,
4102 const SMDS_MeshNode * n3,
4103 const SMDS_MeshNode * n4,
4104 const SMDS_MeshNode * n5,
4105 const SMDS_MeshNode * n12,
4106 const SMDS_MeshNode * n23,
4107 const SMDS_MeshNode * n34,
4108 const SMDS_MeshNode * n41,
4109 const SMDS_MeshNode * n15,
4110 const SMDS_MeshNode * n25,
4111 const SMDS_MeshNode * n35,
4112 const SMDS_MeshNode * n45)
4114 int ID = myElementIDFactory->GetFreeID();
4115 SMDS_MeshVolume * v =
4116 SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, n12, n23, n34, n41,
4117 n15, n25, n35, n45, ID);
4118 if(v==NULL) myElementIDFactory->ReleaseID(ID);
4122 //=======================================================================
4123 //function : AddVolumeWithID
4125 //=======================================================================
4126 SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4, int n5,
4127 int n12,int n23,int n34,int n41,
4128 int n15,int n25,int n35,int n45, int ID)
4130 return SMDS_Mesh::AddVolumeWithID
4131 ((SMDS_MeshNode*) myNodeIDFactory->MeshElement(n1) ,
4132 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n2) ,
4133 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n3) ,
4134 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n4) ,
4135 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n5) ,
4136 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n12),
4137 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n23),
4138 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n34),
4139 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n41),
4140 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n15),
4141 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n25),
4142 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n35),
4143 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n45),
4147 //=======================================================================
4148 //function : AddVolumeWithID
4149 //purpose : 2d order pyramid of 13 nodes
4150 //=======================================================================
4151 SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
4152 const SMDS_MeshNode * n2,
4153 const SMDS_MeshNode * n3,
4154 const SMDS_MeshNode * n4,
4155 const SMDS_MeshNode * n5,
4156 const SMDS_MeshNode * n12,
4157 const SMDS_MeshNode * n23,
4158 const SMDS_MeshNode * n34,
4159 const SMDS_MeshNode * n41,
4160 const SMDS_MeshNode * n15,
4161 const SMDS_MeshNode * n25,
4162 const SMDS_MeshNode * n35,
4163 const SMDS_MeshNode * n45,
4166 if (!n1 || !n2 || !n3 || !n4 || !n5 || !n12 || !n23 ||
4167 !n34 || !n41 || !n15 || !n25 || !n35 || !n45)
4169 if(hasConstructionFaces()) {
4170 // creation quadratic faces - not implemented
4173 // --- retrieve nodes ID
4174 myNodeIds.resize(13);
4175 myNodeIds[0] = n1->getVtkId();
4176 myNodeIds[1] = n4->getVtkId();
4177 myNodeIds[2] = n3->getVtkId();
4178 myNodeIds[3] = n2->getVtkId();
4179 myNodeIds[4] = n5->getVtkId();
4181 myNodeIds[5] = n41->getVtkId();
4182 myNodeIds[6] = n34->getVtkId();
4183 myNodeIds[7] = n23->getVtkId();
4184 myNodeIds[8] = n12->getVtkId();
4186 myNodeIds[9] = n15->getVtkId();
4187 myNodeIds[10] = n45->getVtkId();
4188 myNodeIds[11] = n35->getVtkId();
4189 myNodeIds[12] = n25->getVtkId();
4191 SMDS_VtkVolume *volvtk = myVolumePool->getNew();
4192 volvtk->init(myNodeIds, this);
4193 if (!this->registerElement(ID,volvtk))
4195 this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL);
4196 myVolumePool->destroy(volvtk);
4199 adjustmyCellsCapacity(ID);
4200 myCells[ID] = volvtk;
4201 myInfo.myNbQuadPyramids++;
4203 // if (!registerElement(ID, volvtk)) {
4204 // RemoveElement(volvtk, false);
4211 //=======================================================================
4212 //function : AddVolume
4214 //=======================================================================
4215 SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
4216 const SMDS_MeshNode * n2,
4217 const SMDS_MeshNode * n3,
4218 const SMDS_MeshNode * n4,
4219 const SMDS_MeshNode * n5,
4220 const SMDS_MeshNode * n6,
4221 const SMDS_MeshNode * n12,
4222 const SMDS_MeshNode * n23,
4223 const SMDS_MeshNode * n31,
4224 const SMDS_MeshNode * n45,
4225 const SMDS_MeshNode * n56,
4226 const SMDS_MeshNode * n64,
4227 const SMDS_MeshNode * n14,
4228 const SMDS_MeshNode * n25,
4229 const SMDS_MeshNode * n36)
4231 int ID = myElementIDFactory->GetFreeID();
4232 SMDS_MeshVolume * v =
4233 SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, n6, n12, n23, n31,
4234 n45, n56, n64, n14, n25, n36, ID);
4235 if(v==NULL) myElementIDFactory->ReleaseID(ID);
4239 //=======================================================================
4240 //function : AddVolumeWithID
4242 //=======================================================================
4243 SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(int n1, int n2, int n3,
4244 int n4, int n5, int n6,
4245 int n12,int n23,int n31,
4246 int n45,int n56,int n64,
4247 int n14,int n25,int n36, int ID)
4249 return SMDS_Mesh::AddVolumeWithID
4250 ((SMDS_MeshNode*) myNodeIDFactory->MeshElement(n1) ,
4251 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n2) ,
4252 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n3) ,
4253 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n4) ,
4254 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n5) ,
4255 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n6) ,
4256 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n12),
4257 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n23),
4258 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n31),
4259 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n45),
4260 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n56),
4261 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n64),
4262 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n14),
4263 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n25),
4264 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n36),
4268 //=======================================================================
4269 //function : AddVolumeWithID
4270 //purpose : 2d order Pentahedron with 15 nodes
4271 //=======================================================================
4272 SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
4273 const SMDS_MeshNode * n2,
4274 const SMDS_MeshNode * n3,
4275 const SMDS_MeshNode * n4,
4276 const SMDS_MeshNode * n5,
4277 const SMDS_MeshNode * n6,
4278 const SMDS_MeshNode * n12,
4279 const SMDS_MeshNode * n23,
4280 const SMDS_MeshNode * n31,
4281 const SMDS_MeshNode * n45,
4282 const SMDS_MeshNode * n56,
4283 const SMDS_MeshNode * n64,
4284 const SMDS_MeshNode * n14,
4285 const SMDS_MeshNode * n25,
4286 const SMDS_MeshNode * n36,
4289 if (!n1 || !n2 || !n3 || !n4 || !n5 || !n6 || !n12 || !n23 ||
4290 !n31 || !n45 || !n56 || !n64 || !n14 || !n25 || !n36)
4292 if(hasConstructionFaces()) {
4293 // creation quadratic faces - not implemented
4296 // --- retrieve nodes ID
4297 myNodeIds.resize(15);
4298 myNodeIds[0] = n1->getVtkId();
4299 myNodeIds[1] = n2->getVtkId();
4300 myNodeIds[2] = n3->getVtkId();
4302 myNodeIds[3] = n4->getVtkId();
4303 myNodeIds[4] = n5->getVtkId();
4304 myNodeIds[5] = n6->getVtkId();
4306 myNodeIds[6] = n12->getVtkId();
4307 myNodeIds[7] = n23->getVtkId();
4308 myNodeIds[8] = n31->getVtkId();
4310 myNodeIds[9] = n45->getVtkId();
4311 myNodeIds[10] = n56->getVtkId();
4312 myNodeIds[11] = n64->getVtkId();
4314 myNodeIds[12] = n14->getVtkId();
4315 myNodeIds[13] = n25->getVtkId();
4316 myNodeIds[14] = n36->getVtkId();
4318 SMDS_VtkVolume *volvtk = myVolumePool->getNew();
4319 volvtk->init(myNodeIds, this);
4320 if (!this->registerElement(ID,volvtk))
4322 this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL);
4323 myVolumePool->destroy(volvtk);
4326 adjustmyCellsCapacity(ID);
4327 myCells[ID] = volvtk;
4328 myInfo.myNbQuadPrisms++;
4330 // if (!registerElement(ID, volvtk)) {
4331 // RemoveElement(volvtk, false);
4338 //=======================================================================
4339 //function : AddVolume
4341 //=======================================================================
4342 SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
4343 const SMDS_MeshNode * n2,
4344 const SMDS_MeshNode * n3,
4345 const SMDS_MeshNode * n4,
4346 const SMDS_MeshNode * n5,
4347 const SMDS_MeshNode * n6,
4348 const SMDS_MeshNode * n7,
4349 const SMDS_MeshNode * n8,
4350 const SMDS_MeshNode * n12,
4351 const SMDS_MeshNode * n23,
4352 const SMDS_MeshNode * n34,
4353 const SMDS_MeshNode * n41,
4354 const SMDS_MeshNode * n56,
4355 const SMDS_MeshNode * n67,
4356 const SMDS_MeshNode * n78,
4357 const SMDS_MeshNode * n85,
4358 const SMDS_MeshNode * n15,
4359 const SMDS_MeshNode * n26,
4360 const SMDS_MeshNode * n37,
4361 const SMDS_MeshNode * n48)
4363 int ID = myElementIDFactory->GetFreeID();
4364 SMDS_MeshVolume * v =
4365 SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, n6, n7, n8, n12, n23, n34, n41,
4366 n56, n67, n78, n85, n15, n26, n37, n48, ID);
4367 if(v==NULL) myElementIDFactory->ReleaseID(ID);
4371 //=======================================================================
4372 //function : AddVolumeWithID
4374 //=======================================================================
4375 SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4,
4376 int n5, int n6, int n7, int n8,
4377 int n12,int n23,int n34,int n41,
4378 int n56,int n67,int n78,int n85,
4379 int n15,int n26,int n37,int n48, int ID)
4381 return SMDS_Mesh::AddVolumeWithID
4382 ((SMDS_MeshNode*) myNodeIDFactory->MeshElement(n1),
4383 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n2),
4384 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n3),
4385 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n4),
4386 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n5),
4387 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n6),
4388 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n7),
4389 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n8),
4390 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n12),
4391 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n23),
4392 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n34),
4393 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n41),
4394 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n56),
4395 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n67),
4396 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n78),
4397 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n85),
4398 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n15),
4399 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n26),
4400 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n37),
4401 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n48),
4405 //=======================================================================
4406 //function : AddVolumeWithID
4407 //purpose : 2d order Hexahedrons with 20 nodes
4408 //=======================================================================
4409 SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
4410 const SMDS_MeshNode * n2,
4411 const SMDS_MeshNode * n3,
4412 const SMDS_MeshNode * n4,
4413 const SMDS_MeshNode * n5,
4414 const SMDS_MeshNode * n6,
4415 const SMDS_MeshNode * n7,
4416 const SMDS_MeshNode * n8,
4417 const SMDS_MeshNode * n12,
4418 const SMDS_MeshNode * n23,
4419 const SMDS_MeshNode * n34,
4420 const SMDS_MeshNode * n41,
4421 const SMDS_MeshNode * n56,
4422 const SMDS_MeshNode * n67,
4423 const SMDS_MeshNode * n78,
4424 const SMDS_MeshNode * n85,
4425 const SMDS_MeshNode * n15,
4426 const SMDS_MeshNode * n26,
4427 const SMDS_MeshNode * n37,
4428 const SMDS_MeshNode * n48,
4431 if (!n1 || !n2 || !n3 || !n4 || !n5 || !n6 || !n7 || !n8 || !n12 || !n23 ||
4432 !n34 || !n41 || !n56 || !n67 || !n78 || !n85 || !n15 || !n26 || !n37 || !n48)
4434 if(hasConstructionFaces()) {
4436 // creation quadratic faces - not implemented
4438 // --- retrieve nodes ID
4439 myNodeIds.resize(20);
4440 myNodeIds[0] = n1->getVtkId();
4441 myNodeIds[1] = n4->getVtkId();
4442 myNodeIds[2] = n3->getVtkId();
4443 myNodeIds[3] = n2->getVtkId();
4445 myNodeIds[4] = n5->getVtkId();
4446 myNodeIds[5] = n8->getVtkId();
4447 myNodeIds[6] = n7->getVtkId();
4448 myNodeIds[7] = n6->getVtkId();
4450 myNodeIds[8] = n41->getVtkId();
4451 myNodeIds[9] = n34->getVtkId();
4452 myNodeIds[10] = n23->getVtkId();
4453 myNodeIds[11] = n12->getVtkId();
4455 myNodeIds[12] = n85->getVtkId();
4456 myNodeIds[13] = n78->getVtkId();
4457 myNodeIds[14] = n67->getVtkId();
4458 myNodeIds[15] = n56->getVtkId();
4460 myNodeIds[16] = n15->getVtkId();
4461 myNodeIds[17] = n48->getVtkId();
4462 myNodeIds[18] = n37->getVtkId();
4463 myNodeIds[19] = n26->getVtkId();
4465 SMDS_VtkVolume *volvtk = myVolumePool->getNew();
4466 volvtk->init(myNodeIds, this);
4467 if (!this->registerElement(ID,volvtk))
4469 this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL);
4470 myVolumePool->destroy(volvtk);
4473 adjustmyCellsCapacity(ID);
4474 myCells[ID] = volvtk;
4475 myInfo.myNbQuadHexas++;
4477 // if (!registerElement(ID, volvtk)) {
4478 // RemoveElement(volvtk, false);
4484 //=======================================================================
4485 //function : AddVolume
4487 //=======================================================================
4488 SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
4489 const SMDS_MeshNode * n2,
4490 const SMDS_MeshNode * n3,
4491 const SMDS_MeshNode * n4,
4492 const SMDS_MeshNode * n5,
4493 const SMDS_MeshNode * n6,
4494 const SMDS_MeshNode * n7,
4495 const SMDS_MeshNode * n8,
4496 const SMDS_MeshNode * n12,
4497 const SMDS_MeshNode * n23,
4498 const SMDS_MeshNode * n34,
4499 const SMDS_MeshNode * n41,
4500 const SMDS_MeshNode * n56,
4501 const SMDS_MeshNode * n67,
4502 const SMDS_MeshNode * n78,
4503 const SMDS_MeshNode * n85,
4504 const SMDS_MeshNode * n15,
4505 const SMDS_MeshNode * n26,
4506 const SMDS_MeshNode * n37,
4507 const SMDS_MeshNode * n48,
4508 const SMDS_MeshNode * n1234,
4509 const SMDS_MeshNode * n1256,
4510 const SMDS_MeshNode * n2367,
4511 const SMDS_MeshNode * n3478,
4512 const SMDS_MeshNode * n1458,
4513 const SMDS_MeshNode * n5678,
4514 const SMDS_MeshNode * nCenter)
4516 int ID = myElementIDFactory->GetFreeID();
4517 SMDS_MeshVolume * v =
4518 SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, n6, n7, n8, n12, n23, n34, n41,
4519 n56, n67, n78, n85, n15, n26, n37, n48,
4520 n1234, n1256, n2367, n3478, n1458, n5678, nCenter,
4522 if(v==NULL) myElementIDFactory->ReleaseID(ID);
4526 //=======================================================================
4527 //function : AddVolumeWithID
4529 //=======================================================================
4530 SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4,
4531 int n5, int n6, int n7, int n8,
4532 int n12,int n23,int n34,int n41,
4533 int n56,int n67,int n78,int n85,
4534 int n15,int n26,int n37,int n48,
4535 int n1234,int n1256,int n2367,int n3478,
4536 int n1458,int n5678,int nCenter, int ID)
4538 return SMDS_Mesh::AddVolumeWithID
4539 ((SMDS_MeshNode*) myNodeIDFactory->MeshElement(n1),
4540 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n2),
4541 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n3),
4542 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n4),
4543 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n5),
4544 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n6),
4545 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n7),
4546 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n8),
4547 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n12),
4548 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n23),
4549 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n34),
4550 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n41),
4551 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n56),
4552 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n67),
4553 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n78),
4554 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n85),
4555 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n15),
4556 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n26),
4557 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n37),
4558 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n48),
4559 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n1234),
4560 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n1256),
4561 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n2367),
4562 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n3478),
4563 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n1458),
4564 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n5678),
4565 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(nCenter),
4569 //=======================================================================
4570 //function : AddVolumeWithID
4571 //purpose : 2d order Hexahedrons with 20 nodes
4572 //=======================================================================
4573 SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
4574 const SMDS_MeshNode * n2,
4575 const SMDS_MeshNode * n3,
4576 const SMDS_MeshNode * n4,
4577 const SMDS_MeshNode * n5,
4578 const SMDS_MeshNode * n6,
4579 const SMDS_MeshNode * n7,
4580 const SMDS_MeshNode * n8,
4581 const SMDS_MeshNode * n12,
4582 const SMDS_MeshNode * n23,
4583 const SMDS_MeshNode * n34,
4584 const SMDS_MeshNode * n41,
4585 const SMDS_MeshNode * n56,
4586 const SMDS_MeshNode * n67,
4587 const SMDS_MeshNode * n78,
4588 const SMDS_MeshNode * n85,
4589 const SMDS_MeshNode * n15,
4590 const SMDS_MeshNode * n26,
4591 const SMDS_MeshNode * n37,
4592 const SMDS_MeshNode * n48,
4593 const SMDS_MeshNode * n1234,
4594 const SMDS_MeshNode * n1256,
4595 const SMDS_MeshNode * n2367,
4596 const SMDS_MeshNode * n3478,
4597 const SMDS_MeshNode * n1458,
4598 const SMDS_MeshNode * n5678,
4599 const SMDS_MeshNode * nCenter,
4602 if (!n1 || !n2 || !n3 || !n4 || !n5 || !n6 || !n7 || !n8 || !n12 || !n23 ||
4603 !n34 || !n41 || !n56 || !n67 || !n78 || !n85 || !n15 || !n26 || !n37 || !n48 ||
4604 !n1234 || !n1256 || !n2367 || !n3478 || !n1458 || !n5678 || !nCenter )
4606 if(hasConstructionFaces()) {
4608 // creation quadratic faces - not implemented
4610 // --- retrieve nodes ID
4611 myNodeIds.resize(27);
4612 myNodeIds[0] = n1->getVtkId();
4613 myNodeIds[1] = n4->getVtkId();
4614 myNodeIds[2] = n3->getVtkId();
4615 myNodeIds[3] = n2->getVtkId();
4617 myNodeIds[4] = n5->getVtkId();
4618 myNodeIds[5] = n8->getVtkId();
4619 myNodeIds[6] = n7->getVtkId();
4620 myNodeIds[7] = n6->getVtkId();
4622 myNodeIds[8] = n41->getVtkId();
4623 myNodeIds[9] = n34->getVtkId();
4624 myNodeIds[10] = n23->getVtkId();
4625 myNodeIds[11] = n12->getVtkId();
4627 myNodeIds[12] = n85->getVtkId();
4628 myNodeIds[13] = n78->getVtkId();
4629 myNodeIds[14] = n67->getVtkId();
4630 myNodeIds[15] = n56->getVtkId();
4632 myNodeIds[16] = n15->getVtkId();
4633 myNodeIds[17] = n48->getVtkId();
4634 myNodeIds[18] = n37->getVtkId();
4635 myNodeIds[19] = n26->getVtkId();
4637 myNodeIds[20] = n1256->getVtkId();
4638 myNodeIds[21] = n3478->getVtkId();
4639 myNodeIds[22] = n1458->getVtkId();
4640 myNodeIds[23] = n2367->getVtkId();
4641 myNodeIds[24] = n1234->getVtkId();
4642 myNodeIds[25] = n5678->getVtkId();
4643 myNodeIds[26] = nCenter->getVtkId();
4645 SMDS_VtkVolume *volvtk = myVolumePool->getNew();
4646 volvtk->init(myNodeIds, this);
4647 if (!this->registerElement(ID,volvtk))
4649 this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL);
4650 myVolumePool->destroy(volvtk);
4653 adjustmyCellsCapacity(ID);
4654 myCells[ID] = volvtk;
4655 myInfo.myNbTriQuadHexas++;
4660 void SMDS_Mesh::dumpGrid(string ficdump)
4662 // vtkUnstructuredGridWriter* aWriter = vtkUnstructuredGridWriter::New();
4663 // aWriter->SetFileName(ficdump.c_str());
4664 // aWriter->SetInput(myGrid);
4665 // if(myGrid->GetNumberOfCells())
4667 // aWriter->Write();
4669 // aWriter->Delete();
4670 ficdump = ficdump + "_connectivity";
4671 ofstream ficcon(ficdump.c_str(), ios::out);
4672 int nbPoints = myGrid->GetNumberOfPoints();
4673 ficcon << "-------------------------------- points " << nbPoints << endl;
4674 for (int i=0; i<nbPoints; i++)
4676 ficcon << i << " " << *(myGrid->GetPoint(i)) << " " << *(myGrid->GetPoint(i)+1) << " " << " " << *(myGrid->GetPoint(i)+2) << endl;
4678 int nbCells = myGrid->GetNumberOfCells();
4679 ficcon << "-------------------------------- cells " << nbCells << endl;
4680 for (int i=0; i<nbCells; i++)
4682 ficcon << i << " - " << myGrid->GetCell(i)->GetCellType() << " -";
4683 int nbptcell = myGrid->GetCell(i)->GetNumberOfPoints();
4684 vtkIdList *listid = myGrid->GetCell(i)->GetPointIds();
4685 for (int j=0; j<nbptcell; j++)
4687 ficcon << " " << listid->GetId(j);
4691 ficcon << "-------------------------------- connectivity " << nbPoints << endl;
4692 vtkCellLinks *links = myGrid->GetLinks();
4693 for (int i=0; i<nbPoints; i++)
4695 int ncells = links->GetNcells(i);
4696 vtkIdType *cells = links->GetCells(i);
4697 ficcon << i << " - " << ncells << " -";
4698 for (int j=0; j<ncells; j++)
4700 ficcon << " " << cells[j];
4708 void SMDS_Mesh::compactMesh()
4710 this->myCompactTime = this->myModifTime;
4713 int SMDS_Mesh::fromVtkToSmds(int vtkid)
4715 if (vtkid >= 0 && vtkid < (int)myCellIdVtkToSmds.size())
4716 return myCellIdVtkToSmds[vtkid];
4717 throw SALOME_Exception(LOCALIZED ("vtk id out of bounds"));
4720 // void SMDS_Mesh::updateBoundingBox()
4722 // xmin = 0; xmax = 0;
4723 // ymin = 0; ymax = 0;
4724 // zmin = 0; zmax = 0;
4725 // vtkPoints *points = myGrid->GetPoints();
4726 // int myNodesSize = this->myNodes.size();
4727 // for (int i = 0; i < myNodesSize; i++)
4729 // if (SMDS_MeshNode *n = myNodes[i])
4731 // double coords[3];
4732 // points->GetPoint(n->myVtkID, coords);
4733 // if (coords[0] < xmin) xmin = coords[0];
4734 // else if (coords[0] > xmax) xmax = coords[0];
4735 // if (coords[1] < ymin) ymin = coords[1];
4736 // else if (coords[1] > ymax) ymax = coords[1];
4737 // if (coords[2] < zmin) zmin = coords[2];
4738 // else if (coords[2] > zmax) zmax = coords[2];
4743 double SMDS_Mesh::getMaxDim()
4745 double dmax = 1.e-3;
4746 if ((xmax - xmin) > dmax) dmax = xmax -xmin;
4747 if ((ymax - ymin) > dmax) dmax = ymax -ymin;
4748 if ((zmax - zmin) > dmax) dmax = zmax -zmin;
4752 //! modification that needs compact structure and redraw
4753 void SMDS_Mesh::Modified()
4755 if (this->myModified)
4757 this->myModifTime++;
4762 //! get last modification timeStamp
4763 vtkMTimeType SMDS_Mesh::GetMTime() const
4765 return this->myModifTime;
4768 bool SMDS_Mesh::isCompacted()
4770 return this->myCompactTime == this->myModifTime;