]> https://gitweb.dealii.org/ - dealii-svn.git/commitdiff
dof_renumbering.h moved
authorguido <guido@0785d39b-7218-0410-832d-ea1e28bc413d>
Thu, 3 Jul 2003 10:31:47 +0000 (10:31 +0000)
committerguido <guido@0785d39b-7218-0410-832d-ea1e28bc413d>
Thu, 3 Jul 2003 10:31:47 +0000 (10:31 +0000)
git-svn-id: https://svn.dealii.org/trunk@7833 0785d39b-7218-0410-832d-ea1e28bc413d

14 files changed:
deal.II/Makefile
deal.II/deal.II/source/dofs/dof_renumbering.cc
deal.II/doc/news/c-4-0.html
deal.II/examples/step-16/step-16.cc
deal.II/examples/step-2/step-2.cc
deal.II/examples/step-7/step-7.cc
deal.II/lac/include/lac/solver_gmres.h
tests/bits/anna_1.cc
tests/bits/anna_2.cc
tests/bits/anna_3.cc
tests/deal.II/dof_renumbering.cc
tests/deal.II/dof_test.cc
tests/deal.II/intergrid_constraints.cc
tests/deal.II/wave-test-3.cc

index 7be19f8c6bd6340760f4cd86203b4d5d4f72b4fb..4feff8d2f257aa2912e010d458aebb4bb896063c 100644 (file)
@@ -117,11 +117,13 @@ TODO:
              > $@
 
 
