1 // Copyright (C) 2007-2013 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"
48 #include "SMDS_BallElement.hxx"
50 #include <boost/shared_ptr.hpp>
54 #include <vtkSystemIncludes.h>
57 #include "Utils_SALOME_Exception.hxx"
59 #define MYASSERT(val) if (!(val)) throw SALOME_Exception(LOCALIZED("assertion not verified"));
61 class SMDS_EXPORT SMDS_Mesh:public SMDS_MeshObject
64 friend class SMDS_MeshIDFactory;
65 friend class SMDS_MeshNodeIDFactory;
66 friend class SMDS_MeshElementIDFactory;
67 friend class SMDS_MeshVolumeVtkNodes;
68 friend class SMDS_MeshNode;
72 //! to retreive this SMDS_Mesh instance from its elements (index stored in SMDS_Elements)
73 static std::vector<SMDS_Mesh*> _meshList;
75 //! actual nodes coordinates, cells definition and reverse connectivity are stored in a vtkUnstructuredGrid
76 inline SMDS_UnstructuredGrid* getGrid() {return myGrid; }
77 inline int getMeshId() {return myMeshId; }
79 virtual SMDS_NodeIteratorPtr nodesIterator (bool idInceasingOrder=false) const;
80 virtual SMDS_EdgeIteratorPtr edgesIterator (bool idInceasingOrder=false) const;
81 virtual SMDS_FaceIteratorPtr facesIterator (bool idInceasingOrder=false) const;
82 virtual SMDS_VolumeIteratorPtr volumesIterator (bool idInceasingOrder=false) const;
84 virtual SMDS_ElemIteratorPtr elementsIterator(SMDSAbs_ElementType type=SMDSAbs_All) const;
85 virtual SMDS_ElemIteratorPtr elementGeomIterator(SMDSAbs_GeometryType type) const;
86 virtual SMDS_ElemIteratorPtr elementEntityIterator(SMDSAbs_EntityType type) const;
88 SMDSAbs_ElementType GetElementType( const int id, const bool iselem ) const;
90 SMDS_Mesh *AddSubMesh();
92 virtual SMDS_MeshNode* AddNodeWithID(double x, double y, double z, int ID);
93 virtual SMDS_MeshNode* AddNode (double x, double y, double z);
95 virtual SMDS_Mesh0DElement* Add0DElementWithID(int n, int ID);
96 virtual SMDS_Mesh0DElement* Add0DElementWithID(const SMDS_MeshNode * n, int ID);
97 virtual SMDS_Mesh0DElement* Add0DElement (const SMDS_MeshNode * n);
99 virtual SMDS_BallElement* AddBallWithID(int n, double diameter, int ID);
100 virtual SMDS_BallElement* AddBallWithID(const SMDS_MeshNode * n, double diameter, int ID);
101 virtual SMDS_BallElement* AddBall (const SMDS_MeshNode * n, double diameter);
103 virtual SMDS_MeshEdge* AddEdgeWithID(int n1, int n2, int ID);
104 virtual SMDS_MeshEdge* AddEdgeWithID(const SMDS_MeshNode * n1,
105 const SMDS_MeshNode * n2,
107 virtual SMDS_MeshEdge* AddEdge(const SMDS_MeshNode * n1,
108 const SMDS_MeshNode * n2);
110 // 2d order edge with 3 nodes: n12 - node between n1 and n2
111 virtual SMDS_MeshEdge* AddEdgeWithID(int n1, int n2, int n12, int ID);
112 virtual SMDS_MeshEdge* AddEdgeWithID(const SMDS_MeshNode * n1,
113 const SMDS_MeshNode * n2,
114 const SMDS_MeshNode * n12,
116 virtual SMDS_MeshEdge* AddEdge(const SMDS_MeshNode * n1,
117 const SMDS_MeshNode * n2,
118 const SMDS_MeshNode * n12);
120 virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3, int ID);
121 virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
122 const SMDS_MeshNode * n2,
123 const SMDS_MeshNode * n3,
125 virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
126 const SMDS_MeshNode * n2,
127 const SMDS_MeshNode * n3);
129 virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3, int n4, int ID);
130 virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
131 const SMDS_MeshNode * n2,
132 const SMDS_MeshNode * n3,
133 const SMDS_MeshNode * n4,
135 virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
136 const SMDS_MeshNode * n2,
137 const SMDS_MeshNode * n3,
138 const SMDS_MeshNode * n4);
140 virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshEdge * e1,
141 const SMDS_MeshEdge * e2,
142 const SMDS_MeshEdge * e3, int ID);
143 virtual SMDS_MeshFace* AddFace(const SMDS_MeshEdge * e1,
144 const SMDS_MeshEdge * e2,
145 const SMDS_MeshEdge * e3);
147 virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshEdge * e1,
148 const SMDS_MeshEdge * e2,
149 const SMDS_MeshEdge * e3,
150 const SMDS_MeshEdge * e4, int ID);
151 virtual SMDS_MeshFace* AddFace(const SMDS_MeshEdge * e1,
152 const SMDS_MeshEdge * e2,
153 const SMDS_MeshEdge * e3,
154 const SMDS_MeshEdge * e4);
156 // 2d order triangle of 6 nodes
157 virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3,
158 int n12,int n23,int n31, int ID);
159 virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
160 const SMDS_MeshNode * n2,
161 const SMDS_MeshNode * n3,
162 const SMDS_MeshNode * n12,
163 const SMDS_MeshNode * n23,
164 const SMDS_MeshNode * n31,
166 virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
167 const SMDS_MeshNode * n2,
168 const SMDS_MeshNode * n3,
169 const SMDS_MeshNode * n12,
170 const SMDS_MeshNode * n23,
171 const SMDS_MeshNode * n31);
173 // 2d order quadrangle
174 virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3, int n4,
175 int n12,int n23,int n34,int n41, int ID);
176 virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
177 const SMDS_MeshNode * n2,
178 const SMDS_MeshNode * n3,
179 const SMDS_MeshNode * n4,
180 const SMDS_MeshNode * n12,
181 const SMDS_MeshNode * n23,
182 const SMDS_MeshNode * n34,
183 const SMDS_MeshNode * n41,
185 virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
186 const SMDS_MeshNode * n2,
187 const SMDS_MeshNode * n3,
188 const SMDS_MeshNode * n4,
189 const SMDS_MeshNode * n12,
190 const SMDS_MeshNode * n23,
191 const SMDS_MeshNode * n34,
192 const SMDS_MeshNode * n41);
194 virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3, int n4,
195 int n12,int n23,int n34,int n41, int nCenter, int ID);
196 virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
197 const SMDS_MeshNode * n2,
198 const SMDS_MeshNode * n3,
199 const SMDS_MeshNode * n4,
200 const SMDS_MeshNode * n12,
201 const SMDS_MeshNode * n23,
202 const SMDS_MeshNode * n34,
203 const SMDS_MeshNode * n41,
204 const SMDS_MeshNode * nCenter,
206 virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
207 const SMDS_MeshNode * n2,
208 const SMDS_MeshNode * n3,
209 const SMDS_MeshNode * n4,
210 const SMDS_MeshNode * n12,
211 const SMDS_MeshNode * n23,
212 const SMDS_MeshNode * n34,
213 const SMDS_MeshNode * n41,
214 const SMDS_MeshNode * nCenter);
216 virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int ID);
217 virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
218 const SMDS_MeshNode * n2,
219 const SMDS_MeshNode * n3,
220 const SMDS_MeshNode * n4,
222 virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
223 const SMDS_MeshNode * n2,
224 const SMDS_MeshNode * n3,
225 const SMDS_MeshNode * n4);
227 virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
229 virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
230 const SMDS_MeshNode * n2,
231 const SMDS_MeshNode * n3,
232 const SMDS_MeshNode * n4,
233 const SMDS_MeshNode * n5,
235 virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
236 const SMDS_MeshNode * n2,
237 const SMDS_MeshNode * n3,
238 const SMDS_MeshNode * n4,
239 const SMDS_MeshNode * n5);
241 virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
242 int n5, int n6, int ID);
243 virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
244 const SMDS_MeshNode * n2,
245 const SMDS_MeshNode * n3,
246 const SMDS_MeshNode * n4,
247 const SMDS_MeshNode * n5,
248 const SMDS_MeshNode * n6,
250 virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
251 const SMDS_MeshNode * n2,
252 const SMDS_MeshNode * n3,
253 const SMDS_MeshNode * n4,
254 const SMDS_MeshNode * n5,
255 const SMDS_MeshNode * n6);
257 virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
258 int n5, int n6, int n7, int n8, int ID);
259 virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
260 const SMDS_MeshNode * n2,
261 const SMDS_MeshNode * n3,
262 const SMDS_MeshNode * n4,
263 const SMDS_MeshNode * n5,
264 const SMDS_MeshNode * n6,
265 const SMDS_MeshNode * n7,
266 const SMDS_MeshNode * n8,
268 virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
269 const SMDS_MeshNode * n2,
270 const SMDS_MeshNode * n3,
271 const SMDS_MeshNode * n4,
272 const SMDS_MeshNode * n5,
273 const SMDS_MeshNode * n6,
274 const SMDS_MeshNode * n7,
275 const SMDS_MeshNode * n8);
277 virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshFace * f1,
278 const SMDS_MeshFace * f2,
279 const SMDS_MeshFace * f3,
280 const SMDS_MeshFace * f4, int ID);
281 virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshFace * f1,
282 const SMDS_MeshFace * f2,
283 const SMDS_MeshFace * f3,
284 const SMDS_MeshFace * f4);
286 virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshFace * f1,
287 const SMDS_MeshFace * f2,
288 const SMDS_MeshFace * f3,
289 const SMDS_MeshFace * f4,
290 const SMDS_MeshFace * f5, int ID);
291 virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshFace * f1,
292 const SMDS_MeshFace * f2,
293 const SMDS_MeshFace * f3,
294 const SMDS_MeshFace * f4,
295 const SMDS_MeshFace * f5);
297 virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshFace * f1,
298 const SMDS_MeshFace * f2,
299 const SMDS_MeshFace * f3,
300 const SMDS_MeshFace * f4,
301 const SMDS_MeshFace * f5,
302 const SMDS_MeshFace * f6, int ID);
303 virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshFace * f1,
304 const SMDS_MeshFace * f2,
305 const SMDS_MeshFace * f3,
306 const SMDS_MeshFace * f4,
307 const SMDS_MeshFace * f5,
308 const SMDS_MeshFace * f6);
311 virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, int n6,
312 int n7, int n8, int n9, int n10, int n11, int n12,
314 virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
315 const SMDS_MeshNode * n2,
316 const SMDS_MeshNode * n3,
317 const SMDS_MeshNode * n4,
318 const SMDS_MeshNode * n5,
319 const SMDS_MeshNode * n6,
320 const SMDS_MeshNode * n7,
321 const SMDS_MeshNode * n8,
322 const SMDS_MeshNode * n9,
323 const SMDS_MeshNode * n10,
324 const SMDS_MeshNode * n11,
325 const SMDS_MeshNode * n12,
327 virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
328 const SMDS_MeshNode * n2,
329 const SMDS_MeshNode * n3,
330 const SMDS_MeshNode * n4,
331 const SMDS_MeshNode * n5,
332 const SMDS_MeshNode * n6,
333 const SMDS_MeshNode * n7,
334 const SMDS_MeshNode * n8,
335 const SMDS_MeshNode * n9,
336 const SMDS_MeshNode * n10,
337 const SMDS_MeshNode * n11,
338 const SMDS_MeshNode * n12);
340 // 2d order tetrahedron of 10 nodes
341 virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
342 int n12,int n23,int n31,
343 int n14,int n24,int n34, int ID);
344 virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
345 const SMDS_MeshNode * n2,
346 const SMDS_MeshNode * n3,
347 const SMDS_MeshNode * n4,
348 const SMDS_MeshNode * n12,
349 const SMDS_MeshNode * n23,
350 const SMDS_MeshNode * n31,
351 const SMDS_MeshNode * n14,
352 const SMDS_MeshNode * n24,
353 const SMDS_MeshNode * n34,
355 virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
356 const SMDS_MeshNode * n2,
357 const SMDS_MeshNode * n3,
358 const SMDS_MeshNode * n4,
359 const SMDS_MeshNode * n12,
360 const SMDS_MeshNode * n23,
361 const SMDS_MeshNode * n31,
362 const SMDS_MeshNode * n14,
363 const SMDS_MeshNode * n24,
364 const SMDS_MeshNode * n34);
366 // 2d order pyramid of 13 nodes
367 virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int n5,
368 int n12,int n23,int n34,int n41,
369 int n15,int n25,int n35,int n45,
371 virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
372 const SMDS_MeshNode * n2,
373 const SMDS_MeshNode * n3,
374 const SMDS_MeshNode * n4,
375 const SMDS_MeshNode * n5,
376 const SMDS_MeshNode * n12,
377 const SMDS_MeshNode * n23,
378 const SMDS_MeshNode * n34,
379 const SMDS_MeshNode * n41,
380 const SMDS_MeshNode * n15,
381 const SMDS_MeshNode * n25,
382 const SMDS_MeshNode * n35,
383 const SMDS_MeshNode * n45,
385 virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
386 const SMDS_MeshNode * n2,
387 const SMDS_MeshNode * n3,
388 const SMDS_MeshNode * n4,
389 const SMDS_MeshNode * n5,
390 const SMDS_MeshNode * n12,
391 const SMDS_MeshNode * n23,
392 const SMDS_MeshNode * n34,
393 const SMDS_MeshNode * n41,
394 const SMDS_MeshNode * n15,
395 const SMDS_MeshNode * n25,
396 const SMDS_MeshNode * n35,
397 const SMDS_MeshNode * n45);
399 // 2d order Pentahedron with 15 nodes
400 virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3,
401 int n4, int n5, int n6,
402 int n12,int n23,int n31,
403 int n45,int n56,int n64,
404 int n14,int n25,int n36,
406 virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
407 const SMDS_MeshNode * n2,
408 const SMDS_MeshNode * n3,
409 const SMDS_MeshNode * n4,
410 const SMDS_MeshNode * n5,
411 const SMDS_MeshNode * n6,
412 const SMDS_MeshNode * n12,
413 const SMDS_MeshNode * n23,
414 const SMDS_MeshNode * n31,
415 const SMDS_MeshNode * n45,
416 const SMDS_MeshNode * n56,
417 const SMDS_MeshNode * n64,
418 const SMDS_MeshNode * n14,
419 const SMDS_MeshNode * n25,
420 const SMDS_MeshNode * n36,
422 virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
423 const SMDS_MeshNode * n2,
424 const SMDS_MeshNode * n3,
425 const SMDS_MeshNode * n4,
426 const SMDS_MeshNode * n5,
427 const SMDS_MeshNode * n6,
428 const SMDS_MeshNode * n12,
429 const SMDS_MeshNode * n23,
430 const SMDS_MeshNode * n31,
431 const SMDS_MeshNode * n45,
432 const SMDS_MeshNode * n56,
433 const SMDS_MeshNode * n64,
434 const SMDS_MeshNode * n14,
435 const SMDS_MeshNode * n25,
436 const SMDS_MeshNode * n36);
438 // 2d oreder Hexahedrons with 20 nodes
439 virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
440 int n5, int n6, int n7, int n8,
441 int n12,int n23,int n34,int n41,
442 int n56,int n67,int n78,int n85,
443 int n15,int n26,int n37,int n48,
445 virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
446 const SMDS_MeshNode * n2,
447 const SMDS_MeshNode * n3,
448 const SMDS_MeshNode * n4,
449 const SMDS_MeshNode * n5,
450 const SMDS_MeshNode * n6,
451 const SMDS_MeshNode * n7,
452 const SMDS_MeshNode * n8,
453 const SMDS_MeshNode * n12,
454 const SMDS_MeshNode * n23,
455 const SMDS_MeshNode * n34,
456 const SMDS_MeshNode * n41,
457 const SMDS_MeshNode * n56,
458 const SMDS_MeshNode * n67,
459 const SMDS_MeshNode * n78,
460 const SMDS_MeshNode * n85,
461 const SMDS_MeshNode * n15,
462 const SMDS_MeshNode * n26,
463 const SMDS_MeshNode * n37,
464 const SMDS_MeshNode * n48,
466 virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
467 const SMDS_MeshNode * n2,
468 const SMDS_MeshNode * n3,
469 const SMDS_MeshNode * n4,
470 const SMDS_MeshNode * n5,
471 const SMDS_MeshNode * n6,
472 const SMDS_MeshNode * n7,
473 const SMDS_MeshNode * n8,
474 const SMDS_MeshNode * n12,
475 const SMDS_MeshNode * n23,
476 const SMDS_MeshNode * n34,
477 const SMDS_MeshNode * n41,
478 const SMDS_MeshNode * n56,
479 const SMDS_MeshNode * n67,
480 const SMDS_MeshNode * n78,
481 const SMDS_MeshNode * n85,
482 const SMDS_MeshNode * n15,
483 const SMDS_MeshNode * n26,
484 const SMDS_MeshNode * n37,
485 const SMDS_MeshNode * n48);
487 // 2d oreder Hexahedrons with 27 nodes
488 virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
489 int n5, int n6, int n7, int n8,
490 int n12,int n23,int n34,int n41,
491 int n56,int n67,int n78,int n85,
492 int n15,int n26,int n37,int n48,
493 int n1234,int n1256,int n2367,int n3478,
494 int n1458,int n5678,int nCenter,
496 virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
497 const SMDS_MeshNode * n2,
498 const SMDS_MeshNode * n3,
499 const SMDS_MeshNode * n4,
500 const SMDS_MeshNode * n5,
501 const SMDS_MeshNode * n6,
502 const SMDS_MeshNode * n7,
503 const SMDS_MeshNode * n8,
504 const SMDS_MeshNode * n12,
505 const SMDS_MeshNode * n23,
506 const SMDS_MeshNode * n34,
507 const SMDS_MeshNode * n41,
508 const SMDS_MeshNode * n56,
509 const SMDS_MeshNode * n67,
510 const SMDS_MeshNode * n78,
511 const SMDS_MeshNode * n85,
512 const SMDS_MeshNode * n15,
513 const SMDS_MeshNode * n26,
514 const SMDS_MeshNode * n37,
515 const SMDS_MeshNode * n48,
516 const SMDS_MeshNode * n1234,
517 const SMDS_MeshNode * n1256,
518 const SMDS_MeshNode * n2367,
519 const SMDS_MeshNode * n3478,
520 const SMDS_MeshNode * n1458,
521 const SMDS_MeshNode * n5678,
522 const SMDS_MeshNode * nCenter,
524 virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
525 const SMDS_MeshNode * n2,
526 const SMDS_MeshNode * n3,
527 const SMDS_MeshNode * n4,
528 const SMDS_MeshNode * n5,
529 const SMDS_MeshNode * n6,
530 const SMDS_MeshNode * n7,
531 const SMDS_MeshNode * n8,
532 const SMDS_MeshNode * n12,
533 const SMDS_MeshNode * n23,
534 const SMDS_MeshNode * n34,
535 const SMDS_MeshNode * n41,
536 const SMDS_MeshNode * n56,
537 const SMDS_MeshNode * n67,
538 const SMDS_MeshNode * n78,
539 const SMDS_MeshNode * n85,
540 const SMDS_MeshNode * n15,
541 const SMDS_MeshNode * n26,
542 const SMDS_MeshNode * n37,
543 const SMDS_MeshNode * n48,
544 const SMDS_MeshNode * n1234,
545 const SMDS_MeshNode * n1256,
546 const SMDS_MeshNode * n2367,
547 const SMDS_MeshNode * n3478,
548 const SMDS_MeshNode * n1458,
549 const SMDS_MeshNode * n5678,
550 const SMDS_MeshNode * nCenter);
552 virtual SMDS_MeshFace* AddPolygonalFaceWithID (const std::vector<int> & nodes_ids,
555 virtual SMDS_MeshFace* AddPolygonalFaceWithID (const std::vector<const SMDS_MeshNode*> & nodes,
558 virtual SMDS_MeshFace* AddPolygonalFace (const std::vector<const SMDS_MeshNode*> & nodes);
560 virtual SMDS_MeshVolume* AddPolyhedralVolumeWithID
561 (const std::vector<int> & nodes_ids,
562 const std::vector<int> & quantities,
565 virtual SMDS_MeshVolume* AddPolyhedralVolumeWithID
566 (const std::vector<const SMDS_MeshNode*> & nodes,
567 const std::vector<int> & quantities,
570 virtual SMDS_MeshVolume* AddPolyhedralVolume
571 (const std::vector<const SMDS_MeshNode*> & nodes,
572 const std::vector<int> & quantities);
574 virtual SMDS_MeshVolume* AddVolumeFromVtkIds(const std::vector<vtkIdType>& vtkNodeIds);
576 virtual SMDS_MeshVolume* AddVolumeFromVtkIdsWithID(const std::vector<vtkIdType>& vtkNodeIds,
579 virtual SMDS_MeshFace* AddFaceFromVtkIds(const std::vector<vtkIdType>& vtkNodeIds);
581 virtual SMDS_MeshFace* AddFaceFromVtkIdsWithID(const std::vector<vtkIdType>& vtkNodeIds,
584 virtual void RemoveElement(const SMDS_MeshElement * elem,
585 std::list<const SMDS_MeshElement *>& removedElems,
586 std::list<const SMDS_MeshElement *>& removedNodes,
587 const bool removenodes = false);
588 virtual void RemoveElement(const SMDS_MeshElement * elem, bool removenodes = false);
589 virtual void RemoveNode(const SMDS_MeshNode * node);
590 virtual void Remove0DElement(const SMDS_Mesh0DElement * elem0d);
591 virtual void RemoveEdge(const SMDS_MeshEdge * edge);
592 virtual void RemoveFace(const SMDS_MeshFace * face);
593 virtual void RemoveVolume(const SMDS_MeshVolume * volume);
595 /*! Remove only the given element and only if it is free.
596 * Method does not work for meshes with descendants.
597 * Implemented for fast cleaning of meshes.
599 virtual void RemoveFreeElement(const SMDS_MeshElement * elem);
601 virtual void Clear();
603 virtual bool RemoveFromParent();
604 virtual bool RemoveSubMesh(const SMDS_Mesh * aMesh);
606 bool ChangeElementNodes(const SMDS_MeshElement * elem,
607 const SMDS_MeshNode * nodes[],
609 bool ChangePolyhedronNodes(const SMDS_MeshElement * elem,
610 const std::vector<const SMDS_MeshNode*>& nodes,
611 const std::vector<int> & quantities);
613 virtual void Renumber (const bool isNodes, const int startID = 1, const int deltaID = 1);
614 // Renumber all nodes or elements.
615 virtual void compactMesh();
617 const SMDS_MeshNode *FindNode(int idnode) const;
618 const SMDS_MeshNode *FindNodeVtk(int idnode) const;
619 const SMDS_Mesh0DElement* Find0DElement(int idnode) const;
620 const SMDS_BallElement* FindBall(int idnode) const;
621 const SMDS_MeshEdge *FindEdge(int idnode1, int idnode2) const;
622 const SMDS_MeshEdge *FindEdge(int idnode1, int idnode2, int idnode3) const;
623 const SMDS_MeshFace *FindFace(int idnode1, int idnode2, int idnode3) const;
624 const SMDS_MeshFace *FindFace(int idnode1, int idnode2, int idnode3, int idnode4) const;
625 const SMDS_MeshFace *FindFace(int idnode1, int idnode2, int idnode3,
626 int idnode4, int idnode5, int idnode6) const;
627 const SMDS_MeshFace *FindFace(int idnode1, int idnode2, int idnode3, int idnode4,
628 int idnode5, int idnode6, int idnode7, int idnode8) const;
629 const SMDS_MeshElement *FindElement(int IDelem) const;
630 static const SMDS_Mesh0DElement* Find0DElement(const SMDS_MeshNode * n);
631 static const SMDS_BallElement* FindBall(const SMDS_MeshNode * n);
632 static const SMDS_MeshEdge* FindEdge(const SMDS_MeshNode * n1,
633 const SMDS_MeshNode * n2);
634 static const SMDS_MeshEdge* FindEdge(const SMDS_MeshNode * n1,
635 const SMDS_MeshNode * n2,
636 const SMDS_MeshNode * n3);
637 static const SMDS_MeshFace* FindFace(const SMDS_MeshNode *n1,
638 const SMDS_MeshNode *n2,
639 const SMDS_MeshNode *n3);
640 static const SMDS_MeshFace* FindFace(const SMDS_MeshNode *n1,
641 const SMDS_MeshNode *n2,
642 const SMDS_MeshNode *n3,
643 const SMDS_MeshNode *n4);
644 static const SMDS_MeshFace* FindFace(const SMDS_MeshNode *n1,
645 const SMDS_MeshNode *n2,
646 const SMDS_MeshNode *n3,
647 const SMDS_MeshNode *n4,
648 const SMDS_MeshNode *n5,
649 const SMDS_MeshNode *n6);
650 static const SMDS_MeshFace* FindFace(const SMDS_MeshNode *n1,
651 const SMDS_MeshNode *n2,
652 const SMDS_MeshNode *n3,
653 const SMDS_MeshNode *n4,
654 const SMDS_MeshNode *n5,
655 const SMDS_MeshNode *n6,
656 const SMDS_MeshNode *n7,
657 const SMDS_MeshNode *n8);
659 const SMDS_MeshFace *FindFace(const std::vector<int>& nodes_ids) const;
660 static const SMDS_MeshFace* FindFace(const std::vector<const SMDS_MeshNode *>& nodes);
661 static const SMDS_MeshElement* FindElement(const std::vector<const SMDS_MeshNode *>& nodes,
662 const SMDSAbs_ElementType type=SMDSAbs_All,
663 const bool noMedium=true);
666 * \brief Raise an exception if free memory (ram+swap) too low
667 * \param doNotRaise - if true, suppres exception, just return free memory size
668 * \retval int - amount of available memory in MB or negative number in failure case
670 static int CheckMemory(const bool doNotRaise=false) throw (std::bad_alloc);
672 int MaxNodeID() const;
673 int MinNodeID() const;
674 int MaxElementID() const;
675 int MinElementID() const;
677 const SMDS_MeshInfo& GetMeshInfo() const { return myInfo; }
679 virtual int NbNodes() const;
680 virtual int Nb0DElements() const;
681 virtual int NbBalls() const;
682 virtual int NbEdges() const;
683 virtual int NbFaces() const;
684 virtual int NbVolumes() const;
685 virtual int NbSubMesh() const;
687 void DumpNodes() const;
688 void Dump0DElements() const;
689 void DumpEdges() const;
690 void DumpFaces() const;
691 void DumpVolumes() const;
692 void DebugStats() const;
694 virtual ~SMDS_Mesh();
696 bool hasConstructionEdges();
697 bool hasConstructionFaces();
698 bool hasInverseElements();
699 void setConstructionEdges(bool);
700 void setConstructionFaces(bool);
701 void setInverseElements(bool);
704 * Checks if the element is present in mesh.
705 * Useful to determine dead pointers.
706 * Use this function for debug purpose only! Do not check in the code
707 * using it even in _DEBUG_ mode
709 bool Contains (const SMDS_MeshElement* elem) const;
711 typedef std::vector<SMDS_MeshNode *> SetOfNodes;
712 typedef std::vector<SMDS_MeshCell *> SetOfCells;
714 void updateNodeMinMax();
715 void updateBoundingBox();
717 int fromVtkToSmds(int vtkid);
719 void incrementNodesCapacity(int nbNodes);
720 void incrementCellsCapacity(int nbCells);
721 void adjustStructure();
722 void dumpGrid(string ficdump="dumpGrid");
723 static int chunkSize;
725 //! low level modification: add, change or remove node or element
726 inline void setMyModified() { this->myModified = true; }
729 unsigned long GetMTime() const;
733 SMDS_Mesh(SMDS_Mesh * parent);
735 SMDS_MeshFace * createTriangle(const SMDS_MeshNode * node1,
736 const SMDS_MeshNode * node2,
737 const SMDS_MeshNode * node3,
739 SMDS_MeshFace * createQuadrangle(const SMDS_MeshNode * node1,
740 const SMDS_MeshNode * node2,
741 const SMDS_MeshNode * node3,
742 const SMDS_MeshNode * node4,
744 SMDS_MeshEdge* FindEdgeOrCreate(const SMDS_MeshNode * n1,
745 const SMDS_MeshNode * n2);
746 SMDS_MeshFace* FindFaceOrCreate(const SMDS_MeshNode *n1,
747 const SMDS_MeshNode *n2,
748 const SMDS_MeshNode *n3);
749 SMDS_MeshFace* FindFaceOrCreate(const SMDS_MeshNode *n1,
750 const SMDS_MeshNode *n2,
751 const SMDS_MeshNode *n3,
752 const SMDS_MeshNode *n4);
754 bool registerElement(int ID, SMDS_MeshElement * element);
756 void addChildrenWithNodes(std::set<const SMDS_MeshElement*>& setOfChildren,
757 const SMDS_MeshElement * element,
758 std::set<const SMDS_MeshElement*>& nodes);
760 inline void adjustmyCellsCapacity(int ID)
763 myElementIDFactory->adjustMaxId(ID);
764 if (ID >= myCells.size())
765 myCells.resize(ID+SMDS_Mesh::chunkSize,0);
768 inline void adjustBoundingBox(double x, double y, double z)
770 if (x > xmax) xmax = x;
771 else if (x < xmin) xmin = x;
772 if (y > ymax) ymax = y;
773 else if (y < ymin) ymin = y;
774 if (z > zmax) zmax = z;
775 else if (z < zmin) zmin = z;
780 //! index of this SMDS_mesh in the static vector<SMDS_Mesh*> _meshList
783 //! actual nodes coordinates, cells definition and reverse connectivity are stored in a vtkUnstructuredGrid
784 SMDS_UnstructuredGrid* myGrid;
786 //! Small objects like SMDS_MeshNode are allocated by chunks to limit memory costs of new
787 ObjectPool<SMDS_MeshNode>* myNodePool;
789 //! Small objects like SMDS_VtkVolume are allocated by chunks to limit memory costs of new
790 ObjectPool<SMDS_VtkVolume>* myVolumePool;
791 ObjectPool<SMDS_VtkFace>* myFacePool;
792 ObjectPool<SMDS_VtkEdge>* myEdgePool;
793 ObjectPool<SMDS_BallElement>* myBallPool;
795 //! SMDS_MeshNodes refer to vtk nodes (vtk id = index in myNodes),store reference to this mesh, and sub-shape
798 //! SMDS_MeshCells refer to vtk cells (vtk id != index in myCells),store reference to this mesh, and sub-shape
801 //! for cells only: index = ID for SMDS users, value = ID in vtkUnstructuredGrid
802 //std::vector<int> myCellIdSmdsToVtk;
804 //! for cells only: index = ID in vtkUnstructuredGrid, value = ID for SMDS users
805 std::vector<int> myCellIdVtkToSmds;
807 SMDS_Mesh * myParent;
808 std::list<SMDS_Mesh *> myChildren;
809 SMDS_MeshNodeIDFactory *myNodeIDFactory;
810 SMDS_MeshElementIDFactory *myElementIDFactory;
811 SMDS_MeshInfo myInfo;
813 //! use a counter to keep track of modifications
814 unsigned long myModifTime, myCompactTime;
819 bool myHasConstructionEdges;
820 bool myHasConstructionFaces;
821 bool myHasInverseElements;
823 //! any add, remove or change of node or cell