src/SMESHDS/SMESHDS_Mesh.hxx

   1 //  SMESH SMESHDS : management of mesh data and SMESH document
   2 //
   3 //  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 //  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 //  This library is free software; you can redistribute it and/or
   7 //  modify it under the terms of the GNU Lesser General Public
   8 //  License as published by the Free Software Foundation; either
   9 //  version 2.1 of the License.
  10 //
  11 //  This library is distributed in the hope that it will be useful,
  12 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 //  Lesser General Public License for more details.
  15 //
  16 //  You should have received a copy of the GNU Lesser General Public
  17 //  License along with this library; if not, write to the Free Software
  18 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22 //
  23 //
  24 //  File   : SMESHDS_Mesh.hxx
  25 //  Module : SMESH
  26
  27 #ifndef _SMESHDS_Mesh_HeaderFile
  28 #define _SMESHDS_Mesh_HeaderFile
  29
  30 #include "SMDS_Mesh.hxx"
  31 #include "SMDS_MeshNode.hxx"
  32 #include "SMDS_MeshEdge.hxx"
  33 #include "SMDS_MeshFace.hxx"
  34 #include "SMDS_MeshVolume.hxx"
  35 #include "SMESHDS_Hypothesis.hxx"
  36 #include "SMESHDS_SubMesh.hxx"
  37 #include "SMESHDS_Script.hxx"
  38
  39 #include <TopTools_IndexedMapOfShape.hxx>
  40 #include <TopoDS_Shape.hxx>
  41 #include <TopoDS_Solid.hxx>
  42 #include <TopoDS_Shell.hxx>
  43 #include <TopoDS_Face.hxx>
  44 #include <TopoDS_Vertex.hxx>
  45 #include <TopoDS_Edge.hxx>
  46 #include <map>
  47 #ifdef WNT
  48 #include <hash_map>
  49 #endif
  50
  51 //Not portable see http://gcc.gnu.org/onlinedocs/libstdc++/faq/index.html#5_4 to know more.
  52 #ifdef __GNUC__
  53   #if __GNUC__ < 3
  54     #include <hash_map.h>
  55     namespace gstd { using ::hash_map; }; // inherit globals
  56   #elif __GNUC__ == 3
  57     #include <ext/hash_map>
  58     #if __GNUC_MINOR__ == 0
  59       namespace gstd = std;               // GCC 3.0
  60     #else
  61       namespace gstd = ::__gnu_cxx;       // GCC 3.1 and later
  62     #endif
  63   #else                                   // GCC 4.0 and later
  64     #include <ext/hash_map>
  65     namespace gstd = ::__gnu_cxx;
  66   #endif
  67 #else      // ...  there are other compilers, right?
  68   namespace gstd = std;
  69 #endif
  70
  71 #if defined WNT && defined WIN32 && defined SMESHDS_EXPORTS
  72 #define SMESHDS_WNT_EXPORT __declspec( dllexport )
  73 #else
  74 #define SMESHDS_WNT_EXPORT
  75 #endif
  76
  77 class SMESHDS_GroupBase;
  78
  79 class SMESHDS_WNT_EXPORT SMESHDS_Mesh:public SMDS_Mesh{
  80 public:
  81   SMESHDS_Mesh(int theMeshID, bool theIsEmbeddedMode);
  82   bool IsEmbeddedMode();
  83
  84   void ShapeToMesh(const TopoDS_Shape & S);
  85   bool AddHypothesis(const TopoDS_Shape & SS, const SMESHDS_Hypothesis * H);
  86   bool RemoveHypothesis(const TopoDS_Shape & S, const SMESHDS_Hypothesis * H);
  87
  88   virtual SMDS_MeshNode* AddNodeWithID(double x, double y, double z, int ID);
  89   virtual SMDS_MeshNode * AddNode(double x, double y, double z);
  90
  91   virtual SMDS_MeshEdge* AddEdgeWithID(int n1, int n2, int ID);
  92   virtual SMDS_MeshEdge* AddEdgeWithID(const SMDS_MeshNode * n1,
  93                                        const SMDS_MeshNode * n2,
  94                                        int ID);
  95   virtual SMDS_MeshEdge* AddEdge(const SMDS_MeshNode * n1,
  96                                  const SMDS_MeshNode * n2);
  97
  98   // 2d order edge with 3 nodes: n12 - node between n1 and n2
  99   virtual SMDS_MeshEdge* AddEdgeWithID(int n1, int n2, int n12, int ID);
 100   virtual SMDS_MeshEdge* AddEdgeWithID(const SMDS_MeshNode * n1,
 101                                        const SMDS_MeshNode * n2,
 102                                        const SMDS_MeshNode * n12,
 103                                        int ID);
 104   virtual SMDS_MeshEdge* AddEdge(const SMDS_MeshNode * n1,
 105                                  const SMDS_MeshNode * n2,
 106                                  const SMDS_MeshNode * n12);
 107
 108   virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3, int ID);
 109   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
 110                                        const SMDS_MeshNode * n2,
 111                                        const SMDS_MeshNode * n3,
 112                                        int ID);
 113   virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
 114                                  const SMDS_MeshNode * n2,
 115                                  const SMDS_MeshNode * n3);
 116
 117   virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3, int n4, int ID);
 118   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
 119                                        const SMDS_MeshNode * n2,
 120                                        const SMDS_MeshNode * n3,
 121                                        const SMDS_MeshNode * n4,
 122                                        int ID);
 123   virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
 124                                  const SMDS_MeshNode * n2,
 125                                  const SMDS_MeshNode * n3,
 126                                  const SMDS_MeshNode * n4);
 127
 128   // 2d order triangle of 6 nodes
 129   virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3,
 130                                        int n12,int n23,int n31, int ID);
 131   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
 132                                        const SMDS_MeshNode * n2,
 133                                        const SMDS_MeshNode * n3,
 134                                        const SMDS_MeshNode * n12,
 135                                        const SMDS_MeshNode * n23,
 136                                        const SMDS_MeshNode * n31,
 137                                        int ID);
 138   virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
 139                                  const SMDS_MeshNode * n2,
 140                                  const SMDS_MeshNode * n3,
 141                                  const SMDS_MeshNode * n12,
 142                                  const SMDS_MeshNode * n23,
 143                                  const SMDS_MeshNode * n31);
 144
 145   // 2d order quadrangle
 146   virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3, int n4,
 147                                        int n12,int n23,int n34,int n41, int ID);
 148   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
 149                                        const SMDS_MeshNode * n2,
 150                                        const SMDS_MeshNode * n3,
 151                                        const SMDS_MeshNode * n4,
 152                                        const SMDS_MeshNode * n12,
 153                                        const SMDS_MeshNode * n23,
 154                                        const SMDS_MeshNode * n34,
 155                                        const SMDS_MeshNode * n41,
 156                                        int ID);
 157   virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
 158                                  const SMDS_MeshNode * n2,
 159                                  const SMDS_MeshNode * n3,
 160                                  const SMDS_MeshNode * n4,
 161                                  const SMDS_MeshNode * n12,
 162                                  const SMDS_MeshNode * n23,
 163                                  const SMDS_MeshNode * n34,
 164                                  const SMDS_MeshNode * n41);
 165
 166   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int ID);
 167   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 168                                            const SMDS_MeshNode * n2,
 169                                            const SMDS_MeshNode * n3,
 170                                            const SMDS_MeshNode * n4,
 171                                            int ID);
 172   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 173                                      const SMDS_MeshNode * n2,
 174                                      const SMDS_MeshNode * n3,
 175                                      const SMDS_MeshNode * n4);
 176
 177   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, int ID);
 178   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 179                                            const SMDS_MeshNode * n2,
 180                                            const SMDS_MeshNode * n3,
 181                                            const SMDS_MeshNode * n4,
 182                                            const SMDS_MeshNode * n5,
 183                                            int ID);
 184   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 185                                      const SMDS_MeshNode * n2,
 186                                      const SMDS_MeshNode * n3,
 187                                      const SMDS_MeshNode * n4,
 188                                      const SMDS_MeshNode * n5);
 189
 190   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, int n6, int ID);
 191   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 192                                            const SMDS_MeshNode * n2,
 193                                            const SMDS_MeshNode * n3,
 194                                            const SMDS_MeshNode * n4,
 195                                            const SMDS_MeshNode * n5,
 196                                            const SMDS_MeshNode * n6,
 197                                            int ID);
 198   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 199                                      const SMDS_MeshNode * n2,
 200                                      const SMDS_MeshNode * n3,
 201                                      const SMDS_MeshNode * n4,
 202                                      const SMDS_MeshNode * n5,
 203                                      const SMDS_MeshNode * n6);
 204
 205   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, int n6, int n7, int n8, int ID);
 206   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 207                                            const SMDS_MeshNode * n2,
 208                                            const SMDS_MeshNode * n3,
 209                                            const SMDS_MeshNode * n4,
 210                                            const SMDS_MeshNode * n5,
 211                                            const SMDS_MeshNode * n6,
 212                                            const SMDS_MeshNode * n7,
 213                                            const SMDS_MeshNode * n8,
 214                                            int ID);
 215   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 216                                      const SMDS_MeshNode * n2,
 217                                      const SMDS_MeshNode * n3,
 218                                      const SMDS_MeshNode * n4,
 219                                      const SMDS_MeshNode * n5,
 220                                      const SMDS_MeshNode * n6,
 221                                      const SMDS_MeshNode * n7,
 222                                      const SMDS_MeshNode * n8);
 223
 224   // 2d order tetrahedron of 10 nodes
 225   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
 226                                            int n12,int n23,int n31,
 227                                            int n14,int n24,int n34, int ID);
 228   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 229                                            const SMDS_MeshNode * n2,
 230                                            const SMDS_MeshNode * n3,
 231                                            const SMDS_MeshNode * n4,
 232                                            const SMDS_MeshNode * n12,
 233                                            const SMDS_MeshNode * n23,
 234                                            const SMDS_MeshNode * n31,
 235                                            const SMDS_MeshNode * n14,
 236                                            const SMDS_MeshNode * n24,
 237                                            const SMDS_MeshNode * n34,
 238                                            int ID);
 239   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 240                                      const SMDS_MeshNode * n2,
 241                                      const SMDS_MeshNode * n3,
 242                                      const SMDS_MeshNode * n4,
 243                                      const SMDS_MeshNode * n12,
 244                                      const SMDS_MeshNode * n23,
 245                                      const SMDS_MeshNode * n31,
 246                                      const SMDS_MeshNode * n14,
 247                                      const SMDS_MeshNode * n24,
 248                                      const SMDS_MeshNode * n34);
 249
 250   // 2d order pyramid of 13 nodes
 251   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int n5,
 252                                            int n12,int n23,int n34,int n41,
 253                                            int n15,int n25,int n35,int n45,
 254                                            int ID);
 255   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 256                                            const SMDS_MeshNode * n2,
 257                                            const SMDS_MeshNode * n3,
 258                                            const SMDS_MeshNode * n4,
 259                                            const SMDS_MeshNode * n5,
 260                                            const SMDS_MeshNode * n12,
 261                                            const SMDS_MeshNode * n23,
 262                                            const SMDS_MeshNode * n34,
 263                                            const SMDS_MeshNode * n41,
 264                                            const SMDS_MeshNode * n15,
 265                                            const SMDS_MeshNode * n25,
 266                                            const SMDS_MeshNode * n35,
 267                                            const SMDS_MeshNode * n45,
 268                                            int ID);
 269   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 270                                      const SMDS_MeshNode * n2,
 271                                      const SMDS_MeshNode * n3,
 272                                      const SMDS_MeshNode * n4,
 273                                      const SMDS_MeshNode * n5,
 274                                      const SMDS_MeshNode * n12,
 275                                      const SMDS_MeshNode * n23,
 276                                      const SMDS_MeshNode * n34,
 277                                      const SMDS_MeshNode * n41,
 278                                      const SMDS_MeshNode * n15,
 279                                      const SMDS_MeshNode * n25,
 280                                      const SMDS_MeshNode * n35,
 281                                      const SMDS_MeshNode * n45);
 282
 283   // 2d order Pentahedron with 15 nodes
 284   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3,
 285                                            int n4, int n5, int n6,
 286                                            int n12,int n23,int n31,
 287                                            int n45,int n56,int n64,
 288                                            int n14,int n25,int n36,
 289                                            int ID);
 290   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 291                                            const SMDS_MeshNode * n2,
 292                                            const SMDS_MeshNode * n3,
 293                                            const SMDS_MeshNode * n4,
 294                                            const SMDS_MeshNode * n5,
 295                                            const SMDS_MeshNode * n6,
 296                                            const SMDS_MeshNode * n12,
 297                                            const SMDS_MeshNode * n23,
 298                                            const SMDS_MeshNode * n31,
 299                                            const SMDS_MeshNode * n45,
 300                                            const SMDS_MeshNode * n56,
 301                                            const SMDS_MeshNode * n64,
 302                                            const SMDS_MeshNode * n14,
 303                                            const SMDS_MeshNode * n25,
 304                                            const SMDS_MeshNode * n36,
 305                                            int ID);
 306   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 307                                      const SMDS_MeshNode * n2,
 308                                      const SMDS_MeshNode * n3,
 309                                      const SMDS_MeshNode * n4,
 310                                      const SMDS_MeshNode * n5,
 311                                      const SMDS_MeshNode * n6,
 312                                      const SMDS_MeshNode * n12,
 313                                      const SMDS_MeshNode * n23,
 314                                      const SMDS_MeshNode * n31,
 315                                      const SMDS_MeshNode * n45,
 316                                      const SMDS_MeshNode * n56,
 317                                      const SMDS_MeshNode * n64,
 318                                      const SMDS_MeshNode * n14,
 319                                      const SMDS_MeshNode * n25,
 320                                      const SMDS_MeshNode * n36);
 321
 322   // 2d order Hexahedrons with 20 nodes
 323   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
 324                                            int n5, int n6, int n7, int n8,
 325                                            int n12,int n23,int n34,int n41,
 326                                            int n56,int n67,int n78,int n85,
 327                                            int n15,int n26,int n37,int n48,
 328                                            int ID);
 329   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 330                                            const SMDS_MeshNode * n2,
 331                                            const SMDS_MeshNode * n3,
 332                                            const SMDS_MeshNode * n4,
 333                                            const SMDS_MeshNode * n5,
 334                                            const SMDS_MeshNode * n6,
 335                                            const SMDS_MeshNode * n7,
 336                                            const SMDS_MeshNode * n8,
 337                                            const SMDS_MeshNode * n12,
 338                                            const SMDS_MeshNode * n23,
 339                                            const SMDS_MeshNode * n34,
 340                                            const SMDS_MeshNode * n41,
 341                                            const SMDS_MeshNode * n56,
 342                                            const SMDS_MeshNode * n67,
 343                                            const SMDS_MeshNode * n78,
 344                                            const SMDS_MeshNode * n85,
 345                                            const SMDS_MeshNode * n15,
 346                                            const SMDS_MeshNode * n26,
 347                                            const SMDS_MeshNode * n37,
 348                                            const SMDS_MeshNode * n48,
 349                                            int ID);
 350   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 351                                      const SMDS_MeshNode * n2,
 352                                      const SMDS_MeshNode * n3,
 353                                      const SMDS_MeshNode * n4,
 354                                      const SMDS_MeshNode * n5,
 355                                      const SMDS_MeshNode * n6,
 356                                      const SMDS_MeshNode * n7,
 357                                      const SMDS_MeshNode * n8,
 358                                      const SMDS_MeshNode * n12,
 359                                      const SMDS_MeshNode * n23,
 360                                      const SMDS_MeshNode * n34,
 361                                      const SMDS_MeshNode * n41,
 362                                      const SMDS_MeshNode * n56,
 363                                      const SMDS_MeshNode * n67,
 364                                      const SMDS_MeshNode * n78,
 365                                      const SMDS_MeshNode * n85,
 366                                      const SMDS_MeshNode * n15,
 367                                      const SMDS_MeshNode * n26,
 368                                      const SMDS_MeshNode * n37,
 369                                      const SMDS_MeshNode * n48);
 370
 371   virtual SMDS_MeshFace* AddPolygonalFaceWithID (std::vector<int> nodes_ids,
 372                                                  const int        ID);
 373
 374   virtual SMDS_MeshFace* AddPolygonalFaceWithID (std::vector<const SMDS_MeshNode*> nodes,
 375                                                  const int                         ID);
 376
 377   virtual SMDS_MeshFace* AddPolygonalFace (std::vector<const SMDS_MeshNode*> nodes);
 378
 379   virtual SMDS_MeshVolume* AddPolyhedralVolumeWithID
 380                            (std::vector<int> nodes_ids,
 381                             std::vector<int> quantities,
 382                             const int        ID);
 383
 384   virtual SMDS_MeshVolume* AddPolyhedralVolumeWithID
 385                            (std::vector<const SMDS_MeshNode*> nodes,
 386                             std::vector<int>                  quantities,
 387                             const int                         ID);
 388
 389   virtual SMDS_MeshVolume* AddPolyhedralVolume
 390                            (std::vector<const SMDS_MeshNode*> nodes,
 391                             std::vector<int>                  quantities);
 392
 393   void MoveNode(const SMDS_MeshNode *, double x, double y, double z);
 394   virtual void RemoveNode(const SMDS_MeshNode *);
 395   void RemoveElement(const SMDS_MeshElement *);
 396
 397   /*! Remove only the given element/node and only if it is free.
 398    *  Methods do not work for meshes with descendants.
 399    *  Implemented for fast cleaning of meshes.
 400    */
 401   void RemoveFreeNode(const SMDS_MeshNode *, SMESHDS_SubMesh *);
 402   void RemoveFreeElement(const SMDS_MeshElement *, SMESHDS_SubMesh *);
 403
 404   bool ChangeElementNodes(const SMDS_MeshElement * elem,
 405                           const SMDS_MeshNode    * nodes[],
 406                           const int                nbnodes);
 407   bool ChangePolygonNodes(const SMDS_MeshElement * elem,
 408                           std::vector<const SMDS_MeshNode*> nodes);
 409   bool ChangePolyhedronNodes(const SMDS_MeshElement * elem,
 410                              std::vector<const SMDS_MeshNode*> nodes,
 411                              std::vector<int>                  quantities);
 412   void Renumber (const bool isNodes, const int startID=1, const int deltaID=1);
 413
 414   void SetNodeInVolume(SMDS_MeshNode * aNode, const TopoDS_Shell & S);
 415   void SetNodeInVolume(SMDS_MeshNode * aNode, const TopoDS_Solid & S);
 416   void SetNodeOnFace(SMDS_MeshNode * aNode, const TopoDS_Face & S, double u=0., double v=0.);
 417   void SetNodeOnEdge(SMDS_MeshNode * aNode, const TopoDS_Edge & S, double u=0.);
 418   void SetNodeOnVertex(SMDS_MeshNode * aNode, const TopoDS_Vertex & S);
 419   void UnSetNodeOnShape(const SMDS_MeshNode * aNode);
 420   void SetMeshElementOnShape(const SMDS_MeshElement * anElt,
 421                              const TopoDS_Shape & S);
 422   void UnSetMeshElementOnShape(const SMDS_MeshElement * anElt,
 423                                const TopoDS_Shape & S);
 424   TopoDS_Shape ShapeToMesh() const;
 425   bool HasMeshElements(const TopoDS_Shape & S);
 426   SMESHDS_SubMesh * MeshElements(const TopoDS_Shape & S) const;
 427   SMESHDS_SubMesh * MeshElements(const int Index);
 428   std::list<int> SubMeshIndices();
 429   const std::map<int,SMESHDS_SubMesh*>& SubMeshes()
 430   { return myShapeIndexToSubMesh; }
 431
 432   bool HasHypothesis(const TopoDS_Shape & S);
 433   const std::list<const SMESHDS_Hypothesis*>& GetHypothesis(const TopoDS_Shape & S) const;
 434   SMESHDS_Script * GetScript();
 435   void ClearScript();
 436   int ShapeToIndex(const TopoDS_Shape & aShape) const;
 437   const TopoDS_Shape& IndexToShape(int ShapeIndex) const;
 438   int MaxShapeIndex() const { return myIndexToShape.Extent(); }
 439
 440   SMESHDS_SubMesh * NewSubMesh(int Index);
 441   int AddCompoundSubmesh(const TopoDS_Shape& S, TopAbs_ShapeEnum type = TopAbs_SHAPE);
 442   void SetNodeInVolume(const SMDS_MeshNode * aNode, int Index);
 443   void SetNodeOnFace(SMDS_MeshNode * aNode, int Index , double u=0., double v=0.);
 444   void SetNodeOnEdge(SMDS_MeshNode * aNode, int Index , double u=0.);
 445   void SetNodeOnVertex(SMDS_MeshNode * aNode, int Index);
 446   void SetMeshElementOnShape(const SMDS_MeshElement * anElt, int Index);
 447
 448   void AddGroup (SMESHDS_GroupBase* theGroup)      { myGroups.insert(theGroup); }
 449   void RemoveGroup (SMESHDS_GroupBase* theGroup)   { myGroups.erase(theGroup); }
 450   int GetNbGroups() const                      { return myGroups.size(); }
 451   const std::set<SMESHDS_GroupBase*>& GetGroups() const { return myGroups; }
 452
 453   bool IsGroupOfSubShapes (const TopoDS_Shape& aSubShape) const;
 454
 455   ~SMESHDS_Mesh();
 456
 457 private:
 458 #ifndef WNT
 459   struct HashTopoDS_Shape{
 460     size_t operator()(const TopoDS_Shape& S) const {
 461       return S.HashCode(2147483647);
 462     }
 463   };
 464 #else
 465   typedef gstd::hash_compare< TopoDS_Shape, less<TopoDS_Shape> > HashTopoDS;
 466
 467   class HashTopoDS_Shape : public HashTopoDS {
 468   public:
 469
 470     size_t operator()(const TopoDS_Shape& S) const {
 471       return S.HashCode(2147483647);
 472     }
 473
 474         bool operator()(const TopoDS_Shape& S1,const TopoDS_Shape& S2) const {
 475                 return S1==S2;
 476         }
 477   };
 478
 479
 480
 481 #endif
 482
 483   typedef std::list<const SMESHDS_Hypothesis*> THypList;
 484
 485 #ifndef WNT
 486   typedef gstd::hash_map<TopoDS_Shape,THypList,HashTopoDS_Shape> ShapeToHypothesis;
 487 #else
 488   typedef gstd::hash_map<TopoDS_Shape,THypList,HashTopoDS_Shape> ShapeToHypothesis;
 489 #endif
 490
 491   ShapeToHypothesis          myShapeToHypothesis;
 492
 493   int                        myMeshID;
 494   TopoDS_Shape               myShape;
 495
 496   typedef std::map<int,SMESHDS_SubMesh*> TShapeIndexToSubMesh;
 497   TShapeIndexToSubMesh myShapeIndexToSubMesh;
 498
 499   TopTools_IndexedMapOfShape myIndexToShape;
 500
 501   typedef std::set<SMESHDS_GroupBase*> TGroups;
 502   TGroups myGroups;
 503
 504   SMESHDS_Script*            myScript;
 505   bool                       myIsEmbeddedMode;
 506
 507   // optimize addition of nodes/elements to submeshes by, SetNodeInVolume() etc:
 508   // avoid search of submeshes in maps
 509   bool add( const SMDS_MeshElement* elem, SMESHDS_SubMesh* subMesh );
 510   SMESHDS_SubMesh* getSubmesh( const TopoDS_Shape & shape);
 511   SMESHDS_SubMesh* getSubmesh( const int            Index );
 512   int                        myCurSubID;
 513   TopoDS_Shape               myCurSubShape;
 514   SMESHDS_SubMesh*           myCurSubMesh;
 515 };
 516
 517
 518 #endif