]> https://gitweb.dealii.org/ - dealii-svn.git/commitdiff
Revert some of the structural changes of last week to the state before. Basically...
authorwolf <wolf@0785d39b-7218-0410-832d-ea1e28bc413d>
Tue, 19 Jan 1999 12:21:51 +0000 (12:21 +0000)
committerwolf <wolf@0785d39b-7218-0410-832d-ea1e28bc413d>
Tue, 19 Jan 1999 12:21:51 +0000 (12:21 +0000)
git-svn-id: https://svn.dealii.org/trunk@737 0785d39b-7218-0410-832d-ea1e28bc413d

12 files changed:
deal.II/deal.II/include/fe/fe.h
deal.II/deal.II/include/fe/fe_lib.criss_cross.h
deal.II/deal.II/include/fe/fe_lib.dg.h
deal.II/deal.II/include/fe/fe_lib.lagrange.h
deal.II/deal.II/include/fe/fe_system.h
deal.II/deal.II/source/fe/fe_lib.criss_cross.cc
deal.II/deal.II/source/fe/fe_lib.cubic.cc
deal.II/deal.II/source/fe/fe_lib.dg.cc
deal.II/deal.II/source/fe/fe_lib.dg.constant.cc
deal.II/deal.II/source/fe/fe_lib.linear.cc
deal.II/deal.II/source/fe/fe_lib.quadratic.cc
deal.II/deal.II/source/fe/fe_lib.quartic.cc

index cf482fe16fc9b7d82eff7b83691b811421c83385..9833e96bfd979d92c65cb151ddb1dfabba8d5c1a 100644 (file)
@@ -567,27 +567,6 @@ struct FiniteElementBase :
  *   implemented in the #DoFHandler# class as of now.
  * \end{itemize}
  *
- * On a more general note, a concrete finite element class, derived from
- * the #FiniteElement# class needs to fulfill at least the following criteria:
- * \begin{itemize}
- * \item Overload and define all pure virtual functions;
- * \item If a finite element is to be used as part of a composed finite
- *   element, such as the #FESystem# of the #FEMixed# classes, it has
- *   to provide a \textit{static} function namend #get_fe_data#, which
- *   returns the data which also is stored in the #FiniteElementData# object
- *   at the bottom of the class hierarchy. This function needs to be static,
- *   since its output is needed at the time of construction of the composed
- *   finite element, at which time the subobjects denoting the parts of the
- *   composed element are not yet constructed. You need to make sure that
- *   each element has such a function; the composed elements have no way
- *   to make sure that the function is not inherited from a base class.
- *   You may only use an inherited such function, if the result would be
- *   the same.
- *
- *   It is also a good idea to use the output of this function to construct
- *   the base class #FiniteElement# of a concrete element.
- * \end{itemize}
- *
  * @author Wolfgang Bangerth, 1998
  */
 template <int dim>
