add quadratic element classes

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
 

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);
 

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;
+}

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

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

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

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