-TAGS: $(shell echo $D/base/source/*.cc $D/base/include/*/*.h    \
-                   $D/lac/source/*.cc $D/lac/include/*/*.h      \
-                   $D/deal.II/source/*/*.cc $D/deal.II/include/*/*.h \
-                   $D/tests/*/*.cc $D/tests/*/*.h )
-       @cd $D/common ; etags $^
+TAGS:
+       @cd $D/common ; etags $D/base/source/*.cc $D/base/include/*/*.h \
+       $D/lac/source/*.cc $D/lac/include/*/*.h \
+       $D/deal.II/source/*/*.cc $D/deal.II/include/*/*.h \
+       $D/tests/*/*.cc $D/tests/*/*.h \
+       $D/examples/*/*.cc
+
 
 
 clean: clean-contrib clean-base clean-lac clean-dealII clean-doc clean-examples clean-lib clean-tests
index e392281427b6a744383978801c861b17acf2c978..3c72818669392e83d63621bbd966f7d9a663c0d6 100644 (file)
@@ -26,7 +26,7 @@
 #include <dofs/dof_constraints.h>
 #include <dofs/dof_tools.h>
 #include <fe/fe.h>
-#include <numerics/dof_renumbering.h>
+#include <dofs/dof_renumbering.h>
 
 #ifdef ENABLE_MULTIGRID
 #include <multigrid/mg_dof_handler.h>
index 9743a182d7425a7f77159e87d11ea58dae553536..35d6d6da6a6935cf0683d93cb35854350f031413 100644 (file)
@@ -28,6 +28,22 @@ contributor's names are abbreviated by WB (Wolfgang Bangerth), GK
 </p>
 
 
+<a name="incompatible"></a>
+<h3 style="color:red">Incompatibilities</h3>
+
+<ol>
+  <li> <p> Moved and changed: The header file
+  <tt>include/numerics/dof_renumbering.h</tt> has been moved to the
+  directory <tt>include/dofs</tt>, where it logically
+  belongs. Furthermore, the sorting parameter of the function <code
+  class="class">DoFRenumbering</code>::<code
+  class="member">component_wise</code> has changed its meaning. See
+  the reference documentation for details.
+  <br>
+  (GK 2003/07/03)
+</ol>
+
+
 <a name="general"></a>
 <h3>General</h3>
 
index 0fc88de0b4f57b03bf4a5ec4390c3ad0bbed9456..a4c753b7bc45e87deaac18aec3445489aac07603 100644 (file)
@@ -80,6 +80,10 @@ class LaplaceProblem
   private:
     void setup_system ();
     void assemble_system ();
+                                    // We add this function for
+                                    // assembling the multilevel
+                                    // matrices.
+    void assemble_multigrid ();
     void solve ();
     void output_results (const unsigned int cycle) const;
 
@@ -90,7 +94,12 @@ class LaplaceProblem
     SparsityPattern      sparsity_pattern;
     SparseMatrix<double> system_matrix;
 
+                                    // Here are the new objects for
+                                    // handling level matrices.
     MGLevelObject<SparsityPattern> mg_sparsity;
+                                    // We use number type float to
+                                    // save memory. It's only a
+                                    // preconditioner!
     MGLevelObject<SparseMatrix<float> > mg_matrices;
     
     Vector<double>       solution;
@@ -140,41 +149,33 @@ void LaplaceProblem<dim>::setup_system ()
   const unsigned int nlevels = triangulation.n_levels();
   mg_sparsity.resize(0, nlevels-1);
   mg_matrices.resize(0, nlevels-1);
-  
+
+                                  // Now, we have to build a matrix
+                                  // on each level. Technically, we
+                                  // could use the matrix initialized
+                                  // above on the finest
+                                  // level. Beware that this is not
+                                  // true anymore with local
+                                  // refinement!
   for (unsigned int level=0;level<nlevels;++level)
     {
+      mg_sparsity[level].reinit (mg_dof_handler.n_dofs(level),
+                                mg_dof_handler.n_dofs(level),
+                                mg_dof_handler.max_couplings_between_dofs());
+      MGTools:::make_sparsity_pattern (mg_dof_handler, mg_sparsity[level], level);
+      mg_sparsity[level].compress();
+      mg_matrices[level].reinit(mg_sparsity[level]);
     }
 }
 
-
-
-                                // As in the previous examples, this
-                                // function is not changed much with
-                                // regard to its functionality, but
-                                // there are still some optimizations
-                                // which we will show. For this, it
-                                // is important to note that if
-                                // efficient solvers are used (such
-                                // as the preconditions CG method),
-                                // assembling the matrix and right
-                                // hand side can take a comparable
-                                // time, and you should think about
-                                // using one or two optimizations at
-                                // some places.
+                                // This is the standard assemble
+                                // function you have seen a lot of
+                                // times before.
                                 //
-                                // What we will show here is how we
-                                // can avoid calls to the
-                                // shape_value, shape_grad, and
-                                // quadrature_point functions of the
-                                // FEValues object, and in particular
-                                // optimize away most of the virtual
-                                // function calls of the Function
-                                // object. The way to do so will be
-                                // explained in the following, while
-                                // those parts of this function that
-                                // are not changed with respect to
-                                // the previous example are not
-                                // commented on.
+                                // A small difference, though: we
+                                // assemble the matrix for Helmholtz'
+                                // equation so we can solve the
+                                // Neumann boundary value problem.
 template <int dim>
 void LaplaceProblem<dim>::assemble_system () 
 {  
@@ -270,6 +271,95 @@ void LaplaceProblem<dim>::assemble_system ()
 }
 
 
+                                // Here is another assemble
+                                // function. The integration core is
+                                // the same as above. Only the loop
+                                // goes over all existing cells now
+                                // and the results must be entered
+                                // into the right matrix.
+
+                                // Since we only do multi-level
+                                // preconditioning, no right-hand
+                                // side is assembled here.
+template <int dim>
+void LaplaceProblem<dim>::assemble_multigrid () 
+{  
+  QGauss2<dim>  quadrature_formula;
+
+  FEValues<dim> fe_values (fe, quadrature_formula, 
+                          UpdateFlags(update_gradients |
+                                      update_q_points  |
+                                      update_JxW_values));
+
+  const unsigned int   dofs_per_cell = fe.dofs_per_cell;
+  const unsigned int   n_q_points    = quadrature_formula.n_quadrature_points;
+
+  FullMatrix<double>   cell_matrix (dofs_per_cell, dofs_per_cell);
+
+  std::vector<unsigned int> local_dof_indices (dofs_per_cell);
+
+                                  // 
+  typename DoFHandler<dim>::cell_iterator cell = mg_dof_handler.begin(),
+                                         endc = mg_dof_handler.end();
+  for (; cell!=endc; ++cell)
+    {
+                                      // Remember the level of the
+                                      // current cell.
+      const unsigned int level = cell->level()
+      cell_matrix.clear ();
+
+                                      // Compute the values specified
+                                      // by update flags above.
+      fe_values.reinit (cell);
+
+                                      // This is exactly the
+                                      // integration loop of the cell
+                                      // matrix above.
+      for (unsigned int q_point=0; q_point<n_q_points; ++q_point)
+       for (unsigned int i=0; i<dofs_per_cell; ++i)
+         {
+           for (unsigned int j=0; j<dofs_per_cell; ++j)
+             cell_matrix(i,j) += (fe_values.shape_grad(i,q_point)
+                                  * fe_values.shape_grad(j,q_point)
+                                  * fe_values.JxW(q_point));
+         };
+
+
+                                      // Oops! This is a tiny
+                                      // difference easily
+                                      // forgotten. The indices we
+                                      // want here are the ones for
+                                      // that special level, not for
+                                      // the global
+                                      // matrix. Therefore, a little
+                                      // 'mg' entered into the
+                                      // function call.
+      cell->get_mg_dof_indices (local_dof_indices);
+      for (unsigned int i=0; i<dofs_per_cell; ++i)
+       {
+         for (unsigned int j=0; j<dofs_per_cell; ++j)
+                                            // And now add everything
+                                            // to the matrix on the
+                                            // right level.
+           mg_matrices[level]..add (local_dof_indices[i],
+                                    local_dof_indices[j],
+                                    cell_matrix(i,j));
+       };
+    };
+
+                                  // Again use zero boundary values:
+  std::map<unsigned int,double> boundary_values;
+  VectorTools::interpolate_boundary_values (mg_dof_handler,
+                                           0,
+                                           ZeroFunction<dim>(),
+                                           boundary_values);
+  MatrixTools::apply_boundary_values (boundary_values,
+                                     system_matrix,
+                                     solution,
+                                     system_rhs);
+}
+
+
 
                                 // The solution process again looks
                                 // mostly like in the previous
@@ -332,184 +422,47 @@ void LaplaceProblem<dim>::solve ()
 
 
 
-                                // Writing output to a file is mostly
-                                // the same as for the previous
-                                // example, but here we will show how
-                                // to modify some output options and
-                                // how to construct a different
-                                // filename for each refinement
-                                // cycle.
+                                // Here is the data output, which is
+                                // a simplified version of step 5. We
+                                // do a standard gnuplot output for
+                                // each grid produced in the
+                                // refinement process.
 template <int dim>
 void LaplaceProblem<dim>::output_results (const unsigned int cycle) const
 {
+                                  // Construct and initialize a DataOut object
   DataOut<dim> data_out;
 
   data_out.attach_dof_handler (mg_dof_handler);
   data_out.add_data_vector (solution, "solution");
-
   data_out.build_patches ();
 
-                                  // For this example, we would like
-                                  // to write the output directly to
-                                  // a file in Encapsulated
-                                  // Postscript (EPS) format. The
-                                  // library supports this, but
-                                  // things may be a bit more
-                                  // difficult sometimes, since EPS
-                                  // is a printing format, unlike
-                                  // most other supported formats
-                                  // which serve as input for
-                                  // graphical tools. Therefore, you
-                                  // can't scale or rotate the image
-                                  // after it has been written to
-                                  // disk, and you have to decide
-                                  // about the viewpoint or the
-                                  // scaling in advance.
-                                  //
-                                  // The defaults in the library are
-                                  // usually quite reasonable, and
-                                  // regarding viewpoint and scaling
-                                  // they coincide with the defaults
-                                  // of Gnuplot. However, since this
-                                  // is a tutorial, we will
-                                  // demonstrate how to change
-                                  // them. For this, we first have to
-                                  // generate an object describing
-                                  // the flags for EPS output:
-  DataOutBase::EpsFlags eps_flags;
-                                  // They are initialized with the
-                                  // default values, so we only have
-                                  // to change those that we don't
-                                  // like. For example, we would like
-                                  // to scale the z-axis differently
-                                  // (stretch each data point in
-                                  // z-direction by a factor of four):
-  eps_flags.z_scaling = 4;
-                                  // Then we would also like to alter
-                                  // the viewpoint from which we look
-                                  // at the solution surface. The
-                                  // default is at an angle of 60
-                                  // degrees down from the vertical
-                                  // axis, and 30 degrees rotated
-                                  // against it in mathematical
-                                  // positive sense. We raise our
-                                  // viewpoint a bit and look more
-                                  // along the y-axis:
-  eps_flags.azimut_angle = 40;
-  eps_flags.turn_angle   = 10;
-                                  // That shall suffice. There are
-                                  // more flags, for example whether
-                                  // to draw the mesh lines, which
-                                  // data vectors to use for
-                                  // colorization of the interior of
-                                  // the cells, and so on. You may
-                                  // want to take a look at the
-                                  // documentation of the EpsFlags
-                                  // structure to get an overview of
-                                  // what is possible.
-                                  //
-                                  // The only thing still to be done,
-                                  // is to tell the output object to
-                                  // use these flags:
-  data_out.set_flags (eps_flags);
-                                  // The above way to modify flags
-                                  // requires recompilation each time
-                                  // we would like to use different
-                                  // flags. This is inconvenient, and
-                                  // we will see more advanced ways
-                                  // in following examples where the
-                                  // output flags are determined at
-                                  // run time using an input file.
-
-                                  // Finally, we need the filename to
-                                  // which the results are to be
-                                  // written. We would like to have
-                                  // it of the form
-                                  // ``solution-N.eps'', where N is
-                                  // the number of the refinement
-                                  // cycle. Thus, we have to convert
-                                  // an integer to a part of a
-                                  // string; this can be done using
-                                  // the ``sprintf'' function, but in
-                                  // C++ there is a more elegant way:
-                                  // write everything into a special
-                                  // stream (just like writing into a
-                                  // file or to the screen) and
-                                  // retrieve what you wrote as a
-                                  // string. This applies the usual
-                                  // conversions from integer to
-                                  // strings, and one could as well
-                                  // give stream modifiers such as
-                                  // ``setw'', ``setprecision'', and
-                                  // so on.
-                                  //
-                                  // In C++, you can do this by using
-                                  // the so-called stringstream
-                                  // classes. As already discussed at
-                                  // the point of inclusion of the
-                                  // respective header file above,
-                                  // there is some historical
-                                  // confusion we have to work around
-                                  // here, since the class we'd like
-                                  // to use used to be called
-                                  // ``ostrstream'', but now is named
-                                  // ``ostringstream''. In the same
-                                  // way as done above in deciding
-                                  // which file to include, we here
-                                  // decide which class name to use:
+                                  // The following block generates
+                                  // the file name and opens the
+                                  // file. This looks awkward because
+                                  // of a change in the handling of
+                                  // string streams (See step 5 for explanation).
+  
 #ifdef HAVE_STD_STRINGSTREAM
   std::ostringstream filename;
 #else
   std::ostrstream filename;
 #endif
-                                  // Fortunately, the interface of
-                                  // the two classes which we might
-                                  // now be using, depending on which
-                                  // one is available, is close
-                                  // enough that we need to take care
-                                  // about the differences only once
-                                  // below, so we can use them in a
-                                  // rather straightforward way, even
-                                  // if they are not identical.
-
-                                  // In order to now actually
-                                  // generate a filename, we fill the
-                                  // stringstream variable with the
-                                  // base of the filename, then the
-                                  // number part, and finally the
-                                  // suffix indicating the file type:
   filename << "solution-"
           << cycle
-          << ".eps";
-  
-                                  // For the old string stream
-                                  // classes, we have to append the
-                                  // final '\0' that appears at the
-                                  // end of ``char *''
-                                  // variables. This is done by the
-                                  // following construct:
+          << ".gnuplot";
+
 #ifndef HAVE_STD_STRINGSTREAM
   filename << std::ends;
 #endif
-                                  // We can get whatever we wrote to
-                                  // the stream using the ``str()''
-                                  // function. If the new
-                                  // stringstream classes are used,
-                                  // then the result is a string
-                                  // which we have to convert to a
-                                  // char* using the ``c_str()''
-                                  // function, otherwise the result
-                                  // is a char* right away. Use that
-                                  // as filename for the output
-                                  // stream:
+
 #ifdef HAVE_STD_STRINGSTREAM
   std::ofstream output (filename.str().c_str());
 #else
   std::ofstream output (filename.str());
 #endif
-                                  // And then write the data to the
-                                  // file.
-  data_out.write_eps (output);
+
+  data_out.write_gnuplot (output);
 }
 
 
@@ -521,35 +474,11 @@ void LaplaceProblem<dim>::run ()
     {
       std::cout << "Cycle " << cycle << ':' << std::endl;
 
-                                      // If this is the first round,
-                                      // then we have no grid yet,
-                                      // and we will create it
-                                      // here. In previous examples,
-                                      // we have already used some of
-                                      // the functions from the
-                                      // GridGenerator class. Here we
-                                      // would like to read a grid
-                                      // from a file where the cells
-                                      // are stored and which may
-                                      // originate from someone else,
-                                      // or may be the product of a
-                                      // mesh generator tool.
-                                      //
-                                      // In order to read a grid from
-                                      // a file, we generate an
-                                      // object of data type GridIn
-                                      // and associate the
-                                      // triangulation to it (i.e. we
-                                      // tell it to fill our
-                                      // triangulation object when we
-                                      // ask it to read the
-                                      // file). Then we open the
-                                      // respective file and
-                                      // initialize the triangulation
-                                      // with the data in the file:
       if (cycle == 0)
        {
-                                          // Generate grid here!
+                                          // Generate a simple hypercube grid.
+         GridGenerator::hyper_cube(tr);
+         
        }
                                       // If this is not the first
                                       // cycle, then simply refine
index 6b29f90afa576694cf055533ed328b86477c514a..bfef563132d4cdf8c56d68eee764f997a9fec143 100644 (file)
@@ -56,7 +56,7 @@
                                 // We will want to use a special
                                 // algorithm to renumber degrees of
                                 // freedom. It is declared here:
-#include <numerics/dof_renumbering.h>
+#include <dofs/dof_renumbering.h>
 
                                 // This is needed for C++ output:
 #include <fstream>
index d0462ca73d6932ed35d550b5c363cdcdba42591c..34174a25fbe6a2562822f15e2dc04742c5b23d5b 100644 (file)
@@ -47,7 +47,7 @@
                                 // Cuthill-McKee algorithm. The
                                 // necessary functions are declared
                                 // in the following file:
-#include <numerics/dof_renumbering.h>
+#include <dofs/dof_renumbering.h>
                                 // Then we will show a little trick
                                 // how we can make sure that objects
                                 // are not deleted while they are
index 88a7b882db2ebeca496ef740aa8ea0fd8c57591f..3f189b14d1efa14fc7086c7ec3bdf2e17df1c087 100644 (file)
@@ -14,7 +14,6 @@
 #define __deal2__solver_gmres_h
 
 
-/*----------------------------   solver_pgmres.h     ---------------------------*/
 
 #include <base/config.h>
 #include <base/subscriptor.h>
