src/SMESHDS/SMESHDS_Mesh.hxx

   1 // Copyright (C) 2007-2012  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   // tria 3
  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   // quad 4
 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   // bi-quadratic quadrangle of 9 nodes
 156   virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3, int n4,
 157                                        int n12,int n23,int n34,int n41, int nCenter, int ID);
 158   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
 159                                        const SMDS_MeshNode * n2,
 160                                        const SMDS_MeshNode * n3,
 161                                        const SMDS_MeshNode * n4,
 162                                        const SMDS_MeshNode * n12,
 163                                        const SMDS_MeshNode * n23,
 164                                        const SMDS_MeshNode * n34,
 165                                        const SMDS_MeshNode * n41,
 166                                        const SMDS_MeshNode * nCenter,
 167                                        int ID);
 168   virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
 169                                  const SMDS_MeshNode * n2,
 170                                  const SMDS_MeshNode * n3,
 171                                  const SMDS_MeshNode * n4,
 172                                  const SMDS_MeshNode * n12,
 173                                  const SMDS_MeshNode * n23,
 174                                  const SMDS_MeshNode * n34,
 175                                  const SMDS_MeshNode * n41,
 176                                  const SMDS_MeshNode * nCenter);
 177   // tetra 4
 178   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int ID);
 179   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 180                                            const SMDS_MeshNode * n2,
 181                                            const SMDS_MeshNode * n3,
 182                                            const SMDS_MeshNode * n4,
 183                                            int ID);
 184   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 185                                      const SMDS_MeshNode * n2,
 186                                      const SMDS_MeshNode * n3,
 187                                      const SMDS_MeshNode * n4);
 188   // pyra 5
 189   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, int ID);
 190   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 191                                            const SMDS_MeshNode * n2,
 192                                            const SMDS_MeshNode * n3,
 193                                            const SMDS_MeshNode * n4,
 194                                            const SMDS_MeshNode * n5,
 195                                            int ID);
 196   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 197                                      const SMDS_MeshNode * n2,
 198                                      const SMDS_MeshNode * n3,
 199                                      const SMDS_MeshNode * n4,
 200                                      const SMDS_MeshNode * n5);
 201   // penta 6
 202   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, int n6, int ID);
 203   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 204                                            const SMDS_MeshNode * n2,
 205                                            const SMDS_MeshNode * n3,
 206                                            const SMDS_MeshNode * n4,
 207                                            const SMDS_MeshNode * n5,
 208                                            const SMDS_MeshNode * n6,
 209                                            int ID);
 210   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 211                                      const SMDS_MeshNode * n2,
 212                                      const SMDS_MeshNode * n3,
 213                                      const SMDS_MeshNode * n4,
 214                                      const SMDS_MeshNode * n5,
 215                                      const SMDS_MeshNode * n6);
 216   // hexa 8
 217   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, int n6, int n7, int n8, int ID);
 218   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 219                                            const SMDS_MeshNode * n2,
 220                                            const SMDS_MeshNode * n3,
 221                                            const SMDS_MeshNode * n4,
 222                                            const SMDS_MeshNode * n5,
 223                                            const SMDS_MeshNode * n6,
 224                                            const SMDS_MeshNode * n7,
 225                                            const SMDS_MeshNode * n8,
 226                                            int ID);
 227   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 228                                      const SMDS_MeshNode * n2,
 229                                      const SMDS_MeshNode * n3,
 230                                      const SMDS_MeshNode * n4,
 231                                      const SMDS_MeshNode * n5,
 232                                      const SMDS_MeshNode * n6,
 233                                      const SMDS_MeshNode * n7,
 234                                      const SMDS_MeshNode * n8);
 235   // hexagonal prism of 12 nodes
 236   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, int n6,
 237                                            int n7, int n8, int n9, int n10, int n11, int n12, int ID);
 238   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 239                                            const SMDS_MeshNode * n2,
 240                                            const SMDS_MeshNode * n3,
 241                                            const SMDS_MeshNode * n4,
 242                                            const SMDS_MeshNode * n5,
 243                                            const SMDS_MeshNode * n6,
 244                                            const SMDS_MeshNode * n7,
 245                                            const SMDS_MeshNode * n8,
 246                                            const SMDS_MeshNode * n9,
 247                                            const SMDS_MeshNode * n10,
 248                                            const SMDS_MeshNode * n11,
 249                                            const SMDS_MeshNode * n12,
 250                                            int ID);
 251   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 252                                      const SMDS_MeshNode * n2,
 253                                      const SMDS_MeshNode * n3,
 254                                      const SMDS_MeshNode * n4,
 255                                      const SMDS_MeshNode * n5,
 256                                      const SMDS_MeshNode * n6,
 257                                      const SMDS_MeshNode * n7,
 258                                      const SMDS_MeshNode * n8,
 259                                      const SMDS_MeshNode * n9,
 260                                      const SMDS_MeshNode * n10,
 261                                      const SMDS_MeshNode * n11,
 262                                      const SMDS_MeshNode * n12);
 263
 264   // 2d order tetrahedron of 10 nodes
 265   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
 266                                            int n12,int n23,int n31,
 267                                            int n14,int n24,int n34, int ID);
 268   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 269                                            const SMDS_MeshNode * n2,
 270                                            const SMDS_MeshNode * n3,
 271                                            const SMDS_MeshNode * n4,
 272                                            const SMDS_MeshNode * n12,
 273                                            const SMDS_MeshNode * n23,
 274                                            const SMDS_MeshNode * n31,
 275                                            const SMDS_MeshNode * n14,
 276                                            const SMDS_MeshNode * n24,
 277                                            const SMDS_MeshNode * n34,
 278                                            int ID);
 279   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 280                                      const SMDS_MeshNode * n2,
 281                                      const SMDS_MeshNode * n3,
 282                                      const SMDS_MeshNode * n4,
 283                                      const SMDS_MeshNode * n12,
 284                                      const SMDS_MeshNode * n23,
 285                                      const SMDS_MeshNode * n31,
 286                                      const SMDS_MeshNode * n14,
 287                                      const SMDS_MeshNode * n24,
 288                                      const SMDS_MeshNode * n34);
 289
 290   // 2d order pyramid of 13 nodes
 291   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int n5,
 292                                            int n12,int n23,int n34,int n41,
 293                                            int n15,int n25,int n35,int n45,
 294                                            int ID);
 295   virtual SMDS_MeshVolume* AddVolumeWithID(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 * n12,
 301                                            const SMDS_MeshNode * n23,
 302                                            const SMDS_MeshNode * n34,
 303                                            const SMDS_MeshNode * n41,
 304                                            const SMDS_MeshNode * n15,
 305                                            const SMDS_MeshNode * n25,
 306                                            const SMDS_MeshNode * n35,
 307                                            const SMDS_MeshNode * n45,
 308                                            int ID);
 309   virtual SMDS_MeshVolume* AddVolume(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 * n12,
 315                                      const SMDS_MeshNode * n23,
 316                                      const SMDS_MeshNode * n34,
 317                                      const SMDS_MeshNode * n41,
 318                                      const SMDS_MeshNode * n15,
 319                                      const SMDS_MeshNode * n25,
 320                                      const SMDS_MeshNode * n35,
 321                                      const SMDS_MeshNode * n45);
 322
 323   // 2d order Pentahedron with 15 nodes
 324   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3,
 325                                            int n4, int n5, int n6,
 326                                            int n12,int n23,int n31,
 327                                            int n45,int n56,int n64,
 328                                            int n14,int n25,int n36,
 329                                            int ID);
 330   virtual SMDS_MeshVolume* AddVolumeWithID(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 * n12,
 337                                            const SMDS_MeshNode * n23,
 338                                            const SMDS_MeshNode * n31,
 339                                            const SMDS_MeshNode * n45,
 340                                            const SMDS_MeshNode * n56,
 341                                            const SMDS_MeshNode * n64,
 342                                            const SMDS_MeshNode * n14,
 343                                            const SMDS_MeshNode * n25,
 344                                            const SMDS_MeshNode * n36,
 345                                            int ID);
 346   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 347                                      const SMDS_MeshNode * n2,
 348                                      const SMDS_MeshNode * n3,
 349                                      const SMDS_MeshNode * n4,
 350                                      const SMDS_MeshNode * n5,
 351                                      const SMDS_MeshNode * n6,
 352                                      const SMDS_MeshNode * n12,
 353                                      const SMDS_MeshNode * n23,
 354                                      const SMDS_MeshNode * n31,
 355                                      const SMDS_MeshNode * n45,
 356                                      const SMDS_MeshNode * n56,
 357                                      const SMDS_MeshNode * n64,
 358                                      const SMDS_MeshNode * n14,
 359                                      const SMDS_MeshNode * n25,
 360                                      const SMDS_MeshNode * n36);
 361
 362   // 2d order Hexahedrons with 20 nodes
 363   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
 364                                            int n5, int n6, int n7, int n8,
 365                                            int n12,int n23,int n34,int n41,
 366                                            int n56,int n67,int n78,int n85,
 367                                            int n15,int n26,int n37,int n48,
 368                                            int ID);
 369   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 370                                            const SMDS_MeshNode * n2,
 371                                            const SMDS_MeshNode * n3,
 372                                            const SMDS_MeshNode * n4,
 373                                            const SMDS_MeshNode * n5,
 374                                            const SMDS_MeshNode * n6,
 375                                            const SMDS_MeshNode * n7,
 376                                            const SMDS_MeshNode * n8,
 377                                            const SMDS_MeshNode * n12,
 378                                            const SMDS_MeshNode * n23,
 379                                            const SMDS_MeshNode * n34,
 380                                            const SMDS_MeshNode * n41,
 381                                            const SMDS_MeshNode * n56,
 382                                            const SMDS_MeshNode * n67,
 383                                            const SMDS_MeshNode * n78,
 384                                            const SMDS_MeshNode * n85,
 385                                            const SMDS_MeshNode * n15,
 386                                            const SMDS_MeshNode * n26,
 387                                            const SMDS_MeshNode * n37,
 388                                            const SMDS_MeshNode * n48,
 389                                            int ID);
 390   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 391                                      const SMDS_MeshNode * n2,
 392                                      const SMDS_MeshNode * n3,
 393                                      const SMDS_MeshNode * n4,
 394                                      const SMDS_MeshNode * n5,
 395                                      const SMDS_MeshNode * n6,
 396                                      const SMDS_MeshNode * n7,
 397                                      const SMDS_MeshNode * n8,
 398                                      const SMDS_MeshNode * n12,
 399                                      const SMDS_MeshNode * n23,
 400                                      const SMDS_MeshNode * n34,
 401                                      const SMDS_MeshNode * n41,
 402                                      const SMDS_MeshNode * n56,
 403                                      const SMDS_MeshNode * n67,
 404                                      const SMDS_MeshNode * n78,
 405                                      const SMDS_MeshNode * n85,
 406                                      const SMDS_MeshNode * n15,
 407                                      const SMDS_MeshNode * n26,
 408                                      const SMDS_MeshNode * n37,
 409                                      const SMDS_MeshNode * n48);
 410
 411   // 2d order Hexahedrons with 27 nodes
 412   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
 413                                            int n5, int n6, int n7, int n8,
 414                                            int n12,int n23,int n34,int n41,
 415                                            int n56,int n67,int n78,int n85,
 416                                            int n15,int n26,int n37,int n48,
 417                                            int n1234,int n1256,int n2367,int n3478,
 418                                            int n1458,int n5678,int nCenter,
 419                                            int ID);
 420   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 421                                            const SMDS_MeshNode * n2,
 422                                            const SMDS_MeshNode * n3,
 423                                            const SMDS_MeshNode * n4,
 424                                            const SMDS_MeshNode * n5,
 425                                            const SMDS_MeshNode * n6,
 426                                            const SMDS_MeshNode * n7,
 427                                            const SMDS_MeshNode * n8,
 428                                            const SMDS_MeshNode * n12,
 429                                            const SMDS_MeshNode * n23,
 430                                            const SMDS_MeshNode * n34,
 431                                            const SMDS_MeshNode * n41,
 432                                            const SMDS_MeshNode * n56,
 433                                            const SMDS_MeshNode * n67,
 434                                            const SMDS_MeshNode * n78,
 435                                            const SMDS_MeshNode * n85,
 436                                            const SMDS_MeshNode * n15,
 437                                            const SMDS_MeshNode * n26,
 438                                            const SMDS_MeshNode * n37,
 439                                            const SMDS_MeshNode * n48,
 440                                            const SMDS_MeshNode * n1234,
 441                                            const SMDS_MeshNode * n1256,
 442                                            const SMDS_MeshNode * n2367,
 443                                            const SMDS_MeshNode * n3478,
 444                                            const SMDS_MeshNode * n1458,
 445                                            const SMDS_MeshNode * n5678,
 446                                            const SMDS_MeshNode * nCenter,
 447                                            int ID);
 448   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 449                                      const SMDS_MeshNode * n2,
 450                                      const SMDS_MeshNode * n3,
 451                                      const SMDS_MeshNode * n4,
 452                                      const SMDS_MeshNode * n5,
 453                                      const SMDS_MeshNode * n6,
 454                                      const SMDS_MeshNode * n7,
 455                                      const SMDS_MeshNode * n8,
 456                                      const SMDS_MeshNode * n12,
 457                                      const SMDS_MeshNode * n23,
 458                                      const SMDS_MeshNode * n34,
 459                                      const SMDS_MeshNode * n41,
 460                                      const SMDS_MeshNode * n56,
 461                                      const SMDS_MeshNode * n67,
 462                                      const SMDS_MeshNode * n78,
 463                                      const SMDS_MeshNode * n85,
 464                                      const SMDS_MeshNode * n15,
 465                                      const SMDS_MeshNode * n26,
 466                                      const SMDS_MeshNode * n37,
 467                                      const SMDS_MeshNode * n48,
 468                                      const SMDS_MeshNode * n1234,
 469                                      const SMDS_MeshNode * n1256,
 470                                      const SMDS_MeshNode * n2367,
 471                                      const SMDS_MeshNode * n3478,
 472                                      const SMDS_MeshNode * n1458,
 473                                      const SMDS_MeshNode * n5678,
 474                                      const SMDS_MeshNode * nCenter);
 475
 476   virtual SMDS_MeshFace* AddPolygonalFaceWithID (const std::vector<int>& nodes_ids,
 477                                                  const int               ID);
 478
 479   virtual SMDS_MeshFace* AddPolygonalFaceWithID (const std::vector<const SMDS_MeshNode*>& nodes,
 480                                                  const int                                ID);
 481
 482   virtual SMDS_MeshFace* AddPolygonalFace (const std::vector<const SMDS_MeshNode*>& nodes);
 483
 484   virtual SMDS_MeshVolume* AddPolyhedralVolumeWithID
 485                            (const std::vector<int>& nodes_ids,
 486                             const std::vector<int>& quantities,
 487                             const int               ID);
 488
 489   virtual SMDS_MeshVolume* AddPolyhedralVolumeWithID
 490                            (const std::vector<const SMDS_MeshNode*>& nodes,
 491                             const std::vector<int>&                  quantities,
 492                             const int                                ID);
 493
 494   virtual SMDS_MeshVolume* AddPolyhedralVolume
 495                            (const std::vector<const SMDS_MeshNode*>& nodes,
 496                             const std::vector<int>&                  quantities);
 497
 498   void MoveNode(const SMDS_MeshNode *, double x, double y, double z);
 499   virtual void RemoveNode(const SMDS_MeshNode *);
 500   void RemoveElement(const SMDS_MeshElement *);
 501
 502   /*! Remove only the given element/node and only if it is free.
 503    *  Methods do not work for meshes with descendants.
 504    *  Implemented for fast cleaning of meshes.
 505    */
 506   void RemoveFreeNode   (const SMDS_MeshNode *,    SMESHDS_SubMesh *, bool fromGroups=true);
 507   void RemoveFreeElement(const SMDS_MeshElement *, SMESHDS_SubMesh *, bool fromGroups=true);
 508
 509   void ClearMesh();
 510
 511   bool ChangeElementNodes(const SMDS_MeshElement * elem,
 512                           const SMDS_MeshNode    * nodes[],
 513                           const int                nbnodes);
 514   bool ChangePolygonNodes(const SMDS_MeshElement * elem,
 515                           std::vector<const SMDS_MeshNode*> nodes);
 516   bool ChangePolyhedronNodes(const SMDS_MeshElement * elem,
 517                              std::vector<const SMDS_MeshNode*> nodes,
 518                              std::vector<int>                  quantities);
 519   bool ModifyCellNodes(int smdsVolId, std::map<int,int> localClonedNodeIds);
 520   void Renumber (const bool isNodes, const int startID=1, const int deltaID=1);
 521
 522   void SetNodeInVolume(SMDS_MeshNode * aNode, const TopoDS_Shell & S);
 523   void SetNodeInVolume(SMDS_MeshNode * aNode, const TopoDS_Solid & S);
 524   void SetNodeOnFace(SMDS_MeshNode * aNode, const TopoDS_Face & S, double u=0., double v=0.);
 525   void SetNodeOnEdge(SMDS_MeshNode * aNode, const TopoDS_Edge & S, double u=0.);
 526   void SetNodeOnVertex(SMDS_MeshNode * aNode, const TopoDS_Vertex & S);
 527   void UnSetNodeOnShape(const SMDS_MeshNode * aNode);
 528   void SetMeshElementOnShape(const SMDS_MeshElement * anElt,
 529                              const TopoDS_Shape & S);
 530   void UnSetMeshElementOnShape(const SMDS_MeshElement * anElt,
 531                                const TopoDS_Shape & S);
 532   bool HasMeshElements(const TopoDS_Shape & S) const;
 533   SMESHDS_SubMesh * MeshElements(const TopoDS_Shape & S) const;
 534   SMESHDS_SubMesh * MeshElements(const int Index) const;
 535   std::list<int> SubMeshIndices() const;
 536   const std::map<int,SMESHDS_SubMesh*>& SubMeshes() const
 537   { return myShapeIndexToSubMesh; }
 538
 539   bool HasHypothesis(const TopoDS_Shape & S);
 540   const std::list<const SMESHDS_Hypothesis*>& GetHypothesis(const TopoDS_Shape & S) const;
 541   bool IsUsedHypothesis(const SMESHDS_Hypothesis * H) const;
 542   SMESHDS_Script * GetScript();
 543   void ClearScript();
 544   int ShapeToIndex(const TopoDS_Shape & aShape) const;
 545   const TopoDS_Shape& IndexToShape(int ShapeIndex) const;
 546   int MaxShapeIndex() const { return myIndexToShape.Extent(); }
 547   int MaxSubMeshIndex() const;
 548
 549   SMESHDS_SubMesh * NewSubMesh(int Index);
 550   int AddCompoundSubmesh(const TopoDS_Shape& S, TopAbs_ShapeEnum type = TopAbs_SHAPE);
 551   void SetNodeInVolume(const SMDS_MeshNode * aNode, int Index);
 552   void SetNodeOnFace(SMDS_MeshNode * aNode, int Index , double u=0., double v=0.);
 553   void SetNodeOnEdge(SMDS_MeshNode * aNode, int Index , double u=0.);
 554   void SetNodeOnVertex(SMDS_MeshNode * aNode, int Index);
 555   void SetMeshElementOnShape(const SMDS_MeshElement * anElt, int Index);
 556
 557   // Groups. SMESHDS_Mesh is not an owner of groups
 558   void AddGroup (SMESHDS_GroupBase* theGroup)      { myGroups.insert(theGroup); }
 559   void RemoveGroup (SMESHDS_GroupBase* theGroup)   { myGroups.erase(theGroup); }
 560   int GetNbGroups() const                      { return myGroups.size(); }
 561   const std::set<SMESHDS_GroupBase*>& GetGroups() const { return myGroups; }
 562
 563   bool IsGroupOfSubShapes (const TopoDS_Shape& aSubShape) const;
 564
 565   virtual void compactMesh();
 566   void CleanDownWardConnectivity();
 567   void BuildDownWardConnectivity(bool withEdges);
 568
 569   ~SMESHDS_Mesh();
 570
 571 private:
 572   void addNodeToSubmesh( const SMDS_MeshNode* aNode, int Index )
 573   {
 574     //Update or build submesh
 575     std::map<int,SMESHDS_SubMesh*>::iterator it = myShapeIndexToSubMesh.find( Index );
 576     if ( it == myShapeIndexToSubMesh.end() )
 577       it = myShapeIndexToSubMesh.insert( std::make_pair(Index, new SMESHDS_SubMesh(this, Index) )).first;
 578     it->second->AddNode( aNode ); // add aNode to submesh
 579   }
 580
 581   /*int HashCode( const TopoDS_Shape& S, const Standard_Integer theUpper ) const
 582   {
 583       return S.HashCode(2147483647);
 584   }*/
 585
 586   typedef std::list<const SMESHDS_Hypothesis*> THypList;
 587
 588   typedef NCollection_DataMap< TopoDS_Shape, THypList > ShapeToHypothesis;
 589
 590   ShapeToHypothesis          myShapeToHypothesis;
 591
 592   int                        myMeshID, myPersistentID;
 593   TopoDS_Shape               myShape;
 594
 595   typedef std::map<int,SMESHDS_SubMesh*> TShapeIndexToSubMesh;
 596   TShapeIndexToSubMesh myShapeIndexToSubMesh;
 597
 598   TopTools_IndexedMapOfShape myIndexToShape;
 599
 600   typedef std::set<SMESHDS_GroupBase*> TGroups;
 601   TGroups myGroups;
 602
 603   SMESHDS_Script*            myScript;
 604   bool                       myIsEmbeddedMode;
 605
 606   // optimize addition of nodes/elements to submeshes by, SetNodeInVolume() etc:
 607   // avoid search of submeshes in maps
 608   bool add( const SMDS_MeshElement* elem, SMESHDS_SubMesh* subMesh );
 609   SMESHDS_SubMesh* getSubmesh( const TopoDS_Shape & shape);
 610   SMESHDS_SubMesh* getSubmesh( const int            Index );
 611   int                        myCurSubID;
 612   TopoDS_Shape               myCurSubShape;
 613   SMESHDS_SubMesh*           myCurSubMesh;
 614 };
 615
 616
 617 #endif