src/SMESHDS/SMESHDS_Mesh.hxx

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