From 89bfc5c3c77a955b2ec18c455274ffe949a3af38 Mon Sep 17 00:00:00 2001 From: wolf Date: Wed, 8 Sep 1999 13:02:41 +0000 Subject: [PATCH] Add a new testcase. git-svn-id: https://svn.dealii.org/trunk@1727 0785d39b-7218-0410-832d-ea1e28bc413d --- tests/deal.II/wave-test-3.cc | 9203 ++++++++++++++++++++++++++++++ tests/deal.II/wave-test-3.expect | 2688 +++++++++ tests/deal.II/wave-test-3.prm | 81 + 3 files changed, 11972 insertions(+) create mode 100644 tests/deal.II/wave-test-3.cc create mode 100644 tests/deal.II/wave-test-3.expect create mode 100644 tests/deal.II/wave-test-3.prm diff --git a/tests/deal.II/wave-test-3.cc b/tests/deal.II/wave-test-3.cc new file mode 100644 index 0000000000..424b0f5cc5 --- /dev/null +++ b/tests/deal.II/wave-test-3.cc @@ -0,0 +1,9203 @@ +// deal_II_libraries.g=-ldeal_II_2d.g +// deal_II_libraries=-ldeal_II_2d + + +#include +#include +#include +#include +#include + +#include +#include + + +class UserMatrix; +class SweepInfo; +template class SweepData; +template class WaveParameters; +template class TimeStep_Primal; +template class TimeStep_Dual; +template class DualFunctional; +template class EvaluationBase; +template class TimeStep_ErrorEstimation; +template class TimeStep_Postprocess; + + + +template +class TimeStepBase_Wave : public TimeStepBase_Tria{ + public: + TimeStepBase_Wave (); + TimeStepBase_Wave (const double time, + TimeStepBase_Tria::Flags flags, + const WaveParameters ¶meters); + const TimeStep_Primal & get_timestep_primal () const; + const TimeStep_Dual & get_timestep_dual () const; + const TimeStep_Postprocess & 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 &sweep_data); + + protected: + const WaveParameters ¶meters; + SweepInfo *sweep_info; + SweepData *sweep_data; +}; + + + +template +class TimeStep_Wave : public virtual TimeStepBase_Wave +{ + 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 &solution, + const Vector &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 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 energy; + }; + + DoFHandler *dof_handler; + const FiniteElement &fe; + const Quadrature &quadrature; + const Quadrature &quadrature_face; + ConstraintMatrix constraints; + SparseMatrixStruct system_sparsity; + SparseMatrix mass_matrix, laplace_matrix; + Vector u, v; + StatisticData statistic_data; + void create_matrices (); + void transfer_old_solutions (Vector &old_u, + Vector &old_v) const; + void transfer_old_solutions (const typename DoFHandler::cell_iterator &old_cell, + const typename DoFHandler::cell_iterator &new_cell, + const Vector &old_grid_u, + const Vector &old_grid_v, + Vector &old_u, + Vector &old_v) const; + pair compute_energy (); + template friend class DualFunctional; + template friend class EvaluationBase; + template friend class TimeStep_ErrorEstimation; + template friend class TimeStep_Postprocess; +}; + + + +template +class TimeStep_Primal : public TimeStep_Wave +{ + 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 &right_hand_side1, + Vector &right_hand_side2); + void build_rhs (Vector &right_hand_side1, + Vector &right_hand_side2); + void build_rhs (const typename DoFHandler::cell_iterator &old_cell, + const typename DoFHandler::cell_iterator &new_cell, + FEValues &fe_values, + Vector &right_hand_side1, + Vector &right_hand_side2); + unsigned int + collect_from_children (const typename DoFHandler::cell_iterator &old_cell, + FEValues &fe_values, + Vector &rhs1, + Vector &rhs2) const; + unsigned int + distribute_to_children (const typename DoFHandler::cell_iterator &cell, + FEValues &fe_values, + const Vector &old_dof_values_u, + const Vector &old_dof_values_v, + Vector &right_hand_side1, + Vector &right_hand_side2); +}; + + + +template +class TimeStep_Dual : public TimeStep_Wave +{ + 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 &right_hand_side1, + Vector &right_hand_side2); + void build_rhs (Vector &right_hand_side1, + Vector &right_hand_side2); + void build_rhs (const typename DoFHandler::cell_iterator &old_cell, + const typename DoFHandler::cell_iterator &new_cell, + FEValues &fe_values, + Vector &right_hand_side1, + Vector &right_hand_side2); + unsigned int + collect_from_children (const typename DoFHandler::cell_iterator &old_cell, + FEValues &fe_values, + Vector &rhs1, + Vector &rhs2) const; + unsigned int + distribute_to_children (const typename DoFHandler::cell_iterator &cell, + FEValues &fe_values, + const Vector &old_dof_values_u, + const Vector &old_dof_values_v, + Vector &right_hand_side1, + Vector &right_hand_side2); +}; + + + +#include + + + +template +class TimeStep_ErrorEstimation : public virtual TimeStepBase_Wave +{ + 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 &indicators) const; + void get_error_indicators (Vector &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 errors; + typename vector::iterator next_free_slot; + }; + + Vector estimated_error_per_cell; + FullMatrix embedding_matrix; + FullMatrix interpolation_matrix; + FullMatrix 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::cell_iterator &primal_cell, + const typename DoFHandler::cell_iterator &dual_cell, + const typename DoFHandler::cell_iterator &primal_cell_old, + const typename DoFHandler::cell_iterator &dual_cell_old, + CellwiseError &cellwise_error, + FEValues &fe_values) const; + void compute_error_on_new_children (const typename DoFHandler::cell_iterator &primal_cell, + const typename DoFHandler::cell_iterator &dual_cell, + const Vector &local_u_old, + const Vector &local_v_old, + const Vector &local_u_bar_old, + const Vector &local_v_bar_old, + CellwiseError &cellwise_error, + FEValues &fe_values) const; + ErrorOnCell collect_error_from_children (const typename DoFHandler::cell_iterator &primal_cell_old, + const typename DoFHandler::cell_iterator &dual_cell_old, + const Vector &local_u, + const Vector &local_v, + const Vector &local_u_bar, + const Vector &local_v_bar, + const Vector &local_Ih_u_bar, + const Vector &local_Ih_v_bar, + const Vector &local_Ih_u_bar_old, + const Vector &local_Ih_v_bar_old, + FEValues &fe_values) const; + ErrorOnCell error_formula (const typename DoFHandler::active_cell_iterator &cell, + const Vector &local_u, + const Vector &local_v, + const Vector &local_u_bar, + const Vector &local_v_bar, + const Vector &local_u_old, + const Vector &local_v_old, + const Vector &local_u_bar_old, + const Vector &local_v_bar_old, + FEValues &fe_values) const; + ErrorOnCell error_formula (const typename DoFHandler::active_cell_iterator &cell, + const Vector &local_u, + const Vector &local_v, + const Vector &local_u_bar, + const Vector &local_v_bar, + const Vector &local_u_old, + const Vector &local_v_old, + const Vector &local_u_bar_old, + const Vector &local_v_bar_old, + const Vector &local_difference_u_bar, + const Vector &local_difference_v_bar, + const Vector &local_difference_u_bar_old, + const Vector &local_difference_v_bar_old, + FEValues &fe_values) const; + void make_interpolation_matrices (); +}; + + +#include + + +template +class TimeStep_Postprocess : public TimeStep_ErrorEstimation +{ + 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 ¶meters); + void write (ostream &out) const; + vector evaluation_results; + }; + + StatisticData statistic_data; + + private: + void interpolate_dual_solution (Vector &interpolated_u_bar, + Vector &interpolated_v_bar) const; +}; + + + +template class WaveParameters; + + + +template +class TimeStep : public TimeStep_Primal, public TimeStep_Dual, public TimeStep_Postprocess +{ + public: + TimeStep (const double time, + const WaveParameters ¶meters); + + 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 ¶meters); + void write_statistics (ostream &out) const; +}; + +template class TimeStep_Primal; +template class TimeStep_Dual; + + + +template +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 &final_u_bar, + Vector &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 &j1, + Vector &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 &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 &dual_problem); + + /** + * Exception + */ + DeclException0 (ExcPrimalProblemNotRequested); + + protected: + const bool use_primal_problem; + const bool use_primal_problem_at_endtime; + + const Triangulation *tria; + const Boundary *boundary; + const DoFHandler *dof; + const FiniteElement *fe; + const Quadrature *quadrature; + const Quadrature *quadrature_face; + const Function *density, *stiffness; + + const DoFHandler *primal_dof; + const FiniteElement *primal_fe; + const Quadrature *primal_quadrature; + const Quadrature *primal_quadrature_face; + + const Vector *u; + const Vector *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 +class EndEnergy : public DualFunctional { + 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 &final_u_bar, + Vector &final_v_bar) const; +}; + + + + + + + +/** + * Let the point value of $u$ at the origin integrated over time + * be the goal. + */ +template +class IntegratedValueAtOrigin : public EndEnergy { + public: + /** + * Evaluate the dual functionals and + * return the right hand side contributions + * thereof for the present time step. + */ + virtual void compute_functionals (Vector &j1, + Vector &j2); + + /** + * Exception. + */ + DeclException0 (ExcVertexNotFound); +}; + + + + + +/** + * Dual function corresponding to the #EvaluateSeismicSignal# class. + */ +template +class SeismicSignal : public DualFunctional { + public: + /** + * Evaluate the dual functionals and + * return the right hand side contributions + * thereof for the present time step. + */ + virtual void compute_functionals (Vector &j1, + Vector &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 +class EarthSurface : public DualFunctional { + public: + /** + * Evaluate the dual functionals and + * return the right hand side contributions + * thereof for the present time step. + */ + virtual void compute_functionals (Vector &j1, + Vector &j2); +}; + + + +/** + * Compute $J(\Psi) = \int_0^0.25 u(x=2,y,t=2.2) dy. + */ +template +class SplitSignal : public DualFunctional { + public: + /** + * Evaluate the dual functionals and + * return the right hand side contributions + * thereof for the present time step. + */ + virtual void compute_functionals (Vector &j1, + Vector &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 +class SplitLine : public DualFunctional { + public: + /** + * Compute the initial values of the + * dual problem. + */ + void compute_endtime_vectors (Vector &final_u_bar, + Vector &final_v_bar); +}; + + + +/** + * Compute $J(\Psi) = \int_{-0.6}^{-0.4} u(x,t=2.5) dx. + */ +template +class OneBranch1d : public DualFunctional { + public: + /** + * Evaluate the dual functionals and + * return the right hand side contributions + * thereof for the present time step. + */ + virtual void compute_functionals (Vector &j1, + Vector &j2); +}; + + + +/** + * Compute $J(\Psi) = \int_{-0.1}^{0.1} u(x,t=2.4) dx. + */ +template +class SecondCrossing : public DualFunctional { + public: + /** + * Evaluate the dual functionals and + * return the right hand side contributions + * thereof for the present time step. + */ + virtual void compute_functionals (Vector &j1, + Vector &j2); +}; + + + +/** + */ +template +class HuyghensWave : public DualFunctional { + public: + /** + * Evaluate the dual functionals and + * return the right hand side contributions + * thereof for the present time step. + */ + virtual void compute_functionals (Vector &j1, + Vector &j2); +}; + + +#include +#include +#include +#include +#include + + + + + +/** + * 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 +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 &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 *u, *v; + + /** + * Underlying triangulation. + */ + const Triangulation *tria; + + /** + * Boundary object. + */ + const Boundary *boundary; + + /** + * Degrees of freedom of the primal + * problem. + */ + const DoFHandler *dof; + + /** + * Primal finite element. + */ + const FiniteElement *fe; + + /** + * Quadrature rule appropriate for + * the primal finite element. + */ + const Quadrature *quadrature; + + /** + * Same for quadrature on faces. + */ + const Quadrature *quadrature_face; + + /** + * Density and stiffness coefficients + * for the modell presently under + * investigation. + */ + const Function *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 +class EvaluateEnergyContent : public EvaluationBase { + 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 +class EvaluateIntegratedValueAtOrigin : public EvaluationBase { + 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 +class EvaluateSeismicSignal : public EvaluationBase { + public: + EvaluateSeismicSignal () : + result (0) {}; + + static inline double weight (const Point &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 +class EvaluateSplitSignal : public EvaluationBase { + 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 +class EvaluateOneBranch1d : public EvaluationBase { + 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 +class EvaluateSecondCrossing1d : public EvaluationBase { + 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 +class EvaluateHuyghensWave : public EvaluationBase { + 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 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 +class SweepData +{ + public: + SweepData (const bool use_data_out_stack); + ~SweepData (); + + DataOutStack *data_out_stack; +}; + + + +#include +#include +#include + + + +/** + * 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 + void write_summary (const list*> & eval_list, + ostream &out) const; + + private: + Data data; + Timers timers; +}; + + + +#include + + + + +/** + * Enum denoting the different possibilities to precondition a solver. + */ +enum Preconditioning { + no_preconditioning, + jacobi, + sor, + ssor +}; + + + +/** + * Wrapper for the #SparseMatrix# class which handles the preconditioning. + */ +class UserMatrix : public SparseMatrix { + public: + /** + * Constructor. The parameter specifies + * which way to precondition. + */ + UserMatrix (Preconditioning p) : + SparseMatrix (), + 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(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 &dst, const Vector &src) const; + + private: + /** + * Variable denoting the preconditioning + * method. + */ + Preconditioning preconditioning; +}; + + +#include +#include + +#include + + +string int_to_string (const unsigned int i, const unsigned int digits); + + +template +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 +struct FEHelper { + static const FEQ1 fe_linear; + static const FEQ2 fe_quadratic_sub; +#if 2 < 3 + static const FEQ3 fe_cubic_sub; + static const FEQ4 fe_quartic_sub; +#endif + + static const QGauss2 q_gauss_2; + static const QGauss3 q_gauss_3; + static const QGauss4 q_gauss_4; + static const QGauss5 q_gauss_5; + static const QGauss6 q_gauss_6; + static const QGauss7 q_gauss_7; + static const QGauss8 q_gauss_8; + + static const QGauss2 q_gauss_2_face; + static const QGauss3 q_gauss_3_face; + static const QGauss4 q_gauss_4_face; + static const QGauss5 q_gauss_5_face; + static const QGauss6 q_gauss_6_face; + static const QGauss7 q_gauss_7_face; + static const QGauss8 q_gauss_8_face; + + /** + * Return a reference to the finite + * element specified by the name + * #name#. + */ + static const FiniteElement & get_fe (const string &name); + + /** + * Return the correct domain quadrature + * formula for the finite element denoted + * by the name #name#. + */ + static const Quadrature & get_quadrature (const string &name); + + /** + * Return the correct boundary quadrature + * formula for the finite element denoted + * by the name #name#. + */ + static const Quadrature & get_quadrature_face (const string &name); +}; + + + +#include +#include +#include +#include + +template class DualFunctional; +template 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| +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 *boundary_values_u; + + /** + * Same for the velocity variable v. + */ + Function *boundary_values_v; + + /** + * Initial values for u. + */ + Function *initial_u; + + /** + * Same for the velocity variable v. + */ + Function *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*boundary; + + /** + * Function denoting the coefficient + * within the generalized laplacian + * operator. + */ + Function *density; + + /** + * Same for the stiffness parameter. + */ + Function *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*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 *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 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 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*> 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 + +template class WaveParameters; +template 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 +class TimestepManager : public TimeDependent { + public: + /** + * Constructor. + */ + TimestepManager (const WaveParameters ¶meters); + + /** + * 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 ¶meters; + + /** + * 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 &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 +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 parameters; +}; + + + + + +/* $Id$ */ + + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + + + +/*------------------------ DualFunctional --------------------------------*/ + +template +DualFunctional::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 +void DualFunctional::compute_functionals (Vector &j1, + Vector &j2) { + j1.reinit (dof->n_dofs()); + j2.reinit (dof->n_dofs()); +}; + + + +template +void DualFunctional::compute_endtime_vectors (Vector &final_u_bar, + Vector &final_v_bar) { + final_u_bar.reinit (dof->n_dofs()); + final_v_bar.reinit (dof->n_dofs()); +}; + + + +template +bool DualFunctional::use_primal_solutions () const { + return use_primal_problem; +}; + + + +template +bool DualFunctional::use_primal_solutions_at_endtime () const { + return use_primal_problem_at_endtime; +}; + + + +template +void DualFunctional::reset (const TimeStep_Primal &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 +void DualFunctional::reset (const TimeStep_Dual &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 +EndEnergy::EndEnergy (const bool use_primal_problem) : + DualFunctional (use_primal_problem, true) {}; + + + + +template +void EndEnergy::compute_vectors (const PartOfDomain pod, + Vector &final_u_bar, + Vector &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::active_cell_iterator cell, primal_cell, endc; + cell = dof->begin_active (); + endc = dof->end (); + primal_cell = primal_dof->begin_active(); + + FEValues fe_values (*fe, *quadrature, + UpdateFlags(update_gradients | + update_JxW_values | + update_q_points)); + FEValues fe_values_primal (*primal_fe, *quadrature, + update_gradients); + + FullMatrix cell_matrix (total_dofs, total_dofs); + + vector > local_u_grad (n_q_points); + vector local_v (n_q_points); + + vector density_values(quadrature->n_quadrature_points); + vector stiffness_values(quadrature->n_quadrature_points); + + vector 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 > > &shape_grads = fe_values.get_shape_grads (); + const FullMatrix &shape_values = fe_values.get_shape_values (); + const vector &JxW_values (fe_values.get_JxW_values()); + + vector local_functional1 (total_dofs, 0); + vector local_functional2 (total_dofs, 0); + for (unsigned int shape_func=0; shape_funcget_dof_indices (cell_dof_indices); + for (unsigned int shape_func=0; shape_func +void IntegratedValueAtOrigin::compute_functionals (Vector &j1, + Vector &j2) { + j1.reinit (dof->n_dofs()); + j2.reinit (dof->n_dofs()); + + DoFHandler::active_cell_iterator cell = dof->begin_active(), + endc = dof->end(); + + Point origin; + + bool origin_found = false; + for (; (cell!=endc) && !origin_found; ++cell) + { + for (unsigned int vertex=0; vertex::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 &, + Vector &) +{ + Assert (false, ExcNotImplemented()); +}; + + + +template +void SeismicSignal::compute_functionals (Vector &j1, + Vector &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::active_cell_iterator cell, endc; + DoFHandler::face_iterator face; + cell = dof->begin_active(); + endc = dof->end(); + + vector cell_dof_indices (total_dofs); + + FEFaceValues 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::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 &shape_values = fe_face_values. + get_shape_values (); + const vector &JxW_values (fe_face_values. + get_JxW_values()); + const vector > &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 local_integral (total_dofs, 0); + for (unsigned int shape_func=0; shape_func + ::weight(q_points[point], time)) * + JxW_values[point]; + + cell->get_dof_indices (cell_dof_indices); + for (unsigned int shape_func=0; shape_func +void EarthSurface<1>::compute_functionals (Vector &, + Vector &) +{ + Assert (false, ExcNotImplemented()); +}; + + + +template +void EarthSurface::compute_functionals (Vector &j1, + Vector &j2) { + const unsigned int face_dofs = fe->dofs_per_face; + + j1.reinit (dof->n_dofs()); + j2.reinit (dof->n_dofs()); + + DoFHandler::active_cell_iterator cell, endc; + DoFHandler::face_iterator face; + cell = dof->begin_active(); + endc = dof->end(); + + vector face_dof_indices (face_dofs); + + for (; cell!=endc; ++cell) + for (unsigned int face_no=0; face_no::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 +void SplitSignal<1>::compute_functionals (Vector &, + Vector &) +{ + Assert (false, ExcInternalError()); +}; + + + + +template +void SplitSignal::compute_functionals (Vector &j1, + Vector &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::active_cell_iterator cell, endc; + DoFHandler::face_iterator face; + cell = dof->begin_active(); + endc = dof->end(); + + vector dof_indices (fe->total_dofs); + FEFaceValues fe_face_values (*fe, *quadrature_face, update_JxW_values); + + for (; cell!=endc; ++cell) + for (unsigned int face_no=0; face_no::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::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 &shape_values = fe_face_values.get_shape_values (); + const vector &JxW_values = fe_face_values.get_JxW_values(); + cell->get_dof_indices (dof_indices); + + for (unsigned int i=0; i +void SplitLine::compute_endtime_vectors (Vector &, + Vector &) { + Assert (false, ExcNotImplemented ()); +}; + + +#if 2 == 1 + +template <> +void SplitLine<1>::compute_endtime_vectors (Vector &final_u_bar, + Vector &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::active_cell_iterator cell = dof->begin_active (), + endc = dof->end (); + + FEValues fe_values (*fe, *quadrature, update_JxW_values); + vector 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 &shape_values = fe_values.get_shape_values (); + const vector &JxW_values (fe_values.get_JxW_values()); + + vector local_functional (total_dofs, 0); + for (unsigned int shape_func=0; shape_funcget_dof_indices (cell_dof_indices); + for (unsigned int shape_func=0; shape_func +void OneBranch1d::compute_functionals (Vector &j1, + Vector &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::active_cell_iterator cell, endc; + cell = dof->begin_active(); + endc = dof->end(); + + vector dof_indices (fe->total_dofs); + FEValues 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 &shape_values = fe_values.get_shape_values (); + const vector &JxW_values = fe_values.get_JxW_values(); + cell->get_dof_indices (dof_indices); + + for (unsigned int i=0; i +void SecondCrossing::compute_functionals (Vector &j1, + Vector &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::active_cell_iterator cell, endc; + cell = dof->begin_active(); + endc = dof->end(); + + vector dof_indices (fe->total_dofs); + FEValues 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 &shape_values = fe_values.get_shape_values (); + const vector &JxW_values = fe_values.get_JxW_values(); + cell->get_dof_indices (dof_indices); + + for (unsigned int i=0; i +void HuyghensWave::compute_functionals (Vector &j1, + Vector &j2) { + j1.reinit (dof->n_dofs()); + j2.reinit (dof->n_dofs()); + + if ((time < 0.5) || (time > 0.69)) + return; + + Point p; + p(0) = 0.75; + const Point evaluation_point (p); + + const DoFHandler::cell_iterator endc = dof->end(3); + bool point_found = false; + for (DoFHandler::cell_iterator cell=dof->begin(3); + (cell!=endc) && !point_found; ++cell) + for (unsigned int vertex=0; vertex::vertices_per_cell; ++vertex) + if (cell->vertex(vertex) == evaluation_point) + { + // step down the list of children + // until we find a terminal cell + DoFHandler::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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + + + +/*--------------------------- EvaluationBase --------------------------*/ + +template +EvaluationBase::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 +void EvaluationBase::reset_timelevel (const TimeStep_Primal &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 +void EvaluationBase::reset () {}; + + + +template +void EvaluationBase::print_final_result (ostream &) {}; + + +template +double EvaluationBase::get_final_result () { + return 0; +}; + + + + + + +/*--------------------------- EvaluateEnergyContent ----------------------*/ + +template +EvaluateEnergyContent::EvaluateEnergyContent () : + old_energy (0), + integrated_outflux (0) {}; + + +template +void EvaluateEnergyContent::reset () { + old_energy = 0; + integrated_outflux = 0; +}; + + + +template +double EvaluateEnergyContent::compute_energy (const PartOfDomain pod) const { + const double y_offset = 300000000; + + DoFHandler::active_cell_iterator cell, endc; + cell = dof->begin_active (); + endc = dof->end (); + + FEValues fe_values (*fe, *quadrature, + UpdateFlags(update_gradients | + update_JxW_values | + update_q_points)); + FullMatrix cell_matrix (fe->total_dofs, fe->total_dofs); + Vector local_u (fe->total_dofs); + Vector local_v (fe->total_dofs); + + vector density_values(quadrature->n_quadrature_points); + vector 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 &values = fe_values.get_shape_values(); + const vector > >&gradients = fe_values.get_shape_grads (); + const vector &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; pointtotal_dofs; ++i) + for (unsigned int j=0; jtotal_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; pointtotal_dofs; ++i) + for (unsigned int j=0; jtotal_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 +void EvaluateIntegratedValueAtOrigin::print_final_result (ostream &out) { + out << " Integrated value of u at origin: " + << integrated_value << endl; +}; + + + +template +double EvaluateIntegratedValueAtOrigin::get_final_result () { + return integrated_value; +}; + + + +template +string EvaluateIntegratedValueAtOrigin::description () const { + return "integrated value at origin"; +}; + + + +template +void EvaluateIntegratedValueAtOrigin::reset () { + integrated_value = 0; +}; + + + +template +double EvaluateIntegratedValueAtOrigin::evaluate () { + DoFHandler::active_cell_iterator cell = dof->begin_active(), + endc = dof->end(); + + double value_at_origin = 0; + Point origin; + + bool origin_found = false; + for (; (cell!=endc) && !origin_found; ++cell) + { + for (unsigned int vertex=0; vertex::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 +void EvaluateSeismicSignal::print_final_result (ostream &out) { + out << " Integrated seismic signal: " << result << endl; +}; + + + +template +double EvaluateSeismicSignal::get_final_result () { + return result; +}; + + + +template +string EvaluateSeismicSignal::description () const { + return "Integrated seismic signal at top"; +}; + + + +template +void EvaluateSeismicSignal::reset () { + result = 0; +}; + + + +template <> +double EvaluateSeismicSignal<1>::evaluate () +{ + Assert (false, ExcNotImplemented()); + return 0; +}; + + + +template +double EvaluateSeismicSignal::evaluate () { + const unsigned int n_q_points = quadrature_face->n_quadrature_points; + + ofstream out((base_file_name + ".seismic").c_str()); + AssertThrow (out, ExcIO()); + + DoFHandler::active_cell_iterator cell = dof->begin_active(), + endc = dof->end(); + double u_integrated=0; + FEFaceValues face_values (*fe, *quadrature_face, + UpdateFlags(update_JxW_values|update_q_points)); + vector face_u (fe->dofs_per_face); + + for (; cell!=endc; ++cell) + for (unsigned int face=0; face::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 &JxW_values (face_values.get_JxW_values()); + const vector > &q_points (face_values.get_quadrature_points()); + + double local_integral = 0; + for (unsigned int point=0; pointface(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 +void EvaluateSplitSignal::print_final_result (ostream &out) { + out << " Integrated split signal: " << result << endl; +}; + + + +template +double EvaluateSplitSignal::get_final_result () { + return result; +}; + + + +template +string EvaluateSplitSignal::description () const { + return "Integrated split signal (exact: (2+pi)/(16-pi)=0.010229)"; +}; + + + +template +void EvaluateSplitSignal::reset () { + result = 0; +}; + + + +template <> +double EvaluateSplitSignal<1>::evaluate () +{ + Assert (false, ExcNotImplemented()); + return 0; +}; + + + +template +double EvaluateSplitSignal::evaluate () { + if ((time<=1.6) || (time>1.8)) + return 0; + + const unsigned int n_q_points = quadrature_face->n_quadrature_points; + DoFHandler::active_cell_iterator cell = dof->begin_active(), + endc = dof->end(); + double u_integrated=0; + FEFaceValues face_values (*fe, *quadrature_face, update_JxW_values); + vector face_u (fe->dofs_per_face); + + for (; cell!=endc; ++cell) + for (unsigned int face_no=0; face_no::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::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::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 &JxW_values (face_values.get_JxW_values()); + + double local_integral = 0; + for (unsigned int point=0; point +void EvaluateOneBranch1d::print_final_result (ostream &out) { + out << " One branch integrated: " << result << endl; +}; + + + +template +double EvaluateOneBranch1d::get_final_result () { + return result; +}; + + + +template +string EvaluateOneBranch1d::description () const { + return "One branch integrated (exact: 0.055735)"; +}; + + + +template +void EvaluateOneBranch1d::reset () { + result = 0; +}; + + + +template +double EvaluateOneBranch1d::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 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 &JxW_values (fe_values.get_JxW_values()); + + double local_integral = 0; + for (unsigned int point=0; point +void EvaluateSecondCrossing1d::print_final_result (ostream &out) { + out << " Second crossing: " << result << endl; +}; + + + +template +double EvaluateSecondCrossing1d::get_final_result () { + return result; +}; + + + +template +string EvaluateSecondCrossing1d::description () const { + return "Second crossing (exact: 0.011147)"; +}; + + + +template +void EvaluateSecondCrossing1d::reset () { + result = 0; +}; + + + +template +double EvaluateSecondCrossing1d::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 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 &JxW_values (fe_values.get_JxW_values()); + const vector > &quadrature_points (fe_values.get_quadrature_points()); + + double local_integral = 0; + for (unsigned int point=0; point +void EvaluateHuyghensWave::print_final_result (ostream &out) { + out << " Hughens wave -- weighted time: " << weighted_value / integrated_value << endl; + out << " average : " << integrated_value << endl; +}; + + + +template +double EvaluateHuyghensWave::get_final_result () { + return weighted_value / integrated_value; +}; + + + +template +string EvaluateHuyghensWave::description () const { + return "Huyghens wave"; +}; + + + +template +void EvaluateHuyghensWave::reset () { + integrated_value = weighted_value = 0; +}; + + + +template +double EvaluateHuyghensWave::evaluate () +{ + double value_at_origin = 0; + Point p; + p(0) = 0.75; + const Point evaluation_point (p); + + const DoFHandler::cell_iterator endc = dof->end(3); + bool point_found = false; + for (DoFHandler::cell_iterator cell=dof->begin(3); + (cell!=endc) && !point_found; ++cell) + for (unsigned int vertex=0; vertex::vertices_per_cell; ++vertex) + if (cell->vertex(vertex) == evaluation_point) + { + // step down the list of children + // until we find a terminal cell + DoFHandler::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 +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#include + + +template +TimestepManager::TimestepManager (const WaveParameters ¶meters) : + TimeDependent(TimeDependent::TimeSteppingData(0,1), + TimeDependent::TimeSteppingData(0,1), + TimeDependent::TimeSteppingData(0,1)), + parameters (parameters) +{}; + + + +template +void TimestepManager::run_sweep (const unsigned int sweep_no) +{ + SweepInfo sweep_info; + SweepData sweep_data (parameters.write_stacked_data); + if (parameters.write_stacked_data) + { + sweep_data.data_out_stack->declare_data_vector ("u", DataOutStack::dof_vector); + sweep_data.data_out_stack->declare_data_vector ("v", DataOutStack::dof_vector); + if ((parameters.refinement_strategy == WaveParameters::dual_estimator) + && + (sweep_no >= parameters.initial_energy_estimator_sweeps)) + { + sweep_data.data_out_stack->declare_data_vector ("dual_u", DataOutStack::dof_vector); + sweep_data.data_out_stack->declare_data_vector ("dual_v", DataOutStack::dof_vector); + }; + if ((sweep_no::dual_estimator)) + sweep_data.data_out_stack->declare_data_vector ("est_error", DataOutStack::cell_vector); + }; + + + cout << "Sweep " << setw(2) << sweep_no << ':' << endl + << "---------" << endl; + + for (typename list*>::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::iterator timestep=timesteps.begin(); + timestep!=timesteps.end(); ++timestep) + { + dynamic_cast*>(*timestep)->attach_sweep_info (sweep_info); + dynamic_cast*>(*timestep)->attach_sweep_data (sweep_data); + }; + + solve_primal_problem (); + cout << endl; + + if ((parameters.refinement_strategy == WaveParameters::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 +void TimestepManager::refine_grids () +{ + cout << " Collecting refinement data: " << endl; + + + const unsigned int n_timesteps = timesteps.size(); + + // first collect all the error indicators + vector > indicators (n_timesteps); + + for (unsigned int i=0; i*>(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 time_values (timesteps.size()); + for (unsigned int i=0; iget_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 all_indicators (total_number_of_cells); + unsigned int next_index=0; + for (unsigned int i=0; i partial_sums(all_indicators.size()); + sort (all_indicators.begin(), all_indicators.end(), greater()); + partial_sum (all_indicators.begin(), all_indicators.end(), + partial_sums.begin()); + + const Vector::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::children_per_cell-1) - + (partial_sums.end() - p)/(GeometryInfo::children_per_cell-1)) + << " cells in next sweep." + << endl; + cout << " Now refining..." << flush; + do_loop (mem_fun (&TimeStepBase_Tria::init_for_refinement), + bind2nd (mem_fun1 (&TimeStepBase_Wave::refine_grid), + TimeStepBase_Tria::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[timestep])->init_for_refinement(); + + unsigned int total_expected_cells = 0; + + for (unsigned int timestep=0; timestep *this_timestep + = static_cast*>(timesteps[timestep]); + + this_timestep->wake_up (0); + + // copy criteria and delete the old + // vector + Assert (indicators.size() > 0, ExcInternalError()); + Vector criteria (indicators[0]); + indicators.erase (indicators.begin()); + + const double total_error = criteria.l1_norm(); + + Vector partial_sums(criteria.size()); + + // sort the largest errors to the + // beginning of the vector + sort (criteria.begin(), criteria.end(), greater()); + partial_sum (criteria.begin(), criteria.end(), + partial_sums.begin()); + + const Vector::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::children_per_cell-1) - + (partial_sums.end() - p)/(GeometryInfo::children_per_cell-1)); + + this_timestep->refine_grid (TimeStepBase_Tria::RefinementData (top_threshold, + bottom_threshold)); + + this_timestep->sleep (0); + if (timestep!=0) + static_cast*>(timesteps[timestep-1])->sleep(1); + }; + + if (timesteps.size() != 0) + static_cast*>(timesteps.back())->sleep(1); + + + cout << " Got " << total_number_of_cells << " presently, expecting " + << total_expected_cells << " for next sweep." << endl; + }; +}; + + + + +template +void TimestepManager::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::write_statistics_descriptions (cout, parameters); + cout << endl << endl; + + for (unsigned int timestep=0; timestepget_time() + << " "; + dynamic_cast*> + (static_cast*> + (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 +void TimestepManager::write_stacked_data (DataOutStack &data_out_stack) const +{ + typename DataOutInterface::OutputFormat output_format + = DataOutInterface::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 +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + + +template +const string WaveParameters::initial_value_names ("zero" + "|eigenmode" + "|bump" + "|small bump" + "|center-kink" + "|shifted bump" + "|plateau" + "|earthquake"); +template +const string WaveParameters::coefficient_names ("unit" + "|kink" + "|gradient" + "|preliminary earth model" + "|distorted"); +template +const string WaveParameters::boundary_function_names ("wave from left" + "|fast wave from left" + "|wave from left center" + "|wave from left bottom" + "|zero"); +template +const string WaveParameters::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 +class InitialValues { + public: + class EigenMode : public Function { + public: + virtual double operator () (const Point &p) const { + const double pi = 3.1415926539; + return sin(2*pi*p(0))*sin(2*pi*p(1)); + }; + }; + + class Bump : public Function { + public: + virtual double operator () (const Point &p) const { + const double width = 0.1; + const double r2 = p.square(); + return exp(-r2/width/width) * (r2 { + public: + virtual double operator () (const Point &p) const { + const double width = 0.02; + const double r2 = p.square(); + return exp(-r2/width/width) * (r2 { + public: + virtual double operator () (const Point &p) const { + const double width = 0.1; + Point shift; + shift(0) = 0.5; + const double r2 = (p-shift).square(); + return exp(-r2/width/width) * (r2 { + public: + virtual double operator () (const Point &p) const { + const double width = 0.1; + const double r = sqrt(p.square()); + return (r { + public: + virtual double operator () (const Point &p) const { + const double width = 0.1; + const double r = sqrt(p.square()); + return (r { + public: + virtual double operator () (const Point &p) const { + Point earthquake_center = p; + earthquake_center(1) -= 5500; + const double r2 = earthquake_center.square(); + + return (r2<300*300 ? 1-r2/300/300 : 0); + }; + }; +}; + + + +template +class Coefficients { + public: + class Kink : public Function { + public: + inline virtual double operator () (const Point &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 > &points, + vector &values) const { + Assert (values.size() == points.size(), + ExcVectorHasWrongSize(values.size(), points.size())); + for (unsigned int i=0; iKink::operator()(points[i]); + }; + + virtual Tensor<1,dim> gradient (const Point &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 > &points, + vector > &gradients) const { + for (unsigned int i=0; i { + public: + inline virtual double operator () (const Point &p) const { + return 1+8*p(1)*p(1); + }; + + virtual void value_list (const vector > &points, + vector &values) const { + Assert (values.size() == points.size(), + ExcVectorHasWrongSize(values.size(), points.size())); + for (unsigned int i=0; iGradient::operator()(points[i]); + }; + + virtual Tensor<1,dim> gradient (const Point &p) const { + Tensor<1,dim> tmp; + tmp[1] = 16*p(1); + return tmp; + }; + + virtual void gradient_list (const vector > &points, + vector > &gradients) const { + for (unsigned int i=0; i { + public: + inline virtual double operator () (const Point &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 > &points, + vector &values) const { + Assert (values.size() == points.size(), + ExcVectorHasWrongSize(values.size(), points.size())); + for (unsigned int i=0; iPreliminaryEarthModel::operator()(points[i]); + }; + + virtual Tensor<1,dim> gradient (const Point &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 > &points, + vector > &gradients) const { + for (unsigned int i=0; i { + public: + inline virtual double operator () (const Point &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 > &points, + vector &values) const { + Assert (values.size() == points.size(), + ExcVectorHasWrongSize(values.size(), points.size())); + for (unsigned int i=0; iDistorted::operator()(points[i]); + }; + + virtual Tensor<1,dim> gradient (const Point &) const { + // return zero, since we don't know + // how to do better (regularize?) + return Tensor<1,dim>(); + }; + + virtual void gradient_list (const vector > &points, + vector > &gradients) const { + for (unsigned int i=0; i +class BoundaryValues { + public: + + class WaveFromLeft_u : public Function { + public: + virtual double operator () (const Point &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 { + public: + virtual double operator () (const Point &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 { + public: + virtual double operator () (const Point &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 { + public: + virtual double operator () (const Point &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 { + public: + virtual double operator () (const Point &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 { + public: + virtual double operator () (const Point &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 { + public: + virtual double operator () (const Point &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 { + public: + virtual double operator () (const Point &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 +class Boundaries +{ + public: + class Ring : public StraightBoundary + { + public: + virtual Point + get_new_point_on_line (const typename Triangulation::line_iterator &line) const { + Point middle = StraightBoundary::get_new_point_on_line (line); + middle *= sqrt(line->vertex(0).square()) / sqrt(middle.square()); + return middle; + }; + + + virtual Point + get_new_point_on_quad (const typename Triangulation::quad_iterator &quad) const { + Point middle = StraightBoundary::get_new_point_on_quad (quad); + middle *= sqrt(quad->vertex(0).square()) / sqrt(middle.square()); + return middle; + }; + }; +}; + + + + +template +WaveParameters::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 +WaveParameters::~WaveParameters () +{ + delete_parameters (); +}; + + + +template +void WaveParameters::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*>::iterator i=eval_list.begin(); + i!=eval_list.end(); ++i) + delete *i; + eval_list.erase (eval_list.begin(), eval_list.end()); +}; + + + + +template +void WaveParameters::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 *functions[2]; + + for (unsigned int i=0; i<2; ++i) + { + if (names[i]=="eigenmode") + functions[i] = new InitialValues::EigenMode(); + else + if (names[i]=="zero") + functions[i] = new ZeroFunction(); + else + if (names[i]=="center-kink") + functions[i] = new InitialValues::CenterKink(); + else + if (names[i]=="bump") + functions[i] = new InitialValues::Bump(); + else + if (names[i]=="small bump") + functions[i] = new InitialValues::SmallBump(); + else + if (names[i]=="shifted bump") + functions[i] = new InitialValues::ShiftedBump(); + else + if (names[i]=="plateau") + functions[i] = new InitialValues::Plateau (); + else + if (names[i]=="earthquake") + functions[i] = new InitialValues::Earthquake (); + else + AssertThrow (false, ExcUnknownName(names[i])); + }; + + initial_u = functions[0]; + initial_v = functions[1]; +}; + + + + + +template +void WaveParameters::set_coefficient_functions (const string &name) { + Assert (density==0, ExcInternalError()); + Assert (stiffness==0, ExcInternalError()); + + density = new ConstantFunction(1); + density_constant = true; + + if (name=="kink") + { + stiffness = new Coefficients::Kink(); + stiffness_constant = false; + } + else + if (name=="gradient") + { + stiffness = new Coefficients::Gradient(); + stiffness_constant = false; + } + else + if (name=="unit") + { + stiffness = new ConstantFunction(1); + stiffness_constant = true; + } + else + if (name=="preliminary earth model") + { + stiffness = new Coefficients::PreliminaryEarthModel(); + stiffness_constant = false; + } + else + if (name=="distorted") + { + stiffness = new Coefficients::Distorted(); + stiffness_constant = false; + } + else + AssertThrow (false, ExcUnknownName (name)); +}; + + + +template +void WaveParameters::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::WaveFromLeft_u (); + boundary_values_v = new BoundaryValues::WaveFromLeft_v (); + } + else + if (name=="fast wave from left") + { + boundary_values_u = new BoundaryValues::FastWaveFromLeft_u (); + boundary_values_v = new BoundaryValues::FastWaveFromLeft_v (); + } + else + if (name=="wave from left center") + { + boundary_values_u = new BoundaryValues::WaveFromLeftCenter_u (); + boundary_values_v = new BoundaryValues::WaveFromLeftCenter_v (); + } + else + if (name=="wave from left bottom") + { + boundary_values_u = new BoundaryValues::WaveFromLeftBottom_u (); + boundary_values_v = new BoundaryValues::WaveFromLeftBottom_v (); + } + else + if (name=="zero") + { + boundary_values_u = new ZeroFunction(); + boundary_values_v = new ZeroFunction(); + } + else + AssertThrow (false, ExcUnknownName (name)); +}; + + + +template +void WaveParameters::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()); + else + if (name == "seismic signature") + eval_list.push_back (new EvaluateSeismicSignal()); + else + if (name == "split signal") + eval_list.push_back (new EvaluateSplitSignal()); + else + if (name == "one branch 1d") + eval_list.push_back (new EvaluateOneBranch1d()); + else + if (name == "second crossing") + eval_list.push_back (new EvaluateSecondCrossing1d()); + else + if (name == "Huyghens wave") + eval_list.push_back (new EvaluateHuyghensWave()); + else + AssertThrow (false, ExcUnknownName (name)); + }; +}; + + + + +template +void WaveParameters::set_dual_functional (const string &name) { + Assert (dual_functional==0, ExcInternalError()); + if (name == "none") + dual_functional = new DualFunctional(); + else + if (name == "integrated value at origin") + dual_functional = new IntegratedValueAtOrigin (); + else + if (name == "seismic signature") + dual_functional = new SeismicSignal (); + else + if (name == "split signal") + dual_functional = new SplitSignal (); + else + if (name == "earth surface") + dual_functional = new EarthSurface (); + else + if (name == "split line") + dual_functional = new SplitLine (); + else + if (name == "one branch 1d") + dual_functional = new OneBranch1d (); + else + if (name == "second crossing") + dual_functional = new SecondCrossing (); + else + if (name == "Huyghens wave") + dual_functional = new HuyghensWave (); + 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(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 > 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 >(&vertices[0], + &vertices[4]), + cells, + SubCellData()); + + // refine two of the three cells + Triangulation::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 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(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 vertices[8] = { Point (0,0), + Point (1,0), + Point (1,1), + Point (0,1), + Point (2,0), + Point (2,1), + Point (3,0), + Point (3,1) }; + const int cell_vertices[3][4] = {{0, 1, 2, 3}, + {1, 4, 5, 2}, + {4, 6, 7, 5}}; + + vector > cells (3, CellData()); + + 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 >(&vertices[0], + &vertices[8]), + cells, boundary_info); + + if (initial_refinement >= 1) + { + coarse_grid->refine_global (1); + + switch (initial_mesh) + { + case split_channel_bottom: + { + Triangulation::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::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(), 6371); + + if (boundary) + delete boundary; + + // set all boundary to Neumann type + Triangulation::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 origin; + boundary = new HyperBallBoundary(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 > 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 >(&vertices[0], + &vertices[8]), + cells, + SubCellData()); + if (boundary) + delete boundary; + boundary = new Boundaries::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 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(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(), 6371); + + if (boundary) + delete boundary; + + // set all boundary to Neumann type + Triangulation::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 origin; + boundary = new HyperBallBoundary(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 +void WaveParameters::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::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 +void WaveParameters::parse_parameters (ParameterHandler &prm) { + // declare some maps for convenience, + // to avoid those annoying if then else + // clauses... + map 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 preconditioning_list; + preconditioning_list["jacobi"] = jacobi; + preconditioning_list["sor"] = sor; + preconditioning_list["ssor"] = ssor; + preconditioning_list["none"] = no_preconditioning; + + map 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 +#include //?? +#include + + +template +SweepData::SweepData (const bool use_data_out_stack) +{ + if (use_data_out_stack) + data_out_stack = new DataOutStack(); + else + data_out_stack = 0; +}; + + + +template +SweepData::~SweepData () +{ + if (data_out_stack != 0) + delete data_out_stack; + data_out_stack = 0; +}; + + + + +// explicit instantiations +template class SweepData<2>; +/* $Id$ */ + + +#include +#include + + +SweepInfo::Data & +SweepInfo::get_data () +{ + return data; +}; + + + +SweepInfo::Timers & +SweepInfo::get_timers () +{ + return timers; +}; + + + +template +void +SweepInfo::write_summary (const list*> &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*>::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*> &eval_list, + ostream &out) const; + +/* $Id$ */ + + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +#include +#include + + + + +static const pair 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 > (&relaxations[0], + &relaxations[3])); + + + +template +TimeStepBase_Wave::TimeStepBase_Wave (): + TimeStepBase_Tria (), + parameters (*static_cast*>(0)) +{}; + + + +template +TimeStepBase_Wave::TimeStepBase_Wave (const double time, + TimeStepBase_Tria::Flags flags, + const WaveParameters ¶meters) + : + TimeStepBase_Tria (time, + *parameters.coarse_grid, + flags, + typename TimeStepBase_Wave::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::dual_estimator), + true)), + parameters (parameters) +{}; + + + +template +const TimeStep_Primal & +TimeStepBase_Wave::get_timestep_primal () const +{ + return dynamic_cast &> (*this); +}; + + + +template +const TimeStep_Dual & +TimeStepBase_Wave::get_timestep_dual () const +{ + return dynamic_cast &> (*this); +}; + + + +template +const TimeStep_Postprocess & +TimeStepBase_Wave::get_timestep_postprocess () const +{ + return dynamic_cast &> (*this); +}; + + + +template +string TimeStepBase_Wave::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 +void TimeStepBase_Wave::attach_sweep_info (SweepInfo &si) +{ + sweep_info = &si; +}; + + + +template +void TimeStepBase_Wave::attach_sweep_data (SweepData &sd) +{ + sweep_data = &sd; +}; + + + + + + +/* --------------------------------------------------------------*/ + + +template +TimeStep_Wave::TimeStep_Wave (const string fe_name) : + dof_handler (0), + fe (FEHelper::get_fe(fe_name)), + quadrature (FEHelper::get_quadrature(fe_name)), + quadrature_face (FEHelper::get_quadrature_face(fe_name)), + statistic_data() +{}; + + + +template +TimeStep_Wave::~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 +void TimeStep_Wave::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(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*>(&get_timestep_primal()) + == this)) + || + ((next_action == dual_problem) && + (static_cast*>(&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 +void TimeStep_Wave::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 +void TimeStep_Wave::end_sweep () +{ + string tmp_filename = tmp_filename_base(branch_signature()); + remove (tmp_filename.c_str()); +}; + + + +template +unsigned int TimeStep_Wave::solve (const UserMatrix &matrix, + Vector &solution, + const Vector &rhs) const { + SolverControl control(2000, 1.e-12); + PrimitiveVectorMemory > memory; + SolverCG > pcg(control,memory); + + // solve + pcg.solve (matrix, solution, rhs, + PreconditionUseMatrix > + (matrix, + &UserMatrix::precondition)); + // distribute solution + constraints.distribute (solution); + + return control.last_step(); +}; + + + +template +void TimeStep_Wave::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 density_values (n_q_points, 1.); + vector 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())); + if (stiffness_constant) + fill_n (stiffness_values.begin(), n_q_points, (*parameters.stiffness)(Point())); + + + FEValues 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 dof_indices_on_cell (total_dofs); + FullMatrix cell_mass_matrix (total_dofs, total_dofs); + FullMatrix cell_laplace_matrix (total_dofs, total_dofs); + + + for (typename DoFHandler::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 &shape_values = fe_values.get_shape_values (); + const vector > > &shape_grads = fe_values.get_shape_grads (); + const vector &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 > &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 +void TimeStep_Wave::transfer_old_solutions (Vector &old_u, + Vector &old_v) const +{ + const DoFHandler *present_dof_handler = dof_handler, + * old_dof_handler = 0; + const Vector *old_grid_u = 0, + *old_grid_v = 0; + + switch (next_action) + { + case primal_problem: + Assert (previous_timestep != 0, ExcInternalError()); + + old_dof_handler = (static_cast*> + (previous_timestep)->get_timestep_primal()).dof_handler; + old_grid_u = &(static_cast*> + (previous_timestep)->get_timestep_primal()).u; + old_grid_v = &(static_cast*> + (previous_timestep)->get_timestep_primal()).v; + + break; + + case dual_problem: + Assert (next_timestep != 0, ExcInternalError()); + + old_dof_handler = (static_cast*> + (next_timestep)->get_timestep_dual()).dof_handler; + old_grid_u = &(static_cast*> + (next_timestep)->get_timestep_dual()).u; + old_grid_v = &(static_cast*> + (next_timestep)->get_timestep_dual()).v; + + break; + }; + + Assert (old_dof_handler != 0, ExcInternalError()); + + DoFHandler::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::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 +void +TimeStep_Wave::transfer_old_solutions (const typename DoFHandler::cell_iterator &old_cell, + const typename DoFHandler::cell_iterator &new_cell, + const Vector &old_grid_u, + const Vector &old_grid_v, + Vector &old_u, + Vector &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::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 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 +pair +TimeStep_Wave::compute_energy () { + pair 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 +TimeStep_Wave::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 +TimeStep_Wave::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 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 +void +TimeStep_Wave::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 +void TimeStep_Wave::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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +#include + + + +template +TimeStep_Dual::TimeStep_Dual (const string &dual_fe) + : + TimeStep_Wave (dual_fe) +{}; + + + +template +void TimeStep_Dual::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 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 +void TimeStep_Dual::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 right_hand_side1 (dof_handler->n_dofs()); + Vector 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 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 boundary_value_list; + if (dim != 1) + { + VectorTools::FunctionMap dirichlet_bc; + static const ZeroFunction boundary_values; + + dirichlet_bc[0] = &boundary_values; + + VectorTools::interpolate_boundary_values (*dof_handler, dirichlet_bc, + boundary_value_list); + MatrixTools::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 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::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 +void TimeStep_Dual::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 +string TimeStep_Dual::branch_signature () const +{ + return "d"; +}; + + + +template +void TimeStep_Dual::wake_up (const unsigned int wakeup_level) +{ + TimeStep_Wave::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 +void TimeStep_Dual::assemble_vectors (Vector &right_hand_side1, + Vector &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 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 +void TimeStep_Dual::build_rhs (Vector &right_hand_side1, + Vector &right_hand_side2) { + // select the TimeStep_Wave part in the + // TimeStep_Primal branch + const TimeStep_Dual &previous_time_level + = static_cast*>(next_timestep)->get_timestep_dual(); + + Assert (previous_time_level.tria->n_cells(0) == tria->n_cells(0), + ExcCoarsestGridsDiffer()); + + // convenience typedef + typedef DoFHandler::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 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(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 +void +TimeStep_Dual::build_rhs (const DoFHandler::cell_iterator &old_cell, + const DoFHandler::cell_iterator &new_cell, + FEValues &fe_values, + Vector &right_hand_side1, + Vector &right_hand_side2) { + // declare this type for convenience + typedef DoFHandler::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::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 &previous_time_level + = static_cast*>(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 &values = fe_values.get_shape_values (); + const vector > >&gradients = fe_values.get_shape_grads (); + const vector &weights = fe_values.get_JxW_values (); + + FullMatrix cell_matrix (total_dofs, total_dofs); + + vector density_values(fe_values.n_quadrature_points); + parameters.density->value_list (fe_values.get_quadrature_points(), + density_values); + for (unsigned int point=0; point 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 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 rhs2 (total_dofs); + + // vector of values of the function on the + // old grid restricted to one cell + Vector old_dof_values_v (total_dofs); + // vector of old u and v times the local + // mass matrix + Vector local_M_u (total_dofs); + Vector local_M_v (total_dofs); + Vector 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 stiffness_values(fe_values.n_quadrature_points); + parameters.stiffness->value_list (fe_values.get_quadrature_points(), + stiffness_values); + for (unsigned int point=0; point new_dof_indices (total_dofs, -1); + new_cell->get_dof_indices (new_dof_indices); + for (unsigned int i=0; ihas_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 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 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 new_dof_indices (total_dofs); + new_cell->get_dof_indices (new_dof_indices); + for (unsigned int i=0; ihas_children() && new_cell->has_children()) + { + // vector of values of the function + // on the old grid restricted to + // the large (old) cell + Vector old_dof_values_u (total_dofs); + Vector 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 +unsigned int +TimeStep_Dual::collect_from_children (const DoFHandler::cell_iterator &old_cell, + FEValues &fe_values, + Vector &rhs1, + Vector &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 &previous_time_level + = static_cast*>(next_timestep)->get_timestep_dual(); + + const unsigned int total_dofs = fe.total_dofs; + const double time_step = get_forward_timestep(); + + FullMatrix 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 local_old_dof_values_u (total_dofs); + Vector local_old_dof_values_v (total_dofs); + + // same for the contributions to the + // right hand sides of the projection + Vector local_M_u (total_dofs); + Vector local_M_v (total_dofs); + Vector 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 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 child_rhs2 (total_dofs); + + for (unsigned int c=0; c::children_per_cell; ++c) + { + const DoFHandler::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 &values = fe_values.get_shape_values(); + const vector > >&gradients = fe_values.get_shape_grads (); + const vector &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 density_values(fe_values.n_quadrature_points); + parameters.density->value_list (fe_values.get_quadrature_points(), + density_values); + for (unsigned int point=0; point stiffness_values(fe_values.n_quadrature_points); + parameters.stiffness->value_list (fe_values.get_quadrature_points(), + stiffness_values); + for (unsigned int point=0; point +unsigned int +TimeStep_Dual::distribute_to_children (const DoFHandler::cell_iterator &new_cell, + FEValues &fe_values, + const Vector &old_dof_values_u, + const Vector &old_dof_values_v, + Vector &right_hand_side1, + Vector &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 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 local_old_dof_values_u (total_dofs); + Vector local_old_dof_values_v (total_dofs); + + // vector of old u and v times the local + // mass matrix (on the small cells + // respectively) + Vector local_M_u (total_dofs); + Vector local_M_v (total_dofs); + Vector 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 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 rhs2 (total_dofs); + + // indices of the dofs of a cell on + // the new grid + vector new_dof_indices (total_dofs, -1); + + + // loop over the child cells + for (unsigned int c=0; c::children_per_cell; ++c) + { + const DoFHandler::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 &values = fe_values.get_shape_values(); + const vector > >&gradients = fe_values.get_shape_grads (); + const vector &weights = fe_values.get_JxW_values (); + + // transfer v+ku + cell_matrix.clear (); + vector density_values(fe_values.n_quadrature_points); + parameters.density->value_list (fe_values.get_quadrature_points(), + density_values); + for (unsigned int point=0; point stiffness_values(fe_values.n_quadrature_points); + parameters.stiffness->value_list (fe_values.get_quadrature_points(), + stiffness_values); + for (unsigned int point=0; pointget_dof_indices (new_dof_indices); + for (unsigned int i=0; i; +/* $Id$ */ + + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +#include +#include +#include +#include + + + +template +TimeStep_ErrorEstimation::TimeStep_ErrorEstimation () +{}; + + + +template +void TimeStep_ErrorEstimation::estimate_error () +{ + sweep_info->get_timers().error_estimation.start(); + + cout << "[ee]" << flush; + + if ((parameters.refinement_strategy == WaveParameters::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 +void TimeStep_ErrorEstimation::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 +void TimeStep_ErrorEstimation::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 +void +TimeStep_ErrorEstimation::get_tria_refinement_criteria (Vector &indicators) const +{ + get_error_indicators (indicators); + for (Vector::iterator i=indicators.begin(); i!=indicators.end(); ++i) + *i = fabs(*i); +}; + + +template +void +TimeStep_ErrorEstimation::get_error_indicators (Vector &indicators) const +{ + ifstream in (tmp_filename_base(branch_signature()).c_str()); + indicators.block_read (in); +}; + + + +template +void TimeStep_ErrorEstimation::estimate_error_energy (const unsigned int which_variables) { + Assert (which_variables<=1, ExcInternalError()); + + KellyErrorEstimator::FunctionMap neumann_boundary; + static ZeroFunction homogeneous_neumann_bc; + neumann_boundary[1] = &homogeneous_neumann_bc; + + const TimeStep_Wave &target = (which_variables==0 ? + static_cast&>(get_timestep_primal()) : + static_cast&>(get_timestep_dual ())); + + KellyErrorEstimator::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 v_estimator(estimated_error_per_cell.size()); + KellyErrorEstimator::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 +void TimeStep_ErrorEstimation::estimate_error_dual () { + CellwiseError cellwise_error (tria->n_active_cells()); + + const TimeStep_Primal &primal_problem = get_timestep_primal(), + &primal_problem_old = static_cast*> + (previous_timestep)->get_timestep_primal(); + const TimeStep_Dual &dual_problem = get_timestep_dual(), + &dual_problem_old = static_cast*> + (previous_timestep)->get_timestep_dual(); + + + // first clear the user pointers of + // the cells we need + if (true) + { + DoFHandler::active_cell_iterator + cell = primal_problem.dof_handler->begin_active(); + const DoFHandler::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 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::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::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::iterator i = estimated_error_per_cell.begin(); + DoFHandler::active_cell_iterator + cell = primal_problem.dof_handler->begin_active(); + const DoFHandler::active_cell_iterator + endc = primal_problem.dof_handler->end(); + for (; cell!=endc; ++cell, ++i) + { + const typename vector::iterator + error_on_this_cell = static_cast::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 +void +TimeStep_ErrorEstimation::estimate_error_dual (const DoFHandler::cell_iterator &primal_cell, + const DoFHandler::cell_iterator &dual_cell, + const DoFHandler::cell_iterator &primal_cell_old, + const DoFHandler::cell_iterator &dual_cell_old, + CellwiseError &cellwise_error, + FEValues &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::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 &primal_problem = get_timestep_primal(), + &primal_problem_old = static_cast*> + (previous_timestep)->get_timestep_primal(); + const TimeStep_Dual &dual_problem = get_timestep_dual(), + &dual_problem_old = static_cast*> + (previous_timestep)->get_timestep_dual(); + + const FiniteElement &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 local_u(total_dofs_dual), local_v(total_dofs_dual); + Vector local_u_bar(total_dofs_dual), local_v_bar(total_dofs_dual); + + // same thing for old solutions + Vector local_u_old(total_dofs_dual), local_v_old(total_dofs_dual); + Vector 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 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 local_u_old(total_dofs_dual), local_v_old(total_dofs_dual); + Vector 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 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 local_u(total_dofs_dual), local_v(total_dofs_dual); + Vector local_u_bar(total_dofs_dual), local_v_bar(total_dofs_dual); + Vector local_u_bar_old(total_dofs_dual), local_v_bar_old(total_dofs_dual); + Vector local_Ih_u_bar(total_dofs_dual), local_Ih_v_bar(total_dofs_dual); + Vector 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 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 +void TimeStep_ErrorEstimation:: +compute_error_on_new_children (const DoFHandler::cell_iterator &primal_cell, + const DoFHandler::cell_iterator &dual_cell, + const Vector &local_u_old, + const Vector &local_v_old, + const Vector &local_u_bar_old, + const Vector &local_v_bar_old, + CellwiseError &cellwise_error, + FEValues &fe_values) const { + const TimeStep_Primal &primal_problem = get_timestep_primal(); + const TimeStep_Dual &dual_problem = get_timestep_dual(); + + const FiniteElement &dual_fe = get_timestep_dual().fe; + const unsigned int total_dofs_dual = dual_fe.total_dofs; + + + for (unsigned int child=0; child::children_per_cell; ++child) + { + // we have the solutions on the + // old (large) cell, we restrict it to + // each of the small cells + Vector child_u_old(total_dofs_dual), child_v_old(total_dofs_dual); + Vector 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::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 local_u(total_dofs_dual), local_v(total_dofs_dual); + Vector local_u_bar(total_dofs_dual), local_v_bar(total_dofs_dual); + + // vectors to hold dof values on + // the primal/dual cell (temporary) + Vector 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 +typename TimeStep_ErrorEstimation::ErrorOnCell +TimeStep_ErrorEstimation::collect_error_from_children (const DoFHandler::cell_iterator &primal_cell_old, + const DoFHandler::cell_iterator &dual_cell_old, + const Vector &local_u, + const Vector &local_v, + const Vector &local_u_bar, + const Vector &local_v_bar, + const Vector &local_Ih_u_bar, + const Vector &local_Ih_v_bar, + const Vector &local_Ih_u_bar_old, + const Vector &local_Ih_v_bar_old, + FEValues &fe_values) const { + const TimeStep_Primal &primal_problem_old = static_cast*> + (previous_timestep)->get_timestep_primal(); + const TimeStep_Dual &dual_problem_old = static_cast*> + (previous_timestep)->get_timestep_dual(); + const FiniteElement &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::children_per_cell; ++child) + { + // we have the solutions on the + // new (large) cell, we restrict it to + // each of the small cells + Vector child_u(total_dofs_dual), child_v(total_dofs_dual); + Vector child_u_bar(total_dofs_dual), child_v_bar(total_dofs_dual); + Vector child_Ih_u_bar(total_dofs_dual), child_Ih_v_bar(total_dofs_dual); + Vector 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::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 local_u_old(total_dofs_dual), local_v_old(total_dofs_dual); + Vector 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 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 child_difference_u_bar (total_dofs_dual); + Vector child_difference_v_bar (total_dofs_dual); + Vector local_difference_u_bar_old (total_dofs_dual); + Vector 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 +typename TimeStep_ErrorEstimation::ErrorOnCell +TimeStep_ErrorEstimation::error_formula (const DoFHandler::active_cell_iterator &cell, + const Vector &local_u, + const Vector &local_v, + const Vector &local_u_bar, + const Vector &local_v_bar, + const Vector &local_u_old, + const Vector &local_v_old, + const Vector &local_u_bar_old, + const Vector &local_v_bar_old, + FEValues &fe_values) const { + Vector local_difference_u_bar(local_u_bar.size()); + Vector local_difference_v_bar(local_u_bar.size()); + Vector local_difference_u_bar_old(local_u_bar.size()); + Vector 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 +typename TimeStep_ErrorEstimation::ErrorOnCell +TimeStep_ErrorEstimation::error_formula (const DoFHandler::active_cell_iterator &cell, + const Vector &local_u, + const Vector &local_v, + const Vector &local_u_bar, + const Vector &local_v_bar, + const Vector &local_u_old, + const Vector &local_v_old, + const Vector &local_u_bar_old, + const Vector &local_v_bar_old, + const Vector &local_difference_u_bar, + const Vector &local_difference_v_bar, + const Vector &local_difference_u_bar_old, + const Vector &local_difference_v_bar_old, + FEValues &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 tmp1(total_dofs); + Vector tmp2(total_dofs); + + + vector stiffness(fe_values.n_quadrature_points); + parameters.stiffness->value_list (fe_values.get_quadrature_points(), + stiffness); + vector > 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 mass_matrix (tmp1.size(), tmp1.size()); + // matrix for (a\Delta phi_i, phi_j) +// FullMatrix delta_matrix (tmp1.size(), tmp1.size()); + // matrix for (grad a . grad phi_i, phi_j) +// FullMatrix grad_grad_matrix (tmp1.size(), tmp1.size()); + FullMatrix laplace_matrix (tmp1.size(), tmp1.size()); + + // first task: create matrices + fe_values.reinit (cell); + const FullMatrix &values = fe_values.get_shape_values(); + const vector > >&gradients = fe_values.get_shape_grads (); + const vector > >&second_derivatives + = fe_values.get_shape_2nd_derivatives (); + const vector &weights = fe_values.get_JxW_values (); + + vector density_values(fe_values.n_quadrature_points); + parameters.density->value_list (fe_values.get_quadrature_points(), + density_values); + for (unsigned int point=0; point +void TimeStep_ErrorEstimation::make_interpolation_matrices () { + const FiniteElement &primal_fe = get_timestep_primal().fe, + &dual_fe = get_timestep_dual().fe; + + embedding_matrix.reinit (dual_fe.total_dofs, + primal_fe.total_dofs); + + vector > unit_support_points (dual_fe.total_dofs); + dual_fe.get_unit_support_points (unit_support_points); + + for (unsigned int i=0; i 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 +TimeStep_ErrorEstimation::StatisticData::StatisticData () : + estimated_error (0) +{}; + + + +template +TimeStep_ErrorEstimation::StatisticData::StatisticData (const double estimated_error) : + estimated_error (estimated_error) +{}; + + + +template +void TimeStep_ErrorEstimation::StatisticData::write_descriptions (ostream &out) +{ + out << "# total estimated error in this timestep" << endl; +}; + + + +template +void TimeStep_ErrorEstimation::StatisticData::write (ostream &out) const +{ + out << setprecision(4) << setw(6) << estimated_error; +}; + + + +template +TimeStep_ErrorEstimation::ErrorOnCell::ErrorOnCell () { + for (unsigned int i=0; i +typename TimeStep_ErrorEstimation::ErrorOnCell +TimeStep_ErrorEstimation::ErrorOnCell::operator += (const ErrorOnCell &eoc) { + for (unsigned int i=0; i +double TimeStep_ErrorEstimation::ErrorOnCell::sum () const { + double x=0; + for (unsigned int i=0; i +TimeStep_ErrorEstimation::CellwiseError::CellwiseError (const unsigned int n_errors) : + errors (n_errors), + next_free_slot (errors.begin()) +{}; + + + +// explicit instantiations +template class TimeStep_ErrorEstimation<2>; +/* $Id$ */ + + +#include +#include +#include +#include + + + + +template +TimeStep::TimeStep (const double time, + const WaveParameters ¶meters): + TimeStepBase_Wave (time, + TimeStepBase_Tria::Flags(true, 0, 1), + parameters), + TimeStep_Primal(parameters.primal_fe), + TimeStep_Dual (parameters.dual_fe) +{}; + + + + +template +void TimeStep::wake_up (const unsigned int wakeup_level) +{ + sweep_info->get_timers().grid_generation.start(); + TimeStepBase_Wave::wake_up (wakeup_level); + sweep_info->get_timers().grid_generation.stop(); + + switch (next_action) + { + case primal_problem: + TimeStep_Primal::wake_up (wakeup_level); + break; + + case dual_problem: + TimeStep_Dual::wake_up (wakeup_level); + break; + + case postprocess: + TimeStep_Primal::wake_up (wakeup_level); + + if ((parameters.refinement_strategy == WaveParameters::dual_estimator) + && + (sweep_no >= parameters.initial_energy_estimator_sweeps)) + TimeStep_Dual::wake_up (wakeup_level); + + TimeStep_Postprocess::wake_up (wakeup_level); + + break; + + case grid_refinement: + // do nothing except for waking + // up the grid + break; + + default: + Assert (false, ExcInternalError()); + }; +}; + + + +template +void TimeStep::sleep (const unsigned int sleep_level) +{ + switch (next_action) + { + case primal_problem: + TimeStep_Primal::sleep (sleep_level); + break; + + case dual_problem: + TimeStep_Dual::sleep (sleep_level); + break; + + case postprocess: + TimeStep_Primal::sleep (sleep_level); + + if ((parameters.refinement_strategy == WaveParameters::dual_estimator) + && + (sweep_no >= parameters.initial_energy_estimator_sweeps)) + TimeStep_Dual::sleep (sleep_level); + + TimeStep_Postprocess::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::sleep (sleep_level); + sweep_info->get_timers().grid_generation.stop(); +}; + + + +template +void TimeStep::end_sweep () +{ + TimeStep_Primal::end_sweep (); + TimeStep_Dual::end_sweep (); + TimeStep_Postprocess::end_sweep (); +}; + + + +template +void TimeStep::write_statistics_descriptions (ostream &out, + const WaveParameters ¶meters) +{ + out << "# Primal problem:" << endl; + TimeStep_Primal::StatisticData::write_descriptions (out); + + out << "# Dual problem:" << endl; + TimeStep_Dual::StatisticData::write_descriptions (out); + + out << "# Error estimation:" << endl; + TimeStep_ErrorEstimation::StatisticData::write_descriptions (out); + + if (parameters.eval_list.size() != 0) + { + out << "# Postprocessing:" << endl; + TimeStep_Postprocess::StatisticData::write_descriptions (out, parameters); + }; +}; + + + +template +void TimeStep::write_statistics (ostream &out) const +{ + TimeStep_Primal::statistic_data.write (out); + out << " "; + TimeStep_Dual::statistic_data.write (out); + out << " "; + TimeStep_ErrorEstimation::statistic_data.write (out); + out << " "; + TimeStep_Postprocess::statistic_data.write (out); +}; + + + +// explicit instantiations +template class TimeStep<2>; +/* $Id$ */ + + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + + + +template +void TimeStep_Postprocess::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::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*>::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::all_sweeps) || + ((parameters.write_solution_strategy == WaveParameters::last_sweep_only) && + (sweep_no == parameters.number_of_sweeps-1))) + && + (((timestep_no % parameters.write_steps_interval) == 0) || + (next_timestep == 0))) + { + cout << "[o]" << flush; + + DataOut::OutputFormat output_format + = DataOut::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::default_suffix (output_format)); + DataOut 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 u_bar, v_bar; + + // if dual problem was computed + if ((parameters.refinement_strategy == WaveParameters::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 estimated_error; + if ((sweep_no::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::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 u_bar(get_timestep_primal().dof_handler->n_dofs()); + Vector 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::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 +void TimeStep_Postprocess::wake_up (const unsigned int wakeup_level) +{ + TimeStep_ErrorEstimation::wake_up (wakeup_level); +}; + + + +template +void TimeStep_Postprocess::sleep (const unsigned int sleep_level) +{ + TimeStep_ErrorEstimation::sleep (sleep_level); +}; + + + +template +string TimeStep_Postprocess::branch_signature () const +{ + return "o"; +}; + + + +template +void TimeStep_Postprocess::end_sweep () +{ + string tmp_filename = tmp_filename_base(branch_signature()); + remove (tmp_filename.c_str()); +}; + + + + + + +template +void TimeStep_Postprocess::interpolate_dual_solution (Vector &interpolated_u_bar, + Vector &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 &target = get_timestep_dual (); + + typename DoFHandler::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::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 +void TimeStep_Postprocess::StatisticData:: +write_descriptions (ostream &out, + const WaveParameters ¶meters) +{ + for (typename list*>::const_iterator i = parameters.eval_list.begin(); + i != parameters.eval_list.end(); ++i) + out << "# " << (*i)->description() << endl; +}; + + + +template +void TimeStep_Postprocess::StatisticData::write (ostream &out) const +{ + for (unsigned int i=0; i; +/* $Id$ */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +#include + + + +template +TimeStep_Primal::TimeStep_Primal (const string &primal_fe) + : + TimeStep_Wave (primal_fe) +{}; + + + + +template +void TimeStep_Primal::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::interpolate (*dof_handler, *parameters.initial_u, u); + VectorTools::interpolate (*dof_handler, *parameters.initial_v, v); +#else + VectorTools::project (*dof_handler, constraints, + quadrature, *parameters.initial_u, u, + false, quadrature_face, (dim==2 ? true : false)); + VectorTools::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 +void TimeStep_Primal::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 right_hand_side1 (dof_handler->n_dofs()); + Vector 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 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::FunctionMap dirichlet_bc; + dirichlet_bc[0] = parameters.boundary_values_u; + + map boundary_value_list; + VectorTools::interpolate_boundary_values (*dof_handler, + dirichlet_bc, + boundary_value_list); + MatrixTools::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 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::FunctionMap dirichlet_bc; + dirichlet_bc[0] = parameters.boundary_values_v; + map boundary_value_list; + VectorTools::interpolate_boundary_values (*dof_handler, + dirichlet_bc, + boundary_value_list); + MatrixTools::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 +void TimeStep_Primal::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 +string TimeStep_Primal::branch_signature () const +{ + return "p"; +}; + + + +template +void TimeStep_Primal::wake_up (const unsigned int wakeup_level) +{ + TimeStep_Wave::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 +void TimeStep_Primal::assemble_vectors (Vector &right_hand_side1, + Vector &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 +void TimeStep_Primal::build_rhs (Vector &right_hand_side1, + Vector &right_hand_side2) { + // select the TimeStep_Wave part in the + // TimeStep_Primal branch + const TimeStep_Primal &previous_time_level + = static_cast*>(previous_timestep)->get_timestep_primal(); + + Assert (previous_time_level.tria->n_cells(0) == tria->n_cells(0), + ExcCoarsestGridsDiffer()); + + // convenience typedef + typedef DoFHandler::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 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(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 +void +TimeStep_Primal::build_rhs (const DoFHandler::cell_iterator &old_cell, + const DoFHandler::cell_iterator &new_cell, + FEValues &fe_values, + Vector &right_hand_side1, + Vector &right_hand_side2) { + // declare this type for convenience + typedef DoFHandler::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::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 &previous_time_level + = static_cast*>(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 cell_matrix (total_dofs, total_dofs); + const FullMatrix &values = fe_values.get_shape_values (); + const vector > >&gradients = fe_values.get_shape_grads (); + const vector &weights = fe_values.get_JxW_values (); + + // assemble mass matrix + vector density_values(fe_values.n_quadrature_points); + parameters.density->value_list (fe_values.get_quadrature_points(), + density_values); + for (unsigned int point=0; point 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 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 rhs2 (total_dofs); + + // vector of values of the function on the + // old grid restricted to one cell + Vector old_dof_values_u (total_dofs); + // vector of old u and v times the local + // mass matrix + Vector local_M_u (total_dofs); + Vector local_M_v (total_dofs); + Vector 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 stiffness_values(fe_values.n_quadrature_points); + parameters.stiffness->value_list (fe_values.get_quadrature_points(), + stiffness_values); + for (unsigned int point=0; point new_dof_indices (total_dofs, -1); + new_cell->get_dof_indices (new_dof_indices); + for (unsigned int i=0; ihas_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 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 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 new_dof_indices (total_dofs); + new_cell->get_dof_indices (new_dof_indices); + for (unsigned int i=0; ihas_children() && new_cell->has_children()) + { + // vector of values of the function + // on the old grid restricted to + // the large (old) cell + Vector old_dof_values_u (total_dofs); + Vector 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 +unsigned int +TimeStep_Primal::collect_from_children (const DoFHandler::cell_iterator &old_cell, + FEValues &fe_values, + Vector &rhs1, + Vector &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 &previous_time_level + = static_cast*>(previous_timestep)->get_timestep_primal(); + + const unsigned int total_dofs = fe.total_dofs; + const double time_step = get_backward_timestep(); + + + FullMatrix 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 local_old_dof_values_u (total_dofs); + Vector local_old_dof_values_v (total_dofs); + + // same for the contributions to the + // right hand sides of the projection + Vector local_M_u (total_dofs); + Vector local_M_v (total_dofs); + Vector 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 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 child_rhs2 (total_dofs); + + for (unsigned int c=0; c::children_per_cell; ++c) + { + const DoFHandler::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 &values = fe_values.get_shape_values (); + const vector > >&gradients = fe_values.get_shape_grads (); + const vector &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 density_values(fe_values.n_quadrature_points); + parameters.density->value_list (fe_values.get_quadrature_points(), + density_values); + for (unsigned int point=0; point stiffness_values(fe_values.n_quadrature_points); + parameters.stiffness->value_list (fe_values.get_quadrature_points(), + stiffness_values); + for (unsigned int point=0; point +unsigned int +TimeStep_Primal::distribute_to_children (const DoFHandler::cell_iterator &new_cell, + FEValues &fe_values, + const Vector &old_dof_values_u, + const Vector &old_dof_values_v, + Vector &right_hand_side1, + Vector &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 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 local_old_dof_values_u (total_dofs); + Vector local_old_dof_values_v (total_dofs); + + // vector of old u and v times the local + // mass matrix (on the small cells + // respectively) + Vector local_M_u (total_dofs); + Vector local_M_v (total_dofs); + Vector 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 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 rhs2 (total_dofs); + + // indices of the dofs of a cell on + // the new grid + vector new_dof_indices (total_dofs, -1); + + + // loop over the child cells + for (unsigned int c=0; c::children_per_cell; ++c) + { + const DoFHandler::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 &values = fe_values.get_shape_values (); + const vector > >&gradients = fe_values.get_shape_grads (); + const vector &weights = fe_values.get_JxW_values (); + + // transfer u+kv + cell_matrix.clear (); + vector density_values(fe_values.n_quadrature_points); + parameters.density->value_list (fe_values.get_quadrature_points(), + density_values); + for (unsigned int point=0; point stiffness_values(fe_values.n_quadrature_points); + parameters.stiffness->value_list (fe_values.get_quadrature_points(), + stiffness_values); + for (unsigned int point=0; pointget_dof_indices (new_dof_indices); + for (unsigned int i=0; i; +/* $Id$ */ + +#include + + + +void UserMatrix::precondition (Vector &dst, + const Vector &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 +#include + + + + + + + +// 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 +const FiniteElement & FEHelper::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 +const Quadrature &FEHelper::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 +const Quadrature &FEHelper::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 +#include +#include +#include +#include + + + + +template +WaveProblem::WaveProblem () +{}; + + + +template +WaveProblem::~WaveProblem () +{}; + + + +template +void WaveProblem::declare_parameters (ParameterHandler &prm) +{ + parameters.declare_parameters (prm); +}; + + + +template +void WaveProblem::parse_parameters (ParameterHandler &prm) +{ + parameters.parse_parameters (prm); +}; + + + +template +void WaveProblem::create_new (const unsigned int) +{ + parameters.delete_parameters (); +}; + + + +template +void WaveProblem::run (ParameterHandler &prm) +{ + parse_parameters (prm); +// prm.print_parameters (cout, Text); + + + //////////////////////////////// + // Set up the time step objects + TimestepManager timestep_manager (parameters); + if (true) { + // push back initial level + timestep_manager.add_timestep (new TimeStep(0, parameters)); + double time = 0; + unsigned int step_no = 0; + double local_time_step; + + while (time= 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(time, parameters)); + }; + }; + + + //////////////////////////////////// + // actually do the work (or rather: + // let the work be done) + for (unsigned int sweep=0; sweep 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 index 0000000000..1e221b4412 --- /dev/null +++ b/tests/deal.II/wave-test-3.expect @@ -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 index 0000000000..4f88843e7b --- /dev/null +++ b/tests/deal.II/wave-test-3.prm @@ -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 -- 2.39.5