add quadratic element classes

diff --git a/src/SMDS/Makefile.in b/src/SMDS/Makefile.in
index e066e25e0bbb35d9cb600a6540e5f579f5f2d944..67c41b2031350a58d2f14f96d0caf54eaa12b572 100644 (file)
--- a/src/SMDS/Makefile.in
+++ b/src/SMDS/Makefile.in
@@ -59,7 +59,10 @@ LIB_SRC = \
        SMDS_FaceOfEdges.cxx \
        SMDS_FaceOfNodes.cxx \
        SMDS_PolygonalFaceOfNodes.cxx \
-       SMDS_VolumeTool.cxx
+       SMDS_VolumeTool.cxx \
+       SMDS_QuadraticEdge.cxx \
+       SMDS_QuadraticFaceOfNodes.cxx \
+       SMDS_QuadraticVolumeOfNodes.cxx
 #      SMDS_Tria3OfNodes.cxx \
 #      SMDS_HexahedronOfNodes.cxx
 
@@ -113,7 +116,10 @@ EXPORT_HEADERS= \
        SMDS_FaceOfEdges.hxx \
        SMDS_FaceOfNodes.hxx \
        SMDS_PolygonalFaceOfNodes.hxx \
-       SMDS_VolumeTool.hxx
+       SMDS_VolumeTool.hxx \
+       SMDS_QuadraticEdge.hxx \
+       SMDS_QuadraticFaceOfNodes.hxx \
+       SMDS_QuadraticVolumeOfNodes.hxx
 #      SMDS_Tria3OfNodes.hxx \
 #      SMDS_HexahedronOfNodes.hxx
 

diff --git a/src/SMDS/SMDS_Mesh.hxx b/src/SMDS/SMDS_Mesh.hxx
index 612082ce47ea78b9cf49bc4571e89459098be71d..7147ac801f9317317935a08b32daec0ed540adef 100644 (file)
--- a/src/SMDS/SMDS_Mesh.hxx
+++ b/src/SMDS/SMDS_Mesh.hxx
@@ -84,6 +84,16 @@ public:
   virtual SMDS_MeshEdge* AddEdge(const SMDS_MeshNode * n1,
                                 const SMDS_MeshNode * n2);
   
+  // 2d order edge with 3 nodes: n12 - node between n1 and n2
+  virtual SMDS_MeshEdge* AddEdgeWithID(int n1, int n2, int n12, int ID);
+  virtual SMDS_MeshEdge* AddEdgeWithID(const SMDS_MeshNode * n1,
+                                      const SMDS_MeshNode * n2, 
+                                      const SMDS_MeshNode * n12, 
+                                      int ID);
+  virtual SMDS_MeshEdge* AddEdge(const SMDS_MeshNode * n1,
+                                 const SMDS_MeshNode * n2,
+                                 const SMDS_MeshNode * n12);
+
   virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3, int ID);
   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
                                       const SMDS_MeshNode * n2,
@@ -120,6 +130,44 @@ public:
                                  const SMDS_MeshEdge * e3,
                                  const SMDS_MeshEdge * e4);
 
+  // 2d order triangle of 6 nodes
+  virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3,
+                                       int n12,int n23,int n31, int ID);
+  virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
+                                      const SMDS_MeshNode * n2,
+                                      const SMDS_MeshNode * n3, 
+                                      const SMDS_MeshNode * n12,
+                                      const SMDS_MeshNode * n23,
+                                      const SMDS_MeshNode * n31, 
+                                      int ID);
+  virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
+                                const SMDS_MeshNode * n2,
+                                const SMDS_MeshNode * n3,
+                                 const SMDS_MeshNode * n12,
+                                const SMDS_MeshNode * n23,
+                                const SMDS_MeshNode * n31);
+
+  // 2d order quadrangle
+  virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3, int n4,
+                                       int n12,int n23,int n34,int n41, int ID);
+  virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
+                                      const SMDS_MeshNode * n2,
+                                      const SMDS_MeshNode * n3,
+                                      const SMDS_MeshNode * n4, 
+                                      const SMDS_MeshNode * n12,
+                                      const SMDS_MeshNode * n23,
+                                      const SMDS_MeshNode * n34,
+                                      const SMDS_MeshNode * n41, 
+                                      int ID);
+  virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
+                                const SMDS_MeshNode * n2,
+                                const SMDS_MeshNode * n3,
+                                const SMDS_MeshNode * n4,
+                                 const SMDS_MeshNode * n12,
+                                const SMDS_MeshNode * n23,
+                                const SMDS_MeshNode * n34,
+                                const SMDS_MeshNode * n41);
+
   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int ID);
   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
                                           const SMDS_MeshNode * n2,
