SALOME - SMESH
SMDS_Mesh.hxx
Go to the documentation of this file.
00001 //  Copyright (C) 2007-2008  CEA/DEN, EDF R&D, OPEN CASCADE
00002 //
00003 //  Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
00004 //  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
00005 //
00006 //  This library is free software; you can redistribute it and/or
00007 //  modify it under the terms of the GNU Lesser General Public
00008 //  License as published by the Free Software Foundation; either
00009 //  version 2.1 of the License.
00010 //
00011 //  This library is distributed in the hope that it will be useful,
00012 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
00013 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00014 //  Lesser General Public License for more details.
00015 //
00016 //  You should have received a copy of the GNU Lesser General Public
00017 //  License along with this library; if not, write to the Free Software
00018 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
00019 //
00020 //  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
00021 //
00022 //  SMESH SMDS : implementaion of Salome mesh data structure
00023 //  File   : SMDS_Mesh.hxx
00024 //  Module : SMESH
00025 
00026 #ifndef _SMDS_Mesh_HeaderFile
00027 #define _SMDS_Mesh_HeaderFile
00028 
00029 #include "SMESH_SMDS.hxx"
00030 
00031 #include "SMDS_MeshNode.hxx"
00032 #include "SMDS_Mesh0DElement.hxx"
00033 #include "SMDS_MeshEdge.hxx"
00034 #include "SMDS_MeshFace.hxx"
00035 #include "SMDS_MeshVolume.hxx"
00036 #include "SMDS_MeshElementIDFactory.hxx"
00037 #include "SMDS_MeshInfo.hxx"
00038 #include "SMDS_ElemIterator.hxx"
00039 #include <NCollection_Map.hxx>
00040 
00041 #include <boost/shared_ptr.hpp>
00042 #include <set>
00043 #include <list>
00044 
00045 class SMDS_EXPORT SMDS_Mesh:public SMDS_MeshObject{
00046 public:
00047 
00048   SMDS_Mesh();
00049 
00050   SMDS_NodeIteratorPtr nodesIterator() const;
00051   SMDS_0DElementIteratorPtr elements0dIterator() const;
00052   SMDS_EdgeIteratorPtr edgesIterator() const;
00053   SMDS_FaceIteratorPtr facesIterator() const;
00054   SMDS_VolumeIteratorPtr volumesIterator() const;
00055   SMDS_ElemIteratorPtr elementsIterator(SMDSAbs_ElementType type=SMDSAbs_All) const;
00056 
00057   SMDSAbs_ElementType GetElementType( const int id, const bool iselem ) const;
00058 
00059   SMDS_Mesh *AddSubMesh();
00060 
00061   virtual SMDS_MeshNode* AddNodeWithID(double x, double y, double z, int ID);
00062   virtual SMDS_MeshNode* AddNode(double x, double y, double z);
00063 
00064   virtual SMDS_Mesh0DElement* Add0DElementWithID(int n, int ID);
00065   virtual SMDS_Mesh0DElement* Add0DElementWithID(const SMDS_MeshNode * n, int ID);
00066   virtual SMDS_Mesh0DElement* Add0DElement      (const SMDS_MeshNode * n);
00067 
00068   virtual SMDS_MeshEdge* AddEdgeWithID(int n1, int n2, int ID);
00069   virtual SMDS_MeshEdge* AddEdgeWithID(const SMDS_MeshNode * n1,
00070                                        const SMDS_MeshNode * n2,
00071                                        int ID);
00072   virtual SMDS_MeshEdge* AddEdge(const SMDS_MeshNode * n1,
00073                                  const SMDS_MeshNode * n2);
00074 
00075   // 2d order edge with 3 nodes: n12 - node between n1 and n2
00076   virtual SMDS_MeshEdge* AddEdgeWithID(int n1, int n2, int n12, int ID);
00077   virtual SMDS_MeshEdge* AddEdgeWithID(const SMDS_MeshNode * n1,
00078                                        const SMDS_MeshNode * n2,
00079                                        const SMDS_MeshNode * n12,
00080                                        int ID);
00081   virtual SMDS_MeshEdge* AddEdge(const SMDS_MeshNode * n1,
00082                                  const SMDS_MeshNode * n2,
00083                                  const SMDS_MeshNode * n12);
00084 
00085   virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3, int ID);
00086   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
00087                                        const SMDS_MeshNode * n2,
00088                                        const SMDS_MeshNode * n3,
00089                                        int ID);
00090   virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
00091                                  const SMDS_MeshNode * n2,
00092                                  const SMDS_MeshNode * n3);
00093 
00094   virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3, int n4, int ID);
00095   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
00096                                        const SMDS_MeshNode * n2,
00097                                        const SMDS_MeshNode * n3,
00098                                        const SMDS_MeshNode * n4,
00099                                        int ID);
00100   virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
00101                                  const SMDS_MeshNode * n2,
00102                                  const SMDS_MeshNode * n3,
00103                                  const SMDS_MeshNode * n4);
00104 
00105   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshEdge * e1,
00106                                        const SMDS_MeshEdge * e2,
00107                                        const SMDS_MeshEdge * e3, int ID);
00108   virtual SMDS_MeshFace* AddFace(const SMDS_MeshEdge * e1,
00109                                  const SMDS_MeshEdge * e2,
00110                                  const SMDS_MeshEdge * e3);
00111 
00112   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshEdge * e1,
00113                                        const SMDS_MeshEdge * e2,
00114                                        const SMDS_MeshEdge * e3,
00115                                        const SMDS_MeshEdge * e4, int ID);
00116   virtual SMDS_MeshFace* AddFace(const SMDS_MeshEdge * e1,
00117                                  const SMDS_MeshEdge * e2,
00118                                  const SMDS_MeshEdge * e3,
00119                                  const SMDS_MeshEdge * e4);
00120 
00121   // 2d order triangle of 6 nodes
00122   virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3,
00123                                        int n12,int n23,int n31, int ID);
00124   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
00125                                        const SMDS_MeshNode * n2,
00126                                        const SMDS_MeshNode * n3,
00127                                        const SMDS_MeshNode * n12,
00128                                        const SMDS_MeshNode * n23,
00129                                        const SMDS_MeshNode * n31,
00130                                        int ID);
00131   virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
00132                                  const SMDS_MeshNode * n2,
00133                                  const SMDS_MeshNode * n3,
00134                                  const SMDS_MeshNode * n12,
00135                                  const SMDS_MeshNode * n23,
00136                                  const SMDS_MeshNode * n31);
00137 
00138   // 2d order quadrangle
00139   virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3, int n4,
00140                                        int n12,int n23,int n34,int n41, int ID);
00141   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
00142                                        const SMDS_MeshNode * n2,
00143                                        const SMDS_MeshNode * n3,
00144                                        const SMDS_MeshNode * n4,
00145                                        const SMDS_MeshNode * n12,
00146                                        const SMDS_MeshNode * n23,
00147                                        const SMDS_MeshNode * n34,
00148                                        const SMDS_MeshNode * n41,
00149                                        int ID);
00150   virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
00151                                  const SMDS_MeshNode * n2,
00152                                  const SMDS_MeshNode * n3,
00153                                  const SMDS_MeshNode * n4,
00154                                  const SMDS_MeshNode * n12,
00155                                  const SMDS_MeshNode * n23,
00156                                  const SMDS_MeshNode * n34,
00157                                  const SMDS_MeshNode * n41);
00158 
00159   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int ID);
00160   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
00161                                            const SMDS_MeshNode * n2,
00162                                            const SMDS_MeshNode * n3,
00163                                            const SMDS_MeshNode * n4,
00164                                            int ID);
00165   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
00166                                      const SMDS_MeshNode * n2,
00167                                      const SMDS_MeshNode * n3,
00168                                      const SMDS_MeshNode * n4);
00169 
00170   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
00171                                            int n5, int ID);
00172   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
00173                                            const SMDS_MeshNode * n2,
00174                                            const SMDS_MeshNode * n3,
00175                                            const SMDS_MeshNode * n4,
00176                                            const SMDS_MeshNode * n5,
00177                                            int ID);
00178   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
00179                                      const SMDS_MeshNode * n2,
00180                                      const SMDS_MeshNode * n3,
00181                                      const SMDS_MeshNode * n4,
00182                                      const SMDS_MeshNode * n5);
00183 
00184   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
00185                                            int n5, int n6, int ID);
00186   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
00187                                            const SMDS_MeshNode * n2,
00188                                            const SMDS_MeshNode * n3,
00189                                            const SMDS_MeshNode * n4,
00190                                            const SMDS_MeshNode * n5,
00191                                            const SMDS_MeshNode * n6,
00192                                            int ID);
00193   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
00194                                      const SMDS_MeshNode * n2,
00195                                      const SMDS_MeshNode * n3,
00196                                      const SMDS_MeshNode * n4,
00197                                      const SMDS_MeshNode * n5,
00198                                      const SMDS_MeshNode * n6);
00199 
00200   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
00201                                            int n5, int n6, int n7, int n8, int ID);
00202   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
00203                                            const SMDS_MeshNode * n2,
00204                                            const SMDS_MeshNode * n3,
00205                                            const SMDS_MeshNode * n4,
00206                                            const SMDS_MeshNode * n5,
00207                                            const SMDS_MeshNode * n6,
00208                                            const SMDS_MeshNode * n7,
00209                                            const SMDS_MeshNode * n8,
00210                                            int ID);
00211   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
00212                                      const SMDS_MeshNode * n2,
00213                                      const SMDS_MeshNode * n3,
00214                                      const SMDS_MeshNode * n4,
00215                                      const SMDS_MeshNode * n5,
00216                                      const SMDS_MeshNode * n6,
00217                                      const SMDS_MeshNode * n7,
00218                                      const SMDS_MeshNode * n8);
00219 
00220   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshFace * f1,
00221                                            const SMDS_MeshFace * f2,
00222                                            const SMDS_MeshFace * f3,
00223                                            const SMDS_MeshFace * f4, int ID);
00224   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshFace * f1,
00225                                      const SMDS_MeshFace * f2,
00226                                      const SMDS_MeshFace * f3,
00227                                      const SMDS_MeshFace * f4);
00228 
00229   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshFace * f1,
00230                                            const SMDS_MeshFace * f2,
00231                                            const SMDS_MeshFace * f3,
00232                                            const SMDS_MeshFace * f4,
00233                                            const SMDS_MeshFace * f5, int ID);
00234   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshFace * f1,
00235                                      const SMDS_MeshFace * f2,
00236                                      const SMDS_MeshFace * f3,
00237                                      const SMDS_MeshFace * f4,
00238                                      const SMDS_MeshFace * f5);
00239 
00240   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshFace * f1,
00241                                            const SMDS_MeshFace * f2,
00242                                            const SMDS_MeshFace * f3,
00243                                            const SMDS_MeshFace * f4,
00244                                            const SMDS_MeshFace * f5,
00245                                            const SMDS_MeshFace * f6, int ID);
00246   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshFace * f1,
00247                                      const SMDS_MeshFace * f2,
00248                                      const SMDS_MeshFace * f3,
00249                                      const SMDS_MeshFace * f4,
00250                                      const SMDS_MeshFace * f5,
00251                                      const SMDS_MeshFace * f6);
00252 
00253   // 2d order tetrahedron of 10 nodes
00254   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
00255                                            int n12,int n23,int n31,
00256                                            int n14,int n24,int n34, int ID);
00257   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
00258                                            const SMDS_MeshNode * n2,
00259                                            const SMDS_MeshNode * n3,
00260                                            const SMDS_MeshNode * n4,
00261                                            const SMDS_MeshNode * n12,
00262                                            const SMDS_MeshNode * n23,
00263                                            const SMDS_MeshNode * n31,
00264                                            const SMDS_MeshNode * n14,
00265                                            const SMDS_MeshNode * n24,
00266                                            const SMDS_MeshNode * n34,
00267                                            int ID);
00268   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
00269                                      const SMDS_MeshNode * n2,
00270                                      const SMDS_MeshNode * n3,
00271                                      const SMDS_MeshNode * n4,
00272                                      const SMDS_MeshNode * n12,
00273                                      const SMDS_MeshNode * n23,
00274                                      const SMDS_MeshNode * n31,
00275                                      const SMDS_MeshNode * n14,
00276                                      const SMDS_MeshNode * n24,
00277                                      const SMDS_MeshNode * n34);
00278 
00279   // 2d order pyramid of 13 nodes
00280   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int n5,
00281                                            int n12,int n23,int n34,int n41,
00282                                            int n15,int n25,int n35,int n45,
00283                                            int ID);
00284   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
00285                                            const SMDS_MeshNode * n2,
00286                                            const SMDS_MeshNode * n3,
00287                                            const SMDS_MeshNode * n4,
00288                                            const SMDS_MeshNode * n5,
00289                                            const SMDS_MeshNode * n12,
00290                                            const SMDS_MeshNode * n23,
00291                                            const SMDS_MeshNode * n34,
00292                                            const SMDS_MeshNode * n41,
00293                                            const SMDS_MeshNode * n15,
00294                                            const SMDS_MeshNode * n25,
00295                                            const SMDS_MeshNode * n35,
00296                                            const SMDS_MeshNode * n45,
00297                                            int ID);
00298   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
00299                                      const SMDS_MeshNode * n2,
00300                                      const SMDS_MeshNode * n3,
00301                                      const SMDS_MeshNode * n4,
00302                                      const SMDS_MeshNode * n5,
00303                                      const SMDS_MeshNode * n12,
00304                                      const SMDS_MeshNode * n23,
00305                                      const SMDS_MeshNode * n34,
00306                                      const SMDS_MeshNode * n41,
00307                                      const SMDS_MeshNode * n15,
00308                                      const SMDS_MeshNode * n25,
00309                                      const SMDS_MeshNode * n35,
00310                                      const SMDS_MeshNode * n45);
00311 
00312   // 2d order Pentahedron with 15 nodes
00313   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3,
00314                                            int n4, int n5, int n6,
00315                                            int n12,int n23,int n31,
00316                                            int n45,int n56,int n64,
00317                                            int n14,int n25,int n36,
00318                                            int ID);
00319   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
00320                                            const SMDS_MeshNode * n2,
00321                                            const SMDS_MeshNode * n3,
00322                                            const SMDS_MeshNode * n4,
00323                                            const SMDS_MeshNode * n5,
00324                                            const SMDS_MeshNode * n6,
00325                                            const SMDS_MeshNode * n12,
00326                                            const SMDS_MeshNode * n23,
00327                                            const SMDS_MeshNode * n31,
00328                                            const SMDS_MeshNode * n45,
00329                                            const SMDS_MeshNode * n56,
00330                                            const SMDS_MeshNode * n64,
00331                                            const SMDS_MeshNode * n14,
00332                                            const SMDS_MeshNode * n25,
00333                                            const SMDS_MeshNode * n36,
00334                                            int ID);
00335   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
00336                                      const SMDS_MeshNode * n2,
00337                                      const SMDS_MeshNode * n3,
00338                                      const SMDS_MeshNode * n4,
00339                                      const SMDS_MeshNode * n5,
00340                                      const SMDS_MeshNode * n6,
00341                                      const SMDS_MeshNode * n12,
00342                                      const SMDS_MeshNode * n23,
00343                                      const SMDS_MeshNode * n31,
00344                                      const SMDS_MeshNode * n45,
00345                                      const SMDS_MeshNode * n56,
00346                                      const SMDS_MeshNode * n64,
00347                                      const SMDS_MeshNode * n14,
00348                                      const SMDS_MeshNode * n25,
00349                                      const SMDS_MeshNode * n36);
00350 
00351   // 2d oreder Hexahedrons with 20 nodes
00352   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
00353                                            int n5, int n6, int n7, int n8,
00354                                            int n12,int n23,int n34,int n41,
00355                                            int n56,int n67,int n78,int n85,
00356                                            int n15,int n26,int n37,int n48,
00357                                            int ID);
00358   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
00359                                            const SMDS_MeshNode * n2,
00360                                            const SMDS_MeshNode * n3,
00361                                            const SMDS_MeshNode * n4,
00362                                            const SMDS_MeshNode * n5,
00363                                            const SMDS_MeshNode * n6,
00364                                            const SMDS_MeshNode * n7,
00365                                            const SMDS_MeshNode * n8,
00366                                            const SMDS_MeshNode * n12,
00367                                            const SMDS_MeshNode * n23,
00368                                            const SMDS_MeshNode * n34,
00369                                            const SMDS_MeshNode * n41,
00370                                            const SMDS_MeshNode * n56,
00371                                            const SMDS_MeshNode * n67,
00372                                            const SMDS_MeshNode * n78,
00373                                            const SMDS_MeshNode * n85,
00374                                            const SMDS_MeshNode * n15,
00375                                            const SMDS_MeshNode * n26,
00376                                            const SMDS_MeshNode * n37,
00377                                            const SMDS_MeshNode * n48,
00378                                            int ID);
00379   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
00380                                      const SMDS_MeshNode * n2,
00381                                      const SMDS_MeshNode * n3,
00382                                      const SMDS_MeshNode * n4,
00383                                      const SMDS_MeshNode * n5,
00384                                      const SMDS_MeshNode * n6,
00385                                      const SMDS_MeshNode * n7,
00386                                      const SMDS_MeshNode * n8,
00387                                      const SMDS_MeshNode * n12,
00388                                      const SMDS_MeshNode * n23,
00389                                      const SMDS_MeshNode * n34,
00390                                      const SMDS_MeshNode * n41,
00391                                      const SMDS_MeshNode * n56,
00392                                      const SMDS_MeshNode * n67,
00393                                      const SMDS_MeshNode * n78,
00394                                      const SMDS_MeshNode * n85,
00395                                      const SMDS_MeshNode * n15,
00396                                      const SMDS_MeshNode * n26,
00397                                      const SMDS_MeshNode * n37,
00398                                      const SMDS_MeshNode * n48);
00399 
00400   virtual SMDS_MeshFace* AddPolygonalFaceWithID (std::vector<int> nodes_ids,
00401                                                  const int        ID);
00402 
00403   virtual SMDS_MeshFace* AddPolygonalFaceWithID (std::vector<const SMDS_MeshNode*> nodes,
00404                                                  const int                         ID);
00405 
00406   virtual SMDS_MeshFace* AddPolygonalFace (std::vector<const SMDS_MeshNode*> nodes);
00407 
00408   virtual SMDS_MeshVolume* AddPolyhedralVolumeWithID
00409                            (std::vector<int> nodes_ids,
00410                             std::vector<int> quantities,
00411                             const int        ID);
00412 
00413   virtual SMDS_MeshVolume* AddPolyhedralVolumeWithID
00414                            (std::vector<const SMDS_MeshNode*> nodes,
00415                             std::vector<int>                  quantities,
00416                             const int                         ID);
00417 
00418   virtual SMDS_MeshVolume* AddPolyhedralVolume
00419                            (std::vector<const SMDS_MeshNode*> nodes,
00420                             std::vector<int>                  quantities);
00421 
00422   virtual void RemoveElement(const SMDS_MeshElement *        elem,
00423                              std::list<const SMDS_MeshElement *>& removedElems,
00424                              std::list<const SMDS_MeshElement *>& removedNodes,
00425                              bool                                 removenodes = false);
00426   virtual void RemoveElement(const SMDS_MeshElement * elem, bool removenodes = false);
00427   virtual void RemoveNode(const SMDS_MeshNode * node);
00428   virtual void Remove0DElement(const SMDS_Mesh0DElement * elem0d);
00429   virtual void RemoveEdge(const SMDS_MeshEdge * edge);
00430   virtual void RemoveFace(const SMDS_MeshFace * face);
00431   virtual void RemoveVolume(const SMDS_MeshVolume * volume);
00432 
00437   virtual void RemoveFreeElement(const SMDS_MeshElement * elem);
00438 
00439   virtual void Clear();
00440 
00441   virtual bool RemoveFromParent();
00442   virtual bool RemoveSubMesh(const SMDS_Mesh * aMesh);
00443 
00444   bool ChangeElementNodes(const SMDS_MeshElement * elem,
00445                           const SMDS_MeshNode    * nodes[],
00446                           const int                nbnodes);
00447   bool ChangePolyhedronNodes(const SMDS_MeshElement *                 elem,
00448                              const std::vector<const SMDS_MeshNode*>& nodes,
00449                              const std::vector<int> &                 quantities);
00450 
00451   virtual void Renumber (const bool isNodes, const int startID = 1, const int deltaID = 1);
00452   // Renumber all nodes or elements.
00453 
00454   const SMDS_MeshNode *FindNode(int idnode) const;
00455   const SMDS_Mesh0DElement* Find0DElement(int idnode) const;
00456   const SMDS_MeshEdge *FindEdge(int idnode1, int idnode2) const;
00457   const SMDS_MeshEdge *FindEdge(int idnode1, int idnode2, int idnode3) const;
00458   const SMDS_MeshFace *FindFace(int idnode1, int idnode2, int idnode3) const;
00459   const SMDS_MeshFace *FindFace(int idnode1, int idnode2, int idnode3, int idnode4) const;
00460   const SMDS_MeshFace *FindFace(int idnode1, int idnode2, int idnode3,
00461                                 int idnode4, int idnode5, int idnode6) const;
00462   const SMDS_MeshFace *FindFace(int idnode1, int idnode2, int idnode3, int idnode4,
00463                                 int idnode5, int idnode6, int idnode7, int idnode8) const;
00464   const SMDS_MeshElement *FindElement(int IDelem) const;
00465   static const SMDS_Mesh0DElement* Find0DElement(const SMDS_MeshNode * n);
00466   static const SMDS_MeshEdge* FindEdge(const SMDS_MeshNode * n1,
00467                                        const SMDS_MeshNode * n2);
00468   static const SMDS_MeshEdge* FindEdge(const SMDS_MeshNode * n1,
00469                                        const SMDS_MeshNode * n2,
00470                                        const SMDS_MeshNode * n3);
00471   static const SMDS_MeshFace* FindFace(const SMDS_MeshNode *n1,
00472                                        const SMDS_MeshNode *n2,
00473                                        const SMDS_MeshNode *n3);
00474   static const SMDS_MeshFace* FindFace(const SMDS_MeshNode *n1,
00475                                        const SMDS_MeshNode *n2,
00476                                        const SMDS_MeshNode *n3,
00477                                        const SMDS_MeshNode *n4);
00478   static const SMDS_MeshFace* FindFace(const SMDS_MeshNode *n1,
00479                                        const SMDS_MeshNode *n2,
00480                                        const SMDS_MeshNode *n3,
00481                                        const SMDS_MeshNode *n4,
00482                                        const SMDS_MeshNode *n5,
00483                                        const SMDS_MeshNode *n6);
00484   static const SMDS_MeshFace* FindFace(const SMDS_MeshNode *n1,
00485                                        const SMDS_MeshNode *n2,
00486                                        const SMDS_MeshNode *n3,
00487                                        const SMDS_MeshNode *n4,
00488                                        const SMDS_MeshNode *n5,
00489                                        const SMDS_MeshNode *n6,
00490                                        const SMDS_MeshNode *n7,
00491                                        const SMDS_MeshNode *n8);
00492 
00493   const SMDS_MeshFace *FindFace(std::vector<int> nodes_ids) const;
00494   static const SMDS_MeshFace* FindFace(std::vector<const SMDS_MeshNode *> nodes);
00495 
00501   static int CheckMemory(const bool doNotRaise=false) throw (std::bad_alloc);
00502 
00503   int MaxNodeID() const;
00504   int MinNodeID() const;
00505   int MaxElementID() const;
00506   int MinElementID() const;
00507 
00508   const SMDS_MeshInfo& GetMeshInfo() const { return myInfo; }
00509 
00510   int NbNodes() const;
00511   int Nb0DElements() const;
00512   int NbEdges() const;
00513   int NbFaces() const;
00514   int NbVolumes() const;
00515   int NbSubMesh() const;
00516   void DumpNodes() const;
00517   void Dump0DElements() const;
00518   void DumpEdges() const;
00519   void DumpFaces() const;
00520   void DumpVolumes() const;
00521   void DebugStats() const;
00522   SMDS_Mesh *boundaryFaces();
00523   SMDS_Mesh *boundaryEdges();
00524   virtual ~SMDS_Mesh();
00525   bool hasConstructionEdges();
00526   bool hasConstructionFaces();
00527   bool hasInverseElements();
00528   void setConstructionEdges(bool);
00529   void setConstructionFaces(bool);
00530   void setInverseElements(bool);
00531 
00538   bool Contains (const SMDS_MeshElement* elem) const;
00539 
00540   typedef NCollection_Map<SMDS_MeshNode *> SetOfNodes;
00541   typedef NCollection_Map<SMDS_Mesh0DElement *> SetOf0DElements;
00542   typedef NCollection_Map<SMDS_MeshEdge *> SetOfEdges;
00543   typedef NCollection_Map<SMDS_MeshFace *> SetOfFaces;
00544   typedef NCollection_Map<SMDS_MeshVolume *> SetOfVolumes;
00545 
00546 private:
00547   SMDS_Mesh(SMDS_Mesh * parent);
00548 
00549   SMDS_MeshFace * createTriangle(const SMDS_MeshNode * node1,
00550                                  const SMDS_MeshNode * node2,
00551                                  const SMDS_MeshNode * node3);
00552   SMDS_MeshFace * createQuadrangle(const SMDS_MeshNode * node1,
00553                                    const SMDS_MeshNode * node2,
00554                                    const SMDS_MeshNode * node3,
00555                                    const SMDS_MeshNode * node4);
00556   SMDS_Mesh0DElement* Find0DElementOrCreate(const SMDS_MeshNode * n);
00557   SMDS_MeshEdge* FindEdgeOrCreate(const SMDS_MeshNode * n1,
00558                                   const SMDS_MeshNode * n2);
00559   SMDS_MeshFace* FindFaceOrCreate(const SMDS_MeshNode *n1,
00560                                   const SMDS_MeshNode *n2,
00561                                   const SMDS_MeshNode *n3);
00562   SMDS_MeshFace* FindFaceOrCreate(const SMDS_MeshNode *n1,
00563                                   const SMDS_MeshNode *n2,
00564                                   const SMDS_MeshNode *n3,
00565                                   const SMDS_MeshNode *n4);
00566 
00567   bool registerElement(int ID, SMDS_MeshElement * element);
00568 
00569   void addChildrenWithNodes(std::set<const SMDS_MeshElement*>& setOfChildren,
00570                             const SMDS_MeshElement * element,
00571                             std::set<const SMDS_MeshElement*>& nodes);
00572 
00573   // Fields PRIVATE
00574 
00575   SetOfNodes             myNodes;
00576   SetOf0DElements        my0DElements;
00577   SetOfEdges             myEdges;
00578   SetOfFaces             myFaces;
00579   SetOfVolumes           myVolumes;
00580   SMDS_Mesh *            myParent;
00581   std::list<SMDS_Mesh *> myChildren;
00582   SMDS_MeshElementIDFactory *myNodeIDFactory;
00583   SMDS_MeshElementIDFactory *myElementIDFactory;
00584   SMDS_MeshInfo          myInfo;
00585 
00586   bool myHasConstructionEdges;
00587   bool myHasConstructionFaces;
00588   bool myHasInverseElements;
00589 };
00590 
00591 
00592 #endif