src/SMDS/SMDS_MeshInfo.hxx

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