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