src/SMESHDS/SMESHDS_Mesh.hxx

   1 // Copyright (C) 2007-2024  CEA, EDF, 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, or (at your option) any later version.
  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 "SMESHDS_SubMesh.hxx"
  34
  35 #include <Basics_OCCTVersion.hxx>
  36
  37 #include <TopTools_IndexedMapOfShape.hxx>
  38 #include <TopoDS_Shape.hxx>
  39
  40 #include <map>
  41
  42 class TopoDS_Solid ;
  43 class TopoDS_Shell ;
  44 class TopoDS_Face  ;
  45 class TopoDS_Vertex;
  46 class TopoDS_Edge  ;
  47
  48 class SMESHDS_Script;
  49 class SMESHDS_Hypothesis;
  50 class SMDS_MeshNode     ;
  51 class SMDS_MeshEdge     ;
  52 class SMDS_MeshFace     ;
  53 class SMDS_MeshVolume   ;
  54 class SMDS_Mesh0DElement;
  55 class SMDS_BallElement;
  56
  57 /*
  58  * Using of native hash_map isn't portable and don't work on WIN32 platform.
  59  * So this functionality implement on new NCollection_DataMap technology
  60  */
  61 #include <NCollection_DataMap.hxx>
  62 typedef std::list<const SMESHDS_Hypothesis*>                          THypList;
  63
  64 struct SMESHDS_Hasher
  65 {
  66 #if OCC_VERSION_LARGE < 0x07080000
  67   static inline Standard_Boolean IsEqual(const TopoDS_Shape& S1,
  68                                          const TopoDS_Shape& S2)
  69   {
  70     return S1.IsSame(S2);
  71   }
  72   static inline Standard_Integer HashCode(const TopoDS_Shape& S,
  73                                           const Standard_Integer Upper)
  74   {
  75     return ::HashCode( S, Upper);
  76   }
  77 #else
  78   bool operator()(const TopoDS_Shape& S1, const TopoDS_Shape& S2) const
  79   {
  80     // for the purpose of ShapeToHypothesis map we don't consider shapes orientation
  81     return S1.IsSame(S2);
  82   }
  83   size_t operator()(const TopoDS_Shape& S) const
  84   {
  85     return std::hash<TopoDS_Shape>{}(S);
  86   }
  87 #endif
  88 };
  89
  90 typedef NCollection_DataMap< TopoDS_Shape, THypList, SMESHDS_Hasher > ShapeToHypothesis;
  91
  92 class SMESHDS_GroupBase;
  93 class DownIdType;
  94
  95 class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
  96 {
  97  public:
  98   SMESHDS_Mesh(int theMeshID, bool theIsEmbeddedMode);
  99   bool IsEmbeddedMode();
 100   void SetPersistentId(int id);
 101   int GetPersistentId() const;
 102
 103   void ShapeToMesh(const TopoDS_Shape & S);
 104   TopoDS_Shape ShapeToMesh() const;
 105   bool AddHypothesis(const TopoDS_Shape & SS, const SMESHDS_Hypothesis * H);
 106   bool RemoveHypothesis(const TopoDS_Shape & S, const SMESHDS_Hypothesis * H);
 107
 108   virtual SMDS_MeshNode* AddNodeWithID(double x, double y, double z, smIdType ID);
 109   virtual SMDS_MeshNode* AddNode(double x, double y, double z);
 110
 111   virtual SMDS_Mesh0DElement* Add0DElementWithID(smIdType nodeID, smIdType ID);
 112   virtual SMDS_Mesh0DElement* Add0DElementWithID(const SMDS_MeshNode * node, smIdType ID);
 113   virtual SMDS_Mesh0DElement* Add0DElement      (const SMDS_MeshNode * node);
 114
 115   virtual SMDS_BallElement* AddBallWithID(smIdType n,                   double diameter, smIdType ID);
 116   virtual SMDS_BallElement* AddBallWithID(const SMDS_MeshNode * n, double diameter, smIdType ID);
 117   virtual SMDS_BallElement* AddBall      (const SMDS_MeshNode * n, double diameter);
 118
 119   virtual SMDS_MeshEdge* AddEdgeWithID(smIdType n1, smIdType n2, smIdType ID);
 120   virtual SMDS_MeshEdge* AddEdgeWithID(const SMDS_MeshNode * n1,
 121                                        const SMDS_MeshNode * n2,
 122                                        smIdType ID);
 123   virtual SMDS_MeshEdge* AddEdge(const SMDS_MeshNode * n1,
 124                                  const SMDS_MeshNode * n2);
 125
 126   // 2d order edge with 3 nodes: n12 - node between n1 and n2
 127   virtual SMDS_MeshEdge* AddEdgeWithID(smIdType n1, smIdType n2, smIdType n12, smIdType ID);
 128   virtual SMDS_MeshEdge* AddEdgeWithID(const SMDS_MeshNode * n1,
 129                                        const SMDS_MeshNode * n2,
 130                                        const SMDS_MeshNode * n12,
 131                                        smIdType ID);
 132   virtual SMDS_MeshEdge* AddEdge(const SMDS_MeshNode * n1,
 133                                  const SMDS_MeshNode * n2,
 134                                  const SMDS_MeshNode * n12);
 135   // tria 3
 136   virtual SMDS_MeshFace* AddFaceWithID(smIdType n1, smIdType n2, smIdType n3, smIdType ID);
 137   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
 138                                        const SMDS_MeshNode * n2,
 139                                        const SMDS_MeshNode * n3,
 140                                        smIdType ID);
 141   virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
 142                                  const SMDS_MeshNode * n2,
 143                                  const SMDS_MeshNode * n3);
 144   // quad 4
 145   virtual SMDS_MeshFace* AddFaceWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType ID);
 146   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
 147                                        const SMDS_MeshNode * n2,
 148                                        const SMDS_MeshNode * n3,
 149                                        const SMDS_MeshNode * n4,
 150                                        smIdType ID);
 151   virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
 152                                  const SMDS_MeshNode * n2,
 153                                  const SMDS_MeshNode * n3,
 154                                  const SMDS_MeshNode * n4);
 155
 156   // 2d order triangle of 6 nodes
 157   virtual SMDS_MeshFace* AddFaceWithID(smIdType n1, smIdType n2, smIdType n3,
 158                                        smIdType n12,smIdType n23,smIdType n31, smIdType ID);
 159   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
 160                                        const SMDS_MeshNode * n2,
 161                                        const SMDS_MeshNode * n3,
 162                                        const SMDS_MeshNode * n12,
 163                                        const SMDS_MeshNode * n23,
 164                                        const SMDS_MeshNode * n31,
 165                                        smIdType ID);
 166   virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
 167                                  const SMDS_MeshNode * n2,
 168                                  const SMDS_MeshNode * n3,
 169                                  const SMDS_MeshNode * n12,
 170                                  const SMDS_MeshNode * n23,
 171                                  const SMDS_MeshNode * n31);
 172
 173   // biquadratic triangle of 7 nodes
 174   virtual SMDS_MeshFace* AddFaceWithID(smIdType n1, smIdType n2, smIdType n3,
 175                                        smIdType n12,smIdType n23,smIdType n31, smIdType nCenter, smIdType ID);
 176   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
 177                                        const SMDS_MeshNode * n2,
 178                                        const SMDS_MeshNode * n3,
 179                                        const SMDS_MeshNode * n12,
 180                                        const SMDS_MeshNode * n23,
 181                                        const SMDS_MeshNode * n31,
 182                                        const SMDS_MeshNode * nCenter,
 183                                        smIdType ID);
 184   virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
 185                                  const SMDS_MeshNode * n2,
 186                                  const SMDS_MeshNode * n3,
 187                                  const SMDS_MeshNode * n12,
 188                                  const SMDS_MeshNode * n23,
 189                                  const SMDS_MeshNode * n31,
 190                                  const SMDS_MeshNode * nCenter);
 191
 192   // 2d order quadrangle
 193   virtual SMDS_MeshFace* AddFaceWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
 194                                        smIdType n12,smIdType n23,smIdType n34,smIdType n41, smIdType ID);
 195   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
 196                                        const SMDS_MeshNode * n2,
 197                                        const SMDS_MeshNode * n3,
 198                                        const SMDS_MeshNode * n4,
 199                                        const SMDS_MeshNode * n12,
 200                                        const SMDS_MeshNode * n23,
 201                                        const SMDS_MeshNode * n34,
 202                                        const SMDS_MeshNode * n41,
 203                                        smIdType ID);
 204   virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
 205                                  const SMDS_MeshNode * n2,
 206                                  const SMDS_MeshNode * n3,
 207                                  const SMDS_MeshNode * n4,
 208                                  const SMDS_MeshNode * n12,
 209                                  const SMDS_MeshNode * n23,
 210                                  const SMDS_MeshNode * n34,
 211                                  const SMDS_MeshNode * n41);
 212
 213   // biquadratic quadrangle of 9 nodes
 214   virtual SMDS_MeshFace* AddFaceWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
 215                                        smIdType n12,smIdType n23,smIdType n34,smIdType n41, smIdType nCenter, smIdType ID);
 216   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
 217                                        const SMDS_MeshNode * n2,
 218                                        const SMDS_MeshNode * n3,
 219                                        const SMDS_MeshNode * n4,
 220                                        const SMDS_MeshNode * n12,
 221                                        const SMDS_MeshNode * n23,
 222                                        const SMDS_MeshNode * n34,
 223                                        const SMDS_MeshNode * n41,
 224                                        const SMDS_MeshNode * nCenter,
 225                                        smIdType ID);
 226   virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
 227                                  const SMDS_MeshNode * n2,
 228                                  const SMDS_MeshNode * n3,
 229                                  const SMDS_MeshNode * n4,
 230                                  const SMDS_MeshNode * n12,
 231                                  const SMDS_MeshNode * n23,
 232                                  const SMDS_MeshNode * n34,
 233                                  const SMDS_MeshNode * n41,
 234                                  const SMDS_MeshNode * nCenter);
 235   // tetra 4
 236   virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType ID);
 237   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 238                                            const SMDS_MeshNode * n2,
 239                                            const SMDS_MeshNode * n3,
 240                                            const SMDS_MeshNode * n4,
 241                                            smIdType ID);
 242   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 243                                      const SMDS_MeshNode * n2,
 244                                      const SMDS_MeshNode * n3,
 245                                      const SMDS_MeshNode * n4);
 246   // pyra 5
 247   virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType n5, smIdType ID);
 248   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 249                                            const SMDS_MeshNode * n2,
 250                                            const SMDS_MeshNode * n3,
 251                                            const SMDS_MeshNode * n4,
 252                                            const SMDS_MeshNode * n5,
 253                                            smIdType ID);
 254   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 255                                      const SMDS_MeshNode * n2,
 256                                      const SMDS_MeshNode * n3,
 257                                      const SMDS_MeshNode * n4,
 258                                      const SMDS_MeshNode * n5);
 259   // penta 6
 260   virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType n5, smIdType n6, smIdType ID);
 261   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 262                                            const SMDS_MeshNode * n2,
 263                                            const SMDS_MeshNode * n3,
 264                                            const SMDS_MeshNode * n4,
 265                                            const SMDS_MeshNode * n5,
 266                                            const SMDS_MeshNode * n6,
 267                                            smIdType ID);
 268   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 269                                      const SMDS_MeshNode * n2,
 270                                      const SMDS_MeshNode * n3,
 271                                      const SMDS_MeshNode * n4,
 272                                      const SMDS_MeshNode * n5,
 273                                      const SMDS_MeshNode * n6);
 274   // hexa 8
 275   virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType n5, smIdType n6, smIdType n7, smIdType n8, smIdType ID);
 276   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 277                                            const SMDS_MeshNode * n2,
 278                                            const SMDS_MeshNode * n3,
 279                                            const SMDS_MeshNode * n4,
 280                                            const SMDS_MeshNode * n5,
 281                                            const SMDS_MeshNode * n6,
 282                                            const SMDS_MeshNode * n7,
 283                                            const SMDS_MeshNode * n8,
 284                                            smIdType ID);
 285   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 286                                      const SMDS_MeshNode * n2,
 287                                      const SMDS_MeshNode * n3,
 288                                      const SMDS_MeshNode * n4,
 289                                      const SMDS_MeshNode * n5,
 290                                      const SMDS_MeshNode * n6,
 291                                      const SMDS_MeshNode * n7,
 292                                      const SMDS_MeshNode * n8);
 293   // hexagonal prism of 12 nodes
 294   virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType n5, smIdType n6,
 295                                            smIdType n7, smIdType n8, smIdType n9, smIdType n10, smIdType n11, smIdType n12, smIdType ID);
 296   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 297                                            const SMDS_MeshNode * n2,
 298                                            const SMDS_MeshNode * n3,
 299                                            const SMDS_MeshNode * n4,
 300                                            const SMDS_MeshNode * n5,
 301                                            const SMDS_MeshNode * n6,
 302                                            const SMDS_MeshNode * n7,
 303                                            const SMDS_MeshNode * n8,
 304                                            const SMDS_MeshNode * n9,
 305                                            const SMDS_MeshNode * n10,
 306                                            const SMDS_MeshNode * n11,
 307                                            const SMDS_MeshNode * n12,
 308                                            smIdType 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 * n6,
 315                                      const SMDS_MeshNode * n7,
 316                                      const SMDS_MeshNode * n8,
 317                                      const SMDS_MeshNode * n9,
 318                                      const SMDS_MeshNode * n10,
 319                                      const SMDS_MeshNode * n11,
 320                                      const SMDS_MeshNode * n12);
 321
 322   // 2d order tetrahedron of 10 nodes
 323   virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
 324                                            smIdType n12,smIdType n23,smIdType n31,
 325                                            smIdType n14,smIdType n24,smIdType n34, smIdType ID);
 326   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 327                                            const SMDS_MeshNode * n2,
 328                                            const SMDS_MeshNode * n3,
 329                                            const SMDS_MeshNode * n4,
 330                                            const SMDS_MeshNode * n12,
 331                                            const SMDS_MeshNode * n23,
 332                                            const SMDS_MeshNode * n31,
 333                                            const SMDS_MeshNode * n14,
 334                                            const SMDS_MeshNode * n24,
 335                                            const SMDS_MeshNode * n34,
 336                                            smIdType ID);
 337   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 338                                      const SMDS_MeshNode * n2,
 339                                      const SMDS_MeshNode * n3,
 340                                      const SMDS_MeshNode * n4,
 341                                      const SMDS_MeshNode * n12,
 342                                      const SMDS_MeshNode * n23,
 343                                      const SMDS_MeshNode * n31,
 344                                      const SMDS_MeshNode * n14,
 345                                      const SMDS_MeshNode * n24,
 346                                      const SMDS_MeshNode * n34);
 347
 348   // 2d order pyramid of 13 nodes
 349   virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType n5,
 350                                            smIdType n12,smIdType n23,smIdType n34,smIdType n41,
 351                                            smIdType n15,smIdType n25,smIdType n35,smIdType n45,
 352                                            smIdType ID);
 353   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 354                                            const SMDS_MeshNode * n2,
 355                                            const SMDS_MeshNode * n3,
 356                                            const SMDS_MeshNode * n4,
 357                                            const SMDS_MeshNode * n5,
 358                                            const SMDS_MeshNode * n12,
 359                                            const SMDS_MeshNode * n23,
 360                                            const SMDS_MeshNode * n34,
 361                                            const SMDS_MeshNode * n41,
 362                                            const SMDS_MeshNode * n15,
 363                                            const SMDS_MeshNode * n25,
 364                                            const SMDS_MeshNode * n35,
 365                                            const SMDS_MeshNode * n45,
 366                                            smIdType ID);
 367   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 368                                      const SMDS_MeshNode * n2,
 369                                      const SMDS_MeshNode * n3,
 370                                      const SMDS_MeshNode * n4,
 371                                      const SMDS_MeshNode * n5,
 372                                      const SMDS_MeshNode * n12,
 373                                      const SMDS_MeshNode * n23,
 374                                      const SMDS_MeshNode * n34,
 375                                      const SMDS_MeshNode * n41,
 376                                      const SMDS_MeshNode * n15,
 377                                      const SMDS_MeshNode * n25,
 378                                      const SMDS_MeshNode * n35,
 379                                      const SMDS_MeshNode * n45);
 380
 381   // 2d order Pentahedron with 15 nodes
 382   virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3,
 383                                            smIdType n4, smIdType n5, smIdType n6,
 384                                            smIdType n12,smIdType n23,smIdType n31,
 385                                            smIdType n45,smIdType n56,smIdType n64,
 386                                            smIdType n14,smIdType n25,smIdType n36,
 387                                            smIdType ID);
 388   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 389                                            const SMDS_MeshNode * n2,
 390                                            const SMDS_MeshNode * n3,
 391                                            const SMDS_MeshNode * n4,
 392                                            const SMDS_MeshNode * n5,
 393                                            const SMDS_MeshNode * n6,
 394                                            const SMDS_MeshNode * n12,
 395                                            const SMDS_MeshNode * n23,
 396                                            const SMDS_MeshNode * n31,
 397                                            const SMDS_MeshNode * n45,
 398                                            const SMDS_MeshNode * n56,
 399                                            const SMDS_MeshNode * n64,
 400                                            const SMDS_MeshNode * n14,
 401                                            const SMDS_MeshNode * n25,
 402                                            const SMDS_MeshNode * n36,
 403                                            smIdType ID);
 404   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 405                                      const SMDS_MeshNode * n2,
 406                                      const SMDS_MeshNode * n3,
 407                                      const SMDS_MeshNode * n4,
 408                                      const SMDS_MeshNode * n5,
 409                                      const SMDS_MeshNode * n6,
 410                                      const SMDS_MeshNode * n12,
 411                                      const SMDS_MeshNode * n23,
 412                                      const SMDS_MeshNode * n31,
 413                                      const SMDS_MeshNode * n45,
 414                                      const SMDS_MeshNode * n56,
 415                                      const SMDS_MeshNode * n64,
 416                                      const SMDS_MeshNode * n14,
 417                                      const SMDS_MeshNode * n25,
 418                                      const SMDS_MeshNode * n36);
 419
 420   // 2d order Pentahedron with 18 nodes
 421   virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3,
 422                                            smIdType n4, smIdType n5, smIdType n6,
 423                                            smIdType n12,smIdType n23,smIdType n31,
 424                                            smIdType n45,smIdType n56,smIdType n64,
 425                                            smIdType n14,smIdType n25,smIdType n36,
 426                                            smIdType n1245, smIdType n2356, smIdType n1346,
 427                                            smIdType ID);
 428   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 429                                            const SMDS_MeshNode * n2,
 430                                            const SMDS_MeshNode * n3,
 431                                            const SMDS_MeshNode * n4,
 432                                            const SMDS_MeshNode * n5,
 433                                            const SMDS_MeshNode * n6,
 434                                            const SMDS_MeshNode * n12,
 435                                            const SMDS_MeshNode * n23,
 436                                            const SMDS_MeshNode * n31,
 437                                            const SMDS_MeshNode * n45,
 438                                            const SMDS_MeshNode * n56,
 439                                            const SMDS_MeshNode * n64,
 440                                            const SMDS_MeshNode * n14,
 441                                            const SMDS_MeshNode * n25,
 442                                            const SMDS_MeshNode * n36,
 443                                            const SMDS_MeshNode * n1245,
 444                                            const SMDS_MeshNode * n2356,
 445                                            const SMDS_MeshNode * n1346,
 446                                            smIdType ID);
 447   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 448                                      const SMDS_MeshNode * n2,
 449                                      const SMDS_MeshNode * n3,
 450                                      const SMDS_MeshNode * n4,
 451                                      const SMDS_MeshNode * n5,
 452                                      const SMDS_MeshNode * n6,
 453                                      const SMDS_MeshNode * n12,
 454                                      const SMDS_MeshNode * n23,
 455                                      const SMDS_MeshNode * n31,
 456                                      const SMDS_MeshNode * n45,
 457                                      const SMDS_MeshNode * n56,
 458                                      const SMDS_MeshNode * n64,
 459                                      const SMDS_MeshNode * n14,
 460                                      const SMDS_MeshNode * n25,
 461                                      const SMDS_MeshNode * n36,
 462                                      const SMDS_MeshNode * n1245,
 463                                      const SMDS_MeshNode * n2356,
 464                                      const SMDS_MeshNode * n1346);
 465
 466   // 2d order Hexahedrons with 20 nodes
 467   virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
 468                                            smIdType n5, smIdType n6, smIdType n7, smIdType n8,
 469                                            smIdType n12,smIdType n23,smIdType n34,smIdType n41,
 470                                            smIdType n56,smIdType n67,smIdType n78,smIdType n85,
 471                                            smIdType n15,smIdType n26,smIdType n37,smIdType n48,
 472                                            smIdType ID);
 473   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 474                                            const SMDS_MeshNode * n2,
 475                                            const SMDS_MeshNode * n3,
 476                                            const SMDS_MeshNode * n4,
 477                                            const SMDS_MeshNode * n5,
 478                                            const SMDS_MeshNode * n6,
 479                                            const SMDS_MeshNode * n7,
 480                                            const SMDS_MeshNode * n8,
 481                                            const SMDS_MeshNode * n12,
 482                                            const SMDS_MeshNode * n23,
 483                                            const SMDS_MeshNode * n34,
 484                                            const SMDS_MeshNode * n41,
 485                                            const SMDS_MeshNode * n56,
 486                                            const SMDS_MeshNode * n67,
 487                                            const SMDS_MeshNode * n78,
 488                                            const SMDS_MeshNode * n85,
 489                                            const SMDS_MeshNode * n15,
 490                                            const SMDS_MeshNode * n26,
 491                                            const SMDS_MeshNode * n37,
 492                                            const SMDS_MeshNode * n48,
 493                                            smIdType ID);
 494   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 495                                      const SMDS_MeshNode * n2,
 496                                      const SMDS_MeshNode * n3,
 497                                      const SMDS_MeshNode * n4,
 498                                      const SMDS_MeshNode * n5,
 499                                      const SMDS_MeshNode * n6,
 500                                      const SMDS_MeshNode * n7,
 501                                      const SMDS_MeshNode * n8,
 502                                      const SMDS_MeshNode * n12,
 503                                      const SMDS_MeshNode * n23,
 504                                      const SMDS_MeshNode * n34,
 505                                      const SMDS_MeshNode * n41,
 506                                      const SMDS_MeshNode * n56,
 507                                      const SMDS_MeshNode * n67,
 508                                      const SMDS_MeshNode * n78,
 509                                      const SMDS_MeshNode * n85,
 510                                      const SMDS_MeshNode * n15,
 511                                      const SMDS_MeshNode * n26,
 512                                      const SMDS_MeshNode * n37,
 513                                      const SMDS_MeshNode * n48);
 514
 515   // 2d order Hexahedrons with 27 nodes
 516   virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
 517                                            smIdType n5, smIdType n6, smIdType n7, smIdType n8,
 518                                            smIdType n12,smIdType n23,smIdType n34,smIdType n41,
 519                                            smIdType n56,smIdType n67,smIdType n78,smIdType n85,
 520                                            smIdType n15,smIdType n26,smIdType n37,smIdType n48,
 521                                            smIdType n1234,smIdType n1256,smIdType n2367,smIdType n3478,
 522                                            smIdType n1458,smIdType n5678,smIdType nCenter,
 523                                            smIdType ID);
 524   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 525                                            const SMDS_MeshNode * n2,
 526                                            const SMDS_MeshNode * n3,
 527                                            const SMDS_MeshNode * n4,
 528                                            const SMDS_MeshNode * n5,
 529                                            const SMDS_MeshNode * n6,
 530                                            const SMDS_MeshNode * n7,
 531                                            const SMDS_MeshNode * n8,
 532                                            const SMDS_MeshNode * n12,
 533                                            const SMDS_MeshNode * n23,
 534                                            const SMDS_MeshNode * n34,
 535                                            const SMDS_MeshNode * n41,
 536                                            const SMDS_MeshNode * n56,
 537                                            const SMDS_MeshNode * n67,
 538                                            const SMDS_MeshNode * n78,
 539                                            const SMDS_MeshNode * n85,
 540                                            const SMDS_MeshNode * n15,
 541                                            const SMDS_MeshNode * n26,
 542                                            const SMDS_MeshNode * n37,
 543                                            const SMDS_MeshNode * n48,
 544                                            const SMDS_MeshNode * n1234,
 545                                            const SMDS_MeshNode * n1256,
 546                                            const SMDS_MeshNode * n2367,
 547                                            const SMDS_MeshNode * n3478,
 548                                            const SMDS_MeshNode * n1458,
 549                                            const SMDS_MeshNode * n5678,
 550                                            const SMDS_MeshNode * nCenter,
 551                                            smIdType ID);
 552   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 553                                      const SMDS_MeshNode * n2,
 554                                      const SMDS_MeshNode * n3,
 555                                      const SMDS_MeshNode * n4,
 556                                      const SMDS_MeshNode * n5,
 557                                      const SMDS_MeshNode * n6,
 558                                      const SMDS_MeshNode * n7,
 559                                      const SMDS_MeshNode * n8,
 560                                      const SMDS_MeshNode * n12,
 561                                      const SMDS_MeshNode * n23,
 562                                      const SMDS_MeshNode * n34,
 563                                      const SMDS_MeshNode * n41,
 564                                      const SMDS_MeshNode * n56,
 565                                      const SMDS_MeshNode * n67,
 566                                      const SMDS_MeshNode * n78,
 567                                      const SMDS_MeshNode * n85,
 568                                      const SMDS_MeshNode * n15,
 569                                      const SMDS_MeshNode * n26,
 570                                      const SMDS_MeshNode * n37,
 571                                      const SMDS_MeshNode * n48,
 572                                      const SMDS_MeshNode * n1234,
 573                                      const SMDS_MeshNode * n1256,
 574                                      const SMDS_MeshNode * n2367,
 575                                      const SMDS_MeshNode * n3478,
 576                                      const SMDS_MeshNode * n1458,
 577                                      const SMDS_MeshNode * n5678,
 578                                      const SMDS_MeshNode * nCenter);
 579
 580   virtual SMDS_MeshFace* AddPolygonalFaceWithID (const std::vector<smIdType>& nodes_ids,
 581                                                  const smIdType               ID);
 582
 583   virtual SMDS_MeshFace* AddPolygonalFaceWithID (const std::vector<const SMDS_MeshNode*>& nodes,
 584                                                  const smIdType                                ID);
 585
 586   virtual SMDS_MeshFace* AddPolygonalFace (const std::vector<const SMDS_MeshNode*>& nodes);
 587
 588   virtual SMDS_MeshFace* AddQuadPolygonalFaceWithID(const std::vector<smIdType> & nodes_ids,
 589                                                     const smIdType                ID);
 590
 591   virtual SMDS_MeshFace* AddQuadPolygonalFaceWithID(const std::vector<const SMDS_MeshNode*> & nodes,
 592                                                     const smIdType                                 ID);
 593
 594   virtual SMDS_MeshFace* AddQuadPolygonalFace(const std::vector<const SMDS_MeshNode*> & nodes);
 595
 596   virtual SMDS_MeshVolume* AddPolyhedralVolumeWithID
 597     (const std::vector<smIdType>& nodes_ids,
 598      const std::vector<int>&      quantities,
 599      const smIdType               ID);
 600
 601   virtual SMDS_MeshVolume* AddPolyhedralVolumeWithID
 602     (const std::vector<const SMDS_MeshNode*>& nodes,
 603      const std::vector<int>&                  quantities,
 604      const smIdType                           ID);
 605
 606   virtual SMDS_MeshVolume* AddPolyhedralVolume
 607     (const std::vector<const SMDS_MeshNode*>& nodes,
 608      const std::vector<int>&                  quantities);
 609
 610   virtual void MoveNode(const SMDS_MeshNode *, double x, double y, double z);
 611   virtual void RemoveNode(const SMDS_MeshNode *);
 612   void RemoveElement(const SMDS_MeshElement *);
 613
 614   /*! Remove only the given element/node and only if it is free.
 615    *  Methods do not work for meshes with descendants.
 616    *  Implemented for fast cleaning of meshes.
 617    */
 618   bool RemoveFreeNode   (const SMDS_MeshNode *,    SMESHDS_SubMesh *, bool fromGroups=true);
 619   void RemoveFreeElement(const SMDS_MeshElement *, SMESHDS_SubMesh *, bool fromGroups=true);
 620
 621   void ClearMesh();
 622
 623   bool ChangeElementNodes(const SMDS_MeshElement * elem,
 624                           const SMDS_MeshNode    * nodes[],
 625                           const int                nbnodes);
 626   bool ChangePolygonNodes(const SMDS_MeshElement *           elem,
 627                           std::vector<const SMDS_MeshNode*>& nodes);
 628   bool ChangePolyhedronNodes(const SMDS_MeshElement *                 elem,
 629                              const std::vector<const SMDS_MeshNode*>& nodes,
 630                              const std::vector<int>&                  quantities);
 631   bool ModifyCellNodes(vtkIdType smdsVolId, std::map<int,int> localClonedNodeIds);
 632   void Renumber (const bool isNodes, const smIdType startID=1, const smIdType deltaID=1);
 633
 634   void SetNodeInVolume(const SMDS_MeshNode * aNode, const TopoDS_Shell & S);
 635   void SetNodeInVolume(const SMDS_MeshNode * aNode, const TopoDS_Solid & S);
 636   void SetNodeOnFace  (const SMDS_MeshNode * aNode, const TopoDS_Face& S, double u=0.,double v=0.);
 637   void SetNodeOnEdge  (const SMDS_MeshNode * aNode, const TopoDS_Edge& S, double u=0.);
 638   void SetNodeOnVertex(const SMDS_MeshNode * aNode, const TopoDS_Vertex & S);
 639   void UnSetNodeOnShape(const SMDS_MeshNode * aNode);
 640   void UnSetElementOnShape(const SMDS_MeshElement * anElt);
 641   void SetMeshElementOnShape  (const SMDS_MeshElement * anElt, const TopoDS_Shape & S);
 642   void UnSetMeshElementOnShape(const SMDS_MeshElement * anElt, const TopoDS_Shape & S);
 643   void SetNodeInVolume(const SMDS_MeshNode * aNode, int Index);
 644   void SetNodeOnFace  (const SMDS_MeshNode * aNode, int Index, double u=0., double v=0.);
 645   void SetNodeOnEdge  (const SMDS_MeshNode * aNode, int Index, double u=0.);
 646   void SetNodeOnVertex(const SMDS_MeshNode * aNode, int Index);
 647   void SetMeshElementOnShape(const SMDS_MeshElement * anElt, int Index);
 648   bool HasMeshElements(const TopoDS_Shape & S) const;
 649   SMESHDS_SubMesh * MeshElements(const TopoDS_Shape & S) const;
 650   SMESHDS_SubMesh * MeshElements(const int Index) const;
 651   std::list<int> SubMeshIndices() const;
 652   SMESHDS_SubMeshIteratorPtr SubMeshes() const;
 653
 654   bool HasHypothesis(const TopoDS_Shape & S);
 655   const std::list<const SMESHDS_Hypothesis*>& GetHypothesis(const TopoDS_Shape & S) const;
 656   bool IsUsedHypothesis(const SMESHDS_Hypothesis * H) const;
 657   const ShapeToHypothesis & GetHypotheses() const { return myShapeToHypothesis; }
 658
 659   SMESHDS_Script * GetScript();
 660   void ClearScript();
 661
 662   int ShapeToIndex(const TopoDS_Shape & aShape) const;
 663   const TopoDS_Shape& IndexToShape(int ShapeIndex) const;
 664   int MaxShapeIndex() const { return myIndexToShape.Extent(); }
 665   int MaxSubMeshIndex() const;
 666
 667   SMESHDS_SubMesh * NewSubMesh(int Index);
 668   int AddCompoundSubmesh(const TopoDS_Shape& S, TopAbs_ShapeEnum type = TopAbs_SHAPE);
 669
 670   // Groups. SMESHDS_Mesh is not an owner of groups
 671   void AddGroup (SMESHDS_GroupBase* theGroup)      { myGroups.insert(theGroup); }
 672   void RemoveGroup (SMESHDS_GroupBase* theGroup)   { myGroups.erase(theGroup); }
 673   size_t GetNbGroups() const                      { return myGroups.size(); }
 674   const std::set<SMESHDS_GroupBase*>& GetGroups() const { return myGroups; }
 675
 676   bool IsGroupOfSubShapes (const TopoDS_Shape& aSubShape) const;
 677
 678   virtual void CompactMesh();
 679   void CleanDownWardConnectivity();
 680   void BuildDownWardConnectivity(bool withEdges);
 681
 682   ~SMESHDS_Mesh();
 683
 684  private:
 685
 686   ShapeToHypothesis          myShapeToHypothesis;
 687
 688   int                        myPersistentID;
 689   TopoDS_Shape               myShape;
 690
 691   class SubMeshHolder;
 692   SubMeshHolder*             mySubMeshHolder;
 693
 694   TopTools_IndexedMapOfShape myIndexToShape;
 695
 696   typedef std::set<SMESHDS_GroupBase*> TGroups;
 697   TGroups                    myGroups;
 698
 699   SMESHDS_Script*            myScript;
 700   bool                       myIsEmbeddedMode;
 701
 702   int add( const SMDS_MeshElement* elem, SMESHDS_SubMesh* subMesh );
 703   SMESHDS_SubMesh* getSubmesh( const TopoDS_Shape & shape);
 704 };
 705
 706
 707 #endif