]> https://gitweb.dealii.org/ - dealii-svn.git/commitdiff
Remove redundant parameters to many functions in the Matrix- and VectorTools library...
authorwolf <wolf@0785d39b-7218-0410-832d-ea1e28bc413d>
Mon, 22 Feb 1999 12:14:52 +0000 (12:14 +0000)
committerwolf <wolf@0785d39b-7218-0410-832d-ea1e28bc413d>
Mon, 22 Feb 1999 12:14:52 +0000 (12:14 +0000)
git-svn-id: https://svn.dealii.org/trunk@869 0785d39b-7218-0410-832d-ea1e28bc413d

deal.II/deal.II/Attic/examples/convergence/convergence.cc
deal.II/deal.II/Attic/examples/error-estimation/error-estimation.cc
deal.II/deal.II/Attic/examples/multigrid/multigrid.cc
deal.II/deal.II/include/numerics/matrices.h
deal.II/deal.II/include/numerics/vectors.h
deal.II/deal.II/source/numerics/base.cc
deal.II/deal.II/source/numerics/matrices.cc
deal.II/deal.II/source/numerics/vectors.cc
tests/big-tests/convergence/convergence.cc
tests/big-tests/error-estimation/error-estimation.cc
tests/big-tests/multigrid/multigrid.cc

index 80aa35ae60a9ab68ddb432cbf91e8d65f1e63cbb..b3a337327729b9dcf276838e9552c70eeb8a1bbc 100644 (file)
@@ -39,13 +39,13 @@ class PoissonEquation :  public Equation<dim> {
     virtual void assemble (dFMatrix            &cell_matrix,
                           dVector             &rhs,
                           const FEValues<dim> &fe_values,
-                          const Triangulation<dim>::cell_iterator &cell) const;
+                          const DoFHandler<dim>::cell_iterator &cell) const;
     virtual void assemble (dFMatrix            &cell_matrix,
                           const FEValues<dim> &fe_values,
-                          const Triangulation<dim>::cell_iterator &cell) const;
+                          const DoFHandler<dim>::cell_iterator &cell) const;
     virtual void assemble (dVector             &rhs,
                           const FEValues<dim> &fe_values,
-                          const Triangulation<dim>::cell_iterator &cell) const;
+                          const DoFHandler<dim>::cell_iterator &cell) const;
   protected:
     const Function<dim> &right_hand_side;
 };
