newton_solver.h

// This file is part of Hermes2D
//
// Copyright (c) 2009 hp-FEM group at the University of Nevada, Reno (UNR).
// Email: hpfem-group@unr.edu, home page: http://hpfem.org/.
//
// Hermes2D is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published
// by the Free Software Foundation; either version 2 of the License,
// or (at your option) any later version.
//
// Hermes2D 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 General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Hermes2D; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#ifndef __H2D_SOLVER_NEWTON_H_
#define __H2D_SOLVER_NEWTON_H_

#include "global.h"
#include "discrete_problem.h"
#include "exceptions.h"

namespace Hermes
{
  namespace Hermes2D
  {
    template<typename Scalar>
    class HERMES_API NewtonSolver : public NonlinearSolver<Scalar>, public Hermes::Hermes2D::Mixins::SettableSpaces<Scalar>, public Hermes::Mixins::OutputAttachable, public Hermes::Hermes2D::Mixins::MatrixRhsOutput<Scalar>, public Hermes::Hermes2D::Mixins::StateQueryable
    {
    public:
      NewtonSolver();
      NewtonSolver(DiscreteProblem<Scalar>* dp);
      NewtonSolver(const WeakForm<Scalar>* wf, const Space<Scalar>* space);
      NewtonSolver(const WeakForm<Scalar>* wf, Hermes::vector<const Space<Scalar>*> spaces);
      void init_linear_solver();

      ~NewtonSolver();

      virtual bool isOkay() const;
      inline std::string getClassName() const { return "NewtonSolver"; }

      void solve(Scalar* coeff_vec = NULL);

      void solve(Solution<Scalar>* initial_guess);

      void solve(Hermes::vector<Solution<Scalar>*> initial_guess);

      void solve_keep_jacobian(Scalar* coeff_vec = NULL);
      
      void solve_keep_jacobian(Solution<Scalar>* initial_guess);
      
      void solve_keep_jacobian(Hermes::vector<Solution<Scalar>*> initial_guess);

      void set_max_allowed_residual_norm(double max_allowed_residual_norm_to_set);

      void set_min_allowed_damping_coeff(double min_allowed_damping_coeff_to_set);

      virtual void set_iterative_method(const char* iterative_method_name);

      virtual void set_preconditioner(const char* preconditioner_name);

      void set_residual_as_function();

      void set_newton_tol(double newton_tol);

      void set_newton_max_iter(int newton_max_iter);

      virtual void set_time(double time);
      virtual void set_time_step(double time_step);

      virtual void set_spaces(Hermes::vector<const Space<Scalar>*> spaces);
      virtual void set_space(const Space<Scalar>* space);
      virtual Hermes::vector<const Space<Scalar>*> get_spaces() const;

      void set_manual_damping_coeff(bool onOff, double coeff = 1.0);
      
      void set_initial_auto_damping_coeff(double coeff);
      
      void set_auto_damping_ratio(double ratio);

      void set_sufficient_improvement_factor(double ratio);

      void set_necessary_successful_steps_to_increase(unsigned int steps);

      void set_weak_formulation(const WeakForm<Scalar>* wf);

    protected:
      const bool own_dp;

      SparseMatrix<Scalar>* kept_jacobian;

      void init_attributes();

      SparseMatrix<Scalar>* jacobian;

      Vector<Scalar>* residual;

      LinearMatrixSolver<Scalar>* linear_solver;

      double newton_tol;
      int newton_max_iter;
      bool residual_as_function;

      double max_allowed_residual_norm;
      double min_allowed_damping_coeff;

      double currentDampingCofficient;
      
      bool manual_damping;
      double auto_damping_ratio;
      double initial_auto_damping_ratio;
      double sufficient_improvement_factor;
      unsigned int necessary_successful_steps_to_increase;
    };
  }
}
#endif