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>
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)
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 // --- retreive 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 //=======================================================================
2462 //function : DumpNodes
2464 //=======================================================================
2466 void SMDS_Mesh::DumpNodes() const
2468 SMDS_NodeIteratorPtr itnode=nodesIterator();
2469 while(itnode->more()) ; //MESSAGE(itnode->next());
2472 //=======================================================================
2473 //function : Dump0DElements
2475 //=======================================================================
2476 void SMDS_Mesh::Dump0DElements() const
2478 SMDS_ElemIteratorPtr it0d = elementsIterator(SMDSAbs_0DElement);
2479 while(it0d->more()) ; //MESSAGE(it0d->next());
2482 //=======================================================================
2483 //function : DumpEdges
2485 //=======================================================================
2487 void SMDS_Mesh::DumpEdges() const
2489 SMDS_EdgeIteratorPtr itedge=edgesIterator();
2490 while(itedge->more()) ; //MESSAGE(itedge->next());
2493 //=======================================================================
2494 //function : DumpFaces
2496 //=======================================================================
2498 void SMDS_Mesh::DumpFaces() const
2500 SMDS_FaceIteratorPtr itface=facesIterator();
2501 while(itface->more()) ; //MESSAGE(itface->next());
2504 //=======================================================================
2505 //function : DumpVolumes
2507 //=======================================================================
2509 void SMDS_Mesh::DumpVolumes() const
2511 SMDS_VolumeIteratorPtr itvol=volumesIterator();
2512 while(itvol->more()) ; //MESSAGE(itvol->next());
2515 //=======================================================================
2516 //function : DebugStats
2518 //=======================================================================
2520 void SMDS_Mesh::DebugStats() const
2522 MESSAGE("Debug stats of mesh : ");
2524 MESSAGE("===== NODES ====="<<NbNodes());
2525 MESSAGE("===== 0DELEMS ====="<<Nb0DElements());
2526 MESSAGE("===== EDGES ====="<<NbEdges());
2527 MESSAGE("===== FACES ====="<<NbFaces());
2528 MESSAGE("===== VOLUMES ====="<<NbVolumes());
2530 MESSAGE("End Debug stats of mesh ");
2534 SMDS_NodeIteratorPtr itnode=nodesIterator();
2535 int sizeofnodes = 0;
2536 int sizeoffaces = 0;
2538 while(itnode->more())
2540 const SMDS_MeshNode *node = itnode->next();
2542 sizeofnodes += sizeof(*node);
2544 SMDS_ElemIteratorPtr it = node->GetInverseElementIterator();
2547 const SMDS_MeshElement *me = it->next();
2548 sizeofnodes += sizeof(me);
2552 SMDS_FaceIteratorPtr itface=facesIterator();
2553 while(itface->more())
2555 const SMDS_MeshElement *face = itface->next();
2556 sizeoffaces += sizeof(*face);
2559 MESSAGE("total size of node elements = " << sizeofnodes);;
2560 MESSAGE("total size of face elements = " << sizeoffaces);;
2565 ///////////////////////////////////////////////////////////////////////////////
2566 /// Return the number of nodes
2567 ///////////////////////////////////////////////////////////////////////////////
2568 int SMDS_Mesh::NbNodes() const
2570 return myInfo.NbNodes();
2573 ///////////////////////////////////////////////////////////////////////////////
2574 /// Return the number of 0D elements
2575 ///////////////////////////////////////////////////////////////////////////////
2576 int SMDS_Mesh::Nb0DElements() const
2578 return myInfo.Nb0DElements();
2581 ///////////////////////////////////////////////////////////////////////////////
2582 /// Return the number of 0D elements
2583 ///////////////////////////////////////////////////////////////////////////////
2584 int SMDS_Mesh::NbBalls() const
2586 return myInfo.NbBalls();
2589 ///////////////////////////////////////////////////////////////////////////////
2590 /// Return the number of edges (including construction edges)
2591 ///////////////////////////////////////////////////////////////////////////////
2592 int SMDS_Mesh::NbEdges() const
2594 return myInfo.NbEdges();
2597 ///////////////////////////////////////////////////////////////////////////////
2598 /// Return the number of faces (including construction faces)
2599 ///////////////////////////////////////////////////////////////////////////////
2600 int SMDS_Mesh::NbFaces() const
2602 return myInfo.NbFaces();
2605 ///////////////////////////////////////////////////////////////////////////////
2606 /// Return the number of volumes
2607 ///////////////////////////////////////////////////////////////////////////////
2608 int SMDS_Mesh::NbVolumes() const
2610 return myInfo.NbVolumes();
2613 ///////////////////////////////////////////////////////////////////////////////
2614 /// Return the number of child mesh of this mesh.
2615 /// Note that the tree structure of SMDS_Mesh is unused in SMESH
2616 ///////////////////////////////////////////////////////////////////////////////
2617 int SMDS_Mesh::NbSubMesh() const
2619 return myChildren.size();
2622 ///////////////////////////////////////////////////////////////////////////////
2623 /// Destroy the mesh and all its elements
2624 /// All pointer on elements owned by this mesh become illegals.
2625 ///////////////////////////////////////////////////////////////////////////////
2626 SMDS_Mesh::~SMDS_Mesh()
2628 list<SMDS_Mesh*>::iterator itc=myChildren.begin();
2629 while(itc!=myChildren.end())
2637 delete myNodeIDFactory;
2638 delete myElementIDFactory;
2642 SMDS_ElemIteratorPtr eIt = elementsIterator();
2643 while ( eIt->more() )
2645 const SMDS_MeshElement *elem = eIt->next();
2646 myElementIDFactory->ReleaseID(elem->GetID(), elem->getVtkId());
2648 SMDS_NodeIteratorPtr itn = nodesIterator();
2651 const SMDS_MeshNode *node = itn->next();
2652 ((SMDS_MeshNode*)node)->SetPosition(SMDS_SpacePosition::originSpacePosition());
2653 myNodeIDFactory->ReleaseID(node->GetID(), node->getVtkId());
2659 delete myVolumePool;
2665 //================================================================================
2667 * \brief Clear all data
2669 //================================================================================
2671 void SMDS_Mesh::Clear()
2675 SMDS_ElemIteratorPtr eIt = elementsIterator();
2676 while ( eIt->more() )
2678 const SMDS_MeshElement *elem = eIt->next();
2679 myElementIDFactory->ReleaseID(elem->GetID(), elem->getVtkId());
2681 SMDS_NodeIteratorPtr itn = nodesIterator();
2684 const SMDS_MeshNode *node = itn->next();
2685 myNodeIDFactory->ReleaseID(node->GetID(), node->getVtkId());
2690 myNodeIDFactory->Clear();
2691 myElementIDFactory->Clear();
2694 myVolumePool->clear();
2695 myFacePool->clear();
2696 myEdgePool->clear();
2697 myBallPool->clear();
2699 clearVector( myCells );
2700 clearVector( myCellIdVtkToSmds );
2702 SMDS_NodeIteratorPtr itn = nodesIterator();
2705 SMDS_MeshNode *node = (SMDS_MeshNode*)(itn->next());
2706 node->SetPosition(SMDS_SpacePosition::originSpacePosition());
2707 //myNodePool->destroy(node);
2709 myNodePool->clear();
2710 clearVector( myNodes );
2712 list<SMDS_Mesh*>::iterator itc=myChildren.begin();
2713 while(itc!=myChildren.end())
2724 myGrid->Initialize();
2726 vtkPoints* points = vtkPoints::New();
2727 // rnv: to fix bug "21125: EDF 1233 SMESH: Degrardation of precision in a test case for quadratic conversion"
2728 // using double type for storing coordinates of nodes instead float.
2729 points->SetDataType(VTK_DOUBLE);
2730 points->SetNumberOfPoints( 0 );
2731 myGrid->SetPoints( points );
2733 myGrid->DeleteLinks();
2736 ///////////////////////////////////////////////////////////////////////////////
2737 /// Return true if this mesh create faces with edges.
2738 /// A false returned value mean that faces are created with nodes. A concequence
2739 /// is, iteration on edges (SMDS_Element::edgesIterator) will be unavailable.
2740 ///////////////////////////////////////////////////////////////////////////////
2741 bool SMDS_Mesh::hasConstructionEdges()
2743 return myHasConstructionEdges;
2746 ///////////////////////////////////////////////////////////////////////////////
2747 /// Return true if this mesh create volumes with faces
2748 /// A false returned value mean that volumes are created with nodes or edges.
2749 /// (see hasConstructionEdges)
2750 /// A concequence is, iteration on faces (SMDS_Element::facesIterator) will be
2752 ///////////////////////////////////////////////////////////////////////////////
2753 bool SMDS_Mesh::hasConstructionFaces()
2755 return myHasConstructionFaces;
2758 ///////////////////////////////////////////////////////////////////////////////
2759 /// Return true if nodes are linked to the finit elements, they are belonging to.
2760 /// Currently, It always return true.
2761 ///////////////////////////////////////////////////////////////////////////////
2762 bool SMDS_Mesh::hasInverseElements()
2764 return myHasInverseElements;
2767 ///////////////////////////////////////////////////////////////////////////////
2768 /// Make this mesh creating construction edges (see hasConstructionEdges)
2769 /// @param b true to have construction edges, else false.
2770 ///////////////////////////////////////////////////////////////////////////////
2771 void SMDS_Mesh::setConstructionEdges(bool b)
2773 myHasConstructionEdges=b;
2776 ///////////////////////////////////////////////////////////////////////////////
2777 /// Make this mesh creating construction faces (see hasConstructionFaces)
2778 /// @param b true to have construction faces, else false.
2779 ///////////////////////////////////////////////////////////////////////////////
2780 void SMDS_Mesh::setConstructionFaces(bool b)
2782 myHasConstructionFaces=b;
2785 ///////////////////////////////////////////////////////////////////////////////
2786 /// Make this mesh creating link from nodes to elements (see hasInverseElements)
2787 /// @param b true to link nodes to elements, else false.
2788 ///////////////////////////////////////////////////////////////////////////////
2789 void SMDS_Mesh::setInverseElements(bool b)
2791 if(!b) MESSAGE("Error : inverseElement=false not implemented");
2792 myHasInverseElements=b;
2797 //================================================================================
2799 * \brief Iterator on elements in id increasing order
2801 //================================================================================
2803 template <typename ELEM=const SMDS_MeshElement*>
2804 class IdSortedIterator : public SMDS_Iterator<ELEM>
2806 SMDS_MeshElementIDFactory& myIDFact;
2807 int myID, myMaxID, myNbFound, myTotalNb;
2808 SMDSAbs_ElementType myType;
2812 IdSortedIterator(const SMDS_MeshElementIDFactory& fact,
2813 const SMDSAbs_ElementType type, // SMDSAbs_All NOT allowed!!!
2816 myID(1), myMaxID( myIDFact.GetMaxID() ),myNbFound(0), myTotalNb( totalNb ),
2828 ELEM current = myElem;
2830 for ( myElem = 0; !myElem && myNbFound < myTotalNb && myID <= myMaxID; ++myID )
2831 if ((myElem = (ELEM) myIDFact.MeshElement( myID ))
2832 && myElem->GetType() != myType )
2835 myNbFound += bool(myElem);
2841 //================================================================================
2843 * \brief Iterator on vector of elements, possibly being resized while iteration
2845 //================================================================================
2847 template<typename RETURN_VALUE,
2848 typename VECTOR_VALUE=SMDS_MeshCell*,
2849 typename VALUE_FILTER=SMDS::NonNullFilter<VECTOR_VALUE> >
2850 class ElemVecIterator: public SMDS_Iterator<RETURN_VALUE>
2852 const std::vector<VECTOR_VALUE>& _vector;
2855 VALUE_FILTER _filter;
2857 ElemVecIterator(const std::vector<VECTOR_VALUE>& vec,
2858 const VALUE_FILTER& filter=VALUE_FILTER() )
2859 :_vector( vec ), _index(0), _more( !vec.empty() ), _filter( filter )
2861 if ( _more && !_filter( _vector[ _index ]))
2868 virtual RETURN_VALUE next()
2870 if ( !_more ) return NULL;
2871 VECTOR_VALUE current = _vector[ _index ];
2873 while ( !_more && ++_index < _vector.size() )
2874 _more = _filter( _vector[ _index ]);
2875 return (RETURN_VALUE) current;
2880 ///////////////////////////////////////////////////////////////////////////////
2881 /// Return an iterator on nodes of the current mesh factory
2882 ///////////////////////////////////////////////////////////////////////////////
2884 SMDS_NodeIteratorPtr SMDS_Mesh::nodesIterator(bool idInceasingOrder) const
2886 // naturally always sorted by ID
2887 typedef ElemVecIterator<const SMDS_MeshNode*, SMDS_MeshNode*> TIterator;
2888 return SMDS_NodeIteratorPtr( new TIterator(myNodes));
2891 SMDS_ElemIteratorPtr SMDS_Mesh::elementGeomIterator(SMDSAbs_GeometryType type) const
2893 // naturally always sorted by ID
2894 typedef ElemVecIterator
2895 < const SMDS_MeshElement*, SMDS_MeshCell*, SMDS_MeshElement::GeomFilter > TIterator;
2896 return SMDS_ElemIteratorPtr
2897 (new TIterator(myCells, SMDS_MeshElement::GeomFilter( type )));
2900 SMDS_ElemIteratorPtr SMDS_Mesh::elementEntityIterator(SMDSAbs_EntityType type) const
2902 if ( type == SMDSEntity_Node )
2904 typedef ElemVecIterator<const SMDS_MeshElement*, SMDS_MeshNode*> TIterator;
2905 return SMDS_ElemIteratorPtr( new TIterator(myNodes));
2907 // naturally always sorted by ID
2908 typedef ElemVecIterator
2909 < const SMDS_MeshElement*, SMDS_MeshCell*, SMDS_MeshElement::EntityFilter > TIterator;
2910 return SMDS_ElemIteratorPtr
2911 (new TIterator(myCells, SMDS_MeshElement::EntityFilter( type )));
2914 ///////////////////////////////////////////////////////////////////////////////
2915 /// Return an iterator on elements of the current mesh factory
2916 ///////////////////////////////////////////////////////////////////////////////
2917 SMDS_ElemIteratorPtr SMDS_Mesh::elementsIterator(SMDSAbs_ElementType type) const
2919 // naturally always sorted by ID
2923 return SMDS_ElemIteratorPtr (new ElemVecIterator<const SMDS_MeshElement*>(myCells));
2926 return SMDS_ElemIteratorPtr
2927 ( new ElemVecIterator<const SMDS_MeshElement*, SMDS_MeshNode*>( myNodes ));
2930 typedef ElemVecIterator
2931 < const SMDS_MeshElement*, SMDS_MeshCell*, SMDS_MeshElement::TypeFilter > TIterator;
2932 return SMDS_ElemIteratorPtr (new TIterator(myCells, SMDS_MeshElement::TypeFilter( type )));
2934 return SMDS_ElemIteratorPtr();
2937 ///////////////////////////////////////////////////////////////////////////////
2938 ///Return an iterator on edges of the current mesh.
2939 ///////////////////////////////////////////////////////////////////////////////
2941 SMDS_EdgeIteratorPtr SMDS_Mesh::edgesIterator(bool idInceasingOrder) const
2943 // naturally always sorted by ID
2944 typedef ElemVecIterator
2945 < const SMDS_MeshEdge*, SMDS_MeshCell*, SMDS_MeshElement::TypeFilter > TIterator;
2946 return SMDS_EdgeIteratorPtr
2947 (new TIterator(myCells, SMDS_MeshElement::TypeFilter( SMDSAbs_Edge )));
2950 ///////////////////////////////////////////////////////////////////////////////
2951 ///Return an iterator on faces of the current mesh.
2952 ///////////////////////////////////////////////////////////////////////////////
2954 SMDS_FaceIteratorPtr SMDS_Mesh::facesIterator(bool idInceasingOrder) const
2956 // naturally always sorted by ID
2957 typedef ElemVecIterator
2958 < const SMDS_MeshFace*, SMDS_MeshCell*, SMDS_MeshElement::TypeFilter > TIterator;
2959 return SMDS_FaceIteratorPtr
2960 (new TIterator(myCells, SMDS_MeshElement::TypeFilter( SMDSAbs_Face )));
2963 ///////////////////////////////////////////////////////////////////////////////
2964 ///Return an iterator on volumes of the current mesh.
2965 ///////////////////////////////////////////////////////////////////////////////
2967 SMDS_VolumeIteratorPtr SMDS_Mesh::volumesIterator(bool idInceasingOrder) const
2969 // naturally always sorted by ID
2970 typedef ElemVecIterator
2971 < const SMDS_MeshVolume*, SMDS_MeshCell*, SMDS_MeshElement::TypeFilter > TIterator;
2972 return SMDS_VolumeIteratorPtr
2973 (new TIterator(myCells, SMDS_MeshElement::TypeFilter( SMDSAbs_Volume )));
2976 ///////////////////////////////////////////////////////////////////////////////
2977 /// Do intersection of sets (more than 2)
2978 ///////////////////////////////////////////////////////////////////////////////
2979 static set<const SMDS_MeshElement*> * intersectionOfSets(
2980 set<const SMDS_MeshElement*> vs[], int numberOfSets)
2982 set<const SMDS_MeshElement*>* rsetA=new set<const SMDS_MeshElement*>(vs[0]);
2983 set<const SMDS_MeshElement*>* rsetB;
2985 for(int i=0; i<numberOfSets-1; i++)
2987 rsetB=new set<const SMDS_MeshElement*>();
2989 rsetA->begin(), rsetA->end(),
2990 vs[i+1].begin(), vs[i+1].end(),
2991 inserter(*rsetB, rsetB->begin()));
2998 ///////////////////////////////////////////////////////////////////////////////
2999 /// Return the list of finite elements owning the given element: elements
3000 /// containing all the nodes of the given element, for instance faces and
3001 /// volumes containing a given edge.
3002 ///////////////////////////////////////////////////////////////////////////////
3003 static set<const SMDS_MeshElement*> * getFinitElements(const SMDS_MeshElement * element)
3005 int numberOfSets=element->NbNodes();
3006 set<const SMDS_MeshElement*> *initSet = new set<const SMDS_MeshElement*>[numberOfSets];
3008 SMDS_ElemIteratorPtr itNodes=element->nodesIterator();
3011 while ( itNodes->more() )
3013 const SMDS_MeshElement* node = itNodes->next();
3015 const SMDS_MeshNode * n=static_cast<const SMDS_MeshNode*>(node);
3016 SMDS_ElemIteratorPtr itFe = n->GetInverseElementIterator();
3018 while ( itFe->more() )
3020 const SMDS_MeshElement* elem = itFe->next();
3022 initSet[i].insert(elem);
3027 set<const SMDS_MeshElement*> *retSet = intersectionOfSets( initSet, numberOfSets );
3032 ///////////////////////////////////////////////////////////////////////////////
3033 /// Return the list of nodes used only by the given elements
3034 ///////////////////////////////////////////////////////////////////////////////
3035 static set<const SMDS_MeshElement*> * getExclusiveNodes(set<const SMDS_MeshElement*>& elements)
3037 set<const SMDS_MeshElement*> * toReturn=new set<const SMDS_MeshElement*>();
3038 set<const SMDS_MeshElement*>::iterator itElements=elements.begin();
3040 while(itElements!=elements.end())
3042 SMDS_ElemIteratorPtr itNodes = (*itElements)->nodesIterator();
3045 while(itNodes->more())
3047 const SMDS_MeshNode * n=static_cast<const SMDS_MeshNode*>(itNodes->next());
3048 SMDS_ElemIteratorPtr itFe = n->GetInverseElementIterator();
3049 set<const SMDS_MeshElement*> s;
3051 s.insert(itFe->next());
3052 if(s==elements) toReturn->insert(n);
3058 ///////////////////////////////////////////////////////////////////////////////
3059 ///Find the children of an element that are made of given nodes
3060 ///@param setOfChildren The set in which matching children will be inserted
3061 ///@param element The element were to search matching children
3062 ///@param nodes The nodes that the children must have to be selected
3063 ///////////////////////////////////////////////////////////////////////////////
3064 void SMDS_Mesh::addChildrenWithNodes(set<const SMDS_MeshElement*>& setOfChildren,
3065 const SMDS_MeshElement * element,
3066 set<const SMDS_MeshElement*>& nodes)
3068 switch(element->GetType())
3071 MESSAGE("Internal Error: This should not happen");
3073 case SMDSAbs_0DElement:
3080 SMDS_ElemIteratorPtr itn=element->nodesIterator();
3083 const SMDS_MeshElement * e=itn->next();
3084 if(nodes.find(e)!=nodes.end())
3086 setOfChildren.insert(element);
3093 SMDS_ElemIteratorPtr itn=element->nodesIterator();
3096 const SMDS_MeshElement * e=itn->next();
3097 if(nodes.find(e)!=nodes.end())
3099 setOfChildren.insert(element);
3103 if(hasConstructionEdges())
3105 SMDS_ElemIteratorPtr ite=element->edgesIterator();
3107 addChildrenWithNodes(setOfChildren, ite->next(), nodes);
3110 case SMDSAbs_Volume:
3112 if(hasConstructionFaces())
3114 SMDS_ElemIteratorPtr ite=element->facesIterator();
3116 addChildrenWithNodes(setOfChildren, ite->next(), nodes);
3118 else if(hasConstructionEdges())
3120 SMDS_ElemIteratorPtr ite=element->edgesIterator();
3122 addChildrenWithNodes(setOfChildren, ite->next(), nodes);
3125 case SMDSAbs_NbElementTypes:
3126 case SMDSAbs_All: break;
3130 ///////////////////////////////////////////////////////////////////////////////
3131 ///@param elem The element to delete
3132 ///@param removenodes if true remaining nodes will be removed
3133 ///////////////////////////////////////////////////////////////////////////////
3134 void SMDS_Mesh::RemoveElement(const SMDS_MeshElement * elem,
3135 const bool removenodes)
3137 list<const SMDS_MeshElement *> removedElems;
3138 list<const SMDS_MeshElement *> removedNodes;
3139 RemoveElement( elem, removedElems, removedNodes, removenodes );
3142 ///////////////////////////////////////////////////////////////////////////////
3143 ///@param elem The element to delete
3144 ///@param removedElems to be filled with all removed elements
3145 ///@param removedNodes to be filled with all removed nodes
3146 ///@param removenodes if true remaining nodes will be removed
3147 ///////////////////////////////////////////////////////////////////////////////
3148 void SMDS_Mesh::RemoveElement(const SMDS_MeshElement * elem,
3149 list<const SMDS_MeshElement *>& removedElems,
3150 list<const SMDS_MeshElement *>& removedNodes,
3153 // get finite elements built on elem
3154 set<const SMDS_MeshElement*> * s1;
3155 if ( (elem->GetType() == SMDSAbs_0DElement)
3156 || ((elem->GetType() == SMDSAbs_Edge) && !hasConstructionEdges())
3157 || ((elem->GetType() == SMDSAbs_Face) && !hasConstructionFaces())
3158 || (elem->GetType() == SMDSAbs_Volume) )
3160 s1 = new set<const SMDS_MeshElement*> ();
3164 s1 = getFinitElements(elem);
3166 // get exclusive nodes (which would become free afterwards)
3167 set<const SMDS_MeshElement*> * s2;
3168 if (elem->GetType() == SMDSAbs_Node) // a node is removed
3170 // do not remove nodes except elem
3171 s2 = new set<const SMDS_MeshElement*> ();
3176 s2 = getExclusiveNodes(*s1);
3178 // form the set of finite and construction elements to remove
3179 set<const SMDS_MeshElement*> s3;
3180 set<const SMDS_MeshElement*>::iterator it = s1->begin();
3181 while (it != s1->end())
3183 addChildrenWithNodes(s3, *it, *s2);
3187 if (elem->GetType() != SMDSAbs_Node)
3190 // remove finite and construction elements
3192 while (it != s3.end())
3194 // Remove element from <InverseElements> of its nodes
3195 SMDS_ElemIteratorPtr itn = (*it)->nodesIterator();
3198 SMDS_MeshNode * n = static_cast<SMDS_MeshNode *> (const_cast<SMDS_MeshElement *> (itn->next()));
3199 n->RemoveInverseElement((*it));
3201 int IdToRemove = (*it)->GetID();
3202 int vtkid = (*it)->getVtkId();
3203 switch ((*it)->GetType())
3206 MYASSERT("Internal Error: This should not happen");
3208 case SMDSAbs_0DElement:
3209 if (IdToRemove >= 0)
3211 myCells[IdToRemove] = 0; // -PR- ici ou dans myElementIDFactory->ReleaseID ?
3214 removedElems.push_back((*it));
3215 myElementIDFactory->ReleaseID(IdToRemove, vtkid);
3219 if (IdToRemove >= 0)
3221 myCells[IdToRemove] = 0;
3222 myInfo.RemoveEdge(*it);
3224 removedElems.push_back((*it));
3225 myElementIDFactory->ReleaseID(IdToRemove, vtkid);
3226 if (const SMDS_VtkEdge* vtkElem = dynamic_cast<const SMDS_VtkEdge*>(*it))
3227 myEdgePool->destroy((SMDS_VtkEdge*) vtkElem);
3229 ((SMDS_MeshElement*) *it)->init( -1, -1, -1 ); // avoid reuse
3234 if (IdToRemove >= 0)
3236 myCells[IdToRemove] = 0;
3237 myInfo.RemoveFace(*it);
3239 removedElems.push_back((*it));
3240 myElementIDFactory->ReleaseID(IdToRemove, vtkid);
3241 if (const SMDS_VtkFace* vtkElem = dynamic_cast<const SMDS_VtkFace*>(*it))
3242 myFacePool->destroy((SMDS_VtkFace*) vtkElem);
3244 ((SMDS_MeshElement*) *it)->init( -1, -1, -1 ); // avoid reuse
3248 case SMDSAbs_Volume:
3249 if (IdToRemove >= 0)
3251 myCells[IdToRemove] = 0;
3252 myInfo.RemoveVolume(*it);
3254 removedElems.push_back((*it));
3255 myElementIDFactory->ReleaseID(IdToRemove, vtkid);
3256 if (const SMDS_VtkVolume* vtkElem = dynamic_cast<const SMDS_VtkVolume*>(*it))
3257 myVolumePool->destroy((SMDS_VtkVolume*) vtkElem);
3259 ((SMDS_MeshElement*) *it)->init( -1, -1, -1 ); // avoid reuse
3264 if (IdToRemove >= 0)
3266 myCells[IdToRemove] = 0;
3269 removedElems.push_back((*it));
3270 myElementIDFactory->ReleaseID(IdToRemove, vtkid);
3271 if (const SMDS_BallElement* vtkElem = dynamic_cast<const SMDS_BallElement*>(*it))
3272 myBallPool->destroy(const_cast<SMDS_BallElement*>( vtkElem ));
3274 ((SMDS_MeshElement*) *it)->init( -1, -1, -1 ); // avoid reuse
3279 case SMDSAbs_All: // avoid compilation warning
3280 case SMDSAbs_NbElementTypes: break;
3284 this->myGrid->GetCellTypesArray()->SetValue(vtkid, VTK_EMPTY_CELL);
3289 // remove exclusive (free) nodes
3293 while (it != s2->end())
3295 int IdToRemove = (*it)->GetID();
3296 if (IdToRemove >= 0)
3298 myNodes[IdToRemove] = 0;
3301 myNodeIDFactory->ReleaseID((*it)->GetID(), (*it)->getVtkId());
3302 removedNodes.push_back((*it));
3303 if (const SMDS_MeshNode* vtkElem = dynamic_cast<const SMDS_MeshNode*>(*it))
3305 ((SMDS_MeshNode*)vtkElem)->SetPosition(SMDS_SpacePosition::originSpacePosition());
3306 myNodePool->destroy((SMDS_MeshNode*) vtkElem);
3319 ///////////////////////////////////////////////////////////////////////////////
3320 ///@param elem The element to delete
3321 ///////////////////////////////////////////////////////////////////////////////
3322 void SMDS_Mesh::RemoveFreeElement(const SMDS_MeshElement * elem)
3324 int elemId = elem->GetID();
3325 int vtkId = elem->getVtkId();
3326 SMDSAbs_ElementType aType = elem->GetType();
3327 SMDS_MeshElement* todest = (SMDS_MeshElement*)(elem);
3328 if (aType == SMDSAbs_Node) {
3329 // only free node can be removed by this method
3330 const SMDS_MeshNode* n = static_cast<SMDS_MeshNode*>(todest);
3331 SMDS_ElemIteratorPtr itFe = n->GetInverseElementIterator();
3332 if (!itFe->more()) { // free node
3333 myNodes[elemId] = 0;
3335 ((SMDS_MeshNode*) n)->SetPosition(SMDS_SpacePosition::originSpacePosition());
3336 ((SMDS_MeshNode*) n)->SMDS_MeshElement::init( -1, -1, -1 ); // avoid reuse
3337 myNodePool->destroy(static_cast<SMDS_MeshNode*>(todest));
3338 myNodeIDFactory->ReleaseID(elemId, vtkId);
3341 if (hasConstructionEdges() || hasConstructionFaces())
3342 // this methods is only for meshes without descendants
3345 // Remove element from <InverseElements> of its nodes
3346 SMDS_ElemIteratorPtr itn = elem->nodesIterator();
3347 while (itn->more()) {
3348 SMDS_MeshNode * n = static_cast<SMDS_MeshNode *>
3349 (const_cast<SMDS_MeshElement *>(itn->next()));
3350 n->RemoveInverseElement(elem);
3353 // in meshes without descendants elements are always free
3355 case SMDSAbs_0DElement:
3356 myCells[elemId] = 0;
3357 myInfo.remove(elem);
3362 myCells[elemId] = 0;
3363 myInfo.RemoveEdge(elem);
3364 myEdgePool->destroy(static_cast<SMDS_VtkEdge*>(todest));
3367 myCells[elemId] = 0;
3368 myInfo.RemoveFace(elem);
3369 myFacePool->destroy(static_cast<SMDS_VtkFace*>(todest));
3371 case SMDSAbs_Volume:
3372 myCells[elemId] = 0;
3373 myInfo.RemoveVolume(elem);
3374 myVolumePool->destroy(static_cast<SMDS_VtkVolume*>(todest));
3377 myCells[elemId] = 0;
3378 myInfo.remove(elem);
3379 myBallPool->destroy(static_cast<SMDS_BallElement*>(todest));
3384 myElementIDFactory->ReleaseID(elemId, vtkId);
3386 this->myGrid->GetCellTypesArray()->SetValue(vtkId, VTK_EMPTY_CELL);
3387 // --- to do: keep vtkid in a list of reusable cells
3390 ((SMDS_MeshElement*) elem)->init( -1, -1, -1 ); // avoid reuse
3395 * Checks if the element is present in mesh.
3396 * Useful to determine dead pointers.
3398 bool SMDS_Mesh::Contains (const SMDS_MeshElement* elem) const
3400 // we should not rely on validity of *elem, so iterate on containers
3401 // of all types in the hope of finding <elem> somewhere there
3402 SMDS_NodeIteratorPtr itn = nodesIterator();
3404 if (elem == itn->next())
3406 SMDS_ElemIteratorPtr ite = elementsIterator();
3408 if (elem == ite->next())
3413 //=======================================================================
3414 //function : MaxNodeID
3416 //=======================================================================
3418 int SMDS_Mesh::MaxNodeID() const
3420 return myNodeIDFactory->GetMaxID();
3423 //=======================================================================
3424 //function : MinNodeID
3426 //=======================================================================
3428 int SMDS_Mesh::MinNodeID() const
3430 return myNodeIDFactory->GetMinID();
3433 //=======================================================================
3434 //function : MaxElementID
3436 //=======================================================================
3438 int SMDS_Mesh::MaxElementID() const
3440 return myElementIDFactory->GetMaxID();
3443 //=======================================================================
3444 //function : MinElementID
3446 //=======================================================================
3448 int SMDS_Mesh::MinElementID() const
3450 return myElementIDFactory->GetMinID();
3453 //=======================================================================
3454 //function : Renumber
3455 //purpose : Renumber all nodes or elements.
3456 //=======================================================================
3458 void SMDS_Mesh::Renumber (const bool isNodes, const int startID, const int deltaID)
3463 SMDS_MeshNodeIDFactory * idFactory =
3464 isNodes ? myNodeIDFactory : myElementIDFactory;
3466 // get existing elements in the order of ID increasing
3467 map<int,SMDS_MeshElement*> elemMap;
3468 SMDS_ElemIteratorPtr idElemIt = idFactory->elementsIterator();
3469 while ( idElemIt->more() ) {
3470 SMDS_MeshElement* elem = const_cast<SMDS_MeshElement*>(idElemIt->next());
3471 int id = elem->GetID();
3472 elemMap.insert(map<int,SMDS_MeshElement*>::value_type(id, elem));
3474 // release their ids
3475 map<int,SMDS_MeshElement*>::iterator elemIt = elemMap.begin();
3477 // for ( ; elemIt != elemMap.end(); elemIt++ )
3479 // int id = (*elemIt).first;
3480 // idFactory->ReleaseID( id );
3484 elemIt = elemMap.begin();
3485 for ( ; elemIt != elemMap.end(); elemIt++ )
3487 idFactory->BindID( ID, (*elemIt).second );
3492 //=======================================================================
3493 //function : GetElementType
3494 //purpose : Return type of element or node with id
3495 //=======================================================================
3497 SMDSAbs_ElementType SMDS_Mesh::GetElementType( const int id, const bool iselem ) const
3499 SMDS_MeshElement* elem = 0;
3501 elem = myElementIDFactory->MeshElement( id );
3503 elem = myNodeIDFactory->MeshElement( id );
3507 //throw SALOME_Exception(LOCALIZED ("this element isn't exist"));
3511 return elem->GetType();
3516 //********************************************************************
3517 //********************************************************************
3518 //******** *********
3519 //***** Methods for addition of quadratic elements ******
3520 //******** *********
3521 //********************************************************************
3522 //********************************************************************
3524 //=======================================================================
3525 //function : AddEdgeWithID
3527 //=======================================================================
3528 SMDS_MeshEdge* SMDS_Mesh::AddEdgeWithID(int n1, int n2, int n12, int ID)
3530 return SMDS_Mesh::AddEdgeWithID
3531 ((SMDS_MeshNode*) myNodeIDFactory->MeshElement(n1),
3532 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n2),
3533 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n12),
3537 //=======================================================================
3538 //function : AddEdge
3540 //=======================================================================
3541 SMDS_MeshEdge* SMDS_Mesh::AddEdge(const SMDS_MeshNode* n1,
3542 const SMDS_MeshNode* n2,
3543 const SMDS_MeshNode* n12)
3545 return SMDS_Mesh::AddEdgeWithID(n1, n2, n12, myElementIDFactory->GetFreeID());
3548 //=======================================================================
3549 //function : AddEdgeWithID
3551 //=======================================================================
3552 SMDS_MeshEdge* SMDS_Mesh::AddEdgeWithID(const SMDS_MeshNode * n1,
3553 const SMDS_MeshNode * n2,
3554 const SMDS_MeshNode * n12,
3557 if ( !n1 || !n2 || !n12 ) return 0;
3559 // --- retrieve nodes ID
3560 myNodeIds.resize(3);
3561 myNodeIds[0] = n1->getVtkId();
3562 myNodeIds[1] = n2->getVtkId();
3563 myNodeIds[2] = n12->getVtkId();
3565 SMDS_MeshEdge * edge = 0;
3566 SMDS_VtkEdge *edgevtk = myEdgePool->getNew();
3567 edgevtk->init(myNodeIds, this);
3568 if (!this->registerElement(ID,edgevtk))
3570 this->myGrid->GetCellTypesArray()->SetValue(edgevtk->getVtkId(), VTK_EMPTY_CELL);
3571 myEdgePool->destroy(edgevtk);
3575 adjustmyCellsCapacity(ID);
3577 myInfo.myNbQuadEdges++;
3579 // if (!registerElement(ID, edge)) {
3580 // RemoveElement(edge, false);
3588 //=======================================================================
3589 //function : AddFace
3591 //=======================================================================
3592 SMDS_MeshFace* SMDS_Mesh::AddFace(const SMDS_MeshNode * n1,
3593 const SMDS_MeshNode * n2,
3594 const SMDS_MeshNode * n3,
3595 const SMDS_MeshNode * n12,
3596 const SMDS_MeshNode * n23,
3597 const SMDS_MeshNode * n31)
3599 return SMDS_Mesh::AddFaceWithID(n1,n2,n3,n12,n23,n31,
3600 myElementIDFactory->GetFreeID());
3603 //=======================================================================
3604 //function : AddFaceWithID
3606 //=======================================================================
3607 SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(int n1, int n2, int n3,
3608 int n12,int n23,int n31, int ID)
3610 return SMDS_Mesh::AddFaceWithID
3611 ((SMDS_MeshNode *)myNodeIDFactory->MeshElement(n1) ,
3612 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n2) ,
3613 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n3) ,
3614 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n12),
3615 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n23),
3616 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n31),
3620 //=======================================================================
3621 //function : AddFaceWithID
3623 //=======================================================================
3624 SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
3625 const SMDS_MeshNode * n2,
3626 const SMDS_MeshNode * n3,
3627 const SMDS_MeshNode * n12,
3628 const SMDS_MeshNode * n23,
3629 const SMDS_MeshNode * n31,
3632 if ( !n1 || !n2 || !n3 || !n12 || !n23 || !n31) return 0;
3633 if(hasConstructionEdges()) {
3634 // creation quadratic edges - not implemented
3639 // --- retrieve nodes ID
3640 myNodeIds.resize(6);
3641 myNodeIds[0] = n1->getVtkId();
3642 myNodeIds[1] = n2->getVtkId();
3643 myNodeIds[2] = n3->getVtkId();
3644 myNodeIds[3] = n12->getVtkId();
3645 myNodeIds[4] = n23->getVtkId();
3646 myNodeIds[5] = n31->getVtkId();
3648 SMDS_MeshFace * face = 0;
3649 SMDS_VtkFace *facevtk = myFacePool->getNew();
3650 facevtk->init(myNodeIds, this);
3651 if (!this->registerElement(ID,facevtk))
3653 this->myGrid->GetCellTypesArray()->SetValue(facevtk->getVtkId(), VTK_EMPTY_CELL);
3654 myFacePool->destroy(facevtk);
3658 adjustmyCellsCapacity(ID);
3660 myInfo.myNbQuadTriangles++;
3662 // if (!registerElement(ID, face)) {
3663 // RemoveElement(face, false);
3671 //=======================================================================
3672 //function : AddFace
3674 //=======================================================================
3675 SMDS_MeshFace* SMDS_Mesh::AddFace(const SMDS_MeshNode * n1,
3676 const SMDS_MeshNode * n2,
3677 const SMDS_MeshNode * n3,
3678 const SMDS_MeshNode * n12,
3679 const SMDS_MeshNode * n23,
3680 const SMDS_MeshNode * n31,
3681 const SMDS_MeshNode * nCenter)
3683 return SMDS_Mesh::AddFaceWithID(n1,n2,n3,n12,n23,n31,nCenter,
3684 myElementIDFactory->GetFreeID());
3687 //=======================================================================
3688 //function : AddFaceWithID
3690 //=======================================================================
3691 SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(int n1, int n2, int n3,
3692 int n12,int n23,int n31, int nCenter, int ID)
3694 return SMDS_Mesh::AddFaceWithID
3695 ((SMDS_MeshNode *)myNodeIDFactory->MeshElement(n1) ,
3696 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n2) ,
3697 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n3) ,
3698 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n12),
3699 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n23),
3700 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n31),
3701 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(nCenter),
3705 //=======================================================================
3706 //function : AddFaceWithID
3708 //=======================================================================
3709 SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
3710 const SMDS_MeshNode * n2,
3711 const SMDS_MeshNode * n3,
3712 const SMDS_MeshNode * n12,
3713 const SMDS_MeshNode * n23,
3714 const SMDS_MeshNode * n31,
3715 const SMDS_MeshNode * nCenter,
3718 if ( !n1 || !n2 || !n3 || !n12 || !n23 || !n31 || !nCenter) return 0;
3719 if(hasConstructionEdges()) {
3720 // creation quadratic edges - not implemented
3725 // --- retrieve nodes ID
3726 myNodeIds.resize(7);
3727 myNodeIds[0] = n1->getVtkId();
3728 myNodeIds[1] = n2->getVtkId();
3729 myNodeIds[2] = n3->getVtkId();
3730 myNodeIds[3] = n12->getVtkId();
3731 myNodeIds[4] = n23->getVtkId();
3732 myNodeIds[5] = n31->getVtkId();
3733 myNodeIds[6] = nCenter->getVtkId();
3735 SMDS_MeshFace * face = 0;
3736 SMDS_VtkFace *facevtk = myFacePool->getNew();
3737 facevtk->init(myNodeIds, this);
3738 if (!this->registerElement(ID,facevtk))
3740 this->myGrid->GetCellTypesArray()->SetValue(facevtk->getVtkId(), VTK_EMPTY_CELL);
3741 myFacePool->destroy(facevtk);
3745 adjustmyCellsCapacity(ID);
3747 myInfo.myNbBiQuadTriangles++;
3749 // if (!registerElement(ID, face)) {
3750 // RemoveElement(face, false);
3758 //=======================================================================
3759 //function : AddFace
3761 //=======================================================================
3762 SMDS_MeshFace* SMDS_Mesh::AddFace(const SMDS_MeshNode * n1,
3763 const SMDS_MeshNode * n2,
3764 const SMDS_MeshNode * n3,
3765 const SMDS_MeshNode * n4,
3766 const SMDS_MeshNode * n12,
3767 const SMDS_MeshNode * n23,
3768 const SMDS_MeshNode * n34,
3769 const SMDS_MeshNode * n41)
3771 return SMDS_Mesh::AddFaceWithID(n1,n2,n3,n4,n12,n23,n34,n41,
3772 myElementIDFactory->GetFreeID());
3775 //=======================================================================
3776 //function : AddFaceWithID
3778 //=======================================================================
3779 SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(int n1, int n2, int n3, int n4,
3780 int n12,int n23,int n34,int n41, int ID)
3782 return SMDS_Mesh::AddFaceWithID
3783 ((SMDS_MeshNode *)myNodeIDFactory->MeshElement(n1) ,
3784 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n2) ,
3785 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n3) ,
3786 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n4) ,
3787 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n12),
3788 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n23),
3789 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n34),
3790 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n41),
3794 //=======================================================================
3795 //function : AddFaceWithID
3797 //=======================================================================
3798 SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
3799 const SMDS_MeshNode * n2,
3800 const SMDS_MeshNode * n3,
3801 const SMDS_MeshNode * n4,
3802 const SMDS_MeshNode * n12,
3803 const SMDS_MeshNode * n23,
3804 const SMDS_MeshNode * n34,
3805 const SMDS_MeshNode * n41,
3808 if ( !n1 || !n2 || !n3 || !n4 || !n12 || !n23 || !n34 || !n41) return 0;
3809 if(hasConstructionEdges()) {
3810 // creation quadratic edges - not implemented
3815 // --- retrieve nodes ID
3816 myNodeIds.resize(8);
3817 myNodeIds[0] = n1->getVtkId();
3818 myNodeIds[1] = n2->getVtkId();
3819 myNodeIds[2] = n3->getVtkId();
3820 myNodeIds[3] = n4->getVtkId();
3821 myNodeIds[4] = n12->getVtkId();
3822 myNodeIds[5] = n23->getVtkId();
3823 myNodeIds[6] = n34->getVtkId();
3824 myNodeIds[7] = n41->getVtkId();
3826 SMDS_MeshFace * face = 0;
3827 SMDS_VtkFace *facevtk = myFacePool->getNew();
3828 facevtk->init(myNodeIds, this);
3829 if (!this->registerElement(ID,facevtk))
3831 this->myGrid->GetCellTypesArray()->SetValue(facevtk->getVtkId(), VTK_EMPTY_CELL);
3832 myFacePool->destroy(facevtk);
3836 adjustmyCellsCapacity(ID);
3838 myInfo.myNbQuadQuadrangles++;
3840 // if (!registerElement(ID, face)) {
3841 // RemoveElement(face, false);
3848 //=======================================================================
3849 //function : AddFace
3851 //=======================================================================
3852 SMDS_MeshFace* SMDS_Mesh::AddFace(const SMDS_MeshNode * n1,
3853 const SMDS_MeshNode * n2,
3854 const SMDS_MeshNode * n3,
3855 const SMDS_MeshNode * n4,
3856 const SMDS_MeshNode * n12,
3857 const SMDS_MeshNode * n23,
3858 const SMDS_MeshNode * n34,
3859 const SMDS_MeshNode * n41,
3860 const SMDS_MeshNode * nCenter)
3862 return SMDS_Mesh::AddFaceWithID(n1,n2,n3,n4,n12,n23,n34,n41,nCenter,
3863 myElementIDFactory->GetFreeID());
3866 //=======================================================================
3867 //function : AddFaceWithID
3869 //=======================================================================
3870 SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(int n1, int n2, int n3, int n4,
3871 int n12,int n23,int n34,int n41, int nCenter, int ID)
3873 return SMDS_Mesh::AddFaceWithID
3874 ((SMDS_MeshNode *)myNodeIDFactory->MeshElement(n1) ,
3875 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n2) ,
3876 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n3) ,
3877 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n4) ,
3878 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n12),
3879 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n23),
3880 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n34),
3881 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n41),
3882 (SMDS_MeshNode *)myNodeIDFactory->MeshElement(nCenter),
3886 //=======================================================================
3887 //function : AddFaceWithID
3889 //=======================================================================
3890 SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
3891 const SMDS_MeshNode * n2,
3892 const SMDS_MeshNode * n3,
3893 const SMDS_MeshNode * n4,
3894 const SMDS_MeshNode * n12,
3895 const SMDS_MeshNode * n23,
3896 const SMDS_MeshNode * n34,
3897 const SMDS_MeshNode * n41,
3898 const SMDS_MeshNode * nCenter,
3901 if ( !n1 || !n2 || !n3 || !n4 || !n12 || !n23 || !n34 || !n41 || !nCenter) return 0;
3902 if(hasConstructionEdges()) {
3903 // creation quadratic edges - not implemented
3908 // --- retrieve nodes ID
3909 myNodeIds.resize(9);
3910 myNodeIds[0] = n1->getVtkId();
3911 myNodeIds[1] = n2->getVtkId();
3912 myNodeIds[2] = n3->getVtkId();
3913 myNodeIds[3] = n4->getVtkId();
3914 myNodeIds[4] = n12->getVtkId();
3915 myNodeIds[5] = n23->getVtkId();
3916 myNodeIds[6] = n34->getVtkId();
3917 myNodeIds[7] = n41->getVtkId();
3918 myNodeIds[8] = nCenter->getVtkId();
3920 SMDS_MeshFace * face = 0;
3921 SMDS_VtkFace *facevtk = myFacePool->getNew();
3922 facevtk->init(myNodeIds, this);
3923 if (!this->registerElement(ID,facevtk))
3925 this->myGrid->GetCellTypesArray()->SetValue(facevtk->getVtkId(), VTK_EMPTY_CELL);
3926 myFacePool->destroy(facevtk);
3930 adjustmyCellsCapacity(ID);
3932 myInfo.myNbBiQuadQuadrangles++;
3934 // if (!registerElement(ID, face)) {
3935 // RemoveElement(face, false);
3943 //=======================================================================
3944 //function : AddVolume
3946 //=======================================================================
3947 SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
3948 const SMDS_MeshNode * n2,
3949 const SMDS_MeshNode * n3,
3950 const SMDS_MeshNode * n4,
3951 const SMDS_MeshNode * n12,
3952 const SMDS_MeshNode * n23,
3953 const SMDS_MeshNode * n31,
3954 const SMDS_MeshNode * n14,
3955 const SMDS_MeshNode * n24,
3956 const SMDS_MeshNode * n34)
3958 int ID = myElementIDFactory->GetFreeID();
3959 SMDS_MeshVolume * v = SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n12, n23,
3960 n31, n14, n24, n34, ID);
3961 if(v==NULL) myElementIDFactory->ReleaseID(ID);
3965 //=======================================================================
3966 //function : AddVolumeWithID
3968 //=======================================================================
3969 SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4,
3970 int n12,int n23,int n31,
3971 int n14,int n24,int n34, int ID)
3973 return SMDS_Mesh::AddVolumeWithID
3974 ((SMDS_MeshNode*) myNodeIDFactory->MeshElement(n1) ,
3975 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n2) ,
3976 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n3) ,
3977 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n4) ,
3978 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n12),
3979 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n23),
3980 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n31),
3981 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n14),
3982 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n24),
3983 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n34),
3987 //=======================================================================
3988 //function : AddVolumeWithID
3989 //purpose : 2d order tetrahedron of 10 nodes
3990 //=======================================================================
3991 SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
3992 const SMDS_MeshNode * n2,
3993 const SMDS_MeshNode * n3,
3994 const SMDS_MeshNode * n4,
3995 const SMDS_MeshNode * n12,
3996 const SMDS_MeshNode * n23,
3997 const SMDS_MeshNode * n31,
3998 const SMDS_MeshNode * n14,
3999 const SMDS_MeshNode * n24,
4000 const SMDS_MeshNode * n34,
4003 if ( !n1 || !n2 || !n3 || !n4 || !n12 || !n23 || !n31 || !n14 || !n24 || !n34)
4005 if(hasConstructionFaces()) {
4006 // creation quadratic faces - not implemented
4009 // --- retrieve nodes ID
4010 myNodeIds.resize(10);
4011 myNodeIds[0] = n1->getVtkId();
4012 myNodeIds[1] = n3->getVtkId();
4013 myNodeIds[2] = n2->getVtkId();
4014 myNodeIds[3] = n4->getVtkId();
4016 myNodeIds[4] = n31->getVtkId();
4017 myNodeIds[5] = n23->getVtkId();
4018 myNodeIds[6] = n12->getVtkId();
4020 myNodeIds[7] = n14->getVtkId();
4021 myNodeIds[8] = n34->getVtkId();
4022 myNodeIds[9] = n24->getVtkId();
4024 SMDS_VtkVolume *volvtk = myVolumePool->getNew();
4025 volvtk->init(myNodeIds, this);
4026 if (!this->registerElement(ID,volvtk))
4028 this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL);
4029 myVolumePool->destroy(volvtk);
4032 adjustmyCellsCapacity(ID);
4033 myCells[ID] = volvtk;
4034 myInfo.myNbQuadTetras++;
4036 // if (!registerElement(ID, volvtk)) {
4037 // RemoveElement(volvtk, false);
4044 //=======================================================================
4045 //function : AddVolume
4047 //=======================================================================
4048 SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
4049 const SMDS_MeshNode * n2,
4050 const SMDS_MeshNode * n3,
4051 const SMDS_MeshNode * n4,
4052 const SMDS_MeshNode * n5,
4053 const SMDS_MeshNode * n12,
4054 const SMDS_MeshNode * n23,
4055 const SMDS_MeshNode * n34,
4056 const SMDS_MeshNode * n41,
4057 const SMDS_MeshNode * n15,
4058 const SMDS_MeshNode * n25,
4059 const SMDS_MeshNode * n35,
4060 const SMDS_MeshNode * n45)
4062 int ID = myElementIDFactory->GetFreeID();
4063 SMDS_MeshVolume * v =
4064 SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, n12, n23, n34, n41,
4065 n15, n25, n35, n45, ID);
4066 if(v==NULL) myElementIDFactory->ReleaseID(ID);
4070 //=======================================================================
4071 //function : AddVolumeWithID
4073 //=======================================================================
4074 SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4, int n5,
4075 int n12,int n23,int n34,int n41,
4076 int n15,int n25,int n35,int n45, int ID)
4078 return SMDS_Mesh::AddVolumeWithID
4079 ((SMDS_MeshNode*) myNodeIDFactory->MeshElement(n1) ,
4080 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n2) ,
4081 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n3) ,
4082 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n4) ,
4083 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n5) ,
4084 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n12),
4085 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n23),
4086 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n34),
4087 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n41),
4088 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n15),
4089 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n25),
4090 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n35),
4091 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n45),
4095 //=======================================================================
4096 //function : AddVolumeWithID
4097 //purpose : 2d order pyramid of 13 nodes
4098 //=======================================================================
4099 SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
4100 const SMDS_MeshNode * n2,
4101 const SMDS_MeshNode * n3,
4102 const SMDS_MeshNode * n4,
4103 const SMDS_MeshNode * n5,
4104 const SMDS_MeshNode * n12,
4105 const SMDS_MeshNode * n23,
4106 const SMDS_MeshNode * n34,
4107 const SMDS_MeshNode * n41,
4108 const SMDS_MeshNode * n15,
4109 const SMDS_MeshNode * n25,
4110 const SMDS_MeshNode * n35,
4111 const SMDS_MeshNode * n45,
4114 if (!n1 || !n2 || !n3 || !n4 || !n5 || !n12 || !n23 ||
4115 !n34 || !n41 || !n15 || !n25 || !n35 || !n45)
4117 if(hasConstructionFaces()) {
4118 // creation quadratic faces - not implemented
4121 // --- retrieve nodes ID
4122 myNodeIds.resize(13);
4123 myNodeIds[0] = n1->getVtkId();
4124 myNodeIds[1] = n4->getVtkId();
4125 myNodeIds[2] = n3->getVtkId();
4126 myNodeIds[3] = n2->getVtkId();
4127 myNodeIds[4] = n5->getVtkId();
4129 myNodeIds[5] = n41->getVtkId();
4130 myNodeIds[6] = n34->getVtkId();
4131 myNodeIds[7] = n23->getVtkId();
4132 myNodeIds[8] = n12->getVtkId();
4134 myNodeIds[9] = n15->getVtkId();
4135 myNodeIds[10] = n45->getVtkId();
4136 myNodeIds[11] = n35->getVtkId();
4137 myNodeIds[12] = n25->getVtkId();
4139 SMDS_VtkVolume *volvtk = myVolumePool->getNew();
4140 volvtk->init(myNodeIds, this);
4141 if (!this->registerElement(ID,volvtk))
4143 this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL);
4144 myVolumePool->destroy(volvtk);
4147 adjustmyCellsCapacity(ID);
4148 myCells[ID] = volvtk;
4149 myInfo.myNbQuadPyramids++;
4151 // if (!registerElement(ID, volvtk)) {
4152 // RemoveElement(volvtk, false);
4159 //=======================================================================
4160 //function : AddVolume
4162 //=======================================================================
4163 SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
4164 const SMDS_MeshNode * n2,
4165 const SMDS_MeshNode * n3,
4166 const SMDS_MeshNode * n4,
4167 const SMDS_MeshNode * n5,
4168 const SMDS_MeshNode * n6,
4169 const SMDS_MeshNode * n12,
4170 const SMDS_MeshNode * n23,
4171 const SMDS_MeshNode * n31,
4172 const SMDS_MeshNode * n45,
4173 const SMDS_MeshNode * n56,
4174 const SMDS_MeshNode * n64,
4175 const SMDS_MeshNode * n14,
4176 const SMDS_MeshNode * n25,
4177 const SMDS_MeshNode * n36)
4179 int ID = myElementIDFactory->GetFreeID();
4180 SMDS_MeshVolume * v =
4181 SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, n6, n12, n23, n31,
4182 n45, n56, n64, n14, n25, n36, ID);
4183 if(v==NULL) myElementIDFactory->ReleaseID(ID);
4187 //=======================================================================
4188 //function : AddVolumeWithID
4190 //=======================================================================
4191 SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(int n1, int n2, int n3,
4192 int n4, int n5, int n6,
4193 int n12,int n23,int n31,
4194 int n45,int n56,int n64,
4195 int n14,int n25,int n36, int ID)
4197 return SMDS_Mesh::AddVolumeWithID
4198 ((SMDS_MeshNode*) myNodeIDFactory->MeshElement(n1) ,
4199 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n2) ,
4200 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n3) ,
4201 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n4) ,
4202 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n5) ,
4203 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n6) ,
4204 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n12),
4205 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n23),
4206 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n31),
4207 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n45),
4208 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n56),
4209 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n64),
4210 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n14),
4211 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n25),
4212 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n36),
4216 //=======================================================================
4217 //function : AddVolumeWithID
4218 //purpose : 2d order Pentahedron with 15 nodes
4219 //=======================================================================
4220 SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
4221 const SMDS_MeshNode * n2,
4222 const SMDS_MeshNode * n3,
4223 const SMDS_MeshNode * n4,
4224 const SMDS_MeshNode * n5,
4225 const SMDS_MeshNode * n6,
4226 const SMDS_MeshNode * n12,
4227 const SMDS_MeshNode * n23,
4228 const SMDS_MeshNode * n31,
4229 const SMDS_MeshNode * n45,
4230 const SMDS_MeshNode * n56,
4231 const SMDS_MeshNode * n64,
4232 const SMDS_MeshNode * n14,
4233 const SMDS_MeshNode * n25,
4234 const SMDS_MeshNode * n36,
4237 if (!n1 || !n2 || !n3 || !n4 || !n5 || !n6 || !n12 || !n23 ||
4238 !n31 || !n45 || !n56 || !n64 || !n14 || !n25 || !n36)
4240 if(hasConstructionFaces()) {
4241 // creation quadratic faces - not implemented
4244 // --- retrieve nodes ID
4245 myNodeIds.resize(15);
4246 myNodeIds[0] = n1->getVtkId();
4247 myNodeIds[1] = n2->getVtkId();
4248 myNodeIds[2] = n3->getVtkId();
4250 myNodeIds[3] = n4->getVtkId();
4251 myNodeIds[4] = n5->getVtkId();
4252 myNodeIds[5] = n6->getVtkId();
4254 myNodeIds[6] = n12->getVtkId();
4255 myNodeIds[7] = n23->getVtkId();
4256 myNodeIds[8] = n31->getVtkId();
4258 myNodeIds[9] = n45->getVtkId();
4259 myNodeIds[10] = n56->getVtkId();
4260 myNodeIds[11] = n64->getVtkId();
4262 myNodeIds[12] = n14->getVtkId();
4263 myNodeIds[13] = n25->getVtkId();
4264 myNodeIds[14] = n36->getVtkId();
4266 SMDS_VtkVolume *volvtk = myVolumePool->getNew();
4267 volvtk->init(myNodeIds, this);
4268 if (!this->registerElement(ID,volvtk))
4270 this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL);
4271 myVolumePool->destroy(volvtk);
4274 adjustmyCellsCapacity(ID);
4275 myCells[ID] = volvtk;
4276 myInfo.myNbQuadPrisms++;
4278 // if (!registerElement(ID, volvtk)) {
4279 // RemoveElement(volvtk, false);
4286 //=======================================================================
4287 //function : AddVolume
4289 //=======================================================================
4290 SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
4291 const SMDS_MeshNode * n2,
4292 const SMDS_MeshNode * n3,
4293 const SMDS_MeshNode * n4,
4294 const SMDS_MeshNode * n5,
4295 const SMDS_MeshNode * n6,
4296 const SMDS_MeshNode * n7,
4297 const SMDS_MeshNode * n8,
4298 const SMDS_MeshNode * n12,
4299 const SMDS_MeshNode * n23,
4300 const SMDS_MeshNode * n34,
4301 const SMDS_MeshNode * n41,
4302 const SMDS_MeshNode * n56,
4303 const SMDS_MeshNode * n67,
4304 const SMDS_MeshNode * n78,
4305 const SMDS_MeshNode * n85,
4306 const SMDS_MeshNode * n15,
4307 const SMDS_MeshNode * n26,
4308 const SMDS_MeshNode * n37,
4309 const SMDS_MeshNode * n48)
4311 int ID = myElementIDFactory->GetFreeID();
4312 SMDS_MeshVolume * v =
4313 SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, n6, n7, n8, n12, n23, n34, n41,
4314 n56, n67, n78, n85, n15, n26, n37, n48, ID);
4315 if(v==NULL) myElementIDFactory->ReleaseID(ID);
4319 //=======================================================================
4320 //function : AddVolumeWithID
4322 //=======================================================================
4323 SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4,
4324 int n5, int n6, int n7, int n8,
4325 int n12,int n23,int n34,int n41,
4326 int n56,int n67,int n78,int n85,
4327 int n15,int n26,int n37,int n48, int ID)
4329 return SMDS_Mesh::AddVolumeWithID
4330 ((SMDS_MeshNode*) myNodeIDFactory->MeshElement(n1),
4331 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n2),
4332 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n3),
4333 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n4),
4334 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n5),
4335 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n6),
4336 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n7),
4337 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n8),
4338 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n12),
4339 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n23),
4340 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n34),
4341 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n41),
4342 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n56),
4343 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n67),
4344 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n78),
4345 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n85),
4346 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n15),
4347 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n26),
4348 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n37),
4349 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n48),
4353 //=======================================================================
4354 //function : AddVolumeWithID
4355 //purpose : 2d order Hexahedrons with 20 nodes
4356 //=======================================================================
4357 SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
4358 const SMDS_MeshNode * n2,
4359 const SMDS_MeshNode * n3,
4360 const SMDS_MeshNode * n4,
4361 const SMDS_MeshNode * n5,
4362 const SMDS_MeshNode * n6,
4363 const SMDS_MeshNode * n7,
4364 const SMDS_MeshNode * n8,
4365 const SMDS_MeshNode * n12,
4366 const SMDS_MeshNode * n23,
4367 const SMDS_MeshNode * n34,
4368 const SMDS_MeshNode * n41,
4369 const SMDS_MeshNode * n56,
4370 const SMDS_MeshNode * n67,
4371 const SMDS_MeshNode * n78,
4372 const SMDS_MeshNode * n85,
4373 const SMDS_MeshNode * n15,
4374 const SMDS_MeshNode * n26,
4375 const SMDS_MeshNode * n37,
4376 const SMDS_MeshNode * n48,
4379 if (!n1 || !n2 || !n3 || !n4 || !n5 || !n6 || !n7 || !n8 || !n12 || !n23 ||
4380 !n34 || !n41 || !n56 || !n67 || !n78 || !n85 || !n15 || !n26 || !n37 || !n48)
4382 if(hasConstructionFaces()) {
4384 // creation quadratic faces - not implemented
4386 // --- retrieve nodes ID
4387 myNodeIds.resize(20);
4388 myNodeIds[0] = n1->getVtkId();
4389 myNodeIds[1] = n4->getVtkId();
4390 myNodeIds[2] = n3->getVtkId();
4391 myNodeIds[3] = n2->getVtkId();
4393 myNodeIds[4] = n5->getVtkId();
4394 myNodeIds[5] = n8->getVtkId();
4395 myNodeIds[6] = n7->getVtkId();
4396 myNodeIds[7] = n6->getVtkId();
4398 myNodeIds[8] = n41->getVtkId();
4399 myNodeIds[9] = n34->getVtkId();
4400 myNodeIds[10] = n23->getVtkId();
4401 myNodeIds[11] = n12->getVtkId();
4403 myNodeIds[12] = n85->getVtkId();
4404 myNodeIds[13] = n78->getVtkId();
4405 myNodeIds[14] = n67->getVtkId();
4406 myNodeIds[15] = n56->getVtkId();
4408 myNodeIds[16] = n15->getVtkId();
4409 myNodeIds[17] = n48->getVtkId();
4410 myNodeIds[18] = n37->getVtkId();
4411 myNodeIds[19] = n26->getVtkId();
4413 SMDS_VtkVolume *volvtk = myVolumePool->getNew();
4414 volvtk->init(myNodeIds, this);
4415 if (!this->registerElement(ID,volvtk))
4417 this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL);
4418 myVolumePool->destroy(volvtk);
4421 adjustmyCellsCapacity(ID);
4422 myCells[ID] = volvtk;
4423 myInfo.myNbQuadHexas++;
4425 // if (!registerElement(ID, volvtk)) {
4426 // RemoveElement(volvtk, false);
4432 //=======================================================================
4433 //function : AddVolume
4435 //=======================================================================
4436 SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
4437 const SMDS_MeshNode * n2,
4438 const SMDS_MeshNode * n3,
4439 const SMDS_MeshNode * n4,
4440 const SMDS_MeshNode * n5,
4441 const SMDS_MeshNode * n6,
4442 const SMDS_MeshNode * n7,
4443 const SMDS_MeshNode * n8,
4444 const SMDS_MeshNode * n12,
4445 const SMDS_MeshNode * n23,
4446 const SMDS_MeshNode * n34,
4447 const SMDS_MeshNode * n41,
4448 const SMDS_MeshNode * n56,
4449 const SMDS_MeshNode * n67,
4450 const SMDS_MeshNode * n78,
4451 const SMDS_MeshNode * n85,
4452 const SMDS_MeshNode * n15,
4453 const SMDS_MeshNode * n26,
4454 const SMDS_MeshNode * n37,
4455 const SMDS_MeshNode * n48,
4456 const SMDS_MeshNode * n1234,
4457 const SMDS_MeshNode * n1256,
4458 const SMDS_MeshNode * n2367,
4459 const SMDS_MeshNode * n3478,
4460 const SMDS_MeshNode * n1458,
4461 const SMDS_MeshNode * n5678,
4462 const SMDS_MeshNode * nCenter)
4464 int ID = myElementIDFactory->GetFreeID();
4465 SMDS_MeshVolume * v =
4466 SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, n6, n7, n8, n12, n23, n34, n41,
4467 n56, n67, n78, n85, n15, n26, n37, n48,
4468 n1234, n1256, n2367, n3478, n1458, n5678, nCenter,
4470 if(v==NULL) myElementIDFactory->ReleaseID(ID);
4474 //=======================================================================
4475 //function : AddVolumeWithID
4477 //=======================================================================
4478 SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4,
4479 int n5, int n6, int n7, int n8,
4480 int n12,int n23,int n34,int n41,
4481 int n56,int n67,int n78,int n85,
4482 int n15,int n26,int n37,int n48,
4483 int n1234,int n1256,int n2367,int n3478,
4484 int n1458,int n5678,int nCenter, int ID)
4486 return SMDS_Mesh::AddVolumeWithID
4487 ((SMDS_MeshNode*) myNodeIDFactory->MeshElement(n1),
4488 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n2),
4489 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n3),
4490 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n4),
4491 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n5),
4492 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n6),
4493 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n7),
4494 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n8),
4495 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n12),
4496 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n23),
4497 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n34),
4498 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n41),
4499 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n56),
4500 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n67),
4501 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n78),
4502 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n85),
4503 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n15),
4504 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n26),
4505 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n37),
4506 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n48),
4507 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n1234),
4508 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n1256),
4509 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n2367),
4510 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n3478),
4511 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n1458),
4512 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n5678),
4513 (SMDS_MeshNode*) myNodeIDFactory->MeshElement(nCenter),
4517 //=======================================================================
4518 //function : AddVolumeWithID
4519 //purpose : 2d order Hexahedrons with 20 nodes
4520 //=======================================================================
4521 SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
4522 const SMDS_MeshNode * n2,
4523 const SMDS_MeshNode * n3,
4524 const SMDS_MeshNode * n4,
4525 const SMDS_MeshNode * n5,
4526 const SMDS_MeshNode * n6,
4527 const SMDS_MeshNode * n7,
4528 const SMDS_MeshNode * n8,
4529 const SMDS_MeshNode * n12,
4530 const SMDS_MeshNode * n23,
4531 const SMDS_MeshNode * n34,
4532 const SMDS_MeshNode * n41,
4533 const SMDS_MeshNode * n56,
4534 const SMDS_MeshNode * n67,
4535 const SMDS_MeshNode * n78,
4536 const SMDS_MeshNode * n85,
4537 const SMDS_MeshNode * n15,
4538 const SMDS_MeshNode * n26,
4539 const SMDS_MeshNode * n37,
4540 const SMDS_MeshNode * n48,
4541 const SMDS_MeshNode * n1234,
4542 const SMDS_MeshNode * n1256,
4543 const SMDS_MeshNode * n2367,
4544 const SMDS_MeshNode * n3478,
4545 const SMDS_MeshNode * n1458,
4546 const SMDS_MeshNode * n5678,
4547 const SMDS_MeshNode * nCenter,
4550 if (!n1 || !n2 || !n3 || !n4 || !n5 || !n6 || !n7 || !n8 || !n12 || !n23 ||
4551 !n34 || !n41 || !n56 || !n67 || !n78 || !n85 || !n15 || !n26 || !n37 || !n48 ||
4552 !n1234 || !n1256 || !n2367 || !n3478 || !n1458 || !n5678 || !nCenter )
4554 if(hasConstructionFaces()) {
4556 // creation quadratic faces - not implemented
4558 // --- retrieve nodes ID
4559 myNodeIds.resize(27);
4560 myNodeIds[0] = n1->getVtkId();
4561 myNodeIds[1] = n4->getVtkId();
4562 myNodeIds[2] = n3->getVtkId();
4563 myNodeIds[3] = n2->getVtkId();
4565 myNodeIds[4] = n5->getVtkId();
4566 myNodeIds[5] = n8->getVtkId();
4567 myNodeIds[6] = n7->getVtkId();
4568 myNodeIds[7] = n6->getVtkId();
4570 myNodeIds[8] = n41->getVtkId();
4571 myNodeIds[9] = n34->getVtkId();
4572 myNodeIds[10] = n23->getVtkId();
4573 myNodeIds[11] = n12->getVtkId();
4575 myNodeIds[12] = n85->getVtkId();
4576 myNodeIds[13] = n78->getVtkId();
4577 myNodeIds[14] = n67->getVtkId();
4578 myNodeIds[15] = n56->getVtkId();
4580 myNodeIds[16] = n15->getVtkId();
4581 myNodeIds[17] = n48->getVtkId();
4582 myNodeIds[18] = n37->getVtkId();
4583 myNodeIds[19] = n26->getVtkId();
4585 myNodeIds[20] = n1256->getVtkId();
4586 myNodeIds[21] = n3478->getVtkId();
4587 myNodeIds[22] = n1458->getVtkId();
4588 myNodeIds[23] = n2367->getVtkId();
4589 myNodeIds[24] = n1234->getVtkId();
4590 myNodeIds[25] = n5678->getVtkId();
4591 myNodeIds[26] = nCenter->getVtkId();
4593 SMDS_VtkVolume *volvtk = myVolumePool->getNew();
4594 volvtk->init(myNodeIds, this);
4595 if (!this->registerElement(ID,volvtk))
4597 this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL);
4598 myVolumePool->destroy(volvtk);
4601 adjustmyCellsCapacity(ID);
4602 myCells[ID] = volvtk;
4603 myInfo.myNbTriQuadHexas++;
4608 void SMDS_Mesh::dumpGrid(string ficdump)
4610 // vtkUnstructuredGridWriter* aWriter = vtkUnstructuredGridWriter::New();
4611 // aWriter->SetFileName(ficdump.c_str());
4612 // aWriter->SetInput(myGrid);
4613 // if(myGrid->GetNumberOfCells())
4615 // aWriter->Write();
4617 // aWriter->Delete();
4618 ficdump = ficdump + "_connectivity";
4619 ofstream ficcon(ficdump.c_str(), ios::out);
4620 int nbPoints = myGrid->GetNumberOfPoints();
4621 ficcon << "-------------------------------- points " << nbPoints << endl;
4622 for (int i=0; i<nbPoints; i++)
4624 ficcon << i << " " << *(myGrid->GetPoint(i)) << " " << *(myGrid->GetPoint(i)+1) << " " << " " << *(myGrid->GetPoint(i)+2) << endl;
4626 int nbCells = myGrid->GetNumberOfCells();
4627 ficcon << "-------------------------------- cells " << nbCells << endl;
4628 for (int i=0; i<nbCells; i++)
4630 ficcon << i << " - " << myGrid->GetCell(i)->GetCellType() << " -";
4631 int nbptcell = myGrid->GetCell(i)->GetNumberOfPoints();
4632 vtkIdList *listid = myGrid->GetCell(i)->GetPointIds();
4633 for (int j=0; j<nbptcell; j++)
4635 ficcon << " " << listid->GetId(j);
4639 ficcon << "-------------------------------- connectivity " << nbPoints << endl;
4640 vtkCellLinks *links = myGrid->GetLinks();
4641 for (int i=0; i<nbPoints; i++)
4643 int ncells = links->GetNcells(i);
4644 vtkIdType *cells = links->GetCells(i);
4645 ficcon << i << " - " << ncells << " -";
4646 for (int j=0; j<ncells; j++)
4648 ficcon << " " << cells[j];
4656 void SMDS_Mesh::compactMesh()
4658 this->myCompactTime = this->myModifTime;
4661 int SMDS_Mesh::fromVtkToSmds(int vtkid)
4663 if (vtkid >= 0 && vtkid < (int)myCellIdVtkToSmds.size())
4664 return myCellIdVtkToSmds[vtkid];
4665 throw SALOME_Exception(LOCALIZED ("vtk id out of bounds"));
4668 // void SMDS_Mesh::updateBoundingBox()
4670 // xmin = 0; xmax = 0;
4671 // ymin = 0; ymax = 0;
4672 // zmin = 0; zmax = 0;
4673 // vtkPoints *points = myGrid->GetPoints();
4674 // int myNodesSize = this->myNodes.size();
4675 // for (int i = 0; i < myNodesSize; i++)
4677 // if (SMDS_MeshNode *n = myNodes[i])
4679 // double coords[3];
4680 // points->GetPoint(n->myVtkID, coords);
4681 // if (coords[0] < xmin) xmin = coords[0];
4682 // else if (coords[0] > xmax) xmax = coords[0];
4683 // if (coords[1] < ymin) ymin = coords[1];
4684 // else if (coords[1] > ymax) ymax = coords[1];
4685 // if (coords[2] < zmin) zmin = coords[2];
4686 // else if (coords[2] > zmax) zmax = coords[2];
4691 double SMDS_Mesh::getMaxDim()
4693 double dmax = 1.e-3;
4694 if ((xmax - xmin) > dmax) dmax = xmax -xmin;
4695 if ((ymax - ymin) > dmax) dmax = ymax -ymin;
4696 if ((zmax - zmin) > dmax) dmax = zmax -zmin;
4700 //! modification that needs compact structure and redraw
4701 void SMDS_Mesh::Modified()
4703 if (this->myModified)
4705 this->myModifTime++;
4710 //! get last modification timeStamp
4711 vtkMTimeType SMDS_Mesh::GetMTime() const
4713 return this->myModifTime;
4716 bool SMDS_Mesh::isCompacted()
4718 return this->myCompactTime == this->myModifTime;