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