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