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_Iterator.hxx"
  36
  37 #include <boost/shared_ptr.hpp>
  38 #include <set>
  39 #include <list>
  40
  41 typedef SMDS_Iterator<const SMDS_MeshNode *> SMDS_NodeIterator;
  42 typedef boost::shared_ptr<SMDS_Iterator<const SMDS_MeshNode *> > SMDS_NodeIteratorPtr;
  43 typedef SMDS_Iterator<const SMDS_MeshEdge *> SMDS_EdgeIterator;
  44 typedef boost::shared_ptr<SMDS_Iterator<const SMDS_MeshEdge *> > SMDS_EdgeIteratorPtr;
  45 typedef SMDS_Iterator<const SMDS_MeshFace *> SMDS_FaceIterator;
  46 typedef boost::shared_ptr<SMDS_Iterator<const SMDS_MeshFace *> > SMDS_FaceIteratorPtr;
  47 typedef SMDS_Iterator<const SMDS_MeshVolume *> SMDS_VolumeIterator;
  48 typedef boost::shared_ptr<SMDS_Iterator<const SMDS_MeshVolume *> > SMDS_VolumeIteratorPtr;
  49
  50 class SMDS_Mesh:public SMDS_MeshObject{
  51 public:
  52
  53   SMDS_Mesh();
  54
  55   SMDS_NodeIteratorPtr nodesIterator() const;
  56   SMDS_EdgeIteratorPtr edgesIterator() const;
  57   SMDS_FaceIteratorPtr facesIterator() const;
  58   SMDS_VolumeIteratorPtr volumesIterator() const;
  59   SMDS_ElemIteratorPtr elementsIterator() const;
  60
  61   SMDS_Mesh *AddSubMesh();
  62
  63   virtual SMDS_MeshNode* AddNodeWithID(double x, double y, double z, int ID);
  64   virtual SMDS_MeshNode* AddNode(double x, double y, double z);
  65
  66   virtual SMDS_MeshEdge* AddEdgeWithID(int n1, int n2, int ID);
  67   virtual SMDS_MeshEdge* AddEdgeWithID(const SMDS_MeshNode * n1,
  68                                        const SMDS_MeshNode * n2,
  69                                        int ID);
  70   virtual SMDS_MeshEdge* AddEdge(const SMDS_MeshNode * n1,
  71                                  const SMDS_MeshNode * n2);
  72
  73   virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3, int ID);
  74   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
  75                                        const SMDS_MeshNode * n2,
  76                                        const SMDS_MeshNode * n3,
  77                                        int ID);
  78   virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
  79                                  const SMDS_MeshNode * n2,
  80                                  const SMDS_MeshNode * n3);
  81
  82   virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3, int n4, int ID);
  83   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
  84                                        const SMDS_MeshNode * n2,
  85                                        const SMDS_MeshNode * n3,
  86                                        const SMDS_MeshNode * n4,
  87                                        int ID);
  88   virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
  89                                  const SMDS_MeshNode * n2,
  90                                  const SMDS_MeshNode * n3,
  91                                  const SMDS_MeshNode * n4);
  92
  93   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshEdge * e1,
  94                                        const SMDS_MeshEdge * e2,
  95                                        const SMDS_MeshEdge * e3, int ID);
  96   virtual SMDS_MeshFace* AddFace(const SMDS_MeshEdge * e1,
  97                                  const SMDS_MeshEdge * e2,
  98                                  const SMDS_MeshEdge * e3);
  99
 100   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshEdge * e1,
 101                                        const SMDS_MeshEdge * e2,
 102                                        const SMDS_MeshEdge * e3,
 103                                        const SMDS_MeshEdge * e4, int ID);
 104   virtual SMDS_MeshFace* AddFace(const SMDS_MeshEdge * e1,
 105                                  const SMDS_MeshEdge * e2,
 106                                  const SMDS_MeshEdge * e3,
 107                                  const SMDS_MeshEdge * e4);
 108
 109   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int ID);
 110   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 111                                            const SMDS_MeshNode * n2,
 112                                            const SMDS_MeshNode * n3,
 113                                            const SMDS_MeshNode * n4,
 114                                            int ID);
 115   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 116                                      const SMDS_MeshNode * n2,
 117                                      const SMDS_MeshNode * n3,
 118                                      const SMDS_MeshNode * n4);
 119
 120   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
 121                                            int n5, int ID);
 122   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 123                                            const SMDS_MeshNode * n2,
 124                                            const SMDS_MeshNode * n3,
 125                                            const SMDS_MeshNode * n4,
 126                                            const SMDS_MeshNode * n5,
 127                                            int ID);
 128   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 129                                      const SMDS_MeshNode * n2,
 130                                      const SMDS_MeshNode * n3,
 131                                      const SMDS_MeshNode * n4,
 132                                      const SMDS_MeshNode * n5);
 133
 134   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
 135                                            int n5, int n6, 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                                            const SMDS_MeshNode * n6,
 142                                            int ID);
 143   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 144                                      const SMDS_MeshNode * n2,
 145                                      const SMDS_MeshNode * n3,
 146                                      const SMDS_MeshNode * n4,
 147                                      const SMDS_MeshNode * n5,
 148                                      const SMDS_MeshNode * n6);
 149
 150   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
 151                                            int n5, int n6, int n7, int n8, int ID);
 152   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
 153                                            const SMDS_MeshNode * n2,
 154                                            const SMDS_MeshNode * n3,
 155                                            const SMDS_MeshNode * n4,
 156                                            const SMDS_MeshNode * n5,
 157                                            const SMDS_MeshNode * n6,
 158                                            const SMDS_MeshNode * n7,
 159                                            const SMDS_MeshNode * n8,
 160                                            int ID);
 161   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
 162                                      const SMDS_MeshNode * n2,
 163                                      const SMDS_MeshNode * n3,
 164                                      const SMDS_MeshNode * n4,
 165                                      const SMDS_MeshNode * n5,
 166                                      const SMDS_MeshNode * n6,
 167                                      const SMDS_MeshNode * n7,
 168                                      const SMDS_MeshNode * n8);
 169
 170   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshFace * f1,
 171                                            const SMDS_MeshFace * f2,
 172                                            const SMDS_MeshFace * f3,
 173                                            const SMDS_MeshFace * f4, int ID);
 174   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshFace * f1,
 175                                      const SMDS_MeshFace * f2,
 176                                      const SMDS_MeshFace * f3,
 177                                      const SMDS_MeshFace * f4);
 178
 179   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshFace * f1,
 180                                            const SMDS_MeshFace * f2,
 181                                            const SMDS_MeshFace * f3,
 182                                            const SMDS_MeshFace * f4,
 183                                            const SMDS_MeshFace * f5, int ID);
 184   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshFace * f1,
 185                                      const SMDS_MeshFace * f2,
 186                                      const SMDS_MeshFace * f3,
 187                                      const SMDS_MeshFace * f4,
 188                                      const SMDS_MeshFace * f5);
 189
 190   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshFace * f1,
 191                                            const SMDS_MeshFace * f2,
 192                                            const SMDS_MeshFace * f3,
 193                                            const SMDS_MeshFace * f4,
 194                                            const SMDS_MeshFace * f5,
 195                                            const SMDS_MeshFace * f6, int ID);
 196   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshFace * f1,
 197                                      const SMDS_MeshFace * f2,
 198                                      const SMDS_MeshFace * f3,
 199                                      const SMDS_MeshFace * f4,
 200                                      const SMDS_MeshFace * f5,
 201                                      const SMDS_MeshFace * f6);
 202
 203   virtual void RemoveElement(const SMDS_MeshElement *        elem,
 204                              std::list<const SMDS_MeshElement *>& removedElems,
 205                              std::list<const SMDS_MeshElement *>& removedNodes,
 206                              const bool                      removenodes = false);
 207   virtual void RemoveElement(const SMDS_MeshElement * elem, bool removenodes = false);
 208   virtual void RemoveNode(const SMDS_MeshNode * node);
 209   virtual void RemoveEdge(const SMDS_MeshEdge * edge);
 210   virtual void RemoveFace(const SMDS_MeshFace * face);
 211   virtual void RemoveVolume(const SMDS_MeshVolume * volume);
 212
 213   virtual bool RemoveFromParent();
 214   virtual bool RemoveSubMesh(const SMDS_Mesh * aMesh);
 215
 216   static bool ChangeElementNodes(const SMDS_MeshElement * elem,
 217                                  const SMDS_MeshNode    * nodes[],
 218                                  const int                nbnodes);
 219
 220   virtual void Renumber (const bool isNodes, const int startID = 1, const int deltaID = 1);
 221   // Renumber all nodes or elements.
 222
 223   const SMDS_MeshNode *FindNode(int idnode) const;
 224   const SMDS_MeshEdge *FindEdge(int idnode1, int idnode2) const;
 225   const SMDS_MeshFace *FindFace(int idnode1, int idnode2, int idnode3) const;
 226   const SMDS_MeshFace *FindFace(int idnode1, int idnode2, int idnode3, int idnode4) const;
 227   const SMDS_MeshElement *FindElement(int IDelem) const;
 228   static const SMDS_MeshEdge* FindEdge(const SMDS_MeshNode * n1,
 229                                        const SMDS_MeshNode * n2);
 230   static const SMDS_MeshFace* FindFace(const SMDS_MeshNode *n1,
 231                                        const SMDS_MeshNode *n2,
 232                                        const SMDS_MeshNode *n3);
 233   static const SMDS_MeshFace* FindFace(const SMDS_MeshNode *n1,
 234                                        const SMDS_MeshNode *n2,
 235                                        const SMDS_MeshNode *n3,
 236                                        const SMDS_MeshNode *n4);
 237   int MaxNodeID() const;
 238   int MinNodeID() const;
 239   int MaxElementID() const;
 240   int MinElementID() const;
 241
 242
 243   int NbNodes() const;
 244   int NbEdges() const;
 245   int NbFaces() const;
 246   int NbVolumes() const;
 247   int NbSubMesh() const;
 248   void DumpNodes() const;
 249   void DumpEdges() const;
 250   void DumpFaces() const;
 251   void DumpVolumes() const;
 252   void DebugStats() const;
 253   SMDS_Mesh *boundaryFaces();
 254   SMDS_Mesh *boundaryEdges();
 255   virtual ~SMDS_Mesh();
 256   bool hasConstructionEdges();
 257   bool hasConstructionFaces();
 258   bool hasInverseElements();
 259   void setConstructionEdges(bool);
 260   void setConstructionFaces(bool);
 261   void setInverseElements(bool);
 262
 263   /*!
 264    * Checks if the element is present in mesh.
 265    * Useful to determine dead pointers.
 266    * Use this function for debug purpose only! Do not check in the code
 267    * using it even in _DEBUG_ mode
 268    */
 269   bool Contains (const SMDS_MeshElement* elem) const;
 270
 271   typedef std::set<SMDS_MeshNode *> SetOfNodes;
 272   typedef std::set<SMDS_MeshEdge *> SetOfEdges;
 273   typedef std::set<SMDS_MeshFace *> SetOfFaces;
 274   typedef std::set<SMDS_MeshVolume *> SetOfVolumes;
 275
 276 private:
 277   SMDS_Mesh(SMDS_Mesh * parent);
 278
 279   SMDS_MeshFace * createTriangle(const SMDS_MeshNode * node1,
 280                                  const SMDS_MeshNode * node2,
 281                                  const SMDS_MeshNode * node3);
 282   SMDS_MeshFace * createQuadrangle(const SMDS_MeshNode * node1,
 283                                    const SMDS_MeshNode * node2,
 284                                    const SMDS_MeshNode * node3,
 285                                    const SMDS_MeshNode * node4);
 286   SMDS_MeshEdge* FindEdgeOrCreate(const SMDS_MeshNode * n1,
 287                                   const SMDS_MeshNode * n2);
 288   SMDS_MeshFace* FindFaceOrCreate(const SMDS_MeshNode *n1,
 289                                   const SMDS_MeshNode *n2,
 290                                   const SMDS_MeshNode *n3);
 291   SMDS_MeshFace* FindFaceOrCreate(const SMDS_MeshNode *n1,
 292                                   const SMDS_MeshNode *n2,
 293                                   const SMDS_MeshNode *n3,
 294                                   const SMDS_MeshNode *n4);
 295
 296   bool registerElement(int ID, SMDS_MeshElement * element);
 297
 298   void addChildrenWithNodes(std::set<const SMDS_MeshElement*>& setOfChildren,
 299                             const SMDS_MeshElement * element,
 300                             std::set<const SMDS_MeshElement*>& nodes);
 301
 302   // Fields PRIVATE
 303
 304   SetOfNodes myNodes;
 305   SetOfEdges myEdges;
 306   SetOfFaces myFaces;
 307   SetOfVolumes myVolumes;
 308   SMDS_Mesh *myParent;
 309   std::list<SMDS_Mesh *> myChildren;
 310   SMDS_MeshElementIDFactory *myNodeIDFactory;
 311   SMDS_MeshElementIDFactory *myElementIDFactory;
 312
 313   bool myHasConstructionEdges;
 314   bool myHasConstructionFaces;
 315   bool myHasInverseElements;
 316 };
 317
 318
 319 #endif