@@ -289,6 +288,85 @@ class SolverGMRES : public Solver<VECTOR>
 };
 
 
+/**
+ * Flexible GMRES.
+ *
+ * This version of the GMRES method allows for the use of a different
+ * preconditioner in each iteration step. Therefore, it is also more
+ * robust with respect to inaccurate evaluation of the
+ * preconditioner. An important application is also the use of a
+ * Krylov space method inside the preconditioner.
+ *
+ * FGMRES needs two vectors in each iteration steps yielding a total
+ * of @p{2*AdditionalData::max_basis_size+1} auxiliary vectors.
+ */
+template <class VECTOR = Vector<double> >
+class SolverFGMRES : public Solver<VECTOR>
+{
+  public:
+                                    /**
+                                     * Standardized data struct to
+                                     * pipe additional data to the
+                                     * solver.
+                                     */
+    struct AdditionalData 
+    {
+                                        /**
+                                         * Constructor. By default,
+                                         * set the number of
+                                         * temporary vectors to 30,
+                                         * preconditioning from left
+                                         * and the residual of the
+                                         * stopping criterion to the
+                                         * default residual
+                                         * (cf. class documentation).
+                                         */
+       AdditionalData(const unsigned int max_basis_size = 30,
+                      bool use_default_residual = true)
+                       :
+                       max_basis_size(max_basis_size)
+         {};
+       
+                                        /**
+                                         * Maximum number of
+                                         * tmp vectors.
+                                         */
+       unsigned int    max_basis_size;
+    };
+    
+                                    /**
+                                     * Constructor.
+                                     */
+    SolverFGMRES (SolverControl        &cn,
+                 VectorMemory<VECTOR> &mem,
+                 const AdditionalData &data=AdditionalData());
+
+                                    /**
+                                     * Solve the linear system $Ax=b$
+                                     * for x.
+                                     */
+    template<class MATRIX, class PRECONDITIONER>
+    void
+    solve (const MATRIX         &A,
+          VECTOR               &x,
+          const VECTOR         &b,
+          const PRECONDITIONER &precondition);
+
+  private:
+                                     /**
+                                     * Additional flags.
+                                     */
+    AdditionalData additional_data;
+                                    /**
+                                     * Projected system matrix
+                                     */
+    FullMatrix<double> H;
+                                    /**
+                                     * Auxiliary matrix for inverting @p{H}
+                                     */
+    FullMatrix<double> H1;
+};
+
 /* --------------------- Inline and template functions ------------------- */
 
 
