src/SMDS/SMDS_Mesh.hxx

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