src/SMDS/SMDS_MeshInfo.hxx

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