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