src/SMDS/SMDS_Mesh.hxx

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