1 // Copyright (C) 2007-2011 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.
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 : implementaion of Salome mesh data structure
24 // File : SMDS_Mesh.hxx
27 #ifndef _SMDS_Mesh_HeaderFile
28 #define _SMDS_Mesh_HeaderFile
30 #include "SMESH_SMDS.hxx"
32 #include "SMDS_MeshNode.hxx"
33 #include "SMDS_MeshCell.hxx"
34 #include "SMDS_Mesh0DElement.hxx"
35 #include "SMDS_MeshEdge.hxx"
36 #include "SMDS_MeshFace.hxx"
37 #include "SMDS_MeshVolume.hxx"
38 #include "SMDS_MeshNodeIDFactory.hxx"
39 #include "SMDS_MeshElementIDFactory.hxx"
40 #include "SMDS_MeshInfo.hxx"
41 #include "SMDS_ElemIterator.hxx"
42 #include "SMDS_VolumeOfNodes.hxx"
43 #include "SMDS_VtkEdge.hxx"
44 #include "SMDS_VtkFace.hxx"
45 #include "SMDS_VtkVolume.hxx"
46 #include "ObjectPool.hxx"
47 #include "SMDS_UnstructuredGrid.hxx"
49 #include <boost/shared_ptr.hpp>
53 #include <vtkSystemIncludes.h>
56 #include "Utils_SALOME_Exception.hxx"
57 #define MYASSERT(val) if (!(val)) throw SALOME_Exception(LOCALIZED("assertion not verified"));
59 class SMDS_EXPORT SMDS_Mesh:public SMDS_MeshObject{
61 friend class SMDS_MeshIDFactory;
62 friend class SMDS_MeshNodeIDFactory;
63 friend class SMDS_MeshElementIDFactory;
64 friend class SMDS_MeshVolumeVtkNodes;
65 friend class SMDS_MeshNode;
69 //! to retreive this SMDS_Mesh instance from its elements (index stored in SMDS_Elements)
70 static std::vector<SMDS_Mesh*> _meshList;
72 //! actual nodes coordinates, cells definition and reverse connectivity are stored in a vtkUnstructuredGrid
73 inline SMDS_UnstructuredGrid* getGrid() {return myGrid; }
74 inline int getMeshId() {return myMeshId; }
76 virtual SMDS_NodeIteratorPtr nodesIterator (bool idInceasingOrder=false) const;
77 virtual SMDS_0DElementIteratorPtr elements0dIterator(bool idInceasingOrder=false) const;
78 virtual SMDS_EdgeIteratorPtr edgesIterator (bool idInceasingOrder=false) const;
79 virtual SMDS_FaceIteratorPtr facesIterator (bool idInceasingOrder=false) const;
80 virtual SMDS_VolumeIteratorPtr volumesIterator (bool idInceasingOrder=false) const;
82 virtual SMDS_ElemIteratorPtr elementsIterator(SMDSAbs_ElementType type=SMDSAbs_All) const;
84 SMDSAbs_ElementType GetElementType( const int id, const bool iselem ) const;
86 SMDS_Mesh *AddSubMesh();
88 virtual SMDS_MeshNode* AddNodeWithID(double x, double y, double z, int ID);
89 virtual SMDS_MeshNode* AddNode(double x, double y, double z);
91 virtual SMDS_Mesh0DElement* Add0DElementWithID(int n, int ID);
92 virtual SMDS_Mesh0DElement* Add0DElementWithID(const SMDS_MeshNode * n, int ID);
93 virtual SMDS_Mesh0DElement* Add0DElement (const SMDS_MeshNode * n);
95 virtual SMDS_MeshEdge* AddEdgeWithID(int n1, int n2, int ID);
96 virtual SMDS_MeshEdge* AddEdgeWithID(const SMDS_MeshNode * n1,
97 const SMDS_MeshNode * n2,
99 virtual SMDS_MeshEdge* AddEdge(const SMDS_MeshNode * n1,
100 const SMDS_MeshNode * n2);
102 // 2d order edge with 3 nodes: n12 - node between n1 and n2
103 virtual SMDS_MeshEdge* AddEdgeWithID(int n1, int n2, int n12, int ID);
104 virtual SMDS_MeshEdge* AddEdgeWithID(const SMDS_MeshNode * n1,
105 const SMDS_MeshNode * n2,
106 const SMDS_MeshNode * n12,
108 virtual SMDS_MeshEdge* AddEdge(const SMDS_MeshNode * n1,
109 const SMDS_MeshNode * n2,
110 const SMDS_MeshNode * n12);
112 virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3, int ID);
113 virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
114 const SMDS_MeshNode * n2,
115 const SMDS_MeshNode * n3,
117 virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
118 const SMDS_MeshNode * n2,
119 const SMDS_MeshNode * n3);
121 virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3, int n4, int ID);
122 virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
123 const SMDS_MeshNode * n2,
124 const SMDS_MeshNode * n3,
125 const SMDS_MeshNode * n4,
127 virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
128 const SMDS_MeshNode * n2,
129 const SMDS_MeshNode * n3,
130 const SMDS_MeshNode * n4);
132 virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshEdge * e1,
133 const SMDS_MeshEdge * e2,
134 const SMDS_MeshEdge * e3, int ID);
135 virtual SMDS_MeshFace* AddFace(const SMDS_MeshEdge * e1,
136 const SMDS_MeshEdge * e2,
137 const SMDS_MeshEdge * e3);
139 virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshEdge * e1,
140 const SMDS_MeshEdge * e2,
141 const SMDS_MeshEdge * e3,
142 const SMDS_MeshEdge * e4, int ID);
143 virtual SMDS_MeshFace* AddFace(const SMDS_MeshEdge * e1,
144 const SMDS_MeshEdge * e2,
145 const SMDS_MeshEdge * e3,
146 const SMDS_MeshEdge * e4);
148 // 2d order triangle of 6 nodes
149 virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3,
150 int n12,int n23,int n31, int ID);
151 virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
152 const SMDS_MeshNode * n2,
153 const SMDS_MeshNode * n3,
154 const SMDS_MeshNode * n12,
155 const SMDS_MeshNode * n23,
156 const SMDS_MeshNode * n31,
158 virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
159 const SMDS_MeshNode * n2,
160 const SMDS_MeshNode * n3,
161 const SMDS_MeshNode * n12,
162 const SMDS_MeshNode * n23,
163 const SMDS_MeshNode * n31);
165 // 2d order quadrangle
166 virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3, int n4,
167 int n12,int n23,int n34,int n41, int ID);
168 virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
169 const SMDS_MeshNode * n2,
170 const SMDS_MeshNode * n3,
171 const SMDS_MeshNode * n4,
172 const SMDS_MeshNode * n12,
173 const SMDS_MeshNode * n23,
174 const SMDS_MeshNode * n34,
175 const SMDS_MeshNode * n41,
177 virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
178 const SMDS_MeshNode * n2,
179 const SMDS_MeshNode * n3,
180 const SMDS_MeshNode * n4,
181 const SMDS_MeshNode * n12,
182 const SMDS_MeshNode * n23,
183 const SMDS_MeshNode * n34,
184 const SMDS_MeshNode * n41);
186 virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3, int n4,
187 int n12,int n23,int n34,int n41, int nCenter, int ID);
188 virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
189 const SMDS_MeshNode * n2,
190 const SMDS_MeshNode * n3,
191 const SMDS_MeshNode * n4,
192 const SMDS_MeshNode * n12,
193 const SMDS_MeshNode * n23,
194 const SMDS_MeshNode * n34,
195 const SMDS_MeshNode * n41,
196 const SMDS_MeshNode * nCenter,
198 virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
199 const SMDS_MeshNode * n2,
200 const SMDS_MeshNode * n3,
201 const SMDS_MeshNode * n4,
202 const SMDS_MeshNode * n12,
203 const SMDS_MeshNode * n23,
204 const SMDS_MeshNode * n34,
205 const SMDS_MeshNode * n41,
206 const SMDS_MeshNode * nCenter);
208 virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int ID);
209 virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
210 const SMDS_MeshNode * n2,
211 const SMDS_MeshNode * n3,
212 const SMDS_MeshNode * n4,
214 virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
215 const SMDS_MeshNode * n2,
216 const SMDS_MeshNode * n3,
217 const SMDS_MeshNode * n4);
219 virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
221 virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
222 const SMDS_MeshNode * n2,
223 const SMDS_MeshNode * n3,
224 const SMDS_MeshNode * n4,
225 const SMDS_MeshNode * n5,
227 virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
228 const SMDS_MeshNode * n2,
229 const SMDS_MeshNode * n3,
230 const SMDS_MeshNode * n4,
231 const SMDS_MeshNode * n5);
233 virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
234 int n5, int n6, int ID);
235 virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
236 const SMDS_MeshNode * n2,
237 const SMDS_MeshNode * n3,
238 const SMDS_MeshNode * n4,
239 const SMDS_MeshNode * n5,
240 const SMDS_MeshNode * n6,
242 virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
243 const SMDS_MeshNode * n2,
244 const SMDS_MeshNode * n3,
245 const SMDS_MeshNode * n4,
246 const SMDS_MeshNode * n5,
247 const SMDS_MeshNode * n6);
249 virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
250 int n5, int n6, int n7, int n8, int ID);
251 virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
252 const SMDS_MeshNode * n2,
253 const SMDS_MeshNode * n3,
254 const SMDS_MeshNode * n4,
255 const SMDS_MeshNode * n5,
256 const SMDS_MeshNode * n6,
257 const SMDS_MeshNode * n7,
258 const SMDS_MeshNode * n8,
260 virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
261 const SMDS_MeshNode * n2,
262 const SMDS_MeshNode * n3,
263 const SMDS_MeshNode * n4,
264 const SMDS_MeshNode * n5,
265 const SMDS_MeshNode * n6,
266 const SMDS_MeshNode * n7,
267 const SMDS_MeshNode * n8);
269 virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshFace * f1,
270 const SMDS_MeshFace * f2,
271 const SMDS_MeshFace * f3,
272 const SMDS_MeshFace * f4, int ID);
273 virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshFace * f1,
274 const SMDS_MeshFace * f2,
275 const SMDS_MeshFace * f3,
276 const SMDS_MeshFace * f4);
278 virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshFace * f1,
279 const SMDS_MeshFace * f2,
280 const SMDS_MeshFace * f3,
281 const SMDS_MeshFace * f4,
282 const SMDS_MeshFace * f5, int ID);
283 virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshFace * f1,
284 const SMDS_MeshFace * f2,
285 const SMDS_MeshFace * f3,
286 const SMDS_MeshFace * f4,
287 const SMDS_MeshFace * f5);
289 virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshFace * f1,
290 const SMDS_MeshFace * f2,
291 const SMDS_MeshFace * f3,
292 const SMDS_MeshFace * f4,
293 const SMDS_MeshFace * f5,
294 const SMDS_MeshFace * f6, int ID);
295 virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshFace * f1,
296 const SMDS_MeshFace * f2,
297 const SMDS_MeshFace * f3,
298 const SMDS_MeshFace * f4,
299 const SMDS_MeshFace * f5,
300 const SMDS_MeshFace * f6);
303 virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, int n6,
304 int n7, int n8, int n9, int n10, int n11, int n12,
306 virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
307 const SMDS_MeshNode * n2,
308 const SMDS_MeshNode * n3,
309 const SMDS_MeshNode * n4,
310 const SMDS_MeshNode * n5,
311 const SMDS_MeshNode * n6,
312 const SMDS_MeshNode * n7,
313 const SMDS_MeshNode * n8,
314 const SMDS_MeshNode * n9,
315 const SMDS_MeshNode * n10,
316 const SMDS_MeshNode * n11,
317 const SMDS_MeshNode * n12,
319 virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
320 const SMDS_MeshNode * n2,
321 const SMDS_MeshNode * n3,
322 const SMDS_MeshNode * n4,
323 const SMDS_MeshNode * n5,
324 const SMDS_MeshNode * n6,
325 const SMDS_MeshNode * n7,
326 const SMDS_MeshNode * n8,
327 const SMDS_MeshNode * n9,
328 const SMDS_MeshNode * n10,
329 const SMDS_MeshNode * n11,
330 const SMDS_MeshNode * n12);
332 // 2d order tetrahedron of 10 nodes
333 virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
334 int n12,int n23,int n31,
335 int n14,int n24,int n34, int ID);
336 virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
337 const SMDS_MeshNode * n2,
338 const SMDS_MeshNode * n3,
339 const SMDS_MeshNode * n4,
340 const SMDS_MeshNode * n12,
341 const SMDS_MeshNode * n23,
342 const SMDS_MeshNode * n31,
343 const SMDS_MeshNode * n14,
344 const SMDS_MeshNode * n24,
345 const SMDS_MeshNode * n34,
347 virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
348 const SMDS_MeshNode * n2,
349 const SMDS_MeshNode * n3,
350 const SMDS_MeshNode * n4,
351 const SMDS_MeshNode * n12,
352 const SMDS_MeshNode * n23,
353 const SMDS_MeshNode * n31,
354 const SMDS_MeshNode * n14,
355 const SMDS_MeshNode * n24,
356 const SMDS_MeshNode * n34);
358 // 2d order pyramid of 13 nodes
359 virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int n5,
360 int n12,int n23,int n34,int n41,
361 int n15,int n25,int n35,int n45,
363 virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
364 const SMDS_MeshNode * n2,
365 const SMDS_MeshNode * n3,
366 const SMDS_MeshNode * n4,
367 const SMDS_MeshNode * n5,
368 const SMDS_MeshNode * n12,
369 const SMDS_MeshNode * n23,
370 const SMDS_MeshNode * n34,
371 const SMDS_MeshNode * n41,
372 const SMDS_MeshNode * n15,
373 const SMDS_MeshNode * n25,
374 const SMDS_MeshNode * n35,
375 const SMDS_MeshNode * n45,
377 virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
378 const SMDS_MeshNode * n2,
379 const SMDS_MeshNode * n3,
380 const SMDS_MeshNode * n4,
381 const SMDS_MeshNode * n5,
382 const SMDS_MeshNode * n12,
383 const SMDS_MeshNode * n23,
384 const SMDS_MeshNode * n34,
385 const SMDS_MeshNode * n41,
386 const SMDS_MeshNode * n15,
387 const SMDS_MeshNode * n25,
388 const SMDS_MeshNode * n35,
389 const SMDS_MeshNode * n45);
391 // 2d order Pentahedron with 15 nodes
392 virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3,
393 int n4, int n5, int n6,
394 int n12,int n23,int n31,
395 int n45,int n56,int n64,
396 int n14,int n25,int n36,
398 virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
399 const SMDS_MeshNode * n2,
400 const SMDS_MeshNode * n3,
401 const SMDS_MeshNode * n4,
402 const SMDS_MeshNode * n5,
403 const SMDS_MeshNode * n6,
404 const SMDS_MeshNode * n12,
405 const SMDS_MeshNode * n23,
406 const SMDS_MeshNode * n31,
407 const SMDS_MeshNode * n45,
408 const SMDS_MeshNode * n56,
409 const SMDS_MeshNode * n64,
410 const SMDS_MeshNode * n14,
411 const SMDS_MeshNode * n25,
412 const SMDS_MeshNode * n36,
414 virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
415 const SMDS_MeshNode * n2,
416 const SMDS_MeshNode * n3,
417 const SMDS_MeshNode * n4,
418 const SMDS_MeshNode * n5,
419 const SMDS_MeshNode * n6,
420 const SMDS_MeshNode * n12,
421 const SMDS_MeshNode * n23,
422 const SMDS_MeshNode * n31,
423 const SMDS_MeshNode * n45,
424 const SMDS_MeshNode * n56,
425 const SMDS_MeshNode * n64,
426 const SMDS_MeshNode * n14,
427 const SMDS_MeshNode * n25,
428 const SMDS_MeshNode * n36);
430 // 2d oreder Hexahedrons with 20 nodes
431 virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
432 int n5, int n6, int n7, int n8,
433 int n12,int n23,int n34,int n41,
434 int n56,int n67,int n78,int n85,
435 int n15,int n26,int n37,int n48,
437 virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
438 const SMDS_MeshNode * n2,
439 const SMDS_MeshNode * n3,
440 const SMDS_MeshNode * n4,
441 const SMDS_MeshNode * n5,
442 const SMDS_MeshNode * n6,
443 const SMDS_MeshNode * n7,
444 const SMDS_MeshNode * n8,
445 const SMDS_MeshNode * n12,
446 const SMDS_MeshNode * n23,
447 const SMDS_MeshNode * n34,
448 const SMDS_MeshNode * n41,
449 const SMDS_MeshNode * n56,
450 const SMDS_MeshNode * n67,
451 const SMDS_MeshNode * n78,
452 const SMDS_MeshNode * n85,
453 const SMDS_MeshNode * n15,
454 const SMDS_MeshNode * n26,
455 const SMDS_MeshNode * n37,
456 const SMDS_MeshNode * n48,
458 virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
459 const SMDS_MeshNode * n2,
460 const SMDS_MeshNode * n3,
461 const SMDS_MeshNode * n4,
462 const SMDS_MeshNode * n5,
463 const SMDS_MeshNode * n6,
464 const SMDS_MeshNode * n7,
465 const SMDS_MeshNode * n8,
466 const SMDS_MeshNode * n12,
467 const SMDS_MeshNode * n23,
468 const SMDS_MeshNode * n34,
469 const SMDS_MeshNode * n41,
470 const SMDS_MeshNode * n56,
471 const SMDS_MeshNode * n67,
472 const SMDS_MeshNode * n78,
473 const SMDS_MeshNode * n85,
474 const SMDS_MeshNode * n15,
475 const SMDS_MeshNode * n26,
476 const SMDS_MeshNode * n37,
477 const SMDS_MeshNode * n48);
479 // 2d oreder Hexahedrons with 27 nodes
480 virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
481 int n5, int n6, int n7, int n8,
482 int n12,int n23,int n34,int n41,
483 int n56,int n67,int n78,int n85,
484 int n15,int n26,int n37,int n48,
485 int n1234,int n1256,int n2367,int n3478,
486 int n1458,int n5678,int nCenter,
488 virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
489 const SMDS_MeshNode * n2,
490 const SMDS_MeshNode * n3,
491 const SMDS_MeshNode * n4,
492 const SMDS_MeshNode * n5,
493 const SMDS_MeshNode * n6,
494 const SMDS_MeshNode * n7,
495 const SMDS_MeshNode * n8,
496 const SMDS_MeshNode * n12,
497 const SMDS_MeshNode * n23,
498 const SMDS_MeshNode * n34,
499 const SMDS_MeshNode * n41,
500 const SMDS_MeshNode * n56,
501 const SMDS_MeshNode * n67,
502 const SMDS_MeshNode * n78,
503 const SMDS_MeshNode * n85,
504 const SMDS_MeshNode * n15,
505 const SMDS_MeshNode * n26,
506 const SMDS_MeshNode * n37,
507 const SMDS_MeshNode * n48,
508 const SMDS_MeshNode * n1234,
509 const SMDS_MeshNode * n1256,
510 const SMDS_MeshNode * n2367,
511 const SMDS_MeshNode * n3478,
512 const SMDS_MeshNode * n1458,
513 const SMDS_MeshNode * n5678,
514 const SMDS_MeshNode * nCenter,
516 virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
517 const SMDS_MeshNode * n2,
518 const SMDS_MeshNode * n3,
519 const SMDS_MeshNode * n4,
520 const SMDS_MeshNode * n5,
521 const SMDS_MeshNode * n6,
522 const SMDS_MeshNode * n7,
523 const SMDS_MeshNode * n8,
524 const SMDS_MeshNode * n12,
525 const SMDS_MeshNode * n23,
526 const SMDS_MeshNode * n34,
527 const SMDS_MeshNode * n41,
528 const SMDS_MeshNode * n56,
529 const SMDS_MeshNode * n67,
530 const SMDS_MeshNode * n78,
531 const SMDS_MeshNode * n85,
532 const SMDS_MeshNode * n15,
533 const SMDS_MeshNode * n26,
534 const SMDS_MeshNode * n37,
535 const SMDS_MeshNode * n48,
536 const SMDS_MeshNode * n1234,
537 const SMDS_MeshNode * n1256,
538 const SMDS_MeshNode * n2367,
539 const SMDS_MeshNode * n3478,
540 const SMDS_MeshNode * n1458,
541 const SMDS_MeshNode * n5678,
542 const SMDS_MeshNode * nCenter);
544 virtual SMDS_MeshFace* AddPolygonalFaceWithID (const std::vector<int> & nodes_ids,
547 virtual SMDS_MeshFace* AddPolygonalFaceWithID (const std::vector<const SMDS_MeshNode*> & nodes,
550 virtual SMDS_MeshFace* AddPolygonalFace (const std::vector<const SMDS_MeshNode*> & nodes);
552 virtual SMDS_MeshVolume* AddPolyhedralVolumeWithID
553 (const std::vector<int> & nodes_ids,
554 const std::vector<int> & quantities,
557 virtual SMDS_MeshVolume* AddPolyhedralVolumeWithID
558 (const std::vector<const SMDS_MeshNode*> & nodes,
559 const std::vector<int> & quantities,
562 virtual SMDS_MeshVolume* AddPolyhedralVolume
563 (const std::vector<const SMDS_MeshNode*> & nodes,
564 const std::vector<int> & quantities);
566 virtual SMDS_MeshVolume* AddVolumeFromVtkIds(const std::vector<vtkIdType>& vtkNodeIds);
568 virtual SMDS_MeshVolume* AddVolumeFromVtkIdsWithID(const std::vector<vtkIdType>& vtkNodeIds,
571 virtual void RemoveElement(const SMDS_MeshElement * elem,
572 std::list<const SMDS_MeshElement *>& removedElems,
573 std::list<const SMDS_MeshElement *>& removedNodes,
574 const bool removenodes = false);
575 virtual void RemoveElement(const SMDS_MeshElement * elem, bool removenodes = false);
576 virtual void RemoveNode(const SMDS_MeshNode * node);
577 virtual void Remove0DElement(const SMDS_Mesh0DElement * elem0d);
578 virtual void RemoveEdge(const SMDS_MeshEdge * edge);
579 virtual void RemoveFace(const SMDS_MeshFace * face);
580 virtual void RemoveVolume(const SMDS_MeshVolume * volume);
582 /*! Remove only the given element and only if it is free.
583 * Method does not work for meshes with descendants.
584 * Implemented for fast cleaning of meshes.
586 virtual void RemoveFreeElement(const SMDS_MeshElement * elem);
588 virtual void Clear();
590 virtual bool RemoveFromParent();
591 virtual bool RemoveSubMesh(const SMDS_Mesh * aMesh);
593 bool ChangeElementNodes(const SMDS_MeshElement * elem,
594 const SMDS_MeshNode * nodes[],
596 bool ChangePolyhedronNodes(const SMDS_MeshElement * elem,
597 const std::vector<const SMDS_MeshNode*>& nodes,
598 const std::vector<int> & quantities);
600 virtual void Renumber (const bool isNodes, const int startID = 1, const int deltaID = 1);
601 // Renumber all nodes or elements.
602 virtual void compactMesh();
604 const SMDS_MeshNode *FindNode(int idnode) const;
605 const SMDS_MeshNode *FindNodeVtk(int idnode) const;
606 const SMDS_Mesh0DElement* Find0DElement(int idnode) const;
607 const SMDS_MeshEdge *FindEdge(int idnode1, int idnode2) const;
608 const SMDS_MeshEdge *FindEdge(int idnode1, int idnode2, int idnode3) const;
609 const SMDS_MeshFace *FindFace(int idnode1, int idnode2, int idnode3) const;
610 const SMDS_MeshFace *FindFace(int idnode1, int idnode2, int idnode3, int idnode4) const;
611 const SMDS_MeshFace *FindFace(int idnode1, int idnode2, int idnode3,
612 int idnode4, int idnode5, int idnode6) const;
613 const SMDS_MeshFace *FindFace(int idnode1, int idnode2, int idnode3, int idnode4,
614 int idnode5, int idnode6, int idnode7, int idnode8) const;
615 const SMDS_MeshElement *FindElement(int IDelem) const;
616 static const SMDS_Mesh0DElement* Find0DElement(const SMDS_MeshNode * n);
617 static const SMDS_MeshEdge* FindEdge(const SMDS_MeshNode * n1,
618 const SMDS_MeshNode * n2);
619 static const SMDS_MeshEdge* FindEdge(const SMDS_MeshNode * n1,
620 const SMDS_MeshNode * n2,
621 const SMDS_MeshNode * n3);
622 static const SMDS_MeshFace* FindFace(const SMDS_MeshNode *n1,
623 const SMDS_MeshNode *n2,
624 const SMDS_MeshNode *n3);
625 static const SMDS_MeshFace* FindFace(const SMDS_MeshNode *n1,
626 const SMDS_MeshNode *n2,
627 const SMDS_MeshNode *n3,
628 const SMDS_MeshNode *n4);
629 static const SMDS_MeshFace* FindFace(const SMDS_MeshNode *n1,
630 const SMDS_MeshNode *n2,
631 const SMDS_MeshNode *n3,
632 const SMDS_MeshNode *n4,
633 const SMDS_MeshNode *n5,
634 const SMDS_MeshNode *n6);
635 static const SMDS_MeshFace* FindFace(const SMDS_MeshNode *n1,
636 const SMDS_MeshNode *n2,
637 const SMDS_MeshNode *n3,
638 const SMDS_MeshNode *n4,
639 const SMDS_MeshNode *n5,
640 const SMDS_MeshNode *n6,
641 const SMDS_MeshNode *n7,
642 const SMDS_MeshNode *n8);
644 const SMDS_MeshFace *FindFace(const std::vector<int>& nodes_ids) const;
645 static const SMDS_MeshFace* FindFace(const std::vector<const SMDS_MeshNode *>& nodes);
646 static const SMDS_MeshElement* FindElement(const std::vector<const SMDS_MeshNode *>& nodes,
647 const SMDSAbs_ElementType type=SMDSAbs_All,
648 const bool noMedium=true);
651 * \brief Raise an exception if free memory (ram+swap) too low
652 * \param doNotRaise - if true, suppres exception, just return free memory size
653 * \retval int - amount of available memory in MB or negative number in failure case
655 static int CheckMemory(const bool doNotRaise=false) throw (std::bad_alloc);
657 int MaxNodeID() const;
658 int MinNodeID() const;
659 int MaxElementID() const;
660 int MinElementID() const;
662 const SMDS_MeshInfo& GetMeshInfo() const { return myInfo; }
664 virtual int NbNodes() const;
665 virtual int Nb0DElements() const;
666 virtual int NbEdges() const;
667 virtual int NbFaces() const;
668 virtual int NbVolumes() const;
669 virtual int NbSubMesh() const;
671 void DumpNodes() const;
672 void Dump0DElements() const;
673 void DumpEdges() const;
674 void DumpFaces() const;
675 void DumpVolumes() const;
676 void DebugStats() const;
678 virtual ~SMDS_Mesh();
680 bool hasConstructionEdges();
681 bool hasConstructionFaces();
682 bool hasInverseElements();
683 void setConstructionEdges(bool);
684 void setConstructionFaces(bool);
685 void setInverseElements(bool);
688 * Checks if the element is present in mesh.
689 * Useful to determine dead pointers.
690 * Use this function for debug purpose only! Do not check in the code
691 * using it even in _DEBUG_ mode
693 bool Contains (const SMDS_MeshElement* elem) const;
695 typedef std::vector<SMDS_MeshNode *> SetOfNodes;
696 typedef std::vector<SMDS_MeshCell *> SetOfCells;
698 void updateNodeMinMax();
699 void updateBoundingBox();
701 int fromVtkToSmds(int vtkid);
703 void incrementNodesCapacity(int nbNodes);
704 void incrementCellsCapacity(int nbCells);
705 void adjustStructure();
706 void dumpGrid(string ficdump="dumpGrid");
707 static int chunkSize;
709 //! low level modification: add, change or remove node or element
710 inline void setMyModified() { this->myModified = true; }
713 unsigned long GetMTime() const;
717 SMDS_Mesh(SMDS_Mesh * parent);
719 SMDS_MeshFace * createTriangle(const SMDS_MeshNode * node1,
720 const SMDS_MeshNode * node2,
721 const SMDS_MeshNode * node3,
723 SMDS_MeshFace * createQuadrangle(const SMDS_MeshNode * node1,
724 const SMDS_MeshNode * node2,
725 const SMDS_MeshNode * node3,
726 const SMDS_MeshNode * node4,
728 // SMDS_Mesh0DElement* Find0DElementOrCreate(const SMDS_MeshNode * n);
729 SMDS_MeshEdge* FindEdgeOrCreate(const SMDS_MeshNode * n1,
730 const SMDS_MeshNode * n2);
731 SMDS_MeshFace* FindFaceOrCreate(const SMDS_MeshNode *n1,
732 const SMDS_MeshNode *n2,
733 const SMDS_MeshNode *n3);
734 SMDS_MeshFace* FindFaceOrCreate(const SMDS_MeshNode *n1,
735 const SMDS_MeshNode *n2,
736 const SMDS_MeshNode *n3,
737 const SMDS_MeshNode *n4);
739 bool registerElement(int ID, SMDS_MeshElement * element);
741 void addChildrenWithNodes(std::set<const SMDS_MeshElement*>& setOfChildren,
742 const SMDS_MeshElement * element,
743 std::set<const SMDS_MeshElement*>& nodes);
745 inline void adjustmyCellsCapacity(int ID)
748 myElementIDFactory->adjustMaxId(ID);
749 if (ID >= myCells.size())
750 myCells.resize(ID+SMDS_Mesh::chunkSize,0);
753 inline void adjustBoundingBox(double x, double y, double z)
755 if (x > xmax) xmax = x;
756 else if (x < xmin) xmin = x;
757 if (y > ymax) ymax = y;
758 else if (y < ymin) ymin = y;
759 if (z > zmax) zmax = z;
760 else if (z < zmin) zmin = z;
765 //! index of this SMDS_mesh in the static vector<SMDS_Mesh*> _meshList
768 //! actual nodes coordinates, cells definition and reverse connectivity are stored in a vtkUnstructuredGrid
769 SMDS_UnstructuredGrid* myGrid;
771 //! Small objects like SMDS_MeshNode are allocated by chunks to limit memory costs of new
772 ObjectPool<SMDS_MeshNode>* myNodePool;
774 //! Small objects like SMDS_VtkVolume are allocated by chunks to limit memory costs of new
775 ObjectPool<SMDS_VtkVolume>* myVolumePool;
776 ObjectPool<SMDS_VtkFace>* myFacePool;
777 ObjectPool<SMDS_VtkEdge>* myEdgePool;
779 //! SMDS_MeshNodes refer to vtk nodes (vtk id = index in myNodes),store reference to this mesh, and sub-shape
782 //! SMDS_MeshCells refer to vtk cells (vtk id != index in myCells),store reference to this mesh, and sub-shape
785 //! for cells only: index = ID for SMDS users, value = ID in vtkUnstructuredGrid
786 //std::vector<int> myCellIdSmdsToVtk;
788 //! for cells only: index = ID in vtkUnstructuredGrid, value = ID for SMDS users
789 std::vector<int> myCellIdVtkToSmds;
791 SMDS_Mesh * myParent;
792 std::list<SMDS_Mesh *> myChildren;
793 SMDS_MeshNodeIDFactory *myNodeIDFactory;
794 SMDS_MeshElementIDFactory *myElementIDFactory;
795 SMDS_MeshInfo myInfo;
797 //! use a counter to keep track of modifications
798 unsigned long myModifTime, myCompactTime;
803 bool myHasConstructionEdges;
804 bool myHasConstructionFaces;
805 bool myHasInverseElements;
807 //! any add, remove or change of node or cell