@@ -152,7 +152,7 @@ template <>
 void PoissonEquation<2>::assemble (dFMatrix            &cell_matrix,
                                   dVector             &rhs,
                                   const FEValues<2>   &fe_values,
-                                  const Triangulation<2>::cell_iterator &) const {
+                                  const DoFHandler<2>::cell_iterator &) const {
   for (unsigned int point=0; point<fe_values.n_quadrature_points; ++point)
     for (unsigned int i=0; i<fe_values.total_dofs; ++i) 
       {
@@ -171,7 +171,7 @@ void PoissonEquation<2>::assemble (dFMatrix            &cell_matrix,
 template <int dim>
 void PoissonEquation<dim>::assemble (dFMatrix            &,
                                     const FEValues<dim> &,
-                                    const Triangulation<dim>::cell_iterator &) const {
+                                    const DoFHandler<dim>::cell_iterator &) const {
   Assert (false, ExcPureVirtualFunctionCalled());
 };
 
@@ -180,7 +180,7 @@ void PoissonEquation<dim>::assemble (dFMatrix            &,
 template <int dim>
 void PoissonEquation<dim>::assemble (dVector             &,
                                     const FEValues<dim> &,
-                                    const Triangulation<dim>::cell_iterator &) const {
+                                    const DoFHandler<dim>::cell_iterator &) const {
   Assert (false, ExcPureVirtualFunctionCalled());
 };
 
@@ -337,7 +337,7 @@ int PoissonProblem<dim>::run (const unsigned int level) {
   VectorTools<dim>::integrate_difference (*dof_handler,
                                          solution, sol,
                                          l1_error_per_cell,
-                                         *quadrature, *fe, L1_norm);
+                                         *quadrature, L1_norm);
   cout << l1_error_per_cell.l1_norm() << endl;
   l1_error.push_back (l1_error_per_cell.l1_norm());
 
@@ -345,7 +345,7 @@ int PoissonProblem<dim>::run (const unsigned int level) {
   VectorTools<dim>::integrate_difference (*dof_handler,
                                          solution, sol,
                                          l2_error_per_cell,
-                                         *quadrature, *fe, L2_norm);
+                                         *quadrature, L2_norm);
   cout << l2_error_per_cell.l2_norm() << endl;
   l2_error.push_back (l2_error_per_cell.l2_norm());
 
@@ -353,7 +353,7 @@ int PoissonProblem<dim>::run (const unsigned int level) {
   VectorTools<dim>::integrate_difference (*dof_handler,
                                          solution, sol,
                                          linfty_error_per_cell,
-                                         *quadrature, *fe, Linfty_norm);
+                                         *quadrature, Linfty_norm);
   cout << linfty_error_per_cell.linfty_norm() << endl;
   linfty_error.push_back (linfty_error_per_cell.linfty_norm());
   
@@ -361,7 +361,7 @@ int PoissonProblem<dim>::run (const unsigned int level) {
   VectorTools<dim>::integrate_difference (*dof_handler,
                                          solution, sol,
                                          h1_seminorm_error_per_cell,
-                                         *quadrature, *fe, H1_seminorm);
+                                         *quadrature, H1_seminorm);
   cout << h1_seminorm_error_per_cell.l2_norm() << endl;
   h1_seminorm_error.push_back (h1_seminorm_error_per_cell.l2_norm());
 
@@ -369,7 +369,7 @@ int PoissonProblem<dim>::run (const unsigned int level) {
   VectorTools<dim>::integrate_difference (*dof_handler,
                                          solution, sol,
                                          h1_error_per_cell,
-                                         *quadrature, *fe, H1_norm);
+                                         *quadrature, H1_norm);
   cout << h1_error_per_cell.l2_norm() << endl;
   h1_error.push_back (h1_error_per_cell.l2_norm());
 
index ea856cbbe119323cb5fbf9a5eb118a197b4002bc..54e1c13f2d2f8da68de1f14f25aabb41462eecc7 100644 (file)
@@ -472,7 +472,7 @@ void PoissonProblem<dim>::run (ParameterHandler &prm) {
       cout << "    Calculating L2 error... ";
       VectorTools<dim>::integrate_difference (*dof_handler,
                                              solution, *solution_function,
-                                             l2_error_per_cell, q, fe,
+                                             l2_error_per_cell, q,
                                              L2_norm);
       cout << l2_error_per_cell.l2_norm() << endl;
       l2_error.push_back (l2_error_per_cell.l2_norm());
@@ -480,7 +480,7 @@ void PoissonProblem<dim>::run (ParameterHandler &prm) {
       cout << "    Calculating L-infinity error... ";
       VectorTools<dim>::integrate_difference (*dof_handler,
                                              solution, *solution_function,
-                                             linfty_error_per_cell, q, fe,
+                                             linfty_error_per_cell, q,
                                              Linfty_norm);
       cout << linfty_error_per_cell.linfty_norm() << endl;
       linfty_error.push_back (linfty_error_per_cell.linfty_norm());
@@ -488,7 +488,7 @@ void PoissonProblem<dim>::run (ParameterHandler &prm) {
       cout << "    Calculating H1 error... ";
       VectorTools<dim>::integrate_difference (*dof_handler,
                                              solution, *solution_function,
-                                             h1_error_per_cell, q, fe,
+                                             h1_error_per_cell, q, 
                                              H1_norm);
       cout << h1_error_per_cell.l2_norm() << endl;
       h1_error.push_back (h1_error_per_cell.l2_norm());
index 9061524b50229353d7a73240c582b8afc60f6365..b3d4c57e96167d543205bee0382d614b09d114b8 100644 (file)
@@ -44,13 +44,13 @@ class PoissonEquation :  public Equation<dim> {
     virtual void assemble (dFMatrix            &cell_matrix,
                           dVector             &rhs,
                           const FEValues<dim> &fe_values,
-                          const Triangulation<dim>::cell_iterator &cell) const;
+                          const DoFHandler<dim>::cell_iterator &cell) const;
     virtual void assemble (dFMatrix            &cell_matrix,
                           const FEValues<dim> &fe_values,
-                          const Triangulation<dim>::cell_iterator &cell) const;
+                          const DoFHandler<dim>::cell_iterator &cell) const;
     virtual void assemble (dVector             &rhs,
                           const FEValues<dim> &fe_values,
-                          const Triangulation<dim>::cell_iterator &cell) const;
+                          const DoFHandler<dim>::cell_iterator &cell) const;
   protected:
     const Function<dim> &right_hand_side;
 };
@@ -231,7 +231,7 @@ template <>
 void PoissonEquation<2>::assemble (dFMatrix            &cell_matrix,
                                   dVector             &rhs,
                                   const FEValues<2>   &fe_values,
-                                  const Triangulation<2>::cell_iterator &) const {
+                                  const DoFHandler<2>::cell_iterator &) const {
   for (unsigned int point=0; point<fe_values.n_quadrature_points; ++point)
     for (unsigned int i=0; i<fe_values.total_dofs; ++i) 
       {
@@ -250,7 +250,7 @@ void PoissonEquation<2>::assemble (dFMatrix            &cell_matrix,
 template <int dim>
 void PoissonEquation<dim>::assemble (dFMatrix            &,
                                     const FEValues<dim> &,
-                                    const Triangulation<dim>::cell_iterator &) const {
+                                    const DoFHandler<dim>::cell_iterator &) const {
   Assert (false, ExcPureVirtualFunctionCalled());
 };
 
@@ -259,7 +259,7 @@ void PoissonEquation<dim>::assemble (dFMatrix            &,
 template <int dim>
 void PoissonEquation<dim>::assemble (dVector             &,
                                     const FEValues<dim> &,
-                                    const Triangulation<dim>::cell_iterator &) const {
+                                    const DoFHandler<dim>::cell_iterator &) const {
   Assert (false, ExcPureVirtualFunctionCalled());
 };
 
@@ -379,8 +379,7 @@ void PoissonProblem<dim>::assemble (const Equation<dim>      &equation,
                                   // apply Dirichlet bc as described
                                   // in the docs
   map<int, double> boundary_value_list;
-  VectorTools<dim>::interpolate_boundary_values (*dof,
-                                                dirichlet_bc, fe, boundary,
+  VectorTools<dim>::interpolate_boundary_values (*dof, dirichlet_bc, boundary,
                                                 boundary_value_list);
   MatrixTools<dim>::apply_boundary_values (boundary_value_list,
                                           system_matrix, solution,
@@ -494,7 +493,7 @@ int PoissonProblem<dim>::run (const unsigned int level) {
   VectorTools<dim>::integrate_difference (*dof,
                                          solution, sol,
                                          l1_error_per_cell,
-                                         *quadrature, *fe, L1_norm);
+                                         *quadrature, L1_norm);
   cout << l1_error_per_cell.l1_norm() << endl;
   l1_error.push_back (l1_error_per_cell.l1_norm());
 
@@ -502,7 +501,7 @@ int PoissonProblem<dim>::run (const unsigned int level) {
   VectorTools<dim>::integrate_difference (*dof,
                                          solution, sol,
                                          l2_error_per_cell,
-                                         *quadrature, *fe, L2_norm);
+                                         *quadrature, L2_norm);
   cout << l2_error_per_cell.l2_norm() << endl;
   l2_error.push_back (l2_error_per_cell.l2_norm());
 
@@ -510,7 +509,7 @@ int PoissonProblem<dim>::run (const unsigned int level) {
   VectorTools<dim>::integrate_difference (*dof,
                                          solution, sol,
                                          linfty_error_per_cell,
-                                         *quadrature, *fe, Linfty_norm);
+                                         *quadrature, Linfty_norm);
   cout << linfty_error_per_cell.linfty_norm() << endl;
   linfty_error.push_back (linfty_error_per_cell.linfty_norm());
   
@@ -518,7 +517,7 @@ int PoissonProblem<dim>::run (const unsigned int level) {
   VectorTools<dim>::integrate_difference (*dof,
                                          solution, sol,
                                          h1_seminorm_error_per_cell,
-                                         *quadrature, *fe, H1_seminorm);
+                                         *quadrature, H1_seminorm);
   cout << h1_seminorm_error_per_cell.l2_norm() << endl;
   h1_seminorm_error.push_back (h1_seminorm_error_per_cell.l2_norm());
 
@@ -526,7 +525,7 @@ int PoissonProblem<dim>::run (const unsigned int level) {
   VectorTools<dim>::integrate_difference (*dof,
                                          solution, sol,
                                          h1_error_per_cell,
-                                         *quadrature, *fe, H1_norm);
+                                         *quadrature, H1_norm);
   cout << h1_error_per_cell.l2_norm() << endl;
   h1_error.push_back (h1_error_per_cell.l2_norm());
 
index 89f4df8269531e66d009667bd3b4424b4b785ef2..d5e9b088fca3e41a3f235e2ca0bff002895949bd 100644 (file)
@@ -154,6 +154,10 @@ class dSMatrix;
  * useful if you want to create many right hand side vectors.
  *
  *
+ * All functions in this collection use the finite elemen given to the
+ * #DoFHandler# object the last time that the degrees of freedom were
+ * distributed on the triangulation.
+ *
  * @author Wolfgang Bangerth, 1998
  */
 template <int dim>
@@ -190,7 +194,6 @@ class MatrixCreator {
                                      * for more information.
                                      */
     static void create_mass_matrix (const DoFHandler<dim>    &dof,
-                                   const FiniteElement<dim> &fe,
                                    const Quadrature<dim>    &q,
                                    const Boundary<dim>      &boundary,
                                    dSMatrix                 &matrix,
@@ -214,7 +217,6 @@ class MatrixCreator {
                                      * for more information.
                                      */
     static void create_mass_matrix (const DoFHandler<dim>    &dof,
-                                   const FiniteElement<dim> &fe,
                                    const Quadrature<dim>    &q,
                                    const Boundary<dim>      &boundary,
                                    dSMatrix                 &matrix,
@@ -242,7 +244,6 @@ class MatrixCreator {
                                      * for more information.
                                      */
     static void create_mass_matrix (const DoFHandler<dim>    &dof,
-                                   const FiniteElement<dim> &fe,
                                    const Boundary<dim>      &boundary,
                                    dSMatrix                 &matrix);
     
@@ -262,7 +263,6 @@ class MatrixCreator {
                                      * for more information.
                                      */
     static void create_boundary_mass_matrix (const DoFHandler<dim>    &dof,
-                                            const FiniteElement<dim> &fe,
                                             const Quadrature<dim-1>  &q,
                                             const Boundary<dim>      &boundary,
                                             dSMatrix                 &matrix,
@@ -280,7 +280,6 @@ class MatrixCreator {
                                      * for more information.
                                      */
     static void create_laplace_matrix (const DoFHandler<dim>    &dof,
-                                      const FiniteElement<dim> &fe,
                                       const Quadrature<dim>    &q,
                                       const Boundary<dim>      &boundary,
                                       dSMatrix &matrix,
@@ -296,7 +295,6 @@ class MatrixCreator {
                                      * for more information.
                                      */
     static void create_laplace_matrix (const DoFHandler<dim>    &dof,
-                                      const FiniteElement<dim> &fe,
                                       const Quadrature<dim>    &q,
                                       const Boundary<dim>      &boundary,
                                       dSMatrix &matrix,
@@ -304,14 +302,14 @@ class MatrixCreator {
                                       dVector                  &rhs_vector,
                                       const Function<dim>      *a = 0);
 
-                                  /**
-                                   * Build Lagrange interpolation
-                                   matrix of different finite
-                                   elements.
-                                  */
-  static void create_interpolation_matrix(const FiniteElement<dim> &high,
-                                         const FiniteElement<dim> &low,
-                                         dFMatrix& result);
+                                    /**
+                                     * Build Lagrange interpolation
+                                     * matrix of different finite
+                                     * elements.
+                                     */
+    static void create_interpolation_matrix(const FiniteElement<dim> &high,
+                                           const FiniteElement<dim> &low,
+                                           dFMatrix& result);
 
 
                                     /**
index 1db1ff93dbdd9992214f35558d4ba3e894d30c0f..8a32f053c3e85533a3f0133d2ae0fe73b5e5f3dc 100644 (file)
@@ -245,6 +245,8 @@ enum NormType {
  *   $L_2$ norm: compute the $l_2$ norm of the cell error vector.
  * \end{itemize}
  *
+ * All functions use the finite element given to the #DoFHandler# object the last
+ * time that the degrees of freedom were distributed over the triangulation.
  *
  * @author Wolfgang Bangerth, 1998
  */
@@ -274,28 +276,27 @@ class VectorTools {
                                      * 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);
 
-                                  /**
-                                   * Interpolate different finite element
-                                   * spaces. The interpolation is
-                                   * executed from the higher order
-                                   * space represented by #high# to
-                                   the lower order space
-                                   #low#. The interpolation on each
-                                   cell is represented by the matrix
-                                   #transfer#. Curved boundaries are
-                                   neglected so far.
-                                  */
-  static void interpolate(const DoFHandler<dim>    &high_dof,
-                         const DoFHandler<dim>    &low_dof,
-                         const dFMatrix& transfer,
-                         const dVector& high,
-                         dVector& low);
-  
+                                    /**
+                                     * Interpolate different finite
+                                     * element spaces. The
+                                     * interpolation is executed from
+                                     * the higher order space
+                                     * represented by #high# to the
+                                     * lower order space #low#. The
+                                     * interpolation on each cell is
+                                     * represented by the matrix
+                                     * #transfer#. Curved boundaries
+                                     * are neglected so far.
+                                     */
+    static void interpolate(const DoFHandler<dim>    &high_dof,
+                           const DoFHandler<dim>    &low_dof,
+                           const dFMatrix           &transfer,
+                           const dVector            &high,
+                           dVector                  &low);
                          
                                     /**
                                      * Compute the projection of
@@ -315,7 +316,6 @@ class VectorTools {
                                      */
     static void project (const DoFHandler<dim>    &dof,
                         const ConstraintMatrix   &constraints,
-                        const FiniteElement<dim> &fe,
                         const Boundary<dim>      &boundary,
                         const Quadrature<dim>    &q,
                         const Function<dim>      &function,
@@ -331,7 +331,6 @@ class VectorTools {
                                      * class for further information.
                                      */                                      
     static void create_right_hand_side (const DoFHandler<dim>    &dof,
-                                       const FiniteElement<dim> &fe,
                                        const Quadrature<dim>    &q,
                                        const Boundary<dim>      &boundary,
                                        const Function<dim>      &rhs,
@@ -354,9 +353,8 @@ class VectorTools {
                                      */
     static void interpolate_boundary_values (const DoFHandler<dim> &dof,
                                             const FunctionMap     &dirichlet_bc,
-                                            const FiniteElement<dim> &fe,
-                                            const Boundary<dim> &boundary,
-                                            map<int,double>     &boundary_values);
+                                            const Boundary<dim>   &boundary,
+                                            map<int,double>       &boundary_values);
     
                                     /**
                                      * Project #function# to the boundary
@@ -373,7 +371,6 @@ class VectorTools {
                                      */
     static void project_boundary_values (const DoFHandler<dim>    &dof,
                                         const FunctionMap        &boundary_functions,
-                                        const FiniteElement<dim> &fe,
                                         const Quadrature<dim-1>  &q,
                                         const Boundary<dim>      &boundary,
                                         map<int,double>          &boundary_values);
@@ -393,7 +390,6 @@ class VectorTools {
                                      const Function<dim>      &exact_solution,
                                      dVector                  &difference,
                                      const Quadrature<dim>    &q,
-                                     const FiniteElement<dim> &fe,
                                      const NormType           &norm,
                                      const Boundary<dim> &boundary=StraightBoundary<dim>());
 
index 6b6adfcedad3b7aba9f2a5bf48ad9e8ed633b29a..edbbb09f573b9358b7892e06ecb4b25a9e3e8ad6 100644 (file)
@@ -126,7 +126,7 @@ void ProblemBase<dim>::assemble (const Equation<dim>      &equation,
                                   // in the docs
   map<int, double> boundary_value_list;
   VectorTools<dim>::interpolate_boundary_values (*dof_handler,
-                                                dirichlet_bc, fe, boundary,
+                                                dirichlet_bc, boundary,
                                                 boundary_value_list);
   MatrixTools<dim>::apply_boundary_values (boundary_value_list,
                                           system_matrix, solution,
index 61ff2185f78cae4154d80124c7b6deee74785c3a..45cddee698d326dbe372de0e5d6e13f030a46147 100644 (file)
 
 template <int dim>
 void MatrixCreator<dim>::create_mass_matrix (const DoFHandler<dim>    &dof,
-                                            const FiniteElement<dim> &fe,
                                             const Quadrature<dim>    &q,
                                             const Boundary<dim>      &boundary,
                                             dSMatrix                 &matrix,
                                             const Function<dim> * const a) {
+  const FiniteElement<dim> &fe = dof.get_fe();
+
   dVector dummy;    // no entries, should give an error if accessed
   UpdateFlags update_flags = update_JxW_values;
   if (a != 0)
@@ -52,13 +53,14 @@ void MatrixCreator<dim>::create_mass_matrix (const DoFHandler<dim>    &dof,
 
 template <int dim>
 void MatrixCreator<dim>::create_mass_matrix (const DoFHandler<dim>    &dof,
-                                            const FiniteElement<dim> &fe,
                                             const Quadrature<dim>    &q,
                                             const Boundary<dim>      &boundary,
                                             dSMatrix                 &matrix,
                                             const Function<dim>      &rhs,
                                             dVector                  &rhs_vector,
                                             const Function<dim> * const a) {
+  const FiniteElement<dim> &fe = dof.get_fe();
+
   UpdateFlags update_flags = UpdateFlags(update_q_points |
                                         update_JxW_values);
   const AssemblerData<dim> data (dof,
@@ -82,9 +84,10 @@ void MatrixCreator<dim>::create_mass_matrix (const DoFHandler<dim>    &dof,
 
 template <int dim>
 void MatrixCreator<dim>::create_mass_matrix (const DoFHandler<dim>    &dof,
-                                            const FiniteElement<dim> &fe,
                                             const Boundary<dim>      &boundary,
                                             dSMatrix                 &matrix) {
+  const FiniteElement<dim> &fe = dof.get_fe();
+
   const unsigned int total_dofs = fe.total_dofs;
   
   dFMatrix    local_mass_matrix (total_dofs, total_dofs);
@@ -110,7 +113,6 @@ void MatrixCreator<dim>::create_mass_matrix (const DoFHandler<dim>    &dof,
 
 template <>
 void MatrixCreator<1>::create_boundary_mass_matrix (const DoFHandler<1>    &,
-                                                   const FiniteElement<1> &,
                                                    const Quadrature<0>    &,
                                                    const Boundary<1>      &,
                                                    dSMatrix               &,
@@ -127,7 +129,6 @@ void MatrixCreator<1>::create_boundary_mass_matrix (const DoFHandler<1>    &,
 
 template <int dim>
 void MatrixCreator<dim>::create_boundary_mass_matrix (const DoFHandler<dim>    &dof,
-                                                     const FiniteElement<dim> &fe,
                                                      const Quadrature<dim-1>  &q,
                                                      const Boundary<dim>      &boundary,
                                                      dSMatrix                 &matrix,
@@ -135,6 +136,8 @@ void MatrixCreator<dim>::create_boundary_mass_matrix (const DoFHandler<dim>    &
                                                      dVector                  &rhs_vector,
                                                      vector<int>              &dof_to_boundary_mapping,
                                                      const Function<dim>      *a) {
+  const FiniteElement<dim> &fe = dof.get_fe();
+
   Assert (matrix.n() == dof.n_boundary_dofs(rhs), ExcInternalError());
   Assert (matrix.n() == matrix.m(), ExcInternalError());
   Assert (matrix.n() == rhs_vector.size(), ExcInternalError());
@@ -321,11 +324,12 @@ void MatrixCreator<dim>::create_boundary_mass_matrix (const DoFHandler<dim>    &
 
 template <int dim>
 void MatrixCreator<dim>::create_laplace_matrix (const DoFHandler<dim>    &dof,
-                                               const FiniteElement<dim> &fe,
                                                const Quadrature<dim>    &q,
                                                const Boundary<dim>      &boundary,
                                                dSMatrix                 &matrix,
                                                const Function<dim> * const a) {
+  const FiniteElement<dim> &fe = dof.get_fe();
+
   dVector dummy;   // no entries, should give an error if accessed
   UpdateFlags update_flags = UpdateFlags(update_gradients |
                                         update_JxW_values);
@@ -352,13 +356,14 @@ void MatrixCreator<dim>::create_laplace_matrix (const DoFHandler<dim>    &dof,
 
 template <int dim>
 void MatrixCreator<dim>::create_laplace_matrix (const DoFHandler<dim>    &dof,
-                                               const FiniteElement<dim> &fe,
                                                const Quadrature<dim>    &q,
                                                const Boundary<dim>      &boundary,
                                                dSMatrix                 &matrix,
                                                const Function<dim>      &rhs,
                                                dVector                  &rhs_vector,
                                                const Function<dim> * const a) {
+  const FiniteElement<dim> &fe = dof.get_fe();
+
   UpdateFlags update_flags = UpdateFlags(update_q_points  |
                                         update_gradients |
                                         update_JxW_values);
index d21341c5ec38bd501640529998f8f9a8f820fdc3..9d8213c380d982632e6a1343c03839d339f3c494 100644 (file)
@@ -43,10 +43,12 @@ inline double sqr_point (const Tensor<1,dim> &p) {
 
 template <int dim>
 void VectorTools<dim>::interpolate (const DoFHandler<dim>    &dof,
-                                     const FiniteElement<dim> &fe,
-                                     const Boundary<dim>      &boundary,
-                                     const Function<dim>      &function,
-                                     dVector                  &vec) {
+                                   const Boundary<dim>      &boundary,
+                                   const Function<dim>      &function,
+                                   dVector                  &vec)
+{
+  const FiniteElement<dim> &fe = dof.get_fe();
+  
   DoFHandler<dim>::active_cell_iterator cell = dof.begin_active(),
                                        endc = dof.end();
   vector<int>         dofs_on_cell (fe.total_dofs);
@@ -72,10 +74,10 @@ void VectorTools<dim>::interpolate (const DoFHandler<dim>    &dof,
 
 template <int dim> void
 VectorTools<dim>::interpolate(const DoFHandler<dim>    &high_dof,
-                        const DoFHandler<dim>    &low_dof,
-                        const dFMatrix           &transfer,
-                        const dVector            &high,
-                        dVector                  &low)
+                             const DoFHandler<dim>    &low_dof,
+                             const dFMatrix           &transfer,
+                             const dVector            &high,
+                             dVector                  &low)
 {
   dVector cell_high(high_dof.get_fe().total_dofs);
   dVector cell_low(low_dof.get_fe().total_dofs);
@@ -97,7 +99,6 @@ VectorTools<dim>::interpolate(const DoFHandler<dim>    &high_dof,
 template <>
 void VectorTools<1>::project (const DoFHandler<1>    &,
                              const ConstraintMatrix &,
-                             const FiniteElement<1> &,
                              const Boundary<1>      &,
                              const Quadrature<1>    &,
                              const Function<1>      &,
@@ -122,7 +123,6 @@ void VectorTools<1>::project (const DoFHandler<1>    &,
 template <int dim>
 void VectorTools<dim>::project (const DoFHandler<dim>    &dof,
                                const ConstraintMatrix   &constraints,
-                               const FiniteElement<dim> &fe,
                                const Boundary<dim>      &boundary,
                                const Quadrature<dim>    &q,
                                const Function<dim>      &function,
@@ -130,7 +130,9 @@ void VectorTools<dim>::project (const DoFHandler<dim>    &dof,
                                const bool                enforce_zero_boundary,
                                const Quadrature<dim-1>  &q_boundary,
                                const bool                project_to_boundary_first) {
-                                  // make up boundary values
+  const FiniteElement<dim> &fe = dof.get_fe();
+
+                                  // make up boundary values
   map<int,double> boundary_values;
 
   if (enforce_zero_boundary == true) 
@@ -163,7 +165,7 @@ void VectorTools<dim>::project (const DoFHandler<dim>    &dof,
        FunctionMap boundary_functions;
        for (unsigned char c=0; c<255; ++c)
          boundary_functions[c] = &function;
-       project_boundary_values (dof, boundary_functions, fe, q_boundary,
+       project_boundary_values (dof, boundary_functions, q_boundary,
                                 boundary, boundary_values);
       };
 
@@ -179,8 +181,8 @@ void VectorTools<dim>::project (const DoFHandler<dim>    &dof,
   
   dSMatrix mass_matrix (sparsity);
   dVector tmp (mass_matrix.n());
-  MatrixCreator<dim>::create_mass_matrix (dof, fe, boundary, mass_matrix);
-  VectorTools<dim>::create_right_hand_side (dof, fe, q, boundary,
+  MatrixCreator<dim>::create_mass_matrix (dof, boundary, mass_matrix);
+  VectorTools<dim>::create_right_hand_side (dof, q, boundary,
                                            function, tmp);
 
   constraints.condense (mass_matrix);
@@ -203,11 +205,12 @@ void VectorTools<dim>::project (const DoFHandler<dim>    &dof,
 
 template <int dim>
 void VectorTools<dim>::create_right_hand_side (const DoFHandler<dim>    &dof,
-                                              const FiniteElement<dim> &fe,
                                               const Quadrature<dim>    &q,
                                               const Boundary<dim>      &boundary,
                                               const Function<dim>      &rhs,
                                               dVector                  &rhs_vector) {
+  const FiniteElement<dim> &fe = dof.get_fe();
+  
   UpdateFlags update_flags = UpdateFlags(update_q_points |
                                         update_JxW_values);
   dSMatrix dummy;
@@ -236,7 +239,6 @@ template <>
 void
 VectorTools<1>::interpolate_boundary_values (const DoFHandler<1> &,
                                             const FunctionMap &,
-                                            const FiniteElement<1> &,
                                             const Boundary<1> &,
                                             map<int,double>   &) {
   Assert (false, ExcNotImplemented());
@@ -250,11 +252,13 @@ template <int dim>
 void
 VectorTools<dim>::interpolate_boundary_values (const DoFHandler<dim> &dof,
                                               const FunctionMap     &dirichlet_bc,
-                                              const FiniteElement<dim> &fe,
                                               const Boundary<dim>      &boundary,
                                               map<int,double>   &boundary_values) {
   Assert (dirichlet_bc.find(255) == dirichlet_bc.end(),
          ExcInvalidBoundaryIndicator());
+
+  const FiniteElement<dim> &fe = dof.get_fe();
+
                                   // use two face iterators, since we need
                                   // a DoF-iterator for the dof indices, but
                                   // a Tria-iterator for the fe object
@@ -293,7 +297,6 @@ template <int dim>
 void
 VectorTools<dim>::project_boundary_values (const DoFHandler<dim>    &dof,
                                           const FunctionMap        &boundary_functions,
-                                          const FiniteElement<dim> &fe,
                                           const Quadrature<dim-1>  &q,
                                           const Boundary<dim>      &boundary,
                                           map<int,double>   &boundary_values) {
@@ -331,7 +334,7 @@ VectorTools<dim>::project_boundary_values (const DoFHandler<dim>    &dof,
   dVector        rhs(sparsity.n_rows());
   
 
-  MatrixTools<dim>::create_boundary_mass_matrix (dof, fe, q, boundary,
+  MatrixTools<dim>::create_boundary_mass_matrix (dof, q, boundary,
                                                 mass_matrix, boundary_functions,
                                                 rhs, dof_to_boundary_mapping);
 
@@ -371,11 +374,10 @@ void VectorTools<dim>::integrate_difference (const DoFHandler<dim>    &dof,
                                             const Function<dim>      &exact_solution,
                                             dVector                  &difference,
                                             const Quadrature<dim>    &q,
-                                            const FiniteElement<dim> &fe,
                                             const NormType           &norm,
                                             const Boundary<dim>      &boundary) {
-  Assert (fe == dof.get_fe(), ExcInvalidFE());
-  
+  const FiniteElement<dim> &fe = dof.get_fe();
+    
   difference.reinit (dof.get_tria().n_active_cells());
   
   UpdateFlags update_flags = UpdateFlags (update_q_points  |
index 80aa35ae60a9ab68ddb432cbf91e8d65f1e63cbb..b3a337327729b9dcf276838e9552c70eeb8a1bbc 100644 (file)
@@ -39,13 +39,13 @@ class PoissonEquation :  public Equation<dim> {
     virtual void assemble (dFMatrix            &cell_matrix,
                           dVector             &rhs,
                           const FEValues<dim> &fe_values,
-                          const Triangulation<dim>::cell_iterator &cell) const;
+                          const DoFHandler<dim>::cell_iterator &cell) const;
     virtual void assemble (dFMatrix            &cell_matrix,
                           const FEValues<dim> &fe_values,
-                          const Triangulation<dim>::cell_iterator &cell) const;
+                          const DoFHandler<dim>::cell_iterator &cell) const;
     virtual void assemble (dVector             &rhs,
                           const FEValues<dim> &fe_values,
-                          const Triangulation<dim>::cell_iterator &cell) const;
+                          const DoFHandler<dim>::cell_iterator &cell) const;
   protected:
     const Function<dim> &right_hand_side;
 };
@@ -152,7 +152,7 @@ template <>
 void PoissonEquation<2>::assemble (dFMatrix            &cell_matrix,
                                   dVector             &rhs,
                                   const FEValues<2>   &fe_values,
-                                  const Triangulation<2>::cell_iterator &) const {
+                                  const DoFHandler<2>::cell_iterator &) const {
   for (unsigned int point=0; point<fe_values.n_quadrature_points; ++point)
     for (unsigned int i=0; i<fe_values.total_dofs; ++i) 
       {
@@ -171,7 +171,7 @@ void PoissonEquation<2>::assemble (dFMatrix            &cell_matrix,
 template <int dim>
 void PoissonEquation<dim>::assemble (dFMatrix            &,
                                     const FEValues<dim> &,
-                                    const Triangulation<dim>::cell_iterator &) const {
+                                    const DoFHandler<dim>::cell_iterator &) const {
   Assert (false, ExcPureVirtualFunctionCalled());
 };
 
@@ -180,7 +180,7 @@ void PoissonEquation<dim>::assemble (dFMatrix            &,
 template <int dim>
 void PoissonEquation<dim>::assemble (dVector             &,
                                     const FEValues<dim> &,
-                                    const Triangulation<dim>::cell_iterator &) const {
+                                    const DoFHandler<dim>::cell_iterator &) const {
   Assert (false, ExcPureVirtualFunctionCalled());
 };
 
@@ -337,7 +337,7 @@ int PoissonProblem<dim>::run (const unsigned int level) {
   VectorTools<dim>::integrate_difference (*dof_handler,
                                          solution, sol,
                                          l1_error_per_cell,
-                                         *quadrature, *fe, L1_norm);
+                                         *quadrature, L1_norm);
   cout << l1_error_per_cell.l1_norm() << endl;
   l1_error.push_back (l1_error_per_cell.l1_norm());
 
@@ -345,7 +345,7 @@ int PoissonProblem<dim>::run (const unsigned int level) {
   VectorTools<dim>::integrate_difference (*dof_handler,
                                          solution, sol,
                                          l2_error_per_cell,
-                                         *quadrature, *fe, L2_norm);
+                                         *quadrature, L2_norm);
   cout << l2_error_per_cell.l2_norm() << endl;
   l2_error.push_back (l2_error_per_cell.l2_norm());
 
@@ -353,7 +353,7 @@ int PoissonProblem<dim>::run (const unsigned int level) {
   VectorTools<dim>::integrate_difference (*dof_handler,
                                          solution, sol,
                                          linfty_error_per_cell,
-                                         *quadrature, *fe, Linfty_norm);
+                                         *quadrature, Linfty_norm);
   cout << linfty_error_per_cell.linfty_norm() << endl;
   linfty_error.push_back (linfty_error_per_cell.linfty_norm());
   
@@ -361,7 +361,7 @@ int PoissonProblem<dim>::run (const unsigned int level) {
   VectorTools<dim>::integrate_difference (*dof_handler,
                                          solution, sol,
                                          h1_seminorm_error_per_cell,
-                                         *quadrature, *fe, H1_seminorm);
+                                         *quadrature, H1_seminorm);
   cout << h1_seminorm_error_per_cell.l2_norm() << endl;
   h1_seminorm_error.push_back (h1_seminorm_error_per_cell.l2_norm());
 
@@ -369,7 +369,7 @@ int PoissonProblem<dim>::run (const unsigned int level) {
   VectorTools<dim>::integrate_difference (*dof_handler,
                                          solution, sol,
                                          h1_error_per_cell,
-                                         *quadrature, *fe, H1_norm);
+                                         *quadrature, H1_norm);
   cout << h1_error_per_cell.l2_norm() << endl;
   h1_error.push_back (h1_error_per_cell.l2_norm());
 
index ea856cbbe119323cb5fbf9a5eb118a197b4002bc..54e1c13f2d2f8da68de1f14f25aabb41462eecc7 100644 (file)
@@ -472,7 +472,7 @@ void PoissonProblem<dim>::run (ParameterHandler &prm) {
       cout << "    Calculating L2 error... ";
       VectorTools<dim>::integrate_difference (*dof_handler,
                                              solution, *solution_function,
-                                             l2_error_per_cell, q, fe,
+                                             l2_error_per_cell, q,
                                              L2_norm);
       cout << l2_error_per_cell.l2_norm() << endl;
       l2_error.push_back (l2_error_per_cell.l2_norm());
@@ -480,7 +480,7 @@ void PoissonProblem<dim>::run (ParameterHandler &prm) {
       cout << "    Calculating L-infinity error... ";
       VectorTools<dim>::integrate_difference (*dof_handler,
                                              solution, *solution_function,
-                                             linfty_error_per_cell, q, fe,
+                                             linfty_error_per_cell, q,
                                              Linfty_norm);
       cout << linfty_error_per_cell.linfty_norm() << endl;
       linfty_error.push_back (linfty_error_per_cell.linfty_norm());
@@ -488,7 +488,7 @@ void PoissonProblem<dim>::run (ParameterHandler &prm) {
       cout << "    Calculating H1 error... ";
       VectorTools<dim>::integrate_difference (*dof_handler,
                                              solution, *solution_function,
-                                             h1_error_per_cell, q, fe,
+                                             h1_error_per_cell, q, 
                                              H1_norm);
       cout << h1_error_per_cell.l2_norm() << endl;
       h1_error.push_back (h1_error_per_cell.l2_norm());
index 9061524b50229353d7a73240c582b8afc60f6365..b3d4c57e96167d543205bee0382d614b09d114b8 100644 (file)
@@ -44,13 +44,13 @@ class PoissonEquation :  public Equation<dim> {
     virtual void assemble (dFMatrix            &cell_matrix,
                           dVector             &rhs,
                           const FEValues<dim> &fe_values,
-                          const Triangulation<dim>::cell_iterator &cell) const;
+                          const DoFHandler<dim>::cell_iterator &cell) const;
     virtual void assemble (dFMatrix            &cell_matrix,
                           const FEValues<dim> &fe_values,
-                          const Triangulation<dim>::cell_iterator &cell) const;
+                          const DoFHandler<dim>::cell_iterator &cell) const;
     virtual void assemble (dVector             &rhs,
                           const FEValues<dim> &fe_values,
-                          const Triangulation<dim>::cell_iterator &cell) const;
+                          const DoFHandler<dim>::cell_iterator &cell) const;
   protected:
     const Function<dim> &right_hand_side;
 };
@@ -231,7 +231,7 @@ template <>
 void PoissonEquation<2>::assemble (dFMatrix            &cell_matrix,
                                   dVector             &rhs,
                                   const FEValues<2>   &fe_values,
-                                  const Triangulation<2>::cell_iterator &) const {
+                                  const DoFHandler<2>::cell_iterator &) const {
   for (unsigned int point=0; point<fe_values.n_quadrature_points; ++point)
     for (unsigned int i=0; i<fe_values.total_dofs; ++i) 
       {
@@ -250,7 +250,7 @@ void PoissonEquation<2>::assemble (dFMatrix            &cell_matrix,
 template <int dim>
 void PoissonEquation<dim>::assemble (dFMatrix            &,
                                     const FEValues<dim> &,
-                                    const Triangulation<dim>::cell_iterator &) const {
+                                    const DoFHandler<dim>::cell_iterator &) const {
   Assert (false, ExcPureVirtualFunctionCalled());
 };
 
@@ -259,7 +259,7 @@ void PoissonEquation<dim>::assemble (dFMatrix            &,
 template <int dim>
 void PoissonEquation<dim>::assemble (dVector             &,
                                     const FEValues<dim> &,
-                                    const Triangulation<dim>::cell_iterator &) const {
+                                    const DoFHandler<dim>::cell_iterator &) const {
   Assert (false, ExcPureVirtualFunctionCalled());
 };
 
@@ -379,8 +379,7 @@ void PoissonProblem<dim>::assemble (const Equation<dim>      &equation,
                                   // apply Dirichlet bc as described
                                   // in the docs
   map<int, double> boundary_value_list;
-  VectorTools<dim>::interpolate_boundary_values (*dof,
-                                                dirichlet_bc, fe, boundary,
+  VectorTools<dim>::interpolate_boundary_values (*dof, dirichlet_bc, boundary,
                                                 boundary_value_list);
   MatrixTools<dim>::apply_boundary_values (boundary_value_list,
                                           system_matrix, solution,
@@ -494,7 +493,7 @@ int PoissonProblem<dim>::run (const unsigned int level) {
   VectorTools<dim>::integrate_difference (*dof,
                                          solution, sol,
                                          l1_error_per_cell,
-                                         *quadrature, *fe, L1_norm);
+                                         *quadrature, L1_norm);
   cout << l1_error_per_cell.l1_norm() << endl;
   l1_error.push_back (l1_error_per_cell.l1_norm());
 
@@ -502,7 +501,7 @@ int PoissonProblem<dim>::run (const unsigned int level) {
   VectorTools<dim>::integrate_difference (*dof,
                                          solution, sol,
                                          l2_error_per_cell,
-                                         *quadrature, *fe, L2_norm);
+                                         *quadrature, L2_norm);
   cout << l2_error_per_cell.l2_norm() << endl;
   l2_error.push_back (l2_error_per_cell.l2_norm());
 
@@ -510,7 +509,7 @@ int PoissonProblem<dim>::run (const unsigned int level) {
   VectorTools<dim>::integrate_difference (*dof,
                                          solution, sol,
                                          linfty_error_per_cell,
-                                         *quadrature, *fe, Linfty_norm);
+                                         *quadrature, Linfty_norm);
   cout << linfty_error_per_cell.linfty_norm() << endl;
   linfty_error.push_back (linfty_error_per_cell.linfty_norm());
   
@@ -518,7 +517,7 @@ int PoissonProblem<dim>::run (const unsigned int level) {
   VectorTools<dim>::integrate_difference (*dof,
                                          solution, sol,
                                          h1_seminorm_error_per_cell,
-                                         *quadrature, *fe, H1_seminorm);
+                                         *quadrature, H1_seminorm);
   cout << h1_seminorm_error_per_cell.l2_norm() << endl;
   h1_seminorm_error.push_back (h1_seminorm_error_per_cell.l2_norm());
 
@@ -526,7 +525,7 @@ int PoissonProblem<dim>::run (const unsigned int level) {
   VectorTools<dim>::integrate_difference (*dof,
                                          solution, sol,
                                          h1_error_per_cell,
-                                         *quadrature, *fe, H1_norm);
+                                         *quadrature, H1_norm);
   cout << h1_error_per_cell.l2_norm() << endl;
   h1_error.push_back (h1_error_per_cell.l2_norm());
 

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.