src/SMDS/SMDS_Mesh.hxx

   1 // Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 // This library is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU Lesser General Public
   8 // License as published by the Free Software Foundation; either
   9 // version 2.1 of the License, 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 SMDS : implementation of Salome mesh data structure
  24 //  File   : SMDS_Mesh.hxx
  25 //  Module : SMESH
  26 //
  27 #ifndef _SMDS_Mesh_HeaderFile
  28 #define _SMDS_Mesh_HeaderFile
  29
  30 #include "SMESH_SMDS.hxx"
  31
  32 #include "SMDS_BallElement.hxx"
  33 #include "SMDS_ElemIterator.hxx"
  34 #include "SMDS_Mesh0DElement.hxx"
  35 #include "SMDS_MeshCell.hxx"
  36 #include "SMDS_MeshEdge.hxx"
  37 #include "SMDS_MeshFace.hxx"
  38 #include "SMDS_MeshInfo.hxx"
  39 #include "SMDS_MeshNode.hxx"
  40 #include "SMDS_MeshVolume.hxx"
  41 #include "SMDS_UnstructuredGrid.hxx"
  42
  43 #include <set>
  44 #include <list>
  45 #include <vector>
  46 #include <smIdType.hxx>
  47
  48 class SMDS_ElementHolder;
  49 class SMDS_ElementFactory;
  50 class SMDS_NodeFactory;
  51
  52 class SMDS_EXPORT SMDS_Mesh : public SMDS_MeshObject
  53 {
  54 public:
  55
  56   SMDS_Mesh();
  57
  58   //! actual nodes coordinates, cells definition and reverse connectivity are stored in a vtkUnstructuredGrid
  59   inline SMDS_UnstructuredGrid* GetGrid() { return myGrid; }
  60
  61   virtual SMDS_NodeIteratorPtr   nodesIterator  () const;
  62   virtual SMDS_EdgeIteratorPtr   edgesIterator  () const;
  63   virtual SMDS_FaceIteratorPtr   facesIterator  () const;
  64   virtual SMDS_VolumeIteratorPtr volumesIterator() const;
  65
  66   virtual SMDS_ElemIteratorPtr elementsIterator(SMDSAbs_ElementType type=SMDSAbs_All) const;
  67   virtual SMDS_ElemIteratorPtr elementGeomIterator(SMDSAbs_GeometryType type) const;
  68   virtual SMDS_ElemIteratorPtr elementEntityIterator(SMDSAbs_EntityType type) const;
  69
  70   virtual SMDS_NodeIteratorPtr shapeNodesIterator   (int                  shapeID,
  71                                                      size_t               nbElemsToReturn=-1,
  72                                                      const SMDS_MeshNode* sm1stNode=0) const;
  73   virtual SMDS_ElemIteratorPtr shapeElementsIterator(int                     shapeID,
  74                                                      size_t                  nbElemsToReturn=-1,
  75                                                      const SMDS_MeshElement* sm1stElem=0) const;
  76
  77   SMDSAbs_ElementType GetElementType( const smIdType id, const bool iselem ) const;
  78
  79   SMDS_Mesh *AddSubMesh();
  80
  81   virtual SMDS_MeshNode* AddNodeWithID(double x, double y, double z, smIdType ID);
  82   virtual SMDS_MeshNode* AddNode      (double x, double y, double z);
  83
  84   virtual SMDS_Mesh0DElement* Add0DElementWithID(smIdType n,                   smIdType ID);
  85   virtual SMDS_Mesh0DElement* Add0DElementWithID(const SMDS_MeshNode * n, smIdType ID);
  86   virtual SMDS_Mesh0DElement* Add0DElement      (const SMDS_MeshNode * n);
  87
  88   virtual SMDS_BallElement* AddBallWithID(smIdType n,                   double diameter, smIdType ID);
  89   virtual SMDS_BallElement* AddBallWithID(const SMDS_MeshNode * n, double diameter, smIdType ID);
  90   virtual SMDS_BallElement* AddBall      (const SMDS_MeshNode * n, double diameter);
  91
  92   virtual SMDS_MeshEdge* AddEdgeWithID(smIdType n1, smIdType n2, smIdType ID);
  93   virtual SMDS_MeshEdge* AddEdgeWithID(const SMDS_MeshNode * n1,
  94                                        const SMDS_MeshNode * n2,
  95                                        smIdType ID);
  96   virtual SMDS_MeshEdge* AddEdge(const SMDS_MeshNode * n1,
  97                                  const SMDS_MeshNode * n2);
  98
  99   // 2d order edge with 3 nodes: n12 - node between n1 and n2
 100   virtual SMDS_MeshEdge* AddEdgeWithID(smIdType n1, smIdType n2, smIdType n12, smIdType ID);
 101   virtual SMDS_MeshEdge* AddEdgeWithID(const SMDS_MeshNode * n1,
 102                                        const SMDS_MeshNode * n2,
 103                                        const SMDS_MeshNode * n12,
 104                                        smIdType ID);
 105   virtual SMDS_MeshEdge* AddEdge(const SMDS_MeshNode * n1,
 106                                  const SMDS_MeshNode * n2,
 107                                  const SMDS_MeshNode * n12);
 108
 109   virtual SMDS_MeshFace* AddFaceWithID(smIdType n1, smIdType n2, smIdType n3, smIdType ID);
 110   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
 111                                        const SMDS_MeshNode * n2,
 112                                        const SMDS_MeshNode * n3,
 113                                        smIdType ID);
 114   virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
 115                                  const SMDS_MeshNode * n2,
 116                                  const SMDS_MeshNode * n3);
 117
 118   virtual SMDS_MeshFace* AddFaceWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType ID);
 119   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
 120                                        const SMDS_MeshNode * n2,
 121                                        const SMDS_MeshNode * n3,
 122                                        const SMDS_MeshNode * n4,
 123                                        smIdType ID);
 124   virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
 125                                  const SMDS_MeshNode * n2,
 126                                  const SMDS_MeshNode * n3,
 127                                  const SMDS_MeshNode * n4);
 128
 129
 130   // 2d order triangle of 6 nodes
 131   virtual SMDS_MeshFace* AddFaceWithID(smIdType n1, smIdType n2, smIdType n3,
 132                                        smIdType n12,smIdType n23,smIdType n31, smIdType ID);
 133   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
 134                                        const SMDS_MeshNode * n2,
 135                                        const SMDS_MeshNode * n3,
 136                                        const SMDS_MeshNode * n12,
 137                                        const SMDS_MeshNode * n23,
 138                                        const SMDS_MeshNode * n31,
 139                                        smIdType ID);
 140   virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
 141                                  const SMDS_MeshNode * n2,
 142                                  const SMDS_MeshNode * n3,
 143                                  const SMDS_MeshNode * n12,
 144                                  const SMDS_MeshNode * n23,
 145                                  const SMDS_MeshNode * n31);
 146
 147   // 2d order triangle of 7 nodes
 148   virtual SMDS_MeshFace* AddFaceWithID(smIdType n1, smIdType n2, smIdType n3,
 149                                        smIdType n12,smIdType n23,smIdType n31, smIdType nCenter, smIdType ID);
 150   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
 151                                        const SMDS_MeshNode * n2,
 152                                        const SMDS_MeshNode * n3,
 153                                        const SMDS_MeshNode * n12,
 154                                        const SMDS_MeshNode * n23,
 155                                        const SMDS_MeshNode * n31,
 156                                        const SMDS_MeshNode * nCenter,
 157                                        smIdType ID);
 158   virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
 159                                  const SMDS_MeshNode * n2,
 160                                  const SMDS_MeshNode * n3,
 161                                  const SMDS_MeshNode * n12,
 162                                  const SMDS_MeshNode * n23,
 163                                  const SMDS_MeshNode * n31,
 164                                  const SMDS_MeshNode * nCenter);
 165
 166   // 2d order quadrangle
 167   virtual SMDS_MeshFace* AddFaceWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
 168                                        smIdType n12,smIdType n23,smIdType n34,smIdType n41, smIdType ID);
 169   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
 170                                        const SMDS_MeshNode * n2,
 171                                        const SMDS_MeshNode * n3,
 172                                        const SMDS_MeshNode * n4,
 173                                        const SMDS_MeshNode * n12,
 174                                        const SMDS_MeshNode * n23,
 175                                        const SMDS_MeshNode * n34,
 176                                        const SMDS_MeshNode * n41,
 177                                        smIdType ID);
 178   virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
 179                                  const SMDS_MeshNode * n2,
 180                                  const SMDS_MeshNode * n3,
 181                                  const SMDS_MeshNode * n4,
 182                                  const SMDS_MeshNode * n12,
 183                                  const SMDS_MeshNode * n23,
 184                                  const SMDS_MeshNode * n34,
 185                                  const SMDS_MeshNode * n41);
 186
 187   virtual SMDS_MeshFace* AddFaceWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
 188                                        smIdType n12,smIdType n23,smIdType n34,smIdType n41, smIdType nCenter, smIdType ID);
 189   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
 190                                        const SMDS_MeshNode * n2,
 191                                        const SMDS_MeshNode * n3,
 192                                        const SMDS_MeshNode * n4,
 193                                        const SMDS_MeshNode * n12,
 194                                        const SMDS_MeshNode * n23,
 195                                        const SMDS_MeshNode * n34,
 196                                        const SMDS_MeshNode * n41,
 197                                        const SMDS_MeshNode * nCenter,
 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                                  const SMDS_MeshNode * nCenter);
 208
 209   virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType ID);
 210   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 211                                            const SMDS_MeshNode * n2,
 212                                            const SMDS_MeshNode * n3,
 213                                            const SMDS_MeshNode * n4,
 214                                            smIdType ID);
 215   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 216                                      const SMDS_MeshNode * n2,
 217                                      const SMDS_MeshNode * n3,
 218                                      const SMDS_MeshNode * n4);
 219
 220   virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
 221                                            smIdType n5, smIdType ID);
 222   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 223                                            const SMDS_MeshNode * n2,
 224                                            const SMDS_MeshNode * n3,
 225                                            const SMDS_MeshNode * n4,
 226                                            const SMDS_MeshNode * n5,
 227                                            smIdType ID);
 228   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 229                                      const SMDS_MeshNode * n2,
 230                                      const SMDS_MeshNode * n3,
 231                                      const SMDS_MeshNode * n4,
 232                                      const SMDS_MeshNode * n5);
 233
 234   virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
 235                                            smIdType n5, smIdType n6, smIdType ID);
 236   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 237                                            const SMDS_MeshNode * n2,
 238                                            const SMDS_MeshNode * n3,
 239                                            const SMDS_MeshNode * n4,
 240                                            const SMDS_MeshNode * n5,
 241                                            const SMDS_MeshNode * n6,
 242                                            smIdType ID);
 243   virtual SMDS_MeshVolume* AddVolume(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                                      const SMDS_MeshNode * n6);
 249
 250   virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
 251                                            smIdType n5, smIdType n6, smIdType n7, smIdType n8, smIdType ID);
 252   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 253                                            const SMDS_MeshNode * n2,
 254                                            const SMDS_MeshNode * n3,
 255                                            const SMDS_MeshNode * n4,
 256                                            const SMDS_MeshNode * n5,
 257                                            const SMDS_MeshNode * n6,
 258                                            const SMDS_MeshNode * n7,
 259                                            const SMDS_MeshNode * n8,
 260                                            smIdType ID);
 261   virtual SMDS_MeshVolume* AddVolume(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                                      const SMDS_MeshNode * n7,
 268                                      const SMDS_MeshNode * n8);
 269
 270
 271   // hexagonal prism
 272   virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType n5, smIdType n6,
 273                                            smIdType n7, smIdType n8, smIdType n9, smIdType n10, smIdType n11, smIdType n12,
 274                                            smIdType ID);
 275   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 276                                            const SMDS_MeshNode * n2,
 277                                            const SMDS_MeshNode * n3,
 278                                            const SMDS_MeshNode * n4,
 279                                            const SMDS_MeshNode * n5,
 280                                            const SMDS_MeshNode * n6,
 281                                            const SMDS_MeshNode * n7,
 282                                            const SMDS_MeshNode * n8,
 283                                            const SMDS_MeshNode * n9,
 284                                            const SMDS_MeshNode * n10,
 285                                            const SMDS_MeshNode * n11,
 286                                            const SMDS_MeshNode * n12,
 287                                            smIdType ID);
 288   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 289                                      const SMDS_MeshNode * n2,
 290                                      const SMDS_MeshNode * n3,
 291                                      const SMDS_MeshNode * n4,
 292                                      const SMDS_MeshNode * n5,
 293                                      const SMDS_MeshNode * n6,
 294                                      const SMDS_MeshNode * n7,
 295                                      const SMDS_MeshNode * n8,
 296                                      const SMDS_MeshNode * n9,
 297                                      const SMDS_MeshNode * n10,
 298                                      const SMDS_MeshNode * n11,
 299                                      const SMDS_MeshNode * n12);
 300
 301   // 2d order tetrahedron of 10 nodes
 302   virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
 303                                            smIdType n12,smIdType n23,smIdType n31,
 304                                            smIdType n14,smIdType n24,smIdType n34, smIdType ID);
 305   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 306                                            const SMDS_MeshNode * n2,
 307                                            const SMDS_MeshNode * n3,
 308                                            const SMDS_MeshNode * n4,
 309                                            const SMDS_MeshNode * n12,
 310                                            const SMDS_MeshNode * n23,
 311                                            const SMDS_MeshNode * n31,
 312                                            const SMDS_MeshNode * n14,
 313                                            const SMDS_MeshNode * n24,
 314                                            const SMDS_MeshNode * n34,
 315                                            smIdType ID);
 316   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 317                                      const SMDS_MeshNode * n2,
 318                                      const SMDS_MeshNode * n3,
 319                                      const SMDS_MeshNode * n4,
 320                                      const SMDS_MeshNode * n12,
 321                                      const SMDS_MeshNode * n23,
 322                                      const SMDS_MeshNode * n31,
 323                                      const SMDS_MeshNode * n14,
 324                                      const SMDS_MeshNode * n24,
 325                                      const SMDS_MeshNode * n34);
 326
 327   // 2d order pyramid of 13 nodes
 328   virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType n5,
 329                                            smIdType n12,smIdType n23,smIdType n34,smIdType n41,
 330                                            smIdType n15,smIdType n25,smIdType n35,smIdType n45,
 331                                            smIdType ID);
 332   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 333                                            const SMDS_MeshNode * n2,
 334                                            const SMDS_MeshNode * n3,
 335                                            const SMDS_MeshNode * n4,
 336                                            const SMDS_MeshNode * n5,
 337                                            const SMDS_MeshNode * n12,
 338                                            const SMDS_MeshNode * n23,
 339                                            const SMDS_MeshNode * n34,
 340                                            const SMDS_MeshNode * n41,
 341                                            const SMDS_MeshNode * n15,
 342                                            const SMDS_MeshNode * n25,
 343                                            const SMDS_MeshNode * n35,
 344                                            const SMDS_MeshNode * n45,
 345                                            smIdType ID);
 346   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 347                                      const SMDS_MeshNode * n2,
 348                                      const SMDS_MeshNode * n3,
 349                                      const SMDS_MeshNode * n4,
 350                                      const SMDS_MeshNode * n5,
 351                                      const SMDS_MeshNode * n12,
 352                                      const SMDS_MeshNode * n23,
 353                                      const SMDS_MeshNode * n34,
 354                                      const SMDS_MeshNode * n41,
 355                                      const SMDS_MeshNode * n15,
 356                                      const SMDS_MeshNode * n25,
 357                                      const SMDS_MeshNode * n35,
 358                                      const SMDS_MeshNode * n45);
 359
 360   // 2d order Pentahedron with 15 nodes
 361   virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3,
 362                                            smIdType n4, smIdType n5, smIdType n6,
 363                                            smIdType n12,smIdType n23,smIdType n31,
 364                                            smIdType n45,smIdType n56,smIdType n64,
 365                                            smIdType n14,smIdType n25,smIdType n36,
 366                                            smIdType ID);
 367   virtual SMDS_MeshVolume* AddVolumeWithID(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 * n6,
 373                                            const SMDS_MeshNode * n12,
 374                                            const SMDS_MeshNode * n23,
 375                                            const SMDS_MeshNode * n31,
 376                                            const SMDS_MeshNode * n45,
 377                                            const SMDS_MeshNode * n56,
 378                                            const SMDS_MeshNode * n64,
 379                                            const SMDS_MeshNode * n14,
 380                                            const SMDS_MeshNode * n25,
 381                                            const SMDS_MeshNode * n36,
 382                                            smIdType ID);
 383   virtual SMDS_MeshVolume* AddVolume(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
 399   // 2d order Pentahedron with 18 nodes
 400   virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3,
 401                                            smIdType n4, smIdType n5, smIdType n6,
 402                                            smIdType n12,smIdType n23,smIdType n31,
 403                                            smIdType n45,smIdType n56,smIdType n64,
 404                                            smIdType n14,smIdType n25,smIdType n36,
 405                                            smIdType n1245, smIdType n2356, smIdType n1346,
 406                                            smIdType ID);
 407   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 408                                            const SMDS_MeshNode * n2,
 409                                            const SMDS_MeshNode * n3,
 410                                            const SMDS_MeshNode * n4,
 411                                            const SMDS_MeshNode * n5,
 412                                            const SMDS_MeshNode * n6,
 413                                            const SMDS_MeshNode * n12,
 414                                            const SMDS_MeshNode * n23,
 415                                            const SMDS_MeshNode * n31,
 416                                            const SMDS_MeshNode * n45,
 417                                            const SMDS_MeshNode * n56,
 418                                            const SMDS_MeshNode * n64,
 419                                            const SMDS_MeshNode * n14,
 420                                            const SMDS_MeshNode * n25,
 421                                            const SMDS_MeshNode * n36,
 422                                            const SMDS_MeshNode * n1245,
 423                                            const SMDS_MeshNode * n2356,
 424                                            const SMDS_MeshNode * n1346,
 425                                            smIdType ID);
 426   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 427                                      const SMDS_MeshNode * n2,
 428                                      const SMDS_MeshNode * n3,
 429                                      const SMDS_MeshNode * n4,
 430                                      const SMDS_MeshNode * n5,
 431                                      const SMDS_MeshNode * n6,
 432                                      const SMDS_MeshNode * n12,
 433                                      const SMDS_MeshNode * n23,
 434                                      const SMDS_MeshNode * n31,
 435                                      const SMDS_MeshNode * n45,
 436                                      const SMDS_MeshNode * n56,
 437                                      const SMDS_MeshNode * n64,
 438                                      const SMDS_MeshNode * n14,
 439                                      const SMDS_MeshNode * n25,
 440                                      const SMDS_MeshNode * n36,
 441                                      const SMDS_MeshNode * n1245,
 442                                      const SMDS_MeshNode * n2356,
 443                                      const SMDS_MeshNode * n1346);
 444
 445
 446   // 2d oreder Hexahedrons with 20 nodes
 447   virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
 448                                            smIdType n5, smIdType n6, smIdType n7, smIdType n8,
 449                                            smIdType n12,smIdType n23,smIdType n34,smIdType n41,
 450                                            smIdType n56,smIdType n67,smIdType n78,smIdType n85,
 451                                            smIdType n15,smIdType n26,smIdType n37,smIdType n48,
 452                                            smIdType ID);
 453   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 454                                            const SMDS_MeshNode * n2,
 455                                            const SMDS_MeshNode * n3,
 456                                            const SMDS_MeshNode * n4,
 457                                            const SMDS_MeshNode * n5,
 458                                            const SMDS_MeshNode * n6,
 459                                            const SMDS_MeshNode * n7,
 460                                            const SMDS_MeshNode * n8,
 461                                            const SMDS_MeshNode * n12,
 462                                            const SMDS_MeshNode * n23,
 463                                            const SMDS_MeshNode * n34,
 464                                            const SMDS_MeshNode * n41,
 465                                            const SMDS_MeshNode * n56,
 466                                            const SMDS_MeshNode * n67,
 467                                            const SMDS_MeshNode * n78,
 468                                            const SMDS_MeshNode * n85,
 469                                            const SMDS_MeshNode * n15,
 470                                            const SMDS_MeshNode * n26,
 471                                            const SMDS_MeshNode * n37,
 472                                            const SMDS_MeshNode * n48,
 473                                            smIdType ID);
 474   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 475                                      const SMDS_MeshNode * n2,
 476                                      const SMDS_MeshNode * n3,
 477                                      const SMDS_MeshNode * n4,
 478                                      const SMDS_MeshNode * n5,
 479                                      const SMDS_MeshNode * n6,
 480                                      const SMDS_MeshNode * n7,
 481                                      const SMDS_MeshNode * n8,
 482                                      const SMDS_MeshNode * n12,
 483                                      const SMDS_MeshNode * n23,
 484                                      const SMDS_MeshNode * n34,
 485                                      const SMDS_MeshNode * n41,
 486                                      const SMDS_MeshNode * n56,
 487                                      const SMDS_MeshNode * n67,
 488                                      const SMDS_MeshNode * n78,
 489                                      const SMDS_MeshNode * n85,
 490                                      const SMDS_MeshNode * n15,
 491                                      const SMDS_MeshNode * n26,
 492                                      const SMDS_MeshNode * n37,
 493                                      const SMDS_MeshNode * n48);
 494
 495   // 2d oreder Hexahedrons with 27 nodes
 496   virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
 497                                            smIdType n5, smIdType n6, smIdType n7, smIdType n8,
 498                                            smIdType n12,smIdType n23,smIdType n34,smIdType n41,
 499                                            smIdType n56,smIdType n67,smIdType n78,smIdType n85,
 500                                            smIdType n15,smIdType n26,smIdType n37,smIdType n48,
 501                                            smIdType n1234,smIdType n1256,smIdType n2367,smIdType n3478,
 502                                            smIdType n1458,smIdType n5678,smIdType nCenter,
 503                                            smIdType ID);
 504   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 505                                            const SMDS_MeshNode * n2,
 506                                            const SMDS_MeshNode * n3,
 507                                            const SMDS_MeshNode * n4,
 508                                            const SMDS_MeshNode * n5,
 509                                            const SMDS_MeshNode * n6,
 510                                            const SMDS_MeshNode * n7,
 511                                            const SMDS_MeshNode * n8,
 512                                            const SMDS_MeshNode * n12,
 513                                            const SMDS_MeshNode * n23,
 514                                            const SMDS_MeshNode * n34,
 515                                            const SMDS_MeshNode * n41,
 516                                            const SMDS_MeshNode * n56,
 517                                            const SMDS_MeshNode * n67,
 518                                            const SMDS_MeshNode * n78,
 519                                            const SMDS_MeshNode * n85,
 520                                            const SMDS_MeshNode * n15,
 521                                            const SMDS_MeshNode * n26,
 522                                            const SMDS_MeshNode * n37,
 523                                            const SMDS_MeshNode * n48,
 524                                            const SMDS_MeshNode * n1234,
 525                                            const SMDS_MeshNode * n1256,
 526                                            const SMDS_MeshNode * n2367,
 527                                            const SMDS_MeshNode * n3478,
 528                                            const SMDS_MeshNode * n1458,
 529                                            const SMDS_MeshNode * n5678,
 530                                            const SMDS_MeshNode * nCenter,
 531                                            smIdType ID);
 532   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 533                                      const SMDS_MeshNode * n2,
 534                                      const SMDS_MeshNode * n3,
 535                                      const SMDS_MeshNode * n4,
 536                                      const SMDS_MeshNode * n5,
 537                                      const SMDS_MeshNode * n6,
 538                                      const SMDS_MeshNode * n7,
 539                                      const SMDS_MeshNode * n8,
 540                                      const SMDS_MeshNode * n12,
 541                                      const SMDS_MeshNode * n23,
 542                                      const SMDS_MeshNode * n34,
 543                                      const SMDS_MeshNode * n41,
 544                                      const SMDS_MeshNode * n56,
 545                                      const SMDS_MeshNode * n67,
 546                                      const SMDS_MeshNode * n78,
 547                                      const SMDS_MeshNode * n85,
 548                                      const SMDS_MeshNode * n15,
 549                                      const SMDS_MeshNode * n26,
 550                                      const SMDS_MeshNode * n37,
 551                                      const SMDS_MeshNode * n48,
 552                                      const SMDS_MeshNode * n1234,
 553                                      const SMDS_MeshNode * n1256,
 554                                      const SMDS_MeshNode * n2367,
 555                                      const SMDS_MeshNode * n3478,
 556                                      const SMDS_MeshNode * n1458,
 557                                      const SMDS_MeshNode * n5678,
 558                                      const SMDS_MeshNode * nCenter);
 559
 560   virtual SMDS_MeshFace* AddPolygonalFaceWithID (const std::vector<smIdType> & nodes_ids,
 561                                                  const smIdType                ID);
 562
 563   virtual SMDS_MeshFace* AddPolygonalFaceWithID (const std::vector<const SMDS_MeshNode*> & nodes,
 564                                                  const smIdType                                 ID);
 565
 566   virtual SMDS_MeshFace* AddPolygonalFace (const std::vector<const SMDS_MeshNode*> & nodes);
 567
 568   virtual SMDS_MeshFace* AddQuadPolygonalFaceWithID(const std::vector<smIdType> & nodes_ids,
 569                                                     const smIdType                ID);
 570
 571   virtual SMDS_MeshFace* AddQuadPolygonalFaceWithID(const std::vector<const SMDS_MeshNode*> & nodes,
 572                                                     const smIdType                                 ID);
 573
 574   virtual SMDS_MeshFace* AddQuadPolygonalFace(const std::vector<const SMDS_MeshNode*> & nodes);
 575
 576   virtual SMDS_MeshVolume* AddPolyhedralVolumeWithID
 577     (const std::vector<smIdType> & nodes_ids,
 578      const std::vector<int>      & quantities,
 579      const smIdType                ID);
 580
 581   virtual SMDS_MeshVolume* AddPolyhedralVolumeWithID
 582     (const std::vector<const SMDS_MeshNode*> & nodes,
 583      const std::vector<int>                  & quantities,
 584      const smIdType                            ID);
 585
 586   virtual SMDS_MeshVolume* AddPolyhedralVolume
 587     (const std::vector<const SMDS_MeshNode*> & nodes,
 588      const std::vector<int>                  & quantities);
 589
 590   virtual SMDS_MeshVolume* AddVolumeFromVtkIds(const std::vector<vtkIdType>& vtkNodeIds);
 591
 592   virtual SMDS_MeshFace* AddFaceFromVtkIds(const std::vector<vtkIdType>& vtkNodeIds);
 593
 594   virtual void MoveNode(const SMDS_MeshNode *n, double x, double y, double z);
 595
 596   virtual void RemoveElement(const SMDS_MeshElement *               elem,
 597                              std::vector<const SMDS_MeshElement *>& removedElems,
 598                              std::vector<const SMDS_MeshElement *>& removedNodes,
 599                              const bool                             removenodes = false);
 600   virtual void RemoveElement(const SMDS_MeshElement * elem, bool removenodes = false);
 601   virtual void RemoveNode(const SMDS_MeshNode * node);
 602
 603   /*! Remove only the given element and only if it is free.
 604    *  Method does not work for meshes with descendants.
 605    *  Implemented for fast cleaning of meshes.
 606    */
 607   virtual void RemoveFreeElement(const SMDS_MeshElement * elem);
 608
 609   virtual void Clear();
 610
 611   virtual bool RemoveFromParent();
 612   virtual bool RemoveSubMesh(const SMDS_Mesh * aMesh);
 613
 614   bool ChangeElementNodes(const SMDS_MeshElement * elem,
 615                           const SMDS_MeshNode    * nodes[],
 616                           const int                nbnodes);
 617   bool ChangePolyhedronNodes(const SMDS_MeshElement *                 elem,
 618                              const std::vector<const SMDS_MeshNode*>& nodes,
 619                              const std::vector<int>&                  quantities);
 620
 621   //virtual void Renumber (const bool isNodes, const int startID = 1, const int deltaID = 1);
 622   // Renumber all nodes or elements.
 623
 624   virtual void CompactMesh();
 625   virtual bool IsCompacted();
 626   virtual bool HasNumerationHoles();
 627
 628   template<class ELEMTYPE>
 629     static const ELEMTYPE* DownCast( const SMDS_MeshElement* e )
 630   {
 631     return (( e && !e->IsNull() && ELEMTYPE::Type() == e->GetType() ) ?
 632             static_cast<const ELEMTYPE*>(e) : 0 );
 633   }
 634
 635   const SMDS_MeshNode *FindNode(smIdType idnode) const;
 636   const SMDS_MeshNode *FindNodeVtk(vtkIdType idnode) const;
 637   const SMDS_MeshElement *FindElementVtk(vtkIdType IDelem) const;
 638   virtual const SMDS_MeshElement * FindElement(smIdType IDelem) const;
 639   static const SMDS_Mesh0DElement* Find0DElement(const SMDS_MeshNode * n);
 640   static const SMDS_BallElement* FindBall(const SMDS_MeshNode * n);
 641   static const SMDS_MeshEdge* FindEdge(const SMDS_MeshNode * n1,
 642                                        const SMDS_MeshNode * n2);
 643   static const SMDS_MeshEdge* FindEdge(const SMDS_MeshNode * n1,
 644                                        const SMDS_MeshNode * n2,
 645                                        const SMDS_MeshNode * n3);
 646   static const SMDS_MeshFace* FindFace(const SMDS_MeshNode *n1,
 647                                        const SMDS_MeshNode *n2,
 648                                        const SMDS_MeshNode *n3);
 649   static const SMDS_MeshFace* FindFace(const SMDS_MeshNode *n1,
 650                                        const SMDS_MeshNode *n2,
 651                                        const SMDS_MeshNode *n3,
 652                                        const SMDS_MeshNode *n4);
 653   static const SMDS_MeshFace* FindFace(const SMDS_MeshNode *n1,
 654                                        const SMDS_MeshNode *n2,
 655                                        const SMDS_MeshNode *n3,
 656                                        const SMDS_MeshNode *n4,
 657                                        const SMDS_MeshNode *n5,
 658                                        const SMDS_MeshNode *n6);
 659   static const SMDS_MeshFace* FindFace(const SMDS_MeshNode *n1,
 660                                        const SMDS_MeshNode *n2,
 661                                        const SMDS_MeshNode *n3,
 662                                        const SMDS_MeshNode *n4,
 663                                        const SMDS_MeshNode *n5,
 664                                        const SMDS_MeshNode *n6,
 665                                        const SMDS_MeshNode *n7,
 666                                        const SMDS_MeshNode *n8);
 667
 668   static const SMDS_MeshFace*    FindFace   (const std::vector<const SMDS_MeshNode *>& nodes);
 669   static const SMDS_MeshElement* FindElement(const std::vector<const SMDS_MeshNode *>& nodes,
 670                                              const SMDSAbs_ElementType                 type=SMDSAbs_All,
 671                                              const bool                                noMedium=true);
 672   static int GetElementsByNodes(const std::vector<const SMDS_MeshNode *>& nodes,
 673                                 std::vector<const SMDS_MeshElement *>&    foundElems,
 674                                 const SMDSAbs_ElementType                 type=SMDSAbs_All);
 675
 676   virtual bool Contains( const SMDS_MeshElement* elem ) const;
 677
 678   /*!
 679    * \brief Raise an exception if free memory (ram+swap) too low
 680     * \param doNotRaise - if true, suppress exception, just return free memory size
 681     * \retval int - amount of available memory in MB or negative number in failure case
 682    */
 683   static int CheckMemory(const bool doNotRaise=false);
 684
 685   virtual smIdType MaxNodeID() const;
 686   virtual smIdType MinNodeID() const;
 687   virtual smIdType MaxElementID() const;
 688   virtual smIdType MinElementID() const;
 689
 690   const SMDS_MeshInfo& GetMeshInfo() const { return myInfo; }
 691
 692   virtual smIdType NbNodes() const;
 693   virtual smIdType NbElements() const;
 694   virtual smIdType Nb0DElements() const;
 695   virtual smIdType NbBalls() const;
 696   virtual smIdType NbEdges() const;
 697   virtual smIdType NbFaces() const;
 698   virtual smIdType NbVolumes() const;
 699   virtual smIdType NbSubMesh() const;
 700
 701   virtual ~SMDS_Mesh();
 702
 703   double getMaxDim();
 704   smIdType FromVtkToSmds(vtkIdType  vtkid) const;
 705
 706   void dumpGrid(std::string ficdump="dumpGrid");
 707   static int chunkSize;
 708
 709   //! low level modification: add, change or remove node or element
 710   inline void setMyModified() { this->myModified = true; }
 711
 712   void Modified();
 713   vtkMTimeType GetMTime() const;
 714
 715  protected:
 716   SMDS_Mesh(SMDS_Mesh * parent);
 717
 718   void addChildrenWithNodes(std::set<const SMDS_MeshElement*>& setOfChildren,
 719                             const SMDS_MeshElement *           element,
 720                             std::set<const SMDS_MeshElement*>& nodes);
 721
 722   inline void adjustBoundingBox(double x, double y, double z)
 723   {
 724     if (x > xmax) xmax = x;
 725     else if (x < xmin) xmin = x;
 726     if (y > ymax) ymax = y;
 727     else if (y < ymin) ymin = y;
 728     if (z > zmax) zmax = z;
 729     else if (z < zmin) zmin = z;
 730   }
 731
 732   void updateInverseElements( const SMDS_MeshElement *        element,
 733                               const SMDS_MeshNode* const*     nodes,
 734                               const int                       nbnodes,
 735                               std::set<const SMDS_MeshNode*>& oldNodes );
 736
 737   void setNbShapes( size_t nbShapes );
 738
 739
 740   // Fields PRIVATE
 741
 742   //! actual nodes coordinates, cells definition and reverse connectivity are stored in a vtkUnstructuredGrid
 743   SMDS_UnstructuredGrid* myGrid;
 744
 745   //! Small objects like SMDS_MeshNode are allocated by chunks to limit memory costs of new
 746   SMDS_NodeFactory*      myNodeFactory;
 747   SMDS_ElementFactory*   myCellFactory;
 748
 749   SMDS_Mesh *            myParent;
 750   std::list<SMDS_Mesh *> myChildren;
 751   SMDS_MeshInfo          myInfo;
 752
 753   //! any add, remove or change of node or cell
 754   bool                   myModified;
 755   //! use a counter to keep track of modifications
 756   unsigned long          myModifTime, myCompactTime;
 757
 758   friend class SMDS_ElementHolder;
 759   std::set< SMDS_ElementHolder* > myElemHolders;
 760
 761   double xmin;
 762   double xmax;
 763   double ymin;
 764   double ymax;
 765   double zmin;
 766   double zmax;
 767 };
 768
 769
 770 #endif