src/SMDS/SMDS_MeshInfo.hxx

   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