src/SMDS/SMDS_Mesh.hxx

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