index 1ffb9a07dc0994803c8a7b42fd550b84ea7bf251..bda4a68a04f07d1d9bf8cf1163b07f60af1a4c83 100644 (file)
@@ -169,20 +169,6 @@ class FECrissCross : public FiniteElement<dim> {
                                      * Constructor
                                      */
     FECrissCross ();
-
-                                    /**
-                                     * Declare a static function which returns
-                                     * the number of degrees of freedom per
-                                     * vertex, line, face, etc. This function
-                                     * is used by the constructors, but is
-                                     * mainly needed for the composed finite
-                                     * elements, which assemble a FE object
-                                     * from several other FEs. See the
-                                     * documentation for the #FiniteElement#
-                                     * class for more information on this
-                                     * subject.
-                                     */
-    static const FiniteElementData<dim> get_fe_data ();
     
                                     /**
                                      * Return the value of the #i#th shape
index c1e38e6e27c87f63d6d6dc855fc0ec5e1a78051a..ce5e8c2f14dee3241877de26ebdac9521b4f6f4d 100644 (file)
  * transforms from the unit cell to the real cell.
  * @author Ralf Hartmann, 1998
  */
-
 template <int dim>
 class FEDGConstant : public FELinearMapping<dim> {
   public:
-                                  /**
-                                   * Constructor
-                                   */
-    FEDGConstant ();
-
                                     /**
-                                     * Declare a static function which returns
-                                     * the number of degrees of freedom per
-                                     * vertex, line, face, etc. This function
-                                     * is used by the constructors, but is
-                                     * mainly needed for the composed finite
-                                     * elements, which assemble a FE object
-                                     * from several other FEs. See the
-                                     * documentation for the #FiniteElement#
-                                     * class for more information on this
-                                     * subject.
+                                     * Constructor
                                      */
-    static const FiniteElementData<dim> get_fe_data ();
-
+    FEDGConstant ();
+    
                                     /**
-                                   * Return the value of the #i#th shape
-                                   * function at point #p# on the unit cell.
-                                   */
+                                     * Return the value of the #i#th shape
+                                     * function at point #p# on the unit cell.
+                                     */
     virtual double shape_value(const unsigned int i,
                               const Point<dim>& p) const;
-
-                                  /**
-                                   * Return the gradient of the #i#th shape
-                                   * function at point #p# on the unit cell.
-                                   */
+    
+                                    /**
+                                     * Return the gradient of the #i#th shape
+                                     * function at point #p# on the unit cell.
+                                     */
     virtual Tensor<1,dim> shape_grad(const unsigned int i,
                                     const Point<dim>& p) const;
 
-                                  /**
-                                   * Return the tensor of second derivatives
-                                   * of the #i#th shape function at
-                                   * point #p# on the unit cell.
-                                   *
-                                   * For linear elements, all second
-                                   * derivatives on the unit cell are zero.
-                                   */
+                                    /**
+                                     * Return the tensor of second derivatives
+                                     * of the #i#th shape function at
+                                     * point #p# on the unit cell.
+                                     *
+                                     * For linear elements, all second
+                                     * derivatives on the unit cell are zero.
+                                     */
     virtual Tensor<2,dim> shape_grad_grad (const unsigned int  i,
                                           const Point<dim>   &p) const;
 
-                                  /**
-                                   * Refer to the base class for detailed
-                                   * information on this function.
-                                   */
+                                    /**
+                                     * Refer to the base class for detailed
+                                     * information on this function.
+                                     */
     virtual void get_unit_support_points (vector<Point<dim> > &support_points) const;
 
-                                  /**
-                                   * Refer to the base class for detailed
-                                   * information on this function.
-                                   */
+                                    /**
+                                     * Refer to the base class for detailed
+                                     * information on this function.
+                                     */
     virtual void get_support_points (const DoFHandler<dim>::cell_iterator &cell,
-                                   const Boundary<dim> &boundary,
-                                   vector<Point<dim> > &support_points) const;
+                                    const Boundary<dim> &boundary,
+                                    vector<Point<dim> > &support_points) const;
 
                                     /**
                                      * Refer to the base class for detailed
                                      * information on this function.
                                      */
     virtual void get_face_support_points (const DoFHandler<dim>::face_iterator &face,
-                                        const Boundary<dim> &boundary,
-                                        vector<Point<dim> > &support_points) const;
+                                         const Boundary<dim> &boundary,
+                                         vector<Point<dim> > &support_points) const;
 
                                     /**
                                      * Refer to the base class for detailed
@@ -93,23 +78,23 @@ class FEDGConstant : public FELinearMapping<dim> {
                                        const Boundary<dim> &boundary,
                                        dFMatrix &local_mass_matrix) const;
   
-                                  /**
-                                   * Return a readonly reference to the
-                                   * matrix which describes the transfer of a
-                                   * child with the given number to the
-                                   * mother cell. See the #restriction# array
-                                   * for more information.
-                                   *
-                                   * This function returns an error since the
-                                   * correct use of the restriction
-                                   * matrices is not yet finally decided
-                                   * about.
-                                   */
+                                    /**
+                                     * Return a readonly reference to the
+                                     * matrix which describes the transfer of a
+                                     * child with the given number to the
+                                     * mother cell. See the #restriction# array
+                                     * for more information.
+                                     *
+                                     * This function returns an error since the
+                                     * correct use of the restriction
+                                     * matrices is not yet finally decided
+                                     * about.
+                                     */
     const dFMatrix & restrict (const unsigned int) const;
   
-                                  /**
-                                   * Exception
-                                   */
+                                    /**
+                                     * Exception
+                                     */
     DeclException0 (ExcNotImplemented);
 };
 
