]> https://gitweb.dealii.org/ - dealii.git/commitdiff
Small changes and doc updates.
authorWolfgang Bangerth <bangerth@math.tamu.edu>
Mon, 27 Apr 1998 09:27:36 +0000 (09:27 +0000)
committerWolfgang Bangerth <bangerth@math.tamu.edu>
Mon, 27 Apr 1998 09:27:36 +0000 (09:27 +0000)
git-svn-id: https://svn.dealii.org/trunk@195 0785d39b-7218-0410-832d-ea1e28bc413d

deal.II/deal.II/include/dofs/dof_handler.h
deal.II/deal.II/include/grid/tria_boundary.h
deal.II/deal.II/include/numerics/assembler.h
deal.II/deal.II/include/numerics/base.h

index 741b41aa9b19aa536cdad5ef7e300be095703728..08fcc2d66b06e552a420f48a761e868d4815898e 100644 (file)
@@ -5,7 +5,6 @@
 /*----------------------------   dof.h     ---------------------------*/
 
 #include <vector>
-#include <fe/fe.h>
 #include <base/exceptions.h>
 
 
@@ -27,6 +26,8 @@ template <int dim, class Accessor> class TriaActiveIterator;
 
 template <int dim> class Triangulation;
 
+template <int dim> class FiniteElementBase;
+
 class dVector;
 class dSMatrix;
 class dSMatrixStruct;
