]> https://gitweb.dealii.org/ - dealii.git/commitdiff
Introduce signals into the Solver base class.
authorWolfgang Bangerth <bangerth@math.tamu.edu>
Thu, 16 Oct 2014 15:27:11 +0000 (10:27 -0500)
committerWolfgang Bangerth <bangerth@math.tamu.edu>
Thu, 30 Oct 2014 22:24:31 +0000 (17:24 -0500)
This patch uses signals to determine whether a current iterate
satisfies the convergence criterion. Currently, the only slot that
is connected to a signal is the SolverControl::check() function,
but users will be able to connect different slots there as well,
closely monitoring the convergence process.

Adjust the testcases.

51 files changed:
include/deal.II/lac/eigen.h
include/deal.II/lac/solver.h
include/deal.II/lac/solver_bicgstab.h
include/deal.II/lac/solver_cg.h
include/deal.II/lac/solver_gmres.h
include/deal.II/lac/solver_minres.h
include/deal.II/lac/solver_qmrs.h
include/deal.II/lac/solver_relaxation.h
include/deal.II/lac/solver_richardson.h
tests/bits/deal_solver_04.cc
tests/bits/deal_solver_05.cc
tests/lac/solver.output
tests/lapack/solver_cg.output
tests/petsc/deal_solver_01.cc
tests/petsc/deal_solver_02.cc
tests/petsc/deal_solver_03.cc
tests/petsc/deal_solver_04.cc
tests/petsc/deal_solver_05.cc
tests/petsc/solver_01.cc
tests/petsc/solver_02.cc
tests/petsc/solver_03.cc
tests/petsc/solver_03_mf.cc
tests/petsc/solver_03_precondition_boomeramg.cc
tests/petsc/solver_03_precondition_boomeramg_symmetric.cc
tests/petsc/solver_03_precondition_eisenstat.cc
tests/petsc/solver_03_precondition_icc.cc
tests/petsc/solver_03_precondition_ilu.cc
tests/petsc/solver_03_precondition_lu.cc
tests/petsc/solver_03_precondition_parasails.cc
tests/petsc/solver_03_precondition_sor.cc
tests/petsc/solver_03_precondition_ssor.cc
tests/petsc/solver_04.cc
tests/petsc/solver_05.cc
tests/petsc/solver_06.cc
tests/petsc/solver_07.cc
tests/petsc/solver_08.cc
tests/petsc/solver_09.cc
tests/petsc/solver_10.cc
tests/petsc/solver_11.cc
tests/petsc/solver_12.cc
tests/petsc/solver_13.cc
tests/petsc/sparse_direct_mumps.cc
tests/trilinos/deal_solver_01.cc
tests/trilinos/deal_solver_02.cc
tests/trilinos/deal_solver_03.cc
tests/trilinos/deal_solver_04.cc
tests/trilinos/deal_solver_05.cc
tests/trilinos/deal_solver_06.cc
tests/trilinos/solver_03.cc
tests/trilinos/solver_05.cc
tests/trilinos/solver_07.cc

