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