src/SMDS/SMDS_Mesh.hxx

   1 // Copyright (C) 2007-2011  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 void RemoveElement(const SMDS_MeshElement *        elem,
 572                              std::list<const SMDS_MeshElement *>& removedElems,
 573                              std::list<const SMDS_MeshElement *>& removedNodes,
 574                              const bool                      removenodes = false);
 575   virtual void RemoveElement(const SMDS_MeshElement * elem, bool removenodes = false);
 576   virtual void RemoveNode(const SMDS_MeshNode * node);
 577   virtual void Remove0DElement(const SMDS_Mesh0DElement * elem0d);
 578   virtual void RemoveEdge(const SMDS_MeshEdge * edge);
 579   virtual void RemoveFace(const SMDS_MeshFace * face);
 580   virtual void RemoveVolume(const SMDS_MeshVolume * volume);
 581
 582   /*! Remove only the given element and only if it is free.
 583    *  Method does not work for meshes with descendants.
 584    *  Implemented for fast cleaning of meshes.
 585    */
 586   virtual void RemoveFreeElement(const SMDS_MeshElement * elem);
 587
 588   virtual void Clear();
 589
 590   virtual bool RemoveFromParent();
 591   virtual bool RemoveSubMesh(const SMDS_Mesh * aMesh);
 592
 593   bool ChangeElementNodes(const SMDS_MeshElement * elem,
 594                           const SMDS_MeshNode    * nodes[],
 595                           const int                nbnodes);
 596   bool ChangePolyhedronNodes(const SMDS_MeshElement *                 elem,
 597                              const std::vector<const SMDS_MeshNode*>& nodes,
 598                              const std::vector<int> &                 quantities);
 599
 600   virtual void Renumber (const bool isNodes, const int startID = 1, const int deltaID = 1);
 601   // Renumber all nodes or elements.
 602   virtual void compactMesh();
 603
 604   const SMDS_MeshNode *FindNode(int idnode) const;
 605   const SMDS_MeshNode *FindNodeVtk(int idnode) const;
 606   const SMDS_Mesh0DElement* Find0DElement(int idnode) const;
 607   const SMDS_MeshEdge *FindEdge(int idnode1, int idnode2) const;
 608   const SMDS_MeshEdge *FindEdge(int idnode1, int idnode2, int idnode3) const;
 609   const SMDS_MeshFace *FindFace(int idnode1, int idnode2, int idnode3) const;
 610   const SMDS_MeshFace *FindFace(int idnode1, int idnode2, int idnode3, int idnode4) const;
 611   const SMDS_MeshFace *FindFace(int idnode1, int idnode2, int idnode3,
 612                                 int idnode4, int idnode5, int idnode6) const;
 613   const SMDS_MeshFace *FindFace(int idnode1, int idnode2, int idnode3, int idnode4,
 614                                 int idnode5, int idnode6, int idnode7, int idnode8) const;
 615   const SMDS_MeshElement *FindElement(int IDelem) const;
 616   static const SMDS_Mesh0DElement* Find0DElement(const SMDS_MeshNode * n);
 617   static const SMDS_MeshEdge* FindEdge(const SMDS_MeshNode * n1,
 618                                        const SMDS_MeshNode * n2);
 619   static const SMDS_MeshEdge* FindEdge(const SMDS_MeshNode * n1,
 620                                        const SMDS_MeshNode * n2,
 621                                        const SMDS_MeshNode * n3);
 622   static const SMDS_MeshFace* FindFace(const SMDS_MeshNode *n1,
 623                                        const SMDS_MeshNode *n2,
 624                                        const SMDS_MeshNode *n3);
 625   static const SMDS_MeshFace* FindFace(const SMDS_MeshNode *n1,
 626                                        const SMDS_MeshNode *n2,
 627                                        const SMDS_MeshNode *n3,
 628                                        const SMDS_MeshNode *n4);
 629   static const SMDS_MeshFace* FindFace(const SMDS_MeshNode *n1,
 630                                        const SMDS_MeshNode *n2,
 631                                        const SMDS_MeshNode *n3,
 632                                        const SMDS_MeshNode *n4,
 633                                        const SMDS_MeshNode *n5,
 634                                        const SMDS_MeshNode *n6);
 635   static const SMDS_MeshFace* FindFace(const SMDS_MeshNode *n1,
 636                                        const SMDS_MeshNode *n2,
 637                                        const SMDS_MeshNode *n3,
 638                                        const SMDS_MeshNode *n4,
 639                                        const SMDS_MeshNode *n5,
 640                                        const SMDS_MeshNode *n6,
 641                                        const SMDS_MeshNode *n7,
 642                                        const SMDS_MeshNode *n8);
 643
 644   const SMDS_MeshFace *FindFace(const std::vector<int>& nodes_ids) const;
 645   static const SMDS_MeshFace* FindFace(const std::vector<const SMDS_MeshNode *>& nodes);
 646   static const SMDS_MeshElement* FindElement(const std::vector<const SMDS_MeshNode *>& nodes,
 647                                              const SMDSAbs_ElementType                 type=SMDSAbs_All,
 648                                              const bool                                noMedium=true);
 649
 650   /*!
 651    * \brief Raise an exception if free memory (ram+swap) too low
 652     * \param doNotRaise - if true, suppres exception, just return free memory size
 653     * \retval int - amount of available memory in MB or negative number in failure case
 654    */
 655   static int CheckMemory(const bool doNotRaise=false) throw (std::bad_alloc);
 656
 657   int MaxNodeID() const;
 658   int MinNodeID() const;
 659   int MaxElementID() const;
 660   int MinElementID() const;
 661
 662   const SMDS_MeshInfo& GetMeshInfo() const { return myInfo; }
 663
 664   virtual int NbNodes() const;
 665   virtual int Nb0DElements() const;
 666   virtual int NbEdges() const;
 667   virtual int NbFaces() const;
 668   virtual int NbVolumes() const;
 669   virtual int NbSubMesh() const;
 670
 671   void DumpNodes() const;
 672   void Dump0DElements() const;
 673   void DumpEdges() const;
 674   void DumpFaces() const;
 675   void DumpVolumes() const;
 676   void DebugStats() const;
 677
 678   virtual ~SMDS_Mesh();
 679
 680   bool hasConstructionEdges();
 681   bool hasConstructionFaces();
 682   bool hasInverseElements();
 683   void setConstructionEdges(bool);
 684   void setConstructionFaces(bool);
 685   void setInverseElements(bool);
 686
 687   /*!
 688    * Checks if the element is present in mesh.
 689    * Useful to determine dead pointers.
 690    * Use this function for debug purpose only! Do not check in the code
 691    * using it even in _DEBUG_ mode
 692    */
 693   bool Contains (const SMDS_MeshElement* elem) const;
 694
 695   typedef std::vector<SMDS_MeshNode *> SetOfNodes;
 696   typedef std::vector<SMDS_MeshCell *> SetOfCells;
 697
 698   void updateNodeMinMax();
 699   void updateBoundingBox();
 700   double getMaxDim();
 701   int fromVtkToSmds(int vtkid);
 702
 703   void incrementNodesCapacity(int nbNodes);
 704   void incrementCellsCapacity(int nbCells);
 705   void adjustStructure();
 706   void dumpGrid(string ficdump="dumpGrid");
 707   static int chunkSize;
 708
 709   //! low level modification: add, change or remove node or element
 710   inline void setMyModified() { this->myModified = true; }
 711
 712   void Modified();
 713   unsigned long GetMTime() const;
 714   bool isCompacted();
 715
 716 protected:
 717   SMDS_Mesh(SMDS_Mesh * parent);
 718
 719   SMDS_MeshFace * createTriangle(const SMDS_MeshNode * node1,
 720                                  const SMDS_MeshNode * node2,
 721                                  const SMDS_MeshNode * node3,
 722                                  int ID);
 723   SMDS_MeshFace * createQuadrangle(const SMDS_MeshNode * node1,
 724                                    const SMDS_MeshNode * node2,
 725                                    const SMDS_MeshNode * node3,
 726                                    const SMDS_MeshNode * node4,
 727                                    int ID);
 728 //  SMDS_Mesh0DElement* Find0DElementOrCreate(const SMDS_MeshNode * n);
 729   SMDS_MeshEdge* FindEdgeOrCreate(const SMDS_MeshNode * n1,
 730                                   const SMDS_MeshNode * n2);
 731   SMDS_MeshFace* FindFaceOrCreate(const SMDS_MeshNode *n1,
 732                                   const SMDS_MeshNode *n2,
 733                                   const SMDS_MeshNode *n3);
 734   SMDS_MeshFace* FindFaceOrCreate(const SMDS_MeshNode *n1,
 735                                   const SMDS_MeshNode *n2,
 736                                   const SMDS_MeshNode *n3,
 737                                   const SMDS_MeshNode *n4);
 738
 739   bool registerElement(int ID, SMDS_MeshElement * element);
 740
 741   void addChildrenWithNodes(std::set<const SMDS_MeshElement*>& setOfChildren,
 742                             const SMDS_MeshElement * element,
 743                             std::set<const SMDS_MeshElement*>& nodes);
 744
 745   inline void adjustmyCellsCapacity(int ID)
 746   {
 747     assert(ID >= 0);
 748     myElementIDFactory->adjustMaxId(ID);
 749     if (ID >= myCells.size())
 750       myCells.resize(ID+SMDS_Mesh::chunkSize,0);
 751   }
 752
 753   inline void adjustBoundingBox(double x, double y, double z)
 754   {
 755     if (x > xmax) xmax = x;
 756     else if (x < xmin) xmin = x;
 757     if (y > ymax) ymax = y;
 758     else if (y < ymin) ymin = y;
 759     if (z > zmax) zmax = z;
 760     else if (z < zmin) zmin = z;
 761   }
 762
 763   // Fields PRIVATE
 764
 765   //! index of this SMDS_mesh in the static vector<SMDS_Mesh*> _meshList
 766   int myMeshId;
 767
 768   //! actual nodes coordinates, cells definition and reverse connectivity are stored in a vtkUnstructuredGrid
 769   SMDS_UnstructuredGrid*      myGrid;
 770
 771   //! Small objects like SMDS_MeshNode are allocated by chunks to limit memory costs of new
 772   ObjectPool<SMDS_MeshNode>* myNodePool;
 773
 774   //! Small objects like SMDS_VtkVolume are allocated by chunks to limit memory costs of new
 775   ObjectPool<SMDS_VtkVolume>* myVolumePool;
 776   ObjectPool<SMDS_VtkFace>* myFacePool;
 777   ObjectPool<SMDS_VtkEdge>* myEdgePool;
 778
 779   //! SMDS_MeshNodes refer to vtk nodes (vtk id = index in myNodes),store reference to this mesh, and subshape
 780   SetOfNodes             myNodes;
 781
 782   //! SMDS_MeshCells refer to vtk cells (vtk id != index in myCells),store reference to this mesh, and subshape
 783   SetOfCells             myCells;
 784
 785   //! for cells only: index = ID for SMDS users, value = ID in vtkUnstructuredGrid
 786   //std::vector<int>       myCellIdSmdsToVtk;
 787
 788   //! for cells only: index = ID in vtkUnstructuredGrid, value = ID for SMDS users
 789   std::vector<int>       myCellIdVtkToSmds;
 790
 791   SMDS_Mesh *            myParent;
 792   std::list<SMDS_Mesh *> myChildren;
 793   SMDS_MeshNodeIDFactory *myNodeIDFactory;
 794   SMDS_MeshElementIDFactory *myElementIDFactory;
 795   SMDS_MeshInfo          myInfo;
 796
 797   //! use a counter to keep track of modifications
 798   unsigned long myModifTime, myCompactTime;
 799
 800   int myNodeMin;
 801   int myNodeMax;
 802
 803   bool myHasConstructionEdges;
 804   bool myHasConstructionFaces;
 805   bool myHasInverseElements;
 806
 807   //! any add, remove or change of node or cell
 808   bool myModified;
 809
 810   double xmin;
 811   double xmax;
 812   double ymin;
 813   double ymax;
 814   double zmin;
 815   double zmax;
 816 };
 817
 818
 819 #endif