@@ -214,6 +262,153 @@ public:
                                      const SMDS_MeshFace * f5,
                                      const SMDS_MeshFace * f6);
 
+  // 2d order tetrahedron of 10 nodes
+  virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
+                                           int n12,int n23,int n31,
+                                           int n14,int n24,int n34, int ID);
+  virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
+                                          const SMDS_MeshNode * n2,
+                                          const SMDS_MeshNode * n3,
+                                          const SMDS_MeshNode * n4, 
+                                          const SMDS_MeshNode * n12,
+                                          const SMDS_MeshNode * n23,
+                                          const SMDS_MeshNode * n31,
+                                          const SMDS_MeshNode * n14, 
+                                          const SMDS_MeshNode * n23,
+                                          const SMDS_MeshNode * n34, 
+                                          int ID);
+  virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
+                                    const SMDS_MeshNode * n2,
+                                    const SMDS_MeshNode * n3,
+                                    const SMDS_MeshNode * n4,
+                                     const SMDS_MeshNode * n12,
+                                     const SMDS_MeshNode * n23,
+                                     const SMDS_MeshNode * n31,
+                                     const SMDS_MeshNode * n14, 
+                                     const SMDS_MeshNode * n23,
+                                     const SMDS_MeshNode * n34);
+
+  // 2d order pyramid of 13 nodes
+  virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int n5,
+                                           int n12,int n23,int n34,int n41,
+                                           int n15,int n25,int n35,int n45,
+                                           int ID);
+  virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
+                                          const SMDS_MeshNode * n2,
+                                          const SMDS_MeshNode * n3,
+                                          const SMDS_MeshNode * n4,
+                                          const SMDS_MeshNode * n5, 
+                                          const SMDS_MeshNode * n12,
+                                          const SMDS_MeshNode * n23,
+                                          const SMDS_MeshNode * n34,
+                                          const SMDS_MeshNode * n41, 
+                                          const SMDS_MeshNode * n15,
+                                          const SMDS_MeshNode * n25,
+                                          const SMDS_MeshNode * n35,
+                                          const SMDS_MeshNode * n45, 
+                                          int ID);
+  virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
+                                    const SMDS_MeshNode * n2,
+                                    const SMDS_MeshNode * n3,
+                                    const SMDS_MeshNode * n4,
+                                    const SMDS_MeshNode * n5,
+                                     const SMDS_MeshNode * n12,
+                                     const SMDS_MeshNode * n23,
+                                     const SMDS_MeshNode * n34,
+                                     const SMDS_MeshNode * n41, 
+                                     const SMDS_MeshNode * n15,
+                                     const SMDS_MeshNode * n25,
+                                     const SMDS_MeshNode * n35,
+                                     const SMDS_MeshNode * n45);
+
+  // 2d order Pentahedron with 15 nodes
+  virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3,
+                                           int n4, int n5, int n6,
+                                           int n12,int n23,int n31,
+                                           int n45,int n56,int n64,
+                                           int n14,int n25,int n36,
+                                           int ID);
+  virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
+                                          const SMDS_MeshNode * n2,
+                                          const SMDS_MeshNode * n3,
+                                          const SMDS_MeshNode * n4,
+                                          const SMDS_MeshNode * n5,
+                                          const SMDS_MeshNode * n6, 
+                                          const SMDS_MeshNode * n12,
+                                          const SMDS_MeshNode * n23,
+                                          const SMDS_MeshNode * n31, 
+                                          const SMDS_MeshNode * n45,
+                                          const SMDS_MeshNode * n56,
+                                          const SMDS_MeshNode * n64, 
+                                          const SMDS_MeshNode * n14,
+                                          const SMDS_MeshNode * n25,
+                                          const SMDS_MeshNode * n36, 
+                                          int ID);
+  virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
+                                    const SMDS_MeshNode * n2,
+                                    const SMDS_MeshNode * n3,
+                                    const SMDS_MeshNode * n4,
+                                    const SMDS_MeshNode * n5,
+                                    const SMDS_MeshNode * n6, 
+                                     const SMDS_MeshNode * n12,
+                                     const SMDS_MeshNode * n23,
+                                     const SMDS_MeshNode * n31, 
+                                     const SMDS_MeshNode * n45,
+                                     const SMDS_MeshNode * n56,
+                                     const SMDS_MeshNode * n64, 
+                                     const SMDS_MeshNode * n14,
+                                     const SMDS_MeshNode * n25,
+                                     const SMDS_MeshNode * n36);
+
+  // 2d oreder Hexahedrons with 20 nodes
+  virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
+                                           int n5, int n6, int n7, int n8,
+                                           int n12,int n23,int n34,int n41,
+                                           int n56,int n67,int n78,int n85,
+                                           int n15,int n26,int n37,int n48,
+                                           int ID);
+  virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
+                                          const SMDS_MeshNode * n2,
+                                          const SMDS_MeshNode * n3,
+                                          const SMDS_MeshNode * n4,
+                                          const SMDS_MeshNode * n5,
+                                          const SMDS_MeshNode * n6,
+                                          const SMDS_MeshNode * n7,
+                                          const SMDS_MeshNode * n8, 
+                                          const SMDS_MeshNode * n12,
+                                          const SMDS_MeshNode * n23,
+                                          const SMDS_MeshNode * n34,
+                                          const SMDS_MeshNode * n51, 
+                                          const SMDS_MeshNode * n56,
+                                          const SMDS_MeshNode * n67,
+                                          const SMDS_MeshNode * n78,
+                                          const SMDS_MeshNode * n85, 
+                                          const SMDS_MeshNode * n15,
+                                          const SMDS_MeshNode * n26,
+                                          const SMDS_MeshNode * n37,
+                                          const SMDS_MeshNode * n48, 
+                                          int ID);
+  virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
+                                    const SMDS_MeshNode * n2,
+                                    const SMDS_MeshNode * n3,
+                                    const SMDS_MeshNode * n4,
+                                    const SMDS_MeshNode * n5,
+                                    const SMDS_MeshNode * n6,
+                                    const SMDS_MeshNode * n7,
+                                    const SMDS_MeshNode * n8, 
+                                     const SMDS_MeshNode * n12,
+                                     const SMDS_MeshNode * n23,
+                                     const SMDS_MeshNode * n34,
+                                     const SMDS_MeshNode * n51, 
+                                     const SMDS_MeshNode * n56,
+                                     const SMDS_MeshNode * n67,
+                                     const SMDS_MeshNode * n78,
+                                     const SMDS_MeshNode * n85, 
+                                     const SMDS_MeshNode * n15,
+                                     const SMDS_MeshNode * n26,
+                                     const SMDS_MeshNode * n37,
+                                     const SMDS_MeshNode * n48);
+
   virtual SMDS_MeshFace* AddPolygonalFaceWithID (std::vector<int> nodes_ids,
                                                  const int        ID);
 

