Version: 8.3.0
SMDS_MeshInfo.hxx
Go to the documentation of this file.
1 // Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
2 //
3 // This library is free software; you can redistribute it and/or
4 // modify it under the terms of the GNU Lesser General Public
5 // License as published by the Free Software Foundation; either
6 // version 2.1 of the License, or (at your option) any later version.
7 //
8 // This library is distributed in the hope that it will be useful,
9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 // Lesser General Public License for more details.
12 //
13 // You should have received a copy of the GNU Lesser General Public
14 // License along with this library; if not, write to the Free Software
15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16 //
17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
18 //
19 
20 // File : SMDS_MeshInfo.hxx
21 // Created : Mon Sep 24 18:32:41 2007
22 // Author : Edward AGAPOV (eap)
23 //
24 #ifndef SMDS_MeshInfo_HeaderFile
25 #define SMDS_MeshInfo_HeaderFile
26 
27 #include <vector>
28 
29 #include "SMESH_SMDS.hxx"
30 
31 #include "SMDS_MeshElement.hxx"
32 
33 class SMDS_EXPORT SMDS_MeshInfo
34 {
35 public:
36 
37  inline SMDS_MeshInfo();
38  inline SMDS_MeshInfo& operator=(const SMDS_MeshInfo& other);
39  inline void Clear();
40 
41  inline int NbElements(SMDSAbs_ElementType type=SMDSAbs_All) const;
42  inline int NbElements(SMDSAbs_EntityType type) const { return NbEntities(type); }
43  inline int NbElements(SMDSAbs_GeometryType type) const { return NbElementsOfGeom(type); }
44 
45  inline int NbEntities(SMDSAbs_EntityType type) const;
46  inline int NbElementsOfGeom(SMDSAbs_GeometryType geom) const;
47 
48  int NbNodes() const { return myNbNodes; }
49  int Nb0DElements() const { return myNb0DElements; }
50  int NbBalls() const { return myNbBalls; }
51  inline int NbEdges (SMDSAbs_ElementOrder order = ORDER_ANY) const;
52 
53  inline int NbFaces (SMDSAbs_ElementOrder order = ORDER_ANY) const;
54  inline int NbTriangles (SMDSAbs_ElementOrder order = ORDER_ANY) const;
55  inline int NbQuadrangles(SMDSAbs_ElementOrder order = ORDER_ANY) const;
56  int NbBiQuadTriangles() const { return myNbBiQuadTriangles; }
57  int NbBiQuadQuadrangles() const { return myNbBiQuadQuadrangles; }
58  inline int NbPolygons(SMDSAbs_ElementOrder order = ORDER_ANY) const;
59 
60  inline int NbVolumes (SMDSAbs_ElementOrder order = ORDER_ANY) const;
61  inline int NbTetras (SMDSAbs_ElementOrder order = ORDER_ANY) const;
62  inline int NbHexas (SMDSAbs_ElementOrder order = ORDER_ANY) const;
63  inline int NbPyramids(SMDSAbs_ElementOrder order = ORDER_ANY) const;
64  inline int NbPrisms (SMDSAbs_ElementOrder order = ORDER_ANY) const;
65  inline int NbHexPrisms(SMDSAbs_ElementOrder order = ORDER_ANY) const;
66  int NbTriQuadHexas() const { return myNbTriQuadHexas; }
67  int NbPolyhedrons() const { return myNbPolyhedrons; }
68 
69 protected:
70  inline void addWithPoly(const SMDS_MeshElement* el);
71  inline void setNb(const SMDSAbs_EntityType geomType, const int nb);
72 
73 private:
74  friend class SMDS_Mesh;
75 
76  // methods to count NOT POLY elements
77  inline void remove(const SMDS_MeshElement* el);
78  inline void add (const SMDS_MeshElement* el);
79  inline int index(SMDSAbs_ElementType type, int nbNodes) const;
80  // methods to remove elements of ANY kind
81  inline void RemoveEdge(const SMDS_MeshElement* el);
82  inline void RemoveFace(const SMDS_MeshElement* el);
83  inline void RemoveVolume(const SMDS_MeshElement* el);
84 
85  int myNbNodes;
86 
87  int myNb0DElements;
88  int myNbBalls;
89  int myNbEdges , myNbQuadEdges ;
90  int myNbTriangles , myNbQuadTriangles, myNbBiQuadTriangles ;
91  int myNbQuadrangles, myNbQuadQuadrangles, myNbBiQuadQuadrangles;
92  int myNbPolygons , myNbQuadPolygons;
93 
94  int myNbTetras , myNbQuadTetras ;
95  int myNbHexas , myNbQuadHexas, myNbTriQuadHexas;
96  int myNbPyramids, myNbQuadPyramids;
97  int myNbPrisms , myNbQuadPrisms ;
98  int myNbHexPrism;
99  int myNbPolyhedrons;
100 
101  std::vector<int*> myNb; // pointers to myNb... fields
102  std::vector<int> myShift; // shift to get an index in myNb by elem->NbNodes()
103 };
104 
105 inline SMDS_MeshInfo::SMDS_MeshInfo():
106  myNbNodes (0),
107  myNb0DElements (0),
108  myNbBalls (0),
109  myNbEdges (0), myNbQuadEdges (0),
110  myNbTriangles (0), myNbQuadTriangles (0), myNbBiQuadTriangles(0),
111  myNbQuadrangles(0), myNbQuadQuadrangles(0), myNbBiQuadQuadrangles(0),
112  myNbPolygons (0), myNbQuadPolygons (0),
113  myNbTetras (0), myNbQuadTetras (0),
114  myNbHexas (0), myNbQuadHexas (0), myNbTriQuadHexas(0),
115  myNbPyramids (0), myNbQuadPyramids(0),
116  myNbPrisms (0), myNbQuadPrisms (0),
117  myNbHexPrism (0),
118  myNbPolyhedrons(0)
119 {
120  // Number of nodes in standard element types (. - actual nb, * - after the shift)
121  // n v f e 0 n b
122  // o o a d d o a
123  // d l c g d l
124  // e e e e l
125  // s
126  // ====================
127  // 0 ------------------ - DON't USE 0!!!
128  // 1 . * .
129  // 2 . *
130  // 3 . . *
131  // 4 * .
132  // 5 *
133  // 6 * .
134  // 7 .
135  // 8 * .
136  // 9 .
137  // 10 *
138  // 11
139  // 12 *
140  // 13 *
141  // 14
142  // 15 *
143  // 16 *
144  // 17 *
145  // 18 *
146  // 19 *
147  // 20 *
148  // 21 *
149  // 22 *
150  // 23 *
151  // 24 *
152  // 25
153  // 26
154  // 27 *
155  //
156  // So to have a unique index for each type basing on nb of nodes, we use a shift:
157  myShift.resize(SMDSAbs_NbElementTypes, 0);
158 
159  myShift[ SMDSAbs_Face ] = +15;// 3->18, 4->19, etc.
160  myShift[ SMDSAbs_Edge ] = +14;// 2->16, 3->17
161  myShift[ SMDSAbs_0DElement ] = +2; // 1->3
162  myShift[ SMDSAbs_Ball ] = +1; // 1->2
163 
164  myNb.resize( index( SMDSAbs_Volume,27 ) + 1, NULL);
165 
166  myNb[ index( SMDSAbs_Node,1 )] = & myNbNodes;
167  myNb[ index( SMDSAbs_0DElement,1 )] = & myNb0DElements;
168  myNb[ index( SMDSAbs_Ball,1 )] = & myNbBalls;
169 
170  myNb[ index( SMDSAbs_Edge,2 )] = & myNbEdges;
171  myNb[ index( SMDSAbs_Edge,3 )] = & myNbQuadEdges;
172 
173  myNb[ index( SMDSAbs_Face,3 )] = & myNbTriangles;
174  myNb[ index( SMDSAbs_Face,4 )] = & myNbQuadrangles;
175  myNb[ index( SMDSAbs_Face,6 )] = & myNbQuadTriangles;
176  myNb[ index( SMDSAbs_Face,7 )] = & myNbBiQuadTriangles;
177  myNb[ index( SMDSAbs_Face,8 )] = & myNbQuadQuadrangles;
178  myNb[ index( SMDSAbs_Face,9 )] = & myNbBiQuadQuadrangles;
179 
180  myNb[ index( SMDSAbs_Volume, 4)] = & myNbTetras;
181  myNb[ index( SMDSAbs_Volume, 5)] = & myNbPyramids;
182  myNb[ index( SMDSAbs_Volume, 6)] = & myNbPrisms;
183  myNb[ index( SMDSAbs_Volume, 8)] = & myNbHexas;
184  myNb[ index( SMDSAbs_Volume, 10)] = & myNbQuadTetras;
185  myNb[ index( SMDSAbs_Volume, 12)] = & myNbHexPrism;
186  myNb[ index( SMDSAbs_Volume, 13)] = & myNbQuadPyramids;
187  myNb[ index( SMDSAbs_Volume, 15)] = & myNbQuadPrisms;
188  myNb[ index( SMDSAbs_Volume, 20)] = & myNbQuadHexas;
189  myNb[ index( SMDSAbs_Volume, 27)] = & myNbTriQuadHexas;
190 }
191 
192 inline SMDS_MeshInfo& // operator=
193 SMDS_MeshInfo::operator=(const SMDS_MeshInfo& other)
194 { for ( size_t i=0; i<myNb.size(); ++i ) if ( myNb[i] ) (*myNb[i])=(*other.myNb[i]);
195  myNbPolygons = other.myNbPolygons;
196  myNbQuadPolygons = other.myNbQuadPolygons;
197  myNbPolyhedrons = other.myNbPolyhedrons;
198  return *this;
199 }
200 
201 inline void // Clear
202 SMDS_MeshInfo::Clear()
203 { for ( size_t i=0; i<myNb.size(); ++i ) if ( myNb[i] ) (*myNb[i])=0;
204  myNbPolygons=myNbQuadPolygons=myNbPolyhedrons=0;
205 }
206 
207 inline int // index
208 SMDS_MeshInfo::index(SMDSAbs_ElementType type, int nbNodes) const
209 { return nbNodes + myShift[ type ]; }
210 
211 inline void // remove
212 SMDS_MeshInfo::remove(const SMDS_MeshElement* el)
213 { --(*myNb[ index(el->GetType(), el->NbNodes()) ]); }
214 
215 inline void // add
216 SMDS_MeshInfo::add(const SMDS_MeshElement* el)
217 { ++(*myNb[ index(el->GetType(), el->NbNodes()) ]); }
218 
219 inline void // addWithPoly
220 SMDS_MeshInfo::addWithPoly(const SMDS_MeshElement* el) {
221  switch ( el->GetEntityType() ) {
222  case SMDSEntity_Polygon: ++myNbPolygons; break;
223  case SMDSEntity_Quad_Polygon: ++myNbQuadPolygons; break;
224  case SMDSEntity_Polyhedra: ++myNbPolyhedrons; break;
225  default: add(el);
226  }
227 }
228 inline void // RemoveEdge
229 SMDS_MeshInfo::RemoveEdge(const SMDS_MeshElement* el)
230 { if ( el->IsQuadratic() ) --myNbQuadEdges; else --myNbEdges; }
231 
232 inline void // RemoveFace
233 SMDS_MeshInfo::RemoveFace(const SMDS_MeshElement* el) {
234  switch ( el->GetEntityType() ) {
235  case SMDSEntity_Polygon: --myNbPolygons; break;
236  case SMDSEntity_Quad_Polygon: --myNbQuadPolygons; break;
237  default: remove(el);
238  }
239 }
240 
241 inline void // RemoveVolume
242 SMDS_MeshInfo::RemoveVolume(const SMDS_MeshElement* el)
243 { if ( el->IsPoly() ) --myNbPolyhedrons; else remove( el ); }
244 
245 inline int // NbEdges
246 SMDS_MeshInfo::NbEdges (SMDSAbs_ElementOrder order) const
247 { return order == ORDER_ANY ? myNbEdges+myNbQuadEdges : order == ORDER_LINEAR ? myNbEdges : myNbQuadEdges; }
248 
249 inline int // NbFaces
250 SMDS_MeshInfo::NbFaces (SMDSAbs_ElementOrder order) const
251 { return NbTriangles(order)+NbQuadrangles(order)+(order == ORDER_ANY ? myNbPolygons+myNbQuadPolygons : order == ORDER_LINEAR ? myNbPolygons : myNbQuadPolygons ); }
252 
253 inline int // NbTriangles
254 SMDS_MeshInfo::NbTriangles (SMDSAbs_ElementOrder order) const
255 { return order == ORDER_ANY ? myNbTriangles+myNbQuadTriangles+myNbBiQuadTriangles : order == ORDER_LINEAR ? myNbTriangles : myNbQuadTriangles+myNbBiQuadTriangles; }
256 
257 inline int // NbQuadrangles
258 SMDS_MeshInfo::NbQuadrangles(SMDSAbs_ElementOrder order) const
259 { return order == ORDER_ANY ? myNbQuadrangles+myNbQuadQuadrangles+myNbBiQuadQuadrangles : order == ORDER_LINEAR ? myNbQuadrangles : myNbQuadQuadrangles+myNbBiQuadQuadrangles; }
260 
261 inline int // NbPolygons
262 SMDS_MeshInfo::NbPolygons(SMDSAbs_ElementOrder order) const
263 { return order == ORDER_ANY ? myNbPolygons+myNbQuadPolygons : order == ORDER_LINEAR ? myNbPolygons : myNbQuadPolygons; }
264 
265 inline int // NbVolumes
266 SMDS_MeshInfo::NbVolumes (SMDSAbs_ElementOrder order) const
267 { return NbTetras(order) + NbHexas(order) + NbPyramids(order) + NbPrisms(order) + NbHexPrisms(order) + (order == ORDER_QUADRATIC ? 0 : myNbPolyhedrons); }
268 
269 inline int // NbTetras
270 SMDS_MeshInfo::NbTetras (SMDSAbs_ElementOrder order) const
271 { return order == ORDER_ANY ? myNbTetras+myNbQuadTetras : order == ORDER_LINEAR ? myNbTetras : myNbQuadTetras; }
272 
273 inline int // NbHexas
274 SMDS_MeshInfo::NbHexas (SMDSAbs_ElementOrder order) const
275 { return order == ORDER_ANY ? myNbHexas+myNbQuadHexas+myNbTriQuadHexas : order == ORDER_LINEAR ? myNbHexas : myNbQuadHexas+myNbTriQuadHexas; }
276 
277 inline int // NbPyramids
278 SMDS_MeshInfo::NbPyramids(SMDSAbs_ElementOrder order) const
279 { return order == ORDER_ANY ? myNbPyramids+myNbQuadPyramids : order == ORDER_LINEAR ? myNbPyramids : myNbQuadPyramids; }
280 
281 inline int // NbPrisms
282 SMDS_MeshInfo::NbPrisms (SMDSAbs_ElementOrder order) const
283 { return order == ORDER_ANY ? myNbPrisms+myNbQuadPrisms : order == ORDER_LINEAR ? myNbPrisms : myNbQuadPrisms; }
284 
285 inline int // NbHexPrisms
286 SMDS_MeshInfo::NbHexPrisms (SMDSAbs_ElementOrder order) const
287 { return order == ORDER_ANY ? myNbHexPrism : order == ORDER_LINEAR ? myNbHexPrism : 0; }
288 
289 inline int // NbElements
290 SMDS_MeshInfo::NbElements(SMDSAbs_ElementType type) const
291 {
292  int nb = 0;
293  switch (type) {
294  case SMDSAbs_All:
295  for ( size_t i=1+index( SMDSAbs_Node,1 ); i<myNb.size(); ++i ) if ( myNb[i] ) nb += *myNb[i];
296  nb += myNbPolygons + myNbQuadPolygons + myNbPolyhedrons;
297  break;
298  case SMDSAbs_Volume:
299  nb = ( myNbTetras+ myNbPyramids+ myNbPrisms+ myNbHexas+ myNbHexPrism+
300  myNbQuadTetras+ myNbQuadPyramids+ myNbQuadPrisms+ myNbQuadHexas+ myNbTriQuadHexas+
301  myNbPolyhedrons );
302  break;
303  case SMDSAbs_Face:
304  nb = ( myNbTriangles+ myNbQuadrangles+
305  myNbQuadTriangles+ myNbBiQuadTriangles+
306  myNbQuadQuadrangles+ myNbBiQuadQuadrangles+ myNbPolygons+ myNbQuadPolygons );
307  break;
308  case SMDSAbs_Edge:
309  nb = myNbEdges + myNbQuadEdges;
310  break;
311  case SMDSAbs_Node:
312  nb = myNbNodes;
313  break;
314  case SMDSAbs_0DElement:
315  nb = myNb0DElements;
316  break;
317  case SMDSAbs_Ball:
318  nb = myNbBalls;
319  break;
320  default:;
321  }
322  return nb;
323 }
324 
325 inline int // NbEntities
326 SMDS_MeshInfo::NbEntities(SMDSAbs_EntityType type) const
327 {
328  switch (type) {
329  case SMDSEntity_Node: return myNbNodes;
330  case SMDSEntity_Edge: return myNbEdges;
331  case SMDSEntity_Quad_Edge: return myNbQuadEdges;
332  case SMDSEntity_Triangle: return myNbTriangles;
333  case SMDSEntity_Quad_Triangle: return myNbQuadTriangles;
334  case SMDSEntity_BiQuad_Triangle: return myNbBiQuadTriangles;
335  case SMDSEntity_Quadrangle: return myNbQuadrangles;
336  case SMDSEntity_Quad_Quadrangle: return myNbQuadQuadrangles;
337  case SMDSEntity_BiQuad_Quadrangle:return myNbBiQuadQuadrangles;
338  case SMDSEntity_Polygon: return myNbPolygons;
339  case SMDSEntity_Tetra: return myNbTetras;
340  case SMDSEntity_Quad_Tetra: return myNbQuadTetras;
341  case SMDSEntity_Pyramid: return myNbPyramids;
342  case SMDSEntity_Quad_Pyramid: return myNbQuadPyramids;
343  case SMDSEntity_Hexa: return myNbHexas;
344  case SMDSEntity_Quad_Hexa: return myNbQuadHexas;
345  case SMDSEntity_TriQuad_Hexa: return myNbTriQuadHexas;
346  case SMDSEntity_Penta: return myNbPrisms;
347  case SMDSEntity_Quad_Penta: return myNbQuadPrisms;
348  case SMDSEntity_Hexagonal_Prism: return myNbHexPrism;
349  case SMDSEntity_Polyhedra: return myNbPolyhedrons;
350  case SMDSEntity_0D: return myNb0DElements;
351  case SMDSEntity_Ball: return myNbBalls;
352  case SMDSEntity_Quad_Polygon: return myNbQuadPolygons;
353  case SMDSEntity_Quad_Polyhedra:
354  case SMDSEntity_Last:
355  break;
356  }
357  return 0;
358 }
359 
360 inline int // NbElementsOfGeom
361 SMDS_MeshInfo::NbElementsOfGeom(SMDSAbs_GeometryType geom) const
362 {
363  switch ( geom ) {
364  // 0D:
365  case SMDSGeom_POINT: return myNb0DElements;
366  // 1D:
367  case SMDSGeom_EDGE: return (myNbEdges +
368  myNbQuadEdges);
369  // 2D:
370  case SMDSGeom_TRIANGLE: return (myNbTriangles +
371  myNbQuadTriangles +
372  myNbBiQuadTriangles );
373  case SMDSGeom_QUADRANGLE: return (myNbQuadrangles +
374  myNbQuadQuadrangles +
375  myNbBiQuadQuadrangles );
376  case SMDSGeom_POLYGON: return (myNbPolygons + myNbQuadPolygons );
377  // 3D:
378  case SMDSGeom_TETRA: return (myNbTetras +
379  myNbQuadTetras);
380  case SMDSGeom_PYRAMID: return (myNbPyramids +
381  myNbQuadPyramids);
382  case SMDSGeom_HEXA: return (myNbHexas +
383  myNbQuadHexas +
384  myNbTriQuadHexas);
385  case SMDSGeom_PENTA: return (myNbPrisms +
386  myNbQuadPrisms);
387  case SMDSGeom_HEXAGONAL_PRISM: return myNbHexPrism;
388  case SMDSGeom_POLYHEDRA: return myNbPolyhedrons;
389  // Discrete:
390  case SMDSGeom_BALL: return myNbBalls;
391  //
392  case SMDSGeom_NONE:
393  default:;
394  }
395  return 0;
396 }
397 
398 inline void // setNb
399 SMDS_MeshInfo::setNb(const SMDSAbs_EntityType geomType, const int nb)
400 {
401  switch (geomType) {
402  case SMDSEntity_Node: myNbNodes = nb; break;
403  case SMDSEntity_0D: myNb0DElements = nb; break;
404  case SMDSEntity_Ball: myNbBalls = nb; break;
405  case SMDSEntity_BiQuad_Quadrangle:myNbBiQuadQuadrangles = nb; break;
406  case SMDSEntity_BiQuad_Triangle: myNbBiQuadTriangles = nb; break;
407  case SMDSEntity_Edge: myNbEdges = nb; break;
408  case SMDSEntity_Hexa: myNbHexas = nb; break;
409  case SMDSEntity_Hexagonal_Prism: myNbHexPrism = nb; break;
410  case SMDSEntity_Penta: myNbPrisms = nb; break;
411  case SMDSEntity_Polygon: myNbPolygons = nb; break;
412  case SMDSEntity_Polyhedra: myNbPolyhedrons = nb; break;
413  case SMDSEntity_Pyramid: myNbPyramids = nb; break;
414  case SMDSEntity_Quad_Edge: myNbQuadEdges = nb; break;
415  case SMDSEntity_Quad_Hexa: myNbQuadHexas = nb; break;
416  case SMDSEntity_Quad_Penta: myNbQuadPrisms = nb; break;
417  case SMDSEntity_Quad_Pyramid: myNbQuadPyramids = nb; break;
418  case SMDSEntity_Quad_Quadrangle: myNbQuadQuadrangles = nb; break;
419  case SMDSEntity_Quad_Tetra: myNbQuadTetras = nb; break;
420  case SMDSEntity_Quad_Triangle: myNbQuadTriangles = nb; break;
421  case SMDSEntity_Quadrangle: myNbQuadrangles = nb; break;
422  case SMDSEntity_Tetra: myNbTetras = nb; break;
423  case SMDSEntity_TriQuad_Hexa: myNbTriQuadHexas = nb; break;
424  case SMDSEntity_Triangle: myNbTriangles = nb; break;
425  case SMDSEntity_Quad_Polygon: myNbQuadPolygons = nb; break;
426  case SMDSEntity_Quad_Polyhedra:
427  case SMDSEntity_Last:
428  break;
429  }
430 }
431 
432 #endif