SALOME - SMESH
SMESHDS_Mesh.hxx
Go to the documentation of this file.
00001 //  Copyright (C) 2007-2008  CEA/DEN, EDF R&D, OPEN CASCADE
00002 //
00003 //  Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
00004 //  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
00005 //
00006 //  This library is free software; you can redistribute it and/or
00007 //  modify it under the terms of the GNU Lesser General Public
00008 //  License as published by the Free Software Foundation; either
00009 //  version 2.1 of the License.
00010 //
00011 //  This library is distributed in the hope that it will be useful,
00012 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
00013 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00014 //  Lesser General Public License for more details.
00015 //
00016 //  You should have received a copy of the GNU Lesser General Public
00017 //  License along with this library; if not, write to the Free Software
00018 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
00019 //
00020 //  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
00021 //
00022 //  SMESH SMESHDS : management of mesh data and SMESH document
00023 //  File   : SMESHDS_Mesh.hxx
00024 //  Module : SMESH
00025 //
00026 #ifndef _SMESHDS_Mesh_HeaderFile
00027 #define _SMESHDS_Mesh_HeaderFile
00028 
00029 #include "SMESH_SMESHDS.hxx"
00030 
00031 #include "SMDS_Mesh.hxx"
00032 #include "SMDS_MeshNode.hxx"
00033 #include "SMDS_Mesh0DElement.hxx"
00034 #include "SMDS_MeshEdge.hxx"
00035 #include "SMDS_MeshFace.hxx"
00036 #include "SMDS_MeshVolume.hxx"
00037 #include "SMESHDS_Hypothesis.hxx"
00038 #include "SMESHDS_SubMesh.hxx"
00039 #include "SMESHDS_Script.hxx"
00040 
00041 #include <TopTools_IndexedMapOfShape.hxx>
00042 #include <TopoDS_Shape.hxx>
00043 #include <TopoDS_Solid.hxx>
00044 #include <TopoDS_Shell.hxx>
00045 #include <TopoDS_Face.hxx>
00046 #include <TopoDS_Vertex.hxx>
00047 #include <TopoDS_Edge.hxx>
00048 
00049 #include <NCollection_DataMap.hxx>
00050 #include <map>
00051 /*
00052  * Using of native haah_map isn't portable and don't work on WIN32 platform.
00053  * So this functionality implement on new NCollection_DataMap technology
00054  */
00055 #include "SMESHDS_DataMapOfShape.hxx"
00056 
00057 class SMESHDS_GroupBase;
00058 
00059 class SMESHDS_EXPORT SMESHDS_Mesh:public SMDS_Mesh{
00060 public:
00061   SMESHDS_Mesh(int theMeshID, bool theIsEmbeddedMode);
00062   bool IsEmbeddedMode();
00063 
00064   void ShapeToMesh(const TopoDS_Shape & S);
00065   TopoDS_Shape ShapeToMesh() const;
00066   bool AddHypothesis(const TopoDS_Shape & SS, const SMESHDS_Hypothesis * H);
00067   bool RemoveHypothesis(const TopoDS_Shape & S, const SMESHDS_Hypothesis * H);
00068   
00069   virtual SMDS_MeshNode* AddNodeWithID(double x, double y, double z, int ID);
00070   virtual SMDS_MeshNode* AddNode(double x, double y, double z);
00071   
00072   virtual SMDS_Mesh0DElement* Add0DElementWithID(int nodeID, int ID);
00073   virtual SMDS_Mesh0DElement* Add0DElementWithID(const SMDS_MeshNode * node, int ID);
00074   virtual SMDS_Mesh0DElement* Add0DElement      (const SMDS_MeshNode * node);
00075   
00076   virtual SMDS_MeshEdge* AddEdgeWithID(int n1, int n2, int ID);
00077   virtual SMDS_MeshEdge* AddEdgeWithID(const SMDS_MeshNode * n1,
00078                                        const SMDS_MeshNode * n2, 
00079                                        int ID);
00080   virtual SMDS_MeshEdge* AddEdge(const SMDS_MeshNode * n1,
00081                                  const SMDS_MeshNode * n2);
00082   
00083   // 2d order edge with 3 nodes: n12 - node between n1 and n2
00084   virtual SMDS_MeshEdge* AddEdgeWithID(int n1, int n2, int n12, int ID);
00085   virtual SMDS_MeshEdge* AddEdgeWithID(const SMDS_MeshNode * n1,
00086                                        const SMDS_MeshNode * n2, 
00087                                        const SMDS_MeshNode * n12, 
00088                                        int ID);
00089   virtual SMDS_MeshEdge* AddEdge(const SMDS_MeshNode * n1,
00090                                  const SMDS_MeshNode * n2,
00091                                  const SMDS_MeshNode * n12);
00092 
00093   virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3, int ID);
00094   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
00095                                        const SMDS_MeshNode * n2,
00096                                        const SMDS_MeshNode * n3, 
00097                                        int ID);
00098   virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
00099                                  const SMDS_MeshNode * n2,
00100                                  const SMDS_MeshNode * n3);
00101 
00102   virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3, int n4, int ID);
00103   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
00104                                        const SMDS_MeshNode * n2,
00105                                        const SMDS_MeshNode * n3,
00106                                        const SMDS_MeshNode * n4, 
00107                                        int ID);
00108   virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
00109                                  const SMDS_MeshNode * n2,
00110                                  const SMDS_MeshNode * n3,
00111                                  const SMDS_MeshNode * n4);
00112 
00113   // 2d order triangle of 6 nodes
00114   virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3,
00115                                        int n12,int n23,int n31, int ID);
00116   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
00117                                        const SMDS_MeshNode * n2,
00118                                        const SMDS_MeshNode * n3, 
00119                                        const SMDS_MeshNode * n12,
00120                                        const SMDS_MeshNode * n23,
00121                                        const SMDS_MeshNode * n31, 
00122                                        int ID);
00123   virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
00124                                  const SMDS_MeshNode * n2,
00125                                  const SMDS_MeshNode * n3,
00126                                  const SMDS_MeshNode * n12,
00127                                  const SMDS_MeshNode * n23,
00128                                  const SMDS_MeshNode * n31);
00129 
00130   // 2d order quadrangle
00131   virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3, int n4,
00132                                        int n12,int n23,int n34,int n41, int ID);
00133   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
00134                                        const SMDS_MeshNode * n2,
00135                                        const SMDS_MeshNode * n3,
00136                                        const SMDS_MeshNode * n4, 
00137                                        const SMDS_MeshNode * n12,
00138                                        const SMDS_MeshNode * n23,
00139                                        const SMDS_MeshNode * n34,
00140                                        const SMDS_MeshNode * n41, 
00141                                        int ID);
00142   virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
00143                                  const SMDS_MeshNode * n2,
00144                                  const SMDS_MeshNode * n3,
00145                                  const SMDS_MeshNode * n4,
00146                                  const SMDS_MeshNode * n12,
00147                                  const SMDS_MeshNode * n23,
00148                                  const SMDS_MeshNode * n34,
00149                                  const SMDS_MeshNode * n41);
00150 
00151   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int ID);
00152   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
00153                                            const SMDS_MeshNode * n2,
00154                                            const SMDS_MeshNode * n3,
00155                                            const SMDS_MeshNode * n4, 
00156                                            int ID);
00157   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
00158                                      const SMDS_MeshNode * n2,
00159                                      const SMDS_MeshNode * n3,
00160                                      const SMDS_MeshNode * n4);
00161 
00162   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, int ID);
00163   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
00164                                            const SMDS_MeshNode * n2,
00165                                            const SMDS_MeshNode * n3,
00166                                            const SMDS_MeshNode * n4,
00167                                            const SMDS_MeshNode * n5, 
00168                                            int ID);
00169   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
00170                                      const SMDS_MeshNode * n2,
00171                                      const SMDS_MeshNode * n3,
00172                                      const SMDS_MeshNode * n4,
00173                                      const SMDS_MeshNode * n5);
00174 
00175   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, int n6, int ID);
00176   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
00177                                            const SMDS_MeshNode * n2,
00178                                            const SMDS_MeshNode * n3,
00179                                            const SMDS_MeshNode * n4,
00180                                            const SMDS_MeshNode * n5,
00181                                            const SMDS_MeshNode * n6, 
00182                                            int ID);
00183   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
00184                                      const SMDS_MeshNode * n2,
00185                                      const SMDS_MeshNode * n3,
00186                                      const SMDS_MeshNode * n4,
00187                                      const SMDS_MeshNode * n5,
00188                                      const SMDS_MeshNode * n6);
00189 
00190   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, int n6, int n7, int n8, int ID);
00191   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
00192                                            const SMDS_MeshNode * n2,
00193                                            const SMDS_MeshNode * n3,
00194                                            const SMDS_MeshNode * n4,
00195                                            const SMDS_MeshNode * n5,
00196                                            const SMDS_MeshNode * n6,
00197                                            const SMDS_MeshNode * n7,
00198                                            const SMDS_MeshNode * n8, 
00199                                            int ID);
00200   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
00201                                      const SMDS_MeshNode * n2,
00202                                      const SMDS_MeshNode * n3,
00203                                      const SMDS_MeshNode * n4,
00204                                      const SMDS_MeshNode * n5,
00205                                      const SMDS_MeshNode * n6,
00206                                      const SMDS_MeshNode * n7,
00207                                      const SMDS_MeshNode * n8);
00208   
00209   // 2d order tetrahedron of 10 nodes
00210   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
00211                                            int n12,int n23,int n31,
00212                                            int n14,int n24,int n34, int ID);
00213   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
00214                                            const SMDS_MeshNode * n2,
00215                                            const SMDS_MeshNode * n3,
00216                                            const SMDS_MeshNode * n4, 
00217                                            const SMDS_MeshNode * n12,
00218                                            const SMDS_MeshNode * n23,
00219                                            const SMDS_MeshNode * n31,
00220                                            const SMDS_MeshNode * n14, 
00221                                            const SMDS_MeshNode * n24,
00222                                            const SMDS_MeshNode * n34, 
00223                                            int ID);
00224   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
00225                                      const SMDS_MeshNode * n2,
00226                                      const SMDS_MeshNode * n3,
00227                                      const SMDS_MeshNode * n4,
00228                                      const SMDS_MeshNode * n12,
00229                                      const SMDS_MeshNode * n23,
00230                                      const SMDS_MeshNode * n31,
00231                                      const SMDS_MeshNode * n14, 
00232                                      const SMDS_MeshNode * n24,
00233                                      const SMDS_MeshNode * n34);
00234 
00235   // 2d order pyramid of 13 nodes
00236   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int n5,
00237                                            int n12,int n23,int n34,int n41,
00238                                            int n15,int n25,int n35,int n45,
00239                                            int ID);
00240   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
00241                                            const SMDS_MeshNode * n2,
00242                                            const SMDS_MeshNode * n3,
00243                                            const SMDS_MeshNode * n4,
00244                                            const SMDS_MeshNode * n5, 
00245                                            const SMDS_MeshNode * n12,
00246                                            const SMDS_MeshNode * n23,
00247                                            const SMDS_MeshNode * n34,
00248                                            const SMDS_MeshNode * n41, 
00249                                            const SMDS_MeshNode * n15,
00250                                            const SMDS_MeshNode * n25,
00251                                            const SMDS_MeshNode * n35,
00252                                            const SMDS_MeshNode * n45, 
00253                                            int ID);
00254   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
00255                                      const SMDS_MeshNode * n2,
00256                                      const SMDS_MeshNode * n3,
00257                                      const SMDS_MeshNode * n4,
00258                                      const SMDS_MeshNode * n5,
00259                                      const SMDS_MeshNode * n12,
00260                                      const SMDS_MeshNode * n23,
00261                                      const SMDS_MeshNode * n34,
00262                                      const SMDS_MeshNode * n41, 
00263                                      const SMDS_MeshNode * n15,
00264                                      const SMDS_MeshNode * n25,
00265                                      const SMDS_MeshNode * n35,
00266                                      const SMDS_MeshNode * n45);
00267 
00268   // 2d order Pentahedron with 15 nodes
00269   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3,
00270                                            int n4, int n5, int n6,
00271                                            int n12,int n23,int n31,
00272                                            int n45,int n56,int n64,
00273                                            int n14,int n25,int n36,
00274                                            int ID);
00275   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
00276                                            const SMDS_MeshNode * n2,
00277                                            const SMDS_MeshNode * n3,
00278                                            const SMDS_MeshNode * n4,
00279                                            const SMDS_MeshNode * n5,
00280                                            const SMDS_MeshNode * n6, 
00281                                            const SMDS_MeshNode * n12,
00282                                            const SMDS_MeshNode * n23,
00283                                            const SMDS_MeshNode * n31, 
00284                                            const SMDS_MeshNode * n45,
00285                                            const SMDS_MeshNode * n56,
00286                                            const SMDS_MeshNode * n64, 
00287                                            const SMDS_MeshNode * n14,
00288                                            const SMDS_MeshNode * n25,
00289                                            const SMDS_MeshNode * n36, 
00290                                            int ID);
00291   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
00292                                      const SMDS_MeshNode * n2,
00293                                      const SMDS_MeshNode * n3,
00294                                      const SMDS_MeshNode * n4,
00295                                      const SMDS_MeshNode * n5,
00296                                      const SMDS_MeshNode * n6, 
00297                                      const SMDS_MeshNode * n12,
00298                                      const SMDS_MeshNode * n23,
00299                                      const SMDS_MeshNode * n31, 
00300                                      const SMDS_MeshNode * n45,
00301                                      const SMDS_MeshNode * n56,
00302                                      const SMDS_MeshNode * n64, 
00303                                      const SMDS_MeshNode * n14,
00304                                      const SMDS_MeshNode * n25,
00305                                      const SMDS_MeshNode * n36);
00306 
00307   // 2d order Hexahedrons with 20 nodes
00308   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
00309                                            int n5, int n6, int n7, int n8,
00310                                            int n12,int n23,int n34,int n41,
00311                                            int n56,int n67,int n78,int n85,
00312                                            int n15,int n26,int n37,int n48,
00313                                            int ID);
00314   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
00315                                            const SMDS_MeshNode * n2,
00316                                            const SMDS_MeshNode * n3,
00317                                            const SMDS_MeshNode * n4,
00318                                            const SMDS_MeshNode * n5,
00319                                            const SMDS_MeshNode * n6,
00320                                            const SMDS_MeshNode * n7,
00321                                            const SMDS_MeshNode * n8, 
00322                                            const SMDS_MeshNode * n12,
00323                                            const SMDS_MeshNode * n23,
00324                                            const SMDS_MeshNode * n34,
00325                                            const SMDS_MeshNode * n41, 
00326                                            const SMDS_MeshNode * n56,
00327                                            const SMDS_MeshNode * n67,
00328                                            const SMDS_MeshNode * n78,
00329                                            const SMDS_MeshNode * n85, 
00330                                            const SMDS_MeshNode * n15,
00331                                            const SMDS_MeshNode * n26,
00332                                            const SMDS_MeshNode * n37,
00333                                            const SMDS_MeshNode * n48, 
00334                                            int ID);
00335   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
00336                                      const SMDS_MeshNode * n2,
00337                                      const SMDS_MeshNode * n3,
00338                                      const SMDS_MeshNode * n4,
00339                                      const SMDS_MeshNode * n5,
00340                                      const SMDS_MeshNode * n6,
00341                                      const SMDS_MeshNode * n7,
00342                                      const SMDS_MeshNode * n8, 
00343                                      const SMDS_MeshNode * n12,
00344                                      const SMDS_MeshNode * n23,
00345                                      const SMDS_MeshNode * n34,
00346                                      const SMDS_MeshNode * n41, 
00347                                      const SMDS_MeshNode * n56,
00348                                      const SMDS_MeshNode * n67,
00349                                      const SMDS_MeshNode * n78,
00350                                      const SMDS_MeshNode * n85, 
00351                                      const SMDS_MeshNode * n15,
00352                                      const SMDS_MeshNode * n26,
00353                                      const SMDS_MeshNode * n37,
00354                                      const SMDS_MeshNode * n48);
00355 
00356   virtual SMDS_MeshFace* AddPolygonalFaceWithID (std::vector<int> nodes_ids,
00357                                                  const int        ID);
00358 
00359   virtual SMDS_MeshFace* AddPolygonalFaceWithID (std::vector<const SMDS_MeshNode*> nodes,
00360                                                  const int                         ID);
00361 
00362   virtual SMDS_MeshFace* AddPolygonalFace (std::vector<const SMDS_MeshNode*> nodes);
00363 
00364   virtual SMDS_MeshVolume* AddPolyhedralVolumeWithID
00365                            (std::vector<int> nodes_ids,
00366                             std::vector<int> quantities,
00367                             const int        ID);
00368 
00369   virtual SMDS_MeshVolume* AddPolyhedralVolumeWithID
00370                            (std::vector<const SMDS_MeshNode*> nodes,
00371                             std::vector<int>                  quantities,
00372                             const int                         ID);
00373 
00374   virtual SMDS_MeshVolume* AddPolyhedralVolume
00375                            (std::vector<const SMDS_MeshNode*> nodes,
00376                             std::vector<int>                  quantities);
00377 
00378   void MoveNode(const SMDS_MeshNode *, double x, double y, double z);
00379   virtual void RemoveNode(const SMDS_MeshNode *);
00380   void RemoveElement(const SMDS_MeshElement *);
00381 
00386   void RemoveFreeNode   (const SMDS_MeshNode *,    SMESHDS_SubMesh *, bool fromGroups=true);
00387   void RemoveFreeElement(const SMDS_MeshElement *, SMESHDS_SubMesh *, bool fromGroups=true);
00388 
00389   void ClearMesh();
00390 
00391   bool ChangeElementNodes(const SMDS_MeshElement * elem,
00392                           const SMDS_MeshNode    * nodes[],
00393                           const int                nbnodes);
00394   bool ChangePolygonNodes(const SMDS_MeshElement * elem,
00395                           std::vector<const SMDS_MeshNode*> nodes);
00396   bool ChangePolyhedronNodes(const SMDS_MeshElement * elem,
00397                              std::vector<const SMDS_MeshNode*> nodes,
00398                              std::vector<int>                  quantities);
00399   void Renumber (const bool isNodes, const int startID=1, const int deltaID=1);
00400 
00401   void SetNodeInVolume(SMDS_MeshNode * aNode, const TopoDS_Shell & S);
00402   void SetNodeInVolume(SMDS_MeshNode * aNode, const TopoDS_Solid & S);
00403   void SetNodeOnFace(SMDS_MeshNode * aNode, const TopoDS_Face & S, double u=0., double v=0.);
00404   void SetNodeOnEdge(SMDS_MeshNode * aNode, const TopoDS_Edge & S, double u=0.);
00405   void SetNodeOnVertex(SMDS_MeshNode * aNode, const TopoDS_Vertex & S);
00406   void UnSetNodeOnShape(const SMDS_MeshNode * aNode);
00407   void SetMeshElementOnShape(const SMDS_MeshElement * anElt,
00408                              const TopoDS_Shape & S);
00409   void UnSetMeshElementOnShape(const SMDS_MeshElement * anElt,
00410                                const TopoDS_Shape & S);
00411   bool HasMeshElements(const TopoDS_Shape & S);
00412   SMESHDS_SubMesh * MeshElements(const TopoDS_Shape & S) const;
00413   SMESHDS_SubMesh * MeshElements(const int Index);
00414   std::list<int> SubMeshIndices();
00415   const std::map<int,SMESHDS_SubMesh*>& SubMeshes() const
00416   { return myShapeIndexToSubMesh; }
00417 
00418   bool HasHypothesis(const TopoDS_Shape & S);
00419   const std::list<const SMESHDS_Hypothesis*>& GetHypothesis(const TopoDS_Shape & S) const;
00420   SMESHDS_Script * GetScript();
00421   void ClearScript();
00422   int ShapeToIndex(const TopoDS_Shape & aShape) const;
00423   const TopoDS_Shape& IndexToShape(int ShapeIndex) const;
00424   int MaxShapeIndex() const { return myIndexToShape.Extent(); }
00425 
00426   SMESHDS_SubMesh * NewSubMesh(int Index);
00427   int AddCompoundSubmesh(const TopoDS_Shape& S, TopAbs_ShapeEnum type = TopAbs_SHAPE);
00428   void SetNodeInVolume(const SMDS_MeshNode * aNode, int Index);
00429   void SetNodeOnFace(SMDS_MeshNode * aNode, int Index , double u=0., double v=0.);
00430   void SetNodeOnEdge(SMDS_MeshNode * aNode, int Index , double u=0.);
00431   void SetNodeOnVertex(SMDS_MeshNode * aNode, int Index);
00432   void SetMeshElementOnShape(const SMDS_MeshElement * anElt, int Index);
00433 
00434   void AddGroup (SMESHDS_GroupBase* theGroup)      { myGroups.insert(theGroup); }
00435   void RemoveGroup (SMESHDS_GroupBase* theGroup)   { myGroups.erase(theGroup); }
00436   int GetNbGroups() const                      { return myGroups.size(); }
00437   const std::set<SMESHDS_GroupBase*>& GetGroups() const { return myGroups; }
00438 
00439   bool IsGroupOfSubShapes (const TopoDS_Shape& aSubShape) const;
00440 
00441   ~SMESHDS_Mesh();
00442   
00443 private:
00444   void addNodeToSubmesh( const SMDS_MeshNode* aNode, int Index )
00445   {
00446     //Update or build submesh
00447     std::map<int,SMESHDS_SubMesh*>::iterator it = myShapeIndexToSubMesh.find( Index );
00448     if ( it == myShapeIndexToSubMesh.end() )
00449       it = myShapeIndexToSubMesh.insert( std::make_pair(Index, new SMESHDS_SubMesh() )).first;
00450     it->second->AddNode( aNode ); // add aNode to submesh
00451     }
00452   
00453   /*int HashCode( const TopoDS_Shape& S, const Standard_Integer theUpper ) const
00454   {
00455       return S.HashCode(2147483647);
00456   }*/ 
00457 
00458   typedef std::list<const SMESHDS_Hypothesis*> THypList;
00459 
00460   typedef NCollection_DataMap< TopoDS_Shape, THypList > ShapeToHypothesis;
00461 
00462   ShapeToHypothesis          myShapeToHypothesis;
00463 
00464   int                        myMeshID;
00465   TopoDS_Shape               myShape;
00466 
00467   typedef std::map<int,SMESHDS_SubMesh*> TShapeIndexToSubMesh;
00468   TShapeIndexToSubMesh myShapeIndexToSubMesh;
00469 
00470   TopTools_IndexedMapOfShape myIndexToShape;
00471 
00472   typedef std::set<SMESHDS_GroupBase*> TGroups;
00473   TGroups myGroups;
00474 
00475   SMESHDS_Script*            myScript;
00476   bool                       myIsEmbeddedMode;
00477 
00478   // optimize addition of nodes/elements to submeshes by, SetNodeInVolume() etc:
00479   // avoid search of submeshes in maps
00480   bool add( const SMDS_MeshElement* elem, SMESHDS_SubMesh* subMesh );
00481   SMESHDS_SubMesh* getSubmesh( const TopoDS_Shape & shape);
00482   SMESHDS_SubMesh* getSubmesh( const int            Index );
00483   int                        myCurSubID;
00484   TopoDS_Shape               myCurSubShape;
00485   SMESHDS_SubMesh*           myCurSubMesh;
00486 };
00487 
00488 
00489 #endif