@@ -708,7 +786,112 @@ SolverGMRES<VECTOR>::criterion ()
 }
 
 
-/*----------------------------   solver_pgmres.h     ---------------------------*/
+//----------------------------------------------------------------------//
+
+template <class VECTOR>
+SolverFGMRES<VECTOR>::SolverFGMRES (SolverControl        &cn,
+                                   VectorMemory<VECTOR> &mem,
+                                   const AdditionalData &data)
+               :
+               Solver<VECTOR> (cn, mem),
+  additional_data(data)
+{}
+
+
+template<class VECTOR>
+template<class MATRIX, class PRECONDITIONER>
+void
+SolverFGMRES<VECTOR>::solve (
+  const MATRIX& A,
+  VECTOR& x,
+  const VECTOR& b,
+  const PRECONDITIONER& precondition)
+{
+  deallog.push("FGMRES");
+  
+  SolverControl::State iteration_state = SolverControl::iterate;  
+
+  const unsigned int basis_size = additional_data.max_basis_size;
+
+                                  // Generate an object where basis
+                                  // vectors are stored.
+  typename SolverGMRES<VECTOR>::TmpVectors v (basis_size, this->memory);
+  typename SolverGMRES<VECTOR>::TmpVectors z (basis_size, this->memory);
+  
+                                  // number of the present iteration; this
+                                  // number is not reset to zero upon a
+                                  // restart
+  unsigned int accumulated_iterations = 0;
+  
+                                  // matrix used for the orthogonalization
+                                  // process later
+  H.reinit(basis_size+1, basis_size);
+
+                                  // Vectors for projected system
+  Vector<double> projected_rhs;
+  Vector<double> y;
+
+  // Iteration starts here
+
+  do
+    {
+      VECTOR* aux = this->memory.alloc();
+      aux->reinit(x);
+      A.vmult(*aux, x);
+      aux->sadd(-1., 1., b);
+      
+      double beta = aux->l2_norm();
+      if (this->control().check(accumulated_iterations,beta)
+         == SolverControl::success)
+       break;
+      
+      H.reinit(basis_size+1, basis_size);
+      double a = beta;
+      
+      for (unsigned int j=0;j<basis_size;++j)
+       {
+         v(j,x).equ(1./a, *aux);
+         
+         precondition.vmult(z(j,x), v[j]);
+         A.vmult(*aux, z[j]);
+         
+                                          // Gram-Schmidt
+         for (unsigned int i=0;i<=j;++i)
+           {
+             H(i,j) = *aux * v[i];
+             aux->add(-H(i,j), v[i]);
+           }
+         H(j+1,j) = a = aux->l2_norm();
+         
+                                          // Compute projected solution
+         
+         if (j>0)
+           {
+             H1.reinit(j+1,j);
+             projected_rhs.reinit(j+1);
+             y.reinit(j);        
+             projected_rhs(0) = beta;
+             H1.fill(H);
+             
+             double res = H1.least_squares(y, projected_rhs);
+             iteration_state = this->control().check(++accumulated_iterations, res);
+             if (iteration_state != SolverControl::iterate)
+               break;
+           }
+       }
+                                      // Update solution vector
+      for (unsigned int j=0;j<y.size();++j)
+       x.add(y(j), z[j]);
+      
+      this->memory.free(aux);
+    } while (iteration_state == SolverControl::iterate);
+  
+  deallog.pop();
+                                  // in case of failure: throw
+                                  // exception
+  if (this->control().last_check() != SolverControl::success)
+    throw SolverControl::NoConvergence (this->control().last_step(),
+                                       this->control().last_value());
+}
 
 #endif
