]> https://gitweb.dealii.org/ - dealii-svn.git/commitdiff
new heads
authorguido <guido@0785d39b-7218-0410-832d-ea1e28bc413d>
Tue, 22 Feb 2000 20:44:40 +0000 (20:44 +0000)
committerguido <guido@0785d39b-7218-0410-832d-ea1e28bc413d>
Tue, 22 Feb 2000 20:44:40 +0000 (20:44 +0000)
git-svn-id: https://svn.dealii.org/trunk@2480 0785d39b-7218-0410-832d-ea1e28bc413d

23 files changed:
deal.II/common/misc/head
deal.II/deal.II/include/fe/fe.h
deal.II/deal.II/include/fe/fe_lib.criss_cross.h
deal.II/deal.II/include/fe/fe_lib.dg.h
deal.II/deal.II/include/fe/fe_lib.lagrange.h
deal.II/deal.II/include/fe/fe_system.h
deal.II/deal.II/include/fe/fe_update_flags.h
deal.II/deal.II/include/fe/fe_values.h
deal.II/deal.II/include/fe/q1_mapping.h
tests/deal.II/constraints.cc
tests/deal.II/dof_test.cc
tests/deal.II/fe_tables.cc
tests/deal.II/gradients.cc
tests/deal.II/grid_test.cc
tests/deal.II/mg.cc
tests/deal.II/mglocal.cc
tests/deal.II/second_derivatives.cc
tests/deal.II/wave-test-3.cc
tests/lac/benchmark.cc
tests/lac/mg.cc
tests/lac/mgbase.cc
tests/lac/solver.cc
tests/lac/testmatrix.cc

index 6fb7077475f7ccaf772a1d694486ba45d76acbc0..b8713f7041fa963f0f8910f2fcda3d98287f0e11 100644 (file)
@@ -1,4 +1,4 @@
-//----------------------------  XXX  ---------------------------
+//----------------------------  /var/tmp/deal.II/common/misc/head  ---------------------------
 //    $Id$
 //    Version: $Name$
 //
@@ -9,4 +9,20 @@
 //    to the file deal.II/doc/license.html for the  text  and
 //    further information on this license.
 //
-//----------------------------  XXX  ---------------------------
+//----------------------------  /var/tmp/deal.II/common/misc/head  ---------------------------
+
+
+//----------------------------  /var/tmp/deal.II/common/misc/head  ---------------------------
+//    $Id$
+//    Version: $Name$
+//
+//    Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+//    This file is subject to QPL and may not be  distributed
+//    without copyright and license information. Please refer
+//    to the file deal.II/doc/license.html for the  text  and
+//    further information on this license.
+//
+//----------------------------  /var/tmp/deal.II/common/misc/head  ---------------------------
+
+
index 8fa748cbeccaa6e2030f0e88dca39ecb8b2bd873..81dbc4c91f1fdf62b1b2224f72f701b8eccc0a5d 100644 (file)
@@ -1,9 +1,18 @@
-/*----------------------------   fe.h     ---------------------------*/
-/*      $Id$                 */
-/*      Copyright W. Bangerth, University of Heidelberg, 1998 */
-#ifndef __fe_H
-#define __fe_H
-/*----------------------------   fe.h     ---------------------------*/
+//----------------------------  fe.h  ---------------------------
+//    $Id$
+//    Version: $Name$
+//
+//    Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+//    This file is subject to QPL and may not be  distributed
+//    without copyright and license information. Please refer
+//    to the file deal.II/doc/license.html for the  text  and
+//    further information on this license.
+//
+//----------------------------  fe.h  ---------------------------
+#ifndef __deal2__fe_h
+#define __deal2__fe_h
+
 
 #include <base/exceptions.h>
 #include <base/subscriptor.h>
@@ -14,8 +23,6 @@
 #include <lac/full_matrix.h>
 
 
-
-
 /**
  * Dimension independent data for finite elements. See the #FiniteElementBase#
  * class for more information.
@@ -98,8 +105,8 @@ class FiniteElementData
                                      */
     const unsigned int transform_functions;
 
-    
-                                    /**
+
+/**
                                      * Number of components and dimension of
                                      * the image space.
                                      */
@@ -190,9 +197,9 @@ class FiniteElementData
                                      * Return the #transform_functions#.
                                      */
     unsigned int n_transform_functions () const;
-    
-    
-                                    /**
+
+
+/**
                                      * Comparison operator. It is not clear to
                                      * me (WB) why we have to declare and implement
                                      * this one explicitely.
@@ -206,9 +213,6 @@ class FiniteElementData
                    << "used " << arg1 << "-d constructor for " << arg2 << "-d object");
 };
 
-    
-
-
 
 /**
  * Base class for finite elements in arbitrary dimensions. This class provides
@@ -690,11 +694,6 @@ class FiniteElementBase : public Subscriptor,
 };
 
 
-
-
-
-
-
 /**
  * Finite Element in any dimension. This class declares the
  * functionality to fill the fields of the #FiniteElementBase#
@@ -1641,7 +1640,6 @@ class FiniteElement : public FiniteElementBase<dim>
 };
 
 
-
 /* ------------------------------- Inline functions ----------------------- */
 
 
@@ -1654,7 +1652,6 @@ FiniteElementData<dim>::n_dofs_per_vertex () const
 };
 
 
-
 template <int dim>
 inline
 unsigned int 
@@ -1664,7 +1661,6 @@ FiniteElementData<dim>::n_dofs_per_line () const
 };
 
 
-
 template <int dim>
 inline
 unsigned int 
@@ -1674,7 +1670,6 @@ FiniteElementData<dim>::n_dofs_per_quad () const
 };
 
 
-
 template <int dim>
 inline
 unsigned int 
@@ -1684,7 +1679,6 @@ FiniteElementData<dim>::n_dofs_per_hex () const
 };
 
 
-
 template <int dim>
 inline
 unsigned int 
@@ -1694,7 +1688,6 @@ FiniteElementData<dim>::n_dofs_per_face () const
 };
 
 
-
 template <int dim>
 inline
 unsigned int 
@@ -1704,7 +1697,6 @@ FiniteElementData<dim>::n_dofs_per_cell () const
 };
 
 
-
 template <int dim>
 inline
 unsigned int 
@@ -1714,7 +1706,6 @@ FiniteElementData<dim>::n_components () const
 };
 
 
-
 template <int dim>
 inline
 unsigned int 
@@ -1724,7 +1715,6 @@ FiniteElementData<dim>::n_transform_functions () const
 };
 
 
-
 template <int dim>
 inline
 unsigned int
@@ -1740,7 +1730,6 @@ FiniteElementBase<dim>::component_to_system_index (unsigned int component,
 }
 
 
-
 template <int dim>  
 inline
 pair<unsigned int,unsigned int>
@@ -1752,7 +1741,6 @@ FiniteElementBase<dim>::system_to_component_index (unsigned int index) const
 }
 
 
-
 template <int dim>
 inline
 unsigned int
@@ -1768,7 +1756,6 @@ FiniteElementBase<dim>::face_component_to_system_index (unsigned int component,
 }
 
 
-
 template <int dim>  
 inline
 pair<unsigned int,unsigned int>
@@ -1780,7 +1767,6 @@ FiniteElementBase<dim>::face_system_to_component_index (unsigned int index) cons
 }
 
 
-
 template <int dim>  
 inline
 unsigned int
@@ -1794,7 +1780,6 @@ FiniteElementBase<dim>::component_to_base (unsigned int index) const
 }
 
 
-
 template <int dim>
 inline
 bool
@@ -1806,7 +1791,4 @@ FiniteElementBase<dim>::restriction_is_additive (const unsigned int component) c
 }
 
 
-/*----------------------------   fe.h     ---------------------------*/
-/* end of #ifndef __fe_H */
 #endif
-/*----------------------------   fe.h     ---------------------------*/
index bde4619c9a19ad7c86ace749d39d358d3f57b2fa..185971125ed4d3152f0f60561b09ff592f7c2c5a 100644 (file)
@@ -1,9 +1,17 @@
-/*----------------------------   fe_lib.criss_cross.h     ---------------------------*/
-/*      $Id$                 */
-/*      Copyright W. Bangerth, University of Heidelberg, 1998 */
-#ifndef __fe_lib_criss_cross_H
-#define __fe_lib_criss_cross_H
-/*----------------------------   fe_lib.criss_cross.h     ---------------------------*/
+//----------------------------  fe_lib.criss_cross.h  ---------------------------
+//    $Id$
+//    Version: $Name$
+//
+//    Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+//    This file is subject to QPL and may not be  distributed
+//    without copyright and license information. Please refer
+//    to the file deal.II/doc/license.html for the  text  and
+//    further information on this license.
+//
+//----------------------------  fe_lib.criss_cross.h  ---------------------------
+#ifndef __deal2__fe_lib_criss_cross_h
+#define __deal2__fe_lib_criss_cross_h
 
 
 #include <fe/fe.h>
@@ -340,8 +348,6 @@ class FECrissCross : public FiniteElement<dim> {
 };
 
 
-
-
 /**
  * Quadrature formula for the criss-cross element. This quadrature
  * formula uses one point at the barycenter of each of the four subtriangles.
@@ -358,8 +364,4 @@ class QCrissCross1 : public Quadrature<dim> {
 };
 
 
-
-/*----------------------------   fe_lib.criss_cross.h     ---------------------------*/
-/* end of #ifndef __fe_lib_criss_cross_H */
 #endif
-/*----------------------------   fe_lib.criss_cross.h     ---------------------------*/
index 52712ed91483ebb64bf5ec2013c3eda3dcc695b7..a1a616de5cf2a9e7ae1a34130bafbbc348041bc2 100644 (file)
@@ -1,9 +1,17 @@
-/*----------------------------   fe_lib.dg.h     ---------------------------*/
-/*      $Id$ */
-/*   Ralf Hartmann, University of Heidelberg, Dez 98                        */
-#ifndef __fe_lib_dg_H 
-#define __fe_lib_dg_H 
-/*----------------------------   fe_lib.dg.h     ---------------------------*/
+//----------------------------  fe_lib.dg.h  ---------------------------
+//    $Id$
+//    Version: $Name$
+//
+//    Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+//    This file is subject to QPL and may not be  distributed
+//    without copyright and license information. Please refer
+//    to the file deal.II/doc/license.html for the  text  and
+//    further information on this license.
+//
+//----------------------------  fe_lib.dg.h  ---------------------------
+#ifndef __deal2__fe_lib_dg_h
+#define __deal2__fe_lib_dg_h
 
 
 #include <fe/fe_lib.lagrange.h>
@@ -82,7 +90,6 @@ class FEDG_Q0 : public FEQ1Mapping<dim> {
 };
 
 
-
 /**
  * Define a (bi-, tri-, etc)linear finite element in #dim# space dimensions,
  * along with (bi-, tri-)linear (therefore isoparametric) transforms from the
@@ -120,7 +127,6 @@ class FEDG_Q1 : public FEQ1<dim>{
 };
 
 
-
 /**
  * Define a (bi-, tri-, etc)quadratic finite element in #dim# space dimensions,
  * along with (bi-, tri-)quadratic (therefore isoparametric) transforms from the
@@ -157,8 +163,6 @@ class FEDG_Q2 : public FEQ2<dim>{
 };
 
 
-
-
 /**
  * Define a (bi-, tri-, etc)cubic finite element in #dim# space dimensions,
  * along with (bi-, tri-)cubic (therefore isoparametric) transforms from the
@@ -195,7 +199,6 @@ class FEDG_Q3 : public FEQ3<dim>{
 };
 
 
-
 /**
  * Define a (bi-, tri-, etc)quartic finite element in #dim# space dimensions,
  * along with (bi-, tri-)quartic (therefore isoparametric) transforms from the
@@ -232,10 +235,4 @@ class FEDG_Q4 : public FEQ4<dim>{
 };
 
 
-
-
-
-/*----------------------------   fe_lib.dg.h     ---------------------------*/
-/* end of #ifndef __fe_lib_dg_H */
 #endif
-/*----------------------------   fe_lib.dg.h     ---------------------------*/
index 95b9a4bb5b99159972dad16b90aac83f72911c3c..b9c51060f5051d7c5277f211bafead3368324a57 100644 (file)
@@ -1,8 +1,19 @@
-/*----------------------------   fe_lib.h     ---------------------------*/
-/*      $Id$                 */
-/*      Copyright W. Bangerth, University of Heidelberg, 1998 */
-#ifndef __fe_lib_lagrange_H
-#define __fe_lib_lagrange_H
+//----------------------------  fe_lib.lagrange.h  ---------------------------
+//    $Id$
+//    Version: $Name$
+//
+//    Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+//    This file is subject to QPL and may not be  distributed
+//    without copyright and license information. Please refer
+//    to the file deal.II/doc/license.html for the  text  and
+//    further information on this license.
+//
+//----------------------------  fe_lib.lagrange.h  ---------------------------
+#ifndef __deal2__fe_lib_lagrange_h
+#define __deal2__fe_lib_lagrange_h
+
+
 /*----------------------------   fe_lib.h     ---------------------------*/
 
 
@@ -120,8 +131,6 @@ class FEQ1 : public FEQ1Mapping<dim>
 };
 
 
-
-
 /**
  * Subparametric Q2 finite element in #dim# space dimensions.
  * A Q1 mapping from the unit cell
@@ -299,8 +308,6 @@ class FEQ2 : public FEQ1Mapping<dim>
 };
 
 
-
-
 /**
  * Subparametric Q3 finite element in #dim# space dimensions.
  * A Q1 mapping from the unit cell
@@ -422,7 +429,6 @@ class FEQ3 : public FEQ1Mapping<dim>
 };
 
 
-
 /**
  * Subparametric Q4 finite element in #dim# space dimensions.
  * A linear (subparametric) mapping from the unit cell
@@ -546,14 +552,8 @@ class FEQ4 : public FEQ1Mapping<dim>
 };
 
 
-
-
-
-
-
-
 /*----------------------------   fe_lib.h     ---------------------------*/
-/* end of #ifndef __fe_lib_lagrange_H */
+
 #endif
 /*----------------------------   fe_lib.h     ---------------------------*/
 
index 52e7fcd8f7002fd057662fb88a2e0449c118a19a..b1089cd5dad509c49597bc210e9a26b30308b403 100644 (file)
@@ -1,7 +1,19 @@
-/*----------------------------   fe_lib.system.h     ---------------------------*/
-/*      $Id$                 */
-#ifndef __deal_fe_system_H
-#define __deal_fe_system_H
+//----------------------------  fe_system.h  ---------------------------
+//    $Id$
+//    Version: $Name$
+//
+//    Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+//    This file is subject to QPL and may not be  distributed
+//    without copyright and license information. Please refer
+//    to the file deal.II/doc/license.html for the  text  and
+//    further information on this license.
+//
+//----------------------------  fe_system.h  ---------------------------
+#ifndef __deal2__fe_system_h
+#define __deal2__fe_system_h
+
+
 /*----------------------------   fe_lib.system.h     ---------------------------*/
 
 
@@ -10,7 +22,6 @@
 #include <utility>
 
 
-
 /**
  * This class provides an interface to group several equal elements together
  * into one. To the outside world, the resulting object looks just like
@@ -405,8 +416,8 @@ class FESystem : public FiniteElement<dim>
                                      */
     vector< ElementPair > base_elements;
 
-    
-                                    /**
+
+/**
                                      * Helper function used in the constructor:
                                      * take a #FiniteElementData# object
                                      * and return an object of the same type
@@ -443,8 +454,8 @@ class FESystem : public FiniteElement<dim>
                          const FiniteElementData<dim> &fe3,
                          const unsigned int            N3);
 
-   
-                                    /**
+
+/**
                                      * Helper function used in the constructor:
                                      * takes a #FiniteElement# object
                                      * and returns an boolean vector including
@@ -514,9 +525,6 @@ class FESystem : public FiniteElement<dim>
 };
 
 
-
-
-
 /* ------------------------- template functions ------------------------- */
 
 template<int dim>
@@ -527,7 +535,6 @@ FESystem<dim>::n_base_elements() const
 }
 
 
-
 template <int dim>
 template <class FE>
 FESystem<dim>::FESystem (const FE &fe, const unsigned int n_elements) :
@@ -541,7 +548,6 @@ FESystem<dim>::FESystem (const FE &fe, const unsigned int n_elements) :
 };
 
 
