]> https://gitweb.dealii.org/ - dealii-svn.git/commitdiff
Re-order some member functions and variables.
authorbangerth <bangerth@0785d39b-7218-0410-832d-ea1e28bc413d>
Tue, 6 Mar 2007 20:03:09 +0000 (20:03 +0000)
committerbangerth <bangerth@0785d39b-7218-0410-832d-ea1e28bc413d>
Tue, 6 Mar 2007 20:03:09 +0000 (20:03 +0000)
git-svn-id: https://svn.dealii.org/trunk@14529 0785d39b-7218-0410-832d-ea1e28bc413d

deal.II/deal.II/include/fe/fe.h

index 2c61f473a195e84f2063456e30fa937742049814..7adfc20ee5d1eace67d88d413a757db371273345 100644 (file)
@@ -398,7 +398,7 @@ class FiniteElement : public Subscriptor,
                                      * Constructor
                                      */
     FiniteElement (const FiniteElementData<dim> &fe_data,
-                  const std::vector<bool> &restriction_is_additive_flags,
+                  const std::vector<bool>      &restriction_is_additive_flags,
                   const std::vector<std::vector<bool> > &nonzero_components);
 
                                     /**
@@ -1856,7 +1856,31 @@ class FiniteElement : public Subscriptor,
                                       */
     DeclException0 (ExcInterpolationNotImplemented);
     
-  protected:  
+                                    /**
+                                     * Exception
+                                     *
+                                     * @ingroup Exceptions
+                                     */
+    DeclException0 (ExcBoundaryFaceUsed);
+                                    /**
+                                     * Exception
+                                     *
+                                     * @ingroup Exceptions
+                                     */
+    DeclException0 (ExcJacobiDeterminantHasWrongSign);
+    
+  protected:
+                                    /**
+                                     * Store whether all shape
+                                     * functions are primitive. Since
+                                     * finding this out is a very
+                                     * common operation, we cache the
+                                     * result, i.e. compute the value
+                                     * in the constructor for simpler
+                                     * access.
+                                     */
+    const bool cached_primitivity;
+
                                     /**
                                      * Array of projection
                                      * matrices. See
@@ -1898,6 +1922,101 @@ class FiniteElement : public Subscriptor,
                                      */
     FullMatrix<double> interface_constraints;
 
+                                    /**
+                                     * List of support points on the
+                                     * unit cell, in case the finite
+                                     * element has any. The
+                                     * constructor leaves this field
+                                     * empty, derived classes may
+                                     * write in some contents.
+                                     *
+                                     * Finite elements that allow
+                                     * some kind of interpolation
+                                     * operation usually have support
+                                     * points. On the other hand,
+                                     * elements that define their
+                                     * degrees of freedom by, for
+                                     * example, moments on faces, or
+                                     * as derivatives, don't have
+                                     * support points. In that case,
+                                     * this field remains empty.
+                                     */
+    std::vector<Point<dim> > unit_support_points;
+
+                                    /**
+                                     * Same for the faces. See the
+                                     * description of the
+                                     * @p get_unit_face_support_points
+                                     * function for a discussion of
+                                     * what contributes a face
+                                     * support point.
+                                     */
+    std::vector<Point<dim-1> > unit_face_support_points;
+    
+                                    /**
+                                     * Support points used for
+                                     * interpolation functions of
+                                     * non-Lagrangian elements.
+                                     */
+    std::vector<Point<dim> > generalized_support_points;
+    
+                                    /**
+                                     * Face support points used for
+                                     * interpolation functions of
+                                     * non-Lagrangian elements.
+                                     */    
+    std::vector<Point<dim-1> > generalized_face_support_points;
+    
+                                    /**
+                                     * For faces with non-standard
+                                     * face_orientation in 3D, the dofs on
+                                     * faces (quads) have to be permuted in
+                                     * order to be combined with the correct
+                                     * shape functions. Given a local dof @p
+                                     * index on a quad, return the shift in the
+                                     * local index, if the face has
+                                     * non-standard face_orientation,
+                                     * i.e. <code>old_index + shift =
+                                     * new_index</code>. In 2D and 1D there is
+                                     * no need for permutation so the vector is
+                                     * empty. In 3D it has the size of <code>
+                                     * dofs_per_quad * 8 </code>, where 8 is
+                                     * the number of orientations, a face can
+                                     * be in (all comibinations of the three
+                                     * bool flags face_orientation, face_flip
+                                     * and face_rotation).
+                                     *
+                                     * The standard implementation fills this
+                                     * with zeros, i.e. no permuatation at
+                                     * all. Derived finite element classes have
+                                     * to fill this Table with the correct
+                                     * values.
+                                     */
+    Table<2,int> adjust_quad_dof_index_for_face_orientation_table;
+
+                                    /**
+                                     * For lines with non-standard
+                                     * line_orientation in 3D, the dofs on
+                                     * lines have to be permuted in
+                                     * order to be combined with the correct
+                                     * shape functions. Given a local dof @p
+                                     * index on a line, return the shift in the
+                                     * local index, if the line has
+                                     * non-standard line_orientation,
+                                     * i.e. <code>old_index + shift =
+                                     * new_index</code>. In 2D and 1D there is
+                                     * no need for permutation so the vector is
+                                     * empty. In 3D it has the size of @p
+                                     * dofs_per_line.
+                                     *
+                                     * The standard implementation fills this
+                                     * with zeros, i.e. no permuatation at
+                                     * all. Derived finite element classes have
+                                     * to fill this vector with the correct
+                                     * values.
+                                     */
+    std::vector<int> adjust_line_dof_index_for_line_orientation_table;
+
                                      /**
                                       * Return the size of interface
                                       * constraint matrices. Since
@@ -1922,17 +2041,6 @@ class FiniteElement : public Subscriptor,
                                       */
     TableIndices<2>
     interface_constraints_size () const;
