]> https://gitweb.dealii.org/ - dealii.git/commitdiff
Mainly doc updates.
authorWolfgang Bangerth <bangerth@math.tamu.edu>
Mon, 18 May 1998 08:39:18 +0000 (08:39 +0000)
committerWolfgang Bangerth <bangerth@math.tamu.edu>
Mon, 18 May 1998 08:39:18 +0000 (08:39 +0000)
git-svn-id: https://svn.dealii.org/trunk@303 0785d39b-7218-0410-832d-ea1e28bc413d

deal.II/deal.II/include/numerics/matrices.h
deal.II/deal.II/include/numerics/vectors.h

index bdfe0a2745c3ab14a64e377b1a268a6da197e663..de9b94d9db613e076773853e9798e6f03fddf44b 100644 (file)
@@ -65,6 +65,18 @@ class dSMatrix;
  *   This function uses the #LaplaceMatrix# class.
  * \end{itemize}
  *
+ * All created matrices are `raw': they are not condensed, i.e. hanging
+ * nodes are not eliminated. The reason is that you may want to add
+ * several matrices and could then condense afterwards only once,
+ * instead of for every matrix. To actually do computations with these
+ * matrices, you have to condense the matrix using the
+ * #ConstraintMatrix::condense# function; you also have to condense the
+ * right hand side accordingly and distribute the solution afterwards.
+ *
+ * If you want to use boundary conditions, you have to use a function
+ * like #ProblemBase<>::apply_dirichlet_bc# to matrix and right hand
+ * side.
+ *
  *
  * \subsection{Right hand sides}
  *
index 6039f447caeb49a900d68d5eb4edff7b02963640..c821ddd9d257827189430144ab0a0647ff4918d3 100644 (file)
@@ -19,6 +19,45 @@ class dVector;
  * Provide a class which assembles some standard vectors. Among these are
  * interpolations and projections of continuous functions to the finite
  * element space and other operations.
+ *
+ *
+ * \subsection{Description of operations}
+ *
+ * This collection of methods offers the following operations:
+ * \begin{itemize}
+ * \item Interpolation: assign each degree of freedom in the vector to be
+ *   created the value of the function given as argument. This is identical
+ *   to saying that the resulting finite element function (which is isomorphic
+ *   to the output vector) has exact function values in all off-points of
+ *   ansatz functions. The off-point of an ansatz function is the point where
+ *   it assumes its nominal value, e.g. for linear ansatz functions the
+ *   off-points are th corners of an element. This function therefore relies
+ *   on the assumption that a finite element is used for which the degrees
+ *   of freedom are function values (Lagrange elements) rather than gradients,
+ *   normal derivatives, second derivatives, etc (Hermite elements, quintic
+ *   Argyris element, etc.).
+ *
+ *   It seems inevitable that some values of the vector to be created are set
+ *   twice or even more than that. The reason is that we have to loop over
+ *   all cells and get the function values for each of the ansatz functions
+ *   located thereon. This applies also to the functions located on faces and
+ *   corners which we thus visit more than once. While setting the value
+ *   in the vector is not an expensive operation, the evaluation of the
+ *   given function may be, taking into account that a virtual function has
+ *   to be called.
+ *
+ * \item Projection: compute the $L_2$-projection of the given function onto
+ *   the finite element space. This is done through the solution of the
+ *   linear system of equations $M v = f$ where $M$ is the mass matrix
+ *   $m_{ij} = \int_\Omega \phi_i(x) \phi_j(x) dx$ and
+ *   $f_i = \int_\Omega f(x) \phi_i(x) dx$. The solution vector $v$ then is
+ *   the projection.
+ *
+ *   The solution of the linear system is presently done using a simple CG
+ *   method without preconditioning and without multigrid. This is clearly not
+ *   too efficient, but sufficient in many cases and simple to implement. This
+ *   detail may change in the future.
+ * \end{itemize}
  */
 template <int dim>
 class VectorCreator {
@@ -27,15 +66,22 @@ class VectorCreator {
                                      * Compute the interpolation of
                                      * #function# at the ansatz points to
                                      * the finite element space.
+                                     *
+                                     * See the general documentation of this
+                                     * class for further information.
                                      */
     static void interpolate (const DoFHandler<dim>    &dof,
                             const FiniteElement<dim> &fe,
+                            const Boundary<dim>      &boundary,
                             const Function<dim>      &function,
                             dVector                  &vec);
 
                                     /**
                                      * Compute the projection of
                                      * #function# to the finite element space.
+                                     *
+                                     * See the general documentation of this
+                                     * class for further information.
                                      */
     static void project (const DoFHandler<dim>    &dof,
                         const ConstraintMatrix   &constraints,

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.