src/SMDS/SMDS_MeshInfo.hxx

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