-    
-                                    /**
-                                     * Store whether all shape
-                                     * functions are primitive. Since
-                                     * finding this out is a very
-                                     * common operation, we cache the
-                                     * result, i.e. compute the value
-                                     * in the constructor for simpler
-                                     * access.
-                                     */
-    const bool cached_primitivity;
 
                                      /**
                                      * Compute second derivatives by
@@ -1959,19 +2067,6 @@ class FiniteElement : public Subscriptor,
     static
     std::vector<unsigned int>
     compute_n_nonzero_components (const std::vector<std::vector<bool> > &nonzero_components);
-    
-                                    /**
-                                     * Exception
-                                     *
-                                     * @ingroup Exceptions
-                                     */
-    DeclException0 (ExcBoundaryFaceUsed);
-                                    /**
-                                     * Exception
-                                     *
-                                     * @ingroup Exceptions
-                                     */
-    DeclException0 (ExcJacobiDeterminantHasWrongSign);
 
                                     /**
                                      * Determine the values a finite
@@ -2039,103 +2134,8 @@ class FiniteElement : public Subscriptor,
                                      * constructors of FESystem as well
                                      * as by the hp::FECollection class.
                                      */
-    virtual FiniteElement<dim> *clone() const = 0;
-    
-                                    /**
-                                     * List of support points on the
-                                     * unit cell, in case the finite
-                                     * element has any. The
-                                     * constructor leaves this field
-                                     * empty, derived classes may
-                                     * write in some contents.
-                                     *
-                                     * Finite elements that allow
-                                     * some kind of interpolation
-                                     * operation usually have support
-                                     * points. On the other hand,
-                                     * elements that define their
-                                     * degrees of freedom by, for
-                                     * example, moments on faces, or
-                                     * as derivatives, don't have
-                                     * support points. In that case,
-                                     * this field remains empty.
-                                     */
-    std::vector<Point<dim> > unit_support_points;
-
-                                    /**
-                                     * Same for the faces. See the
-                                     * description of the
-                                     * @p get_unit_face_support_points
-                                     * function for a discussion of
-                                     * what contributes a face
-                                     * support point.
-                                     */
-    std::vector<Point<dim-1> > unit_face_support_points;
+    virtual FiniteElement<dim> *clone() const = 0;    
     
-                                    /**
-                                     * Support points used for
-                                     * interpolation functions of
-                                     * non-Lagrangian elements.
-                                     */
-    std::vector<Point<dim> > generalized_support_points;
-    
-                                    /**
-                                     * Face support points used for
-                                     * interpolation functions of
-                                     * non-Lagrangian elements.
-                                     */    
-    std::vector<Point<dim-1> > generalized_face_support_points;
-    
-                                    /**
-                                     * For faces with non-standard
-                                     * face_orientation in 3D, the dofs on
-                                     * faces (quads) have to be permuted in
-                                     * order to be combined with the correct
-                                     * shape functions. Given a local dof @p
-                                     * index on a quad, return the shift in the
-                                     * local index, if the face has
-                                     * non-standard face_orientation,
-                                     * i.e. <code>old_index + shift =
-                                     * new_index</code>. In 2D and 1D there is
-                                     * no need for permutation so the vector is
-                                     * empty. In 3D it has the size of <code>
-                                     * dofs_per_quad * 8 </code>, where 8 is
-                                     * the number of orientations, a face can
-                                     * be in (all comibinations of the three
-                                     * bool flags face_orientation, face_flip
-                                     * and face_rotation).
-                                     *
-                                     * The standard implementation fills this
-                                     * with zeros, i.e. no permuatation at
-                                     * all. Derived finite element classes have
-                                     * to fill this Table with the correct
-                                     * values.
-                                     */
-    Table<2,int> adjust_quad_dof_index_for_face_orientation_table;
-
-                                    /**
-                                     * For lines with non-standard
-                                     * line_orientation in 3D, the dofs on
-                                     * lines have to be permuted in
-                                     * order to be combined with the correct
-                                     * shape functions. Given a local dof @p
-                                     * index on a line, return the shift in the
-                                     * local index, if the line has
-                                     * non-standard line_orientation,
-                                     * i.e. <code>old_index + shift =
-                                     * new_index</code>. In 2D and 1D there is
-                                     * no need for permutation so the vector is
-                                     * empty. In 3D it has the size of @p
-                                     * dofs_per_line.
-                                     *
-                                     * The standard implementation fills this
-                                     * with zeros, i.e. no permuatation at
-                                     * all. Derived finite element classes have
-                                     * to fill this vector with the correct
-                                     * values.
-                                     */
-    std::vector<int> adjust_line_dof_index_for_line_orientation_table;
-
   private:
                                     /**
                                      * Store what

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.