src/SMESHDS/SMESHDS_Mesh.hxx

   1 //  Copyright (C) 2007-2010  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 //  Copyright (C) 2003-2007  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 //  SMESH SMESHDS : management of mesh data and SMESH document
  24 //  File   : SMESHDS_Mesh.hxx
  25 //  Module : SMESH
  26 //
  27 #ifndef _SMESHDS_Mesh_HeaderFile
  28 #define _SMESHDS_Mesh_HeaderFile
  29
  30 #include "SMESH_SMESHDS.hxx"
  31
  32 #include "SMDS_Mesh.hxx"
  33 #include "SMDS_MeshNode.hxx"
  34 #include "SMDS_Mesh0DElement.hxx"
  35 #include "SMDS_MeshEdge.hxx"
  36 #include "SMDS_MeshFace.hxx"
  37 #include "SMDS_MeshVolume.hxx"
  38 #include "SMESHDS_Hypothesis.hxx"
  39 #include "SMESHDS_SubMesh.hxx"
  40 #include "SMESHDS_Script.hxx"
  41
  42 #include <TopTools_IndexedMapOfShape.hxx>
  43 #include <TopoDS_Shape.hxx>
  44 #include <TopoDS_Solid.hxx>
  45 #include <TopoDS_Shell.hxx>
  46 #include <TopoDS_Face.hxx>
  47 #include <TopoDS_Vertex.hxx>
  48 #include <TopoDS_Edge.hxx>
  49
  50 #include <NCollection_DataMap.hxx>
  51 #include <map>
  52 /*
  53  * Using of native hash_map isn't portable and don't work on WIN32 platform.
  54  * So this functionality implement on new NCollection_DataMap technology
  55  */
  56 #include "SMESHDS_DataMapOfShape.hxx"
  57
  58 class SMESHDS_GroupBase;
  59
  60 class SMESHDS_EXPORT SMESHDS_Mesh:public SMDS_Mesh{
  61 public:
  62   SMESHDS_Mesh(int theMeshID, bool theIsEmbeddedMode);
  63   bool IsEmbeddedMode();
  64   void SetPersistentId(int id);
  65   int GetPersistentId() const;
  66
  67   void ShapeToMesh(const TopoDS_Shape & S);
  68   TopoDS_Shape ShapeToMesh() const;
  69   bool AddHypothesis(const TopoDS_Shape & SS, const SMESHDS_Hypothesis * H);
  70   bool RemoveHypothesis(const TopoDS_Shape & S, const SMESHDS_Hypothesis * H);
  71
  72   virtual SMDS_MeshNode* AddNodeWithID(double x, double y, double z, int ID);
  73   virtual SMDS_MeshNode* AddNode(double x, double y, double z);
  74
  75   virtual SMDS_Mesh0DElement* Add0DElementWithID(int nodeID, int ID);
  76   virtual SMDS_Mesh0DElement* Add0DElementWithID(const SMDS_MeshNode * node, int ID);
  77   virtual SMDS_Mesh0DElement* Add0DElement      (const SMDS_MeshNode * node);
  78
  79   virtual SMDS_MeshEdge* AddEdgeWithID(int n1, int n2, int ID);
  80   virtual SMDS_MeshEdge* AddEdgeWithID(const SMDS_MeshNode * n1,
  81                                        const SMDS_MeshNode * n2,
  82                                        int ID);
  83   virtual SMDS_MeshEdge* AddEdge(const SMDS_MeshNode * n1,
  84                                  const SMDS_MeshNode * n2);
  85
  86   // 2d order edge with 3 nodes: n12 - node between n1 and n2
  87   virtual SMDS_MeshEdge* AddEdgeWithID(int n1, int n2, int n12, int ID);
  88   virtual SMDS_MeshEdge* AddEdgeWithID(const SMDS_MeshNode * n1,
  89                                        const SMDS_MeshNode * n2,
  90                                        const SMDS_MeshNode * n12,
  91                                        int ID);
  92   virtual SMDS_MeshEdge* AddEdge(const SMDS_MeshNode * n1,
  93                                  const SMDS_MeshNode * n2,
  94                                  const SMDS_MeshNode * n12);
  95
  96   virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3, int ID);
  97   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
  98                                        const SMDS_MeshNode * n2,
  99                                        const SMDS_MeshNode * n3,
 100                                        int ID);
 101   virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
 102                                  const SMDS_MeshNode * n2,
 103                                  const SMDS_MeshNode * n3);
 104
 105   virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3, int n4, int ID);
 106   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
 107                                        const SMDS_MeshNode * n2,
 108                                        const SMDS_MeshNode * n3,
 109                                        const SMDS_MeshNode * n4,
 110                                        int ID);
 111   virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
 112                                  const SMDS_MeshNode * n2,
 113                                  const SMDS_MeshNode * n3,
 114                                  const SMDS_MeshNode * n4);
 115
 116   // 2d order triangle of 6 nodes
 117   virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3,
 118                                        int n12,int n23,int n31, int ID);
 119   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
 120                                        const SMDS_MeshNode * n2,
 121                                        const SMDS_MeshNode * n3,
 122                                        const SMDS_MeshNode * n12,
 123                                        const SMDS_MeshNode * n23,
 124                                        const SMDS_MeshNode * n31,
 125                                        int ID);
 126   virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
 127                                  const SMDS_MeshNode * n2,
 128                                  const SMDS_MeshNode * n3,
 129                                  const SMDS_MeshNode * n12,
 130                                  const SMDS_MeshNode * n23,
 131                                  const SMDS_MeshNode * n31);
 132
 133   // 2d order quadrangle
 134   virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3, int n4,
 135                                        int n12,int n23,int n34,int n41, int ID);
 136   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
 137                                        const SMDS_MeshNode * n2,
 138                                        const SMDS_MeshNode * n3,
 139                                        const SMDS_MeshNode * n4,
 140                                        const SMDS_MeshNode * n12,
 141                                        const SMDS_MeshNode * n23,
 142                                        const SMDS_MeshNode * n34,
 143                                        const SMDS_MeshNode * n41,
 144                                        int ID);
 145   virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
 146                                  const SMDS_MeshNode * n2,
 147                                  const SMDS_MeshNode * n3,
 148                                  const SMDS_MeshNode * n4,
 149                                  const SMDS_MeshNode * n12,
 150                                  const SMDS_MeshNode * n23,
 151                                  const SMDS_MeshNode * n34,
 152                                  const SMDS_MeshNode * n41);
 153
 154   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int ID);
 155   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 156                                            const SMDS_MeshNode * n2,
 157                                            const SMDS_MeshNode * n3,
 158                                            const SMDS_MeshNode * n4,
 159                                            int ID);
 160   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 161                                      const SMDS_MeshNode * n2,
 162                                      const SMDS_MeshNode * n3,
 163                                      const SMDS_MeshNode * n4);
 164
 165   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, int ID);
 166   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 167                                            const SMDS_MeshNode * n2,
 168                                            const SMDS_MeshNode * n3,
 169                                            const SMDS_MeshNode * n4,
 170                                            const SMDS_MeshNode * n5,
 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                                      const SMDS_MeshNode * n5);
 177
 178   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, int n6, int ID);
 179   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 180                                            const SMDS_MeshNode * n2,
 181                                            const SMDS_MeshNode * n3,
 182                                            const SMDS_MeshNode * n4,
 183                                            const SMDS_MeshNode * n5,
 184                                            const SMDS_MeshNode * n6,
 185                                            int ID);
 186   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 187                                      const SMDS_MeshNode * n2,
 188                                      const SMDS_MeshNode * n3,
 189                                      const SMDS_MeshNode * n4,
 190                                      const SMDS_MeshNode * n5,
 191                                      const SMDS_MeshNode * n6);
 192
 193   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, int n6, int n7, int n8, int ID);
 194   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 195                                            const SMDS_MeshNode * n2,
 196                                            const SMDS_MeshNode * n3,
 197                                            const SMDS_MeshNode * n4,
 198                                            const SMDS_MeshNode * n5,
 199                                            const SMDS_MeshNode * n6,
 200                                            const SMDS_MeshNode * n7,
 201                                            const SMDS_MeshNode * n8,
 202                                            int ID);
 203   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 204                                      const SMDS_MeshNode * n2,
 205                                      const SMDS_MeshNode * n3,
 206                                      const SMDS_MeshNode * n4,
 207                                      const SMDS_MeshNode * n5,
 208                                      const SMDS_MeshNode * n6,
 209                                      const SMDS_MeshNode * n7,
 210                                      const SMDS_MeshNode * n8);
 211
 212   // 2d order tetrahedron of 10 nodes
 213   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
 214                                            int n12,int n23,int n31,
 215                                            int n14,int n24,int n34, int ID);
 216   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 217                                            const SMDS_MeshNode * n2,
 218                                            const SMDS_MeshNode * n3,
 219                                            const SMDS_MeshNode * n4,
 220                                            const SMDS_MeshNode * n12,
 221                                            const SMDS_MeshNode * n23,
 222                                            const SMDS_MeshNode * n31,
 223                                            const SMDS_MeshNode * n14,
 224                                            const SMDS_MeshNode * n24,
 225                                            const SMDS_MeshNode * n34,
 226                                            int ID);
 227   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 228                                      const SMDS_MeshNode * n2,
 229                                      const SMDS_MeshNode * n3,
 230                                      const SMDS_MeshNode * n4,
 231                                      const SMDS_MeshNode * n12,
 232                                      const SMDS_MeshNode * n23,
 233                                      const SMDS_MeshNode * n31,
 234                                      const SMDS_MeshNode * n14,
 235                                      const SMDS_MeshNode * n24,
 236                                      const SMDS_MeshNode * n34);
 237
 238   // 2d order pyramid of 13 nodes
 239   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int n5,
 240                                            int n12,int n23,int n34,int n41,
 241                                            int n15,int n25,int n35,int n45,
 242                                            int ID);
 243   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 244                                            const SMDS_MeshNode * n2,
 245                                            const SMDS_MeshNode * n3,
 246                                            const SMDS_MeshNode * n4,
 247                                            const SMDS_MeshNode * n5,
 248                                            const SMDS_MeshNode * n12,
 249                                            const SMDS_MeshNode * n23,
 250                                            const SMDS_MeshNode * n34,
 251                                            const SMDS_MeshNode * n41,
 252                                            const SMDS_MeshNode * n15,
 253                                            const SMDS_MeshNode * n25,
 254                                            const SMDS_MeshNode * n35,
 255                                            const SMDS_MeshNode * n45,
 256                                            int ID);
 257   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 258                                      const SMDS_MeshNode * n2,
 259                                      const SMDS_MeshNode * n3,
 260                                      const SMDS_MeshNode * n4,
 261                                      const SMDS_MeshNode * n5,
 262                                      const SMDS_MeshNode * n12,
 263                                      const SMDS_MeshNode * n23,
 264                                      const SMDS_MeshNode * n34,
 265                                      const SMDS_MeshNode * n41,
 266                                      const SMDS_MeshNode * n15,
 267                                      const SMDS_MeshNode * n25,
 268                                      const SMDS_MeshNode * n35,
 269                                      const SMDS_MeshNode * n45);
 270
 271   // 2d order Pentahedron with 15 nodes
 272   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3,
 273                                            int n4, int n5, int n6,
 274                                            int n12,int n23,int n31,
 275                                            int n45,int n56,int n64,
 276                                            int n14,int n25,int n36,
 277                                            int ID);
 278   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 279                                            const SMDS_MeshNode * n2,
 280                                            const SMDS_MeshNode * n3,
 281                                            const SMDS_MeshNode * n4,
 282                                            const SMDS_MeshNode * n5,
 283                                            const SMDS_MeshNode * n6,
 284                                            const SMDS_MeshNode * n12,
 285                                            const SMDS_MeshNode * n23,
 286                                            const SMDS_MeshNode * n31,
 287                                            const SMDS_MeshNode * n45,
 288                                            const SMDS_MeshNode * n56,
 289                                            const SMDS_MeshNode * n64,
 290                                            const SMDS_MeshNode * n14,
 291                                            const SMDS_MeshNode * n25,
 292                                            const SMDS_MeshNode * n36,
 293                                            int ID);
 294   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 295                                      const SMDS_MeshNode * n2,
 296                                      const SMDS_MeshNode * n3,
 297                                      const SMDS_MeshNode * n4,
 298                                      const SMDS_MeshNode * n5,
 299                                      const SMDS_MeshNode * n6,
 300                                      const SMDS_MeshNode * n12,
 301                                      const SMDS_MeshNode * n23,
 302                                      const SMDS_MeshNode * n31,
 303                                      const SMDS_MeshNode * n45,
 304                                      const SMDS_MeshNode * n56,
 305                                      const SMDS_MeshNode * n64,
 306                                      const SMDS_MeshNode * n14,
 307                                      const SMDS_MeshNode * n25,
 308                                      const SMDS_MeshNode * n36);
 309
 310   // 2d order Hexahedrons with 20 nodes
 311   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
 312                                            int n5, int n6, int n7, int n8,
 313                                            int n12,int n23,int n34,int n41,
 314                                            int n56,int n67,int n78,int n85,
 315                                            int n15,int n26,int n37,int n48,
 316                                            int ID);
 317   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 318                                            const SMDS_MeshNode * n2,
 319                                            const SMDS_MeshNode * n3,
 320                                            const SMDS_MeshNode * n4,
 321                                            const SMDS_MeshNode * n5,
 322                                            const SMDS_MeshNode * n6,
 323                                            const SMDS_MeshNode * n7,
 324                                            const SMDS_MeshNode * n8,
 325                                            const SMDS_MeshNode * n12,
 326                                            const SMDS_MeshNode * n23,
 327                                            const SMDS_MeshNode * n34,
 328                                            const SMDS_MeshNode * n41,
 329                                            const SMDS_MeshNode * n56,
 330                                            const SMDS_MeshNode * n67,
 331                                            const SMDS_MeshNode * n78,
 332                                            const SMDS_MeshNode * n85,
 333                                            const SMDS_MeshNode * n15,
 334                                            const SMDS_MeshNode * n26,
 335                                            const SMDS_MeshNode * n37,
 336                                            const SMDS_MeshNode * n48,
 337                                            int ID);
 338   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 339                                      const SMDS_MeshNode * n2,
 340                                      const SMDS_MeshNode * n3,
 341                                      const SMDS_MeshNode * n4,
 342                                      const SMDS_MeshNode * n5,
 343                                      const SMDS_MeshNode * n6,
 344                                      const SMDS_MeshNode * n7,
 345                                      const SMDS_MeshNode * n8,
 346                                      const SMDS_MeshNode * n12,
 347                                      const SMDS_MeshNode * n23,
 348                                      const SMDS_MeshNode * n34,
 349                                      const SMDS_MeshNode * n41,
 350                                      const SMDS_MeshNode * n56,
 351                                      const SMDS_MeshNode * n67,
 352                                      const SMDS_MeshNode * n78,
 353                                      const SMDS_MeshNode * n85,
 354                                      const SMDS_MeshNode * n15,
 355                                      const SMDS_MeshNode * n26,
 356                                      const SMDS_MeshNode * n37,
 357                                      const SMDS_MeshNode * n48);
 358
 359   virtual SMDS_MeshFace* AddPolygonalFaceWithID (const std::vector<int>& nodes_ids,
 360                                                  const int               ID);
 361
 362   virtual SMDS_MeshFace* AddPolygonalFaceWithID (const std::vector<const SMDS_MeshNode*>& nodes,
 363                                                  const int                                ID);
 364
 365   virtual SMDS_MeshFace* AddPolygonalFace (const std::vector<const SMDS_MeshNode*>& nodes);
 366
 367   virtual SMDS_MeshVolume* AddPolyhedralVolumeWithID
 368                            (const std::vector<int>& nodes_ids,
 369                             const std::vector<int>& quantities,
 370                             const int               ID);
 371
 372   virtual SMDS_MeshVolume* AddPolyhedralVolumeWithID
 373                            (const std::vector<const SMDS_MeshNode*>& nodes,
 374                             const std::vector<int>&                  quantities,
 375                             const int                                ID);
 376
 377   virtual SMDS_MeshVolume* AddPolyhedralVolume
 378                            (const std::vector<const SMDS_MeshNode*>& nodes,
 379                             const std::vector<int>&                  quantities);
 380
 381   void MoveNode(const SMDS_MeshNode *, double x, double y, double z);
 382   virtual void RemoveNode(const SMDS_MeshNode *);
 383   void RemoveElement(const SMDS_MeshElement *);
 384
 385   /*! Remove only the given element/node and only if it is free.
 386    *  Methods do not work for meshes with descendants.
 387    *  Implemented for fast cleaning of meshes.
 388    */
 389   void RemoveFreeNode   (const SMDS_MeshNode *,    SMESHDS_SubMesh *, bool fromGroups=true);
 390   void RemoveFreeElement(const SMDS_MeshElement *, SMESHDS_SubMesh *, bool fromGroups=true);
 391
 392   void ClearMesh();
 393
 394   bool ChangeElementNodes(const SMDS_MeshElement * elem,
 395                           const SMDS_MeshNode    * nodes[],
 396                           const int                nbnodes);
 397   bool ChangePolygonNodes(const SMDS_MeshElement * elem,
 398                           std::vector<const SMDS_MeshNode*> nodes);
 399   bool ChangePolyhedronNodes(const SMDS_MeshElement * elem,
 400                              std::vector<const SMDS_MeshNode*> nodes,
 401                              std::vector<int>                  quantities);
 402   void Renumber (const bool isNodes, const int startID=1, const int deltaID=1);
 403
 404   void SetNodeInVolume(SMDS_MeshNode * aNode, const TopoDS_Shell & S);
 405   void SetNodeInVolume(SMDS_MeshNode * aNode, const TopoDS_Solid & S);
 406   void SetNodeOnFace(SMDS_MeshNode * aNode, const TopoDS_Face & S, double u=0., double v=0.);
 407   void SetNodeOnEdge(SMDS_MeshNode * aNode, const TopoDS_Edge & S, double u=0.);
 408   void SetNodeOnVertex(SMDS_MeshNode * aNode, const TopoDS_Vertex & S);
 409   void UnSetNodeOnShape(const SMDS_MeshNode * aNode);
 410   void SetMeshElementOnShape(const SMDS_MeshElement * anElt,
 411                              const TopoDS_Shape & S);
 412   void UnSetMeshElementOnShape(const SMDS_MeshElement * anElt,
 413                                const TopoDS_Shape & S);
 414   bool HasMeshElements(const TopoDS_Shape & S);
 415   SMESHDS_SubMesh * MeshElements(const TopoDS_Shape & S) const;
 416   SMESHDS_SubMesh * MeshElements(const int Index);
 417   std::list<int> SubMeshIndices();
 418   const std::map<int,SMESHDS_SubMesh*>& SubMeshes() const
 419   { return myShapeIndexToSubMesh; }
 420
 421   bool HasHypothesis(const TopoDS_Shape & S);
 422   const std::list<const SMESHDS_Hypothesis*>& GetHypothesis(const TopoDS_Shape & S) const;
 423   SMESHDS_Script * GetScript();
 424   void ClearScript();
 425   int ShapeToIndex(const TopoDS_Shape & aShape) const;
 426   const TopoDS_Shape& IndexToShape(int ShapeIndex) const;
 427   int MaxShapeIndex() const { return myIndexToShape.Extent(); }
 428   int MaxSubMeshIndex() const;
 429
 430   SMESHDS_SubMesh * NewSubMesh(int Index);
 431   int AddCompoundSubmesh(const TopoDS_Shape& S, TopAbs_ShapeEnum type = TopAbs_SHAPE);
 432   void SetNodeInVolume(const SMDS_MeshNode * aNode, int Index);
 433   void SetNodeOnFace(SMDS_MeshNode * aNode, int Index , double u=0., double v=0.);
 434   void SetNodeOnEdge(SMDS_MeshNode * aNode, int Index , double u=0.);
 435   void SetNodeOnVertex(SMDS_MeshNode * aNode, int Index);
 436   void SetMeshElementOnShape(const SMDS_MeshElement * anElt, int Index);
 437
 438   void AddGroup (SMESHDS_GroupBase* theGroup)      { myGroups.insert(theGroup); }
 439   void RemoveGroup (SMESHDS_GroupBase* theGroup)   { myGroups.erase(theGroup); }
 440   int GetNbGroups() const                      { return myGroups.size(); }
 441   const std::set<SMESHDS_GroupBase*>& GetGroups() const { return myGroups; }
 442
 443   bool IsGroupOfSubShapes (const TopoDS_Shape& aSubShape) const;
 444
 445   ~SMESHDS_Mesh();
 446
 447 private:
 448   void addNodeToSubmesh( const SMDS_MeshNode* aNode, int Index )
 449   {
 450     //Update or build submesh
 451     std::map<int,SMESHDS_SubMesh*>::iterator it = myShapeIndexToSubMesh.find( Index );
 452     if ( it == myShapeIndexToSubMesh.end() )
 453       it = myShapeIndexToSubMesh.insert( std::make_pair(Index, new SMESHDS_SubMesh() )).first;
 454     it->second->AddNode( aNode ); // add aNode to submesh
 455   }
 456
 457   /*int HashCode( const TopoDS_Shape& S, const Standard_Integer theUpper ) const
 458   {
 459       return S.HashCode(2147483647);
 460   }*/
 461
 462   typedef std::list<const SMESHDS_Hypothesis*> THypList;
 463
 464   typedef NCollection_DataMap< TopoDS_Shape, THypList > ShapeToHypothesis;
 465
 466   ShapeToHypothesis          myShapeToHypothesis;
 467
 468   int                        myMeshID, myPersistentID;
 469   TopoDS_Shape               myShape;
 470
 471   typedef std::map<int,SMESHDS_SubMesh*> TShapeIndexToSubMesh;
 472   TShapeIndexToSubMesh myShapeIndexToSubMesh;
 473
 474   TopTools_IndexedMapOfShape myIndexToShape;
 475
 476   typedef std::set<SMESHDS_GroupBase*> TGroups;
 477   TGroups myGroups;
 478
 479   SMESHDS_Script*            myScript;
 480   bool                       myIsEmbeddedMode;
 481
 482   // optimize addition of nodes/elements to submeshes by, SetNodeInVolume() etc:
 483   // avoid search of submeshes in maps
 484   bool add( const SMDS_MeshElement* elem, SMESHDS_SubMesh* subMesh );
 485   SMESHDS_SubMesh* getSubmesh( const TopoDS_Shape & shape);
 486   SMESHDS_SubMesh* getSubmesh( const int            Index );
 487   int                        myCurSubID;
 488   TopoDS_Shape               myCurSubShape;
 489   SMESHDS_SubMesh*           myCurSubMesh;
 490 };
 491
 492
 493 #endif