diff --git a/src/SMDS/SMDS_MeshElement.cxx b/src/SMDS/SMDS_MeshElement.cxx
index 8d4d9b75dc2e0bb913603c73ac5a5fefb72f9887..9126f04f3499e23156967f05d095013712237e8e 100644 (file)
--- a/src/SMDS/SMDS_MeshElement.cxx
+++ b/src/SMDS/SMDS_MeshElement.cxx
@@ -192,3 +192,12 @@ bool operator<(const SMDS_MeshElement& e1, const SMDS_MeshElement& e2)
        }
         return false;
 }
+
+bool SMDS_MeshElement::IsQuadratic() const
+{
+  return false;
+}
+bool SMDS_MeshElement::IsMediumNode(class SMDS_MeshNode* node) const
+{
+  return false;
+}

diff --git a/src/SMDS/SMDS_MeshElement.hxx b/src/SMDS/SMDS_MeshElement.hxx
index 73870b707fbf37d96184688cd7ac4c763a98ca0a..010173c94303c15dc878583dd37d3ec0d7aa62e5 100644 (file)
--- a/src/SMDS/SMDS_MeshElement.hxx
+++ b/src/SMDS/SMDS_MeshElement.hxx
@@ -56,32 +56,34 @@ class SMDS_MeshFace;
 ///////////////////////////////////////////////////////////////////////////////
 class SMDS_WNT_EXPORT SMDS_MeshElement:public SMDS_MeshObject
 {
+public:
 
-  public:
-       SMDS_ElemIteratorPtr nodesIterator() const;
-       SMDS_ElemIteratorPtr edgesIterator() const;
-       SMDS_ElemIteratorPtr facesIterator() const;
-       virtual SMDS_ElemIteratorPtr
-               elementsIterator(SMDSAbs_ElementType type) const;
+  SMDS_ElemIteratorPtr nodesIterator() const;
+  SMDS_ElemIteratorPtr edgesIterator() const;
+  SMDS_ElemIteratorPtr facesIterator() const;
+  virtual SMDS_ElemIteratorPtr elementsIterator(SMDSAbs_ElementType type) const;
 
-       virtual int NbNodes() const;
-       virtual int NbEdges() const;
-       virtual int NbFaces() const;
-       int GetID() const;
+  virtual int NbNodes() const;
+  virtual int NbEdges() const;
+  virtual int NbFaces() const;
+  int GetID() const;
 
-       ///Return the type of the current element
-       virtual SMDSAbs_ElementType GetType() const = 0;
-       virtual bool IsPoly() const { return false; };
+  ///Return the type of the current element
+  virtual SMDSAbs_ElementType GetType() const = 0;
+  virtual bool IsPoly() const { return false; };
+  virtual bool IsQuadratic() const;
 
-       friend std::ostream & operator <<(std::ostream & OS, const SMDS_MeshElement *);
-       friend bool SMDS_MeshElementIDFactory::BindID(int ID,SMDS_MeshElement*elem);
+  virtual bool IsMediumNode(class SMDS_MeshNode* node) const;
 
-  protected:
-       SMDS_MeshElement(int ID=-1);
-       virtual void Print(std::ostream & OS) const;
-       
-  private:
-       int myID;
+  friend std::ostream & operator <<(std::ostream & OS, const SMDS_MeshElement *);
+  friend bool SMDS_MeshElementIDFactory::BindID(int ID,SMDS_MeshElement*elem);
+
+protected:
+  SMDS_MeshElement(int ID=-1);
+  virtual void Print(std::ostream & OS) const;
+
+private:
+  int myID;
 };
 
 #endif