index 7fbe6320a1587889742c449e2586b82aefa35163..aa03e5ad841ab1af6642ab83110f1226617b6ccd 100644 (file)
@@ -273,7 +273,8 @@ EigenPower<VECTOR>::solve (double       &value,
   A.vmult (y,x);
 
   // Main loop
-  for (int iter=0; conv==SolverControl::iterate; iter++)
+  int iter=0;
+  for (; conv==SolverControl::iterate; iter++)
     {
       y.add(additional_data.shift, x);
 
@@ -307,7 +308,7 @@ EigenPower<VECTOR>::solve (double       &value,
 
       // Check the change of the eigenvalue
       // Brrr, this is not really a good criterion
-      conv = this->control().check (iter, std::fabs(1./length-1./old_length));
+      conv = this->iteration_status (iter, std::fabs(1./length-1./old_length), x);
     }
 
   this->memory.free(Vy);
@@ -316,9 +317,9 @@ EigenPower<VECTOR>::solve (double       &value,
   deallog.pop();
 
   // in case of failure: throw exception
-  if (this->control().last_check() != SolverControl::success)
-    AssertThrow(false, SolverControl::NoConvergence (this->control().last_step(),
-                                                     this->control().last_value()));
+  AssertThrow(conv == SolverControl::success, SolverControl::NoConvergence (iter,
+              std::fabs(1./length-1./old_length)));
+
   // otherwise exit as normal
 }
 
@@ -378,7 +379,9 @@ EigenInverse<VECTOR>::solve (double       &value,
   x.scale(1./length);
 
   // Main loop
-  for (size_type iter=0; conv==SolverControl::iterate; iter++)
+  double res = -std::numeric_limits<double>::max();
+  size_type iter=0;
+  for (; conv==SolverControl::iterate; iter++)
     {
       solver.solve (A_s, y, x, prec);
 
@@ -420,13 +423,14 @@ EigenInverse<VECTOR>::solve (double       &value,
           y.equ (value, x);
           A.vmult(r,x);
           r.sadd(-1., value, x);
-          double res = r.l2_norm();
+          res = r.l2_norm();
           // Check the residual
-          conv = this->control().check (iter, res);
+          conv = this->iteration_status (iter, res, x);
         }
       else
         {
-          conv = this->control().check (iter, std::fabs(1./value-1./old_value));
+          res = std::fabs(1./value-1./old_value);
+          conv = this->iteration_status (iter, res, x);
         }
       old_value = value;
     }
@@ -438,9 +442,9 @@ EigenInverse<VECTOR>::solve (double       &value,
 
   // in case of failure: throw
   // exception
-  if (this->control().last_check() != SolverControl::success)
-    throw SolverControl::NoConvergence (this->control().last_step(),
-                                        this->control().last_value());
+  AssertThrow (conv == SolverControl::success,
+               SolverControl::NoConvergence (iter,
+                                             res));
   // otherwise exit as normal
 }
 
index 748e748eec8ce9ef318c3f13c2340d915fafc721..327f7e4e6f95ec98818675e6c999172b06b4e744 100644 (file)
 #include <deal.II/base/config.h>
 #include <deal.II/base/subscriptor.h>
 #include <deal.II/lac/vector_memory.h>
+#include <deal.II/lac/solver_control.h>
+
+#include <boost/signals2.hpp>
 
 DEAL_II_NAMESPACE_OPEN
 
 template <typename number> class Vector;
-class SolverControl;
 
 /**
  * A base class for iterative linear solvers. This class
@@ -192,12 +194,6 @@ public:
    */
   Solver (SolverControl        &solver_control);
 
-  /**
-   * Return a reference to the object that controls
-   * convergence.
-   */
-  SolverControl &control() const;
-
 protected:
   /**
    * A static vector memory object
@@ -208,27 +204,120 @@ protected:
   mutable GrowingVectorMemory<VECTOR> static_vector_memory;
 
   /**
-   * Reference to the object that determines convergence.
+   * A reference to an object that provides memory for auxiliary vectors.
    */
-  SolverControl &cntrl;
+  VectorMemory<VECTOR> &memory;
 
+private:
   /**
-   * A reference to an object that provides memory for auxiliary vectors.
+   * A class whose operator() combines two states indicating whether
+   * we should continue iterating or stop, and returns a state that
+   * dominates. The rules are:
+   * - If one of the two states indicates failure, return failure.
+   * - Otherwise, if one of the two states indicates to continue
+   *   iterating, then continue iterating.
+   * - Otherwise, return success.
    */
-  VectorMemory<VECTOR> &memory;
+  struct StateCombiner
+  {
+    typedef SolverControl::State result_type;
+
+    SolverControl::State operator() (const SolverControl::State state1,
+                                     const SolverControl::State state2) const;
+
+    template <typename Iterator>
+    SolverControl::State operator() (const Iterator begin,
+                                     const Iterator end) const;
+  };
+
+protected:
+  /**
+   * A signal that iterative solvers can execute at the end of every
+   * iteration (or in an otherwise periodic fashion) to find out whether
+   * we should continue iterating or not. The signal may call one or
+   * more slots that each will make this determination by themselves,
+   * and the result over all slots (function calls) will be determined
+   * by the StateCombiner object.
+   *
+   * The arguments passed to the signal are (i) the number of the current
+   * iteration; (ii) the value that is used to determine convergence (oftentimes
+   * the residual, but in other cases other quantities may be used as long
+   * as they converge to zero as the iterate approaches the solution of
+   * the linear system); and (iii) a vector that corresponds to the current
+   * best guess for the solution at the point where the signal is called.
+   * Note that some solvers do not update the approximate solution in every
+   * iteration but only after convergence or failure has been determined
+   * (GMRES is an example); in such cases, the vector passed as the last
+   * argument to the signal is simply the best approximate at the time
+   * the signal is called, but not the vector that will be returned if
+   * the signal's return value indicates that the iteration should be
+   * terminated.
+   */
+  boost::signals2::signal<SolverControl::State (const unsigned int iteration,
+                                                const double        check_value,
+                                                const VECTOR       &current_iterate),
+                                                      StateCombiner> iteration_status;
 };
 
 
 /*-------------------------------- Inline functions ------------------------*/
 
+
+template <class VECTOR>
+inline
+SolverControl::State
+Solver<VECTOR>::StateCombiner::operator ()(const SolverControl::State state1,
+                                           const SolverControl::State state2) const
+{
+  if ((state1 == SolverControl::failure)
+      ||
+      (state2 == SolverControl::failure))
+    return SolverControl::failure;
+  else if ((state1 == SolverControl::iterate)
+           ||
+           (state2 == SolverControl::iterate))
+    return SolverControl::iterate;
+  else
+    return SolverControl::success;
+}
+
+
+template <class VECTOR>
+template <typename Iterator>
+inline
+SolverControl::State
+Solver<VECTOR>::StateCombiner::operator ()(const Iterator begin,
+                                           const Iterator end) const
+{
+  Assert (begin != end, ExcMessage ("You can't combine iterator states if no state is given."));
+
+  // combine the first with all of the following states
+  SolverControl::State state = *begin;
+  Iterator p = begin;
+  ++p;
+  for (; p != end; ++p)
+    state = this->operator()(state, *p);
+
+  return state;
+}
+
+
 template<class VECTOR>
 inline
 Solver<VECTOR>::Solver (SolverControl        &solver_control,
                         VectorMemory<VECTOR> &vector_memory)
   :
-  cntrl(solver_control),
   memory(vector_memory)
-{}
+{
+  // connect the solver control object to the signal. SolverControl::check
+  // only takes two arguments, the iteration and the check_value, and so
+  // we simply ignore the third argument that is passed in whenever the
+  // signal is executed
+  iteration_status.connect (std_cxx11::bind(&SolverControl::check,
+                                            std_cxx11::ref(solver_control),
+                                            std_cxx11::_1,
+                                            std_cxx11::_2));
+}
 
 
 
@@ -236,18 +325,17 @@ template<class VECTOR>
 inline
 Solver<VECTOR>::Solver (SolverControl        &solver_control)
   :
-  cntrl(solver_control),
+  // use the static memory object this class owns
   memory(static_vector_memory)
-{}
-
-
-
-template <class VECTOR>
-inline
-SolverControl &
-Solver<VECTOR>::control() const
 {
-  return cntrl;
+  // connect the solver control object to the signal. SolverControl::check
+  // only takes two arguments, the iteration and the check_value, and so
+  // we simply ignore the third argument that is passed in whenever the
+  // signal is executed
+  iteration_status.connect (std_cxx11::bind(&SolverControl::check,
+                                            std_cxx11::ref(solver_control),
+                                            std_cxx11::_1,
+                                            std_cxx11::_2));
 }
 
 
index 5041c67c19e3a3f03dba2acd9bd391aa672c0aed..bde7fc7353d5d044fda81414a38d0c5e32250f3f 100644 (file)
@@ -226,12 +226,30 @@ private:
   SolverControl::State start(const MATRIX &A);
 
   /**
-   * The iteration loop itself.
+   * A structure returned by the iterate() function representing
+   * what it found is happening during the iteration.
    */
-  template<class MATRIX, class PRECONDITIONER>
-  bool
-  iterate(const MATRIX &A, const PRECONDITIONER &precondition);
+  struct IterationResult
+  {
+    bool                 breakdown;
+    SolverControl::State state;
+    unsigned int         last_step;
+    double               last_residual;
+
+    IterationResult (const bool breakdown,
+                     const SolverControl::State state,
+                     const unsigned int         last_step,
+                     const double               last_residual);
+  };
 
+  /**
+   * The iteration loop itself. The function returns a structure
+   * indicating what happened in this function.
+   */
+  template<class MATRIX, class PRECONDITIONER>
+  IterationResult
+  iterate(const MATRIX &A,
+          const PRECONDITIONER &precondition);
 };
 
 /*@}*/
@@ -239,6 +257,20 @@ private:
 
 #ifndef DOXYGEN
 
+
+template<class VECTOR>
+SolverBicgstab<VECTOR>::IterationResult::IterationResult(const bool breakdown,
+                                                         const SolverControl::State state,
+                                                         const unsigned int         last_step,
+                                                         const double               last_residual)
+  :
+  breakdown (breakdown),
+  state (state),
+  last_step (last_step),
+  last_residual (last_residual)
+{}
+
+
 template<class VECTOR>
 SolverBicgstab<VECTOR>::SolverBicgstab (SolverControl &cn,
                                         VectorMemory<VECTOR> &mem,
@@ -289,7 +321,7 @@ SolverBicgstab<VECTOR>::start(const MATRIX &A)
   Vr->sadd(-1.,1.,*Vb);
   res = Vr->l2_norm();
 
-  return this->control().check(step, res);
+  return this->iteration_status(step, res, *Vx);
 }
 
 
@@ -306,7 +338,7 @@ SolverBicgstab<VECTOR>::print_vectors(const unsigned int,
 
 template<class VECTOR>
 template<class MATRIX, class PRECONDITIONER>
-bool
+typename SolverBicgstab<VECTOR>::IterationResult
 SolverBicgstab<VECTOR>::iterate(const MATRIX &A,
                                 const PRECONDITIONER &precondition)
 {
@@ -349,17 +381,22 @@ SolverBicgstab<VECTOR>::iterate(const MATRIX &A,
 //TODO:[?] Find better breakdown criterion
 
       if (std::fabs(alpha) > 1.e10)
-        return true;
+        return IterationResult(true, state, step, res);
 
       r.add(-alpha, v);
 
       // check for early success, see the lac/bicgstab_early testcase as to
       // why this is necessary
-      if (this->control().check(step, r.l2_norm()) == SolverControl::success)
+      //
+      // note: the vector *Vx we pass to the iteration_status signal here is only
+      // the current approximation, not the one we will return with,
+      // which will be x=*Vx + alpha*y
+      res = r.l2_norm();
+      if (this->iteration_status(step, res, *Vx) == SolverControl::success)
         {
           Vx->add(alpha, y);
           print_vectors(step, *Vx, r, y);
-          return false;
+          return IterationResult(false, SolverControl::success, step, res);
         }
 
       precondition.vmult(z,r);
@@ -374,11 +411,11 @@ SolverBicgstab<VECTOR>::iterate(const MATRIX &A,
       else
         res = r.l2_norm();
 
-      state = this->control().check(step, res);
+      state = this->iteration_status(step, res, *Vx);
       print_vectors(step, *Vx, r, y);
     }
   while (state == SolverControl::iterate);
-  return false;
+  return IterationResult(false, state, step, res);
 }
 
 
@@ -411,17 +448,21 @@ SolverBicgstab<VECTOR>::solve(const MATRIX &A,
 
   step = 0;
 
-  bool state;
+  IterationResult state(false,SolverControl::failure,0,0);
 
+  // iterate while the inner iteration returns a breakdown
   do
     {
       if (step != 0)
         deallog << "Restart step " << step << std::endl;
       if (start(A) == SolverControl::success)
-        break;
+        {
+          state.state = SolverControl::success;
+          break;
+        }
       state = iterate(A, precondition);
     }
-  while (state);
+  while (state.breakdown == true);
 
   this->memory.free(Vr);
   this->memory.free(Vrbar);
@@ -434,9 +475,9 @@ SolverBicgstab<VECTOR>::solve(const MATRIX &A,
   deallog.pop();
 
   // in case of failure: throw exception
-  if (this->control().last_check() != SolverControl::success)
-    AssertThrow(false, SolverControl::NoConvergence (this->control().last_step(),
-                                                     this->control().last_value()));
+  AssertThrow(state.state == SolverControl::success,
+              SolverControl::NoConvergence (state.last_step,
+                                            state.last_residual));
   // otherwise exit as normal
 }
 
index 9f57f281278d01793d856f7726f28fd3a4000289..515af42a24691dae4f157e7aebb5b8f3ba76e373 100644 (file)
@@ -332,6 +332,9 @@ SolverCG<VECTOR>::solve (const MATRIX         &A,
   std::vector<double> diagonal;
   std::vector<double> offdiagonal;
 
+  int  it=0;
+  double res = -std::numeric_limits<double>::max();
+
   try
     {
       // define some aliases for simpler access
@@ -344,10 +347,8 @@ SolverCG<VECTOR>::solve (const MATRIX         &A,
       g.reinit(x, true);
       d.reinit(x, true);
       h.reinit(x, true);
-      // Implementation taken from the DEAL
-      // library
-      int  it=0;
-      double res,gh,alpha,beta;
+
+      double gh,alpha,beta;
 
       // compute residual. if vector is
       // zero, then short-circuit the
@@ -361,8 +362,8 @@ SolverCG<VECTOR>::solve (const MATRIX         &A,
         g.equ(-1.,b);
       res = g.l2_norm();
 
-      conv = this->control().check(0,res);
-      if (conv)
+      conv = this->iteration_status(0, res, x);
+      if (conv != SolverControl::iterate)
         {
           cleanup();
           return;
@@ -397,7 +398,7 @@ SolverCG<VECTOR>::solve (const MATRIX         &A,
 
           print_vectors(it, x, g, d);
 
-          conv = this->control().check(it,res);
+          conv = this->iteration_status(it, res, x);
           if (conv != SolverControl::iterate)
             break;
 
@@ -481,9 +482,8 @@ SolverCG<VECTOR>::solve (const MATRIX         &A,
   // Deallocate Memory
   cleanup();
   // in case of failure: throw exception
-  if (this->control().last_check() != SolverControl::success)
-    AssertThrow(false, SolverControl::NoConvergence (this->control().last_step(),
-                                                     this->control().last_value()));
+  if (conv != SolverControl::success)
+    AssertThrow(false, SolverControl::NoConvergence (it, res));
   // otherwise exit as normal
 }
 
index 9e4d9333258b5cafe563c54c15051918c6ff065a..d01eeb84efdbc590747a54aa111fb1b6dfd0e378 100644 (file)
@@ -623,6 +623,7 @@ SolverGMRES<VECTOR>::solve (const MATRIX         &A,
   unsigned int dim = 0;
 
   SolverControl::State iteration_state = SolverControl::iterate;
+  double last_res = -std::numeric_limits<double>::max();
 
   // switch to determine whether we want a left or a right preconditioner. at
   // present, left is default, but both ways are implemented
@@ -683,8 +684,8 @@ SolverGMRES<VECTOR>::solve (const MATRIX         &A,
       // check here, the next scaling operation would produce garbage
       if (use_default_residual)
         {
-          iteration_state = this->control().check (
-                              accumulated_iterations, rho);
+          last_res = rho;
+          iteration_state = this->iteration_status (accumulated_iterations, rho, x);
 
           if (iteration_state != SolverControl::iterate)
             break;
@@ -702,8 +703,8 @@ SolverGMRES<VECTOR>::solve (const MATRIX         &A,
             precondition.vmult(*r,v);
 
           double res = r->l2_norm();
-          iteration_state = this->control().check (
-                              accumulated_iterations, res);
+          last_res = res;
+          iteration_state = this->iteration_status (accumulated_iterations, res, x);
 
           if (iteration_state != SolverControl::iterate)
             {
@@ -741,7 +742,7 @@ SolverGMRES<VECTOR>::solve (const MATRIX         &A,
             {
               precondition.vmult(p, tmp_vectors[inner_iteration]);
               A.vmult(vv,p);
-            };
+            }
 
           dim = inner_iteration+1;
 
@@ -761,7 +762,7 @@ SolverGMRES<VECTOR>::solve (const MATRIX         &A,
             for (unsigned int i=0; i<dim+1; ++i)
               H_orig(i,inner_iteration) = h(i);
 
-          //  Transformation into triagonal structure
+          //  Transformation into tridiagonal structure
           givens_rotation(h,gamma,ci,si,inner_iteration);
 
           //  append vector on matrix
@@ -772,8 +773,10 @@ SolverGMRES<VECTOR>::solve (const MATRIX         &A,
           rho = std::fabs(gamma(dim));
 
           if (use_default_residual)
-            iteration_state = this->control().check (
-                                accumulated_iterations, rho);
+            {
+              last_res = rho;
+              iteration_state = this->iteration_status (accumulated_iterations, rho, x);
+            }
           else
             {
               deallog << "default_res=" << rho << std::endl;
@@ -806,17 +809,18 @@ SolverGMRES<VECTOR>::solve (const MATRIX         &A,
               if (left_precondition)
                 {
                   const double res=r->l2_norm();
+                  last_res = res;
 
-                  iteration_state = this->control().check (
-                                      accumulated_iterations, res);
+                  iteration_state = this->iteration_status (accumulated_iterations, res, x);
                 }
               else
                 {
                   precondition.vmult(*x_, *r);
                   const double preconditioned_res=x_->l2_norm();
+                  last_res = preconditioned_res;
 
-                  iteration_state = this->control().check (
-                                      accumulated_iterations, preconditioned_res);
+                  iteration_state = this->iteration_status (accumulated_iterations,
+                                                            preconditioned_res, x);
                 }
             }
         };
@@ -878,11 +882,11 @@ SolverGMRES<VECTOR>::solve (const MATRIX         &A,
     }
 
   deallog.pop();
+
   // in case of failure: throw exception
-  if (this->control().last_check() != SolverControl::success)
-    AssertThrow(false, SolverControl::NoConvergence (this->control().last_step(),
-                                                     this->control().last_value()));
-  // otherwise exit as normal
+  AssertThrow(iteration_state == SolverControl::success,
+              SolverControl::NoConvergence (accumulated_iterations,
+                                            last_res));
 }
 
 
@@ -952,6 +956,7 @@ SolverFGMRES<VECTOR>::solve (
   Vector<double> y;
 
   // Iteration starts here
+  double res = -std::numeric_limits<double>::max();
 
   VECTOR *aux = this->memory.alloc();
   aux->reinit(x);
@@ -961,8 +966,9 @@ SolverFGMRES<VECTOR>::solve (
       aux->sadd(-1., 1., b);
 
       double beta = aux->l2_norm();
-      if (this->control().check(accumulated_iterations,beta)
-          == SolverControl::success)
+      res = beta;
+      iteration_state = this->iteration_status(accumulated_iterations, res, x);
+      if (iteration_state == SolverControl::success)
         break;
 
       H.reinit(basis_size+1, basis_size);
@@ -996,17 +1002,22 @@ SolverFGMRES<VECTOR>::solve (
               y.reinit(j);
               projected_rhs(0) = beta;
               H1.fill(H);
+
+              // check convergence. note that the vector 'x' we pass to the
+              // criterion is not the final solution we compute if we
+              // decide to jump out of the iteration (we update 'x' again
+              // right after the current loop)
               Householder<double> house(H1);
-              double res = house.least_squares(y, projected_rhs);
-              iteration_state = this->control().check(++accumulated_iterations, res);
+              res = house.least_squares(y, projected_rhs);
+              iteration_state = this->iteration_status(++accumulated_iterations, res, x);
               if (iteration_state != SolverControl::iterate)
                 break;
             }
         }
+
       // Update solution vector
       for (unsigned int j=0; j<y.size(); ++j)
         x.add(y(j), z[j]);
-
     }
   while (iteration_state == SolverControl::iterate);
 
@@ -1014,9 +1025,9 @@ SolverFGMRES<VECTOR>::solve (
 
   deallog.pop();
   // in case of failure: throw exception
-  if (this->control().last_check() != SolverControl::success)
-    AssertThrow(false, SolverControl::NoConvergence (this->control().last_step(),
-                                                     this->control().last_value()));
+  if (iteration_state != SolverControl::success)
+    AssertThrow(false, SolverControl::NoConvergence (accumulated_iterations,
+                                                     res));
 }
 
 #endif // DOXYGEN
index 72a830adc1a4a70384360f67efcdad75ac4c6fe9..66bbf5ae5d152723a06d9c35e9e2e6d2834e0a21 100644 (file)
@@ -281,7 +281,7 @@ SolverMinRes<VECTOR>::solve (const MATRIX         &A,
   m[1]->reinit(b);
   m[2]->reinit(b);
 
-  conv = this->control().check(0,r_l2);
+  conv = this->iteration_status(0, r_l2, x);
 
   while (conv==SolverControl::iterate)
     {
@@ -321,7 +321,8 @@ SolverMinRes<VECTOR>::solve (const MATRIX         &A,
 
       d = std::sqrt (d_*d_ + delta[2]);
 
-      if (j>1) tau *= s / c;
+      if (j>1)
+        tau *= s / c;
       c = d_ / d;
       tau *= c;
 
@@ -337,7 +338,7 @@ SolverMinRes<VECTOR>::solve (const MATRIX         &A,
       x.add (tau, *m[0]);
       r_l2 *= std::fabs(s);
 
-      conv = this->control().check(j,r_l2);
+      conv = this->iteration_status(j, r_l2, x);
 
       // next iteration step
       ++j;
@@ -380,9 +381,9 @@ SolverMinRes<VECTOR>::solve (const MATRIX         &A,
   deallog.pop ();
 
   // in case of failure: throw exception
-  if (this->control().last_check() != SolverControl::success)
-    AssertThrow(false, SolverControl::NoConvergence (this->control().last_step(),
-                                                     this->control().last_value()));
+  AssertThrow(conv == SolverControl::success,
+              SolverControl::NoConvergence (j, r_l2));
+
   // otherwise exit as normal
 }
 
index 545804866abfc4ad24d47790ba4d6a238fcf8624..cbd3234c1c541cb5562dcead59fc16e4c85098a2 100644 (file)
@@ -189,19 +189,39 @@ protected:
    * the square root of the @p res2 value.
    */
   double res2;
+
   /**
-   * Additional parameters..
+   * Additional parameters.
    */
   AdditionalData additional_data;
+
 private:
+
+  /**
+   * A structure returned by the iterate() function representing
+   * what it found is happening during the iteration.
+   */
+  struct IterationResult
+  {
+    SolverControl::State state;
+    double               last_residual;
+
+    IterationResult (const SolverControl::State state,
+                     const double               last_residual);
+  };
+
+
   /**
-   * The iteration loop itself.
+   * The iteration loop itself. The function returns a structure
+   * indicating what happened in this function.
    */
   template<class MATRIX, class PRECONDITIONER>
-  bool
-  iterate(const MATRIX &A, const PRECONDITIONER &precondition);
+  IterationResult
+  iterate (const MATRIX &A,
+           const PRECONDITIONER &precondition);
+
   /**
-   * The current iteration step.
+   * Number of the current iteration (accumulated over restarts)
    */
   unsigned int step;
 };
@@ -211,6 +231,15 @@ private:
 
 #ifndef DOXYGEN
 
+template<class VECTOR>
+SolverQMRS<VECTOR>::IterationResult::IterationResult(const SolverControl::State state,
+                                                     const double               last_residual)
+  :
+  state (state),
+  last_residual (last_residual)
+{}
+
+
 template<class VECTOR>
 SolverQMRS<VECTOR>::SolverQMRS(SolverControl &cn,
                                VectorMemory<VECTOR> &mem,
@@ -280,15 +309,15 @@ SolverQMRS<VECTOR>::solve (const MATRIX         &A,
 
   step = 0;
 
-  bool state;
+  IterationResult state (SolverControl::failure,0);
 
   do
     {
-      if (step)
+      if (step > 0)
         deallog << "Restart step " << step << std::endl;
       state = iterate(A, precondition);
     }
-  while (state);
+  while (state.state == SolverControl::iterate);
 
   // Deallocate Memory
   this->memory.free(Vv);
@@ -301,9 +330,9 @@ SolverQMRS<VECTOR>::solve (const MATRIX         &A,
   deallog.pop();
 
   // in case of failure: throw exception
-  if (this->control().last_check() != SolverControl::success)
-    AssertThrow(false, SolverControl::NoConvergence (this->control().last_step(),
-                                                     this->control().last_value()));
+  AssertThrow(state.state == SolverControl::success,
+              SolverControl::NoConvergence (step,
+                                            state.last_residual));
   // otherwise exit as normal
 }
 
@@ -311,7 +340,7 @@ SolverQMRS<VECTOR>::solve (const MATRIX         &A,
 
 template<class VECTOR>
 template<class MATRIX, class PRECONDITIONER>
-bool
+typename SolverQMRS<VECTOR>::IterationResult
 SolverQMRS<VECTOR>::iterate(const MATRIX         &A,
                             const PRECONDITIONER &precondition)
 {
@@ -346,8 +375,8 @@ SolverQMRS<VECTOR>::iterate(const MATRIX         &A,
   v.sadd(-1.,1.,b);
   res = v.l2_norm();
 
-  if (this->control().check(step, res) == SolverControl::success)
-    return false;
+  if (this->iteration_status(step, res, x) == SolverControl::success)
+    return IterationResult(SolverControl::success, res);
 
   p = v;
 
@@ -367,7 +396,7 @@ SolverQMRS<VECTOR>::iterate(const MATRIX         &A,
 
 //TODO:[?] Find a really good breakdown criterion. The absolute one detects breakdown instead of convergence
       if (std::fabs(sigma/rho) < additional_data.breakdown)
-        return true;
+        return IterationResult(SolverControl::iterate, std::fabs(sigma/rho));
       // Step 3
       alpha = rho/sigma;
 
@@ -391,13 +420,13 @@ SolverQMRS<VECTOR>::iterate(const MATRIX         &A,
         }
       else
         res = std::sqrt((it+1)*tau);
-      state = this->control().check(step,res);
+      state = this->iteration_status(step,res,x);
       if ((state == SolverControl::success)
           || (state == SolverControl::failure))
-        return false;
+        return IterationResult(state, res);
       // Step 6
       if (std::fabs(rho) < additional_data.breakdown)
-        return true;
+        return IterationResult(SolverControl::iterate, std::fabs(rho));
       // Step 7
       rho_old = rho;
       precondition.vmult(q,v);
@@ -407,7 +436,7 @@ SolverQMRS<VECTOR>::iterate(const MATRIX         &A,
       p.sadd(beta,v);
       precondition.vmult(q,p);
     }
-  return false;
+  return IterationResult(SolverControl::success, std::fabs(rho));
 }
 
 #endif // DOXYGEN
index 491f8afd0f40edf187ae5bf2f58777c5149c5530..22e40e8e2af4ce2f194e59c98b6eeabcb05557ae 100644 (file)
@@ -122,10 +122,11 @@ SolverRelaxation<VECTOR>::solve (
 
   deallog.push("Relaxation");
 
+  int iter=0;
   try
     {
       // Main loop
-      for (int iter=0; conv==SolverControl::iterate; iter++)
+      for (; conv==SolverControl::iterate; iter++)
         {
           // Compute residual
           A.vmult(r,x);
@@ -136,7 +137,7 @@ SolverRelaxation<VECTOR>::solve (
           // residual is computed in
           // criterion() and stored
           // in res.
-          conv = this->control().check (iter, r.l2_norm());
+          conv = this->iteration_status (iter, r.l2_norm(), x);
           if (conv != SolverControl::iterate)
             break;
           R.step(x,b);
@@ -150,9 +151,8 @@ SolverRelaxation<VECTOR>::solve (
   deallog.pop();
 
   // in case of failure: throw exception
-  if (this->control().last_check() != SolverControl::success)
-    AssertThrow(false, SolverControl::NoConvergence (this->control().last_step(),
-                                                     this->control().last_value()));
+  AssertThrow(conv == SolverControl::success,
+              SolverControl::NoConvergence (iter, r.l2_norm()));
   // otherwise exit as normal
 }
 
index 5ce4178a9f0e048bcaf803a26dacf6823e3752f6..9e2938227a287ac4239cb3fecea823bf4b6fe070 100644 (file)
@@ -237,6 +237,10 @@ SolverRichardson<VECTOR>::solve (const MATRIX         &A,
 {
   SolverControl::State conv=SolverControl::iterate;
 
+  double last_criterion = -std::numeric_limits<double>::max();
+
+  unsigned int iter = 0;
+
   // Memory allocation
   Vr  = this->memory.alloc();
   VECTOR &r  = *Vr;
@@ -250,7 +254,7 @@ SolverRichardson<VECTOR>::solve (const MATRIX         &A,
   try
     {
       // Main loop
-      for (int iter=0; conv==SolverControl::iterate; iter++)
+      while (conv==SolverControl::iterate)
         {
           // Do not use residual,
           // but do it in 2 steps
@@ -263,13 +267,15 @@ SolverRichardson<VECTOR>::solve (const MATRIX         &A,
           // residual is computed in
           // criterion() and stored
           // in res.
-          conv = this->control().check (iter, criterion());
-//        conv = this->control().check (iter, std::sqrt(A.matrix_norm_square(r)));
+          last_criterion = criterion();
+          conv = this->iteration_status (iter, last_criterion, x);
           if (conv != SolverControl::iterate)
             break;
 
           x.add(additional_data.omega,d);
           print_vectors(iter,x,r,d);
+
+          ++iter;
         }
     }
   catch (...)
@@ -285,9 +291,9 @@ SolverRichardson<VECTOR>::solve (const MATRIX         &A,
   deallog.pop();
 
   // in case of failure: throw exception
-  if (this->control().last_check() != SolverControl::success)
-    AssertThrow(false, SolverControl::NoConvergence (this->control().last_step(),
-                                                     this->control().last_value()));
+  if (conv != SolverControl::success)
+    AssertThrow(false, SolverControl::NoConvergence (iter,
+                                                     last_criterion));
   // otherwise exit as normal
 }
 
@@ -301,6 +307,9 @@ SolverRichardson<VECTOR>::Tsolve (const MATRIX         &A,
                                   const PRECONDITIONER &precondition)
 {
   SolverControl::State conv=SolverControl::iterate;
+  double last_criterion = -std::numeric_limits<double>::max();
+
+  unsigned int iter = 0;
 
   // Memory allocation
   Vr  = this->memory.alloc();
@@ -315,7 +324,7 @@ SolverRichardson<VECTOR>::Tsolve (const MATRIX         &A,
   try
     {
       // Main loop
-      for (int iter=0; conv==SolverControl::iterate; iter++)
+      while (conv==SolverControl::iterate)
         {
           // Do not use Tresidual,
           // but do it in 2 steps
@@ -323,12 +332,15 @@ SolverRichardson<VECTOR>::Tsolve (const MATRIX         &A,
           r.sadd(-1.,1.,b);
           precondition.Tvmult(d,r);
 
-          conv = this->control().check (iter, criterion());
+          last_criterion = criterion();
+          conv = this->iteration_status (iter, last_criterion, x);
           if (conv != SolverControl::iterate)
             break;
 
           x.add(additional_data.omega,d);
           print_vectors(iter,x,r,d);
+
+          ++iter;
         }
     }
   catch (...)
@@ -344,9 +356,9 @@ SolverRichardson<VECTOR>::Tsolve (const MATRIX         &A,
   this->memory.free(Vd);
   deallog.pop();
   // in case of failure: throw exception
-  if (this->control().last_check() != SolverControl::success)
-    AssertThrow(false, SolverControl::NoConvergence (this->control().last_step(),
-                                                     this->control().last_value()));
+  if (conv != SolverControl::success)
+    AssertThrow(false, SolverControl::NoConvergence (iter, last_criterion));
+
   // otherwise exit as normal
 }
 
index 69f167dc77e9da77afff692f993210f6b648d436..ee108412eb8868eec0309875c517db98803261be 100644 (file)
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2004 - 2013 by the deal.II authors
+// Copyright (C) 2004 - 2014 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -39,7 +39,9 @@
 
 template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
 void
-check_solve( SOLVER &solver, const MATRIX &A,
+check_solve( SOLVER &solver,
+            const SolverControl &solver_control,
+            const MATRIX &A,
              VECTOR &u, VECTOR &f, const PRECONDITION &P)
 {
   deallog << "Solver type: " << typeid(solver).name() << std::endl;
@@ -56,7 +58,7 @@ check_solve( SOLVER &solver, const MATRIX &A,
       abort ();
     }
 
-  deallog << "Solver stopped after " << solver.control().last_step()
+  deallog << "Solver stopped after " << solver_control.last_step()
           << " iterations" << std::endl;
 }
 
@@ -91,6 +93,6 @@ int main()
 
   SolverMinRes<> solver(control, mem);
   PreconditionIdentity preconditioner;
-  check_solve (solver, A,u,f, preconditioner);
+  check_solve (solver, control, A,u,f, preconditioner);
 }
 
index 5154b0810627cc4020ee89202c5bc3ff722a7e05..05c46a9ca50463ff726c3fa4cdd98df00d817f21 100644 (file)
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2004 - 2013 by the deal.II authors
+// Copyright (C) 2004 - 2014 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -38,7 +38,9 @@
 
 template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
 void
-check_solve( SOLVER &solver, const MATRIX &A,
+check_solve( SOLVER &solver,
+            const SolverControl &solver_control,
+            const MATRIX &A,
              VECTOR &u, VECTOR &f, const PRECONDITION &P)
 {
   deallog << "Solver type: " << typeid(solver).name() << std::endl;
@@ -55,7 +57,7 @@ check_solve( SOLVER &solver, const MATRIX &A,
       abort ();
     }
 
-  deallog << "Solver stopped after " << solver.control().last_step()
+  deallog << "Solver stopped after " << solver_control.last_step()
           << " iterations" << std::endl;
 }
 
@@ -90,6 +92,6 @@ int main()
 
   SolverQMRS<> solver(control, mem);
   PreconditionIdentity preconditioner;
-  check_solve (solver, A,u,f, preconditioner);
+  check_solve (solver, control, A,u,f, preconditioner);
 }
 
index c5eda03ebd235c1e22ec94a53c315540e9b4c202..d77ff53976cdbacd6bc53f9e2dcbba87731a05b8 100644 (file)
@@ -55,7 +55,7 @@ DEAL:sor:Richardson::Starting value 3.000
 DEAL:sor:Richardson::Convergence step 7 value 0.0004339
 DEAL:sor:cg::Starting value 3.000
 DEAL:sor:cg::Failure step 100 value 0.2585
-DEAL:sor::Exception: SolverControl::NoConvergence (this->control().last_step(), this->control().last_value())
+DEAL:sor::Exception: SolverControl::NoConvergence (it, res)
 DEAL:sor:Bicgstab::Starting value 3.000
 DEAL:sor:Bicgstab::Convergence step 5 value 0
 DEAL:sor:GMRES::Starting value 1.462
@@ -70,7 +70,7 @@ DEAL:psor:Richardson::Starting value 3.000
 DEAL:psor:Richardson::Convergence step 8 value 0.0004237
 DEAL:psor:cg::Starting value 3.000
 DEAL:psor:cg::Failure step 100 value 0.1024
-DEAL:psor::Exception: SolverControl::NoConvergence (this->control().last_step(), this->control().last_value())
+DEAL:psor::Exception: SolverControl::NoConvergence (it, res)
 DEAL:psor:Bicgstab::Starting value 3.000
 DEAL:psor:Bicgstab::Convergence step 4 value 0.0007969
 DEAL:psor:GMRES::Starting value 1.467
@@ -81,23 +81,23 @@ DEAL::Size 12 Unknowns 121
 DEAL::SOR-diff:0
 DEAL:no-fail:cg::Starting value 11.00
 DEAL:no-fail:cg::Failure step 10 value 0.1496
-DEAL:no-fail::Exception: SolverControl::NoConvergence (this->control().last_step(), this->control().last_value())
+DEAL:no-fail::Exception: SolverControl::NoConvergence (it, res)
 DEAL:no-fail:Bicgstab::Starting value 11.00
 DEAL:no-fail:Bicgstab::Failure step 10 value 0.002830
 DEAL:no-fail:Bicgstab::Failure step 10 value 0.001961
-DEAL:no-fail::Exception: SolverControl::NoConvergence (this->control().last_step(), this->control().last_value())
+DEAL:no-fail::Exception: SolverControl::NoConvergence (state.last_step, state.last_residual)
 DEAL:no-fail:GMRES::Starting value 11.00
 DEAL:no-fail:GMRES::Failure step 10 value 0.8414
-DEAL:no-fail::Exception: SolverControl::NoConvergence (this->control().last_step(), this->control().last_value())
+DEAL:no-fail::Exception: SolverControl::NoConvergence (accumulated_iterations, last_res)
 DEAL:no-fail:GMRES::Starting value 11.00
 DEAL:no-fail:GMRES::Failure step 10 value 0.8414
-DEAL:no-fail::Exception: SolverControl::NoConvergence (this->control().last_step(), this->control().last_value())
+DEAL:no-fail::Exception: SolverControl::NoConvergence (accumulated_iterations, last_res)
 DEAL:no-fail:QMRS::Starting value 11.00
 DEAL:no-fail:QMRS::Failure step 10 value 0.4215
-DEAL:no-fail::Exception: SolverControl::NoConvergence (this->control().last_step(), this->control().last_value())
+DEAL:no-fail::Exception: SolverControl::NoConvergence (step, state.last_residual)
 DEAL:no:Richardson::Starting value 11.00
 DEAL:no:Richardson::Failure step 100 value 0.3002
-DEAL:no::Exception: SolverControl::NoConvergence (this->control().last_step(), this->control().last_value())
+DEAL:no::Exception: SolverControl::NoConvergence (iter, last_criterion)
 DEAL:no:cg::Starting value 11.00
 DEAL:no:cg::Convergence step 15 value 0.0005794
 DEAL:no:Bicgstab::Starting value 11.00
@@ -110,7 +110,7 @@ DEAL:no:QMRS::Starting value 11.00
 DEAL:no:QMRS::Convergence step 16 value 0.0002583
 DEAL:rich:Richardson::Starting value 11.00
 DEAL:rich:Richardson::Failure step 100 value 1.219
-DEAL:rich::Exception: SolverControl::NoConvergence (this->control().last_step(), this->control().last_value())
+DEAL:rich::Exception: SolverControl::NoConvergence (iter, last_criterion)
 DEAL:rich:cg::Starting value 11.00
 DEAL:rich:cg::Convergence step 15 value 0.0005794
 DEAL:rich:Bicgstab::Starting value 11.00
@@ -141,7 +141,7 @@ DEAL:sor:Richardson::Starting value 11.00
 DEAL:sor:Richardson::Convergence step 88 value 0.0009636
 DEAL:sor:cg::Starting value 11.00
 DEAL:sor:cg::Failure step 100 value 5.643
-DEAL:sor::Exception: SolverControl::NoConvergence (this->control().last_step(), this->control().last_value())
+DEAL:sor::Exception: SolverControl::NoConvergence (it, res)
 DEAL:sor:Bicgstab::Starting value 11.00
 DEAL:sor:Bicgstab::Convergence step 14 value 0.0009987
 DEAL:sor:GMRES::Starting value 7.322
@@ -154,7 +154,7 @@ DEAL:psor:Richardson::Starting value 11.00
 DEAL:psor:Richardson::Convergence step 89 value 0.0009736
 DEAL:psor:cg::Starting value 11.00
 DEAL:psor:cg::Failure step 100 value 2.935
-DEAL:psor::Exception: SolverControl::NoConvergence (this->control().last_step(), this->control().last_value())
+DEAL:psor::Exception: SolverControl::NoConvergence (it, res)
 DEAL:psor:Bicgstab::Starting value 11.00
 DEAL:psor:Bicgstab::Convergence step 11 value 0.0005151
 DEAL:psor:GMRES::Starting value 7.345
index a407848c2393089337a84543214f4e98fef6f789..609ea6e9a6f28a6ba3e04de49059e7ef1f590eb9 100644 (file)
@@ -29,7 +29,7 @@ DEAL:no-fail:cg::Condition number estimate: 53.54
 DEAL:no-fail:cg::Condition number estimate: 54.75
 DEAL:no-fail:cg::Failure step 10 value 0.1496
 DEAL:no-fail:cg:: 0.1363 0.6565 1.499 2.357 3.131 3.994 5.392 6.576 7.464
-DEAL:no-fail::Exception: SolverControl::NoConvergence (this->control().last_step(), this->control().last_value())
+DEAL:no-fail::Exception: SolverControl::NoConvergence (it, res)
 DEAL:no:cg::Starting value 11.00
 DEAL:no:cg::Condition number estimate: 11.01
 DEAL:no:cg::Condition number estimate: 21.10
index c0f4a69a4f123facce5300044cb15ec9fb7a96de..51fe0842809e1158dedae9d9764d4f0ff8dadc28 100644 (file)
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2004 - 2013 by the deal.II authors
+// Copyright (C) 2004 - 2014 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -38,7 +38,9 @@
 
 template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
 void
-check_solve( SOLVER &solver, const MATRIX &A,
+check_solve( SOLVER &solver,
+            const SolverControl &solver_control,
+            const MATRIX &A,
              VECTOR &u, VECTOR &f, const PRECONDITION &P)
 {
   deallog << "Solver type: " << typeid(solver).name() << std::endl;
@@ -55,7 +57,7 @@ check_solve( SOLVER &solver, const MATRIX &A,
       abort ();
     }
 
-  deallog << "Solver stopped after " << solver.control().last_step()
+  deallog << "Solver stopped after " << solver_control.last_step()
           << " iterations" << std::endl;
 }
 
@@ -92,7 +94,7 @@ int main(int argc, char **argv)
     GrowingVectorMemory<PETScWrappers::Vector> mem;
     SolverCG<PETScWrappers::Vector> solver(control,mem);
     PreconditionIdentity preconditioner;
-    check_solve (solver, A,u,f, preconditioner);
+    check_solve (solver, control, A,u,f, preconditioner);
   }
   GrowingVectorMemory<PETScWrappers::Vector>::release_unused_memory ();
 
index c6ed17c75d2b200fdb498ca104391c03fb59f10f..b45cb28dff7da959c4edf343c2950e995a158e45 100644 (file)
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2004 - 2013 by the deal.II authors
+// Copyright (C) 2004 - 2014 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -40,7 +40,9 @@
 
 template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
 void
-check_solve( SOLVER &solver, const MATRIX &A,
+check_solve( SOLVER &solver,
+            const SolverControl &solver_control,
+            const MATRIX &A,
              VECTOR &u, VECTOR &f, const PRECONDITION &P)
 {
   deallog << "Solver type: " << typeid(solver).name() << std::endl;
@@ -60,7 +62,7 @@ check_solve( SOLVER &solver, const MATRIX &A,
       abort ();
     }
 
-  const unsigned int steps = solver.control().last_step();
+  const unsigned int steps = solver_control.last_step();
   if (steps >= 49 && steps <= 51)
     {
       deallog << "Solver stopped within 49 - 51 iterations"
@@ -68,7 +70,7 @@ check_solve( SOLVER &solver, const MATRIX &A,
     }
   else
     {
-      deallog << "Solver stopped after " << solver.control().last_step()
+      deallog << "Solver stopped after " << solver_control.last_step()
               << " iterations" << std::endl;
     }
 }
@@ -106,7 +108,7 @@ int main(int argc, char **argv)
     GrowingVectorMemory<PETScWrappers::Vector> mem;
     SolverBicgstab<PETScWrappers::Vector> solver(control,mem);
     PreconditionIdentity preconditioner;
-    check_solve (solver, A,u,f, preconditioner);
+    check_solve (solver, control, A,u,f, preconditioner);
   }
   GrowingVectorMemory<PETScWrappers::Vector>::release_unused_memory ();
 
index 87797610f455b7c3a9b1cbc40b4e116cc3397a24..3edb73d612c1b81a4dd1b12b40289c5c86711765 100644 (file)
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2004 - 2013 by the deal.II authors
+// Copyright (C) 2004 - 2014 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -40,7 +40,9 @@
 
 template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
 void
-check_solve( SOLVER &solver, const MATRIX &A,
+check_solve( SOLVER &solver,
+            const SolverControl &solver_control,
+            const MATRIX &A,
              VECTOR &u, VECTOR &f, const PRECONDITION &P)
 {
   deallog << "Solver type: " << typeid(solver).name() << std::endl;
@@ -57,7 +59,7 @@ check_solve( SOLVER &solver, const MATRIX &A,
       abort ();
     }
 
-  deallog << "Solver stopped after " << solver.control().last_step()
+  deallog << "Solver stopped after " << solver_control.last_step()
           << " iterations" << std::endl;
 }
 
@@ -94,7 +96,7 @@ int main(int argc, char **argv)
     GrowingVectorMemory<PETScWrappers::Vector> mem;
     SolverGMRES<PETScWrappers::Vector> solver(control,mem);
     PreconditionIdentity preconditioner;
-    check_solve (solver, A,u,f, preconditioner);
+    check_solve (solver, control, A,u,f, preconditioner);
   }
   GrowingVectorMemory<PETScWrappers::Vector>::release_unused_memory ();
 
index 2ee73c6efc7c3679465303cfd41b1de5f3aedf73..d3f932664b862913476646b782e1097fb71ec9cb 100644 (file)
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2004 - 2013 by the deal.II authors
+// Copyright (C) 2004 - 2014 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -39,7 +39,9 @@
 
 template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
 void
-check_solve( SOLVER &solver, const MATRIX &A,
+check_solve( SOLVER &solver,
+            const SolverControl &solver_control,
+            const MATRIX &A,
              VECTOR &u, VECTOR &f, const PRECONDITION &P)
 {
   deallog << "Solver type: " << typeid(solver).name() << std::endl;
@@ -56,7 +58,7 @@ check_solve( SOLVER &solver, const MATRIX &A,
       abort ();
     }
 
-  deallog << "Solver stopped after " << solver.control().last_step()
+  deallog << "Solver stopped after " << solver_control.last_step()
           << " iterations" << std::endl;
 }
 
@@ -93,7 +95,7 @@ int main(int argc, char **argv)
     GrowingVectorMemory<PETScWrappers::Vector> mem;
     SolverMinRes<PETScWrappers::Vector> solver(control,mem);
     PreconditionIdentity preconditioner;
-    check_solve (solver, A,u,f, preconditioner);
+    check_solve (solver, control, A,u,f, preconditioner);
   }
   GrowingVectorMemory<PETScWrappers::Vector>::release_unused_memory ();
 
index b7c165cea88b787dcd22b9da670415e79d1f473b..ce225df08d4eb8f6c64913b72ad1c63d6ea3b06c 100644 (file)
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2004 - 2013 by the deal.II authors
+// Copyright (C) 2004 - 2014 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -38,7 +38,9 @@
 
 template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
 void
-check_solve( SOLVER &solver, const MATRIX &A,
+check_solve( SOLVER &solver,
+            const SolverControl &solver_control,
+            const MATRIX &A,
              VECTOR &u, VECTOR &f, const PRECONDITION &P)
 {
   deallog << "Solver type: " << typeid(solver).name() << std::endl;
@@ -55,7 +57,7 @@ check_solve( SOLVER &solver, const MATRIX &A,
       abort ();
     }
 
-  deallog << "Solver stopped after " << solver.control().last_step()
+  deallog << "Solver stopped after " << solver_control.last_step()
           << " iterations" << std::endl;
 }
 
@@ -92,7 +94,7 @@ int main(int argc, char **argv)
     GrowingVectorMemory<PETScWrappers::Vector> mem;
     SolverQMRS<PETScWrappers::Vector> solver(control,mem);
     PreconditionIdentity preconditioner;
-    check_solve (solver, A,u,f, preconditioner);
+    check_solve (solver, control, A,u,f, preconditioner);
   }
   GrowingVectorMemory<PETScWrappers::Vector>::release_unused_memory ();
 
index 427c60fe5bcbfbec047524dab84c5a83a6133950..0294903e5504430c0d99d7502e6e14a27d509e40 100644 (file)
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2004 - 2013 by the deal.II authors
+// Copyright (C) 2004 - 2014 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -33,7 +33,9 @@
 
 template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
 void
-check_solve( SOLVER &solver, const MATRIX &A,
+check_solve( SOLVER &solver,
+            const SolverControl &solver_control,
+            const MATRIX &A,
              VECTOR &u, VECTOR &f, const PRECONDITION &P)
 {
   deallog << "Solver type: " << typeid(solver).name() << std::endl;
@@ -49,7 +51,7 @@ check_solve( SOLVER &solver, const MATRIX &A,
       deallog << "Exception: " << e.get_exc_name() << std::endl;
     }
 
-  deallog << "Solver stopped after " << solver.control().last_step()
+  deallog << "Solver stopped after " << solver_control.last_step()
           << " iterations" << std::endl;
 }
 
@@ -85,7 +87,7 @@ int main(int argc, char **argv)
 
     PETScWrappers::SolverRichardson solver(control);
     PETScWrappers::PreconditionJacobi preconditioner(A);
-    check_solve (solver, A,u,f, preconditioner);
+    check_solve (solver, control, A,u,f, preconditioner);
   }
 
 }
index 0a5caf7bedb352338fb109460248050665ffda0a..372fe4acc783f417db76f9c317f3c6a4db61ec98 100644 (file)
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2004 - 2013 by the deal.II authors
+// Copyright (C) 2004 - 2014 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -33,7 +33,9 @@
 
 template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
 void
-check_solve( SOLVER &solver, const MATRIX &A,
+check_solve( SOLVER &solver,
+            const SolverControl &solver_control,
+            const MATRIX &A,
              VECTOR &u, VECTOR &f, const PRECONDITION &P)
 {
   deallog << "Solver type: " << typeid(solver).name() << std::endl;
@@ -52,7 +54,7 @@ check_solve( SOLVER &solver, const MATRIX &A,
       deallog << "Exception: " << e.get_exc_name() << std::endl;
     }
 
-  deallog << "Solver stopped after " << solver.control().last_step()
+  deallog << "Solver stopped after " << solver_control.last_step()
           << " iterations" << std::endl;
 }
 
@@ -88,7 +90,7 @@ int main(int argc, char **argv)
 
     PETScWrappers::SolverChebychev solver(control);
     PETScWrappers::PreconditionJacobi preconditioner(A);
-    check_solve (solver, A,u,f, preconditioner);
+    check_solve (solver, control, A,u,f, preconditioner);
   }
 
 }
index 4960762653337208d1defb325474451d18365fc9..c8ba190a513893bfb4e21a0d92d789cdbbdbc902 100644 (file)
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2004 - 2013 by the deal.II authors
+// Copyright (C) 2004 - 2014 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -33,7 +33,9 @@
 
 template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
 void
-check_solve( SOLVER &solver, const MATRIX &A,
+check_solve( SOLVER &solver,
+            const SolverControl &solver_control,
+            const MATRIX &A,
              VECTOR &u, VECTOR &f, const PRECONDITION &P)
 {
   deallog << "Solver type: " << typeid(solver).name() << std::endl;
@@ -50,7 +52,7 @@ check_solve( SOLVER &solver, const MATRIX &A,
       abort ();
     }
 
-  deallog << "Solver stopped after " << solver.control().last_step()
+  deallog << "Solver stopped after " << solver_control.last_step()
           << " iterations" << std::endl;
 }
 
@@ -86,7 +88,7 @@ int main(int argc, char **argv)
 
     PETScWrappers::SolverCG solver(control);
     PETScWrappers::PreconditionJacobi preconditioner(A);
-    check_solve (solver, A,u,f, preconditioner);
+    check_solve (solver, control, A,u,f, preconditioner);
   }
 
 }
index 300a874561984d286a3bd95f3c1ca9ff9c0f7b5d..ad3b8eae4c649c2c879f290505921cdabf62da7c 100644 (file)
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2004 - 2013 by the deal.II authors
+// Copyright (C) 2004 - 2014 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -33,7 +33,9 @@
 
 template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
 void
-check_solve( SOLVER &solver, const MATRIX &A,
+check_solve( SOLVER &solver,
+            const SolverControl &solver_control,
+            const MATRIX &A,
              VECTOR &u, VECTOR &f, const PRECONDITION &P)
 {
   deallog << "Solver type: " << typeid(solver).name() << std::endl;
@@ -51,7 +53,7 @@ check_solve( SOLVER &solver, const MATRIX &A,
       abort ();
     }
 
-  deallog << "Solver stopped after " << solver.control().last_step()
+  deallog << "Solver stopped after " << solver_control.last_step()
           << " iterations" << std::endl;
 }
 
@@ -84,7 +86,7 @@ int main(int argc, char **argv)
 
     PETScWrappers::SolverCG solver(control);
     PETScWrappers::PreconditionNone preconditioner(A);
-    check_solve (solver, A,u,f, preconditioner);
+    check_solve (solver, control, A,u,f, preconditioner);
   }
 
 }
index 809d85534c7124f66ecc67790afec0ee0f579ddc..3952dd18c1a11d88818c693ed499a88dc837ae29 100644 (file)
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2004 - 2013 by the deal.II authors
+// Copyright (C) 2004 - 2014 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -34,7 +34,9 @@
 
 template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
 void
-check_solve( SOLVER &solver, const MATRIX &A,
+check_solve( SOLVER &solver,
+            const SolverControl &solver_control,
+            const MATRIX &A,
              VECTOR &u, VECTOR &f, const PRECONDITION &P)
 {
   deallog << "Solver type: " << typeid(solver).name() << std::endl;
@@ -51,7 +53,7 @@ check_solve( SOLVER &solver, const MATRIX &A,
       abort ();
     }
 
-  deallog << "Solver stopped after " << solver.control().last_step()
+  deallog << "Solver stopped after " << solver_control.last_step()
           << " iterations" << std::endl;
 }
 
@@ -87,7 +89,7 @@ int main(int argc, char **argv)
 
     PETScWrappers::SolverCG solver(control);
     PETScWrappers::PreconditionBoomerAMG preconditioner(A);
-    check_solve (solver, A,u,f, preconditioner);
+    check_solve (solver, control, A,u,f, preconditioner);
   }
 
 }
index 7d40747ce68e57bdb18ab340ee8d3301464843db..c301083b4ac221c5777591aa7bc5317685d94af7 100644 (file)
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2004 - 2013 by the deal.II authors
+// Copyright (C) 2004 - 2014 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -35,7 +35,9 @@
 
 template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
 void
-check_solve( SOLVER &solver, const MATRIX &A,
+check_solve( SOLVER &solver,
+            const SolverControl &solver_control,
+            const MATRIX &A,
              VECTOR &u, VECTOR &f, const PRECONDITION &P)
 {
   deallog << "Solver type: " << typeid(solver).name() << std::endl;
@@ -52,7 +54,7 @@ check_solve( SOLVER &solver, const MATRIX &A,
       abort ();
     }
 
-  deallog << "Solver stopped after " << solver.control().last_step()
+  deallog << "Solver stopped after " << solver_control.last_step()
           << " iterations" << std::endl;
 }
 
@@ -88,7 +90,7 @@ int main(int argc, char **argv)
 
     PETScWrappers::SolverCG solver(control);
     PETScWrappers::PreconditionBoomerAMG preconditioner(A, true);
-    check_solve (solver, A,u,f, preconditioner);
+    check_solve (solver, control, A,u,f, preconditioner);
   }
 
 }
index 8c8e2fb76f64d089a5eabbeb23f02769273146d8..8528015206656887c446a62396a01dfa57bec690 100644 (file)
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2004 - 2013 by the deal.II authors
+// Copyright (C) 2004 - 2014 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -33,7 +33,9 @@
 
 template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
 void
-check_solve( SOLVER &solver, const MATRIX &A,
+check_solve( SOLVER &solver,
+            const SolverControl &solver_control,
+            const MATRIX &A,
              VECTOR &u, VECTOR &f, const PRECONDITION &P)
 {
   deallog << "Solver type: " << typeid(solver).name() << std::endl;
@@ -50,7 +52,7 @@ check_solve( SOLVER &solver, const MATRIX &A,
       abort ();
     }
 
-  deallog << "Solver stopped after " << solver.control().last_step()
+  deallog << "Solver stopped after " << solver_control.last_step()
           << " iterations" << std::endl;
 }
 
@@ -86,7 +88,7 @@ int main(int argc, char **argv)
 
     PETScWrappers::SolverCG solver(control);
     PETScWrappers::PreconditionEisenstat preconditioner(A);
-    check_solve (solver, A,u,f, preconditioner);
+    check_solve (solver, control, A,u,f, preconditioner);
   }
 
 }
index 2d8655d9ea9adadbfa56083ddac8f441d39db448..6f3fa7708a7d60b2fe1c37df2dfb787f5fc1e55a 100644 (file)
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2004 - 2013 by the deal.II authors
+// Copyright (C) 2004 - 2014 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -33,7 +33,9 @@
 
 template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
 void
-check_solve( SOLVER &solver, const MATRIX &A,
+check_solve( SOLVER &solver,
+            const SolverControl &solver_control,
+            const MATRIX &A,
              VECTOR &u, VECTOR &f, const PRECONDITION &P)
 {
   deallog << "Solver type: " << typeid(solver).name() << std::endl;
@@ -50,7 +52,7 @@ check_solve( SOLVER &solver, const MATRIX &A,
       abort ();
     }
 
-  deallog << "Solver stopped after " << solver.control().last_step()
+  deallog << "Solver stopped after " << solver_control.last_step()
           << " iterations" << std::endl;
 }
 
@@ -86,7 +88,7 @@ int main(int argc, char **argv)
 
     PETScWrappers::SolverCG solver(control);
     PETScWrappers::PreconditionICC preconditioner(A);
-    check_solve (solver, A,u,f, preconditioner);
+    check_solve (solver, control, A,u,f, preconditioner);
   }
 
 }
index b561b7473f8615f6863f4597ee94174ab1e76567..7d5ce9fe6510a3af33da01dd5aa17c68a27a10ee 100644 (file)
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2004 - 2013 by the deal.II authors
+// Copyright (C) 2004 - 2014 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -33,7 +33,9 @@
 
 template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
 void
-check_solve( SOLVER &solver, const MATRIX &A,
+check_solve( SOLVER &solver,
+            const SolverControl &solver_control,
+            const MATRIX &A,
              VECTOR &u, VECTOR &f, const PRECONDITION &P)
 {
   deallog << "Solver type: " << typeid(solver).name() << std::endl;
@@ -50,7 +52,7 @@ check_solve( SOLVER &solver, const MATRIX &A,
       abort ();
     }
 
-  deallog << "Solver stopped after " << solver.control().last_step()
+  deallog << "Solver stopped after " << solver_control.last_step()
           << " iterations" << std::endl;
 }
 
@@ -85,7 +87,7 @@ int main(int argc, char **argv)
 
     PETScWrappers::SolverCG solver(control);
     PETScWrappers::PreconditionILU preconditioner(A);
-    check_solve (solver, A,u,f, preconditioner);
+    check_solve (solver, control, A,u,f, preconditioner);
   }
 
 }
index 2d01d1bc19f881e18db7736a3bbbe5f46059831f..3bb0a590b430b9cbfb44cab5e946c893c226af05 100644 (file)
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2004 - 2013 by the deal.II authors
+// Copyright (C) 2004 - 2014 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -34,7 +34,9 @@
 
 template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
 void
-check_solve( SOLVER &solver, const MATRIX &A,
+check_solve( SOLVER &solver,
+            const SolverControl &solver_control,
+            const MATRIX &A,
              VECTOR &u, VECTOR &f, const PRECONDITION &P)
 {
   deallog << "Solver type: " << typeid(solver).name() << std::endl;
@@ -51,13 +53,13 @@ check_solve( SOLVER &solver, const MATRIX &A,
       abort ();
     }
 
-  deallog << "Solver stopped after " << solver.control().last_step()
+  deallog << "Solver stopped after " << solver_control.last_step()
           << " iterations" << std::endl;
 
   // we use a direct solver as a
   // preconditioner. this should
   // converge in one step!
-  Assert (solver.control().last_step() == 1,
+  Assert (solver_control.last_step() == 1,
           ExcInternalError());
 }
 
@@ -93,7 +95,7 @@ int main(int argc, char **argv)
 
     PETScWrappers::SolverCG solver(control);
     PETScWrappers::PreconditionLU preconditioner(A);
-    check_solve (solver, A,u,f, preconditioner);
+    check_solve (solver, control, A,u,f, preconditioner);
   }
 
 }
index 2d2e253dafe698a3ad4800b3c35ef96e8ae32b97..def46b1520c94de76e733c315b72acc31e34359f 100644 (file)
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2004 - 2013 by the deal.II authors
+// Copyright (C) 2004 - 2014 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -33,7 +33,9 @@
 
 template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
 void
-check_solve( SOLVER &solver, const MATRIX &A,
+check_solve( SOLVER &solver,
+            const SolverControl &solver_control,
+            const MATRIX &A,
              VECTOR &u, VECTOR &f, const PRECONDITION &P)
 {
   deallog << "Solver type: " << typeid(solver).name() << std::endl;
@@ -50,7 +52,7 @@ check_solve( SOLVER &solver, const MATRIX &A,
       abort ();
     }
 
-  deallog << "Solver stopped after " << solver.control().last_step()
+  deallog << "Solver stopped after " << solver_control.last_step()
           << " iterations" << std::endl;
 }
 
@@ -86,7 +88,7 @@ int main(int argc, char **argv)
 
     PETScWrappers::SolverCG solver(control);
     PETScWrappers::PreconditionParaSails preconditioner(A);
-    check_solve (solver, A,u,f, preconditioner);
+    check_solve (solver, control, A,u,f, preconditioner);
   }
 
 }
index c86ba4717aa369ea963abedb28d2b479839d5d96..ceab998ba09fa01ace5252ddaeaafe4a59c74e96 100644 (file)
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2004 - 2013 by the deal.II authors
+// Copyright (C) 2004 - 2014 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -33,7 +33,9 @@
 
 template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
 void
-check_solve( SOLVER &solver, const MATRIX &A,
+check_solve( SOLVER &solver,
+            const SolverControl &solver_control,
+            const MATRIX &A,
              VECTOR &u, VECTOR &f, const PRECONDITION &P)
 {
   deallog << "Solver type: " << typeid(solver).name() << std::endl;
@@ -50,7 +52,7 @@ check_solve( SOLVER &solver, const MATRIX &A,
       abort ();
     }
 
-  deallog << "Solver stopped after " << solver.control().last_step()
+  deallog << "Solver stopped after " << solver_control.last_step()
           << " iterations" << std::endl;
 }
 
@@ -86,7 +88,7 @@ int main(int argc, char **argv)
 
     PETScWrappers::SolverCG solver(control);
     PETScWrappers::PreconditionSOR preconditioner(A);
-    check_solve (solver, A,u,f, preconditioner);
+    check_solve (solver, control, A,u,f, preconditioner);
   }
 
 }
index 3c8cda90c8e29347a331a77c275219f4261cc167..5f47ab3d907a79072965f92063abf966fcbe92e5 100644 (file)
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2004 - 2013 by the deal.II authors
+// Copyright (C) 2004 - 2014 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -33,7 +33,9 @@
 
 template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
 void
-check_solve( SOLVER &solver, const MATRIX &A,
+check_solve( SOLVER &solver,
+            const SolverControl &solver_control,
+            const MATRIX &A,
              VECTOR &u, VECTOR &f, const PRECONDITION &P)
 {
   deallog << "Solver type: " << typeid(solver).name() << std::endl;
@@ -50,7 +52,7 @@ check_solve( SOLVER &solver, const MATRIX &A,
       abort ();
     }
 
-  deallog << "Solver stopped after " << solver.control().last_step()
+  deallog << "Solver stopped after " << solver_control.last_step()
           << " iterations" << std::endl;
 }
 
@@ -86,7 +88,7 @@ int main(int argc, char **argv)
 
     PETScWrappers::SolverCG solver(control);
     PETScWrappers::PreconditionSSOR preconditioner(A);
-    check_solve (solver, A,u,f, preconditioner);
+    check_solve (solver, control, A,u,f, preconditioner);
   }
 
 }
index fae99130b9c1525729ed59e3be8d282495f7f04b..895845c74e9f0a34fc7622ece07b62ad9178de1e 100644 (file)
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2004 - 2013 by the deal.II authors
+// Copyright (C) 2004 - 2014 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -33,7 +33,9 @@
 
 template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
 void
-check_solve( SOLVER &solver, const MATRIX &A,
+check_solve( SOLVER &solver,
+            const SolverControl &solver_control,
+            const MATRIX &A,
              VECTOR &u, VECTOR &f, const PRECONDITION &P)
 {
   deallog << "Solver type: " << typeid(solver).name() << std::endl;
@@ -50,7 +52,7 @@ check_solve( SOLVER &solver, const MATRIX &A,
       abort ();
     }
 
-  deallog << "Solver stopped after " << solver.control().last_step()
+  deallog << "Solver stopped after " << solver_control.last_step()
           << " iterations" << std::endl;
 }
 
@@ -86,7 +88,7 @@ int main(int argc, char **argv)
 
     PETScWrappers::SolverBiCG solver(control);
     PETScWrappers::PreconditionJacobi preconditioner(A);
-    check_solve (solver, A,u,f, preconditioner);
+    check_solve (solver, control, A,u,f, preconditioner);
   }
 
 }
index 08086eb5e931b80286f0146b9a33d5bec11e233e..c88c9e4786f80bd2197bc1ad69ac25855a763252 100644 (file)
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2004 - 2013 by the deal.II authors
+// Copyright (C) 2004 - 2014 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -33,7 +33,9 @@
 
 template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
 void
-check_solve( SOLVER &solver, const MATRIX &A,
+check_solve( SOLVER &solver,
+            const SolverControl &solver_control,
+            const MATRIX &A,
              VECTOR &u, VECTOR &f, const PRECONDITION &P)
 {
   deallog << "Solver type: " << typeid(solver).name() << std::endl;
@@ -50,7 +52,7 @@ check_solve( SOLVER &solver, const MATRIX &A,
       abort ();
     }
 
-  deallog << "Solver stopped after " << solver.control().last_step()
+  deallog << "Solver stopped after " << solver_control.last_step()
           << " iterations" << std::endl;
 }
 
@@ -86,7 +88,7 @@ int main(int argc, char **argv)
 
     PETScWrappers::SolverGMRES solver(control);
     PETScWrappers::PreconditionJacobi preconditioner(A);
-    check_solve (solver, A,u,f, preconditioner);
+    check_solve (solver, control, A,u,f, preconditioner);
   }
 
 }
index 3691b25164290da3b27494b7190b6f87617ee176..1a81d8e151858b89d1531c10dfe44995b0f33aaa 100644 (file)
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2004 - 2013 by the deal.II authors
+// Copyright (C) 2004 - 2014 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -33,7 +33,9 @@
 
 template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
 void
-check_solve( SOLVER &solver, const MATRIX &A,
+check_solve( SOLVER &solver,
+            const SolverControl &solver_control,
+            const MATRIX &A,
              VECTOR &u, VECTOR &f, const PRECONDITION &P)
 {
   deallog << "Solver type: " << typeid(solver).name() << std::endl;
@@ -53,7 +55,7 @@ check_solve( SOLVER &solver, const MATRIX &A,
       abort ();
     }
 
-  deallog << "Solver stopped after " << solver.control().last_step()
+  deallog << "Solver stopped after " << solver_control.last_step()
           << " iterations" << std::endl;
 }
 
@@ -89,7 +91,7 @@ int main(int argc, char **argv)
 
     PETScWrappers::SolverBicgstab solver(control);
     PETScWrappers::PreconditionJacobi preconditioner(A);
-    check_solve (solver, A,u,f, preconditioner);
+    check_solve (solver, control, A,u,f, preconditioner);
   }
 
 }
index 1759d9fdea7940fc32be5fc82df5f54a6a98beeb..6d677ade0535424b090081fb1cfe3e5be82a7d66 100644 (file)
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2004 - 2013 by the deal.II authors
+// Copyright (C) 2004 - 2014 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -33,7 +33,9 @@
 
 template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
 void
-check_solve( SOLVER &solver, const MATRIX &A,
+check_solve( SOLVER &solver,
+            const SolverControl &solver_control,
+            const MATRIX &A,
              VECTOR &u, VECTOR &f, const PRECONDITION &P)
 {
   deallog << "Solver type: " << typeid(solver).name() << std::endl;
@@ -50,7 +52,7 @@ check_solve( SOLVER &solver, const MATRIX &A,
       abort ();
     }
 
-  deallog << "Solver stopped after " << solver.control().last_step()
+  deallog << "Solver stopped after " << solver_control.last_step()
           << " iterations" << std::endl;
 }
 
@@ -86,7 +88,7 @@ int main(int argc, char **argv)
 
     PETScWrappers::SolverCGS solver(control);
     PETScWrappers::PreconditionJacobi preconditioner(A);
-    check_solve (solver, A,u,f, preconditioner);
+    check_solve (solver, control, A,u,f, preconditioner);
   }
 
 }
index adb44ad96c973b162f3fa88041cbae7e8fc72b4c..4b749fd338f9d5836f4a88a70a13b94f5c276381 100644 (file)
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2004 - 2013 by the deal.II authors
+// Copyright (C) 2004 - 2014 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -33,7 +33,9 @@
 
 template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
 void
-check_solve( SOLVER &solver, const MATRIX &A,
+check_solve( SOLVER &solver,
+            const SolverControl &solver_control,
+            const MATRIX &A,
              VECTOR &u, VECTOR &f, const PRECONDITION &P)
 {
   deallog << "Solver type: " << typeid(solver).name() << std::endl;
@@ -50,7 +52,7 @@ check_solve( SOLVER &solver, const MATRIX &A,
       abort ();
     }
 
-  deallog << "Solver stopped after " << solver.control().last_step()
+  deallog << "Solver stopped after " << solver_control.last_step()
           << " iterations" << std::endl;
 }
 
@@ -86,7 +88,7 @@ int main(int argc, char **argv)
 
     PETScWrappers::SolverTFQMR solver(control);
     PETScWrappers::PreconditionJacobi preconditioner(A);
-    check_solve (solver, A,u,f, preconditioner);
+    check_solve (solver, control, A,u,f, preconditioner);
   }
 
 }
index db5e6923b2ec0377b98c469c6815d278141ec661..08520c11ba25da46db5774e91ff8cc0458dc4e40 100644 (file)
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2004 - 2013 by the deal.II authors
+// Copyright (C) 2004 - 2014 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -37,7 +37,9 @@
 
 template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
 void
-check_solve( SOLVER &solver, const MATRIX &A,
+check_solve( SOLVER &solver,
+            const SolverControl &solver_control,
+            const MATRIX &A,
              VECTOR &u, VECTOR &f, const PRECONDITION &P)
 {
   deallog << "Solver type: " << typeid(solver).name() << std::endl;
@@ -54,7 +56,7 @@ check_solve( SOLVER &solver, const MATRIX &A,
       abort ();
     }
 
-  deallog << "Solver stopped after " << solver.control().last_step()
+  deallog << "Solver stopped after " << solver_control.last_step()
           << " iterations" << std::endl;
 }
 
@@ -90,7 +92,7 @@ int main(int argc, char **argv)
 
     PETScWrappers::SolverTCQMR solver(control);
     PETScWrappers::PreconditionJacobi preconditioner(A);
-    check_solve (solver, A,u,f, preconditioner);
+    check_solve (solver, control, A,u,f, preconditioner);
   }
 
 }
index ceda168292cafde948ef63f308d3285714be937f..5fc7cd7efc8c7f530f5b294374f025d956da464a 100644 (file)
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2004 - 2013 by the deal.II authors
+// Copyright (C) 2004 - 2014 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -33,7 +33,9 @@
 
 template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
 void
-check_solve( SOLVER &solver, const MATRIX &A,
+check_solve( SOLVER &solver,
+            const SolverControl &solver_control,
+            const MATRIX &A,
              VECTOR &u, VECTOR &f, const PRECONDITION &P)
 {
   deallog << "Solver type: " << typeid(solver).name() << std::endl;
@@ -50,7 +52,7 @@ check_solve( SOLVER &solver, const MATRIX &A,
       abort ();
     }
 
-  deallog << "Solver stopped after " << solver.control().last_step()
+  deallog << "Solver stopped after " << solver_control.last_step()
           << " iterations" << std::endl;
 }
 
@@ -86,7 +88,7 @@ int main(int argc, char **argv)
 
     PETScWrappers::SolverCR solver(control);
     PETScWrappers::PreconditionJacobi preconditioner(A);
-    check_solve (solver, A,u,f, preconditioner);
+    check_solve (solver, control, A,u,f, preconditioner);
   }
 
 }
index 5986f7d3701296156bf49a558e819660a2b8c94a..c22613b52897fc486c3525d2ee2b5c13352c3359 100644 (file)
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2004 - 2013 by the deal.II authors
+// Copyright (C) 2004 - 2014 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -33,7 +33,9 @@
 
 template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
 void
-check_solve( SOLVER &solver, const MATRIX &A,
+check_solve( SOLVER &solver,
+            const SolverControl &solver_control,
+            const MATRIX &A,
              VECTOR &u, VECTOR &f, const PRECONDITION &P)
 {
   deallog << "Solver type: " << typeid(solver).name() << std::endl;
@@ -54,7 +56,7 @@ check_solve( SOLVER &solver, const MATRIX &A,
       deallog << "Catched exception dealii::SolverControl::NoConvergence" << std::endl;
     }
 
-  deallog << "Solver stopped after " << solver.control().last_step()
+  deallog << "Solver stopped after " << solver_control.last_step()
           << " iterations" << std::endl;
 }
 
@@ -90,7 +92,7 @@ int main(int argc, char **argv)
 
     PETScWrappers::SolverLSQR solver(control);
     PETScWrappers::PreconditionJacobi preconditioner(A);
-    check_solve (solver, A,u,f, preconditioner);
+    check_solve (solver, control, A,u,f, preconditioner);
   }
 
 }
index 1d20e891aecde8b18facf71d14688f7098fabeed..b0c4032d39fdeda14e3613276c96db1552277f10 100644 (file)
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2004 - 2013 by the deal.II authors
+// Copyright (C) 2004 - 2014 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -33,7 +33,9 @@
 
 template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
 void
-check_solve( SOLVER &solver, const MATRIX &A,
+check_solve( SOLVER &solver,
+            const SolverControl &solver_control,
+            const MATRIX &A,
              VECTOR &u, VECTOR &f, const PRECONDITION &P)
 {
   deallog << "Solver type: " << typeid(solver).name() << std::endl;
@@ -43,7 +45,7 @@ check_solve( SOLVER &solver, const MATRIX &A,
 
   solver.solve(A,u,f,P);
 
-  deallog << "Solver stopped after " << solver.control().last_step()
+  deallog << "Solver stopped after " << solver_control.last_step()
           << " iterations" << std::endl;
 }
 
@@ -80,10 +82,10 @@ int main(int argc, char **argv)
     PETScWrappers::SolverPreOnly solver(control);
 
     PETScWrappers::PreconditionJacobi preconditioner(A);
-    check_solve (solver, A,u,f, preconditioner);
+    check_solve (solver, control, A,u,f, preconditioner);
 
     //run twice because this errored out at some point
-    check_solve (solver, A,u,f, preconditioner);
+    check_solve (solver, control, A,u,f, preconditioner);
   }
 
 }
index e8906cb9807654faf85054b50a7b1a7286e05c32..50909db7cd45ab328cca144645b203a0ebf405a5 100644 (file)
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2004 - 2013 by the deal.II authors
+// Copyright (C) 2004 - 2014 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
 
 template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
 void
-check_solve( SOLVER &solver, const MATRIX &A,
+check_solve( SOLVER &solver,
+            const SolverControl &solver_control,
+            const MATRIX &A,
              VECTOR &u, VECTOR &f, const PRECONDITION &P)
 {
   deallog << "Solver type: " << typeid(solver).name() << std::endl;
 
   solver.solve(A,u,f,P);
 
-  deallog << "Solver stopped after " << solver.control().last_step()
+  deallog << "Solver stopped after " << solver_control.last_step()
           << " iterations" << std::endl;
 }
 
@@ -80,11 +82,11 @@ int main(int argc, char **argv)
 
     PETScWrappers::PreconditionJacobi preconditioner(A);
 
-    check_solve (solver, A,u,f, preconditioner);
+    check_solve (solver, control, A,u,f, preconditioner);
 
     deallog << u.l2_norm() << std::endl;
 
-    check_solve (solver, A,t,u, preconditioner);
+    check_solve (solver, control, A,t,u, preconditioner);
 
     deallog << t.l2_norm() << std::endl;
 
index dd74621eadcbfe8095399c93eb374107fdde5fd0..4670fb127e8abe043d5d93743af796da99cbbe36 100644 (file)
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2004 - 2013 by the deal.II authors
+// Copyright (C) 2004 - 2014 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
 #include <deal.II/lac/vector_memory.h>
 #include <typeinfo>
 
-template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
-void
-check_solve( SOLVER &solver, const MATRIX &A,
-             VECTOR &u, VECTOR &f, const PRECONDITION &P)
-{
-  deallog << "Solver type: " << typeid(solver).name() << std::endl;
-
-  u = 0.;
-  f = 1.;
-  try
-    {
-      solver.solve(A,u,f,P);
-    }
-  catch (std::exception &e)
-    {
-      deallog << e.what() << std::endl;
-      abort ();
-    }
-
-  deallog << "Solver stopped after " << solver.control().last_step()
-          << " iterations" << std::endl;
-}
 
 
 int main(int argc, char **argv)
index 6f8fbb56665974157d3bf986353811f04883734f..b77cb5a86a58249c48ca359a79b57ee322aa8e7f 100644 (file)
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2004 - 2013 by the deal.II authors
+// Copyright (C) 2004 - 2014 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -39,7 +39,9 @@
 
 template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
 void
-check_solve( SOLVER &solver, const MATRIX &A,
+check_solve( SOLVER &solver,
+            const SolverControl &solver_control,
+            const MATRIX &A,
              VECTOR &u, VECTOR &f, const PRECONDITION &P)
 {
   deallog << "Solver type: " << typeid(solver).name() << std::endl;
@@ -56,7 +58,7 @@ check_solve( SOLVER &solver, const MATRIX &A,
       abort ();
     }
 
-  deallog << "Solver stopped after " << solver.control().last_step()
+  deallog << "Solver stopped after " << solver_control.last_step()
           << " iterations" << std::endl;
 }
 
@@ -98,7 +100,7 @@ int main(int argc, char **argv)
     GrowingVectorMemory<TrilinosWrappers::Vector> mem;
     SolverCG<TrilinosWrappers::Vector> solver(control, mem);
     PreconditionIdentity preconditioner;
-    check_solve (solver, A,u,f, preconditioner);
+    check_solve (solver, control, A,u,f, preconditioner);
   }
 }
 
index 18da9f9cd5bffb9db6c242bc191c92eec42ce6cb..6457179c2ede7bd9f0910bbc1622eb29107c6d8e 100644 (file)
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2004 - 2013 by the deal.II authors
+// Copyright (C) 2004 - 2014 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -41,7 +41,9 @@
 
 template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
 void
-check_solve( SOLVER &solver, const MATRIX &A,
+check_solve( SOLVER &solver,
+            const SolverControl &solver_control,
+            const MATRIX &A,
              VECTOR &u, VECTOR &f, const PRECONDITION &P)
 {
   deallog << "Solver type: " << typeid(solver).name() << std::endl;
@@ -61,7 +63,7 @@ check_solve( SOLVER &solver, const MATRIX &A,
       abort ();
     }
 
-  const unsigned int steps = solver.control().last_step();
+  const unsigned int steps = solver_control.last_step();
   if (steps >= 49 && steps <= 51)
     {
       deallog << "Solver stopped within 49 - 51 iterations"
@@ -69,7 +71,7 @@ check_solve( SOLVER &solver, const MATRIX &A,
     }
   else
     {
-      deallog << "Solver stopped after " << solver.control().last_step()
+      deallog << "Solver stopped after " << solver_control.last_step()
               << " iterations" << std::endl;
     }
 }
@@ -112,7 +114,7 @@ int main(int argc, char **argv)
     GrowingVectorMemory<TrilinosWrappers::Vector> mem;
     SolverBicgstab<TrilinosWrappers::Vector> solver(control,mem);
     PreconditionIdentity preconditioner;
-    check_solve (solver, A,u,f, preconditioner);
+    check_solve (solver, control, A,u,f, preconditioner);
   }
 }
 
index 40a1f3e125d7c281eb951660c0c1b21911543d8e..b62bffd74cb68ec4dbefaaaac733f9ec25d65ea9 100644 (file)
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2004 - 2013 by the deal.II authors
+// Copyright (C) 2004 - 2014 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -41,7 +41,9 @@
 
 template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
 void
-check_solve( SOLVER &solver, const MATRIX &A,
+check_solve( SOLVER &solver,
+            const SolverControl &solver_control,
+            const MATRIX &A,
              VECTOR &u, VECTOR &f, const PRECONDITION &P)
 {
   deallog << "Solver type: " << typeid(solver).name() << std::endl;
@@ -58,7 +60,7 @@ check_solve( SOLVER &solver, const MATRIX &A,
       abort ();
     }
 
-  deallog << "Solver stopped after " << solver.control().last_step()
+  deallog << "Solver stopped after " << solver_control.last_step()
           << " iterations" << std::endl;
 }
 
@@ -100,7 +102,7 @@ int main(int argc, char **argv)
     GrowingVectorMemory<TrilinosWrappers::Vector> mem;
     SolverGMRES<TrilinosWrappers::Vector> solver(control,mem);
     PreconditionIdentity preconditioner;
-    check_solve (solver, A,u,f, preconditioner);
+    check_solve (solver, control, A,u,f, preconditioner);
   }
 }
 
index 44a3b8d4cad5241bc3e69a228dacbaa7b33f1395..eb9c9baa58f1ff32707ede71e49b6e76a32f3ca7 100644 (file)
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2004 - 2013 by the deal.II authors
+// Copyright (C) 2004 - 2014 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -40,7 +40,9 @@
 
 template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
 void
-check_solve( SOLVER &solver, const MATRIX &A,
+check_solve( SOLVER &solver,
+            const SolverControl &solver_control,
+            const MATRIX &A,
              VECTOR &u, VECTOR &f, const PRECONDITION &P)
 {
   deallog << "Solver type: " << typeid(solver).name() << std::endl;
@@ -57,7 +59,7 @@ check_solve( SOLVER &solver, const MATRIX &A,
       abort ();
     }
 
-  deallog << "Solver stopped after " << solver.control().last_step()
+  deallog << "Solver stopped after " << solver_control.last_step()
           << " iterations" << std::endl;
 }
 
@@ -99,7 +101,7 @@ int main(int argc, char **argv)
     GrowingVectorMemory<TrilinosWrappers::Vector> mem;
     SolverMinRes<TrilinosWrappers::Vector> solver(control,mem);
     PreconditionIdentity preconditioner;
-    check_solve (solver, A,u,f, preconditioner);
+    check_solve (solver, control, A,u,f, preconditioner);
   }
 }
 
index e1140b25717cbf730724f10c4dabc3955d551397..7c1f701861f80a09eb7ffba4a857017deff1d9fd 100644 (file)
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2004 - 2013 by the deal.II authors
+// Copyright (C) 2004 - 2014 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -39,7 +39,9 @@
 
 template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
 void
-check_solve( SOLVER &solver, const MATRIX &A,
+check_solve( SOLVER &solver,
+            const SolverControl &solver_control,
+            const MATRIX &A,
              VECTOR &u, VECTOR &f, const PRECONDITION &P)
 {
   deallog << "Solver type: " << typeid(solver).name() << std::endl;
@@ -56,7 +58,7 @@ check_solve( SOLVER &solver, const MATRIX &A,
       abort ();
     }
 
-  deallog << "Solver stopped after " << solver.control().last_step()
+  deallog << "Solver stopped after " << solver_control.last_step()
           << " iterations" << std::endl;
 }
 
@@ -98,7 +100,7 @@ int main(int argc, char **argv)
     GrowingVectorMemory<TrilinosWrappers::Vector> mem;
     SolverQMRS<TrilinosWrappers::Vector> solver(control,mem);
     PreconditionIdentity preconditioner;
-    check_solve (solver, A,u,f, preconditioner);
+    check_solve (solver, control, A,u,f, preconditioner);
   }
 }
 
index 8ca8def3a2c4bec070725968309ecd6d382447df..13fd55325497b2e400be5179c63f18c09b55a004 100644 (file)
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2004 - 2013 by the deal.II authors
+// Copyright (C) 2004 - 2014 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -39,7 +39,9 @@
 
 template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
 void
-check_solve( SOLVER &solver, const MATRIX &A,
+check_solve( SOLVER &solver,
+            const SolverControl &solver_control,
+            const MATRIX &A,
              VECTOR &u, VECTOR &f, const PRECONDITION &P)
 {
   deallog << "Solver type: " << typeid(solver).name() << std::endl;
@@ -55,7 +57,7 @@ check_solve( SOLVER &solver, const MATRIX &A,
       deallog << e.what() << std::endl;
     }
 
-  deallog << "Solver stopped after " << solver.control().last_step()
+  deallog << "Solver stopped after " << solver_control.last_step()
           << " iterations" << std::endl;
 }
 
@@ -96,7 +98,7 @@ int main(int argc, char **argv)
     GrowingVectorMemory<TrilinosWrappers::Vector> mem;
     SolverRichardson<TrilinosWrappers::Vector> solver(control,mem,0.1);
     PreconditionIdentity preconditioner;
-    check_solve (solver, A,u,f, preconditioner);
+    check_solve (solver, control, A,u,f, preconditioner);
   }
 }
 
index 38eb27cb01f18481192254d61fbfff5a0abd0ff4..f551e9ce51134af20b5e33dc88b7faa081ee0ffc 100644 (file)
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2004 - 2013 by the deal.II authors
+// Copyright (C) 2004 - 2014 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -34,7 +34,9 @@
 
 template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
 void
-check_solve( SOLVER &solver, const MATRIX &A,
+check_solve( SOLVER &solver,
+            const SolverControl &solver_control,
+            const MATRIX &A,
              VECTOR &u, VECTOR &f, const PRECONDITION &P)
 {
   deallog << "Solver type: " << typeid(solver).name() << std::endl;
@@ -51,7 +53,7 @@ check_solve( SOLVER &solver, const MATRIX &A,
       abort ();
     }
 
-  deallog << "Solver stopped after " << solver.control().last_step()
+  deallog << "Solver stopped after " << solver_control.last_step()
           << " iterations" << std::endl;
 }
 
@@ -93,7 +95,7 @@ int main(int argc, char **argv)
     TrilinosWrappers::SolverCG solver(control);
     TrilinosWrappers::PreconditionJacobi preconditioner;
     preconditioner.initialize(A);
-    check_solve (solver, A,u,f, preconditioner);
+    check_solve (solver, control, A,u,f, preconditioner);
   }
 }
 
index ce55a59fca8a5eba6feaefbd0ad59a2dd6c2958a..cb89878023d501f63224c28f5465d7a2d218e263 100644 (file)
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2004 - 2013 by the deal.II authors
+// Copyright (C) 2004 - 2014 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -34,7 +34,9 @@
 
 template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
 void
-check_solve( SOLVER &solver, const MATRIX &A,
+check_solve( SOLVER &solver,
+            const SolverControl &solver_control,
+            const MATRIX &A,
              VECTOR &u, VECTOR &f, const PRECONDITION &P)
 {
   deallog << "Solver type: " << typeid(solver).name() << std::endl;
@@ -51,7 +53,7 @@ check_solve( SOLVER &solver, const MATRIX &A,
       abort ();
     }
 
-  deallog << "Solver stopped after " << solver.control().last_step()
+  deallog << "Solver stopped after " << solver_control.last_step()
           << " iterations" << std::endl;
 }
 
@@ -93,7 +95,7 @@ int main(int argc, char **argv)
     TrilinosWrappers::SolverGMRES solver(control);
     TrilinosWrappers::PreconditionJacobi preconditioner;
     preconditioner.initialize(A);
-    check_solve (solver, A,u,f, preconditioner);
+    check_solve (solver, control, A,u,f, preconditioner);
   }
 }
 
index 4832f78d56c84a25c76ce6a91b06134443e0187b..b371296a298eb241e905782f37f05a4c821d5398 100644 (file)
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2004 - 2013 by the deal.II authors
+// Copyright (C) 2004 - 2014 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -34,7 +34,9 @@
 
 template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
 void
-check_solve( SOLVER &solver, const MATRIX &A,
+check_solve( SOLVER &solver,
+            const SolverControl &solver_control,
+            const MATRIX &A,
              VECTOR &u, VECTOR &f, const PRECONDITION &P)
 {
   deallog << "Solver type: " << typeid(solver).name() << std::endl;
@@ -51,7 +53,7 @@ check_solve( SOLVER &solver, const MATRIX &A,
       abort ();
     }
 
-  deallog << "Solver stopped after " << solver.control().last_step()
+  deallog << "Solver stopped after " << solver_control.last_step()
           << " iterations" << std::endl;
 }
 
@@ -92,7 +94,7 @@ int main(int argc, char **argv)
     TrilinosWrappers::SolverCGS solver(control);
     TrilinosWrappers::PreconditionJacobi preconditioner;
     preconditioner.initialize(A);
-    check_solve (solver, A,u,f, preconditioner);
+    check_solve (solver, control, A,u,f, preconditioner);
   }
 
 }

In the beginning the Universe was created. This has made a lot of people very angry and has been widely regarded as a bad move.

Douglas Adams


Typeset in Trocchi and Trocchi Bold Sans Serif.