]> https://gitweb.dealii.org/ - dealii-svn.git/commitdiff
Add a new testcase.
authorwolf <wolf@0785d39b-7218-0410-832d-ea1e28bc413d>
Wed, 8 Sep 1999 13:02:41 +0000 (13:02 +0000)
committerwolf <wolf@0785d39b-7218-0410-832d-ea1e28bc413d>
Wed, 8 Sep 1999 13:02:41 +0000 (13:02 +0000)
git-svn-id: https://svn.dealii.org/trunk@1727 0785d39b-7218-0410-832d-ea1e28bc413d

tests/deal.II/wave-test-3.cc [new file with mode: 0644]
tests/deal.II/wave-test-3.expect [new file with mode: 0644]
tests/deal.II/wave-test-3.prm [new file with mode: 0644]

diff --git a/tests/deal.II/wave-test-3.cc b/tests/deal.II/wave-test-3.cc
new file mode 100644 (file)
index 0000000..424b0f5
--- /dev/null
@@ -0,0 +1,9203 @@
+// deal_II_libraries.g=-ldeal_II_2d.g
+// deal_II_libraries=-ldeal_II_2d
+
+
+#include <base/parameter_handler.h>
+#include <base/forward-declarations.h>
+#include <lac/forward-declarations.h>
+#include <basic/forward-declarations.h>
+#include <numerics/time-dependent.h>
+
+#include <iostream>
+#include <string>
+
+
+class UserMatrix;
+class SweepInfo;
+template <int dim> class SweepData;
+template <int dim> class WaveParameters;
+template <int dim> class TimeStep_Primal;
+template <int dim> class TimeStep_Dual;
+template <int dim> class DualFunctional;
+template <int dim> class EvaluationBase;
+template <int dim> class TimeStep_ErrorEstimation;
+template <int dim> class TimeStep_Postprocess;
+
+
+
+template <int dim>
+class TimeStepBase_Wave :  public TimeStepBase_Tria<dim>{
+  public:
+    TimeStepBase_Wave ();
+    TimeStepBase_Wave (const double                    time,
+                      TimeStepBase_Tria<dim>::Flags   flags,
+                      const WaveParameters<dim>      &parameters);
+    const TimeStep_Primal<dim> & get_timestep_primal () const;
+    const TimeStep_Dual<dim> &   get_timestep_dual () const;
+    const TimeStep_Postprocess<dim> &   get_timestep_postprocess () const;
+    string tmp_filename_base (const string &branch_signature) const;
+    void attach_sweep_info (SweepInfo &sweep_info);
+    void attach_sweep_data (SweepData<dim> &sweep_data);
+
+  protected:
+    const WaveParameters<dim> &parameters;
+    SweepInfo *sweep_info;
+    SweepData<dim> *sweep_data;
+};
+
+
+
+template <int dim>
+class TimeStep_Wave :  public virtual TimeStepBase_Wave<dim>
+{
+  public:
+    TimeStep_Wave (const string fe_name);
+    ~TimeStep_Wave();
+    virtual void wake_up (const unsigned int wakeup_level);
+    virtual void sleep (const unsigned int sleep_level);
+    virtual void end_sweep ();
+    unsigned int solve (const UserMatrix       &matrix,
+                       Vector<double>         &solution,
+                       const Vector<double>   &rhs) const;
+    virtual string branch_signature () const = 0;
+    DeclException0 (ExcIO);
+    DeclException0 (ExcCoarsestGridsDiffer);
+    
+    
+  protected:
+    struct StatisticData 
+    {
+       StatisticData ();
+       StatisticData (const unsigned int        n_active_cells,
+                      const unsigned int        n_dofs,
+                      const unsigned int        n_solver_steps_helmholtz,
+                      const unsigned int        n_solver_steps_projection,
+                      const pair<double,double> energy);
+       static void write_descriptions (ostream &out);
+       void write (ostream &out) const;
+       unsigned int n_active_cells;
+       unsigned int n_dofs;
+       unsigned int n_solver_steps_helmholtz;
+       unsigned int n_solver_steps_projection;
+       pair<double,double> energy;
+    }; 
+
+    DoFHandler<dim>           *dof_handler;
+    const FiniteElement<dim> &fe;
+    const Quadrature<dim>    &quadrature;
+    const Quadrature<dim-1>  &quadrature_face;
+    ConstraintMatrix          constraints;
+    SparseMatrixStruct        system_sparsity;
+    SparseMatrix<double>       mass_matrix, laplace_matrix;
+    Vector<double>             u, v;
+    StatisticData              statistic_data;
+    void create_matrices ();
+    void transfer_old_solutions (Vector<double> &old_u,
+                                Vector<double> &old_v) const;
+    void transfer_old_solutions (const typename DoFHandler<dim>::cell_iterator &old_cell,
+                                const typename DoFHandler<dim>::cell_iterator &new_cell,
+                                const Vector<double>  &old_grid_u,
+                                const Vector<double>  &old_grid_v,
+                                Vector<double>        &old_u,
+                                Vector<double>        &old_v) const;
+    pair<double,double> compute_energy ();
+    template <int anydim> friend class DualFunctional;
+    template <int anydim> friend class EvaluationBase;
+    template <int anydim> friend class TimeStep_ErrorEstimation;
+    template <int anydim> friend class TimeStep_Postprocess;
+};
+
+
+
+template <int dim>
+class TimeStep_Primal :  public TimeStep_Wave<dim> 
+{
+  public:
+    TimeStep_Primal (const string &primal_fe);
+    void do_initial_step ();
+    void do_timestep ();
+    virtual void solve_primal_problem ();    
+    virtual string branch_signature () const;
+    virtual void wake_up (const unsigned int wakeup_level);
+    
+  private:
+    void assemble_vectors (Vector<double> &right_hand_side1,
+                          Vector<double> &right_hand_side2);
+    void build_rhs (Vector<double> &right_hand_side1,
+                   Vector<double> &right_hand_side2);
+    void build_rhs (const typename DoFHandler<dim>::cell_iterator &old_cell,
+                   const typename DoFHandler<dim>::cell_iterator &new_cell,
+                   FEValues<dim>        &fe_values,
+                   Vector<double>       &right_hand_side1,
+                   Vector<double>       &right_hand_side2);
+    unsigned int
+    collect_from_children (const typename DoFHandler<dim>::cell_iterator &old_cell,
+                          FEValues<dim>  &fe_values,
+                          Vector<double>        &rhs1,
+                          Vector<double>        &rhs2) const;
+    unsigned int
+    distribute_to_children (const typename DoFHandler<dim>::cell_iterator &cell,
+                           FEValues<dim>  &fe_values,
+                           const Vector<double>  &old_dof_values_u,
+                           const Vector<double>  &old_dof_values_v,
+                           Vector<double>        &right_hand_side1,
+                           Vector<double>        &right_hand_side2);
+};
+
+
+
+template <int dim>
+class TimeStep_Dual :  public TimeStep_Wave<dim>
+{
+  public:
+    TimeStep_Dual (const string &dual_fe);
+    void do_initial_step ();
+    void do_timestep ();
+    virtual void solve_dual_problem ();    
+    virtual string branch_signature () const;
+    virtual void wake_up (const unsigned int wakeup_level);
+
+  private:
+    void assemble_vectors (Vector<double> &right_hand_side1,
+                          Vector<double> &right_hand_side2);
+    void build_rhs (Vector<double> &right_hand_side1,
+                   Vector<double> &right_hand_side2);
+    void build_rhs (const typename DoFHandler<dim>::cell_iterator &old_cell,
+                   const typename DoFHandler<dim>::cell_iterator &new_cell,
+                   FEValues<dim>        &fe_values,
+                   Vector<double>       &right_hand_side1,
+                   Vector<double>       &right_hand_side2);
+    unsigned int
+    collect_from_children (const typename DoFHandler<dim>::cell_iterator &old_cell,
+                          FEValues<dim>  &fe_values,
+                          Vector<double>        &rhs1,
+                          Vector<double>        &rhs2) const;
+    unsigned int
+    distribute_to_children (const typename DoFHandler<dim>::cell_iterator &cell,
+                           FEValues<dim>  &fe_values,
+                           const Vector<double>  &old_dof_values_u,
+                           const Vector<double>  &old_dof_values_v,
+                           Vector<double>        &right_hand_side1,
+                           Vector<double>        &right_hand_side2);
+};
+
+
+
+#include <lac/fullmatrix.h>
+
+
+
+template <int dim>
+class TimeStep_ErrorEstimation :  public virtual TimeStepBase_Wave<dim>
+{
+  public:
+    TimeStep_ErrorEstimation ();
+    virtual void estimate_error ();
+    virtual void wake_up (const unsigned int wakeup_level);
+    virtual void sleep (const unsigned int sleep_level);
+    virtual void get_tria_refinement_criteria (Vector<float> &indicators) const;
+    void get_error_indicators (Vector<float> &indicators) const;
+    virtual string branch_signature () const = 0;
+    
+  protected:
+    struct StatisticData 
+    {
+       StatisticData ();
+       StatisticData (const double estimated_error);
+       static void write_descriptions (ostream &out);
+       void write (ostream &out) const;
+       double estimated_error;
+    };
+
+    struct ErrorOnCell {
+       double part[8];
+       ErrorOnCell ();
+       ErrorOnCell operator += (const ErrorOnCell &eoc);
+       double sum () const;
+    };
+
+
+    struct CellwiseError
+    {
+       CellwiseError (const unsigned int n_errors);
+       vector<ErrorOnCell>                    errors;
+       typename vector<ErrorOnCell>::iterator next_free_slot;
+    };
+
+    Vector<float> estimated_error_per_cell;
+    FullMatrix<double> embedding_matrix;
+    FullMatrix<double> interpolation_matrix;
+    FullMatrix<double> difference_matrix;
+    StatisticData      statistic_data;
+    void estimate_error_energy (const unsigned int which_variables);
+    void estimate_error_dual ();
+    void estimate_error_dual (const typename DoFHandler<dim>::cell_iterator &primal_cell,
+                             const typename DoFHandler<dim>::cell_iterator &dual_cell,
+                             const typename DoFHandler<dim>::cell_iterator &primal_cell_old,
+                             const typename DoFHandler<dim>::cell_iterator &dual_cell_old,
+                             CellwiseError                                 &cellwise_error,
+                             FEValues<dim>                                 &fe_values) const;
+    void compute_error_on_new_children (const typename DoFHandler<dim>::cell_iterator &primal_cell,
+                                       const typename DoFHandler<dim>::cell_iterator &dual_cell,
+                                       const Vector<double>  &local_u_old,
+                                       const Vector<double>  &local_v_old,
+                                       const Vector<double>  &local_u_bar_old,
+                                       const Vector<double>  &local_v_bar_old,
+                                       CellwiseError         &cellwise_error,
+                                       FEValues<dim>         &fe_values) const;
+    ErrorOnCell collect_error_from_children (const typename DoFHandler<dim>::cell_iterator &primal_cell_old,
+                                            const typename DoFHandler<dim>::cell_iterator &dual_cell_old,
+                                            const Vector<double>  &local_u,
+                                            const Vector<double>  &local_v,
+                                            const Vector<double>  &local_u_bar,
+                                            const Vector<double>  &local_v_bar,
+                                            const Vector<double>  &local_Ih_u_bar,
+                                            const Vector<double>  &local_Ih_v_bar,
+                                            const Vector<double>  &local_Ih_u_bar_old,
+                                            const Vector<double>  &local_Ih_v_bar_old,
+                                            FEValues<dim>  &fe_values) const;
+    ErrorOnCell error_formula (const typename DoFHandler<dim>::active_cell_iterator &cell,
+                              const Vector<double>  &local_u,
+                              const Vector<double>  &local_v,
+                              const Vector<double>  &local_u_bar,
+                              const Vector<double>  &local_v_bar,
+                              const Vector<double>  &local_u_old,
+                              const Vector<double>  &local_v_old,
+                              const Vector<double>  &local_u_bar_old,
+                              const Vector<double>  &local_v_bar_old,
+                              FEValues<dim>         &fe_values) const;
+    ErrorOnCell error_formula (const typename DoFHandler<dim>::active_cell_iterator &cell,
+                              const Vector<double>  &local_u,
+                              const Vector<double>  &local_v,
+                              const Vector<double>  &local_u_bar,
+                              const Vector<double>  &local_v_bar,
+                              const Vector<double>  &local_u_old,
+                              const Vector<double>  &local_v_old,
+                              const Vector<double>  &local_u_bar_old,
+                              const Vector<double>  &local_v_bar_old,
+                              const Vector<double>  &local_difference_u_bar,
+                              const Vector<double>  &local_difference_v_bar,
+                              const Vector<double>  &local_difference_u_bar_old,
+                              const Vector<double>  &local_difference_v_bar_old,
+                              FEValues<dim>         &fe_values) const;
+    void make_interpolation_matrices ();
+};
+
+
+#include <vector>
+
+
+template <int dim>
+class TimeStep_Postprocess : public TimeStep_ErrorEstimation<dim> 
+{
+  public:
+    virtual void postprocess_timestep ();
+    virtual void wake_up (const unsigned int wakeup_level);
+    virtual void sleep (const unsigned int sleep_level);
+    virtual void end_sweep ();
+    string branch_signature () const;
+
+  protected:
+    struct StatisticData 
+    {
+       static void write_descriptions (ostream &out,
+                                       const WaveParameters<dim> &parameters);
+       void write (ostream &out) const;
+       vector<double> evaluation_results;
+    };
+
+    StatisticData statistic_data;
+
+  private:
+    void interpolate_dual_solution (Vector<double> &interpolated_u_bar,
+                                   Vector<double> &interpolated_v_bar) const;
+};
+
+
+
+template <int dim> class WaveParameters;
+
+
+
+template <int dim>
+class TimeStep :  public TimeStep_Primal<dim>, public TimeStep_Dual<dim>, public TimeStep_Postprocess<dim>
+{
+  public:
+    TimeStep (const double               time,
+             const WaveParameters<dim> &parameters);
+
+    virtual void wake_up (const unsigned int wakeup_level);
+    virtual void sleep (const unsigned int sleep_level);
+    virtual void end_sweep ();
+    static void write_statistics_descriptions (ostream                   &out,
+                                              const WaveParameters<dim> &parameters);
+    void write_statistics (ostream &out) const;
+};
+
+template <int dim> class TimeStep_Primal;
+template <int dim> class TimeStep_Dual;
+
+
+
+template <int dim>
+class DualFunctional {
+  public:
+                                    /**
+                                     * Constructor. Specify whether an
+                                     * actual functional needs the primal
+                                     * solution at all times or at the
+                                     * endtime. Default is #false# is
+                                     * both cases which means that the
+                                     * functional is linear.
+                                     */
+    DualFunctional (const bool use_primal_problem            = false,
+                   const bool use_primal_problem_at_endtime = false);
+
+                                    /**
+                                     * Return that part of the dual functional
+                                     * related to a delta function in time at
+                                     * the end time.
+                                     *
+                                     * The default is to return zero.
+                                     */
+    virtual void compute_endtime_vectors (Vector<double> &final_u_bar,
+                                         Vector<double> &final_v_bar);
+
+                                    /**
+                                     * Return that part of the dual functional
+                                     * related to the regular time integral.
+                                     *
+                                     * The default is to return zero.
+                                     */
+    virtual void compute_functionals (Vector<double> &j1,
+                                     Vector<double> &j2);
+
+                                    /**
+                                     * Return whether this object uses
+                                     * information from the primal problem
+                                     * (i.e. whether it is nonlinear or not).
+                                     * The necessary information is set in
+                                     * the constructor.
+                                     *
+                                     * This function refers to all times.
+                                     */
+    bool use_primal_solutions () const;
+
+                                    /**
+                                     * Return whether this object uses
+                                     * information from the primal problem
+                                     * (i.e. whether it is nonlinear or not).
+                                     * The necessary information is set in
+                                     * the constructor.
+                                     *
+                                     * This function refers to the solution
+                                     * at the end time. There are functionals
+                                     * which only evaluate at the endpoint
+                                     * but are nonlinear anyway. For them it
+                                     * is not necessary to reload the primal
+                                     * data at other times than the end time.
+                                     */
+    bool use_primal_solutions_at_endtime () const;
+
+                                    /**
+                                     * Reset the functional to the present
+                                     * time level. This function needs to be
+                                     * called at each time level if the
+                                     * functional is nonlinear and at the
+                                     * endtime if the functional is nonlinear
+                                     * only at the endtime.
+                                     */
+    virtual void reset (const TimeStep_Primal<dim> &primal_problem);
+
+                                    /**
+                                     * Reset the functional to the present
+                                     * time level. This function needs to be
+                                     * called at each time level. It resets
+                                     * pointers to the dof handler, the
+                                     * triangulation and several other
+                                     * objects which are needed to compute
+                                     * the dual functional.
+                                     */
+    virtual void reset (const TimeStep_Dual<dim> &dual_problem);
+
+                                    /**
+                                     * Exception
+                                     */
+    DeclException0 (ExcPrimalProblemNotRequested);
+    
+  protected:
+    const bool use_primal_problem;
+    const bool use_primal_problem_at_endtime;
+
+    const Triangulation<dim> *tria;
+    const Boundary<dim>      *boundary;
+    const DoFHandler<dim>    *dof;
+    const FiniteElement<dim> *fe;
+    const Quadrature<dim>    *quadrature;
+    const Quadrature<dim-1>  *quadrature_face;
+    const Function<dim>      *density, *stiffness;
+
+    const DoFHandler<dim>    *primal_dof;
+    const FiniteElement<dim> *primal_fe;
+    const Quadrature<dim>    *primal_quadrature;
+    const Quadrature<dim-1>  *primal_quadrature_face;
+
+    const Vector<double>     *u;
+    const Vector<double>     *v;
+
+    double       time;
+    double       time_step;
+    unsigned int step_no;
+};
+
+
+
+
+
+/**
+ * Compute the dual functional which is approximately associated
+ * with the end time energy in the high atmosphere above 4000km.
+ * The energy in a domain $D$ is given by
+ * $E_D = \int_D (v^2 + \nabla u a \nabla u)_{t=T}$ and the
+ * associated functional for the error is approximately
+ * $J(\Psi) = \int_D v_h(T) \psi + \nabla u_h(T) a \nabla \phi$.
+ */
+template <int dim>
+class EndEnergy : public DualFunctional<dim> {
+  public:
+                                    /**
+                                     * Constructor.
+                                     */
+    EndEnergy (const bool use_primal_problem_at_any_time = false);
+
+  protected:
+    enum PartOfDomain { low_atmosphere, high_atmosphere };
+
+                                    /**
+                                     * Compute the initial values of the
+                                     * dual problem.
+                                     */
+    void compute_vectors (const PartOfDomain pod,
+                         Vector<double> &final_u_bar,
+                         Vector<double> &final_v_bar) const;
+};
+
+
+
+
+
+
+
+/**
+ * Let the point value of $u$ at the origin integrated over time
+ * be the goal.
+ */
+template <int dim>
+class IntegratedValueAtOrigin : public EndEnergy<dim> {
+  public:
+                                    /**
+                                     * Evaluate the dual functionals and
+                                     * return the right hand side contributions
+                                     * thereof for the present time step.
+                                     */
+    virtual void compute_functionals (Vector<double> &j1,
+                                     Vector<double> &j2);
+
+                                    /**
+                                     * Exception.
+                                     */
+    DeclException0 (ExcVertexNotFound);
+};
+
+
+
+
+
+/**
+ * Dual function corresponding to the #EvaluateSeismicSignal# class.
+ */
+template <int dim>
+class SeismicSignal : public DualFunctional<dim> {
+  public:
+                                    /**
+                                     * Evaluate the dual functionals and
+                                     * return the right hand side contributions
+                                     * thereof for the present time step.
+                                     */
+    virtual void compute_functionals (Vector<double> &j1,
+                                     Vector<double> &j2);
+};
+
+
+
+/**
+ * Compute the dual problem associated with the functional
+ * $J(\Psi) = \int u ds$ with the integral being over some
+ * parts of the boundary.
+ */
+template <int dim>
+class EarthSurface : public DualFunctional<dim> {
+  public:
+                                    /**
+                                     * Evaluate the dual functionals and
+                                     * return the right hand side contributions
+                                     * thereof for the present time step.
+                                     */
+    virtual void compute_functionals (Vector<double> &j1,
+                                     Vector<double> &j2);
+};
+
+
+
+/**
+ * Compute $J(\Psi) = \int_0^0.25 u(x=2,y,t=2.2) dy.
+ */
+template <int dim>
+class SplitSignal : public DualFunctional<dim> {
+  public:
+                                    /**
+                                     * Evaluate the dual functionals and
+                                     * return the right hand side contributions
+                                     * thereof for the present time step.
+                                     */
+    virtual void compute_functionals (Vector<double> &j1,
+                                     Vector<double> &j2);
+};
+
+
+
+
+
+/**
+ * 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.
+ */
+template <int dim>
+class SplitLine : public DualFunctional<dim> {
+  public:
+                                    /**
+                                     * Compute the initial values of the
+                                     * dual problem.
+                                     */
+    void compute_endtime_vectors (Vector<double> &final_u_bar,
+                                 Vector<double> &final_v_bar);
+};
+
+
+
+/**
+ * Compute $J(\Psi) = \int_{-0.6}^{-0.4} u(x,t=2.5) dx.
+ */
+template <int dim>
+class OneBranch1d : public DualFunctional<dim> {
+  public:
+                                    /**
+                                     * Evaluate the dual functionals and
+                                     * return the right hand side contributions
+                                     * thereof for the present time step.
+                                     */
+    virtual void compute_functionals (Vector<double> &j1,
+                                     Vector<double> &j2);
+};
+
+
+
+/**
+ * Compute $J(\Psi) = \int_{-0.1}^{0.1} u(x,t=2.4) dx.
+ */
+template <int dim>
+class SecondCrossing : public DualFunctional<dim> {
+  public:
+                                    /**
+                                     * Evaluate the dual functionals and
+                                     * return the right hand side contributions
+                                     * thereof for the present time step.
+                                     */
+    virtual void compute_functionals (Vector<double> &j1,
+                                     Vector<double> &j2);
+};
+
+
+
+/**
+ */
+template <int dim>
+class HuyghensWave : public DualFunctional<dim> {
+  public:
+                                    /**
+                                     * Evaluate the dual functionals and
+                                     * return the right hand side contributions
+                                     * thereof for the present time step.
+                                     */
+    virtual void compute_functionals (Vector<double> &j1,
+                                     Vector<double> &j2);
+};
+
+
+#include <basic/forward-declarations.h>
+#include <base/forward-declarations.h>
+#include <lac/forward-declarations.h>
+#include <base/exceptions.h>
+#include <string>
+
+
+
+
+
+/**
+ * This class provides a simple interface to do arbitrary evaluations of
+ * the numerical solution. Concrete classes implementing evaluations
+ * need access to the solution vectors #u# and #v# as well as to the
+ * triangulation and the associated degrees of freedoms, which is what
+ * this class provides. This way is chosen to separate the problem
+ * classes which do the actual solution from the evaluation classes, since
+ * they don't need to know much about the solution classes apart from
+ * the solution itself. Thus, we reduce dependencies which speeds up
+ * compilation and makes software engineering more simple.
+ */
+template <int dim>
+class EvaluationBase {
+  public:
+                                    /**
+                                     * Constructor. Set all pointers in this
+                                     * class to invalid values.
+                                     */
+    EvaluationBase ();
+
+                                    /**
+                                     * Destructor. Does nothing but needs
+                                     * to be declared to make it virtual.
+                                     */
+    virtual ~EvaluationBase () {};
+
+                                    /**
+                                     * Reset pointers to triangulation, dof
+                                     * handler, quadrature formulae etc.
+                                     * to the right values for the time level
+                                     * to be evaluated next. This function
+                                     * needs to be called each time an
+                                     * evaluation is to take place.
+                                     */
+    virtual void reset_timelevel (const TimeStep_Primal<dim> &target);
+
+                                    /**
+                                     * Template for the evaluation functions.
+                                     * Return one value for the output file.
+                                     */
+    virtual double evaluate () = 0;
+
+                                    /**
+                                     * Reset the evaluator for the
+                                     * next sweep. This may be useful
+                                     * if you want to sum up the contributions
+                                     * of each time step and print them
+                                     * at the end; you then have to
+                                     * reset the sum at the start of
+                                     * the next sweep, which is done through
+                                     * this function.
+                                     *
+                                     * Default is: do nothing.
+                                     */
+    virtual void reset ();
+
+                                    /**
+                                     * Print the result at the end of
+                                     * each sweep. This function may
+                                     * print lines of data with four
+                                     * spaces at the beginning of each
+                                     * line.
+                                     *
+                                     * Default is: do nothing.
+                                     */
+    virtual void print_final_result (ostream &out);
+
+                                    /**
+                                     * Return the final result as a number
+                                     * for the result file.
+                                     *
+                                     * Default is: do nothing.
+                                     */
+    virtual double get_final_result ();
+
+                                    /**
+                                     * Return a brief string of description
+                                     * which will go into the first line
+                                     * of the "results" file.
+                                     */
+    virtual string description () const = 0;
+
+                                    /**
+                                     * Exception.
+                                     */
+    DeclException0 (ExcIO);
+    
+  protected:
+                                    /**
+                                     * Pointers to the solution vectors
+                                     * of the primal problem.
+                                     */
+    const Vector<double>     *u, *v;
+
+                                    /**
+                                     * Underlying triangulation.
+                                     */
+    const Triangulation<dim> *tria;
+
+                                    /**
+                                     * Boundary object.
+                                     */
+    const Boundary<dim>      *boundary;
+
+                                    /**
+                                     * Degrees of freedom of the primal
+                                     * problem.
+                                     */
+    const DoFHandler<dim>    *dof;
+
+                                    /**
+                                     * Primal finite element.
+                                     */
+    const FiniteElement<dim> *fe;
+
+                                    /**
+                                     * Quadrature rule appropriate for
+                                     * the primal finite element.
+                                     */
+    const Quadrature<dim>    *quadrature;
+
+                                    /**
+                                     * Same for quadrature on faces.
+                                     */
+    const Quadrature<dim-1>  *quadrature_face;
+
+                                    /**
+                                     * Density and stiffness coefficients
+                                     * for the modell presently under
+                                     * investigation.
+                                     */
+    const Function<dim>      *density, *stiffness;
+
+                                    /**
+                                     * Continuous time of the time step
+                                     * we are evaluating at present.
+                                     */
+    double                    time;
+
+                                    /**
+                                     * Length of the last time step, i.e. in
+                                     * the backward direction in time. If
+                                     * this is the first timestep, the this
+                                     * value is set to zero.
+                                     */
+    double                    time_step;
+
+                                    /**
+                                     * Number of that time step.
+                                     */
+    unsigned int              step_no;
+
+                                    /**
+                                     * Base of the filenames under which
+                                     * we shall store our results.
+                                     */
+    string                    base_file_name;
+};
+
+
+
+
+
+/**
+ * This class is a common base class to the following two. It provides
+ * for some infrastructure for evaluations computing the energy in part
+ * of the domain and computing the in/outflow of energy.
+ *
+ * Central is the #compute_energy# function, which takes an argument
+ * describing which part of the domain to take and returns the energy
+ * therein.
+ */
+template <int dim>
+class EvaluateEnergyContent : public EvaluationBase<dim> {
+  public:
+                                    /**
+                                     * Constructor.
+                                     */
+    EvaluateEnergyContent ();
+
+                                    /**
+                                     * Reset the accumulated energy to zero.
+                                     */
+    virtual void reset ();
+
+  protected:
+                                    /**
+                                     * Enum denoting for which of the two
+                                     * subdomains the computation is to be
+                                     * performed.
+                                     */
+    enum PartOfDomain { low_atmosphere, high_atmosphere };
+
+                                    /**
+                                     * Compute the energy for the given
+                                     * subdomain.
+                                     */
+    double compute_energy (const PartOfDomain pod) const;
+      
+  protected:
+                                    /**
+                                     * Energy in the domain in the previous
+                                     * time step. This information is needed
+                                     * to compute the accumulated in/outflux
+                                     * of energy from the domain.
+                                     */
+    double old_energy;
+
+                                    /**
+                                     * Accumulated in/outflux into/from the
+                                     * domain integrated over time.
+                                     */
+    double integrated_outflux;
+};
+
+
+
+
+
+
+
+/**
+ * Evaluate the value of $u$ at the origin, i.e. $u(0,0)$.
+ *
+ * As final result, the time integrated value at the origin is computed.
+ * The origin shall be a vertex in the finest grid.
+ */
+template <int dim>
+class EvaluateIntegratedValueAtOrigin : public EvaluationBase<dim> {
+  public:
+    EvaluateIntegratedValueAtOrigin ():
+                   integrated_value (0) {};
+    
+    virtual double evaluate ();
+    virtual void print_final_result (ostream &out);
+    virtual double get_final_result ();
+    virtual string description () const;
+
+                                    /**
+                                     * Reset the average value to zero.
+                                     */
+    virtual void reset ();
+
+                                    /**
+                                     * Exception.
+                                     */
+    DeclException0 (ExcVertexNotFound);
+    
+  private:
+    double integrated_value;
+};
+
+
+
+
+
+
+/**
+ * Integrate the value of $u_h$ at the top boundary over $x$ and $t$ using a
+ * highly oscillatory weight.
+ */
+template <int dim>
+class EvaluateSeismicSignal : public EvaluationBase<dim> {
+  public:
+    EvaluateSeismicSignal () :
+                   result (0) {};
+
+    static inline double weight (const Point<dim> &p, const double time) {
+      const double pi = 3.14159265359;
+      return sin(3*pi*p(0))*sin(5*pi*time/2);
+    };
+    
+    
+    virtual double evaluate ();
+    virtual void print_final_result (ostream &out);
+    virtual double get_final_result ();
+    virtual string description () const;
+
+                                    /**
+                                     * Reset the value to zero.
+                                     */
+    virtual void reset ();
+
+  private:
+    double result;
+};
+
+
+
+/**
+ * Integrate the value of $u_h$ at the top line $x=1.5, y=0..1/16$ at $t=1.6..1.8$.
+ */
+template <int dim>
+class EvaluateSplitSignal : public EvaluationBase<dim> {
+  public:
+    EvaluateSplitSignal () :
+                   result (0) {};
+    
+    
+    virtual double evaluate ();
+    virtual void print_final_result (ostream &out);
+    virtual double get_final_result ();
+    virtual string description () const;
+
+                                    /**
+                                     * Reset the value to zero.
+                                     */
+    virtual void reset ();
+
+  private:
+    double result;
+};
+
+    
+
+template <int dim>
+class EvaluateOneBranch1d : public EvaluationBase<dim> {
+  public:
+    EvaluateOneBranch1d () :
+                   result (0) {};
+    
+    
+    virtual double evaluate ();
+    virtual void print_final_result (ostream &out);
+    virtual double get_final_result ();
+    virtual string description () const;
+
+                                    /**
+                                     * Reset the value to zero.
+                                     */
+    virtual void reset ();
+
+  private:
+    double result;
+};
+
+
+
+
+template <int dim>
+class EvaluateSecondCrossing1d : public EvaluationBase<dim> {
+  public:
+    EvaluateSecondCrossing1d () :
+                   result (0) {};
+    
+    
+    virtual double evaluate ();
+    virtual void print_final_result (ostream &out);
+    virtual double get_final_result ();
+    virtual string description () const;
+
+                                    /**
+                                     * Reset the value to zero.
+                                     */
+    virtual void reset ();
+
+  private:
+    double result;
+};
+
+
+
+template <int dim>
+class EvaluateHuyghensWave : public EvaluationBase<dim> {
+  public:
+    EvaluateHuyghensWave () :
+                   integrated_value (0),
+                   weighted_value (0) {};
+    
+    
+    virtual double evaluate ();
+    virtual void print_final_result (ostream &out);
+    virtual double get_final_result ();
+    virtual string description () const;
+
+                                    /**
+                                     * Reset the value to zero.
+                                     */
+    virtual void reset ();
+
+  private:
+    double integrated_value, weighted_value;
+};
+
+
+    
+
+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
+ * do not collect information for later output, but provide services to
+ * the time steps.
+ */
+template <int dim>
+class SweepData 
+{
+  public:
+    SweepData (const bool use_data_out_stack);
+    ~SweepData ();
+
+    DataOutStack<dim> *data_out_stack;
+};
+
+
+
+#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.
+ */
+class SweepInfo 
+{
+  public:
+    struct Data 
+    {
+                                        /**
+                                         * Constructor. Set all fields to
+                                         * their initial values.
+                                         */
+       Data ();
+       
+       double accumulated_error;
+
+       unsigned int cells;
+       unsigned int primal_dofs;
+       unsigned int dual_dofs;
+    };
+
+
+    struct Timers 
+    {
+       Timer grid_generation;
+       Timer primal_problem;
+       Timer dual_problem;
+       Timer error_estimation;
+       Timer postprocessing;
+    };
+
+
+    Data & get_data ();
+
+    Timers & get_timers ();
+    
+    
+    template <int dim>
+    void write_summary (const list<EvaluationBase<dim>*> & eval_list,
+                       ostream &out) const;
+    
+  private:
+    Data data;
+    Timers timers;
+};
+
+
+
+#include <lac/sparsematrix.h>
+
+
+
+
+/**
+ * Enum denoting the different possibilities to precondition a solver.
+ */
+enum Preconditioning {
+      no_preconditioning,
+      jacobi,
+      sor,
+      ssor
+};
+
+
+
+/**
+ * Wrapper for the #SparseMatrix<double># class which handles the preconditioning.
+ */
+class UserMatrix :  public SparseMatrix<double> {
+  public:
+                                    /**
+                                     * Constructor. The parameter specifies
+                                     * which way to precondition.
+                                     */
+    UserMatrix (Preconditioning p) :
+                   SparseMatrix<double> (),
+                   preconditioning (p) {};
+
+                                    /**
+                                     * Constructor. The second parameter
+                                     * specifies which way to precondition.
+                                     * The first parameter is simply passed
+                                     * down to the base class.
+                                     */
+    UserMatrix (const SparseMatrixStruct &sparsity,
+               Preconditioning       p) :
+                   SparseMatrix<double>(sparsity),
+                   preconditioning (p) {};
+
+                                    /**
+                                     * Precondition a vector #src# and write
+                                     * the result into #dst#. This function
+                                     * does not much more than delegating to
+                                     * the respective #precondition_*#
+                                     * function of the base class, according
+                                     * to the preconditioning method specified
+                                     * to the constructor of this class.
+                                     */
+    void precondition (Vector<double> &dst, const Vector<double> &src) const;
+
+  private:
+                                    /**
+                                     * Variable denoting the preconditioning
+                                     * method.
+                                     */
+    Preconditioning preconditioning;
+};
+
+
+#include <base/exceptions.h>
+#include <basic/forward-declarations.h>
+
+#include <string>
+
+
+string int_to_string (const unsigned int i, const unsigned int digits);
+
+
+template <typename number>
+inline number sqr (const number a) {
+  return a*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.
+ * It is also able to return the correct quadrature formula for domain and
+ * boundary integrals for the specified finite element.
+ */
+template <int dim>
+struct FEHelper {
+    static const FEQ1<dim>           fe_linear;
+    static const FEQ2<dim>           fe_quadratic_sub;
+#if 2 < 3    
+    static const FEQ3<dim>           fe_cubic_sub;
+    static const FEQ4<dim>           fe_quartic_sub;
+#endif
+
+    static const QGauss2<dim>        q_gauss_2;
+    static const QGauss3<dim>        q_gauss_3;
+    static const QGauss4<dim>        q_gauss_4;
+    static const QGauss5<dim>        q_gauss_5;
+    static const QGauss6<dim>        q_gauss_6;
+    static const QGauss7<dim>        q_gauss_7;
+    static const QGauss8<dim>        q_gauss_8;
+
+    static const QGauss2<dim-1>      q_gauss_2_face;
+    static const QGauss3<dim-1>      q_gauss_3_face;
+    static const QGauss4<dim-1>      q_gauss_4_face;
+    static const QGauss5<dim-1>      q_gauss_5_face;
+    static const QGauss6<dim-1>      q_gauss_6_face;
+    static const QGauss7<dim-1>      q_gauss_7_face;
+    static const QGauss8<dim-1>      q_gauss_8_face;
+
+                                    /**
+                                     * Return a reference to the finite
+                                     * element specified by the name
+                                     * #name#.
+                                     */
+    static const FiniteElement<dim> & get_fe (const string &name);
+
+                                    /**
+                                     * Return the correct domain quadrature
+                                     * formula for the finite element denoted
+                                     * by the name #name#.
+                                     */
+    static const Quadrature<dim>    & get_quadrature (const string &name);
+
+                                    /**
+                                     * Return the correct boundary quadrature
+                                     * formula for the finite element denoted
+                                     * by the name #name#.
+                                     */
+    static const Quadrature<dim-1>  & get_quadrature_face (const string &name);
+};
+
+
+
+#include <base/forward-declarations.h>
+#include <basic/forward-declarations.h>
+#include <list>
+#include <string>
+
+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
+ * to assemble all the parameters and the functions evaluating them from the
+ * input file at one place without the need to scatter this functionality
+ * all over the program.
+ *
+ *
+ * \section{Description of the input parameters}
+ *
+ * Note that this list may not be up-tp-date at present.
+ *
+ * \subsection{Subsection #Grid#}
+ * \begin{itemize}
+ * \item #Coarse mesh#: Names a grid to be taken as a coarse grid. The following
+ *    names are allowed:
+ *    \begin{itemize}
+ *    \item #uniform channel#: The domain is $[0,3]\times[0,1]$, triangulated
+ *        by three cells. Left and right boundary are of Dirichlet type, top
+ *        and bottom boundary are of homogeneous Neumann type.
+ *    \item #split channel bottom#: As above, but the lower half is refined once
+ *        more than the top half.
+ *    \item #split channel {left | right}#: Same as #uniform channel#, but with
+ *        cells on the left or right, according to the last word, more refined
+ *        than on the other side.
+ *    \item #square#: $[-1,1]\times[-1,1]$.
+ *    \item #seismic square#: same as #square#, but with Neumann boundary
+ *        at top.
+ *    \item #temperature-square#: Square with size $400,000,000$ (we use the
+ *        cgs system, so this amounts to 4000 km).
+ *    \item #temperature-testcase#: As above, but with a sequence of
+ *        continuously growing cells set atop to avoid the implementation of
+ *        absorbing boundary conditions. The left boundary is of Neumann
+ *        type (mirror boundary).
+ *    \item #random#: Unit square, but randomly refined to test for correctness
+ *        of the time stepping scheme.
+ *    \item #earth#: Circle with radius 6371 (measured in km).
+ *    \end{itemize}
+ * \item #Initial refinement#: States how often the grid named by the above
+ *    parameter shall be globally refined to form the coarse mesh.
+ * \item #Maximum refinement#: maximum refinement level a cell may attain.
+ *    Cells with such a refinement level are flagged as others are, but they
+ *    are not refined any more; it is therefore not necessary to lower the
+ *    fraction of cells to be refined in order to avoid the refinement of a
+ *    similar number of cells with a lower level number.
+ *
+ *    The default to this value is zero, meaning no limit.
+ * \item #Refinement fraction#: Upon refinement, those cells are refined which
+ *    together make up for a given fraction of the total error. This parameter
+ *    gives that fraction. Default is #0.95#.
+ * \item #Coarsening fraction#: Similar as above, gives the fraction of the
+ *    total error for which the cells shall be coarsened. Default is #0.03#.
+ * \item #Top cell number deviation#: Denotes a fraction by which the number of
+ *    cells on a time level may be higher than the number of cells on the
+ *    previous time level. This and the next two parameters help to avoid
+ *    to much differing grids on the time levels and try to smooth the numbers
+ *    of cells as a function of time. The default value is #0.1#.
+ * \item #Bottom cell number deviation#: Denotes the fraction by which the
+ *    number of cells on a time level may be lower than on the previous time
+ *    level. Default is #0.03#.
+ * \item #Cell number correction steps#: Usually, the goal denoted by the two
+ *    parameters above cannot be reached directly because the number of cells
+ *    is modified by grid regularization etc. The goal can therefore only be
+ *    reached by an iterative process. This parameter tells how many iterations
+ *    of this process shall be done. Default is #2#.
+ * \end{itemize}
+ *
+ * \subsection{Subsection #Equation data#}
+ * \begin{itemize}
+ * \item #Coefficient#: Names for the different coefficients for the Laplace
+ *    like part of the wave operator. Allowed values are:
+ *    \begin{itemize}
+ *    \item #unit#: Constant one.
+ *    \item #kink#: One for $y<\frac 13$, 4 otherwise.
+ *    \item #gradient#: $1+8*y^2$.
+ *    \item #tube#: $0.2$ for $|x|<0.2$, one otherwise.
+ *    \item #temperature VAL81#: Coefficient computed from the temperature
+ *        field given by Varnazza, Avrett, Loeser 1981.
+ *    \item #temperature kolmogorov#: Broadened temperature spectrum.
+ *    \item #temperature undisturbed#: Quiet atmosphere.
+ *    \item #temperature monochromatic 20s#: Temperature as computed with
+ *        shock waves with $T=20s$.
+ *    \item #temperature monochromatic 40s#: Temperature as computed with
+ *        shock waves with $T=40s$.
+ *    \end{itemize}
+ * \item #Initial u#: Names for the initial value for the amplitude. Allowed
+ *    names are:
+ *    \begin{itemize}
+ *    \item #zero#: $u_0=0$.
+ *    \item #eigenmode#: $u_0=sin(2\pi x)sin(2\pi y)$.
+ *    \item #bump#: $u_0=(1-\frac{\vec x^2}{a^2})e^{-\frac{\vec x^2}{a^2}}$
+ *        for $|\vec x|<a$ and $u_0=0$ otherwise. $a=0.1$
+ *    \item #center-kink#: $u_0=r/a$ for $r<a$, $u_0=2-r/a$ for $a<r<2a$,
+ *        $u=0$ otherwise. $a=0.1$, $r=|\vec x|$.
+ *    \item #shifted bump#: Same as #bump# but the center of the bump is
+ *        located at $x=0.5, y=0$.
+ *    \item #tube#: $u_0=1$ for $|x|<0.2, zero otherwise.
+ *    \end{itemize}
+ * \item #Initial v#: Names for the initial value for the amplitude. Allowed
+ *    names are the same as above.
+ * \item #Boundary#: Names for the boundary functions. The boundary values
+ *    for $u$ and $v$ are always set together. The boundary values apply only
+ *    to those boundary parts which are of Dirichlet type. Allowed names are:
+ *    \begin{itemize}
+ *    \item #zero#: Homogeneous boundary values.
+ *    \item #wave from left#: For $t<T=0.4$ we set $u=sin^2(\pi \frac tT)$ at
+ *        the boundary where $x=0$.
+ *    \item #wave from left center#: For $t<T=0.4$ and $0.4<y<0.6$ we set
+ *        $u=sin^2(\pi \frac tT) (y-0.4) (0.6-y)$ at
+ *        the boundary where $x=0$.
+ *    \item #wave from left bottom#: For $t<T=60s$ and $r=|\vec x|<a=5000000cm=50km$
+ *        let $u=(cos(\pi/2 r/a) sin(\pi t/T))^2$.
+ *        This boundary condition is only suited to the temperature domains. 
+ *    \end{itemize}
+ * \end{itemize}
+ *
+ * \subsection{Subsection #Time stepping#}
+ * \begin{itemize}
+ * \item #Primal method#: Time stepping method for the primal problem.
+ *     Allowed values are:
+ *     \begin{itemize}
+ *     \item #theta#: Use the $\theta$ scheme with the $\theta$-parameter
+ *         as given below.
+ *     \item #fractional step#: Use the fractional step $\theta$ scheme.
+ *     \end{itemize}
+ * \item #Dual method#: Time stepping method for the dual problem. Allowed
+ *     values are the same as above. Note that the fractional step scheme
+ *     is not implemented for right hand sides not equal to zero, i.e. the
+ *     fractional step scheme will fail of the error functional evaluates
+ *     to non-zero at times not equal to the end time.
+ * \item #Theta#: $\theta$ parameter for the $\theta$ time stepping scheme.
+ *     $\theta=1/2$ denotes the Crank-Nicolson scheme.
+ * \item #Time step#: Selfdocumenting.
+ * \item #End time#: Selfdocumenting.
+ * \end{itemize}
+ */
+template <int dim>
+class WaveParameters
+{
+  public:
+                                    /**
+                                     * Constructor.
+                                     */
+    WaveParameters ();
+
+                                    /**
+                                     * Destructor.
+                                     */
+    ~WaveParameters ();
+
+                                    /**
+                                     * Declare all the parameters to the
+                                     * given parameter handler.
+                                     */
+    void declare_parameters (ParameterHandler &prm);
+
+                                    /**
+                                     * Extract the parameters values provided
+                                     * by the input file and/or the default
+                                     * values from the parameter handler.
+                                     */
+    void parse_parameters (ParameterHandler &prm);
+
+                                    /**
+                                     * Delete the contents of this class and
+                                     * set up a clean state.
+                                     */
+    void delete_parameters ();
+
+                                    /**
+                                     * Enum holding a list of possible coarse
+                                     * mesh choices.
+                                     */
+    enum InitialMesh {
+         uniform_channel,
+         split_channel_bottom,
+         split_channel_right,
+         split_channel_left,
+         square,
+         ring,
+         seismic_square,
+         earth,
+         line,
+         split_line
+    };
+
+                                    /**
+                                     * Enum holding a list of possible
+                                     * boundary condition choices.
+                                     */
+    enum BoundaryConditions {
+         wave_from_left,
+         fast_wave_from_left,
+         wave_from_left_center,
+         wave_from_left_bottom,
+         zero
+    };
+
+                                    /**
+                                     * Enum denoting possible strategies
+                                     * for output of meshes and solutions.
+                                     * This enum tells us, at which sweeps
+                                     * data is to be written.
+                                     */
+    enum WriteStrategy {
+         never,
+         all_sweeps,
+         last_sweep_only
+    };
+
+                                    /**
+                                     * Boundary values. Continuous function
+                                     * of space and time.
+                                     */
+    Function<dim>      *boundary_values_u;
+
+                                    /**
+                                     * Same for the velocity variable v.
+                                     */
+    Function<dim>      *boundary_values_v;
+
+                                    /**
+                                     * Initial values for u.
+                                     */
+    Function<dim>      *initial_u;
+
+                                    /**
+                                     * Same for the velocity variable v.
+                                     */
+    Function<dim>      *initial_v;
+
+                                    /**
+                                     * Object describing the boundary. By
+                                     * default the domain is polygonal made
+                                     * from the vertices of the coarsest
+                                     * triangulation. However, some of the
+                                     * example geometries set in
+                                     * #make_coarse_grid# may set this variable
+                                     * to another address. The object pointed
+                                     * will be deleted at the end of the
+                                     * lifetime of this object; when setting
+                                     * this variable to another object, you
+                                     * may want to delete the object pointed
+                                     * to previously.
+                                     */
+    const Boundary<dim>*boundary;
+
+                                    /**
+                                     * Function denoting the coefficient
+                                     * within the generalized laplacian
+                                     * operator.
+                                     */
+    Function<dim>      *density;
+
+                                    /**
+                                     * Same for the stiffness parameter.
+                                     */
+    Function<dim>      *stiffness;
+
+                                    /**
+                                     * Store whether the density is a function
+                                     * that is constant in space (not
+                                     * necessarily in time as well, but at
+                                     * each fixed time).
+                                     */
+    bool density_constant;
+
+                                    /**
+                                     * Same thing for the stiffness parameter.
+                                     */
+    bool stiffness_constant;
+    
+                                    /**
+                                     * Pointer to an object denoting the
+                                     * error functional.
+                                     */
+    DualFunctional<dim>*dual_functional;
+    
+                                    /**
+                                     * Level of initial refinement, i.e. the
+                                     * minimum level cells on all grids at
+                                     * all times need to have.
+                                     */
+    unsigned int        initial_refinement;
+
+                                    /**
+                                     * Maximum refinement level a cell may
+                                     * have. This one defaults to zero,
+                                     * meaning no limit.
+                                     */
+    unsigned int        maximum_refinement;
+
+                                    /**
+                                     * Define structure of initial mesh:
+                                     * created by regular refinement of
+                                     * the coarsest mesh (uniform) or
+                                     * refine one half once more than
+                                     * the other (split) or some other
+                                     */
+    Triangulation<dim>      *coarse_grid;
+    
+                                    /**
+                                     * Pair of numbers denoting the fraction
+                                     * of the total error for which the cells
+                                     * are to be refined (first) and
+                                     * coarsened (second).
+                                     */
+    pair<double,double>      refinement_fraction;
+
+                                    /**
+                                     * Fraction by which the number of cells
+                                     * on a time level may differ from the
+                                     * number on the previous time level
+                                     * (first: top deviation, second: bottom
+                                     * deviation).
+                                     */
+    pair<double,double>      cell_number_corridor;
+
+                                    /**
+                                     * Number of iterations to be performed
+                                     * to adjust the number of cells on a
+                                     * time level to those on the previous
+                                     * one.
+                                     */
+    unsigned int             cell_number_correction_steps;
+
+                                    /**
+                                     * Shall we renumber the degrees of
+                                     * freedom according to the Cuthill-McKee
+                                     * algorithm or not.
+                                     */
+    bool                     renumber_dofs;
+
+                                    /**
+                                     * Compare error indicators globally or
+                                     * refine each time step separately from
+                                     * the others.
+                                     */
+    bool                     compare_indicators_globally;
+    
+                                    /**
+                                     * Parameters for the time discretization
+                                     * of the two equations using the
+                                     * theta scheme.
+                                     */
+    double              theta;
+
+                                    /**
+                                     * Time step size.
+                                     */
+    double              time_step;
+    
+                                    /**
+                                     * Time up to which we want to compute.
+                                     */
+    double              end_time;
+
+                                    /**
+                                     * Mode of preconditioning.
+                                     */
+    Preconditioning     preconditioning;
+
+                                    /**
+                                     * Use extrapolated values of the old
+                                     * solutions as starting values for
+                                     * the solver on the new timestep.
+                                     */
+    bool                extrapolate_old_solutions;
+    
+                                    /**
+                                     * Directory to which we want the output
+                                     * written.
+                                     */
+    string              output_directory;
+
+                                    /**
+                                     * Directory to which we want the temporary
+                                     * file to be written.
+                                     */
+    string              tmp_directory;
+    
+                                    /**
+                                     * Format in which the results on the
+                                     * meshes is to be written to files.
+                                     */
+    string              output_format;
+
+                                    /**
+                                     * Denotes in which sweeps the solution is
+                                     * to be written.
+                                     */
+    WriteStrategy       write_solution_strategy;
+
+                                    /**
+                                     * Denote the interval between the steps
+                                     * which are to be written.
+                                     */
+    unsigned int        write_steps_interval;
+
+                                    /**
+                                     * Specify whether error information is
+                                     * to be written as cell data or node
+                                     * data.
+                                     */
+    bool                write_error_as_cell_data;
+
+                                    /**
+                                     * Flag determining whether we shall
+                                     * write out the data of the different
+                                     * time steps stacked together for a
+                                     * whole sweep, and into one file for
+                                     * the whole sweep.
+                                     */
+    bool                write_stacked_data;
+
+                                    /**
+                                     * Same as #write_steps_interval#, but
+                                     * for stacked output.
+                                     */
+    unsigned int        write_stacked_interval;
+    
+                                    /**
+                                     * Write statistics for the error
+                                     * distribution in each sweep.
+                                     */
+    bool                produce_error_statistics;
+
+                                    /**
+                                     * Number of histogram intervals for
+                                     * the error statistics.
+                                     */
+    unsigned int        error_statistic_intervals;
+
+                                    /**
+                                     * How to break the intervals: linear
+                                     * or logarithmic.
+                                     */
+    string              error_statistics_scaling;
+    
+                                    /**
+                                     * Names of the finite element classes to
+                                     * be used for the primal and dual problems.
+                                     */
+    string              primal_fe, dual_fe;
+    
+                                    /**
+                                     * Strategy for mesh refinement.
+                                     */
+    enum { energy_estimator, dual_estimator } refinement_strategy;
+
+                                    /**
+                                     * Try to adjust the mesh to the error
+                                     * functional as well as to the dual
+                                     * solution. For the dual solution, an
+                                     * energy estimator is used.
+                                     */
+    bool adapt_mesh_to_dual_solution;
+
+                                    /**
+                                     * When adapting the mesh for the dual
+                                     * problem as well, we have to weigh
+                                     * the error indicator for the dual
+                                     * problem with that for the primal
+                                     * one. This is the factor.
+                                     */
+    double primal_to_dual_weight;
+
+                                    /**
+                                     * Number of sweeps at the beginning
+                                     * where the energy estimator is to
+                                     * be used rather than the dual
+                                     * estimator.
+                                     */
+    unsigned int initial_energy_estimator_sweeps;
+
+                                    /**
+                                     * How many adaptive cycles of solving
+                                     * the whole problem shall be made.
+                                     */
+    unsigned int        number_of_sweeps;
+
+                                    /**
+                                     * List of operations which shall be
+                                     * done on each time step after finishing
+                                     * a sweep.
+                                     */
+    list<EvaluationBase<dim>*> eval_list;
+
+                                    /**
+                                     * Symbolic name of the boundary conditions
+                                     * (additionally to the boundary functions
+                                     * themselves), which may be used by some
+                                     * of the evaluations and other functionals
+                                     * in the program.
+                                     */
+    BoundaryConditions boundary_conditions;
+
+                                    /**
+                                     * Exception.
+                                     */
+    DeclException1 (ExcParameterNotInList,
+                   string,
+                   << "The given parameter <" << arg1 << "> is not "
+                   << "recognized to be a valid one.");
+    
+  private:
+
+                                    /**
+                                     * Undefined copy constructor.
+                                     */
+    WaveParameters (const 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
+                                     * values could be different from
+                                     * dimension to dimension.
+                                     */
+    static const string initial_value_names;
+
+                                    /**
+                                     * Names of coefficient functions. The
+                                     * same applies as for
+                                     * #initial_value_names#.
+                                     */
+    static const string coefficient_names;
+
+                                    /**
+                                     * Names of boundary value functions. The
+                                     * same applies as for
+                                     * #initial_value_names#.
+                                     */
+    static const string boundary_function_names;
+
+                                    /**
+                                     * Names of error functionals. The
+                                     * same applies as for
+                                     * #initial_value_names#.
+                                     */
+    static const string dual_functional_names;
+
+    
+                                    /**
+                                     * Set the initial function pointers
+                                     * depending on the given names.
+                                     */
+    void set_initial_functions (const string &u_name,
+                               const string &v_name);
+
+                                    /**
+                                     * Set the coefficient functions.
+                                     */
+    void set_coefficient_functions (const string &name);
+
+                                    /**
+                                     * Set the boundary values.
+                                     */
+    void set_boundary_functions (const string &name);
+
+                                    /**
+                                     * Make a list of evaluations to be
+                                     * performed after each sweep.
+                                     */
+    void make_eval_list (const string &names);
+
+                                    /**
+                                     * Set the dual functional after
+                                     * which the dual solution will be
+                                     * computed.
+                                     */
+    void set_dual_functional (const string &name);
+
+                                    /**
+                                     * Create the coarse grid for
+                                     * this run.
+                                     */
+    void make_coarse_grid (const string &name);
+};
+
+
+
+#include <numerics/time-dependent.h>
+
+template <int dim> class WaveParameters;
+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
+ * error estimates and doing the refinement of grids.
+ *
+ * @author Wolfgang Bangerth, 1999
+ */
+template <int dim>
+class TimestepManager : public TimeDependent {
+  public:
+                                    /**
+                                     * Constructor.
+                                     */
+    TimestepManager (const WaveParameters<dim> &parameters);
+
+                                    /**
+                                     * Run a complete sweep, consisting
+                                     * of the solution of the primal problem,
+                                     * the solution of the dual problem if
+                                     * requested, computation of error
+                                     * quantities and refinement.
+                                     */
+    void run_sweep (const unsigned int sweep_no);
+
+                                    /**
+                                     * Exception
+                                     */
+    DeclException0 (ExcIO);
+    
+  private:
+                                    /**
+                                     * Reference to the global parameters
+                                     * object.
+                                     */
+    const WaveParameters<dim> &parameters;
+
+                                    /**
+                                     * Refine the grids, or, better, find
+                                     * out which cells need to be refined.
+                                     * Refinement is done by a following
+                                     * sweep.
+                                     */
+    void refine_grids ();
+
+                                    /**
+                                     * Write some statistics to a file.
+                                     */
+    void write_statistics (const SweepInfo &sweep_info) const;
+
+                                    /**
+                                     * Write the data stacked together
+                                     * from all the time steps into
+                                     * one single file.
+                                     */
+    void write_stacked_data (DataOutStack<dim> &data_out_stack) const;
+};
+
+
+
+
+
+/**
+ * Top-level class providing the set up of a simulation. The
+ * class provides an interface suitable to the #MultipleParameterLoop#
+ * class to do several simulations in a row, stores global simulation
+ * parameters, and so on.
+ *
+ * @author Wolfgang Bangerth, 1998, 1999
+ */
+template <int dim>
+class WaveProblem :  public MultipleParameterLoop::UserClass {
+  public:
+
+                                    /**
+                                     * Constructor.
+                                     */
+    WaveProblem ();
+
+                                    /**
+                                     * Destructor.
+                                     */
+    virtual ~WaveProblem ();
+
+                                    /**
+                                     * Put this object into a clean state.
+                                     * This function is called at the
+                                     * beginning of each loop by the
+                                     * #MultipleParameterHandler#.
+                                     */
+    virtual void create_new (const unsigned int run_no);
+
+                                    /**
+                                     * Make the list of parameters known
+                                     * to the parameter handler. This
+                                     * function only delegates its work
+                                     * to the #parameters# sub-object.
+                                     */
+    virtual void declare_parameters (ParameterHandler &prm);
+
+                                    /**
+                                     * Parse the list of parameters given
+                                     * by the parameter handler. This
+                                     * function only delegates its work
+                                     * to the #parameters# sub-object.
+                                     */
+    virtual void parse_parameters (ParameterHandler &prm);
+
+                                    /**
+                                     * Run a complete simulation.
+                                     */
+    virtual void run (ParameterHandler &prm);
+
+  private:
+                                    /**
+                                     * Object holding the parameters of
+                                     * the present simulation.
+                                     */
+    WaveParameters<dim> parameters;
+};
+
+
+
+
+
+/* $Id$ */
+
+
+#include <lac/vector.h>
+#include <lac/sparsematrix.h>
+#include <grid/dof.h>
+#include <grid/dof_accessor.h>
+#include <grid/tria_iterator.h>
+#include <grid/dof_constraints.h>
+#include <fe/fe.h>
+#include <fe/fe_values.h>
+#include <base/quadrature.h>
+#include <base/function.h>
+
+#include <cmath>
+
+
+
+/*------------------------ DualFunctional --------------------------------*/
+
+template <int dim>
+DualFunctional<dim>::DualFunctional (const bool use_primal_problem,
+                                    const bool use_primal_problem_at_endtime) :
+               use_primal_problem (use_primal_problem),
+               use_primal_problem_at_endtime (use_primal_problem_at_endtime),
+               tria (0),
+               boundary (0),
+               dof (0),
+               fe(0),
+               quadrature(0),
+               quadrature_face(0),
+               density(0),
+               stiffness(0),
+               primal_dof(0),
+               primal_fe(0),
+               primal_quadrature(0),
+               primal_quadrature_face(0),
+               u(0),
+               v(0),
+               time(0),
+               time_step(0),
+               step_no(0)
+{};
+
+
+
+template <int dim>
+void DualFunctional<dim>::compute_functionals (Vector<double> &j1,
+                                              Vector<double> &j2) {
+  j1.reinit (dof->n_dofs());
+  j2.reinit (dof->n_dofs());
+};
+
+
+
+template <int dim>
+void DualFunctional<dim>::compute_endtime_vectors (Vector<double> &final_u_bar,
+                                                  Vector<double> &final_v_bar) {
+  final_u_bar.reinit (dof->n_dofs());
+  final_v_bar.reinit (dof->n_dofs());
+};
+
+
+
+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 ||
+         (use_primal_problem_at_endtime &&
+          (primal_problem.parameters.end_time==primal_problem.time)),
+         ExcPrimalProblemNotRequested());
+
+  primal_dof             = primal_problem.dof_handler;
+  primal_fe              = &primal_problem.fe;
+  primal_quadrature      = &primal_problem.quadrature;
+  primal_quadrature_face = &primal_problem.quadrature_face;
+
+  u = &primal_problem.u;
+  v = &primal_problem.v;
+};
+
+
+
+template <int dim>
+void DualFunctional<dim>::reset (const TimeStep_Dual<dim> &dual_problem) {
+  tria            = dual_problem.tria;
+  boundary        = dual_problem.parameters.boundary;
+  dof             = dual_problem.dof_handler;
+  fe              = &dual_problem.fe;
+  quadrature      = &dual_problem.quadrature;
+  quadrature_face = &dual_problem.quadrature_face;
+  density         = dual_problem.parameters.density;
+  stiffness       = dual_problem.parameters.stiffness;
+  time            = dual_problem.time;
+  time_step       = (dual_problem.next_timestep == 0 ?
+                    0 :
+                    dual_problem.get_forward_timestep());
+  step_no         = dual_problem.timestep_no;
+};
+
+
+
+
+
+
+
+
+
+/* ----------------------- EndEnergy ------------------------------*/
+
+
+template <int dim>
+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,
+                                     Vector<double> &final_v_bar) const {
+  const double y_offset = 300000000;
+  const double n_q_points = quadrature->n_quadrature_points;
+  const unsigned int total_dofs = fe->total_dofs;
+  
+  final_u_bar.reinit (dof->n_dofs());
+  final_v_bar.reinit (dof->n_dofs());
+
+  DoFHandler<dim>::active_cell_iterator cell, primal_cell, endc;
+  cell = dof->begin_active ();
+  endc = dof->end ();
+  primal_cell = primal_dof->begin_active();
+
+  FEValues<dim> fe_values (*fe, *quadrature,
+                          UpdateFlags(update_gradients      |
+                                      update_JxW_values     |
+                                      update_q_points));
+  FEValues<dim> fe_values_primal (*primal_fe, *quadrature,
+                                 update_gradients);
+  
+  FullMatrix<double>  cell_matrix (total_dofs, total_dofs);
+
+  vector<Tensor<1,dim> > local_u_grad (n_q_points);
+  vector<double>         local_v (n_q_points);
+  
+  vector<double> density_values(quadrature->n_quadrature_points);
+  vector<double> stiffness_values(quadrature->n_quadrature_points);
+
+  vector<int> cell_dof_indices (total_dofs);
+
+  for (; cell!=endc; ++cell, ++primal_cell)
+    {
+                                      // only consider cells in the specified
+                                      // domain
+      switch (pod)
+       {
+         case low_atmosphere:
+               if (cell->center()(1) >= y_offset)
+                 continue;
+               break;
+         case high_atmosphere:
+               if (cell->center()(1) < y_offset)
+                 continue;
+               break;
+       };
+      
+      
+      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);
+
+                                      // get the coefficients at the
+                                      // quadrature points
+      density->value_list (fe_values.get_quadrature_points(),
+                          density_values);
+      stiffness->value_list (fe_values.get_quadrature_points(),
+                            stiffness_values);
+      
+                                      // set up a vector of the gradients
+                                      // of the finite element basis
+                                      // functions on this face at the
+                                      // quadrature points
+      const vector<vector<Tensor<1,dim> > > &shape_grads = fe_values.get_shape_grads ();
+      const FullMatrix<double>            &shape_values = fe_values.get_shape_values ();
+      const vector<double>      &JxW_values (fe_values.get_JxW_values());
+      
+      vector<double> local_functional1 (total_dofs, 0);
+      vector<double> local_functional2 (total_dofs, 0);
+      for (unsigned int shape_func=0; shape_func<total_dofs; ++shape_func)
+       for (unsigned int point=0; point<n_q_points; ++point) 
+         {
+           local_functional1[shape_func] += local_u_grad[point] *
+                                            shape_grads[shape_func][point] *
+                                            stiffness_values[point] *
+                                            JxW_values[point];
+           local_functional2[shape_func] += local_v[point] *
+                                            shape_values(shape_func,point) *
+                                            density_values[point] *
+                                            JxW_values[point];
+         };
+
+      cell->get_dof_indices (cell_dof_indices);
+      for (unsigned int shape_func=0; shape_func<total_dofs; ++shape_func)
+       {
+         final_u_bar(cell_dof_indices[shape_func]) += local_functional1[shape_func];
+         final_v_bar(cell_dof_indices[shape_func]) += local_functional2[shape_func];
+       };
+    };
+};
+
+
+
+
+
+/*------------------------ IntegrateValueAtOrigin --------------------------------*/
+
+
+template <int dim>
+void IntegratedValueAtOrigin<dim>::compute_functionals (Vector<double> &j1,
+                                                       Vector<double> &j2) {
+  j1.reinit (dof->n_dofs());
+  j2.reinit (dof->n_dofs());
+
+  DoFHandler<dim>::active_cell_iterator cell = dof->begin_active(),
+                                       endc = dof->end();
+
+  Point<dim> origin;
+
+  bool origin_found = false;
+  for (; (cell!=endc) && !origin_found; ++cell) 
+    {
+      for (unsigned int vertex=0; vertex<GeometryInfo<dim>::vertices_per_cell; ++vertex)
+       if (cell->vertex(vertex) == origin) 
+         {
+           j1(cell->vertex_dof_index(vertex,0)) = 1;
+           origin_found = true;
+         };
+    };
+
+  Assert (origin_found, ExcVertexNotFound());
+};
+
+
+
+
+
+
+/*------------------------ SeismicSignal --------------------------------*/
+
+
+template <>
+void SeismicSignal<1>::compute_functionals (Vector<double> &,
+                                           Vector<double> &)
+{
+  Assert (false, ExcNotImplemented());
+};
+
+
+
+template <int dim>
+void SeismicSignal<dim>::compute_functionals (Vector<double> &j1,
+                                             Vector<double> &j2) {
+  const double y_offset = 1.0;
+  const unsigned int n_q_points = quadrature_face->n_quadrature_points;
+  const unsigned int total_dofs = fe->total_dofs;
+  
+  j1.reinit (dof->n_dofs());
+  j2.reinit (dof->n_dofs());
+
+  DoFHandler<dim>::active_cell_iterator cell, endc;
+  DoFHandler<dim>::face_iterator        face;
+  cell = dof->begin_active();
+  endc = dof->end();
+
+  vector<int> cell_dof_indices (total_dofs);
+
+  FEFaceValues<dim> fe_face_values (*fe, *quadrature_face,
+                                   UpdateFlags(update_JxW_values     |
+                                               update_q_points));
+  
+  for (; cell!=endc; ++cell)
+    for (unsigned int face_no=0; face_no<GeometryInfo<dim>::faces_per_cell;
+        ++face_no)
+      if (face=cell->face(face_no),
+         (face->vertex(0)(1) == y_offset) &&
+         (face->vertex(1)(1) == y_offset))
+                                        // this is one of the faces we
+                                        // are interested in, i.e. which
+                                        // lie on the interesting line
+       {
+         fe_face_values.reinit (cell, face_no);
+         const FullMatrix<double>            &shape_values = fe_face_values.
+                                                   get_shape_values ();
+         const vector<double>      &JxW_values (fe_face_values.
+                                                get_JxW_values());
+         const vector<Point<dim> > &q_points (fe_face_values.get_quadrature_points());
+
+                                          // now compute the local integral
+                                          // \int w(x,t) phi_i(x,y,t) ds
+                                          // through this line for each
+                                          // of the basis functions
+         vector<double> local_integral (total_dofs, 0);
+         for (unsigned int shape_func=0; shape_func<total_dofs; ++shape_func)
+           for (unsigned int point=0; point<n_q_points; ++point)
+             local_integral[shape_func] += shape_values(shape_func,point) *
+                                           (EvaluateSeismicSignal<dim>
+                                            ::weight(q_points[point], time)) *
+                                           JxW_values[point];
+
+         cell->get_dof_indices (cell_dof_indices);
+         for (unsigned int shape_func=0; shape_func<total_dofs; ++shape_func)
+           j1(cell_dof_indices[shape_func]) += local_integral[shape_func];
+       };
+};
+
+
+
+
+/*------------------------ EarthSurface --------------------------------*/
+
+
+template <>
+void EarthSurface<1>::compute_functionals (Vector<double> &,
+                                          Vector<double> &)
+{
+  Assert (false, ExcNotImplemented());
+};
+
+
+
+template <int dim>
+void EarthSurface<dim>::compute_functionals (Vector<double> &j1,
+                                            Vector<double> &j2) {
+  const unsigned int face_dofs = fe->dofs_per_face;
+  
+  j1.reinit (dof->n_dofs());
+  j2.reinit (dof->n_dofs());
+
+  DoFHandler<dim>::active_cell_iterator cell, endc;
+  DoFHandler<dim>::face_iterator        face;
+  cell = dof->begin_active();
+  endc = dof->end();
+
+  vector<int> face_dof_indices (face_dofs);
+
+  for (; cell!=endc; ++cell)
+    for (unsigned int face_no=0; face_no<GeometryInfo<dim>::faces_per_cell;
+        ++face_no)
+      if (face=cell->face(face_no),
+         face->at_boundary())
+                                        // this is one of the faces we
+                                        // may be interested in
+       {
+                                          // find out whether it is part of
+                                          // the boundary portions we are
+                                          // looking for
+         const double x = face->center()(0),
+                      y = face->center()(1);
+
+         if (!  (((x>0) && (fabs(y) < 500)) ||
+                 ((x>0) && (y<0) && (fabs(x+y)<500))))
+           continue;
+
+                                          // doubtful for higher
+                                          // order elements!
+         const double h = face->measure ();
+         
+         face->get_dof_indices (face_dof_indices);
+         for (unsigned int shape_func=0; shape_func<face_dofs; ++shape_func)
+                                            // also doubtful!
+           j1(face_dof_indices[shape_func]) = h;
+       };
+};
+
+
+
+
+/*------------------------ SplitSignal --------------------------------*/
+
+
+template <>
+void SplitSignal<1>::compute_functionals (Vector<double> &,
+                                         Vector<double> &)
+{
+  Assert (false, ExcInternalError());
+};
+
+
+
+
+template <int dim>
+void SplitSignal<dim>::compute_functionals (Vector<double> &j1,
+                                           Vector<double> &j2) {
+  const unsigned int total_dofs = fe->total_dofs;
+  const unsigned int n_q_points = quadrature_face->n_quadrature_points;
+  
+  j1.reinit (dof->n_dofs());
+  j2.reinit (dof->n_dofs());
+
+  if ((time<=1.6) || (time>1.8))
+    return;
+  
+  DoFHandler<dim>::active_cell_iterator cell, endc;
+  DoFHandler<dim>::face_iterator        face;
+  cell = dof->begin_active();
+  endc = dof->end();
+
+  vector<int> dof_indices (fe->total_dofs);
+  FEFaceValues<dim> fe_face_values (*fe, *quadrature_face, update_JxW_values);
+  
+  for (; cell!=endc; ++cell)
+    for (unsigned int face_no=0; face_no<GeometryInfo<dim>::faces_per_cell;
+        ++face_no)
+      if (cell->face(face_no)->center()(0) == 1.5)
+                                        // this is one of the faces we
+                                        // may be interested in
+       {
+         face=cell->face(face_no);
+                                          // check whether it really is
+         bool wrong_face = face->center()(1) > 0.0625;
+         if (!wrong_face)
+           for (unsigned int v=0; v<GeometryInfo<dim>::vertices_per_face; ++v)
+             if (face->vertex(v)(0) != 1.5)
+               {
+                 wrong_face=true;
+                 break;
+               };
+         if (wrong_face)
+           continue;
+
+         fe_face_values.reinit (cell, face_no);
+         const FullMatrix<double> &shape_values = fe_face_values.get_shape_values ();
+         const vector<double>     &JxW_values   = fe_face_values.get_JxW_values();
+         cell->get_dof_indices (dof_indices);
+
+         for (unsigned int i=0; i<total_dofs; ++i)
+           {
+             double sum=0;
+             for (unsigned int j=0; j<n_q_points; ++j)
+               sum += shape_values(i,j)*JxW_values[j];
+
+                                              // since we integrate over each face
+                                              // twice, add only half of it
+             j1(dof_indices[i]) += sum * time_step / 2;
+           };
+       };
+};
+
+
+
+
+/* ------------------------------ Split line 1d case ----------------------------- */
+
+template <int dim>
+void SplitLine<dim>::compute_endtime_vectors (Vector<double> &,
+                                             Vector<double> &) {
+  Assert (false, ExcNotImplemented ());
+};
+
+
+#if 2 == 1
+
+template <>
+void SplitLine<1>::compute_endtime_vectors (Vector<double> &final_u_bar,
+                                           Vector<double> &final_v_bar) {
+  const unsigned int dim = 1;
+
+  const double n_q_points = quadrature->n_quadrature_points;
+  const unsigned int total_dofs = fe->total_dofs;
+
+  final_u_bar.reinit (dof->n_dofs());
+  final_v_bar.reinit (dof->n_dofs());
+
+  DoFHandler<dim>::active_cell_iterator cell = dof->begin_active (),
+                                       endc = dof->end ();
+
+  FEValues<dim> fe_values (*fe, *quadrature, update_JxW_values);
+  vector<int> cell_dof_indices (total_dofs);
+
+  for (; cell!=endc; ++cell)
+    {
+      if ((cell->vertex(0)(0) < -0.5) ||
+         (cell->vertex(1)(0)  > 0.5))
+       continue;
+      
+      fe_values.reinit (cell);
+
+      const FullMatrix<double>  &shape_values = fe_values.get_shape_values ();
+      const vector<double>      &JxW_values (fe_values.get_JxW_values());
+
+      vector<double> local_functional (total_dofs, 0);
+      for (unsigned int shape_func=0; shape_func<total_dofs; ++shape_func)
+       for (unsigned int point=0; point<n_q_points; ++point) 
+         local_functional[shape_func] += shape_values(shape_func,point) *
+                                          JxW_values[point];
+
+      cell->get_dof_indices (cell_dof_indices);
+      for (unsigned int shape_func=0; shape_func<total_dofs; ++shape_func)
+       final_u_bar(cell_dof_indices[shape_func]) += local_functional[shape_func];
+    };
+};
+
+#endif
+
+
+
+/*------------------------ OneBranch1d --------------------------------*/
+
+
+
+template <int dim>
+void OneBranch1d<dim>::compute_functionals (Vector<double> &j1,
+                                           Vector<double> &j2) {
+  const unsigned int total_dofs = fe->total_dofs;
+  const unsigned int n_q_points = quadrature->n_quadrature_points;
+  
+  j1.reinit (dof->n_dofs());
+  j2.reinit (dof->n_dofs());
+  
+                                  // take the time step right before 2.5
+  if ((time<=2.5-time_step) || (time>2.5))
+    return;
+
+  DoFHandler<dim>::active_cell_iterator cell, endc;
+  cell = dof->begin_active();
+  endc = dof->end();
+
+  vector<int> dof_indices (fe->total_dofs);
+  FEValues<dim> fe_values (*fe, *quadrature, update_JxW_values);
+  
+  for (; cell!=endc; ++cell)
+    if ((cell->center()(0) > -0.6) &&
+       (cell->center()(0) < -0.4))
+      {
+       fe_values.reinit (cell);
+       const FullMatrix<double>  &shape_values = fe_values.get_shape_values ();
+       const vector<double>      &JxW_values   = fe_values.get_JxW_values();
+       cell->get_dof_indices (dof_indices);
+       
+       for (unsigned int i=0; i<total_dofs; ++i)
+         {
+           double sum=0;
+           for (unsigned int j=0; j<n_q_points; ++j)
+             sum += shape_values(i,j)
+                    *JxW_values[j];
+           
+                                            // since we integrate over each face
+                                            // twice, add only half of it
+           j1(dof_indices[i]) += sum;
+         };
+      };
+};
+
+
+
+/*------------------------ SecondCrossing --------------------------------*/
+
+
+
+template <int dim>
+void SecondCrossing<dim>::compute_functionals (Vector<double> &j1,
+                                              Vector<double> &j2) {
+  const unsigned int total_dofs = fe->total_dofs;
+  const unsigned int n_q_points = quadrature->n_quadrature_points;
+  
+  j1.reinit (dof->n_dofs());
+  j2.reinit (dof->n_dofs());
+  
+                                  // take the time step right before 2.4
+  if ((time<=2.4-time_step) || (time>2.4))
+    return;
+
+  DoFHandler<dim>::active_cell_iterator cell, endc;
+  cell = dof->begin_active();
+  endc = dof->end();
+
+  vector<int> dof_indices (fe->total_dofs);
+  FEValues<dim> fe_values (*fe, *quadrature, update_JxW_values);
+  
+  for (; cell!=endc; ++cell)
+    if ((cell->center()(0) > -0.03) &&
+       (cell->center()(0) < 0.03))
+      {
+       fe_values.reinit (cell);
+       const FullMatrix<double>  &shape_values = fe_values.get_shape_values ();
+       const vector<double>      &JxW_values   = fe_values.get_JxW_values();
+       cell->get_dof_indices (dof_indices);
+       
+       for (unsigned int i=0; i<total_dofs; ++i)
+         {
+           double sum=0;
+           for (unsigned int j=0; j<n_q_points; ++j)
+             sum += shape_values(i,j)
+                    *JxW_values[j];
+           
+           j1(dof_indices[i]) += sum / time_step;
+         };
+      };
+};
+
+
+
+/*------------------------ HuyghensWave --------------------------------*/
+
+
+
+template <int dim>
+void HuyghensWave<dim>::compute_functionals (Vector<double> &j1,
+                                            Vector<double> &j2) {
+  j1.reinit (dof->n_dofs());
+  j2.reinit (dof->n_dofs());
+  
+  if ((time < 0.5) || (time > 0.69)) 
+    return;
+  
+  Point<dim> p;
+  p(0) = 0.75;
+  const Point<dim> evaluation_point (p);
+
+  const DoFHandler<dim>::cell_iterator endc = dof->end(3);
+  bool point_found = false;
+  for (DoFHandler<dim>::cell_iterator cell=dof->begin(3);
+       (cell!=endc) && !point_found; ++cell)
+    for (unsigned int vertex=0; vertex<GeometryInfo<dim>::vertices_per_cell; ++vertex) 
+      if (cell->vertex(vertex) == evaluation_point)
+       {
+                                          // step down the list of children
+                                          // until we find a terminal cell
+         DoFHandler<dim>::cell_iterator terminal_cell = cell;
+         while (terminal_cell->has_children())
+           terminal_cell = terminal_cell->child(vertex);
+         
+                                          // now terminal cell is the right one
+         j1(cell->vertex_dof_index(vertex,0)) = time*time_step;
+         point_found = true;
+
+         break;
+       };
+  
+  AssertThrow (point_found, ExcInternalError());
+};
+
+
+
+// explicit specializations
+
+template class DualFunctional<2>;
+template class EndEnergy<2>;
+template class IntegratedValueAtOrigin<2>;
+template class SeismicSignal<2>;
+template class EarthSurface<2>;
+template class SplitSignal<2>;
+template class SplitLine<2>;
+template class OneBranch1d<2>;
+template class SecondCrossing<2>;
+template class HuyghensWave<2>;
+/*  $Id$ */
+
+
+#include <grid/tria.h>
+#include <grid/dof.h>
+#include <grid/dof_accessor.h>
+#include <grid/tria_iterator.h>
+#include <grid/dof_constraints.h>
+#include <grid/geometry_info.h>
+#include <fe/fe.h>
+#include <fe/fe_values.h>
+#include <base/quadrature.h>
+#include <base/function.h>
+#include <lac/vector.h>
+#include <lac/sparsematrix.h>
+
+#include <cmath>
+#include <fstream>
+
+
+
+/*--------------------------- EvaluationBase --------------------------*/
+
+template <int dim>
+EvaluationBase<dim>::EvaluationBase () :
+               u (0),
+               v (0),
+               tria (0),
+               boundary (0),
+               dof (0),
+               fe (0),
+               quadrature (0),
+               quadrature_face (0),
+               density (0),
+               stiffness (0),
+               time (0),
+               time_step (0),
+               step_no (0)
+{};
+
+
+template <int dim>
+void EvaluationBase<dim>::reset_timelevel (const TimeStep_Primal<dim> &target) {
+  u               = &target.u;
+  v               = &target.v;
+  tria            = target.tria;
+  boundary        = target.parameters.boundary;
+  dof             = target.dof_handler;
+  fe              = &target.fe;
+  quadrature      = &target.quadrature;
+  quadrature_face = &target.quadrature_face;
+  density         = target.parameters.density;
+  stiffness       = target.parameters.stiffness;
+  time            = target.time;
+  time_step       = (target.timestep_no == 0 ?
+                    0 :
+                    target.get_backward_timestep());
+  step_no         = target.timestep_no;
+
+  base_file_name  = target.parameters.output_directory +
+                   "sweep"+int_to_string(target.sweep_no, 2) + "/evaluation/" +
+                   int_to_string(step_no,4);
+};
+
+
+
+template <int dim>
+void EvaluationBase<dim>::reset () {};
+
+
+
+template <int dim>
+void EvaluationBase<dim>::print_final_result (ostream &) {};
+
+
+template <int dim>
+double EvaluationBase<dim>::get_final_result () {
+  return 0;
+};
+
+
+
+
+
+
+/*--------------------------- EvaluateEnergyContent ----------------------*/
+
+template <int dim>
+EvaluateEnergyContent<dim>::EvaluateEnergyContent () :
+               old_energy (0),
+               integrated_outflux (0) {};
+
+
+template <int dim>
+void EvaluateEnergyContent<dim>::reset () {
+  old_energy         = 0;
+  integrated_outflux = 0;
+};
+
+
+
+template <int dim>
+double EvaluateEnergyContent<dim>::compute_energy (const PartOfDomain pod) const {
+  const double y_offset = 300000000;
+
+  DoFHandler<dim>::active_cell_iterator cell, endc;
+  cell = dof->begin_active ();
+  endc = dof->end ();
+
+  FEValues<dim> fe_values (*fe, *quadrature,
+                          UpdateFlags(update_gradients      |
+                                      update_JxW_values     |
+                                      update_q_points));
+  FullMatrix<double>  cell_matrix (fe->total_dofs, fe->total_dofs);
+  Vector<double>   local_u (fe->total_dofs);
+  Vector<double>   local_v (fe->total_dofs);
+  
+  vector<double> density_values(quadrature->n_quadrature_points);
+  vector<double> stiffness_values(quadrature->n_quadrature_points);
+
+  double total_energy = 0;
+  
+  for (; cell!=endc; ++cell)
+    {
+                                      // only consider cells in the specified
+                                      // domain
+      switch (pod)
+       {
+         case low_atmosphere:
+               if (cell->center()(1) >= y_offset)
+                 continue;
+               break;
+         case high_atmosphere:
+               if (cell->center()(1) < y_offset)
+                 continue;
+               break;
+       };
+      
+      
+      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 ();
+
+      cell->get_dof_values (*u, local_u);
+      cell->get_dof_values (*v, local_v);
+
+                                      // compute mass matrix
+      cell_matrix.clear ();
+      density->value_list (fe_values.get_quadrature_points(),
+                          density_values);
+      for (unsigned int point=0; point<fe_values.n_quadrature_points; ++point)
+       for (unsigned int i=0; i<fe->total_dofs; ++i) 
+         for (unsigned int j=0; j<fe->total_dofs; ++j)
+           cell_matrix(i,j) += (values(i,point) *
+                                values(j,point)) *
+                               weights[point] *
+                               density_values[point];
+
+      total_energy += 1./2. * cell_matrix.matrix_norm (local_v);
+
+                                      // now for the part with the laplace
+                                      // matrix
+      cell_matrix.clear ();
+      stiffness->value_list (fe_values.get_quadrature_points(),
+                            stiffness_values);
+      for (unsigned int point=0; point<fe_values.n_quadrature_points; ++point)
+       for (unsigned int i=0; i<fe->total_dofs; ++i) 
+         for (unsigned int j=0; j<fe->total_dofs; ++j)
+           cell_matrix(i,j) += (gradients[i][point] *
+                                gradients[j][point]) *
+                               weights[point] *
+                               stiffness_values[point];
+      total_energy += 1./2. * cell_matrix.matrix_norm (local_u);
+    };
+
+  return total_energy;
+};
+
+
+
+
+/* ---------------------------- EvaluateIntegratedValueAtOrigin ------------------- */
+
+
+template <int dim>
+void EvaluateIntegratedValueAtOrigin<dim>::print_final_result (ostream &out) {
+  out << "    Integrated value of u at origin: "
+      << integrated_value << endl;
+};
+
+
+
+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(),
+                                       endc = dof->end();
+
+  double     value_at_origin = 0;
+  Point<dim> origin;
+
+  bool origin_found = false;
+  for (; (cell!=endc) && !origin_found; ++cell) 
+    {
+      for (unsigned int vertex=0; vertex<GeometryInfo<dim>::vertices_per_cell; ++vertex)
+       if (cell->vertex(vertex) == origin) 
+         {
+           value_at_origin = (*u)(cell->vertex_dof_index(vertex,0));
+           origin_found = true;
+         };
+    };
+
+  Assert (origin_found, ExcVertexNotFound());
+
+  if (time > 0)
+    integrated_value += value_at_origin * time_step;
+      
+  return value_at_origin;
+};
+
+
+
+
+
+
+/*------------------------- EvaluateSeismicSignal --------------------------*/
+
+
+template <int dim>
+void EvaluateSeismicSignal<dim>::print_final_result (ostream &out) {
+  out << "    Integrated seismic signal: " << result << endl;
+};
+
+
+
+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 ()
+{
+  Assert (false, ExcNotImplemented());
+  return 0;
+};
+
+
+
+template <int dim>
+double EvaluateSeismicSignal<dim>::evaluate () {
+  const unsigned int n_q_points = quadrature_face->n_quadrature_points;
+
+  ofstream out((base_file_name + ".seismic").c_str());
+  AssertThrow (out, ExcIO());
+  
+  DoFHandler<dim>::active_cell_iterator cell = dof->begin_active(),
+                                       endc = dof->end();
+  double u_integrated=0;
+  FEFaceValues<dim> face_values (*fe, *quadrature_face,
+                                UpdateFlags(update_JxW_values|update_q_points));
+  vector<double>    face_u (fe->dofs_per_face);
+  
+  for (; cell!=endc; ++cell)
+    for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell; ++face)
+                                      // check if face is at top boundary
+      if (cell->face(face)->center()(1) == 1.0)
+       {
+         face_values.reinit (cell, face);
+         face_values.get_function_values (*u, face_u);
+         const vector<double>      &JxW_values (face_values.get_JxW_values());
+         const vector<Point<dim> > &q_points   (face_values.get_quadrature_points());
+         
+         double local_integral = 0;
+         for (unsigned int point=0; point<n_q_points; ++point)
+           local_integral += face_u[point] *
+                             weight (q_points[point], time) *
+                             JxW_values[point];
+         u_integrated += local_integral;
+
+                                          // output the t and x coordinate
+         out << time
+             << ' '
+             << cell->face(face)->vertex(0)(0)
+             << "  "
+             << (*u)(cell->face(face)->vertex_dof_index(0,0))
+             << endl
+             << time
+             << ' '
+             << cell->face(face)->vertex(1)(0)
+             << "  "
+             << (*u)(cell->face(face)->vertex_dof_index(1,0))
+             << endl
+             << endl;
+       };
+  AssertThrow (out, ExcIO());
+  out.close ();
+  
+  if (time!=0)
+    result += u_integrated*time_step;
+  
+  return u_integrated;
+};
+
+
+
+
+/*------------------------- EvaluateSplitSignal --------------------------*/
+
+
+template <int dim>
+void EvaluateSplitSignal<dim>::print_final_result (ostream &out) {
+  out << "    Integrated split signal: " << result << endl;
+};
+
+
+
+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 ()
+{
+  Assert (false, ExcNotImplemented());
+  return 0;
+};
+
+
+
+template <int dim>
+double EvaluateSplitSignal<dim>::evaluate () {
+  if ((time<=1.6) || (time>1.8))
+    return 0;
+
+  const unsigned int n_q_points = quadrature_face->n_quadrature_points;
+  DoFHandler<dim>::active_cell_iterator cell = dof->begin_active(),
+                                       endc = dof->end();
+  double u_integrated=0;
+  FEFaceValues<dim> face_values (*fe, *quadrature_face, update_JxW_values);
+  vector<double>    face_u (fe->dofs_per_face);
+  
+  for (; cell!=endc; ++cell)
+    for (unsigned int face_no=0; face_no<GeometryInfo<dim>::faces_per_cell; ++face_no)
+                                        // this is one of the faces we
+                                        // may be interested in
+      if (cell->face(face_no)->center()(0) == 1.5)
+       {
+         DoFHandler<dim>::face_iterator face=cell->face(face_no);
+                                          // check whether it really is
+         bool wrong_face = face->center()(1) > 0.0625;
+         if (!wrong_face)
+           for (unsigned int v=0; v<GeometryInfo<dim>::vertices_per_face; ++v)
+             if (face->vertex(v)(0) != 1.5)
+               {
+                 wrong_face=true;
+                 break;
+               };
+         if (wrong_face)
+           continue;
+
+         face_values.reinit (cell, face_no);
+         face_values.get_function_values (*u, face_u);
+         const vector<double>      &JxW_values (face_values.get_JxW_values());
+         
+         double local_integral = 0;
+         for (unsigned int point=0; point<n_q_points; ++point)
+           local_integral += face_u[point] *
+                             JxW_values[point];
+         u_integrated += local_integral;
+       };
+
+                                  // note that we integrate over each line twice, so
+                                  // we divide the result by two
+  if (time!=0)
+    result += u_integrated*time_step / 2;
+  
+  return u_integrated;
+};
+
+
+
+
+/*------------------------- EvaluateOneBranch1d --------------------------*/
+
+
+template <int dim>
+void EvaluateOneBranch1d<dim>::print_final_result (ostream &out) {
+  out << "    One branch integrated: " << result << endl;
+};
+
+
+
+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 ()
+{
+  Assert (false, ExcNotImplemented());
+  return 0;
+};
+
+
+#if 2 == 1
+
+template <>
+double EvaluateOneBranch1d<1>::evaluate () {
+  if ((time<=2.5-time_step) || (time>2.5))
+    return 0;
+
+  const unsigned int n_q_points = quadrature->n_quadrature_points;
+  DoFHandler<1>::active_cell_iterator cell = dof->begin_active(),
+                                     endc = dof->end();
+  double u_integrated=0;
+  FEValues<1>  fe_values (*fe, *quadrature, update_JxW_values);
+  vector<double> cell_u (fe->total_dofs);
+  
+  for (; cell!=endc; ++cell)
+    if ((cell->center()(0) > -0.6) &&
+       (cell->center()(0) < -0.4))
+      {
+       fe_values.reinit (cell);
+       fe_values.get_function_values (*u, cell_u);
+       const vector<double>    &JxW_values (fe_values.get_JxW_values());
+
+       double local_integral = 0;
+       for (unsigned int point=0; point<n_q_points; ++point)
+         local_integral += cell_u[point] *
+                           JxW_values[point];
+       u_integrated += local_integral;
+      };
+  result += u_integrated;
+  
+  return u_integrated;
+};
+
+#endif
+
+
+
+
+/*------------------------- EvaluateSecondCrossing1d --------------------------*/
+
+
+template <int dim>
+void EvaluateSecondCrossing1d<dim>::print_final_result (ostream &out) {
+  out << "    Second crossing: " << result << endl;
+};
+
+
+
+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 ()
+{
+  Assert (false, ExcNotImplemented());
+  return 0;
+};
+
+
+#if 2 == 1
+
+template <>
+double EvaluateSecondCrossing1d<1>::evaluate () {
+  if ((time<=2.4-time_step) || (time>2.4))
+    return 0;
+
+  const unsigned int n_q_points = quadrature->n_quadrature_points;
+  DoFHandler<1>::active_cell_iterator cell = dof->begin_active(),
+                                     endc = dof->end();
+  double u_integrated=0;
+  FEValues<1>  fe_values (*fe, *quadrature, UpdateFlags(update_JxW_values | update_q_points));
+  vector<double> cell_u (fe->total_dofs);
+  
+  for (; cell!=endc; ++cell)
+    if ((cell->center()(0) > -0.03) &&
+       (cell->center()(0) < 0.03))
+      {
+       fe_values.reinit (cell);
+       fe_values.get_function_values (*u, cell_u);
+       const vector<double>    &JxW_values (fe_values.get_JxW_values());
+       const vector<Point<1> > &quadrature_points (fe_values.get_quadrature_points());
+       
+       double local_integral = 0;
+       for (unsigned int point=0; point<n_q_points; ++point)
+         local_integral += cell_u[point] *
+                           JxW_values[point];
+       u_integrated += local_integral;
+      };
+  result += u_integrated;
+  
+  return u_integrated;
+};
+
+#endif
+
+
+
+/*------------------------- EvaluateHuyghensWave --------------------------*/
+
+
+template <int dim>
+void EvaluateHuyghensWave<dim>::print_final_result (ostream &out) {
+  out << "    Hughens wave -- weighted time: " << weighted_value / integrated_value << endl;
+  out << "                    average      : " << integrated_value << endl;
+};
+
+
+
+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 ()
+{
+  double     value_at_origin = 0;
+  Point<dim> p;
+  p(0) = 0.75;
+  const Point<dim> evaluation_point (p);
+
+  const DoFHandler<dim>::cell_iterator endc = dof->end(3);
+  bool point_found = false;
+  for (DoFHandler<dim>::cell_iterator cell=dof->begin(3);
+       (cell!=endc) && !point_found; ++cell)
+    for (unsigned int vertex=0; vertex<GeometryInfo<dim>::vertices_per_cell; ++vertex)
+      if (cell->vertex(vertex) == evaluation_point)
+       {
+                                          // step down the list of children
+                                          // until we find a terminal cell
+         DoFHandler<dim>::cell_iterator terminal_cell = cell;
+         while (terminal_cell->has_children())
+           terminal_cell = terminal_cell->child(vertex);
+         
+                                          // now terminal cell is the right one
+         value_at_origin = (*u)(cell->vertex_dof_index(vertex,0));
+         point_found = true;
+         
+         break;
+       };
+
+  AssertThrow (point_found, ExcInternalError());
+
+  if ((time > 0.5) && (time < 0.69)) 
+    {
+      integrated_value += value_at_origin * time_step;
+      weighted_value += value_at_origin * time_step * time;
+    };
+  
+  return value_at_origin;
+};
+
+
+               
+// explicit instantiations
+template class EvaluationBase<2>;
+template class EvaluateEnergyContent<2>;
+template class EvaluateIntegratedValueAtOrigin<2>;
+template class EvaluateSeismicSignal<2>;
+template class EvaluateSplitSignal<2>;
+template class EvaluateOneBranch1d<2>;
+template class EvaluateSecondCrossing1d<2>;
+template class EvaluateHuyghensWave<2>;
+
+/* $Id$ */
+
+#include <base/data_out_base.h>
+#include <basic/histogram.h>
+#include <lac/sparsematrix.h>
+#include <lac/vector.h>
+#include <grid/dof_constraints.h>
+#include <grid/dof.h>
+#include <grid/geometry_info.h>
+
+#include <cmath>
+#include <algorithm>
+#include <numeric>
+#include <fstream>
+#include <iomanip>
+
+#include <basic/data_out_stack.h>
+
+
+template <int dim>
+TimestepManager<dim>::TimestepManager (const WaveParameters<dim> &parameters) :
+                TimeDependent(TimeDependent::TimeSteppingData(0,1),
+                              TimeDependent::TimeSteppingData(0,1),
+                              TimeDependent::TimeSteppingData(0,1)),
+                parameters (parameters)
+{};
+
+
+
+template <int dim>
+void TimestepManager<dim>::run_sweep (const unsigned int sweep_no)
+{
+  SweepInfo      sweep_info;
+  SweepData<dim> sweep_data (parameters.write_stacked_data);
+  if (parameters.write_stacked_data)
+    {
+      sweep_data.data_out_stack->declare_data_vector ("u", DataOutStack<dim>::dof_vector);
+      sweep_data.data_out_stack->declare_data_vector ("v", DataOutStack<dim>::dof_vector);
+      if ((parameters.refinement_strategy == WaveParameters<dim>::dual_estimator)
+         &&
+         (sweep_no >= parameters.initial_energy_estimator_sweeps))
+       {
+         sweep_data.data_out_stack->declare_data_vector ("dual_u", DataOutStack<dim>::dof_vector);
+         sweep_data.data_out_stack->declare_data_vector ("dual_v", DataOutStack<dim>::dof_vector);
+       };
+      if ((sweep_no<parameters.number_of_sweeps-1) ||
+         (parameters.refinement_strategy == WaveParameters<dim>::dual_estimator))
+       sweep_data.data_out_stack->declare_data_vector ("est_error", DataOutStack<dim>::cell_vector);
+    };
+  
+  
+  cout << "Sweep " << setw(2) << sweep_no << ':' << endl
+       << "---------" << endl;
+
+  for (typename list<EvaluationBase<dim>*>::const_iterator i = parameters.eval_list.begin();
+       i != parameters.eval_list.end(); ++i)
+    (*i)->reset ();
+  
+  start_sweep (sweep_no);
+
+                                  // attach the present sweep_info object
+                                  // to all the time steps. also for
+                                  // the sweep_data object
+  for (vector<TimeStepBase*>::iterator timestep=timesteps.begin();
+       timestep!=timesteps.end(); ++timestep)
+    {
+      dynamic_cast<TimeStepBase_Wave<dim>*>(*timestep)->attach_sweep_info (sweep_info);
+      dynamic_cast<TimeStepBase_Wave<dim>*>(*timestep)->attach_sweep_data (sweep_data);
+    };
+  
+  solve_primal_problem ();
+  cout << endl;
+
+  if ((parameters.refinement_strategy == WaveParameters<dim>::dual_estimator)
+      &&
+      (sweep_no >= parameters.initial_energy_estimator_sweeps))
+    {
+      solve_dual_problem ();
+      cout << endl;
+    };
+  
+  postprocess ();
+
+  if (parameters.write_stacked_data)
+    write_stacked_data (*sweep_data.data_out_stack);
+
+  cout << endl;
+  
+  if (sweep_no != parameters.number_of_sweeps-1)
+    refine_grids ();
+
+  write_statistics (sweep_info);
+
+  end_sweep ();
+  
+  cout << endl << endl;
+};
+
+
+
+
+template <int dim>
+void TimestepManager<dim>::refine_grids () 
+{
+  cout << "  Collecting refinement data: " << endl;
+
+  
+  const unsigned int n_timesteps = timesteps.size();
+      
+                                      // first collect all the error indicators
+  vector<Vector<float> > indicators (n_timesteps);
+      
+  for (unsigned int i=0; i<n_timesteps; ++i)
+    static_cast<TimeStepBase_Wave<dim>*>(timesteps[i])
+      ->get_timestep_postprocess().get_tria_refinement_criteria (indicators[i]);
+
+
+                                  // 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)
+    {
+      cout << "    Generating error statistics " << flush;
+
+      vector<double> time_values (timesteps.size());
+      for (unsigned int i=0; i<timesteps.size(); ++i)
+       time_values[i] = timesteps[i]->get_time();
+      
+      Histogram error_statistics;
+      error_statistics.evaluate (indicators,
+                                time_values,
+                                parameters.error_statistic_intervals,
+                                Histogram::parse_interval_spacing(parameters.error_statistics_scaling));
+      error_statistics.write_gnuplot (cout);
+
+      cout << endl;
+    };
+
+
+  if (parameters.compare_indicators_globally)
+    {
+
+                                      // collect all indicators in one
+                                      // array; delete the old data as soon
+                                      // as possible, i.e. right after
+                                      // copying
+      Vector<float> all_indicators (total_number_of_cells);
+      unsigned int next_index=0;
+      for (unsigned int i=0; i<timesteps.size(); ++i)
+       {
+         copy (indicators[0].begin(),
+               indicators[0].end(),
+               &all_indicators(next_index));
+         next_index += (indicators[0].end() - indicators[0].begin());
+         
+         indicators.erase (indicators.begin());
+       };
+
+      Assert (next_index==all_indicators.size(),
+             ExcInternalError());
+
+                                      /////////////////////////////////////
+                                      // now find the thresholds for
+                                      // refinement and coarsening
+                                      //
+                                      // let #all_indicators# be the list
+                                      // of indicators sorted in *descending*
+                                      // order. #partial_sums# is the list
+                                      // of partial sums of #all_indicator#'s
+                                      // elements from the first to the present
+                                      // one.
+      const double total_error = all_indicators.l1_norm();
+
+      Vector<float> partial_sums(all_indicators.size());
+      sort (all_indicators.begin(), all_indicators.end(), greater<double>());
+      partial_sum (all_indicators.begin(), all_indicators.end(),
+                  partial_sums.begin());
+
+      const Vector<float>::const_iterator
+       p = upper_bound (partial_sums.begin(), partial_sums.end(),
+                        total_error*(1-parameters.refinement_fraction.second)),
+       q = lower_bound (partial_sums.begin(), partial_sums.end(),
+                        parameters.refinement_fraction.first*total_error);
+
+      double bottom_threshold = all_indicators(p != partial_sums.end() ?
+                                              p-partial_sums.begin() :
+                                              all_indicators.size()-1),
+            top_threshold    = all_indicators(q-partial_sums.begin());
+      
+      if (bottom_threshold==top_threshold)
+         bottom_threshold = 0.999*top_threshold;
+
+      cout << "    " << all_indicators.size()
+          << " cells in total."
+          << endl;
+      cout << "    Thresholds are [" << bottom_threshold << "," << top_threshold << "]"
+          << " out of ["
+          << *min_element(all_indicators.begin(),all_indicators.end())
+          << ','
+          << *max_element(all_indicators.begin(),all_indicators.end())
+          << "]. "
+          << endl;
+      cout << "    Expecting "
+          << (all_indicators.size() +
+              (q-partial_sums.begin())*(GeometryInfo<dim>::children_per_cell-1) -
+              (partial_sums.end() - p)/(GeometryInfo<dim>::children_per_cell-1))
+          << " cells in next sweep."
+          << endl;
+      cout << "    Now refining..." << flush;
+      do_loop (mem_fun (&TimeStepBase_Tria<dim>::init_for_refinement),
+              bind2nd (mem_fun1 (&TimeStepBase_Wave<dim>::refine_grid),
+                       TimeStepBase_Tria<dim>::RefinementData (top_threshold,
+                                                               bottom_threshold)),
+              TimeDependent::TimeSteppingData (0,1),
+              TimeDependent::forward);
+      cout << endl;
+    }
+
+  else
+                                    // refine each time step individually
+    {
+      cout << "    Refining each time step separately." << endl;
+      
+      for (unsigned int timestep=0; timestep<timesteps.size(); ++timestep)
+       static_cast<TimeStepBase_Tria<dim>*>(timesteps[timestep])->init_for_refinement();
+
+      unsigned int total_expected_cells = 0;
+      
+      for (unsigned int timestep=0; timestep<timesteps.size(); ++timestep)
+       {
+         TimeStepBase_Wave<dim> *this_timestep
+           = static_cast<TimeStepBase_Wave<dim>*>(timesteps[timestep]);
+           
+         this_timestep->wake_up (0);
+
+                                          // copy criteria and delete the old
+                                          // vector
+         Assert (indicators.size() > 0, ExcInternalError());
+         Vector<float> criteria (indicators[0]);
+         indicators.erase (indicators.begin());
+         
+         const double total_error = criteria.l1_norm();
+         
+         Vector<float> partial_sums(criteria.size());
+
+                                          // sort the largest errors to the
+                                          // beginning of the vector
+         sort (criteria.begin(), criteria.end(), greater<double>());
+         partial_sum (criteria.begin(), criteria.end(),
+                      partial_sums.begin());
+
+         const Vector<float>::const_iterator
+           p = upper_bound (partial_sums.begin(), partial_sums.end(),
+                            total_error*(1-parameters.refinement_fraction.second)),
+           q = lower_bound (partial_sums.begin(), partial_sums.end(),
+                            parameters.refinement_fraction.first*total_error);
+
+         double bottom_threshold = criteria(p != partial_sums.end() ?
+                                            p-partial_sums.begin() :
+                                            criteria.size()-1),
+                top_threshold    = criteria(q != partial_sums.end() ?
+                                            q-partial_sums.begin() :
+                                            criteria.size()-1);
+         
+         if (bottom_threshold==top_threshold)
+           bottom_threshold = 0.999*top_threshold;
+         
+         total_expected_cells += (criteria.size() +
+                                  (q-partial_sums.begin())*(GeometryInfo<dim>::children_per_cell-1) -
+                                  (partial_sums.end() - p)/(GeometryInfo<dim>::children_per_cell-1));
+         
+         this_timestep->refine_grid (TimeStepBase_Tria<dim>::RefinementData (top_threshold,
+                                                                             bottom_threshold));
+
+         this_timestep->sleep (0);
+         if (timestep!=0)
+           static_cast<TimeStepBase_Tria<dim>*>(timesteps[timestep-1])->sleep(1);
+       };
+      
+      if (timesteps.size() != 0)
+       static_cast<TimeStepBase_Tria<dim>*>(timesteps.back())->sleep(1);
+
+
+      cout << "    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 
+{
+                                  // write statistics
+  if (true)
+    {
+      cout << "    Writing statistics for whole sweep." << flush;
+      
+      cout << "#  Description of fields" << endl
+          << "#  =====================" << endl
+          << "#  General:"              << endl
+          << "#    time"                << endl;
+      cout.setf (ios::scientific, ios::floatfield);
+      
+      TimeStep<dim>::write_statistics_descriptions (cout, parameters);
+      cout << endl << endl;
+      
+      for (unsigned int timestep=0; timestep<timesteps.size(); ++timestep)
+       {
+         cout << setprecision(4) << setw(6) << timesteps[timestep]->get_time()
+              << "   ";
+         dynamic_cast<TimeStep<dim>*>
+           (static_cast<TimeStepBase_Wave<dim>*>
+            (timesteps[timestep]))->write_statistics (cout);
+         cout << endl;
+       };
+
+      AssertThrow (cout, ExcIO());
+      
+      cout << endl;
+    };
+
+  
+                                  // write summary
+  if (true)
+    {
+      cout << "    Writing summary." << flush;
+      
+      sweep_info.write_summary (parameters.eval_list,
+                               cout);
+      AssertThrow (cout, ExcIO());
+
+      cout << endl;
+    };
+};
+
+                                                       
+
+template <int dim>
+void TimestepManager<dim>::write_stacked_data (DataOutStack<dim> &data_out_stack) const 
+{
+  typename DataOutInterface<dim+1>::OutputFormat output_format
+    = DataOutInterface<dim+1>::parse_output_format (parameters.output_format);
+  
+  cout << "    Writing stacked time steps" << flush;
+  DataOutBase::EpsFlags eps_flags;
+  eps_flags.height_vector = eps_flags.color_vector = 2;
+  eps_flags.draw_mesh = false;
+  eps_flags.draw_cells = true;
+  eps_flags.azimut_angle = 0;
+  eps_flags.turn_angle = 0;
+  data_out_stack.set_flags (eps_flags);
+  data_out_stack.write (cout, output_format);
+  cout << '.' << endl;
+};
+
+
+
+
+//explicit instantiation
+template class TimestepManager<2>;
+  
+/* $Id$ */
+
+#include <base/exceptions.h>
+#include <base/function.h>
+#include <base/parameter_handler.h>
+#include <basic/histogram.h>
+#include <base/data_out_base.h>
+#include <grid/tria.h>
+#include <grid/tria_accessor.h>
+#include <grid/tria_iterator.h>
+#include <grid/tria_boundary.h>
+#include <grid/grid_generator.h>
+
+#include <map>
+#include <list>
+#include <cmath>
+
+
+template <int dim>
+const string WaveParameters<dim>::initial_value_names ("zero"
+                                                      "|eigenmode"
+                                                      "|bump"
+                                                      "|small bump"
+                                                      "|center-kink"
+                                                      "|shifted bump"
+                                                      "|plateau"
+                                                      "|earthquake");
+template <int dim>
+const string WaveParameters<dim>::coefficient_names ("unit"
+                                                    "|kink"
+                                                    "|gradient"
+                                                    "|preliminary earth model"
+                                                    "|distorted");
+template <int dim>
+const string WaveParameters<dim>::boundary_function_names ("wave from left"
+                                                          "|fast wave from left"
+                                                          "|wave from left center"
+                                                          "|wave from left bottom"
+                                                          "|zero");
+template <int dim>
+const string WaveParameters<dim>::dual_functional_names ("none"
+                                                        "|integrated value at origin"
+                                                        "|seismic signature"
+                                                        "|split signal"
+                                                        "|earth surface"
+                                                        "|split line"
+                                                        "|one branch 1d"
+                                                        "|second crossing"
+                                                        "|Huyghens wave");
+
+
+
+DeclException1 (ExcUnknownName,
+               string,
+               << "Unknown description string " << arg1);
+
+
+
+template <int dim>
+class InitialValues {
+  public:
+    class EigenMode : public Function<dim> {
+      public:
+       virtual double operator () (const Point<dim> &p) const {
+         const double pi = 3.1415926539;
+         return sin(2*pi*p(0))*sin(2*pi*p(1));
+       };
+    };
+
+    class Bump : public Function<dim> {
+      public:
+       virtual double operator () (const Point<dim> &p) const {
+         const double width = 0.1;
+         const double r2 = p.square();
+         return exp(-r2/width/width) * (r2<width*width ?
+                                        1-r2/width/width :
+                                        0);
+       };
+    };
+
+
+    class SmallBump : public Function<dim> {
+      public:
+       virtual double operator () (const Point<dim> &p) const {
+         const double width = 0.02;
+         const double r2 = p.square();
+         return exp(-r2/width/width) * (r2<width*width ?
+                                        1-r2/width/width :
+                                        0);
+       };
+    };
+
+
+    class ShiftedBump : public Function<dim> {
+      public:
+       virtual double operator () (const Point<dim> &p) const {
+         const double width = 0.1;
+         Point<dim> shift;
+         shift(0) = 0.5;
+         const double r2 = (p-shift).square();
+         return exp(-r2/width/width) * (r2<width*width ?
+                                        1-r2/width/width :
+                                        0);
+       };
+    };
+
+    class CenterKink : public Function<dim> {
+      public:
+       virtual double operator () (const Point<dim> &p) const {
+         const double width = 0.1;
+         const double r     = sqrt(p.square());
+         return (r<width ? r/width : (r<2*width ? 2-r/width : 0));
+       };
+    };
+
+    class Plateau : public Function<dim> {
+      public:
+       virtual double operator () (const Point<dim> &p) const {
+         const double width = 0.1;
+         const double r     = sqrt(p.square());
+         return (r<width ? 1 : 0);
+       };
+    };
+
+
+    class Earthquake : public Function<dim> {
+      public:
+       virtual double operator () (const Point<dim> &p) const {
+         Point<dim> earthquake_center = p;
+         earthquake_center(1) -= 5500;
+         const double r2 = earthquake_center.square();
+         
+         return (r2<300*300 ? 1-r2/300/300 : 0);
+       };
+    };
+};
+
+
+
+template <int dim>
+class Coefficients {
+  public:
+    class Kink : public Function<dim> {
+      public:
+       inline virtual double operator () (const Point<dim> &p) const {
+                                          // always let the kink be
+                                          // in direction of the last
+                                          // variable
+         return 1+8*(p(dim-1)>1./5. ? 1. : 0.);
+       };
+       
+       virtual void value_list (const vector<Point<dim> > &points,
+                                vector<double>            &values) const {
+         Assert (values.size() == points.size(),
+                 ExcVectorHasWrongSize(values.size(), points.size()));
+         for (unsigned int i=0; i<points.size(); ++i)
+           values[i]  = this->Kink::operator()(points[i]);
+       };
+
+       virtual Tensor<1,dim> gradient (const Point<dim> &p) const {
+         Tensor<1,dim> tmp;
+         if (fabs(p(1)-1./5.) < 1./400.)
+           tmp[1] = 100;
+         return tmp;
+       };
+       
+       virtual void gradient_list (const vector<Point<dim> > &points,
+                                   vector<Tensor<1,dim> >    &gradients) const {
+         for (unsigned int i=0; i<points.size(); ++i)
+           gradients[i] = Kink::gradient (points[i]);
+       };
+    };
+
+
+    class Gradient : public Function<dim> {
+      public:
+       inline virtual double operator () (const Point<dim> &p) const {
+         return 1+8*p(1)*p(1);
+       };
+       
+       virtual void value_list (const vector<Point<dim> > &points,
+                                vector<double>            &values) const {
+         Assert (values.size() == points.size(),
+                 ExcVectorHasWrongSize(values.size(), points.size()));
+         for (unsigned int i=0; i<points.size(); ++i)
+           values[i]  = this->Gradient::operator()(points[i]);
+       };
+
+       virtual Tensor<1,dim> gradient (const Point<dim> &p) const {
+         Tensor<1,dim> tmp;
+         tmp[1] = 16*p(1);
+         return tmp;
+       };
+       
+       virtual void gradient_list (const vector<Point<dim> > &points,
+                                   vector<Tensor<1,dim> >    &gradients) const {
+         for (unsigned int i=0; i<points.size(); ++i)
+           gradients[i] = Gradient::gradient (points[i]);
+       };
+    };
+
+
+
+    class PreliminaryEarthModel : public Function<dim> {
+      public:
+       inline virtual double operator () (const Point<dim> &p) const {
+         const double r=sqrt(p.square());
+                                          // this data just ad hoc, not taken
+                                          // from the PREM
+         return 10+2.5*(2-r/6371)*(2-r/6371)+20*(r<2000 ? 1 : 0);
+       };
+       
+       virtual void value_list (const vector<Point<dim> > &points,
+                                vector<double>            &values) const {
+         Assert (values.size() == points.size(),
+                 ExcVectorHasWrongSize(values.size(), points.size()));
+         for (unsigned int i=0; i<points.size(); ++i)
+           values[i]  = this->PreliminaryEarthModel::operator()(points[i]);
+       };
+
+       virtual Tensor<1,dim> gradient (const Point<dim> &p) const {
+                                          // gradient is derivative with
+                                          // respect to r times a unit vector
+                                          // in direction of p
+         Tensor<1,dim> tmp(p);
+         const double r=sqrt(p.square());        
+         tmp *= 1./r * 2*(10-5*r/6371);
+         return tmp;
+       };
+       
+       virtual void gradient_list (const vector<Point<dim> > &points,
+                                   vector<Tensor<1,dim> >    &gradients) const {
+         for (unsigned int i=0; i<points.size(); ++i)
+           gradients[i] = PreliminaryEarthModel::gradient (points[i]);
+       };
+    };
+
+    
+    
+    class Distorted : public Function<dim> {
+      public:
+       inline virtual double operator () (const Point<dim> &p) const {
+         const double x=p(0),
+                      y=p(1);
+         const double pi = 3.1415926539;
+         
+         return (1+0.5*((sin(3*pi*x)>0 ? 1 : 0)+
+                        (sin(3*pi*(2*x+y)/sqrt(3)))>0 ? 1 : 0));
+       };
+       
+       virtual void value_list (const vector<Point<dim> > &points,
+                                vector<double>            &values) const {
+         Assert (values.size() == points.size(),
+                 ExcVectorHasWrongSize(values.size(), points.size()));
+         for (unsigned int i=0; i<points.size(); ++i)
+           values[i]  = this->Distorted::operator()(points[i]);
+       };
+
+       virtual Tensor<1,dim> gradient (const Point<dim> &) const {
+                                          // return zero, since we don't know
+                                          // how to do better (regularize?)
+         return Tensor<1,dim>();
+       };
+       
+       virtual void gradient_list (const vector<Point<dim> > &points,
+                                   vector<Tensor<1,dim> >    &gradients) const {
+         for (unsigned int i=0; i<points.size(); ++i)
+           gradients[i] = Distorted::gradient (points[i]);
+       };
+    };
+};
+
+
+
+
+template <int dim>
+class BoundaryValues {
+  public:
+
+    class WaveFromLeft_u : public Function<dim> {
+      public:
+       virtual double operator () (const Point<dim> &p) const {
+         const double pi = 3.1415926536;
+//       if ((get_time()<0.4) && (p(0)==0))
+         if (p(0)==0)
+           return sin(pi*get_time()/0.4)*sin(pi*get_time()/0.4);
+         else
+           return 0;
+       };
+    };
+
+    class WaveFromLeft_v : public Function<dim> {
+      public:
+       virtual double operator () (const Point<dim> &p) const {
+         const double pi = 3.1415926536;
+//       if ((get_time()<0.4) && (p(0)==0))
+         if (p(0)==0)
+           return 2*pi/0.4*sin(pi*get_time()/0.4)*cos(pi*get_time()/0.4);
+         else
+           return 0;
+       };
+    };
+
+
+    class FastWaveFromLeft_u : public Function<dim> {
+      public:
+       virtual double operator () (const Point<dim> &p) const {
+         const double pi = 3.1415926536;
+         if ((get_time()<0.2) && (p(0)==0))
+           return sin(pi*get_time()/0.2)*sin(pi*get_time()/0.2);
+         else
+           return 0;
+       };
+    };
+
+    class FastWaveFromLeft_v : public Function<dim> {
+      public:
+       virtual double operator () (const Point<dim> &p) const {
+         const double pi = 3.1415926536;
+         if ((get_time()<0.2) && (p(0)==0))
+           return 2*pi/0.2*sin(pi*get_time()/0.2)*cos(pi*get_time()/0.2);
+         else
+           return 0;
+       };
+    };
+
+    
+    class WaveFromLeftCenter_u : public Function<dim> {
+      public:
+       virtual double operator () (const Point<dim> &p) const {
+         const double pi = 3.1415926536;
+         if ((0.4 <= p(1)) && (p(1) <= 0.6) && (p(0) <= 0.5))
+           return (p(1)-0.4)*(0.6-p(1)) * sin(pi*get_time()/0.2);
+         else
+           return 0;
+       };
+    };
+
+    class WaveFromLeftCenter_v : public Function<dim> {
+      public:
+       virtual double operator () (const Point<dim> &p) const {
+         const double pi = 3.1415926536;
+         if ((0.4 <= p(1)) && (p(1) <= 0.6) && (p(0) <= 0.5))
+           return pi/0.2*(p(1)-0.4)*(0.6-p(1)) * cos(pi*get_time()/0.2);
+         else
+           return 0;
+       };
+    };
+
+
+    class WaveFromLeftBottom_u : public Function<dim> {
+      public:
+       virtual double operator () (const Point<dim> &p) const {
+         const double pi = 3.1415926536;
+         const double r  = sqrt(p.square());
+                                          // let the radius of
+                                          // the excited site be
+                                          // 50 km
+         const double a  = 5000000;
+
+                                          // let the period be
+                                          // 60 seconds
+         const double period = 60;
+
+         if ((get_time()>=period) || (r>=a))
+           return 0;
+
+         const double s = cos(r/a*pi/2)*sin(pi*get_time()/period);
+         return s*s;
+       };
+    };
+
+    class WaveFromLeftBottom_v : public Function<dim> {
+      public:
+       virtual double operator () (const Point<dim> &p) const {
+         const double pi = 3.1415926536;
+         const double r  = sqrt(p.square());
+                                          // let the radius of
+                                          // the excited site be
+                                          // 50 km
+         const double a  = 5000000;
+                                          // let the period be
+                                          // 60 seconds
+         const double period = 60;
+
+         if ((get_time()>=period) || (r>=a))
+           return 0;
+         else
+           return (2*pi/period*cos(r/a*pi/2)*cos(r/a*pi/2)*
+                   sin(pi*get_time()/period)*cos(pi*get_time()/period));
+       };
+    };
+
+};
+
+
+
+template <int dim>
+class Boundaries 
+{
+  public:
+    class Ring :  public StraightBoundary<dim> 
+    {
+      public:
+       virtual Point<dim>
+       get_new_point_on_line (const typename Triangulation<dim>::line_iterator &line) const {
+         Point<dim> middle = StraightBoundary<dim>::get_new_point_on_line (line);
+         middle *= sqrt(line->vertex(0).square()) / sqrt(middle.square());
+         return middle;
+       };
+       
+       
+       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());
+         return middle;
+       };
+    };
+};
+
+
+
+
+template <int dim>
+WaveParameters<dim>::WaveParameters () :
+               boundary_values_u (0),
+               boundary_values_v (0),
+               initial_u (0),
+               initial_v (0),
+               boundary (0),
+               density (0),
+               stiffness (0),
+               dual_functional (0),
+               coarse_grid (0)
+{};
+
+
+
+template <int dim>
+WaveParameters<dim>::~WaveParameters ()
+{
+  delete_parameters ();
+};
+
+
+
+template <int dim>
+void WaveParameters<dim>::delete_parameters ()
+{
+  if (boundary_values_u)
+    delete boundary_values_u;
+  boundary_values_u = 0;
+
+  if (boundary_values_v)
+    delete boundary_values_v;
+  boundary_values_v = 0;
+
+  if (initial_u)
+    delete initial_u;
+  initial_u = 0;
+
+  if (initial_v)
+    delete initial_v;
+  initial_v = 0;
+
+  if (boundary)
+    delete boundary;
+  boundary = 0;
+
+  if (density)
+    delete density;
+  density = 0;
+
+  if (stiffness)
+    delete stiffness;
+  stiffness = 0;
+
+  if (dual_functional)
+    delete dual_functional;
+  dual_functional = 0;
+
+  if (coarse_grid)
+    delete coarse_grid;
+  coarse_grid = 0;
+
+                                  // free memory used by the evaluation
+                                  // objects
+  for (typename list<EvaluationBase<dim>*>::iterator i=eval_list.begin();
+       i!=eval_list.end(); ++i)
+    delete *i;
+  eval_list.erase (eval_list.begin(), eval_list.end());
+};
+
+
+
+
+template <int dim>
+void WaveParameters<dim>::set_initial_functions (const string &u_name,
+                                                const string &v_name) {
+  Assert (initial_u==0, ExcInternalError());
+  Assert (initial_v==0, ExcInternalError());
+  
+  const string names[2] = {u_name, v_name};
+  Function<dim> *functions[2];
+  
+  for (unsigned int i=0; i<2; ++i)
+    {
+      if (names[i]=="eigenmode")
+       functions[i] = new InitialValues<dim>::EigenMode();
+      else
+       if (names[i]=="zero")
+         functions[i] = new ZeroFunction<dim>();
+       else
+         if (names[i]=="center-kink")
+           functions[i] = new InitialValues<dim>::CenterKink();
+         else
+           if (names[i]=="bump")
+             functions[i] = new InitialValues<dim>::Bump();
+           else
+             if (names[i]=="small bump")
+               functions[i] = new InitialValues<dim>::SmallBump();
+             else
+               if (names[i]=="shifted bump")
+                 functions[i] = new InitialValues<dim>::ShiftedBump();
+               else
+                 if (names[i]=="plateau")
+                   functions[i] = new InitialValues<dim>::Plateau ();
+                 else
+                   if (names[i]=="earthquake")
+                     functions[i] = new InitialValues<dim>::Earthquake ();
+                   else
+                     AssertThrow (false, ExcUnknownName(names[i]));
+    };
+
+  initial_u = functions[0];
+  initial_v = functions[1];
+};
+
+
+
+
+
+template <int dim>
+void WaveParameters<dim>::set_coefficient_functions (const string &name) {  
+  Assert (density==0, ExcInternalError());
+  Assert (stiffness==0, ExcInternalError());
+
+  density = new ConstantFunction<dim>(1);
+  density_constant = true;
+  
+  if (name=="kink")
+    {
+      stiffness = new Coefficients<dim>::Kink();
+      stiffness_constant = false;
+    }
+  else
+    if (name=="gradient")
+      {
+       stiffness = new Coefficients<dim>::Gradient();
+       stiffness_constant = false;
+      }
+    else
+      if (name=="unit")
+       {
+         stiffness = new ConstantFunction<dim>(1);
+         stiffness_constant = true;
+       }
+      else
+       if (name=="preliminary earth model")
+         {
+           stiffness = new Coefficients<dim>::PreliminaryEarthModel();
+           stiffness_constant = false;
+         }
+       else
+         if (name=="distorted")
+           {
+             stiffness = new Coefficients<dim>::Distorted();
+             stiffness_constant = false;
+         }
+         else
+           AssertThrow (false, ExcUnknownName (name));
+};
+
+
+
+template <int dim>
+void WaveParameters<dim>::set_boundary_functions (const string &name) {
+  Assert (boundary_values_u==0, ExcInternalError());
+  Assert (boundary_values_v==0, ExcInternalError());
+  
+  if (name=="wave from left") 
+    {
+      boundary_values_u = new BoundaryValues<dim>::WaveFromLeft_u ();
+      boundary_values_v = new BoundaryValues<dim>::WaveFromLeft_v ();
+    }
+  else
+    if (name=="fast wave from left") 
+      {
+       boundary_values_u = new BoundaryValues<dim>::FastWaveFromLeft_u ();
+       boundary_values_v = new BoundaryValues<dim>::FastWaveFromLeft_v ();
+      }
+    else
+      if (name=="wave from left center")
+       {
+         boundary_values_u = new BoundaryValues<dim>::WaveFromLeftCenter_u ();
+         boundary_values_v = new BoundaryValues<dim>::WaveFromLeftCenter_v ();
+       }
+      else
+       if (name=="wave from left bottom")
+         {
+           boundary_values_u = new BoundaryValues<dim>::WaveFromLeftBottom_u ();
+           boundary_values_v = new BoundaryValues<dim>::WaveFromLeftBottom_v ();
+         }
+       else
+         if (name=="zero")
+           {
+             boundary_values_u = new ZeroFunction<dim>();
+             boundary_values_v = new ZeroFunction<dim>();
+           }
+         else
+           AssertThrow (false, ExcUnknownName (name));
+};
+
+
+
+template <int dim>
+void WaveParameters<dim>::make_eval_list (const string &names) {
+  Assert (eval_list.size()==0, ExcInternalError());
+  string split_list = names;
+
+  while (split_list.length())
+    {
+      string name;
+      name = split_list;
+      
+      if (name.find(",") != string::npos)
+       {
+         name.erase (name.find(","), string::npos);
+         split_list.erase (0, split_list.find(",")+1);
+       }
+      else
+       split_list = "";
+
+      while (name[0] == ' ')
+       name.erase (0,1);
+      while (name[name.length()-1] == ' ')
+       name.erase (name.length()-1, 1);
+
+      if (name == "integrated value at origin")
+       eval_list.push_back (new EvaluateIntegratedValueAtOrigin<dim>());
+      else
+       if (name == "seismic signature")
+         eval_list.push_back (new EvaluateSeismicSignal<dim>());
+       else
+         if (name == "split signal")
+           eval_list.push_back (new EvaluateSplitSignal<dim>());
+         else
+           if (name == "one branch 1d")
+             eval_list.push_back (new EvaluateOneBranch1d<dim>());
+           else
+             if (name == "second crossing")
+               eval_list.push_back (new EvaluateSecondCrossing1d<dim>());
+             else
+               if (name == "Huyghens wave")
+                 eval_list.push_back (new EvaluateHuyghensWave<dim>());
+               else
+                 AssertThrow (false, ExcUnknownName (name));
+    };
+};
+
+
+
+
+template <int dim>
+void WaveParameters<dim>::set_dual_functional (const string &name) {
+  Assert (dual_functional==0, ExcInternalError());
+  if (name == "none")
+    dual_functional = new DualFunctional<dim>();
+  else
+    if (name == "integrated value at origin")
+      dual_functional = new IntegratedValueAtOrigin<dim> ();
+    else
+      if (name == "seismic signature")
+       dual_functional = new SeismicSignal<dim> ();
+      else
+       if (name == "split signal")
+         dual_functional = new SplitSignal<dim> ();
+       else
+         if (name == "earth surface")
+           dual_functional = new EarthSurface<dim> ();
+         else
+           if (name == "split line")
+             dual_functional = new SplitLine<dim> ();
+           else
+             if (name == "one branch 1d")
+               dual_functional = new OneBranch1d<dim> ();
+             else
+               if (name == "second crossing")
+                 dual_functional = new SecondCrossing<dim> ();
+               else
+                 if (name == "Huyghens wave")
+                   dual_functional = new HuyghensWave<dim> ();
+                 else
+                   AssertThrow (false, ExcUnknownName (name));
+};
+
+
+
+
+#if 2 == 1
+
+template <>
+void WaveParameters<1>::make_coarse_grid (const string &name) {
+  const unsigned int dim = 1;
+  
+  coarse_grid = new Triangulation<dim>(MeshSmoothing(smoothing_on_refinement |
+                                                    eliminate_refined_inner_islands));
+
+  if (name == "line")
+    GridGenerator::hyper_cube (*coarse_grid, -1, 1);
+  else
+    if (name == "split line") 
+      {
+       const Point<1> vertices[4] = { Point<1>(-1.),
+                                      Point<1>(-1./3.),
+                                      Point<1>(1./3.),
+                                      Point<1>(1.) };
+       vector<CellData<1> > cells (3, CellData<1>());
+       cells[0].vertices[0] = 0;
+       cells[0].vertices[1] = 1;
+       cells[0].material_id = 0;
+
+       cells[1].vertices[0] = 1;
+       cells[1].vertices[1] = 2;
+       cells[1].material_id = 0;
+
+       cells[2].vertices[0] = 2;
+       cells[2].vertices[1] = 3;
+       cells[2].material_id = 0;
+
+       coarse_grid->create_triangulation (vector<Point<1> >(&vertices[0],
+                                                            &vertices[4]),
+                                          cells,
+                                          SubCellData());
+
+                                        // refine two of the three cells
+       Triangulation<dim>::active_cell_iterator cell = coarse_grid->begin_active();
+       (++cell)->set_refine_flag ();
+       (++cell)->set_refine_flag ();
+       coarse_grid->execute_coarsening_and_refinement ();
+
+                                        // refine the level 1 cells 
+                                        // twice more
+       for (int k=0; k<2; ++k)
+         {
+           for (cell=coarse_grid->begin_active(); cell!=coarse_grid->end(); ++cell)
+             if (cell->level() == k+1)
+               cell->set_refine_flag ();
+           coarse_grid->execute_coarsening_and_refinement ();
+         };
+      }
+    else
+      AssertThrow (false, ExcParameterNotInList(name));
+  
+  coarse_grid->refine_global (initial_refinement);
+};
+
+#endif
+
+
+
+#if 2 == 2
+
+template <>
+void WaveParameters<2>::make_coarse_grid (const string &name) {
+  const unsigned int dim=2;
+
+  map<string,InitialMesh> initial_mesh_list;
+  initial_mesh_list["split channel bottom"] = split_channel_bottom;
+  initial_mesh_list["split channel left"]   = split_channel_left;
+  initial_mesh_list["split channel right"]  = split_channel_right;
+  initial_mesh_list["uniform channel"] = uniform_channel;
+  initial_mesh_list["square"]          = square;
+  initial_mesh_list["ring"]            = ring;
+  initial_mesh_list["earth"]           = earth;
+  initial_mesh_list["seismic square"]  = seismic_square;
+  AssertThrow (initial_mesh_list.find(name) != initial_mesh_list.end(),
+              ExcParameterNotInList(name));
+
+  const InitialMesh initial_mesh = initial_mesh_list[name];
+
+  coarse_grid = new Triangulation<dim>(MeshSmoothing(smoothing_on_refinement |
+                                                    eliminate_refined_inner_islands));
+  
+  switch (initial_mesh) 
+    {
+      case uniform_channel:
+      case split_channel_bottom:
+      case split_channel_left:
+      case split_channel_right:
+      {
+       const Point<dim> vertices[8] = { Point<dim> (0,0),
+                                        Point<dim> (1,0),
+                                        Point<dim> (1,1),
+                                        Point<dim> (0,1),
+                                        Point<dim> (2,0),
+                                        Point<dim> (2,1),
+                                        Point<dim> (3,0),
+                                        Point<dim> (3,1)  };
+       const int cell_vertices[3][4] = {{0, 1, 2, 3},
+                                        {1, 4, 5, 2},
+                                        {4, 6, 7, 5}};
+       
+       vector<CellData<dim> > cells (3, CellData<dim>());
+       
+       for (unsigned int i=0; i<3; ++i) 
+         {
+           for (unsigned int j=0; j<4; ++j)
+             cells[i].vertices[j] = cell_vertices[i][j];
+           cells[i].material_id = 0;
+         };
+       
+       SubCellData boundary_info;
+       if ((boundary_conditions == wave_from_left) ||
+           (boundary_conditions == fast_wave_from_left))
+         {
+           for (unsigned int i=0; i<6; ++i)
+             {
+               boundary_info.boundary_lines.push_back (CellData<1>());
+                                                // use Neumann boundary
+                                                // conditions at top
+                                                // and bottom of channel
+               boundary_info.boundary_lines.back().material_id = 1;
+             };
+           
+           boundary_info.boundary_lines[0].vertices[0] = 0;
+           boundary_info.boundary_lines[0].vertices[1] = 1;
+           boundary_info.boundary_lines[1].vertices[0] = 1;
+           boundary_info.boundary_lines[1].vertices[1] = 4;
+           boundary_info.boundary_lines[2].vertices[0] = 4;
+           boundary_info.boundary_lines[2].vertices[1] = 6;
+           boundary_info.boundary_lines[3].vertices[0] = 3;
+           boundary_info.boundary_lines[3].vertices[1] = 2;
+           boundary_info.boundary_lines[4].vertices[0] = 2;
+           boundary_info.boundary_lines[4].vertices[1] = 5;
+           boundary_info.boundary_lines[5].vertices[0] = 5;
+           boundary_info.boundary_lines[5].vertices[1] = 7;      
+         };
+
+       if (boundary_conditions == wave_from_left_bottom)
+         {
+                                            // use Neumann bc at left
+                                            // (mirror condition)
+           boundary_info.boundary_lines.push_back (CellData<1>());
+           boundary_info.boundary_lines.back().material_id = 1;
+           boundary_info.boundary_lines[0].vertices[0] = 0;
+           boundary_info.boundary_lines[0].vertices[1] = 3;
+         };
+       
+       coarse_grid->create_triangulation (vector<Point<dim> >(&vertices[0],
+                                                              &vertices[8]),
+                                          cells, boundary_info);
+       
+       if (initial_refinement >= 1) 
+         {
+           coarse_grid->refine_global (1);
+
+           switch (initial_mesh)
+             {
+               case split_channel_bottom:
+               {
+                 Triangulation<dim>::active_cell_iterator cell;
+                 cell = coarse_grid->begin_active();
+                 (cell++)->set_refine_flag ();
+                 (cell++)->set_refine_flag ();
+                 ++cell; ++cell;
+                 (cell++)->set_refine_flag ();
+                 (cell++)->set_refine_flag ();
+                 ++cell; ++cell;
+                 (cell++)->set_refine_flag ();
+                 (cell++)->set_refine_flag ();
+                 coarse_grid->execute_coarsening_and_refinement ();
+
+                 coarse_grid->refine_global (initial_refinement-1);
+
+                 break;
+               };
+
+               case split_channel_left:
+               case split_channel_right:
+               {
+                 coarse_grid->refine_global (1);
+                 for (unsigned int i=0; i<2; ++i)
+                   {
+                     Triangulation<dim>::active_cell_iterator
+                       cell = coarse_grid->begin_active();
+
+                     for (; cell!=coarse_grid->end(); ++cell)
+                       if (((cell->center()(0) >= 1) &&
+                            (initial_mesh == split_channel_right)) ||
+                           ((cell->center()(0) <= 1) &&
+                            (initial_mesh == split_channel_left)))
+                         cell->set_refine_flag ();
+                     coarse_grid->execute_coarsening_and_refinement ();
+                   };
+
+                 if (initial_refinement > 4)
+                   coarse_grid->refine_global (initial_refinement-4);
+
+                 break;
+               };
+                 
+               
+               case uniform_channel:
+               {
+                 coarse_grid->refine_global (initial_refinement-1);
+                 break;
+               };
+
+
+               default:
+                     Assert (false, ExcInternalError());
+             };
+         };
+       break;
+      };
+
+      
+      case square:
+      case seismic_square:
+      {
+       GridGenerator::hyper_cube (*coarse_grid, -1, 1);
+       if (initial_mesh==seismic_square)
+         coarse_grid->begin_active()->face(2)->set_boundary_indicator(1);
+
+       coarse_grid->refine_global (initial_refinement);
+
+       break;
+      };
+
+      case earth:
+      {
+                                        // create ball
+       GridGenerator::hyper_ball (*coarse_grid, Point<dim>(), 6371);
+
+       if (boundary)
+         delete boundary;
+       
+                                        // set all boundary to Neumann type
+       Triangulation<dim>::active_face_iterator face;
+       for (face=coarse_grid->begin_active_face();
+            face != coarse_grid->end_face();
+            ++face)
+         if (face->at_boundary())
+           face->set_boundary_indicator (1);
+
+       const Point<dim> origin;
+       boundary = new HyperBallBoundary<dim>(origin, 6371);
+                                        // set boundary. note that only
+                                        // id 1 is used
+       coarse_grid->set_boundary (1, *boundary);
+
+       coarse_grid->refine_global (initial_refinement);
+
+       break;
+      };
+
+      case ring:
+      {
+       const double radius = 1.;
+       const double a = radius/2;
+       const Point<2> vertices[8] = { Point<2>(-1,-1)*(radius/sqrt(2)),
+                                      Point<2>(+1,-1)*(radius/sqrt(2)),
+                                      Point<2>(-1,-1)*(radius/sqrt(2)*a),
+                                      Point<2>(+1,-1)*(radius/sqrt(2)*a),
+                                      Point<2>(-1,+1)*(radius/sqrt(2)*a),
+                                      Point<2>(+1,+1)*(radius/sqrt(2)*a),
+                                      Point<2>(-1,+1)*(radius/sqrt(2)),
+                                      Point<2>(+1,+1)*(radius/sqrt(2)) };
+       
+       const int cell_vertices[4][4] = {{0, 1, 3, 2},
+                                        {0, 2, 4, 6},
+                                        {1, 7, 5, 3},
+                                        {6, 4, 5, 7}};
+       
+       vector<CellData<2> > cells (4, CellData<2>());
+       
+       for (unsigned int i=0; i<4; ++i) 
+         {
+           for (unsigned int j=0; j<4; ++j)
+             cells[i].vertices[j] = cell_vertices[i][j];
+           cells[i].material_id = 0;
+         };
+  
+       coarse_grid->create_triangulation (vector<Point<2> >(&vertices[0],
+                                                            &vertices[8]),
+                                          cells,
+                                          SubCellData());
+       if (boundary)
+         delete boundary;
+       boundary = new Boundaries<dim>::Ring();
+       coarse_grid->set_boundary (0, *boundary);
+
+       coarse_grid->refine_global (initial_refinement);
+       
+       break;
+      };
+      
+      default:
+           Assert (false, ExcInternalError());
+    };
+};
+
+#endif
+
+
+#if 2 == 3
+
+template <>
+void WaveParameters<3>::make_coarse_grid (const string &name) {
+  const unsigned int dim=3;
+
+  map<string,InitialMesh> initial_mesh_list;
+  initial_mesh_list["square"]          = square;
+  initial_mesh_list["earth"]           = earth;
+  initial_mesh_list["seismic square"]  = seismic_square;
+  AssertThrow (initial_mesh_list.find(name) != initial_mesh_list.end(),
+              ExcParameterNotInList(name));
+
+  const InitialMesh initial_mesh = initial_mesh_list[name];
+
+  coarse_grid = new Triangulation<dim>(MeshSmoothing(smoothing_on_refinement |
+                                                    eliminate_refined_inner_islands));
+  
+  switch (initial_mesh) 
+    {
+      case square:
+      case seismic_square:
+      {
+       GridGenerator::hyper_cube (*coarse_grid, -1, 1);
+       if (initial_mesh==seismic_square)
+         coarse_grid->begin_active()->face(2)->set_boundary_indicator(1);
+
+       coarse_grid->refine_global (initial_refinement);
+
+       break;
+      };
+
+      case earth:
+      {
+                                        // create ball
+       GridGenerator::hyper_ball (*coarse_grid, Point<dim>(), 6371);
+
+       if (boundary)
+         delete boundary;
+       
+                                        // set all boundary to Neumann type
+       Triangulation<dim>::active_face_iterator face;
+       for (face=coarse_grid->begin_active_face();
+            face != coarse_grid->end_face();
+            ++face)
+         if (face->at_boundary())
+           face->set_boundary_indicator (1);
+
+       const Point<dim> origin;
+       boundary = new HyperBallBoundary<dim>(origin, 6371);
+                                        // set boundary. note that only
+                                        // id 1 is used
+       coarse_grid->set_boundary (1, *boundary);
+
+       coarse_grid->refine_global (initial_refinement);
+
+       break;
+      };
+
+      default:
+           AssertThrow (false, ExcInternalError());
+           break;
+    };
+};
+
+#endif
+
+
+
+
+template <int dim>
+void WaveParameters<dim>::declare_parameters (ParameterHandler &prm) 
+{
+  prm.enter_subsection ("Grid");
+  if (true) {
+    prm.declare_entry ("Initial refinement", "0", Patterns::Integer());
+    prm.declare_entry ("Coarse mesh", "uniform channel",
+                      Patterns::Selection ("uniform channel|split channel bottom|"
+                                          "split channel left|split channel right|"
+                                          "square|line|split line|ring|"
+                                          "seismic square|temperature-square|"
+                                          "temperature-testcase|random|earth"));
+    prm.enter_subsection ("Refinement");
+    if (true) {
+      prm.declare_entry ("Refinement fraction", "0.95",
+                        Patterns::Double());
+      prm.declare_entry ("Coarsening fraction", "0.02",
+                        Patterns::Double());
+      prm.declare_entry ("Compare indicators globally", "true", Patterns::Bool());
+      prm.declare_entry ("Maximum refinement", "0", Patterns::Integer());
+      prm.declare_entry ("Adapt mesh to dual solution", "true",
+                        Patterns::Bool());
+      prm.declare_entry ("Primal to dual weight", "1.0",
+                        Patterns::Double());
+      prm.declare_entry ("Initial energy estimator sweeps", "0",
+                        Patterns::Integer());
+    };
+    prm.leave_subsection ();
+     
+    prm.enter_subsection ("Mesh smoothing");
+    if (true) {
+      prm.declare_entry ("Top cell number deviation", "0.1", Patterns::Double());
+      prm.declare_entry ("Bottom cell number deviation", "0.03", Patterns::Double());
+      prm.declare_entry ("Cell number correction steps", "2", Patterns::Integer());
+    };
+    prm.leave_subsection ();
+  };
+  prm.declare_entry ("Renumber dofs", "false", Patterns::Bool());
+  prm.leave_subsection ();
+
+  prm.enter_subsection ("Equation data");
+  if (true) {
+    prm.declare_entry ("Coefficient", "unit", Patterns::Selection(coefficient_names));
+    prm.declare_entry ("Initial u", "zero", Patterns::Selection (initial_value_names));
+    prm.declare_entry ("Initial v", "zero", Patterns::Selection (initial_value_names));
+    prm.declare_entry ("Boundary", "wave from left",
+                      Patterns::Selection (boundary_function_names));
+  };
+  prm.leave_subsection ();
+
+  prm.enter_subsection ("Discretization");
+  prm.declare_entry ("Primal FE", "linear",
+                    Patterns::Selection ("linear|quadratic|cubic|quartic"));
+  prm.declare_entry ("Dual FE", "linear",
+                    Patterns::Selection ("linear|quadratic|cubic|quartic"));
+
+  prm.enter_subsection ("Time stepping");
+  prm.declare_entry ("Primal method", "fractional step",
+                    Patterns::Selection ("theta|fractional step"));
+  prm.declare_entry ("Dual method", "fractional step",
+                    Patterns::Selection ("theta|fractional step"));
+  prm.declare_entry ("Theta", "0.5", Patterns::Double());
+  prm.declare_entry ("Time step", "0.1", Patterns::Double());
+  prm.declare_entry ("End time", "1",  Patterns::Double());
+  prm.leave_subsection ();
+  prm.leave_subsection ();
+
+  prm.enter_subsection ("Solver");
+  prm.declare_entry ("Preconditioning", "none",
+                    Patterns::Selection ("none|jacobi|sor|ssor"));
+  prm.declare_entry ("Extrapolate old solutions", "true",
+                    Patterns::Bool());
+  prm.leave_subsection ();
+
+  prm.enter_subsection ("Output");
+  prm.declare_entry ("Format", "gnuplot",
+                    Patterns::Selection(DataOutInterface<dim>::get_output_format_names()));
+  prm.declare_entry ("Directory", "data");
+  prm.declare_entry ("Directory for temporaries", "data/tmp");
+  prm.declare_entry ("Write solutions", "all sweeps",
+                    Patterns::Selection ("never|all sweeps|last sweep only"));
+  prm.declare_entry ("Write stacked time steps", "false", Patterns::Bool());
+  prm.declare_entry ("Write stacked interval", "1", Patterns::Integer());
+  prm.declare_entry ("Write steps interval", "1", Patterns::Integer());
+  prm.declare_entry ("Write error as cell data", "true", Patterns::Bool());
+  prm.enter_subsection ("Error statistics");
+  prm.declare_entry ("Produce error statistics", "false", Patterns::Bool());
+  prm.declare_entry ("Number of intervals", "10", Patterns::Integer());
+  prm.declare_entry ("Interval spacing", "linear",
+                    Patterns::Selection(Histogram::get_interval_spacing_names()));
+  prm.leave_subsection ();
+  prm.leave_subsection ();
+
+
+  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",
+                    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,
+                                  // to avoid those annoying if then else
+                                  // clauses...
+  map<string,BoundaryConditions> boundary_conditions_list;
+  boundary_conditions_list["wave from left"]        = wave_from_left;
+  boundary_conditions_list["fast wave from left"]   = fast_wave_from_left;
+  boundary_conditions_list["wave from left center"] = wave_from_left_center;
+  boundary_conditions_list["wave from left bottom"] = wave_from_left_bottom;
+  boundary_conditions_list["zero"] = zero;
+  
+  map<string,Preconditioning> preconditioning_list;
+  preconditioning_list["jacobi"] = jacobi;
+  preconditioning_list["sor"]    = sor;
+  preconditioning_list["ssor"]   = ssor;
+  preconditioning_list["none"]   = no_preconditioning;
+  
+  map<string,WriteStrategy> write_strategy_list;
+  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");
+  initial_refinement = prm.get_integer ("Initial refinement");
+                                  // don't make the grid here already, since
+                                  // it may depend on the chosen boundary
+                                  // conditions (which need some boundary
+                                  // flags to be set), etc.
+
+  prm.enter_subsection ("Refinement");
+  {
+    refinement_fraction.first   = prm.get_double ("Refinement fraction");
+    refinement_fraction.second  = prm.get_double ("Coarsening fraction");
+    compare_indicators_globally = prm.get_bool ("Compare indicators globally");
+    maximum_refinement          = prm.get_integer ("Maximum refinement");
+    adapt_mesh_to_dual_solution = prm.get_bool ("Adapt mesh to dual solution");
+    primal_to_dual_weight       = prm.get_double ("Primal to dual weight");
+    initial_energy_estimator_sweeps = prm.get_integer("Initial energy estimator sweeps");
+  };
+  prm.leave_subsection ();
+
+  prm.enter_subsection ("Mesh smoothing");
+  {
+    cell_number_corridor.first  = prm.get_double ("Top cell number deviation");
+    cell_number_corridor.second = prm.get_double ("Bottom cell number deviation");
+    cell_number_correction_steps= prm.get_integer ("Cell number correction steps");
+  };
+  prm.leave_subsection ();
+
+  renumber_dofs               = prm.get_bool ("Renumber dofs");
+  prm.leave_subsection ();
+
+  prm.enter_subsection ("Equation data");
+  set_coefficient_functions (prm.get("Coefficient"));
+  set_initial_functions (prm.get("Initial u"), prm.get("Initial v"));
+  boundary_conditions = boundary_conditions_list[prm.get("Boundary")];
+  set_boundary_functions (prm.get("Boundary"));  
+  Assert (boundary_conditions_list.find(prm.get("Boundary")) !=
+         boundary_conditions_list.end(),
+         ExcParameterNotInList(prm.get("Boundary")));
+  prm.leave_subsection ();
+  
+  prm.enter_subsection ("Discretization");
+  primal_fe = prm.get("Primal FE");
+  dual_fe = prm.get("Dual FE");
+  prm.enter_subsection ("Time stepping");
+  theta    = prm.get_double ("Theta");
+  time_step= prm.get_double ("Time step");
+  end_time = prm.get_double ("End time");
+  prm.leave_subsection ();
+  prm.leave_subsection ();
+
+  prm.enter_subsection ("Solver");
+  preconditioning = preconditioning_list[prm.get("Preconditioning")];
+  Assert (preconditioning_list.find(prm.get("Preconditioning")) !=
+         preconditioning_list.end(),
+         ExcParameterNotInList(prm.get("Preconditioning")));
+  extrapolate_old_solutions = prm.get_bool ("Extrapolate old solutions");
+  prm.leave_subsection ();
+  
+  prm.enter_subsection ("Output");
+  output_format = prm.get("Format");
+  output_directory = prm.get("Directory");
+  if (output_directory[output_directory.size()-1] != '/')
+    output_directory += '/';
+  tmp_directory = prm.get ("Directory for temporaries");
+  if (tmp_directory[tmp_directory.size()-1] != '/')
+    tmp_directory += '/';
+  write_solution_strategy = write_strategy_list[prm.get("Write solutions")];
+  Assert (write_strategy_list.find(prm.get("Write solutions")) !=
+         write_strategy_list.end(),
+         ExcParameterNotInList(prm.get("Write solutions")));
+  write_stacked_data       = prm.get_bool ("Write stacked time steps");
+  write_stacked_interval   = prm.get_integer ("Write stacked interval");
+  write_steps_interval     = prm.get_integer ("Write steps interval");
+  write_error_as_cell_data = prm.get_bool ("Write error as cell data");
+  prm.enter_subsection ("Error statistics");
+  produce_error_statistics = prm.get_bool ("Produce error statistics");
+  error_statistic_intervals= prm.get_integer ("Number of intervals");
+  error_statistics_scaling = prm.get ("Interval spacing");
+  prm.leave_subsection ();
+  prm.leave_subsection ();
+
+
+  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")
+    refinement_strategy = energy_estimator;
+  else
+    refinement_strategy = dual_estimator;
+
+  number_of_sweeps = prm.get_integer ("Sweeps");
+
+                                  // now that we know everything, we can make
+                                  // the grid
+  prm.enter_subsection ("Grid");
+  make_coarse_grid (prm.get("Coarse mesh"));
+  prm.leave_subsection ();
+};
+
+
+
+
+// explicit instantiations
+template class WaveParameters<2>;
+/* $Id$ */
+
+#include <basic/data_out_stack.h>
+#include <grid/dof.h>  //??
+#include <lac/vector.h>
+
+
+template <int dim>
+SweepData<dim>::SweepData (const bool use_data_out_stack) 
+{
+  if (use_data_out_stack)
+    data_out_stack = new DataOutStack<dim>();
+  else
+    data_out_stack = 0;
+};
+
+
+
+template <int dim>
+SweepData<dim>::~SweepData () 
+{
+  if (data_out_stack != 0)
+    delete data_out_stack;
+  data_out_stack = 0;
+};
+
+
+
+
+// explicit instantiations
+template class SweepData<2>;
+/* $Id$ */
+
+
+#include <iomanip>
+#include <ctime>
+
+
+SweepInfo::Data &
+SweepInfo::get_data () 
+{
+  return data;
+};
+
+
+
+SweepInfo::Timers &
+SweepInfo::get_timers () 
+{
+  return timers;
+};
+
+
+
+template <int dim>
+void
+SweepInfo::write_summary (const list<EvaluationBase<dim>*> &eval_list,
+                         ostream &out) const
+{
+  out << "Summary of this sweep:" << endl
+      << "======================" << endl
+      << endl;
+
+  out << "  Accumulated number of cells: " << data.cells       << endl
+      << "  Acc. number of primal dofs : " << data.primal_dofs << endl
+      << "  Acc. number of dual dofs   : " << data.dual_dofs   << endl
+      << "  Accumulated error          : " << data.accumulated_error       << endl;
+  
+  if (eval_list.size() != 0)
+    {
+      out << endl;
+      out << "  Evaluations:" << endl
+         << "  ------------" << endl;
+      
+      for (typename list<EvaluationBase<dim>*>::const_iterator i = eval_list.begin();
+          i != eval_list.end(); ++i)
+//     out << "    "
+//         << (*i)->description ()
+//         << ": "
+//         << setprecision(12) << setw(12)
+//         << (*i)->get_final_result ()
+//          << endl;
+      (*i)->print_final_result (out);
+    };
+
+// exclude timing information for testcase  
+//   out << "  Timing information:" << endl
+//       << "  -------------------" << endl
+//       << "    Time for grid generation : " << timers.grid_generation()  << " secs." << endl
+//       << "    Time for primal problem  : " << timers.primal_problem()   << " secs." << endl
+//       << "    Time for dual problem    : " << timers.dual_problem()     << " secs." << endl
+//       << "    Time for error estimation: " << timers.error_estimation() << " secs." << endl
+//       << "    Time for postprocessing  : " << timers.postprocessing()   << " secs." << endl;
+//   out << endl;
+
+  
+  time_t  time1= time (0);
+  tm     *time = localtime(&time1); 
+  out << "  Time tag: "
+      << time->tm_year+1900 << "/"
+      << time->tm_mon+1 << "/"
+      << time->tm_mday << ' '
+      << int_to_string (time->tm_hour, 2) << ":"
+      << int_to_string (time->tm_min, 2) << ":"
+      << int_to_string (time->tm_sec, 2) << endl;
+};
+
+
+  
+
+
+
+
+SweepInfo::Data::Data () :
+               accumulated_error (0),
+               cells (0),
+               primal_dofs (0),
+               dual_dofs (0)
+{};
+
+
+
+
+
+
+
+// explicit instantiations
+template 
+void SweepInfo::write_summary (const list<EvaluationBase<2>*> &eval_list,
+                              ostream &out) const;
+
+/* $Id$ */
+
+
+#include <base/quadrature.h>
+#include <base/function.h>
+#include <lac/vector.h>
+#include <lac/fullmatrix.h>
+#include <lac/sparsematrix.h>
+#include <lac/solver_cg.h>
+#include <lac/vector_memory.h>
+#include <lac/precondition.h>
+#include <grid/geometry_info.h>
+#include <grid/dof_constraints.h>
+#include <grid/dof.h>
+#include <grid/dof_accessor.h>
+#include <grid/tria_iterator.h>
+#include <grid/tria.h>
+#include <fe/fe.h>
+#include <fe/fe_values.h>
+#include <fe/fe_update_flags.h>
+#include <numerics/matrices.h>
+#include <numerics/dof_renumbering.h>
+
+
+#include <fstream>
+#include <iomanip>
+
+
+
+
+static const pair<unsigned int, double> relaxations[3]
+= { make_pair(100,5), make_pair(300,3), make_pair(500,2) };
+
+
+static const TimeStepBase_Tria<2>::RefinementFlags::CorrectionRelaxations
+wave_correction_relaxations (1,
+                            vector<pair<unsigned int,double> > (&relaxations[0],
+                                                                &relaxations[3]));
+
+
+
+template <int dim>
+TimeStepBase_Wave<dim>::TimeStepBase_Wave ():
+               TimeStepBase_Tria<dim> (),
+               parameters (*static_cast<WaveParameters<dim>*>(0))
+{};
+
+
+
+template <int dim>
+TimeStepBase_Wave<dim>::TimeStepBase_Wave (const double                    time,
+                                          TimeStepBase_Tria<dim>::Flags   flags,
+                                          const WaveParameters<dim>      &parameters)
+               :
+               TimeStepBase_Tria<dim> (time,
+                                       *parameters.coarse_grid,
+                                       flags,
+                                       typename TimeStepBase_Wave<dim>::RefinementFlags
+                                       (parameters.maximum_refinement,
+                                        1,
+                                        0,
+                                        parameters.cell_number_corridor.first,
+                                        parameters.cell_number_corridor.first,
+                                        wave_correction_relaxations,
+                                        parameters.cell_number_correction_steps,
+                                        (parameters.refinement_strategy ==
+                                         WaveParameters<dim>::dual_estimator),
+                                        true)),
+               parameters (parameters)
+{};
+
+
+
+template <int dim>
+const TimeStep_Primal<dim> &
+TimeStepBase_Wave<dim>::get_timestep_primal () const
+{
+  return dynamic_cast<const TimeStep_Primal<dim> &> (*this);
+};
+
+
+
+template <int dim>
+const TimeStep_Dual<dim> &
+TimeStepBase_Wave<dim>::get_timestep_dual () const
+{
+  return dynamic_cast<const TimeStep_Dual<dim> &> (*this);
+};
+
+
+
+template <int dim>
+const TimeStep_Postprocess<dim> &
+TimeStepBase_Wave<dim>::get_timestep_postprocess () const
+{
+  return dynamic_cast<const TimeStep_Postprocess<dim> &> (*this);
+};
+
+
+
+template <int dim>
+string TimeStepBase_Wave<dim>::tmp_filename_base (const string &branch_signature) const
+{
+  return (parameters.tmp_directory +
+         branch_signature + 's' +
+         int_to_string (sweep_no, 2) + 't' +
+         int_to_string (timestep_no, 4));
+};
+
+
+
+template <int dim>
+void TimeStepBase_Wave<dim>::attach_sweep_info (SweepInfo &si)
+{
+  sweep_info = &si;
+};
+
+
+
+template <int dim>
+void TimeStepBase_Wave<dim>::attach_sweep_data (SweepData<dim> &sd)
+{
+  sweep_data = &sd;
+};
+
+
+
+
+
+
+/* --------------------------------------------------------------*/
+
+
+template <int dim>
+TimeStep_Wave<dim>::TimeStep_Wave (const string fe_name) :
+               dof_handler (0),
+               fe (FEHelper<dim>::get_fe(fe_name)),
+               quadrature (FEHelper<dim>::get_quadrature(fe_name)),
+               quadrature_face (FEHelper<dim>::get_quadrature_face(fe_name)),
+               statistic_data()
+{};
+
+
+
+template <int dim>
+TimeStep_Wave<dim>::~TimeStep_Wave ()
+{
+  Assert (dof_handler == 0, ExcInternalError());
+  Assert (constraints.n_constraints() == 0, ExcInternalError());
+  Assert (system_sparsity.empty(), ExcInternalError());
+  Assert (mass_matrix.empty(), ExcInternalError());
+  Assert (laplace_matrix.empty(), ExcInternalError());
+  Assert (u.size() ==0, ExcInternalError());
+  Assert (v.size() ==0, ExcInternalError());
+};
+
+                                  
+
+template <int dim>
+void TimeStep_Wave<dim>::wake_up (const unsigned int wakeup_level) 
+{
+                                  // only do something if we are
+                                  // right at the beginning of a
+                                  // time level
+  if (wakeup_level==0)
+    {
+                                      // first make the dof handler
+      Assert (dof_handler==0, ExcInternalError());
+
+      sweep_info->get_timers().grid_generation.start();
+
+      dof_handler = new DoFHandler<dim>(tria);
+      dof_handler->distribute_dofs (fe);
+
+      if (parameters.renumber_dofs)
+       DoFRenumbering::Cuthill_McKee (*dof_handler);
+      
+
+      constraints.clear ();
+      dof_handler->make_hanging_node_constraints (constraints);
+      constraints.close ();
+
+      sweep_info->get_timers().grid_generation.stop();
+      
+      Assert (u.size()==0, ExcInternalError ());
+      Assert (v.size()==0, ExcInternalError ());
+
+      switch (next_action)
+       {
+         case primal_problem:
+         case dual_problem:
+         {
+                                            // assert that this function only
+                                            // wakes up data members in the right
+                                            // branch of the multiple inheritance
+                                            // lattice, i.e. the dual problem
+                                            // branch may only be woken up if the
+                                            // dual problem is solved and vica
+                                            // versa
+           Assert (((next_action == primal_problem) &&
+                    (static_cast<const TimeStep_Wave<dim>*>(&get_timestep_primal())
+                     == this))
+                   ||
+                   ((next_action == dual_problem) &&
+                    (static_cast<const TimeStep_Wave<dim>*>(&get_timestep_dual())
+                     == this)),
+                   ExcInternalError());
+           
+                                            // if we are to extrapolate the old
+                                            // solutions, we overwrite the previous
+                                            // content of the vectors anyway, so
+                                            // we can use the fast initialization
+           u.reinit (dof_handler->n_dofs(),
+                     parameters.extrapolate_old_solutions && (timestep_no!=0));
+           v.reinit (dof_handler->n_dofs(),
+                     parameters.extrapolate_old_solutions && (timestep_no!=0));
+           break;
+         };
+          
+         case postprocess:
+         {
+           sweep_info->get_timers().postprocessing.start();
+                                            // reload data vectors from disk
+           ifstream tmp_in(tmp_filename_base(branch_signature()).c_str());
+           u.block_read (tmp_in);
+           v.block_read (tmp_in);
+           tmp_in.close ();
+
+           sweep_info->get_timers().postprocessing.stop();
+                   
+           break;
+         };
+          
+         default:
+               Assert (false, ExcInternalError());
+       };
+    };
+};
+
+
+
+template <int dim>
+void TimeStep_Wave<dim>::sleep (const unsigned int sleep_level) 
+{
+  switch (sleep_level)
+    {
+      case 1:
+      {
+       Assert (dof_handler!=0, ExcInternalError());
+      
+       delete dof_handler;
+       dof_handler = 0;
+
+       Assert (u.size() != 0, ExcInternalError());
+       Assert (v.size() != 0, ExcInternalError());
+
+       ofstream tmp_out(tmp_filename_base(branch_signature()).c_str());
+       u.block_write (tmp_out);
+       v.block_write (tmp_out);
+       tmp_out.close ();
+       
+       u.reinit (0);
+       v.reinit (0);
+       
+       Assert (constraints.n_constraints() == 0, ExcInternalError());
+       Assert (system_sparsity.empty(), ExcInternalError());
+       Assert (mass_matrix.empty(), ExcInternalError());
+       Assert (laplace_matrix.empty(), ExcInternalError());
+
+       break;
+      };
+
+      case 0:
+      {
+                                        // these are the data we don't need
+                                        // any more right after the time step
+                                        // do this action for the derived classes
+       constraints.clear ();
+       system_sparsity.reinit (0,0,0);
+       mass_matrix.reinit (system_sparsity);
+       laplace_matrix.reinit (system_sparsity);
+
+       break;
+      };
+
+      default:
+           Assert (false, ExcInternalError());
+    };
+};
+
+
+
+template <int dim>
+void TimeStep_Wave<dim>::end_sweep ()
+{
+  string tmp_filename = tmp_filename_base(branch_signature());
+  remove (tmp_filename.c_str());
+};
+
+
+    
+template <int dim>
+unsigned int TimeStep_Wave<dim>::solve (const UserMatrix       &matrix,
+                                       Vector<double>         &solution,
+                                       const Vector<double>   &rhs) const {
+  SolverControl                    control(2000, 1.e-12);
+  PrimitiveVectorMemory<Vector<double> >   memory;
+  SolverCG<UserMatrix,Vector<double> >     pcg(control,memory);
+
+                                  // solve
+  pcg.solve (matrix, solution, rhs,
+            PreconditionUseMatrix<UserMatrix,Vector<double> >
+            (matrix,
+             &UserMatrix::precondition));
+                                  // distribute solution
+  constraints.distribute (solution);
+
+  return control.last_step();
+};
+
+
+
+template <int dim>
+void TimeStep_Wave<dim>::create_matrices () 
+{        
+                                  // reinitialize sparsity and vector size
+  system_sparsity.reinit (dof_handler->n_dofs(), dof_handler->n_dofs(),
+                         dof_handler->max_couplings_between_dofs());
+                                  // build sparsity pattern and condense
+                                  // with hanging nodes
+  dof_handler->make_sparsity_pattern (system_sparsity);
+  constraints.condense (system_sparsity);
+  system_sparsity.compress ();
+      
+                                      // reinit matrices
+  laplace_matrix.reinit (system_sparsity);
+  mass_matrix.reinit (system_sparsity);
+
+                                  // now actually assemble the matrices
+  const unsigned int total_dofs       = fe.total_dofs,
+                    n_q_points       = quadrature.n_quadrature_points;
+
+  const bool   density_constant = parameters.density_constant,
+            stiffness_constant = parameters.stiffness_constant;
+
+  vector<double> density_values   (n_q_points, 1.);
+  vector<double> stiffness_values (n_q_points, 1.);
+
+                                  // if a coefficient is constant, get
+                                  // its value
+  if (density_constant)
+    fill_n (density_values.begin(), n_q_points, (*parameters.density)(Point<dim>()));
+  if (stiffness_constant)
+    fill_n (stiffness_values.begin(), n_q_points, (*parameters.stiffness)(Point<dim>()));
+  
+  
+  FEValues<dim>  fe_values (fe, quadrature,
+                           UpdateFlags(update_gradients  |
+                                       update_JxW_values |
+                                       (!density_constant || !stiffness_constant ?
+                                        update_q_points :
+                                        0)));
+
+                                  // indices of all the dofs on this
+                                  // cell
+  vector<int>    dof_indices_on_cell (total_dofs);
+  FullMatrix<double> cell_mass_matrix (total_dofs, total_dofs);
+  FullMatrix<double> cell_laplace_matrix (total_dofs, total_dofs);
+
+  
+  for (typename DoFHandler<dim>::active_cell_iterator cell=dof_handler->begin_active();
+       cell != dof_handler->end(); ++cell)
+    {
+      fe_values.reinit (cell);
+      cell_mass_matrix.clear ();
+      cell_laplace_matrix.clear ();
+      cell->get_dof_indices (dof_indices_on_cell);
+
+      const FullMatrix<double>              &shape_values = fe_values.get_shape_values ();
+      const vector<vector<Tensor<1,dim> > > &shape_grads  = fe_values.get_shape_grads ();
+      const vector<double>                  &JxW_values   = fe_values.get_JxW_values ();
+
+                                      // if necessary: get the values of any
+                                      // of the coefficients at the quadrature
+                                      // points
+      if (!density_constant || !stiffness_constant)
+       {
+         const vector<Point<dim> > &quadrature_points = fe_values.get_quadrature_points ();
+         if (!density_constant)
+           parameters.density->value_list (quadrature_points,
+                                           density_values);
+         if (!stiffness_constant)
+           parameters.stiffness->value_list (quadrature_points,
+                                             stiffness_values);
+       };
+      
+                                      // now do the loop
+      for (unsigned int q_point=0; q_point<fe_values.n_quadrature_points; ++q_point)
+       for (unsigned int i=0; i<total_dofs; ++i)
+         for (unsigned int j=0; j<total_dofs; ++j)
+           {
+             cell_mass_matrix(i,j) += (shape_values(i, q_point) *
+                                       shape_values(j, q_point) *
+                                       JxW_values[q_point]      *
+                                       density_values[q_point]);
+             cell_laplace_matrix(i,j) += (shape_grads[i][q_point] *
+                                          shape_grads[j][q_point] *
+                                          JxW_values[q_point]      *
+                                          stiffness_values[q_point]);
+           };
+
+                                      // now transfer to global matrices
+      for (unsigned int i=0; i<total_dofs; ++i)
+       for (unsigned int j=0; j<total_dofs; ++j)
+         {
+           mass_matrix.add(dof_indices_on_cell[i],
+                           dof_indices_on_cell[j],
+                           cell_mass_matrix(i,j));
+           laplace_matrix.add(dof_indices_on_cell[i],
+                              dof_indices_on_cell[j],
+                              cell_laplace_matrix(i,j));
+         };
+    };
+};
+
+
+
+template <int dim>
+void TimeStep_Wave<dim>::transfer_old_solutions (Vector<double> &old_u,
+                                                Vector<double> &old_v) const 
+{
+  const DoFHandler<dim> *present_dof_handler = dof_handler,
+                       *    old_dof_handler = 0;
+  const Vector<double>  *old_grid_u = 0,
+                       *old_grid_v = 0;
+  
+  switch (next_action)
+    {
+      case primal_problem:
+           Assert (previous_timestep != 0, ExcInternalError());
+           
+           old_dof_handler = (static_cast<const TimeStepBase_Wave<dim>*>
+                              (previous_timestep)->get_timestep_primal()).dof_handler;
+           old_grid_u      = &(static_cast<const TimeStepBase_Wave<dim>*>
+                               (previous_timestep)->get_timestep_primal()).u;
+           old_grid_v      = &(static_cast<const TimeStepBase_Wave<dim>*>
+                               (previous_timestep)->get_timestep_primal()).v;
+           
+           break;
+
+      case dual_problem:
+           Assert (next_timestep != 0, ExcInternalError());
+           
+           old_dof_handler = (static_cast<const TimeStepBase_Wave<dim>*>
+                              (next_timestep)->get_timestep_dual()).dof_handler;
+           old_grid_u      = &(static_cast<const TimeStepBase_Wave<dim>*>
+                               (next_timestep)->get_timestep_dual()).u;
+           old_grid_v      = &(static_cast<const TimeStepBase_Wave<dim>*>
+                               (next_timestep)->get_timestep_dual()).v;
+
+           break;
+    };
+  
+  Assert (old_dof_handler != 0, ExcInternalError());
+
+  DoFHandler<dim>::cell_iterator old_cell = old_dof_handler->begin(),
+                                new_cell = present_dof_handler->begin();
+  for (; old_cell != (old_dof_handler->get_tria().n_levels() == 1  ?
+                     static_cast<DoFHandler<dim>::cell_iterator>(old_dof_handler->end()) :
+                     old_dof_handler->begin(1));
+       ++old_cell, new_cell)
+    transfer_old_solutions (old_cell, new_cell,
+                           *old_grid_u, *old_grid_v,
+                           old_u, old_v);
+};
+
+
+
+template <int dim>
+void
+TimeStep_Wave<dim>::transfer_old_solutions (const typename DoFHandler<dim>::cell_iterator &old_cell,
+                                           const typename DoFHandler<dim>::cell_iterator &new_cell,
+                                           const Vector<double>  &old_grid_u,
+                                           const Vector<double>  &old_grid_v,
+                                           Vector<double>        &old_u,
+                                           Vector<double>        &old_v) const 
+{
+  if (!old_cell->has_children() && !new_cell->has_children()) 
+    {
+                                      // none of the children are active, so
+                                      // recurse into the triangulation
+      for (unsigned int c=0; c<GeometryInfo<dim>::children_per_cell; ++c)
+       transfer_old_solutions (old_cell->child(c),
+                               new_cell->child(c),
+                               old_grid_u, old_grid_v,
+                               old_u, old_v);
+    }
+  else
+                                    // one of the cells is active
+    {
+                                      // get values from
+                                      // old cell and set on the new one
+      Vector<double> cell_data (fe.total_dofs);
+
+      old_cell->get_interpolated_dof_values (old_grid_u, cell_data);
+      new_cell->set_dof_values_by_interpolation (cell_data, old_u);
+      
+      old_cell->get_interpolated_dof_values (old_grid_v, cell_data);
+      new_cell->set_dof_values_by_interpolation (cell_data, old_v);
+    };
+};
+
+
+
+template <int dim>
+pair<double,double>
+TimeStep_Wave<dim>::compute_energy () {
+  pair<double,double> energy;
+  
+  switch (next_action)
+    {
+      case primal_problem:
+           energy.first = 0.5*laplace_matrix.matrix_norm (u);
+           energy.second = 0.5*mass_matrix.matrix_norm(v);
+           break;
+
+      case dual_problem:
+           energy.first = 0.5*laplace_matrix.matrix_norm (v);
+           energy.second = 0.5*mass_matrix.matrix_norm(u);
+           break;
+
+      default:
+           Assert (false, ExcInternalError());
+    };
+
+  return energy;
+};
+
+
+
+template <int dim>
+TimeStep_Wave<dim>::StatisticData::
+StatisticData () :
+               n_active_cells (0),
+               n_dofs (0),
+               n_solver_steps_helmholtz (0),
+               n_solver_steps_projection (0),
+               energy (make_pair(0.0, 0.0))
+{};
+
+
+
+template <int dim>
+TimeStep_Wave<dim>::StatisticData::
+StatisticData (const unsigned int        n_active_cells,
+              const unsigned int        n_dofs,
+              const unsigned int        n_solver_steps_helmholtz,
+              const unsigned int        n_solver_steps_projection,
+              const pair<double,double> energy) :
+               n_active_cells (n_active_cells),
+               n_dofs (n_dofs),
+               n_solver_steps_helmholtz (n_solver_steps_helmholtz),
+               n_solver_steps_projection (n_solver_steps_projection),
+               energy (energy)
+{};
+
+
+
+template <int dim>
+void
+TimeStep_Wave<dim>::StatisticData::write_descriptions (ostream &out) 
+{
+  out << "#    number of active cells"                 << endl
+      << "#    number of degrees of freedom"           << endl
+      << "#    iterations for the helmholtz equation"  << endl
+      << "#    iterations for the projection equation" << endl
+      << "#    elastic energy"                         << endl
+      << "#    kinetic energy"                         << endl
+      << "#    total energy"                           << endl;
+};
+
+
+
+template <int dim>
+void TimeStep_Wave<dim>::StatisticData::write (ostream &out) const
+{
+  out << setw(6) << n_active_cells             << ' '
+      << setw(6) << n_dofs                     << ' '
+      << setw(3) << n_solver_steps_helmholtz   << ' '
+      << setw(3) << n_solver_steps_projection  << ' '
+      << setprecision(4) << setw(6) << energy.first               << ' '
+      << setprecision(4) << setw(6) << energy.second              << ' '
+      << setprecision(6) << setw(8) << energy.first+energy.second;
+};
+
+
+
+
+
+
+
+// explicit instantiations
+template class TimeStepBase_Wave<2>;
+template class TimeStep_Wave<2>;
+/* $Id$ */
+
+#include <base/function.h>
+#include <lac/fullmatrix.h>
+#include <lac/vector.h>
+#include <lac/sparsematrix.h>
+#include <grid/tria.h>
+#include <grid/dof.h>
+#include <grid/dof_constraints.h>
+#include <grid/dof_accessor.h>
+#include <grid/tria_iterator.h>
+#include <fe/fe_values.h>
+#include <fe/fe.h>
+#include <numerics/vectors.h>
+#include <numerics/matrices.h>
+
+
+#include <iomanip>
+
+
+
+template <int dim>
+TimeStep_Dual<dim>::TimeStep_Dual (const string &dual_fe)
+               :
+               TimeStep_Wave<dim> (dual_fe)
+{};
+
+
+
+template <int dim>
+void TimeStep_Dual<dim>::do_initial_step () {
+  cout << "  Dual problem: time="
+       << setprecision(4) << setw(6) << time
+       << ", step=" << setw(4) << timestep_no
+       << ", sweep=" << setw(2) << sweep_no
+       << ". "
+       << tria->n_active_cells() << " cells, "
+       << dof_handler->n_dofs() << " dofs" << flush;
+  
+                                  // add up sweep-accumulated data. count
+                                  // u and v as separate dofs
+                                  //
+                                  // do not add up cells, since this is already
+                                  // done in the primal problem
+  sweep_info->get_data().dual_dofs += dof_handler->n_dofs() * 2;
+
+  Vector<double> tmp_u_bar, tmp_v_bar;
+
+                                  // get evaluation of dual functional
+                                  // at end time
+  parameters.dual_functional->reset (*this);
+  parameters.dual_functional->
+    compute_endtime_vectors (tmp_u_bar, tmp_v_bar);
+                                  // compute final values for the dual
+                                  // problem by projection, i.e. by
+                                  // inversion of the mass matrix; don't
+                                  // do so if the solution will be zero
+                                  // (inversion would not take long, but
+                                  // assembling the matrices is expensive)
+  u.reinit (tmp_u_bar.size());
+  v.reinit (tmp_v_bar.size());
+  if ((tmp_u_bar.linfty_norm() > 0) || (tmp_v_bar.linfty_norm() > 0))
+    {
+      UserMatrix system_matrix (system_sparsity,
+                               parameters.preconditioning);
+      system_matrix.copy_from (mass_matrix);
+      constraints.condense (system_matrix);
+      const unsigned int
+       solver_steps1 = solve (system_matrix, u, tmp_u_bar),
+       solver_steps2 = solve (system_matrix, v, tmp_v_bar);
+
+      statistic_data = StatisticData (tria->n_active_cells(),
+                                     dof_handler->n_dofs(),
+                                     solver_steps1, solver_steps2,
+                                     compute_energy ());
+    }
+  else
+    statistic_data = StatisticData (tria->n_active_cells(),
+                                   dof_handler->n_dofs(),
+                                   0, 0,
+                                   make_pair (0.0, 0.0));
+  cout << "." << endl;
+};
+
+
+
+template <int dim>
+void TimeStep_Dual<dim>::do_timestep ()
+{
+  cout << "  Dual problem: time="
+       << setprecision(4) << setw(6) << time
+       << ", step=" << setw(4) << timestep_no
+       << ", sweep=" << setw(2) << sweep_no
+       << ". "
+       << tria->n_active_cells() << " cells, "
+       << dof_handler->n_dofs() << " dofs" << flush;
+
+                                  // add up sweep-accumulated data. count
+                                  // u and v as separate dofs
+                                  //
+                                  // do not add up cells, since this is already
+                                  // done in the primal problem
+  sweep_info->get_data().dual_dofs += dof_handler->n_dofs() * 2;
+
+  const double time_step = get_forward_timestep ();
+
+                                  // Vectors holding the right hand sides of
+                                  // the two equations.
+  Vector<double> right_hand_side1 (dof_handler->n_dofs());
+  Vector<double> right_hand_side2 (dof_handler->n_dofs());
+  
+                                  // Vector holding a the values for
+                                  // u and v of the previous time step.
+                                  // these are used in case we want to
+                                  // use extrapolation from the previous
+                                  // time step to the present one
+  Vector<double> old_u, old_v;
+  if (parameters.extrapolate_old_solutions)
+    {
+      old_u.reinit (dof_handler->n_dofs());
+      old_v.reinit (dof_handler->n_dofs());
+
+      transfer_old_solutions (old_u, old_v);
+    };
+    
+  assemble_vectors (right_hand_side1, right_hand_side2);
+
+  UserMatrix system_matrix (system_sparsity, parameters.preconditioning);
+  system_matrix.copy_from (mass_matrix);
+  system_matrix.add_scaled (time_step * time_step *
+                           parameters.theta *
+                           parameters.theta,
+                           laplace_matrix);
+  constraints.condense (system_matrix);
+       
+  if (parameters.extrapolate_old_solutions)
+                                    // solve with a hopefully good guess
+                                    // as start vector
+    {
+      v  = old_v;
+      v.add (time_step, old_u);
+    };
+                                  // in the other case, the wake_up
+                                  // function of the base class has set
+                                  // the solution vector's values to
+                                  // zero already.
+
+
+                                  // in 1d, do not set boundary conditions
+                                  // at all
+                                  //
+                                  // note: in boundary_value_map, all entries
+                                  // for dirichlet boundary nodes are set to
+                                  // zero. we re-use them later, and because
+                                  // zero is such a universal constant, we
+                                  // don't even need to recompute the values!
+  map<int,double> boundary_value_list;
+  if (dim != 1)
+    {
+      VectorTools<dim>::FunctionMap dirichlet_bc;
+      static const ZeroFunction<dim> boundary_values;
+      
+      dirichlet_bc[0] = &boundary_values;
+      
+      VectorTools<dim>::interpolate_boundary_values (*dof_handler, dirichlet_bc,
+                                                    boundary_value_list);
+      MatrixTools<dim>::apply_boundary_values (boundary_value_list,
+                                              system_matrix, v,
+                                              right_hand_side1);
+    };
+  
+  const unsigned int solver_steps1 = solve (system_matrix, v, right_hand_side1);
+       
+  system_matrix.copy_from (mass_matrix);
+  constraints.condense (system_matrix);
+  if (true)
+    {
+      Vector<double> tmp (right_hand_side2.size());
+      laplace_matrix.vmult (tmp, v);
+      right_hand_side2.add (-parameters.theta*time_step, tmp);
+    };
+  constraints.condense (right_hand_side2);
+                                  ///////////////////////////
+                                  // This is not ok here, for two reasons:
+                                  // 1. it assumes that for v the same
+                                  //    bc hold as for u; build the list
+                                  //    of bc for v separately, this way
+                                  //    it only holds for u=v=0
+                                  // 2. v has no boundary conditions at
+                                  //    all!
+                                  ///////////////////////////
+  if (dim != 1)
+                                    // note: the values in boundary_value_map
+                                    // are already set for the first component
+                                    // and have not been touched since.
+    MatrixTools<dim>::apply_boundary_values (boundary_value_list,
+                                            system_matrix, u,
+                                            right_hand_side2);
+  
+  if (parameters.extrapolate_old_solutions)
+                                    // solve with a hopefully good guess
+                                    // as start vector
+    {
+      u  = v;
+      u -= old_v;
+      u.scale (2./time_step);
+      u -= old_u;
+    };
+  
+  const unsigned int solver_steps2 = solve (system_matrix, u, right_hand_side2);
+
+  statistic_data = StatisticData (tria->n_active_cells(),
+                                 dof_handler->n_dofs(),
+                                 solver_steps1,
+                                 solver_steps2,
+                                 compute_energy ());
+  
+  cout << "." << endl;
+};
+
+
+
+
+template <int dim>
+void TimeStep_Dual<dim>::solve_dual_problem ()
+{
+  sweep_info->get_timers().dual_problem.start();
+  if (next_timestep == 0)
+    do_initial_step ();
+  else
+    do_timestep ();
+  sweep_info->get_timers().dual_problem.stop();
+};
+
+
+
+template <int dim>
+string TimeStep_Dual<dim>::branch_signature () const 
+{
+  return "d";
+};
+
+
+
+template <int dim>
+void TimeStep_Dual<dim>::wake_up (const unsigned int wakeup_level)
+{
+  TimeStep_Wave<dim>::wake_up (wakeup_level);
+  
+  sweep_info->get_timers().dual_problem.start();
+  if ((wakeup_level==0) && (next_action==dual_problem))
+    {
+      Assert (system_sparsity.empty(), ExcInternalError());
+      
+      create_matrices ();
+    };
+  sweep_info->get_timers().dual_problem.stop();
+};
+
+
+
+template <int dim>
+void TimeStep_Dual<dim>::assemble_vectors (Vector<double> &right_hand_side1,
+                                          Vector<double> &right_hand_side2) {
+                                  // don't do some things for the initial
+                                  // step since we don't need them there
+  Assert (next_timestep != 0, ExcInternalError());
+  
+                                  // construct right hand side
+  build_rhs (right_hand_side1, right_hand_side2);
+
+                                  // compute contributions of error
+                                  // functional to right hand sides
+  Vector<double> dual1, dual2;
+  parameters.dual_functional->reset (*this);
+  parameters.dual_functional->compute_functionals (dual1, dual2);
+
+  const double timestep = get_forward_timestep();
+  right_hand_side1.add (timestep, dual2);
+  right_hand_side1.add (parameters.theta * timestep * timestep, dual1);
+
+  right_hand_side2.add (timestep, dual1);
+
+                                  // condense right hand side in-place
+  constraints.condense (right_hand_side1);
+};
+
+
+
+template <int dim>
+void TimeStep_Dual<dim>::build_rhs (Vector<double> &right_hand_side1,
+                                   Vector<double> &right_hand_side2) {
+                                  // select the TimeStep_Wave part in the
+                                  // TimeStep_Primal branch
+  const TimeStep_Dual<dim> &previous_time_level
+    = static_cast<const TimeStepBase_Wave<dim>*>(next_timestep)->get_timestep_dual();
+
+  Assert (previous_time_level.tria->n_cells(0) == tria->n_cells(0),
+         ExcCoarsestGridsDiffer());
+
+                                  // convenience typedef
+  typedef DoFHandler<dim>::cell_iterator cell_iterator;
+
+                                  // create this here and pass it to
+                                  // the cellwise function since it
+                                  // is expensive to create it for
+                                  // every cell
+  FEValues<dim> fe_values (fe, quadrature,
+                          UpdateFlags(update_gradients |
+                                      update_JxW_values |
+                                      update_q_points));
+
+  
+  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()) :
+                           dof_handler->begin(1));  
+  for (; new_cell!=end_cell; ++new_cell, ++old_cell)
+    build_rhs (old_cell, new_cell,
+              fe_values,
+              right_hand_side1, right_hand_side2);
+};
+
+
+
+template <int dim>
+void
+TimeStep_Dual<dim>::build_rhs (const DoFHandler<dim>::cell_iterator &old_cell,
+                              const DoFHandler<dim>::cell_iterator &new_cell,
+                              FEValues<dim>        &fe_values,
+                              Vector<double>       &right_hand_side1,
+                              Vector<double>       &right_hand_side2) {
+                                  // declare this type for convenience
+  typedef DoFHandler<dim>::cell_iterator cell_iterator;
+
+                                  // both cells have children, so
+                                  // recurse into the tree
+  if (old_cell->has_children() && new_cell->has_children()) 
+    {
+      for (unsigned int child=0; child<GeometryInfo<dim>::children_per_cell; ++child)
+       build_rhs (old_cell->child(child),
+                  new_cell->child(child),
+                  fe_values,
+                  right_hand_side1,
+                  right_hand_side2);
+      return;
+    };
+
+
+                                  // 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();
+
+  const unsigned int total_dofs = fe.total_dofs;
+  const double time_step = get_forward_timestep();
+
+                                  // both cells are on the same refinement
+                                  // level
+  if (!old_cell->has_children() && !new_cell->has_children()) 
+    {
+      fe_values.reinit (old_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 ();
+
+      FullMatrix<double>    cell_matrix (total_dofs, total_dofs);
+
+      vector<double> density_values(fe_values.n_quadrature_points);
+      parameters.density->value_list (fe_values.get_quadrature_points(),
+                                     density_values);
+      for (unsigned int point=0; point<fe_values.n_quadrature_points; ++point)
+       for (unsigned int i=0; i<total_dofs; ++i) 
+         for (unsigned int j=0; j<total_dofs; ++j)
+           cell_matrix(i,j) += (values(i,point) *
+                                values(j,point)) *
+                               weights[point] *
+                               density_values[point];
+
+      Vector<double> tmp (total_dofs);
+                                      // this is the right hand side of the
+                                      // first equation
+                                      // for the theta scheme:
+                                      //    rhs1 := Mv^1 + kMu^1
+                                      //           -(1-theta)theta k^2 Av^1
+      Vector<double> rhs1 (total_dofs);
+
+                                      // this is the part of the right hand side
+                                      // of the second equation which depends
+                                      // on the solutions of the previous time
+                                      // step.
+                                      // for the theta scheme:
+                                      //    rhs2 := Mu^1-(1-theta)kAv^1
+      Vector<double> rhs2 (total_dofs);
+           
+                                      // vector of values of the function on the
+                                      // old grid restricted to one cell
+      Vector<double> old_dof_values_v (total_dofs);
+                                      // vector of old u and v times the local
+                                      // mass matrix
+      Vector<double> local_M_u (total_dofs);
+      Vector<double> local_M_v (total_dofs);
+      Vector<double> local_A_v (total_dofs);      
+                                      // transfer v+k*u. Note that we need
+                                      // old_dof_values_u again below
+      old_cell->get_dof_values (previous_time_level.v, old_dof_values_v);
+      cell_matrix.vmult (local_M_v, old_dof_values_v);
+      
+      old_cell->get_dof_values (previous_time_level.u, tmp);
+      cell_matrix.vmult (local_M_u, tmp);
+
+                                      // now for the part with the laplace
+                                      // matrix
+      cell_matrix.clear ();
+      vector<double> stiffness_values(fe_values.n_quadrature_points);
+      parameters.stiffness->value_list (fe_values.get_quadrature_points(),
+                                       stiffness_values);
+      for (unsigned int point=0; point<fe_values.n_quadrature_points; ++point)
+       for (unsigned int i=0; i<total_dofs; ++i) 
+         for (unsigned int j=0; j<total_dofs; ++j)
+           cell_matrix(i,j) += (gradients[i][point] *
+                                gradients[j][point]) *
+                               weights[point] *
+                               stiffness_values[point];
+      cell_matrix.vmult (local_A_v, old_dof_values_v);
+
+      rhs1 = local_M_v;
+      rhs1.add (time_step, local_M_u);
+      rhs1.add ((-time_step*time_step*
+                parameters.theta*
+                (1-parameters.theta)),
+               local_A_v);
+      rhs2 = local_M_u;
+      rhs2.add (-(1-parameters.theta)*
+               time_step,
+               local_A_v);
+
+                                      // transfer into the global
+                                      // right hand side
+      vector<int> new_dof_indices (total_dofs, -1);
+      new_cell->get_dof_indices (new_dof_indices);
+      for (unsigned int i=0; i<total_dofs; ++i)
+       {
+         right_hand_side1(new_dof_indices[i]) += rhs1(i);
+         right_hand_side2(new_dof_indices[i]) += rhs2(i);
+       };
+      
+      return;
+    };
+
+                                  // only old cell is refined
+  if (old_cell->has_children() && !new_cell->has_children())
+    {
+                                      // this is the right hand side of the
+                                      // first equation
+                                      // for the theta scheme:
+                                      //    rhs1 := Mv^0 + kMu^1
+                                      //           -(1-theta)theta k^2 Av^1
+      Vector<double> rhs1 (total_dofs);
+                                      // this is the part of the right hand side
+                                      // of the second equation which depends
+                                      // on the solutions of the previous time
+                                      // step.
+                                      // for the theta scheme:
+                                      //    rhs2 := Mu^1-(1-theta)kAv^1
+      Vector<double> rhs2 (total_dofs);
+
+                                      // collect the contributions of the
+                                      // child cells (and possibly their
+                                      // children as well)
+      collect_from_children (old_cell, fe_values, rhs1, rhs2);
+      
+                                      // transfer into the global
+                                      // right hand side
+      vector<int> new_dof_indices (total_dofs);
+      new_cell->get_dof_indices (new_dof_indices);
+      for (unsigned int i=0; i<total_dofs; ++i) 
+       {
+         right_hand_side1(new_dof_indices[i]) += rhs1(i);
+         right_hand_side2(new_dof_indices[i]) += rhs2(i);
+       };
+
+      return;
+    };
+
+                                  // only new cell is refined
+  if (!old_cell->has_children() && new_cell->has_children())
+    {
+                                      // vector of values of the function
+                                      // on the old grid restricted to
+                                      // the large (old) cell
+      Vector<double>  old_dof_values_u (total_dofs);
+      Vector<double>  old_dof_values_v (total_dofs);
+      old_cell->get_dof_values (previous_time_level.u, old_dof_values_u);
+      old_cell->get_dof_values (previous_time_level.v, old_dof_values_v);
+
+                                      // distribute the contribution of the
+                                      // large old cell to the children on
+                                      // the new cell
+      distribute_to_children (new_cell, fe_values,
+                             old_dof_values_u, old_dof_values_v,
+                             right_hand_side1, right_hand_side2);
+
+      return;
+    };
+
+  Assert (false, ExcInternalError());
+};
+
+
+
+template <int dim>
+unsigned int
+TimeStep_Dual<dim>::collect_from_children (const DoFHandler<dim>::cell_iterator &old_cell,
+                                          FEValues<dim>  &fe_values,
+                                          Vector<double> &rhs1,
+                                          Vector<double> &rhs2) const {
+                                  // maximal difference of levels between the
+                                  // cell to which we write and the cells from
+                                  // which we read. Default is one, but this is
+                                  // increased with each level of recursion
+  unsigned int level_difference = 1;  
+  
+                                  // select the TimeStep_Wave part in the
+                                  // TimeStep_Primal branch
+  const TimeStep_Dual<dim> &previous_time_level
+    = static_cast<const TimeStepBase_Wave<dim>*>(next_timestep)->get_timestep_dual();
+
+  const unsigned int total_dofs = fe.total_dofs;
+  const double time_step = get_forward_timestep();
+
+  FullMatrix<double>   cell_matrix (total_dofs, total_dofs);
+
+                                      // these will hold the values of the
+                                      // solution on the old grid, i.e. on
+                                      // the small cells
+  Vector<double>  local_old_dof_values_u (total_dofs);
+  Vector<double>  local_old_dof_values_v (total_dofs);
+
+                                      // same for the contributions to the
+                                      // right hand sides of the projection
+  Vector<double>  local_M_u (total_dofs);
+  Vector<double>  local_M_v (total_dofs);
+  Vector<double>  local_A_v (total_dofs);
+      
+                                  // this is the right hand side of the
+                                  // first equation
+                                  // for the theta scheme:
+                                  //    rhs1 := Mv^0 + kMu^1
+                                  //           -(1-theta)theta k^2 Av^1
+  Vector<double> child_rhs1 (total_dofs);
+                                  // this is the part of the right hand side
+                                  // of the second equation which depends
+                                  // on the solutions of the previous time
+                                  // step.
+                                  // for the theta scheme:
+                                  //    rhs2 := Mu^1-(1-theta)kAv^1
+  Vector<double> child_rhs2 (total_dofs);
+      
+  for (unsigned int c=0; c<GeometryInfo<dim>::children_per_cell; ++c) 
+    {
+      const DoFHandler<dim>::cell_iterator old_child = old_cell->child(c);
+
+      child_rhs1.clear ();
+      child_rhs2.clear ();
+      
+                                      // if this child is further subdivided:
+                                      // collect the contributions of the
+                                      // children
+      if (old_child->has_children())
+       {
+         const unsigned int l = collect_from_children (old_child, fe_values,
+                                                       child_rhs1, child_rhs2);
+         level_difference = max (l+1, level_difference);
+       }
+      else
+       {
+         fe_values.reinit (old_child);
+         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 ();
+
+                                          // get solutions restricted to small
+                                          // cell
+         old_child->get_dof_values (previous_time_level.u, local_old_dof_values_u);
+         old_child->get_dof_values (previous_time_level.v, local_old_dof_values_v);
+
+                                          // compute M*(v+ku) on the small cell
+         cell_matrix.clear ();
+         vector<double> density_values(fe_values.n_quadrature_points);
+         parameters.density->value_list (fe_values.get_quadrature_points(),
+                                         density_values);
+         for (unsigned int point=0; point<fe_values.n_quadrature_points; ++point)
+           for (unsigned int i=0; i<total_dofs; ++i) 
+             for (unsigned int j=0; j<total_dofs; ++j)
+               cell_matrix(i,j) += (values(i,point) *
+                                    values(j,point)) *
+                                   weights[point] *
+                                   density_values[point];
+
+         cell_matrix.vmult (local_M_u, local_old_dof_values_u);
+         cell_matrix.vmult (local_M_v, local_old_dof_values_v);
+
+                                          // now for the part with the laplace
+                                          // matrix
+         cell_matrix.clear ();
+         vector<double> stiffness_values(fe_values.n_quadrature_points);
+         parameters.stiffness->value_list (fe_values.get_quadrature_points(),
+                                               stiffness_values);
+         for (unsigned int point=0; point<fe_values.n_quadrature_points; ++point)
+           for (unsigned int i=0; i<total_dofs; ++i) 
+             for (unsigned int j=0; j<total_dofs; ++j)
+               cell_matrix(i,j) += (gradients[i][point] *
+                                    gradients[j][point]) *
+                                   weights[point] *
+                                   stiffness_values[point];
+         cell_matrix.vmult (local_A_v, local_old_dof_values_v);
+         
+         child_rhs1 = local_M_v;
+         child_rhs1.add (time_step, local_M_u);
+         child_rhs1.add ((-time_step*time_step*
+                          parameters.theta*
+                          (1-parameters.theta)),
+                         local_A_v);
+         child_rhs2 = local_M_u;
+         child_rhs2.add (-(1-parameters.theta)*
+                         time_step,
+                         local_A_v);
+       };
+      
+                                      // transfer the contribution of this
+                                      // child cell to its parent cell
+                                      // (#true# means: add up)
+      fe.prolongate(c).Tvmult (rhs1, child_rhs1, true);
+      fe.prolongate(c).Tvmult (rhs2, child_rhs2, true);
+    };
+
+  return level_difference;
+};
+
+
+
+template <int dim>
+unsigned int
+TimeStep_Dual<dim>::distribute_to_children (const DoFHandler<dim>::cell_iterator &new_cell,
+                                           FEValues<dim>         &fe_values,
+                                           const Vector<double>  &old_dof_values_u,
+                                           const Vector<double>  &old_dof_values_v,
+                                           Vector<double>        &right_hand_side1,
+                                           Vector<double>        &right_hand_side2) {
+                                  // maximal difference of levels between the
+                                  // cell to which we write and the cells from
+                                  // which we read. Default is one, but this is
+                                  // increased with each level of recursion
+  unsigned int level_difference = 1;  
+  
+  const unsigned int total_dofs = fe.total_dofs;
+  const double time_step = get_forward_timestep();
+
+  FullMatrix<double>    cell_matrix(total_dofs, total_dofs);
+                                  // set up a vector which will hold the
+                                  // restriction of the old
+                                  // functions (u,v) to a childcell
+  Vector<double> local_old_dof_values_u (total_dofs);
+  Vector<double> local_old_dof_values_v (total_dofs);
+
+                                  // vector of old u and v times the local
+                                  // mass matrix (on the small cells
+                                  // respectively)
+  Vector<double> local_M_u (total_dofs);
+  Vector<double> local_M_v (total_dofs);
+  Vector<double> local_A_v (total_dofs);
+
+                                  // this is the right hand side of the
+                                  // first equation
+                                  // for the theta scheme:
+                                  //    rhs1 := Mv^1 + kMu^1
+                                  //           -(1-theta)theta k^2 Av^1
+  Vector<double> rhs1 (total_dofs);
+
+                                  // this is the part of the right hand side
+                                  // of the second equation which depends
+                                  // on the solutions of the previous time
+                                  // step.
+                                  // for the theta scheme:
+                                  //    rhs2 := Mu^1-(1-theta)kAv^1
+  Vector<double> rhs2 (total_dofs);
+           
+                                  // indices of the dofs of a cell on
+                                  // the new grid
+  vector<int> new_dof_indices (total_dofs, -1);
+
+      
+                                      // 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);
+
+                                      // get u and v on the childcells
+      fe.prolongate(c).vmult (local_old_dof_values_u,
+                                  old_dof_values_u);
+      fe.prolongate(c).vmult (local_old_dof_values_v,
+                                  old_dof_values_v);
+
+      if (new_child->has_children())
+                                        // cell on new grid is further refined
+                                        // distribute data on this local cell
+                                        // to its children
+       {
+         const unsigned int l = distribute_to_children (new_child, fe_values,
+                                                        local_old_dof_values_u,
+                                                        local_old_dof_values_v,
+                                                        right_hand_side1,
+                                                        right_hand_side2);
+         level_difference = max (l+1, level_difference);
+       }
+      else
+                                        // child is not further refined
+                                        // -> directly distribute data
+       {
+         fe_values.reinit (new_child);
+         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 ();
+
+                                          // transfer v+ku
+         cell_matrix.clear ();
+         vector<double> density_values(fe_values.n_quadrature_points);
+         parameters.density->value_list (fe_values.get_quadrature_points(),
+                                         density_values);
+         for (unsigned int point=0; point<fe_values.n_quadrature_points; ++point)
+           for (unsigned int i=0; i<total_dofs; ++i) 
+             for (unsigned int j=0; j<total_dofs; ++j)
+               cell_matrix(i,j) += (values(i,point) *
+                                    values(j,point)) *
+                                   weights[point] *
+                                   density_values[point];
+
+         cell_matrix.vmult (local_M_u, local_old_dof_values_u);
+         cell_matrix.vmult (local_M_v, local_old_dof_values_v);
+
+                                          // now for the part with the laplace
+                                          // matrix
+         cell_matrix.clear ();
+         vector<double> stiffness_values(fe_values.n_quadrature_points);
+         parameters.stiffness->value_list (fe_values.get_quadrature_points(),
+                                           stiffness_values);
+         for (unsigned int point=0; point<fe_values.n_quadrature_points; ++point)
+           for (unsigned int i=0; i<total_dofs; ++i) 
+             for (unsigned int j=0; j<total_dofs; ++j)
+               cell_matrix(i,j) += (gradients[i][point] *
+                                    gradients[j][point]) *
+                                   weights[point] *
+                                   stiffness_values[point];
+         cell_matrix.vmult (local_A_v, local_old_dof_values_v);
+
+         rhs1 = local_M_v;
+         rhs1.add (time_step, local_M_u);
+         rhs1.add ((-time_step*time_step*
+                    parameters.theta*
+                    (1-parameters.theta)),
+                   local_A_v);
+         rhs2 = local_M_u;
+         rhs2.add (-(1-parameters.theta)*
+                   time_step,
+                   local_A_v);
+         
+                                          // transfer into the global
+                                          // right hand side
+         new_child->get_dof_indices (new_dof_indices);
+         for (unsigned int i=0; i<total_dofs; ++i)
+           {
+             right_hand_side1(new_dof_indices[i]) += rhs1(i);
+             right_hand_side2(new_dof_indices[i]) += rhs2(i);
+           };
+       };
+    };
+
+  return level_difference;
+};
+
+
+
+
+// explicit instantiations
+template class TimeStep_Dual<2>;
+/* $Id$ */
+
+
+#include <base/tensor.h>
+#include <lac/vector.h>
+#include <grid/tria.h>
+#include <grid/dof.h>
+#include <grid/dof_accessor.h>
+#include <grid/tria_iterator.h>
+#include <grid/dof_constraints.h>
+#include <fe/fe.h>
+#include <fe/fe_values.h>
+#include <numerics/error_estimator.h>
+
+
+#include <fstream>
+#include <iomanip>
+#include <cmath>
+#include <numeric>
+
+
+
+template <int dim>
+TimeStep_ErrorEstimation<dim>::TimeStep_ErrorEstimation () 
+{};
+
+
+
+template <int dim>
+void TimeStep_ErrorEstimation<dim>::estimate_error ()
+{
+  sweep_info->get_timers().error_estimation.start();
+
+  cout << "[ee]" << flush;
+  
+  if ((parameters.refinement_strategy == WaveParameters<dim>::energy_estimator)
+      ||
+      (sweep_no < parameters.initial_energy_estimator_sweeps))
+    estimate_error_energy (0);
+
+  else
+    {
+                                      // can't estimate error
+                                      // this way for the initial
+                                      // time level
+      if (timestep_no != 0)
+       estimate_error_dual ();
+    };
+
+  const double accumulated_error = accumulate (estimated_error_per_cell.begin(),
+                                              estimated_error_per_cell.end(),
+                                              0.0);
+  statistic_data = StatisticData (accumulated_error);
+  sweep_info->get_data().accumulated_error += accumulated_error;
+
+  sweep_info->get_timers().error_estimation.stop();
+};
+
+
+
+template <int dim>
+void TimeStep_ErrorEstimation<dim>::wake_up (const unsigned int wakeup_level)
+{
+  Assert (next_action==postprocess, ExcInternalError());
+
+  if (wakeup_level==0)
+    {
+      Assert (estimated_error_per_cell.size()==0,
+             ExcInternalError());
+      
+      estimated_error_per_cell.reinit (tria->n_active_cells());
+    };
+};
+
+
+
+template <int dim>
+void TimeStep_ErrorEstimation<dim>::sleep (const unsigned int sleep_level)
+{
+  Assert (next_action==postprocess, ExcInternalError());
+
+  if (sleep_level==0)
+    {
+      Assert (estimated_error_per_cell.size()!=0,
+             ExcInternalError());
+
+      ofstream tmp_out(tmp_filename_base(branch_signature()).c_str());
+      estimated_error_per_cell.block_write (tmp_out);
+      tmp_out.close ();
+
+      estimated_error_per_cell.reinit (0);
+    };
+};
+
+
+
+template <int dim>
+void
+TimeStep_ErrorEstimation<dim>::get_tria_refinement_criteria (Vector<float> &indicators) const 
+{
+  get_error_indicators (indicators);
+  for (Vector<float>::iterator i=indicators.begin(); i!=indicators.end(); ++i)
+    *i = fabs(*i);
+};
+
+
+template <int dim>
+void
+TimeStep_ErrorEstimation<dim>::get_error_indicators (Vector<float> &indicators) const 
+{
+  ifstream in (tmp_filename_base(branch_signature()).c_str());
+  indicators.block_read (in);
+};
+
+
+
+template <int dim>
+void TimeStep_ErrorEstimation<dim>::estimate_error_energy (const unsigned int which_variables) {
+  Assert (which_variables<=1, ExcInternalError());
+  
+  KellyErrorEstimator<dim>::FunctionMap neumann_boundary;
+  static ZeroFunction<dim> homogeneous_neumann_bc;
+  neumann_boundary[1] = &homogeneous_neumann_bc;
+
+  const TimeStep_Wave<dim> &target = (which_variables==0 ?
+                                     static_cast<const TimeStep_Wave<dim>&>(get_timestep_primal()) :
+                                     static_cast<const TimeStep_Wave<dim>&>(get_timestep_dual ()));
+
+  KellyErrorEstimator<dim>::estimate (*target.dof_handler,
+                                     target.quadrature_face,
+                                     neumann_boundary,
+                                     (which_variables==0 ?
+                                      target.u :
+                                      target.v),
+                                     estimated_error_per_cell,
+                                     parameters.stiffness);
+
+                                  // if we are at the first time step, we
+                                  // try to adapt the mesh to the variable
+                                  // v also, since in some cases only v.neq.0
+                                  // and then the error indicator results in
+                                  // zero on all cells
+  if (((previous_timestep == 0) && (which_variables==0)) ||
+      ((next_timestep     == 0) && (which_variables==1)  ))
+    {
+      Vector<float> v_estimator(estimated_error_per_cell.size());
+      KellyErrorEstimator<dim>::estimate (*target.dof_handler,
+                                         target.quadrature_face,
+                                         neumann_boundary,
+                                         (which_variables==0 ?
+                                          target.v :
+                                          target.u),
+                                         v_estimator,
+                                         parameters.density);
+      estimated_error_per_cell += v_estimator;
+    };
+};
+
+
+
+template <int dim>
+void TimeStep_ErrorEstimation<dim>::estimate_error_dual () {
+  CellwiseError cellwise_error (tria->n_active_cells());
+
+  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(),
+                            &dual_problem_old = static_cast<const TimeStepBase_Wave<dim>*>
+                                                (previous_timestep)->get_timestep_dual();
+
+
+                                  // first clear the user pointers of
+                                  // the cells we need
+  if (true)
+    {
+      DoFHandler<dim>::active_cell_iterator
+       cell = primal_problem.dof_handler->begin_active();
+      const DoFHandler<dim>::active_cell_iterator
+       endc = primal_problem.dof_handler->end();
+      for (; cell!=endc; ++cell)
+       cell->clear_user_pointer();
+    };
+  
+                                  // set up some matrices used by the
+                                  // functions called in the sequel
+  make_interpolation_matrices ();
+
+                                  // then go recursively through the two
+                                  // grids and collect the data
+  if (true)
+    {
+      FEValues<dim> fe_values (dual_problem.fe,
+                              dual_problem.quadrature,
+                              UpdateFlags(update_gradients |
+                                          update_second_derivatives |
+                                          update_JxW_values |
+                                          update_q_points));
+
+                                      // get dof iterators for the primal
+                                      // and dual dof handlers for the
+                                      // present and the last time level.
+                                      // since the coarse grids are the
+                                      // same and since we only loop
+                                      // over coarse grid cells here,
+                                      // the cells over which we loop
+                                      // match each other
+      DoFHandler<dim>::cell_iterator
+       primal_cell     = primal_problem.dof_handler->begin(),
+       dual_cell       = dual_problem.dof_handler->begin(),
+       primal_cell_old = primal_problem_old.dof_handler->begin(),
+       dual_cell_old   = dual_problem_old.dof_handler->begin();
+                                      // get last cell to loop over. note that
+                                      // we only loop over the coarsest mesh
+                                      // in this function
+      const DoFHandler<dim>::cell_iterator
+       endc            = primal_problem.dof_handler->end(0);
+
+                                      // loop over all corse grid cells, since
+                                      // they are the same on the two time
+                                      // levels
+      for (; primal_cell!=endc; (++primal_cell, ++dual_cell,
+                                ++primal_cell_old, ++dual_cell_old))
+       estimate_error_dual (primal_cell, dual_cell,
+                            primal_cell_old, dual_cell_old,
+                            cellwise_error,
+                            fe_values);
+
+      Assert (cellwise_error.next_free_slot == cellwise_error.errors.end(),
+             ::ExcInternalError());
+    };
+
+                                  // compute the sum of the errors
+                                  // on the cells
+  ErrorOnCell total_estimated_error;
+  
+
+                                  // 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
+    cell = primal_problem.dof_handler->begin_active();
+  const DoFHandler<dim>::active_cell_iterator
+    endc = primal_problem.dof_handler->end();
+  for (; cell!=endc; ++cell, ++i)
+    {
+      const typename vector<ErrorOnCell>::iterator
+       error_on_this_cell = static_cast<typename vector<ErrorOnCell>::iterator>(cell->user_pointer());
+      Assert (error_on_this_cell != 0, ::ExcInternalError());
+
+      cell->clear_user_pointer ();
+      
+      *i = error_on_this_cell->sum();
+      total_estimated_error += *error_on_this_cell;
+    };
+};
+
+
+
+template <int dim>
+void
+TimeStep_ErrorEstimation<dim>::estimate_error_dual (const DoFHandler<dim>::cell_iterator &primal_cell,
+                                                   const DoFHandler<dim>::cell_iterator &dual_cell,
+                                                   const DoFHandler<dim>::cell_iterator &primal_cell_old,
+                                                   const DoFHandler<dim>::cell_iterator &dual_cell_old,
+                                                   CellwiseError  &cellwise_error,
+                                                   FEValues<dim>  &fe_values) const {
+  
+                                  // if both of the two cells have children:
+                                  // recurse into the grid
+  if (primal_cell->has_children() && primal_cell_old->has_children())
+    {
+      for (unsigned int child=0; child<GeometryInfo<dim>::children_per_cell; ++child)
+       estimate_error_dual (primal_cell->child(child),
+                            dual_cell->child(child),
+                            primal_cell_old->child(child),
+                            dual_cell_old->child(child),
+                            cellwise_error,
+                            fe_values);
+      return;
+    };
+
+  
+
+  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(),
+                            &dual_problem_old = static_cast<const TimeStepBase_Wave<dim>*>
+                                                (previous_timestep)->get_timestep_dual();
+
+  const FiniteElement<dim> &primal_fe = get_timestep_primal().fe,
+                          &dual_fe   = get_timestep_dual().fe;
+
+  const unsigned int        total_dofs_primal = primal_fe.total_dofs,
+                           total_dofs_dual   = dual_fe.total_dofs;  
+
+
+                                  // none of the two cells has children
+  if (!primal_cell->has_children() && !primal_cell_old->has_children())
+    {
+                                      // vector holding the solutions on
+                                      // this time level. u and v will
+                                      // hold the solution interpolated
+                                      // up to the ansatz degree of the
+                                      // dual problem.
+      Vector<double> local_u(total_dofs_dual), local_v(total_dofs_dual);
+      Vector<double> local_u_bar(total_dofs_dual), local_v_bar(total_dofs_dual);
+
+                                      // same thing for old solutions
+      Vector<double> local_u_old(total_dofs_dual), local_v_old(total_dofs_dual);
+      Vector<double> local_u_bar_old(total_dofs_dual), local_v_bar_old(total_dofs_dual);
+
+                                      // vectors to hold dof values on
+                                      // the primal/dual cell (temporary)
+      Vector<double> primal_tmp(total_dofs_primal);
+      
+                                      // fill local solution vectors
+      primal_cell->get_dof_values (primal_problem.u, primal_tmp);
+      embedding_matrix.vmult (local_u, primal_tmp);
+
+      primal_cell->get_dof_values (primal_problem.v, primal_tmp);
+      embedding_matrix.vmult (local_v, primal_tmp);
+
+      dual_cell->get_dof_values (dual_problem.u, local_u_bar);
+      dual_cell->get_dof_values (dual_problem.v, local_v_bar);
+
+
+                                      // 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);
+      embedding_matrix.vmult (local_u_old, primal_tmp);
+
+      primal_cell_old->get_dof_values (primal_problem_old.v, primal_tmp);
+      embedding_matrix.vmult (local_v_old, primal_tmp);
+
+      dual_cell_old->get_dof_values (dual_problem_old.u, local_u_bar_old);
+      dual_cell_old->get_dof_values (dual_problem_old.v, local_v_bar_old);
+
+                                      // store the error on this cell
+      primal_cell->set_user_pointer (cellwise_error.next_free_slot);
+      *cellwise_error.next_free_slot = error_formula (dual_cell,
+                                                     local_u,     local_v,
+                                                     local_u_bar, local_v_bar,
+                                                     local_u_old,     local_v_old,
+                                                     local_u_bar_old, local_v_bar_old,
+                                                     fe_values);
+      ++cellwise_error.next_free_slot;
+      
+      return;
+    };
+
+
+
+                                  // only new cell has children. handle this
+                                  // case by prolonging the solutions on the
+                                  // old cell to its children and recursing
+                                  // thereon
+  if (!primal_cell_old->has_children() && primal_cell->has_children())
+    {
+      Vector<double> local_u_old(total_dofs_dual), local_v_old(total_dofs_dual);
+      Vector<double> local_u_bar_old(total_dofs_dual), local_v_bar_old(total_dofs_dual);
+
+                                      // vectors to hold dof values on
+                                      // the primal/dual cell (temporary)
+      Vector<double> primal_tmp(total_dofs_primal);
+      
+                                      // 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);
+      embedding_matrix.vmult (local_u_old, primal_tmp);
+  
+      primal_cell_old->get_dof_values (primal_problem_old.v, primal_tmp);
+      embedding_matrix.vmult (local_v_old, primal_tmp);
+  
+      dual_cell_old->get_dof_values (dual_problem_old.u, local_u_bar_old);
+      dual_cell_old->get_dof_values (dual_problem_old.v, local_v_bar_old);
+
+
+      compute_error_on_new_children (primal_cell, dual_cell,
+                                    local_u_old,
+                                    local_v_old,
+                                    local_u_bar_old,
+                                    local_v_bar_old,
+                                    cellwise_error,
+                                    fe_values);
+
+      return;
+    };
+
+
+                                  // 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
+                                  //
+                                  // note that we have to perform the
+                                  // interpolation of the dual solution
+                                  // on the large cell of the new grid
+                                  // and have to pass the interpolant
+                                  // down to the children (which are
+                                  // taken from the old grid)
+  if (primal_cell_old->has_children() && !primal_cell->has_children())
+    {
+                                      // vector holding the solutions on
+                                      // this time level. u and v will
+                                      // hold the solution interpolated
+                                      // up to the ansatz degree of the
+                                      // dual problem.
+      Vector<double> local_u(total_dofs_dual), local_v(total_dofs_dual);
+      Vector<double> local_u_bar(total_dofs_dual), local_v_bar(total_dofs_dual);
+      Vector<double> local_u_bar_old(total_dofs_dual), local_v_bar_old(total_dofs_dual);
+      Vector<double> local_Ih_u_bar(total_dofs_dual), local_Ih_v_bar(total_dofs_dual);
+      Vector<double> local_Ih_u_bar_old(total_dofs_dual), local_Ih_v_bar_old(total_dofs_dual);
+      
+                                      // vectors to hold dof values on
+                                      // the primal/dual cell (temporary)
+      Vector<double> primal_tmp(embedding_matrix.n());
+      
+                                      // fill local solution vectors
+      primal_cell->get_dof_values (primal_problem.u, primal_tmp);
+      embedding_matrix.vmult (local_u, primal_tmp);
+      
+      primal_cell->get_dof_values (primal_problem.v, primal_tmp);
+      embedding_matrix.vmult (local_v, primal_tmp);
+
+                                      // get the dual solution on the new
+                                      // time level to allow its interpolation
+      dual_cell->get_dof_values (dual_problem.u, local_u_bar);
+      dual_cell->get_dof_values (dual_problem.v, local_v_bar);
+
+                                      // now we have to get the interpolant
+                                      // of the dual solution on the old
+                                      // time level. Originally I wanted
+                                      // to do the following
+                                      //      dual_cell_old->get_dof_values
+                                      //       (previous_time_level->u_bar,
+                                      //        local_u_bar_old
+                                      //       );
+                                      //      dual_cell_old->get_dof_values
+                                      //       (previous_time_level->v_bar,
+                                      //        local_v_bar_old
+                                      //       );
+                                      //
+                                      // However, this must fail since
+                                      // dual_cell_old has children and
+                                      // we can't access data values on
+                                      // nonterminal cells...
+                                      //
+                                      // therefore, we use a new function
+                                      // which does exactly this interpolation
+      dual_cell_old->get_interpolated_dof_values (dual_problem_old.u,
+                                                 local_u_bar_old);
+      dual_cell_old->get_interpolated_dof_values (dual_problem_old.v,
+                                                 local_v_bar_old);
+
+                                      // compute the interpolant of w_bar and
+                                      // w_bar_old on the large cell
+      interpolation_matrix.vmult (local_Ih_u_bar, local_u_bar);
+      interpolation_matrix.vmult (local_Ih_v_bar, local_v_bar);
+      interpolation_matrix.vmult (local_Ih_u_bar_old, local_u_bar_old);
+      interpolation_matrix.vmult (local_Ih_v_bar_old, local_v_bar_old);
+
+      primal_cell->set_user_pointer (cellwise_error.next_free_slot);
+      *cellwise_error.next_free_slot
+       = collect_error_from_children (primal_cell_old,
+                                      dual_cell_old,
+                                      local_u,            local_v,
+                                      local_u_bar,        local_v_bar,
+                                      local_Ih_u_bar,     local_Ih_v_bar,
+                                      local_Ih_u_bar_old, local_Ih_v_bar_old,
+                                      fe_values);
+      ++cellwise_error.next_free_slot;
+      
+      return;
+    };
+
+
+  Assert (false, ExcInternalError());
+};
+
+
+
+
+template <int dim>
+void TimeStep_ErrorEstimation<dim>::
+compute_error_on_new_children (const DoFHandler<dim>::cell_iterator &primal_cell,
+                              const DoFHandler<dim>::cell_iterator &dual_cell,
+                              const Vector<double>  &local_u_old,
+                              const Vector<double>  &local_v_old,
+                              const Vector<double>  &local_u_bar_old,
+                              const Vector<double>  &local_v_bar_old,
+                              CellwiseError         &cellwise_error,
+                              FEValues<dim>  &fe_values) const {
+  const TimeStep_Primal<dim> &primal_problem = get_timestep_primal();
+  const TimeStep_Dual<dim>   &dual_problem   = get_timestep_dual();
+
+  const FiniteElement<dim> &dual_fe  = get_timestep_dual().fe;
+  const unsigned int total_dofs_dual = dual_fe.total_dofs;
+  
+  
+  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
+                                      // each of the small cells
+      Vector<double> child_u_old(total_dofs_dual), child_v_old(total_dofs_dual);
+      Vector<double> child_u_bar_old(total_dofs_dual), child_v_bar_old(total_dofs_dual);
+
+      dual_fe.prolongate(child).vmult (child_u_old, local_u_old);
+      dual_fe.prolongate(child).vmult (child_v_old, local_v_old);
+      dual_fe.prolongate(child).vmult (child_u_bar_old, local_u_bar_old);
+      dual_fe.prolongate(child).vmult (child_v_bar_old, local_v_bar_old);
+
+      const DoFHandler<dim>::cell_iterator
+       new_primal_child = primal_cell->child(child),
+       new_dual_child   = dual_cell->child(child);
+
+      if (new_primal_child->has_children())
+                                        // cell on new grid is further refined
+                                        // distribute data on this local cell
+                                        // to its children
+       compute_error_on_new_children (new_primal_child, new_dual_child,
+                                      child_u_old,
+                                      child_v_old,
+                                      child_u_bar_old,
+                                      child_v_bar_old,
+                                      cellwise_error,
+                                      fe_values);
+      else
+                                        // we have reached the final level
+                                        // -> gather the information from
+                                        // the new cell and compute the
+                                        // error
+       {
+                                          // vector holding the solutions on
+                                          // this time level. u and v will
+                                          // hold the solution interpolated
+                                          // up to the ansatz degree of the
+                                          // dual problem.
+         Vector<double> local_u(total_dofs_dual), local_v(total_dofs_dual);
+         Vector<double> local_u_bar(total_dofs_dual), local_v_bar(total_dofs_dual);
+         
+                                          // vectors to hold dof values on
+                                          // the primal/dual cell (temporary)
+         Vector<double> primal_tmp(embedding_matrix.n());
+         
+                                          // fill local solution vectors
+         new_primal_child->get_dof_values (primal_problem.u, primal_tmp);
+         embedding_matrix.vmult (local_u, primal_tmp);
+         
+         new_primal_child->get_dof_values (primal_problem.v, primal_tmp);
+         embedding_matrix.vmult (local_v, primal_tmp);
+         
+         new_dual_child->get_dof_values (dual_problem.u, local_u_bar);
+         new_dual_child->get_dof_values (dual_problem.v, local_v_bar);
+
+         new_primal_child->set_user_pointer (cellwise_error.next_free_slot);
+         *cellwise_error.next_free_slot
+           = error_formula (new_dual_child,
+                            local_u,     local_v,
+                            local_u_bar, local_v_bar,
+                            child_u_old,     child_v_old,
+                            child_u_bar_old, child_v_bar_old,
+                            fe_values);
+         ++cellwise_error.next_free_slot;
+       };
+    };
+};
+
+
+
+template <int dim>
+typename TimeStep_ErrorEstimation<dim>::ErrorOnCell
+TimeStep_ErrorEstimation<dim>::collect_error_from_children (const DoFHandler<dim>::cell_iterator &primal_cell_old,
+                                                           const DoFHandler<dim>::cell_iterator &dual_cell_old,
+                                                           const Vector<double>  &local_u,
+                                                           const Vector<double>  &local_v,
+                                                           const Vector<double>  &local_u_bar,
+                                                           const Vector<double>  &local_v_bar,
+                                                           const Vector<double>  &local_Ih_u_bar,
+                                                           const Vector<double>  &local_Ih_v_bar,
+                                                           const Vector<double>  &local_Ih_u_bar_old,
+                                                           const Vector<double>  &local_Ih_v_bar_old,
+                                                           FEValues<dim>  &fe_values) const {
+  const TimeStep_Primal<dim> &primal_problem_old = static_cast<const TimeStepBase_Wave<dim>*>
+                                                  (previous_timestep)->get_timestep_primal();
+  const TimeStep_Dual<dim>   &dual_problem_old = static_cast<const TimeStepBase_Wave<dim>*>
+                                                (previous_timestep)->get_timestep_dual();
+  const FiniteElement<dim>   &dual_fe          = dual_problem_old.fe;
+  
+  ErrorOnCell error_sum;
+
+  const unsigned int total_dofs_dual = local_u_bar.size();
+  
+  for (unsigned int child=0; child<GeometryInfo<dim>::children_per_cell; ++child)
+    {
+                                      // we have the solutions on the
+                                      // new (large) cell, we restrict it to
+                                      // each of the small cells
+      Vector<double> child_u(total_dofs_dual), child_v(total_dofs_dual);
+      Vector<double> child_u_bar(total_dofs_dual), child_v_bar(total_dofs_dual);
+      Vector<double> child_Ih_u_bar(total_dofs_dual), child_Ih_v_bar(total_dofs_dual);
+      Vector<double> child_Ih_u_bar_old(total_dofs_dual), child_Ih_v_bar_old(total_dofs_dual);      
+
+      dual_fe.prolongate(child).vmult (child_u, local_u);
+      dual_fe.prolongate(child).vmult (child_v, local_v);
+      dual_fe.prolongate(child).vmult (child_u_bar, local_u_bar);
+      dual_fe.prolongate(child).vmult (child_v_bar, local_v_bar);
+      dual_fe.prolongate(child).vmult (child_Ih_u_bar, local_Ih_u_bar);
+      dual_fe.prolongate(child).vmult (child_Ih_v_bar, local_Ih_v_bar);
+      dual_fe.prolongate(child).vmult (child_Ih_u_bar_old, local_Ih_u_bar_old);
+      dual_fe.prolongate(child).vmult (child_Ih_v_bar_old, local_Ih_v_bar_old);
+
+      const DoFHandler<dim>::cell_iterator
+       old_primal_child = primal_cell_old->child(child),
+       old_dual_child   = dual_cell_old->child(child);
+
+      if (old_primal_child->has_children())
+                                        // the old cell was further
+                                        // refined -> recurse into the tree
+       error_sum += collect_error_from_children (old_primal_child,
+                                                 old_dual_child,
+                                                 child_u,            child_v,
+                                                 child_u_bar,        child_v_bar,
+                                                 child_Ih_u_bar,     child_Ih_v_bar,
+                                                 child_Ih_u_bar_old, child_Ih_v_bar_old,
+                                                 fe_values);
+      else
+                                        // the old cell was not further
+                                        // refined -> go on here directly
+       {
+         Vector<double> local_u_old(total_dofs_dual), local_v_old(total_dofs_dual);
+         Vector<double> local_u_bar_old(total_dofs_dual), local_v_bar_old(total_dofs_dual);
+
+                                          // vectors to hold dof values on
+                                          // the primal/dual cell (temporary)
+         Vector<double> primal_tmp(embedding_matrix.n());
+      
+                                      // fill local old solution vectors.
+                                      // no problems here, since the two
+                                      // cells are both unrefined
+         old_primal_child->get_dof_values (primal_problem_old.u, primal_tmp);
+         embedding_matrix.vmult (local_u_old, primal_tmp);
+  
+         old_primal_child->get_dof_values (primal_problem_old.v, primal_tmp);
+         embedding_matrix.vmult (local_v_old, primal_tmp);
+
+         Vector<double> child_difference_u_bar (total_dofs_dual);
+         Vector<double> child_difference_v_bar (total_dofs_dual);
+         Vector<double> local_difference_u_bar_old (total_dofs_dual);
+         Vector<double> local_difference_v_bar_old (total_dofs_dual);
+
+         child_difference_u_bar =  child_u_bar;
+         child_difference_u_bar -= child_Ih_u_bar;
+         child_difference_v_bar =  child_v_bar;
+         child_difference_v_bar -= child_Ih_v_bar;
+
+         local_difference_u_bar_old =  local_u_bar_old;
+         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,
+                                     child_u,            child_v,
+                                     child_u_bar,        child_v_bar,
+                                     local_u_old,        local_v_old,
+                                     local_u_bar_old,    local_v_bar_old,
+                                     fe_values);
+       };
+    };
+
+  return error_sum;
+};
+
+
+
+template <int dim>
+typename TimeStep_ErrorEstimation<dim>::ErrorOnCell
+TimeStep_ErrorEstimation<dim>::error_formula (const DoFHandler<dim>::active_cell_iterator &cell,
+                                             const Vector<double>  &local_u,
+                                             const Vector<double>  &local_v,
+                                             const Vector<double>  &local_u_bar,
+                                             const Vector<double>  &local_v_bar,
+                                             const Vector<double>  &local_u_old,
+                                             const Vector<double>  &local_v_old,
+                                             const Vector<double>  &local_u_bar_old,
+                                             const Vector<double>  &local_v_bar_old,
+                                             FEValues<dim>  &fe_values) const {
+  Vector<double> local_difference_u_bar(local_u_bar.size());
+  Vector<double> local_difference_v_bar(local_u_bar.size());
+  Vector<double> local_difference_u_bar_old(local_u_bar.size());
+  Vector<double> local_difference_v_bar_old(local_u_bar.size());
+  
+  difference_matrix.vmult (local_difference_u_bar, local_u_bar);
+  difference_matrix.vmult (local_difference_v_bar, local_v_bar);
+  difference_matrix.vmult (local_difference_u_bar_old, local_u_bar_old);
+  difference_matrix.vmult (local_difference_v_bar_old, local_v_bar_old);
+
+  return error_formula (cell,
+                       local_u,            local_v,
+                       local_u_bar,        local_v_bar,
+                       local_u_old,        local_v_old,
+                       local_u_bar_old,    local_v_bar_old,
+                       local_difference_u_bar,
+                       local_difference_v_bar,
+                       local_difference_u_bar_old,
+                       local_difference_v_bar_old,
+                       fe_values);                     
+};
+
+
+
+template <int dim>
+typename TimeStep_ErrorEstimation<dim>::ErrorOnCell
+TimeStep_ErrorEstimation<dim>::error_formula (const DoFHandler<dim>::active_cell_iterator &cell,
+                                             const Vector<double>  &local_u,
+                                             const Vector<double>  &local_v,
+                                             const Vector<double>  &local_u_bar,
+                                             const Vector<double>  &local_v_bar,
+                                             const Vector<double>  &local_u_old,
+                                             const Vector<double>  &local_v_old,
+                                             const Vector<double>  &local_u_bar_old,
+                                             const Vector<double>  &local_v_bar_old,
+                                             const Vector<double>  &local_difference_u_bar,
+                                             const Vector<double>  &local_difference_v_bar,
+                                             const Vector<double>  &local_difference_u_bar_old,
+                                             const Vector<double>  &local_difference_v_bar_old,
+                                             FEValues<dim>         &fe_values) const {
+
+                                  // this will be used to sum up the
+                                  // different parts of the error
+                                  // identity on this cell
+  ErrorOnCell error_on_cell;
+
+  const unsigned int total_dofs = get_timestep_dual().fe.total_dofs;
+  
+                                  // two temporaries needed for the
+                                  // calculation of the scalar products
+  Vector<double> tmp1(total_dofs);
+  Vector<double> tmp2(total_dofs);
+
+
+  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);
+  parameters.stiffness->gradient_list (fe_values.get_quadrature_points(),
+                                      grad_stiffness);
+
+                                  // matrix for (phi_i, phi_j)
+  FullMatrix<double> mass_matrix (tmp1.size(), tmp1.size());
+                                  // matrix for (a\Delta phi_i, phi_j)
+//  FullMatrix<double> delta_matrix (tmp1.size(), tmp1.size());
+                                  // matrix for (grad a . grad phi_i, phi_j)
+//  FullMatrix<double> grad_grad_matrix (tmp1.size(), tmp1.size());
+  FullMatrix<double> laplace_matrix (tmp1.size(), tmp1.size());
+  
+                                  // first task: create matrices
+  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<vector<Tensor<2,dim> > >&second_derivatives
+    = fe_values.get_shape_2nd_derivatives ();
+  const vector<double>                 &weights   = fe_values.get_JxW_values ();
+
+  vector<double> density_values(fe_values.n_quadrature_points);
+  parameters.density->value_list (fe_values.get_quadrature_points(),
+                                 density_values);
+  for (unsigned int point=0; point<fe_values.n_quadrature_points; ++point)
+    for (unsigned int i=0; i<total_dofs; ++i) 
+      for (unsigned int j=0; j<total_dofs; ++j)
+       {
+         mass_matrix(i,j) += (values(i,point) *
+                              values(j,point)) *
+                             weights[point] *
+                             density_values[point];
+
+                                          // compute laplacian of phi_i
+                                          // by summing the trace of the
+                                          // tensor of second derivatives
+         double laplace_phi_i = 0;
+         for (unsigned int t=0; t<dim; ++t)
+           laplace_phi_i += second_derivatives[i][point][t][t];
+         
+//       delta_matrix(i,j) += stiffness[point] *
+//                            laplace_phi_i *
+//                            values(j,point) *
+//                            weights[point];
+
+//       grad_grad_matrix(i,j) += (grad_stiffness[point] *
+//                                 gradients[i][point]) *
+//                                values(j,point) *
+//                                weights[point];
+
+         laplace_matrix(i,j) += (gradients[i][point] *
+                                 gradients[j][point]) *
+                                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
+                                  // 1/2 (1-I)(u_bar^n + u_bar^(n-1))
+                                  // with I the interpolation operator
+  tmp2  = local_difference_u_bar;
+  tmp2 += local_difference_u_bar_old;
+  tmp2.scale (1./2.);
+  
+                                  // let #tmp_dual1# hold
+                                  // u^n - u^(n-1)
+  tmp1  = local_u;
+  tmp1 -= local_u_old;
+  
+  error_on_cell.part[0] = mass_matrix.matrix_scalar_product (tmp1, tmp2);
+  
+  
+                                  // same thing for the second part
+                                  // with v instead of u
+  tmp2  = local_difference_v_bar;
+  tmp2 += local_difference_v_bar_old;
+  tmp2.scale (1./2.);
+  
+  tmp1  = local_v;
+  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))
+                                  // let tmp1 = v^n+v^(n-1)
+  tmp2  = local_difference_u_bar;
+  tmp2 += local_difference_u_bar_old;
+
+  tmp1  = local_v;
+  tmp1 += local_v_old;
+
+  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)
+                                  // let tmp2=u_bar^n - u_bar^(n-1)
+  tmp1  = local_v;
+  tmp1 -= local_v_old;
+
+  tmp2  = local_u_bar;
+  tmp2 -= local_u_bar_old;
+
+  error_on_cell.part[3] = -(get_backward_timestep() / 12 *
+                           mass_matrix.matrix_scalar_product (tmp1, tmp2));
+
+
+                                  // ////////////////////////////////
+                                  // PART 3a
+                                  //
+                                  // let tmp2=(1-I)(v_bar^n+v_bar^(n-1))
+                                  // let tmp1 = u^n+u^(n-1)
+  tmp2  = local_difference_v_bar;
+  tmp2 += local_difference_v_bar_old;
+
+  tmp1  = local_u;
+  tmp1 += local_u_old;
+
+  error_on_cell.part[4] = (get_backward_timestep() / 4 *
+                          laplace_matrix.matrix_scalar_product (tmp1, tmp2));
+
+
+                                  // ////////////////////////////////
+                                  // PART 3b
+                                  //
+                                  // let tmp1 = u^n-u^(n-1)
+                                  // let tmp2 = (v_bar^n - v_bar^(n-1))
+  tmp1  = local_u;
+  tmp1 -= local_u_old;
+
+  tmp2  = local_v_bar;
+  tmp2 -= local_v_bar_old;
+
+  error_on_cell.part[5] = (get_backward_timestep() / 12 *
+                          laplace_matrix.matrix_scalar_product (tmp1, tmp2));
+
+
+
+//                                // ///////////////////////////
+//                                // PART 0:
+//                                // tmp1 = u^n-u^(n-1)
+//                                // tmp2 = 1/2 (1-I) (u_bar^n + u_bar^(n-1)
+//   tmp1  = local_u;
+//   tmp1 -= local_u_old;
+
+//   tmp2  = local_difference_u_bar;
+//   tmp2 += local_difference_u_bar_old;
+//   tmp2.scale (1./2.);
+
+//   error_on_cell.part[0] = -1. * mass_matrix.matrix_scalar_product (tmp1, tmp2);
+
+//                                // ////////////////////////////
+//                                // PART 1:
+//                                // same as above, but with u and
+//                                // v interchanged
+//   tmp1  = local_v;
+//   tmp1 -= local_v_old;
+
+//   tmp2  = local_difference_v_bar;
+//   tmp2 += local_difference_v_bar_old;
+//   tmp2.scale (1./2.);
+
+//   error_on_cell.part[1] = -1. * mass_matrix.matrix_scalar_product (tmp1, tmp2);
+
+
+//                                // /////////////////////////////
+//                                // PART 2:
+//                                // tmp1 = v^n+v^(n-1)
+//                                // tmp2 = (1-I) (u_bar^n + u_bar^(n-1))
+//   tmp1  = local_v;
+//   tmp1 += local_v_old;
+
+//   tmp2  = local_difference_u_bar;
+//   tmp2 += local_difference_u_bar_old;
+
+//   error_on_cell.part[2]  = mass_matrix.matrix_scalar_product (tmp1, tmp2);
+//   error_on_cell.part[2] *= get_backward_timestep() / 4;
+
+//                                // //////////////////////////////
+//                                // PART 3:
+//                                // tmp1 = v^n-v^(n-1)
+//                                // tmp2 = u_bar^n - u_bar^(n-1)
+//   tmp1  = local_v;
+//   tmp1 -= local_v_old;
+
+//   tmp2  = local_u_bar;
+//   tmp2 -= local_u_bar_old;
+
+
+//   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:
+//                                // tmp1 = u^n+u^(n-1)
+//                                // tmp2 = (1-I) (v_bar^n + v_bar^(n-1))
+//   tmp1  = local_u;
+//   tmp1 += local_u_old;
+
+//   tmp2  = local_difference_v_bar;
+//   tmp2 += local_difference_v_bar_old;
+
+//   error_on_cell.part[4]  = delta_matrix.matrix_scalar_product (tmp1, tmp2);
+//   error_on_cell.part[4] *= get_backward_timestep() / 4;
+
+//   error_on_cell.part[6]  = grad_grad_matrix.matrix_scalar_product (tmp1, tmp2);
+//   error_on_cell.part[6] *= get_backward_timestep() / 12;
+
+//                                // //////////////////////////////
+//                                // PART 5 and 7:
+//                                // tmp1 = u^n-u^(n-1)
+//                                // tmp2 = v_bar^n - v_bar^(n-1)
+//   tmp1  = local_u;
+//   tmp1 -= local_u_old;
+
+//   tmp2  = local_v_bar;
+//   tmp2 -= local_v_bar_old;
+
+
+//   error_on_cell.part[5]  = delta_matrix.matrix_scalar_product (tmp1, tmp2);
+//   error_on_cell.part[5] *= get_backward_timestep() / 12;
+
+//   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;
+};
+
+
+
+
+
+
+template <int dim>
+void TimeStep_ErrorEstimation<dim>::make_interpolation_matrices () {
+  const FiniteElement<dim> &primal_fe = get_timestep_primal().fe,
+                          &dual_fe   = get_timestep_dual().fe;
+  
+  embedding_matrix.reinit (dual_fe.total_dofs,
+                          primal_fe.total_dofs);
+
+  vector<Point<dim> > unit_support_points (dual_fe.total_dofs);
+  dual_fe.get_unit_support_points (unit_support_points);
+  
+  for (unsigned int i=0; i<dual_fe.total_dofs; ++i)
+    for (unsigned int j=0; j<primal_fe.total_dofs; ++j)
+      embedding_matrix(i,j) = primal_fe.shape_value (j, unit_support_points[i]);
+
+
+                                  // construct the difference between the
+                                  // identity and the interpolation operator
+                                  // to the primal ansatz space. The
+                                  // interpolation operator is to act from
+                                  // and to the dual space (not as above
+                                  // where it acted from one space into
+                                  // the other), so we construct it by
+                                  // first interpolating down to the
+                                  // primal space and then back to the
+                                  // dual space (by injection, using
+                                  // the matrix constructed above)
+  FullMatrix<double> inverse_interpolation (primal_fe.total_dofs,
+                                           dual_fe.total_dofs);
+  unit_support_points.resize (primal_fe.total_dofs);
+  primal_fe.get_unit_support_points (unit_support_points);
+  
+  for (unsigned int i=0; i<primal_fe.total_dofs; ++i)
+    for (unsigned int j=0; j<dual_fe.total_dofs; ++j)
+      inverse_interpolation(i,j) = dual_fe.shape_value (j, unit_support_points[i]);
+
+  interpolation_matrix.reinit (dual_fe.total_dofs, dual_fe.total_dofs);
+  embedding_matrix.mmult (interpolation_matrix, inverse_interpolation);
+  
+  difference_matrix.reinit (dual_fe.total_dofs, dual_fe.total_dofs);
+                                  // initialize with the unit matrix
+  for (unsigned int i=0; i<dual_fe.total_dofs; ++i)
+    difference_matrix(i,i) = 1.;
+                                  // compute difference
+  difference_matrix.add (-1, interpolation_matrix);
+};
+
+
+
+
+
+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)
+{
+  out << "#    total estimated error in this timestep" << endl;
+};
+
+
+
+template <int dim>
+void TimeStep_ErrorEstimation<dim>::StatisticData::write (ostream &out) const
+{
+  out << setprecision(4) << setw(6) << estimated_error;
+};
+
+
+
+template <int dim>
+TimeStep_ErrorEstimation<dim>::ErrorOnCell::ErrorOnCell () {
+  for (unsigned int i=0; i<sizeof(part)/sizeof(part[0]); ++i)
+    part[i] = 0;
+};
+
+
+
+template <int dim>
+typename TimeStep_ErrorEstimation<dim>::ErrorOnCell
+TimeStep_ErrorEstimation<dim>::ErrorOnCell::operator += (const ErrorOnCell &eoc) {
+  for (unsigned int i=0; i<sizeof(part)/sizeof(part[0]); ++i)
+    part[i] += eoc.part[i];
+  return *this;
+};
+
+
+
+template <int dim>
+double TimeStep_ErrorEstimation<dim>::ErrorOnCell::sum () const {
+  double x=0;
+  for (unsigned int i=0; i<sizeof(part)/sizeof(part[0]); ++i)
+    x += part[i];
+  return x;
+};
+
+
+
+template <int dim>
+TimeStep_ErrorEstimation<dim>::CellwiseError::CellwiseError (const unsigned int n_errors) :
+               errors (n_errors),
+               next_free_slot (errors.begin())
+{};
+
+
+
+// explicit instantiations
+template class TimeStep_ErrorEstimation<2>;
+/* $Id$ */
+
+
+#include <lac/vector.h>
+#include <lac/sparsematrix.h>
+#include <grid/dof_constraints.h>
+#include <grid/dof.h>
+
+
+
+
+template <int dim>
+TimeStep<dim>::TimeStep (const double               time,
+                        const WaveParameters<dim> &parameters):
+               TimeStepBase_Wave<dim> (time,
+                                       TimeStepBase_Tria<dim>::Flags(true, 0, 1),
+                                       parameters),
+               TimeStep_Primal<dim>(parameters.primal_fe),
+               TimeStep_Dual<dim>  (parameters.dual_fe)
+{};
+
+
+
+
+template <int dim>
+void TimeStep<dim>::wake_up (const unsigned int wakeup_level)
+{
+  sweep_info->get_timers().grid_generation.start();
+  TimeStepBase_Wave<dim>::wake_up (wakeup_level);
+  sweep_info->get_timers().grid_generation.stop();
+
+  switch (next_action)
+    {
+      case primal_problem:
+           TimeStep_Primal<dim>::wake_up (wakeup_level);
+           break;
+           
+      case dual_problem:
+           TimeStep_Dual<dim>::wake_up (wakeup_level);
+           break;
+           
+      case postprocess:            
+           TimeStep_Primal<dim>::wake_up (wakeup_level);
+
+           if ((parameters.refinement_strategy == WaveParameters<dim>::dual_estimator)
+               &&
+               (sweep_no >= parameters.initial_energy_estimator_sweeps))
+             TimeStep_Dual<dim>::wake_up (wakeup_level);
+           
+           TimeStep_Postprocess<dim>::wake_up (wakeup_level);
+           
+           break;
+
+      case grid_refinement:
+                                            // do nothing except for waking
+                                            // up the grid
+           break;
+
+      default:
+           Assert (false, ExcInternalError());
+    };
+};
+
+
+
+template <int dim>
+void TimeStep<dim>::sleep (const unsigned int sleep_level)
+{  
+  switch (next_action)
+    {
+      case primal_problem:
+           TimeStep_Primal<dim>::sleep (sleep_level);
+           break;
+           
+      case dual_problem:
+           TimeStep_Dual<dim>::sleep (sleep_level);
+           break;
+
+      case postprocess:
+           TimeStep_Primal<dim>::sleep (sleep_level);
+           
+           if ((parameters.refinement_strategy == WaveParameters<dim>::dual_estimator)
+               &&
+               (sweep_no >= parameters.initial_energy_estimator_sweeps))
+             TimeStep_Dual<dim>::sleep (sleep_level);
+           
+           TimeStep_Postprocess<dim>::sleep (sleep_level);
+           break;
+
+      case grid_refinement:
+                                            // save the flags since the grid
+                                            // will be deleted next along with
+                                            // the flags
+           if (sleep_level == 1)
+             save_refine_flags ();
+           break;
+
+      default:
+           Assert (false, ExcInternalError());
+    };
+
+  sweep_info->get_timers().grid_generation.start();
+  TimeStepBase_Wave<dim>::sleep (sleep_level);
+  sweep_info->get_timers().grid_generation.stop();
+};
+
+
+
+template <int dim>
+void TimeStep<dim>::end_sweep ()
+{
+  TimeStep_Primal<dim>::end_sweep ();
+  TimeStep_Dual<dim>::end_sweep ();
+  TimeStep_Postprocess<dim>::end_sweep ();
+};
+
+
+
+template <int dim>
+void TimeStep<dim>::write_statistics_descriptions (ostream                   &out,
+                                                  const WaveParameters<dim> &parameters)
+{
+  out << "#  Primal problem:" << endl;
+  TimeStep_Primal<dim>::StatisticData::write_descriptions (out);
+
+  out << "#  Dual problem:" << endl;
+  TimeStep_Dual<dim>::StatisticData::write_descriptions (out);
+
+  out << "#  Error estimation:" << endl;
+  TimeStep_ErrorEstimation<dim>::StatisticData::write_descriptions (out);
+
+  if (parameters.eval_list.size() != 0)
+    {
+      out << "#  Postprocessing:" << endl;
+      TimeStep_Postprocess<dim>::StatisticData::write_descriptions (out, parameters);
+    };
+};
+
+
+
+template <int dim>
+void TimeStep<dim>::write_statistics (ostream &out) const 
+{
+  TimeStep_Primal<dim>::statistic_data.write (out);
+  out << "    ";
+  TimeStep_Dual<dim>::statistic_data.write (out);
+  out << "    ";
+  TimeStep_ErrorEstimation<dim>::statistic_data.write (out);
+  out << "    ";
+  TimeStep_Postprocess<dim>::statistic_data.write (out);
+};
+
+
+
+// explicit instantiations
+template class TimeStep<2>;
+/* $Id$ */
+
+
+#include <lac/vector.h>
+#include <basic/data_out.h>
+#include <grid/dof_constraints.h>
+#include <grid/dof.h>
+#include <grid/dof_accessor.h>
+#include <grid/tria.h>
+#include <grid/tria_iterator.h>
+#include <grid/geometry_info.h>
+#include <basic/data_out_stack.h>
+
+#include <fstream>
+#include <iomanip>
+
+
+
+template <int dim>
+void TimeStep_Postprocess<dim>::postprocess_timestep () 
+{
+  cout << "  Postprocessing: time="
+       << setprecision(4) << setw(6) << time
+       << ", step=" << setw(4) << timestep_no
+       << ", sweep=" << setw(2) << sweep_no
+       << ". "
+       << flush;
+
+  if ((sweep_no < parameters.number_of_sweeps-1) ||
+      (parameters.refinement_strategy == WaveParameters<dim>::dual_estimator))
+    estimate_error ();
+
+                                  // the error estimator has its own timer,
+                                  // so start the postprocessing timer
+                                  // only here
+  sweep_info->get_timers().postprocessing.start();
+
+                                  // do the user evaluations
+  statistic_data.evaluation_results.clear();
+  for (typename list<EvaluationBase<dim>*>::const_iterator i = parameters.eval_list.begin();
+       i != parameters.eval_list.end(); ++i)
+    {
+      (*i)->reset_timelevel (get_timestep_primal());
+      statistic_data.evaluation_results.push_back ((*i)->evaluate());
+    };
+
+                                  // write data if requested
+  if (((parameters.write_solution_strategy == WaveParameters<dim>::all_sweeps) ||
+       ((parameters.write_solution_strategy == WaveParameters<dim>::last_sweep_only) &&
+       (sweep_no == parameters.number_of_sweeps-1)))
+      &&
+      (((timestep_no % parameters.write_steps_interval) == 0) ||
+       (next_timestep == 0)))
+    {
+      cout << "[o]" << flush;
+
+      DataOut<dim>::OutputFormat output_format
+       = DataOut<dim>::parse_output_format (parameters.output_format);
+      
+      string data_filename     = (parameters.output_directory +
+                                  "sweep" + int_to_string(sweep_no,2) +
+                                  "/" + int_to_string(timestep_no,4) +
+                                  DataOut<dim>::default_suffix (output_format));
+      DataOut<dim> out;
+      out.attach_dof_handler (*get_timestep_primal().dof_handler);
+      out.add_data_vector (get_timestep_primal().u, "u");
+      out.add_data_vector (get_timestep_primal().v, "v");
+
+                                      // vectors holding the dual variables,
+                                      // if needed
+      Vector<double> u_bar, v_bar;
+      
+                                      // if dual problem was computed
+      if ((parameters.refinement_strategy == WaveParameters<dim>::dual_estimator)
+         &&
+         (sweep_no >= parameters.initial_energy_estimator_sweeps))
+       {
+         u_bar.reinit (get_timestep_primal().u.size());
+         v_bar.reinit (get_timestep_primal().u.size());
+         
+         if (parameters.primal_fe == parameters.dual_fe)
+                                            // if primal and dual solution
+                                            // were computed using the same
+                                            // ansatz, we may add the dual
+                                            // solutions "as is"
+           {
+             u_bar = get_timestep_dual().u;
+             v_bar = get_timestep_dual().v;
+           }
+         else
+                                            // otherwise: first interpolate
+                                            // the dual solutions to the
+                                            // same degree
+           interpolate_dual_solution (u_bar, v_bar);
+         
+         out.add_data_vector (u_bar, "dual_u");
+         out.add_data_vector (v_bar, "dual_v");
+       };
+
+                                      // add error vector if error
+                                      // was computed
+      Vector<double> estimated_error;
+      if ((sweep_no<parameters.number_of_sweeps-1) ||
+         (parameters.refinement_strategy == WaveParameters<dim>::dual_estimator))
+       {
+         if (parameters.write_error_as_cell_data) 
+           {
+             estimated_error.reinit (estimated_error_per_cell.size());
+             copy_n (estimated_error_per_cell.begin(),
+                     estimated_error_per_cell.size(),
+                     estimated_error.begin());
+           }
+         else
+           {
+             estimated_error.reinit (get_timestep_primal().dof_handler->n_dofs());
+             get_timestep_primal().dof_handler
+               ->distribute_cell_to_dof_vector (estimated_error_per_cell,
+                                                estimated_error);
+           };
+      
+         out.add_data_vector (estimated_error, "est_error");
+       };
+
+      out.build_patches ();
+      
+      out.write (cout, output_format);
+
+      cout << "." << flush;
+    };
+
+  if (parameters.write_stacked_data &&
+      (timestep_no % parameters.write_stacked_interval == 0))
+    {
+      cout << "[st]" << flush;
+
+      sweep_data->data_out_stack->new_parameter_value (time,
+                                                      (timestep_no == 0 ?
+                                                       0 :
+                                                       get_backward_timestep() *
+                                                       parameters.write_stacked_interval));
+      sweep_data->data_out_stack->attach_dof_handler (*get_timestep_primal().dof_handler);
+      sweep_data->data_out_stack->add_data_vector (get_timestep_primal().u, "u");
+      sweep_data->data_out_stack->add_data_vector (get_timestep_primal().v, "v");
+
+                                      // if dual problem was computed
+      if ((parameters.refinement_strategy == WaveParameters<dim>::dual_estimator)
+         &&
+         (sweep_no >= parameters.initial_energy_estimator_sweeps))
+       {
+         if (parameters.primal_fe == parameters.dual_fe)
+                                            // if primal and dual solution
+                                            // were computed using the same
+                                            // ansatz, we may add the dual
+                                            // solutions "as is"
+           {
+             sweep_data->data_out_stack->add_data_vector (get_timestep_dual().u, "dual_u");
+             sweep_data->data_out_stack->add_data_vector (get_timestep_dual().v, "dual_v");
+           }
+         else
+                                            // otherwise: first interpolate
+                                            // the dual solutions to the
+                                            // same degree
+           {
+             Vector<double> u_bar(get_timestep_primal().dof_handler->n_dofs());
+             Vector<double> v_bar(get_timestep_primal().dof_handler->n_dofs());
+             
+             interpolate_dual_solution (u_bar, v_bar);
+             
+             sweep_data->data_out_stack->add_data_vector (u_bar, "dual_u");
+             sweep_data->data_out_stack->add_data_vector (v_bar, "dual_v");
+           };
+       };
+
+                                      // add error estimator if that was
+                                      // computed
+      if ((sweep_no < parameters.number_of_sweeps-1) ||
+         (parameters.refinement_strategy == WaveParameters<dim>::dual_estimator))
+       sweep_data->data_out_stack->add_data_vector (estimated_error_per_cell, "est_error");
+
+      sweep_data->data_out_stack->build_patches ();
+      sweep_data->data_out_stack->finish_parameter_value ();
+    };
+  
+       
+  cout << endl;
+  sweep_info->get_timers().postprocessing.stop();
+};
+
+
+
+template <int dim>
+void TimeStep_Postprocess<dim>::wake_up (const unsigned int wakeup_level) 
+{
+  TimeStep_ErrorEstimation<dim>::wake_up (wakeup_level);
+};
+
+
+
+template <int dim>
+void TimeStep_Postprocess<dim>::sleep (const unsigned int sleep_level) 
+{
+  TimeStep_ErrorEstimation<dim>::sleep (sleep_level);
+};
+
+
+
+template <int dim>
+string TimeStep_Postprocess<dim>::branch_signature () const 
+{
+  return "o";
+};
+
+
+
+template <int dim>
+void TimeStep_Postprocess<dim>::end_sweep ()
+{
+  string tmp_filename = tmp_filename_base(branch_signature());
+  remove (tmp_filename.c_str());
+};
+
+
+    
+
+
+
+template <int dim>
+void TimeStep_Postprocess<dim>::interpolate_dual_solution (Vector<double> &interpolated_u_bar,
+                                                          Vector<double> &interpolated_v_bar) const {
+  const unsigned int n_primal_dofs = get_timestep_primal().dof_handler->n_dofs();
+  
+  interpolated_u_bar.reinit (n_primal_dofs);
+  interpolated_v_bar.reinit (n_primal_dofs);
+
+  const TimeStep_Wave<dim> &target = get_timestep_dual ();
+  
+  typename DoFHandler<dim>::active_cell_iterator primal_cell, dual_cell, endc;
+  primal_cell = get_timestep_primal().dof_handler->begin_active();
+  endc        = get_timestep_primal().dof_handler->end();
+  dual_cell   = target.dof_handler->begin_active();
+  
+                                  // loop over all cells and set the vertex
+                                  // values of the interpolated vector to
+                                  // the vertex values of the dual solutions.
+                                  // don't care that we set these values
+                                  // more than once...
+  for (; primal_cell != endc; ++primal_cell, ++dual_cell)
+    for (unsigned int vertex=0; vertex<GeometryInfo<dim>::vertices_per_cell; ++vertex)
+      {
+       const unsigned int  primal_vertex_index = primal_cell->vertex_dof_index(vertex,0),
+                           dual_vertex_index   = dual_cell->vertex_dof_index(vertex,0);
+       interpolated_u_bar(primal_vertex_index) = target.u(dual_vertex_index);
+       interpolated_v_bar(primal_vertex_index) = target.v(dual_vertex_index);
+      };      
+};
+
+
+
+
+template <int dim>
+void TimeStep_Postprocess<dim>::StatisticData::
+write_descriptions (ostream &out,
+                   const WaveParameters<dim> &parameters) 
+{
+  for (typename list<EvaluationBase<dim>*>::const_iterator i = parameters.eval_list.begin();
+       i != parameters.eval_list.end(); ++i)
+    out << "#    " << (*i)->description() << endl;
+};
+
+
+
+template <int dim>
+void TimeStep_Postprocess<dim>::StatisticData::write (ostream &out) const
+{
+  for (unsigned int i=0; i<evaluation_results.size(); ++i)
+    out << evaluation_results[i] << ' ';
+};
+
+
+
+
+// explicit instantiations
+template class TimeStep_Postprocess<2>;
+/* $Id$ */
+
+#include <base/function.h>
+#include <lac/fullmatrix.h>
+#include <lac/vector.h>
+#include <lac/sparsematrix.h>
+#include <grid/tria.h>
+#include <grid/dof.h>
+#include <grid/dof_constraints.h>
+#include <grid/dof_accessor.h>
+#include <grid/tria_iterator.h>
+#include <fe/fe_values.h>
+#include <fe/fe.h>
+#include <numerics/vectors.h>
+#include <numerics/matrices.h>
+
+
+#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 ()
+{
+  cout << "  Primal problem: time="
+       << setprecision(4) << setw(6) << time
+       << ", step=" << setw(4) << timestep_no
+       << ", sweep=" << setw(2) << sweep_no
+       << ". "
+       << tria->n_active_cells() << " cells, "
+       << dof_handler->n_dofs() << " dofs" << flush;
+
+
+                                  // 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;
+
+                                  // use L2-projection for u0 and v0
+#if 2 == 1
+  VectorTools<dim>::interpolate (*dof_handler, *parameters.initial_u, u);
+  VectorTools<dim>::interpolate (*dof_handler, *parameters.initial_v, v);
+#else
+  VectorTools<dim>::project (*dof_handler, constraints,
+                            quadrature, *parameters.initial_u, u,
+                            false, quadrature_face, (dim==2 ? true : false));
+  VectorTools<dim>::project (*dof_handler, constraints,
+                            quadrature, *parameters.initial_v, v,
+                            false, quadrature_face, (dim==2 ? true : false));
+#endif
+                                  // set energy to zero since we
+                                  // don't want to assemble the matrices
+                                  // needed for this
+  statistic_data = StatisticData (tria->n_active_cells(),
+                                 dof_handler->n_dofs(),
+                                 0,
+                                 0,
+                                 make_pair (0.0, 0.0));
+
+  cout << "." << endl;
+};
+
+
+
+
+template <int dim>
+void TimeStep_Primal<dim>::do_timestep ()
+{
+  cout << "  Primal problem: time="
+       << setprecision(4) << setw(6) << time
+       << ", step=" << setw(4) << timestep_no
+       << ", sweep=" << setw(2) << sweep_no
+       << ". "
+       << tria->n_active_cells() << " cells, "
+       << dof_handler->n_dofs() << " dofs" << flush;
+  
+                                  // 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;
+  
+  
+  const double time_step = get_backward_timestep ();
+  
+                                  // Vectors holding the right hand sides of
+                                  // the two equations.
+  Vector<double> right_hand_side1 (dof_handler->n_dofs());
+  Vector<double> right_hand_side2 (dof_handler->n_dofs());
+
+                                  // Vector holding a the values for
+                                  // u and v of the previous time step.
+                                  // these are used in case we want to
+                                  // use extrapolation from the previous
+                                  // time step to the present one
+  Vector<double> old_u, old_v;
+  if (parameters.extrapolate_old_solutions)
+    {
+      old_u.reinit (dof_handler->n_dofs());
+      old_v.reinit (dof_handler->n_dofs());
+
+      transfer_old_solutions (old_u, old_v);
+    };
+
+  
+  assemble_vectors (right_hand_side1, right_hand_side2);
+
+  UserMatrix system_matrix (system_sparsity, parameters.preconditioning);
+  system_matrix.copy_from (mass_matrix);
+  system_matrix.add_scaled (time_step * time_step *
+                           parameters.theta *
+                           parameters.theta,
+                           laplace_matrix);
+  constraints.condense (system_matrix);
+       
+  if (parameters.extrapolate_old_solutions)
+                                    // solve with a hopefully good guess
+                                    // as start vector
+    {
+      u  = old_u;
+      u.add (time_step, old_v);
+    };
+
+                                  // in 1d, do not set boundary conditions
+                                  // at all
+  if (dim!=1) 
+    {
+                                      // in the other case, the wake_up
+                                      // function of the base class has set
+                                      // the solution vector's values to
+                                      // zero already.
+      parameters.boundary_values_u->set_time (time);
+      parameters.boundary_values_v->set_time (time);
+      VectorTools<dim>::FunctionMap dirichlet_bc;
+      dirichlet_bc[0] = parameters.boundary_values_u;
+      
+      map<int,double> boundary_value_list;
+      VectorTools<dim>::interpolate_boundary_values (*dof_handler,
+                                                    dirichlet_bc,
+                                                    boundary_value_list);
+      MatrixTools<dim>::apply_boundary_values (boundary_value_list,
+                                              system_matrix, u,
+                                              right_hand_side1);
+    };
+
+  const unsigned int solver_steps1 = solve (system_matrix, u, right_hand_side1);
+               
+  system_matrix.copy_from (mass_matrix);
+  constraints.condense (system_matrix);
+  if (true)
+    { 
+      Vector<double> tmp (right_hand_side2.size());
+      laplace_matrix.vmult (tmp, u);
+      right_hand_side2.add (-parameters.theta*time_step, tmp);
+    };
+  constraints.condense (right_hand_side2);
+
+
+                                  // in 1d, do not set boundary conditions
+                                  // at all
+  if (dim != 1)
+    {
+      VectorTools<dim>::FunctionMap dirichlet_bc;
+      dirichlet_bc[0] = parameters.boundary_values_v;
+      map<int,double> boundary_value_list;
+      VectorTools<dim>::interpolate_boundary_values (*dof_handler,
+                                                    dirichlet_bc,
+                                                    boundary_value_list);
+      MatrixTools<dim>::apply_boundary_values (boundary_value_list,
+                                              system_matrix, v,
+                                              right_hand_side2);
+    };
+  
+
+  if (parameters.extrapolate_old_solutions)
+                                    // solve with a hopefully good guess
+                                    // as start vector
+    {
+      v  = u;
+      v -= old_u;
+      v.scale (2./time_step);
+      v -= old_v;
+    };
+
+  const unsigned int solver_steps2 = solve (system_matrix, v, right_hand_side2);
+
+  statistic_data = StatisticData (tria->n_active_cells(),
+                                 dof_handler->n_dofs(),
+                                 solver_steps1,
+                                 solver_steps2,
+                                 compute_energy ());
+  
+  cout << "." << endl;
+};
+
+
+
+
+template <int dim>
+void TimeStep_Primal<dim>::solve_primal_problem ()
+{
+  sweep_info->get_timers().primal_problem.start();
+  if (timestep_no == 0)
+    do_initial_step ();
+  else
+    do_timestep ();
+  sweep_info->get_timers().primal_problem.stop();
+};
+
+
+
+template <int dim>
+string TimeStep_Primal<dim>::branch_signature () const 
+{
+  return "p";
+};
+
+
+
+template <int dim>
+void TimeStep_Primal<dim>::wake_up (const unsigned int wakeup_level)
+{
+  TimeStep_Wave<dim>::wake_up (wakeup_level);
+  
+  sweep_info->get_timers().primal_problem.start();
+  if ((wakeup_level==0) && (next_action==primal_problem))
+    {
+      Assert (system_sparsity.empty(), ExcInternalError());
+      
+      create_matrices ();
+    };
+  sweep_info->get_timers().primal_problem.stop();
+};
+
+
+
+template <int dim>
+void TimeStep_Primal<dim>::assemble_vectors (Vector<double> &right_hand_side1,
+                                            Vector<double> &right_hand_side2) {
+                                  // don't do some things for the initial
+                                  // step since we don't need them there
+  Assert (timestep_no>=1, ExcInternalError());
+  
+                                  // construct right hand side
+  build_rhs (right_hand_side1, right_hand_side2);
+                                  // condense right hand side in-place
+  constraints.condense (right_hand_side1);
+};
+
+
+
+
+
+
+
+
+template <int dim>
+void TimeStep_Primal<dim>::build_rhs (Vector<double> &right_hand_side1,
+                                     Vector<double> &right_hand_side2) {
+                                  // 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();
+
+  Assert (previous_time_level.tria->n_cells(0) == tria->n_cells(0),
+         ExcCoarsestGridsDiffer());
+
+                                  // convenience typedef
+  typedef DoFHandler<dim>::cell_iterator cell_iterator;
+
+                                  // create this here and pass it to
+                                  // the cellwise function since it
+                                  // is expensive to create it for
+                                  // every cell
+  FEValues<dim> fe_values (fe, quadrature,
+                          UpdateFlags(update_gradients |
+                                      update_JxW_values |
+                                      update_q_points));
+
+  
+  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()) :
+                           dof_handler->begin(1));  
+  for (; new_cell!=end_cell; ++new_cell, ++old_cell)
+    build_rhs (old_cell, new_cell,
+              fe_values,
+              right_hand_side1, right_hand_side2);
+};
+
+
+
+template <int dim>
+void
+TimeStep_Primal<dim>::build_rhs (const DoFHandler<dim>::cell_iterator &old_cell,
+                                const DoFHandler<dim>::cell_iterator &new_cell,
+                                FEValues<dim>        &fe_values,
+                                Vector<double>       &right_hand_side1,
+                                Vector<double>       &right_hand_side2) {
+                                  // declare this type for convenience
+  typedef DoFHandler<dim>::cell_iterator cell_iterator;
+  
+                                  // both cells have children, so
+                                  // recurse into the tree
+  if (old_cell->has_children() && new_cell->has_children()) 
+    {
+      for (unsigned int child=0; child<GeometryInfo<dim>::children_per_cell; ++child)
+       build_rhs (old_cell->child(child),
+                  new_cell->child(child),
+                  fe_values,
+                  right_hand_side1,
+                  right_hand_side2);
+      return;
+    };
+
+
+                                  // 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();
+
+  const unsigned int total_dofs = fe.total_dofs;
+  const double time_step = get_backward_timestep();
+
+                                  // both cells are on the same refinement
+                                  // level
+  if (!old_cell->has_children() && !new_cell->has_children()) 
+    {
+      fe_values.reinit (old_cell);
+
+      FullMatrix<double>                    cell_matrix (total_dofs, total_dofs);
+      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 ();
+
+                                      // assemble mass matrix
+      vector<double> density_values(fe_values.n_quadrature_points);
+      parameters.density->value_list (fe_values.get_quadrature_points(),
+                                     density_values);
+      for (unsigned int point=0; point<fe_values.n_quadrature_points; ++point)
+       for (unsigned int i=0; i<total_dofs; ++i) 
+         for (unsigned int j=0; j<total_dofs; ++j)
+           cell_matrix(i,j) += (values(i,point) *
+                                values(j,point)) *
+                               weights[point] *
+                               density_values[point];
+
+      Vector<double> tmp (total_dofs);
+                                      // this is the right hand side of the
+                                      // first equation
+                                      // for the theta scheme:
+                                      //    rhs1 := Mu^0 + kMv^0
+                                      //           -(1-theta)theta k^2 Au^0
+      Vector<double> rhs1 (total_dofs);
+
+                                      // this is the part of the right hand side
+                                      // of the second equation which depends
+                                      // on the solutions of the previous time
+                                      // step.
+                                      // for the theta scheme:
+                                      //    rhs2 := Mv^0-(1-theta)kA^0
+      Vector<double> rhs2 (total_dofs);
+           
+                                      // vector of values of the function on the
+                                      // old grid restricted to one cell
+      Vector<double>     old_dof_values_u (total_dofs);
+                                      // vector of old u and v times the local
+                                      // mass matrix
+      Vector<double> local_M_u (total_dofs);
+      Vector<double> local_M_v (total_dofs);
+      Vector<double> local_A_u (total_dofs);      
+                                      // transfer u+k*v. Note that we need
+                                      // old_dof_values_u again below
+      old_cell->get_dof_values (previous_time_level.u, old_dof_values_u);
+      cell_matrix.vmult (local_M_u, old_dof_values_u);
+      
+      old_cell->get_dof_values (previous_time_level.v, tmp);
+      cell_matrix.vmult (local_M_v, tmp);
+
+                                      // now for the part with the laplace
+                                      // matrix
+      cell_matrix.clear ();
+      vector<double> stiffness_values(fe_values.n_quadrature_points);
+      parameters.stiffness->value_list (fe_values.get_quadrature_points(),
+                                           stiffness_values);
+      for (unsigned int point=0; point<fe_values.n_quadrature_points; ++point)
+       for (unsigned int i=0; i<total_dofs; ++i) 
+         for (unsigned int j=0; j<total_dofs; ++j)
+           cell_matrix(i,j) += (gradients[i][point] *
+                                gradients[j][point]) *
+                               weights[point] *
+                               stiffness_values[point];
+      cell_matrix.vmult (local_A_u, old_dof_values_u);
+
+
+      rhs1 = local_M_u;
+      rhs1.add (time_step, local_M_v);
+      rhs1.add ((-time_step*time_step*
+                parameters.theta*
+                (1-parameters.theta)),
+               local_A_u);
+      rhs2 = local_M_v;
+      rhs2.add (-(1-parameters.theta)*
+               time_step,
+               local_A_u);
+
+                                      // transfer into the global
+                                      // right hand side
+      vector<int> new_dof_indices (total_dofs, -1);
+      new_cell->get_dof_indices (new_dof_indices);
+      for (unsigned int i=0; i<total_dofs; ++i)
+       {
+         right_hand_side1(new_dof_indices[i]) += rhs1(i);
+         right_hand_side2(new_dof_indices[i]) += rhs2(i);
+       };
+      
+      return;
+    };
+  
+                                  // only old cell is refined
+  if (old_cell->has_children() && !new_cell->has_children())
+    {
+                                      // this is the right hand side of the
+                                      // first equation
+                                      // for the theta scheme:
+                                      //    rhs1 := Mu^0 + kMv^0
+                                      //           -(1-theta)theta k^2 Au^0
+      Vector<double> rhs1 (total_dofs);
+
+                                      // this is the part of the right hand side
+                                      // of the second equation which depends
+                                      // on the solutions of the previous time
+                                      // step.
+                                      // for the theta scheme:
+                                      //    rhs2 := Mv^0-(1-theta)kA^0
+      Vector<double> rhs2 (total_dofs);
+
+                                      // collect the contributions of the
+                                      // child cells (and possibly their
+                                      // children as well)
+      collect_from_children (old_cell, fe_values, rhs1, rhs2);
+
+                                      // transfer into the global
+                                      // right hand side
+      vector<int> new_dof_indices (total_dofs);
+      new_cell->get_dof_indices (new_dof_indices);
+      for (unsigned int i=0; i<total_dofs; ++i) 
+       {
+         right_hand_side1(new_dof_indices[i]) += rhs1(i);
+         right_hand_side2(new_dof_indices[i]) += rhs2(i);
+       };
+
+      return;
+    };
+
+                                  // only new cell is refined
+  if (!old_cell->has_children() && new_cell->has_children())
+    {
+                                      // vector of values of the function
+                                      // on the old grid restricted to
+                                      // the large (old) cell
+      Vector<double>  old_dof_values_u (total_dofs);
+      Vector<double>  old_dof_values_v (total_dofs);
+      old_cell->get_dof_values (previous_time_level.u, old_dof_values_u);
+      old_cell->get_dof_values (previous_time_level.v, old_dof_values_v);
+
+                                      // distribute the contribution of the
+                                      // large old cell to the children on
+                                      // the new cell
+      distribute_to_children (new_cell, fe_values,
+                             old_dof_values_u, old_dof_values_v,
+                             right_hand_side1, right_hand_side2);
+
+      return;
+    };
+
+  Assert (false, ExcInternalError());
+};
+
+
+     
+  
+template <int dim>
+unsigned int
+TimeStep_Primal<dim>::collect_from_children (const DoFHandler<dim>::cell_iterator &old_cell,
+                                            FEValues<dim>  &fe_values,
+                                            Vector<double> &rhs1,
+                                            Vector<double> &rhs2) const {
+                                  // maximal difference of levels between the
+                                  // cell to which we write and the cells from
+                                  // which we read. Default is one, but this is
+                                  // increased with each level of recursion
+  unsigned int level_difference = 1;  
+  
+                                  // 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();
+
+  const unsigned int total_dofs = fe.total_dofs;
+  const double time_step = get_backward_timestep();
+
+  
+  FullMatrix<double>   cell_matrix (total_dofs, total_dofs);
+  
+                                  // these will hold the values of the
+                                  // solution on the old grid, i.e. on
+                                  // the small cells
+  Vector<double>  local_old_dof_values_u (total_dofs);
+  Vector<double>  local_old_dof_values_v (total_dofs);
+  
+                                  // same for the contributions to the
+                                  // right hand sides of the projection
+  Vector<double>  local_M_u (total_dofs);
+  Vector<double>  local_M_v (total_dofs);
+  Vector<double>  local_A_u (total_dofs);
+                                  // this is the right hand side of the
+                                  // first equation
+                                  // for the theta scheme:
+                                  //    rhs1 := Mu^0 + kMv^0
+                                  //           -(1-theta)theta k^2 Au^0
+  Vector<double> child_rhs1 (total_dofs);
+
+                                  // this is the part of the right hand side
+                                  // of the second equation which depends
+                                  // on the solutions of the previous time
+                                  // step.
+                                  // for the theta scheme:
+                                  //    rhs2 := Mv^0-(1-theta)kA^0
+  Vector<double> child_rhs2 (total_dofs);
+
+  for (unsigned int c=0; c<GeometryInfo<dim>::children_per_cell; ++c) 
+    {
+      const DoFHandler<dim>::cell_iterator old_child = old_cell->child(c);
+
+      child_rhs1.clear ();
+      child_rhs2.clear ();
+      
+                                      // if this child is further subdivided:
+                                      // collect the contributions of the
+                                      // children
+      if (old_child->has_children())
+       {
+         const unsigned int l = collect_from_children (old_child, fe_values,
+                                                       child_rhs1, child_rhs2);
+         level_difference = max (l+1, level_difference);
+       }
+      else
+       {
+         fe_values.reinit (old_child);
+         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 ();
+
+                                          // get solutions restricted to small
+                                          // cell
+         old_child->get_dof_values (previous_time_level.u, local_old_dof_values_u);
+         old_child->get_dof_values (previous_time_level.v, local_old_dof_values_v);
+      
+                                          // compute M*(u+kv) on the small cell
+         cell_matrix.clear ();
+         vector<double> density_values(fe_values.n_quadrature_points);
+         parameters.density->value_list (fe_values.get_quadrature_points(),
+                                         density_values);
+         for (unsigned int point=0; point<fe_values.n_quadrature_points; ++point)
+           for (unsigned int i=0; i<total_dofs; ++i) 
+             for (unsigned int j=0; j<total_dofs; ++j)
+               cell_matrix(i,j) += (values(i,point) *
+                                    values(j,point)) *
+                                   weights[point] *
+                                   density_values[point];
+
+         cell_matrix.vmult (local_M_u, local_old_dof_values_u);
+         cell_matrix.vmult (local_M_v, local_old_dof_values_v);
+      
+                                          // now for the part with the laplace
+                                          // matrix
+         cell_matrix.clear ();
+
+         vector<double> stiffness_values(fe_values.n_quadrature_points);
+         parameters.stiffness->value_list (fe_values.get_quadrature_points(),
+                                           stiffness_values);
+         for (unsigned int point=0; point<fe_values.n_quadrature_points; ++point)
+           for (unsigned int i=0; i<total_dofs; ++i) 
+             for (unsigned int j=0; j<total_dofs; ++j)
+               cell_matrix(i,j) += (gradients[i][point] *
+                                    gradients[j][point]) *
+                                   weights[point] *
+                                   stiffness_values[point];
+         cell_matrix.vmult (local_A_u, local_old_dof_values_u);
+      
+         child_rhs1 = local_M_u;
+         child_rhs1.add (time_step, local_M_v);
+         child_rhs1.add ((-time_step*time_step*
+                          parameters.theta*
+                          (1-parameters.theta)),
+                         local_A_u);
+         child_rhs2 = local_M_v;
+         child_rhs2.add (-(1-parameters.theta)*
+                         time_step,
+                         local_A_u);
+       };
+      
+                                      // transfer the contribution of this
+                                      // child cell to its parent cell
+                                      // (#true# means: add up)
+      fe.prolongate(c).Tvmult (rhs1, child_rhs1, true);
+      fe.prolongate(c).Tvmult (rhs2, child_rhs2, true);
+    };
+
+  return level_difference;
+};
+
+
+
+
+template <int dim>
+unsigned int
+TimeStep_Primal<dim>::distribute_to_children (const DoFHandler<dim>::cell_iterator &new_cell,
+                                             FEValues<dim>         &fe_values,
+                                             const Vector<double>  &old_dof_values_u,
+                                             const Vector<double>  &old_dof_values_v,
+                                             Vector<double>        &right_hand_side1,
+                                             Vector<double>        &right_hand_side2) {
+                                  // maximal difference of levels between the
+                                  // cell to which we write and the cells from
+                                  // which we read. Default is one, but this is
+                                  // increased with each level of recursion
+  unsigned int level_difference = 1;  
+  
+  const unsigned int total_dofs = fe.total_dofs;
+  const double time_step = get_backward_timestep();
+
+  FullMatrix<double>    cell_matrix(total_dofs, total_dofs);
+                                  // set up a vector which will hold the
+                                  // restriction of the old
+                                  // functions (u,v) to a childcell
+  Vector<double> local_old_dof_values_u (total_dofs);
+  Vector<double> local_old_dof_values_v (total_dofs);
+
+                                  // vector of old u and v times the local
+                                  // mass matrix (on the small cells
+                                  // respectively)
+  Vector<double> local_M_u (total_dofs);
+  Vector<double> local_M_v (total_dofs);
+  Vector<double> local_A_u (total_dofs);
+
+                                  // this is the right hand side of the
+                                  // first equation
+                                  // for the theta scheme:
+                                  //    rhs1 := Mu^0 + kMv^0
+                                  //           -(1-theta)theta k^2 Au^0
+  Vector<double> rhs1 (total_dofs);
+
+                                  // this is the part of the right hand side
+                                  // of the second equation which depends
+                                  // on the solutions of the previous time
+                                  // step.
+                                  // for the theta scheme:
+                                  //    rhs2 := Mv^0-(1-theta)kA^0
+  Vector<double> rhs2 (total_dofs);
+           
+                                  // indices of the dofs of a cell on
+                                  // the new grid
+  vector<int> new_dof_indices (total_dofs, -1);
+
+      
+                                      // 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);
+
+                                      // get u and v on the childcells
+      fe.prolongate(c).vmult (local_old_dof_values_u,
+                             old_dof_values_u);
+      fe.prolongate(c).vmult (local_old_dof_values_v,
+                             old_dof_values_v);
+
+      if (new_child->has_children())
+                                        // cell on new grid is further refined
+                                        // distribute data on this local cell
+                                        // to its children
+       {
+         const unsigned int l = distribute_to_children (new_child, fe_values,
+                                                        local_old_dof_values_u,
+                                                        local_old_dof_values_v,
+                                                        right_hand_side1,
+                                                        right_hand_side2);
+         level_difference = max (l+1, level_difference);
+       }
+      else
+                                        // child is not further refined
+                                        // -> directly distribute data
+       {
+         fe_values.reinit (new_child);
+         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 ();
+
+                                          // transfer u+kv
+         cell_matrix.clear ();
+         vector<double> density_values(fe_values.n_quadrature_points);
+         parameters.density->value_list (fe_values.get_quadrature_points(),
+                                             density_values);
+         for (unsigned int point=0; point<fe_values.n_quadrature_points; ++point)
+           for (unsigned int i=0; i<total_dofs; ++i) 
+             for (unsigned int j=0; j<total_dofs; ++j)
+               cell_matrix(i,j) += (values(i,point) *
+                                    values(j,point)) *
+                                   weights[point] *
+                                   density_values[point];
+
+         cell_matrix.vmult (local_M_u, local_old_dof_values_u);
+         cell_matrix.vmult (local_M_v, local_old_dof_values_v);
+
+                                          // now for the part with the laplace
+                                          // matrix
+         cell_matrix.clear ();
+         vector<double> stiffness_values(fe_values.n_quadrature_points);
+         parameters.stiffness->value_list (fe_values.get_quadrature_points(),
+                                               stiffness_values);
+         for (unsigned int point=0; point<fe_values.n_quadrature_points; ++point)
+           for (unsigned int i=0; i<total_dofs; ++i) 
+             for (unsigned int j=0; j<total_dofs; ++j)
+               cell_matrix(i,j) += (gradients[i][point] *
+                                    gradients[j][point]) *
+                                   weights[point] *
+                                   stiffness_values[point];
+         cell_matrix.vmult (local_A_u, local_old_dof_values_u);
+
+         rhs1 = local_M_u;
+         rhs1.add (time_step, local_M_v);
+         rhs1.add ((-time_step*time_step*
+                    parameters.theta*
+                    (1-parameters.theta)),
+                   local_A_u);
+         rhs2 = local_M_v;
+         rhs2.add (-(1-parameters.theta)*
+                   time_step,
+                   local_A_u);
+         
+                                          // transfer into the global
+                                          // right hand side
+         new_child->get_dof_indices (new_dof_indices);
+         for (unsigned int i=0; i<total_dofs; ++i)
+           {
+             right_hand_side1(new_dof_indices[i]) += rhs1(i);
+             right_hand_side2(new_dof_indices[i]) += rhs2(i);
+           };
+       };
+    };
+
+  return level_difference;
+};
+
+
+
+
+
+
+
+// explicit instantiations
+template class TimeStep_Primal<2>;
+/* $Id$ */
+
+#include <lac/vector.h>
+
+
+
+void UserMatrix::precondition (Vector<double> &dst,
+                              const Vector<double> &src) const {
+  switch (preconditioning)
+    {
+      case jacobi:
+           precondition_Jacobi (dst, src);
+           return;
+      case sor:
+           precondition_SOR (dst, src);
+           return;
+      case ssor:
+           precondition_SSOR (dst, src);
+           return;
+      default:
+           dst = src;
+           return;
+    };
+};
+
+
+/* $Id$ */
+
+
+
+#include <fe/fe_lib.lagrange.h>
+#include <base/quadrature_lib.h>
+
+
+
+
+
+
+
+// static objects
+
+const FEQ1<2>   FEHelper<2>::fe_linear;
+const FEQ2<2>   FEHelper<2>::fe_quadratic_sub;
+#if 2 < 3
+const FEQ3<2>   FEHelper<2>::fe_cubic_sub;
+const FEQ4<2>   FEHelper<2>::fe_quartic_sub;
+#endif
+    
+const QGauss2<2> FEHelper<2>::q_gauss_2;
+const QGauss3<2> FEHelper<2>::q_gauss_3;
+const QGauss4<2> FEHelper<2>::q_gauss_4;
+const QGauss5<2> FEHelper<2>::q_gauss_5;
+const QGauss6<2> FEHelper<2>::q_gauss_6;
+const QGauss7<2> FEHelper<2>::q_gauss_7;
+const QGauss8<2> FEHelper<2>::q_gauss_8;
+
+#if 2 > 1
+const QGauss2<2-1> FEHelper<2>::q_gauss_2_face;
+const QGauss3<2-1> FEHelper<2>::q_gauss_3_face;
+const QGauss4<2-1> FEHelper<2>::q_gauss_4_face;
+const QGauss5<2-1> FEHelper<2>::q_gauss_5_face;
+const QGauss6<2-1> FEHelper<2>::q_gauss_6_face;
+const QGauss7<2-1> FEHelper<2>::q_gauss_7_face;
+const QGauss8<2-1> FEHelper<2>::q_gauss_8_face;
+#endif
+
+
+template <int dim>
+const FiniteElement<dim> & FEHelper<dim>::get_fe (const string &name) {
+  if (name=="linear")
+    return fe_linear;
+  else
+    if (name=="quadratic")
+      return fe_quadratic_sub;
+#if 2 < 3
+    else
+      if (name=="cubic")
+       return fe_cubic_sub;
+      else
+       if (name=="quartic")
+         return fe_quartic_sub;
+#endif
+  
+  Assert (false, ExcInternalError());
+
+  return fe_linear;
+};
+
+
+
+template <int dim>
+const Quadrature<dim> &FEHelper<dim>::get_quadrature (const string &name) {
+  if (name=="linear")
+    return q_gauss_2;
+  else
+    if (name=="quadratic")
+      return q_gauss_3;
+#if 2 < 3
+    else
+      if (name=="cubic")
+       return q_gauss_4;
+      else
+       if (name=="quartic")
+         return q_gauss_5;
+#endif
+  
+  Assert (false, ExcInternalError());
+
+  return q_gauss_2;
+};
+
+
+
+template <>
+const Quadrature<0> &FEHelper<1>::get_quadrature_face (const string &) {
+  static const Quadrature<0> dummy_quadrature(1);
+  return dummy_quadrature;
+};
+
+
+
+template <int dim>
+const Quadrature<dim-1> &FEHelper<dim>::get_quadrature_face (const string &name) {
+  if (name=="linear")
+    return q_gauss_2_face;
+  else
+    if (name=="quadratic")
+      return q_gauss_3_face;
+#if 2 < 3
+    else
+      if (name=="cubic")
+       return q_gauss_4_face;
+      else
+       if (name=="quartic")
+         return q_gauss_5_face;
+#endif
+  
+  Assert (false, ExcInternalError());
+
+  return q_gauss_2_face;
+};
+
+
+
+string int_to_string (const unsigned int i, const unsigned int digits) {
+  string s;
+  switch (digits) 
+    {
+      case 4:
+           s += '0' + i/1000;
+      case 3:
+           s += '0' + (i%1000)/100;
+      case 2:
+           s += '0' + (i%100)/10;
+      case 1:
+           s += '0' + i%10;
+           break;
+      default:
+           s += "invalid digits information";
+    };
+  return s;
+};
+
+
+
+
+
+// explicit instantiations
+template class FEHelper<2>;
+
+
+/* $Id$ */
+
+
+
+#include <base/logstream.h>
+#include <lac/sparsematrix.h>
+#include <lac/vector.h>
+#include <grid/dof.h>
+#include <grid/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)
+{
+  parameters.declare_parameters (prm);
+};
+
+
+
+template <int dim>
+void WaveProblem<dim>::parse_parameters (ParameterHandler &prm)
+{
+  parameters.parse_parameters (prm);
+};
+
+
+
+template <int dim>
+void WaveProblem<dim>::create_new (const unsigned int)
+{
+  parameters.delete_parameters ();
+};
+
+
+
+template <int dim>
+void WaveProblem<dim>::run (ParameterHandler &prm) 
+{
+  parse_parameters (prm);
+//  prm.print_parameters (cout, Text);
+
+
+                                  ////////////////////////////////
+                                  // Set up the time step objects
+  TimestepManager<dim> timestep_manager (parameters);
+  if (true) {
+                                    // push back initial level
+    timestep_manager.add_timestep (new TimeStep<dim>(0, parameters));
+    double       time = 0;
+    unsigned int step_no = 0;
+    double       local_time_step;
+    
+    while (time<parameters.end_time)
+      {
+       ++step_no;
+       
+                                        // if on last time step
+                                        // allow last time step to
+                                        // be at most 10% longer than
+                                        // initially wanted
+       if (time+parameters.time_step*1.1 >= parameters.end_time)
+         local_time_step = parameters.end_time-time;
+       else
+                                          // equilibrate time step size
+                                          // of the two last time steps
+         if (time+2*parameters.time_step >= parameters.end_time)
+           local_time_step = (parameters.end_time-time)/2;
+         else
+                                            // regular time step
+           local_time_step = parameters.time_step;
+       
+       time += local_time_step;
+       
+       timestep_manager.add_timestep (new TimeStep<dim>(time, parameters));
+      };
+  };
+
+
+                                  ////////////////////////////////////
+                                  // actually do the work (or rather:
+                                  // let the work be done)
+  for (unsigned int sweep=0; sweep<parameters.number_of_sweeps; ++sweep)
+    timestep_manager.run_sweep (sweep);
+};
+
+
+
+
+int main () {
+                                  // no additional output to console
+  deallog.depth_console (0);
+
+  WaveProblem<2> waves;
+  MultipleParameterLoop input_data;
+
+  waves.declare_parameters(input_data);
+
+  try 
+    {
+      input_data.read_input ("wave-test-3.prm");
+    }
+  catch (exception &e)
+    {
+      cerr << endl << endl
+          << "----------------------------------------------------"
+          << endl;
+      cerr << "Exception on input: " << e.what() << endl
+          << "Aborting!" << endl
+          << "----------------------------------------------------"
+          << endl;
+                                      // abort
+      return 1;
+    };
+
+  try
+    {
+      input_data.loop (waves);
+    }
+  catch (exception &e)
+    {
+      cerr << endl << endl
+          << "----------------------------------------------------"
+          << endl;
+      cerr << "Exception on processing: " << e.what() << endl
+          << "Aborting!" << endl
+          << "----------------------------------------------------"
+          << endl;
+                                      // abort
+      return 2;
+    }
+  catch (...) 
+    {
+      cerr << endl << endl
+          << "----------------------------------------------------"
+          << endl;
+      cerr << "Unknown exception!" << endl
+          << "Aborting!" << endl
+          << "----------------------------------------------------"
+          << endl;
+                                      // abort
+      return 3;
+    };
+  
+  
+  return 0;
+};
+
+
+
diff --git a/tests/deal.II/wave-test-3.expect b/tests/deal.II/wave-test-3.expect
new file mode 100644 (file)
index 0000000..1e221b4
--- /dev/null
@@ -0,0 +1,2688 @@
+Sweep  0:
+---------
+  Primal problem: time=     0, step=   0, sweep= 0. 256 cells, 289 dofs.
+  Primal problem: time= 0.028, step=   1, sweep= 0. 256 cells, 289 dofs.
+  Primal problem: time= 0.056, step=   2, sweep= 0. 256 cells, 289 dofs.
+  Primal problem: time= 0.084, step=   3, sweep= 0. 256 cells, 289 dofs.
+  Primal problem: time= 0.112, step=   4, sweep= 0. 256 cells, 289 dofs.
+  Primal problem: time=  0.14, step=   5, sweep= 0. 256 cells, 289 dofs.
+  Primal problem: time= 0.168, step=   6, sweep= 0. 256 cells, 289 dofs.
+  Primal problem: time= 0.196, step=   7, sweep= 0. 256 cells, 289 dofs.
+  Primal problem: time= 0.224, step=   8, sweep= 0. 256 cells, 289 dofs.
+  Primal problem: time= 0.252, step=   9, sweep= 0. 256 cells, 289 dofs.
+  Primal problem: time=  0.28, step=  10, sweep= 0. 256 cells, 289 dofs.
+  Primal problem: time= 0.308, step=  11, sweep= 0. 256 cells, 289 dofs.
+  Primal problem: time= 0.336, step=  12, sweep= 0. 256 cells, 289 dofs.
+  Primal problem: time= 0.364, step=  13, sweep= 0. 256 cells, 289 dofs.
+  Primal problem: time= 0.392, step=  14, sweep= 0. 256 cells, 289 dofs.
+  Primal problem: time=  0.42, step=  15, sweep= 0. 256 cells, 289 dofs.
+  Primal problem: time= 0.448, step=  16, sweep= 0. 256 cells, 289 dofs.
+  Primal problem: time= 0.476, step=  17, sweep= 0. 256 cells, 289 dofs.
+  Primal problem: time= 0.504, step=  18, sweep= 0. 256 cells, 289 dofs.
+  Primal problem: time= 0.532, step=  19, sweep= 0. 256 cells, 289 dofs.
+  Primal problem: time=  0.56, step=  20, sweep= 0. 256 cells, 289 dofs.
+  Primal problem: time= 0.588, step=  21, sweep= 0. 256 cells, 289 dofs.
+  Primal problem: time= 0.616, step=  22, sweep= 0. 256 cells, 289 dofs.
+  Primal problem: time= 0.644, step=  23, sweep= 0. 256 cells, 289 dofs.
+  Primal problem: time= 0.672, step=  24, sweep= 0. 256 cells, 289 dofs.
+  Primal problem: time=   0.7, step=  25, sweep= 0. 256 cells, 289 dofs.
+
+  Dual problem: time=   0.7, step=  25, sweep= 0. 256 cells, 1089 dofs.
+  Dual problem: time= 0.672, step=  24, sweep= 0. 256 cells, 1089 dofs.
+  Dual problem: time= 0.644, step=  23, sweep= 0. 256 cells, 1089 dofs.
+  Dual problem: time= 0.616, step=  22, sweep= 0. 256 cells, 1089 dofs.
+  Dual problem: time= 0.588, step=  21, sweep= 0. 256 cells, 1089 dofs.
+  Dual problem: time=  0.56, step=  20, sweep= 0. 256 cells, 1089 dofs.
+  Dual problem: time= 0.532, step=  19, sweep= 0. 256 cells, 1089 dofs.
+  Dual problem: time= 0.504, step=  18, sweep= 0. 256 cells, 1089 dofs.
+  Dual problem: time= 0.476, step=  17, sweep= 0. 256 cells, 1089 dofs.
+  Dual problem: time= 0.448, step=  16, sweep= 0. 256 cells, 1089 dofs.
+  Dual problem: time=  0.42, step=  15, sweep= 0. 256 cells, 1089 dofs.
+  Dual problem: time= 0.392, step=  14, sweep= 0. 256 cells, 1089 dofs.
+  Dual problem: time= 0.364, step=  13, sweep= 0. 256 cells, 1089 dofs.
+  Dual problem: time= 0.336, step=  12, sweep= 0. 256 cells, 1089 dofs.
+  Dual problem: time= 0.308, step=  11, sweep= 0. 256 cells, 1089 dofs.
+  Dual problem: time=  0.28, step=  10, sweep= 0. 256 cells, 1089 dofs.
+  Dual problem: time= 0.252, step=   9, sweep= 0. 256 cells, 1089 dofs.
+  Dual problem: time= 0.224, step=   8, sweep= 0. 256 cells, 1089 dofs.
+  Dual problem: time= 0.196, step=   7, sweep= 0. 256 cells, 1089 dofs.
+  Dual problem: time= 0.168, step=   6, sweep= 0. 256 cells, 1089 dofs.
+  Dual problem: time=  0.14, step=   5, sweep= 0. 256 cells, 1089 dofs.
+  Dual problem: time= 0.112, step=   4, sweep= 0. 256 cells, 1089 dofs.
+  Dual problem: time= 0.084, step=   3, sweep= 0. 256 cells, 1089 dofs.
+  Dual problem: time= 0.056, step=   2, sweep= 0. 256 cells, 1089 dofs.
+  Dual problem: time= 0.028, step=   1, sweep= 0. 256 cells, 1089 dofs.
+  Dual problem: time=     0, step=   0, sweep= 0. 256 cells, 1089 dofs.
+
+  Postprocessing: time=     0, step=   0, sweep= 0. [ee][o]%!PS-Adobe-2.0 EPSF-1.2
+%%Title: deal.II Output
+%%Creator: the deal.II library
+%%Creation Date: 1999/8/12 - 17:48:18
+%%BoundingBox: 0 0 300 189
+/m {moveto} bind def
+/l {lineto} bind def
+/s {setrgbcolor} bind def
+/sg {setgray} bind def
+/lx {lineto closepath stroke} bind def
+/lf {lineto closepath fill} bind def
+%%EndProlog
+
+0.5 setlinewidth
+0 0 0.40691 s 102.94 144.06 m 114.83 140.63 l 121.69 146.57 l 109.81 150 lf
+0 sg 102.94 144.06 m 114.83 140.63 l 121.69 146.57 l 109.81 150 lx
+0 0 0.40691 s 114.83 140.63 m 126.72 137.19 l 133.58 143.14 l 121.69 146.57 lf
+0 sg 114.83 140.63 m 126.72 137.19 l 133.58 143.14 l 121.69 146.57 lx
+0 0 0.40691 s 96.082 138.11 m 107.97 134.68 l 114.83 140.63 l 102.94 144.06 lf
+0 sg 96.082 138.11 m 107.97 134.68 l 114.83 140.63 l 102.94 144.06 lx
+0 0 0.40691 s 126.72 137.19 m 138.61 133.76 l 145.47 139.71 l 133.58 143.14 lf
+0 sg 126.72 137.19 m 138.61 133.76 l 145.47 139.71 l 133.58 143.14 lx
+0 0 0.40691 s 107.97 134.68 m 119.86 131.25 l 126.72 137.19 l 114.83 140.63 lf
+0 sg 107.97 134.68 m 119.86 131.25 l 126.72 137.19 l 114.83 140.63 lx
+0 0 0.40691 s 138.61 133.76 m 150.49 130.33 l 157.36 136.27 l 145.47 139.71 lf
+0 sg 138.61 133.76 m 150.49 130.33 l 157.36 136.27 l 145.47 139.71 lx
+0 0 0.40691 s 89.219 132.17 m 101.11 128.74 l 107.97 134.68 l 96.082 138.11 lf
+0 sg 89.219 132.17 m 101.11 128.74 l 107.97 134.68 l 96.082 138.11 lx
+0 0 0.40691 s 119.86 131.25 m 131.74 127.82 l 138.61 133.76 l 126.72 137.19 lf
+0 sg 119.86 131.25 m 131.74 127.82 l 138.61 133.76 l 126.72 137.19 lx
+0 0 0.40691 s 150.49 130.33 m 162.38 126.9 l 169.24 132.84 l 157.36 136.27 lf
+0 sg 150.49 130.33 m 162.38 126.9 l 169.24 132.84 l 157.36 136.27 lx
+0 0 0.40691 s 101.11 128.74 m 112.99 125.31 l 119.86 131.25 l 107.97 134.68 lf
+0 sg 101.11 128.74 m 112.99 125.31 l 119.86 131.25 l 107.97 134.68 lx
+0 0 0.40691 s 131.74 127.82 m 143.63 124.39 l 150.49 130.33 l 138.61 133.76 lf
+0 sg 131.74 127.82 m 143.63 124.39 l 150.49 130.33 l 138.61 133.76 lx
+0 0 0.40691 s 162.38 126.9 m 174.27 123.47 l 181.13 129.41 l 169.24 132.84 lf
+0 sg 162.38 126.9 m 174.27 123.47 l 181.13 129.41 l 169.24 132.84 lx
+0 0 0.40691 s 82.356 126.23 m 94.243 122.79 l 101.11 128.74 l 89.219 132.17 lf
+0 sg 82.356 126.23 m 94.243 122.79 l 101.11 128.74 l 89.219 132.17 lx
+0 0 0.40691 s 112.99 125.31 m 124.88 121.88 l 131.74 127.82 l 119.86 131.25 lf
+0 sg 112.99 125.31 m 124.88 121.88 l 131.74 127.82 l 119.86 131.25 lx
+0 0 0.40691 s 143.63 124.39 m 155.52 120.96 l 162.38 126.9 l 150.49 130.33 lf
+0 sg 143.63 124.39 m 155.52 120.96 l 162.38 126.9 l 150.49 130.33 lx
+0 0 0.40693 s 174.27 123.47 m 186.15 120.04 l 193.02 125.98 l 181.13 129.41 lf
+0 sg 174.27 123.47 m 186.15 120.04 l 193.02 125.98 l 181.13 129.41 lx
+0 0 0.40691 s 94.243 122.79 m 106.13 119.36 l 112.99 125.31 l 101.11 128.74 lf
+0 sg 94.243 122.79 m 106.13 119.36 l 112.99 125.31 l 101.11 128.74 lx
+0 0 0.40691 s 124.88 121.88 m 136.77 118.44 l 143.63 124.39 l 131.74 127.82 lf
+0 sg 124.88 121.88 m 136.77 118.44 l 143.63 124.39 l 131.74 127.82 lx
+0 0 0.40693 s 155.52 120.96 m 167.4 117.52 l 174.27 123.47 l 162.38 126.9 lf
+0 sg 155.52 120.96 m 167.4 117.52 l 174.27 123.47 l 162.38 126.9 lx
+0 0 0.40691 s 75.493 120.28 m 87.38 116.85 l 94.243 122.79 l 82.356 126.23 lf
+0 sg 75.493 120.28 m 87.38 116.85 l 94.243 122.79 l 82.356 126.23 lx
+0 0 0.40672 s 186.15 120.04 m 198.04 116.6 l 204.9 122.55 l 193.02 125.98 lf
+0 sg 186.15 120.04 m 198.04 116.6 l 204.9 122.55 l 193.02 125.98 lx
+0 0 0.40691 s 106.13 119.36 m 118.02 115.93 l 124.88 121.88 l 112.99 125.31 lf
+0 sg 106.13 119.36 m 118.02 115.93 l 124.88 121.88 l 112.99 125.31 lx
+0 0 0.40693 s 136.77 118.44 m 148.65 115.01 l 155.52 120.96 l 143.63 124.39 lf
+0 sg 136.77 118.44 m 148.65 115.01 l 155.52 120.96 l 143.63 124.39 lx
+0 0 0.40685 s 167.4 117.52 m 179.29 114.09 l 186.15 120.04 l 174.27 123.47 lf
+0 sg 167.4 117.52 m 179.29 114.09 l 186.15 120.04 l 174.27 123.47 lx
+0 0 0.40691 s 87.38 116.85 m 99.267 113.42 l 106.13 119.36 l 94.243 122.79 lf
+0 sg 87.38 116.85 m 99.267 113.42 l 106.13 119.36 l 94.243 122.79 lx
+0 0 0.40672 s 198.04 116.6 m 209.93 113.17 l 216.79 119.12 l 204.9 122.55 lf
+0 sg 198.04 116.6 m 209.93 113.17 l 216.79 119.12 l 204.9 122.55 lx
+0 0 0.40693 s 118.02 115.93 m 129.9 112.5 l 136.77 118.44 l 124.88 121.88 lf
+0 sg 118.02 115.93 m 129.9 112.5 l 136.77 118.44 l 124.88 121.88 lx
+0 0 0.40685 s 148.65 115.01 m 160.54 111.58 l 167.4 117.52 l 155.52 120.96 lf
+0 sg 148.65 115.01 m 160.54 111.58 l 167.4 117.52 l 155.52 120.96 lx
+0 0 0.40691 s 68.63 114.34 m 80.517 110.91 l 87.38 116.85 l 75.493 120.28 lf
+0 sg 68.63 114.34 m 80.517 110.91 l 87.38 116.85 l 75.493 120.28 lx
+0 0 0.40749 s 179.29 114.09 m 191.18 110.68 l 198.04 116.6 l 186.15 120.04 lf
+0 sg 179.29 114.09 m 191.18 110.68 l 198.04 116.6 l 186.15 120.04 lx
+0 0 0.40693 s 99.267 113.42 m 111.15 109.99 l 118.02 115.93 l 106.13 119.36 lf
+0 sg 99.267 113.42 m 111.15 109.99 l 118.02 115.93 l 106.13 119.36 lx
+0 0 0.40693 s 209.93 113.17 m 221.81 109.74 l 228.68 115.69 l 216.79 119.12 lf
+0 sg 209.93 113.17 m 221.81 109.74 l 228.68 115.69 l 216.79 119.12 lx
+0 0 0.40685 s 129.9 112.5 m 141.79 109.07 l 148.65 115.01 l 136.77 118.44 lf
+0 sg 129.9 112.5 m 141.79 109.07 l 148.65 115.01 l 136.77 118.44 lx
+0 0 0.40715 s 160.54 111.58 m 172.43 108.16 l 179.29 114.09 l 167.4 117.52 lf
+0 sg 160.54 111.58 m 172.43 108.16 l 179.29 114.09 l 167.4 117.52 lx
+0 0 0.40693 s 80.517 110.91 m 92.404 107.48 l 99.267 113.42 l 87.38 116.85 lf
+0 sg 80.517 110.91 m 92.404 107.48 l 99.267 113.42 l 87.38 116.85 lx
+0 0 0.40749 s 191.18 110.68 m 203.06 107.23 l 209.93 113.17 l 198.04 116.6 lf
+0 sg 191.18 110.68 m 203.06 107.23 l 209.93 113.17 l 198.04 116.6 lx
+0 0 0.40685 s 111.15 109.99 m 123.04 106.55 l 129.9 112.5 l 118.02 115.93 lf
+0 sg 111.15 109.99 m 123.04 106.55 l 129.9 112.5 l 118.02 115.93 lx
+0 0 0.40691 s 221.81 109.74 m 233.7 106.31 l 240.56 112.25 l 228.68 115.69 lf
+0 sg 221.81 109.74 m 233.7 106.31 l 240.56 112.25 l 228.68 115.69 lx
+0 0 0.40715 s 141.79 109.07 m 153.68 105.65 l 160.54 111.58 l 148.65 115.01 lf
+0 sg 141.79 109.07 m 153.68 105.65 l 160.54 111.58 l 148.65 115.01 lx
+0 0 0.40693 s 61.767 108.4 m 73.654 104.96 l 80.517 110.91 l 68.63 114.34 lf
+0 sg 61.767 108.4 m 73.654 104.96 l 80.517 110.91 l 68.63 114.34 lx
+0 0 0.40481 s 172.43 108.16 m 184.31 104.64 l 191.18 110.68 l 179.29 114.09 lf
+0 sg 172.43 108.16 m 184.31 104.64 l 191.18 110.68 l 179.29 114.09 lx
+0 0 0.40685 s 92.404 107.48 m 104.29 104.04 l 111.15 109.99 l 99.267 113.42 lf
+0 sg 92.404 107.48 m 104.29 104.04 l 111.15 109.99 l 99.267 113.42 lx
+0 0 0.40685 s 203.06 107.23 m 214.95 103.8 l 221.81 109.74 l 209.93 113.17 lf
+0 sg 203.06 107.23 m 214.95 103.8 l 221.81 109.74 l 209.93 113.17 lx
+0 0 0.40715 s 123.04 106.55 m 134.93 103.14 l 141.79 109.07 l 129.9 112.5 lf
+0 sg 123.04 106.55 m 134.93 103.14 l 141.79 109.07 l 129.9 112.5 lx
+0 0 0.40691 s 233.7 106.31 m 245.59 102.88 l 252.45 108.82 l 240.56 112.25 lf
+0 sg 233.7 106.31 m 245.59 102.88 l 252.45 108.82 l 240.56 112.25 lx
+0 0 0.40603 s 153.68 105.65 m 165.56 102.17 l 172.43 108.16 l 160.54 111.58 lf
+0 sg 153.68 105.65 m 165.56 102.17 l 172.43 108.16 l 160.54 111.58 lx
+0 0 0.40685 s 73.654 104.96 m 85.541 101.53 l 92.404 107.48 l 80.517 110.91 lf
+0 sg 73.654 104.96 m 85.541 101.53 l 92.404 107.48 l 80.517 110.91 lx
+0 0 0.40481 s 184.31 104.64 m 196.2 101.3 l 203.06 107.23 l 191.18 110.68 lf
+0 sg 184.31 104.64 m 196.2 101.3 l 203.06 107.23 l 191.18 110.68 lx
+0 0 0.40715 s 104.29 104.04 m 116.18 100.62 l 123.04 106.55 l 111.15 109.99 lf
+0 sg 104.29 104.04 m 116.18 100.62 l 123.04 106.55 l 111.15 109.99 lx
+0 0 0.40693 s 214.95 103.8 m 226.84 100.37 l 233.7 106.31 l 221.81 109.74 lf
+0 sg 214.95 103.8 m 226.84 100.37 l 233.7 106.31 l 221.81 109.74 lx
+0 0 0.40603 s 134.93 103.14 m 146.81 99.654 l 153.68 105.65 l 141.79 109.07 lf
+0 sg 134.93 103.14 m 146.81 99.654 l 153.68 105.65 l 141.79 109.07 lx
+0 0 0.40691 s 245.59 102.88 m 257.48 99.447 l 264.34 105.39 l 252.45 108.82 lf
+0 sg 245.59 102.88 m 257.48 99.447 l 264.34 105.39 l 252.45 108.82 lx
+0 0 0.40672 s 54.904 102.45 m 66.791 99.015 l 73.654 104.96 l 61.767 108.4 lf
+0 sg 54.904 102.45 m 66.791 99.015 l 73.654 104.96 l 61.767 108.4 lx
+0 0 0.41474 s 165.56 102.17 m 177.45 99.069 l 184.31 104.64 l 172.43 108.16 lf
+0 sg 165.56 102.17 m 177.45 99.069 l 184.31 104.64 l 172.43 108.16 lx
+0 0 0.40715 s 85.541 101.53 m 97.428 98.112 l 104.29 104.04 l 92.404 107.48 lf
+0 sg 85.541 101.53 m 97.428 98.112 l 104.29 104.04 l 92.404 107.48 lx
+0 0 0.40715 s 196.2 101.3 m 208.09 97.852 l 214.95 103.8 l 203.06 107.23 lf
+0 sg 196.2 101.3 m 208.09 97.852 l 214.95 103.8 l 203.06 107.23 lx
+0 0 0.40603 s 116.18 100.62 m 128.06 97.142 l 134.93 103.14 l 123.04 106.55 lf
+0 sg 116.18 100.62 m 128.06 97.142 l 134.93 103.14 l 123.04 106.55 lx
+0 0 0.40691 s 226.84 100.37 m 238.73 96.935 l 245.59 102.88 l 233.7 106.31 lf
+0 sg 226.84 100.37 m 238.73 96.935 l 245.59 102.88 l 233.7 106.31 lx
+0 0 0.41022 s 146.81 99.654 m 158.7 96.409 l 165.56 102.17 l 153.68 105.65 lf
+0 sg 146.81 99.654 m 158.7 96.409 l 165.56 102.17 l 153.68 105.65 lx
+0 0 0.40691 s 257.48 99.447 m 269.36 96.016 l 276.23 101.96 l 264.34 105.39 lf
+0 sg 257.48 99.447 m 269.36 96.016 l 276.23 101.96 l 264.34 105.39 lx
+0 0 0.40749 s 66.791 99.015 m 78.678 95.61 l 85.541 101.53 l 73.654 104.96 lf
+0 sg 66.791 99.015 m 78.678 95.61 l 85.541 101.53 l 73.654 104.96 lx
+0 0 0.41474 s 177.45 99.069 m 189.34 95.303 l 196.2 101.3 l 184.31 104.64 lf
+0 sg 177.45 99.069 m 189.34 95.303 l 196.2 101.3 l 184.31 104.64 lx
+0 0 0.40603 s 97.428 98.112 m 109.31 94.63 l 116.18 100.62 l 104.29 104.04 lf
+0 sg 97.428 98.112 m 109.31 94.63 l 116.18 100.62 l 104.29 104.04 lx
+0 0 0.40685 s 208.09 97.852 m 219.98 94.424 l 226.84 100.37 l 214.95 103.8 lf
+0 sg 208.09 97.852 m 219.98 94.424 l 226.84 100.37 l 214.95 103.8 lx
+0 0 0.41022 s 128.06 97.142 m 139.95 93.897 l 146.81 99.654 l 134.93 103.14 lf
+0 sg 128.06 97.142 m 139.95 93.897 l 146.81 99.654 l 134.93 103.14 lx
+0 0 0.40691 s 238.73 96.935 m 250.61 93.504 l 257.48 99.447 l 245.59 102.88 lf
+0 sg 238.73 96.935 m 250.61 93.504 l 257.48 99.447 l 245.59 102.88 lx
+0 0 0.40672 s 48.041 96.508 m 59.928 93.078 l 66.791 99.015 l 54.904 102.45 lf
+0 sg 48.041 96.508 m 59.928 93.078 l 66.791 99.015 l 54.904 102.45 lx
+0 0 0.3777 s 158.7 96.409 m 170.59 91.73 l 177.45 99.069 l 165.56 102.17 lf
+0 sg 158.7 96.409 m 170.59 91.73 l 177.45 99.069 l 165.56 102.17 lx
+0 0 0.40691 s 269.36 96.016 m 281.25 92.584 l 288.11 98.528 l 276.23 101.96 lf
+0 sg 269.36 96.016 m 281.25 92.584 l 288.11 98.528 l 276.23 101.96 lx
+0 0 0.40481 s 78.678 95.61 m 90.565 92.078 l 97.428 98.112 l 85.541 101.53 lf
+0 sg 78.678 95.61 m 90.565 92.078 l 97.428 98.112 l 85.541 101.53 lx
+0 0 0.40603 s 189.34 95.303 m 201.23 91.922 l 208.09 97.852 l 196.2 101.3 lf
+0 sg 189.34 95.303 m 201.23 91.922 l 208.09 97.852 l 196.2 101.3 lx
+0 0 0.41022 s 109.31 94.63 m 121.2 91.385 l 128.06 97.142 l 116.18 100.62 lf
+0 sg 109.31 94.63 m 121.2 91.385 l 128.06 97.142 l 116.18 100.62 lx
+0 0 0.40693 s 219.98 94.424 m 231.86 90.991 l 238.73 96.935 l 226.84 100.37 lf
+0 sg 219.98 94.424 m 231.86 90.991 l 238.73 96.935 l 226.84 100.37 lx
+0 0 0.39456 s 139.95 93.897 m 151.84 89.768 l 158.7 96.409 l 146.81 99.654 lf
+0 sg 139.95 93.897 m 151.84 89.768 l 158.7 96.409 l 146.81 99.654 lx
+0 0 0.40691 s 250.61 93.504 m 262.5 90.072 l 269.36 96.016 l 257.48 99.447 lf
+0 sg 250.61 93.504 m 262.5 90.072 l 269.36 96.016 l 257.48 99.447 lx
+0 0 0.40749 s 59.928 93.078 m 71.815 89.643 l 78.678 95.61 l 66.791 99.015 lf
+0 sg 59.928 93.078 m 71.815 89.643 l 78.678 95.61 l 66.791 99.015 lx
+0 0 0.3777 s 170.59 91.73 m 182.48 89.546 l 189.34 95.303 l 177.45 99.069 lf
+0 sg 170.59 91.73 m 182.48 89.546 l 189.34 95.303 l 177.45 99.069 lx
+0 0 0.40691 s 281.25 92.584 m 293.14 89.153 l 300 95.096 l 288.11 98.528 lf
+0 sg 281.25 92.584 m 293.14 89.153 l 300 95.096 l 288.11 98.528 lx
+0 0 0.41474 s 90.565 92.078 m 102.45 89.021 l 109.31 94.63 l 97.428 98.112 lf
+0 sg 90.565 92.078 m 102.45 89.021 l 109.31 94.63 l 97.428 98.112 lx
+0 0 0.40715 s 201.23 91.922 m 213.11 88.477 l 219.98 94.424 l 208.09 97.852 lf
+0 sg 201.23 91.922 m 213.11 88.477 l 219.98 94.424 l 208.09 97.852 lx
+0 0 0.39456 s 121.2 91.385 m 133.09 87.256 l 139.95 93.897 l 128.06 97.142 lf
+0 sg 121.2 91.385 m 133.09 87.256 l 139.95 93.897 l 128.06 97.142 lx
+0 0 0.40691 s 231.86 90.991 m 243.75 87.56 l 250.61 93.504 l 238.73 96.935 lf
+0 sg 231.86 90.991 m 243.75 87.56 l 250.61 93.504 l 238.73 96.935 lx
+0 0 0.40693 s 41.178 90.565 m 53.065 87.133 l 59.928 93.078 l 48.041 96.508 lf
+0 sg 41.178 90.565 m 53.065 87.133 l 59.928 93.078 l 48.041 96.508 lx
+0 0 0.51594 s 151.84 89.768 m 163.73 90.994 l 170.59 91.73 l 158.7 96.409 lf
+0 sg 151.84 89.768 m 163.73 90.994 l 170.59 91.73 l 158.7 96.409 lx
+0 0 0.40691 s 262.5 90.072 m 274.39 86.641 l 281.25 92.584 l 269.36 96.016 lf
+0 sg 262.5 90.072 m 274.39 86.641 l 281.25 92.584 l 269.36 96.016 lx
+0 0 0.40481 s 71.815 89.643 m 83.702 86.225 l 90.565 92.078 l 78.678 95.61 lf
+0 sg 71.815 89.643 m 83.702 86.225 l 90.565 92.078 l 78.678 95.61 lx
+0 0 0.41022 s 182.48 89.546 m 194.36 85.928 l 201.23 91.922 l 189.34 95.303 lf
+0 sg 182.48 89.546 m 194.36 85.928 l 201.23 91.922 l 189.34 95.303 lx
+0 0 0.3777 s 102.45 89.021 m 114.34 84.194 l 121.2 91.385 l 109.31 94.63 lf
+0 sg 102.45 89.021 m 114.34 84.194 l 121.2 91.385 l 109.31 94.63 lx
+0 0 0.40685 s 213.11 88.477 m 225 85.049 l 231.86 90.991 l 219.98 94.424 lf
+0 sg 213.11 88.477 m 225 85.049 l 231.86 90.991 l 219.98 94.424 lx
+0 0 0.45299 s 133.09 87.256 m 144.98 86.429 l 151.84 89.768 l 139.95 93.897 lf
+0 sg 133.09 87.256 m 144.98 86.429 l 151.84 89.768 l 139.95 93.897 lx
+0 0 0.40691 s 243.75 87.56 m 255.64 84.129 l 262.5 90.072 l 250.61 93.504 lf
+0 sg 243.75 87.56 m 255.64 84.129 l 262.5 90.072 l 250.61 93.504 lx
+0 0 0.40685 s 53.065 87.133 m 64.952 83.703 l 71.815 89.643 l 59.928 93.078 lf
+0 sg 53.065 87.133 m 64.952 83.703 l 71.815 89.643 l 59.928 93.078 lx
+0 0 0.51594 s 163.73 90.994 m 175.61 82.905 l 182.48 89.546 l 170.59 91.73 lf
+0 sg 163.73 90.994 m 175.61 82.905 l 182.48 89.546 l 170.59 91.73 lx
+0 0 0.40691 s 274.39 86.641 m 286.27 83.209 l 293.14 89.153 l 281.25 92.584 lf
+0 sg 274.39 86.641 m 286.27 83.209 l 293.14 89.153 l 281.25 92.584 lx
+0 0 0.41474 s 83.702 86.225 m 95.589 82.743 l 102.45 89.021 l 90.565 92.078 lf
+0 sg 83.702 86.225 m 95.589 82.743 l 102.45 89.021 l 90.565 92.078 lx
+0 0 0.40603 s 194.36 85.928 m 206.25 82.547 l 213.11 88.477 l 201.23 91.922 lf
+0 sg 194.36 85.928 m 206.25 82.547 l 213.11 88.477 l 201.23 91.922 lx
+0 0 0 s 144.98 86.429 m 156.86 65.615 l 163.73 90.994 l 151.84 89.768 lf
+0 sg 144.98 86.429 m 156.86 65.615 l 163.73 90.994 l 151.84 89.768 lx
+0 0 0.51594 s 114.34 84.194 m 126.23 85.97 l 133.09 87.256 l 121.2 91.385 lf
+0 sg 114.34 84.194 m 126.23 85.97 l 133.09 87.256 l 121.2 91.385 lx
+0 0 0.40693 s 225 85.049 m 236.89 81.616 l 243.75 87.56 l 231.86 90.991 lf
+0 sg 225 85.049 m 236.89 81.616 l 243.75 87.56 l 231.86 90.991 lx
+0 0 0.40691 s 34.315 84.621 m 46.202 81.19 l 53.065 87.133 l 41.178 90.565 lf
+0 sg 34.315 84.621 m 46.202 81.19 l 53.065 87.133 l 41.178 90.565 lx
+0 0 0.40691 s 255.64 84.129 m 267.52 80.697 l 274.39 86.641 l 262.5 90.072 lf
+0 sg 255.64 84.129 m 267.52 80.697 l 274.39 86.641 l 262.5 90.072 lx
+0 0 0.40715 s 64.952 83.703 m 76.839 80.268 l 83.702 86.225 l 71.815 89.643 lf
+0 sg 64.952 83.703 m 76.839 80.268 l 83.702 86.225 l 71.815 89.643 lx
+0 0 0.39456 s 175.61 82.905 m 187.5 80.171 l 194.36 85.928 l 182.48 89.546 lf
+0 sg 175.61 82.905 m 187.5 80.171 l 194.36 85.928 l 182.48 89.546 lx
+0 0 0.3777 s 95.589 82.743 m 107.48 79.498 l 114.34 84.194 l 102.45 89.021 lf
+0 sg 95.589 82.743 m 107.48 79.498 l 114.34 84.194 l 102.45 89.021 lx
+0 0 0 s 126.23 85.97 m 138.11 63.103 l 144.98 86.429 l 133.09 87.256 lf
+0 sg 126.23 85.97 m 138.11 63.103 l 144.98 86.429 l 133.09 87.256 lx
+0 0 0.40715 s 206.25 82.547 m 218.14 79.102 l 225 85.049 l 213.11 88.477 lf
+0 sg 206.25 82.547 m 218.14 79.102 l 225 85.049 l 213.11 88.477 lx
+0 0 0 s 156.86 65.615 m 168.75 79.566 l 175.61 82.905 l 163.73 90.994 lf
+0 sg 156.86 65.615 m 168.75 79.566 l 175.61 82.905 l 163.73 90.994 lx
+0 0 0.40691 s 236.89 81.616 m 248.77 78.185 l 255.64 84.129 l 243.75 87.56 lf
+0 sg 236.89 81.616 m 248.77 78.185 l 255.64 84.129 l 243.75 87.56 lx
+0 0 0.40693 s 46.202 81.19 m 58.089 77.758 l 64.952 83.703 l 53.065 87.133 lf
+0 sg 46.202 81.19 m 58.089 77.758 l 64.952 83.703 l 53.065 87.133 lx
+0 0 0.40691 s 267.52 80.697 m 279.41 77.266 l 286.27 83.209 l 274.39 86.641 lf
+0 sg 267.52 80.697 m 279.41 77.266 l 286.27 83.209 l 274.39 86.641 lx
+0 0 0.40603 s 76.839 80.268 m 88.726 76.85 l 95.589 82.743 l 83.702 86.225 lf
+0 sg 76.839 80.268 m 88.726 76.85 l 95.589 82.743 l 83.702 86.225 lx
+0 0 0.41022 s 187.5 80.171 m 199.39 76.553 l 206.25 82.547 l 194.36 85.928 lf
+0 sg 187.5 80.171 m 199.39 76.553 l 206.25 82.547 l 194.36 85.928 lx
+0 0 0.51594 s 107.48 79.498 m 119.36 75.369 l 126.23 85.97 l 114.34 84.194 lf
+0 sg 107.48 79.498 m 119.36 75.369 l 126.23 85.97 l 114.34 84.194 lx
+0 0 0.40685 s 218.14 79.102 m 230.02 75.674 l 236.89 81.616 l 225 85.049 lf
+0 sg 218.14 79.102 m 230.02 75.674 l 236.89 81.616 l 225 85.049 lx
+0 0 0.40691 s 27.452 78.678 m 39.339 75.246 l 46.202 81.19 l 34.315 84.621 lf
+0 sg 27.452 78.678 m 39.339 75.246 l 46.202 81.19 l 34.315 84.621 lx
+0 0 0.40691 s 248.77 78.185 m 260.66 74.754 l 267.52 80.697 l 255.64 84.129 lf
+0 sg 248.77 78.185 m 260.66 74.754 l 267.52 80.697 l 255.64 84.129 lx
+0 0 0.40685 s 58.089 77.758 m 69.976 74.328 l 76.839 80.268 l 64.952 83.703 lf
+0 sg 58.089 77.758 m 69.976 74.328 l 76.839 80.268 l 64.952 83.703 lx
+0 0 0.45299 s 168.75 79.566 m 180.64 73.53 l 187.5 80.171 l 175.61 82.905 lf
+0 sg 168.75 79.566 m 180.64 73.53 l 187.5 80.171 l 175.61 82.905 lx
+0 0 0.41022 s 88.726 76.85 m 100.61 73.368 l 107.48 79.498 l 95.589 82.743 lf
+0 sg 88.726 76.85 m 100.61 73.368 l 107.48 79.498 l 95.589 82.743 lx
+0 0 0 s 119.36 75.369 m 131.25 74.542 l 138.11 63.103 l 126.23 85.97 lf
+0 sg 119.36 75.369 m 131.25 74.542 l 138.11 63.103 l 126.23 85.97 lx
+0 0 0.40603 s 199.39 76.553 m 211.27 73.172 l 218.14 79.102 l 206.25 82.547 lf
+0 sg 199.39 76.553 m 211.27 73.172 l 218.14 79.102 l 206.25 82.547 lx
+0 0 0.40693 s 230.02 75.674 m 241.91 72.241 l 248.77 78.185 l 236.89 81.616 lf
+0 sg 230.02 75.674 m 241.91 72.241 l 248.77 78.185 l 236.89 81.616 lx
+0 0 0.40691 s 39.339 75.246 m 51.226 71.815 l 58.089 77.758 l 46.202 81.19 lf
+0 sg 39.339 75.246 m 51.226 71.815 l 58.089 77.758 l 46.202 81.19 lx
+0 0 0.40691 s 260.66 74.754 m 272.55 71.322 l 279.41 77.266 l 267.52 80.697 lf
+0 sg 260.66 74.754 m 272.55 71.322 l 279.41 77.266 l 267.52 80.697 lx
+0 0 0.40715 s 69.976 74.328 m 81.863 70.893 l 88.726 76.85 l 76.839 80.268 lf
+0 sg 69.976 74.328 m 81.863 70.893 l 88.726 76.85 l 76.839 80.268 lx
+0 0 0.39456 s 180.64 73.53 m 192.52 70.796 l 199.39 76.553 l 187.5 80.171 lf
+0 sg 180.64 73.53 m 192.52 70.796 l 199.39 76.553 l 187.5 80.171 lx
+0 0 0.39456 s 100.61 73.368 m 112.5 70.123 l 119.36 75.369 l 107.48 79.498 lf
+0 sg 100.61 73.368 m 112.5 70.123 l 119.36 75.369 l 107.48 79.498 lx
+0 0 0.40715 s 211.27 73.172 m 223.16 69.727 l 230.02 75.674 l 218.14 79.102 lf
+0 sg 211.27 73.172 m 223.16 69.727 l 230.02 75.674 l 218.14 79.102 lx
+0 0 0.40691 s 20.589 72.734 m 32.476 69.303 l 39.339 75.246 l 27.452 78.678 lf
+0 sg 20.589 72.734 m 32.476 69.303 l 39.339 75.246 l 27.452 78.678 lx
+0 0 0 s 161.89 56.24 m 173.77 72.244 l 180.64 73.53 l 168.75 79.566 lf
+0 sg 161.89 56.24 m 173.77 72.244 l 180.64 73.53 l 168.75 79.566 lx
+0 0 0.40691 s 241.91 72.241 m 253.8 68.81 l 260.66 74.754 l 248.77 78.185 lf
+0 sg 241.91 72.241 m 253.8 68.81 l 260.66 74.754 l 248.77 78.185 lx
+0 0 0.40693 s 51.226 71.815 m 63.113 68.383 l 69.976 74.328 l 58.089 77.758 lf
+0 sg 51.226 71.815 m 63.113 68.383 l 69.976 74.328 l 58.089 77.758 lx
+1 1 1 s 138.11 63.103 m 150 189.41 l 156.86 65.615 l 144.98 86.429 lf
+0 sg 138.11 63.103 m 150 189.41 l 156.86 65.615 l 144.98 86.429 lx
+0 0 0.40603 s 81.863 70.893 m 93.75 67.475 l 100.61 73.368 l 88.726 76.85 lf
+0 sg 81.863 70.893 m 93.75 67.475 l 100.61 73.368 l 88.726 76.85 lx
+0 0 0.41022 s 192.52 70.796 m 204.41 67.178 l 211.27 73.172 l 199.39 76.553 lf
+0 sg 192.52 70.796 m 204.41 67.178 l 211.27 73.172 l 199.39 76.553 lx
+0 0 0.45299 s 112.5 70.123 m 124.39 65.994 l 131.25 74.542 l 119.36 75.369 lf
+0 sg 112.5 70.123 m 124.39 65.994 l 131.25 74.542 l 119.36 75.369 lx
+0 0 0.40685 s 223.16 69.727 m 235.05 66.299 l 241.91 72.241 l 230.02 75.674 lf
+0 sg 223.16 69.727 m 235.05 66.299 l 241.91 72.241 l 230.02 75.674 lx
+0 0 0.40691 s 32.476 69.303 m 44.363 65.871 l 51.226 71.815 l 39.339 75.246 lf
+0 sg 32.476 69.303 m 44.363 65.871 l 51.226 71.815 l 39.339 75.246 lx
+0 0 0.40691 s 253.8 68.81 m 265.69 65.379 l 272.55 71.322 l 260.66 74.754 lf
+0 sg 253.8 68.81 m 265.69 65.379 l 272.55 71.322 l 260.66 74.754 lx
+0 0 0.40685 s 63.113 68.383 m 75 64.953 l 81.863 70.893 l 69.976 74.328 lf
+0 sg 63.113 68.383 m 75 64.953 l 81.863 70.893 l 69.976 74.328 lx
+0 0 0.51594 s 173.77 72.244 m 185.66 63.605 l 192.52 70.796 l 180.64 73.53 lf
+0 sg 173.77 72.244 m 185.66 63.605 l 192.52 70.796 l 180.64 73.53 lx
+1 1 1 s 150 189.41 m 161.89 56.24 l 168.75 79.566 l 156.86 65.615 lf
+0 sg 150 189.41 m 161.89 56.24 l 168.75 79.566 l 156.86 65.615 lx
+0 0 0.41022 s 93.75 67.475 m 105.64 63.993 l 112.5 70.123 l 100.61 73.368 lf
+0 sg 93.75 67.475 m 105.64 63.993 l 112.5 70.123 l 100.61 73.368 lx
+0 0 0 s 124.39 65.994 m 136.27 67.22 l 143.14 53.728 l 131.25 74.542 lf
+0 sg 124.39 65.994 m 136.27 67.22 l 143.14 53.728 l 131.25 74.542 lx
+0 0 0.40603 s 204.41 67.178 m 216.3 63.797 l 223.16 69.727 l 211.27 73.172 lf
+0 sg 204.41 67.178 m 216.3 63.797 l 223.16 69.727 l 211.27 73.172 lx
+0 0 0.40691 s 13.726 66.791 m 25.613 63.359 l 32.476 69.303 l 20.589 72.734 lf
+0 sg 13.726 66.791 m 25.613 63.359 l 32.476 69.303 l 20.589 72.734 lx
+0 0 0 s 155.02 67.679 m 166.91 61.643 l 173.77 72.244 l 161.89 56.24 lf
+0 sg 155.02 67.679 m 166.91 61.643 l 173.77 72.244 l 161.89 56.24 lx
+0 0 0.40693 s 235.05 66.299 m 246.94 62.866 l 253.8 68.81 l 241.91 72.241 lf
+0 sg 235.05 66.299 m 246.94 62.866 l 253.8 68.81 l 241.91 72.241 lx
+0 0 0.40691 s 44.363 65.871 m 56.25 62.44 l 63.113 68.383 l 51.226 71.815 lf
+0 sg 44.363 65.871 m 56.25 62.44 l 63.113 68.383 l 51.226 71.815 lx
+1 1 1 s 131.25 74.542 m 143.14 53.728 l 150 189.41 l 138.11 63.103 lf
+0 sg 131.25 74.542 m 143.14 53.728 l 150 189.41 l 138.11 63.103 lx
+0 0 0.40715 s 75 64.953 m 86.887 61.518 l 93.75 67.475 l 81.863 70.893 lf
+0 sg 75 64.953 m 86.887 61.518 l 93.75 67.475 l 81.863 70.893 lx
+0 0 0.3777 s 185.66 63.605 m 197.55 61.569 l 204.41 67.178 l 192.52 70.796 lf
+0 sg 185.66 63.605 m 197.55 61.569 l 204.41 67.178 l 192.52 70.796 lx
+0 0 0.39456 s 105.64 63.993 m 117.52 60.748 l 124.39 65.994 l 112.5 70.123 lf
+0 sg 105.64 63.993 m 117.52 60.748 l 124.39 65.994 l 112.5 70.123 lx
+0 0 0 s 136.27 67.22 m 148.16 59.131 l 155.02 67.679 l 143.14 53.728 lf
+0 sg 136.27 67.22 m 148.16 59.131 l 155.02 67.679 l 143.14 53.728 lx
+0 0 0.40715 s 216.3 63.797 m 228.19 60.352 l 235.05 66.299 l 223.16 69.727 lf
+0 sg 216.3 63.797 m 228.19 60.352 l 235.05 66.299 l 223.16 69.727 lx
+0 0 0.40691 s 25.613 63.359 m 37.5 59.928 l 44.363 65.871 l 32.476 69.303 lf
+0 sg 25.613 63.359 m 37.5 59.928 l 44.363 65.871 l 32.476 69.303 lx
+0 0 0.40691 s 246.94 62.866 m 258.82 59.435 l 265.69 65.379 l 253.8 68.81 lf
+0 sg 246.94 62.866 m 258.82 59.435 l 265.69 65.379 l 253.8 68.81 lx
+0 0 0.40693 s 56.25 62.44 m 68.137 59.008 l 75 64.953 l 63.113 68.383 lf
+0 sg 56.25 62.44 m 68.137 59.008 l 75 64.953 l 63.113 68.383 lx
+0 0 0.51594 s 166.91 61.643 m 178.8 58.909 l 185.66 63.605 l 173.77 72.244 lf
+0 sg 166.91 61.643 m 178.8 58.909 l 185.66 63.605 l 173.77 72.244 lx
+1 1 1 s 143.14 53.728 m 155.02 67.679 l 161.89 56.24 l 150 189.41 lf
+0 sg 143.14 53.728 m 155.02 67.679 l 161.89 56.24 l 150 189.41 lx
+0 0 0.40603 s 86.887 61.518 m 98.774 58.1 l 105.64 63.993 l 93.75 67.475 lf
+0 sg 86.887 61.518 m 98.774 58.1 l 105.64 63.993 l 93.75 67.475 lx
+0 0 0.41474 s 197.55 61.569 m 209.44 57.764 l 216.3 63.797 l 204.41 67.178 lf
+0 sg 197.55 61.569 m 209.44 57.764 l 216.3 63.797 l 204.41 67.178 lx
+0 0 0.40691 s 6.863 60.847 m 18.75 57.416 l 25.613 63.359 l 13.726 66.791 lf
+0 sg 6.863 60.847 m 18.75 57.416 l 25.613 63.359 l 13.726 66.791 lx
+0 0 0.51594 s 117.52 60.748 m 129.41 56.069 l 136.27 67.22 l 124.39 65.994 lf
+0 sg 117.52 60.748 m 129.41 56.069 l 136.27 67.22 l 124.39 65.994 lx
+0 0 0.40685 s 228.19 60.352 m 240.07 56.924 l 246.94 62.866 l 235.05 66.299 lf
+0 sg 228.19 60.352 m 240.07 56.924 l 246.94 62.866 l 235.05 66.299 lx
+0 0 0.40691 s 37.5 59.928 m 49.387 56.496 l 56.25 62.44 l 44.363 65.871 lf
+0 sg 37.5 59.928 m 49.387 56.496 l 56.25 62.44 l 44.363 65.871 lx
+0 0 0.45299 s 148.16 59.131 m 160.05 56.397 l 166.91 61.643 l 155.02 67.679 lf
+0 sg 148.16 59.131 m 160.05 56.397 l 166.91 61.643 l 155.02 67.679 lx
+0 0 0.40685 s 68.137 59.008 m 80.024 55.578 l 86.887 61.518 l 75 64.953 lf
+0 sg 68.137 59.008 m 80.024 55.578 l 86.887 61.518 l 75 64.953 lx
+0 0 0.3777 s 178.8 58.909 m 190.69 55.291 l 197.55 61.569 l 185.66 63.605 lf
+0 sg 178.8 58.909 m 190.69 55.291 l 197.55 61.569 l 185.66 63.605 lx
+0 0 0.41022 s 98.774 58.1 m 110.66 54.618 l 117.52 60.748 l 105.64 63.993 lf
+0 sg 98.774 58.1 m 110.66 54.618 l 117.52 60.748 l 105.64 63.993 lx
+0 0 0.40481 s 209.44 57.764 m 221.32 54.432 l 228.19 60.352 l 216.3 63.797 lf
+0 sg 209.44 57.764 m 221.32 54.432 l 228.19 60.352 l 216.3 63.797 lx
+0 0 0.40691 s 18.75 57.416 m 30.637 53.984 l 37.5 59.928 l 25.613 63.359 lf
+0 sg 18.75 57.416 m 30.637 53.984 l 37.5 59.928 l 25.613 63.359 lx
+0 0 0.51594 s 129.41 56.069 m 141.3 53.885 l 148.16 59.131 l 136.27 67.22 lf
+0 sg 129.41 56.069 m 141.3 53.885 l 148.16 59.131 l 136.27 67.22 lx
+0 0 0.40693 s 240.07 56.924 m 251.96 53.492 l 258.82 59.435 l 246.94 62.866 lf
+0 sg 240.07 56.924 m 251.96 53.492 l 258.82 59.435 l 246.94 62.866 lx
+0 0 0.40691 s 49.387 56.496 m 61.274 53.065 l 68.137 59.008 l 56.25 62.44 lf
+0 sg 49.387 56.496 m 61.274 53.065 l 68.137 59.008 l 56.25 62.44 lx
+0 0 0.39456 s 160.05 56.397 m 171.94 52.779 l 178.8 58.909 l 166.91 61.643 lf
+0 sg 160.05 56.397 m 171.94 52.779 l 178.8 58.909 l 166.91 61.643 lx
+0 0 0.40715 s 80.024 55.578 m 91.911 52.143 l 98.774 58.1 l 86.887 61.518 lf
+0 sg 80.024 55.578 m 91.911 52.143 l 98.774 58.1 l 86.887 61.518 lx
+0 0 0.41474 s 190.69 55.291 m 202.57 51.91 l 209.44 57.764 l 197.55 61.569 lf
+0 sg 190.69 55.291 m 202.57 51.91 l 209.44 57.764 l 197.55 61.569 lx
+0 0 0.40691 s 0 54.904 m 11.887 51.472 l 18.75 57.416 l 6.863 60.847 lf
+0 sg 0 54.904 m 11.887 51.472 l 18.75 57.416 l 6.863 60.847 lx
+0 0 0.3777 s 110.66 54.618 m 122.55 51.521 l 129.41 56.069 l 117.52 60.748 lf
+0 sg 110.66 54.618 m 122.55 51.521 l 129.41 56.069 l 117.52 60.748 lx
+0 0 0.40749 s 221.32 54.432 m 233.21 50.974 l 240.07 56.924 l 228.19 60.352 lf
+0 sg 221.32 54.432 m 233.21 50.974 l 240.07 56.924 l 228.19 60.352 lx
+0 0 0.40691 s 30.637 53.984 m 42.524 50.553 l 49.387 56.496 l 37.5 59.928 lf
+0 sg 30.637 53.984 m 42.524 50.553 l 49.387 56.496 l 37.5 59.928 lx
+0 0 0.39456 s 141.3 53.885 m 153.19 50.267 l 160.05 56.397 l 148.16 59.131 lf
+0 sg 141.3 53.885 m 153.19 50.267 l 160.05 56.397 l 148.16 59.131 lx
+0 0 0.40693 s 61.274 53.065 m 73.161 49.633 l 80.024 55.578 l 68.137 59.008 lf
+0 sg 61.274 53.065 m 73.161 49.633 l 80.024 55.578 l 68.137 59.008 lx
+0 0 0.41022 s 171.94 52.779 m 183.82 49.398 l 190.69 55.291 l 178.8 58.909 lf
+0 sg 171.94 52.779 m 183.82 49.398 l 190.69 55.291 l 178.8 58.909 lx
+0 0 0.40603 s 91.911 52.143 m 103.8 48.725 l 110.66 54.618 l 98.774 58.1 lf
+0 sg 91.911 52.143 m 103.8 48.725 l 110.66 54.618 l 98.774 58.1 lx
+0 0 0.40481 s 202.57 51.91 m 214.46 48.465 l 221.32 54.432 l 209.44 57.764 lf
+0 sg 202.57 51.91 m 214.46 48.465 l 221.32 54.432 l 209.44 57.764 lx
+0 0 0.40691 s 11.887 51.472 m 23.774 48.041 l 30.637 53.984 l 18.75 57.416 lf
+0 sg 11.887 51.472 m 23.774 48.041 l 30.637 53.984 l 18.75 57.416 lx
+0 0 0.3777 s 122.55 51.521 m 134.44 47.755 l 141.3 53.885 l 129.41 56.069 lf
+0 sg 122.55 51.521 m 134.44 47.755 l 141.3 53.885 l 129.41 56.069 lx
+0 0 0.40672 s 233.21 50.974 m 245.1 47.548 l 251.96 53.492 l 240.07 56.924 lf
+0 sg 233.21 50.974 m 245.1 47.548 l 251.96 53.492 l 240.07 56.924 lx
+0 0 0.40691 s 42.524 50.553 m 54.411 47.121 l 61.274 53.065 l 49.387 56.496 lf
+0 sg 42.524 50.553 m 54.411 47.121 l 61.274 53.065 l 49.387 56.496 lx
+0 0 0.41022 s 153.19 50.267 m 165.07 46.886 l 171.94 52.779 l 160.05 56.397 lf
+0 sg 153.19 50.267 m 165.07 46.886 l 171.94 52.779 l 160.05 56.397 lx
+0 0 0.40685 s 73.161 49.633 m 85.048 46.203 l 91.911 52.143 l 80.024 55.578 lf
+0 sg 73.161 49.633 m 85.048 46.203 l 91.911 52.143 l 80.024 55.578 lx
+0 0 0.40603 s 183.82 49.398 m 195.71 45.953 l 202.57 51.91 l 190.69 55.291 lf
+0 sg 183.82 49.398 m 195.71 45.953 l 202.57 51.91 l 190.69 55.291 lx
+0 0 0.41474 s 103.8 48.725 m 115.69 45.203 l 122.55 51.521 l 110.66 54.618 lf
+0 sg 103.8 48.725 m 115.69 45.203 l 122.55 51.521 l 110.66 54.618 lx
+0 0 0.40749 s 214.46 48.465 m 226.35 45.037 l 233.21 50.974 l 221.32 54.432 lf
+0 sg 214.46 48.465 m 226.35 45.037 l 233.21 50.974 l 221.32 54.432 lx
+0 0 0.40691 s 23.774 48.041 m 35.661 44.609 l 42.524 50.553 l 30.637 53.984 lf
+0 sg 23.774 48.041 m 35.661 44.609 l 42.524 50.553 l 30.637 53.984 lx
+0 0 0.41022 s 134.44 47.755 m 146.32 44.374 l 153.19 50.267 l 141.3 53.885 lf
+0 sg 134.44 47.755 m 146.32 44.374 l 153.19 50.267 l 141.3 53.885 lx
+0 0 0.40691 s 54.411 47.121 m 66.298 43.69 l 73.161 49.633 l 61.274 53.065 lf
+0 sg 54.411 47.121 m 66.298 43.69 l 73.161 49.633 l 61.274 53.065 lx
+0 0 0.40603 s 165.07 46.886 m 176.96 43.441 l 183.82 49.398 l 171.94 52.779 lf
+0 sg 165.07 46.886 m 176.96 43.441 l 183.82 49.398 l 171.94 52.779 lx
+0 0 0.40715 s 85.048 46.203 m 96.935 42.768 l 103.8 48.725 l 91.911 52.143 lf
+0 sg 85.048 46.203 m 96.935 42.768 l 103.8 48.725 l 91.911 52.143 lx
+0 0 0.40715 s 195.71 45.953 m 207.6 42.525 l 214.46 48.465 l 202.57 51.91 lf
+0 sg 195.71 45.953 m 207.6 42.525 l 214.46 48.465 l 202.57 51.91 lx
+0 0 0.41474 s 115.69 45.203 m 127.57 41.862 l 134.44 47.755 l 122.55 51.521 lf
+0 sg 115.69 45.203 m 127.57 41.862 l 134.44 47.755 l 122.55 51.521 lx
+0 0 0.40672 s 226.35 45.037 m 238.23 41.605 l 245.1 47.548 l 233.21 50.974 lf
+0 sg 226.35 45.037 m 238.23 41.605 l 245.1 47.548 l 233.21 50.974 lx
+0 0 0.40691 s 35.661 44.609 m 47.548 41.178 l 54.411 47.121 l 42.524 50.553 lf
+0 sg 35.661 44.609 m 47.548 41.178 l 54.411 47.121 l 42.524 50.553 lx
+0 0 0.40603 s 146.32 44.374 m 158.21 40.929 l 165.07 46.886 l 153.19 50.267 lf
+0 sg 146.32 44.374 m 158.21 40.929 l 165.07 46.886 l 153.19 50.267 lx
+0 0 0.40693 s 66.298 43.69 m 78.185 40.258 l 85.048 46.203 l 73.161 49.633 lf
+0 sg 66.298 43.69 m 78.185 40.258 l 85.048 46.203 l 73.161 49.633 lx
+0 0 0.40715 s 176.96 43.441 m 188.85 40.013 l 195.71 45.953 l 183.82 49.398 lf
+0 sg 176.96 43.441 m 188.85 40.013 l 195.71 45.953 l 183.82 49.398 lx
+0 0 0.40481 s 96.935 42.768 m 108.82 39.36 l 115.69 45.203 l 103.8 48.725 lf
+0 sg 96.935 42.768 m 108.82 39.36 l 115.69 45.203 l 103.8 48.725 lx
+0 0 0.40685 s 207.6 42.525 m 219.48 39.092 l 226.35 45.037 l 214.46 48.465 lf
+0 sg 207.6 42.525 m 219.48 39.092 l 226.35 45.037 l 214.46 48.465 lx
+0 0 0.40603 s 127.57 41.862 m 139.46 38.417 l 146.32 44.374 l 134.44 47.755 lf
+0 sg 127.57 41.862 m 139.46 38.417 l 146.32 44.374 l 134.44 47.755 lx
+0 0 0.40691 s 47.548 41.178 m 59.435 37.746 l 66.298 43.69 l 54.411 47.121 lf
+0 sg 47.548 41.178 m 59.435 37.746 l 66.298 43.69 l 54.411 47.121 lx
+0 0 0.40715 s 158.21 40.929 m 170.1 37.501 l 176.96 43.441 l 165.07 46.886 lf
+0 sg 158.21 40.929 m 170.1 37.501 l 176.96 43.441 l 165.07 46.886 lx
+0 0 0.40685 s 78.185 40.258 m 90.072 36.828 l 96.935 42.768 l 85.048 46.203 lf
+0 sg 78.185 40.258 m 90.072 36.828 l 96.935 42.768 l 85.048 46.203 lx
+0 0 0.40685 s 188.85 40.013 m 200.73 36.58 l 207.6 42.525 l 195.71 45.953 lf
+0 sg 188.85 40.013 m 200.73 36.58 l 207.6 42.525 l 195.71 45.953 lx
+0 0 0.40481 s 108.82 39.36 m 120.71 35.905 l 127.57 41.862 l 115.69 45.203 lf
+0 sg 108.82 39.36 m 120.71 35.905 l 127.57 41.862 l 115.69 45.203 lx
+0 0 0.40693 s 219.48 39.092 m 231.37 35.661 l 238.23 41.605 l 226.35 45.037 lf
+0 sg 219.48 39.092 m 231.37 35.661 l 238.23 41.605 l 226.35 45.037 lx
+0 0 0.40715 s 139.46 38.417 m 151.35 34.989 l 158.21 40.929 l 146.32 44.374 lf
+0 sg 139.46 38.417 m 151.35 34.989 l 158.21 40.929 l 146.32 44.374 lx
+0 0 0.40691 s 59.435 37.746 m 71.322 34.315 l 78.185 40.258 l 66.298 43.69 lf
+0 sg 59.435 37.746 m 71.322 34.315 l 78.185 40.258 l 66.298 43.69 lx
+0 0 0.40685 s 170.1 37.501 m 181.98 34.068 l 188.85 40.013 l 176.96 43.441 lf
+0 sg 170.1 37.501 m 181.98 34.068 l 188.85 40.013 l 176.96 43.441 lx
+0 0 0.40749 s 90.072 36.828 m 101.96 33.39 l 108.82 39.36 l 96.935 42.768 lf
+0 sg 90.072 36.828 m 101.96 33.39 l 108.82 39.36 l 96.935 42.768 lx
+0 0 0.40693 s 200.73 36.58 m 212.62 33.149 l 219.48 39.092 l 207.6 42.525 lf
+0 sg 200.73 36.58 m 212.62 33.149 l 219.48 39.092 l 207.6 42.525 lx
+0 0 0.40715 s 120.71 35.905 m 132.6 32.477 l 139.46 38.417 l 127.57 41.862 lf
+0 sg 120.71 35.905 m 132.6 32.477 l 139.46 38.417 l 127.57 41.862 lx
+0 0 0.40685 s 151.35 34.989 m 163.23 31.556 l 170.1 37.501 l 158.21 40.929 lf
+0 sg 151.35 34.989 m 163.23 31.556 l 170.1 37.501 l 158.21 40.929 lx
+0 0 0.40693 s 71.322 34.315 m 83.209 30.883 l 90.072 36.828 l 78.185 40.258 lf
+0 sg 71.322 34.315 m 83.209 30.883 l 90.072 36.828 l 78.185 40.258 lx
+0 0 0.40693 s 181.98 34.068 m 193.87 30.637 l 200.73 36.58 l 188.85 40.013 lf
+0 sg 181.98 34.068 m 193.87 30.637 l 200.73 36.58 l 188.85 40.013 lx
+0 0 0.40749 s 101.96 33.39 m 113.85 29.965 l 120.71 35.905 l 108.82 39.36 lf
+0 sg 101.96 33.39 m 113.85 29.965 l 120.71 35.905 l 108.82 39.36 lx
+0 0 0.40691 s 212.62 33.149 m 224.51 29.718 l 231.37 35.661 l 219.48 39.092 lf
+0 sg 212.62 33.149 m 224.51 29.718 l 231.37 35.661 l 219.48 39.092 lx
+0 0 0.40685 s 132.6 32.477 m 144.48 29.044 l 151.35 34.989 l 139.46 38.417 lf
+0 sg 132.6 32.477 m 144.48 29.044 l 151.35 34.989 l 139.46 38.417 lx
+0 0 0.40693 s 163.23 31.556 m 175.12 28.125 l 181.98 34.068 l 170.1 37.501 lf
+0 sg 163.23 31.556 m 175.12 28.125 l 181.98 34.068 l 170.1 37.501 lx
+0 0 0.40672 s 83.209 30.883 m 95.096 27.452 l 101.96 33.39 l 90.072 36.828 lf
+0 sg 83.209 30.883 m 95.096 27.452 l 101.96 33.39 l 90.072 36.828 lx
+0 0 0.40691 s 193.87 30.637 m 205.76 27.206 l 212.62 33.149 l 200.73 36.58 lf
+0 sg 193.87 30.637 m 205.76 27.206 l 212.62 33.149 l 200.73 36.58 lx
+0 0 0.40685 s 113.85 29.965 m 125.73 26.532 l 132.6 32.477 l 120.71 35.905 lf
+0 sg 113.85 29.965 m 125.73 26.532 l 132.6 32.477 l 120.71 35.905 lx
+0 0 0.40693 s 144.48 29.044 m 156.37 25.613 l 163.23 31.556 l 151.35 34.989 lf
+0 sg 144.48 29.044 m 156.37 25.613 l 163.23 31.556 l 151.35 34.989 lx
+0 0 0.40691 s 175.12 28.125 m 187.01 24.693 l 193.87 30.637 l 181.98 34.068 lf
+0 sg 175.12 28.125 m 187.01 24.693 l 193.87 30.637 l 181.98 34.068 lx
+0 0 0.40672 s 95.096 27.452 m 106.98 24.02 l 113.85 29.965 l 101.96 33.39 lf
+0 sg 95.096 27.452 m 106.98 24.02 l 113.85 29.965 l 101.96 33.39 lx
+0 0 0.40691 s 205.76 27.206 m 217.64 23.774 l 224.51 29.718 l 212.62 33.149 lf
+0 sg 205.76 27.206 m 217.64 23.774 l 224.51 29.718 l 212.62 33.149 lx
+0 0 0.40693 s 125.73 26.532 m 137.62 23.101 l 144.48 29.044 l 132.6 32.477 lf
+0 sg 125.73 26.532 m 137.62 23.101 l 144.48 29.044 l 132.6 32.477 lx
+0 0 0.40691 s 156.37 25.613 m 168.26 22.181 l 175.12 28.125 l 163.23 31.556 lf
+0 sg 156.37 25.613 m 168.26 22.181 l 175.12 28.125 l 163.23 31.556 lx
+0 0 0.40691 s 187.01 24.693 m 198.89 21.262 l 205.76 27.206 l 193.87 30.637 lf
+0 sg 187.01 24.693 m 198.89 21.262 l 205.76 27.206 l 193.87 30.637 lx
+0 0 0.40693 s 106.98 24.02 m 118.87 20.589 l 125.73 26.532 l 113.85 29.965 lf
+0 sg 106.98 24.02 m 118.87 20.589 l 125.73 26.532 l 113.85 29.965 lx
+0 0 0.40691 s 137.62 23.101 m 149.51 19.669 l 156.37 25.613 l 144.48 29.044 lf
+0 sg 137.62 23.101 m 149.51 19.669 l 156.37 25.613 l 144.48 29.044 lx
+0 0 0.40691 s 168.26 22.181 m 180.14 18.75 l 187.01 24.693 l 175.12 28.125 lf
+0 sg 168.26 22.181 m 180.14 18.75 l 187.01 24.693 l 175.12 28.125 lx
+0 0 0.40691 s 198.89 21.262 m 210.78 17.831 l 217.64 23.774 l 205.76 27.206 lf
+0 sg 198.89 21.262 m 210.78 17.831 l 217.64 23.774 l 205.76 27.206 lx
+0 0 0.40691 s 118.87 20.589 m 130.76 17.157 l 137.62 23.101 l 125.73 26.532 lf
+0 sg 118.87 20.589 m 130.76 17.157 l 137.62 23.101 l 125.73 26.532 lx
+0 0 0.40691 s 149.51 19.669 m 161.39 16.238 l 168.26 22.181 l 156.37 25.613 lf
+0 sg 149.51 19.669 m 161.39 16.238 l 168.26 22.181 l 156.37 25.613 lx
+0 0 0.40691 s 180.14 18.75 m 192.03 15.319 l 198.89 21.262 l 187.01 24.693 lf
+0 sg 180.14 18.75 m 192.03 15.319 l 198.89 21.262 l 187.01 24.693 lx
+0 0 0.40691 s 130.76 17.157 m 142.64 13.726 l 149.51 19.669 l 137.62 23.101 lf
+0 sg 130.76 17.157 m 142.64 13.726 l 149.51 19.669 l 137.62 23.101 lx
+0 0 0.40691 s 161.39 16.238 m 173.28 12.806 l 180.14 18.75 l 168.26 22.181 lf
+0 sg 161.39 16.238 m 173.28 12.806 l 180.14 18.75 l 168.26 22.181 lx
+0 0 0.40691 s 192.03 15.319 m 203.92 11.887 l 210.78 17.831 l 198.89 21.262 lf
+0 sg 192.03 15.319 m 203.92 11.887 l 210.78 17.831 l 198.89 21.262 lx
+0 0 0.40691 s 142.64 13.726 m 154.53 10.294 l 161.39 16.238 l 149.51 19.669 lf
+0 sg 142.64 13.726 m 154.53 10.294 l 161.39 16.238 l 149.51 19.669 lx
+0 0 0.40691 s 173.28 12.806 m 185.17 9.375 l 192.03 15.319 l 180.14 18.75 lf
+0 sg 173.28 12.806 m 185.17 9.375 l 192.03 15.319 l 180.14 18.75 lx
+0 0 0.40691 s 154.53 10.294 m 166.42 6.863 l 173.28 12.806 l 161.39 16.238 lf
+0 sg 154.53 10.294 m 166.42 6.863 l 173.28 12.806 l 161.39 16.238 lx
+0 0 0.40691 s 185.17 9.375 m 197.06 5.9435 l 203.92 11.887 l 192.03 15.319 lf
+0 sg 185.17 9.375 m 197.06 5.9435 l 203.92 11.887 l 192.03 15.319 lx
+0 0 0.40691 s 166.42 6.863 m 178.31 3.4315 l 185.17 9.375 l 173.28 12.806 lf
+0 sg 166.42 6.863 m 178.31 3.4315 l 185.17 9.375 l 173.28 12.806 lx
+0 0 0.40691 s 178.31 3.4315 m 190.19 0 l 197.06 5.9435 l 185.17 9.375 lf
+0 sg 178.31 3.4315 m 190.19 0 l 197.06 5.9435 l 185.17 9.375 lx
+showpage
+.
+  Postprocessing: time= 0.028, step=   1, sweep= 0. [ee]
+  Postprocessing: time= 0.056, step=   2, sweep= 0. [ee]
+  Postprocessing: time= 0.084, step=   3, sweep= 0. [ee]
+  Postprocessing: time= 0.112, step=   4, sweep= 0. [ee]
+  Postprocessing: time=  0.14, step=   5, sweep= 0. [ee]
+  Postprocessing: time= 0.168, step=   6, sweep= 0. [ee]
+  Postprocessing: time= 0.196, step=   7, sweep= 0. [ee]
+  Postprocessing: time= 0.224, step=   8, sweep= 0. [ee]
+  Postprocessing: time= 0.252, step=   9, sweep= 0. [ee]
+  Postprocessing: time=  0.28, step=  10, sweep= 0. [ee]
+  Postprocessing: time= 0.308, step=  11, sweep= 0. [ee]
+  Postprocessing: time= 0.336, step=  12, sweep= 0. [ee]
+  Postprocessing: time= 0.364, step=  13, sweep= 0. [ee]
+  Postprocessing: time= 0.392, step=  14, sweep= 0. [ee]
+  Postprocessing: time=  0.42, step=  15, sweep= 0. [ee]
+  Postprocessing: time= 0.448, step=  16, sweep= 0. [ee]
+  Postprocessing: time= 0.476, step=  17, sweep= 0. [ee]
+  Postprocessing: time= 0.504, step=  18, sweep= 0. [ee]
+  Postprocessing: time= 0.532, step=  19, sweep= 0. [ee]
+  Postprocessing: time=  0.56, step=  20, sweep= 0. [ee]
+  Postprocessing: time= 0.588, step=  21, sweep= 0. [ee]
+  Postprocessing: time= 0.616, step=  22, sweep= 0. [ee]
+  Postprocessing: time= 0.644, step=  23, sweep= 0. [ee]
+  Postprocessing: time= 0.672, step=  24, sweep= 0. [ee]
+  Postprocessing: time=   0.7, step=  25, sweep= 0. [ee][o]%!PS-Adobe-2.0 EPSF-1.2
+%%Title: deal.II Output
+%%Creator: the deal.II library
+%%Creation Date: 1999/8/12 - 17:49: 4
+%%BoundingBox: 0 0 300 150
+/m {moveto} bind def
+/l {lineto} bind def
+/s {setrgbcolor} bind def
+/sg {setgray} bind def
+/lx {lineto closepath stroke} bind def
+/lf {lineto closepath fill} bind def
+%%EndProlog
+
+0.5 setlinewidth
+0 0.9599 0.040097 s 102.94 144.06 m 114.83 140.54 l 121.69 146.57 l 109.81 150 lf
+0 sg 102.94 144.06 m 114.83 140.54 l 121.69 146.57 l 109.81 150 lx
+0.16685 0.83315 0 s 114.83 140.54 m 126.72 139.96 l 133.58 143.14 l 121.69 146.57 lf
+0 sg 114.83 140.54 m 126.72 139.96 l 133.58 143.14 l 121.69 146.57 lx
+0.15365 0.84635 0 s 96.082 138.11 m 107.97 137.27 l 114.83 140.54 l 102.94 144.06 lf
+0 sg 96.082 138.11 m 107.97 137.27 l 114.83 140.54 l 102.94 144.06 lx
+0.29608 0.70392 0 s 126.72 139.96 m 138.61 135.4 l 145.47 139.71 l 133.58 143.14 lf
+0 sg 126.72 139.96 m 138.61 135.4 l 145.47 139.71 l 133.58 143.14 lx
+0.5405 0.4595 0 s 107.97 137.27 m 119.86 133.65 l 126.72 139.96 l 114.83 140.54 lf
+0 sg 107.97 137.27 m 119.86 133.65 l 126.72 139.96 l 114.83 140.54 lx
+0.056033 0.94397 0 s 138.61 135.4 m 150.49 129.89 l 157.36 136.27 l 145.47 139.71 lf
+0 sg 138.61 135.4 m 150.49 129.89 l 157.36 136.27 l 145.47 139.71 lx
+0.43065 0.56935 0 s 89.219 132.17 m 101.11 132.35 l 107.97 137.27 l 96.082 138.11 lf
+0 sg 89.219 132.17 m 101.11 132.35 l 107.97 137.27 l 96.082 138.11 lx
+0 0.82167 0.17833 s 150.49 129.89 m 162.38 125.41 l 169.24 132.84 l 157.36 136.27 lf
+0 sg 150.49 129.89 m 162.38 125.41 l 169.24 132.84 l 157.36 136.27 lx
+0.70913 0.29087 0 s 119.86 133.65 m 131.74 130.93 l 138.61 135.4 l 126.72 139.96 lf
+0 sg 119.86 133.65 m 131.74 130.93 l 138.61 135.4 l 126.72 139.96 lx
+0.87044 0.12956 0 s 101.11 132.35 m 112.99 128.77 l 119.86 133.65 l 107.97 137.27 lf
+0 sg 101.11 132.35 m 112.99 128.77 l 119.86 133.65 l 107.97 137.27 lx
+0.32597 0.67404 0 s 131.74 130.93 m 143.63 124.88 l 150.49 129.89 l 138.61 135.4 lf
+0 sg 131.74 130.93 m 143.63 124.88 l 150.49 129.89 l 138.61 135.4 lx
+0 0.77878 0.22122 s 162.38 125.41 m 174.27 122.45 l 181.13 129.41 l 169.24 132.84 lf
+0 sg 162.38 125.41 m 174.27 122.45 l 181.13 129.41 l 169.24 132.84 lx
+0.35995 0.64005 0 s 82.356 126.23 m 94.243 124.44 l 101.11 132.35 l 89.219 132.17 lf
+0 sg 82.356 126.23 m 94.243 124.44 l 101.11 132.35 l 89.219 132.17 lx
+0 0.69985 0.30015 s 143.63 124.88 m 155.52 118.84 l 162.38 125.41 l 150.49 129.89 lf
+0 sg 143.63 124.88 m 155.52 118.84 l 162.38 125.41 l 150.49 129.89 lx
+0.78864 0.21136 0 s 112.99 128.77 m 124.88 123.87 l 131.74 130.93 l 119.86 133.65 lf
+0 sg 112.99 128.77 m 124.88 123.87 l 131.74 130.93 l 119.86 133.65 lx
+0 0.85117 0.14883 s 174.27 122.45 m 186.15 119.52 l 193.02 125.98 l 181.13 129.41 lf
+0 sg 174.27 122.45 m 186.15 119.52 l 193.02 125.98 l 181.13 129.41 lx
+0.81365 0.18635 0 s 94.243 124.44 m 106.13 121.95 l 112.99 128.77 l 101.11 132.35 lf
+0 sg 94.243 124.44 m 106.13 121.95 l 112.99 128.77 l 101.11 132.35 lx
+0 0.50326 0.49674 s 155.52 118.84 m 167.4 115.96 l 174.27 122.45 l 162.38 125.41 lf
+0 sg 155.52 118.84 m 167.4 115.96 l 174.27 122.45 l 162.38 125.41 lx
+0.37472 0.62528 0 s 124.88 123.87 m 136.77 118.3 l 143.63 124.88 l 131.74 130.93 lf
+0 sg 124.88 123.87 m 136.77 118.3 l 143.63 124.88 l 131.74 130.93 lx
+0.075048 0.92495 0 s 75.493 120.28 m 87.38 116.66 l 94.243 124.44 l 82.356 126.23 lf
+0 sg 75.493 120.28 m 87.38 116.66 l 94.243 124.44 l 82.356 126.23 lx
+0 0.88777 0.11223 s 186.15 119.52 m 198.04 116.08 l 204.9 122.55 l 193.02 125.98 lf
+0 sg 186.15 119.52 m 198.04 116.08 l 204.9 122.55 l 193.02 125.98 lx
+0 0.81548 0.18452 s 136.77 118.3 m 148.65 114.77 l 155.52 118.84 l 143.63 124.88 lf
+0 sg 136.77 118.3 m 148.65 114.77 l 155.52 118.84 l 143.63 124.88 lx
+0.64742 0.35258 0 s 106.13 121.95 m 118.02 116.97 l 124.88 123.87 l 112.99 128.77 lf
+0 sg 106.13 121.95 m 118.02 116.97 l 124.88 123.87 l 112.99 128.77 lx
+0 0.63766 0.36234 s 167.4 115.96 m 179.29 112.8 l 186.15 119.52 l 174.27 122.45 lf
+0 sg 167.4 115.96 m 179.29 112.8 l 186.15 119.52 l 174.27 122.45 lx
+0 0.88777 0.11223 s 198.04 116.08 m 209.93 112.65 l 216.79 119.12 l 204.9 122.55 lf
+0 sg 198.04 116.08 m 209.93 112.65 l 216.79 119.12 l 204.9 122.55 lx
+0.25101 0.74899 0 s 87.38 116.66 m 99.267 113.18 l 106.13 121.95 l 94.243 124.44 lf
+0 sg 87.38 116.66 m 99.267 113.18 l 106.13 121.95 l 94.243 124.44 lx
+0.24057 0.75943 0 s 118.02 116.97 m 129.9 113.27 l 136.77 118.3 l 124.88 123.87 lf
+0 sg 118.02 116.97 m 129.9 113.27 l 136.77 118.3 l 124.88 123.87 lx
+0 0.61832 0.38168 s 148.65 114.77 m 160.54 110.85 l 167.4 115.96 l 155.52 118.84 lf
+0 sg 148.65 114.77 m 160.54 110.85 l 167.4 115.96 l 155.52 118.84 lx
+0 0.75152 0.24848 s 179.29 112.8 m 191.18 110.13 l 198.04 116.08 l 186.15 119.52 lf
+0 sg 179.29 112.8 m 191.18 110.13 l 198.04 116.08 l 186.15 119.52 lx
+0.014731 0.98527 0 s 68.63 114.34 m 80.517 111.74 l 87.38 116.66 l 75.493 120.28 lf
+0 sg 68.63 114.34 m 80.517 111.74 l 87.38 116.66 l 75.493 120.28 lx
+0 0.85117 0.14883 s 209.93 112.65 m 221.81 108.73 l 228.68 115.69 l 216.79 119.12 lf
+0 sg 209.93 112.65 m 221.81 108.73 l 228.68 115.69 l 216.79 119.12 lx
+0.13581 0.86419 0 s 99.267 113.18 m 111.15 108.86 l 118.02 116.97 l 106.13 121.95 lf
+0 sg 99.267 113.18 m 111.15 108.86 l 118.02 116.97 l 106.13 121.95 lx
+0 0.94432 0.055679 s 129.9 113.27 m 141.79 108.39 l 148.65 114.77 l 136.77 118.3 lf
+0 sg 129.9 113.27 m 141.79 108.39 l 148.65 114.77 l 136.77 118.3 lx
+0 0.7691 0.2309 s 160.54 110.85 m 172.43 109.1 l 179.29 112.8 l 167.4 115.96 lf
+0 sg 160.54 110.85 m 172.43 109.1 l 179.29 112.8 l 167.4 115.96 lx
+0 0.9242 0.0758 s 80.517 111.74 m 92.404 106.51 l 99.267 113.18 l 87.38 116.66 lf
+0 sg 80.517 111.74 m 92.404 106.51 l 99.267 113.18 l 87.38 116.66 lx
+0 0.75152 0.24848 s 191.18 110.13 m 203.06 105.94 l 209.93 112.65 l 198.04 116.08 lf
+0 sg 191.18 110.13 m 203.06 105.94 l 209.93 112.65 l 198.04 116.08 lx
+0 0.99211 0.0078871 s 111.15 108.86 m 123.04 106.22 l 129.9 113.27 l 118.02 116.97 lf
+0 sg 111.15 108.86 m 123.04 106.22 l 129.9 113.27 l 118.02 116.97 lx
+0 0.77878 0.22122 s 221.81 108.73 m 233.7 104.83 l 240.56 112.25 l 228.68 115.69 lf
+0 sg 221.81 108.73 m 233.7 104.83 l 240.56 112.25 l 228.68 115.69 lx
+0 0.80928 0.19072 s 141.79 108.39 m 153.68 105.19 l 160.54 110.85 l 148.65 114.77 lf
+0 sg 141.79 108.39 m 153.68 105.19 l 160.54 110.85 l 148.65 114.77 lx
+0 0.93868 0.061323 s 172.43 109.1 m 184.31 105.22 l 191.18 110.13 l 179.29 112.8 lf
+0 sg 172.43 109.1 m 184.31 105.22 l 191.18 110.13 l 179.29 112.8 lx
+0 0.45822 0.54178 s 92.404 106.51 m 104.29 99.6 l 111.15 108.86 l 99.267 113.18 lf
+0 sg 92.404 106.51 m 104.29 99.6 l 111.15 108.86 l 99.267 113.18 lx
+0.34403 0.65597 0 s 61.767 108.4 m 73.654 109.17 l 80.517 111.74 l 68.63 114.34 lf
+0 sg 61.767 108.4 m 73.654 109.17 l 80.517 111.74 l 68.63 114.34 lx
+0 0.63766 0.36234 s 203.06 105.94 m 214.95 102.24 l 221.81 108.73 l 209.93 112.65 lf
+0 sg 203.06 105.94 m 214.95 102.24 l 221.81 108.73 l 209.93 112.65 lx
+0 0.95062 0.049377 s 123.04 106.22 m 134.93 103.17 l 141.79 108.39 l 129.9 113.27 lf
+0 sg 123.04 106.22 m 134.93 103.17 l 141.79 108.39 l 129.9 113.27 lx
+0 0.82167 0.17833 s 233.7 104.83 m 245.59 102.44 l 252.45 108.82 l 240.56 112.25 lf
+0 sg 233.7 104.83 m 245.59 102.44 l 252.45 108.82 l 240.56 112.25 lx
+0 0.98545 0.014552 s 153.68 105.19 m 165.56 102.69 l 172.43 109.1 l 160.54 110.85 lf
+0 sg 153.68 105.19 m 165.56 102.69 l 172.43 109.1 l 160.54 110.85 lx
+0 0.31336 0.68664 s 104.29 99.6 m 116.18 97.812 l 123.04 106.22 l 111.15 108.86 lf
+0 sg 104.29 99.6 m 116.18 97.812 l 123.04 106.22 l 111.15 108.86 lx
+0 0.93868 0.061323 s 184.31 105.22 m 196.2 102.23 l 203.06 105.94 l 191.18 110.13 lf
+0 sg 184.31 105.22 m 196.2 102.23 l 203.06 105.94 l 191.18 110.13 lx
+0 0.50326 0.49674 s 214.95 102.24 m 226.84 98.25 l 233.7 104.83 l 221.81 108.73 lf
+0 sg 214.95 102.24 m 226.84 98.25 l 233.7 104.83 l 221.81 108.73 lx
+0.67823 0.32177 0 s 73.654 109.17 m 85.541 106.96 l 92.404 106.51 l 80.517 111.74 lf
+0 sg 73.654 109.17 m 85.541 106.96 l 92.404 106.51 l 80.517 111.74 lx
+0 0.92046 0.079544 s 134.93 103.17 m 146.81 100.17 l 153.68 105.19 l 141.79 108.39 lf
+0 sg 134.93 103.17 m 146.81 100.17 l 153.68 105.19 l 141.79 108.39 lx
+0.056033 0.94397 0 s 245.59 102.44 m 257.48 101.09 l 264.34 105.39 l 252.45 108.82 lf
+0 sg 245.59 102.44 m 257.48 101.09 l 264.34 105.39 l 252.45 108.82 lx
+0 0.0731 0.9269 s 85.541 106.96 m 97.428 86.17 l 104.29 99.6 l 92.404 106.51 lf
+0 sg 85.541 106.96 m 97.428 86.17 l 104.29 99.6 l 92.404 106.51 lx
+0.18494 0.81506 0 s 165.56 102.69 m 177.45 99.753 l 184.31 105.22 l 172.43 109.1 lf
+0 sg 165.56 102.69 m 177.45 99.753 l 184.31 105.22 l 172.43 109.1 lx
+0.50399 0.49601 0 s 54.904 102.45 m 66.791 101.99 l 73.654 109.17 l 61.767 108.4 lf
+0 sg 54.904 102.45 m 66.791 101.99 l 73.654 109.17 l 61.767 108.4 lx
+0 0.7691 0.2309 s 196.2 102.23 m 208.09 97.129 l 214.95 102.24 l 203.06 105.94 lf
+0 sg 196.2 102.23 m 208.09 97.129 l 214.95 102.24 l 203.06 105.94 lx
+0 0.67338 0.32662 s 116.18 97.812 m 128.06 96.376 l 134.93 103.17 l 123.04 106.22 lf
+0 sg 116.18 97.812 m 128.06 96.376 l 134.93 103.17 l 123.04 106.22 lx
+0 0.69985 0.30015 s 226.84 98.25 m 238.73 97.426 l 245.59 102.44 l 233.7 104.83 lf
+0 sg 226.84 98.25 m 238.73 97.426 l 245.59 102.44 l 233.7 104.83 lx
+0 0 0.30666 s 97.428 86.17 m 109.31 91.702 l 116.18 97.812 l 104.29 99.6 lf
+0 sg 97.428 86.17 m 109.31 91.702 l 116.18 97.812 l 104.29 99.6 lx
+0.051768 0.94823 0 s 146.81 100.17 m 158.7 96.889 l 165.56 102.69 l 153.68 105.19 lf
+0 sg 146.81 100.17 m 158.7 96.889 l 165.56 102.69 l 153.68 105.19 lx
+0 0.8783 0.1217 s 66.791 101.99 m 78.678 81.809 l 85.541 106.96 l 73.654 109.17 lf
+0 sg 66.791 101.99 m 78.678 81.809 l 85.541 106.96 l 73.654 109.17 lx
+0.29608 0.70392 0 s 257.48 101.09 m 269.36 98.777 l 276.23 101.96 l 264.34 105.39 lf
+0 sg 257.48 101.09 m 269.36 98.777 l 276.23 101.96 l 264.34 105.39 lx
+0.18494 0.81506 0 s 177.45 99.753 m 189.34 95.832 l 196.2 102.23 l 184.31 105.22 lf
+0 sg 177.45 99.753 m 189.34 95.832 l 196.2 102.23 l 184.31 105.22 lx
+0 0.61832 0.38168 s 208.09 97.129 m 219.98 94.185 l 226.84 98.25 l 214.95 102.24 lf
+0 sg 208.09 97.129 m 219.98 94.185 l 226.84 98.25 l 214.95 102.24 lx
+0 0.92655 0.07345 s 128.06 96.376 m 139.95 93.508 l 146.81 100.17 l 134.93 103.17 lf
+0 sg 128.06 96.376 m 139.95 93.508 l 146.81 100.17 l 134.93 103.17 lx
+0 0 0.91269 s 78.678 81.809 m 90.565 98.382 l 97.428 86.17 l 85.541 106.96 lf
+0 sg 78.678 81.809 m 90.565 98.382 l 97.428 86.17 l 85.541 106.96 lx
+0.32597 0.67404 0 s 238.73 97.426 m 250.61 96.615 l 257.48 101.09 l 245.59 102.44 lf
+0 sg 238.73 97.426 m 250.61 96.615 l 257.48 101.09 l 245.59 102.44 lx
+0.22268 0.77732 0 s 158.7 96.889 m 170.59 94.16 l 177.45 99.753 l 165.56 102.69 lf
+0 sg 158.7 96.889 m 170.59 94.16 l 177.45 99.753 l 165.56 102.69 lx
+0.16685 0.83315 0 s 269.36 98.777 m 281.25 92.502 l 288.11 98.528 l 276.23 101.96 lf
+0 sg 269.36 98.777 m 281.25 92.502 l 288.11 98.528 l 276.23 101.96 lx
+0 0.98545 0.014552 s 189.34 95.832 m 201.23 91.46 l 208.09 97.129 l 196.2 102.23 lf
+0 sg 189.34 95.832 m 201.23 91.46 l 208.09 97.129 l 196.2 102.23 lx
+1 0.053413 0.053413 s 48.041 96.508 m 59.928 104.62 l 66.791 101.99 l 54.904 102.45 lf
+0 sg 48.041 96.508 m 59.928 104.62 l 66.791 101.99 l 54.904 102.45 lx
+0 0.56052 0.43948 s 109.31 91.702 m 121.2 92.399 l 128.06 96.376 l 116.18 97.812 lf
+0 sg 109.31 91.702 m 121.2 92.399 l 128.06 96.376 l 116.18 97.812 lx
+0 0.81548 0.18452 s 219.98 94.185 m 231.86 90.846 l 238.73 97.426 l 226.84 98.25 lf
+0 sg 219.98 94.185 m 231.86 90.846 l 238.73 97.426 l 226.84 98.25 lx
+0.042934 0.95707 0 s 139.95 93.508 m 151.84 90.48 l 158.7 96.889 l 146.81 100.17 lf
+0 sg 139.95 93.508 m 151.84 90.48 l 158.7 96.889 l 146.81 100.17 lx
+0.037296 0.9627 0 s 59.928 104.62 m 71.815 89.865 l 78.678 81.809 l 66.791 101.99 lf
+0 sg 59.928 104.62 m 71.815 89.865 l 78.678 81.809 l 66.791 101.99 lx
+0.70913 0.29087 0 s 250.61 96.615 m 262.5 92.473 l 269.36 98.777 l 257.48 101.09 lf
+0 sg 250.61 96.615 m 262.5 92.473 l 269.36 98.777 l 257.48 101.09 lx
+0 0.54541 0.45459 s 90.565 98.382 m 102.45 91.787 l 109.31 91.702 l 97.428 86.17 lf
+0 sg 90.565 98.382 m 102.45 91.787 l 109.31 91.702 l 97.428 86.17 lx
+0 0.9599 0.040097 s 281.25 92.502 m 293.14 89.153 l 300 95.096 l 288.11 98.528 lf
+0 sg 281.25 92.502 m 293.14 89.153 l 300 95.096 l 288.11 98.528 lx
+0.22268 0.77732 0 s 170.59 94.16 m 182.48 90.026 l 189.34 95.832 l 177.45 99.753 lf
+0 sg 170.59 94.16 m 182.48 90.026 l 189.34 95.832 l 177.45 99.753 lx
+0 0.18293 0.81707 s 121.2 92.399 m 133.09 77.241 l 139.95 93.508 l 128.06 96.376 lf
+0 sg 121.2 92.399 m 133.09 77.241 l 139.95 93.508 l 128.06 96.376 lx
+0 0.80928 0.19072 s 201.23 91.46 m 213.11 87.802 l 219.98 94.185 l 208.09 97.129 lf
+0 sg 201.23 91.46 m 213.11 87.802 l 219.98 94.185 l 208.09 97.129 lx
+0 0 0 s 71.815 89.865 m 83.702 67.313 l 90.565 98.382 l 78.678 81.809 lf
+0 sg 71.815 89.865 m 83.702 67.313 l 90.565 98.382 l 78.678 81.809 lx
+0.37472 0.62528 0 s 231.86 90.846 m 243.75 89.557 l 250.61 96.615 l 238.73 97.426 lf
+0 sg 231.86 90.846 m 243.75 89.557 l 250.61 96.615 l 238.73 97.426 lx
+0.17552 0.82448 0 s 151.84 90.48 m 163.73 87.564 l 170.59 94.16 l 158.7 96.889 lf
+0 sg 151.84 90.48 m 163.73 87.564 l 170.59 94.16 l 158.7 96.889 lx
+0.79737 0.20263 0 s 41.178 90.565 m 53.065 86.688 l 59.928 104.62 l 48.041 96.508 lf
+0 sg 41.178 90.565 m 53.065 86.688 l 59.928 104.62 l 48.041 96.508 lx
+0.5405 0.4595 0 s 262.5 92.473 m 274.39 89.226 l 281.25 92.502 l 269.36 98.777 lf
+0 sg 262.5 92.473 m 274.39 89.226 l 281.25 92.502 l 269.36 98.777 lx
+0 0.43592 0.56408 s 102.45 91.787 m 114.34 76.965 l 121.2 92.399 l 109.31 91.702 lf
+0 sg 102.45 91.787 m 114.34 76.965 l 121.2 92.399 l 109.31 91.702 lx
+0.051768 0.94823 0 s 182.48 90.026 m 194.36 86.447 l 201.23 91.46 l 189.34 95.832 lf
+0 sg 182.48 90.026 m 194.36 86.447 l 201.23 91.46 l 189.34 95.832 lx
+0 0.22633 0.77367 s 133.09 77.241 m 144.98 85.149 l 151.84 90.48 l 139.95 93.508 lf
+0 sg 133.09 77.241 m 144.98 85.149 l 151.84 90.48 l 139.95 93.508 lx
+0 0.94432 0.055679 s 213.11 87.802 m 225 85.819 l 231.86 90.846 l 219.98 94.185 lf
+0 sg 213.11 87.802 m 225 85.819 l 231.86 90.846 l 219.98 94.185 lx
+0.17552 0.82448 0 s 163.73 87.564 m 175.61 83.617 l 182.48 90.026 l 170.59 94.16 lf
+0 sg 163.73 87.564 m 175.61 83.617 l 182.48 90.026 l 170.59 94.16 lx
+0.78864 0.21136 0 s 243.75 89.557 m 255.64 87.597 l 262.5 92.473 l 250.61 96.615 lf
+0 sg 243.75 89.557 m 255.64 87.597 l 262.5 92.473 l 250.61 96.615 lx
+0.15365 0.84635 0 s 274.39 89.226 m 286.27 83.209 l 293.14 89.153 l 281.25 92.502 lf
+0 sg 274.39 89.226 m 286.27 83.209 l 293.14 89.153 l 281.25 92.502 lx
+0.037415 0.96259 0 s 83.702 67.313 m 95.589 93.351 l 102.45 91.787 l 90.565 98.382 lf
+0 sg 83.702 67.313 m 95.589 93.351 l 102.45 91.787 l 90.565 98.382 lx
+0 0.92046 0.079544 s 194.36 86.447 m 206.25 82.577 l 213.11 87.802 l 201.23 91.46 lf
+0 sg 194.36 86.447 m 206.25 82.577 l 213.11 87.802 l 201.23 91.46 lx
+0 0.40271 0.59729 s 114.34 76.965 m 126.23 92.079 l 133.09 77.241 l 121.2 92.399 lf
+0 sg 114.34 76.965 m 126.23 92.079 l 133.09 77.241 l 121.2 92.399 lx
+0 0.26154 0.73846 s 144.98 85.149 m 156.86 69.929 l 163.73 87.564 l 151.84 90.48 lf
+0 sg 144.98 85.149 m 156.86 69.929 l 163.73 87.564 l 151.84 90.48 lx
+0 0.50352 0.49648 s 34.315 84.621 m 46.202 75.462 l 53.065 86.688 l 41.178 90.565 lf
+0 sg 34.315 84.621 m 46.202 75.462 l 53.065 86.688 l 41.178 90.565 lx
+1 1 1 s 53.065 86.688 m 64.952 99.531 l 71.815 89.865 l 59.928 104.62 lf
+0 sg 53.065 86.688 m 64.952 99.531 l 71.815 89.865 l 59.928 104.62 lx
+0.24057 0.75943 0 s 225 85.819 m 236.89 82.658 l 243.75 89.557 l 231.86 90.846 lf
+0 sg 225 85.819 m 236.89 82.658 l 243.75 89.557 l 231.86 90.846 lx
+0 0.14593 0.85407 s 64.952 99.531 m 76.839 72.178 l 83.702 67.313 l 71.815 89.865 lf
+0 sg 64.952 99.531 m 76.839 72.178 l 83.702 67.313 l 71.815 89.865 lx
+0.042934 0.95707 0 s 175.61 83.617 m 187.5 79.782 l 194.36 86.447 l 182.48 90.026 lf
+0 sg 175.61 83.617 m 187.5 79.782 l 194.36 86.447 l 182.48 90.026 lx
+0.87044 0.12956 0 s 255.64 87.597 m 267.52 84.311 l 274.39 89.226 l 262.5 92.473 lf
+0 sg 255.64 87.597 m 267.52 84.311 l 274.39 89.226 l 262.5 92.473 lx
+0 0.93302 0.066977 s 95.589 93.351 m 107.48 73.611 l 114.34 76.965 l 102.45 91.787 lf
+0 sg 95.589 93.351 m 107.48 73.611 l 114.34 76.965 l 102.45 91.787 lx
+0 0.95062 0.049377 s 206.25 82.577 m 218.14 78.764 l 225 85.819 l 213.11 87.802 lf
+0 sg 206.25 82.577 m 218.14 78.764 l 225 85.819 l 213.11 87.802 lx
+0 0.37663 0.62337 s 126.23 92.079 m 138.11 70.141 l 144.98 85.149 l 133.09 77.241 lf
+0 sg 126.23 92.079 m 138.11 70.141 l 144.98 85.149 l 133.09 77.241 lx
+0 0 0.44665 s 76.839 72.178 m 88.726 72.988 l 95.589 93.351 l 83.702 67.313 lf
+0 sg 76.839 72.178 m 88.726 72.988 l 95.589 93.351 l 83.702 67.313 lx
+0 0.26154 0.73846 s 156.86 69.929 m 168.75 78.286 l 175.61 83.617 l 163.73 87.564 lf
+0 sg 156.86 69.929 m 168.75 78.286 l 175.61 83.617 l 163.73 87.564 lx
+0.64742 0.35258 0 s 236.89 82.658 m 248.77 80.772 l 255.64 87.597 l 243.75 89.557 lf
+0 sg 236.89 82.658 m 248.77 80.772 l 255.64 87.597 l 243.75 89.557 lx
+0.43065 0.56935 0 s 267.52 84.311 m 279.41 77.266 l 286.27 83.209 l 274.39 89.226 lf
+0 sg 267.52 84.311 m 279.41 77.266 l 286.27 83.209 l 274.39 89.226 lx
+0 0.92655 0.07345 s 187.5 79.782 m 199.39 75.788 l 206.25 82.577 l 194.36 86.447 lf
+0 sg 187.5 79.782 m 199.39 75.788 l 206.25 82.577 l 194.36 86.447 lx
+1 0.18511 0.18511 s 46.202 75.462 m 58.089 84.37 l 64.952 99.531 l 53.065 86.688 lf
+0 sg 46.202 75.462 m 58.089 84.37 l 64.952 99.531 l 53.065 86.688 lx
+0 0.52415 0.47585 s 27.452 78.678 m 39.339 75.077 l 46.202 75.462 l 34.315 84.621 lf
+0 sg 27.452 78.678 m 39.339 75.077 l 46.202 75.462 l 34.315 84.621 lx
+0 0.99211 0.0078871 s 218.14 78.764 m 230.02 74.549 l 236.89 82.658 l 225 85.819 lf
+0 sg 218.14 78.764 m 230.02 74.549 l 236.89 82.658 l 225 85.819 lx
+0.22985 0.77015 0 s 107.48 73.611 m 119.36 83.294 l 126.23 92.079 l 114.34 76.965 lf
+0 sg 107.48 73.611 m 119.36 83.294 l 126.23 92.079 l 114.34 76.965 lx
+0 0.44501 0.55499 s 138.11 70.141 m 150 86.577 l 156.86 69.929 l 144.98 85.149 lf
+0 sg 138.11 70.141 m 150 86.577 l 156.86 69.929 l 144.98 85.149 lx
+0 0.22633 0.77367 s 168.75 78.286 m 180.64 63.515 l 187.5 79.782 l 175.61 83.617 lf
+0 sg 168.75 78.286 m 180.64 63.515 l 187.5 79.782 l 175.61 83.617 lx
+0.81365 0.18635 0 s 248.77 80.772 m 260.66 76.396 l 267.52 84.311 l 255.64 87.597 lf
+0 sg 248.77 80.772 m 260.66 76.396 l 267.52 84.311 l 255.64 87.597 lx
+0 0.82168 0.17832 s 88.726 72.988 m 100.61 70.504 l 107.48 73.611 l 95.589 93.351 lf
+0 sg 88.726 72.988 m 100.61 70.504 l 107.48 73.611 l 95.589 93.351 lx
+0 0.67338 0.32662 s 199.39 75.788 m 211.27 70.36 l 218.14 78.764 l 206.25 82.577 lf
+0 sg 199.39 75.788 m 211.27 70.36 l 218.14 78.764 l 206.25 82.577 lx
+1 0.53147 0.53147 s 58.089 84.37 m 69.976 80.869 l 76.839 72.178 l 64.952 99.531 lf
+0 sg 58.089 84.37 m 69.976 80.869 l 76.839 72.178 l 64.952 99.531 lx
+0.15566 0.84434 0 s 119.36 83.294 m 131.25 65.718 l 138.11 70.141 l 126.23 92.079 lf
+0 sg 119.36 83.294 m 131.25 65.718 l 138.11 70.141 l 126.23 92.079 lx
+0 0.44501 0.55499 s 150 86.577 m 161.89 63.278 l 168.75 78.286 l 156.86 69.929 lf
+0 sg 150 86.577 m 161.89 63.278 l 168.75 78.286 l 156.86 69.929 lx
+0 0 0.85332 s 69.976 80.869 m 81.863 61.447 l 88.726 72.988 l 76.839 72.178 lf
+0 sg 69.976 80.869 m 81.863 61.447 l 88.726 72.988 l 76.839 72.178 lx
+0.13581 0.86419 0 s 230.02 74.549 m 241.91 72.003 l 248.77 80.772 l 236.89 82.658 lf
+0 sg 230.02 74.549 m 241.91 72.003 l 248.77 80.772 l 236.89 82.658 lx
+0 0.77296 0.22704 s 39.339 75.077 m 51.226 68.524 l 58.089 84.37 l 46.202 75.462 lf
+0 sg 39.339 75.077 m 51.226 68.524 l 58.089 84.37 l 46.202 75.462 lx
+0 0.18293 0.81707 s 180.64 63.515 m 192.52 71.811 l 199.39 75.788 l 187.5 79.782 lf
+0 sg 180.64 63.515 m 192.52 71.811 l 199.39 75.788 l 187.5 79.782 lx
+0.35995 0.64005 0 s 260.66 76.396 m 272.55 71.322 l 279.41 77.266 l 267.52 84.311 lf
+0 sg 260.66 76.396 m 272.55 71.322 l 279.41 77.266 l 267.52 84.311 lx
+0 0.31336 0.68664 s 211.27 70.36 m 223.16 65.285 l 230.02 74.549 l 218.14 78.764 lf
+0 sg 211.27 70.36 m 223.16 65.285 l 230.02 74.549 l 218.14 78.764 lx
+0 0.67603 0.32397 s 100.61 70.504 m 112.5 67.375 l 119.36 83.294 l 107.48 73.611 lf
+0 sg 100.61 70.504 m 112.5 67.375 l 119.36 83.294 l 107.48 73.611 lx
+0.029095 0.9709 0 s 20.589 72.734 m 32.476 70.314 l 39.339 75.077 l 27.452 78.678 lf
+0 sg 20.589 72.734 m 32.476 70.314 l 39.339 75.077 l 27.452 78.678 lx
+0.063893 0.93611 0 s 131.25 65.718 m 143.14 73.845 l 150 86.577 l 138.11 70.141 lf
+0 sg 131.25 65.718 m 143.14 73.845 l 150 86.577 l 138.11 70.141 lx
+0 0.37663 0.62337 s 161.89 63.278 m 173.77 78.353 l 180.64 63.515 l 168.75 78.286 lf
+0 sg 161.89 63.278 m 173.77 78.353 l 180.64 63.515 l 168.75 78.286 lx
+0.25101 0.74899 0 s 241.91 72.003 m 253.8 68.622 l 260.66 76.396 l 248.77 80.772 lf
+0 sg 241.91 72.003 m 253.8 68.622 l 260.66 76.396 l 248.77 80.772 lx
+0 0.17267 0.82733 s 81.863 61.447 m 93.75 73.079 l 100.61 70.504 l 88.726 72.988 lf
+0 sg 81.863 61.447 m 93.75 73.079 l 100.61 70.504 l 88.726 72.988 lx
+0 0.56052 0.43948 s 192.52 71.811 m 204.41 64.25 l 211.27 70.36 l 199.39 75.788 lf
+0 sg 192.52 71.811 m 204.41 64.25 l 211.27 70.36 l 199.39 75.788 lx
+0 0.45822 0.54178 s 223.16 65.285 m 235.05 65.328 l 241.91 72.003 l 230.02 74.549 lf
+0 sg 223.16 65.285 m 235.05 65.328 l 241.91 72.003 l 230.02 74.549 lx
+1 0.41711 0.41711 s 51.226 68.524 m 63.113 77.885 l 69.976 80.869 l 58.089 84.37 lf
+0 sg 51.226 68.524 m 63.113 77.885 l 69.976 80.869 l 58.089 84.37 lx
+0.14401 0.85599 0 s 112.5 67.375 m 124.39 70.916 l 131.25 65.718 l 119.36 83.294 lf
+0 sg 112.5 67.375 m 124.39 70.916 l 131.25 65.718 l 119.36 83.294 lx
+0 0.6807 0.3193 s 32.476 70.314 m 44.363 64.513 l 51.226 68.524 l 39.339 75.077 lf
+0 sg 32.476 70.314 m 44.363 64.513 l 51.226 68.524 l 39.339 75.077 lx
+0 0 0.30666 s 204.41 64.25 m 216.3 51.855 l 223.16 65.285 l 211.27 70.36 lf
+0 sg 204.41 64.25 m 216.3 51.855 l 223.16 65.285 l 211.27 70.36 lx
+0.063893 0.93611 0 s 143.14 73.845 m 155.02 58.855 l 161.89 63.278 l 150 86.577 lf
+0 sg 143.14 73.845 m 155.02 58.855 l 161.89 63.278 l 150 86.577 lx
+0 0.40271 0.59729 s 173.77 78.353 m 185.66 56.376 l 192.52 71.811 l 180.64 63.515 lf
+0 sg 173.77 78.353 m 185.66 56.376 l 192.52 71.811 l 180.64 63.515 lx
+0.075048 0.92495 0 s 253.8 68.622 m 265.69 65.379 l 272.55 71.322 l 260.66 76.396 lf
+0 sg 253.8 68.622 m 265.69 65.379 l 272.55 71.322 l 260.66 76.396 lx
+0 0.47943 0.52057 s 93.75 73.079 m 105.64 57.428 l 112.5 67.375 l 100.61 70.504 lf
+0 sg 93.75 73.079 m 105.64 57.428 l 112.5 67.375 l 100.61 70.504 lx
+0.52958 0.47042 0 s 63.113 77.885 m 75 65.876 l 81.863 61.447 l 69.976 80.869 lf
+0 sg 63.113 77.885 m 75 65.876 l 81.863 61.447 l 69.976 80.869 lx
+0.019984 0.98002 0 s 13.726 66.791 m 25.613 63.068 l 32.476 70.314 l 20.589 72.734 lf
+0 sg 13.726 66.791 m 25.613 63.068 l 32.476 70.314 l 20.589 72.734 lx
+0.0098512 0.99015 0 s 124.39 70.916 m 136.27 61.308 l 143.14 73.845 l 131.25 65.718 lf
+0 sg 124.39 70.916 m 136.27 61.308 l 143.14 73.845 l 131.25 65.718 lx
+0 0.9242 0.0758 s 235.05 65.328 m 246.94 63.704 l 253.8 68.622 l 241.91 72.003 lf
+0 sg 235.05 65.328 m 246.94 63.704 l 253.8 68.622 l 241.91 72.003 lx
+0 0.046362 0.95364 s 75 65.876 m 86.887 52.156 l 93.75 73.079 l 81.863 61.447 lf
+0 sg 75 65.876 m 86.887 52.156 l 93.75 73.079 l 81.863 61.447 lx
+0.17549 0.82451 0 s 44.363 64.513 m 56.25 60.382 l 63.113 77.885 l 51.226 68.524 lf
+0 sg 44.363 64.513 m 56.25 60.382 l 63.113 77.885 l 51.226 68.524 lx
+0.15566 0.84434 0 s 155.02 58.855 m 166.91 69.568 l 173.77 78.353 l 161.89 63.278 lf
+0 sg 155.02 58.855 m 166.91 69.568 l 173.77 78.353 l 161.89 63.278 lx
+0 0.43592 0.56408 s 185.66 56.376 m 197.55 64.335 l 204.41 64.25 l 192.52 71.811 lf
+0 sg 185.66 56.376 m 197.55 64.335 l 204.41 64.25 l 192.52 71.811 lx
+0 0.0731 0.9269 s 216.3 51.855 m 228.19 65.784 l 235.05 65.328 l 223.16 65.285 lf
+0 sg 216.3 51.855 m 228.19 65.784 l 235.05 65.328 l 223.16 65.285 lx
+0 0.77966 0.22034 s 105.64 57.428 m 117.52 62.948 l 124.39 70.916 l 112.5 67.375 lf
+0 sg 105.64 57.428 m 117.52 62.948 l 124.39 70.916 l 112.5 67.375 lx
+0 0.99739 0.0026055 s 25.613 63.068 m 37.5 60.985 l 44.363 64.513 l 32.476 70.314 lf
+0 sg 25.613 63.068 m 37.5 60.985 l 44.363 64.513 l 32.476 70.314 lx
+0.0098512 0.99015 0 s 136.27 61.308 m 148.16 64.053 l 155.02 58.855 l 143.14 73.845 lf
+0 sg 136.27 61.308 m 148.16 64.053 l 155.02 58.855 l 143.14 73.845 lx
+0.014731 0.98527 0 s 246.94 63.704 m 258.82 59.435 l 265.69 65.379 l 253.8 68.622 lf
+0 sg 246.94 63.704 m 258.82 59.435 l 265.69 65.379 l 253.8 68.622 lx
+0 0.27002 0.72998 s 86.887 52.156 m 98.774 59.154 l 105.64 57.428 l 93.75 73.079 lf
+0 sg 86.887 52.156 m 98.774 59.154 l 105.64 57.428 l 93.75 73.079 lx
+0.22985 0.77015 0 s 166.91 69.568 m 178.8 53.022 l 185.66 56.376 l 173.77 78.353 lf
+0 sg 166.91 69.568 m 178.8 53.022 l 185.66 56.376 l 173.77 78.353 lx
+0 0.54541 0.45459 s 197.55 64.335 m 209.44 64.067 l 216.3 51.855 l 204.41 64.25 lf
+0 sg 197.55 64.335 m 209.44 64.067 l 216.3 51.855 l 204.41 64.25 lx
+1 0.36982 0.36982 s 56.25 60.382 m 68.137 69.373 l 75 65.876 l 63.113 77.885 lf
+0 sg 56.25 60.382 m 68.137 69.373 l 75 65.876 l 63.113 77.885 lx
+0 0.94365 0.056351 s 6.863 60.847 m 18.75 57.408 l 25.613 63.068 l 13.726 66.791 lf
+0 sg 6.863 60.847 m 18.75 57.408 l 25.613 63.068 l 13.726 66.791 lx
+0 0.83348 0.16652 s 117.52 62.948 m 129.41 50.487 l 136.27 61.308 l 124.39 70.916 lf
+0 sg 117.52 62.948 m 129.41 50.487 l 136.27 61.308 l 124.39 70.916 lx
+0 0.66761 0.33239 s 37.5 60.985 m 49.387 54.873 l 56.25 60.382 l 44.363 64.513 lf
+0 sg 37.5 60.985 m 49.387 54.873 l 56.25 60.382 l 44.363 64.513 lx
+0.67823 0.32177 0 s 228.19 65.784 m 240.07 61.13 l 246.94 63.704 l 235.05 65.328 lf
+0 sg 228.19 65.784 m 240.07 61.13 l 246.94 63.704 l 235.05 65.328 lx
+0.14401 0.85599 0 s 148.16 64.053 m 160.05 53.649 l 166.91 69.568 l 155.02 58.855 lf
+0 sg 148.16 64.053 m 160.05 53.649 l 166.91 69.568 l 155.02 58.855 lx
+0 0 0.91269 s 209.44 64.067 m 221.32 40.632 l 228.19 65.784 l 216.3 51.855 lf
+0 sg 209.44 64.067 m 221.32 40.632 l 228.19 65.784 l 216.3 51.855 lx
+0 0.93302 0.066977 s 178.8 53.022 m 190.69 65.899 l 197.55 64.335 l 185.66 56.376 lf
+0 sg 178.8 53.022 m 190.69 65.899 l 197.55 64.335 l 185.66 56.376 lx
+0 0.43536 0.56464 s 98.774 59.154 m 110.66 50.768 l 117.52 62.948 l 105.64 57.428 lf
+0 sg 98.774 59.154 m 110.66 50.768 l 117.52 62.948 l 105.64 57.428 lx
+0.34713 0.65287 0 s 68.137 69.373 m 80.024 58.738 l 86.887 52.156 l 75 65.876 lf
+0 sg 68.137 69.373 m 80.024 58.738 l 86.887 52.156 l 75 65.876 lx
+0.0032332 0.99677 0 s 18.75 57.408 m 30.637 53.722 l 37.5 60.985 l 25.613 63.068 lf
+0 sg 18.75 57.408 m 30.637 53.722 l 37.5 60.985 l 25.613 63.068 lx
+0 0.83348 0.16652 s 129.41 50.487 m 141.3 56.085 l 148.16 64.053 l 136.27 61.308 lf
+0 sg 129.41 50.487 m 141.3 56.085 l 148.16 64.053 l 136.27 61.308 lx
+0 0.67603 0.32397 s 160.05 53.649 m 171.94 49.915 l 178.8 53.022 l 166.91 69.568 lf
+0 sg 160.05 53.649 m 171.94 49.915 l 178.8 53.022 l 166.91 69.568 lx
+0.34403 0.65597 0 s 240.07 61.13 m 251.96 53.492 l 258.82 59.435 l 246.94 63.704 lf
+0 sg 240.07 61.13 m 251.96 53.492 l 258.82 59.435 l 246.94 63.704 lx
+0 0.19338 0.80662 s 80.024 58.738 m 91.911 46.972 l 98.774 59.154 l 86.887 52.156 lf
+0 sg 80.024 58.738 m 91.911 46.972 l 98.774 59.154 l 86.887 52.156 lx
+0.2575 0.7425 0 s 49.387 54.873 m 61.274 50.271 l 68.137 69.373 l 56.25 60.382 lf
+0 sg 49.387 54.873 m 61.274 50.271 l 68.137 69.373 l 56.25 60.382 lx
+0.037415 0.96259 0 s 190.69 65.899 m 202.57 32.998 l 209.44 64.067 l 197.55 64.335 lf
+0 sg 190.69 65.899 m 202.57 32.998 l 209.44 64.067 l 197.55 64.335 lx
+0 0.66846 0.33154 s 110.66 50.768 m 122.55 55.48 l 129.41 50.487 l 117.52 62.948 lf
+0 sg 110.66 50.768 m 122.55 55.48 l 129.41 50.487 l 117.52 62.948 lx
+0 0.96548 0.034519 s 0 54.904 m 11.887 51.472 l 18.75 57.408 l 6.863 60.847 lf
+0 sg 0 54.904 m 11.887 51.472 l 18.75 57.408 l 6.863 60.847 lx
+0 0.8783 0.1217 s 221.32 40.632 m 233.21 53.951 l 240.07 61.13 l 228.19 65.784 lf
+0 sg 221.32 40.632 m 233.21 53.951 l 240.07 61.13 l 228.19 65.784 lx
+0 0 0 s 202.57 32.998 m 214.46 48.687 l 221.32 40.632 l 209.44 64.067 lf
+0 sg 202.57 32.998 m 214.46 48.687 l 221.32 40.632 l 209.44 64.067 lx
+0 0.98458 0.015425 s 30.637 53.722 m 42.524 51.629 l 49.387 54.873 l 37.5 60.985 lf
+0 sg 30.637 53.722 m 42.524 51.629 l 49.387 54.873 l 37.5 60.985 lx
+0 0.77966 0.22034 s 141.3 56.085 m 153.19 43.702 l 160.05 53.649 l 148.16 64.053 lf
+0 sg 141.3 56.085 m 153.19 43.702 l 160.05 53.649 l 148.16 64.053 lx
+0 0 0.93358 s 91.911 46.972 m 103.8 42.933 l 110.66 50.768 l 98.774 59.154 lf
+0 sg 91.911 46.972 m 103.8 42.933 l 110.66 50.768 l 98.774 59.154 lx
+0 0.82168 0.17832 s 171.94 49.915 m 183.82 45.536 l 190.69 65.899 l 178.8 53.022 lf
+0 sg 171.94 49.915 m 183.82 45.536 l 190.69 65.899 l 178.8 53.022 lx
+0 0.66846 0.33154 s 122.55 55.48 m 134.44 43.905 l 141.3 56.085 l 129.41 50.487 lf
+0 sg 122.55 55.48 m 134.44 43.905 l 141.3 56.085 l 129.41 50.487 lx
+1 0.37522 0.37522 s 61.274 50.271 m 73.161 57.707 l 80.024 58.738 l 68.137 69.373 lf
+0 sg 61.274 50.271 m 73.161 57.707 l 80.024 58.738 l 68.137 69.373 lx
+0 0.94585 0.054147 s 11.887 51.472 m 23.774 48.041 l 30.637 53.722 l 18.75 57.408 lf
+0 sg 11.887 51.472 m 23.774 48.041 l 30.637 53.722 l 18.75 57.408 lx
+0 0 0.44665 s 183.82 45.536 m 195.71 37.863 l 202.57 32.998 l 190.69 65.899 lf
+0 sg 183.82 45.536 m 195.71 37.863 l 202.57 32.998 l 190.69 65.899 lx
+0 0.66045 0.33955 s 42.524 51.629 m 54.411 46.385 l 61.274 50.271 l 49.387 54.873 lf
+0 sg 42.524 51.629 m 54.411 46.385 l 61.274 50.271 l 49.387 54.873 lx
+0 0.47943 0.52057 s 153.19 43.702 m 165.07 52.49 l 171.94 49.915 l 160.05 53.649 lf
+0 sg 153.19 43.702 m 165.07 52.49 l 171.94 49.915 l 160.05 53.649 lx
+0.50399 0.49601 0 s 233.21 53.951 m 245.1 47.548 l 251.96 53.492 l 240.07 61.13 lf
+0 sg 233.21 53.951 m 245.1 47.548 l 251.96 53.492 l 240.07 61.13 lx
+0 0 0.97197 s 103.8 42.933 m 115.69 37.433 l 122.55 55.48 l 110.66 50.768 lf
+0 sg 103.8 42.933 m 115.69 37.433 l 122.55 55.48 l 110.66 50.768 lx
+1 0.045942 0.045942 s 73.161 57.707 m 85.048 54.551 l 91.911 46.972 l 80.024 58.738 lf
+0 sg 73.161 57.707 m 85.048 54.551 l 91.911 46.972 l 80.024 58.738 lx
+0.037296 0.9627 0 s 214.46 48.687 m 226.35 56.575 l 233.21 53.951 l 221.32 40.632 lf
+0 sg 214.46 48.687 m 226.35 56.575 l 233.21 53.951 l 221.32 40.632 lx
+0 0.43536 0.56464 s 134.44 43.905 m 146.32 45.428 l 153.19 43.702 l 141.3 56.085 lf
+0 sg 134.44 43.905 m 146.32 45.428 l 153.19 43.702 l 141.3 56.085 lx
+0.027044 0.97296 0 s 23.774 48.041 m 35.661 44.609 l 42.524 51.629 l 30.637 53.722 lf
+0 sg 23.774 48.041 m 35.661 44.609 l 42.524 51.629 l 30.637 53.722 lx
+0 0.17267 0.82733 s 165.07 52.49 m 176.96 33.995 l 183.82 45.536 l 171.94 49.915 lf
+0 sg 165.07 52.49 m 176.96 33.995 l 183.82 45.536 l 171.94 49.915 lx
+0 0.96569 0.034313 s 54.411 46.385 m 66.298 39.142 l 73.161 57.707 l 61.274 50.271 lf
+0 sg 54.411 46.385 m 66.298 39.142 l 73.161 57.707 l 61.274 50.271 lx
+0 0.14593 0.85407 s 195.71 37.863 m 207.6 58.354 l 214.46 48.687 l 202.57 32.998 lf
+0 sg 195.71 37.863 m 207.6 58.354 l 214.46 48.687 l 202.57 32.998 lx
+0 0 0.97197 s 115.69 37.433 m 127.57 36.07 l 134.44 43.905 l 122.55 55.48 lf
+0 sg 115.69 37.433 m 127.57 36.07 l 134.44 43.905 l 122.55 55.48 lx
+0.22858 0.77142 0 s 85.048 54.551 m 96.935 48.878 l 103.8 42.933 l 91.911 46.972 lf
+0 sg 85.048 54.551 m 96.935 48.878 l 103.8 42.933 l 91.911 46.972 lx
+0 0.27002 0.72998 s 146.32 45.428 m 158.21 31.567 l 165.07 52.49 l 153.19 43.702 lf
+0 sg 146.32 45.428 m 158.21 31.567 l 165.07 52.49 l 153.19 43.702 lx
+0 0 0.85332 s 176.96 33.995 m 188.85 46.554 l 195.71 37.863 l 183.82 45.536 lf
+0 sg 176.96 33.995 m 188.85 46.554 l 195.71 37.863 l 183.82 45.536 lx
+0 0.99151 0.008494 s 35.661 44.609 m 47.548 41.178 l 54.411 46.385 l 42.524 51.629 lf
+0 sg 35.661 44.609 m 47.548 41.178 l 54.411 46.385 l 42.524 51.629 lx
+1 0.053413 0.053413 s 226.35 56.575 m 238.23 41.605 l 245.1 47.548 l 233.21 53.951 lf
+0 sg 226.35 56.575 m 238.23 41.605 l 245.1 47.548 l 233.21 53.951 lx
+0 0.69278 0.30722 s 96.935 48.878 m 108.82 43.214 l 115.69 37.433 l 103.8 42.933 lf
+0 sg 96.935 48.878 m 108.82 43.214 l 115.69 37.433 l 103.8 42.933 lx
+0 0 0.93358 s 127.57 36.07 m 139.46 33.246 l 146.32 45.428 l 134.44 43.905 lf
+0 sg 127.57 36.07 m 139.46 33.246 l 146.32 45.428 l 134.44 43.905 lx
+0.8286 0.1714 0 s 66.298 39.142 m 78.185 39.894 l 85.048 54.551 l 73.161 57.707 lf
+0 sg 66.298 39.142 m 78.185 39.894 l 85.048 54.551 l 73.161 57.707 lx
+0 0.046362 0.95364 s 158.21 31.567 m 170.1 38.424 l 176.96 33.995 l 165.07 52.49 lf
+0 sg 158.21 31.567 m 170.1 38.424 l 176.96 33.995 l 165.07 52.49 lx
+0 0.57007 0.42993 s 47.548 41.178 m 59.435 37.746 l 66.298 39.142 l 54.411 46.385 lf
+0 sg 47.548 41.178 m 59.435 37.746 l 66.298 39.142 l 54.411 46.385 lx
+1 1 1 s 207.6 58.354 m 219.48 38.647 l 226.35 56.575 l 214.46 48.687 lf
+0 sg 207.6 58.354 m 219.48 38.647 l 226.35 56.575 l 214.46 48.687 lx
+0 0.69278 0.30722 s 108.82 43.214 m 120.71 42.015 l 127.57 36.07 l 115.69 37.433 lf
+0 sg 108.82 43.214 m 120.71 42.015 l 127.57 36.07 l 115.69 37.433 lx
+0 0.19338 0.80662 s 139.46 33.246 m 151.35 38.149 l 158.21 31.567 l 146.32 45.428 lf
+0 sg 139.46 33.246 m 151.35 38.149 l 158.21 31.567 l 146.32 45.428 lx
+1 0.2561 0.2561 s 78.185 39.894 m 90.072 39.949 l 96.935 48.878 l 85.048 54.551 lf
+0 sg 78.185 39.894 m 90.072 39.949 l 96.935 48.878 l 85.048 54.551 lx
+1 0.53147 0.53147 s 188.85 46.554 m 200.73 43.192 l 207.6 58.354 l 195.71 37.863 lf
+0 sg 188.85 46.554 m 200.73 43.192 l 207.6 58.354 l 195.71 37.863 lx
+0.79737 0.20263 0 s 219.48 38.647 m 231.37 35.661 l 238.23 41.605 l 226.35 56.575 lf
+0 sg 219.48 38.647 m 231.37 35.661 l 238.23 41.605 l 226.35 56.575 lx
+0 0.59794 0.40206 s 59.435 37.746 m 71.322 34.315 l 78.185 39.894 l 66.298 39.142 lf
+0 sg 59.435 37.746 m 71.322 34.315 l 78.185 39.894 l 66.298 39.142 lx
+0.52958 0.47042 0 s 170.1 38.424 m 181.98 43.57 l 188.85 46.554 l 176.96 33.995 lf
+0 sg 170.1 38.424 m 181.98 43.57 l 188.85 46.554 l 176.96 33.995 lx
+0.22858 0.77142 0 s 120.71 42.015 m 132.6 40.825 l 139.46 33.246 l 127.57 36.07 lf
+0 sg 120.71 42.015 m 132.6 40.825 l 139.46 33.246 l 127.57 36.07 lx
+1 0.3567 0.3567 s 90.072 39.949 m 101.96 38.848 l 108.82 43.214 l 96.935 48.878 lf
+0 sg 90.072 39.949 m 101.96 38.848 l 108.82 43.214 l 96.935 48.878 lx
+1 0.18511 0.18511 s 200.73 43.192 m 212.62 27.422 l 219.48 38.647 l 207.6 58.354 lf
+0 sg 200.73 43.192 m 212.62 27.422 l 219.48 38.647 l 207.6 58.354 lx
+0.34713 0.65287 0 s 151.35 38.149 m 163.23 41.921 l 170.1 38.424 l 158.21 31.567 lf
+0 sg 151.35 38.149 m 163.23 41.921 l 170.1 38.424 l 158.21 31.567 lx
+0.17274 0.82726 0 s 71.322 34.315 m 83.209 30.883 l 90.072 39.949 l 78.185 39.894 lf
+0 sg 71.322 34.315 m 83.209 30.883 l 90.072 39.949 l 78.185 39.894 lx
+0 0.50352 0.49648 s 212.62 27.422 m 224.51 29.718 l 231.37 35.661 l 219.48 38.647 lf
+0 sg 212.62 27.422 m 224.51 29.718 l 231.37 35.661 l 219.48 38.647 lx
+1 0.41711 0.41711 s 181.98 43.57 m 193.87 27.346 l 200.73 43.192 l 188.85 46.554 lf
+0 sg 181.98 43.57 m 193.87 27.346 l 200.73 43.192 l 188.85 46.554 lx
+1 0.3567 0.3567 s 101.96 38.848 m 113.85 33.086 l 120.71 42.015 l 108.82 43.214 lf
+0 sg 101.96 38.848 m 113.85 33.086 l 120.71 42.015 l 108.82 43.214 lx
+1 0.045942 0.045942 s 132.6 40.825 m 144.48 37.118 l 151.35 38.149 l 139.46 33.246 lf
+0 sg 132.6 40.825 m 144.48 37.118 l 151.35 38.149 l 139.46 33.246 lx
+0 0.77296 0.22704 s 193.87 27.346 m 205.76 27.036 l 212.62 27.422 l 200.73 43.192 lf
+0 sg 193.87 27.346 m 205.76 27.036 l 212.62 27.422 l 200.73 43.192 lx
+0.60862 0.39138 0 s 83.209 30.883 m 95.096 27.452 l 101.96 38.848 l 90.072 39.949 lf
+0 sg 83.209 30.883 m 95.096 27.452 l 101.96 38.848 l 90.072 39.949 lx
+1 0.36982 0.36982 s 163.23 41.921 m 175.12 26.067 l 181.98 43.57 l 170.1 38.424 lf
+0 sg 163.23 41.921 m 175.12 26.067 l 181.98 43.57 l 170.1 38.424 lx
+1 0.2561 0.2561 s 113.85 33.086 m 125.73 26.168 l 132.6 40.825 l 120.71 42.015 lf
+0 sg 113.85 33.086 m 125.73 26.168 l 132.6 40.825 l 120.71 42.015 lx
+0.17549 0.82451 0 s 175.12 26.067 m 187.01 23.335 l 193.87 27.346 l 181.98 43.57 lf
+0 sg 175.12 26.067 m 187.01 23.335 l 193.87 27.346 l 181.98 43.57 lx
+0 0.52415 0.47585 s 205.76 27.036 m 217.64 23.774 l 224.51 29.718 l 212.62 27.422 lf
+0 sg 205.76 27.036 m 217.64 23.774 l 224.51 29.718 l 212.62 27.422 lx
+1 0.37522 0.37522 s 144.48 37.118 m 156.37 22.819 l 163.23 41.921 l 151.35 38.149 lf
+0 sg 144.48 37.118 m 156.37 22.819 l 163.23 41.921 l 151.35 38.149 lx
+0.60862 0.39138 0 s 95.096 27.452 m 106.98 24.02 l 113.85 33.086 l 101.96 38.848 lf
+0 sg 95.096 27.452 m 106.98 24.02 l 113.85 33.086 l 101.96 38.848 lx
+0.8286 0.1714 0 s 125.73 26.168 m 137.62 18.553 l 144.48 37.118 l 132.6 40.825 lf
+0 sg 125.73 26.168 m 137.62 18.553 l 144.48 37.118 l 132.6 40.825 lx
+0.2575 0.7425 0 s 156.37 22.819 m 168.26 20.558 l 175.12 26.067 l 163.23 41.921 lf
+0 sg 156.37 22.819 m 168.26 20.558 l 175.12 26.067 l 163.23 41.921 lx
+0 0.6807 0.3193 s 187.01 23.335 m 198.89 22.273 l 205.76 27.036 l 193.87 27.346 lf
+0 sg 187.01 23.335 m 198.89 22.273 l 205.76 27.036 l 193.87 27.346 lx
+0.17274 0.82726 0 s 106.98 24.02 m 118.87 20.589 l 125.73 26.168 l 113.85 33.086 lf
+0 sg 106.98 24.02 m 118.87 20.589 l 125.73 26.168 l 113.85 33.086 lx
+0 0.96569 0.034313 s 137.62 18.553 m 149.51 18.933 l 156.37 22.819 l 144.48 37.118 lf
+0 sg 137.62 18.553 m 149.51 18.933 l 156.37 22.819 l 144.48 37.118 lx
+0 0.66761 0.33239 s 168.26 20.558 m 180.14 19.807 l 187.01 23.335 l 175.12 26.067 lf
+0 sg 168.26 20.558 m 180.14 19.807 l 187.01 23.335 l 175.12 26.067 lx
+0.029095 0.9709 0 s 198.89 22.273 m 210.78 17.831 l 217.64 23.774 l 205.76 27.036 lf
+0 sg 198.89 22.273 m 210.78 17.831 l 217.64 23.774 l 205.76 27.036 lx
+0 0.59794 0.40206 s 118.87 20.589 m 130.76 17.157 l 137.62 18.553 l 125.73 26.168 lf
+0 sg 118.87 20.589 m 130.76 17.157 l 137.62 18.553 l 125.73 26.168 lx
+0 0.66045 0.33955 s 149.51 18.933 m 161.39 17.314 l 168.26 20.558 l 156.37 22.819 lf
+0 sg 149.51 18.933 m 161.39 17.314 l 168.26 20.558 l 156.37 22.819 lx
+0 0.99739 0.0026055 s 180.14 19.807 m 192.03 15.027 l 198.89 22.273 l 187.01 23.335 lf
+0 sg 180.14 19.807 m 192.03 15.027 l 198.89 22.273 l 187.01 23.335 lx
+0 0.57007 0.42993 s 130.76 17.157 m 142.64 13.726 l 149.51 18.933 l 137.62 18.553 lf
+0 sg 130.76 17.157 m 142.64 13.726 l 149.51 18.933 l 137.62 18.553 lx
+0 0.98458 0.015425 s 161.39 17.314 m 173.28 12.545 l 180.14 19.807 l 168.26 20.558 lf
+0 sg 161.39 17.314 m 173.28 12.545 l 180.14 19.807 l 168.26 20.558 lx
+0.019984 0.98002 0 s 192.03 15.027 m 203.92 11.887 l 210.78 17.831 l 198.89 22.273 lf
+0 sg 192.03 15.027 m 203.92 11.887 l 210.78 17.831 l 198.89 22.273 lx
+0 0.99151 0.008494 s 142.64 13.726 m 154.53 10.294 l 161.39 17.314 l 149.51 18.933 lf
+0 sg 142.64 13.726 m 154.53 10.294 l 161.39 17.314 l 149.51 18.933 lx
+0.0032332 0.99677 0 s 173.28 12.545 m 185.17 9.3673 l 192.03 15.027 l 180.14 19.807 lf
+0 sg 173.28 12.545 m 185.17 9.3673 l 192.03 15.027 l 180.14 19.807 lx
+0.027044 0.97296 0 s 154.53 10.294 m 166.42 6.863 l 173.28 12.545 l 161.39 17.314 lf
+0 sg 154.53 10.294 m 166.42 6.863 l 173.28 12.545 l 161.39 17.314 lx
+0 0.94365 0.056351 s 185.17 9.3673 m 197.06 5.9435 l 203.92 11.887 l 192.03 15.027 lf
+0 sg 185.17 9.3673 m 197.06 5.9435 l 203.92 11.887 l 192.03 15.027 lx
+0 0.94585 0.054147 s 166.42 6.863 m 178.31 3.4315 l 185.17 9.3673 l 173.28 12.545 lf
+0 sg 166.42 6.863 m 178.31 3.4315 l 185.17 9.3673 l 173.28 12.545 lx
+0 0.96548 0.034519 s 178.31 3.4315 m 190.19 0 l 197.06 5.9435 l 185.17 9.3673 lf
+0 sg 178.31 3.4315 m 190.19 0 l 197.06 5.9435 l 185.17 9.3673 lx
+showpage
+.
+
+  Collecting refinement data: 
+    Refining each time step separately.
+    Got 6656 presently, expecting 6203 for next sweep.
+    Writing statistics for whole sweep.#  Description of fields
+#  =====================
+#  General:
+#    time
+#  Primal problem:
+#    number of active cells
+#    number of degrees of freedom
+#    iterations for the helmholtz equation
+#    iterations for the projection equation
+#    elastic energy
+#    kinetic energy
+#    total energy
+#  Dual problem:
+#    number of active cells
+#    number of degrees of freedom
+#    iterations for the helmholtz equation
+#    iterations for the projection equation
+#    elastic energy
+#    kinetic energy
+#    total energy
+#  Error estimation:
+#    total estimated error in this timestep
+#  Postprocessing:
+#    Huyghens wave
+
+
+0.0000e+00      256    289   0   0 0.0000e+00 0.0000e+00 0.000000e+00       256   1089   6   9 1.0352e-04 1.0173e-04 2.052509e-04    0.0000e+00    2.2149e-04 
+2.8000e-02      256    289   8  12 1.2298e+00 1.1202e+00 2.349990e+00       256   1089   6   9 1.0167e-04 1.0359e-04 2.052509e-04    9.1038e-06    -6.0221e-05 
+5.6000e-02      256    289   9  12 3.3854e-01 2.0114e+00 2.349990e+00       256   1089   6   9 1.0257e-04 1.0268e-04 2.052509e-04    4.5228e-07    -4.0604e-04 
+8.4000e-02      256    289   9  11 1.0453e+00 1.3046e+00 2.349990e+00       256   1089   6   9 1.0310e-04 1.0216e-04 2.052509e-04    9.4601e-06    -2.1792e-05 
+1.1200e-01      256    289   9  11 1.5788e+00 7.7119e-01 2.349990e+00       256   1089   6   9 1.0155e-04 1.0370e-04 2.052509e-04    5.9747e-06    9.5001e-04 
+1.4000e-01      256    289   8  12 1.2155e+00 1.1345e+00 2.349990e+00       256   1089   6   9 1.0442e-04 1.0083e-04 2.052509e-04    -1.0084e-06    1.2343e-03 
+1.6800e-01      256    289   9  12 1.0048e+00 1.3451e+00 2.349990e+00       256   1089   6   9 1.0130e-04 1.0396e-04 2.052509e-04    1.4618e-05    -2.6861e-04 
+1.9600e-01      256    289   9  11 1.1099e+00 1.2401e+00 2.349990e+00       256   1089   6   9 1.0826e-04 9.6995e-05 2.052509e-04    1.2630e-05    -2.9474e-03 
+2.2400e-01      256    289   9  12 1.2863e+00 1.0637e+00 2.349990e+00       256   1089   6   9 9.7063e-05 1.0819e-04 2.052509e-04    -5.7965e-06    -4.4829e-03 
+2.5200e-01      256    289   9  11 1.3040e+00 1.0460e+00 2.349990e+00       256   1089   6   9 1.0113e-04 1.0412e-04 2.052509e-04    5.2411e-06    -2.4366e-03 
+2.8000e-01      256    289   9  11 1.0431e+00 1.3069e+00 2.349990e+00       256   1089   6   9 8.4194e-05 1.2106e-04 2.052509e-04    1.6208e-05    3.8873e-03 
+3.0800e-01      256    289   8  12 1.0537e+00 1.2963e+00 2.349990e+00       256   1089   6   9 9.6942e-05 1.0831e-04 2.052509e-04    5.0250e-06    1.1928e-02 
+3.3600e-01      256    289   9  12 1.3528e+00 9.9719e-01 2.349990e+00       256   1089   6   9 1.0012e-04 1.0513e-04 2.052509e-04    -6.9116e-06    1.5683e-02 
+3.6400e-01      256    289   9  11 1.2267e+00 1.1233e+00 2.349990e+00       256   1089   6   9 1.1070e-04 9.4550e-05 2.052509e-04    -2.1861e-05    8.8433e-03 
+3.9200e-01      256    289   8  12 1.0111e+00 1.3389e+00 2.349990e+00       256   1089   6   9 1.2329e-04 8.1956e-05 2.052509e-04    -1.6485e-05    -9.7408e-03 
+4.2000e-01      256    289   8  12 1.1929e+00 1.1571e+00 2.349990e+00       256   1089   6   9 1.0887e-04 9.6382e-05 2.052509e-04    -9.2024e-06    -3.2882e-02 
+4.4800e-01      256    289   8  11 1.2412e+00 1.1087e+00 2.349990e+00       256   1089   5   9 1.2811e-04 7.7138e-05 2.052509e-04    -1.8383e-05    -4.6769e-02 
+4.7600e-01      256    289   8  12 1.1736e+00 1.1764e+00 2.349990e+00       256   1089   5   9 9.9461e-05 1.0579e-04 2.052509e-04    2.2089e-05    -3.6559e-02 
+5.0400e-01      256    289   9  11 1.1604e+00 1.1896e+00 2.349990e+00       256   1089   5   9 1.4358e-04 6.1667e-05 2.052509e-04    4.6946e-05    5.0228e-03 
+5.3200e-01      256    289   9  11 1.1092e+00 1.2408e+00 2.349990e+00       256   1089   5   9 1.4480e-04 6.2563e-05 2.073682e-04    5.2889e-06    6.8138e-02 
+5.6000e-01      256    289   9  11 1.2002e+00 1.1498e+00 2.349990e+00       256   1089   5   9 9.8857e-05 6.5212e-05 1.640683e-04    6.9220e-06    1.2313e-01 
+5.8800e-01      256    289   9  11 1.2988e+00 1.0512e+00 2.349990e+00       256   1089   5   9 1.0057e-04 5.6546e-05 1.571161e-04    1.7432e-05    1.3353e-01 
+6.1600e-01      256    289   8  12 1.1205e+00 1.2295e+00 2.349990e+00       256   1089   5   9 1.5695e-04 6.3305e-05 2.202540e-04    -1.9785e-05    8.1203e-02 
+6.4400e-01      256    289   8  12 1.0811e+00 1.2689e+00 2.349990e+00       256   1089   5   9 1.8308e-04 4.1336e-05 2.244119e-04    -2.2049e-05    -1.5289e-02 
+6.7200e-01      256    289   9  11 1.2217e+00 1.1283e+00 2.349990e+00       256   1089   4   9 3.5693e-05 5.8500e-05 9.419290e-05    7.7743e-06    -1.0713e-01 
+7.0000e-01      256    289   9  12 1.2092e+00 1.1408e+00 2.349990e+00       256   1089   0   0 0.0000e+00 0.0000e+00 0.000000e+00    9.8961e-06    -1.4490e-01 
+
+    Writing summary.Summary of this sweep:
+======================
+
+  Accumulated number of cells: 6656
+  Acc. number of primal dofs : 15028
+  Acc. number of dual dofs   : 56628
+  Accumulated error          : 7.3579e-05
+
+  Evaluations:
+  ------------
+    Hughens wave -- weighted time: 5.3510e-01
+                    average      : 8.0809e-03
+  Time tag: 1999/8/12 17:49:12
+
+
+
+Sweep  1:
+---------
+  Primal problem: time=0.0000e+00, step=   0, sweep= 1. 163 cells, 201 dofs.
+  Primal problem: time=2.8000e-02, step=   1, sweep= 1. 169 cells, 208 dofs.
+  Primal problem: time=5.6000e-02, step=   2, sweep= 1. 202 cells, 242 dofs.
+  Primal problem: time=8.4000e-02, step=   3, sweep= 1. 205 cells, 245 dofs.
+  Primal problem: time=1.1200e-01, step=   4, sweep= 1. 202 cells, 243 dofs.
+  Primal problem: time=1.4000e-01, step=   5, sweep= 1. 220 cells, 262 dofs.
+  Primal problem: time=1.6800e-01, step=   6, sweep= 1. 238 cells, 282 dofs.
+  Primal problem: time=1.9600e-01, step=   7, sweep= 1. 250 cells, 296 dofs.
+  Primal problem: time=2.2400e-01, step=   8, sweep= 1. 226 cells, 270 dofs.
+  Primal problem: time=2.5200e-01, step=   9, sweep= 1. 268 cells, 317 dofs.
+  Primal problem: time=2.8000e-01, step=  10, sweep= 1. 265 cells, 313 dofs.
+  Primal problem: time=3.0800e-01, step=  11, sweep= 1. 241 cells, 283 dofs.
+  Primal problem: time=3.3600e-01, step=  12, sweep= 1. 226 cells, 266 dofs.
+  Primal problem: time=3.6400e-01, step=  13, sweep= 1. 202 cells, 241 dofs.
+  Primal problem: time=3.9200e-01, step=  14, sweep= 1. 193 cells, 231 dofs.
+  Primal problem: time=4.2000e-01, step=  15, sweep= 1. 190 cells, 228 dofs.
+  Primal problem: time=4.4800e-01, step=  16, sweep= 1. 166 cells, 201 dofs.
+  Primal problem: time=4.7600e-01, step=  17, sweep= 1. 154 cells, 189 dofs.
+  Primal problem: time=5.0400e-01, step=  18, sweep= 1. 148 cells, 181 dofs.
+  Primal problem: time=5.3200e-01, step=  19, sweep= 1. 145 cells, 178 dofs.
+  Primal problem: time=5.6000e-01, step=  20, sweep= 1. 130 cells, 163 dofs.
+  Primal problem: time=5.8800e-01, step=  21, sweep= 1. 124 cells, 155 dofs.
+  Primal problem: time=6.1600e-01, step=  22, sweep= 1. 112 cells, 141 dofs.
+  Primal problem: time=6.4400e-01, step=  23, sweep= 1. 106 cells, 137 dofs.
+  Primal problem: time=6.7200e-01, step=  24, sweep= 1. 112 cells, 143 dofs.
+  Primal problem: time=7.0000e-01, step=  25, sweep= 1. 109 cells, 138 dofs.
+
+  Dual problem: time=7.0000e-01, step=  25, sweep= 1. 109 cells, 514 dofs.
+  Dual problem: time=6.7200e-01, step=  24, sweep= 1. 112 cells, 534 dofs.
+  Dual problem: time=6.4400e-01, step=  23, sweep= 1. 106 cells, 510 dofs.
+  Dual problem: time=6.1600e-01, step=  22, sweep= 1. 112 cells, 526 dofs.
+  Dual problem: time=5.8800e-01, step=  21, sweep= 1. 124 cells, 579 dofs.
+  Dual problem: time=5.6000e-01, step=  20, sweep= 1. 130 cells, 611 dofs.
+  Dual problem: time=5.3200e-01, step=  19, sweep= 1. 145 cells, 669 dofs.
+  Dual problem: time=5.0400e-01, step=  18, sweep= 1. 148 cells, 681 dofs.
+  Dual problem: time=4.7600e-01, step=  17, sweep= 1. 154 cells, 713 dofs.
+  Dual problem: time=4.4800e-01, step=  16, sweep= 1. 166 cells, 761 dofs.
+  Dual problem: time=4.2000e-01, step=  15, sweep= 1. 190 cells, 867 dofs.
+  Dual problem: time=3.9200e-01, step=  14, sweep= 1. 193 cells, 879 dofs.
+  Dual problem: time=3.6400e-01, step=  13, sweep= 1. 202 cells, 920 dofs.
+  Dual problem: time=3.3600e-01, step=  12, sweep= 1. 226 cells, 1019 dofs.
+  Dual problem: time=3.0800e-01, step=  11, sweep= 1. 241 cells, 1087 dofs.
+  Dual problem: time=2.8000e-01, step=  10, sweep= 1. 265 cells, 1207 dofs.
+  Dual problem: time=2.5200e-01, step=   9, sweep= 1. 268 cells, 1224 dofs.
+  Dual problem: time=2.2400e-01, step=   8, sweep= 1. 226 cells, 1041 dofs.
+  Dual problem: time=1.9600e-01, step=   7, sweep= 1. 250 cells, 1143 dofs.
+  Dual problem: time=1.6800e-01, step=   6, sweep= 1. 238 cells, 1091 dofs.
+  Dual problem: time=1.4000e-01, step=   5, sweep= 1. 220 cells, 1011 dofs.
+  Dual problem: time=1.1200e-01, step=   4, sweep= 1. 202 cells, 935 dofs.
+  Dual problem: time=8.4000e-02, step=   3, sweep= 1. 205 cells, 945 dofs.
+  Dual problem: time=5.6000e-02, step=   2, sweep= 1. 202 cells, 933 dofs.
+  Dual problem: time=2.8000e-02, step=   1, sweep= 1. 169 cells, 797 dofs.
+  Dual problem: time=0.0000e+00, step=   0, sweep= 1. 163 cells, 769 dofs.
+
+  Postprocessing: time=0.0000e+00, step=   0, sweep= 1. [ee][o]%!PS-Adobe-2.0 EPSF-1.2
+%%Title: deal.II Output
+%%Creator: the deal.II library
+%%Creation Date: 1999/8/12 - 17:50:16
+%%BoundingBox: 0 0 300 198
+/m {moveto} bind def
+/l {lineto} bind def
+/s {setrgbcolor} bind def
+/sg {setgray} bind def
+/lx {lineto closepath stroke} bind def
+/lf {lineto closepath fill} bind def
+%%EndProlog
+
+5.0000e-01 setlinewidth
+0.00000e+00 0.00000e+00 1.04995e-01 s 9.60817e+01 1.38113e+02 m 1.19856e+02 1.31250e+02 l 1.33582e+02 1.43137e+02 l 1.09808e+02 1.50000e+02 lf
+0 sg 9.60817e+01 1.38113e+02 m 1.19856e+02 1.31250e+02 l 1.33582e+02 1.43137e+02 l 1.09808e+02 1.50000e+02 lx
+0.00000e+00 0.00000e+00 1.04998e-01 s 1.19856e+02 1.31250e+02 m 1.43630e+02 1.24387e+02 l 1.57356e+02 1.36274e+02 l 1.33582e+02 1.43137e+02 lf
+0 sg 1.19856e+02 1.31250e+02 m 1.43630e+02 1.24387e+02 l 1.57356e+02 1.36274e+02 l 1.33582e+02 1.43137e+02 lx
+0.00000e+00 0.00000e+00 1.04998e-01 s 8.23557e+01 1.26226e+02 m 1.06130e+02 1.19363e+02 l 1.19856e+02 1.31250e+02 l 9.60817e+01 1.38113e+02 lf
+0 sg 8.23557e+01 1.26226e+02 m 1.06130e+02 1.19363e+02 l 1.19856e+02 1.31250e+02 l 9.60817e+01 1.38113e+02 lx
+0.00000e+00 0.00000e+00 1.04994e-01 s 1.43630e+02 1.24387e+02 m 1.67404e+02 1.17524e+02 l 1.81130e+02 1.29411e+02 l 1.57356e+02 1.36274e+02 lf
+0 sg 1.43630e+02 1.24387e+02 m 1.67404e+02 1.17524e+02 l 1.81130e+02 1.29411e+02 l 1.57356e+02 1.36274e+02 lx
+0.00000e+00 0.00000e+00 1.04987e-01 s 1.06130e+02 1.19363e+02 m 1.29904e+02 1.12499e+02 l 1.43630e+02 1.24387e+02 l 1.19856e+02 1.31250e+02 lf
+0 sg 1.06130e+02 1.19363e+02 m 1.29904e+02 1.12499e+02 l 1.43630e+02 1.24387e+02 l 1.19856e+02 1.31250e+02 lx
+0.00000e+00 0.00000e+00 1.05025e-01 s 1.67404e+02 1.17524e+02 m 1.91178e+02 1.10663e+02 l 2.04904e+02 1.22548e+02 l 1.81130e+02 1.29411e+02 lf
+0 sg 1.67404e+02 1.17524e+02 m 1.91178e+02 1.10663e+02 l 2.04904e+02 1.22548e+02 l 1.81130e+02 1.29411e+02 lx
+0.00000e+00 0.00000e+00 1.04990e-01 s 6.86298e+01 1.14339e+02 m 9.24038e+01 1.07475e+02 l 1.06130e+02 1.19363e+02 l 8.23557e+01 1.26226e+02 lf
+0 sg 6.86298e+01 1.14339e+02 m 9.24038e+01 1.07475e+02 l 1.06130e+02 1.19363e+02 l 8.23557e+01 1.26226e+02 lx
+0.00000e+00 0.00000e+00 1.04999e-01 s 1.29904e+02 1.12499e+02 m 1.53678e+02 1.05638e+02 l 1.67404e+02 1.17524e+02 l 1.43630e+02 1.24387e+02 lf
+0 sg 1.29904e+02 1.12499e+02 m 1.53678e+02 1.05638e+02 l 1.67404e+02 1.17524e+02 l 1.43630e+02 1.24387e+02 lx
+0.00000e+00 0.00000e+00 1.05020e-01 s 1.91178e+02 1.10663e+02 m 2.14952e+02 1.03798e+02 l 2.28678e+02 1.15685e+02 l 2.04904e+02 1.22548e+02 lf
+0 sg 1.91178e+02 1.10663e+02 m 2.14952e+02 1.03798e+02 l 2.28678e+02 1.15685e+02 l 2.04904e+02 1.22548e+02 lx
+0.00000e+00 0.00000e+00 1.05013e-01 s 9.24038e+01 1.07475e+02 m 1.16178e+02 1.00615e+02 l 1.29904e+02 1.12499e+02 l 1.06130e+02 1.19363e+02 lf
+0 sg 9.24038e+01 1.07475e+02 m 1.16178e+02 1.00615e+02 l 1.29904e+02 1.12499e+02 l 1.06130e+02 1.19363e+02 lx
+0.00000e+00 0.00000e+00 1.04906e-01 s 1.53678e+02 1.05638e+02 m 1.77452e+02 9.87664e+01 l 1.91178e+02 1.10663e+02 l 1.67404e+02 1.17524e+02 lf
+0 sg 1.53678e+02 1.05638e+02 m 1.77452e+02 9.87664e+01 l 1.91178e+02 1.10663e+02 l 1.67404e+02 1.17524e+02 lx
+0.00000e+00 0.00000e+00 1.04988e-01 s 2.14952e+02 1.03798e+02 m 2.38726e+02 9.69353e+01 l 2.52452e+02 1.08822e+02 l 2.28678e+02 1.15685e+02 lf
+0 sg 2.14952e+02 1.03798e+02 m 2.38726e+02 9.69353e+01 l 2.52452e+02 1.08822e+02 l 2.28678e+02 1.15685e+02 lx
+0.00000e+00 0.00000e+00 1.05015e-01 s 5.49038e+01 1.02452e+02 m 7.86779e+01 9.55905e+01 l 9.24038e+01 1.07475e+02 l 6.86298e+01 1.14339e+02 lf
+0 sg 5.49038e+01 1.02452e+02 m 7.86779e+01 9.55905e+01 l 9.24038e+01 1.07475e+02 l 6.86298e+01 1.14339e+02 lx
+0.00000e+00 0.00000e+00 1.05030e-01 s 1.16178e+02 1.00615e+02 m 1.39952e+02 9.37495e+01 l 1.53678e+02 1.05638e+02 l 1.29904e+02 1.12499e+02 lf
+0 sg 1.16178e+02 1.00615e+02 m 1.39952e+02 9.37495e+01 l 1.53678e+02 1.05638e+02 l 1.29904e+02 1.12499e+02 lx
+0.00000e+00 0.00000e+00 1.04922e-01 s 1.77452e+02 9.87664e+01 m 2.01226e+02 9.19133e+01 l 2.14952e+02 1.03798e+02 l 1.91178e+02 1.10663e+02 lf
+0 sg 1.77452e+02 9.87664e+01 m 2.01226e+02 9.19133e+01 l 2.14952e+02 1.03798e+02 l 1.91178e+02 1.10663e+02 lx
+0.00000e+00 0.00000e+00 1.04969e-01 s 1.46815e+02 9.96938e+01 m 1.58702e+02 9.62625e+01 l 1.65565e+02 1.02202e+02 l 1.53678e+02 1.05638e+02 lf
+0 sg 1.46815e+02 9.96938e+01 m 1.58702e+02 9.62625e+01 l 1.65565e+02 1.02202e+02 l 1.53678e+02 1.05638e+02 lx
+0.00000e+00 0.00000e+00 1.04998e-01 s 2.38726e+02 9.69353e+01 m 2.62500e+02 9.00721e+01 l 2.76226e+02 1.01959e+02 l 2.52452e+02 1.08822e+02 lf
+0 sg 2.38726e+02 9.69353e+01 m 2.62500e+02 9.00721e+01 l 2.76226e+02 1.01959e+02 l 2.52452e+02 1.08822e+02 lx
+0.00000e+00 0.00000e+00 1.04938e-01 s 7.86779e+01 9.55905e+01 m 1.02452e+02 8.87197e+01 l 1.16178e+02 1.00615e+02 l 9.24038e+01 1.07475e+02 lf
+0 sg 7.86779e+01 9.55905e+01 m 1.02452e+02 8.87197e+01 l 1.16178e+02 1.00615e+02 l 9.24038e+01 1.07475e+02 lx
+0.00000e+00 0.00000e+00 1.05957e-01 s 1.58702e+02 9.62625e+01 m 1.70589e+02 9.28937e+01 l 1.77452e+02 9.87664e+01 l 1.65565e+02 1.02202e+02 lf
+0 sg 1.58702e+02 9.62625e+01 m 1.70589e+02 9.28937e+01 l 1.77452e+02 9.87664e+01 l 1.65565e+02 1.02202e+02 lx
+0.00000e+00 0.00000e+00 1.04827e-01 s 1.09315e+02 9.46674e+01 m 1.21202e+02 9.12279e+01 l 1.28065e+02 9.71823e+01 l 1.16178e+02 1.00615e+02 lf
+0 sg 1.09315e+02 9.46674e+01 m 1.21202e+02 9.12279e+01 l 1.28065e+02 9.71823e+01 l 1.16178e+02 1.00615e+02 lx
+0.00000e+00 0.00000e+00 1.05021e-01 s 1.39952e+02 9.37495e+01 m 1.51839e+02 9.03196e+01 l 1.58702e+02 9.62625e+01 l 1.46815e+02 9.96938e+01 lf
+0 sg 1.39952e+02 9.37495e+01 m 1.51839e+02 9.03196e+01 l 1.58702e+02 9.62625e+01 l 1.46815e+02 9.96938e+01 lx
+0.00000e+00 0.00000e+00 1.05018e-01 s 2.01226e+02 9.19133e+01 m 2.25000e+02 8.50475e+01 l 2.38726e+02 9.69353e+01 l 2.14952e+02 1.03798e+02 lf
+0 sg 2.01226e+02 9.19133e+01 m 2.25000e+02 8.50475e+01 l 2.38726e+02 9.69353e+01 l 2.14952e+02 1.03798e+02 lx
+0.00000e+00 0.00000e+00 1.05846e-01 s 1.70589e+02 9.28937e+01 m 1.82476e+02 8.93928e+01 l 1.89339e+02 9.53399e+01 l 1.77452e+02 9.87664e+01 lf
+0 sg 1.70589e+02 9.28937e+01 m 1.82476e+02 8.93928e+01 l 1.89339e+02 9.53399e+01 l 1.77452e+02 9.87664e+01 lx
+0.00000e+00 0.00000e+00 1.05017e-01 s 4.11779e+01 9.05649e+01 m 6.49519e+01 8.37015e+01 l 7.86779e+01 9.55905e+01 l 5.49038e+01 1.02452e+02 lf
+0 sg 4.11779e+01 9.05649e+01 m 6.49519e+01 8.37015e+01 l 7.86779e+01 9.55905e+01 l 5.49038e+01 1.02452e+02 lx
+0.00000e+00 0.00000e+00 1.04995e-01 s 2.62500e+02 9.00721e+01 m 2.86274e+02 8.32092e+01 l 3.00000e+02 9.50962e+01 l 2.76226e+02 1.01959e+02 lf
+0 sg 2.62500e+02 9.00721e+01 m 2.86274e+02 8.32092e+01 l 3.00000e+02 9.50962e+01 l 2.76226e+02 1.01959e+02 lx
+0.00000e+00 0.00000e+00 1.04503e-01 s 1.21202e+02 9.12279e+01 m 1.33089e+02 8.77891e+01 l 1.39952e+02 9.37495e+01 l 1.28065e+02 9.71823e+01 lf
+0 sg 1.21202e+02 9.12279e+01 m 1.33089e+02 8.77891e+01 l 1.39952e+02 9.37495e+01 l 1.28065e+02 9.71823e+01 lx
+0.00000e+00 0.00000e+00 1.01704e-01 s 1.51839e+02 9.03196e+01 m 1.63726e+02 8.66416e+01 l 1.70589e+02 9.28937e+01 l 1.58702e+02 9.62625e+01 lf
+0 sg 1.51839e+02 9.03196e+01 m 1.63726e+02 8.66416e+01 l 1.70589e+02 9.28937e+01 l 1.58702e+02 9.62625e+01 lx
+0.00000e+00 0.00000e+00 1.04857e-01 s 1.82476e+02 8.93928e+01 m 1.94363e+02 8.59666e+01 l 2.01226e+02 9.19133e+01 l 1.89339e+02 9.53399e+01 lf
+0 sg 1.82476e+02 8.93928e+01 m 1.94363e+02 8.59666e+01 l 2.01226e+02 9.19133e+01 l 1.89339e+02 9.53399e+01 lx
+0.00000e+00 0.00000e+00 1.05589e-01 s 1.02452e+02 8.87197e+01 m 1.14339e+02 8.53454e+01 l 1.21202e+02 9.12279e+01 l 1.09315e+02 9.46674e+01 lf
+0 sg 1.02452e+02 8.87197e+01 m 1.14339e+02 8.53454e+01 l 1.21202e+02 9.12279e+01 l 1.09315e+02 9.46674e+01 lx
+0.00000e+00 0.00000e+00 1.06264e-01 s 1.33089e+02 8.77891e+01 m 1.44976e+02 8.44613e+01 l 1.51839e+02 9.03196e+01 l 1.39952e+02 9.37495e+01 lf
+0 sg 1.33089e+02 8.77891e+01 m 1.44976e+02 8.44613e+01 l 1.51839e+02 9.03196e+01 l 1.39952e+02 9.37495e+01 lx
+0.00000e+00 0.00000e+00 1.06199e-01 s 1.17770e+02 8.82867e+01 m 1.23714e+02 8.66198e+01 l 1.27145e+02 8.95085e+01 l 1.21202e+02 9.12279e+01 lf
+0 sg 1.17770e+02 8.82867e+01 m 1.23714e+02 8.66198e+01 l 1.27145e+02 8.95085e+01 l 1.21202e+02 9.12279e+01 lx
+0.00000e+00 0.00000e+00 1.02090e-01 s 1.63726e+02 8.66416e+01 m 1.75613e+02 8.34845e+01 l 1.82476e+02 8.93928e+01 l 1.70589e+02 9.28937e+01 lf
+0 sg 1.63726e+02 8.66416e+01 m 1.75613e+02 8.34845e+01 l 1.82476e+02 8.93928e+01 l 1.70589e+02 9.28937e+01 lx
+0.00000e+00 0.00000e+00 1.08391e-01 s 1.48407e+02 8.73905e+01 m 1.54351e+02 8.58948e+01 l 1.57782e+02 8.84806e+01 l 1.51839e+02 9.03196e+01 lf
+0 sg 1.48407e+02 8.73905e+01 m 1.54351e+02 8.58948e+01 l 1.57782e+02 8.84806e+01 l 1.51839e+02 9.03196e+01 lx
+0.00000e+00 0.00000e+00 1.04989e-01 s 2.25000e+02 8.50475e+01 m 2.48774e+02 7.81852e+01 l 2.62500e+02 9.00721e+01 l 2.38726e+02 9.69353e+01 lf
+0 sg 2.25000e+02 8.50475e+01 m 2.48774e+02 7.81852e+01 l 2.62500e+02 9.00721e+01 l 2.38726e+02 9.69353e+01 lx
+0.00000e+00 0.00000e+00 1.03523e-01 s 1.23714e+02 8.66198e+01 m 1.29657e+02 8.47156e+01 l 1.33089e+02 8.77891e+01 l 1.27145e+02 8.95085e+01 lf
+0 sg 1.23714e+02 8.66198e+01 m 1.29657e+02 8.47156e+01 l 1.33089e+02 8.77891e+01 l 1.27145e+02 8.95085e+01 lx
+0.00000e+00 0.00000e+00 1.04931e-01 s 6.49519e+01 8.37015e+01 m 8.87260e+01 7.68405e+01 l 1.02452e+02 8.87197e+01 l 7.86779e+01 9.55905e+01 lf
+0 sg 6.49519e+01 8.37015e+01 m 8.87260e+01 7.68405e+01 l 1.02452e+02 8.87197e+01 l 7.86779e+01 9.55905e+01 lx
+0.00000e+00 0.00000e+00 1.35150e-01 s 1.54351e+02 8.58948e+01 m 1.60294e+02 8.56747e+01 l 1.63726e+02 8.66416e+01 l 1.57782e+02 8.84806e+01 lf
+0 sg 1.54351e+02 8.58948e+01 m 1.60294e+02 8.56747e+01 l 1.63726e+02 8.66416e+01 l 1.57782e+02 8.84806e+01 lx
+0.00000e+00 0.00000e+00 1.05639e-01 s 1.14339e+02 8.53454e+01 m 1.20282e+02 8.34733e+01 l 1.23714e+02 8.66198e+01 l 1.17770e+02 8.82867e+01 lf
+0 sg 1.14339e+02 8.53454e+01 m 1.20282e+02 8.34733e+01 l 1.23714e+02 8.66198e+01 l 1.17770e+02 8.82867e+01 lx
+0.00000e+00 0.00000e+00 1.07964e-01 s 1.29657e+02 8.47156e+01 m 1.35601e+02 8.33840e+01 l 1.39032e+02 8.61252e+01 l 1.33089e+02 8.77891e+01 lf
+0 sg 1.29657e+02 8.47156e+01 m 1.35601e+02 8.33840e+01 l 1.39032e+02 8.61252e+01 l 1.33089e+02 8.77891e+01 lx
+0.00000e+00 0.00000e+00 9.38969e-02 s 1.44976e+02 8.44613e+01 m 1.50919e+02 8.16561e+01 l 1.54351e+02 8.58948e+01 l 1.48407e+02 8.73905e+01 lf
+0 sg 1.44976e+02 8.44613e+01 m 1.50919e+02 8.16561e+01 l 1.54351e+02 8.58948e+01 l 1.48407e+02 8.73905e+01 lx
+0.00000e+00 0.00000e+00 1.05320e-01 s 1.75613e+02 8.34845e+01 m 1.87500e+02 8.00200e+01 l 1.94363e+02 8.59666e+01 l 1.82476e+02 8.93928e+01 lf
+0 sg 1.75613e+02 8.34845e+01 m 1.87500e+02 8.00200e+01 l 1.94363e+02 8.59666e+01 l 1.82476e+02 8.93928e+01 lx
+0.00000e+00 0.00000e+00 1.35782e-01 s 1.60294e+02 8.56747e+01 m 1.66238e+02 8.24841e+01 l 1.69669e+02 8.50630e+01 l 1.63726e+02 8.66416e+01 lf
+0 sg 1.60294e+02 8.56747e+01 m 1.66238e+02 8.24841e+01 l 1.69669e+02 8.50630e+01 l 1.63726e+02 8.66416e+01 lx
+0.00000e+00 0.00000e+00 9.74021e-02 s 1.20282e+02 8.34733e+01 m 1.26226e+02 8.16013e+01 l 1.29657e+02 8.47156e+01 l 1.23714e+02 8.66198e+01 lf
+0 sg 1.20282e+02 8.34733e+01 m 1.26226e+02 8.16013e+01 l 1.29657e+02 8.47156e+01 l 1.23714e+02 8.66198e+01 lx
+0.00000e+00 0.00000e+00 1.05836e-01 s 9.55889e+01 8.27801e+01 m 1.07476e+02 7.93548e+01 l 1.14339e+02 8.53454e+01 l 1.02452e+02 8.87197e+01 lf
+0 sg 9.55889e+01 8.27801e+01 m 1.07476e+02 7.93548e+01 l 1.14339e+02 8.53454e+01 l 1.02452e+02 8.87197e+01 lx
+0.00000e+00 0.00000e+00 9.37953e-02 s 1.35601e+02 8.33840e+01 m 1.41544e+02 8.04025e+01 l 1.44976e+02 8.44613e+01 l 1.39032e+02 8.61252e+01 lf
+0 sg 1.35601e+02 8.33840e+01 m 1.41544e+02 8.04025e+01 l 1.44976e+02 8.44613e+01 l 1.39032e+02 8.61252e+01 lx
+0.00000e+00 0.00000e+00 2.03902e-04 s 1.50919e+02 8.16561e+01 m 1.56863e+02 7.41700e+01 l 1.60294e+02 8.56747e+01 l 1.54351e+02 8.58948e+01 lf
+0 sg 1.50919e+02 8.16561e+01 m 1.56863e+02 7.41700e+01 l 1.60294e+02 8.56747e+01 l 1.54351e+02 8.58948e+01 lx
+0.00000e+00 0.00000e+00 1.07608e-01 s 1.66238e+02 8.24841e+01 m 1.72181e+02 8.04220e+01 l 1.75613e+02 8.34845e+01 l 1.69669e+02 8.50630e+01 lf
+0 sg 1.66238e+02 8.24841e+01 m 1.72181e+02 8.04220e+01 l 1.75613e+02 8.34845e+01 l 1.69669e+02 8.50630e+01 lx
+0.00000e+00 0.00000e+00 1.04971e-01 s 1.87500e+02 8.00200e+01 m 2.11274e+02 7.31621e+01 l 2.25000e+02 8.50475e+01 l 2.01226e+02 9.19133e+01 lf
+0 sg 1.87500e+02 8.00200e+01 m 2.11274e+02 7.31621e+01 l 2.25000e+02 8.50475e+01 l 2.01226e+02 9.19133e+01 lx
+0.00000e+00 0.00000e+00 1.35119e-01 s 1.26226e+02 8.16013e+01 m 1.32169e+02 8.19170e+01 l 1.35601e+02 8.33840e+01 l 1.29657e+02 8.47156e+01 lf
+0 sg 1.26226e+02 8.16013e+01 m 1.32169e+02 8.19170e+01 l 1.35601e+02 8.33840e+01 l 1.29657e+02 8.47156e+01 lx
+0.00000e+00 0.00000e+00 0.00000e+00 s 1.56863e+02 7.41700e+01 m 1.62806e+02 7.81926e+01 l 1.66238e+02 8.24841e+01 l 1.60294e+02 8.56747e+01 lf
+0 sg 1.56863e+02 7.41700e+01 m 1.62806e+02 7.81926e+01 l 1.66238e+02 8.24841e+01 l 1.60294e+02 8.56747e+01 lx
+0.00000e+00 0.00000e+00 1.54596e-01 s 1.41544e+02 8.04025e+01 m 1.47488e+02 8.43283e+01 l 1.50919e+02 8.16561e+01 l 1.44976e+02 8.44613e+01 lf
+0 sg 1.41544e+02 8.04025e+01 m 1.47488e+02 8.43283e+01 l 1.50919e+02 8.16561e+01 l 1.44976e+02 8.44613e+01 lx
+0.00000e+00 0.00000e+00 2.52812e-04 s 1.32169e+02 8.19170e+01 m 1.38113e+02 7.16467e+01 l 1.41544e+02 8.04025e+01 l 1.35601e+02 8.33840e+01 lf
+0 sg 1.32169e+02 8.19170e+01 m 1.38113e+02 7.16467e+01 l 1.41544e+02 8.04025e+01 l 1.35601e+02 8.33840e+01 lx
+0.00000e+00 0.00000e+00 1.04991e-01 s 2.74519e+01 7.86779e+01 m 5.12260e+01 7.18150e+01 l 6.49519e+01 8.37015e+01 l 4.11779e+01 9.05649e+01 lf
+0 sg 2.74519e+01 7.86779e+01 m 5.12260e+01 7.18150e+01 l 6.49519e+01 8.37015e+01 l 4.11779e+01 9.05649e+01 lx
+0.00000e+00 0.00000e+00 1.04805e-01 s 1.72181e+02 8.04220e+01 m 1.78125e+02 7.87779e+01 l 1.81556e+02 8.17522e+01 l 1.75613e+02 8.34845e+01 lf
+0 sg 1.72181e+02 8.04220e+01 m 1.78125e+02 7.87779e+01 l 1.81556e+02 8.17522e+01 l 1.75613e+02 8.34845e+01 lx
+0.00000e+00 0.00000e+00 1.04997e-01 s 2.48774e+02 7.81852e+01 m 2.72548e+02 7.13221e+01 l 2.86274e+02 8.32092e+01 l 2.62500e+02 9.00721e+01 lf
+0 sg 2.48774e+02 7.81852e+01 m 2.72548e+02 7.13221e+01 l 2.86274e+02 8.32092e+01 l 2.62500e+02 9.00721e+01 lx
+0.00000e+00 0.00000e+00 1.01334e-01 s 1.07476e+02 7.93548e+01 m 1.19363e+02 7.59254e+01 l 1.26226e+02 8.16013e+01 l 1.14339e+02 8.53454e+01 lf
+0 sg 1.07476e+02 7.93548e+01 m 1.19363e+02 7.59254e+01 l 1.26226e+02 8.16013e+01 l 1.14339e+02 8.53454e+01 lx
+0.00000e+00 0.00000e+00 9.42107e-02 s 1.62806e+02 7.81926e+01 m 1.68750e+02 7.77323e+01 l 1.72181e+02 8.04220e+01 l 1.66238e+02 8.24841e+01 lf
+0 sg 1.62806e+02 7.81926e+01 m 1.68750e+02 7.77323e+01 l 1.72181e+02 8.04220e+01 l 1.66238e+02 8.24841e+01 lx
+0.00000e+00 0.00000e+00 1.05363e-01 s 1.78125e+02 7.87779e+01 m 1.84069e+02 7.70541e+01 l 1.87500e+02 8.00200e+01 l 1.81556e+02 8.17522e+01 lf
+0 sg 1.78125e+02 7.87779e+01 m 1.84069e+02 7.70541e+01 l 1.87500e+02 8.00200e+01 l 1.81556e+02 8.17522e+01 lx
+0.00000e+00 0.00000e+00 1.34943e-01 s 1.22794e+02 7.87633e+01 m 1.28738e+02 7.74395e+01 l 1.32169e+02 8.19170e+01 l 1.26226e+02 8.16013e+01 lf
+0 sg 1.22794e+02 7.87633e+01 m 1.28738e+02 7.74395e+01 l 1.32169e+02 8.19170e+01 l 1.26226e+02 8.16013e+01 lx
+0.00000e+00 0.00000e+00 2.74279e-04 s 1.28738e+02 7.74395e+01 m 1.34681e+02 7.44611e+01 l 1.38113e+02 7.16467e+01 l 1.32169e+02 8.19170e+01 lf
+0 sg 1.28738e+02 7.74395e+01 m 1.34681e+02 7.44611e+01 l 1.38113e+02 7.16467e+01 l 1.32169e+02 8.19170e+01 lx
+0.00000e+00 0.00000e+00 1.07054e-01 s 1.68750e+02 7.77323e+01 m 1.74694e+02 7.57409e+01 l 1.78125e+02 7.87779e+01 l 1.72181e+02 8.04220e+01 lf
+0 sg 1.68750e+02 7.77323e+01 m 1.74694e+02 7.57409e+01 l 1.78125e+02 7.87779e+01 l 1.72181e+02 8.04220e+01 lx
+0.00000e+00 0.00000e+00 1.05017e-01 s 8.87260e+01 7.68405e+01 m 1.00613e+02 7.34056e+01 l 1.07476e+02 7.93548e+01 l 9.55889e+01 8.27801e+01 lf
+0 sg 8.87260e+01 7.68405e+01 m 1.00613e+02 7.34056e+01 l 1.07476e+02 7.93548e+01 l 9.55889e+01 8.27801e+01 lx
+0.00000e+00 0.00000e+00 8.24560e-01 s 1.47488e+02 8.43283e+01 m 1.53431e+02 1.20614e+02 l 1.56863e+02 7.41700e+01 l 1.50919e+02 8.16561e+01 lf
+0 sg 1.47488e+02 8.43283e+01 m 1.53431e+02 1.20614e+02 l 1.56863e+02 7.41700e+01 l 1.50919e+02 8.16561e+01 lx
+0.00000e+00 0.00000e+00 1.56004e-01 s 1.59375e+02 8.09045e+01 m 1.65319e+02 7.35072e+01 l 1.68750e+02 7.77323e+01 l 1.62806e+02 7.81926e+01 lf
+0 sg 1.59375e+02 8.09045e+01 m 1.65319e+02 7.35072e+01 l 1.68750e+02 7.77323e+01 l 1.62806e+02 7.81926e+01 lx
+0.00000e+00 0.00000e+00 1.08338e-01 s 1.19363e+02 7.59254e+01 m 1.25306e+02 7.42452e+01 l 1.28738e+02 7.74395e+01 l 1.22794e+02 7.87633e+01 lf
+0 sg 1.19363e+02 7.59254e+01 m 1.25306e+02 7.42452e+01 l 1.28738e+02 7.74395e+01 l 1.22794e+02 7.87633e+01 lx
+0.00000e+00 0.00000e+00 1.04341e-01 s 1.74694e+02 7.57409e+01 m 1.80637e+02 7.40882e+01 l 1.84069e+02 7.70541e+01 l 1.78125e+02 7.87779e+01 lf
+0 sg 1.74694e+02 7.57409e+01 m 1.80637e+02 7.40882e+01 l 1.84069e+02 7.70541e+01 l 1.78125e+02 7.87779e+01 lx
+0.00000e+00 0.00000e+00 8.24450e-01 s 1.38113e+02 7.16467e+01 m 1.44056e+02 1.19361e+02 l 1.47488e+02 8.43283e+01 l 1.41544e+02 8.04025e+01 lf
+0 sg 1.38113e+02 7.16467e+01 m 1.44056e+02 1.19361e+02 l 1.47488e+02 8.43283e+01 l 1.41544e+02 8.04025e+01 lx
+0.00000e+00 0.00000e+00 1.05003e-01 s 2.11274e+02 7.31621e+01 m 2.35048e+02 6.62979e+01 l 2.48774e+02 7.81852e+01 l 2.25000e+02 8.50475e+01 lf
+0 sg 2.11274e+02 7.31621e+01 m 2.35048e+02 6.62979e+01 l 2.48774e+02 7.81852e+01 l 2.25000e+02 8.50475e+01 lx
+0.00000e+00 0.00000e+00 1.05014e-01 s 1.80637e+02 7.40882e+01 m 1.92524e+02 7.06479e+01 l 1.99387e+02 7.65911e+01 l 1.87500e+02 8.00200e+01 lf
+0 sg 1.80637e+02 7.40882e+01 m 1.92524e+02 7.06479e+01 l 1.99387e+02 7.65911e+01 l 1.87500e+02 8.00200e+01 lx
+0.00000e+00 0.00000e+00 8.24117e-01 s 1.53431e+02 1.20614e+02 m 1.59375e+02 8.09045e+01 l 1.62806e+02 7.81926e+01 l 1.56863e+02 7.41700e+01 lf
+0 sg 1.53431e+02 1.20614e+02 m 1.59375e+02 8.09045e+01 l 1.62806e+02 7.81926e+01 l 1.56863e+02 7.41700e+01 lx
+0.00000e+00 0.00000e+00 9.41861e-02 s 1.65319e+02 7.35072e+01 m 1.71262e+02 7.30993e+01 l 1.74694e+02 7.57409e+01 l 1.68750e+02 7.77323e+01 lf
+0 sg 1.65319e+02 7.35072e+01 m 1.71262e+02 7.30993e+01 l 1.74694e+02 7.57409e+01 l 1.68750e+02 7.77323e+01 lx
+0.00000e+00 0.00000e+00 9.37728e-02 s 1.25306e+02 7.42452e+01 m 1.31250e+02 7.25649e+01 l 1.34681e+02 7.44611e+01 l 1.28738e+02 7.74395e+01 lf
+0 sg 1.25306e+02 7.42452e+01 m 1.31250e+02 7.25649e+01 l 1.34681e+02 7.44611e+01 l 1.28738e+02 7.74395e+01 lx
+0.00000e+00 0.00000e+00 1.05046e-01 s 1.00613e+02 7.34056e+01 m 1.12500e+02 6.99708e+01 l 1.19363e+02 7.59254e+01 l 1.07476e+02 7.93548e+01 lf
+0 sg 1.00613e+02 7.34056e+01 m 1.12500e+02 6.99708e+01 l 1.19363e+02 7.59254e+01 l 1.07476e+02 7.93548e+01 lx
+0.00000e+00 0.00000e+00 1.05010e-01 s 5.12260e+01 7.18150e+01 m 7.50000e+01 6.49515e+01 l 8.87260e+01 7.68405e+01 l 6.49519e+01 8.37015e+01 lf
+0 sg 5.12260e+01 7.18150e+01 m 7.50000e+01 6.49515e+01 l 8.87260e+01 7.68405e+01 l 6.49519e+01 8.37015e+01 lx
+0.00000e+00 0.00000e+00 1.07830e-01 s 1.71262e+02 7.30993e+01 m 1.77206e+02 7.10374e+01 l 1.80637e+02 7.40882e+01 l 1.74694e+02 7.57409e+01 lf
+0 sg 1.71262e+02 7.30993e+01 m 1.77206e+02 7.10374e+01 l 1.80637e+02 7.40882e+01 l 1.74694e+02 7.57409e+01 lx
+0.00000e+00 0.00000e+00 1.54525e-01 s 1.31250e+02 7.25649e+01 m 1.37194e+02 6.97734e+01 l 1.40625e+02 7.83838e+01 l 1.34681e+02 7.44611e+01 lf
+0 sg 1.31250e+02 7.25649e+01 m 1.37194e+02 6.97734e+01 l 1.40625e+02 7.83838e+01 l 1.34681e+02 7.44611e+01 lx
+0.00000e+00 0.00000e+00 8.24470e-01 s 1.34681e+02 7.44611e+01 m 1.40625e+02 7.83838e+01 l 1.44056e+02 1.19361e+02 l 1.38113e+02 7.16467e+01 lf
+0 sg 1.34681e+02 7.44611e+01 m 1.40625e+02 7.83838e+01 l 1.44056e+02 1.19361e+02 l 1.38113e+02 7.16467e+01 lx
+0.00000e+00 0.00000e+00 7.31031e-04 s 1.61887e+02 6.47783e+01 m 1.67831e+02 7.16768e+01 l 1.71262e+02 7.30993e+01 l 1.65319e+02 7.35072e+01 lf
+0 sg 1.61887e+02 6.47783e+01 m 1.67831e+02 7.16768e+01 l 1.71262e+02 7.30993e+01 l 1.65319e+02 7.35072e+01 lx
+0.00000e+00 0.00000e+00 1.04968e-01 s 1.92524e+02 7.06479e+01 m 2.04411e+02 6.72177e+01 l 2.11274e+02 7.31621e+01 l 1.99387e+02 7.65911e+01 lf
+0 sg 1.92524e+02 7.06479e+01 m 2.04411e+02 6.72177e+01 l 2.11274e+02 7.31621e+01 l 1.99387e+02 7.65911e+01 lx
+0.00000e+00 0.00000e+00 1.04222e-01 s 1.77206e+02 7.10374e+01 m 1.83149e+02 6.94110e+01 l 1.86581e+02 7.23680e+01 l 1.80637e+02 7.40882e+01 lf
+0 sg 1.77206e+02 7.10374e+01 m 1.83149e+02 6.94110e+01 l 1.86581e+02 7.23680e+01 l 1.80637e+02 7.40882e+01 lx
+0.00000e+00 0.00000e+00 1.06520e-01 s 1.12500e+02 6.99708e+01 m 1.24387e+02 6.65504e+01 l 1.31250e+02 7.25649e+01 l 1.19363e+02 7.59254e+01 lf
+0 sg 1.12500e+02 6.99708e+01 m 1.24387e+02 6.65504e+01 l 1.31250e+02 7.25649e+01 l 1.19363e+02 7.59254e+01 lx
+0.00000e+00 0.00000e+00 8.23929e-01 s 1.55944e+02 1.15931e+02 m 1.61887e+02 6.47783e+01 l 1.65319e+02 7.35072e+01 l 1.59375e+02 8.09045e+01 lf
+0 sg 1.55944e+02 1.15931e+02 m 1.61887e+02 6.47783e+01 l 1.65319e+02 7.35072e+01 l 1.59375e+02 8.09045e+01 lx
+0.00000e+00 0.00000e+00 1.32990e-01 s 1.67831e+02 7.16768e+01 m 1.73774e+02 6.76467e+01 l 1.77206e+02 7.10374e+01 l 1.71262e+02 7.30993e+01 lf
+0 sg 1.67831e+02 7.16768e+01 m 1.73774e+02 6.76467e+01 l 1.77206e+02 7.10374e+01 l 1.71262e+02 7.30993e+01 lx
+0.00000e+00 0.00000e+00 9.37686e-02 s 1.27819e+02 6.95577e+01 m 1.33762e+02 6.80645e+01 l 1.37194e+02 6.97734e+01 l 1.31250e+02 7.25649e+01 lf
+0 sg 1.27819e+02 6.95577e+01 m 1.33762e+02 6.80645e+01 l 1.37194e+02 6.97734e+01 l 1.31250e+02 7.25649e+01 lx
+0.00000e+00 0.00000e+00 1.05274e-01 s 1.83149e+02 6.94110e+01 m 1.89093e+02 6.76725e+01 l 1.92524e+02 7.06479e+01 l 1.86581e+02 7.23680e+01 lf
+0 sg 1.83149e+02 6.94110e+01 m 1.89093e+02 6.76725e+01 l 1.92524e+02 7.06479e+01 l 1.86581e+02 7.23680e+01 lx
+0.00000e+00 0.00000e+00 8.86605e-04 s 1.58456e+02 6.75949e+01 m 1.64399e+02 6.71331e+01 l 1.67831e+02 7.16768e+01 l 1.61887e+02 6.47783e+01 lf
+0 sg 1.58456e+02 6.75949e+01 m 1.64399e+02 6.71331e+01 l 1.67831e+02 7.16768e+01 l 1.61887e+02 6.47783e+01 lx
+0.00000e+00 0.00000e+00 1.04997e-01 s 1.37260e+01 6.67908e+01 m 3.75000e+01 5.99278e+01 l 5.12260e+01 7.18150e+01 l 2.74519e+01 7.86779e+01 lf
+0 sg 1.37260e+01 6.67908e+01 m 3.75000e+01 5.99278e+01 l 5.12260e+01 7.18150e+01 l 2.74519e+01 7.86779e+01 lx
+0.00000e+00 0.00000e+00 2.87919e-04 s 1.33762e+02 6.80645e+01 m 1.39706e+02 6.78547e+01 l 1.43137e+02 6.22724e+01 l 1.37194e+02 6.97734e+01 lf
+0 sg 1.33762e+02 6.80645e+01 m 1.39706e+02 6.78547e+01 l 1.43137e+02 6.22724e+01 l 1.37194e+02 6.97734e+01 lx
+0.00000e+00 0.00000e+00 1.04994e-01 s 2.35048e+02 6.62979e+01 m 2.58822e+02 5.94351e+01 l 2.72548e+02 7.13221e+01 l 2.48774e+02 7.81852e+01 lf
+0 sg 2.35048e+02 6.62979e+01 m 2.58822e+02 5.94351e+01 l 2.72548e+02 7.13221e+01 l 2.48774e+02 7.81852e+01 lx
+0.00000e+00 0.00000e+00 9.74698e-02 s 1.73774e+02 6.76467e+01 m 1.79718e+02 6.65519e+01 l 1.83149e+02 6.94110e+01 l 1.77206e+02 7.10374e+01 lf
+0 sg 1.73774e+02 6.76467e+01 m 1.79718e+02 6.65519e+01 l 1.83149e+02 6.94110e+01 l 1.77206e+02 7.10374e+01 lx
+0.00000e+00 0.00000e+00 1.05021e-01 s 2.04411e+02 6.72177e+01 m 2.16298e+02 6.37859e+01 l 2.23161e+02 6.97300e+01 l 2.11274e+02 7.31621e+01 lf
+0 sg 2.04411e+02 6.72177e+01 m 2.16298e+02 6.37859e+01 l 2.23161e+02 6.97300e+01 l 2.11274e+02 7.31621e+01 lx
+0.00000e+00 0.00000e+00 1.04904e-01 s 1.89093e+02 6.76725e+01 m 1.95036e+02 6.59630e+01 l 1.98468e+02 6.89328e+01 l 1.92524e+02 7.06479e+01 lf
+0 sg 1.89093e+02 6.76725e+01 m 1.95036e+02 6.59630e+01 l 1.98468e+02 6.89328e+01 l 1.92524e+02 7.06479e+01 lx
+0.00000e+00 0.00000e+00 8.24476e-01 s 1.37194e+02 6.97734e+01 m 1.43137e+02 6.22724e+01 l 1.46569e+02 1.14673e+02 l 1.40625e+02 7.83838e+01 lf
+0 sg 1.37194e+02 6.97734e+01 m 1.43137e+02 6.22724e+01 l 1.46569e+02 1.14673e+02 l 1.40625e+02 7.83838e+01 lx
+0.00000e+00 0.00000e+00 1.54735e-01 s 1.49081e+02 6.63376e+01 m 1.55024e+02 6.57204e+01 l 1.58456e+02 6.75949e+01 l 1.52512e+02 7.49531e+01 lf
+0 sg 1.49081e+02 6.63376e+01 m 1.55024e+02 6.57204e+01 l 1.58456e+02 6.75949e+01 l 1.52512e+02 7.49531e+01 lx
+0.00000e+00 0.00000e+00 8.24352e-01 s 1.52512e+02 7.49531e+01 m 1.58456e+02 6.75949e+01 l 1.61887e+02 6.47783e+01 l 1.55944e+02 1.15931e+02 lf
+0 sg 1.52512e+02 7.49531e+01 m 1.58456e+02 6.75949e+01 l 1.61887e+02 6.47783e+01 l 1.55944e+02 1.15931e+02 lx
+0.00000e+00 0.00000e+00 1.04949e-01 s 7.50000e+01 6.49515e+01 m 9.87740e+01 5.80904e+01 l 1.12500e+02 6.99708e+01 l 8.87260e+01 7.68405e+01 lf
+0 sg 7.50000e+01 6.49515e+01 m 9.87740e+01 5.80904e+01 l 1.12500e+02 6.99708e+01 l 8.87260e+01 7.68405e+01 lx
+0.00000e+00 0.00000e+00 1.32726e-01 s 1.64399e+02 6.71331e+01 m 1.70343e+02 6.51020e+01 l 1.73774e+02 6.76467e+01 l 1.67831e+02 7.16768e+01 lf
+0 sg 1.64399e+02 6.71331e+01 m 1.70343e+02 6.51020e+01 l 1.73774e+02 6.76467e+01 l 1.67831e+02 7.16768e+01 lx
+0.00000e+00 0.00000e+00 2.07354e-04 s 1.39706e+02 6.78547e+01 m 1.45649e+02 6.46330e+01 l 1.49081e+02 6.63376e+01 l 1.43137e+02 6.22724e+01 lf
+0 sg 1.39706e+02 6.78547e+01 m 1.45649e+02 6.46330e+01 l 1.49081e+02 6.63376e+01 l 1.43137e+02 6.22724e+01 lx
+0.00000e+00 0.00000e+00 1.08338e-01 s 1.24387e+02 6.65504e+01 m 1.30331e+02 6.47008e+01 l 1.33762e+02 6.80645e+01 l 1.27819e+02 6.95577e+01 lf
+0 sg 1.24387e+02 6.65504e+01 m 1.30331e+02 6.47008e+01 l 1.33762e+02 6.80645e+01 l 1.27819e+02 6.95577e+01 lx
+0.00000e+00 0.00000e+00 1.06983e-01 s 1.79718e+02 6.65519e+01 m 1.85661e+02 6.46709e+01 l 1.89093e+02 6.76725e+01 l 1.83149e+02 6.94110e+01 lf
+0 sg 1.79718e+02 6.65519e+01 m 1.85661e+02 6.46709e+01 l 1.89093e+02 6.76725e+01 l 1.83149e+02 6.94110e+01 lx
+0.00000e+00 0.00000e+00 1.05006e-01 s 1.95036e+02 6.59630e+01 m 2.00980e+02 6.42454e+01 l 2.04411e+02 6.72177e+01 l 1.98468e+02 6.89328e+01 lf
+0 sg 1.95036e+02 6.59630e+01 m 2.00980e+02 6.42454e+01 l 2.04411e+02 6.72177e+01 l 1.98468e+02 6.89328e+01 lx
+0.00000e+00 0.00000e+00 8.24410e-01 s 1.43137e+02 6.22724e+01 m 1.49081e+02 6.63376e+01 l 1.52512e+02 7.49531e+01 l 1.46569e+02 1.14673e+02 lf
+0 sg 1.43137e+02 6.22724e+01 m 1.49081e+02 6.63376e+01 l 1.52512e+02 7.49531e+01 l 1.46569e+02 1.14673e+02 lx
+0.00000e+00 0.00000e+00 9.37194e-02 s 1.55024e+02 6.57204e+01 m 1.60968e+02 6.39445e+01 l 1.64399e+02 6.71331e+01 l 1.58456e+02 6.75949e+01 lf
+0 sg 1.55024e+02 6.57204e+01 m 1.60968e+02 6.39445e+01 l 1.64399e+02 6.71331e+01 l 1.58456e+02 6.75949e+01 lx
+0.00000e+00 0.00000e+00 9.76763e-02 s 1.70343e+02 6.51020e+01 m 1.76286e+02 6.34707e+01 l 1.79718e+02 6.65519e+01 l 1.73774e+02 6.76467e+01 lf
+0 sg 1.70343e+02 6.51020e+01 m 1.76286e+02 6.34707e+01 l 1.79718e+02 6.65519e+01 l 1.73774e+02 6.76467e+01 lx
+0.00000e+00 0.00000e+00 1.04469e-01 s 1.85661e+02 6.46709e+01 m 1.91605e+02 6.29989e+01 l 1.95036e+02 6.59630e+01 l 1.89093e+02 6.76725e+01 lf
+0 sg 1.85661e+02 6.46709e+01 m 1.91605e+02 6.29989e+01 l 1.95036e+02 6.59630e+01 l 1.89093e+02 6.76725e+01 lx
+0.00000e+00 0.00000e+00 1.34945e-01 s 1.30331e+02 6.47008e+01 m 1.36274e+02 6.28512e+01 l 1.39706e+02 6.78547e+01 l 1.33762e+02 6.80645e+01 lf
+0 sg 1.30331e+02 6.47008e+01 m 1.36274e+02 6.28512e+01 l 1.39706e+02 6.78547e+01 l 1.33762e+02 6.80645e+01 lx
+0.00000e+00 0.00000e+00 1.05046e-01 s 1.05637e+02 6.40306e+01 m 1.17524e+02 6.06047e+01 l 1.24387e+02 6.65504e+01 l 1.12500e+02 6.99708e+01 lf
+0 sg 1.05637e+02 6.40306e+01 m 1.17524e+02 6.06047e+01 l 1.24387e+02 6.65504e+01 l 1.12500e+02 6.99708e+01 lx
+0.00000e+00 0.00000e+00 9.39686e-02 s 1.45649e+02 6.46330e+01 m 1.51593e+02 6.26916e+01 l 1.55024e+02 6.57204e+01 l 1.49081e+02 6.63376e+01 lf
+0 sg 1.45649e+02 6.46330e+01 m 1.51593e+02 6.26916e+01 l 1.55024e+02 6.57204e+01 l 1.49081e+02 6.63376e+01 lx
+0.00000e+00 0.00000e+00 1.04995e-01 s 2.16298e+02 6.37859e+01 m 2.28185e+02 6.03545e+01 l 2.35048e+02 6.62979e+01 l 2.23161e+02 6.97300e+01 lf
+0 sg 2.16298e+02 6.37859e+01 m 2.28185e+02 6.03545e+01 l 2.35048e+02 6.62979e+01 l 2.23161e+02 6.97300e+01 lx
+0.00000e+00 0.00000e+00 1.08624e-01 s 1.60968e+02 6.39445e+01 m 1.66911e+02 6.21686e+01 l 1.70343e+02 6.51020e+01 l 1.64399e+02 6.71331e+01 lf
+0 sg 1.60968e+02 6.39445e+01 m 1.66911e+02 6.21686e+01 l 1.70343e+02 6.51020e+01 l 1.64399e+02 6.71331e+01 lx
+0.00000e+00 0.00000e+00 1.07008e-01 s 1.76286e+02 6.34707e+01 m 1.82230e+02 6.17271e+01 l 1.85661e+02 6.46709e+01 l 1.79718e+02 6.65519e+01 lf
+0 sg 1.76286e+02 6.34707e+01 m 1.82230e+02 6.17271e+01 l 1.85661e+02 6.46709e+01 l 1.79718e+02 6.65519e+01 lx
+0.00000e+00 0.00000e+00 1.05162e-01 s 1.91605e+02 6.29989e+01 m 1.97548e+02 6.12731e+01 l 2.00980e+02 6.42454e+01 l 1.95036e+02 6.59630e+01 lf
+0 sg 1.91605e+02 6.29989e+01 m 1.97548e+02 6.12731e+01 l 2.00980e+02 6.42454e+01 l 1.95036e+02 6.59630e+01 lx
+0.00000e+00 0.00000e+00 1.35110e-01 s 1.36274e+02 6.28512e+01 m 1.42218e+02 6.12784e+01 l 1.45649e+02 6.46330e+01 l 1.39706e+02 6.78547e+01 lf
+0 sg 1.36274e+02 6.28512e+01 m 1.42218e+02 6.12784e+01 l 1.45649e+02 6.46330e+01 l 1.39706e+02 6.78547e+01 lx
+0.00000e+00 0.00000e+00 1.03603e-01 s 1.66911e+02 6.21686e+01 m 1.72855e+02 6.04683e+01 l 1.76286e+02 6.34707e+01 l 1.70343e+02 6.51020e+01 lf
+0 sg 1.66911e+02 6.21686e+01 m 1.72855e+02 6.04683e+01 l 1.76286e+02 6.34707e+01 l 1.70343e+02 6.51020e+01 lx
+0.00000e+00 0.00000e+00 1.04981e-01 s 1.97548e+02 6.12731e+01 m 2.09435e+02 5.78428e+01 l 2.16298e+02 6.37859e+01 l 2.04411e+02 6.72177e+01 lf
+0 sg 1.97548e+02 6.12731e+01 m 2.09435e+02 5.78428e+01 l 2.16298e+02 6.37859e+01 l 2.04411e+02 6.72177e+01 lx
+0.00000e+00 0.00000e+00 1.04991e-01 s 3.75000e+01 5.99278e+01 m 6.12740e+01 5.30650e+01 l 7.50000e+01 6.49515e+01 l 5.12260e+01 7.18150e+01 lf
+0 sg 3.75000e+01 5.99278e+01 m 6.12740e+01 5.30650e+01 l 7.50000e+01 6.49515e+01 l 5.12260e+01 7.18150e+01 lx
+0.00000e+00 0.00000e+00 1.04427e-01 s 1.82230e+02 6.17271e+01 m 1.88173e+02 6.00190e+01 l 1.91605e+02 6.29989e+01 l 1.85661e+02 6.46709e+01 lf
+0 sg 1.82230e+02 6.17271e+01 m 1.88173e+02 6.00190e+01 l 1.91605e+02 6.29989e+01 l 1.85661e+02 6.46709e+01 lx
+0.00000e+00 0.00000e+00 1.07999e-01 s 1.42218e+02 6.12784e+01 m 1.48161e+02 5.96628e+01 l 1.51593e+02 6.26916e+01 l 1.45649e+02 6.46330e+01 lf
+0 sg 1.42218e+02 6.12784e+01 m 1.48161e+02 5.96628e+01 l 1.51593e+02 6.26916e+01 l 1.45649e+02 6.46330e+01 lx
+0.00000e+00 0.00000e+00 1.01333e-01 s 1.17524e+02 6.06047e+01 m 1.29411e+02 5.72204e+01 l 1.36274e+02 6.28512e+01 l 1.24387e+02 6.65504e+01 lf
+0 sg 1.17524e+02 6.06047e+01 m 1.29411e+02 5.72204e+01 l 1.36274e+02 6.28512e+01 l 1.24387e+02 6.65504e+01 lx
+0.00000e+00 0.00000e+00 1.05195e-01 s 1.72855e+02 6.04683e+01 m 1.78798e+02 5.87679e+01 l 1.82230e+02 6.17271e+01 l 1.76286e+02 6.34707e+01 lf
+0 sg 1.72855e+02 6.04683e+01 m 1.78798e+02 5.87679e+01 l 1.82230e+02 6.17271e+01 l 1.76286e+02 6.34707e+01 lx
+0.00000e+00 0.00000e+00 1.05997e-01 s 1.48161e+02 5.96628e+01 m 1.60048e+02 5.62531e+01 l 1.66911e+02 6.21686e+01 l 1.55024e+02 6.57204e+01 lf
+0 sg 1.48161e+02 5.96628e+01 m 1.60048e+02 5.62531e+01 l 1.66911e+02 6.21686e+01 l 1.55024e+02 6.57204e+01 lx
+0.00000e+00 0.00000e+00 9.74109e-02 s 1.32843e+02 6.00358e+01 m 1.38786e+02 5.84950e+01 l 1.42218e+02 6.12784e+01 l 1.36274e+02 6.28512e+01 lf
+0 sg 1.32843e+02 6.00358e+01 m 1.38786e+02 5.84950e+01 l 1.42218e+02 6.12784e+01 l 1.36274e+02 6.28512e+01 lx
+0.00000e+00 0.00000e+00 1.05142e-01 s 1.88173e+02 6.00190e+01 m 1.94117e+02 5.83013e+01 l 1.97548e+02 6.12731e+01 l 1.91605e+02 6.29989e+01 lf
+0 sg 1.88173e+02 6.00190e+01 m 1.94117e+02 5.83013e+01 l 1.97548e+02 6.12731e+01 l 1.91605e+02 6.29989e+01 lx
+1.00000e+00 9.99833e-01 9.99833e-01 s 1.44056e+02 1.19361e+02 m 1.50000e+02 1.98912e+02 l 1.53431e+02 1.20614e+02 l 1.47488e+02 8.43283e+01 lf
+0 sg 1.44056e+02 1.19361e+02 m 1.50000e+02 1.98912e+02 l 1.53431e+02 1.20614e+02 l 1.47488e+02 8.43283e+01 lx
+0.00000e+00 0.00000e+00 1.05043e-01 s 1.78798e+02 5.87679e+01 m 1.84742e+02 5.70487e+01 l 1.88173e+02 6.00190e+01 l 1.82230e+02 6.17271e+01 lf
+0 sg 1.78798e+02 5.87679e+01 m 1.84742e+02 5.70487e+01 l 1.88173e+02 6.00190e+01 l 1.82230e+02 6.17271e+01 lx
+0.00000e+00 0.00000e+00 1.05016e-01 s 9.87740e+01 5.80904e+01 m 1.10661e+02 5.46552e+01 l 1.17524e+02 6.06047e+01 l 1.05637e+02 6.40306e+01 lf
+0 sg 9.87740e+01 5.80904e+01 m 1.10661e+02 5.46552e+01 l 1.17524e+02 6.06047e+01 l 1.05637e+02 6.40306e+01 lx
+0.00000e+00 0.00000e+00 1.04995e-01 s 2.09435e+02 5.78428e+01 m 2.21322e+02 5.44110e+01 l 2.28185e+02 6.03545e+01 l 2.16298e+02 6.37859e+01 lf
+0 sg 2.09435e+02 5.78428e+01 m 2.21322e+02 5.44110e+01 l 2.28185e+02 6.03545e+01 l 2.16298e+02 6.37859e+01 lx
+0.00000e+00 0.00000e+00 1.03495e-01 s 1.38786e+02 5.84950e+01 m 1.44730e+02 5.66953e+01 l 1.48161e+02 5.96628e+01 l 1.42218e+02 6.12784e+01 lf
+0 sg 1.38786e+02 5.84950e+01 m 1.44730e+02 5.66953e+01 l 1.48161e+02 5.96628e+01 l 1.42218e+02 6.12784e+01 lx
+1.00000e+00 1.00000e+00 1.00000e+00 s 1.50000e+02 1.98912e+02 m 1.55944e+02 1.15931e+02 l 1.59375e+02 8.09045e+01 l 1.53431e+02 1.20614e+02 lf
+0 sg 1.50000e+02 1.98912e+02 m 1.55944e+02 1.15931e+02 l 1.59375e+02 8.09045e+01 l 1.53431e+02 1.20614e+02 lx
+0.00000e+00 0.00000e+00 1.05641e-01 s 1.29411e+02 5.72204e+01 m 1.35355e+02 5.54741e+01 l 1.38786e+02 5.84950e+01 l 1.32843e+02 6.00358e+01 lf
+0 sg 1.29411e+02 5.72204e+01 m 1.35355e+02 5.54741e+01 l 1.38786e+02 5.84950e+01 l 1.32843e+02 6.00358e+01 lx
+0.00000e+00 0.00000e+00 1.05020e-01 s 1.84742e+02 5.70487e+01 m 1.90685e+02 5.53295e+01 l 1.94117e+02 5.83013e+01 l 1.88173e+02 6.00190e+01 lf
+0 sg 1.84742e+02 5.70487e+01 m 1.90685e+02 5.53295e+01 l 1.94117e+02 5.83013e+01 l 1.88173e+02 6.00190e+01 lx
+0.00000e+00 0.00000e+00 1.04726e-01 s 1.60048e+02 5.62531e+01 m 1.71935e+02 5.28196e+01 l 1.78798e+02 5.87679e+01 l 1.66911e+02 6.21686e+01 lf
+0 sg 1.60048e+02 5.62531e+01 m 1.71935e+02 5.28196e+01 l 1.78798e+02 5.87679e+01 l 1.66911e+02 6.21686e+01 lx
+0.00000e+00 0.00000e+00 1.04995e-01 s 0.00000e+00 5.49038e+01 m 2.37740e+01 4.80408e+01 l 3.75000e+01 5.99278e+01 l 1.37260e+01 6.67908e+01 lf
+0 sg 0.00000e+00 5.49038e+01 m 2.37740e+01 4.80408e+01 l 3.75000e+01 5.99278e+01 l 1.37260e+01 6.67908e+01 lx
+0.00000e+00 0.00000e+00 1.04991e-01 s 2.21322e+02 5.44110e+01 m 2.45096e+02 4.75481e+01 l 2.58822e+02 5.94351e+01 l 2.35048e+02 6.62979e+01 lf
+0 sg 2.21322e+02 5.44110e+01 m 2.45096e+02 4.75481e+01 l 2.58822e+02 5.94351e+01 l 2.35048e+02 6.62979e+01 lx
+0.00000e+00 0.00000e+00 1.04970e-01 s 1.90685e+02 5.53295e+01 m 2.02572e+02 5.18994e+01 l 2.09435e+02 5.78428e+01 l 1.97548e+02 6.12731e+01 lf
+0 sg 1.90685e+02 5.53295e+01 m 2.02572e+02 5.18994e+01 l 2.09435e+02 5.78428e+01 l 1.97548e+02 6.12731e+01 lx
+1.00000e+00 9.99862e-01 9.99862e-01 s 1.40625e+02 7.83838e+01 m 1.46569e+02 1.14673e+02 l 1.50000e+02 1.98912e+02 l 1.44056e+02 1.19361e+02 lf
+0 sg 1.40625e+02 7.83838e+01 m 1.46569e+02 1.14673e+02 l 1.50000e+02 1.98912e+02 l 1.44056e+02 1.19361e+02 lx
+0.00000e+00 0.00000e+00 1.06182e-01 s 1.35355e+02 5.54741e+01 m 1.41298e+02 5.37277e+01 l 1.44730e+02 5.66953e+01 l 1.38786e+02 5.84950e+01 lf
+0 sg 1.35355e+02 5.54741e+01 m 1.41298e+02 5.37277e+01 l 1.44730e+02 5.66953e+01 l 1.38786e+02 5.84950e+01 lx
+0.00000e+00 0.00000e+00 1.05840e-01 s 1.10661e+02 5.46552e+01 m 1.22548e+02 5.12199e+01 l 1.29411e+02 5.72204e+01 l 1.17524e+02 6.06047e+01 lf
+0 sg 1.10661e+02 5.46552e+01 m 1.22548e+02 5.12199e+01 l 1.29411e+02 5.72204e+01 l 1.17524e+02 6.06047e+01 lx
+0.00000e+00 0.00000e+00 1.05010e-01 s 6.12740e+01 5.30650e+01 m 8.50481e+01 4.62015e+01 l 9.87740e+01 5.80904e+01 l 7.50000e+01 6.49515e+01 lf
+0 sg 6.12740e+01 5.30650e+01 m 8.50481e+01 4.62015e+01 l 9.87740e+01 5.80904e+01 l 7.50000e+01 6.49515e+01 lx
+0.00000e+00 0.00000e+00 1.04565e-01 s 1.41298e+02 5.37277e+01 m 1.53185e+02 5.03087e+01 l 1.60048e+02 5.62531e+01 l 1.48161e+02 5.96628e+01 lf
+0 sg 1.41298e+02 5.37277e+01 m 1.53185e+02 5.03087e+01 l 1.60048e+02 5.62531e+01 l 1.48161e+02 5.96628e+01 lx
+1.00000e+00 9.99903e-01 9.99903e-01 s 1.46569e+02 1.14673e+02 m 1.52512e+02 7.49531e+01 l 1.55944e+02 1.15931e+02 l 1.50000e+02 1.98912e+02 lf
+0 sg 1.46569e+02 1.14673e+02 m 1.52512e+02 7.49531e+01 l 1.55944e+02 1.15931e+02 l 1.50000e+02 1.98912e+02 lx
+0.00000e+00 0.00000e+00 1.05089e-01 s 1.71935e+02 5.28196e+01 m 1.83822e+02 4.93862e+01 l 1.90685e+02 5.53295e+01 l 1.78798e+02 5.87679e+01 lf
+0 sg 1.71935e+02 5.28196e+01 m 1.83822e+02 4.93862e+01 l 1.90685e+02 5.53295e+01 l 1.78798e+02 5.87679e+01 lx
+0.00000e+00 0.00000e+00 1.05008e-01 s 2.02572e+02 5.18994e+01 m 2.14459e+02 4.84676e+01 l 2.21322e+02 5.44110e+01 l 2.09435e+02 5.78428e+01 lf
+0 sg 2.02572e+02 5.18994e+01 m 2.14459e+02 4.84676e+01 l 2.21322e+02 5.44110e+01 l 2.09435e+02 5.78428e+01 lx
+0.00000e+00 0.00000e+00 1.05583e-01 s 1.22548e+02 5.12199e+01 m 1.34435e+02 4.77921e+01 l 1.41298e+02 5.37277e+01 l 1.29411e+02 5.72204e+01 lf
+0 sg 1.22548e+02 5.12199e+01 m 1.34435e+02 4.77921e+01 l 1.41298e+02 5.37277e+01 l 1.29411e+02 5.72204e+01 lx
+0.00000e+00 0.00000e+00 1.04962e-01 s 1.83822e+02 4.93862e+01 m 1.95709e+02 4.59552e+01 l 2.02572e+02 5.18994e+01 l 1.90685e+02 5.53295e+01 lf
+0 sg 1.83822e+02 4.93862e+01 m 1.95709e+02 4.59552e+01 l 2.02572e+02 5.18994e+01 l 1.90685e+02 5.53295e+01 lx
+0.00000e+00 0.00000e+00 1.04997e-01 s 2.37740e+01 4.80408e+01 m 4.75481e+01 4.11779e+01 l 6.12740e+01 5.30650e+01 l 3.75000e+01 5.99278e+01 lf
+0 sg 2.37740e+01 4.80408e+01 m 4.75481e+01 4.11779e+01 l 6.12740e+01 5.30650e+01 l 3.75000e+01 5.99278e+01 lx
+0.00000e+00 0.00000e+00 1.04829e-01 s 1.34435e+02 4.77921e+01 m 1.46322e+02 4.43643e+01 l 1.53185e+02 5.03087e+01 l 1.41298e+02 5.37277e+01 lf
+0 sg 1.34435e+02 4.77921e+01 m 1.46322e+02 4.43643e+01 l 1.53185e+02 5.03087e+01 l 1.41298e+02 5.37277e+01 lx
+0.00000e+00 0.00000e+00 1.04933e-01 s 8.50481e+01 4.62015e+01 m 1.08822e+02 3.93404e+01 l 1.22548e+02 5.12199e+01 l 9.87740e+01 5.80904e+01 lf
+0 sg 8.50481e+01 4.62015e+01 m 1.08822e+02 3.93404e+01 l 1.22548e+02 5.12199e+01 l 9.87740e+01 5.80904e+01 lx
+0.00000e+00 0.00000e+00 1.05000e-01 s 1.95709e+02 4.59552e+01 m 2.07596e+02 4.25242e+01 l 2.14459e+02 4.84676e+01 l 2.02572e+02 5.18994e+01 lf
+0 sg 1.95709e+02 4.59552e+01 m 2.07596e+02 4.25242e+01 l 2.14459e+02 4.84676e+01 l 2.02572e+02 5.18994e+01 lx
+0.00000e+00 0.00000e+00 1.05054e-01 s 1.46322e+02 4.43643e+01 m 1.70096e+02 3.74997e+01 l 1.83822e+02 4.93862e+01 l 1.60048e+02 5.62531e+01 lf
+0 sg 1.46322e+02 4.43643e+01 m 1.70096e+02 3.74997e+01 l 1.83822e+02 4.93862e+01 l 1.60048e+02 5.62531e+01 lx
+0.00000e+00 0.00000e+00 1.04998e-01 s 2.07596e+02 4.25242e+01 m 2.31370e+02 3.56611e+01 l 2.45096e+02 4.75481e+01 l 2.21322e+02 5.44110e+01 lf
+0 sg 2.07596e+02 4.25242e+01 m 2.31370e+02 3.56611e+01 l 2.45096e+02 4.75481e+01 l 2.21322e+02 5.44110e+01 lx
+0.00000e+00 0.00000e+00 1.04991e-01 s 4.75481e+01 4.11779e+01 m 7.13221e+01 3.43149e+01 l 8.50481e+01 4.62015e+01 l 6.12740e+01 5.30650e+01 lf
+0 sg 4.75481e+01 4.11779e+01 m 7.13221e+01 3.43149e+01 l 8.50481e+01 4.62015e+01 l 6.12740e+01 5.30650e+01 lx
+0.00000e+00 0.00000e+00 1.04931e-01 s 1.08822e+02 3.93404e+01 m 1.32596e+02 3.24756e+01 l 1.46322e+02 4.43643e+01 l 1.22548e+02 5.12199e+01 lf
+0 sg 1.08822e+02 3.93404e+01 m 1.32596e+02 3.24756e+01 l 1.46322e+02 4.43643e+01 l 1.22548e+02 5.12199e+01 lx
+0.00000e+00 0.00000e+00 1.04979e-01 s 1.70096e+02 3.74997e+01 m 1.93870e+02 3.06371e+01 l 2.07596e+02 4.25242e+01 l 1.83822e+02 4.93862e+01 lf
+0 sg 1.70096e+02 3.74997e+01 m 1.93870e+02 3.06371e+01 l 2.07596e+02 4.25242e+01 l 1.83822e+02 4.93862e+01 lx
+0.00000e+00 0.00000e+00 1.05016e-01 s 7.13221e+01 3.43149e+01 m 9.50962e+01 2.74519e+01 l 1.08822e+02 3.93404e+01 l 8.50481e+01 4.62015e+01 lf
+0 sg 7.13221e+01 3.43149e+01 m 9.50962e+01 2.74519e+01 l 1.08822e+02 3.93404e+01 l 8.50481e+01 4.62015e+01 lx
+0.00000e+00 0.00000e+00 1.05009e-01 s 1.32596e+02 3.24756e+01 m 1.56370e+02 2.56131e+01 l 1.70096e+02 3.74997e+01 l 1.46322e+02 4.43643e+01 lf
+0 sg 1.32596e+02 3.24756e+01 m 1.56370e+02 2.56131e+01 l 1.70096e+02 3.74997e+01 l 1.46322e+02 4.43643e+01 lx
+0.00000e+00 0.00000e+00 1.05000e-01 s 1.93870e+02 3.06371e+01 m 2.17644e+02 2.37740e+01 l 2.31370e+02 3.56611e+01 l 2.07596e+02 4.25242e+01 lf
+0 sg 1.93870e+02 3.06371e+01 m 2.17644e+02 2.37740e+01 l 2.31370e+02 3.56611e+01 l 2.07596e+02 4.25242e+01 lx
+0.00000e+00 0.00000e+00 1.05017e-01 s 9.50962e+01 2.74519e+01 m 1.18870e+02 2.05889e+01 l 1.32596e+02 3.24756e+01 l 1.08822e+02 3.93404e+01 lf
+0 sg 9.50962e+01 2.74519e+01 m 1.18870e+02 2.05889e+01 l 1.32596e+02 3.24756e+01 l 1.08822e+02 3.93404e+01 lx
+0.00000e+00 0.00000e+00 1.04992e-01 s 1.56370e+02 2.56131e+01 m 1.80144e+02 1.87500e+01 l 1.93870e+02 3.06371e+01 l 1.70096e+02 3.74997e+01 lf
+0 sg 1.56370e+02 2.56131e+01 m 1.80144e+02 1.87500e+01 l 1.93870e+02 3.06371e+01 l 1.70096e+02 3.74997e+01 lx
+0.00000e+00 0.00000e+00 1.04991e-01 s 1.18870e+02 2.05889e+01 m 1.42644e+02 1.37260e+01 l 1.56370e+02 2.56131e+01 l 1.32596e+02 3.24756e+01 lf
+0 sg 1.18870e+02 2.05889e+01 m 1.42644e+02 1.37260e+01 l 1.56370e+02 2.56131e+01 l 1.32596e+02 3.24756e+01 lx
+0.00000e+00 0.00000e+00 1.04997e-01 s 1.80144e+02 1.87500e+01 m 2.03918e+02 1.18870e+01 l 2.17644e+02 2.37740e+01 l 1.93870e+02 3.06371e+01 lf
+0 sg 1.80144e+02 1.87500e+01 m 2.03918e+02 1.18870e+01 l 2.17644e+02 2.37740e+01 l 1.93870e+02 3.06371e+01 lx
+0.00000e+00 0.00000e+00 1.04997e-01 s 1.42644e+02 1.37260e+01 m 1.66418e+02 6.86298e+00 l 1.80144e+02 1.87500e+01 l 1.56370e+02 2.56131e+01 lf
+0 sg 1.42644e+02 1.37260e+01 m 1.66418e+02 6.86298e+00 l 1.80144e+02 1.87500e+01 l 1.56370e+02 2.56131e+01 lx
+0.00000e+00 0.00000e+00 1.04995e-01 s 1.66418e+02 6.86298e+00 m 1.90192e+02 0.00000e+00 l 2.03918e+02 1.18870e+01 l 1.80144e+02 1.87500e+01 lf
+0 sg 1.66418e+02 6.86298e+00 m 1.90192e+02 0.00000e+00 l 2.03918e+02 1.18870e+01 l 1.80144e+02 1.87500e+01 lx
+showpage
+.
+  Postprocessing: time=2.8000e-02, step=   1, sweep= 1. [ee]
+  Postprocessing: time=5.6000e-02, step=   2, sweep= 1. [ee]
+  Postprocessing: time=8.4000e-02, step=   3, sweep= 1. [ee]
+  Postprocessing: time=1.1200e-01, step=   4, sweep= 1. [ee]
+  Postprocessing: time=1.4000e-01, step=   5, sweep= 1. [ee]
+  Postprocessing: time=1.6800e-01, step=   6, sweep= 1. [ee]
+  Postprocessing: time=1.9600e-01, step=   7, sweep= 1. [ee]
+  Postprocessing: time=2.2400e-01, step=   8, sweep= 1. [ee]
+  Postprocessing: time=2.5200e-01, step=   9, sweep= 1. [ee]
+  Postprocessing: time=2.8000e-01, step=  10, sweep= 1. [ee]
+  Postprocessing: time=3.0800e-01, step=  11, sweep= 1. [ee]
+  Postprocessing: time=3.3600e-01, step=  12, sweep= 1. [ee]
+  Postprocessing: time=3.6400e-01, step=  13, sweep= 1. [ee]
+  Postprocessing: time=3.9200e-01, step=  14, sweep= 1. [ee]
+  Postprocessing: time=4.2000e-01, step=  15, sweep= 1. [ee]
+  Postprocessing: time=4.4800e-01, step=  16, sweep= 1. [ee]
+  Postprocessing: time=4.7600e-01, step=  17, sweep= 1. [ee]
+  Postprocessing: time=5.0400e-01, step=  18, sweep= 1. [ee]
+  Postprocessing: time=5.3200e-01, step=  19, sweep= 1. [ee]
+  Postprocessing: time=5.6000e-01, step=  20, sweep= 1. [ee]
+  Postprocessing: time=5.8800e-01, step=  21, sweep= 1. [ee]
+  Postprocessing: time=6.1600e-01, step=  22, sweep= 1. [ee]
+  Postprocessing: time=6.4400e-01, step=  23, sweep= 1. [ee]
+  Postprocessing: time=6.7200e-01, step=  24, sweep= 1. [ee]
+  Postprocessing: time=7.0000e-01, step=  25, sweep= 1. [ee][o]%!PS-Adobe-2.0 EPSF-1.2
+%%Title: deal.II Output
+%%Creator: the deal.II library
+%%Creation Date: 1999/8/12 - 17:50:55
+%%BoundingBox: 0 0 300 150
+/m {moveto} bind def
+/l {lineto} bind def
+/s {setrgbcolor} bind def
+/sg {setgray} bind def
+/lx {lineto closepath stroke} bind def
+/lf {lineto closepath fill} bind def
+%%EndProlog
+
+5.0000e-01 setlinewidth
+6.97260e-02 9.30274e-01 0.00000e+00 s 9.60817e+01 1.38113e+02 m 1.19856e+02 1.33363e+02 l 1.33582e+02 1.43137e+02 l 1.09808e+02 1.50000e+02 lf
+0 sg 9.60817e+01 1.38113e+02 m 1.19856e+02 1.33363e+02 l 1.33582e+02 1.43137e+02 l 1.09808e+02 1.50000e+02 lx
+0.00000e+00 9.88143e-01 1.18573e-02 s 1.19856e+02 1.33363e+02 m 1.43630e+02 1.22914e+02 l 1.57356e+02 1.36274e+02 l 1.33582e+02 1.43137e+02 lf
+0 sg 1.19856e+02 1.33363e+02 m 1.43630e+02 1.22914e+02 l 1.57356e+02 1.36274e+02 l 1.33582e+02 1.43137e+02 lx
+1.56220e-01 8.43780e-01 0.00000e+00 s 8.23557e+01 1.26226e+02 m 1.06130e+02 1.20925e+02 l 1.19856e+02 1.33363e+02 l 9.60817e+01 1.38113e+02 lf
+0 sg 8.23557e+01 1.26226e+02 m 1.06130e+02 1.20925e+02 l 1.19856e+02 1.33363e+02 l 9.60817e+01 1.38113e+02 lx
+0.00000e+00 7.68406e-01 2.31594e-01 s 1.43630e+02 1.22914e+02 m 1.67404e+02 1.15669e+02 l 1.81130e+02 1.29411e+02 l 1.57356e+02 1.36274e+02 lf
+0 sg 1.43630e+02 1.22914e+02 m 1.67404e+02 1.15669e+02 l 1.81130e+02 1.29411e+02 l 1.57356e+02 1.36274e+02 lx
+1.12949e-01 8.87051e-01 0.00000e+00 s 1.06130e+02 1.20925e+02 m 1.29904e+02 1.13192e+02 l 1.43630e+02 1.22914e+02 l 1.19856e+02 1.33363e+02 lf
+0 sg 1.06130e+02 1.20925e+02 m 1.29904e+02 1.13192e+02 l 1.43630e+02 1.22914e+02 l 1.19856e+02 1.33363e+02 lx
+0.00000e+00 8.72567e-01 1.27433e-01 s 1.67404e+02 1.15669e+02 m 1.91178e+02 1.11069e+02 l 2.04904e+02 1.22548e+02 l 1.81130e+02 1.29411e+02 lf
+0 sg 1.67404e+02 1.15669e+02 m 1.91178e+02 1.11069e+02 l 2.04904e+02 1.22548e+02 l 1.81130e+02 1.29411e+02 lx
+0.00000e+00 9.10592e-01 8.94083e-02 s 6.86298e+01 1.14339e+02 m 9.24038e+01 1.05153e+02 l 1.06130e+02 1.20925e+02 l 8.23557e+01 1.26226e+02 lf
+0 sg 6.86298e+01 1.14339e+02 m 9.24038e+01 1.05153e+02 l 1.06130e+02 1.20925e+02 l 8.23557e+01 1.26226e+02 lx
+0.00000e+00 7.53248e-01 2.46752e-01 s 1.29904e+02 1.13192e+02 m 1.53678e+02 1.04671e+02 l 1.67404e+02 1.15669e+02 l 1.43630e+02 1.22914e+02 lf
+0 sg 1.29904e+02 1.13192e+02 m 1.53678e+02 1.04671e+02 l 1.67404e+02 1.15669e+02 l 1.43630e+02 1.22914e+02 lx
+0.00000e+00 8.93804e-01 1.06196e-01 s 1.91178e+02 1.11069e+02 m 2.14952e+02 1.02326e+02 l 2.28678e+02 1.15685e+02 l 2.04904e+02 1.22548e+02 lf
+0 sg 1.91178e+02 1.11069e+02 m 2.14952e+02 1.02326e+02 l 2.28678e+02 1.15685e+02 l 2.04904e+02 1.22548e+02 lx
+0.00000e+00 7.50782e-01 2.49218e-01 s 9.24038e+01 1.05153e+02 m 1.16178e+02 9.70351e+01 l 1.29904e+02 1.13192e+02 l 1.06130e+02 1.20925e+02 lf
+0 sg 9.24038e+01 1.05153e+02 m 1.16178e+02 9.70351e+01 l 1.29904e+02 1.13192e+02 l 1.06130e+02 1.20925e+02 lx
+0.00000e+00 9.04288e-01 9.57122e-02 s 1.53678e+02 1.04671e+02 m 1.77452e+02 1.00313e+02 l 1.91178e+02 1.11069e+02 l 1.67404e+02 1.15669e+02 lf
+0 sg 1.53678e+02 1.04671e+02 m 1.77452e+02 1.00313e+02 l 1.91178e+02 1.11069e+02 l 1.67404e+02 1.15669e+02 lx
+0.00000e+00 8.38938e-01 1.61062e-01 s 2.14952e+02 1.02326e+02 m 2.38726e+02 9.63520e+01 l 2.52452e+02 1.08822e+02 l 2.28678e+02 1.15685e+02 lf
+0 sg 2.14952e+02 1.02326e+02 m 2.38726e+02 9.63520e+01 l 2.52452e+02 1.08822e+02 l 2.28678e+02 1.15685e+02 lx
+0.00000e+00 8.74961e-01 1.25039e-01 s 5.49038e+01 1.02452e+02 m 7.86779e+01 9.65075e+01 l 9.24038e+01 1.05153e+02 l 6.86298e+01 1.14339e+02 lf
+0 sg 5.49038e+01 1.02452e+02 m 7.86779e+01 9.65075e+01 l 9.24038e+01 1.05153e+02 l 6.86298e+01 1.14339e+02 lx
+0.00000e+00 5.22507e-01 4.77493e-01 s 1.16178e+02 9.70351e+01 m 1.39952e+02 8.98322e+01 l 1.53678e+02 1.04671e+02 l 1.29904e+02 1.13192e+02 lf
+0 sg 1.16178e+02 9.70351e+01 m 1.39952e+02 8.98322e+01 l 1.53678e+02 1.04671e+02 l 1.29904e+02 1.13192e+02 lx
+0.00000e+00 9.64949e-01 3.50507e-02 s 1.77452e+02 1.00313e+02 m 2.01226e+02 9.16574e+01 l 2.14952e+02 1.02326e+02 l 1.91178e+02 1.11069e+02 lf
+0 sg 1.77452e+02 1.00313e+02 m 2.01226e+02 9.16574e+01 l 2.14952e+02 1.02326e+02 l 1.91178e+02 1.11069e+02 lx
+9.09015e-02 9.09098e-01 0.00000e+00 s 2.38726e+02 9.63520e+01 m 2.62500e+02 9.31505e+01 l 2.76226e+02 1.01959e+02 l 2.52452e+02 1.08822e+02 lf
+0 sg 2.38726e+02 9.63520e+01 m 2.62500e+02 9.31505e+01 l 2.76226e+02 1.01959e+02 l 2.52452e+02 1.08822e+02 lx
+0.00000e+00 4.25712e-01 5.74288e-01 s 7.86779e+01 9.65075e+01 m 1.02452e+02 8.41908e+01 l 1.16178e+02 9.70351e+01 l 9.24038e+01 1.05153e+02 lf
+0 sg 7.86779e+01 9.65075e+01 m 1.02452e+02 8.41908e+01 l 1.16178e+02 9.70351e+01 l 9.24038e+01 1.05153e+02 lx
+0.00000e+00 7.87646e-01 2.12354e-01 s 1.39952e+02 8.98322e+01 m 1.63726e+02 8.72507e+01 l 1.77452e+02 1.00313e+02 l 1.53678e+02 1.04671e+02 lf
+0 sg 1.39952e+02 8.98322e+01 m 1.63726e+02 8.72507e+01 l 1.77452e+02 1.00313e+02 l 1.53678e+02 1.04671e+02 lx
+0.00000e+00 9.07027e-01 9.29730e-02 s 2.01226e+02 9.16574e+01 m 2.25000e+02 8.65314e+01 l 2.38726e+02 9.63520e+01 l 2.14952e+02 1.02326e+02 lf
+0 sg 2.01226e+02 9.16574e+01 m 2.25000e+02 8.65314e+01 l 2.38726e+02 9.63520e+01 l 2.14952e+02 1.02326e+02 lx
+4.35102e-01 5.64898e-01 0.00000e+00 s 4.11779e+01 9.05649e+01 m 6.49519e+01 9.14945e+01 l 7.86779e+01 9.65075e+01 l 5.49038e+01 1.02452e+02 lf
+0 sg 4.11779e+01 9.05649e+01 m 6.49519e+01 9.14945e+01 l 7.86779e+01 9.65075e+01 l 5.49038e+01 1.02452e+02 lx
+1.23190e-01 8.76810e-01 0.00000e+00 s 2.62500e+02 9.31505e+01 m 2.86274e+02 8.32092e+01 l 3.00000e+02 9.50962e+01 l 2.76226e+02 1.01959e+02 lf
+0 sg 2.62500e+02 9.31505e+01 m 2.86274e+02 8.32092e+01 l 3.00000e+02 9.50962e+01 l 2.76226e+02 1.01959e+02 lx
+0.00000e+00 5.13988e-01 4.86012e-01 s 1.02452e+02 8.41908e+01 m 1.26226e+02 8.59705e+01 l 1.39952e+02 8.98322e+01 l 1.16178e+02 9.70351e+01 lf
+0 sg 1.02452e+02 8.41908e+01 m 1.26226e+02 8.59705e+01 l 1.39952e+02 8.98322e+01 l 1.16178e+02 9.70351e+01 lx
+0.00000e+00 8.39708e-01 1.60292e-01 s 1.63726e+02 8.72507e+01 m 1.87500e+02 7.63344e+01 l 2.01226e+02 9.16574e+01 l 1.77452e+02 1.00313e+02 lf
+0 sg 1.63726e+02 8.72507e+01 m 1.87500e+02 7.63344e+01 l 2.01226e+02 9.16574e+01 l 1.77452e+02 1.00313e+02 lx
+2.16589e-01 7.83411e-01 0.00000e+00 s 2.25000e+02 8.65314e+01 m 2.48774e+02 7.89716e+01 l 2.62500e+02 9.31505e+01 l 2.38726e+02 9.63520e+01 lf
+0 sg 2.25000e+02 8.65314e+01 m 2.48774e+02 7.89716e+01 l 2.62500e+02 9.31505e+01 l 2.38726e+02 9.63520e+01 lx
+0.00000e+00 6.90383e-01 3.09617e-01 s 6.49519e+01 9.14945e+01 m 8.87260e+01 6.79251e+01 l 1.02452e+02 8.41908e+01 l 7.86779e+01 9.65075e+01 lf
+0 sg 6.49519e+01 9.14945e+01 m 8.87260e+01 6.79251e+01 l 1.02452e+02 8.41908e+01 l 7.86779e+01 9.65075e+01 lx
+0.00000e+00 8.04328e-01 1.95672e-01 s 1.26226e+02 8.59705e+01 m 1.50000e+02 7.17666e+01 l 1.63726e+02 8.72507e+01 l 1.39952e+02 8.98322e+01 lf
+0 sg 1.26226e+02 8.59705e+01 m 1.50000e+02 7.17666e+01 l 1.63726e+02 8.72507e+01 l 1.39952e+02 8.98322e+01 lx
+0.00000e+00 7.18331e-01 2.81669e-01 s 1.87500e+02 7.63344e+01 m 2.11274e+02 7.13880e+01 l 2.25000e+02 8.65314e+01 l 2.01226e+02 9.16574e+01 lf
+0 sg 1.87500e+02 7.63344e+01 m 2.11274e+02 7.13880e+01 l 2.25000e+02 8.65314e+01 l 2.01226e+02 9.16574e+01 lx
+4.40994e-01 5.59006e-01 0.00000e+00 s 2.74519e+01 7.86779e+01 m 5.12260e+01 7.28398e+01 l 6.49519e+01 9.14945e+01 l 4.11779e+01 9.05649e+01 lf
+0 sg 2.74519e+01 7.86779e+01 m 5.12260e+01 7.28398e+01 l 6.49519e+01 9.14945e+01 l 4.11779e+01 9.05649e+01 lx
+1.66742e-01 8.33258e-01 0.00000e+00 s 2.48774e+02 7.89716e+01 m 2.72548e+02 7.13221e+01 l 2.86274e+02 8.32092e+01 l 2.62500e+02 9.31505e+01 lf
+0 sg 2.48774e+02 7.89716e+01 m 2.72548e+02 7.13221e+01 l 2.86274e+02 8.32092e+01 l 2.62500e+02 9.31505e+01 lx
+0.00000e+00 5.15467e-01 4.84533e-01 s 8.87260e+01 6.79251e+01 m 1.12500e+02 7.14207e+01 l 1.26226e+02 8.59705e+01 l 1.02452e+02 8.41908e+01 lf
+0 sg 8.87260e+01 6.79251e+01 m 1.12500e+02 7.14207e+01 l 1.26226e+02 8.59705e+01 l 1.02452e+02 8.41908e+01 lx
+0.00000e+00 5.22941e-01 4.77059e-01 s 1.50000e+02 7.17666e+01 m 1.73774e+02 6.69348e+01 l 1.87500e+02 7.63344e+01 l 1.63726e+02 8.72507e+01 lf
+0 sg 1.50000e+02 7.17666e+01 m 1.73774e+02 6.69348e+01 l 1.87500e+02 7.63344e+01 l 1.63726e+02 8.72507e+01 lx
+0.00000e+00 3.87046e-01 6.12954e-01 s 1.80637e+02 7.16346e+01 m 1.92524e+02 6.93002e+01 l 1.99387e+02 7.38612e+01 l 1.87500e+02 7.63344e+01 lf
+0 sg 1.80637e+02 7.16346e+01 m 1.92524e+02 6.93002e+01 l 1.99387e+02 7.38612e+01 l 1.87500e+02 7.63344e+01 lx
+0.00000e+00 8.45042e-01 1.54958e-01 s 2.11274e+02 7.13880e+01 m 2.35048e+02 6.38566e+01 l 2.48774e+02 7.89716e+01 l 2.25000e+02 8.65314e+01 lf
+0 sg 2.11274e+02 7.13880e+01 m 2.35048e+02 6.38566e+01 l 2.48774e+02 7.89716e+01 l 2.25000e+02 8.65314e+01 lx
+2.02117e-01 7.97883e-01 0.00000e+00 s 5.12260e+01 7.28398e+01 m 7.50000e+01 6.95518e+01 l 8.87260e+01 6.79251e+01 l 6.49519e+01 9.14945e+01 lf
+0 sg 5.12260e+01 7.28398e+01 m 7.50000e+01 6.95518e+01 l 8.87260e+01 6.79251e+01 l 6.49519e+01 9.14945e+01 lx
+0.00000e+00 3.65396e-01 6.34604e-01 s 1.92524e+02 6.93002e+01 m 2.04411e+02 6.24641e+01 l 2.11274e+02 7.13880e+01 l 1.99387e+02 7.38612e+01 lf
+0 sg 1.92524e+02 6.93002e+01 m 2.04411e+02 6.24641e+01 l 2.11274e+02 7.13880e+01 l 1.99387e+02 7.38612e+01 lx
+0.00000e+00 9.90903e-01 9.09739e-03 s 1.12500e+02 7.14207e+01 m 1.36274e+02 6.14834e+01 l 1.50000e+02 7.17666e+01 l 1.26226e+02 8.59705e+01 lf
+0 sg 1.12500e+02 7.14207e+01 m 1.36274e+02 6.14834e+01 l 1.50000e+02 7.17666e+01 l 1.26226e+02 8.59705e+01 lx
+0.00000e+00 9.11125e-01 8.88751e-02 s 1.73774e+02 6.69348e+01 m 1.85661e+02 6.89512e+01 l 1.92524e+02 6.93002e+01 l 1.80637e+02 7.16346e+01 lf
+0 sg 1.73774e+02 6.69348e+01 m 1.85661e+02 6.89512e+01 l 1.92524e+02 6.93002e+01 l 1.80637e+02 7.16346e+01 lx
+0.00000e+00 3.15365e-01 6.84635e-01 s 2.04411e+02 6.24641e+01 m 2.16298e+02 6.09096e+01 l 2.23161e+02 6.76223e+01 l 2.11274e+02 7.13880e+01 lf
+0 sg 2.04411e+02 6.24641e+01 m 2.16298e+02 6.09096e+01 l 2.23161e+02 6.76223e+01 l 2.11274e+02 7.13880e+01 lx
+0.00000e+00 9.46488e-01 5.35122e-02 s 1.37260e+01 6.67908e+01 m 3.75000e+01 5.87902e+01 l 5.12260e+01 7.28398e+01 l 2.74519e+01 7.86779e+01 lf
+0 sg 1.37260e+01 6.67908e+01 m 3.75000e+01 5.87902e+01 l 5.12260e+01 7.28398e+01 l 2.74519e+01 7.86779e+01 lx
+0.00000e+00 8.61089e-01 1.38911e-01 s 2.35048e+02 6.38566e+01 m 2.58822e+02 5.94351e+01 l 2.72548e+02 7.13221e+01 l 2.48774e+02 7.89716e+01 lf
+0 sg 2.35048e+02 6.38566e+01 m 2.58822e+02 5.94351e+01 l 2.72548e+02 7.13221e+01 l 2.48774e+02 7.89716e+01 lx
+0.00000e+00 4.00192e-01 5.99808e-01 s 7.50000e+01 6.95518e+01 m 9.87740e+01 5.09797e+01 l 1.12500e+02 7.14207e+01 l 8.87260e+01 6.79251e+01 lf
+0 sg 7.50000e+01 6.95518e+01 m 9.87740e+01 5.09797e+01 l 1.12500e+02 7.14207e+01 l 8.87260e+01 6.79251e+01 lx
+0.00000e+00 7.18232e-01 2.81768e-01 s 1.36274e+02 6.14834e+01 m 1.60048e+02 5.80804e+01 l 1.73774e+02 6.69348e+01 l 1.50000e+02 7.17666e+01 lf
+0 sg 1.36274e+02 6.14834e+01 m 1.60048e+02 5.80804e+01 l 1.73774e+02 6.69348e+01 l 1.50000e+02 7.17666e+01 lx
+4.10040e-02 9.58996e-01 0.00000e+00 s 1.85661e+02 6.89512e+01 m 1.97548e+02 6.47248e+01 l 2.04411e+02 6.24641e+01 l 1.92524e+02 6.93002e+01 lf
+0 sg 1.85661e+02 6.89512e+01 m 1.97548e+02 6.47248e+01 l 2.04411e+02 6.24641e+01 l 1.92524e+02 6.93002e+01 lx
+0.00000e+00 3.83489e-01 6.16511e-01 s 2.00980e+02 6.35945e+01 m 2.06923e+02 6.14698e+01 l 2.10355e+02 6.16869e+01 l 2.04411e+02 6.24641e+01 lf
+0 sg 2.00980e+02 6.35945e+01 m 2.06923e+02 6.14698e+01 l 2.10355e+02 6.16869e+01 l 2.04411e+02 6.24641e+01 lx
+0.00000e+00 5.63000e-01 4.37000e-01 s 2.16298e+02 6.09096e+01 m 2.28185e+02 6.07416e+01 l 2.35048e+02 6.38566e+01 l 2.23161e+02 6.76223e+01 lf
+0 sg 2.16298e+02 6.09096e+01 m 2.28185e+02 6.07416e+01 l 2.35048e+02 6.38566e+01 l 2.23161e+02 6.76223e+01 lx
+0.00000e+00 2.51103e-01 7.48897e-01 s 2.06923e+02 6.14698e+01 m 2.12867e+02 5.58952e+01 l 2.16298e+02 6.09096e+01 l 2.10355e+02 6.16869e+01 lf
+0 sg 2.06923e+02 6.14698e+01 m 2.12867e+02 5.58952e+01 l 2.16298e+02 6.09096e+01 l 2.10355e+02 6.16869e+01 lx
+1.37156e-01 8.62844e-01 0.00000e+00 s 1.66911e+02 6.25076e+01 m 1.78798e+02 5.87351e+01 l 1.85661e+02 6.89512e+01 l 1.73774e+02 6.69348e+01 lf
+0 sg 1.66911e+02 6.25076e+01 m 1.78798e+02 5.87351e+01 l 1.85661e+02 6.89512e+01 l 1.73774e+02 6.69348e+01 lx
+0.00000e+00 0.00000e+00 8.40660e-01 s 2.12867e+02 5.58952e+01 m 2.18810e+02 4.80559e+01 l 2.22242e+02 6.08256e+01 l 2.16298e+02 6.09096e+01 lf
+0 sg 2.12867e+02 5.58952e+01 m 2.18810e+02 4.80559e+01 l 2.22242e+02 6.08256e+01 l 2.16298e+02 6.09096e+01 lx
+0.00000e+00 8.53207e-01 1.46793e-01 s 1.97548e+02 6.47248e+01 m 2.03492e+02 5.60218e+01 l 2.06923e+02 6.14698e+01 l 2.00980e+02 6.35945e+01 lf
+0 sg 1.97548e+02 6.47248e+01 m 2.03492e+02 5.60218e+01 l 2.06923e+02 6.14698e+01 l 2.00980e+02 6.35945e+01 lx
+2.80347e-01 7.19653e-01 0.00000e+00 s 3.75000e+01 5.87902e+01 m 6.12740e+01 5.44942e+01 l 7.50000e+01 6.95518e+01 l 5.12260e+01 7.28398e+01 lf
+0 sg 3.75000e+01 5.87902e+01 m 6.12740e+01 5.44942e+01 l 7.50000e+01 6.95518e+01 l 5.12260e+01 7.28398e+01 lx
+0.00000e+00 8.14111e-01 1.85889e-01 s 2.28185e+02 6.07416e+01 m 2.40072e+02 5.76949e+01 l 2.46935e+02 6.16459e+01 l 2.35048e+02 6.38566e+01 lf
+0 sg 2.28185e+02 6.07416e+01 m 2.40072e+02 5.76949e+01 l 2.46935e+02 6.16459e+01 l 2.35048e+02 6.38566e+01 lx
+0.00000e+00 3.71263e-01 6.28737e-01 s 9.87740e+01 5.09797e+01 m 1.22548e+02 4.80192e+01 l 1.36274e+02 6.14834e+01 l 1.12500e+02 7.14207e+01 lf
+0 sg 9.87740e+01 5.09797e+01 m 1.22548e+02 4.80192e+01 l 1.36274e+02 6.14834e+01 l 1.12500e+02 7.14207e+01 lx
+0.00000e+00 1.38510e-01 8.61490e-01 s 2.03492e+02 5.60218e+01 m 2.09435e+02 5.26543e+01 l 2.12867e+02 5.58952e+01 l 2.06923e+02 6.14698e+01 lf
+0 sg 2.03492e+02 5.60218e+01 m 2.09435e+02 5.26543e+01 l 2.12867e+02 5.58952e+01 l 2.06923e+02 6.14698e+01 lx
+0.00000e+00 0.00000e+00 0.00000e+00 s 2.09435e+02 5.26543e+01 m 2.15379e+02 4.20123e+01 l 2.18810e+02 4.80559e+01 l 2.12867e+02 5.58952e+01 lf
+0 sg 2.09435e+02 5.26543e+01 m 2.15379e+02 4.20123e+01 l 2.18810e+02 4.80559e+01 l 2.12867e+02 5.58952e+01 lx
+0.00000e+00 5.11658e-01 4.88342e-01 s 2.18810e+02 4.80559e+01 m 2.24754e+02 6.13178e+01 l 2.28185e+02 6.07416e+01 l 2.22242e+02 6.08256e+01 lf
+0 sg 2.18810e+02 4.80559e+01 m 2.24754e+02 6.13178e+01 l 2.28185e+02 6.07416e+01 l 2.22242e+02 6.08256e+01 lx
+2.64623e-01 7.35377e-01 0.00000e+00 s 1.78798e+02 5.87351e+01 m 1.90685e+02 5.32935e+01 l 1.97548e+02 6.47248e+01 l 1.85661e+02 6.89512e+01 lf
+0 sg 1.78798e+02 5.87351e+01 m 1.90685e+02 5.32935e+01 l 1.97548e+02 6.47248e+01 l 1.85661e+02 6.89512e+01 lx
+0.00000e+00 5.73257e-01 4.26743e-01 s 1.94117e+02 5.90092e+01 m 2.00060e+02 4.91124e+01 l 2.03492e+02 5.60218e+01 l 1.97548e+02 6.47248e+01 lf
+0 sg 1.94117e+02 5.90092e+01 m 2.00060e+02 4.91124e+01 l 2.03492e+02 5.60218e+01 l 1.97548e+02 6.47248e+01 lx
+0.00000e+00 0.00000e+00 7.09870e-01 s 2.00060e+02 4.91124e+01 m 2.06004e+02 4.86247e+01 l 2.09435e+02 5.26543e+01 l 2.03492e+02 5.60218e+01 lf
+0 sg 2.00060e+02 4.91124e+01 m 2.06004e+02 4.86247e+01 l 2.09435e+02 5.26543e+01 l 2.03492e+02 5.60218e+01 lx
+0.00000e+00 9.27875e-01 7.21250e-02 s 2.40072e+02 5.76949e+01 m 2.51959e+02 5.34916e+01 l 2.58822e+02 5.94351e+01 l 2.46935e+02 6.16459e+01 lf
+0 sg 2.40072e+02 5.76949e+01 m 2.51959e+02 5.34916e+01 l 2.58822e+02 5.94351e+01 l 2.46935e+02 6.16459e+01 lx
+0.00000e+00 0.00000e+00 2.01167e-01 s 2.06004e+02 4.86247e+01 m 2.11947e+02 4.70722e+01 l 2.15379e+02 4.20123e+01 l 2.09435e+02 5.26543e+01 lf
+0 sg 2.06004e+02 4.86247e+01 m 2.11947e+02 4.70722e+01 l 2.15379e+02 4.20123e+01 l 2.09435e+02 5.26543e+01 lx
+0.00000e+00 2.76276e-01 7.23724e-01 s 2.15379e+02 4.20123e+01 m 2.21322e+02 6.34171e+01 l 2.24754e+02 6.13178e+01 l 2.18810e+02 4.80559e+01 lf
+0 sg 2.15379e+02 4.20123e+01 m 2.21322e+02 6.34171e+01 l 2.24754e+02 6.13178e+01 l 2.18810e+02 4.80559e+01 lx
+0.00000e+00 9.33055e-01 6.69448e-02 s 1.60048e+02 5.80804e+01 m 1.71935e+02 5.03456e+01 l 1.78798e+02 5.87351e+01 l 1.66911e+02 6.25076e+01 lf
+0 sg 1.60048e+02 5.80804e+01 m 1.71935e+02 5.03456e+01 l 1.78798e+02 5.87351e+01 l 1.66911e+02 6.25076e+01 lx
+0.00000e+00 8.89732e-01 1.10268e-01 s 0.00000e+00 5.49038e+01 m 2.37740e+01 4.80408e+01 l 3.75000e+01 5.87902e+01 l 1.37260e+01 6.67908e+01 lf
+0 sg 0.00000e+00 5.49038e+01 m 2.37740e+01 4.80408e+01 l 3.75000e+01 5.87902e+01 l 1.37260e+01 6.67908e+01 lx
+5.97114e-01 4.02886e-01 0.00000e+00 s 2.24754e+02 6.13178e+01 m 2.30697e+02 6.24026e+01 l 2.34129e+02 5.92183e+01 l 2.28185e+02 6.07416e+01 lf
+0 sg 2.24754e+02 6.13178e+01 m 2.30697e+02 6.24026e+01 l 2.34129e+02 5.92183e+01 l 2.28185e+02 6.07416e+01 lx
+0.00000e+00 2.53629e-01 7.46371e-01 s 1.90685e+02 5.32935e+01 m 1.96629e+02 4.97939e+01 l 2.00060e+02 4.91124e+01 l 1.94117e+02 5.90092e+01 lf
+0 sg 1.90685e+02 5.32935e+01 m 1.96629e+02 4.97939e+01 l 2.00060e+02 4.91124e+01 l 1.94117e+02 5.90092e+01 lx
+0.00000e+00 0.00000e+00 6.71049e-01 s 1.96629e+02 4.97939e+01 m 2.02572e+02 4.62942e+01 l 2.06004e+02 4.86247e+01 l 2.00060e+02 4.91124e+01 lf
+0 sg 1.96629e+02 4.97939e+01 m 2.02572e+02 4.62942e+01 l 2.06004e+02 4.86247e+01 l 2.00060e+02 4.91124e+01 lx
+2.94319e-01 7.05681e-01 0.00000e+00 s 2.30697e+02 6.24026e+01 m 2.36641e+02 5.20333e+01 l 2.40072e+02 5.76949e+01 l 2.34129e+02 5.92183e+01 lf
+0 sg 2.30697e+02 6.24026e+01 m 2.36641e+02 5.20333e+01 l 2.40072e+02 5.76949e+01 l 2.34129e+02 5.92183e+01 lx
+2.00501e-01 7.99500e-01 0.00000e+00 s 6.12740e+01 5.44942e+01 m 8.50481e+01 5.17564e+01 l 9.87740e+01 5.09797e+01 l 7.50000e+01 6.95518e+01 lf
+0 sg 6.12740e+01 5.44942e+01 m 8.50481e+01 5.17564e+01 l 9.87740e+01 5.09797e+01 l 7.50000e+01 6.95518e+01 lx
+0.00000e+00 3.26288e-01 6.73712e-01 s 1.71935e+02 5.03456e+01 m 1.83822e+02 4.26109e+01 l 1.90685e+02 5.32935e+01 l 1.78798e+02 5.87351e+01 lf
+0 sg 1.71935e+02 5.03456e+01 m 1.83822e+02 4.26109e+01 l 1.90685e+02 5.32935e+01 l 1.78798e+02 5.87351e+01 lx
+0.00000e+00 4.59689e-01 5.40311e-01 s 1.22548e+02 4.80192e+01 m 1.46322e+02 3.84650e+01 l 1.60048e+02 5.80804e+01 l 1.36274e+02 6.14834e+01 lf
+0 sg 1.22548e+02 4.80192e+01 m 1.46322e+02 3.84650e+01 l 1.60048e+02 5.80804e+01 l 1.36274e+02 6.14834e+01 lx
+0.00000e+00 1.49617e-01 8.50383e-01 s 2.02572e+02 4.62942e+01 m 2.08516e+02 5.36136e+01 l 2.11947e+02 4.70722e+01 l 2.06004e+02 4.86247e+01 lf
+0 sg 2.02572e+02 4.62942e+01 m 2.08516e+02 5.36136e+01 l 2.11947e+02 4.70722e+01 l 2.06004e+02 4.86247e+01 lx
+3.82773e-02 9.61723e-01 0.00000e+00 s 2.11947e+02 4.70722e+01 m 2.17891e+02 6.41755e+01 l 2.21322e+02 6.34171e+01 l 2.15379e+02 4.20123e+01 lf
+0 sg 2.11947e+02 4.70722e+01 m 2.17891e+02 6.41755e+01 l 2.21322e+02 6.34171e+01 l 2.15379e+02 4.20123e+01 lx
+1.00000e+00 2.79566e-01 2.79566e-01 s 2.21322e+02 6.34171e+01 m 2.27266e+02 5.69802e+01 l 2.30697e+02 6.24026e+01 l 2.24754e+02 6.13178e+01 lf
+0 sg 2.21322e+02 6.34171e+01 m 2.27266e+02 5.69802e+01 l 2.30697e+02 6.24026e+01 l 2.24754e+02 6.13178e+01 lx
+2.01605e-01 7.98395e-01 0.00000e+00 s 2.27266e+02 5.69802e+01 m 2.33209e+02 4.63717e+01 l 2.36641e+02 5.20333e+01 l 2.30697e+02 6.24026e+01 lf
+0 sg 2.27266e+02 5.69802e+01 m 2.33209e+02 4.63717e+01 l 2.36641e+02 5.20333e+01 l 2.30697e+02 6.24026e+01 lx
+0.00000e+00 7.40314e-01 2.59686e-01 s 2.33209e+02 4.63717e+01 m 2.45096e+02 4.75481e+01 l 2.51959e+02 5.34916e+01 l 2.40072e+02 5.76949e+01 lf
+0 sg 2.33209e+02 4.63717e+01 m 2.45096e+02 4.75481e+01 l 2.51959e+02 5.34916e+01 l 2.40072e+02 5.76949e+01 lx
+0.00000e+00 1.45329e-01 8.54671e-01 s 1.83822e+02 4.26109e+01 m 1.95709e+02 4.57926e+01 l 2.02572e+02 4.62942e+01 l 1.90685e+02 5.32935e+01 lf
+0 sg 1.83822e+02 4.26109e+01 m 1.95709e+02 4.57926e+01 l 2.02572e+02 4.62942e+01 l 1.90685e+02 5.32935e+01 lx
+0.00000e+00 9.68878e-01 3.11216e-02 s 2.37740e+01 4.80408e+01 m 4.75481e+01 4.11779e+01 l 6.12740e+01 5.44942e+01 l 3.75000e+01 5.87902e+01 lf
+0 sg 2.37740e+01 4.80408e+01 m 4.75481e+01 4.11779e+01 l 6.12740e+01 5.44942e+01 l 3.75000e+01 5.87902e+01 lx
+1.85870e-02 9.81413e-01 0.00000e+00 s 2.23834e+02 5.45448e+01 m 2.29778e+02 4.46990e+01 l 2.33209e+02 4.63717e+01 l 2.27266e+02 5.69802e+01 lf
+0 sg 2.23834e+02 5.45448e+01 m 2.29778e+02 4.46990e+01 l 2.33209e+02 4.63717e+01 l 2.27266e+02 5.69802e+01 lx
+1.00000e+00 6.60917e-01 6.60917e-01 s 2.17891e+02 6.41755e+01 m 2.23834e+02 5.45448e+01 l 2.27266e+02 5.69802e+01 l 2.21322e+02 6.34171e+01 lf
+0 sg 2.17891e+02 6.41755e+01 m 2.23834e+02 5.45448e+01 l 2.27266e+02 5.69802e+01 l 2.21322e+02 6.34171e+01 lx
+1.00000e+00 2.01357e-01 2.01357e-01 s 2.08516e+02 5.36136e+01 m 2.14459e+02 6.09330e+01 l 2.17891e+02 6.41755e+01 l 2.11947e+02 4.70722e+01 lf
+0 sg 2.08516e+02 5.36136e+01 m 2.14459e+02 6.09330e+01 l 2.17891e+02 6.41755e+01 l 2.11947e+02 4.70722e+01 lx
+0.00000e+00 8.79372e-01 1.20628e-01 s 8.50481e+01 5.17564e+01 m 1.08822e+02 4.27756e+01 l 1.22548e+02 4.80192e+01 l 9.87740e+01 5.09797e+01 lf
+0 sg 8.50481e+01 5.17564e+01 m 1.08822e+02 4.27756e+01 l 1.22548e+02 4.80192e+01 l 9.87740e+01 5.09797e+01 lx
+0.00000e+00 6.03003e-01 3.96997e-01 s 1.46322e+02 3.84650e+01 m 1.70096e+02 4.20280e+01 l 1.83822e+02 4.26109e+01 l 1.60048e+02 5.80804e+01 lf
+0 sg 1.46322e+02 3.84650e+01 m 1.70096e+02 4.20280e+01 l 1.83822e+02 4.26109e+01 l 1.60048e+02 5.80804e+01 lx
+0.00000e+00 5.86282e-01 4.13718e-01 s 2.26346e+02 4.30262e+01 m 2.38233e+02 4.16046e+01 l 2.45096e+02 4.75481e+01 l 2.33209e+02 4.63717e+01 lf
+0 sg 2.26346e+02 4.30262e+01 m 2.38233e+02 4.16046e+01 l 2.45096e+02 4.75481e+01 l 2.33209e+02 4.63717e+01 lx
+3.09976e-01 6.90024e-01 0.00000e+00 s 2.20403e+02 5.37008e+01 m 2.26346e+02 4.30262e+01 l 2.29778e+02 4.46990e+01 l 2.23834e+02 5.45448e+01 lf
+0 sg 2.20403e+02 5.37008e+01 m 2.26346e+02 4.30262e+01 l 2.29778e+02 4.46990e+01 l 2.23834e+02 5.45448e+01 lx
+6.57370e-01 3.42630e-01 0.00000e+00 s 1.95709e+02 4.57926e+01 m 2.07596e+02 4.85515e+01 l 2.14459e+02 6.09330e+01 l 2.02572e+02 4.62942e+01 lf
+0 sg 1.95709e+02 4.57926e+01 m 2.07596e+02 4.85515e+01 l 2.14459e+02 6.09330e+01 l 2.02572e+02 4.62942e+01 lx
+1.00000e+00 1.00000e+00 1.00000e+00 s 2.14459e+02 6.09330e+01 m 2.20403e+02 5.37008e+01 l 2.23834e+02 5.45448e+01 l 2.17891e+02 6.41755e+01 lf
+0 sg 2.14459e+02 6.09330e+01 m 2.20403e+02 5.37008e+01 l 2.23834e+02 5.45448e+01 l 2.17891e+02 6.41755e+01 lx
+0.00000e+00 5.73617e-01 4.26383e-01 s 1.76959e+02 4.23194e+01 m 1.88846e+02 4.12288e+01 l 1.95709e+02 4.57926e+01 l 1.83822e+02 4.26109e+01 lf
+0 sg 1.76959e+02 4.23194e+01 m 1.88846e+02 4.12288e+01 l 1.95709e+02 4.57926e+01 l 1.83822e+02 4.26109e+01 lx
+4.71924e-01 5.28076e-01 0.00000e+00 s 2.16971e+02 5.00400e+01 m 2.22915e+02 4.02413e+01 l 2.26346e+02 4.30262e+01 l 2.20403e+02 5.37008e+01 lf
+0 sg 2.16971e+02 5.00400e+01 m 2.22915e+02 4.02413e+01 l 2.26346e+02 4.30262e+01 l 2.20403e+02 5.37008e+01 lx
+1.00000e+00 8.86431e-01 8.86431e-01 s 2.11028e+02 5.47422e+01 m 2.16971e+02 5.00400e+01 l 2.20403e+02 5.37008e+01 l 2.14459e+02 6.09330e+01 lf
+0 sg 2.11028e+02 5.47422e+01 m 2.16971e+02 5.00400e+01 l 2.20403e+02 5.37008e+01 l 2.14459e+02 6.09330e+01 lx
+3.39452e-01 6.60548e-01 0.00000e+00 s 4.75481e+01 4.11779e+01 m 7.13221e+01 3.43149e+01 l 8.50481e+01 5.17564e+01 l 6.12740e+01 5.44942e+01 lf
+0 sg 4.75481e+01 4.11779e+01 m 7.13221e+01 3.43149e+01 l 8.50481e+01 5.17564e+01 l 6.12740e+01 5.44942e+01 lx
+0.00000e+00 9.08588e-01 9.14116e-02 s 1.08822e+02 4.27756e+01 m 1.32596e+02 3.73468e+01 l 1.46322e+02 3.84650e+01 l 1.22548e+02 4.80192e+01 lf
+0 sg 1.08822e+02 4.27756e+01 m 1.32596e+02 3.73468e+01 l 1.46322e+02 3.84650e+01 l 1.22548e+02 4.80192e+01 lx
+1.00000e+00 2.66728e-01 2.66728e-01 s 2.07596e+02 4.85515e+01 m 2.13540e+02 4.30040e+01 l 2.16971e+02 5.00400e+01 l 2.11028e+02 5.47422e+01 lf
+0 sg 2.07596e+02 4.85515e+01 m 2.13540e+02 4.30040e+01 l 2.16971e+02 5.00400e+01 l 2.11028e+02 5.47422e+01 lx
+2.29402e-01 7.70598e-01 0.00000e+00 s 2.13540e+02 4.30040e+01 m 2.19483e+02 3.74564e+01 l 2.22915e+02 4.02413e+01 l 2.16971e+02 5.00400e+01 lf
+0 sg 2.13540e+02 4.30040e+01 m 2.19483e+02 3.74564e+01 l 2.22915e+02 4.02413e+01 l 2.16971e+02 5.00400e+01 lx
+0.00000e+00 7.50838e-01 2.49162e-01 s 2.19483e+02 3.74564e+01 m 2.31370e+02 3.56611e+01 l 2.38233e+02 4.16046e+01 l 2.26346e+02 4.30262e+01 lf
+0 sg 2.19483e+02 3.74564e+01 m 2.31370e+02 3.56611e+01 l 2.38233e+02 4.16046e+01 l 2.26346e+02 4.30262e+01 lx
+5.16610e-01 4.83390e-01 0.00000e+00 s 1.88846e+02 4.12288e+01 m 2.00733e+02 3.96823e+01 l 2.07596e+02 4.85515e+01 l 1.95709e+02 4.57926e+01 lf
+0 sg 1.88846e+02 4.12288e+01 m 2.00733e+02 3.96823e+01 l 2.07596e+02 4.85515e+01 l 1.95709e+02 4.57926e+01 lx
+3.49354e-01 6.50646e-01 0.00000e+00 s 1.70096e+02 4.20280e+01 m 1.81983e+02 3.66106e+01 l 1.88846e+02 4.12288e+01 l 1.76959e+02 4.23194e+01 lf
+0 sg 1.70096e+02 4.20280e+01 m 1.81983e+02 3.66106e+01 l 1.88846e+02 4.12288e+01 l 1.76959e+02 4.23194e+01 lx
+2.84920e-01 7.15080e-01 0.00000e+00 s 2.00733e+02 3.96823e+01 m 2.12620e+02 3.16549e+01 l 2.19483e+02 3.74564e+01 l 2.07596e+02 4.85515e+01 lf
+0 sg 2.00733e+02 3.96823e+01 m 2.12620e+02 3.16549e+01 l 2.19483e+02 3.74564e+01 l 2.07596e+02 4.85515e+01 lx
+4.50609e-01 5.49391e-01 0.00000e+00 s 7.13221e+01 3.43149e+01 m 9.50962e+01 2.74519e+01 l 1.08822e+02 4.27756e+01 l 8.50481e+01 5.17564e+01 lf
+0 sg 7.13221e+01 3.43149e+01 m 9.50962e+01 2.74519e+01 l 1.08822e+02 4.27756e+01 l 8.50481e+01 5.17564e+01 lx
+3.63425e-01 6.36575e-01 0.00000e+00 s 1.81983e+02 3.66106e+01 m 1.93870e+02 3.11932e+01 l 2.00733e+02 3.96823e+01 l 1.88846e+02 4.12288e+01 lf
+0 sg 1.81983e+02 3.66106e+01 m 1.93870e+02 3.11932e+01 l 2.00733e+02 3.96823e+01 l 1.88846e+02 4.12288e+01 lx
+0.00000e+00 7.79395e-01 2.20605e-01 s 2.12620e+02 3.16549e+01 m 2.24507e+02 2.97176e+01 l 2.31370e+02 3.56611e+01 l 2.19483e+02 3.74564e+01 lf
+0 sg 2.12620e+02 3.16549e+01 m 2.24507e+02 2.97176e+01 l 2.31370e+02 3.56611e+01 l 2.19483e+02 3.74564e+01 lx
+2.08518e-01 7.91481e-01 0.00000e+00 s 1.32596e+02 3.73468e+01 m 1.56370e+02 2.67314e+01 l 1.70096e+02 4.20280e+01 l 1.46322e+02 3.84650e+01 lf
+0 sg 1.32596e+02 3.73468e+01 m 1.56370e+02 2.67314e+01 l 1.70096e+02 4.20280e+01 l 1.46322e+02 3.84650e+01 lx
+8.79503e-02 9.12050e-01 0.00000e+00 s 1.93870e+02 3.11932e+01 m 2.05757e+02 2.74836e+01 l 2.12620e+02 3.16549e+01 l 2.00733e+02 3.96823e+01 lf
+0 sg 1.93870e+02 3.11932e+01 m 2.05757e+02 2.74836e+01 l 2.12620e+02 3.16549e+01 l 2.00733e+02 3.96823e+01 lx
+4.12753e-01 5.87247e-01 0.00000e+00 s 9.50962e+01 2.74519e+01 m 1.18870e+02 2.05889e+01 l 1.32596e+02 3.73468e+01 l 1.08822e+02 4.27756e+01 lf
+0 sg 9.50962e+01 2.74519e+01 m 1.18870e+02 2.05889e+01 l 1.32596e+02 3.73468e+01 l 1.08822e+02 4.27756e+01 lx
+0.00000e+00 8.85395e-01 1.14605e-01 s 2.05757e+02 2.74836e+01 m 2.17644e+02 2.37740e+01 l 2.24507e+02 2.97176e+01 l 2.12620e+02 3.16549e+01 lf
+0 sg 2.05757e+02 2.74836e+01 m 2.17644e+02 2.37740e+01 l 2.24507e+02 2.97176e+01 l 2.12620e+02 3.16549e+01 lx
+2.53540e-01 7.46460e-01 0.00000e+00 s 1.56370e+02 2.67314e+01 m 1.80144e+02 1.79798e+01 l 1.93870e+02 3.11932e+01 l 1.70096e+02 4.20280e+01 lf
+0 sg 1.56370e+02 2.67314e+01 m 1.80144e+02 1.79798e+01 l 1.93870e+02 3.11932e+01 l 1.70096e+02 4.20280e+01 lx
+2.84382e-01 7.15618e-01 0.00000e+00 s 1.18870e+02 2.05889e+01 m 1.42644e+02 1.37260e+01 l 1.56370e+02 2.67314e+01 l 1.32596e+02 3.73468e+01 lf
+0 sg 1.18870e+02 2.05889e+01 m 1.42644e+02 1.37260e+01 l 1.56370e+02 2.67314e+01 l 1.32596e+02 3.73468e+01 lx
+0.00000e+00 9.40879e-01 5.91214e-02 s 1.80144e+02 1.79798e+01 m 2.03918e+02 1.18870e+01 l 2.17644e+02 2.37740e+01 l 1.93870e+02 3.11932e+01 lf
+0 sg 1.80144e+02 1.79798e+01 m 2.03918e+02 1.18870e+01 l 2.17644e+02 2.37740e+01 l 1.93870e+02 3.11932e+01 lx
+0.00000e+00 9.72014e-01 2.79859e-02 s 1.42644e+02 1.37260e+01 m 1.66418e+02 6.86298e+00 l 1.80144e+02 1.79798e+01 l 1.56370e+02 2.67314e+01 lf
+0 sg 1.42644e+02 1.37260e+01 m 1.66418e+02 6.86298e+00 l 1.80144e+02 1.79798e+01 l 1.56370e+02 2.67314e+01 lx
+0.00000e+00 9.10083e-01 8.99171e-02 s 1.66418e+02 6.86298e+00 m 1.90192e+02 0.00000e+00 l 2.03918e+02 1.18870e+01 l 1.80144e+02 1.79798e+01 lf
+0 sg 1.66418e+02 6.86298e+00 m 1.90192e+02 0.00000e+00 l 2.03918e+02 1.18870e+01 l 1.80144e+02 1.79798e+01 lx
+showpage
+.
+
+  Collecting refinement data: 
+    Refining each time step separately.
+    Got 4766 presently, expecting 7151 for next sweep.
+    Writing statistics for whole sweep.#  Description of fields
+#  =====================
+#  General:
+#    time
+#  Primal problem:
+#    number of active cells
+#    number of degrees of freedom
+#    iterations for the helmholtz equation
+#    iterations for the projection equation
+#    elastic energy
+#    kinetic energy
+#    total energy
+#  Dual problem:
+#    number of active cells
+#    number of degrees of freedom
+#    iterations for the helmholtz equation
+#    iterations for the projection equation
+#    elastic energy
+#    kinetic energy
+#    total energy
+#  Error estimation:
+#    total estimated error in this timestep
+#  Postprocessing:
+#    Huyghens wave
+
+
+0.0000e+00      163    201   0   0 0.0000e+00 0.0000e+00 0.000000e+00       163    769   8   8 6.4764e-05 6.3423e-05 1.281876e-04    0.0000e+00    -3.2238e-07 
+2.8000e-02      169    208   8  11 9.2458e-01 1.3333e+00 2.257925e+00       169    797   8   9 6.4792e-05 6.6003e-05 1.307951e-04    5.3913e-07    -7.2565e-07 
+5.6000e-02      202    242   8  11 5.9737e-01 1.6605e+00 2.257904e+00       202    933   8   9 6.6438e-05 6.7096e-05 1.335338e-04    9.2420e-09    1.5267e-07 
+8.4000e-02      205    245   8  12 1.2941e+00 9.6378e-01 2.257902e+00       205    945   9   9 6.8484e-05 6.5051e-05 1.335342e-04    1.6502e-06    2.4656e-06 
+1.1200e-01      202    243   8  11 1.1197e+00 1.1398e+00 2.259523e+00       202    935   9   9 6.7807e-05 7.0039e-05 1.378456e-04    7.2516e-07    1.0243e-05 
+1.4000e-01      220    262   8  11 1.1877e+00 1.0718e+00 2.259525e+00       220   1011  10   9 8.0641e-05 8.3222e-05 1.638631e-04    1.1753e-06    2.1839e-05 
+1.6800e-01      238    282   8  11 1.0639e+00 1.1966e+00 2.260513e+00       238   1091  11   9 9.1403e-05 8.2735e-05 1.741382e-04    -2.1311e-07    1.8134e-05 
+1.9600e-01      250    296   8  11 9.3418e-01 1.1144e+00 2.048580e+00       250   1143  11   9 1.1254e-04 1.0298e-04 2.155124e-04    1.3103e-06    -6.3262e-06 
+2.2400e-01      226    270   8  11 8.9621e-01 7.6374e-01 1.659950e+00       226   1041   9   9 1.0326e-04 1.1424e-04 2.174995e-04    9.4038e-07    -4.7214e-05 
+2.5200e-01      268    317   8  11 8.9940e-01 7.6979e-01 1.669186e+00       268   1224  10   9 1.1181e-04 1.2451e-04 2.363150e-04    -8.0735e-07    -9.0329e-05 
+2.8000e-01      265    313   8  11 8.0109e-01 7.4786e-01 1.548953e+00       265   1207  10   9 1.1012e-04 1.2702e-04 2.371417e-04    1.2728e-06    -3.3904e-05 
+3.0800e-01      241    283   8  12 6.2420e-01 7.8082e-01 1.405017e+00       241   1087  10   9 1.0390e-04 1.3329e-04 2.371967e-04    -5.0338e-08    2.0875e-04 
+3.3600e-01      226    266   8  13 6.2657e-01 5.9963e-01 1.226201e+00       226   1019  10  10 1.2108e-04 1.1611e-04 2.371943e-04    2.4444e-06    3.8150e-04 
+3.6400e-01      202    241   8  12 5.4195e-01 4.9977e-01 1.041721e+00       202    920   9   9 1.2147e-04 1.1594e-04 2.374096e-04    6.7017e-07    -1.0966e-04 
+3.9200e-01      193    231   8  12 4.6651e-01 4.9917e-01 9.656805e-01       193    879   8   9 1.3520e-04 1.0221e-04 2.374062e-04    1.0765e-06    -1.2493e-03 
+4.2000e-01      190    228   8  12 4.6215e-01 5.0230e-01 9.644502e-01       190    867   8   9 1.3949e-04 9.7915e-05 2.374062e-04    -1.6374e-08    -1.5319e-03 
+4.4800e-01      166    201   9  11 5.1612e-01 3.8528e-01 9.013997e-01       166    761   7   9 1.3088e-04 1.0652e-04 2.374043e-04    -3.3323e-06    8.7543e-04 
+4.7600e-01      154    189   8  12 3.8463e-01 4.1062e-01 7.952531e-01       154    713   7   9 1.1146e-04 1.2595e-04 2.374043e-04    7.4942e-07    5.1159e-03 
+5.0400e-01      148    181   8  12 3.5074e-01 4.1000e-01 7.607330e-01       148    681   6   9 1.6599e-04 7.1417e-05 2.374043e-04    -2.1817e-06    7.0168e-03 
+5.3200e-01      145    178   8  12 3.8060e-01 3.7380e-01 7.544022e-01       145    669   6   9 1.2699e-04 6.9697e-05 1.966915e-04    4.7203e-06    2.2599e-03 
+5.6000e-01      130    163   8  11 3.8988e-01 3.4268e-01 7.325648e-01       130    611   5   9 1.7342e-04 7.8696e-05 2.521153e-04    2.3587e-06    -6.8476e-03 
+5.8800e-01      124    155   8  11 3.6655e-01 3.5446e-01 7.210062e-01       124    579   4   9 1.6585e-04 6.9577e-05 2.354260e-04    3.6707e-06    -9.2850e-03 
+6.1600e-01      112    141   8  11 3.1667e-01 3.8417e-01 7.008428e-01       112    526   4   8 1.0014e-04 5.8112e-05 1.582569e-04    3.9034e-06    1.3295e-02 
+6.4400e-01      106    137   9  10 3.4924e-01 3.1232e-01 6.615640e-01       106    510   5   9 1.9831e-04 6.7079e-05 2.653885e-04    -4.3174e-06    6.8384e-02 
+6.7200e-01      112    143   9  11 3.5576e-01 3.0580e-01 6.615640e-01       112    534   5   9 1.1692e-04 6.9148e-05 1.860672e-04    -1.2396e-05    1.2351e-01 
+7.0000e-01      109    138   9  11 3.0569e-01 3.5398e-01 6.596694e-01       109    514   0   0 0.0000e+00 0.0000e+00 0.000000e+00    -6.0693e-06    9.4704e-02 
+
+    Writing summary.Summary of this sweep:
+======================
+
+  Accumulated number of cells: 4766
+  Acc. number of primal dofs : 11508
+  Acc. number of dual dofs   : 43932
+  Accumulated error          : -2.1676e-06
+
+  Evaluations:
+  ------------
+    Hughens wave -- weighted time: 6.5885e-01
+                    average      : 5.5533e-03
+  Time tag: 1999/8/12 17:51:08
+
+
+
+Sweep  2:
+---------
+  Primal problem: time=0.0000e+00, step=   0, sweep= 2. 169 cells, 211 dofs.
+  Primal problem: time=2.8000e-02, step=   1, sweep= 2. 211 cells, 257 dofs.
+  Primal problem: time=5.6000e-02, step=   2, sweep= 2. 310 cells, 366 dofs.
+  Primal problem: time=8.4000e-02, step=   3, sweep= 2. 367 cells, 429 dofs.
+  Primal problem: time=1.1200e-01, step=   4, sweep= 2. 439 cells, 504 dofs.
+  Primal problem: time=1.4000e-01, step=   5, sweep= 2. 487 cells, 554 dofs.
+  Primal problem: time=1.6800e-01, step=   6, sweep= 2. 502 cells, 573 dofs.
+  Primal problem: time=1.9600e-01, step=   7, sweep= 2. 484 cells, 552 dofs.
+  Primal problem: time=2.2400e-01, step=   8, sweep= 2. 508 cells, 576 dofs.
+  Primal problem: time=2.5200e-01, step=   9, sweep= 2. 550 cells, 624 dofs.
+  Primal problem: time=2.8000e-01, step=  10, sweep= 2. 550 cells, 625 dofs.
+  Primal problem: time=3.0800e-01, step=  11, sweep= 2. 517 cells, 585 dofs.
+  Primal problem: time=3.3600e-01, step=  12, sweep= 2. 493 cells, 560 dofs.
+  Primal problem: time=3.6400e-01, step=  13, sweep= 2. 487 cells, 552 dofs.
+  Primal problem: time=3.9200e-01, step=  14, sweep= 2. 457 cells, 518 dofs.
+  Primal problem: time=4.2000e-01, step=  15, sweep= 2. 400 cells, 460 dofs.
+  Primal problem: time=4.4800e-01, step=  16, sweep= 2. 337 cells, 393 dofs.
+  Primal problem: time=4.7600e-01, step=  17, sweep= 2. 301 cells, 352 dofs.
+  Primal problem: time=5.0400e-01, step=  18, sweep= 2. 286 cells, 335 dofs.
+  Primal problem: time=5.3200e-01, step=  19, sweep= 2. 223 cells, 267 dofs.
+  Primal problem: time=5.6000e-01, step=  20, sweep= 2. 199 cells, 242 dofs.
+  Primal problem: time=5.8800e-01, step=  21, sweep= 2. 181 cells, 221 dofs.
+  Primal problem: time=6.1600e-01, step=  22, sweep= 2. 154 cells, 192 dofs.
+  Primal problem: time=6.4400e-01, step=  23, sweep= 2. 121 cells, 157 dofs.
+  Primal problem: time=6.7200e-01, step=  24, sweep= 2. 124 cells, 160 dofs.
+  Primal problem: time=7.0000e-01, step=  25, sweep= 2. 115 cells, 149 dofs.
+
+  Dual problem: time=7.0000e-01, step=  25, sweep= 2. 115 cells, 567 dofs.
+  Dual problem: time=6.7200e-01, step=  24, sweep= 2. 124 cells, 608 dofs.
+  Dual problem: time=6.4400e-01, step=  23, sweep= 2. 121 cells, 599 dofs.
+  Dual problem: time=6.1600e-01, step=  22, sweep= 2. 154 cells, 734 dofs.
+  Dual problem: time=5.8800e-01, step=  21, sweep= 2. 181 cells, 850 dofs.
+  Dual problem: time=5.6000e-01, step=  20, sweep= 2. 199 cells, 934 dofs.
+  Dual problem: time=5.3200e-01, step=  19, sweep= 2. 223 cells, 1034 dofs.
+  Dual problem: time=5.0400e-01, step=  18, sweep= 2. 286 cells, 1303 dofs.
+  Dual problem: time=4.7600e-01, step=  17, sweep= 2. 301 cells, 1371 dofs.
+  Dual problem: time=4.4800e-01, step=  16, sweep= 2. 337 cells, 1535 dofs.
+  Dual problem: time=4.2000e-01, step=  15, sweep= 2. 400 cells, 1801 dofs.
+  Dual problem: time=3.9200e-01, step=  14, sweep= 2. 457 cells, 2032 dofs.
+  Dual problem: time=3.6400e-01, step=  13, sweep= 2. 487 cells, 2162 dofs.
+  Dual problem: time=3.3600e-01, step=  12, sweep= 2. 493 cells, 2196 dofs.
+  Dual problem: time=3.0800e-01, step=  11, sweep= 2. 517 cells, 2298 dofs.
+  Dual problem: time=2.8000e-01, step=  10, sweep= 2. 550 cells, 2455 dofs.
+  Dual problem: time=2.5200e-01, step=   9, sweep= 2. 550 cells, 2450 dofs.
+  Dual problem: time=2.2400e-01, step=   8, sweep= 2. 508 cells, 2258 dofs.
+  Dual problem: time=1.9600e-01, step=   7, sweep= 2. 484 cells, 2166 dofs.
+  Dual problem: time=1.6800e-01, step=   6, sweep= 2. 502 cells, 2250 dofs.
+  Dual problem: time=1.4000e-01, step=   5, sweep= 2. 487 cells, 2175 dofs.
+  Dual problem: time=1.1200e-01, step=   4, sweep= 2. 439 cells, 1978 dofs.
+  Dual problem: time=8.4000e-02, step=   3, sweep= 2. 367 cells, 1682 dofs.
+  Dual problem: time=5.6000e-02, step=   2, sweep= 2. 310 cells, 1433 dofs.
+  Dual problem: time=2.8000e-02, step=   1, sweep= 2. 211 cells, 1001 dofs.
+  Dual problem: time=0.0000e+00, step=   0, sweep= 2. 169 cells, 817 dofs.
+
+  Postprocessing: time=0.0000e+00, step=   0, sweep= 2. [ee][o]%!PS-Adobe-2.0 EPSF-1.2
+%%Title: deal.II Output
+%%Creator: the deal.II library
+%%Creation Date: 1999/8/12 - 17:53:10
+%%BoundingBox: 0 0 300 175
+/m {moveto} bind def
+/l {lineto} bind def
+/s {setrgbcolor} bind def
+/sg {setgray} bind def
+/lx {lineto closepath stroke} bind def
+/lf {lineto closepath fill} bind def
+%%EndProlog
+
+5.0000e-01 setlinewidth
+0.00000e+00 0.00000e+00 5.75111e-02 s 8.23557e+01 1.26226e+02 m 1.29904e+02 1.12500e+02 l 1.57356e+02 1.36274e+02 l 1.09808e+02 1.50000e+02 lf
+0 sg 8.23557e+01 1.26226e+02 m 1.29904e+02 1.12500e+02 l 1.57356e+02 1.36274e+02 l 1.09808e+02 1.50000e+02 lx
+0.00000e+00 0.00000e+00 5.75183e-02 s 1.43630e+02 1.24387e+02 m 1.67404e+02 1.17525e+02 l 1.81130e+02 1.29411e+02 l 1.57356e+02 1.36274e+02 lf
+0 sg 1.43630e+02 1.24387e+02 m 1.67404e+02 1.17525e+02 l 1.81130e+02 1.29411e+02 l 1.57356e+02 1.36274e+02 lx
+0.00000e+00 0.00000e+00 5.74681e-02 s 1.67404e+02 1.17525e+02 m 1.91178e+02 1.10657e+02 l 2.04904e+02 1.22548e+02 l 1.81130e+02 1.29411e+02 lf
+0 sg 1.67404e+02 1.17525e+02 m 1.91178e+02 1.10657e+02 l 2.04904e+02 1.22548e+02 l 1.81130e+02 1.29411e+02 lx
+0.00000e+00 0.00000e+00 5.75106e-02 s 6.86298e+01 1.14339e+02 m 9.24038e+01 1.07476e+02 l 1.06130e+02 1.19363e+02 l 8.23557e+01 1.26226e+02 lf
+0 sg 6.86298e+01 1.14339e+02 m 9.24038e+01 1.07476e+02 l 1.06130e+02 1.19363e+02 l 8.23557e+01 1.26226e+02 lx
+0.00000e+00 0.00000e+00 5.74826e-02 s 1.29904e+02 1.12500e+02 m 1.53678e+02 1.05634e+02 l 1.67404e+02 1.17525e+02 l 1.43630e+02 1.24387e+02 lf
+0 sg 1.29904e+02 1.12500e+02 m 1.53678e+02 1.05634e+02 l 1.67404e+02 1.17525e+02 l 1.43630e+02 1.24387e+02 lx
+0.00000e+00 0.00000e+00 5.74724e-02 s 1.91178e+02 1.10657e+02 m 2.14952e+02 1.03799e+02 l 2.28678e+02 1.15685e+02 l 2.04904e+02 1.22548e+02 lf
+0 sg 1.91178e+02 1.10657e+02 m 2.14952e+02 1.03799e+02 l 2.28678e+02 1.15685e+02 l 2.04904e+02 1.22548e+02 lx
+0.00000e+00 0.00000e+00 5.75057e-02 s 9.24038e+01 1.07476e+02 m 1.16178e+02 1.00612e+02 l 1.29904e+02 1.12500e+02 l 1.06130e+02 1.19363e+02 lf
+0 sg 9.24038e+01 1.07476e+02 m 1.16178e+02 1.00612e+02 l 1.29904e+02 1.12500e+02 l 1.06130e+02 1.19363e+02 lx
+0.00000e+00 0.00000e+00 5.76231e-02 s 1.53678e+02 1.05634e+02 m 1.77452e+02 9.87907e+01 l 1.91178e+02 1.10657e+02 l 1.67404e+02 1.17525e+02 lf
+0 sg 1.53678e+02 1.05634e+02 m 1.77452e+02 9.87907e+01 l 1.91178e+02 1.10657e+02 l 1.67404e+02 1.17525e+02 lx
+0.00000e+00 0.00000e+00 5.75220e-02 s 2.14952e+02 1.03799e+02 m 2.38726e+02 9.69352e+01 l 2.52452e+02 1.08822e+02 l 2.28678e+02 1.15685e+02 lf
+0 sg 2.14952e+02 1.03799e+02 m 2.38726e+02 9.69352e+01 l 2.52452e+02 1.08822e+02 l 2.28678e+02 1.15685e+02 lx
+0.00000e+00 0.00000e+00 5.75293e-02 s 5.49038e+01 1.02452e+02 m 7.86779e+01 9.55907e+01 l 9.24038e+01 1.07476e+02 l 6.86298e+01 1.14339e+02 lf
+0 sg 5.49038e+01 1.02452e+02 m 7.86779e+01 9.55907e+01 l 9.24038e+01 1.07476e+02 l 6.86298e+01 1.14339e+02 lx
+0.00000e+00 0.00000e+00 5.75107e-02 s 1.16178e+02 1.00612e+02 m 1.39952e+02 9.37541e+01 l 1.53678e+02 1.05634e+02 l 1.29904e+02 1.12500e+02 lf
+0 sg 1.16178e+02 1.00612e+02 m 1.39952e+02 9.37541e+01 l 1.53678e+02 1.05634e+02 l 1.29904e+02 1.12500e+02 lx
+0.00000e+00 0.00000e+00 5.76110e-02 s 1.77452e+02 9.87907e+01 m 2.01226e+02 9.19063e+01 l 2.14952e+02 1.03799e+02 l 1.91178e+02 1.10657e+02 lf
+0 sg 1.77452e+02 9.87907e+01 m 2.01226e+02 9.19063e+01 l 2.14952e+02 1.03799e+02 l 1.91178e+02 1.10657e+02 lx
+0.00000e+00 0.00000e+00 5.77032e-02 s 1.46815e+02 9.96939e+01 m 1.58702e+02 9.62752e+01 l 1.65565e+02 1.02212e+02 l 1.53678e+02 1.05634e+02 lf
+0 sg 1.46815e+02 9.96939e+01 m 1.58702e+02 9.62752e+01 l 1.65565e+02 1.02212e+02 l 1.53678e+02 1.05634e+02 lx
+0.00000e+00 0.00000e+00 5.74392e-02 s 7.86779e+01 9.55907e+01 m 1.02452e+02 8.87190e+01 l 1.16178e+02 1.00612e+02 l 9.24038e+01 1.07476e+02 lf
+0 sg 7.86779e+01 9.55907e+01 m 1.02452e+02 8.87190e+01 l 1.16178e+02 1.00612e+02 l 9.24038e+01 1.07476e+02 lx
+0.00000e+00 0.00000e+00 5.59696e-02 s 1.58702e+02 9.62752e+01 m 1.70589e+02 9.26623e+01 l 1.77452e+02 9.87907e+01 l 1.65565e+02 1.02212e+02 lf
+0 sg 1.58702e+02 9.62752e+01 m 1.70589e+02 9.26623e+01 l 1.77452e+02 9.87907e+01 l 1.65565e+02 1.02212e+02 lx
+0.00000e+00 0.00000e+00 5.76929e-02 s 1.09315e+02 9.46656e+01 m 1.21202e+02 9.12568e+01 l 1.28065e+02 9.71832e+01 l 1.16178e+02 1.00612e+02 lf
+0 sg 1.09315e+02 9.46656e+01 m 1.21202e+02 9.12568e+01 l 1.28065e+02 9.71832e+01 l 1.16178e+02 1.00612e+02 lx
+0.00000e+00 0.00000e+00 5.70135e-02 s 1.39952e+02 9.37541e+01 m 1.51839e+02 9.02586e+01 l 1.58702e+02 9.62752e+01 l 1.46815e+02 9.96939e+01 lf
+0 sg 1.39952e+02 9.37541e+01 m 1.51839e+02 9.02586e+01 l 1.58702e+02 9.62752e+01 l 1.46815e+02 9.96939e+01 lx
+0.00000e+00 0.00000e+00 5.74687e-02 s 2.01226e+02 9.19063e+01 m 2.25000e+02 8.50483e+01 l 2.38726e+02 9.69352e+01 l 2.14952e+02 1.03799e+02 lf
+0 sg 2.01226e+02 9.19063e+01 m 2.25000e+02 8.50483e+01 l 2.38726e+02 9.69352e+01 l 2.14952e+02 1.03799e+02 lx
+0.00000e+00 0.00000e+00 5.64489e-02 s 1.70589e+02 9.26623e+01 m 1.82476e+02 8.94540e+01 l 1.89339e+02 9.53485e+01 l 1.77452e+02 9.87907e+01 lf
+0 sg 1.70589e+02 9.26623e+01 m 1.82476e+02 8.94540e+01 l 1.89339e+02 9.53485e+01 l 1.77452e+02 9.87907e+01 lx
+0.00000e+00 0.00000e+00 5.75275e-02 s 4.11779e+01 9.05649e+01 m 6.49519e+01 8.37019e+01 l 7.86779e+01 9.55907e+01 l 5.49038e+01 1.02452e+02 lf
+0 sg 4.11779e+01 9.05649e+01 m 6.49519e+01 8.37019e+01 l 7.86779e+01 9.55907e+01 l 5.49038e+01 1.02452e+02 lx
+0.00000e+00 0.00000e+00 5.69273e-02 s 1.21202e+02 9.12568e+01 m 1.33089e+02 8.77322e+01 l 1.39952e+02 9.37541e+01 l 1.28065e+02 9.71832e+01 lf
+0 sg 1.21202e+02 9.12568e+01 m 1.33089e+02 8.77322e+01 l 1.39952e+02 9.37541e+01 l 1.28065e+02 9.71832e+01 lx
+0.00000e+00 0.00000e+00 6.26598e-02 s 1.51839e+02 9.02586e+01 m 1.63726e+02 8.75433e+01 l 1.70589e+02 9.26623e+01 l 1.58702e+02 9.62752e+01 lf
+0 sg 1.51839e+02 9.02586e+01 m 1.63726e+02 8.75433e+01 l 1.70589e+02 9.26623e+01 l 1.58702e+02 9.62752e+01 lx
+0.00000e+00 0.00000e+00 5.80039e-02 s 1.82476e+02 8.94540e+01 m 1.94363e+02 8.59540e+01 l 2.01226e+02 9.19063e+01 l 1.89339e+02 9.53485e+01 lf
+0 sg 1.82476e+02 8.94540e+01 m 1.94363e+02 8.59540e+01 l 2.01226e+02 9.19063e+01 l 1.89339e+02 9.53485e+01 lx
+0.00000e+00 0.00000e+00 5.75099e-02 s 2.25000e+02 8.50483e+01 m 2.72548e+02 7.13221e+01 l 3.00000e+02 9.50962e+01 l 2.52452e+02 1.08822e+02 lf
+0 sg 2.25000e+02 8.50483e+01 m 2.72548e+02 7.13221e+01 l 3.00000e+02 9.50962e+01 l 2.52452e+02 1.08822e+02 lx
+0.00000e+00 0.00000e+00 5.81152e-02 s 1.02452e+02 8.87190e+01 m 1.14339e+02 8.53385e+01 l 1.21202e+02 9.12568e+01 l 1.09315e+02 9.46656e+01 lf
+0 sg 1.02452e+02 8.87190e+01 m 1.14339e+02 8.53385e+01 l 1.21202e+02 9.12568e+01 l 1.09315e+02 9.46656e+01 lx
+0.00000e+00 0.00000e+00 6.07428e-02 s 1.33089e+02 8.77322e+01 m 1.44976e+02 8.47822e+01 l 1.51839e+02 9.02586e+01 l 1.39952e+02 9.37541e+01 lf
+0 sg 1.33089e+02 8.77322e+01 m 1.44976e+02 8.47822e+01 l 1.51839e+02 9.02586e+01 l 1.39952e+02 9.37541e+01 lx
+0.00000e+00 0.00000e+00 6.12105e-02 s 1.63726e+02 8.75433e+01 m 1.75613e+02 8.32297e+01 l 1.82476e+02 8.94540e+01 l 1.70589e+02 9.26623e+01 lf
+0 sg 1.63726e+02 8.75433e+01 m 1.75613e+02 8.32297e+01 l 1.82476e+02 8.94540e+01 l 1.70589e+02 9.26623e+01 lx
+0.00000e+00 0.00000e+00 5.73122e-02 s 1.94363e+02 8.59540e+01 m 2.06250e+02 8.25400e+01 l 2.13113e+02 8.84773e+01 l 2.01226e+02 9.19063e+01 lf
+0 sg 1.94363e+02 8.59540e+01 m 2.06250e+02 8.25400e+01 l 2.13113e+02 8.84773e+01 l 2.01226e+02 9.19063e+01 lx
+0.00000e+00 0.00000e+00 5.54119e-02 s 1.14339e+02 8.53385e+01 m 1.26226e+02 8.16949e+01 l 1.33089e+02 8.77322e+01 l 1.21202e+02 9.12568e+01 lf
+0 sg 1.14339e+02 8.53385e+01 m 1.26226e+02 8.16949e+01 l 1.33089e+02 8.77322e+01 l 1.21202e+02 9.12568e+01 lx
+0.00000e+00 0.00000e+00 5.74456e-02 s 6.49519e+01 8.37019e+01 m 8.87260e+01 7.68389e+01 l 1.02452e+02 8.87190e+01 l 7.86779e+01 9.55907e+01 lf
+0 sg 6.49519e+01 8.37019e+01 m 8.87260e+01 7.68389e+01 l 1.02452e+02 8.87190e+01 l 7.86779e+01 9.55907e+01 lx
+0.00000e+00 0.00000e+00 3.27717e-02 s 1.44976e+02 8.47822e+01 m 1.56863e+02 7.78213e+01 l 1.63726e+02 8.75433e+01 l 1.51839e+02 9.02586e+01 lf
+0 sg 1.44976e+02 8.47822e+01 m 1.56863e+02 7.78213e+01 l 1.63726e+02 8.75433e+01 l 1.51839e+02 9.02586e+01 lx
+0.00000e+00 0.00000e+00 5.95371e-02 s 1.29657e+02 8.47135e+01 m 1.35601e+02 8.33218e+01 l 1.39032e+02 8.62572e+01 l 1.33089e+02 8.77322e+01 lf
+0 sg 1.29657e+02 8.47135e+01 m 1.35601e+02 8.33218e+01 l 1.39032e+02 8.62572e+01 l 1.33089e+02 8.77322e+01 lx
+0.00000e+00 0.00000e+00 5.60469e-02 s 1.75613e+02 8.32297e+01 m 1.87500e+02 8.00834e+01 l 1.94363e+02 8.59540e+01 l 1.82476e+02 8.94540e+01 lf
+0 sg 1.75613e+02 8.32297e+01 m 1.87500e+02 8.00834e+01 l 1.94363e+02 8.59540e+01 l 1.82476e+02 8.94540e+01 lx
+0.00000e+00 0.00000e+00 6.19885e-02 s 1.60294e+02 8.26823e+01 m 1.66238e+02 8.29449e+01 l 1.69669e+02 8.53865e+01 l 1.63726e+02 8.75433e+01 lf
+0 sg 1.60294e+02 8.26823e+01 m 1.66238e+02 8.29449e+01 l 1.69669e+02 8.53865e+01 l 1.63726e+02 8.75433e+01 lx
+0.00000e+00 0.00000e+00 5.80442e-02 s 9.55889e+01 8.27789e+01 m 1.07476e+02 7.93634e+01 l 1.14339e+02 8.53385e+01 l 1.02452e+02 8.87190e+01 lf
+0 sg 9.55889e+01 8.27789e+01 m 1.07476e+02 7.93634e+01 l 1.14339e+02 8.53385e+01 l 1.02452e+02 8.87190e+01 lx
+0.00000e+00 0.00000e+00 5.75392e-02 s 2.06250e+02 8.25400e+01 m 2.18137e+02 7.91055e+01 l 2.25000e+02 8.50483e+01 l 2.13113e+02 8.84773e+01 lf
+0 sg 2.06250e+02 8.25400e+01 m 2.18137e+02 7.91055e+01 l 2.25000e+02 8.50483e+01 l 2.13113e+02 8.84773e+01 lx
+0.00000e+00 0.00000e+00 5.52527e-02 s 1.35601e+02 8.33218e+01 m 1.41544e+02 8.04336e+01 l 1.44976e+02 8.47822e+01 l 1.39032e+02 8.62572e+01 lf
+0 sg 1.35601e+02 8.33218e+01 m 1.41544e+02 8.04336e+01 l 1.44976e+02 8.47822e+01 l 1.39032e+02 8.62572e+01 lx
+0.00000e+00 0.00000e+00 6.58415e-02 s 1.66238e+02 8.29449e+01 m 1.72181e+02 8.04629e+01 l 1.75613e+02 8.32297e+01 l 1.69669e+02 8.53865e+01 lf
+0 sg 1.66238e+02 8.29449e+01 m 1.72181e+02 8.04629e+01 l 1.75613e+02 8.32297e+01 l 1.69669e+02 8.53865e+01 lx
+0.00000e+00 0.00000e+00 7.34271e-02 s 1.26226e+02 8.16949e+01 m 1.32169e+02 8.15972e+01 l 1.35601e+02 8.33218e+01 l 1.29657e+02 8.47135e+01 lf
+0 sg 1.26226e+02 8.16949e+01 m 1.32169e+02 8.15972e+01 l 1.35601e+02 8.33218e+01 l 1.29657e+02 8.47135e+01 lx
+0.00000e+00 0.00000e+00 0.00000e+00 s 1.56863e+02 7.78213e+01 m 1.62806e+02 7.79120e+01 l 1.66238e+02 8.29449e+01 l 1.60294e+02 8.26823e+01 lf
+0 sg 1.56863e+02 7.78213e+01 m 1.62806e+02 7.79120e+01 l 1.66238e+02 8.29449e+01 l 1.60294e+02 8.26823e+01 lx
+0.00000e+00 0.00000e+00 8.50866e-02 s 1.41544e+02 8.04336e+01 m 1.47488e+02 8.39697e+01 l 1.50919e+02 8.13017e+01 l 1.44976e+02 8.47822e+01 lf
+0 sg 1.41544e+02 8.04336e+01 m 1.47488e+02 8.39697e+01 l 1.50919e+02 8.13017e+01 l 1.44976e+02 8.47822e+01 lx
+0.00000e+00 0.00000e+00 5.79152e-02 s 1.87500e+02 8.00834e+01 m 1.99387e+02 7.65778e+01 l 2.06250e+02 8.25400e+01 l 1.94363e+02 8.59540e+01 lf
+0 sg 1.87500e+02 8.00834e+01 m 1.99387e+02 7.65778e+01 l 2.06250e+02 8.25400e+01 l 1.94363e+02 8.59540e+01 lx
+0.00000e+00 0.00000e+00 5.75081e-02 s 2.74519e+01 7.86779e+01 m 5.12260e+01 7.18150e+01 l 6.49519e+01 8.37019e+01 l 4.11779e+01 9.05649e+01 lf
+0 sg 2.74519e+01 7.86779e+01 m 5.12260e+01 7.18150e+01 l 6.49519e+01 8.37019e+01 l 4.11779e+01 9.05649e+01 lx
+0.00000e+00 0.00000e+00 1.11936e-03 s 1.32169e+02 8.15972e+01 m 1.38113e+02 7.29185e+01 l 1.41544e+02 8.04336e+01 l 1.35601e+02 8.33218e+01 lf
+0 sg 1.32169e+02 8.15972e+01 m 1.38113e+02 7.29185e+01 l 1.41544e+02 8.04336e+01 l 1.35601e+02 8.33218e+01 lx
+0.00000e+00 0.00000e+00 5.56425e-02 s 1.07476e+02 7.93634e+01 m 1.19363e+02 7.58714e+01 l 1.26226e+02 8.16949e+01 l 1.14339e+02 8.53385e+01 lf
+0 sg 1.07476e+02 7.93634e+01 m 1.19363e+02 7.58714e+01 l 1.26226e+02 8.16949e+01 l 1.14339e+02 8.53385e+01 lx
+0.00000e+00 0.00000e+00 5.27520e-02 s 1.62806e+02 7.79120e+01 m 1.68750e+02 7.76960e+01 l 1.72181e+02 8.04629e+01 l 1.66238e+02 8.29449e+01 lf
+0 sg 1.62806e+02 7.79120e+01 m 1.68750e+02 7.76960e+01 l 1.72181e+02 8.04629e+01 l 1.66238e+02 8.29449e+01 lx
+0.00000e+00 0.00000e+00 7.39728e-02 s 1.22794e+02 7.87831e+01 m 1.28738e+02 7.74120e+01 l 1.32169e+02 8.15972e+01 l 1.26226e+02 8.16949e+01 lf
+0 sg 1.22794e+02 7.87831e+01 m 1.28738e+02 7.74120e+01 l 1.32169e+02 8.15972e+01 l 1.26226e+02 8.16949e+01 lx
+0.00000e+00 0.00000e+00 5.71713e-02 s 1.68750e+02 7.76960e+01 m 1.80637e+02 7.40342e+01 l 1.87500e+02 8.00834e+01 l 1.75613e+02 8.32297e+01 lf
+0 sg 1.68750e+02 7.76960e+01 m 1.80637e+02 7.40342e+01 l 1.87500e+02 8.00834e+01 l 1.75613e+02 8.32297e+01 lx
+0.00000e+00 0.00000e+00 7.57811e-04 s 1.28738e+02 7.74120e+01 m 1.34681e+02 7.44254e+01 l 1.38113e+02 7.29185e+01 l 1.32169e+02 8.15972e+01 lf
+0 sg 1.28738e+02 7.74120e+01 m 1.34681e+02 7.44254e+01 l 1.38113e+02 7.29185e+01 l 1.32169e+02 8.15972e+01 lx
+0.00000e+00 0.00000e+00 5.76238e-02 s 8.87260e+01 7.68389e+01 m 1.00613e+02 7.34086e+01 l 1.07476e+02 7.93634e+01 l 9.55889e+01 8.27789e+01 lf
+0 sg 8.87260e+01 7.68389e+01 m 1.00613e+02 7.34086e+01 l 1.07476e+02 7.93634e+01 l 9.55889e+01 8.27789e+01 lx
+0.00000e+00 0.00000e+00 5.74089e-02 s 1.99387e+02 7.65778e+01 m 2.11274e+02 7.31626e+01 l 2.18137e+02 7.91055e+01 l 2.06250e+02 8.25400e+01 lf
+0 sg 1.99387e+02 7.65778e+01 m 2.11274e+02 7.31626e+01 l 2.18137e+02 7.91055e+01 l 2.06250e+02 8.25400e+01 lx
+0.00000e+00 0.00000e+00 4.92181e-01 s 1.47488e+02 8.39697e+01 m 1.53431e+02 1.15400e+02 l 1.56863e+02 7.78213e+01 l 1.50919e+02 8.13017e+01 lf
+0 sg 1.47488e+02 8.39697e+01 m 1.53431e+02 1.15400e+02 l 1.56863e+02 7.78213e+01 l 1.50919e+02 8.13017e+01 lx
+0.00000e+00 0.00000e+00 7.66475e-02 s 1.59375e+02 7.99700e+01 m 1.65319e+02 7.35974e+01 l 1.68750e+02 7.76960e+01 l 1.62806e+02 7.79120e+01 lf
+0 sg 1.59375e+02 7.99700e+01 m 1.65319e+02 7.35974e+01 l 1.68750e+02 7.76960e+01 l 1.62806e+02 7.79120e+01 lx
+0.00000e+00 0.00000e+00 5.97419e-02 s 1.19363e+02 7.58714e+01 m 1.25306e+02 7.43148e+01 l 1.28738e+02 7.74120e+01 l 1.22794e+02 7.87831e+01 lf
+0 sg 1.19363e+02 7.58714e+01 m 1.25306e+02 7.43148e+01 l 1.28738e+02 7.74120e+01 l 1.22794e+02 7.87831e+01 lx
+0.00000e+00 0.00000e+00 4.75501e-01 s 1.38113e+02 7.29185e+01 m 1.44056e+02 1.14719e+02 l 1.47488e+02 8.39697e+01 l 1.41544e+02 8.04336e+01 lf
+0 sg 1.38113e+02 7.29185e+01 m 1.44056e+02 1.14719e+02 l 1.47488e+02 8.39697e+01 l 1.41544e+02 8.04336e+01 lx
+0.00000e+00 0.00000e+00 5.75247e-02 s 2.11274e+02 7.31626e+01 m 2.35048e+02 6.62977e+01 l 2.48774e+02 7.81852e+01 l 2.25000e+02 8.50483e+01 lf
+0 sg 2.11274e+02 7.31626e+01 m 2.35048e+02 6.62977e+01 l 2.48774e+02 7.81852e+01 l 2.25000e+02 8.50483e+01 lx
+0.00000e+00 0.00000e+00 4.86035e-01 s 1.53431e+02 1.15400e+02 m 1.59375e+02 7.99700e+01 l 1.62806e+02 7.79120e+01 l 1.56863e+02 7.78213e+01 lf
+0 sg 1.53431e+02 1.15400e+02 m 1.59375e+02 7.99700e+01 l 1.62806e+02 7.79120e+01 l 1.56863e+02 7.78213e+01 lx
+0.00000e+00 0.00000e+00 5.75978e-02 s 1.80637e+02 7.40342e+01 m 1.92524e+02 7.06585e+01 l 1.99387e+02 7.65778e+01 l 1.87500e+02 8.00834e+01 lf
+0 sg 1.80637e+02 7.40342e+01 m 1.92524e+02 7.06585e+01 l 1.99387e+02 7.65778e+01 l 1.87500e+02 8.00834e+01 lx
+0.00000e+00 0.00000e+00 5.15115e-02 s 1.65319e+02 7.35974e+01 m 1.71262e+02 7.30010e+01 l 1.74694e+02 7.58651e+01 l 1.68750e+02 7.76960e+01 lf
+0 sg 1.65319e+02 7.35974e+01 m 1.71262e+02 7.30010e+01 l 1.74694e+02 7.58651e+01 l 1.68750e+02 7.76960e+01 lx
+0.00000e+00 0.00000e+00 5.26459e-02 s 1.25306e+02 7.43148e+01 m 1.31250e+02 7.27583e+01 l 1.34681e+02 7.44254e+01 l 1.28738e+02 7.74120e+01 lf
+0 sg 1.25306e+02 7.43148e+01 m 1.31250e+02 7.27583e+01 l 1.34681e+02 7.44254e+01 l 1.28738e+02 7.74120e+01 lx
+0.00000e+00 0.00000e+00 5.71306e-02 s 1.00613e+02 7.34086e+01 m 1.12500e+02 6.99783e+01 l 1.19363e+02 7.58714e+01 l 1.07476e+02 7.93634e+01 lf
+0 sg 1.00613e+02 7.34086e+01 m 1.12500e+02 6.99783e+01 l 1.19363e+02 7.58714e+01 l 1.07476e+02 7.93634e+01 lx
+0.00000e+00 0.00000e+00 5.75103e-02 s 5.12260e+01 7.18150e+01 m 7.50000e+01 6.49521e+01 l 8.87260e+01 7.68389e+01 l 6.49519e+01 8.37019e+01 lf
+0 sg 5.12260e+01 7.18150e+01 m 7.50000e+01 6.49521e+01 l 8.87260e+01 7.68389e+01 l 6.49519e+01 8.37019e+01 lx
+0.00000e+00 0.00000e+00 5.22612e-02 s 1.60631e+02 7.24730e+01 m 1.63603e+02 7.36015e+01 l 1.65319e+02 7.35974e+01 l 1.62347e+02 7.67837e+01 lf
+0 sg 1.60631e+02 7.24730e+01 m 1.63603e+02 7.36015e+01 l 1.65319e+02 7.35974e+01 l 1.62347e+02 7.67837e+01 lx
+0.00000e+00 0.00000e+00 5.93738e-02 s 1.71262e+02 7.30010e+01 m 1.77206e+02 7.10697e+01 l 1.80637e+02 7.40342e+01 l 1.74694e+02 7.58651e+01 lf
+0 sg 1.71262e+02 7.30010e+01 m 1.77206e+02 7.10697e+01 l 1.80637e+02 7.40342e+01 l 1.74694e+02 7.58651e+01 lx
+0.00000e+00 0.00000e+00 4.83859e-02 s 1.63603e+02 7.36015e+01 m 1.66575e+02 7.21942e+01 l 1.68290e+02 7.32992e+01 l 1.65319e+02 7.35974e+01 lf
+0 sg 1.63603e+02 7.36015e+01 m 1.66575e+02 7.21942e+01 l 1.68290e+02 7.32992e+01 l 1.65319e+02 7.35974e+01 lx
+0.00000e+00 0.00000e+00 4.78538e-01 s 1.34681e+02 7.44254e+01 m 1.40625e+02 7.83510e+01 l 1.44056e+02 1.14719e+02 l 1.38113e+02 7.29185e+01 lf
+0 sg 1.34681e+02 7.44254e+01 m 1.40625e+02 7.83510e+01 l 1.44056e+02 1.14719e+02 l 1.38113e+02 7.29185e+01 lx
+0.00000e+00 0.00000e+00 8.88988e-02 s 1.31250e+02 7.27583e+01 m 1.37194e+02 6.96180e+01 l 1.40625e+02 7.83510e+01 l 1.34681e+02 7.44254e+01 lf
+0 sg 1.31250e+02 7.27583e+01 m 1.37194e+02 6.96180e+01 l 1.40625e+02 7.83510e+01 l 1.34681e+02 7.44254e+01 lx
+0.00000e+00 0.00000e+00 6.67884e-02 s 1.58915e+02 7.47996e+01 m 1.61887e+02 7.08823e+01 l 1.63603e+02 7.36015e+01 l 1.60631e+02 7.24730e+01 lf
+0 sg 1.58915e+02 7.47996e+01 m 1.61887e+02 7.08823e+01 l 1.63603e+02 7.36015e+01 l 1.60631e+02 7.24730e+01 lx
+0.00000e+00 0.00000e+00 5.58459e-02 s 1.66575e+02 7.21942e+01 m 1.69546e+02 7.14055e+01 l 1.71262e+02 7.30010e+01 l 1.68290e+02 7.32992e+01 lf
+0 sg 1.66575e+02 7.21942e+01 m 1.69546e+02 7.14055e+01 l 1.71262e+02 7.30010e+01 l 1.68290e+02 7.32992e+01 lx
+0.00000e+00 0.00000e+00 4.66293e-01 s 1.57659e+02 1.06123e+02 m 1.60631e+02 7.24730e+01 l 1.62347e+02 7.67837e+01 l 1.59375e+02 7.99700e+01 lf
+0 sg 1.57659e+02 1.06123e+02 m 1.60631e+02 7.24730e+01 l 1.62347e+02 7.67837e+01 l 1.59375e+02 7.99700e+01 lx
+0.00000e+00 0.00000e+00 5.74418e-02 s 1.92524e+02 7.06585e+01 m 2.04411e+02 6.72157e+01 l 2.11274e+02 7.31626e+01 l 1.99387e+02 7.65778e+01 lf
+0 sg 1.92524e+02 7.06585e+01 m 2.04411e+02 6.72157e+01 l 2.11274e+02 7.31626e+01 l 1.99387e+02 7.65778e+01 lx
+0.00000e+00 0.00000e+00 5.76369e-02 s 1.61887e+02 7.08823e+01 m 1.64859e+02 7.08632e+01 l 1.66575e+02 7.21942e+01 l 1.63603e+02 7.36015e+01 lf
+0 sg 1.61887e+02 7.08823e+01 m 1.64859e+02 7.08632e+01 l 1.66575e+02 7.21942e+01 l 1.63603e+02 7.36015e+01 lx
+0.00000e+00 0.00000e+00 5.64900e-02 s 1.77206e+02 7.10697e+01 m 1.83149e+02 6.94097e+01 l 1.86581e+02 7.23464e+01 l 1.80637e+02 7.40342e+01 lf
+0 sg 1.77206e+02 7.10697e+01 m 1.83149e+02 6.94097e+01 l 1.86581e+02 7.23464e+01 l 1.80637e+02 7.40342e+01 lx
+0.00000e+00 0.00000e+00 5.96951e-02 s 1.12500e+02 6.99783e+01 m 1.24387e+02 6.65073e+01 l 1.31250e+02 7.27583e+01 l 1.19363e+02 7.58714e+01 lf
+0 sg 1.12500e+02 6.99783e+01 m 1.24387e+02 6.65073e+01 l 1.31250e+02 7.27583e+01 l 1.19363e+02 7.58714e+01 lx
+0.00000e+00 0.00000e+00 7.13554e-02 s 1.57200e+02 7.02024e+01 m 1.60171e+02 7.03198e+01 l 1.61887e+02 7.08823e+01 l 1.58915e+02 7.47996e+01 lf
+0 sg 1.57200e+02 7.02024e+01 m 1.60171e+02 7.03198e+01 l 1.61887e+02 7.08823e+01 l 1.58915e+02 7.47996e+01 lx
+0.00000e+00 0.00000e+00 5.95416e-02 s 1.64859e+02 7.08632e+01 m 1.67831e+02 6.98100e+01 l 1.69546e+02 7.14055e+01 l 1.66575e+02 7.21942e+01 lf
+0 sg 1.64859e+02 7.08632e+01 m 1.67831e+02 6.98100e+01 l 1.69546e+02 7.14055e+01 l 1.66575e+02 7.21942e+01 lx
+0.00000e+00 0.00000e+00 5.87124e-02 s 1.67831e+02 6.98100e+01 m 1.73774e+02 6.81457e+01 l 1.77206e+02 7.10697e+01 l 1.71262e+02 7.30010e+01 lf
+0 sg 1.67831e+02 6.98100e+01 m 1.73774e+02 6.81457e+01 l 1.77206e+02 7.10697e+01 l 1.71262e+02 7.30010e+01 lx
+0.00000e+00 0.00000e+00 5.30961e-02 s 1.60171e+02 7.03198e+01 m 1.63143e+02 6.91434e+01 l 1.64859e+02 7.08632e+01 l 1.61887e+02 7.08823e+01 lf
+0 sg 1.60171e+02 7.03198e+01 m 1.63143e+02 6.91434e+01 l 1.64859e+02 7.08632e+01 l 1.61887e+02 7.08823e+01 lx
+0.00000e+00 0.00000e+00 5.76299e-02 s 1.83149e+02 6.94097e+01 m 1.89093e+02 6.76800e+01 l 1.92524e+02 7.06585e+01 l 1.86581e+02 7.23464e+01 lf
+0 sg 1.83149e+02 6.94097e+01 m 1.89093e+02 6.76800e+01 l 1.92524e+02 7.06585e+01 l 1.86581e+02 7.23464e+01 lx
+0.00000e+00 0.00000e+00 3.81517e-02 s 1.55484e+02 6.80467e+01 m 1.58456e+02 6.88477e+01 l 1.60171e+02 7.03198e+01 l 1.57200e+02 7.02024e+01 lf
+0 sg 1.55484e+02 6.80467e+01 m 1.58456e+02 6.88477e+01 l 1.60171e+02 7.03198e+01 l 1.57200e+02 7.02024e+01 lx
+0.00000e+00 0.00000e+00 5.73610e-02 s 1.63143e+02 6.91434e+01 m 1.66115e+02 6.83259e+01 l 1.67831e+02 6.98100e+01 l 1.64859e+02 7.08632e+01 lf
+0 sg 1.63143e+02 6.91434e+01 m 1.66115e+02 6.83259e+01 l 1.67831e+02 6.98100e+01 l 1.64859e+02 7.08632e+01 lx
+0.00000e+00 0.00000e+00 2.46961e-03 s 1.46109e+02 6.73593e+01 m 1.49081e+02 6.82407e+01 l 1.50796e+02 6.81004e+01 l 1.47825e+02 6.56359e+01 lf
+0 sg 1.46109e+02 6.73593e+01 m 1.49081e+02 6.82407e+01 l 1.50796e+02 6.81004e+01 l 1.47825e+02 6.56359e+01 lx
+0.00000e+00 0.00000e+00 6.34929e-02 s 1.58456e+02 6.88477e+01 m 1.61427e+02 6.78448e+01 l 1.63143e+02 6.91434e+01 l 1.60171e+02 7.03198e+01 lf
+0 sg 1.58456e+02 6.88477e+01 m 1.61427e+02 6.78448e+01 l 1.63143e+02 6.91434e+01 l 1.60171e+02 7.03198e+01 lx
+0.00000e+00 0.00000e+00 1.01512e-01 s 1.50796e+02 6.81004e+01 m 1.53768e+02 6.80380e+01 l 1.55484e+02 6.80467e+01 l 1.52512e+02 7.61466e+01 lf
+0 sg 1.50796e+02 6.81004e+01 m 1.53768e+02 6.80380e+01 l 1.55484e+02 6.80467e+01 l 1.52512e+02 7.61466e+01 lx
+0.00000e+00 0.00000e+00 5.75040e-02 s 2.35048e+02 6.62977e+01 m 2.58822e+02 5.94351e+01 l 2.72548e+02 7.13221e+01 l 2.48774e+02 7.81852e+01 lf
+0 sg 2.35048e+02 6.62977e+01 m 2.58822e+02 5.94351e+01 l 2.72548e+02 7.13221e+01 l 2.48774e+02 7.81852e+01 lx
+0.00000e+00 0.00000e+00 5.73007e-02 s 1.73774e+02 6.81457e+01 m 1.79718e+02 6.64174e+01 l 1.83149e+02 6.94097e+01 l 1.77206e+02 7.10697e+01 lf
+0 sg 1.73774e+02 6.81457e+01 m 1.79718e+02 6.64174e+01 l 1.83149e+02 6.94097e+01 l 1.77206e+02 7.10697e+01 lx
+0.00000e+00 4.36344e-01 5.63656e-01 s 1.45772e+02 9.93442e+01 m 1.48744e+02 1.49165e+02 l 1.50460e+02 9.96851e+01 l 1.47488e+02 8.39697e+01 lf
+0 sg 1.45772e+02 9.93442e+01 m 1.48744e+02 1.49165e+02 l 1.50460e+02 9.96851e+01 l 1.47488e+02 8.39697e+01 lx
+0.00000e+00 0.00000e+00 1.62110e-01 s 1.43137e+02 6.64778e+01 m 1.46109e+02 6.73593e+01 l 1.47825e+02 6.56359e+01 l 1.44853e+02 8.69685e+01 lf
+0 sg 1.43137e+02 6.64778e+01 m 1.46109e+02 6.73593e+01 l 1.47825e+02 6.56359e+01 l 1.44853e+02 8.69685e+01 lx
+0.00000e+00 0.00000e+00 5.75132e-02 s 2.04411e+02 6.72157e+01 m 2.16298e+02 6.37863e+01 l 2.23161e+02 6.97302e+01 l 2.11274e+02 7.31626e+01 lf
+0 sg 2.04411e+02 6.72157e+01 m 2.16298e+02 6.37863e+01 l 2.23161e+02 6.97302e+01 l 2.11274e+02 7.31626e+01 lx
+0.00000e+00 0.00000e+00 4.81370e-01 s 1.37194e+02 6.96180e+01 m 1.43137e+02 6.64778e+01 l 1.46569e+02 1.07459e+02 l 1.40625e+02 7.83510e+01 lf
+0 sg 1.37194e+02 6.96180e+01 m 1.43137e+02 6.64778e+01 l 1.46569e+02 1.07459e+02 l 1.40625e+02 7.83510e+01 lx
+0.00000e+00 0.00000e+00 4.48749e-02 s 1.53768e+02 6.80380e+01 m 1.56740e+02 6.71166e+01 l 1.58456e+02 6.88477e+01 l 1.55484e+02 6.80467e+01 lf
+0 sg 1.53768e+02 6.80380e+01 m 1.56740e+02 6.71166e+01 l 1.58456e+02 6.88477e+01 l 1.55484e+02 6.80467e+01 lx
+0.00000e+00 0.00000e+00 5.68578e-02 s 1.61427e+02 6.78448e+01 m 1.64399e+02 6.68418e+01 l 1.66115e+02 6.83259e+01 l 1.63143e+02 6.91434e+01 lf
+0 sg 1.61427e+02 6.78448e+01 m 1.64399e+02 6.68418e+01 l 1.66115e+02 6.83259e+01 l 1.63143e+02 6.91434e+01 lx
+0.00000e+00 0.00000e+00 3.66711e-02 s 1.24387e+02 6.65073e+01 m 1.36274e+02 6.36738e+01 l 1.43137e+02 6.64778e+01 l 1.31250e+02 7.27583e+01 lf
+0 sg 1.24387e+02 6.65073e+01 m 1.36274e+02 6.36738e+01 l 1.43137e+02 6.64778e+01 l 1.31250e+02 7.27583e+01 lx
+0.00000e+00 0.00000e+00 4.60433e-01 s 1.52512e+02 7.61466e+01 m 1.55484e+02 6.80467e+01 l 1.57200e+02 7.02024e+01 l 1.54228e+02 1.02622e+02 lf
+0 sg 1.52512e+02 7.61466e+01 m 1.55484e+02 6.80467e+01 l 1.57200e+02 7.02024e+01 l 1.54228e+02 1.02622e+02 lx
+0.00000e+00 0.00000e+00 6.42003e-02 s 1.49081e+02 6.82407e+01 m 1.52052e+02 6.68131e+01 l 1.53768e+02 6.80380e+01 l 1.50796e+02 6.81004e+01 lf
+0 sg 1.49081e+02 6.82407e+01 m 1.52052e+02 6.68131e+01 l 1.53768e+02 6.80380e+01 l 1.50796e+02 6.81004e+01 lx
+0.00000e+00 0.00000e+00 9.07780e-01 s 1.55944e+02 1.13825e+02 m 1.58915e+02 7.47996e+01 l 1.60631e+02 7.24730e+01 l 1.57659e+02 1.06123e+02 lf
+0 sg 1.55944e+02 1.13825e+02 m 1.58915e+02 7.47996e+01 l 1.60631e+02 7.24730e+01 l 1.57659e+02 1.06123e+02 lx
+0.00000e+00 0.00000e+00 5.67994e-02 s 1.64399e+02 6.68418e+01 m 1.70343e+02 6.51780e+01 l 1.73774e+02 6.81457e+01 l 1.67831e+02 6.98100e+01 lf
+0 sg 1.64399e+02 6.68418e+01 m 1.70343e+02 6.51780e+01 l 1.73774e+02 6.81457e+01 l 1.67831e+02 6.98100e+01 lx
+0.00000e+00 0.00000e+00 5.75051e-02 s 7.50000e+01 6.49521e+01 m 9.87740e+01 5.80863e+01 l 1.12500e+02 6.99783e+01 l 8.87260e+01 7.68389e+01 lf
+0 sg 7.50000e+01 6.49521e+01 m 9.87740e+01 5.80863e+01 l 1.12500e+02 6.99783e+01 l 8.87260e+01 7.68389e+01 lx
+0.00000e+00 0.00000e+00 4.43428e-01 s 1.47825e+02 6.56359e+01 m 1.50796e+02 6.81004e+01 l 1.52512e+02 7.61466e+01 l 1.49540e+02 1.03166e+02 lf
+0 sg 1.47825e+02 6.56359e+01 m 1.50796e+02 6.81004e+01 l 1.52512e+02 7.61466e+01 l 1.49540e+02 1.03166e+02 lx
+0.00000e+00 0.00000e+00 5.76411e-02 s 1.79718e+02 6.64174e+01 m 1.85661e+02 6.47015e+01 l 1.89093e+02 6.76800e+01 l 1.83149e+02 6.94097e+01 lf
+0 sg 1.79718e+02 6.64174e+01 m 1.85661e+02 6.47015e+01 l 1.89093e+02 6.76800e+01 l 1.83149e+02 6.94097e+01 lx
+0.00000e+00 0.00000e+00 2.76267e-02 s 1.39706e+02 6.50758e+01 m 1.45649e+02 6.44973e+01 l 1.49081e+02 6.82407e+01 l 1.43137e+02 6.64778e+01 lf
+0 sg 1.39706e+02 6.50758e+01 m 1.45649e+02 6.44973e+01 l 1.49081e+02 6.82407e+01 l 1.43137e+02 6.64778e+01 lx
+0.00000e+00 0.00000e+00 5.94417e-02 s 1.52052e+02 6.68131e+01 m 1.55024e+02 6.53855e+01 l 1.56740e+02 6.71166e+01 l 1.53768e+02 6.80380e+01 lf
+0 sg 1.52052e+02 6.68131e+01 m 1.55024e+02 6.53855e+01 l 1.56740e+02 6.71166e+01 l 1.53768e+02 6.80380e+01 lx
+0.00000e+00 0.00000e+00 5.77910e-02 s 1.55024e+02 6.53855e+01 m 1.60968e+02 6.39613e+01 l 1.64399e+02 6.68418e+01 l 1.58456e+02 6.88477e+01 lf
+0 sg 1.55024e+02 6.53855e+01 m 1.60968e+02 6.39613e+01 l 1.64399e+02 6.68418e+01 l 1.58456e+02 6.88477e+01 lx
+0.00000e+00 0.00000e+00 9.09783e-01 s 1.54228e+02 1.02622e+02 m 1.57200e+02 7.02024e+01 l 1.58915e+02 7.47996e+01 l 1.55944e+02 1.13825e+02 lf
+0 sg 1.54228e+02 1.02622e+02 m 1.57200e+02 7.02024e+01 l 1.58915e+02 7.47996e+01 l 1.55944e+02 1.13825e+02 lx
+0.00000e+00 0.00000e+00 5.75586e-02 s 1.85661e+02 6.47015e+01 m 1.97548e+02 6.12749e+01 l 2.04411e+02 6.72157e+01 l 1.92524e+02 7.06585e+01 lf
+0 sg 1.85661e+02 6.47015e+01 m 1.97548e+02 6.12749e+01 l 2.04411e+02 6.72157e+01 l 1.92524e+02 7.06585e+01 lx
+0.00000e+00 0.00000e+00 5.77128e-02 s 1.70343e+02 6.51780e+01 m 1.76286e+02 6.34497e+01 l 1.79718e+02 6.64174e+01 l 1.73774e+02 6.81457e+01 lf
+0 sg 1.70343e+02 6.51780e+01 m 1.76286e+02 6.34497e+01 l 1.79718e+02 6.64174e+01 l 1.73774e+02 6.81457e+01 lx
+0.00000e+00 5.14574e-01 4.85426e-01 s 1.54688e+02 1.44791e+02 m 1.57659e+02 1.06123e+02 l 1.59375e+02 7.99700e+01 l 1.56403e+02 9.76852e+01 lf
+0 sg 1.54688e+02 1.44791e+02 m 1.57659e+02 1.06123e+02 l 1.59375e+02 7.99700e+01 l 1.56403e+02 9.76852e+01 lx
+0.00000e+00 0.00000e+00 5.71896e-02 s 1.05637e+02 6.40323e+01 m 1.17524e+02 6.06087e+01 l 1.24387e+02 6.65073e+01 l 1.12500e+02 6.99783e+01 lf
+0 sg 1.05637e+02 6.40323e+01 m 1.17524e+02 6.06087e+01 l 1.24387e+02 6.65073e+01 l 1.12500e+02 6.99783e+01 lx
+0.00000e+00 0.00000e+00 5.75110e-02 s 2.16298e+02 6.37863e+01 m 2.28185e+02 6.03545e+01 l 2.35048e+02 6.62977e+01 l 2.23161e+02 6.97302e+01 lf
+0 sg 2.16298e+02 6.37863e+01 m 2.28185e+02 6.03545e+01 l 2.35048e+02 6.62977e+01 l 2.23161e+02 6.97302e+01 lx
+0.00000e+00 0.00000e+00 6.65850e-02 s 1.45649e+02 6.44973e+01 m 1.51593e+02 6.26420e+01 l 1.55024e+02 6.53855e+01 l 1.49081e+02 6.82407e+01 lf
+0 sg 1.45649e+02 6.44973e+01 m 1.51593e+02 6.26420e+01 l 1.55024e+02 6.53855e+01 l 1.49081e+02 6.82407e+01 lx
+0.00000e+00 0.00000e+00 5.75737e-02 s 1.60968e+02 6.39613e+01 m 1.66911e+02 6.21736e+01 l 1.70343e+02 6.51780e+01 l 1.64399e+02 6.68418e+01 lf
+0 sg 1.60968e+02 6.39613e+01 m 1.66911e+02 6.21736e+01 l 1.70343e+02 6.51780e+01 l 1.64399e+02 6.68418e+01 lx
+0.00000e+00 4.33945e-01 5.66055e-01 s 1.40625e+02 7.83510e+01 m 1.43597e+02 9.29051e+01 l 1.45312e+02 1.46337e+02 l 1.42341e+02 9.65348e+01 lf
+0 sg 1.40625e+02 7.83510e+01 m 1.43597e+02 9.29051e+01 l 1.45312e+02 1.46337e+02 l 1.42341e+02 9.65348e+01 lx
+0.00000e+00 0.00000e+00 9.89228e-01 s 1.44853e+02 8.69685e+01 m 1.47825e+02 6.56359e+01 l 1.49540e+02 1.03166e+02 l 1.46569e+02 1.07459e+02 lf
+0 sg 1.44853e+02 8.69685e+01 m 1.47825e+02 6.56359e+01 l 1.49540e+02 1.03166e+02 l 1.46569e+02 1.07459e+02 lx
+0.00000e+00 0.00000e+00 5.74222e-02 s 1.76286e+02 6.34497e+01 m 1.82230e+02 6.17342e+01 l 1.85661e+02 6.47015e+01 l 1.79718e+02 6.64174e+01 lf
+0 sg 1.76286e+02 6.34497e+01 m 1.82230e+02 6.17342e+01 l 1.85661e+02 6.47015e+01 l 1.79718e+02 6.64174e+01 lx
+0.00000e+00 0.00000e+00 5.61986e-02 s 1.36274e+02 6.36738e+01 m 1.42218e+02 6.16050e+01 l 1.45649e+02 6.44973e+01 l 1.39706e+02 6.50758e+01 lf
+0 sg 1.36274e+02 6.36738e+01 m 1.42218e+02 6.16050e+01 l 1.45649e+02 6.44973e+01 l 1.39706e+02 6.50758e+01 lx
+0.00000e+00 0.00000e+00 5.54872e-02 s 1.51593e+02 6.26420e+01 m 1.57536e+02 6.09631e+01 l 1.60968e+02 6.39613e+01 l 1.55024e+02 6.53855e+01 lf
+0 sg 1.51593e+02 6.26420e+01 m 1.57536e+02 6.09631e+01 l 1.60968e+02 6.39613e+01 l 1.55024e+02 6.53855e+01 lx
+0.00000e+00 0.00000e+00 5.73388e-02 s 1.66911e+02 6.21736e+01 m 1.72855e+02 6.04703e+01 l 1.76286e+02 6.34497e+01 l 1.70343e+02 6.51780e+01 lf
+0 sg 1.66911e+02 6.21736e+01 m 1.72855e+02 6.04703e+01 l 1.76286e+02 6.34497e+01 l 1.70343e+02 6.51780e+01 lx
+0.00000e+00 0.00000e+00 5.74962e-02 s 1.97548e+02 6.12749e+01 m 2.09435e+02 5.78424e+01 l 2.16298e+02 6.37863e+01 l 2.04411e+02 6.72157e+01 lf
+0 sg 1.97548e+02 6.12749e+01 m 2.09435e+02 5.78424e+01 l 2.16298e+02 6.37863e+01 l 2.04411e+02 6.72157e+01 lx
+0.00000e+00 0.00000e+00 5.96025e-02 s 1.42218e+02 6.16050e+01 m 1.48161e+02 5.95362e+01 l 1.51593e+02 6.26420e+01 l 1.45649e+02 6.44973e+01 lf
+0 sg 1.42218e+02 6.16050e+01 m 1.48161e+02 5.95362e+01 l 1.51593e+02 6.26420e+01 l 1.45649e+02 6.44973e+01 lx
+0.00000e+00 0.00000e+00 6.20310e-02 s 1.17524e+02 6.06087e+01 m 1.29411e+02 5.70254e+01 l 1.36274e+02 6.36738e+01 l 1.24387e+02 6.65073e+01 lf
+0 sg 1.17524e+02 6.06087e+01 m 1.29411e+02 5.70254e+01 l 1.36274e+02 6.36738e+01 l 1.24387e+02 6.65073e+01 lx
+0.00000e+00 0.00000e+00 5.82552e-02 s 1.57536e+02 6.09631e+01 m 1.63480e+02 5.92280e+01 l 1.66911e+02 6.21736e+01 l 1.60968e+02 6.39613e+01 lf
+0 sg 1.57536e+02 6.09631e+01 m 1.63480e+02 5.92280e+01 l 1.66911e+02 6.21736e+01 l 1.60968e+02 6.39613e+01 lx
+0.00000e+00 0.00000e+00 5.74862e-02 s 1.72855e+02 6.04703e+01 m 1.78798e+02 5.87670e+01 l 1.82230e+02 6.17342e+01 l 1.76286e+02 6.34497e+01 lf
+0 sg 1.72855e+02 6.04703e+01 m 1.78798e+02 5.87670e+01 l 1.82230e+02 6.17342e+01 l 1.76286e+02 6.34497e+01 lx
+0.00000e+00 0.00000e+00 5.53189e-02 s 1.48161e+02 5.95362e+01 m 1.54105e+02 5.79092e+01 l 1.57536e+02 6.09631e+01 l 1.51593e+02 6.26420e+01 lf
+0 sg 1.48161e+02 5.95362e+01 m 1.54105e+02 5.79092e+01 l 1.57536e+02 6.09631e+01 l 1.51593e+02 6.26420e+01 lx
+0.00000e+00 6.33127e-01 3.66873e-01 s 1.49540e+02 1.03166e+02 m 1.52512e+02 7.61466e+01 l 1.54228e+02 1.02622e+02 l 1.51256e+02 1.38959e+02 lf
+0 sg 1.49540e+02 1.03166e+02 m 1.52512e+02 7.61466e+01 l 1.54228e+02 1.02622e+02 l 1.51256e+02 1.38959e+02 lx
+0.00000e+00 0.00000e+00 5.75171e-02 s 1.78798e+02 5.87670e+01 m 1.90685e+02 5.53296e+01 l 1.97548e+02 6.12749e+01 l 1.85661e+02 6.47015e+01 lf
+0 sg 1.78798e+02 5.87670e+01 m 1.90685e+02 5.53296e+01 l 1.97548e+02 6.12749e+01 l 1.85661e+02 6.47015e+01 lx
+0.00000e+00 0.00000e+00 5.75099e-02 s 0.00000e+00 5.49038e+01 m 4.75481e+01 4.11779e+01 l 7.50000e+01 6.49521e+01 l 2.74519e+01 7.86779e+01 lf
+0 sg 0.00000e+00 5.49038e+01 m 4.75481e+01 4.11779e+01 l 7.50000e+01 6.49521e+01 l 2.74519e+01 7.86779e+01 lx
+5.41745e-01 4.58255e-01 0.00000e+00 s 1.48744e+02 1.49165e+02 m 1.51716e+02 1.59163e+02 l 1.53431e+02 1.15400e+02 l 1.50460e+02 9.96851e+01 lf
+0 sg 1.48744e+02 1.49165e+02 m 1.51716e+02 1.59163e+02 l 1.53431e+02 1.15400e+02 l 1.50460e+02 9.96851e+01 lx
+0.00000e+00 0.00000e+00 5.76380e-02 s 9.87740e+01 5.80863e+01 m 1.10661e+02 5.46637e+01 l 1.17524e+02 6.06087e+01 l 1.05637e+02 6.40323e+01 lf
+0 sg 9.87740e+01 5.80863e+01 m 1.10661e+02 5.46637e+01 l 1.17524e+02 6.06087e+01 l 1.05637e+02 6.40323e+01 lx
+5.39434e-01 4.60566e-01 0.00000e+00 s 1.44056e+02 1.14719e+02 m 1.47028e+02 1.57476e+02 l 1.48744e+02 1.49165e+02 l 1.45772e+02 9.93442e+01 lf
+0 sg 1.44056e+02 1.14719e+02 m 1.47028e+02 1.57476e+02 l 1.48744e+02 1.49165e+02 l 1.45772e+02 9.93442e+01 lx
+5.07397e-01 4.92603e-01 0.00000e+00 s 1.51716e+02 1.59163e+02 m 1.54688e+02 1.44791e+02 l 1.56403e+02 9.76852e+01 l 1.53431e+02 1.15400e+02 lf
+0 sg 1.51716e+02 1.59163e+02 m 1.54688e+02 1.44791e+02 l 1.56403e+02 9.76852e+01 l 1.53431e+02 1.15400e+02 lx
+0.00000e+00 0.00000e+00 5.75088e-02 s 2.09435e+02 5.78424e+01 m 2.21322e+02 5.44112e+01 l 2.28185e+02 6.03545e+01 l 2.16298e+02 6.37863e+01 lf
+0 sg 2.09435e+02 5.78424e+01 m 2.21322e+02 5.44112e+01 l 2.28185e+02 6.03545e+01 l 2.16298e+02 6.37863e+01 lx
+0.00000e+00 0.00000e+00 5.75961e-02 s 1.54105e+02 5.79092e+01 m 1.60048e+02 5.62823e+01 l 1.63480e+02 5.92280e+01 l 1.57536e+02 6.09631e+01 lf
+0 sg 1.54105e+02 5.79092e+01 m 1.60048e+02 5.62823e+01 l 1.63480e+02 5.92280e+01 l 1.57536e+02 6.09631e+01 lx
+0.00000e+00 0.00000e+00 6.10844e-02 s 1.29411e+02 5.70254e+01 m 1.41298e+02 5.37729e+01 l 1.48161e+02 5.95362e+01 l 1.36274e+02 6.36738e+01 lf
+0 sg 1.29411e+02 5.70254e+01 m 1.41298e+02 5.37729e+01 l 1.48161e+02 5.95362e+01 l 1.36274e+02 6.36738e+01 lx
+5.43009e-01 4.56991e-01 0.00000e+00 s 1.42341e+02 9.65348e+01 m 1.45312e+02 1.46337e+02 l 1.47028e+02 1.57476e+02 l 1.44056e+02 1.14719e+02 lf
+0 sg 1.42341e+02 9.65348e+01 m 1.45312e+02 1.46337e+02 l 1.47028e+02 1.57476e+02 l 1.44056e+02 1.14719e+02 lx
+0.00000e+00 0.00000e+00 5.76121e-02 s 1.60048e+02 5.62823e+01 m 1.71935e+02 5.28101e+01 l 1.78798e+02 5.87670e+01 l 1.66911e+02 6.21736e+01 lf
+0 sg 1.60048e+02 5.62823e+01 m 1.71935e+02 5.28101e+01 l 1.78798e+02 5.87670e+01 l 1.66911e+02 6.21736e+01 lx
+0.00000e+00 0.00000e+00 5.75044e-02 s 2.21322e+02 5.44112e+01 m 2.45096e+02 4.75481e+01 l 2.58822e+02 5.94351e+01 l 2.35048e+02 6.62977e+01 lf
+0 sg 2.21322e+02 5.44112e+01 m 2.45096e+02 4.75481e+01 l 2.58822e+02 5.94351e+01 l 2.35048e+02 6.62977e+01 lx
+0.00000e+00 0.00000e+00 5.75057e-02 s 1.90685e+02 5.53296e+01 m 2.02572e+02 5.18992e+01 l 2.09435e+02 5.78424e+01 l 1.97548e+02 6.12749e+01 lf
+0 sg 1.90685e+02 5.53296e+01 m 2.02572e+02 5.18992e+01 l 2.09435e+02 5.78424e+01 l 1.97548e+02 6.12749e+01 lx
+0.00000e+00 0.00000e+00 5.61673e-02 s 1.10661e+02 5.46637e+01 m 1.22548e+02 5.12411e+01 l 1.29411e+02 5.70254e+01 l 1.17524e+02 6.06087e+01 lf
+0 sg 1.10661e+02 5.46637e+01 m 1.22548e+02 5.12411e+01 l 1.29411e+02 5.70254e+01 l 1.17524e+02 6.06087e+01 lx
+6.59727e-01 3.40273e-01 0.00000e+00 s 1.52972e+02 1.55972e+02 m 1.55944e+02 1.13825e+02 l 1.57659e+02 1.06123e+02 l 1.54688e+02 1.44791e+02 lf
+0 sg 1.52972e+02 1.55972e+02 m 1.55944e+02 1.13825e+02 l 1.57659e+02 1.06123e+02 l 1.54688e+02 1.44791e+02 lx
+5.16370e-01 4.83630e-01 0.00000e+00 s 1.43597e+02 9.29051e+01 m 1.46569e+02 1.07459e+02 l 1.48284e+02 1.56708e+02 l 1.45312e+02 1.46337e+02 lf
+0 sg 1.43597e+02 9.29051e+01 m 1.46569e+02 1.07459e+02 l 1.48284e+02 1.56708e+02 l 1.45312e+02 1.46337e+02 lx
+0.00000e+00 0.00000e+00 5.74873e-02 s 6.12740e+01 5.30650e+01 m 8.50481e+01 4.62025e+01 l 9.87740e+01 5.80863e+01 l 7.50000e+01 6.49521e+01 lf
+0 sg 6.12740e+01 5.30650e+01 m 8.50481e+01 4.62025e+01 l 9.87740e+01 5.80863e+01 l 7.50000e+01 6.49521e+01 lx
+0.00000e+00 0.00000e+00 5.65131e-02 s 1.41298e+02 5.37729e+01 m 1.53185e+02 5.02995e+01 l 1.60048e+02 5.62823e+01 l 1.48161e+02 5.95362e+01 lf
+0 sg 1.41298e+02 5.37729e+01 m 1.53185e+02 5.02995e+01 l 1.60048e+02 5.62823e+01 l 1.48161e+02 5.95362e+01 lx
+6.20146e-01 3.79854e-01 0.00000e+00 s 1.51256e+02 1.38959e+02 m 1.54228e+02 1.02622e+02 l 1.55944e+02 1.13825e+02 l 1.52972e+02 1.55972e+02 lf
+0 sg 1.51256e+02 1.38959e+02 m 1.54228e+02 1.02622e+02 l 1.55944e+02 1.13825e+02 l 1.52972e+02 1.55972e+02 lx
+5.90093e-01 4.09907e-01 0.00000e+00 s 1.46569e+02 1.07459e+02 m 1.49540e+02 1.03166e+02 l 1.51256e+02 1.38959e+02 l 1.48284e+02 1.56708e+02 lf
+0 sg 1.46569e+02 1.07459e+02 m 1.49540e+02 1.03166e+02 l 1.51256e+02 1.38959e+02 l 1.48284e+02 1.56708e+02 lx
+0.00000e+00 0.00000e+00 5.74663e-02 s 1.71935e+02 5.28101e+01 m 1.83822e+02 4.93879e+01 l 1.90685e+02 5.53296e+01 l 1.78798e+02 5.87670e+01 lf
+0 sg 1.71935e+02 5.28101e+01 m 1.83822e+02 4.93879e+01 l 1.90685e+02 5.53296e+01 l 1.78798e+02 5.87670e+01 lx
+0.00000e+00 0.00000e+00 5.75079e-02 s 2.02572e+02 5.18992e+01 m 2.14459e+02 4.84675e+01 l 2.21322e+02 5.44112e+01 l 2.09435e+02 5.78424e+01 lf
+0 sg 2.02572e+02 5.18992e+01 m 2.14459e+02 4.84675e+01 l 2.21322e+02 5.44112e+01 l 2.09435e+02 5.78424e+01 lx
+0.00000e+00 0.00000e+00 5.64765e-02 s 1.22548e+02 5.12411e+01 m 1.34435e+02 4.78001e+01 l 1.41298e+02 5.37729e+01 l 1.29411e+02 5.70254e+01 lf
+0 sg 1.22548e+02 5.12411e+01 m 1.34435e+02 4.78001e+01 l 1.41298e+02 5.37729e+01 l 1.29411e+02 5.70254e+01 lx
+0.00000e+00 0.00000e+00 5.77315e-02 s 1.53185e+02 5.02995e+01 m 1.65072e+02 4.68774e+01 l 1.71935e+02 5.28101e+01 l 1.60048e+02 5.62823e+01 lf
+0 sg 1.53185e+02 5.02995e+01 m 1.65072e+02 4.68774e+01 l 1.71935e+02 5.28101e+01 l 1.60048e+02 5.62823e+01 lx
+0.00000e+00 0.00000e+00 5.75111e-02 s 1.83822e+02 4.93879e+01 m 1.95709e+02 4.59558e+01 l 2.02572e+02 5.18992e+01 l 1.90685e+02 5.53296e+01 lf
+0 sg 1.83822e+02 4.93879e+01 m 1.95709e+02 4.59558e+01 l 2.02572e+02 5.18992e+01 l 1.90685e+02 5.53296e+01 lx
+0.00000e+00 0.00000e+00 5.78522e-02 s 1.34435e+02 4.78001e+01 m 1.46322e+02 4.43590e+01 l 1.53185e+02 5.02995e+01 l 1.41298e+02 5.37729e+01 lf
+0 sg 1.34435e+02 4.78001e+01 m 1.46322e+02 4.43590e+01 l 1.53185e+02 5.02995e+01 l 1.41298e+02 5.37729e+01 lx
+0.00000e+00 0.00000e+00 5.76167e-02 s 8.50481e+01 4.62025e+01 m 1.08822e+02 3.93352e+01 l 1.22548e+02 5.12411e+01 l 9.87740e+01 5.80863e+01 lf
+0 sg 8.50481e+01 4.62025e+01 m 1.08822e+02 3.93352e+01 l 1.22548e+02 5.12411e+01 l 9.87740e+01 5.80863e+01 lx
+0.00000e+00 0.00000e+00 5.74527e-02 s 1.65072e+02 4.68774e+01 m 1.76959e+02 4.34440e+01 l 1.83822e+02 4.93879e+01 l 1.71935e+02 5.28101e+01 lf
+0 sg 1.65072e+02 4.68774e+01 m 1.76959e+02 4.34440e+01 l 1.83822e+02 4.93879e+01 l 1.71935e+02 5.28101e+01 lx
+1.00000e+00 9.92286e-01 9.92286e-01 s 1.47028e+02 1.57476e+02 m 1.50000e+02 1.75910e+02 l 1.51716e+02 1.59163e+02 l 1.48744e+02 1.49165e+02 lf
+0 sg 1.47028e+02 1.57476e+02 m 1.50000e+02 1.75910e+02 l 1.51716e+02 1.59163e+02 l 1.48744e+02 1.49165e+02 lx
+1.00000e+00 9.63735e-01 9.63735e-01 s 1.50000e+02 1.75910e+02 m 1.52972e+02 1.55972e+02 l 1.54688e+02 1.44791e+02 l 1.51716e+02 1.59163e+02 lf
+0 sg 1.50000e+02 1.75910e+02 m 1.52972e+02 1.55972e+02 l 1.54688e+02 1.44791e+02 l 1.51716e+02 1.59163e+02 lx
+0.00000e+00 0.00000e+00 5.75086e-02 s 1.95709e+02 4.59558e+01 m 2.07596e+02 4.25238e+01 l 2.14459e+02 4.84675e+01 l 2.02572e+02 5.18992e+01 lf
+0 sg 1.95709e+02 4.59558e+01 m 2.07596e+02 4.25238e+01 l 2.14459e+02 4.84675e+01 l 2.02572e+02 5.18992e+01 lx
+1.00000e+00 1.00000e+00 1.00000e+00 s 1.45312e+02 1.46337e+02 m 1.48284e+02 1.56708e+02 l 1.50000e+02 1.75910e+02 l 1.47028e+02 1.57476e+02 lf
+0 sg 1.45312e+02 1.46337e+02 m 1.48284e+02 1.56708e+02 l 1.50000e+02 1.75910e+02 l 1.47028e+02 1.57476e+02 lx
+1.00000e+00 9.36372e-01 9.36372e-01 s 1.48284e+02 1.56708e+02 m 1.51256e+02 1.38959e+02 l 1.52972e+02 1.55972e+02 l 1.50000e+02 1.75910e+02 lf
+0 sg 1.48284e+02 1.56708e+02 m 1.51256e+02 1.38959e+02 l 1.52972e+02 1.55972e+02 l 1.50000e+02 1.75910e+02 lx
+0.00000e+00 0.00000e+00 5.73846e-02 s 1.46322e+02 4.43590e+01 m 1.58209e+02 4.09296e+01 l 1.65072e+02 4.68774e+01 l 1.53185e+02 5.02995e+01 lf
+0 sg 1.46322e+02 4.43590e+01 m 1.58209e+02 4.09296e+01 l 1.65072e+02 4.68774e+01 l 1.53185e+02 5.02995e+01 lx
+0.00000e+00 0.00000e+00 5.75061e-02 s 2.07596e+02 4.25238e+01 m 2.31370e+02 3.56611e+01 l 2.45096e+02 4.75481e+01 l 2.21322e+02 5.44112e+01 lf
+0 sg 2.07596e+02 4.25238e+01 m 2.31370e+02 3.56611e+01 l 2.45096e+02 4.75481e+01 l 2.21322e+02 5.44112e+01 lx
+0.00000e+00 0.00000e+00 5.75158e-02 s 4.75481e+01 4.11779e+01 m 7.13221e+01 3.43149e+01 l 8.50481e+01 4.62025e+01 l 6.12740e+01 5.30650e+01 lf
+0 sg 4.75481e+01 4.11779e+01 m 7.13221e+01 3.43149e+01 l 8.50481e+01 4.62025e+01 l 6.12740e+01 5.30650e+01 lx
+0.00000e+00 0.00000e+00 5.75218e-02 s 1.58209e+02 4.09296e+01 m 1.70096e+02 3.75002e+01 l 1.76959e+02 4.34440e+01 l 1.65072e+02 4.68774e+01 lf
+0 sg 1.58209e+02 4.09296e+01 m 1.70096e+02 3.75002e+01 l 1.76959e+02 4.34440e+01 l 1.65072e+02 4.68774e+01 lx
+0.00000e+00 0.00000e+00 5.76053e-02 s 1.08822e+02 3.93352e+01 m 1.32596e+02 3.24769e+01 l 1.46322e+02 4.43590e+01 l 1.22548e+02 5.12411e+01 lf
+0 sg 1.08822e+02 3.93352e+01 m 1.32596e+02 3.24769e+01 l 1.46322e+02 4.43590e+01 l 1.22548e+02 5.12411e+01 lx
+0.00000e+00 0.00000e+00 5.75182e-02 s 1.70096e+02 3.75002e+01 m 1.93870e+02 3.06371e+01 l 2.07596e+02 4.25238e+01 l 1.83822e+02 4.93879e+01 lf
+0 sg 1.70096e+02 3.75002e+01 m 1.93870e+02 3.06371e+01 l 2.07596e+02 4.25238e+01 l 1.83822e+02 4.93879e+01 lx
+0.00000e+00 0.00000e+00 5.74704e-02 s 7.13221e+01 3.43149e+01 m 9.50962e+01 2.74519e+01 l 1.08822e+02 3.93352e+01 l 8.50481e+01 4.62025e+01 lf
+0 sg 7.13221e+01 3.43149e+01 m 9.50962e+01 2.74519e+01 l 1.08822e+02 3.93352e+01 l 8.50481e+01 4.62025e+01 lx
+0.00000e+00 0.00000e+00 5.74760e-02 s 1.32596e+02 3.24769e+01 m 1.56370e+02 2.56131e+01 l 1.70096e+02 3.75002e+01 l 1.46322e+02 4.43590e+01 lf
+0 sg 1.32596e+02 3.24769e+01 m 1.56370e+02 2.56131e+01 l 1.70096e+02 3.75002e+01 l 1.46322e+02 4.43590e+01 lx
+0.00000e+00 0.00000e+00 5.75058e-02 s 1.93870e+02 3.06371e+01 m 2.17644e+02 2.37740e+01 l 2.31370e+02 3.56611e+01 l 2.07596e+02 4.25238e+01 lf
+0 sg 1.93870e+02 3.06371e+01 m 2.17644e+02 2.37740e+01 l 2.31370e+02 3.56611e+01 l 2.07596e+02 4.25238e+01 lx
+0.00000e+00 0.00000e+00 5.74742e-02 s 9.50962e+01 2.74519e+01 m 1.18870e+02 2.05889e+01 l 1.32596e+02 3.24769e+01 l 1.08822e+02 3.93352e+01 lf
+0 sg 9.50962e+01 2.74519e+01 m 1.18870e+02 2.05889e+01 l 1.32596e+02 3.24769e+01 l 1.08822e+02 3.93352e+01 lx
+0.00000e+00 0.00000e+00 5.75196e-02 s 1.18870e+02 2.05889e+01 m 1.42644e+02 1.37260e+01 l 1.56370e+02 2.56131e+01 l 1.32596e+02 3.24769e+01 lf
+0 sg 1.18870e+02 2.05889e+01 m 1.42644e+02 1.37260e+01 l 1.56370e+02 2.56131e+01 l 1.32596e+02 3.24769e+01 lx
+0.00000e+00 0.00000e+00 5.75099e-02 s 1.42644e+02 1.37260e+01 m 1.90192e+02 0.00000e+00 l 2.17644e+02 2.37740e+01 l 1.70096e+02 3.75002e+01 lf
+0 sg 1.42644e+02 1.37260e+01 m 1.90192e+02 0.00000e+00 l 2.17644e+02 2.37740e+01 l 1.70096e+02 3.75002e+01 lx
+showpage
+.
+  Postprocessing: time=2.8000e-02, step=   1, sweep= 2. [ee]
+  Postprocessing: time=5.6000e-02, step=   2, sweep= 2. [ee]
+  Postprocessing: time=8.4000e-02, step=   3, sweep= 2. [ee]
+  Postprocessing: time=1.1200e-01, step=   4, sweep= 2. [ee]
+  Postprocessing: time=1.4000e-01, step=   5, sweep= 2. [ee]
+  Postprocessing: time=1.6800e-01, step=   6, sweep= 2. [ee]
+  Postprocessing: time=1.9600e-01, step=   7, sweep= 2. [ee]
+  Postprocessing: time=2.2400e-01, step=   8, sweep= 2. [ee]
+  Postprocessing: time=2.5200e-01, step=   9, sweep= 2. [ee]
+  Postprocessing: time=2.8000e-01, step=  10, sweep= 2. [ee]
+  Postprocessing: time=3.0800e-01, step=  11, sweep= 2. [ee]
+  Postprocessing: time=3.3600e-01, step=  12, sweep= 2. [ee]
+  Postprocessing: time=3.6400e-01, step=  13, sweep= 2. [ee]
+  Postprocessing: time=3.9200e-01, step=  14, sweep= 2. [ee]
+  Postprocessing: time=4.2000e-01, step=  15, sweep= 2. [ee]
+  Postprocessing: time=4.4800e-01, step=  16, sweep= 2. [ee]
+  Postprocessing: time=4.7600e-01, step=  17, sweep= 2. [ee]
+  Postprocessing: time=5.0400e-01, step=  18, sweep= 2. [ee]
+  Postprocessing: time=5.3200e-01, step=  19, sweep= 2. [ee]
+  Postprocessing: time=5.6000e-01, step=  20, sweep= 2. [ee]
+  Postprocessing: time=5.8800e-01, step=  21, sweep= 2. [ee]
+  Postprocessing: time=6.1600e-01, step=  22, sweep= 2. [ee]
+  Postprocessing: time=6.4400e-01, step=  23, sweep= 2. [ee]
+  Postprocessing: time=6.7200e-01, step=  24, sweep= 2. [ee]
+  Postprocessing: time=7.0000e-01, step=  25, sweep= 2. [ee][o]%!PS-Adobe-2.0 EPSF-1.2
+%%Title: deal.II Output
+%%Creator: the deal.II library
+%%Creation Date: 1999/8/12 - 17:54:26
+%%BoundingBox: 0 0 300 150
+/m {moveto} bind def
+/l {lineto} bind def
+/s {setrgbcolor} bind def
+/sg {setgray} bind def
+/lx {lineto closepath stroke} bind def
+/lf {lineto closepath fill} bind def
+%%EndProlog
+
+5.0000e-01 setlinewidth
+2.50399e-01 7.49601e-01 0.00000e+00 s 8.23557e+01 1.26226e+02 m 1.29904e+02 1.12850e+02 l 1.57356e+02 1.36274e+02 l 1.09808e+02 1.50000e+02 lf
+0 sg 8.23557e+01 1.26226e+02 m 1.29904e+02 1.12850e+02 l 1.57356e+02 1.36274e+02 l 1.09808e+02 1.50000e+02 lx
+1.84477e-01 8.15523e-01 0.00000e+00 s 1.29904e+02 1.12850e+02 m 1.77452e+02 9.73956e+01 l 2.04904e+02 1.22548e+02 l 1.57356e+02 1.36274e+02 lf
+0 sg 1.29904e+02 1.12850e+02 m 1.77452e+02 9.73956e+01 l 2.04904e+02 1.22548e+02 l 1.57356e+02 1.36274e+02 lx
+0.00000e+00 9.87755e-01 1.22450e-02 s 5.49038e+01 1.02452e+02 m 1.02452e+02 8.32339e+01 l 1.29904e+02 1.12850e+02 l 8.23557e+01 1.26226e+02 lf
+0 sg 5.49038e+01 1.02452e+02 m 1.02452e+02 8.32339e+01 l 1.29904e+02 1.12850e+02 l 8.23557e+01 1.26226e+02 lx
+1.39334e-01 8.60666e-01 0.00000e+00 s 1.77452e+02 9.73956e+01 m 2.25000e+02 8.44542e+01 l 2.52452e+02 1.08822e+02 l 2.04904e+02 1.22548e+02 lf
+0 sg 1.77452e+02 9.73956e+01 m 2.25000e+02 8.44542e+01 l 2.52452e+02 1.08822e+02 l 2.04904e+02 1.22548e+02 lx
+4.31441e-02 9.56856e-01 0.00000e+00 s 1.02452e+02 8.32339e+01 m 1.50000e+02 7.75367e+01 l 1.77452e+02 9.73956e+01 l 1.29904e+02 1.12850e+02 lf
+0 sg 1.02452e+02 8.32339e+01 m 1.50000e+02 7.75367e+01 l 1.77452e+02 9.73956e+01 l 1.29904e+02 1.12850e+02 lx
+2.05256e-01 7.94744e-01 0.00000e+00 s 2.25000e+02 8.44542e+01 m 2.72548e+02 7.13221e+01 l 3.00000e+02 9.50962e+01 l 2.52452e+02 1.08822e+02 lf
+0 sg 2.25000e+02 8.44542e+01 m 2.72548e+02 7.13221e+01 l 3.00000e+02 9.50962e+01 l 2.52452e+02 1.08822e+02 lx
+1.97699e-02 9.80230e-01 0.00000e+00 s 1.63726e+02 8.74661e+01 m 1.87500e+02 7.73371e+01 l 2.01226e+02 9.09249e+01 l 1.77452e+02 9.73956e+01 lf
+0 sg 1.63726e+02 8.74661e+01 m 1.87500e+02 7.73371e+01 l 2.01226e+02 9.09249e+01 l 1.77452e+02 9.73956e+01 lx
+1.10780e-01 8.89220e-01 0.00000e+00 s 2.74519e+01 7.86779e+01 m 7.50000e+01 6.78745e+01 l 1.02452e+02 8.32339e+01 l 5.49038e+01 1.02452e+02 lf
+0 sg 2.74519e+01 7.86779e+01 m 7.50000e+01 6.78745e+01 l 1.02452e+02 8.32339e+01 l 5.49038e+01 1.02452e+02 lx
+0.00000e+00 9.60899e-01 3.91013e-02 s 1.87500e+02 7.73371e+01 m 2.11274e+02 7.17245e+01 l 2.25000e+02 8.44542e+01 l 2.01226e+02 9.09249e+01 lf
+0 sg 1.87500e+02 7.73371e+01 m 2.11274e+02 7.17245e+01 l 2.25000e+02 8.44542e+01 l 2.01226e+02 9.09249e+01 lx
+1.44068e-01 8.55932e-01 0.00000e+00 s 1.50000e+02 7.75367e+01 m 1.73774e+02 6.58348e+01 l 1.87500e+02 7.73371e+01 l 1.63726e+02 8.74661e+01 lf
+0 sg 1.50000e+02 7.75367e+01 m 1.73774e+02 6.58348e+01 l 1.87500e+02 7.73371e+01 l 1.63726e+02 8.74661e+01 lx
+3.61834e-02 9.63817e-01 0.00000e+00 s 2.11274e+02 7.17245e+01 m 2.35048e+02 6.44961e+01 l 2.48774e+02 7.78882e+01 l 2.25000e+02 8.44542e+01 lf
+0 sg 2.11274e+02 7.17245e+01 m 2.35048e+02 6.44961e+01 l 2.48774e+02 7.78882e+01 l 2.25000e+02 8.44542e+01 lx
+0.00000e+00 9.66358e-01 3.36423e-02 s 1.80637e+02 7.15860e+01 m 1.92524e+02 7.23030e+01 l 1.99387e+02 7.45308e+01 l 1.87500e+02 7.73371e+01 lf
+0 sg 1.80637e+02 7.15860e+01 m 1.92524e+02 7.23030e+01 l 1.99387e+02 7.45308e+01 l 1.87500e+02 7.73371e+01 lx
+0.00000e+00 8.80625e-01 1.19375e-01 s 1.92524e+02 7.23030e+01 m 2.04411e+02 6.16798e+01 l 2.11274e+02 7.17245e+01 l 1.99387e+02 7.45308e+01 lf
+0 sg 1.92524e+02 7.23030e+01 m 2.04411e+02 6.16798e+01 l 2.11274e+02 7.17245e+01 l 1.99387e+02 7.45308e+01 lx
+1.07804e-01 8.92196e-01 0.00000e+00 s 7.50000e+01 6.78745e+01 m 1.22548e+02 4.86270e+01 l 1.50000e+02 7.75367e+01 l 1.02452e+02 8.32339e+01 lf
+0 sg 7.50000e+01 6.78745e+01 m 1.22548e+02 4.86270e+01 l 1.50000e+02 7.75367e+01 l 1.02452e+02 8.32339e+01 lx
+0.00000e+00 9.17220e-01 8.27797e-02 s 1.73774e+02 6.58348e+01 m 1.85661e+02 6.12315e+01 l 1.92524e+02 7.23030e+01 l 1.80637e+02 7.15860e+01 lf
+0 sg 1.73774e+02 6.58348e+01 m 1.85661e+02 6.12315e+01 l 1.92524e+02 7.23030e+01 l 1.80637e+02 7.15860e+01 lx
+0.00000e+00 6.06764e-01 3.93236e-01 s 2.04411e+02 6.16798e+01 m 2.16298e+02 5.92709e+01 l 2.23161e+02 6.81103e+01 l 2.11274e+02 7.17245e+01 lf
+0 sg 2.04411e+02 6.16798e+01 m 2.16298e+02 5.92709e+01 l 2.23161e+02 6.81103e+01 l 2.11274e+02 7.17245e+01 lx
+1.33282e-01 8.66718e-01 0.00000e+00 s 2.35048e+02 6.44961e+01 m 2.58822e+02 5.94351e+01 l 2.72548e+02 7.13221e+01 l 2.48774e+02 7.78882e+01 lf
+0 sg 2.35048e+02 6.44961e+01 m 2.58822e+02 5.94351e+01 l 2.72548e+02 7.13221e+01 l 2.48774e+02 7.78882e+01 lx
+2.03744e-01 7.96256e-01 0.00000e+00 s 1.85661e+02 6.12315e+01 m 1.97548e+02 6.80064e+01 l 2.04411e+02 6.16798e+01 l 1.92524e+02 7.23030e+01 lf
+0 sg 1.85661e+02 6.12315e+01 m 1.97548e+02 6.80064e+01 l 2.04411e+02 6.16798e+01 l 1.92524e+02 7.23030e+01 lx
+0.00000e+00 8.17193e-01 1.82807e-01 s 2.16298e+02 5.92709e+01 m 2.28185e+02 5.95825e+01 l 2.35048e+02 6.44961e+01 l 2.23161e+02 6.81103e+01 lf
+0 sg 2.16298e+02 5.92709e+01 m 2.28185e+02 5.95825e+01 l 2.35048e+02 6.44961e+01 l 2.23161e+02 6.81103e+01 lx
+0.00000e+00 7.51755e-01 2.48245e-01 s 2.00980e+02 6.48431e+01 m 2.06923e+02 6.24201e+01 l 2.10355e+02 6.04753e+01 l 2.04411e+02 6.16798e+01 lf
+0 sg 2.00980e+02 6.48431e+01 m 2.06923e+02 6.24201e+01 l 2.10355e+02 6.04753e+01 l 2.04411e+02 6.16798e+01 lx
+2.48298e-01 7.51702e-01 0.00000e+00 s 1.36274e+02 6.30819e+01 m 1.60048e+02 5.63528e+01 l 1.73774e+02 6.58348e+01 l 1.50000e+02 7.75367e+01 lf
+0 sg 1.36274e+02 6.30819e+01 m 1.60048e+02 5.63528e+01 l 1.73774e+02 6.58348e+01 l 1.50000e+02 7.75367e+01 lx
+0.00000e+00 2.92971e-01 7.07029e-01 s 2.06923e+02 6.24201e+01 m 2.12867e+02 5.07956e+01 l 2.16298e+02 5.92709e+01 l 2.10355e+02 6.04753e+01 lf
+0 sg 2.06923e+02 6.24201e+01 m 2.12867e+02 5.07956e+01 l 2.16298e+02 5.92709e+01 l 2.10355e+02 6.04753e+01 lx
+0.00000e+00 9.31357e-01 6.86435e-02 s 1.66911e+02 6.10938e+01 m 1.78798e+02 5.93167e+01 l 1.85661e+02 6.12315e+01 l 1.73774e+02 6.58348e+01 lf
+0 sg 1.66911e+02 6.10938e+01 m 1.78798e+02 5.93167e+01 l 1.85661e+02 6.12315e+01 l 1.73774e+02 6.58348e+01 lx
+0.00000e+00 3.71789e-01 6.28211e-01 s 2.12867e+02 5.07956e+01 m 2.18810e+02 5.82539e+01 l 2.22242e+02 5.94267e+01 l 2.16298e+02 5.92709e+01 lf
+0 sg 2.12867e+02 5.07956e+01 m 2.18810e+02 5.82539e+01 l 2.22242e+02 5.94267e+01 l 2.16298e+02 5.92709e+01 lx
+0.00000e+00 0.00000e+00 4.34556e-01 s 2.11151e+02 4.67638e+01 m 2.14123e+02 4.88653e+01 l 2.15838e+02 5.45248e+01 l 2.12867e+02 5.07956e+01 lf
+0 sg 2.11151e+02 4.67638e+01 m 2.14123e+02 4.88653e+01 l 2.15838e+02 5.45248e+01 l 2.12867e+02 5.07956e+01 lx
+0.00000e+00 0.00000e+00 9.06796e-01 s 2.03492e+02 5.70521e+01 m 2.09435e+02 4.27319e+01 l 2.12867e+02 5.07956e+01 l 2.06923e+02 6.24201e+01 lf
+0 sg 2.03492e+02 5.70521e+01 m 2.09435e+02 4.27319e+01 l 2.12867e+02 5.07956e+01 l 2.06923e+02 6.24201e+01 lx
+0.00000e+00 0.00000e+00 0.00000e+00 s 2.09435e+02 4.27319e+01 m 2.12407e+02 4.75580e+01 l 2.14123e+02 4.88653e+01 l 2.11151e+02 4.67638e+01 lf
+0 sg 2.09435e+02 4.27319e+01 m 2.12407e+02 4.75580e+01 l 2.14123e+02 4.88653e+01 l 2.11151e+02 4.67638e+01 lx
+1.61627e-01 8.38373e-01 0.00000e+00 s 2.28185e+02 5.95825e+01 m 2.40072e+02 5.88920e+01 l 2.46935e+02 6.19656e+01 l 2.35048e+02 6.44961e+01 lf
+0 sg 2.28185e+02 5.95825e+01 m 2.40072e+02 5.88920e+01 l 2.46935e+02 6.19656e+01 l 2.35048e+02 6.44961e+01 lx
+4.59068e-01 5.40932e-01 0.00000e+00 s 1.97548e+02 6.80064e+01 m 2.03492e+02 5.70521e+01 l 2.06923e+02 6.24201e+01 l 2.00980e+02 6.48431e+01 lf
+0 sg 1.97548e+02 6.80064e+01 m 2.03492e+02 5.70521e+01 l 2.06923e+02 6.24201e+01 l 2.00980e+02 6.48431e+01 lx
+0.00000e+00 0.00000e+00 1.35710e-01 s 2.07719e+02 4.37457e+01 m 2.10691e+02 4.87776e+01 l 2.12407e+02 4.75580e+01 l 2.09435e+02 4.27319e+01 lf
+0 sg 2.07719e+02 4.37457e+01 m 2.10691e+02 4.87776e+01 l 2.12407e+02 4.75580e+01 l 2.09435e+02 4.27319e+01 lx
+5.68276e-02 9.43172e-01 0.00000e+00 s 1.78798e+02 5.93167e+01 m 1.90685e+02 4.78199e+01 l 1.97548e+02 6.80064e+01 l 1.85661e+02 6.12315e+01 lf
+0 sg 1.78798e+02 5.93167e+01 m 1.90685e+02 4.78199e+01 l 1.97548e+02 6.80064e+01 l 1.85661e+02 6.12315e+01 lx
+0.00000e+00 0.00000e+00 5.47769e-01 s 2.00060e+02 4.90617e+01 m 2.06004e+02 4.47594e+01 l 2.09435e+02 4.27319e+01 l 2.03492e+02 5.70521e+01 lf
+0 sg 2.00060e+02 4.90617e+01 m 2.06004e+02 4.47594e+01 l 2.09435e+02 4.27319e+01 l 2.03492e+02 5.70521e+01 lx
+0.00000e+00 6.04314e-01 3.95686e-01 s 2.14123e+02 4.88653e+01 m 2.17094e+02 6.03343e+01 l 2.18810e+02 5.82539e+01 l 2.15838e+02 5.45248e+01 lf
+0 sg 2.14123e+02 4.88653e+01 m 2.17094e+02 6.03343e+01 l 2.18810e+02 5.82539e+01 l 2.15838e+02 5.45248e+01 lx
+2.46476e-01 7.53524e-01 0.00000e+00 s 2.18810e+02 5.82539e+01 m 2.24754e+02 6.19113e+01 l 2.28185e+02 5.95825e+01 l 2.22242e+02 5.94267e+01 lf
+0 sg 2.18810e+02 5.82539e+01 m 2.24754e+02 6.19113e+01 l 2.28185e+02 5.95825e+01 l 2.22242e+02 5.94267e+01 lx
+3.73424e-01 6.26576e-01 0.00000e+00 s 0.00000e+00 5.49038e+01 m 4.75481e+01 4.11779e+01 l 7.50000e+01 6.78745e+01 l 2.74519e+01 7.86779e+01 lf
+0 sg 0.00000e+00 5.49038e+01 m 4.75481e+01 4.11779e+01 l 7.50000e+01 6.78745e+01 l 2.74519e+01 7.86779e+01 lx
+5.72982e-02 9.42702e-01 0.00000e+00 s 1.94117e+02 5.79132e+01 m 2.00060e+02 4.90617e+01 l 2.03492e+02 5.70521e+01 l 1.97548e+02 6.80064e+01 lf
+0 sg 1.94117e+02 5.79132e+01 m 2.00060e+02 4.90617e+01 l 2.03492e+02 5.70521e+01 l 1.97548e+02 6.80064e+01 lx
+0.00000e+00 6.49228e-01 3.50772e-01 s 2.12407e+02 4.75580e+01 m 2.15379e+02 6.02163e+01 l 2.17094e+02 6.03343e+01 l 2.14123e+02 4.88653e+01 lf
+0 sg 2.12407e+02 4.75580e+01 m 2.15379e+02 6.02163e+01 l 2.17094e+02 6.03343e+01 l 2.14123e+02 4.88653e+01 lx
+2.84725e-01 7.15275e-01 0.00000e+00 s 2.40072e+02 5.88920e+01 m 2.51959e+02 5.34916e+01 l 2.58822e+02 5.94351e+01 l 2.46935e+02 6.19656e+01 lf
+0 sg 2.40072e+02 5.88920e+01 m 2.51959e+02 5.34916e+01 l 2.58822e+02 5.94351e+01 l 2.46935e+02 6.19656e+01 lx
+5.92881e-02 9.40712e-01 0.00000e+00 s 1.60048e+02 5.63528e+01 m 1.71935e+02 4.96147e+01 l 1.78798e+02 5.93167e+01 l 1.66911e+02 6.10938e+01 lf
+0 sg 1.60048e+02 5.63528e+01 m 1.71935e+02 4.96147e+01 l 1.78798e+02 5.93167e+01 l 1.66911e+02 6.10938e+01 lx
+3.49349e-01 6.50651e-01 0.00000e+00 s 2.24754e+02 6.19113e+01 m 2.30697e+02 5.37316e+01 l 2.34129e+02 5.92372e+01 l 2.28185e+02 5.95825e+01 lf
+0 sg 2.24754e+02 6.19113e+01 m 2.30697e+02 5.37316e+01 l 2.34129e+02 5.92372e+01 l 2.28185e+02 5.95825e+01 lx
+0.00000e+00 0.00000e+00 7.37544e-01 s 2.06004e+02 4.47594e+01 m 2.08975e+02 5.21718e+01 l 2.10691e+02 4.87776e+01 l 2.07719e+02 4.37457e+01 lf
+0 sg 2.06004e+02 4.47594e+01 m 2.08975e+02 5.21718e+01 l 2.10691e+02 4.87776e+01 l 2.07719e+02 4.37457e+01 lx
+0.00000e+00 2.73064e-01 7.26936e-01 s 1.90685e+02 4.78199e+01 m 1.96629e+02 4.89527e+01 l 2.00060e+02 4.90617e+01 l 1.94117e+02 5.79132e+01 lf
+0 sg 1.90685e+02 4.78199e+01 m 1.96629e+02 4.89527e+01 l 2.00060e+02 4.90617e+01 l 1.94117e+02 5.79132e+01 lx
+7.17576e-01 2.82424e-01 0.00000e+00 s 2.17094e+02 6.03343e+01 m 2.20066e+02 6.31550e+01 l 2.21782e+02 6.00826e+01 l 2.18810e+02 5.82539e+01 lf
+0 sg 2.17094e+02 6.03343e+01 m 2.20066e+02 6.31550e+01 l 2.21782e+02 6.00826e+01 l 2.18810e+02 5.82539e+01 lx
+0.00000e+00 9.29308e-01 7.06918e-02 s 2.10691e+02 4.87776e+01 m 2.13663e+02 6.03351e+01 l 2.15379e+02 6.02163e+01 l 2.12407e+02 4.75580e+01 lf
+0 sg 2.10691e+02 4.87776e+01 m 2.13663e+02 6.03351e+01 l 2.15379e+02 6.02163e+01 l 2.12407e+02 4.75580e+01 lx
+2.14037e-01 7.85963e-01 0.00000e+00 s 2.30697e+02 5.37316e+01 m 2.36641e+02 5.29094e+01 l 2.40072e+02 5.88920e+01 l 2.34129e+02 5.92372e+01 lf
+0 sg 2.30697e+02 5.37316e+01 m 2.36641e+02 5.29094e+01 l 2.40072e+02 5.88920e+01 l 2.34129e+02 5.92372e+01 lx
+0.00000e+00 8.05625e-02 9.19437e-01 s 1.96629e+02 4.89527e+01 m 2.02572e+02 5.00854e+01 l 2.06004e+02 4.47594e+01 l 2.00060e+02 4.90617e+01 lf
+0 sg 1.96629e+02 4.89527e+01 m 2.02572e+02 5.00854e+01 l 2.06004e+02 4.47594e+01 l 2.00060e+02 4.90617e+01 lx
+9.97267e-01 2.73336e-03 0.00000e+00 s 2.20066e+02 6.31550e+01 m 2.23038e+02 5.90940e+01 l 2.24754e+02 6.19113e+01 l 2.21782e+02 6.00826e+01 lf
+0 sg 2.20066e+02 6.31550e+01 m 2.23038e+02 5.90940e+01 l 2.24754e+02 6.19113e+01 l 2.21782e+02 6.00826e+01 lx
+1.58365e-01 8.41635e-01 0.00000e+00 s 2.26010e+02 5.51343e+01 m 2.28981e+02 5.31507e+01 l 2.30697e+02 5.37316e+01 l 2.27725e+02 5.78214e+01 lf
+0 sg 2.26010e+02 5.51343e+01 m 2.28981e+02 5.31507e+01 l 2.30697e+02 5.37316e+01 l 2.27725e+02 5.78214e+01 lx
+0.00000e+00 4.36441e-01 5.63559e-01 s 1.71935e+02 4.96147e+01 m 1.83822e+02 4.28765e+01 l 1.90685e+02 4.78199e+01 l 1.78798e+02 5.93167e+01 lf
+0 sg 1.71935e+02 4.96147e+01 m 1.83822e+02 4.28765e+01 l 1.90685e+02 4.78199e+01 l 1.78798e+02 5.93167e+01 lx
+6.69663e-01 3.30337e-01 0.00000e+00 s 2.23038e+02 5.90940e+01 m 2.26010e+02 5.51343e+01 l 2.27725e+02 5.78214e+01 l 2.24754e+02 6.19113e+01 lf
+0 sg 2.23038e+02 5.90940e+01 m 2.26010e+02 5.51343e+01 l 2.27725e+02 5.78214e+01 l 2.24754e+02 6.19113e+01 lx
+0.00000e+00 9.76763e-01 2.32370e-02 s 2.28981e+02 5.31507e+01 m 2.31953e+02 5.24063e+01 l 2.33669e+02 5.33205e+01 l 2.30697e+02 5.37316e+01 lf
+0 sg 2.28981e+02 5.31507e+01 m 2.31953e+02 5.24063e+01 l 2.33669e+02 5.33205e+01 l 2.30697e+02 5.37316e+01 lx
+1.00000e+00 2.32578e-01 2.32578e-01 s 2.15379e+02 6.02163e+01 m 2.18350e+02 6.29458e+01 l 2.20066e+02 6.31550e+01 l 2.17094e+02 6.03343e+01 lf
+0 sg 2.15379e+02 6.02163e+01 m 2.18350e+02 6.29458e+01 l 2.20066e+02 6.31550e+01 l 2.17094e+02 6.03343e+01 lx
+3.18808e-01 6.81192e-01 0.00000e+00 s 2.36641e+02 5.29094e+01 m 2.42584e+02 5.21048e+01 l 2.46016e+02 5.61918e+01 l 2.40072e+02 5.88920e+01 lf
+0 sg 2.36641e+02 5.29094e+01 m 2.42584e+02 5.21048e+01 l 2.46016e+02 5.61918e+01 l 2.40072e+02 5.88920e+01 lx
+4.03948e-01 5.96052e-01 0.00000e+00 s 2.08975e+02 5.21718e+01 m 2.11947e+02 5.95841e+01 l 2.13663e+02 6.03351e+01 l 2.10691e+02 4.87776e+01 lf
+0 sg 2.08975e+02 5.21718e+01 m 2.11947e+02 5.95841e+01 l 2.13663e+02 6.03351e+01 l 2.10691e+02 4.87776e+01 lx
+4.95847e-02 9.50415e-01 0.00000e+00 s 2.31953e+02 5.24063e+01 m 2.34925e+02 5.20641e+01 l 2.36641e+02 5.29094e+01 l 2.33669e+02 5.33205e+01 lf
+0 sg 2.31953e+02 5.24063e+01 m 2.34925e+02 5.20641e+01 l 2.36641e+02 5.29094e+01 l 2.33669e+02 5.33205e+01 lx
+1.18388e-01 8.81612e-01 0.00000e+00 s 1.22548e+02 4.86270e+01 m 1.46322e+02 4.44799e+01 l 1.60048e+02 5.63528e+01 l 1.36274e+02 6.30819e+01 lf
+0 sg 1.22548e+02 4.86270e+01 m 1.46322e+02 4.44799e+01 l 1.60048e+02 5.63528e+01 l 1.36274e+02 6.30819e+01 lx
+7.14930e-01 2.85070e-01 0.00000e+00 s 2.21322e+02 5.90581e+01 m 2.24294e+02 5.56777e+01 l 2.26010e+02 5.51343e+01 l 2.23038e+02 5.90940e+01 lf
+0 sg 2.21322e+02 5.90581e+01 m 2.24294e+02 5.56777e+01 l 2.26010e+02 5.51343e+01 l 2.23038e+02 5.90940e+01 lx
+1.00000e+00 2.81973e-01 2.81973e-01 s 2.18350e+02 6.29458e+01 m 2.21322e+02 5.90581e+01 l 2.23038e+02 5.90940e+01 l 2.20066e+02 6.31550e+01 lf
+0 sg 2.18350e+02 6.29458e+01 m 2.21322e+02 5.90581e+01 l 2.23038e+02 5.90940e+01 l 2.20066e+02 6.31550e+01 lx
+3.28783e-01 6.71218e-01 0.00000e+00 s 2.24294e+02 5.56777e+01 m 2.27266e+02 5.34953e+01 l 2.28981e+02 5.31507e+01 l 2.26010e+02 5.51343e+01 lf
+0 sg 2.24294e+02 5.56777e+01 m 2.27266e+02 5.34953e+01 l 2.28981e+02 5.31507e+01 l 2.26010e+02 5.51343e+01 lx
+1.96073e-01 8.03927e-01 0.00000e+00 s 2.27266e+02 5.34953e+01 m 2.30237e+02 5.21991e+01 l 2.31953e+02 5.24063e+01 l 2.28981e+02 5.31507e+01 lf
+0 sg 2.27266e+02 5.34953e+01 m 2.30237e+02 5.21991e+01 l 2.31953e+02 5.24063e+01 l 2.28981e+02 5.31507e+01 lx
+2.74481e-01 7.25519e-01 0.00000e+00 s 2.42584e+02 5.21048e+01 m 2.48528e+02 5.05199e+01 l 2.51959e+02 5.34916e+01 l 2.46016e+02 5.61918e+01 lf
+0 sg 2.42584e+02 5.21048e+01 m 2.48528e+02 5.05199e+01 l 2.51959e+02 5.34916e+01 l 2.46016e+02 5.61918e+01 lx
+1.00000e+00 5.37833e-01 5.37833e-01 s 2.13663e+02 6.03351e+01 m 2.16635e+02 6.35937e+01 l 2.18350e+02 6.29458e+01 l 2.15379e+02 6.02163e+01 lf
+0 sg 2.13663e+02 6.03351e+01 m 2.16635e+02 6.35937e+01 l 2.18350e+02 6.29458e+01 l 2.15379e+02 6.02163e+01 lx
+3.61014e-01 6.38986e-01 0.00000e+00 s 2.02572e+02 5.00854e+01 m 2.08516e+02 5.83424e+01 l 2.11947e+02 5.95841e+01 l 2.06004e+02 4.47594e+01 lf
+0 sg 2.02572e+02 5.00854e+01 m 2.08516e+02 5.83424e+01 l 2.11947e+02 5.95841e+01 l 2.06004e+02 4.47594e+01 lx
+1.99350e-01 8.00650e-01 0.00000e+00 s 2.30237e+02 5.21991e+01 m 2.33209e+02 5.12189e+01 l 2.34925e+02 5.20641e+01 l 2.31953e+02 5.24063e+01 lf
+0 sg 2.30237e+02 5.21991e+01 m 2.33209e+02 5.12189e+01 l 2.34925e+02 5.20641e+01 l 2.31953e+02 5.24063e+01 lx
+1.00000e+00 6.51843e-02 6.51843e-02 s 2.19606e+02 5.96422e+01 m 2.22578e+02 5.59666e+01 l 2.24294e+02 5.56777e+01 l 2.21322e+02 5.90581e+01 lf
+0 sg 2.19606e+02 5.96422e+01 m 2.22578e+02 5.59666e+01 l 2.24294e+02 5.56777e+01 l 2.21322e+02 5.90581e+01 lx
+1.00000e+00 6.13407e-01 6.13407e-01 s 2.16635e+02 6.35937e+01 m 2.19606e+02 5.96422e+01 l 2.21322e+02 5.90581e+01 l 2.18350e+02 6.29458e+01 lf
+0 sg 2.16635e+02 6.35937e+01 m 2.19606e+02 5.96422e+01 l 2.21322e+02 5.90581e+01 l 2.18350e+02 6.29458e+01 lx
+0.00000e+00 6.34433e-01 3.65567e-01 s 1.83822e+02 4.28765e+01 m 1.95709e+02 4.92601e+01 l 2.02572e+02 5.00854e+01 l 1.90685e+02 4.78199e+01 lf
+0 sg 1.83822e+02 4.28765e+01 m 1.95709e+02 4.92601e+01 l 2.02572e+02 5.00854e+01 l 1.90685e+02 4.78199e+01 lx
+1.92240e-01 8.07760e-01 0.00000e+00 s 2.33209e+02 5.12189e+01 m 2.39153e+02 4.93312e+01 l 2.42584e+02 5.21048e+01 l 2.36641e+02 5.29094e+01 lf
+0 sg 2.33209e+02 5.12189e+01 m 2.39153e+02 4.93312e+01 l 2.42584e+02 5.21048e+01 l 2.36641e+02 5.29094e+01 lx
+6.79380e-01 3.20620e-01 0.00000e+00 s 2.22578e+02 5.59666e+01 m 2.25550e+02 5.37061e+01 l 2.27266e+02 5.34953e+01 l 2.24294e+02 5.56777e+01 lf
+0 sg 2.22578e+02 5.59666e+01 m 2.25550e+02 5.37061e+01 l 2.27266e+02 5.34953e+01 l 2.24294e+02 5.56777e+01 lx
+4.82246e-01 5.17754e-01 0.00000e+00 s 2.25550e+02 5.37061e+01 m 2.28522e+02 5.18915e+01 l 2.30237e+02 5.21991e+01 l 2.27266e+02 5.34953e+01 lf
+0 sg 2.25550e+02 5.37061e+01 m 2.28522e+02 5.18915e+01 l 2.30237e+02 5.21991e+01 l 2.27266e+02 5.34953e+01 lx
+1.00000e+00 8.09747e-01 8.09747e-01 s 2.11947e+02 5.95841e+01 m 2.14919e+02 6.33204e+01 l 2.16635e+02 6.35937e+01 l 2.13663e+02 6.03351e+01 lf
+0 sg 2.11947e+02 5.95841e+01 m 2.14919e+02 6.33204e+01 l 2.16635e+02 6.35937e+01 l 2.13663e+02 6.03351e+01 lx
+3.67916e-01 6.32084e-01 0.00000e+00 s 2.28522e+02 5.18915e+01 m 2.31493e+02 5.01603e+01 l 2.33209e+02 5.12189e+01 l 2.30237e+02 5.21991e+01 lf
+0 sg 2.28522e+02 5.18915e+01 m 2.31493e+02 5.01603e+01 l 2.33209e+02 5.12189e+01 l 2.30237e+02 5.21991e+01 lx
+2.30626e-01 7.69374e-01 0.00000e+00 s 2.39153e+02 4.93312e+01 m 2.45096e+02 4.75481e+01 l 2.48528e+02 5.05199e+01 l 2.42584e+02 5.21048e+01 lf
+0 sg 2.39153e+02 4.93312e+01 m 2.45096e+02 4.75481e+01 l 2.48528e+02 5.05199e+01 l 2.42584e+02 5.21048e+01 lx
+1.00000e+00 3.44783e-01 3.44783e-01 s 2.17891e+02 5.90565e+01 m 2.20862e+02 5.55824e+01 l 2.22578e+02 5.59666e+01 l 2.19606e+02 5.96422e+01 lf
+0 sg 2.17891e+02 5.90565e+01 m 2.20862e+02 5.55824e+01 l 2.22578e+02 5.59666e+01 l 2.19606e+02 5.96422e+01 lx
+8.92727e-01 1.07273e-01 0.00000e+00 s 2.20862e+02 5.55824e+01 m 2.23834e+02 5.21084e+01 l 2.25550e+02 5.37061e+01 l 2.22578e+02 5.59666e+01 lf
+0 sg 2.20862e+02 5.55824e+01 m 2.23834e+02 5.21084e+01 l 2.25550e+02 5.37061e+01 l 2.22578e+02 5.59666e+01 lx
+1.00000e+00 9.15479e-01 9.15479e-01 s 2.14919e+02 6.33204e+01 m 2.17891e+02 5.90565e+01 l 2.19606e+02 5.96422e+01 l 2.16635e+02 6.35937e+01 lf
+0 sg 2.14919e+02 6.33204e+01 m 2.17891e+02 5.90565e+01 l 2.19606e+02 5.96422e+01 l 2.16635e+02 6.35937e+01 lx
+6.23919e-01 3.76081e-01 0.00000e+00 s 2.23834e+02 5.21084e+01 m 2.26806e+02 5.06050e+01 l 2.28522e+02 5.18915e+01 l 2.25550e+02 5.37061e+01 lf
+0 sg 2.23834e+02 5.21084e+01 m 2.26806e+02 5.06050e+01 l 2.28522e+02 5.18915e+01 l 2.25550e+02 5.37061e+01 lx
+1.00000e+00 9.30621e-01 9.30621e-01 s 2.10231e+02 5.89633e+01 m 2.13203e+02 6.15496e+01 l 2.14919e+02 6.33204e+01 l 2.11947e+02 5.95841e+01 lf
+0 sg 2.10231e+02 5.89633e+01 m 2.13203e+02 6.15496e+01 l 2.14919e+02 6.33204e+01 l 2.11947e+02 5.95841e+01 lx
+4.74667e-01 5.25333e-01 0.00000e+00 s 2.26806e+02 5.06050e+01 m 2.29778e+02 4.91017e+01 l 2.31493e+02 5.01603e+01 l 2.28522e+02 5.18915e+01 lf
+0 sg 2.26806e+02 5.06050e+01 m 2.29778e+02 4.91017e+01 l 2.31493e+02 5.01603e+01 l 2.28522e+02 5.18915e+01 lx
+3.25167e-01 6.74833e-01 0.00000e+00 s 2.29778e+02 4.91017e+01 m 2.35721e+02 4.68051e+01 l 2.39153e+02 4.93312e+01 l 2.33209e+02 5.12189e+01 lf
+0 sg 2.29778e+02 4.91017e+01 m 2.35721e+02 4.68051e+01 l 2.39153e+02 4.93312e+01 l 2.33209e+02 5.12189e+01 lx
+8.62204e-01 1.37796e-01 0.00000e+00 s 1.99141e+02 4.96728e+01 m 2.05084e+02 5.32640e+01 l 2.08516e+02 5.83424e+01 l 2.02572e+02 5.00854e+01 lf
+0 sg 1.99141e+02 4.96728e+01 m 2.05084e+02 5.32640e+01 l 2.08516e+02 5.83424e+01 l 2.02572e+02 5.00854e+01 lx
+1.00000e+00 1.00000e+00 1.00000e+00 s 2.13203e+02 6.15496e+01 m 2.16175e+02 5.75102e+01 l 2.17891e+02 5.90565e+01 l 2.14919e+02 6.33204e+01 lf
+0 sg 2.13203e+02 6.15496e+01 m 2.16175e+02 5.75102e+01 l 2.17891e+02 5.90565e+01 l 2.14919e+02 6.33204e+01 lx
+1.00000e+00 8.60540e-01 8.60540e-01 s 2.08516e+02 5.83424e+01 m 2.11487e+02 5.71532e+01 l 2.13203e+02 6.15496e+01 l 2.10231e+02 5.89633e+01 lf
+0 sg 2.08516e+02 5.83424e+01 m 2.11487e+02 5.71532e+01 l 2.13203e+02 6.15496e+01 l 2.10231e+02 5.89633e+01 lx
+1.00000e+00 9.73035e-02 9.73035e-02 s 2.14459e+02 5.59639e+01 m 2.20403e+02 4.73129e+01 l 2.23834e+02 5.21084e+01 l 2.17891e+02 5.90565e+01 lf
+0 sg 2.14459e+02 5.59639e+01 m 2.20403e+02 4.73129e+01 l 2.23834e+02 5.21084e+01 l 2.17891e+02 5.90565e+01 lx
+6.82849e-02 9.31715e-01 0.00000e+00 s 1.46322e+02 4.44799e+01 m 1.70096e+02 4.03328e+01 l 1.83822e+02 4.28765e+01 l 1.60048e+02 5.63528e+01 lf
+0 sg 1.46322e+02 4.44799e+01 m 1.70096e+02 4.03328e+01 l 1.83822e+02 4.28765e+01 l 1.60048e+02 5.63528e+01 lx
+4.53036e-01 5.46964e-01 0.00000e+00 s 2.20403e+02 4.73129e+01 m 2.26346e+02 4.55837e+01 l 2.29778e+02 4.91017e+01 l 2.23834e+02 5.21084e+01 lf
+0 sg 2.20403e+02 4.73129e+01 m 2.26346e+02 4.55837e+01 l 2.29778e+02 4.91017e+01 l 2.23834e+02 5.21084e+01 lx
+2.61412e-01 7.38588e-01 0.00000e+00 s 2.35721e+02 4.68051e+01 m 2.41665e+02 4.45763e+01 l 2.45096e+02 4.75481e+01 l 2.39153e+02 4.93312e+01 lf
+0 sg 2.35721e+02 4.68051e+01 m 2.41665e+02 4.45763e+01 l 2.45096e+02 4.75481e+01 l 2.39153e+02 4.93312e+01 lx
+1.00000e+00 8.41411e-01 8.41411e-01 s 2.11487e+02 5.71532e+01 m 2.14459e+02 5.59639e+01 l 2.16175e+02 5.75102e+01 l 2.13203e+02 6.15496e+01 lf
+0 sg 2.11487e+02 5.71532e+01 m 2.14459e+02 5.59639e+01 l 2.16175e+02 5.75102e+01 l 2.13203e+02 6.15496e+01 lx
+2.49137e-01 7.50863e-01 0.00000e+00 s 4.75481e+01 4.11779e+01 m 9.50962e+01 2.74519e+01 l 1.22548e+02 4.86270e+01 l 7.50000e+01 6.78745e+01 lf
+0 sg 4.75481e+01 4.11779e+01 m 9.50962e+01 2.74519e+01 l 1.22548e+02 4.86270e+01 l 7.50000e+01 6.78745e+01 lx
+1.00000e+00 5.41041e-01 5.41041e-01 s 2.05084e+02 5.32640e+01 m 2.11028e+02 5.11261e+01 l 2.14459e+02 5.59639e+01 l 2.08516e+02 5.83424e+01 lf
+0 sg 2.05084e+02 5.32640e+01 m 2.11028e+02 5.11261e+01 l 2.14459e+02 5.59639e+01 l 2.08516e+02 5.83424e+01 lx
+8.85853e-01 1.14147e-01 0.00000e+00 s 1.95709e+02 4.92601e+01 m 2.01653e+02 4.77751e+01 l 2.05084e+02 5.32640e+01 l 1.99141e+02 4.96728e+01 lf
+0 sg 1.95709e+02 4.92601e+01 m 2.01653e+02 4.77751e+01 l 2.05084e+02 5.32640e+01 l 1.99141e+02 4.96728e+01 lx
+3.60688e-01 6.39312e-01 0.00000e+00 s 2.26346e+02 4.55837e+01 m 2.32290e+02 4.38222e+01 l 2.35721e+02 4.68051e+01 l 2.29778e+02 4.91017e+01 lf
+0 sg 2.26346e+02 4.55837e+01 m 2.32290e+02 4.38222e+01 l 2.35721e+02 4.68051e+01 l 2.29778e+02 4.91017e+01 lx
+9.00031e-01 9.99691e-02 0.00000e+00 s 2.11028e+02 5.11261e+01 m 2.16971e+02 4.40266e+01 l 2.20403e+02 4.73129e+01 l 2.14459e+02 5.59639e+01 lf
+0 sg 2.11028e+02 5.11261e+01 m 2.16971e+02 4.40266e+01 l 2.20403e+02 4.73129e+01 l 2.14459e+02 5.59639e+01 lx
+2.85606e-01 7.14394e-01 0.00000e+00 s 1.76959e+02 4.16047e+01 m 1.88846e+02 4.61431e+01 l 1.95709e+02 4.92601e+01 l 1.83822e+02 4.28765e+01 lf
+0 sg 1.76959e+02 4.16047e+01 m 1.88846e+02 4.61431e+01 l 1.95709e+02 4.92601e+01 l 1.83822e+02 4.28765e+01 lx
+2.86454e-01 7.13546e-01 0.00000e+00 s 2.16971e+02 4.40266e+01 m 2.22915e+02 4.18131e+01 l 2.26346e+02 4.55837e+01 l 2.20403e+02 4.73129e+01 lf
+0 sg 2.16971e+02 4.40266e+01 m 2.22915e+02 4.18131e+01 l 2.26346e+02 4.55837e+01 l 2.20403e+02 4.73129e+01 lx
+2.82188e-01 7.17812e-01 0.00000e+00 s 2.32290e+02 4.38222e+01 m 2.38233e+02 4.16046e+01 l 2.41665e+02 4.45763e+01 l 2.35721e+02 4.68051e+01 lf
+0 sg 2.32290e+02 4.38222e+01 m 2.38233e+02 4.16046e+01 l 2.41665e+02 4.45763e+01 l 2.35721e+02 4.68051e+01 lx
+1.00000e+00 1.41530e-01 1.41530e-01 s 2.01653e+02 4.77751e+01 m 2.07596e+02 4.62901e+01 l 2.11028e+02 5.11261e+01 l 2.05084e+02 5.32640e+01 lf
+0 sg 2.01653e+02 4.77751e+01 m 2.07596e+02 4.62901e+01 l 2.11028e+02 5.11261e+01 l 2.05084e+02 5.32640e+01 lx
+2.71654e-01 7.28346e-01 0.00000e+00 s 2.22915e+02 4.18131e+01 m 2.28858e+02 4.03449e+01 l 2.32290e+02 4.38222e+01 l 2.26346e+02 4.55837e+01 lf
+0 sg 2.22915e+02 4.18131e+01 m 2.28858e+02 4.03449e+01 l 2.32290e+02 4.38222e+01 l 2.26346e+02 4.55837e+01 lx
+7.59590e-01 2.40410e-01 0.00000e+00 s 2.07596e+02 4.62901e+01 m 2.13540e+02 4.21630e+01 l 2.16971e+02 4.40266e+01 l 2.11028e+02 5.11261e+01 lf
+0 sg 2.07596e+02 4.62901e+01 m 2.13540e+02 4.21630e+01 l 2.16971e+02 4.40266e+01 l 2.11028e+02 5.11261e+01 lx
+2.47686e-01 7.52314e-01 0.00000e+00 s 2.13540e+02 4.21630e+01 m 2.19483e+02 3.80359e+01 l 2.22915e+02 4.18131e+01 l 2.16971e+02 4.40266e+01 lf
+0 sg 2.13540e+02 4.21630e+01 m 2.19483e+02 3.80359e+01 l 2.22915e+02 4.18131e+01 l 2.16971e+02 4.40266e+01 lx
+2.57479e-01 7.42521e-01 0.00000e+00 s 2.28858e+02 4.03449e+01 m 2.34802e+02 3.86328e+01 l 2.38233e+02 4.16046e+01 l 2.32290e+02 4.38222e+01 lf
+0 sg 2.28858e+02 4.03449e+01 m 2.34802e+02 3.86328e+01 l 2.38233e+02 4.16046e+01 l 2.32290e+02 4.38222e+01 lx
+9.38102e-01 6.18981e-02 0.00000e+00 s 1.88846e+02 4.61431e+01 m 2.00733e+02 3.81092e+01 l 2.07596e+02 4.62901e+01 l 1.95709e+02 4.92601e+01 lf
+0 sg 1.88846e+02 4.61431e+01 m 2.00733e+02 3.81092e+01 l 2.07596e+02 4.62901e+01 l 1.95709e+02 4.92601e+01 lx
+1.45669e-01 8.54331e-01 0.00000e+00 s 2.19483e+02 3.80359e+01 m 2.25427e+02 3.68485e+01 l 2.28858e+02 4.03449e+01 l 2.22915e+02 4.18131e+01 lf
+0 sg 2.19483e+02 3.80359e+01 m 2.25427e+02 3.68485e+01 l 2.28858e+02 4.03449e+01 l 2.22915e+02 4.18131e+01 lx
+2.08214e-01 7.91786e-01 0.00000e+00 s 2.25427e+02 3.68485e+01 m 2.31370e+02 3.56611e+01 l 2.34802e+02 3.86328e+01 l 2.28858e+02 4.03449e+01 lf
+0 sg 2.25427e+02 3.68485e+01 m 2.31370e+02 3.56611e+01 l 2.34802e+02 3.86328e+01 l 2.28858e+02 4.03449e+01 lx
+6.50466e-01 3.49534e-01 0.00000e+00 s 1.70096e+02 4.03328e+01 m 1.81983e+02 3.56593e+01 l 1.88846e+02 4.61431e+01 l 1.76959e+02 4.16047e+01 lf
+0 sg 1.70096e+02 4.03328e+01 m 1.81983e+02 3.56593e+01 l 1.88846e+02 4.61431e+01 l 1.76959e+02 4.16047e+01 lx
+3.50941e-01 6.49059e-01 0.00000e+00 s 2.00733e+02 3.81092e+01 m 2.12620e+02 3.13634e+01 l 2.19483e+02 3.80359e+01 l 2.07596e+02 4.62901e+01 lf
+0 sg 2.00733e+02 3.81092e+01 m 2.12620e+02 3.13634e+01 l 2.19483e+02 3.80359e+01 l 2.07596e+02 4.62901e+01 lx
+9.77314e-02 9.02269e-01 0.00000e+00 s 2.12620e+02 3.13634e+01 m 2.24507e+02 2.97176e+01 l 2.31370e+02 3.56611e+01 l 2.19483e+02 3.80359e+01 lf
+0 sg 2.12620e+02 3.13634e+01 m 2.24507e+02 2.97176e+01 l 2.31370e+02 3.56611e+01 l 2.19483e+02 3.80359e+01 lx
+6.92725e-01 3.07275e-01 0.00000e+00 s 1.81983e+02 3.56593e+01 m 1.93870e+02 3.09859e+01 l 2.00733e+02 3.81092e+01 l 1.88846e+02 4.61431e+01 lf
+0 sg 1.81983e+02 3.56593e+01 m 1.93870e+02 3.09859e+01 l 2.00733e+02 3.81092e+01 l 1.88846e+02 4.61431e+01 lx
+2.44839e-01 7.55161e-01 0.00000e+00 s 9.50962e+01 2.74519e+01 m 1.42644e+02 1.37260e+01 l 1.70096e+02 4.03328e+01 l 1.22548e+02 4.86270e+01 lf
+0 sg 9.50962e+01 2.74519e+01 m 1.42644e+02 1.37260e+01 l 1.70096e+02 4.03328e+01 l 1.22548e+02 4.86270e+01 lx
+2.46395e-01 7.53605e-01 0.00000e+00 s 1.93870e+02 3.09859e+01 m 2.05757e+02 2.73800e+01 l 2.12620e+02 3.13634e+01 l 2.00733e+02 3.81092e+01 lf
+0 sg 1.93870e+02 3.09859e+01 m 2.05757e+02 2.73800e+01 l 2.12620e+02 3.13634e+01 l 2.00733e+02 3.81092e+01 lx
+1.56606e-01 8.43394e-01 0.00000e+00 s 2.05757e+02 2.73800e+01 m 2.17644e+02 2.37740e+01 l 2.24507e+02 2.97176e+01 l 2.12620e+02 3.13634e+01 lf
+0 sg 2.05757e+02 2.73800e+01 m 2.17644e+02 2.37740e+01 l 2.24507e+02 2.97176e+01 l 2.12620e+02 3.13634e+01 lx
+4.14652e-01 5.85348e-01 0.00000e+00 s 1.56370e+02 2.70294e+01 m 1.80144e+02 1.79367e+01 l 1.93870e+02 3.09859e+01 l 1.70096e+02 4.03328e+01 lf
+0 sg 1.56370e+02 2.70294e+01 m 1.80144e+02 1.79367e+01 l 1.93870e+02 3.09859e+01 l 1.70096e+02 4.03328e+01 lx
+2.11447e-01 7.88553e-01 0.00000e+00 s 1.80144e+02 1.79367e+01 m 2.03918e+02 1.18870e+01 l 2.17644e+02 2.37740e+01 l 1.93870e+02 3.09859e+01 lf
+0 sg 1.80144e+02 1.79367e+01 m 2.03918e+02 1.18870e+01 l 2.17644e+02 2.37740e+01 l 1.93870e+02 3.09859e+01 lx
+2.62498e-01 7.37502e-01 0.00000e+00 s 1.42644e+02 1.37260e+01 m 1.66418e+02 6.86298e+00 l 1.80144e+02 1.79367e+01 l 1.56370e+02 2.70294e+01 lf
+0 sg 1.42644e+02 1.37260e+01 m 1.66418e+02 6.86298e+00 l 1.80144e+02 1.79367e+01 l 1.56370e+02 2.70294e+01 lx
+1.94763e-01 8.05237e-01 0.00000e+00 s 1.66418e+02 6.86298e+00 m 1.90192e+02 0.00000e+00 l 2.03918e+02 1.18870e+01 l 1.80144e+02 1.79367e+01 lf
+0 sg 1.66418e+02 6.86298e+00 m 1.90192e+02 0.00000e+00 l 2.03918e+02 1.18870e+01 l 1.80144e+02 1.79367e+01 lx
+showpage
+.
+
+    Writing statistics for whole sweep.#  Description of fields
+#  =====================
+#  General:
+#    time
+#  Primal problem:
+#    number of active cells
+#    number of degrees of freedom
+#    iterations for the helmholtz equation
+#    iterations for the projection equation
+#    elastic energy
+#    kinetic energy
+#    total energy
+#  Dual problem:
+#    number of active cells
+#    number of degrees of freedom
+#    iterations for the helmholtz equation
+#    iterations for the projection equation
+#    elastic energy
+#    kinetic energy
+#    total energy
+#  Error estimation:
+#    total estimated error in this timestep
+#  Postprocessing:
+#    Huyghens wave
+
+
+0.0000e+00      169    211   0   0 0.0000e+00 0.0000e+00 0.000000e+00       169    817   8   9 5.7587e-05 5.4373e-05 1.119600e-04    0.0000e+00    1.4945e-06 
+2.8000e-02      211    257   7  11 9.4011e-01 1.2453e+00 2.185453e+00       211   1001   9   9 5.8143e-05 5.4101e-05 1.122438e-04    -4.2070e-07    -8.6574e-07 
+5.6000e-02      310    366   7  12 5.4382e-01 1.6415e+00 2.185370e+00       310   1433  11   9 6.4376e-05 6.0405e-05 1.247818e-04    -1.1717e-07    -4.1454e-06 
+8.4000e-02      367    429   7  12 1.1928e+00 9.9251e-01 2.185333e+00       367   1682  14   9 6.5182e-05 6.5257e-05 1.304393e-04    -2.2252e-07    -5.3217e-06 
+1.1200e-01      439    504   8  12 1.1456e+00 1.0326e+00 2.178182e+00       439   1978  18   9 6.6807e-05 6.7042e-05 1.338492e-04    -2.8754e-07    -2.2031e-06 
+1.4000e-01      487    554   9  12 1.1109e+00 1.0449e+00 2.155779e+00       487   2175  19   9 6.7175e-05 6.8871e-05 1.360462e-04    -1.5095e-07    1.7460e-06 
+1.6800e-01      502    573   9  12 9.9758e-01 1.0751e+00 2.072671e+00       502   2250  19   9 7.0309e-05 6.5855e-05 1.361640e-04    -1.7273e-07    -1.6320e-06 
+1.9600e-01      484    552   9  12 8.3563e-01 9.5615e-01 1.791775e+00       484   2166  18   9 6.9923e-05 6.7415e-05 1.373384e-04    2.8526e-08    -1.1812e-06 
+2.2400e-01      508    576   8  12 9.2851e-01 8.1114e-01 1.739651e+00       508   2258  18   9 7.0152e-05 6.7381e-05 1.375328e-04    -6.5978e-09    7.2727e-06 
+2.5200e-01      550    624   8  12 9.0198e-01 7.0701e-01 1.608994e+00       550   2450  18   9 6.7023e-05 8.6824e-05 1.538462e-04    -4.8222e-07    1.1178e-05 
+2.8000e-01      550    625   9  12 7.4954e-01 7.5519e-01 1.504727e+00       550   2455  18   9 7.1049e-05 8.7282e-05 1.583303e-04    -6.1958e-07    -3.9066e-07 
+3.0800e-01      517    585   9  12 6.1174e-01 7.4223e-01 1.353966e+00       517   2298  19   9 9.1328e-05 1.1012e-04 2.014517e-04    -1.6043e-07    -1.8481e-05 
+3.3600e-01      493    560   9  12 5.0491e-01 6.7542e-01 1.180338e+00       493   2196  19   9 1.0497e-04 1.1987e-04 2.248441e-04    -2.1442e-07    -7.9463e-06 
+3.6400e-01      487    552   8  14 5.4634e-01 4.8130e-01 1.027646e+00       487   2162  17   9 1.2112e-04 1.0808e-04 2.291960e-04    -8.4327e-08    3.9392e-05 
+3.9200e-01      457    518   8  13 5.1102e-01 4.5505e-01 9.660671e-01       457   2032  17   9 1.3121e-04 1.0073e-04 2.319403e-04    -2.6802e-07    9.6578e-05 
+4.2000e-01      400    460   8  13 4.0294e-01 4.3286e-01 8.358041e-01       400   1801  16   9 1.3154e-04 1.0040e-04 2.319400e-04    7.3392e-08    1.4085e-04 
+4.4800e-01      337    393   8  12 3.7743e-01 3.9830e-01 7.757345e-01       337   1535  15   9 1.2739e-04 1.0621e-04 2.336038e-04    -2.0384e-07    1.8030e-04 
+4.7600e-01      301    352   8  12 3.8030e-01 3.2294e-01 7.032375e-01       301   1371  13   9 1.3155e-04 1.0291e-04 2.344609e-04    -1.6185e-07    3.5826e-04 
+5.0400e-01      286    335   7  12 2.6843e-01 2.7812e-01 5.465549e-01       286   1303  12   9 1.5432e-04 8.0640e-05 2.349614e-04    -7.9974e-07    1.1511e-03 
+5.3200e-01      223    267   7  12 2.7503e-01 2.5530e-01 5.303319e-01       223   1034   8   9 2.2359e-04 7.3526e-05 2.971130e-04    3.0156e-07    3.4608e-03 
+5.6000e-01      199    242   7  12 2.4928e-01 2.4894e-01 4.982188e-01       199    934   8   9 1.2621e-04 7.5341e-05 2.015514e-04    5.5585e-07    8.2008e-03 
+5.8800e-01      181    221   7  12 2.2444e-01 2.4672e-01 4.711569e-01       181    850   8   9 2.3531e-04 8.0625e-05 3.159352e-04    4.9786e-07    1.5315e-02 
+6.1600e-01      154    192   8  11 2.1009e-01 1.8893e-01 3.990155e-01       154    734   7   9 1.2907e-04 9.0473e-05 2.195380e-04    6.3166e-07    2.3342e-02 
+6.4400e-01      121    157   7  10 1.8576e-01 1.8985e-01 3.756090e-01       121    599   7   8 1.4950e-04 9.0445e-05 2.399451e-04    -2.4092e-07    3.0769e-02 
+6.7200e-01      124    160   7  10 1.7392e-01 2.0155e-01 3.754677e-01       124    608   7   8 2.1526e-04 6.2468e-05 2.777330e-04    -3.8595e-06    3.8858e-02 
+7.0000e-01      115    149   7  10 1.6720e-01 1.5213e-01 3.193275e-01       115    567   0   0 0.0000e+00 0.0000e+00 0.000000e+00    -5.4712e-06    4.8866e-02 
+
+    Writing summary.Summary of this sweep:
+======================
+
+  Accumulated number of cells: 8972
+  Acc. number of primal dofs : 20828
+  Acc. number of dual dofs   : 81378
+  Accumulated error          : -1.1855e-05
+
+  Evaluations:
+  ------------
+    Hughens wave -- weighted time: 6.3029e-01
+                    average      : 3.3907e-03
+  Time tag: 1999/8/12 17:54:26
+
+
+
diff --git a/tests/deal.II/wave-test-3.prm b/tests/deal.II/wave-test-3.prm
new file mode 100644 (file)
index 0000000..4f88843
--- /dev/null
@@ -0,0 +1,81 @@
+subsection Grid
+  set Initial refinement           = 4
+  set Coarse mesh                  = square
+
+  subsection Refinement
+    set Refinement fraction            = 0.95
+    set Coarsening fraction            = 0.01
+    set Compare indicators globally    = false
+    set Maximum refinement             = 0
+    set Adapt mesh to dual solution    = true
+    set Primal to dual weight          = 4
+    set Initial energy estimator sweeps= 0
+  end
+
+  subsection Mesh smoothing
+    set Cell number correction steps = 2
+    set Top cell number deviation    = 0.1
+    set Bottom cell number deviation = 0.06
+  end
+
+  set Renumber dofs                = true
+end
+
+
+
+subsection Equation data
+  set Coefficient                  = kink
+  set Initial u                    = bump
+  set Initial v                    = zero
+  set Boundary                     = zero
+end
+
+
+
+subsection Discretization
+  set Primal FE                    = linear
+  set Dual FE                      = quadratic
+  subsection Time stepping
+    set Primal method              = theta
+    set Dual method                = theta
+    set Theta                      = 0.5
+    set Time step                  = 0.028
+    set End time                   = 0.7
+  end
+end
+
+
+
+subsection Solver
+  set Preconditioning              = ssor
+  set Extrapolate old solutions    = false
+end
+
+
+
+subsection Output
+  set Format                       = eps
+  set Directory                    = tmp
+  set Directory for temporaries    = tmp
+  set Write solutions              = all sweeps
+  set Write steps interval         = 25
+  set Write stacked time steps     = false
+  set Write error as cell data     = true
+
+  subsection Error statistics
+    set Produce error statistics   = false
+    set Number of intervals        = 25
+    set Interval spacing           = logarithmic
+  end
+end
+
+
+
+subsection Goal
+  set Goal                         = Huyghens wave
+  set Evaluate                     = Huyghens wave
+end
+
+
+set Refinement criterion           = dual estimator
+set Sweeps                         = 3

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.