diff --git a/src/SMDS/SMDS_QuadraticEdge.hxx b/src/SMDS/SMDS_QuadraticEdge.hxx
new file mode 100644 (file)
index 0000000..6bb9b2b
--- /dev/null
+++ b/src/SMDS/SMDS_QuadraticEdge.hxx
@@ -0,0 +1,53 @@
+//  SMESH SMDS : implementaion of Salome mesh data structure
+//
+//  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
+// 
+//  This library is free software; you can redistribute it and/or 
+//  modify it under the terms of the GNU Lesser General Public 
+//  License as published by the Free Software Foundation; either 
+//  version 2.1 of the License. 
+// 
+//  This library is distributed in the hope that it will be useful, 
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of 
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
+//  Lesser General Public License for more details. 
+// 
+//  You should have received a copy of the GNU Lesser General Public 
+//  License along with this library; if not, write to the Free Software 
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
+// 
+//  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org 
+//
+//
+//
+//  File   : SMDS_QuadraticEdge.hxx
+//  Module : SMESH
+
+#ifndef _SMDS_QuadraticEdge_HeaderFile
+#define _SMDS_QuadraticEdge_HeaderFile
+
+#include "SMDS_MeshEdge.hxx"
+
+class SMDS_WNT_EXPORT SMDS_QuadraticEdge: public SMDS_MeshEdge
+{
+
+  public:
+       SMDS_QuadraticEdge(const SMDS_MeshNode * node1,
+                           const SMDS_MeshNode * node2,
+                           const SMDS_MeshNode * node12);
+        bool ChangeNodes(const SMDS_MeshNode * node1,
+                         const SMDS_MeshNode * node2,
+                         const SMDS_MeshNode * node12);
+       void Print(std::ostream & OS) const;
+
+       int NbNodes() const;
+  protected:
+       SMDS_ElemIteratorPtr
+               elementsIterator(SMDSAbs_ElementType type) const;
+
+  private:
+       const SMDS_MeshNode* myNodes[3];
+
+};
+#endif

