NewtonSolver.h

// Copyright (C) 2005-2008 Garth N. Wells
//
// This file is part of DOLFIN.
//
// DOLFIN is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// DOLFIN is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with DOLFIN. If not, see <http://www.gnu.org/licenses/>.
//
// Modified by Anders Logg 2006-2011
// Modified by Anders E. Johansen 2011
//
// First added:  2005-10-23
// Last changed: 2013-11-20
 
#ifndef __NEWTON_SOLVER_H
#define __NEWTON_SOLVER_H
 
#include <utility>
#include <memory>
#include <dolfin/common/MPI.h>
#include <dolfin/common/Variable.h>
 
namespace dolfin
{
 
  // Forward declarations
  class GenericLinearSolver;
  class GenericLinearAlgebraFactory;
  class GenericMatrix;
  class GenericVector;
  class NonlinearProblem;

 
  class NewtonSolver : public Variable
  {
  public:

    explicit NewtonSolver(MPI_Comm comm=MPI_COMM_WORLD);

    NewtonSolver(MPI_Comm comm, std::shared_ptr<GenericLinearSolver> solver,
                 GenericLinearAlgebraFactory& factory);

    virtual ~NewtonSolver();

    std::pair<std::size_t, bool> solve(NonlinearProblem& nonlinear_function,
                                       GenericVector& x);

    std::size_t iteration() const;

    std::size_t krylov_iterations() const;

    double residual() const;

    double residual0() const;

    double relative_residual() const;

    GenericLinearSolver& linear_solver() const;

    static Parameters default_parameters();

    void set_relaxation_parameter(double relaxation_parameter)
    { _relaxation_parameter = relaxation_parameter; }

    double get_relaxation_parameter()
    { return _relaxation_parameter; }
 
  protected:

    virtual bool converged(const GenericVector& r,
                           const NonlinearProblem& nonlinear_problem,
                           std::size_t iteration);

    virtual void solver_setup(std::shared_ptr<const GenericMatrix> A,
                              std::shared_ptr<const GenericMatrix> P,
                              const NonlinearProblem& nonlinear_problem,
                              std::size_t iteration);

    virtual void update_solution(GenericVector& x,
                                 const GenericVector& dx,
                                 double relaxation_parameter,
                                 const NonlinearProblem& nonlinear_problem,
                                 std::size_t iteration);
 
  private:
 
    // Current number of Newton iterations
    std::size_t _newton_iteration;
 
    // Accumulated number of Krylov iterations since solve began
    std::size_t _krylov_iterations;
 
    // Relaxation parameter
    double _relaxation_parameter;
 
    // Most recent residual and initial residual
    double _residual, _residual0;
 
    // Solver
    std::shared_ptr<GenericLinearSolver> _solver;
 
    // Jacobian matrix
    std::shared_ptr<GenericMatrix> _matA;
 
    // Preconditioner matrix
    std::shared_ptr<GenericMatrix> _matP;
 
    // Solution vector
    std::shared_ptr<GenericVector> _dx;
 
    // Residual vector
    std::shared_ptr<GenericVector> _b;
 
    // MPI communicator
    dolfin::MPI::Comm _mpi_comm;
 
  };
 
}
 
#endif