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   virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3, int ID);
  88   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
  89                                        const SMDS_MeshNode * n2,
  90                                        const SMDS_MeshNode * n3,
  91                                        int ID);
  92   virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
  93                                  const SMDS_MeshNode * n2,
  94                                  const SMDS_MeshNode * n3);
  95
  96   virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3, int n4, int ID);
  97   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
  98                                        const SMDS_MeshNode * n2,
  99                                        const SMDS_MeshNode * n3,
 100                                        const SMDS_MeshNode * n4,
 101                                        int ID);
 102   virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
 103                                  const SMDS_MeshNode * n2,
 104                                  const SMDS_MeshNode * n3,
 105                                  const SMDS_MeshNode * n4);
 106
 107   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshEdge * e1,
 108                                        const SMDS_MeshEdge * e2,
 109                                        const SMDS_MeshEdge * e3, int ID);
 110   virtual SMDS_MeshFace* AddFace(const SMDS_MeshEdge * e1,
 111                                  const SMDS_MeshEdge * e2,
 112                                  const SMDS_MeshEdge * e3);
 113
 114   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshEdge * e1,
 115                                        const SMDS_MeshEdge * e2,
 116                                        const SMDS_MeshEdge * e3,
 117                                        const SMDS_MeshEdge * e4, int ID);
 118   virtual SMDS_MeshFace* AddFace(const SMDS_MeshEdge * e1,
 119                                  const SMDS_MeshEdge * e2,
 120                                  const SMDS_MeshEdge * e3,
 121                                  const SMDS_MeshEdge * e4);
 122
 123   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int ID);
 124   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 125                                            const SMDS_MeshNode * n2,
 126                                            const SMDS_MeshNode * n3,
 127                                            const SMDS_MeshNode * n4,
 128                                            int ID);
 129   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 130                                      const SMDS_MeshNode * n2,
 131                                      const SMDS_MeshNode * n3,
 132                                      const SMDS_MeshNode * n4);
 133
 134   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
 135                                            int n5, int ID);
 136   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 137                                            const SMDS_MeshNode * n2,
 138                                            const SMDS_MeshNode * n3,
 139                                            const SMDS_MeshNode * n4,
 140                                            const SMDS_MeshNode * n5,
 141                                            int ID);
 142   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 143                                      const SMDS_MeshNode * n2,
 144                                      const SMDS_MeshNode * n3,
 145                                      const SMDS_MeshNode * n4,
 146                                      const SMDS_MeshNode * n5);
 147
 148   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
 149                                            int n5, int n6, int ID);
 150   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 151                                            const SMDS_MeshNode * n2,
 152                                            const SMDS_MeshNode * n3,
 153                                            const SMDS_MeshNode * n4,
 154                                            const SMDS_MeshNode * n5,
 155                                            const SMDS_MeshNode * n6,
 156                                            int ID);
 157   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 158                                      const SMDS_MeshNode * n2,
 159                                      const SMDS_MeshNode * n3,
 160                                      const SMDS_MeshNode * n4,
 161                                      const SMDS_MeshNode * n5,
 162                                      const SMDS_MeshNode * n6);
 163
 164   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
 165                                            int n5, int n6, int n7, int n8, int ID);
 166   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 167                                            const SMDS_MeshNode * n2,
 168                                            const SMDS_MeshNode * n3,
 169                                            const SMDS_MeshNode * n4,
 170                                            const SMDS_MeshNode * n5,
 171                                            const SMDS_MeshNode * n6,
 172                                            const SMDS_MeshNode * n7,
 173                                            const SMDS_MeshNode * n8,
 174                                            int ID);
 175   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 176                                      const SMDS_MeshNode * n2,
 177                                      const SMDS_MeshNode * n3,
 178                                      const SMDS_MeshNode * n4,
 179                                      const SMDS_MeshNode * n5,
 180                                      const SMDS_MeshNode * n6,
 181                                      const SMDS_MeshNode * n7,
 182                                      const SMDS_MeshNode * n8);
 183
 184   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshFace * f1,
 185                                            const SMDS_MeshFace * f2,
 186                                            const SMDS_MeshFace * f3,
 187                                            const SMDS_MeshFace * f4, int ID);
 188   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshFace * f1,
 189                                      const SMDS_MeshFace * f2,
 190                                      const SMDS_MeshFace * f3,
 191                                      const SMDS_MeshFace * f4);
 192
 193   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshFace * f1,
 194                                            const SMDS_MeshFace * f2,
 195                                            const SMDS_MeshFace * f3,
 196                                            const SMDS_MeshFace * f4,
 197                                            const SMDS_MeshFace * f5, int ID);
 198   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshFace * f1,
 199                                      const SMDS_MeshFace * f2,
 200                                      const SMDS_MeshFace * f3,
 201                                      const SMDS_MeshFace * f4,
 202                                      const SMDS_MeshFace * f5);
 203
 204   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshFace * f1,
 205                                            const SMDS_MeshFace * f2,
 206                                            const SMDS_MeshFace * f3,
 207                                            const SMDS_MeshFace * f4,
 208                                            const SMDS_MeshFace * f5,
 209                                            const SMDS_MeshFace * f6, int ID);
 210   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshFace * f1,
 211                                      const SMDS_MeshFace * f2,
 212                                      const SMDS_MeshFace * f3,
 213                                      const SMDS_MeshFace * f4,
 214                                      const SMDS_MeshFace * f5,
 215                                      const SMDS_MeshFace * f6);
 216
 217   virtual SMDS_MeshFace* AddPolygonalFaceWithID (std::vector<int> nodes_ids,
 218                                                  const int        ID);
 219
 220   virtual SMDS_MeshFace* AddPolygonalFaceWithID (std::vector<const SMDS_MeshNode*> nodes,
 221                                                  const int                         ID);
 222
 223   virtual SMDS_MeshFace* AddPolygonalFace (std::vector<const SMDS_MeshNode*> nodes);
 224
 225   virtual SMDS_MeshVolume* AddPolyhedralVolumeWithID
 226                            (std::vector<int> nodes_ids,
 227                             std::vector<int> quantities,
 228                             const int        ID);
 229
 230   virtual SMDS_MeshVolume* AddPolyhedralVolumeWithID
 231                            (std::vector<const SMDS_MeshNode*> nodes,
 232                             std::vector<int>                  quantities,
 233                             const int                         ID);
 234
 235   virtual SMDS_MeshVolume* AddPolyhedralVolume
 236                            (std::vector<const SMDS_MeshNode*> nodes,
 237                             std::vector<int>                  quantities);
 238
 239   virtual void RemoveElement(const SMDS_MeshElement *        elem,
 240                              std::list<const SMDS_MeshElement *>& removedElems,
 241                              std::list<const SMDS_MeshElement *>& removedNodes,
 242                              const bool                      removenodes = false);
 243   virtual void RemoveElement(const SMDS_MeshElement * elem, bool removenodes = false);
 244   virtual void RemoveNode(const SMDS_MeshNode * node);
 245   virtual void RemoveEdge(const SMDS_MeshEdge * edge);
 246   virtual void RemoveFace(const SMDS_MeshFace * face);
 247   virtual void RemoveVolume(const SMDS_MeshVolume * volume);
 248
 249   virtual bool RemoveFromParent();
 250   virtual bool RemoveSubMesh(const SMDS_Mesh * aMesh);
 251
 252   static bool ChangeElementNodes(const SMDS_MeshElement * elem,
 253                                  const SMDS_MeshNode    * nodes[],
 254                                  const int                nbnodes);
 255   static bool ChangePolyhedronNodes(const SMDS_MeshElement * elem,
 256                                     std::vector<const SMDS_MeshNode*> nodes,
 257                                     std::vector<int>                  quantities);
 258
 259   virtual void Renumber (const bool isNodes, const int startID = 1, const int deltaID = 1);
 260   // Renumber all nodes or elements.
 261
 262   const SMDS_MeshNode *FindNode(int idnode) const;
 263   const SMDS_MeshEdge *FindEdge(int idnode1, int idnode2) const;
 264   const SMDS_MeshFace *FindFace(int idnode1, int idnode2, int idnode3) const;
 265   const SMDS_MeshFace *FindFace(int idnode1, int idnode2, int idnode3, int idnode4) const;
 266   const SMDS_MeshElement *FindElement(int IDelem) const;
 267   static const SMDS_MeshEdge* FindEdge(const SMDS_MeshNode * n1,
 268                                        const SMDS_MeshNode * n2);
 269   static const SMDS_MeshFace* FindFace(const SMDS_MeshNode *n1,
 270                                        const SMDS_MeshNode *n2,
 271                                        const SMDS_MeshNode *n3);
 272   static const SMDS_MeshFace* FindFace(const SMDS_MeshNode *n1,
 273                                        const SMDS_MeshNode *n2,
 274                                        const SMDS_MeshNode *n3,
 275                                        const SMDS_MeshNode *n4);
 276
 277   const SMDS_MeshFace *FindFace(std::vector<int> nodes_ids) const;
 278   static const SMDS_MeshFace* FindFace(std::vector<const SMDS_MeshNode *> nodes);
 279
 280   int MaxNodeID() const;
 281   int MinNodeID() const;
 282   int MaxElementID() const;
 283   int MinElementID() const;
 284
 285
 286   int NbNodes() const;
 287   int NbEdges() const;
 288   int NbFaces() const;
 289   int NbVolumes() const;
 290   int NbSubMesh() const;
 291   void DumpNodes() const;
 292   void DumpEdges() const;
 293   void DumpFaces() const;
 294   void DumpVolumes() const;
 295   void DebugStats() const;
 296   SMDS_Mesh *boundaryFaces();
 297   SMDS_Mesh *boundaryEdges();
 298   virtual ~SMDS_Mesh();
 299   bool hasConstructionEdges();
 300   bool hasConstructionFaces();
 301   bool hasInverseElements();
 302   void setConstructionEdges(bool);
 303   void setConstructionFaces(bool);
 304   void setInverseElements(bool);
 305
 306   /*!
 307    * Checks if the element is present in mesh.
 308    * Useful to determine dead pointers.
 309    * Use this function for debug purpose only! Do not check in the code
 310    * using it even in _DEBUG_ mode
 311    */
 312   bool Contains (const SMDS_MeshElement* elem) const;
 313
 314   typedef NCollection_Map<SMDS_MeshNode *> SetOfNodes;
 315   typedef NCollection_Map<SMDS_MeshEdge *> SetOfEdges;
 316   typedef NCollection_Map<SMDS_MeshFace *> SetOfFaces;
 317   typedef NCollection_Map<SMDS_MeshVolume *> SetOfVolumes;
 318
 319 private:
 320   SMDS_Mesh(SMDS_Mesh * parent);
 321
 322   SMDS_MeshFace * createTriangle(const SMDS_MeshNode * node1,
 323                                  const SMDS_MeshNode * node2,
 324                                  const SMDS_MeshNode * node3);
 325   SMDS_MeshFace * createQuadrangle(const SMDS_MeshNode * node1,
 326                                    const SMDS_MeshNode * node2,
 327                                    const SMDS_MeshNode * node3,
 328                                    const SMDS_MeshNode * node4);
 329   SMDS_MeshEdge* FindEdgeOrCreate(const SMDS_MeshNode * n1,
 330                                   const SMDS_MeshNode * n2);
 331   SMDS_MeshFace* FindFaceOrCreate(const SMDS_MeshNode *n1,
 332                                   const SMDS_MeshNode *n2,
 333                                   const SMDS_MeshNode *n3);
 334   SMDS_MeshFace* FindFaceOrCreate(const SMDS_MeshNode *n1,
 335                                   const SMDS_MeshNode *n2,
 336                                   const SMDS_MeshNode *n3,
 337                                   const SMDS_MeshNode *n4);
 338
 339   bool registerElement(int ID, SMDS_MeshElement * element);
 340
 341   void addChildrenWithNodes(std::set<const SMDS_MeshElement*>& setOfChildren,
 342                             const SMDS_MeshElement * element,
 343                             std::set<const SMDS_MeshElement*>& nodes);
 344
 345   // Fields PRIVATE
 346
 347   SetOfNodes myNodes;
 348   SetOfEdges myEdges;
 349   SetOfFaces myFaces;
 350   SetOfVolumes myVolumes;
 351   SMDS_Mesh *myParent;
 352   std::list<SMDS_Mesh *> myChildren;
 353   SMDS_MeshElementIDFactory *myNodeIDFactory;
 354   SMDS_MeshElementIDFactory *myElementIDFactory;
 355
 356   bool myHasConstructionEdges;
 357   bool myHasConstructionFaces;
 358   bool myHasInverseElements;
 359 };
 360
 361
 362 #endif