@@ -468,7 +469,7 @@ class DoFHandler : public DoFDimensionInfo<dim> {
                                      * don't need them after calling this
                                      * function, or if so store them.
                                      */
-    void distribute_dofs (const FiniteElement<dim> &);
+    void distribute_dofs (const FiniteElementBase<dim> &);
 
                                     /**
                                      * Renumber the degrees of freedom according
@@ -999,7 +1000,7 @@ class DoFHandler : public DoFDimensionInfo<dim> {
                                      * Return a constant reference to the
                                      * selected finite element object.
                                      */
-    const FiniteElement<dim> & get_selected_fe () const;
+    const FiniteElementBase<dim> & get_selected_fe () const;
 
                                     /**
                                      * Return a constant reference to the
@@ -1065,18 +1066,24 @@ class DoFHandler : public DoFDimensionInfo<dim> {
                                      * Reserve enough space in the 
                                      * #levels[]# objects to store the
                                      * numbers of the degrees of freedom
-                                     * needed for the given element.
+                                     * needed for the given element. The
+                                     * given element is that one which
+                                     * was selected when calling
+                                     * #distribute_dofs# the last time.
                                      */
-    void reserve_space (const FiniteElement<dim> &);
+    void reserve_space ();
 
                                     /**
                                      * Distribute dofs on the given cell,
                                      * with new dofs starting with index
                                      * #next_free_dof#. Return the next
-                                     * unused index number.
+                                     * unused index number. The finite
+                                     * element used is the one given to
+                                     * #distribute_dofs#, which is copied
+                                     * to #selected_fe#.
+                                     *
                                      */
     int distribute_dofs_on_cell (active_cell_iterator &cell,
-                                const FiniteElement<dim> &fe,
                                 unsigned int next_free_dof);
 
                                     /**
@@ -1121,15 +1128,13 @@ class DoFHandler : public DoFDimensionInfo<dim> {
                                     /**
                                      * Store a copy of the finite element given
                                      * latest for the distribution of dofs. In
-                                     * fact, since the FE class itself has not
-                                     * much functionality, this object only
+                                     * fact, since the FE base class itself has
+                                     * not much functionality, this object only
                                      * stores numbers such as the number of
-                                     * dofs per line etc. Calling any of the
-                                     * more specific functions will result in
-                                     * an error about calling a pure virtual
-                                     * function.
+                                     * dofs per line, but also restriction
+                                     * and prolongation matrices, etc.
                                      */
-    FiniteElement<dim>       *selected_fe;
+    const FiniteElementBase<dim>   *selected_fe;
 
                                     /**
                                      * Store the number of dofs created last
index 4df6ee48e2fef017d23e0c05c00e2cec39bb85ed..ae9f05541d2e58f1a37062d801244ebe4d823328 100644 (file)
@@ -56,6 +56,11 @@ class Boundary {
     Specialisation of \Ref{Boundary}<dim>, which places the new point right
     into the middle of the given points. The middle is defined as the
     arithmetic mean of the points.
+
+    This class does not really describe a boundary in the usual sense. By
+    placing new points in teh middle of old ones, it rather assumes that the
+    boundary of the domain is given by the polygon/polyhedron defined by the
+    boundary of the initial coarse triangulation.
     */
 template <int dim>
 class StraightBoundary : public Boundary<dim> {
index 6ca23f3edd0b8711c600c8a6146796194e949321..20cca022bb048716a996a357f77e99947c03e476 100644 (file)
@@ -109,7 +109,7 @@ struct AssemblerData {
                   dVector                  &rhs_vector,
                   const Quadrature<dim>    &quadrature,
                   const FiniteElement<dim> &fe,
-                  const UpdateFields       &update_flags,
+                  const UpdateFlags       &update_flags,
                   const Boundary<dim>      &boundary);
     
                                     /**
@@ -155,7 +155,7 @@ struct AssemblerData {
                                      * FEValues object need to be reinitialized
                                      * on each cell.
                                      */
-    const UpdateFields       update_flags;
+    const UpdateFlags       update_flags;
 
                                     /**
                                      * Store a pointer to the object describing
index b4cf45b0365adfec10c063009e28644ff01f083c..03d682b35abaf7c2e19cde6a8b03cdb97bec17fa 100644 (file)
@@ -8,6 +8,7 @@
 #include <lac/dsmatrix.h>
 #include <base/exceptions.h>
 #include <grid/dof_constraints.h>
+#include <fe/fe_update_flags.h>
 #include <map>
 
 
@@ -25,7 +26,6 @@ template <int dim> class StraightBoundary;
 
 
 
-
 /**
    Denote which norm/integral is to be computed. The following possibilities
    are implemented:
@@ -83,8 +83,7 @@ enum NormType {
   since for higher order finite elements, we may be tempted to use curved faces
   of cells for better approximation of the boundary. In this case, the
   transformation from the unit cell to the real cell requires knowledge of
-  the exact boundary of the domain. By default it is assumed that the
-  boundary be approximated by straight segments.
+  the exact boundary of the domain.
   
 
   {\bf Solving}
@@ -106,7 +105,7 @@ enum NormType {
 
   Usually, all other boundary conditions, such as inhomogeneous Neumann values
   or mixed boundary conditions are handled in the weak formulation. No attempt
-  is made to include this into the process of assemblage therefore.
+  is made to include these into the process of assemblage therefore.
 
   The inclusion into the assemblage process is as follows: when the matrix and
   vectors are set up, a list of nodes subject to dirichlet bc is made and
@@ -165,6 +164,14 @@ enum NormType {
   This can be done by overloading the virtual function
   #make_boundary_value_list# which must return a list of boundary dofs
   and their corresponding values.
+
+  You should be aware that the boundary function may be evaluated at nodes
+  on the interior of faces. These, however, need not be on the true
+  boundary, but rather are on the approximation of the boundary represented
+  by teh mapping of the unit cell to the real cell. Since this mapping will
+  in most cases not be the exact one at the face, the boundary function is
+  evaluated at points which are not on the boundary and you should make
+  sure that the returned values are reasonable in some sense anyway.
   
 
   {\bf Computing errors}
@@ -301,7 +308,7 @@ class ProblemBase {
     virtual void assemble (const Equation<dim>      &equation,
                           const Quadrature<dim>    &q,
                           const FiniteElement<dim> &fe,
-                          const UpdateFields       &update_flags,
+                          const UpdateFlags        &update_flags,
                           const DirichletBC        &dirichlet_bc = DirichletBC(),
                           const Boundary<dim>      &boundary = StraightBoundary<dim>());
     

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.