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_MeshNode.hxx"
  33 #include "SMDS_MeshCell.hxx"
  34 #include "SMDS_Mesh0DElement.hxx"
  35 #include "SMDS_MeshEdge.hxx"
  36 #include "SMDS_MeshFace.hxx"
  37 #include "SMDS_MeshVolume.hxx"
  38 #include "SMDS_MeshNodeIDFactory.hxx"
  39 #include "SMDS_MeshElementIDFactory.hxx"
  40 #include "SMDS_MeshInfo.hxx"
  41 #include "SMDS_ElemIterator.hxx"
  42 #include "SMDS_VolumeOfNodes.hxx"
  43 #include "SMDS_VtkEdge.hxx"
  44 #include "SMDS_VtkFace.hxx"
  45 #include "SMDS_VtkVolume.hxx"
  46 #include "ObjectPool.hxx"
  47 #include "SMDS_UnstructuredGrid.hxx"
  48 #include "SMDS_BallElement.hxx"
  49
  50 #include <boost/shared_ptr.hpp>
  51 #include <set>
  52 #include <list>
  53 #include <vector>
  54 #include <vtkSystemIncludes.h>
  55 #include <cassert>
  56
  57 #include "Utils_SALOME_Exception.hxx"
  58
  59 #define MYASSERT(val) if (!(val)) throw SALOME_Exception(LOCALIZED("assertion not verified"));
  60
  61 class SMDS_EXPORT SMDS_Mesh : public SMDS_MeshObject
  62 {
  63 public:
  64   friend class SMDS_MeshIDFactory;
  65   friend class SMDS_MeshNodeIDFactory;
  66   friend class SMDS_MeshElementIDFactory;
  67   friend class SMDS_MeshVolumeVtkNodes;
  68   friend class SMDS_MeshNode;
  69
  70   SMDS_Mesh();
  71
  72   //! to retrieve this SMDS_Mesh instance from its elements (index stored in SMDS_Elements)
  73   static std::vector<SMDS_Mesh*> _meshList;
  74
  75   //! actual nodes coordinates, cells definition and reverse connectivity are stored in a vtkUnstructuredGrid
  76   inline SMDS_UnstructuredGrid* getGrid() { return myGrid; }
  77   inline int getMeshId() { return myMeshId; }
  78
  79   virtual SMDS_NodeIteratorPtr   nodesIterator     (bool idInceasingOrder=false) const;
  80   virtual SMDS_EdgeIteratorPtr   edgesIterator     (bool idInceasingOrder=false) const;
  81   virtual SMDS_FaceIteratorPtr   facesIterator     (bool idInceasingOrder=false) const;
  82   virtual SMDS_VolumeIteratorPtr volumesIterator   (bool idInceasingOrder=false) const;
  83
  84   virtual SMDS_ElemIteratorPtr elementsIterator(SMDSAbs_ElementType type=SMDSAbs_All) const;
  85   virtual SMDS_ElemIteratorPtr elementGeomIterator(SMDSAbs_GeometryType type) const;
  86   virtual SMDS_ElemIteratorPtr elementEntityIterator(SMDSAbs_EntityType type) const;
  87
  88   SMDSAbs_ElementType GetElementType( const int id, const bool iselem ) const;
  89
  90   SMDS_Mesh *AddSubMesh();
  91
  92   virtual SMDS_MeshNode* AddNodeWithID(double x, double y, double z, int ID);
  93   virtual SMDS_MeshNode* AddNode      (double x, double y, double z);
  94
  95   virtual SMDS_Mesh0DElement* Add0DElementWithID(int n,                   int ID);
  96   virtual SMDS_Mesh0DElement* Add0DElementWithID(const SMDS_MeshNode * n, int ID);
  97   virtual SMDS_Mesh0DElement* Add0DElement      (const SMDS_MeshNode * n);
  98
  99   virtual SMDS_BallElement* AddBallWithID(int n,                   double diameter, int ID);
 100   virtual SMDS_BallElement* AddBallWithID(const SMDS_MeshNode * n, double diameter, int ID);
 101   virtual SMDS_BallElement* AddBall      (const SMDS_MeshNode * n, double diameter);
 102
 103   virtual SMDS_MeshEdge* AddEdgeWithID(int n1, int n2, int ID);
 104   virtual SMDS_MeshEdge* AddEdgeWithID(const SMDS_MeshNode * n1,
 105                                        const SMDS_MeshNode * n2,
 106                                        int ID);
 107   virtual SMDS_MeshEdge* AddEdge(const SMDS_MeshNode * n1,
 108                                  const SMDS_MeshNode * n2);
 109
 110   // 2d order edge with 3 nodes: n12 - node between n1 and n2
 111   virtual SMDS_MeshEdge* AddEdgeWithID(int n1, int n2, int n12, int ID);
 112   virtual SMDS_MeshEdge* AddEdgeWithID(const SMDS_MeshNode * n1,
 113                                        const SMDS_MeshNode * n2,
 114                                        const SMDS_MeshNode * n12,
 115                                        int ID);
 116   virtual SMDS_MeshEdge* AddEdge(const SMDS_MeshNode * n1,
 117                                  const SMDS_MeshNode * n2,
 118                                  const SMDS_MeshNode * n12);
 119
 120   virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3, int ID);
 121   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
 122                                        const SMDS_MeshNode * n2,
 123                                        const SMDS_MeshNode * n3,
 124                                        int ID);
 125   virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
 126                                  const SMDS_MeshNode * n2,
 127                                  const SMDS_MeshNode * n3);
 128
 129   virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3, int n4, int ID);
 130   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
 131                                        const SMDS_MeshNode * n2,
 132                                        const SMDS_MeshNode * n3,
 133                                        const SMDS_MeshNode * n4,
 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 * n4);
 139
 140   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshEdge * e1,
 141                                        const SMDS_MeshEdge * e2,
 142                                        const SMDS_MeshEdge * e3, int ID);
 143   virtual SMDS_MeshFace* AddFace(const SMDS_MeshEdge * e1,
 144                                  const SMDS_MeshEdge * e2,
 145                                  const SMDS_MeshEdge * e3);
 146
 147   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshEdge * e1,
 148                                        const SMDS_MeshEdge * e2,
 149                                        const SMDS_MeshEdge * e3,
 150                                        const SMDS_MeshEdge * e4, int ID);
 151   virtual SMDS_MeshFace* AddFace(const SMDS_MeshEdge * e1,
 152                                  const SMDS_MeshEdge * e2,
 153                                  const SMDS_MeshEdge * e3,
 154                                  const SMDS_MeshEdge * e4);
 155
 156   // 2d order triangle of 6 nodes
 157   virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3,
 158                                        int n12,int n23,int n31, int ID);
 159   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
 160                                        const SMDS_MeshNode * n2,
 161                                        const SMDS_MeshNode * n3,
 162                                        const SMDS_MeshNode * n12,
 163                                        const SMDS_MeshNode * n23,
 164                                        const SMDS_MeshNode * n31,
 165                                        int ID);
 166   virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
 167                                  const SMDS_MeshNode * n2,
 168                                  const SMDS_MeshNode * n3,
 169                                  const SMDS_MeshNode * n12,
 170                                  const SMDS_MeshNode * n23,
 171                                  const SMDS_MeshNode * n31);
 172
 173   // 2d order triangle of 7 nodes
 174   virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3,
 175                                        int n12,int n23,int n31, int nCenter, int ID);
 176   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
 177                                        const SMDS_MeshNode * n2,
 178                                        const SMDS_MeshNode * n3,
 179                                        const SMDS_MeshNode * n12,
 180                                        const SMDS_MeshNode * n23,
 181                                        const SMDS_MeshNode * n31,
 182                                        const SMDS_MeshNode * nCenter,
 183                                        int ID);
 184   virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
 185                                  const SMDS_MeshNode * n2,
 186                                  const SMDS_MeshNode * n3,
 187                                  const SMDS_MeshNode * n12,
 188                                  const SMDS_MeshNode * n23,
 189                                  const SMDS_MeshNode * n31,
 190                                  const SMDS_MeshNode * nCenter);
 191
 192   // 2d order quadrangle
 193   virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3, int n4,
 194                                        int n12,int n23,int n34,int n41, int ID);
 195   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
 196                                        const SMDS_MeshNode * n2,
 197                                        const SMDS_MeshNode * n3,
 198                                        const SMDS_MeshNode * n4,
 199                                        const SMDS_MeshNode * n12,
 200                                        const SMDS_MeshNode * n23,
 201                                        const SMDS_MeshNode * n34,
 202                                        const SMDS_MeshNode * n41,
 203                                        int ID);
 204   virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
 205                                  const SMDS_MeshNode * n2,
 206                                  const SMDS_MeshNode * n3,
 207                                  const SMDS_MeshNode * n4,
 208                                  const SMDS_MeshNode * n12,
 209                                  const SMDS_MeshNode * n23,
 210                                  const SMDS_MeshNode * n34,
 211                                  const SMDS_MeshNode * n41);
 212
 213   virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3, int n4,
 214                                        int n12,int n23,int n34,int n41, int nCenter, int ID);
 215   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
 216                                        const SMDS_MeshNode * n2,
 217                                        const SMDS_MeshNode * n3,
 218                                        const SMDS_MeshNode * n4,
 219                                        const SMDS_MeshNode * n12,
 220                                        const SMDS_MeshNode * n23,
 221                                        const SMDS_MeshNode * n34,
 222                                        const SMDS_MeshNode * n41,
 223                                        const SMDS_MeshNode * nCenter,
 224                                        int ID);
 225   virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
 226                                  const SMDS_MeshNode * n2,
 227                                  const SMDS_MeshNode * n3,
 228                                  const SMDS_MeshNode * n4,
 229                                  const SMDS_MeshNode * n12,
 230                                  const SMDS_MeshNode * n23,
 231                                  const SMDS_MeshNode * n34,
 232                                  const SMDS_MeshNode * n41,
 233                                  const SMDS_MeshNode * nCenter);
 234
 235   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int 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                                            int ID);
 241   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 242                                      const SMDS_MeshNode * n2,
 243                                      const SMDS_MeshNode * n3,
 244                                      const SMDS_MeshNode * n4);
 245
 246   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
 247                                            int n5, int ID);
 248   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 249                                            const SMDS_MeshNode * n2,
 250                                            const SMDS_MeshNode * n3,
 251                                            const SMDS_MeshNode * n4,
 252                                            const SMDS_MeshNode * n5,
 253                                            int ID);
 254   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 255                                      const SMDS_MeshNode * n2,
 256                                      const SMDS_MeshNode * n3,
 257                                      const SMDS_MeshNode * n4,
 258                                      const SMDS_MeshNode * n5);
 259
 260   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
 261                                            int n5, int n6, int ID);
 262   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 263                                            const SMDS_MeshNode * n2,
 264                                            const SMDS_MeshNode * n3,
 265                                            const SMDS_MeshNode * n4,
 266                                            const SMDS_MeshNode * n5,
 267                                            const SMDS_MeshNode * n6,
 268                                            int ID);
 269   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 270                                      const SMDS_MeshNode * n2,
 271                                      const SMDS_MeshNode * n3,
 272                                      const SMDS_MeshNode * n4,
 273                                      const SMDS_MeshNode * n5,
 274                                      const SMDS_MeshNode * n6);
 275
 276   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
 277                                            int n5, int n6, int n7, int n8, int ID);
 278   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 279                                            const SMDS_MeshNode * n2,
 280                                            const SMDS_MeshNode * n3,
 281                                            const SMDS_MeshNode * n4,
 282                                            const SMDS_MeshNode * n5,
 283                                            const SMDS_MeshNode * n6,
 284                                            const SMDS_MeshNode * n7,
 285                                            const SMDS_MeshNode * n8,
 286                                            int ID);
 287   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 288                                      const SMDS_MeshNode * n2,
 289                                      const SMDS_MeshNode * n3,
 290                                      const SMDS_MeshNode * n4,
 291                                      const SMDS_MeshNode * n5,
 292                                      const SMDS_MeshNode * n6,
 293                                      const SMDS_MeshNode * n7,
 294                                      const SMDS_MeshNode * n8);
 295
 296   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshFace * f1,
 297                                            const SMDS_MeshFace * f2,
 298                                            const SMDS_MeshFace * f3,
 299                                            const SMDS_MeshFace * f4, int ID);
 300   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshFace * f1,
 301                                      const SMDS_MeshFace * f2,
 302                                      const SMDS_MeshFace * f3,
 303                                      const SMDS_MeshFace * f4);
 304
 305   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshFace * f1,
 306                                            const SMDS_MeshFace * f2,
 307                                            const SMDS_MeshFace * f3,
 308                                            const SMDS_MeshFace * f4,
 309                                            const SMDS_MeshFace * f5, int ID);
 310   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshFace * f1,
 311                                      const SMDS_MeshFace * f2,
 312                                      const SMDS_MeshFace * f3,
 313                                      const SMDS_MeshFace * f4,
 314                                      const SMDS_MeshFace * f5);
 315
 316   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshFace * f1,
 317                                            const SMDS_MeshFace * f2,
 318                                            const SMDS_MeshFace * f3,
 319                                            const SMDS_MeshFace * f4,
 320                                            const SMDS_MeshFace * f5,
 321                                            const SMDS_MeshFace * f6, int ID);
 322   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshFace * f1,
 323                                      const SMDS_MeshFace * f2,
 324                                      const SMDS_MeshFace * f3,
 325                                      const SMDS_MeshFace * f4,
 326                                      const SMDS_MeshFace * f5,
 327                                      const SMDS_MeshFace * f6);
 328
 329   // hexagonal prism
 330   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, int n6,
 331                                            int n7, int n8, int n9, int n10, int n11, int n12,
 332                                            int ID);
 333   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 334                                            const SMDS_MeshNode * n2,
 335                                            const SMDS_MeshNode * n3,
 336                                            const SMDS_MeshNode * n4,
 337                                            const SMDS_MeshNode * n5,
 338                                            const SMDS_MeshNode * n6,
 339                                            const SMDS_MeshNode * n7,
 340                                            const SMDS_MeshNode * n8,
 341                                            const SMDS_MeshNode * n9,
 342                                            const SMDS_MeshNode * n10,
 343                                            const SMDS_MeshNode * n11,
 344                                            const SMDS_MeshNode * n12,
 345                                            int 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 * n6,
 352                                      const SMDS_MeshNode * n7,
 353                                      const SMDS_MeshNode * n8,
 354                                      const SMDS_MeshNode * n9,
 355                                      const SMDS_MeshNode * n10,
 356                                      const SMDS_MeshNode * n11,
 357                                      const SMDS_MeshNode * n12);
 358
 359   // 2d order tetrahedron of 10 nodes
 360   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
 361                                            int n12,int n23,int n31,
 362                                            int n14,int n24,int n34, int ID);
 363   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 364                                            const SMDS_MeshNode * n2,
 365                                            const SMDS_MeshNode * n3,
 366                                            const SMDS_MeshNode * n4,
 367                                            const SMDS_MeshNode * n12,
 368                                            const SMDS_MeshNode * n23,
 369                                            const SMDS_MeshNode * n31,
 370                                            const SMDS_MeshNode * n14,
 371                                            const SMDS_MeshNode * n24,
 372                                            const SMDS_MeshNode * n34,
 373                                            int ID);
 374   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 375                                      const SMDS_MeshNode * n2,
 376                                      const SMDS_MeshNode * n3,
 377                                      const SMDS_MeshNode * n4,
 378                                      const SMDS_MeshNode * n12,
 379                                      const SMDS_MeshNode * n23,
 380                                      const SMDS_MeshNode * n31,
 381                                      const SMDS_MeshNode * n14,
 382                                      const SMDS_MeshNode * n24,
 383                                      const SMDS_MeshNode * n34);
 384
 385   // 2d order pyramid of 13 nodes
 386   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int n5,
 387                                            int n12,int n23,int n34,int n41,
 388                                            int n15,int n25,int n35,int n45,
 389                                            int ID);
 390   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 391                                            const SMDS_MeshNode * n2,
 392                                            const SMDS_MeshNode * n3,
 393                                            const SMDS_MeshNode * n4,
 394                                            const SMDS_MeshNode * n5,
 395                                            const SMDS_MeshNode * n12,
 396                                            const SMDS_MeshNode * n23,
 397                                            const SMDS_MeshNode * n34,
 398                                            const SMDS_MeshNode * n41,
 399                                            const SMDS_MeshNode * n15,
 400                                            const SMDS_MeshNode * n25,
 401                                            const SMDS_MeshNode * n35,
 402                                            const SMDS_MeshNode * n45,
 403                                            int ID);
 404   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 405                                      const SMDS_MeshNode * n2,
 406                                      const SMDS_MeshNode * n3,
 407                                      const SMDS_MeshNode * n4,
 408                                      const SMDS_MeshNode * n5,
 409                                      const SMDS_MeshNode * n12,
 410                                      const SMDS_MeshNode * n23,
 411                                      const SMDS_MeshNode * n34,
 412                                      const SMDS_MeshNode * n41,
 413                                      const SMDS_MeshNode * n15,
 414                                      const SMDS_MeshNode * n25,
 415                                      const SMDS_MeshNode * n35,
 416                                      const SMDS_MeshNode * n45);
 417
 418   // 2d order Pentahedron with 15 nodes
 419   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3,
 420                                            int n4, int n5, int n6,
 421                                            int n12,int n23,int n31,
 422                                            int n45,int n56,int n64,
 423                                            int n14,int n25,int n36,
 424                                            int ID);
 425   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 426                                            const SMDS_MeshNode * n2,
 427                                            const SMDS_MeshNode * n3,
 428                                            const SMDS_MeshNode * n4,
 429                                            const SMDS_MeshNode * n5,
 430                                            const SMDS_MeshNode * n6,
 431                                            const SMDS_MeshNode * n12,
 432                                            const SMDS_MeshNode * n23,
 433                                            const SMDS_MeshNode * n31,
 434                                            const SMDS_MeshNode * n45,
 435                                            const SMDS_MeshNode * n56,
 436                                            const SMDS_MeshNode * n64,
 437                                            const SMDS_MeshNode * n14,
 438                                            const SMDS_MeshNode * n25,
 439                                            const SMDS_MeshNode * n36,
 440                                            int ID);
 441   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 442                                      const SMDS_MeshNode * n2,
 443                                      const SMDS_MeshNode * n3,
 444                                      const SMDS_MeshNode * n4,
 445                                      const SMDS_MeshNode * n5,
 446                                      const SMDS_MeshNode * n6,
 447                                      const SMDS_MeshNode * n12,
 448                                      const SMDS_MeshNode * n23,
 449                                      const SMDS_MeshNode * n31,
 450                                      const SMDS_MeshNode * n45,
 451                                      const SMDS_MeshNode * n56,
 452                                      const SMDS_MeshNode * n64,
 453                                      const SMDS_MeshNode * n14,
 454                                      const SMDS_MeshNode * n25,
 455                                      const SMDS_MeshNode * n36);
 456
 457   // 2d order Pentahedron with 18 nodes
 458   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3,
 459                                            int n4, int n5, int n6,
 460                                            int n12,int n23,int n31,
 461                                            int n45,int n56,int n64,
 462                                            int n14,int n25,int n36,
 463                                            int n1245, int n2356, int n1346,
 464                                            int ID);
 465   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 466                                            const SMDS_MeshNode * n2,
 467                                            const SMDS_MeshNode * n3,
 468                                            const SMDS_MeshNode * n4,
 469                                            const SMDS_MeshNode * n5,
 470                                            const SMDS_MeshNode * n6,
 471                                            const SMDS_MeshNode * n12,
 472                                            const SMDS_MeshNode * n23,
 473                                            const SMDS_MeshNode * n31,
 474                                            const SMDS_MeshNode * n45,
 475                                            const SMDS_MeshNode * n56,
 476                                            const SMDS_MeshNode * n64,
 477                                            const SMDS_MeshNode * n14,
 478                                            const SMDS_MeshNode * n25,
 479                                            const SMDS_MeshNode * n36,
 480                                            const SMDS_MeshNode * n1245,
 481                                            const SMDS_MeshNode * n2356,
 482                                            const SMDS_MeshNode * n1346,
 483                                            int ID);
 484   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 485                                      const SMDS_MeshNode * n2,
 486                                      const SMDS_MeshNode * n3,
 487                                      const SMDS_MeshNode * n4,
 488                                      const SMDS_MeshNode * n5,
 489                                      const SMDS_MeshNode * n6,
 490                                      const SMDS_MeshNode * n12,
 491                                      const SMDS_MeshNode * n23,
 492                                      const SMDS_MeshNode * n31,
 493                                      const SMDS_MeshNode * n45,
 494                                      const SMDS_MeshNode * n56,
 495                                      const SMDS_MeshNode * n64,
 496                                      const SMDS_MeshNode * n14,
 497                                      const SMDS_MeshNode * n25,
 498                                      const SMDS_MeshNode * n36,
 499                                      const SMDS_MeshNode * n1245,
 500                                      const SMDS_MeshNode * n2356,
 501                                      const SMDS_MeshNode * n1346);
 502
 503
 504   // 2d oreder Hexahedrons with 20 nodes
 505   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
 506                                            int n5, int n6, int n7, int n8,
 507                                            int n12,int n23,int n34,int n41,
 508                                            int n56,int n67,int n78,int n85,
 509                                            int n15,int n26,int n37,int n48,
 510                                            int ID);
 511   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 512                                            const SMDS_MeshNode * n2,
 513                                            const SMDS_MeshNode * n3,
 514                                            const SMDS_MeshNode * n4,
 515                                            const SMDS_MeshNode * n5,
 516                                            const SMDS_MeshNode * n6,
 517                                            const SMDS_MeshNode * n7,
 518                                            const SMDS_MeshNode * n8,
 519                                            const SMDS_MeshNode * n12,
 520                                            const SMDS_MeshNode * n23,
 521                                            const SMDS_MeshNode * n34,
 522                                            const SMDS_MeshNode * n41,
 523                                            const SMDS_MeshNode * n56,
 524                                            const SMDS_MeshNode * n67,
 525                                            const SMDS_MeshNode * n78,
 526                                            const SMDS_MeshNode * n85,
 527                                            const SMDS_MeshNode * n15,
 528                                            const SMDS_MeshNode * n26,
 529                                            const SMDS_MeshNode * n37,
 530                                            const SMDS_MeshNode * n48,
 531                                            int 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
 553   // 2d oreder Hexahedrons with 27 nodes
 554   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
 555                                            int n5, int n6, int n7, int n8,
 556                                            int n12,int n23,int n34,int n41,
 557                                            int n56,int n67,int n78,int n85,
 558                                            int n15,int n26,int n37,int n48,
 559                                            int n1234,int n1256,int n2367,int n3478,
 560                                            int n1458,int n5678,int nCenter,
 561                                            int ID);
 562   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 563                                            const SMDS_MeshNode * n2,
 564                                            const SMDS_MeshNode * n3,
 565                                            const SMDS_MeshNode * n4,
 566                                            const SMDS_MeshNode * n5,
 567                                            const SMDS_MeshNode * n6,
 568                                            const SMDS_MeshNode * n7,
 569                                            const SMDS_MeshNode * n8,
 570                                            const SMDS_MeshNode * n12,
 571                                            const SMDS_MeshNode * n23,
 572                                            const SMDS_MeshNode * n34,
 573                                            const SMDS_MeshNode * n41,
 574                                            const SMDS_MeshNode * n56,
 575                                            const SMDS_MeshNode * n67,
 576                                            const SMDS_MeshNode * n78,
 577                                            const SMDS_MeshNode * n85,
 578                                            const SMDS_MeshNode * n15,
 579                                            const SMDS_MeshNode * n26,
 580                                            const SMDS_MeshNode * n37,
 581                                            const SMDS_MeshNode * n48,
 582                                            const SMDS_MeshNode * n1234,
 583                                            const SMDS_MeshNode * n1256,
 584                                            const SMDS_MeshNode * n2367,
 585                                            const SMDS_MeshNode * n3478,
 586                                            const SMDS_MeshNode * n1458,
 587                                            const SMDS_MeshNode * n5678,
 588                                            const SMDS_MeshNode * nCenter,
 589                                            int ID);
 590   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 591                                      const SMDS_MeshNode * n2,
 592                                      const SMDS_MeshNode * n3,
 593                                      const SMDS_MeshNode * n4,
 594                                      const SMDS_MeshNode * n5,
 595                                      const SMDS_MeshNode * n6,
 596                                      const SMDS_MeshNode * n7,
 597                                      const SMDS_MeshNode * n8,
 598                                      const SMDS_MeshNode * n12,
 599                                      const SMDS_MeshNode * n23,
 600                                      const SMDS_MeshNode * n34,
 601                                      const SMDS_MeshNode * n41,
 602                                      const SMDS_MeshNode * n56,
 603                                      const SMDS_MeshNode * n67,
 604                                      const SMDS_MeshNode * n78,
 605                                      const SMDS_MeshNode * n85,
 606                                      const SMDS_MeshNode * n15,
 607                                      const SMDS_MeshNode * n26,
 608                                      const SMDS_MeshNode * n37,
 609                                      const SMDS_MeshNode * n48,
 610                                      const SMDS_MeshNode * n1234,
 611                                      const SMDS_MeshNode * n1256,
 612                                      const SMDS_MeshNode * n2367,
 613                                      const SMDS_MeshNode * n3478,
 614                                      const SMDS_MeshNode * n1458,
 615                                      const SMDS_MeshNode * n5678,
 616                                      const SMDS_MeshNode * nCenter);
 617
 618   virtual SMDS_MeshFace* AddPolygonalFaceWithID (const std::vector<int> & nodes_ids,
 619                                                  const int                ID);
 620
 621   virtual SMDS_MeshFace* AddPolygonalFaceWithID (const std::vector<const SMDS_MeshNode*> & nodes,
 622                                                  const int                                 ID);
 623
 624   virtual SMDS_MeshFace* AddPolygonalFace (const std::vector<const SMDS_MeshNode*> & nodes);
 625
 626   virtual SMDS_MeshFace* AddQuadPolygonalFaceWithID(const std::vector<int> & nodes_ids,
 627                                                     const int                ID);
 628
 629   virtual SMDS_MeshFace* AddQuadPolygonalFaceWithID(const std::vector<const SMDS_MeshNode*> & nodes,
 630                                                     const int                                 ID);
 631
 632   virtual SMDS_MeshFace* AddQuadPolygonalFace(const std::vector<const SMDS_MeshNode*> & nodes);
 633
 634   virtual SMDS_MeshVolume* AddPolyhedralVolumeWithID
 635     (const std::vector<int> & nodes_ids,
 636      const std::vector<int> & quantities,
 637      const int                ID);
 638
 639   virtual SMDS_MeshVolume* AddPolyhedralVolumeWithID
 640     (const std::vector<const SMDS_MeshNode*> & nodes,
 641      const std::vector<int>                  & quantities,
 642                             const int                                 ID);
 643
 644   virtual SMDS_MeshVolume* AddPolyhedralVolume
 645                            (const std::vector<const SMDS_MeshNode*> & nodes,
 646                             const std::vector<int>                  & quantities);
 647
 648   virtual SMDS_MeshVolume* AddVolumeFromVtkIds(const std::vector<vtkIdType>& vtkNodeIds);
 649
 650   virtual SMDS_MeshVolume* AddVolumeFromVtkIdsWithID(const std::vector<vtkIdType>& vtkNodeIds,
 651                                                      const int ID);
 652
 653   virtual SMDS_MeshFace* AddFaceFromVtkIds(const std::vector<vtkIdType>& vtkNodeIds);
 654
 655   virtual SMDS_MeshFace* AddFaceFromVtkIdsWithID(const std::vector<vtkIdType>& vtkNodeIds,
 656                                                      const int ID);
 657   virtual void MoveNode(const SMDS_MeshNode *n, double x, double y, double z);
 658
 659   virtual void RemoveElement(const SMDS_MeshElement *        elem,
 660                              std::list<const SMDS_MeshElement *>& removedElems,
 661                              std::list<const SMDS_MeshElement *>& removedNodes,
 662                              const bool                      removenodes = false);
 663   virtual void RemoveElement(const SMDS_MeshElement * elem, bool removenodes = false);
 664   virtual void RemoveNode(const SMDS_MeshNode * node);
 665   virtual void Remove0DElement(const SMDS_Mesh0DElement * elem0d);
 666   virtual void RemoveEdge(const SMDS_MeshEdge * edge);
 667   virtual void RemoveFace(const SMDS_MeshFace * face);
 668   virtual void RemoveVolume(const SMDS_MeshVolume * volume);
 669
 670   /*! Remove only the given element and only if it is free.
 671    *  Method does not work for meshes with descendants.
 672    *  Implemented for fast cleaning of meshes.
 673    */
 674   virtual void RemoveFreeElement(const SMDS_MeshElement * elem);
 675
 676   virtual void Clear();
 677
 678   virtual bool RemoveFromParent();
 679   virtual bool RemoveSubMesh(const SMDS_Mesh * aMesh);
 680
 681   bool ChangeElementNodes(const SMDS_MeshElement * elem,
 682                           const SMDS_MeshNode    * nodes[],
 683                           const int                nbnodes);
 684   bool ChangePolyhedronNodes(const SMDS_MeshElement *                 elem,
 685                              const std::vector<const SMDS_MeshNode*>& nodes,
 686                              const std::vector<int> &                 quantities);
 687
 688   virtual void Renumber (const bool isNodes, const int startID = 1, const int deltaID = 1);
 689   // Renumber all nodes or elements.
 690   virtual void compactMesh();
 691
 692   const SMDS_MeshNode *FindNode(int idnode) const;
 693   const SMDS_MeshNode *FindNodeVtk(int idnode) const;
 694   const SMDS_Mesh0DElement* Find0DElement(int idnode) const;
 695   const SMDS_BallElement* FindBall(int idnode) const;
 696   const SMDS_MeshEdge *FindEdge(int idnode1, int idnode2) const;
 697   const SMDS_MeshEdge *FindEdge(int idnode1, int idnode2, int idnode3) const;
 698   const SMDS_MeshFace *FindFace(int idnode1, int idnode2, int idnode3) const;
 699   const SMDS_MeshFace *FindFace(int idnode1, int idnode2, int idnode3, int idnode4) const;
 700   const SMDS_MeshFace *FindFace(int idnode1, int idnode2, int idnode3,
 701                                 int idnode4, int idnode5, int idnode6) const;
 702   const SMDS_MeshFace *FindFace(int idnode1, int idnode2, int idnode3, int idnode4,
 703                                 int idnode5, int idnode6, int idnode7, int idnode8) const;
 704   virtual const SMDS_MeshElement * FindElement(int IDelem) const;
 705   static const SMDS_Mesh0DElement* Find0DElement(const SMDS_MeshNode * n);
 706   static const SMDS_BallElement* FindBall(const SMDS_MeshNode * n);
 707   static const SMDS_MeshEdge* FindEdge(const SMDS_MeshNode * n1,
 708                                        const SMDS_MeshNode * n2);
 709   static const SMDS_MeshEdge* FindEdge(const SMDS_MeshNode * n1,
 710                                        const SMDS_MeshNode * n2,
 711                                        const SMDS_MeshNode * n3);
 712   static const SMDS_MeshFace* FindFace(const SMDS_MeshNode *n1,
 713                                        const SMDS_MeshNode *n2,
 714                                        const SMDS_MeshNode *n3);
 715   static const SMDS_MeshFace* FindFace(const SMDS_MeshNode *n1,
 716                                        const SMDS_MeshNode *n2,
 717                                        const SMDS_MeshNode *n3,
 718                                        const SMDS_MeshNode *n4);
 719   static const SMDS_MeshFace* FindFace(const SMDS_MeshNode *n1,
 720                                        const SMDS_MeshNode *n2,
 721                                        const SMDS_MeshNode *n3,
 722                                        const SMDS_MeshNode *n4,
 723                                        const SMDS_MeshNode *n5,
 724                                        const SMDS_MeshNode *n6);
 725   static const SMDS_MeshFace* FindFace(const SMDS_MeshNode *n1,
 726                                        const SMDS_MeshNode *n2,
 727                                        const SMDS_MeshNode *n3,
 728                                        const SMDS_MeshNode *n4,
 729                                        const SMDS_MeshNode *n5,
 730                                        const SMDS_MeshNode *n6,
 731                                        const SMDS_MeshNode *n7,
 732                                        const SMDS_MeshNode *n8);
 733
 734   const SMDS_MeshFace *FindFace(const std::vector<int>& nodes_ids) const;
 735   static const SMDS_MeshFace* FindFace(const std::vector<const SMDS_MeshNode *>& nodes);
 736   static const SMDS_MeshElement* FindElement(const std::vector<const SMDS_MeshNode *>& nodes,
 737                                              const SMDSAbs_ElementType                 type=SMDSAbs_All,
 738                                              const bool                                noMedium=true);
 739   static int GetElementsByNodes(const std::vector<const SMDS_MeshNode *>& nodes,
 740                                 std::vector<const SMDS_MeshElement *>&    foundElems,
 741                                 const SMDSAbs_ElementType                 type=SMDSAbs_All);
 742
 743   /*!
 744    * \brief Raise an exception if free memory (ram+swap) too low
 745     * \param doNotRaise - if true, suppres exception, just return free memory size
 746     * \retval int - amount of available memory in MB or negative number in failure case
 747    */
 748   static int CheckMemory(const bool doNotRaise=false) throw (std::bad_alloc);
 749
 750   int MaxNodeID() const;
 751   int MinNodeID() const;
 752   int MaxElementID() const;
 753   int MinElementID() const;
 754
 755   const SMDS_MeshInfo& GetMeshInfo() const { return myInfo; }
 756
 757   virtual int NbNodes() const;
 758   virtual int NbElements() const;
 759   virtual int Nb0DElements() const;
 760   virtual int NbBalls() const;
 761   virtual int NbEdges() const;
 762   virtual int NbFaces() const;
 763   virtual int NbVolumes() const;
 764   virtual int NbSubMesh() const;
 765
 766   void DumpNodes() const;
 767   void Dump0DElements() const;
 768   void DumpEdges() const;
 769   void DumpFaces() const;
 770   void DumpVolumes() const;
 771   void DebugStats() const;
 772
 773   virtual ~SMDS_Mesh();
 774
 775   bool hasConstructionEdges();
 776   bool hasConstructionFaces();
 777   bool hasInverseElements();
 778   void setConstructionEdges(bool);
 779   void setConstructionFaces(bool);
 780   void setInverseElements(bool);
 781
 782   /*!
 783    * Checks if the element is present in mesh.
 784    * Useful to determine dead pointers.
 785    * Use this function for debug purpose only! Do not check in the code
 786    * using it even in _DEBUG_ mode
 787    */
 788   bool Contains (const SMDS_MeshElement* elem) const;
 789
 790   typedef std::vector<SMDS_MeshNode *> SetOfNodes;
 791   typedef std::vector<SMDS_MeshCell *> SetOfCells;
 792
 793   //void updateBoundingBox();
 794   double getMaxDim();
 795   int fromVtkToSmds(int vtkid);
 796
 797   void dumpGrid(std::string ficdump="dumpGrid");
 798   static int chunkSize;
 799
 800   //! low level modification: add, change or remove node or element
 801   inline void setMyModified() { this->myModified = true; }
 802
 803   void Modified();
 804   vtkMTimeType GetMTime() const;
 805   bool isCompacted();
 806
 807 protected:
 808   SMDS_Mesh(SMDS_Mesh * parent);
 809
 810   SMDS_MeshFace * createTriangle(const SMDS_MeshNode * node1,
 811                                  const SMDS_MeshNode * node2,
 812                                  const SMDS_MeshNode * node3,
 813                                  int ID);
 814   SMDS_MeshFace * createQuadrangle(const SMDS_MeshNode * node1,
 815                                    const SMDS_MeshNode * node2,
 816                                    const SMDS_MeshNode * node3,
 817                                    const SMDS_MeshNode * node4,
 818                                    int ID);
 819   SMDS_MeshEdge* FindEdgeOrCreate(const SMDS_MeshNode * n1,
 820                                   const SMDS_MeshNode * n2);
 821   SMDS_MeshFace* FindFaceOrCreate(const SMDS_MeshNode *n1,
 822                                   const SMDS_MeshNode *n2,
 823                                   const SMDS_MeshNode *n3);
 824   SMDS_MeshFace* FindFaceOrCreate(const SMDS_MeshNode *n1,
 825                                   const SMDS_MeshNode *n2,
 826                                   const SMDS_MeshNode *n3,
 827                                   const SMDS_MeshNode *n4);
 828
 829   bool registerElement(int ID, SMDS_MeshElement * element);
 830
 831   void addChildrenWithNodes(std::set<const SMDS_MeshElement*>& setOfChildren,
 832                             const SMDS_MeshElement *           element,
 833                             std::set<const SMDS_MeshElement*>& nodes);
 834
 835   inline void adjustmyCellsCapacity(int ID)
 836   {
 837     assert(ID >= 0);
 838     myElementIDFactory->adjustMaxId(ID);
 839     if (ID >= (int)myCells.size())
 840       myCells.resize(ID+SMDS_Mesh::chunkSize,0);
 841   }
 842
 843   inline void adjustBoundingBox(double x, double y, double z)
 844   {
 845     if (x > xmax) xmax = x;
 846     else if (x < xmin) xmin = x;
 847     if (y > ymax) ymax = y;
 848     else if (y < ymin) ymin = y;
 849     if (z > zmax) zmax = z;
 850     else if (z < zmin) zmin = z;
 851   }
 852
 853   // Fields PRIVATE
 854
 855   //! index of this SMDS_mesh in the static vector<SMDS_Mesh*> _meshList
 856   int myMeshId;
 857
 858   //! actual nodes coordinates, cells definition and reverse connectivity are stored in a vtkUnstructuredGrid
 859   SMDS_UnstructuredGrid*        myGrid;
 860
 861   //! Small objects like SMDS_MeshNode are allocated by chunks to limit memory costs of new
 862   ObjectPool<SMDS_MeshNode>*    myNodePool;
 863
 864   //! Small objects like SMDS_VtkVolume are allocated by chunks to limit memory costs of new
 865   ObjectPool<SMDS_VtkVolume>*   myVolumePool;
 866   ObjectPool<SMDS_VtkFace>*     myFacePool;
 867   ObjectPool<SMDS_VtkEdge>*     myEdgePool;
 868   ObjectPool<SMDS_BallElement>* myBallPool;
 869
 870   //! SMDS_MeshNodes refer to vtk nodes (vtk id != index in myNodes),store reference to this mesh, and sub-shape
 871   SetOfNodes                    myNodes;
 872   SetOfCells                    myCells;
 873
 874   //! a buffer to speed up elements addition by excluding some memory allocation
 875   std::vector<vtkIdType>        myNodeIds;
 876
 877   //! for cells only: index = ID in vtkUnstructuredGrid, value = ID for SMDS users
 878   std::vector<int>              myCellIdVtkToSmds;
 879
 880   SMDS_Mesh *                   myParent;
 881   std::list<SMDS_Mesh *>        myChildren;
 882   SMDS_MeshNodeIDFactory *      myNodeIDFactory;
 883   SMDS_MeshElementIDFactory *   myElementIDFactory;
 884   SMDS_MeshInfo                 myInfo;
 885
 886   //! any add, remove or change of node or cell
 887   bool myModified;
 888   //! use a counter to keep track of modifications
 889   unsigned long myModifTime, myCompactTime;
 890
 891   bool myHasConstructionEdges;
 892   bool myHasConstructionFaces;
 893   bool myHasInverseElements;
 894
 895   double xmin;
 896   double xmax;
 897   double ymin;
 898   double ymax;
 899   double zmin;
 900   double zmax;
 901 };
 902
 903
 904 #endif