]> https://gitweb.dealii.org/ - dealii.git/commitdiff
Small doc update and some reformatting.
authorWolfgang Bangerth <bangerth@math.tamu.edu>
Mon, 17 Jan 2000 13:48:13 +0000 (13:48 +0000)
committerWolfgang Bangerth <bangerth@math.tamu.edu>
Mon, 17 Jan 2000 13:48:13 +0000 (13:48 +0000)
git-svn-id: https://svn.dealii.org/trunk@2232 0785d39b-7218-0410-832d-ea1e28bc413d

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

index f5f21be4cfa8d99f558c9f37f684efccfe55f549..8fa748cbeccaa6e2030f0e88dca39ecb8b2bd873 100644 (file)
@@ -511,41 +511,49 @@ class FiniteElementBase : public Subscriptor,
 #endif
 
                                     /**
-                                     * Specify the constraints which the
-                                     * dofs on the two sides of a cell interface
-                                     * underly if the line connects two
-                                     * cells of which one is refined once.
+                                     * Specify the constraints which
+                                     * the dofs on the two sides of a
+                                     * cell interface underly if the
+                                     * line connects two cells of
+                                     * which one is refined once.
                                      *
-                                     * For further details see the general
-                                     * description of the derived class.
+                                     * For further details see the
+                                     * general description of the
+                                     * derived class.
                                      *
-                                     * This field is obviously useless in one
-                                     * space dimension.
+                                     * This field is obviously
+                                     * useless in one space dimension
+                                     * and has there a zero size.
                                      */
     FullMatrix<double> interface_constraints;
 
                                     /**
-                                     * Map between linear dofs and component dofs.
+                                     * Map between linear dofs and
+                                     * component dofs.
                                      */
     vector< pair<unsigned int, unsigned int> > system_to_component_table;
 
                                     /**
-                                     * Map between linear dofs and component dofs on face.
+                                     * Map between linear dofs and
+                                     * component dofs on face.
                                      */
     vector< pair<unsigned int, unsigned int> > face_system_to_component_table;
 
                                     /**
-                                     * Map between component and linear dofs.
+                                     * Map between component and
+                                     * linear dofs.
                                      */
     vector< vector<unsigned int> > component_to_system_table;
 
                                     /**
-                                     * Map between component and linear dofs on a face.
+                                     * Map between component and
+                                     * linear dofs on a face.
                                      */
     vector< vector<unsigned int> > face_component_to_system_table;