-/*----------------------------   solver_pgmres.h     ---------------------------*/
index 6d64cda0881a2a20c339bea081b7217acbc67d00..98e2f417c798fdcdd7bda74d6d610784f806f3d9 100644 (file)
@@ -33,7 +33,7 @@
 #include <fe/fe_q.h>
 #include <fe/fe_nedelec.h>
 #include <fe/fe_base.h>
-#include <numerics/dof_renumbering.h>
+#include <dofs/dof_renumbering.h>
 #include <iostream>
 #include <fstream>
 
index 96f55918e3a2168aa4b4276e75c5bd73d73e264d..0cd178873c7cb3badea25e618994984affa3db68 100644 (file)
@@ -37,7 +37,7 @@
 #include <fe/fe_q.h>
 #include <fe/fe_nedelec.h>
 #include <fe/fe_base.h>
-#include <numerics/dof_renumbering.h>
+#include <dofs/dof_renumbering.h>
 #include <iostream>
 #include <fstream>
 
index 59b688b0bff0ae7d2d7228acd4142a7e7d651d25..c9baa8864f59e1d764a047a18d8c5845327f0ca6 100644 (file)
@@ -32,7 +32,7 @@
 #include <fe/fe_nedelec.h>
 #include <fe/fe_base.h>
 #include <dofs/dof_tools.h>
