src/SMDS/SMDS_Mesh.hxx

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