@@ -145,20 +130,6 @@ class FEDGLinear : public FELinear<dim>{
                                      */
     FEDGLinear();
 
-                                    /**
-                                     * Declare a static function which returns
-                                     * the number of degrees of freedom per
-                                     * vertex, line, face, etc. This function
-                                     * is used by the constructors, but is
-                                     * mainly needed for the composed finite
-                                     * elements, which assemble a FE object
-                                     * from several other FEs. See the
-                                     * documentation for the #FiniteElement#
-                                     * class for more information on this
-                                     * subject.
-                                     */
-    static const FiniteElementData<dim> get_fe_data ();
-
                                     /**
                                      * This function returns an error since the
                                      * correct use of the restriction
@@ -199,20 +170,6 @@ class FEDGQuadraticSub : public FEQuadraticSub<dim>{
                                      */
     FEDGQuadraticSub();
 
-                                    /**
-                                     * Declare a static function which returns
-                                     * the number of degrees of freedom per
-                                     * vertex, line, face, etc. This function
-                                     * is used by the constructors, but is
-                                     * mainly needed for the composed finite
-                                     * elements, which assemble a FE object
-                                     * from several other FEs. See the
-                                     * documentation for the #FiniteElement#
-                                     * class for more information on this
-                                     * subject.
-                                     */
-    static const FiniteElementData<dim> get_fe_data ();
-
                                     /**
                                      * This function returns an error since the
                                      * correct use of the restriction
@@ -254,20 +211,6 @@ class FEDGCubicSub : public FECubicSub<dim>{
                                      */
     FEDGCubicSub();
 
-                                    /**
-                                     * Declare a static function which returns
-                                     * the number of degrees of freedom per
-                                     * vertex, line, face, etc. This function
-                                     * is used by the constructors, but is
-                                     * mainly needed for the composed finite
-                                     * elements, which assemble a FE object
-                                     * from several other FEs. See the
-                                     * documentation for the #FiniteElement#
-                                     * class for more information on this
-                                     * subject.
-                                     */
-    static const FiniteElementData<dim> get_fe_data ();
-
                                     /**
                                      * This function returns an error since the
                                      * correct use of the restriction
@@ -308,20 +251,6 @@ class FEDGQuarticSub : public FEQuarticSub<dim>{
                                      */
     FEDGQuarticSub();
 
-                                    /**
-                                     * Declare a static function which returns
-                                     * the number of degrees of freedom per
-                                     * vertex, line, face, etc. This function
-                                     * is used by the constructors, but is
-                                     * mainly needed for the composed finite
-                                     * elements, which assemble a FE object
-                                     * from several other FEs. See the
-                                     * documentation for the #FiniteElement#
-                                     * class for more information on this
-                                     * subject.
-                                     */
-    static const FiniteElementData<dim> get_fe_data ();
-
                                     /**
                                      * This function returns an error since the
                                      * correct use of the restriction
index 60b5abac828536fe081367fdb08e721f63694243..8eff4866573616f353aa352749d023b05f5c34c8 100644 (file)
@@ -44,22 +44,8 @@ class FELinear : public FELinearMapping<dim> {
                                      * For more detail see class #FEDGLinear#.
                                      */
     FELinear (const int);
-  public:
-
-                                    /**
-                                     * Declare a static function which returns
-                                     * the number of degrees of freedom per
-                                     * vertex, line, face, etc. This function
-                                     * is used by the constructors, but is
-                                     * mainly needed for the composed finite
-                                     * elements, which assemble a FE object
-                                     * from several other FEs. See the
-                                     * documentation for the #FiniteElement#
-                                     * class for more information on this
-                                     * subject.
-                                     */
-    static const FiniteElementData<dim> get_fe_data ();
     
+  public:
                                     /**
                                      * Return the value of the #i#th shape
                                      * function at point #p# on the unit cell.
@@ -160,20 +146,6 @@ class FEQuadraticSub : public FELinearMapping<dim> {
     FEQuadraticSub (const int);
     
   public:
-                                    /**
-                                     * Declare a static function which returns
-                                     * the number of degrees of freedom per
-                                     * vertex, line, face, etc. This function
-                                     * is used by the constructors, but is
-                                     * mainly needed for the composed finite
-                                     * elements, which assemble a FE object
-                                     * from several other FEs. See the
-                                     * documentation for the #FiniteElement#
-                                     * class for more information on this
-                                     * subject.
-                                     */
-    static const FiniteElementData<dim> get_fe_data ();
-
                                     /**
                                      * Return the value of the #i#th shape
                                      * function at point #p# on the unit cell.
@@ -290,21 +262,6 @@ class FECubicSub : public FELinearMapping<dim> {
     FECubicSub (const int);
 
   public:
-
-                                    /**
-                                     * Declare a static function which returns
-                                     * the number of degrees of freedom per
-                                     * vertex, line, face, etc. This function
-                                     * is used by the constructors, but is
-                                     * mainly needed for the composed finite
-                                     * elements, which assemble a FE object
-                                     * from several other FEs. See the
-                                     * documentation for the #FiniteElement#
-                                     * class for more information on this
-                                     * subject.
-                                     */
-    static const FiniteElementData<dim> get_fe_data ();
-
                                     /**
                                      * Return the value of the #i#th shape
                                      * function at point #p# on the unit cell.
@@ -422,21 +379,6 @@ class FEQuarticSub : public FELinearMapping<dim> {
     FEQuarticSub (const int);
 
   public:
-
-                                    /**
-                                     * Declare a static function which returns
-                                     * the number of degrees of freedom per
-                                     * vertex, line, face, etc. This function
-                                     * is used by the constructors, but is
-                                     * mainly needed for the composed finite
-                                     * elements, which assemble a FE object
-                                     * from several other FEs. See the
-                                     * documentation for the #FiniteElement#
-                                     * class for more information on this
-                                     * subject.
-                                     */
-    static const FiniteElementData<dim> get_fe_data ();
-
                                     /**
                                      * Return the value of the #i#th shape
                                      * function at point #p# on the unit cell.
index 506561ac1a2c53114400845c4222a53216e976a0..3f83f4df399564f3dd4dc4184d522196e7222996 100644 (file)
@@ -77,20 +77,13 @@ class FESystem : public FiniteElement<dim> {
                                      * In fact, the object #fe# is not used,
                                      * apart from getting the number of dofs
                                      * per vertex, line, etc for that finite
-                                     * element class. For this, it would have
-                                     * been possible to use the #get_fe_data#
-                                     * function that each element has to
-                                     * provide. The correct way to write
-                                     * this constructor would therefore have
-                                     * been to specify it without the first
-                                     * argument and let the user specify the
-                                     * desired finite element by an explicit
-                                     * template argument list, like this:
-                                     * #AnyClass::f<int>()#. However, #C++#
-                                     * does not allow this call sequence for
-                                     * constructors, so we have to use the
-                                     * way as shown here, to let the compiler
-                                     * deduce the template argument itself.
+                                     * element class. The objects creates its
+                                     * own copy of the finite element object
+                                     * at construction time (but after
+                                     * the initialization of the base class
+                                     * #FiniteElement#, which is why we need
+                                     * a valid finite element object passed
+                                     * to the constructor).
                                      *
                                      * Obviously, the template finite element
                                      * class needs to be of the same dimension
index adb3e7e29b899260b82e9c9caf49f0a5c2af8ad9..7262f3bf3ecc2b6f5d36b5845d206780ad1814f7 100644 (file)
 
 #if deal_II_dimension == 1
 
-// declare explicit instantiation
-template <>
-const FiniteElementData<1> FECrissCross<1>::get_fe_data ();
-
-
 
 template <>
 FECrissCross<1>::FECrissCross () :
-               FiniteElement<1> (get_fe_data ())
+                                  // set more or less invalid data
+               FiniteElement<1> (FiniteElementData<1> (0,0,0))
 {
   Assert (false, ExcNotUseful());
 };
 
 
 
-template <>
-const FiniteElementData<1>
-FECrissCross<1>::get_fe_data () {
-                                  // return more or less invalid data
-  return FiniteElementData<1> (0,0,0);
-};
-
-
-
 template <>
 double FECrissCross<1>::shape_value (const unsigned int, const Point<1> &) const {
   Assert (false, ExcNotUseful());
@@ -471,14 +458,10 @@ void FECrissCross<1>::fill_fe_values (const DoFHandler<1>::cell_iterator &,
 
 #if deal_II_dimension == 2
 
-// declare explicit instantiation
-template <>
-const FiniteElementData<2> FECrissCross<2>::get_fe_data ();
-
 
 template <>
 FECrissCross<2>::FECrissCross () :
-               FiniteElement<2> (get_fe_data ())
+               FiniteElement<2> (FiniteElementData<2> (1,0,1,5))
 {
   interface_constraints(0,0) = 1./2.;
   interface_constraints(0,1) = 1./2.;
@@ -528,14 +511,6 @@ FECrissCross<2>::FECrissCross () :
 
 
 
-template <>
-const FiniteElementData<2>
-FECrissCross<2>::get_fe_data () {
-  return FiniteElementData<2> (1,0,1,5);
-};
-
-
-
 
 template <>
 inline
index 0384f217f633f852622b3820bbc008cb93996da0..ad15a4653d1c82e6f453da6d09039bacba0d8de0 100644 (file)
@@ -36,14 +36,6 @@ FECubicSub<1>::FECubicSub (const int) :
 
 
 
-template <>
-const FiniteElementData<1>
-FECubicSub<1>::get_fe_data () {
-  return FiniteElementData<1> (1, 2, GeometryInfo<1>::vertices_per_cell);
-};
-
-
-
 template <>
 void FECubicSub<1>::initialize_matrices () {
   
@@ -282,14 +274,6 @@ FECubicSub<2>::FECubicSub (const int) :
 
 
 
-template <>
-const FiniteElementData<2>
-FECubicSub<2>::get_fe_data () {
-  return FiniteElementData<2> (1, 2, 4, GeometryInfo<2>::vertices_per_cell);
-};
-
-
-
 template <>
 void FECubicSub<2>::initialize_matrices () {
   prolongation[0](0,0) = 1.0;
index 0b8eb817c0023dfc6b4132bf4e4a7401ca77196a..bf0d9454d15f0a87a776819c591288b70dd21284 100644 (file)
@@ -26,104 +26,6 @@ FEDGQuarticSub<dim>::FEDGQuarticSub():
 
 
 
-#if deal_II_dimension == 1
-
-template <>
-const FiniteElementData<1>
-FEDGLinear<1>::get_fe_data () {
-                                  // no dofs at the vertices, all in the
-                                  // interior of the line
-  return FiniteElementData<1> (0,
-                              FELinear<1>::get_fe_data().total_dofs,
-                              FELinear<1>::get_fe_data().n_transform_functions);
-};
-
-
-template <>
-const FiniteElementData<1>
-FEDGQuadraticSub<1>::get_fe_data () {
-                                  // no dofs at the vertices, all in the
-                                  // interior of the line
-  return FiniteElementData<1> (0,
-                              FEQuadraticSub<1>::get_fe_data().total_dofs,
-                              FEQuadraticSub<1>::get_fe_data().n_transform_functions);
-};
-
-
-template <>
-const FiniteElementData<1>
-FEDGCubicSub<1>::get_fe_data () {
-                                  // no dofs at the vertices, all in the
-                                  // interior of the line
-  return FiniteElementData<1> (0,
-                              FECubicSub<1>::get_fe_data().total_dofs,
-                              FECubicSub<1>::get_fe_data().n_transform_functions);
-};
-
-
-template <>
-const FiniteElementData<1>
-FEDGQuarticSub<1>::get_fe_data () {
-                                  // no dofs at the vertices, all in the
-                                  // interior of the line
-  return FiniteElementData<1> (0,
-                              FEQuarticSub<1>::get_fe_data().total_dofs,
-                              FEQuarticSub<1>::get_fe_data().n_transform_functions);
-};
-
-#endif
-
-
-
-#if deal_II_dimension == 2
-
-template <>
-const FiniteElementData<2>
-FEDGLinear<2>::get_fe_data () {
-                                  // no dofs at the vertices or lines, all in the
-                                  // interior of the line
-  return FiniteElementData<2> (0, 0,
-                              FELinear<2>::get_fe_data().total_dofs,
-                              FELinear<2>::get_fe_data().n_transform_functions);
-};
-
-
-template <>
-const FiniteElementData<2>
-FEDGQuadraticSub<2>::get_fe_data () {
-                                  // no dofs at the vertices or lines, all in the
-                                  // interior of the line
-  return FiniteElementData<2> (0, 0,
-                              FEQuadraticSub<2>::get_fe_data().total_dofs,
-                              FEQuadraticSub<2>::get_fe_data().n_transform_functions);
-};
-
-
-template <>
-const FiniteElementData<2>
-FEDGCubicSub<2>::get_fe_data () {
-                                  // no dofs at the vertices or lines, all in the
-                                  // interior of the line
-  return FiniteElementData<2> (0, 0,
-                              FECubicSub<2>::get_fe_data().total_dofs,
-                              FECubicSub<2>::get_fe_data().n_transform_functions);
-};
-
-
-template <>
-const FiniteElementData<2>
-FEDGQuarticSub<2>::get_fe_data () {
-                                  // no dofs at the vertices or lines, all in the
-                                  // interior of the line
-  return FiniteElementData<2> (0, 0,
-                              FEQuarticSub<2>::get_fe_data().total_dofs,
-                              FEQuarticSub<2>::get_fe_data().n_transform_functions);
-};
-
-#endif
-
-
-
 template <int dim>
 const dFMatrix & 
 FEDGLinear<dim>::restrict (const unsigned int child) const {
index aab9dcf5a3f2b5d8fc68699bb6c8c599568a701e..1a4e9e7835b5b74776c1bbcc66f696ad71984567 100644 (file)
@@ -42,13 +42,6 @@ FEDGConstant<1>::FEDGConstant () :
 };
 
 
-template <>
-const FiniteElementData<1>
-FEDGConstant<1>::get_fe_data () {
-  return FiniteElementData<1> (0, 1, GeometryInfo<1>::vertices_per_cell);
-};
-
-
 
 template <>
 void FEDGConstant<1>::get_face_support_points (const typename DoFHandler<1>::face_iterator &,
@@ -89,15 +82,6 @@ FEDGConstant<2>::FEDGConstant () :
 
 
 
-template <>
-const FiniteElementData<2>
-FEDGConstant<2>::get_fe_data () {
-  return FiniteElementData<2> (0, 0, 1, GeometryInfo<2>::vertices_per_cell);
-};
-
-
-
-
 #endif
 
 
index 374efcce55bc5e9e20165f1094d033e591db84d7..c0ad349751c1ef444ab544ae2dcde350db978aa6 100644 (file)
@@ -37,14 +37,6 @@ FELinear<1>::FELinear (const int) :
 
 
 
-template <>
-const FiniteElementData<1>
-FELinear<1>::get_fe_data () {
-  return FiniteElementData<1> (1, 0, GeometryInfo<1>::vertices_per_cell);
-};
-
-
-
 
 template <>
 void FELinear<1>::initialize_matrices () {
@@ -195,14 +187,6 @@ FELinear<2>::FELinear (const int) :
 
 
 
-template <>
-const FiniteElementData<2>
-FELinear<2>::get_fe_data () {
-  return FiniteElementData<2> (1, 0, 0, GeometryInfo<2>::vertices_per_cell);
-};
-
-
-
 template <>
 void FELinear<2>::initialize_matrices () {
   restriction[0](0,0) = 1.0;
index 3a982635d89f7ddf90900e4bb9cfb65b65757e98..89a40fc3435283c9aed8f5e7ea569295262a0677 100644 (file)
@@ -33,14 +33,6 @@ FEQuadraticSub<1>::FEQuadraticSub (const int) :
 
 
 
-template <>
-const FiniteElementData<1>
-FEQuadraticSub<1>::get_fe_data () {
-  return FiniteElementData<1> (1, 1, GeometryInfo<1>::vertices_per_cell);
-};
-
-
-
 template <>
 void FEQuadraticSub<1>::initialize_matrices () {
 /*
@@ -267,14 +259,6 @@ FEQuadraticSub<2>::FEQuadraticSub (const int) :
 
 
 
-template <>
-const FiniteElementData<2>
-FEQuadraticSub<2>::get_fe_data () {
-  return FiniteElementData<2> (1, 1, 1, GeometryInfo<2>::vertices_per_cell);
-};
-
-
-
 template <>
 void FEQuadraticSub<2>::initialize_matrices () {
 /*
index d084d0f618a68254970be655ab3a411d84e2dfcc..3d3c27be8c8c6b17189084cfbf024592b7ceeffa 100644 (file)
@@ -32,13 +32,6 @@ FEQuarticSub<1>::FEQuarticSub (const int) :
 
 
 
-template <>
-const FiniteElementData<1>
-FEQuarticSub<1>::get_fe_data () {
-  return FiniteElementData<1> (1, 3, GeometryInfo<1>::vertices_per_cell);
-};
-
-
 
 template <>
 void FEQuarticSub<1>::initialize_matrices () {
@@ -268,14 +261,6 @@ FEQuarticSub<2>::FEQuarticSub (const int) :
 
 
 
-template <>
-const FiniteElementData<2>
-FEQuarticSub<2>::get_fe_data () {
-  return FiniteElementData<2> (1, 3, 9, GeometryInfo<2>::vertices_per_cell);
-};
-
-
-
 template <>
 void FEQuarticSub<2>::initialize_matrices () {
   prolongation[0](0,0) = 1.0;

In the beginning the Universe was created. This has made a lot of people very angry and has been widely regarded as a bad move.

Douglas Adams


Typeset in Trocchi and Trocchi Bold Sans Serif.