-
 template <int dim>
 template <class FE1, class FE2>
 FESystem<dim>::FESystem (const FE1 &fe1, const unsigned int n1,
@@ -563,7 +569,6 @@ FESystem<dim>::FESystem (const FE1 &fe1, const unsigned int n1,
 };
 
 
-
 template <int dim>
 template <class FE1, class FE2, class FE3>
 FESystem<dim>::FESystem (const FE1 &fe1, const unsigned int n1,
@@ -593,7 +598,6 @@ FESystem<dim>::FESystem (const FE1 &fe1, const unsigned int n1,
 };
 
 
-
 template<int dim>
 inline unsigned int
 FESystem<dim>::element_multiplicity(unsigned int index) const
@@ -604,7 +608,6 @@ FESystem<dim>::element_multiplicity(unsigned int index) const
 }
 
 
-
 template <int dim>
 inline const FiniteElement<dim>&
 FESystem<dim>::base_element(unsigned int index) const
@@ -615,12 +618,7 @@ FESystem<dim>::base_element(unsigned int index) const
 }
 
 
-
-
-
-
-
 /*----------------------------  fe_lib.system.h  ---------------------------*/
-/* end of #ifndef __fe_system_H */
+
 #endif
 /*----------------------------  fe_lib.system.h  ---------------------------*/
index 4c2ec388ce3ea3dcb76fd18eb60dd4a1d1280da7..fadac746653c3d3a02830d0a8b1a98f6700968be 100644 (file)
@@ -1,9 +1,17 @@
-/*----------------------------   fe_update_flags.h     ---------------------------*/
-/*      $Id$                 */
-/*      Copyright W. Bangerth, University of Heidelberg, 1998 */
-#ifndef __fe_update_flags_H
-#define __fe_update_flags_H
-/*----------------------------   fe_update_flags.h     ---------------------------*/
+//----------------------------  fe_update_flags.h  ---------------------------
+//    $Id$
+//    Version: $Name$
+//
+//    Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+//    This file is subject to QPL and may not be  distributed
+//    without copyright and license information. Please refer
+//    to the file deal.II/doc/license.html for the  text  and
+//    further information on this license.
+//
+//----------------------------  fe_update_flags.h  ---------------------------
+#ifndef __deal2__fe_update_flags_h
+#define __deal2__fe_update_flags_h
 
 
 /**
@@ -91,8 +99,4 @@ enum UpdateFlags {
 };
 
 
-
-/*----------------------------   fe_update_flags.h     ---------------------------*/
-/* end of #ifndef __fe_update_flags_H */
 #endif
-/*----------------------------   fe_update_flags.h     ---------------------------*/
index 1bae229f3782fa7e8f3ab5f9dce4f6becba2c8c1..be937cadba54d16ad83adcaeb8fbc2b34f065306 100644 (file)
@@ -1,9 +1,17 @@
-/*----------------------------   fe_values.h     ---------------------------*/
-/*      $Id$                 */
-/*      Copyright W. Bangerth, University of Heidelberg, 1998 */
-#ifndef __fe_values_H
-#define __fe_values_H
-/*---------------------------   fe_values.h     ---------------------------*/
+//----------------------------  fe_values.h  ---------------------------
+//    $Id$
+//    Version: $Name$
+//
+//    Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+//    This file is subject to QPL and may not be  distributed
+//    without copyright and license information. Please refer
+//    to the file deal.II/doc/license.html for the  text  and
+//    further information on this license.
+//
+//----------------------------  fe_values.h  ---------------------------
+#ifndef __deal2__fe_values_h
+#define __deal2__fe_values_h
 
 
 #include <base/exceptions.h>
@@ -16,8 +24,6 @@
 #include <fe/fe_update_flags.h>
 
 
-
-
 /**
  *  This class offers a multitude of arrays and other fields which are used by
  *  the derived classes #FEValues#, #FEFaceValues# and #FESubfaceValues#.
@@ -251,9 +257,9 @@ class FEValuesBase
                  const unsigned int n_values_array,
                  const UpdateFlags         update_flags,
                  const FiniteElement<dim> &fe);
-    
 
-                                    /**
+
+/**
                                      * Return the value of the #i#th shape
                                      * function at the #j# quadrature point
                                      * on the cell, face or subface selected
@@ -707,8 +713,6 @@ class FEValuesBase
 };
 
 
-
-
 /**
  * Represent a finite element evaluated with a specific quadrature rule on
  * a cell.
@@ -733,9 +737,8 @@ class FEValues : public FEValuesBase<dim>
 {
   public:
 
-    
-    
-                                    /**
+
+/**
                                      * Constructor. Fill all arrays with the
                                      * values of the shape functions of the
                                      * specified finite element using the
@@ -814,9 +817,6 @@ class FEValues : public FEValuesBase<dim>
 };
 
 
-
-
-
 /**
  *  This class provides for the data elements needed for the restriction of
  *  finite elements to faces or subfaces. It does no real computations, apart
@@ -1000,7 +1000,6 @@ class FEFaceValuesBase : public FEValuesBase<dim>
 };
 
 
-
 /**
  * Represent a finite element evaluated with a specific quadrature rule on
  * the face of a cell.
@@ -1072,8 +1071,6 @@ class FEFaceValues : public FEFaceValuesBase<dim>
 };
 
 
-
-
 /**
  * Represent a finite element evaluated with a specific quadrature rule on
  * the child of the face of a cell.
@@ -1215,14 +1212,9 @@ class FESubfaceValues : public FEFaceValuesBase<dim>
 };
 
 
-
-
-
 /*------------------------ Inline functions: FEValuesBase ------------------------*/
 
 
-
-
 template <int dim>
 inline
 const FullMatrix<double> & FEValuesBase<dim>::get_shape_values () const
@@ -1234,7 +1226,6 @@ const FullMatrix<double> & FEValuesBase<dim>::get_shape_values () const
 };
 
 
-
 template <int dim>
 inline
 const vector<vector<Tensor<1,dim> > > &
@@ -1245,7 +1236,6 @@ FEValuesBase<dim>::get_shape_grads () const
 };
 
 
-
 template <int dim>
 inline
 const vector<vector<Tensor<2,dim> > > &
@@ -1256,7 +1246,6 @@ FEValuesBase<dim>::get_shape_2nd_derivatives () const
 };
 
 
-
 template <int dim>
 inline
 const vector<Point<dim> > &
@@ -1266,7 +1255,6 @@ FEValuesBase<dim>::get_quadrature_points () const {
 };
 
 
-
 template <int dim>
 inline
 const vector<Point<dim> > &
@@ -1276,7 +1264,6 @@ FEValuesBase<dim>::get_support_points () const {
 };
 
 
-
 template <int dim>
 inline
 const vector<double> &
@@ -1286,7 +1273,6 @@ FEValuesBase<dim>::get_JxW_values () const {
 };
 
 
-
 template <int dim>
 inline
 const FiniteElement<dim> & 
@@ -1307,9 +1293,4 @@ FEFaceValuesBase<dim>::get_normal_vectors () const {
 };
 
 
-
-
-/*----------------------------   fe_values.h     ---------------------------*/
-/* end of #ifndef __fe_values_H */
 #endif
-/*----------------------------   fe_values.h     ---------------------------*/
index 432ca5c8bf83320a4beae083f5d3a8b84b816734..e5a20522a06c7124979ab191cf943465745dd050 100644 (file)
@@ -1,17 +1,25 @@
-/*----------------------------   q1_mapping.h     ---------------------------*/
-/*      $Id$                 */
-/*      Copyright W. Bangerth, University of Heidelberg, 1998 */
-#ifndef __fe_q1_mapping_H
-#define __fe_q1_mapping_H
-/*----------------------------   q1_mapping.h     ---------------------------*/
+//----------------------------  q1_mapping.h  ---------------------------
+//    $Id$
+//    Version: $Name$
+//
+//    Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+//    This file is subject to QPL and may not be  distributed
+//    without copyright and license information. Please refer
+//    to the file deal.II/doc/license.html for the  text  and
+//    further information on this license.
+//
+//----------------------------  q1_mapping.h  ---------------------------
+#ifndef __deal2__q1_mapping_h
+#define __deal2__q1_mapping_h
+
+
 // File has moved from fe_linear_mapping.h
 
 #include <cmath>
 #include <fe/fe.h>
 
 
-
-
 /**
  * Implementation of Q1 transformation to the unit cell.
  * All finite element classes using a Q1 mapping of the grid cell to the
@@ -169,7 +177,7 @@ class FEQ1Mapping : public FiniteElement<dim>
                                            vector<Tensor<3,dim> >               &jacobians);
 
 
-                                    /**
+/**
                                      * Exception
                                      */
     DeclException0 (ExcInternalError);
@@ -180,9 +188,4 @@ class FEQ1Mapping : public FiniteElement<dim>
 };
 
 
-
-
-/*----------------------------   q1_mapping.h     ---------------------------*/
-/* end of #ifndef __q1_mapping_H */
 #endif
-/*----------------------------   q1_mapping.h     ---------------------------*/
index 0888279fc85df8f844a391b9a30d543236f433fc..5f326c2f9159f87a9b110683d1367dca4d9a90d2 100644 (file)
@@ -1,20 +1,15 @@
-/* $Id$ */
-/* Copyright W. Bangerth, University of Heidelberg, 1999 */
-
-
-// deal_II_libraries.g=-ldeal_II_3d.g
-// deal_II_libraries=-ldeal_II_3d
-
-
-// this test case produces a lot of output about hanging nodes in 3d.
-// I used it to track down an error, but it serves perfectly well as
-// a standalone testcase.
+//----------------------------  constraints.cc  ---------------------------
+//    $Id$
+//    Version: $Name$
+//
+//    Copyright (C) 1998, 1999, 2000 by the deal.II authors
 //
-// the tests are reliable in the following way: I checked all test cases
-// for the tri-linear elements by hand, and the first test case for the
-// biquadratic. all other tests are used to find differences in the
-// behavious of the library, without stating that the previous behaviour
-// was correct.
+//    This file is subject to QPL and may not be  distributed
+//    without copyright and license information. Please refer
+//    to the file deal.II/doc/license.html for the  text  and
+//    further information on this license.
+//
+//----------------------------  constraints.cc  ---------------------------
 
 
 #include <dofs/dof_handler.h>
@@ -35,7 +30,6 @@
 #include <cstdlib>
 
 
-
 void make_tria (Triangulation<3> &tria, int step) 
 {
   switch (step)
@@ -163,8 +157,8 @@ void make_tria (Triangulation<3> &tria, int step)
        break;
       };
 
-       
-      case 6:
+
+case 6:
       case 7:
       case 8:
       {
@@ -234,8 +228,6 @@ void make_tria (Triangulation<3> &tria, int step)
 };
 
 
-
-
 int main ()
 {
   ofstream logfile("constraints.output");
index 710dffbc4ed4bc919845414483ef3f1a4ec8a729..85431ed17a08bf8d3e207c9086f2e7d25d4ba4aa 100644 (file)
@@ -1,9 +1,15 @@
-/* $Id$ */
-/* Copyright W. Bangerth, University of Heidelberg, 1998 */
-
-// deal_II_libraries.g=-ldeal_II_2d.g -ldeal_II_3d.g
-// deal_II_libraries=-ldeal_II_2d -ldeal_II_3d
-
+//----------------------------  dof_test.cc  ---------------------------
+//    $Id$
+//    Version: $Name$
+//
+//    Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+//    This file is subject to QPL and may not be  distributed
+//    without copyright and license information. Please refer
+//    to the file deal.II/doc/license.html for the  text  and
+//    further information on this license.
+//
+//----------------------------  dof_test.cc  ---------------------------
 
 
 #include <dofs/dof_handler.h>
@@ -51,8 +57,8 @@ class Ball
        return middle;
       };
 
-    
-    virtual Point<dim>
+
+virtual Point<dim>
     get_new_point_on_quad (const typename Triangulation<dim>::quad_iterator &quad) const
       {
        Point<dim> middle = StraightBoundary<dim>::get_new_point_on_quad(quad);
@@ -82,7 +88,6 @@ class CurvedLine
 };
 
 
-
 template <int dim>
 Point<dim>
 CurvedLine<dim>::get_new_point_on_line (const typename Triangulation<dim>::line_iterator &line) const
@@ -113,7 +118,7 @@ CurvedLine<dim>::get_new_point_on_line (const typename Triangulation<dim>::line_
       return middle;
 
 
-  double x=middle(0),
+double x=middle(0),
         y=middle(1);
   
   if (y<x)
@@ -132,7 +137,6 @@ CurvedLine<dim>::get_new_point_on_line (const typename Triangulation<dim>::line_
 };
 
 
-
 template <int dim>
 Point<dim>
 CurvedLine<dim>::get_new_point_on_quad (const typename Triangulation<dim>::quad_iterator &quad) const
@@ -167,8 +171,6 @@ CurvedLine<dim>::get_new_point_on_quad (const typename Triangulation<dim>::quad_
 };
 
 
-
-
 template <int dim>
 class TestCases
 {
@@ -187,7 +189,6 @@ class TestCases
 };
 
 
-
 template <int dim>
 TestCases<dim>::TestCases () :
                tria(0), dof(0) {};
@@ -201,7 +202,6 @@ TestCases<dim>::~TestCases ()
 };
 
 
-
 template <int dim>
 void TestCases<dim>::create_new ()
 {
@@ -215,9 +215,6 @@ void TestCases<dim>::create_new ()
 };
 
 
-
-
-
 template <int dim>
 void TestCases<dim>::run (const unsigned int test_case)
 {
@@ -291,7 +288,7 @@ void TestCases<dim>::run (const unsigned int test_case)
     };
 
 
-  deallog << "    Distributing degrees of freedom..." << endl;
+deallog << "    Distributing degrees of freedom..." << endl;
   FEQ1<dim> fe;
   dof->distribute_dofs (fe);
 
@@ -300,17 +297,16 @@ void TestCases<dim>::run (const unsigned int test_case)
     
   SparsityPattern sparsity (dof->n_dofs(),
                            dof->max_couplings_between_dofs());
-  
-  
-  DoFTools::make_sparsity_pattern (*dof, sparsity);
+
+
+DoFTools::make_sparsity_pattern (*dof, sparsity);
   int unconstrained_bandwidth = sparsity.bandwidth();
 
   deallog << "    Writing sparsity pattern..." << endl;
   sparsity.print_gnuplot (logfile);
 
 
-  
-                                  // computing constraints
+// computing constraints
   deallog << "    Computing constraints..." << endl;
   ConstraintMatrix constraints;
   DoFTools::make_hanging_node_constraints (*dof, constraints);
@@ -321,7 +317,7 @@ void TestCases<dim>::run (const unsigned int test_case)
   sparsity.print_gnuplot (logfile);
 
 
-  deallog << endl
+deallog << endl
        << "    Total number of cells         = " << tria->n_cells() << endl
        << "    Total number of active cells  = " << tria->n_active_cells() << endl
        << "    Number of DoFs                = " << dof->n_dofs() << endl
@@ -336,7 +332,6 @@ void TestCases<dim>::run (const unsigned int test_case)
 };
 
 