diff --git a/src/SMDS/SMDS_QuadraticFaceOfNodes.hxx b/src/SMDS/SMDS_QuadraticFaceOfNodes.hxx
new file mode 100644 (file)
index 0000000..bf69974
--- /dev/null
+++ b/src/SMDS/SMDS_QuadraticFaceOfNodes.hxx
@@ -0,0 +1,73 @@
+//  SMESH SMDS : implementaion of Salome mesh data structure
+//
+//  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
+// 
+//  This library is free software; you can redistribute it and/or 
+//  modify it under the terms of the GNU Lesser General Public 
+//  License as published by the Free Software Foundation; either 
+//  version 2.1 of the License. 
+// 
+//  This library is distributed in the hope that it will be useful, 
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of 
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
+//  Lesser General Public License for more details. 
+// 
+//  You should have received a copy of the GNU Lesser General Public 
+//  License along with this library; if not, write to the Free Software 
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
+// 
+//  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org 
+//
+//
+//
+//  File   : SMDS_QuadraticVolumeOfNodes.hxx
+//  Module : SMESH
+
+#ifndef _SMDS_QuadraticVolumeOfNodes_HeaderFile
+#define _SMDS_QuadraticVolumeOfNodes_HeaderFile
+
+#include "SMDS_MeshFace.hxx"
+
+class SMDS_WNT_EXPORT SMDS_QuadraticFaceOfNodes:public SMDS_MeshFace
+{
+public:
+  SMDS_QuadraticFaceOfNodes (const SMDS_MeshNode * n1,
+                             const SMDS_MeshNode * n2,
+                             const SMDS_MeshNode * n3,
+                             const SMDS_MeshNode * n12,
+                             const SMDS_MeshNode * n23,
+                             const SMDS_MeshNode * n31);
+
+  SMDS_QuadraticFaceOfNodes(const SMDS_MeshNode * n1,
+                            const SMDS_MeshNode * n2,
+                            const SMDS_MeshNode * n3,
+                            const SMDS_MeshNode * n4,
+                            const SMDS_MeshNode * n12,
+                            const SMDS_MeshNode * n23,
+                            const SMDS_MeshNode * n34,
+                            const SMDS_MeshNode * n41);
+
+  virtual bool IsQuadratic() const { return true; }
+
+  virtual bool IsMediumNode(class SMDS_MeshNode* node) const;
+
+  bool ChangeNodes(const SMDS_MeshNode* nodes[],
+                   const int            nbNodes);
+
+  virtual int NbNodes() const;
+  virtual int NbEdges() const;
+  virtual int NbFaces() const;
+
+  virtual void Print (std::ostream & OS) const;
+
+  SMDS_NodeIteratorPtr interlacedNodesIterator() const;
+
+protected:
+  virtual SMDS_ElemIteratorPtr elementsIterator (SMDSAbs_ElementType type) const;
+
+ private:
+  std::vector<const SMDS_MeshNode *> myNodes;
+};
+
+#endif