+    
                                     /**
-                                     * The base element establishing a
-                                     * component.
+                                     * The base element establishing
+                                     * component.
                                      *
                                      * This table converts a
                                      * component number to the
@@ -559,100 +567,124 @@ class FiniteElementBase : public Subscriptor,
     vector<unsigned int> component_to_base_table;
 
                                     /**
-                                     * This flag determines how the restriction
-                                     * of data from child cells to its mother
-                                     * is to be done. In this, it also
-                                     * determines in which way the restriction
-                                     * matrices of the derived class are to
-                                     * be used.
-                                     *
-                                     * For most elements, the mode is the
-                                     * following. Consider a 1d linear element,
-                                     * with two children and nodal values
-                                     * 1 and 2 on the first child, and 2 and 4
-                                     * on the second child. The restriction
-                                     * to the mother child then yields the
-                                     * values 1 and four, i.e. the values on
-                                     * the mother cell can be obtained by
-                                     * pointwise interpolation, where for each
-                                     * nodal value on the mother child one
-                                     * point on exactly one child exists.
-                                     * However, already on the quadratic
-                                     * element, the midpoint on the mother
-                                     * element can be obtained from any of
-                                     * the two children, which however would
-                                     * both yield the same value due to
-                                     * continuity. What we do in practice
-                                     * is to compute them from both sides
-                                     * and set them, rather than add them up.
-                                     * This makes some things much easier. In
-                                     * practice, if a degree of freedom on
-                                     * one of the child cells yields a
-                                     * nonzero contribution to one of the
-                                     * degrees of freedom on the mother
-                                     * cell, we overwrite the value on
-                                     * the mother cell. This way, when setting
-                                     * up the restriction matrices, we do not
-                                     * have to track which child is responsible
-                                     * for setting a given value on the mother
-                                     * cell. We call this the non-additive
-                                     * mode.
-                                     *
-                                     * The other possibility would be to
-                                     * add up the contributions from the
-                                     * different children. This would mean
-                                     * that both of the inner endpoint of
-                                     * the quadratic child elements above
-                                     * would have a weight of 1/2 with
-                                     * respect to the midpoint value on
-                                     * the mother cell. However, this also
-                                     * means that we have to first compute
-                                     * the restriction to the mother cell
-                                     * by addition from the child cells, and
-                                     * afterwards set them to the global
-                                     * vector. The same process, adding
-                                     * up the local contributions to the
-                                     * global vector is not possible since
-                                     * we do not know how many coarse cells
-                                     * contribute to nodes on the boundary.
-                                     *
-                                     * In contrast to the non-additive mode
-                                     * described above, which is the simplest
-                                     * way for elements can be interpolated
-                                     * from its children, interpolation is
-                                     * not possible for piecewise constant
-                                     * elements, to name only one example.
-                                     * Here, the value on the mother cell
-                                     * has to be taken the average of the
-                                     * values on the children, i.e. all
-                                     * children contribute alike to the
-                                     * one degree of freedom. Here, we have
-                                     * to sum up the contributions of all
-                                     * child cells with the same weight,
-                                     * and the non-additive mode of above
-                                     * would only set the value on the mother
-                                     * cell to the value of one of the child
-                                     * cell, irrespective of the values on the
-                                     * other cells.
-                                     *
-                                     * Similarly, for discontinuous linear
-                                     * elements, it might be better to not
-                                     * interpolate the values at the corners
-                                     * from the child cells, but to take a
+                                     * This flag determines how the
+                                     * restriction of data from child
+                                     * cells to its mother is to be
+                                     * done. In this, it also
+                                     * determines in which way the
+                                     * restriction matrices of the
+                                     * derived class are to be used.
+                                     *
+                                     * For most elements, the mode is
+                                     * the following. Consider a 1d
+                                     * linear element, with two
+                                     * children and nodal values 1
+                                     * and 2 on the first child, and
+                                     * 2 and 4 on the second
+                                     * child. The restriction to the
+                                     * mother child then yields the
+                                     * values 1 and four, i.e. the
+                                     * values on the mother cell can
+                                     * be obtained by pointwise
+                                     * interpolation, where for each
+                                     * nodal value on the mother
+                                     * child one point on exactly one
+                                     * child exists.  However,
+                                     * already on the quadratic
+                                     * element, the midpoint on the
+                                     * mother element can be obtained
+                                     * from any of the two children,
+                                     * which however would both yield
+                                     * the same value due to
+                                     * continuity. What we do in
+                                     * practice is to compute them
+                                     * from both sides and set them,
+                                     * rather than add them up.  This
+                                     * makes some things much
+                                     * easier. In practice, if a
+                                     * degree of freedom on one of
+                                     * the child cells yields a
+                                     * nonzero contribution to one of
+                                     * the degrees of freedom on the
+                                     * mother cell, we overwrite the
+                                     * value on the mother cell. This
+                                     * way, when setting up the
+                                     * restriction matrices, we do
+                                     * not have to track which child
+                                     * is responsible for setting a
+                                     * given value on the mother
+                                     * cell. We call this the
+                                     * non-additive mode.
+                                     *
+                                     * The other possibility would be
+                                     * to add up the contributions
+                                     * from the different
+                                     * children. This would mean that
+                                     * both of the inner endpoint of
+                                     * the quadratic child elements
+                                     * above would have a weight of
+                                     * 1/2 with respect to the
+                                     * midpoint value on the mother
+                                     * cell. However, this also means
+                                     * that we have to first compute
+                                     * the restriction to the mother
+                                     * cell by addition from the
+                                     * child cells, and afterwards
+                                     * set them to the global
+                                     * vector. The same process,
+                                     * adding up the local
+                                     * contributions to the global
+                                     * vector is not possible since
+                                     * we do not know how many coarse
+                                     * cells contribute to nodes on
+                                     * the boundary.
+                                     *
+                                     * In contrast to the
+                                     * non-additive mode described
+                                     * above, which is the simplest
+                                     * way for elements can be
+                                     * interpolated from its
+                                     * children, interpolation is not
+                                     * possible for piecewise
+                                     * constant elements, to name
+                                     * only one example.  Here, the
+                                     * value on the mother cell has
+                                     * to be taken the average of the
+                                     * values on the children,
+                                     * i.e. all children contribute
+                                     * alike to the one degree of
+                                     * freedom. Here, we have to sum
+                                     * up the contributions of all
+                                     * child cells with the same
+                                     * weight, and the non-additive
+                                     * mode of above would only set
+                                     * the value on the mother cell
+                                     * to the value of one of the
+                                     * child cell, irrespective of
+                                     * the values on the other cells.
+                                     *
+                                     * Similarly, for discontinuous
+                                     * linear elements, it might be
+                                     * better to not interpolate the
+                                     * values at the corners from the
+                                     * child cells, but to take a
                                      * better average, for example
-                                     * interpolating at the centers of the
-                                     * child cells; in that case, the
-                                     * contributions of the child cells
-                                     * have to be additive as well.
-                                     *
-                                     * Given these notes, the flag under
-                                     * consideration has to be set to #false#
-                                     * for the usual continuous Lagrange
-                                     * elements, and #true# for the other
-                                     * cases mentioned above. The main function
-                                     * where it is used is
+                                     * interpolating at the centers
+                                     * of the child cells; in that
+                                     * case, the contributions of the
+                                     * child cells have to be
+                                     * additive as well.
+                                     *
+                                     * Given these notes, the flag
+                                     * under consideration has to be
+                                     * set to #false# for the usual
+                                     * continuous Lagrange elements,
+                                     * and #true# for the other cases
+                                     * mentioned above. The main
+                                     * function where it is used is
                                      * #DoFAccessor::get_interpolated_dof_values#.
-                                     * There is one flag per component.
+                                     * There is one flag per
+                                     * component.
                                      */
     const vector<bool> restriction_is_additive_flags;    
 };
@@ -664,11 +696,11 @@ class FiniteElementBase : public Subscriptor,
 
 
 /**
- * Finite Element in any dimension. This class declares the functionality
- * to fill the fields of the #FiniteElementBase# class. Since this is
- * something that depends on the actual finite element, the functions are
- * declared virtual if it is not possible to provide a reasonable standard
- * implementation.
+ * Finite Element in any dimension. This class declares the
+ * functionality to fill the fields of the #FiniteElementBase#
+ * class. Since this is something that depends on the actual finite
+ * element, the functions are declared virtual if it is not possible
+ * to provide a reasonable standard implementation.
  *
  *
  * \subsection{Finite elements in one dimension}

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.