-
 int main ()
 {
   deallog.attach(logfile);
index 82adfb17c204d9b7c0ee9a909a0877e31026b721..c1f86065b547337a67c5b2d621577c3977e61d49 100644 (file)
@@ -1,7 +1,16 @@
-// $Id$
+//----------------------------  fe_tables.cc  ---------------------------
+//    $Id$
+//    Version: $Name$
+//
+//    Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+//    This file is subject to QPL and may not be  distributed
+//    without copyright and license information. Please refer
+//    to the file deal.II/doc/license.html for the  text  and
+//    further information on this license.
+//
+//----------------------------  fe_tables.cc  ---------------------------
 
-// deal_II_libraries.g=-ldeal_II_2d.g -ldeal_II_1d.g
-// deal_II_libraries=-ldeal_II_2d
 
 #include <base/exceptions.h>
 #include <base/point.h>
@@ -94,7 +103,6 @@ print_fe_matrices(const FiniteElement<dim>& high,
 }
 
 
-
 int main()
 {
   deallog.attach(logfile);
index 9aad41133dcefe5117370a5b1e52d2ccba7de4b2..7ce4da8f59d971481894bd5621d17a802db49a46 100644 (file)
@@ -1,15 +1,15 @@
-//     $Id$
-
-// test for correctness of gradients on a given cell. originally, this
-// file did the testing itself, by comparing the computed results with
-// builtin values; this would be unnecessary now, by simply comparing
-// against a prebuilt output file, but it works this way also. if the
-// computations fail at some time, the "ok" will be replaced by
-// "WRONG!", which would let the comparison against the stored .expect
-// file fail also.
-
-// deal_II_libraries.g=-ldeal_II_2d.g
-// deal_II_libraries=-ldeal_II_2d
+//----------------------------  gradients.cc  ---------------------------
+//    $Id$
+//    Version: $Name$
+//
+//    Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+//    This file is subject to QPL and may not be  distributed
+//    without copyright and license information. Please refer
+//    to the file deal.II/doc/license.html for the  text  and
+//    further information on this license.
+//
+//----------------------------  gradients.cc  ---------------------------
 
 
 #include <grid/tria.h>
@@ -46,9 +46,9 @@ int main ()
   QTrapez<2> q;
   FEValues<2> fevalues(fe,q,update_gradients);
   fevalues.reinit (dof.begin_active());
-  
-  
-  Vector<double> val(4);
+
+
+Vector<double> val(4);
 
   deallog << "Testing transformation of gradients of shape function:" << endl;
   
@@ -63,8 +63,8 @@ int main ()
       vector<Tensor<1,2> > grads(4);
       fevalues.get_function_grads (val, grads);
 
-      
-      bool ok;
+
+bool ok;
       switch (vertex) 
        {
          case 0:
index 0ebc21980cc22c6abf76573234f13f9337846f23..152d6c8fd221315dbbf1f1125fbc09ddd7c14e1b 100644 (file)
@@ -1,12 +1,15 @@
-/* $Id$ */
-/* Copyright W. Bangerth, University of Heidelberg, 1998 */
-
-
-
-// deal_II_libraries.g=-ldeal_II_2d.g -ldeal_II_3d.g
-// deal_II_libraries=-ldeal_II_2d -ldeal_II_3d
-
-
+//----------------------------  grid_test.cc  ---------------------------
+//    $Id$
+//    Version: $Name$
+//
+//    Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+//    This file is subject to QPL and may not be  distributed
+//    without copyright and license information. Please refer
+//    to the file deal.II/doc/license.html for the  text  and
+//    further information on this license.
+//
+//----------------------------  grid_test.cc  ---------------------------
 
 
 #include <grid/tria_boundary.h>
@@ -29,10 +32,6 @@ ofstream logfile("grid_test.output");
 // 2: refinement of a wiggled area at the boundary
 
 
-
-
-
-
 template <int dim>
 class Ball :
   public StraightBoundary<dim>
@@ -51,8 +50,8 @@ class Ball :
       return middle;
     };
 
-    
-    virtual Point<dim>
+
+virtual Point<dim>
     get_new_point_on_quad (const typename Triangulation<dim>::quad_iterator &quad) const {
       Point<dim> middle = StraightBoundary<dim>::get_new_point_on_quad(quad);
       
@@ -80,7 +79,6 @@ class CurvedLine :
 };
 
 
-
 template <int dim>
 Point<dim>
 CurvedLine<dim>::get_new_point_on_line (const typename Triangulation<dim>::line_iterator &line) const
@@ -111,7 +109,7 @@ CurvedLine<dim>::get_new_point_on_line (const typename Triangulation<dim>::line_
       return middle;
 
 
-  double x=middle(0),
+double x=middle(0),
         y=middle(1);
   
   if (y<x)
@@ -130,7 +128,6 @@ CurvedLine<dim>::get_new_point_on_line (const typename Triangulation<dim>::line_
 };
 
 
-
 template <int dim>
 Point<dim>
 CurvedLine<dim>::get_new_point_on_quad (const typename Triangulation<dim>::quad_iterator &quad) const
@@ -165,7 +162,6 @@ CurvedLine<dim>::get_new_point_on_quad (const typename Triangulation<dim>::quad_
 };
 
 
-
 template <int dim>
 void test (const int test_case)
 {
@@ -184,8 +180,8 @@ void test (const int test_case)
       return;
     };
 
-  
-  switch (test_case) 
+
+switch (test_case) 
     {
       case 1: 
       {
@@ -222,9 +218,9 @@ void test (const int test_case)
            tria.begin_active()->face(2)->set_boundary_indicator(1);
            tria.begin_active()->face(4)->set_boundary_indicator(1);
          };
-       
-       
-                                        // set the boundary function
+
+
+// set the boundary function
        Ball<dim>       ball;
        CurvedLine<dim> curved_line;
        if (test_case==2)
@@ -256,9 +252,9 @@ void test (const int test_case)
        break;
       }
     };
-  
-  
-  GridOut().write_gnuplot (tria, logfile);
+
+
+GridOut().write_gnuplot (tria, logfile);
     
   deallog << "     Total number of cells        = " << tria.n_cells() << endl
        << "     Total number of active cells = " << tria.n_active_cells() << endl;
@@ -267,7 +263,6 @@ void test (const int test_case)
 };
 
 
-
 int main ()
 {
   logfile.precision(3);
index 2d12b88ceabedb267ce6f3526854b28a16b6675c..d96e98ac10a1f4807f8df50a1d0687f6dcbbbf67 100644 (file)
@@ -1,8 +1,16 @@
-// $Id$
-/* (c) Guido Kanschat, 1999 */
+//----------------------------  mg.cc  ---------------------------
+//    $Id$
+//    Version: $Name$
+//
+//    Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+//    This file is subject to QPL and may not be  distributed
+//    without copyright and license information. Please refer
+//    to the file deal.II/doc/license.html for the  text  and
+//    further information on this license.
+//
+//----------------------------  mg.cc  ---------------------------
 
-// deal_II_libraries.g=-ldeal_II_2d.g
-// deal_II_libraries=-ldeal_II_2d
 
 #include <base/function.h>
 #include <base/quadrature_lib.h>
@@ -34,8 +42,6 @@
 #include <fstream>
 
 
-
-
 template<int dim>
 class RHSFunction : public Function<dim>
 {
@@ -144,9 +150,9 @@ int main()
          MGSmootherLAC smoother(mgA);
          MGTransferPrebuilt transfer;
          transfer.build_matrices(mgdof);
-         
-         
-         Multigrid<2> multigrid(mgdof, hanging_nodes, mgstruct, mgA, transfer);
+
+
+Multigrid<2> multigrid(mgdof, hanging_nodes, mgstruct, mgA, transfer);
          PreconditionMG<Multigrid<2> >
            mgprecondition(multigrid, smoother, smoother, coarse);
          
index be63e1a6ae97c250f1b55fbbcff3395d898b47e7..5c7ca307397574c9d223abfae4837362b99a140e 100644 (file)
@@ -1,8 +1,16 @@
-// $Id$
-/* (c) Guido Kanschat, 1999 */
+//----------------------------  mglocal.cc  ---------------------------
+//    $Id$
+//    Version: $Name$
+//
+//    Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+//    This file is subject to QPL and may not be  distributed
+//    without copyright and license information. Please refer
+//    to the file deal.II/doc/license.html for the  text  and
+//    further information on this license.
+//
+//----------------------------  mglocal.cc  ---------------------------
 
-// deal_II_libraries.g=-ldeal_II_2d.g
-// deal_II_libraries=-ldeal_II_2d
 
 #include <base/function.h>
 #include <base/quadrature_lib.h>
@@ -39,7 +47,6 @@ MGSmoother* smoother_object;
 #endif
 
 
-
 int step_counter = 0;
 
 #include "helmholtz.h"
@@ -156,9 +163,9 @@ int main()
          
          MGTransferPrebuilt transfer;
          transfer.build_matrices(mgdof);
-         
-         
-         Multigrid<2> multigrid(mgdof, hanging_nodes, mgstruct, mgA, transfer, tr.n_levels()-2);
+
+
+Multigrid<2> multigrid(mgdof, hanging_nodes, mgstruct, mgA, transfer, tr.n_levels()-2);
          PreconditionMG<Multigrid<2> >
            mgprecondition(multigrid, smoother, smoother, coarse);
 
index 82d7cf3587a6cc78a8d6e1d6a6bc765a9b23a0ce..1a8a3ee56ad2f15e9b932c0ca2cb8ebc4b90bb81 100644 (file)
@@ -1,8 +1,16 @@
-//     $Id$    
-// test for correctness of gradients on a given cell
+//----------------------------  second_derivatives.cc  ---------------------------
+//    $Id$
+//    Version: $Name$
+//
+//    Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+//    This file is subject to QPL and may not be  distributed
+//    without copyright and license information. Please refer
+//    to the file deal.II/doc/license.html for the  text  and
+//    further information on this license.
+//
+//----------------------------  second_derivatives.cc  ---------------------------
 
-// deal_II_libraries.g=-ldeal_II_2d.g
-// deal_II_libraries=-ldeal_II_2d
 
 #include <grid/tria.h>
 #include <grid/tria_boundary.h>
@@ -36,9 +44,9 @@ int main ()
   StraightBoundary<2> b;
   QTrapez<2> q;
   FEValues<2> fevalues(fe,q,update_second_derivatives);
-  
-  
-  Vector<double> val(4);
+
+
+Vector<double> val(4);
 
   deallog << "Testing transformation of 2nd derivatives of shape function:" << endl;
   
index 3adef59acc16cbb51362ba02e4e9fb925e6b79f0..ada2e99351e34def29bc28d37c272da2f1d75b01 100644 (file)
@@ -1,5 +1,16 @@
-// deal_II_libraries.g=-ldeal_II_2d.g
-// deal_II_libraries=-ldeal_II_2d
+//----------------------------  wave-test-3.cc  ---------------------------
+//    $Id$
+//    Version: $Name$
+//
+//    Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+//    This file is subject to QPL and may not be  distributed
+//    without copyright and license information. Please refer
+//    to the file deal.II/doc/license.html for the  text  and
+//    further information on this license.
+//
+//----------------------------  wave-test-3.cc  ---------------------------
+
 
 #include <grid/tria_boundary_lib.h>
 #include <base/parameter_handler.h>
@@ -27,7 +38,6 @@ template <int dim> class TimeStep_ErrorEstimation;
 template <int dim> class TimeStep_Postprocess;
 
 
-
 template <int dim>
 class TimeStepBase_Wave :  public TimeStepBase_Tria<dim>{
   public:
@@ -49,7 +59,6 @@ class TimeStepBase_Wave :  public TimeStepBase_Tria<dim>{
 };
 
 
-
 template <int dim>
 class TimeStep_Wave :  public virtual TimeStepBase_Wave<dim>
 {
@@ -65,9 +74,9 @@ class TimeStep_Wave :  public virtual TimeStepBase_Wave<dim>
     virtual string branch_signature () const = 0;
     DeclException0 (ExcIO);
     DeclException0 (ExcCoarsestGridsDiffer);
-    
-    
-  protected:
+
+
+protected:
     struct StatisticData 
     {
        StatisticData ();
@@ -111,7 +120,6 @@ class TimeStep_Wave :  public virtual TimeStepBase_Wave<dim>
 };
 
 
-
 template <int dim>
 class TimeStep_Primal :  public TimeStep_Wave<dim> 
 {
@@ -148,7 +156,6 @@ class TimeStep_Primal :  public TimeStep_Wave<dim>
 };
 
 
-
 template <int dim>
 class TimeStep_Dual :  public TimeStep_Wave<dim>
 {
@@ -185,11 +192,9 @@ class TimeStep_Dual :  public TimeStep_Wave<dim>
 };
 
 
-
 #include <lac/full_matrix.h>
 
 
-
 template <int dim>
 class TimeStep_ErrorEstimation :  public virtual TimeStepBase_Wave<dim>
 {
@@ -220,7 +225,7 @@ class TimeStep_ErrorEstimation :  public virtual TimeStepBase_Wave<dim>
     };
 
 
-    struct CellwiseError
+struct CellwiseError
     {
        CellwiseError (const unsigned int n_errors);
        vector<ErrorOnCell>                    errors;
@@ -317,11 +322,9 @@ class TimeStep_Postprocess : public TimeStep_ErrorEstimation<dim>
 };
 
 
-
 template <int dim> class WaveParameters;
 
 
-
 template <int dim>
 class TimeStep :  public TimeStep_Primal<dim>, public TimeStep_Dual<dim>, public TimeStep_Postprocess<dim>
 {
@@ -341,7 +344,6 @@ template <int dim> class TimeStep_Primal;
 template <int dim> class TimeStep_Dual;
 
 
-
 template <int dim>
 class DualFunctional {
   public:
@@ -454,9 +456,6 @@ class DualFunctional {
 };
 
 
-
-
-
 /**
  * Compute the dual functional which is approximately associated
  * with the end time energy in the high atmosphere above 4000km.
@@ -486,11 +485,6 @@ class EndEnergy : public DualFunctional<dim> {
 };
 
 
-
-
-
-
-
 /**
  * Let the point value of $u$ at the origin integrated over time
  * be the goal.
@@ -513,9 +507,6 @@ class IntegratedValueAtOrigin : public EndEnergy<dim> {
 };
 
 
-
-
-
 /**
  * Dual function corresponding to the #EvaluateSeismicSignal# class.
  */
@@ -532,7 +523,6 @@ class SeismicSignal : public DualFunctional<dim> {
 };
 
 
-
 /**
  * Compute the dual problem associated with the functional
  * $J(\Psi) = \int u ds$ with the integral being over some
@@ -551,7 +541,6 @@ class EarthSurface : public DualFunctional<dim> {
 };
 
 
-
 /**
  * Compute $J(\Psi) = \int_0^0.25 u(x=2,y,t=2.2) dy.
  */
@@ -568,9 +557,6 @@ class SplitSignal : public DualFunctional<dim> {
 };
 
 
-
-
-
 /**
  * 1d test case, evaluating the region (-.5,.5) at the endtime. Intended for some
  * tests on split triangulations with one fine and one coarse region.
@@ -587,7 +573,6 @@ class SplitLine : public DualFunctional<dim> {
 };
 
 
-
 /**
  * Compute $J(\Psi) = \int_{-0.6}^{-0.4} u(x,t=2.5) dx.
  */
@@ -604,7 +589,6 @@ class OneBranch1d : public DualFunctional<dim> {
 };
 
 
-
 /**
  * Compute $J(\Psi) = \int_{-0.1}^{0.1} u(x,t=2.4) dx.
  */
@@ -621,7 +605,6 @@ class SecondCrossing : public DualFunctional<dim> {
 };
 
 
-
 /**
  */
 template <int dim>
@@ -644,9 +627,6 @@ class HuyghensWave : public DualFunctional<dim> {
 #include <string>
 
 
-
-
-
 /**
  * This class provides a simple interface to do arbitrary evaluations of
  * the numerical solution. Concrete classes implementing evaluations
@@ -807,9 +787,6 @@ class EvaluationBase {
 };
 
 
-
-
-
 /**
  * This class is a common base class to the following two. It provides
  * for some infrastructure for evaluations computing the energy in part
@@ -863,11 +840,6 @@ class EvaluateEnergyContent : public EvaluationBase<dim> {
 };
 
 
-
-
-
-
-
 /**
  * Evaluate the value of $u$ at the origin, i.e. $u(0,0)$.
  *
@@ -900,10 +872,6 @@ class EvaluateIntegratedValueAtOrigin : public EvaluationBase<dim> {
 };
 
 
-
-
-
-
 /**
  * Integrate the value of $u_h$ at the top boundary over $x$ and $t$ using a
  * highly oscillatory weight.
@@ -918,9 +886,9 @@ class EvaluateSeismicSignal : public EvaluationBase<dim> {
       const double pi = 3.14159265359;
       return sin(3*pi*p(0))*sin(5*pi*time/2);
     };
-    
-    
-    virtual double evaluate ();
+
+
+virtual double evaluate ();
     virtual void print_final_result (ostream &out);
     virtual double get_final_result ();
     virtual string description () const;
@@ -935,7 +903,6 @@ class EvaluateSeismicSignal : public EvaluationBase<dim> {
 };
 
 
-
 /**
  * Integrate the value of $u_h$ at the top line $x=1.5, y=0..1/16$ at $t=1.6..1.8$.
  */
@@ -944,9 +911,9 @@ class EvaluateSplitSignal : public EvaluationBase<dim> {
   public:
     EvaluateSplitSignal () :
                    result (0) {};
-    
-    
-    virtual double evaluate ();
+
+
+virtual double evaluate ();
     virtual void print_final_result (ostream &out);
     virtual double get_final_result ();
     virtual string description () const;
@@ -960,16 +927,15 @@ class EvaluateSplitSignal : public EvaluationBase<dim> {
     double result;
 };
 
-    
 
 template <int dim>
 class EvaluateOneBranch1d : public EvaluationBase<dim> {
   public:
     EvaluateOneBranch1d () :
                    result (0) {};
-    
-    
-    virtual double evaluate ();
+
+
+virtual double evaluate ();
     virtual void print_final_result (ostream &out);
     virtual double get_final_result ();
     virtual string description () const;
@@ -984,16 +950,14 @@ class EvaluateOneBranch1d : public EvaluationBase<dim> {
 };
 
 
-
-
 template <int dim>
 class EvaluateSecondCrossing1d : public EvaluationBase<dim> {
   public:
     EvaluateSecondCrossing1d () :
                    result (0) {};
-    
-    
-    virtual double evaluate ();
+
+
+virtual double evaluate ();
     virtual void print_final_result (ostream &out);
     virtual double get_final_result ();
     virtual string description () const;
@@ -1008,16 +972,15 @@ class EvaluateSecondCrossing1d : public EvaluationBase<dim> {
 };
 
 
-
 template <int dim>
 class EvaluateHuyghensWave : public EvaluationBase<dim> {
   public:
     EvaluateHuyghensWave () :
                    integrated_value (0),
                    weighted_value (0) {};
-    
-    
-    virtual double evaluate ();
+
+
+virtual double evaluate ();
     virtual void print_final_result (ostream &out);
     virtual double get_final_result ();
     virtual string description () const;
@@ -1032,12 +995,9 @@ class EvaluateHuyghensWave : public EvaluationBase<dim> {
 };
 
 
-    
-
 template <int dim> class DataOutStack;
 
 
-
 /**
  * This class has some data members which are shared between the different
  * time steps within one sweep. Unlike the #SweepInfo# class, the members
@@ -1055,13 +1015,11 @@ class SweepData
 };
 
 
-
 #include <base/timer.h>
 #include <iostream>
 #include <list>
 
 
-
 /**
  * This class provides some data members which collect information on the
  * different time steps of one sweep.
@@ -1085,7 +1043,7 @@ class SweepInfo
     };
 
 
-    struct Timers 
+struct Timers 
     {
        Timer grid_generation;
        Timer primal_problem;
@@ -1095,12 +1053,12 @@ class SweepInfo
     };
 
 
-    Data & get_data ();
+Data & get_data ();
 
     Timers & get_timers ();
-    
-    
-    template <int dim>
+
+
+template <int dim>
     void write_summary (const list<EvaluationBase<dim>*> & eval_list,
                        ostream &out) const;
     
@@ -1110,12 +1068,9 @@ class SweepInfo
 };
 
 
-
 #include <lac/sparse_matrix.h>
 
 
-
-
 /**
  * Enum denoting the different possibilities to precondition a solver.
  */
@@ -1127,7 +1082,6 @@ enum Preconditioning {
 };
 
 
-
 /**
  * Wrapper for the #SparseMatrix<double># class which handles the preconditioning.
  */
@@ -1187,7 +1141,6 @@ inline number sqr (const number a) {
 };
 
 
-
 /**
  * This is a helper class which has a collection of static elements and returns
  * the right finite element as a pointer when the name of the element is given.
@@ -1242,7 +1195,6 @@ struct FEHelper {
 };
 
 
-
 #include <base/forward_declarations.h>
 #include <grid/forward_declarations.h>
 #include <list>
@@ -1252,8 +1204,6 @@ template <int dim> class DualFunctional;
 template <int dim> class EvaluationBase;
 
 
-
-
 /**
  * This is a class holding all the input parameters to the program. It is more
  * or less a loose collection of data and the only purpose of this class is
@@ -1770,9 +1720,9 @@ class WaveParameters
                                      * Undefined copy operator.
                                      */
     WaveParameters & operator = (const WaveParameters &);
-    
-    
-                                    /**
+
+
+/**
                                      * List of names for the initial values.
                                      * Make this a member of the templated
                                      * class since the supported initial
@@ -1802,8 +1752,8 @@ class WaveParameters
                                      */
     static const string dual_functional_names;
 
-    
-                                    /**
+
+/**
                                      * Set the initial function pointers
                                      * depending on the given names.
                                      */
@@ -1841,7 +1791,6 @@ class WaveParameters
 };
 
 
-
 #include <numerics/time_dependent.h>
 
 template <int dim> class WaveParameters;
@@ -1849,7 +1798,6 @@ template <int dim> class DataOutStack;
 class SweepInfo;
 
 
-
 /**
  * Top-level class of the timestepping mechanism. This class manages
  * the execution and solution of primal and dual problem, of computing
@@ -1908,9 +1856,6 @@ class TimestepManager : public TimeDependent {
 };
 
 
-
-
-
 /**
  * Top-level class providing the set up of a simulation. The
  * class provides an interface suitable to the #MultipleParameterLoop#
@@ -1971,9 +1916,6 @@ class WaveProblem :  public MultipleParameterLoop::UserClass {
 };
 
 
-
-
-
 /* $Id$ */
 
 
@@ -1991,7 +1933,6 @@ class WaveProblem :  public MultipleParameterLoop::UserClass {
 #include <cmath>
 
 
-
 /*------------------------ DualFunctional --------------------------------*/
 
 template <int dim>
@@ -2019,7 +1960,6 @@ DualFunctional<dim>::DualFunctional (const bool use_primal_problem,
 {};
 
 
-
 template <int dim>
 void DualFunctional<dim>::compute_functionals (Vector<double> &j1,
                                               Vector<double> &j2) {
@@ -2028,7 +1968,6 @@ void DualFunctional<dim>::compute_functionals (Vector<double> &j1,
 };
 
 
-
 template <int dim>
 void DualFunctional<dim>::compute_endtime_vectors (Vector<double> &final_u_bar,
                                                   Vector<double> &final_v_bar) {
@@ -2037,21 +1976,18 @@ void DualFunctional<dim>::compute_endtime_vectors (Vector<double> &final_u_bar,
 };
 
 
-
 template <int dim>
 bool DualFunctional<dim>::use_primal_solutions () const {
   return use_primal_problem;
 };
 
 
-
 template <int dim>
 bool DualFunctional<dim>::use_primal_solutions_at_endtime () const {
   return use_primal_problem_at_endtime;
 };
 
 
-
 template <int dim>
 void DualFunctional<dim>::reset (const TimeStep_Primal<dim> &primal_problem) {
   Assert (use_primal_problem ||
@@ -2069,7 +2005,6 @@ void DualFunctional<dim>::reset (const TimeStep_Primal<dim> &primal_problem) {
 };
 
 
-
 template <int dim>
 void DualFunctional<dim>::reset (const TimeStep_Dual<dim> &dual_problem) {
   tria            = dual_problem.tria;
@@ -2088,13 +2023,6 @@ void DualFunctional<dim>::reset (const TimeStep_Dual<dim> &dual_problem) {
 };
 
 
-
-
-
-
-
-
-
 /* ----------------------- EndEnergy ------------------------------*/
 
 
@@ -2103,8 +2031,6 @@ EndEnergy<dim>::EndEnergy (const bool use_primal_problem) :
                DualFunctional<dim> (use_primal_problem, true) {};
 
 
-
-
 template <int dim>
 void EndEnergy<dim>::compute_vectors (const PartOfDomain pod,
                                      Vector<double> &final_u_bar,
@@ -2154,9 +2080,9 @@ void EndEnergy<dim>::compute_vectors (const PartOfDomain pod,
                  continue;
                break;
        };
-      
-      
-      fe_values.reinit (cell);
+
+
+fe_values.reinit (cell);
       fe_values_primal.reinit (primal_cell);
       fe_values_primal.get_function_values (*v, local_v);
       fe_values_primal.get_function_grads (*u, local_u_grad);
@@ -2201,9 +2127,6 @@ void EndEnergy<dim>::compute_vectors (const PartOfDomain pod,
 };
 
 
-
-
-
 /*------------------------ IntegrateValueAtOrigin --------------------------------*/
 
 
@@ -2233,10 +2156,6 @@ void IntegratedValueAtOrigin<dim>::compute_functionals (Vector<double> &j1,
 };
 
 
-
-
-
-
 /*------------------------ SeismicSignal --------------------------------*/
 
 
@@ -2248,7 +2167,6 @@ void SeismicSignal<1>::compute_functionals (Vector<double> &,
 };
 
 
-
 template <int dim>
 void SeismicSignal<dim>::compute_functionals (Vector<double> &j1,
                                              Vector<double> &j2) {
@@ -2307,8 +2225,6 @@ void SeismicSignal<dim>::compute_functionals (Vector<double> &j1,
 };
 
 
-
-
 /*------------------------ EarthSurface --------------------------------*/
 
 
@@ -2320,7 +2236,6 @@ void EarthSurface<1>::compute_functionals (Vector<double> &,
 };
 
 
-
 template <int dim>
 void EarthSurface<dim>::compute_functionals (Vector<double> &j1,
                                             Vector<double> &j2) {
@@ -2366,8 +2281,6 @@ void EarthSurface<dim>::compute_functionals (Vector<double> &j1,
 };
 
 
-
-
 /*------------------------ SplitSignal --------------------------------*/
 
 
@@ -2379,8 +2292,6 @@ void SplitSignal<1>::compute_functionals (Vector<double> &,
 };
 
 
-
-
 template <int dim>
 void SplitSignal<dim>::compute_functionals (Vector<double> &j1,
                                            Vector<double> &j2) {
@@ -2440,8 +2351,6 @@ void SplitSignal<dim>::compute_functionals (Vector<double> &j1,
 };
 
 
-
-
 /* ------------------------------ Split line 1d case ----------------------------- */
 
 template <int dim>
@@ -2496,11 +2405,9 @@ void SplitLine<1>::compute_endtime_vectors (Vector<double> &final_u_bar,
 #endif
 
 
-
 /*------------------------ OneBranch1d --------------------------------*/
 
 
-
 template <int dim>
 void OneBranch1d<dim>::compute_functionals (Vector<double> &j1,
                                            Vector<double> &j2) {
@@ -2545,11 +2452,9 @@ void OneBranch1d<dim>::compute_functionals (Vector<double> &j1,
 };
 
 
-
 /*------------------------ SecondCrossing --------------------------------*/
 
 
-
 template <int dim>
 void SecondCrossing<dim>::compute_functionals (Vector<double> &j1,
                                               Vector<double> &j2) {
@@ -2592,11 +2497,9 @@ void SecondCrossing<dim>::compute_functionals (Vector<double> &j1,
 };
 
 
-
 /*------------------------ HuyghensWave --------------------------------*/
 
 
-
 template <int dim>
 void HuyghensWave<dim>::compute_functionals (Vector<double> &j1,
                                             Vector<double> &j2) {
@@ -2634,7 +2537,6 @@ void HuyghensWave<dim>::compute_functionals (Vector<double> &j1,
 };
 
 
-
 // explicit specializations
 
 template class DualFunctional<2>;
@@ -2667,7 +2569,6 @@ template class HuyghensWave<2>;
 #include <fstream>
 
 
-
 /*--------------------------- EvaluationBase --------------------------*/
 
 template <int dim>
@@ -2712,12 +2613,10 @@ void EvaluationBase<dim>::reset_timelevel (const TimeStep_Primal<dim> &target) {
 };
 
 
-
 template <int dim>
 void EvaluationBase<dim>::reset () {};
 
 
-
 template <int dim>
 void EvaluationBase<dim>::print_final_result (ostream &) {};
 
@@ -2728,10 +2627,6 @@ double EvaluationBase<dim>::get_final_result () {
 };
 
 
-
-
-
-
 /*--------------------------- EvaluateEnergyContent ----------------------*/
 
 template <int dim>
@@ -2747,7 +2642,6 @@ void EvaluateEnergyContent<dim>::reset () {
 };
 
 
-
 template <int dim>
 double EvaluateEnergyContent<dim>::compute_energy (const PartOfDomain pod) const {
   const double y_offset = 300000000;
@@ -2785,9 +2679,9 @@ double EvaluateEnergyContent<dim>::compute_energy (const PartOfDomain pod) const
                  continue;
                break;
        };
-      
-      
-      fe_values.reinit (cell);
+
+
+fe_values.reinit (cell);
       const FullMatrix<double>             &values    = fe_values.get_shape_values();
       const vector<vector<Tensor<1,dim> > >&gradients = fe_values.get_shape_grads ();
       const vector<double>                 &weights   = fe_values.get_JxW_values ();
@@ -2828,8 +2722,6 @@ double EvaluateEnergyContent<dim>::compute_energy (const PartOfDomain pod) const
 };
 
 
-
-
 /* ---------------------------- EvaluateIntegratedValueAtOrigin ------------------- */
 
 
@@ -2840,28 +2732,24 @@ void EvaluateIntegratedValueAtOrigin<dim>::print_final_result (ostream &out) {
 };
 
 
-
 template <int dim>
 double EvaluateIntegratedValueAtOrigin<dim>::get_final_result () {
   return integrated_value;
 };
 
 
-
 template <int dim>
 string EvaluateIntegratedValueAtOrigin<dim>::description () const {
   return "integrated value at origin";
 };
 
 
-
 template <int dim>
 void EvaluateIntegratedValueAtOrigin<dim>::reset () {
   integrated_value = 0;
 };
 
 
-
 template <int dim>
 double EvaluateIntegratedValueAtOrigin<dim>::evaluate () {
   DoFHandler<dim>::active_cell_iterator cell = dof->begin_active(),
@@ -2890,10 +2778,6 @@ double EvaluateIntegratedValueAtOrigin<dim>::evaluate () {
 };
 
 
-
-
-
-
 /*------------------------- EvaluateSeismicSignal --------------------------*/
 
 
@@ -2903,28 +2787,24 @@ void EvaluateSeismicSignal<dim>::print_final_result (ostream &out) {
 };
 
 
-
 template <int dim>
 double EvaluateSeismicSignal<dim>::get_final_result () {
   return result;
 };
 
 
-
 template <int dim>
 string EvaluateSeismicSignal<dim>::description () const {
   return "Integrated seismic signal at top";
 };
 
 
-
 template <int dim>
 void EvaluateSeismicSignal<dim>::reset () {
   result = 0;
 };
 
 
-
 template <>
 double EvaluateSeismicSignal<1>::evaluate ()
 {
@@ -2933,7 +2813,6 @@ double EvaluateSeismicSignal<1>::evaluate ()
 };
 
 
-
 template <int dim>
 double EvaluateSeismicSignal<dim>::evaluate () {
   const unsigned int n_q_points = quadrature_face->n_quadrature_points;
@@ -2992,8 +2871,6 @@ double EvaluateSeismicSignal<dim>::evaluate () {
 };
 
 
-
-
 /*------------------------- EvaluateSplitSignal --------------------------*/
 
 
@@ -3003,28 +2880,24 @@ void EvaluateSplitSignal<dim>::print_final_result (ostream &out) {
 };
 
 
-
 template <int dim>
 double EvaluateSplitSignal<dim>::get_final_result () {
   return result;
 };
 
 
-
 template <int dim>
 string EvaluateSplitSignal<dim>::description () const {
   return "Integrated split signal (exact: (2+pi)/(16-pi)=0.010229)";
 };
 
 
-
 template <int dim>
 void EvaluateSplitSignal<dim>::reset () {
   result = 0;
 };
 
 
-
 template <>
 double EvaluateSplitSignal<1>::evaluate ()
 {
@@ -3033,7 +2906,6 @@ double EvaluateSplitSignal<1>::evaluate ()
 };
 
 
-
 template <int dim>
 double EvaluateSplitSignal<dim>::evaluate () {
   if ((time<=1.6) || (time>1.8))
@@ -3085,8 +2957,6 @@ double EvaluateSplitSignal<dim>::evaluate () {
 };
 
 
-
-
 /*------------------------- EvaluateOneBranch1d --------------------------*/
 
 
@@ -3096,28 +2966,24 @@ void EvaluateOneBranch1d<dim>::print_final_result (ostream &out) {
 };
 
 
-
 template <int dim>
 double EvaluateOneBranch1d<dim>::get_final_result () {
   return result;
 };
 
 
-
 template <int dim>
 string EvaluateOneBranch1d<dim>::description () const {
   return "One branch integrated (exact: 0.055735)";
 };
 
 
-
 template <int dim>
 void EvaluateOneBranch1d<dim>::reset () {
   result = 0;
 };
 
 
-
 template <int dim>
 double EvaluateOneBranch1d<dim>::evaluate ()
 {
@@ -3162,8 +3028,6 @@ double EvaluateOneBranch1d<1>::evaluate () {
 #endif
 
 
-
-
 /*------------------------- EvaluateSecondCrossing1d --------------------------*/
 
 
@@ -3173,28 +3037,24 @@ void EvaluateSecondCrossing1d<dim>::print_final_result (ostream &out) {
 };
 
 
-
 template <int dim>
 double EvaluateSecondCrossing1d<dim>::get_final_result () {
   return result;
 };
 
 
-
 template <int dim>
 string EvaluateSecondCrossing1d<dim>::description () const {
   return "Second crossing (exact: 0.011147)";
 };
 
 
-
 template <int dim>
 void EvaluateSecondCrossing1d<dim>::reset () {
   result = 0;
 };
 
 
-
 template <int dim>
 double EvaluateSecondCrossing1d<dim>::evaluate ()
 {
@@ -3241,7 +3101,6 @@ double EvaluateSecondCrossing1d<1>::evaluate () {
 #endif
 
 
-
 /*------------------------- EvaluateHuyghensWave --------------------------*/
 
 
@@ -3252,28 +3111,24 @@ void EvaluateHuyghensWave<dim>::print_final_result (ostream &out) {
 };
 
 
-
 template <int dim>
 double EvaluateHuyghensWave<dim>::get_final_result () {
   return weighted_value / integrated_value;
 };
 
 
-
 template <int dim>
 string EvaluateHuyghensWave<dim>::description () const {
   return "Huyghens wave";
 };
 
 
-
 template <int dim>
 void EvaluateHuyghensWave<dim>::reset () {
   integrated_value = weighted_value = 0;
 };
 
 
-
 template <int dim>
 double EvaluateHuyghensWave<dim>::evaluate ()
 {
@@ -3314,7 +3169,6 @@ double EvaluateHuyghensWave<dim>::evaluate ()
 };
 
 
-               
 // explicit instantiations
 template class EvaluationBase<2>;
 template class EvaluateEnergyContent<2>;
@@ -3353,7 +3207,6 @@ TimestepManager<dim>::TimestepManager (const WaveParameters<dim> &parameters) :
 {};
 
 
-
 template <int dim>
 void TimestepManager<dim>::run_sweep (const unsigned int sweep_no)
 {
@@ -3374,9 +3227,9 @@ void TimestepManager<dim>::run_sweep (const unsigned int sweep_no)
          (parameters.refinement_strategy == WaveParameters<dim>::dual_estimator))
        sweep_data.data_out_stack->declare_data_vector ("est_error", DataOutStack<dim>::cell_vector);
     };
-  
-  
-  deallog << "Sweep " << setw(2) << sweep_no << ':' << endl
+
+
+deallog << "Sweep " << setw(2) << sweep_no << ':' << endl
        << "---------" << endl;
 
   for (typename list<EvaluationBase<dim>*>::const_iterator i = parameters.eval_list.begin();
@@ -3424,15 +3277,13 @@ void TimestepManager<dim>::run_sweep (const unsigned int sweep_no)
 };
 
 
-
-
 template <int dim>
 void TimestepManager<dim>::refine_grids () 
 {
   deallog << "  Collecting refinement data: " << endl;
 
-  
-  const unsigned int n_timesteps = timesteps.size();
+
+const unsigned int n_timesteps = timesteps.size();
       
                                       // first collect all the error indicators
   vector<Vector<float> > indicators (n_timesteps);
@@ -3442,15 +3293,14 @@ void TimestepManager<dim>::refine_grids ()
       ->get_timestep_postprocess().get_tria_refinement_criteria (indicators[i]);
 
 
-                                  // count the number of cells for some
+// count the number of cells for some
                                   // statistics and other things
   unsigned int total_number_of_cells = 0;
   for (unsigned int i=0; i<timesteps.size(); ++i)
     total_number_of_cells += indicators[i].size();
 
 
-
-  if (parameters.produce_error_statistics)
+if (parameters.produce_error_statistics)
     {
       deallog << "    Generating error statistics ";
 
@@ -3469,7 +3319,7 @@ void TimestepManager<dim>::refine_grids ()
     };
 
 
-  if (parameters.compare_indicators_globally)
+if (parameters.compare_indicators_globally)
     {
 
                                       // collect all indicators in one
@@ -3613,14 +3463,12 @@ void TimestepManager<dim>::refine_grids ()
        static_cast<TimeStepBase_Tria<dim>*>(timesteps.back())->sleep(1);
 
 
-      deallog << "    Got " << total_number_of_cells << " presently, expecting "
+deallog << "    Got " << total_number_of_cells << " presently, expecting "
           << total_expected_cells << " for next sweep." << endl;
     };
 };
 
 
-
-
 template <int dim>
 void TimestepManager<dim>::write_statistics (const SweepInfo &sweep_info) const 
 {
@@ -3652,8 +3500,8 @@ void TimestepManager<dim>::write_statistics (const SweepInfo &sweep_info) const
       deallog << endl;
     };
 
-  
-                                  // write summary
+
+// write summary
   if (true)
     {
       deallog << "    Writing summary.";
@@ -3666,7 +3514,6 @@ void TimestepManager<dim>::write_statistics (const SweepInfo &sweep_info) const
     };
 };
 
-                                                       
 
 template <int dim>
 void TimestepManager<dim>::write_stacked_data (DataOutStack<dim> &data_out_stack) const 
@@ -3687,8 +3534,6 @@ void TimestepManager<dim>::write_stacked_data (DataOutStack<dim> &data_out_stack
 };
 
 
-
-
 //explicit instantiation
 template class TimestepManager<2>;
   
@@ -3743,13 +3588,11 @@ const string WaveParameters<dim>::dual_functional_names ("none"
                                                         "|Huyghens wave");
 
 
-
 DeclException1 (ExcUnknownName,
                string,
                << "Unknown description string " << arg1);
 
 
-
 template <int dim>
 class InitialValues {
   public:
@@ -3775,7 +3618,7 @@ class InitialValues {
     };
 
 
-    class SmallBump : public Function<dim> {
+class SmallBump : public Function<dim> {
       public:
        virtual double value (const Point<dim> &p,
                              const unsigned int) const {
@@ -3788,7 +3631,7 @@ class InitialValues {
     };
 
 
-    class ShiftedBump : public Function<dim> {
+class ShiftedBump : public Function<dim> {
       public:
        virtual double value (const Point<dim> &p,
                              const unsigned int) const {
@@ -3823,7 +3666,7 @@ class InitialValues {
     };
 
 
-    class Earthquake : public Function<dim> {
+class Earthquake : public Function<dim> {
       public:
        virtual double value (const Point<dim> &p,
                              const unsigned int) const {
@@ -3837,7 +3680,6 @@ class InitialValues {
 };
 
 
-
 template <int dim>
 class Coefficients {
   public:
@@ -3877,7 +3719,7 @@ class Coefficients {
     };
 
 
-    class Gradient : public Function<dim> {
+class Gradient : public Function<dim> {
       public:
        inline virtual double value (const Point<dim> &p,
                                     const unsigned int) const {
@@ -3909,8 +3751,7 @@ class Coefficients {
     };
 
 
-
-    class PreliminaryEarthModel : public Function<dim> {
+class PreliminaryEarthModel : public Function<dim> {
       public:
        inline virtual double value (const Point<dim> &p,
                                     const unsigned int) const {
@@ -3948,9 +3789,8 @@ class Coefficients {
        };
     };
 
-    
-    
-    class Distorted : public Function<dim> {
+
+class Distorted : public Function<dim> {
       public:
        inline virtual double value (const Point<dim> &p,
                                     const unsigned int) const {
@@ -3988,8 +3828,6 @@ class Coefficients {
 };
 
 
-
-
 template <int dim>
 class BoundaryValues {
   public:
@@ -4021,7 +3859,7 @@ class BoundaryValues {
     };
 
 
-    class FastWaveFromLeft_u : public Function<dim> {
+class FastWaveFromLeft_u : public Function<dim> {
       public:
        virtual double value (const Point<dim> &p,
                              const unsigned int) const {
@@ -4045,8 +3883,8 @@ class BoundaryValues {
        };
     };
 
-    
-    class WaveFromLeftCenter_u : public Function<dim> {
+
+class WaveFromLeftCenter_u : public Function<dim> {
       public:
        virtual double value (const Point<dim> &p,
                              const unsigned int) const {
@@ -4071,7 +3909,7 @@ class BoundaryValues {
     };
 
 
-    class WaveFromLeftBottom_u : public Function<dim> {
+class WaveFromLeftBottom_u : public Function<dim> {
       public:
        virtual double value (const Point<dim> &p,
                              const unsigned int) const {
@@ -4119,7 +3957,6 @@ class BoundaryValues {
 };
 
 
-
 template <int dim>
 class Boundaries 
 {
@@ -4133,9 +3970,9 @@ class Boundaries
          middle *= sqrt(line->vertex(0).square()) / sqrt(middle.square());
          return middle;
        };
-       
-       
-       virtual Point<dim>
+
+
+virtual Point<dim>
        get_new_point_on_quad (const typename Triangulation<dim>::quad_iterator &quad) const {
          Point<dim> middle = StraightBoundary<dim>::get_new_point_on_quad (quad);
          middle *= sqrt(quad->vertex(0).square()) / sqrt(middle.square());
@@ -4145,8 +3982,6 @@ class Boundaries
 };
 
 
-
-
 template <int dim>
 WaveParameters<dim>::WaveParameters () :
                boundary_values_u (0),
@@ -4161,7 +3996,6 @@ WaveParameters<dim>::WaveParameters () :
 {};
 
 
-
 template <int dim>
 WaveParameters<dim>::~WaveParameters ()
 {
@@ -4169,7 +4003,6 @@ WaveParameters<dim>::~WaveParameters ()
 };
 
 
-
 template <int dim>
 void WaveParameters<dim>::delete_parameters ()
 {
@@ -4218,8 +4051,6 @@ void WaveParameters<dim>::delete_parameters ()
 };
 
 
-
-
 template <int dim>
 void WaveParameters<dim>::set_initial_functions (const string &u_name,
                                                 const string &v_name) {
@@ -4263,9 +4094,6 @@ void WaveParameters<dim>::set_initial_functions (const string &u_name,
 };
 
 
-
-
-
 template <int dim>
 void WaveParameters<dim>::set_coefficient_functions (const string &name) {  
   Assert (density==0, ExcInternalError());
@@ -4308,7 +4136,6 @@ void WaveParameters<dim>::set_coefficient_functions (const string &name) {
 };
 
 
-
 template <int dim>
 void WaveParameters<dim>::set_boundary_functions (const string &name) {
   Assert (boundary_values_u==0, ExcInternalError());
@@ -4348,7 +4175,6 @@ void WaveParameters<dim>::set_boundary_functions (const string &name) {
 };
 
 
-
 template <int dim>
 void WaveParameters<dim>::make_eval_list (const string &names) {
   Assert (eval_list.size()==0, ExcInternalError());
@@ -4395,8 +4221,6 @@ void WaveParameters<dim>::make_eval_list (const string &names) {
 };
 
 
-
-
 template <int dim>
 void WaveParameters<dim>::set_dual_functional (const string &name) {
   Assert (dual_functional==0, ExcInternalError());
@@ -4431,8 +4255,6 @@ void WaveParameters<dim>::set_dual_functional (const string &name) {
 };
 
 
-
-
 #if 2 == 1
 
 template <>
@@ -4494,7 +4316,6 @@ void WaveParameters<1>::make_coarse_grid (const string &name) {
 #endif
 
 
-
 #if 2 == 2
 
 template <>
@@ -4635,24 +4456,24 @@ void WaveParameters<2>::make_coarse_grid (const string &name) {
 
                  break;
                };
-                 
-               
-               case uniform_channel:
+
+
+case uniform_channel:
                {
                  coarse_grid->refine_global (initial_refinement-1);
                  break;
                };
 
 
-               default:
+default:
                      Assert (false, ExcInternalError());
              };
          };
        break;
       };
 
-      
-      case square:
+
+case square:
       case seismic_square:
       {
        GridGenerator::hyper_cube (*coarse_grid, -1, 1);
@@ -4808,8 +4629,6 @@ void WaveParameters<3>::make_coarse_grid (const string &name) {
 #endif
 
 
-
-
 template <int dim>
 void WaveParameters<dim>::declare_parameters (ParameterHandler &prm) 
 {
@@ -4904,20 +4723,19 @@ void WaveParameters<dim>::declare_parameters (ParameterHandler &prm)
   prm.leave_subsection ();
 
 
-  prm.enter_subsection ("Goal");
+prm.enter_subsection ("Goal");
   prm.declare_entry ("Goal", "none",
                     Patterns::Selection (dual_functional_names));
   prm.declare_entry ("Evaluate", "");
   prm.leave_subsection ();  
 
 
-  prm.declare_entry ("Refinement criterion", "energy estimator",
+prm.declare_entry ("Refinement criterion", "energy estimator",
                     Patterns::Selection ("energy estimator|dual estimator"));
   prm.declare_entry ("Sweeps", "3", Patterns::Integer());
 };
 
 
-
 template <int dim>
 void WaveParameters<dim>::parse_parameters (ParameterHandler &prm) {
                                   // declare some maps for convenience,
@@ -4940,9 +4758,9 @@ void WaveParameters<dim>::parse_parameters (ParameterHandler &prm) {
   write_strategy_list["never"] = never;
   write_strategy_list["all sweeps"] = all_sweeps;
   write_strategy_list["last sweep only"] = last_sweep_only;
-  
-  
-  prm.enter_subsection ("Grid");
+
+
+prm.enter_subsection ("Grid");
   initial_refinement = prm.get_integer ("Initial refinement");
                                   // don't make the grid here already, since
                                   // it may depend on the chosen boundary
@@ -5024,14 +4842,13 @@ void WaveParameters<dim>::parse_parameters (ParameterHandler &prm) {
   prm.leave_subsection ();
 
 
-  prm.enter_subsection ("Goal");
+prm.enter_subsection ("Goal");
   set_dual_functional (prm.get("Goal"));
   make_eval_list (prm.get("Evaluate"));
   prm.leave_subsection ();
 
-  
-  
-  if (prm.get("Refinement criterion")=="energy estimator")
+
+if (prm.get("Refinement criterion")=="energy estimator")
     refinement_strategy = energy_estimator;
   else
     refinement_strategy = dual_estimator;
@@ -5046,8 +4863,6 @@ void WaveParameters<dim>::parse_parameters (ParameterHandler &prm) {
 };
 
 
-
-
 // explicit instantiations
 template class WaveParameters<2>;
 /* $Id$ */
@@ -5067,7 +4882,6 @@ SweepData<dim>::SweepData (const bool use_data_out_stack)
 };
 
 
-
 template <int dim>
 SweepData<dim>::~SweepData () 
 {
@@ -5077,8 +4891,6 @@ SweepData<dim>::~SweepData ()
 };
 
 
-
-
 // explicit instantiations
 template class SweepData<2>;
 /* $Id$ */
@@ -5095,7 +4907,6 @@ SweepInfo::get_data ()
 };
 
 
-
 SweepInfo::Timers &
 SweepInfo::get_timers () 
 {
@@ -5103,7 +4914,6 @@ SweepInfo::get_timers ()
 };
 
 
-
 template <int dim>
 void
 SweepInfo::write_summary (const list<EvaluationBase<dim>*> &eval_list,
@@ -5142,11 +4952,6 @@ SweepInfo::write_summary (const list<EvaluationBase<dim>*> &eval_list,
 };
 
 
-  
-
-
-
-
 SweepInfo::Data::Data () :
                accumulated_error (0),
                cells (0),
@@ -5155,11 +4960,6 @@ SweepInfo::Data::Data () :
 {};
 
 
-
-
-
-
-
 // explicit instantiations
 template 
 void SweepInfo::write_summary (const list<EvaluationBase<2>*> &eval_list,
@@ -5193,8 +4993,6 @@ void SweepInfo::write_summary (const list<EvaluationBase<2>*> &eval_list,
 #include <iomanip>
 
 
-
-
 static const pair<unsigned int, double> relaxations[3]
 = { make_pair(100,5), make_pair(300,3), make_pair(500,2) };
 
@@ -5205,7 +5003,6 @@ wave_correction_relaxations (1,
                                                                 &relaxations[3]));
 
 
-
 template <int dim>
 TimeStepBase_Wave<dim>::TimeStepBase_Wave ():
                TimeStepBase_Tria<dim> (),
@@ -5213,7 +5010,6 @@ TimeStepBase_Wave<dim>::TimeStepBase_Wave ():
 {};
 
 
-
 template <int dim>
 TimeStepBase_Wave<dim>::TimeStepBase_Wave (const double                    time,
                                           TimeStepBase_Tria<dim>::Flags   flags,
@@ -5237,7 +5033,6 @@ TimeStepBase_Wave<dim>::TimeStepBase_Wave (const double                    time,
 {};
 
 
-
 template <int dim>
 const TimeStep_Primal<dim> &
 TimeStepBase_Wave<dim>::get_timestep_primal () const
@@ -5246,7 +5041,6 @@ TimeStepBase_Wave<dim>::get_timestep_primal () const
 };
 
 
-
 template <int dim>
 const TimeStep_Dual<dim> &
 TimeStepBase_Wave<dim>::get_timestep_dual () const
@@ -5255,7 +5049,6 @@ TimeStepBase_Wave<dim>::get_timestep_dual () const
 };
 
 
-
 template <int dim>
 const TimeStep_Postprocess<dim> &
 TimeStepBase_Wave<dim>::get_timestep_postprocess () const
@@ -5264,7 +5057,6 @@ TimeStepBase_Wave<dim>::get_timestep_postprocess () const
 };
 
 
-
 template <int dim>
 string TimeStepBase_Wave<dim>::tmp_filename_base (const string &branch_signature) const
 {
@@ -5275,7 +5067,6 @@ string TimeStepBase_Wave<dim>::tmp_filename_base (const string &branch_signature
 };
 
 
-
 template <int dim>
 void TimeStepBase_Wave<dim>::attach_sweep_info (SweepInfo &si)
 {
@@ -5283,7 +5074,6 @@ void TimeStepBase_Wave<dim>::attach_sweep_info (SweepInfo &si)
 };
 
 
-
 template <int dim>
 void TimeStepBase_Wave<dim>::attach_sweep_data (SweepData<dim> &sd)
 {
@@ -5291,10 +5081,6 @@ void TimeStepBase_Wave<dim>::attach_sweep_data (SweepData<dim> &sd)
 };
 
 
-
-
-
-
 /* --------------------------------------------------------------*/
 
 
@@ -5308,7 +5094,6 @@ TimeStep_Wave<dim>::TimeStep_Wave (const string fe_name) :
 {};
 
 
-
 template <int dim>
 TimeStep_Wave<dim>::~TimeStep_Wave ()
 {
@@ -5321,7 +5106,6 @@ TimeStep_Wave<dim>::~TimeStep_Wave ()
   Assert (v.size() ==0, ExcInternalError());
 };
 
-                                  
 
 template <int dim>
 void TimeStep_Wave<dim>::wake_up (const unsigned int wakeup_level) 
@@ -5341,9 +5125,9 @@ void TimeStep_Wave<dim>::wake_up (const unsigned int wakeup_level)
 
       if (parameters.renumber_dofs)
        DoFRenumbering::Cuthill_McKee (*dof_handler);
-      
 
-      constraints.clear ();
+
+constraints.clear ();
       DoFTools::make_hanging_node_constraints (*dof_handler, constraints);
       constraints.close ();
 
@@ -5405,7 +5189,6 @@ void TimeStep_Wave<dim>::wake_up (const unsigned int wakeup_level)
 };
 
 
-
 template <int dim>
 void TimeStep_Wave<dim>::sleep (const unsigned int sleep_level) 
 {
@@ -5456,7 +5239,6 @@ void TimeStep_Wave<dim>::sleep (const unsigned int sleep_level)
 };
 
 
-
 template <int dim>
 void TimeStep_Wave<dim>::end_sweep ()
 {
@@ -5465,7 +5247,6 @@ void TimeStep_Wave<dim>::end_sweep ()
 };
 
 
-    
 template <int dim>
 unsigned int TimeStep_Wave<dim>::solve (const UserMatrix       &matrix,
                                        Vector<double>         &solution,
@@ -5486,7 +5267,6 @@ unsigned int TimeStep_Wave<dim>::solve (const UserMatrix       &matrix,
 };
 
 
-
 template <int dim>
 void TimeStep_Wave<dim>::create_matrices () 
 {        
@@ -5521,9 +5301,9 @@ void TimeStep_Wave<dim>::create_matrices ()
   if (stiffness_constant)
     fill_n (stiffness_values.begin(), n_q_points,
            parameters.stiffness->value(Point<dim>()));
-  
-  
-  FEValues<dim>  fe_values (fe, quadrature,
+
+
+FEValues<dim>  fe_values (fe, quadrature,
                            UpdateFlags(update_values |
                                        update_gradients  |
                                        update_JxW_values |
@@ -5537,8 +5317,8 @@ void TimeStep_Wave<dim>::create_matrices ()
   FullMatrix<double> cell_mass_matrix (dofs_per_cell, dofs_per_cell);
   FullMatrix<double> cell_laplace_matrix (dofs_per_cell, dofs_per_cell);
 
-  
-  for (typename DoFHandler<dim>::active_cell_iterator cell=dof_handler->begin_active();
+
+for (typename DoFHandler<dim>::active_cell_iterator cell=dof_handler->begin_active();
        cell != dof_handler->end(); ++cell)
     {
       fe_values.reinit (cell);
@@ -5594,7 +5374,6 @@ void TimeStep_Wave<dim>::create_matrices ()
 };
 
 
-
 template <int dim>
 void TimeStep_Wave<dim>::transfer_old_solutions (Vector<double> &old_u,
                                                 Vector<double> &old_v) const 
@@ -5645,7 +5424,6 @@ void TimeStep_Wave<dim>::transfer_old_solutions (Vector<double> &old_u,
 };
 
 
-
 template <int dim>
 void
 TimeStep_Wave<dim>::transfer_old_solutions (const typename DoFHandler<dim>::cell_iterator &old_cell,
@@ -5681,7 +5459,6 @@ TimeStep_Wave<dim>::transfer_old_solutions (const typename DoFHandler<dim>::cell
 };
 
 
-
 template <int dim>
 pair<double,double>
 TimeStep_Wave<dim>::compute_energy () {
@@ -5707,7 +5484,6 @@ TimeStep_Wave<dim>::compute_energy () {
 };
 
 
-
 template <int dim>
 TimeStep_Wave<dim>::StatisticData::
 StatisticData () :
@@ -5719,7 +5495,6 @@ StatisticData () :
 {};
 
 
-
 template <int dim>
 TimeStep_Wave<dim>::StatisticData::
 StatisticData (const unsigned int        n_active_cells,
@@ -5735,7 +5510,6 @@ StatisticData (const unsigned int        n_active_cells,
 {};
 
 
-
 template <int dim>
 void
 TimeStep_Wave<dim>::StatisticData::write_descriptions (ostream &out) 
@@ -5750,7 +5524,6 @@ TimeStep_Wave<dim>::StatisticData::write_descriptions (ostream &out)
 };
 
 
-
 template <int dim>
 void TimeStep_Wave<dim>::StatisticData::write (ostream &out) const
 {
@@ -5764,11 +5537,6 @@ void TimeStep_Wave<dim>::StatisticData::write (ostream &out) const
 };
 
 
-
-
-
-
-
 // explicit instantiations
 template class TimeStepBase_Wave<2>;
 template class TimeStep_Wave<2>;
@@ -5792,7 +5560,6 @@ template class TimeStep_Wave<2>;
 #include <iomanip>
 
 
-
 template <int dim>
 TimeStep_Dual<dim>::TimeStep_Dual (const string &dual_fe)
                :
@@ -5800,7 +5567,6 @@ TimeStep_Dual<dim>::TimeStep_Dual (const string &dual_fe)
 {};
 
 
-
 template <int dim>
 void TimeStep_Dual<dim>::do_initial_step () {
   deallog << "  Dual problem: time="
@@ -5857,7 +5623,6 @@ void TimeStep_Dual<dim>::do_initial_step () {
 };
 
 
-
 template <int dim>
 void TimeStep_Dual<dim>::do_timestep ()
 {
@@ -5920,7 +5685,7 @@ void TimeStep_Dual<dim>::do_timestep ()
                                   // zero already.
 
 
-                                  // in 1d, do not set boundary conditions
+// in 1d, do not set boundary conditions
                                   // at all
                                   //
                                   // note: in boundary_value_map, all entries
@@ -5990,8 +5755,6 @@ void TimeStep_Dual<dim>::do_timestep ()
 };
 
 
-
-
 template <int dim>
 void TimeStep_Dual<dim>::solve_dual_problem ()
 {
@@ -6004,7 +5767,6 @@ void TimeStep_Dual<dim>::solve_dual_problem ()
 };
 
 
-
 template <int dim>
 string TimeStep_Dual<dim>::branch_signature () const 
 {
@@ -6012,7 +5774,6 @@ string TimeStep_Dual<dim>::branch_signature () const
 };
 
 
-
 template <int dim>
 void TimeStep_Dual<dim>::wake_up (const unsigned int wakeup_level)
 {
@@ -6029,7 +5790,6 @@ void TimeStep_Dual<dim>::wake_up (const unsigned int wakeup_level)
 };
 
 
-
 template <int dim>
 void TimeStep_Dual<dim>::assemble_vectors (Vector<double> &right_hand_side1,
                                           Vector<double> &right_hand_side2) {
@@ -6057,7 +5817,6 @@ void TimeStep_Dual<dim>::assemble_vectors (Vector<double> &right_hand_side1,
 };
 
 
-
 template <int dim>
 void TimeStep_Dual<dim>::build_rhs (Vector<double> &right_hand_side1,
                                    Vector<double> &right_hand_side2) {
@@ -6082,8 +5841,8 @@ void TimeStep_Dual<dim>::build_rhs (Vector<double> &right_hand_side1,
                                       update_JxW_values |
                                       update_q_points));
 
-  
-  cell_iterator old_cell = previous_time_level.dof_handler->begin(),
+
+cell_iterator old_cell = previous_time_level.dof_handler->begin(),
                new_cell = dof_handler->begin(),
                end_cell = (tria->n_levels() == 1                  ?
                            static_cast<cell_iterator>(dof_handler->end()) :
@@ -6095,7 +5854,6 @@ void TimeStep_Dual<dim>::build_rhs (Vector<double> &right_hand_side1,
 };
 
 
-
 template <int dim>
 void
 TimeStep_Dual<dim>::build_rhs (const DoFHandler<dim>::cell_iterator &old_cell,
@@ -6120,7 +5878,7 @@ TimeStep_Dual<dim>::build_rhs (const DoFHandler<dim>::cell_iterator &old_cell,
     };
 
 
-                                  // select the TimeStep_Wave part in the
+// select the TimeStep_Wave part in the
                                   // TimeStep_Dual branch
   const TimeStep_Dual<dim> &previous_time_level
     = static_cast<const TimeStepBase_Wave<dim>*>(next_timestep)->get_timestep_dual();
@@ -6281,7 +6039,6 @@ TimeStep_Dual<dim>::build_rhs (const DoFHandler<dim>::cell_iterator &old_cell,
 };
 
 
-
 template <int dim>
 unsigned int
 TimeStep_Dual<dim>::collect_from_children (const DoFHandler<dim>::cell_iterator &old_cell,
@@ -6412,7 +6169,6 @@ TimeStep_Dual<dim>::collect_from_children (const DoFHandler<dim>::cell_iterator
 };
 
 
-
 template <int dim>
 unsigned int
 TimeStep_Dual<dim>::distribute_to_children (const DoFHandler<dim>::cell_iterator &new_cell,
@@ -6463,8 +6219,8 @@ TimeStep_Dual<dim>::distribute_to_children (const DoFHandler<dim>::cell_iterator
                                   // the new grid
   vector<unsigned int> new_dof_indices (dofs_per_cell, DoFHandler<dim>::invalid_dof_index);
 
-      
-                                      // loop over the child cells
+
+// loop over the child cells
   for (unsigned int c=0; c<GeometryInfo<dim>::children_per_cell; ++c) 
     {
       const DoFHandler<dim>::cell_iterator new_child = new_cell->child(c);
@@ -6553,8 +6309,6 @@ TimeStep_Dual<dim>::distribute_to_children (const DoFHandler<dim>::cell_iterator
 };
 
 
-
-
 // explicit instantiations
 template class TimeStep_Dual<2>;
 /* $Id$ */
@@ -6578,13 +6332,11 @@ template class TimeStep_Dual<2>;
 #include <numeric>
 
 
-
 template <int dim>
 TimeStep_ErrorEstimation<dim>::TimeStep_ErrorEstimation () 
 {};
 
 
-
 template <int dim>
 void TimeStep_ErrorEstimation<dim>::estimate_error ()
 {
@@ -6616,7 +6368,6 @@ void TimeStep_ErrorEstimation<dim>::estimate_error ()
 };
 
 
-
 template <int dim>
 void TimeStep_ErrorEstimation<dim>::wake_up (const unsigned int wakeup_level)
 {
@@ -6632,7 +6383,6 @@ void TimeStep_ErrorEstimation<dim>::wake_up (const unsigned int wakeup_level)
 };
 
 
-
 template <int dim>
 void TimeStep_ErrorEstimation<dim>::sleep (const unsigned int sleep_level)
 {
@@ -6652,7 +6402,6 @@ void TimeStep_ErrorEstimation<dim>::sleep (const unsigned int sleep_level)
 };
 
 
-
 template <int dim>
 void
 TimeStep_ErrorEstimation<dim>::get_tria_refinement_criteria (Vector<float> &indicators) const 
@@ -6672,7 +6421,6 @@ TimeStep_ErrorEstimation<dim>::get_error_indicators (Vector<float> &indicators)
 };
 
 
-
 template <int dim>
 void TimeStep_ErrorEstimation<dim>::estimate_error_energy (const unsigned int which_variables) {
   Assert (which_variables<=1, ExcInternalError());
@@ -6718,7 +6466,6 @@ void TimeStep_ErrorEstimation<dim>::estimate_error_energy (const unsigned int wh
 };
 
 
-
 template <int dim>
 void TimeStep_ErrorEstimation<dim>::estimate_error_dual () {
   CellwiseError cellwise_error (tria->n_active_cells());
@@ -6731,7 +6478,7 @@ void TimeStep_ErrorEstimation<dim>::estimate_error_dual () {
                                                 (previous_timestep)->get_timestep_dual();
 
 
-                                  // first clear the user pointers of
+// first clear the user pointers of
                                   // the cells we need
   if (true)
     {
@@ -6795,9 +6542,9 @@ void TimeStep_ErrorEstimation<dim>::estimate_error_dual () {
                                   // compute the sum of the errors
                                   // on the cells
   ErrorOnCell total_estimated_error;
-  
 
-                                  // now fill the data we collected to the
+
+// now fill the data we collected to the
                                   // error_per_cell array
   Vector<float>::iterator i = estimated_error_per_cell.begin();
   DoFHandler<dim>::active_cell_iterator
@@ -6818,7 +6565,6 @@ void TimeStep_ErrorEstimation<dim>::estimate_error_dual () {
 };
 
 
-
 template <int dim>
 void
 TimeStep_ErrorEstimation<dim>::estimate_error_dual (const DoFHandler<dim>::cell_iterator &primal_cell,
@@ -6842,9 +6588,8 @@ TimeStep_ErrorEstimation<dim>::estimate_error_dual (const DoFHandler<dim>::cell_
       return;
     };
 
-  
 
-  const TimeStep_Primal<dim> &primal_problem     = get_timestep_primal(),
+const TimeStep_Primal<dim> &primal_problem     = get_timestep_primal(),
                             &primal_problem_old = static_cast<const TimeStepBase_Wave<dim>*>
                                                   (previous_timestep)->get_timestep_primal();
   const TimeStep_Dual<dim>   &dual_problem     = get_timestep_dual(),
@@ -6858,7 +6603,7 @@ TimeStep_ErrorEstimation<dim>::estimate_error_dual (const DoFHandler<dim>::cell_
                            dofs_per_cell_dual   = dual_fe.dofs_per_cell;  
 
 
-                                  // none of the two cells has children
+// none of the two cells has children
   if (!primal_cell->has_children() && !primal_cell_old->has_children())
     {
                                       // vector holding the solutions on
@@ -6888,7 +6633,7 @@ TimeStep_ErrorEstimation<dim>::estimate_error_dual (const DoFHandler<dim>::cell_
       dual_cell->get_dof_values (dual_problem.v, local_v_bar);
 
 
-                                      // fill local old solution vectors.
+// fill local old solution vectors.
                                       // no problems here, since the two
                                       // cells are both unrefined
       primal_cell_old->get_dof_values (primal_problem_old.u, primal_tmp);
@@ -6914,8 +6659,7 @@ TimeStep_ErrorEstimation<dim>::estimate_error_dual (const DoFHandler<dim>::cell_
     };
 
 
-
-                                  // only new cell has children. handle this
+// only new cell has children. handle this
                                   // case by prolonging the solutions on the
                                   // old cell to its children and recursing
                                   // thereon
@@ -6941,7 +6685,7 @@ TimeStep_ErrorEstimation<dim>::estimate_error_dual (const DoFHandler<dim>::cell_
       dual_cell_old->get_dof_values (dual_problem_old.v, local_v_bar_old);
 
 
-      compute_error_on_new_children (primal_cell, dual_cell,
+compute_error_on_new_children (primal_cell, dual_cell,
                                     local_u_old,
                                     local_v_old,
                                     local_u_bar_old,
@@ -6953,7 +6697,7 @@ TimeStep_ErrorEstimation<dim>::estimate_error_dual (const DoFHandler<dim>::cell_
     };
 
 
-                                  // last possibility: new cell is not
+// last possibility: new cell is not
                                   // refined, but old one is. in this case:
                                   // collect error on this cell from the
                                   // smaller ones on the old grid
@@ -7040,12 +6784,10 @@ TimeStep_ErrorEstimation<dim>::estimate_error_dual (const DoFHandler<dim>::cell_
     };
 
 
-  Assert (false, ExcInternalError());
+Assert (false, ExcInternalError());
 };
 
 
-
-
 template <int dim>
 void TimeStep_ErrorEstimation<dim>::
 compute_error_on_new_children (const DoFHandler<dim>::cell_iterator &primal_cell,
@@ -7061,9 +6803,9 @@ compute_error_on_new_children (const DoFHandler<dim>::cell_iterator &primal_cell
 
   const FiniteElement<dim> &dual_fe  = get_timestep_dual().fe;
   const unsigned int dofs_per_cell_dual = dual_fe.dofs_per_cell;
-  
-  
-  for (unsigned int child=0; child<GeometryInfo<dim>::children_per_cell; ++child)
+
+
+for (unsigned int child=0; child<GeometryInfo<dim>::children_per_cell; ++child)
     {
                                       // we have the solutions on the
                                       // old (large) cell, we restrict it to
@@ -7133,7 +6875,6 @@ compute_error_on_new_children (const DoFHandler<dim>::cell_iterator &primal_cell
 };
 
 
-
 template <int dim>
 typename TimeStep_ErrorEstimation<dim>::ErrorOnCell
 TimeStep_ErrorEstimation<dim>::collect_error_from_children (const DoFHandler<dim>::cell_iterator &primal_cell_old,
@@ -7224,9 +6965,9 @@ TimeStep_ErrorEstimation<dim>::collect_error_from_children (const DoFHandler<dim
          local_difference_u_bar_old -= local_Ih_u_bar_old;
          local_difference_v_bar_old =  local_v_bar_old;
          local_difference_v_bar_old -= local_Ih_v_bar_old;
-         
-         
-         error_sum += error_formula (old_dual_child,
+
+
+error_sum += error_formula (old_dual_child,
                                      child_u,            child_v,
                                      child_u_bar,        child_v_bar,
                                      local_u_old,        local_v_old,
@@ -7239,7 +6980,6 @@ TimeStep_ErrorEstimation<dim>::collect_error_from_children (const DoFHandler<dim
 };
 
 
-
 template <int dim>
 typename TimeStep_ErrorEstimation<dim>::ErrorOnCell
 TimeStep_ErrorEstimation<dim>::error_formula (const DoFHandler<dim>::active_cell_iterator &cell,
@@ -7275,7 +7015,6 @@ TimeStep_ErrorEstimation<dim>::error_formula (const DoFHandler<dim>::active_cell
 };
 
 
-
 template <int dim>
 typename TimeStep_ErrorEstimation<dim>::ErrorOnCell
 TimeStep_ErrorEstimation<dim>::error_formula (const DoFHandler<dim>::active_cell_iterator &cell,
@@ -7306,7 +7045,7 @@ TimeStep_ErrorEstimation<dim>::error_formula (const DoFHandler<dim>::active_cell
   Vector<double> tmp2(dofs_per_cell);
 
 
-  vector<double> stiffness(fe_values.n_quadrature_points);
+vector<double> stiffness(fe_values.n_quadrature_points);
   parameters.stiffness->value_list (fe_values.get_quadrature_points(),
                                    stiffness);
   vector<Tensor<1,dim> > grad_stiffness(fe_values.n_quadrature_points);
@@ -7363,19 +7102,18 @@ TimeStep_ErrorEstimation<dim>::error_formula (const DoFHandler<dim>::active_cell
                                 weights[point] *
                                 stiffness[point];
        };
-  
-                              
-                                  
-                                  // ////////////////////////////////////
+
+
+// ////////////////////////////////////
                                   // Compute the different contributions
                                   // separately. Note that the parts
                                   // 1 and 2a+2b together should give
                                   // a small quantity, since they form
                                   // the first domain residual, which is
                                   // small for elements of odd order.
-  
-      
-                                  // ////////////////////////////////////
+
+
+// ////////////////////////////////////
                                   // PART 1
                                   //
                                   // let #tmp_dual2# hold the contribution
@@ -7391,9 +7129,9 @@ TimeStep_ErrorEstimation<dim>::error_formula (const DoFHandler<dim>::active_cell
   tmp1 -= local_u_old;
   
   error_on_cell.part[0] = mass_matrix.matrix_scalar_product (tmp1, tmp2);
-  
-  
-                                  // same thing for the second part
+
+
+// same thing for the second part
                                   // with v instead of u
   tmp2  = local_difference_v_bar;
   tmp2 += local_difference_v_bar_old;
@@ -7403,10 +7141,9 @@ TimeStep_ErrorEstimation<dim>::error_formula (const DoFHandler<dim>::active_cell
   tmp1 -= local_v_old;
   
   error_on_cell.part[1] = mass_matrix.matrix_scalar_product (tmp1, tmp2);
-  
 
-  
-                                  // ////////////////////////////////
+
+// ////////////////////////////////
                                   // PART 2a
                                   //
                                   // let tmp2=(1-I)(u_bar^n+u_bar^(n-1))
@@ -7419,9 +7156,9 @@ TimeStep_ErrorEstimation<dim>::error_formula (const DoFHandler<dim>::active_cell
 
   error_on_cell.part[2] = -(get_backward_timestep() / 4 *
                            mass_matrix.matrix_scalar_product (tmp1, tmp2));
-  
 
-                                  // ////////////////////////////////
+
+// ////////////////////////////////
                                   // PART 2b
                                   //
                                   // let tmp1 = v^n-v^(n-1)
@@ -7436,7 +7173,7 @@ TimeStep_ErrorEstimation<dim>::error_formula (const DoFHandler<dim>::active_cell
                            mass_matrix.matrix_scalar_product (tmp1, tmp2));
 
 
-                                  // ////////////////////////////////
+// ////////////////////////////////
                                   // PART 3a
                                   //
                                   // let tmp2=(1-I)(v_bar^n+v_bar^(n-1))
@@ -7451,7 +7188,7 @@ TimeStep_ErrorEstimation<dim>::error_formula (const DoFHandler<dim>::active_cell
                           laplace_matrix.matrix_scalar_product (tmp1, tmp2));
 
 
-                                  // ////////////////////////////////
+// ////////////////////////////////
                                   // PART 3b
                                   //
                                   // let tmp1 = u^n-u^(n-1)
@@ -7466,7 +7203,6 @@ TimeStep_ErrorEstimation<dim>::error_formula (const DoFHandler<dim>::active_cell
                           laplace_matrix.matrix_scalar_product (tmp1, tmp2));
 
 
-
 //                                // ///////////////////////////
 //                                // PART 0:
 //                                // tmp1 = u^n-u^(n-1)
@@ -7520,7 +7256,7 @@ TimeStep_ErrorEstimation<dim>::error_formula (const DoFHandler<dim>::active_cell
 
 //   error_on_cell.part[3]  = mass_matrix.matrix_scalar_product (tmp1, tmp2);
 //   error_on_cell.part[3] *= get_backward_timestep() / 12;
-  
+
 
 //                                // /////////////////////////////
 //                                // PART 4 and 6:
@@ -7555,13 +7291,9 @@ TimeStep_ErrorEstimation<dim>::error_formula (const DoFHandler<dim>::active_cell
 //   error_on_cell.part[7]  = grad_grad_matrix.matrix_scalar_product (tmp1, tmp2);
 //   error_on_cell.part[7] *= get_backward_timestep() / 12;
 
-  
-  return error_on_cell;
-};
-
-
-
 
+return error_on_cell;
+};
 
 
 template <int dim>
@@ -7580,7 +7312,7 @@ void TimeStep_ErrorEstimation<dim>::make_interpolation_matrices () {
       embedding_matrix(i,j) = primal_fe.shape_value (j, unit_support_points[i]);
 
 
-                                  // construct the difference between the
+// construct the difference between the
                                   // identity and the interpolation operator
                                   // to the primal ansatz space. The
                                   // interpolation operator is to act from
@@ -7612,23 +7344,18 @@ void TimeStep_ErrorEstimation<dim>::make_interpolation_matrices () {
 };
 
 
-
-
-
 template <int dim>
 TimeStep_ErrorEstimation<dim>::StatisticData::StatisticData () :
                estimated_error (0)
 {};
 
 
-
 template <int dim>
 TimeStep_ErrorEstimation<dim>::StatisticData::StatisticData (const double estimated_error) :
                estimated_error (estimated_error)
 {};
 
 
-
 template <int dim>
 void TimeStep_ErrorEstimation<dim>::StatisticData::write_descriptions (ostream &out)
 {
@@ -7636,7 +7363,6 @@ void TimeStep_ErrorEstimation<dim>::StatisticData::write_descriptions (ostream &
 };
 
 
-
 template <int dim>
 void TimeStep_ErrorEstimation<dim>::StatisticData::write (ostream &out) const
 {
@@ -7644,7 +7370,6 @@ void TimeStep_ErrorEstimation<dim>::StatisticData::write (ostream &out) const
 };
 
 
-
 template <int dim>
 TimeStep_ErrorEstimation<dim>::ErrorOnCell::ErrorOnCell () {
   for (unsigned int i=0; i<sizeof(part)/sizeof(part[0]); ++i)
@@ -7652,7 +7377,6 @@ TimeStep_ErrorEstimation<dim>::ErrorOnCell::ErrorOnCell () {
 };
 
 
-
 template <int dim>
 typename TimeStep_ErrorEstimation<dim>::ErrorOnCell
 TimeStep_ErrorEstimation<dim>::ErrorOnCell::operator += (const ErrorOnCell &eoc) {
@@ -7662,7 +7386,6 @@ TimeStep_ErrorEstimation<dim>::ErrorOnCell::operator += (const ErrorOnCell &eoc)
 };
 
 
-
 template <int dim>
 double TimeStep_ErrorEstimation<dim>::ErrorOnCell::sum () const {
   double x=0;
@@ -7672,7 +7395,6 @@ double TimeStep_ErrorEstimation<dim>::ErrorOnCell::sum () const {
 };
 
 
-
 template <int dim>
 TimeStep_ErrorEstimation<dim>::CellwiseError::CellwiseError (const unsigned int n_errors) :
                errors (n_errors),
@@ -7680,7 +7402,6 @@ TimeStep_ErrorEstimation<dim>::CellwiseError::CellwiseError (const unsigned int
 {};
 
 
-
 // explicit instantiations
 template class TimeStep_ErrorEstimation<2>;
 /* $Id$ */
@@ -7692,8 +7413,6 @@ template class TimeStep_ErrorEstimation<2>;
 #include <dofs/dof_handler.h>
 
 
-
-
 template <int dim>
 TimeStep<dim>::TimeStep (const double               time,
                         const WaveParameters<dim> &parameters):
@@ -7705,8 +7424,6 @@ TimeStep<dim>::TimeStep (const double               time,
 {};
 
 
-
-
 template <int dim>
 void TimeStep<dim>::wake_up (const unsigned int wakeup_level)
 {
@@ -7747,7 +7464,6 @@ void TimeStep<dim>::wake_up (const unsigned int wakeup_level)
 };
 
 
-
 template <int dim>
 void TimeStep<dim>::sleep (const unsigned int sleep_level)
 {  
@@ -7790,7 +7506,6 @@ void TimeStep<dim>::sleep (const unsigned int sleep_level)
 };
 
 
-
 template <int dim>
 void TimeStep<dim>::end_sweep ()
 {
@@ -7800,7 +7515,6 @@ void TimeStep<dim>::end_sweep ()
 };
 
 
-
 template <int dim>
 void TimeStep<dim>::write_statistics_descriptions (ostream                   &out,
                                                   const WaveParameters<dim> &parameters)
@@ -7822,7 +7536,6 @@ void TimeStep<dim>::write_statistics_descriptions (ostream                   &ou
 };
 
 
-
 template <int dim>
 void TimeStep<dim>::write_statistics (ostream &out) const 
 {
@@ -7836,7 +7549,6 @@ void TimeStep<dim>::write_statistics (ostream &out) const
 };
 
 
-
 // explicit instantiations
 template class TimeStep<2>;
 /* $Id$ */
@@ -7856,7 +7568,6 @@ template class TimeStep<2>;
 #include <iomanip>
 
 
-
 template <int dim>
 void TimeStep_Postprocess<dim>::postprocess_timestep () 
 {
@@ -8020,14 +7731,13 @@ void TimeStep_Postprocess<dim>::postprocess_timestep ()
       sweep_data->data_out_stack->build_patches ();
       sweep_data->data_out_stack->finish_parameter_value ();
     };
-  
-       
-  deallog << endl;
+
+
+deallog << endl;
   sweep_info->get_timers().postprocessing.stop();
 };
 
 
-
 template <int dim>
 void TimeStep_Postprocess<dim>::wake_up (const unsigned int wakeup_level) 
 {
@@ -8035,7 +7745,6 @@ void TimeStep_Postprocess<dim>::wake_up (const unsigned int wakeup_level)
 };
 
 
-
 template <int dim>
 void TimeStep_Postprocess<dim>::sleep (const unsigned int sleep_level) 
 {
@@ -8043,7 +7752,6 @@ void TimeStep_Postprocess<dim>::sleep (const unsigned int sleep_level)
 };
 
 
-
 template <int dim>
 string TimeStep_Postprocess<dim>::branch_signature () const 
 {
@@ -8051,7 +7759,6 @@ string TimeStep_Postprocess<dim>::branch_signature () const
 };
 
 
-
 template <int dim>
 void TimeStep_Postprocess<dim>::end_sweep ()
 {
@@ -8060,10 +7767,6 @@ void TimeStep_Postprocess<dim>::end_sweep ()
 };
 
 
-    
-
-
-
 template <int dim>
 void TimeStep_Postprocess<dim>::interpolate_dual_solution (Vector<double> &interpolated_u_bar,
                                                           Vector<double> &interpolated_v_bar) const {
@@ -8095,8 +7798,6 @@ void TimeStep_Postprocess<dim>::interpolate_dual_solution (Vector<double> &inter
 };
 
 
-
-
 template <int dim>
 void TimeStep_Postprocess<dim>::StatisticData::
 write_descriptions (ostream &out,
@@ -8108,7 +7809,6 @@ write_descriptions (ostream &out,
 };
 
 
-
 template <int dim>
 void TimeStep_Postprocess<dim>::StatisticData::write (ostream &out) const
 {
@@ -8117,8 +7817,6 @@ void TimeStep_Postprocess<dim>::StatisticData::write (ostream &out) const
 };
 
 
-
-
 // explicit instantiations
 template class TimeStep_Postprocess<2>;
 /* $Id$ */
@@ -8141,15 +7839,12 @@ template class TimeStep_Postprocess<2>;
 #include <iomanip>
 
 
-
 template <int dim>
 TimeStep_Primal<dim>::TimeStep_Primal (const string &primal_fe)
                :
                TimeStep_Wave<dim> (primal_fe)
 {};
 
-               
-
 
 template <int dim>
 void TimeStep_Primal<dim>::do_initial_step ()
@@ -8163,7 +7858,7 @@ void TimeStep_Primal<dim>::do_initial_step ()
        << dof_handler->n_dofs() << " dofs";
 
 
-                                  // add up sweep-accumulated data. count
+// add up sweep-accumulated data. count
                                   // u and v as separate dofs
   sweep_info->get_data().cells       += tria->n_active_cells();
   sweep_info->get_data().primal_dofs += dof_handler->n_dofs() * 2;
@@ -8193,8 +7888,6 @@ void TimeStep_Primal<dim>::do_initial_step ()
 };
 
 
-
-
 template <int dim>
 void TimeStep_Primal<dim>::do_timestep ()
 {
@@ -8210,9 +7903,9 @@ void TimeStep_Primal<dim>::do_timestep ()
                                   // u and v as separate dofs
   sweep_info->get_data().cells       += tria->n_active_cells();
   sweep_info->get_data().primal_dofs += dof_handler->n_dofs() * 2;
-  
-  
-  const double time_step = get_backward_timestep ();
+
+
+const double time_step = get_backward_timestep ();
   
                                   // Vectors holding the right hand sides of
                                   // the two equations.
@@ -8233,8 +7926,8 @@ void TimeStep_Primal<dim>::do_timestep ()
       transfer_old_solutions (old_u, old_v);
     };
 
-  
-  assemble_vectors (right_hand_side1, right_hand_side2);
+
+assemble_vectors (right_hand_side1, right_hand_side2);
 
   UserMatrix system_matrix (system_sparsity, parameters.preconditioning);
   system_matrix.copy_from (mass_matrix);
@@ -8285,7 +7978,7 @@ void TimeStep_Primal<dim>::do_timestep ()
   constraints.condense (right_hand_side2);
 
 
-                                  // in 1d, do not set boundary conditions
+// in 1d, do not set boundary conditions
                                   // at all
   if (dim != 1)
     {
@@ -8297,9 +7990,9 @@ void TimeStep_Primal<dim>::do_timestep ()
                                               system_matrix, v,
                                               right_hand_side2);
     };
-  
 
-  if (parameters.extrapolate_old_solutions)
+
+if (parameters.extrapolate_old_solutions)
                                     // solve with a hopefully good guess
                                     // as start vector
     {
@@ -8321,8 +8014,6 @@ void TimeStep_Primal<dim>::do_timestep ()
 };
 
 
-
-
 template <int dim>
 void TimeStep_Primal<dim>::solve_primal_problem ()
 {
@@ -8335,7 +8026,6 @@ void TimeStep_Primal<dim>::solve_primal_problem ()
 };
 
 
-
 template <int dim>
 string TimeStep_Primal<dim>::branch_signature () const 
 {
@@ -8343,7 +8033,6 @@ string TimeStep_Primal<dim>::branch_signature () const
 };
 
 
-
 template <int dim>
 void TimeStep_Primal<dim>::wake_up (const unsigned int wakeup_level)
 {
@@ -8360,7 +8049,6 @@ void TimeStep_Primal<dim>::wake_up (const unsigned int wakeup_level)
 };
 
 
-
 template <int dim>
 void TimeStep_Primal<dim>::assemble_vectors (Vector<double> &right_hand_side1,
                                             Vector<double> &right_hand_side2) {
@@ -8375,12 +8063,6 @@ void TimeStep_Primal<dim>::assemble_vectors (Vector<double> &right_hand_side1,
 };
 
 
-
-
-
-
-
-
 template <int dim>
 void TimeStep_Primal<dim>::build_rhs (Vector<double> &right_hand_side1,
                                      Vector<double> &right_hand_side2) {
@@ -8405,8 +8087,8 @@ void TimeStep_Primal<dim>::build_rhs (Vector<double> &right_hand_side1,
                                       update_JxW_values |
                                       update_q_points));
 
-  
-  cell_iterator old_cell = previous_time_level.dof_handler->begin(),
+
+cell_iterator old_cell = previous_time_level.dof_handler->begin(),
                new_cell = dof_handler->begin(),
                end_cell = (tria->n_levels() == 1                  ?
                            static_cast<cell_iterator>(dof_handler->end()) :
@@ -8418,7 +8100,6 @@ void TimeStep_Primal<dim>::build_rhs (Vector<double> &right_hand_side1,
 };
 
 
-
 template <int dim>
 void
 TimeStep_Primal<dim>::build_rhs (const DoFHandler<dim>::cell_iterator &old_cell,
@@ -8443,7 +8124,7 @@ TimeStep_Primal<dim>::build_rhs (const DoFHandler<dim>::cell_iterator &old_cell,
     };
 
 
-                                  // select the TimeStep_Wave part in the
+// select the TimeStep_Wave part in the
                                   // TimeStep_Primal branch
   const TimeStep_Primal<dim> &previous_time_level
     = static_cast<const TimeStepBase_Wave<dim>*>(previous_timestep)->get_timestep_primal();
@@ -8522,7 +8203,7 @@ TimeStep_Primal<dim>::build_rhs (const DoFHandler<dim>::cell_iterator &old_cell,
       cell_matrix.vmult (local_A_u, old_dof_values_u);
 
 
-      rhs1 = local_M_u;
+rhs1 = local_M_u;
       rhs1.add (time_step, local_M_v);
       rhs1.add ((-time_step*time_step*
                 parameters.theta*
@@ -8607,8 +8288,6 @@ TimeStep_Primal<dim>::build_rhs (const DoFHandler<dim>::cell_iterator &old_cell,
 };
 
 
-     
-  
 template <int dim>
 unsigned int
 TimeStep_Primal<dim>::collect_from_children (const DoFHandler<dim>::cell_iterator &old_cell,
@@ -8629,8 +8308,8 @@ TimeStep_Primal<dim>::collect_from_children (const DoFHandler<dim>::cell_iterato
   const unsigned int dofs_per_cell = fe.dofs_per_cell;
   const double time_step = get_backward_timestep();
 
-  
-  FullMatrix<double>   cell_matrix (dofs_per_cell, dofs_per_cell);
+
+FullMatrix<double>   cell_matrix (dofs_per_cell, dofs_per_cell);
   
                                   // these will hold the values of the
                                   // solution on the old grid, i.e. on
@@ -8741,8 +8420,6 @@ TimeStep_Primal<dim>::collect_from_children (const DoFHandler<dim>::cell_iterato
 };
 
 
-
-
 template <int dim>
 unsigned int
 TimeStep_Primal<dim>::distribute_to_children (const DoFHandler<dim>::cell_iterator &new_cell,
@@ -8793,8 +8470,8 @@ TimeStep_Primal<dim>::distribute_to_children (const DoFHandler<dim>::cell_iterat
                                   // the new grid
   vector<unsigned int> new_dof_indices (dofs_per_cell, DoFHandler<dim>::invalid_dof_index);
 
-      
-                                      // loop over the child cells
+
+// loop over the child cells
   for (unsigned int c=0; c<GeometryInfo<dim>::children_per_cell; ++c) 
     {
       const DoFHandler<dim>::cell_iterator new_child = new_cell->child(c);
@@ -8883,11 +8560,6 @@ TimeStep_Primal<dim>::distribute_to_children (const DoFHandler<dim>::cell_iterat
 };
 
 
-
-
-
-
-
 // explicit instantiations
 template class TimeStep_Primal<2>;
 /* $Id$ */
@@ -8895,7 +8567,6 @@ template class TimeStep_Primal<2>;
 #include <lac/vector.h>
 
 
-
 void UserMatrix::precondition (Vector<double> &dst,
                               const Vector<double> &src) const {
   switch (preconditioning)
@@ -8919,16 +8590,10 @@ void UserMatrix::precondition (Vector<double> &dst,
 /* $Id$ */
 
 
-
 #include <fe/fe_lib.lagrange.h>
 #include <base/quadrature_lib.h>
 
 
-
-
-
-
-
 // static objects
 
 const FEQ1<2>   FEHelper<2>::fe_linear;
@@ -8979,7 +8644,6 @@ const FiniteElement<dim> & FEHelper<dim>::get_fe (const string &name) {
 };
 
 
-
 template <int dim>
 const Quadrature<dim> &FEHelper<dim>::get_quadrature (const string &name) {
   if (name=="linear")
@@ -9002,7 +8666,6 @@ const Quadrature<dim> &FEHelper<dim>::get_quadrature (const string &name) {
 };
 
 
-
 template <>
 const Quadrature<0> &FEHelper<1>::get_quadrature_face (const string &) {
   static const Quadrature<0> dummy_quadrature(1);
@@ -9010,7 +8673,6 @@ const Quadrature<0> &FEHelper<1>::get_quadrature_face (const string &) {
 };
 
 
-
 template <int dim>
 const Quadrature<dim-1> &FEHelper<dim>::get_quadrature_face (const string &name) {
   if (name=="linear")
@@ -9033,7 +8695,6 @@ const Quadrature<dim-1> &FEHelper<dim>::get_quadrature_face (const string &name)
 };
 
 
-
 string int_to_string (const unsigned int i, const unsigned int digits) {
   string s;
   switch (digits) 
@@ -9054,9 +8715,6 @@ string int_to_string (const unsigned int i, const unsigned int digits) {
 };
 
 
-
-
-
 // explicit instantiations
 template class FEHelper<2>;
 
@@ -9064,7 +8722,6 @@ template class FEHelper<2>;
 /* $Id$ */
 
 
-
 #include <base/logstream.h>
 #include <lac/sparse_matrix.h>
 #include <lac/vector.h>
@@ -9072,20 +8729,16 @@ template class FEHelper<2>;
 #include <dofs/dof_constraints.h>
 
 
-
-
 template <int dim>
 WaveProblem<dim>::WaveProblem ()
 {};
 
 
-
 template <int dim>
 WaveProblem<dim>::~WaveProblem ()
 {};
 
 
-
 template <int dim>
 void WaveProblem<dim>::declare_parameters (ParameterHandler &prm)
 {
@@ -9093,7 +8746,6 @@ void WaveProblem<dim>::declare_parameters (ParameterHandler &prm)
 };
 
 
-
 template <int dim>
 void WaveProblem<dim>::parse_parameters (ParameterHandler &prm)
 {
@@ -9101,7 +8753,6 @@ void WaveProblem<dim>::parse_parameters (ParameterHandler &prm)
 };
 
 
-
 template <int dim>
 void WaveProblem<dim>::create_new (const unsigned int)
 {
@@ -9109,7 +8760,6 @@ void WaveProblem<dim>::create_new (const unsigned int)
 };
 
 
-
 template <int dim>
 void WaveProblem<dim>::run (ParameterHandler &prm) 
 {
@@ -9117,7 +8767,7 @@ void WaveProblem<dim>::run (ParameterHandler &prm)
 //  prm.print_parameters (logfile, Text);
 
 
-                                  ////////////////////////////////
+////////////////////////////////
                                   // Set up the time step objects
   TimestepManager<dim> timestep_manager (parameters);
   if (true) {
@@ -9153,7 +8803,7 @@ void WaveProblem<dim>::run (ParameterHandler &prm)
   };
 
 
-                                  ////////////////////////////////////
+////////////////////////////////////
                                   // actually do the work (or rather:
                                   // let the work be done)
   for (unsigned int sweep=0; sweep<parameters.number_of_sweeps; ++sweep)
@@ -9161,8 +8811,6 @@ void WaveProblem<dim>::run (ParameterHandler &prm)
 };
 
 
-
-
 int main ()
 {
                                   // no additional output to console
@@ -9221,10 +8869,9 @@ int main ()
                                       // abort
       return 3;
     };
-  
-  
-  return 0;
-};
 
 
+return 0;
+};
+
 
index 30ac1b5453297671517c8d0184787e4a2dfe798f..07c8150190c4567a4c3a9a7cc54ac638c8631ce7 100644 (file)
@@ -1,4 +1,15 @@
-// $Id$
+//----------------------------  benchmark.cc  ---------------------------
+//    $Id$
+//    Version: $Name$
+//
+//    Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+//    This file is subject to QPL and may not be  distributed
+//    without copyright and license information. Please refer
+//    to the file deal.II/doc/license.html for the  text  and
+//    further information on this license.
+//
+//----------------------------  benchmark.cc  ---------------------------
 
 
 #include <base/logstream.h>
@@ -53,9 +64,3 @@ main()
 }
 
 
-
-
-
-
-
-
index dc27e69805d7130bd99c324c95e6ba910fc0af7f..9c8e3541a72fcd21cb45cc28b4ff1efc5ad60ab8 100644 (file)
@@ -1,6 +1,16 @@
-// $Id$
+//----------------------------  mg.cc  ---------------------------
+//    $Id$
+//    Version: $Name$
+//
+//    Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+//    This file is subject to QPL and may not be  distributed
+//    without copyright and license information. Please refer
+//    to the file deal.II/doc/license.html for the  text  and
+//    further information on this license.
+//
+//----------------------------  mg.cc  ---------------------------
 
-// Test program for multigrid with test matrices (fd)
 
 #include <cmath>
 #include <fstream>
@@ -50,9 +60,9 @@ class FDMG
   public:
     FDMG(unsigned int maxlevel, MGLevelObject<SparseMatrix<double> >& matrices,
         FDMGTransfer& transfer);
-    
-    
-    virtual void level_vmult (unsigned int level,
+
+
+virtual void level_vmult (unsigned int level,
                                 Vector<double>& dst,
                                 const Vector<double>& src,
                                 const Vector<double>& rhs);
@@ -103,8 +113,8 @@ int main()
   ReductionControl cgcontrol(100, 1.e-30, 1.e-2, false, false);
   SolverCG<> cgcg(cgcontrol,cgmem);
 
-  
-  for (unsigned int level = 0; level <= maxlevel; ++level)
+
+for (unsigned int level = 0; level <= maxlevel; ++level)
     {
       const unsigned int minlevel = 0;
 
index 882d62039e0af8f511efdb627e6410c8026b6275..b8cdb2058f8cc37cf84344339b1fd603f965534b 100644 (file)
@@ -1,7 +1,16 @@
-// $Id$
+//----------------------------  mgbase.cc  ---------------------------
+//    $Id$
+//    Version: $Name$
+//
+//    Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+//    This file is subject to QPL and may not be  distributed
+//    without copyright and license information. Please refer
+//    to the file deal.II/doc/license.html for the  text  and
+//    further information on this license.
+//
+//----------------------------  mgbase.cc  ---------------------------
 
-// deal_II_libraries.g=-ldeal_II_2d.g
-// deal_II_libraries=-ldeal_II_2d
 
 #include <multigrid/mg_base.h>
 #include <multigrid/mg_smoother.h>
index f3d26a53d82212097ccec2c90336c1d3fc672faa..a00dc2e5615168f50b706f272c287451bccd0cfa 100644 (file)
@@ -1,6 +1,16 @@
-// $Id$
+//----------------------------  solver.cc  ---------------------------
+//    $Id$
+//    Version: $Name$
 //
-// Test program for linear solvers.
+//    Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+//    This file is subject to QPL and may not be  distributed
+//    without copyright and license information. Please refer
+//    to the file deal.II/doc/license.html for the  text  and
+//    further information on this license.
+//
+//----------------------------  solver.cc  ---------------------------
+
 
 #include <cmath>
 #include <fstream>
index a0bd9ae234acba9c127001088e4f66fb6911d8f6..77d38427dd674b1c1224271ab265f268e638798e 100644 (file)
@@ -1,4 +1,16 @@
-// $Id$
+//----------------------------  testmatrix.cc  ---------------------------
+//    $Id$
+//    Version: $Name$
+//
+//    Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+//    This file is subject to QPL and may not be  distributed
+//    without copyright and license information. Please refer
+//    to the file deal.II/doc/license.html for the  text  and
+//    further information on this license.
+//
+//----------------------------  testmatrix.cc  ---------------------------
+
 
 #include "testmatrix.h"
 #include <lac/sparse_matrix.h>

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.