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