src/SMDS/SMDS_Mesh.hxx

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