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