src/SMDS/SMDS_Mesh.hxx

   1 //  Copyright (C) 2007-2008  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 //  SMESH SMDS : implementaion of Salome mesh data structure
  23 //  File   : SMDS_Mesh.hxx
  24 //  Module : SMESH
  25
  26 #ifndef _SMDS_Mesh_HeaderFile
  27 #define _SMDS_Mesh_HeaderFile
  28
  29 #include "SMESH_SMDS.hxx"
  30
  31 #include "SMDS_MeshNode.hxx"
  32 #include "SMDS_MeshCell.hxx"
  33 #include "SMDS_Mesh0DElement.hxx"
  34 #include "SMDS_MeshEdge.hxx"
  35 #include "SMDS_MeshFace.hxx"
  36 #include "SMDS_MeshVolume.hxx"
  37 #include "SMDS_MeshNodeIDFactory.hxx"
  38 #include "SMDS_MeshElementIDFactory.hxx"
  39 #include "SMDS_MeshInfo.hxx"
  40 #include "SMDS_ElemIterator.hxx"
  41 #include "SMDS_VolumeOfNodes.hxx"
  42 #include "SMDS_VtkVolume.hxx"
  43 #include "ObjectPool.hxx"
  44
  45 #include <boost/shared_ptr.hpp>
  46 #include <set>
  47 #include <list>
  48 #include <vector>
  49 #include <vtkSystemIncludes.h>
  50
  51 class vtkUnstructuredGrid;
  52
  53 class SMDS_EXPORT SMDS_Mesh:public SMDS_MeshObject{
  54 public:
  55   friend class SMDS_MeshElementIDFactory;
  56   friend class SMDS_MeshVolumeVtkNodes;
  57
  58   SMDS_Mesh();
  59
  60   //! to retreive this SMDS_Mesh instance from its elements (index stored in SMDS_Elements)
  61   static std::vector<SMDS_Mesh*> _meshList;
  62
  63   //! actual nodes coordinates, cells definition and reverse connectivity are stored in a vtkUnstructuredGrid
  64   inline vtkUnstructuredGrid* getGrid() {return myGrid; };
  65   inline int getMeshId() {return myMeshId; };
  66
  67   SMDS_NodeIteratorPtr nodesIterator() const;
  68   SMDS_0DElementIteratorPtr elements0dIterator() const;
  69   SMDS_EdgeIteratorPtr edgesIterator() const;
  70   SMDS_FaceIteratorPtr facesIterator() const;
  71   SMDS_VolumeIteratorPtr volumesIterator() const;
  72   SMDS_ElemIteratorPtr elementsIterator(SMDSAbs_ElementType type=SMDSAbs_All) const;
  73
  74   SMDSAbs_ElementType GetElementType( const int id, const bool iselem ) const;
  75
  76   SMDS_Mesh *AddSubMesh();
  77
  78   virtual SMDS_MeshNode* AddNodeWithID(double x, double y, double z, int ID);
  79   virtual SMDS_MeshNode* AddNode(double x, double y, double z);
  80
  81   virtual SMDS_Mesh0DElement* Add0DElementWithID(int n, int ID);
  82   virtual SMDS_Mesh0DElement* Add0DElementWithID(const SMDS_MeshNode * n, int ID);
  83   virtual SMDS_Mesh0DElement* Add0DElement      (const SMDS_MeshNode * n);
  84
  85   virtual SMDS_MeshEdge* AddEdgeWithID(int n1, int n2, int ID);
  86   virtual SMDS_MeshEdge* AddEdgeWithID(const SMDS_MeshNode * n1,
  87                                        const SMDS_MeshNode * n2,
  88                                        int ID);
  89   virtual SMDS_MeshEdge* AddEdge(const SMDS_MeshNode * n1,
  90                                  const SMDS_MeshNode * n2);
  91
  92   // 2d order edge with 3 nodes: n12 - node between n1 and n2
  93   virtual SMDS_MeshEdge* AddEdgeWithID(int n1, int n2, int n12, int ID);
  94   virtual SMDS_MeshEdge* AddEdgeWithID(const SMDS_MeshNode * n1,
  95                                        const SMDS_MeshNode * n2,
  96                                        const SMDS_MeshNode * n12,
  97                                        int ID);
  98   virtual SMDS_MeshEdge* AddEdge(const SMDS_MeshNode * n1,
  99                                  const SMDS_MeshNode * n2,
 100                                  const SMDS_MeshNode * n12);
 101
 102   virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3, int ID);
 103   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
 104                                        const SMDS_MeshNode * n2,
 105                                        const SMDS_MeshNode * n3,
 106                                        int ID);
 107   virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
 108                                  const SMDS_MeshNode * n2,
 109                                  const SMDS_MeshNode * n3);
 110
 111   virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3, int n4, int ID);
 112   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
 113                                        const SMDS_MeshNode * n2,
 114                                        const SMDS_MeshNode * n3,
 115                                        const SMDS_MeshNode * n4,
 116                                        int ID);
 117   virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
 118                                  const SMDS_MeshNode * n2,
 119                                  const SMDS_MeshNode * n3,
 120                                  const SMDS_MeshNode * n4);
 121
 122   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshEdge * e1,
 123                                        const SMDS_MeshEdge * e2,
 124                                        const SMDS_MeshEdge * e3, int ID);
 125   virtual SMDS_MeshFace* AddFace(const SMDS_MeshEdge * e1,
 126                                  const SMDS_MeshEdge * e2,
 127                                  const SMDS_MeshEdge * e3);
 128
 129   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshEdge * e1,
 130                                        const SMDS_MeshEdge * e2,
 131                                        const SMDS_MeshEdge * e3,
 132                                        const SMDS_MeshEdge * e4, int ID);
 133   virtual SMDS_MeshFace* AddFace(const SMDS_MeshEdge * e1,
 134                                  const SMDS_MeshEdge * e2,
 135                                  const SMDS_MeshEdge * e3,
 136                                  const SMDS_MeshEdge * e4);
 137
 138   // 2d order triangle of 6 nodes
 139   virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3,
 140                                        int n12,int n23,int n31, int ID);
 141   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
 142                                        const SMDS_MeshNode * n2,
 143                                        const SMDS_MeshNode * n3,
 144                                        const SMDS_MeshNode * n12,
 145                                        const SMDS_MeshNode * n23,
 146                                        const SMDS_MeshNode * n31,
 147                                        int ID);
 148   virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
 149                                  const SMDS_MeshNode * n2,
 150                                  const SMDS_MeshNode * n3,
 151                                  const SMDS_MeshNode * n12,
 152                                  const SMDS_MeshNode * n23,
 153                                  const SMDS_MeshNode * n31);
 154
 155   // 2d order quadrangle
 156   virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3, int n4,
 157                                        int n12,int n23,int n34,int n41, int ID);
 158   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
 159                                        const SMDS_MeshNode * n2,
 160                                        const SMDS_MeshNode * n3,
 161                                        const SMDS_MeshNode * n4,
 162                                        const SMDS_MeshNode * n12,
 163                                        const SMDS_MeshNode * n23,
 164                                        const SMDS_MeshNode * n34,
 165                                        const SMDS_MeshNode * n41,
 166                                        int ID);
 167   virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
 168                                  const SMDS_MeshNode * n2,
 169                                  const SMDS_MeshNode * n3,
 170                                  const SMDS_MeshNode * n4,
 171                                  const SMDS_MeshNode * n12,
 172                                  const SMDS_MeshNode * n23,
 173                                  const SMDS_MeshNode * n34,
 174                                  const SMDS_MeshNode * n41);
 175
 176   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int ID);
 177   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 178                                            const SMDS_MeshNode * n2,
 179                                            const SMDS_MeshNode * n3,
 180                                            const SMDS_MeshNode * n4,
 181                                            int ID);
 182   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 183                                      const SMDS_MeshNode * n2,
 184                                      const SMDS_MeshNode * n3,
 185                                      const SMDS_MeshNode * n4);
 186
 187   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
 188                                            int n5, int ID);
 189   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 190                                            const SMDS_MeshNode * n2,
 191                                            const SMDS_MeshNode * n3,
 192                                            const SMDS_MeshNode * n4,
 193                                            const SMDS_MeshNode * n5,
 194                                            int ID);
 195   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 196                                      const SMDS_MeshNode * n2,
 197                                      const SMDS_MeshNode * n3,
 198                                      const SMDS_MeshNode * n4,
 199                                      const SMDS_MeshNode * n5);
 200
 201   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
 202                                            int n5, int n6, int ID);
 203   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 204                                            const SMDS_MeshNode * n2,
 205                                            const SMDS_MeshNode * n3,
 206                                            const SMDS_MeshNode * n4,
 207                                            const SMDS_MeshNode * n5,
 208                                            const SMDS_MeshNode * n6,
 209                                            int ID);
 210   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 211                                      const SMDS_MeshNode * n2,
 212                                      const SMDS_MeshNode * n3,
 213                                      const SMDS_MeshNode * n4,
 214                                      const SMDS_MeshNode * n5,
 215                                      const SMDS_MeshNode * n6);
 216
 217   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
 218                                            int n5, int n6, int n7, int n8, int ID);
 219   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 220                                            const SMDS_MeshNode * n2,
 221                                            const SMDS_MeshNode * n3,
 222                                            const SMDS_MeshNode * n4,
 223                                            const SMDS_MeshNode * n5,
 224                                            const SMDS_MeshNode * n6,
 225                                            const SMDS_MeshNode * n7,
 226                                            const SMDS_MeshNode * n8,
 227                                            int ID);
 228   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 229                                      const SMDS_MeshNode * n2,
 230                                      const SMDS_MeshNode * n3,
 231                                      const SMDS_MeshNode * n4,
 232                                      const SMDS_MeshNode * n5,
 233                                      const SMDS_MeshNode * n6,
 234                                      const SMDS_MeshNode * n7,
 235                                      const SMDS_MeshNode * n8);
 236
 237   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshFace * f1,
 238                                            const SMDS_MeshFace * f2,
 239                                            const SMDS_MeshFace * f3,
 240                                            const SMDS_MeshFace * f4, int ID);
 241   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshFace * f1,
 242                                      const SMDS_MeshFace * f2,
 243                                      const SMDS_MeshFace * f3,
 244                                      const SMDS_MeshFace * f4);
 245
 246   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshFace * f1,
 247                                            const SMDS_MeshFace * f2,
 248                                            const SMDS_MeshFace * f3,
 249                                            const SMDS_MeshFace * f4,
 250                                            const SMDS_MeshFace * f5, int ID);
 251   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshFace * f1,
 252                                      const SMDS_MeshFace * f2,
 253                                      const SMDS_MeshFace * f3,
 254                                      const SMDS_MeshFace * f4,
 255                                      const SMDS_MeshFace * f5);
 256
 257   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshFace * f1,
 258                                            const SMDS_MeshFace * f2,
 259                                            const SMDS_MeshFace * f3,
 260                                            const SMDS_MeshFace * f4,
 261                                            const SMDS_MeshFace * f5,
 262                                            const SMDS_MeshFace * f6, int ID);
 263   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshFace * f1,
 264                                      const SMDS_MeshFace * f2,
 265                                      const SMDS_MeshFace * f3,
 266                                      const SMDS_MeshFace * f4,
 267                                      const SMDS_MeshFace * f5,
 268                                      const SMDS_MeshFace * f6);
 269
 270   // 2d order tetrahedron of 10 nodes
 271   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
 272                                            int n12,int n23,int n31,
 273                                            int n14,int n24,int n34, int ID);
 274   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 275                                            const SMDS_MeshNode * n2,
 276                                            const SMDS_MeshNode * n3,
 277                                            const SMDS_MeshNode * n4,
 278                                            const SMDS_MeshNode * n12,
 279                                            const SMDS_MeshNode * n23,
 280                                            const SMDS_MeshNode * n31,
 281                                            const SMDS_MeshNode * n14,
 282                                            const SMDS_MeshNode * n24,
 283                                            const SMDS_MeshNode * n34,
 284                                            int ID);
 285   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 286                                      const SMDS_MeshNode * n2,
 287                                      const SMDS_MeshNode * n3,
 288                                      const SMDS_MeshNode * n4,
 289                                      const SMDS_MeshNode * n12,
 290                                      const SMDS_MeshNode * n23,
 291                                      const SMDS_MeshNode * n31,
 292                                      const SMDS_MeshNode * n14,
 293                                      const SMDS_MeshNode * n24,
 294                                      const SMDS_MeshNode * n34);
 295
 296   // 2d order pyramid of 13 nodes
 297   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int n5,
 298                                            int n12,int n23,int n34,int n41,
 299                                            int n15,int n25,int n35,int n45,
 300                                            int ID);
 301   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 302                                            const SMDS_MeshNode * n2,
 303                                            const SMDS_MeshNode * n3,
 304                                            const SMDS_MeshNode * n4,
 305                                            const SMDS_MeshNode * n5,
 306                                            const SMDS_MeshNode * n12,
 307                                            const SMDS_MeshNode * n23,
 308                                            const SMDS_MeshNode * n34,
 309                                            const SMDS_MeshNode * n41,
 310                                            const SMDS_MeshNode * n15,
 311                                            const SMDS_MeshNode * n25,
 312                                            const SMDS_MeshNode * n35,
 313                                            const SMDS_MeshNode * n45,
 314                                            int ID);
 315   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 316                                      const SMDS_MeshNode * n2,
 317                                      const SMDS_MeshNode * n3,
 318                                      const SMDS_MeshNode * n4,
 319                                      const SMDS_MeshNode * n5,
 320                                      const SMDS_MeshNode * n12,
 321                                      const SMDS_MeshNode * n23,
 322                                      const SMDS_MeshNode * n34,
 323                                      const SMDS_MeshNode * n41,
 324                                      const SMDS_MeshNode * n15,
 325                                      const SMDS_MeshNode * n25,
 326                                      const SMDS_MeshNode * n35,
 327                                      const SMDS_MeshNode * n45);
 328
 329   // 2d order Pentahedron with 15 nodes
 330   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3,
 331                                            int n4, int n5, int n6,
 332                                            int n12,int n23,int n31,
 333                                            int n45,int n56,int n64,
 334                                            int n14,int n25,int n36,
 335                                            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 * n5,
 341                                            const SMDS_MeshNode * n6,
 342                                            const SMDS_MeshNode * n12,
 343                                            const SMDS_MeshNode * n23,
 344                                            const SMDS_MeshNode * n31,
 345                                            const SMDS_MeshNode * n45,
 346                                            const SMDS_MeshNode * n56,
 347                                            const SMDS_MeshNode * n64,
 348                                            const SMDS_MeshNode * n14,
 349                                            const SMDS_MeshNode * n25,
 350                                            const SMDS_MeshNode * n36,
 351                                            int ID);
 352   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 353                                      const SMDS_MeshNode * n2,
 354                                      const SMDS_MeshNode * n3,
 355                                      const SMDS_MeshNode * n4,
 356                                      const SMDS_MeshNode * n5,
 357                                      const SMDS_MeshNode * n6,
 358                                      const SMDS_MeshNode * n12,
 359                                      const SMDS_MeshNode * n23,
 360                                      const SMDS_MeshNode * n31,
 361                                      const SMDS_MeshNode * n45,
 362                                      const SMDS_MeshNode * n56,
 363                                      const SMDS_MeshNode * n64,
 364                                      const SMDS_MeshNode * n14,
 365                                      const SMDS_MeshNode * n25,
 366                                      const SMDS_MeshNode * n36);
 367
 368   // 2d oreder Hexahedrons with 20 nodes
 369   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
 370                                            int n5, int n6, int n7, int n8,
 371                                            int n12,int n23,int n34,int n41,
 372                                            int n56,int n67,int n78,int n85,
 373                                            int n15,int n26,int n37,int n48,
 374                                            int ID);
 375   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 376                                            const SMDS_MeshNode * n2,
 377                                            const SMDS_MeshNode * n3,
 378                                            const SMDS_MeshNode * n4,
 379                                            const SMDS_MeshNode * n5,
 380                                            const SMDS_MeshNode * n6,
 381                                            const SMDS_MeshNode * n7,
 382                                            const SMDS_MeshNode * n8,
 383                                            const SMDS_MeshNode * n12,
 384                                            const SMDS_MeshNode * n23,
 385                                            const SMDS_MeshNode * n34,
 386                                            const SMDS_MeshNode * n41,
 387                                            const SMDS_MeshNode * n56,
 388                                            const SMDS_MeshNode * n67,
 389                                            const SMDS_MeshNode * n78,
 390                                            const SMDS_MeshNode * n85,
 391                                            const SMDS_MeshNode * n15,
 392                                            const SMDS_MeshNode * n26,
 393                                            const SMDS_MeshNode * n37,
 394                                            const SMDS_MeshNode * n48,
 395                                            int ID);
 396   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 397                                      const SMDS_MeshNode * n2,
 398                                      const SMDS_MeshNode * n3,
 399                                      const SMDS_MeshNode * n4,
 400                                      const SMDS_MeshNode * n5,
 401                                      const SMDS_MeshNode * n6,
 402                                      const SMDS_MeshNode * n7,
 403                                      const SMDS_MeshNode * n8,
 404                                      const SMDS_MeshNode * n12,
 405                                      const SMDS_MeshNode * n23,
 406                                      const SMDS_MeshNode * n34,
 407                                      const SMDS_MeshNode * n41,
 408                                      const SMDS_MeshNode * n56,
 409                                      const SMDS_MeshNode * n67,
 410                                      const SMDS_MeshNode * n78,
 411                                      const SMDS_MeshNode * n85,
 412                                      const SMDS_MeshNode * n15,
 413                                      const SMDS_MeshNode * n26,
 414                                      const SMDS_MeshNode * n37,
 415                                      const SMDS_MeshNode * n48);
 416
 417   virtual SMDS_MeshFace* AddPolygonalFaceWithID (std::vector<int> nodes_ids,
 418                                                  const int        ID);
 419
 420   virtual SMDS_MeshFace* AddPolygonalFaceWithID (std::vector<const SMDS_MeshNode*> nodes,
 421                                                  const int                         ID);
 422
 423   virtual SMDS_MeshFace* AddPolygonalFace (std::vector<const SMDS_MeshNode*> nodes);
 424
 425   virtual SMDS_MeshVolume* AddPolyhedralVolumeWithID
 426                            (std::vector<int> nodes_ids,
 427                             std::vector<int> quantities,
 428                             const int        ID);
 429
 430   virtual SMDS_MeshVolume* AddPolyhedralVolumeWithID
 431                            (std::vector<const SMDS_MeshNode*> nodes,
 432                             std::vector<int>                  quantities,
 433                             const int                         ID);
 434
 435   virtual SMDS_MeshVolume* AddPolyhedralVolume
 436                            (std::vector<const SMDS_MeshNode*> nodes,
 437                             std::vector<int>                  quantities);
 438
 439   virtual void RemoveElement(const SMDS_MeshElement *        elem,
 440                              std::list<const SMDS_MeshElement *>& removedElems,
 441                              std::list<const SMDS_MeshElement *>& removedNodes,
 442                              const bool                      removenodes = false);
 443   virtual void RemoveElement(const SMDS_MeshElement * elem, bool removenodes = false);
 444   virtual void RemoveNode(const SMDS_MeshNode * node);
 445   virtual void Remove0DElement(const SMDS_Mesh0DElement * elem0d);
 446   virtual void RemoveEdge(const SMDS_MeshEdge * edge);
 447   virtual void RemoveFace(const SMDS_MeshFace * face);
 448   virtual void RemoveVolume(const SMDS_MeshVolume * volume);
 449
 450   /*! Remove only the given element and only if it is free.
 451    *  Method does not work for meshes with descendants.
 452    *  Implemented for fast cleaning of meshes.
 453    */
 454   virtual void RemoveFreeElement(const SMDS_MeshElement * elem);
 455
 456   virtual void Clear();
 457
 458   virtual bool RemoveFromParent();
 459   virtual bool RemoveSubMesh(const SMDS_Mesh * aMesh);
 460
 461   bool ChangeElementNodes(const SMDS_MeshElement * elem,
 462                           const SMDS_MeshNode    * nodes[],
 463                           const int                nbnodes);
 464   bool ChangePolyhedronNodes(const SMDS_MeshElement *                 elem,
 465                              const std::vector<const SMDS_MeshNode*>& nodes,
 466                              const std::vector<int> &                 quantities);
 467
 468   virtual void Renumber (const bool isNodes, const int startID = 1, const int deltaID = 1);
 469   // Renumber all nodes or elements.
 470
 471   const SMDS_MeshNode *FindNode(int idnode) const;
 472   const SMDS_Mesh0DElement* Find0DElement(int idnode) const;
 473   const SMDS_MeshEdge *FindEdge(int idnode1, int idnode2) const;
 474   const SMDS_MeshEdge *FindEdge(int idnode1, int idnode2, int idnode3) const;
 475   const SMDS_MeshFace *FindFace(int idnode1, int idnode2, int idnode3) const;
 476   const SMDS_MeshFace *FindFace(int idnode1, int idnode2, int idnode3, int idnode4) const;
 477   const SMDS_MeshFace *FindFace(int idnode1, int idnode2, int idnode3,
 478                                 int idnode4, int idnode5, int idnode6) const;
 479   const SMDS_MeshFace *FindFace(int idnode1, int idnode2, int idnode3, int idnode4,
 480                                 int idnode5, int idnode6, int idnode7, int idnode8) const;
 481   const SMDS_MeshElement *FindElement(int IDelem) const;
 482   static const SMDS_Mesh0DElement* Find0DElement(const SMDS_MeshNode * n);
 483   static const SMDS_MeshEdge* FindEdge(const SMDS_MeshNode * n1,
 484                                        const SMDS_MeshNode * n2);
 485   static const SMDS_MeshEdge* FindEdge(const SMDS_MeshNode * n1,
 486                                        const SMDS_MeshNode * n2,
 487                                        const SMDS_MeshNode * n3);
 488   static const SMDS_MeshFace* FindFace(const SMDS_MeshNode *n1,
 489                                        const SMDS_MeshNode *n2,
 490                                        const SMDS_MeshNode *n3);
 491   static const SMDS_MeshFace* FindFace(const SMDS_MeshNode *n1,
 492                                        const SMDS_MeshNode *n2,
 493                                        const SMDS_MeshNode *n3,
 494                                        const SMDS_MeshNode *n4);
 495   static const SMDS_MeshFace* FindFace(const SMDS_MeshNode *n1,
 496                                        const SMDS_MeshNode *n2,
 497                                        const SMDS_MeshNode *n3,
 498                                        const SMDS_MeshNode *n4,
 499                                        const SMDS_MeshNode *n5,
 500                                        const SMDS_MeshNode *n6);
 501   static const SMDS_MeshFace* FindFace(const SMDS_MeshNode *n1,
 502                                        const SMDS_MeshNode *n2,
 503                                        const SMDS_MeshNode *n3,
 504                                        const SMDS_MeshNode *n4,
 505                                        const SMDS_MeshNode *n5,
 506                                        const SMDS_MeshNode *n6,
 507                                        const SMDS_MeshNode *n7,
 508                                        const SMDS_MeshNode *n8);
 509
 510   const SMDS_MeshFace *FindFace(std::vector<int> nodes_ids) const;
 511   static const SMDS_MeshFace* FindFace(std::vector<const SMDS_MeshNode *> nodes);
 512
 513   /*!
 514    * \brief Raise an exception if free memory (ram+swap) too low
 515     * \param doNotRaise - if true, suppres exception, just return free memory size
 516     * \retval int - amount of available memory in MB or negative number in failure case
 517    */
 518   static int CheckMemory(const bool doNotRaise=false) throw (std::bad_alloc);
 519
 520   int MaxNodeID() const;
 521   int MinNodeID() const;
 522   int MaxElementID() const;
 523   int MinElementID() const;
 524
 525   const SMDS_MeshInfo& GetMeshInfo() const { return myInfo; }
 526
 527   int NbNodes() const;
 528   int Nb0DElements() const;
 529   int NbEdges() const;
 530   int NbFaces() const;
 531   int NbVolumes() const;
 532   int NbSubMesh() const;
 533   void DumpNodes() const;
 534   void Dump0DElements() const;
 535   void DumpEdges() const;
 536   void DumpFaces() const;
 537   void DumpVolumes() const;
 538   void DebugStats() const;
 539   SMDS_Mesh *boundaryFaces();
 540   SMDS_Mesh *boundaryEdges();
 541   virtual ~SMDS_Mesh();
 542   bool hasConstructionEdges();
 543   bool hasConstructionFaces();
 544   bool hasInverseElements();
 545   void setConstructionEdges(bool);
 546   void setConstructionFaces(bool);
 547   void setInverseElements(bool);
 548
 549   /*!
 550    * Checks if the element is present in mesh.
 551    * Useful to determine dead pointers.
 552    * Use this function for debug purpose only! Do not check in the code
 553    * using it even in _DEBUG_ mode
 554    */
 555   bool Contains (const SMDS_MeshElement* elem) const;
 556
 557   typedef std::vector<SMDS_MeshNode *> SetOfNodes;
 558   typedef std::vector<SMDS_MeshCell *> SetOfCells;
 559
 560   void updateNodeMinMax();
 561   inline int fromVtkToSmds(int vtkid) { return myVtkIndex[vtkid]; };
 562
 563   void incrementNodesCapacity(int nbNodes);
 564   void incrementCellsCapacity(int nbCells);
 565
 566   int myCellLinksSize;
 567
 568   static int chunkSize;
 569
 570 private:
 571   SMDS_Mesh(SMDS_Mesh * parent);
 572
 573   SMDS_MeshFace * createTriangle(const SMDS_MeshNode * node1,
 574                                  const SMDS_MeshNode * node2,
 575                                  const SMDS_MeshNode * node3);
 576   SMDS_MeshFace * createQuadrangle(const SMDS_MeshNode * node1,
 577                                    const SMDS_MeshNode * node2,
 578                                    const SMDS_MeshNode * node3,
 579                                    const SMDS_MeshNode * node4,
 580                                    int ID);
 581 //  SMDS_Mesh0DElement* Find0DElementOrCreate(const SMDS_MeshNode * n);
 582   SMDS_MeshEdge* FindEdgeOrCreate(const SMDS_MeshNode * n1,
 583                                   const SMDS_MeshNode * n2);
 584   SMDS_MeshFace* FindFaceOrCreate(const SMDS_MeshNode *n1,
 585                                   const SMDS_MeshNode *n2,
 586                                   const SMDS_MeshNode *n3);
 587   SMDS_MeshFace* FindFaceOrCreate(const SMDS_MeshNode *n1,
 588                                   const SMDS_MeshNode *n2,
 589                                   const SMDS_MeshNode *n3,
 590                                   const SMDS_MeshNode *n4);
 591
 592   bool registerElement(int ID, SMDS_MeshElement * element);
 593
 594   void addChildrenWithNodes(std::set<const SMDS_MeshElement*>& setOfChildren,
 595                             const SMDS_MeshElement * element,
 596                             std::set<const SMDS_MeshElement*>& nodes);
 597
 598   inline void adjustmyCellsCapacity(int ID)
 599   {
 600     assert(ID >= 0);
 601     if (ID >= myCells.size())
 602         myCells.resize(ID+SMDS_Mesh::chunkSize,0);
 603   };
 604
 605   // Fields PRIVATE
 606
 607   //! index of this SMDS_mesh in the static vector<SMDS_Mesh*> _meshList
 608   int myMeshId;
 609
 610   //! actual nodes coordinates, cells definition and reverse connectivity are stored in a vtkUnstructuredGrid
 611   vtkUnstructuredGrid*      myGrid;
 612
 613   //! Small objects like SMDS_MeshNode are allocated by chunks to limit memory costs of new
 614   ObjectPool<SMDS_MeshNode>* myNodePool;
 615
 616   //! Small objects like SMDS_VtkVolume are allocated by chunks to limit memory costs of new
 617   ObjectPool<SMDS_VtkVolume>* myVolumePool;
 618
 619   //! SMDS_MeshNodes refer to vtk nodes (vtk id = index in myNodes),store reference to this mesh, and subshape
 620   SetOfNodes             myNodes;
 621
 622   //! SMDS_MeshCells refer to vtk cells (vtk id != index in myCells),store reference to this mesh, and subshape
 623   SetOfCells             myCells;
 624
 625   //! for cells only: index = ID for SMDS users, value = ID in vtkUnstructuredGrid
 626   std::vector<int>       myIDElements;
 627
 628   //! for cells only: index = ID in vtkUnstructuredGrid, value = ID for SMDS users
 629   std::vector<int>       myVtkIndex;
 630
 631   SMDS_Mesh *            myParent;
 632   std::list<SMDS_Mesh *> myChildren;
 633   SMDS_MeshNodeIDFactory *myNodeIDFactory;
 634   SMDS_MeshElementIDFactory *myElementIDFactory;
 635   SMDS_MeshInfo          myInfo;
 636
 637   int myNodeMin;
 638   int myNodeMax;
 639
 640   bool myHasConstructionEdges;
 641   bool myHasConstructionFaces;
 642   bool myHasInverseElements;
 643 };
 644
 645
 646 #endif