-#include <numerics/dof_renumbering.h>
+#include <dofs/dof_renumbering.h>
 #include <iostream>
 #include <fstream>
 
index 93568b02dfd0a202920aace5d5981681e1165d98..72c55b5dcfa3de6aceed92c386a4e63b17d4e081 100644 (file)
@@ -2,7 +2,7 @@
 //    $Id$
 //    Version: $Name$
 //
-//    Copyright (C) 2000, 2001 by the deal.II authors
+//    Copyright (C) 2000, 2001, 2003 by the deal.II authors
 //
 //    This file is subject to QPL and may not be  distributed
 //    without copyright and license information. Please refer
 #include <grid/grid_generator.h>
 #include <dofs/dof_accessor.h>
 #include <dofs/dof_handler.h>
+#include <dofs/dof_renumbering.h>
 #include <multigrid/mg_dof_accessor.h>
 #include <multigrid/mg_dof_handler.h>
 #include <fe/fe_q.h>
 #include <fe/fe_dgq.h>
 #include <fe/fe_system.h>
-#include <numerics/dof_renumbering.h>
 
 #include <fstream>
 
index c28798dc7f6f4c92f7764d3456e2eb610e6ac2dd..01f4c4202ee3a0d7f66d99787ea12ab3e96cb92e 100644 (file)
@@ -22,7 +22,7 @@
 #include <lac/sparse_matrix.h>
 #include <dofs/dof_constraints.h>
 #include <dofs/dof_accessor.h>
-#include <numerics/dof_renumbering.h>
+#include <dofs/dof_renumbering.h>
 #include <dofs/dof_tools.h>
 #include <base/logstream.h>
 
index 65cc7eb6693dd535ab282df6dd34c67a019c98de..21841617e82677d9126bcc272512b0042bdc3c03 100644 (file)
@@ -9,7 +9,7 @@
 #include <dofs/dof_handler.h>
 #include <dofs/dof_constraints.h>
 #include <dofs/dof_tools.h>
-#include <numerics/dof_renumbering.h>
+#include <dofs/dof_renumbering.h>
 #include <grid/grid_generator.h>
 #include <grid/tria_accessor.h>
 #include <grid/tria_iterator.h>
index 15eed7412a2226bfd7b4708731b3a4cdd9a9035c..a9428921d92fa750dfdc53423c60d61311ff5674 100644 (file)
@@ -4468,7 +4468,7 @@ void SweepInfo::write_summary (const std::list<EvaluationBase<2>*> &eval_list,
 #include <fe/fe_values.h>
 #include <fe/fe_update_flags.h>
 #include <numerics/matrices.h>
-#include <numerics/dof_renumbering.h>
+#include <dofs/dof_renumbering.h>
 
 
 #include <fstream>

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.