diff --git a/src/SMDS/SMDS_QuadraticVolumeOfNodes.hxx b/src/SMDS/SMDS_QuadraticVolumeOfNodes.hxx
new file mode 100644 (file)
index 0000000..9964f2f
--- /dev/null
+++ b/src/SMDS/SMDS_QuadraticVolumeOfNodes.hxx
@@ -0,0 +1,120 @@
+//  SMESH SMDS : implementaion of Salome mesh data structure
+//
+//  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
+// 
+//  This library is free software; you can redistribute it and/or 
+//  modify it under the terms of the GNU Lesser General Public 
+//  License as published by the Free Software Foundation; either 
+//  version 2.1 of the License. 
+// 
+//  This library is distributed in the hope that it will be useful, 
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of 
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
+//  Lesser General Public License for more details. 
+// 
+//  You should have received a copy of the GNU Lesser General Public 
+//  License along with this library; if not, write to the Free Software 
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
+// 
+//  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org 
+//
+//
+//
+//  File   : SMDS_QuadraticVolumeOfNodes.hxx
+//  Module : SMESH
+
+#ifndef _SMDS_QuadraticVolumeOfNodes_HeaderFile
+#define _SMDS_QuadraticVolumeOfNodes_HeaderFile
+
+#include "SMDS_MeshVolume.hxx"
+
+class SMDS_WNT_EXPORT SMDS_QuadraticVolumeOfNodes:public SMDS_MeshVolume
+{
+public:
+  // tetrahedron of 10 nodes
+  SMDS_QuadraticVolumeOfNodes (const SMDS_MeshNode * n1,
+                               const SMDS_MeshNode * n2,
+                               const SMDS_MeshNode * n3,
+                               const SMDS_MeshNode * n4,
+                               const SMDS_MeshNode * n12,
+                               const SMDS_MeshNode * n23,
+                               const SMDS_MeshNode * n31,
+                               const SMDS_MeshNode * n14, 
+                               const SMDS_MeshNode * n23,
+                               const SMDS_MeshNode * n34);
+  // pyramid of 13 nodes
+  SMDS_QuadraticVolumeOfNodes(const SMDS_MeshNode * n1,
+                              const SMDS_MeshNode * n2,
+                              const SMDS_MeshNode * n3,
+                              const SMDS_MeshNode * n4,
+                              const SMDS_MeshNode * n5,
+                              const SMDS_MeshNode * n12,
+                              const SMDS_MeshNode * n23,
+                              const SMDS_MeshNode * n34,
+                              const SMDS_MeshNode * n41, 
+                              const SMDS_MeshNode * n15,
+                              const SMDS_MeshNode * n25,
+                              const SMDS_MeshNode * n35,
+                              const SMDS_MeshNode * n45);
+
+  //  Pentahedron with 15 nodes
+  SMDS_QuadraticVolumeOfNodes(const SMDS_MeshNode * n1,
+                              const SMDS_MeshNode * n2,
+                              const SMDS_MeshNode * n3,
+                              const SMDS_MeshNode * n4,
+                              const SMDS_MeshNode * n5,
+                              const SMDS_MeshNode * n6, 
+                              const SMDS_MeshNode * n12,
+                              const SMDS_MeshNode * n23,
+                              const SMDS_MeshNode * n31, 
+                              const SMDS_MeshNode * n45,
+                              const SMDS_MeshNode * n56,
+                              const SMDS_MeshNode * n64, 
+                              const SMDS_MeshNode * n14,
+                              const SMDS_MeshNode * n25,
+                              const SMDS_MeshNode * n36);
+
+  // Hexahedrons with 20 nodes
+  SMDS_QuadraticVolumeOfNodes(const SMDS_MeshNode * n1,
+                              const SMDS_MeshNode * n2,
+                              const SMDS_MeshNode * n3,
+                              const SMDS_MeshNode * n4,
+                              const SMDS_MeshNode * n5,
+                              const SMDS_MeshNode * n6,
+                              const SMDS_MeshNode * n7,
+                              const SMDS_MeshNode * n8, 
+                              const SMDS_MeshNode * n12,
+                              const SMDS_MeshNode * n23,
+                              const SMDS_MeshNode * n34,
+                              const SMDS_MeshNode * n51, 
+                              const SMDS_MeshNode * n56,
+                              const SMDS_MeshNode * n67,
+                              const SMDS_MeshNode * n78,
+                              const SMDS_MeshNode * n85, 
+                              const SMDS_MeshNode * n15,
+                              const SMDS_MeshNode * n26,
+                              const SMDS_MeshNode * n37,
+                              const SMDS_MeshNode * n48);
+
+  virtual bool IsQuadratic() const { return true; }
+
+  virtual bool IsMediumNode(class SMDS_MeshNode* node) const;
+
+  bool ChangeNodes(const SMDS_MeshNode* nodes[],
+                   const int            nbNodes);
+
+  virtual int NbNodes() const;
+  virtual int NbEdges() const;
+  virtual int NbFaces() const;
+
+  virtual void Print (std::ostream & OS) const;
+
+ protected:
+  virtual SMDS_ElemIteratorPtr elementsIterator (SMDSAbs_ElementType type) const;
+
+ private:
+  std::vector<const SMDS_MeshNode *> myNodes;
+};
+
+#endif