src/SMDS/SMDS_Mesh.hxx

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