src/SMDS/SMDS_Mesh.hxx

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