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