src/SMDS/SMDS_MeshInfo.hxx

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