#include <newton_solver.h>

Inheritance diagram for libMesh::NewtonSolver:

Public Types
typedef DiffSolver	Parent
enum	SolveResult { INVALID_SOLVE_RESULT = 0, CONVERGED_NO_REASON = 1, CONVERGED_ABSOLUTE_RESIDUAL = 2, CONVERGED_RELATIVE_RESIDUAL = 4, CONVERGED_ABSOLUTE_STEP = 8, CONVERGED_RELATIVE_STEP = 16, DIVERGED_NO_REASON = 32, DIVERGED_MAX_NONLINEAR_ITERATIONS = 64, DIVERGED_BACKTRACKING_FAILURE = 128, DIVERGED_LINEAR_SOLVER_FAILURE = 256 }
typedef ImplicitSystem	sys_type
Public Member Functions
	NewtonSolver (sys_type &system)
virtual	~NewtonSolver ()
virtual void	init ()
virtual void	reinit ()
virtual unsigned int	solve ()
unsigned int	total_outer_iterations ()
unsigned int	total_inner_iterations ()
unsigned int	solve_result ()
const sys_type &	system () const
sys_type &	system ()
const Parallel::Communicator &	comm () const
processor_id_type	n_processors () const
processor_id_type	processor_id () const
Static Public Member Functions
static UniquePtr< DiffSolver >	build (sys_type &s)
static std::string	get_info ()
static void	print_info (std::ostream &out=libMesh::out)
static unsigned int	n_objects ()
static void	enable_print_counter_info ()
static void	disable_print_counter_info ()
Public Attributes
bool	require_residual_reduction
bool	require_finite_residual
bool	brent_line_search
bool	track_linear_convergence
Real	minsteplength
Real	linear_tolerance_multiplier
unsigned int	max_linear_iterations
unsigned int	max_nonlinear_iterations
bool	quiet
bool	verbose
bool	continue_after_max_iterations
bool	continue_after_backtrack_failure
Real	absolute_residual_tolerance
Real	relative_residual_tolerance
Real	absolute_step_tolerance
Real	relative_step_tolerance
Real	initial_linear_tolerance
Real	minimum_linear_tolerance
UniquePtr< LinearSolutionMonitor >	linear_solution_monitor
Protected Types
typedef std::map< std::string, std::pair< unsigned int, unsigned int > >	Counts
Protected Member Functions
Real	line_search (Real tol, Real last_residual, Real &current_residual, NumericVector< Number > &newton_iterate, const NumericVector< Number > &linear_solution)
void	print_convergence (unsigned int step_num, Real current_residual, Real step_norm, bool linear_solve_finished)
bool	test_convergence (Real current_residual, Real step_norm, bool linear_solve_finished)
void	increment_constructor_count (const std::string &name)
void	increment_destructor_count (const std::string &name)
Protected Attributes
UniquePtr< LinearSolver< Number > >	linear_solver
Real	max_solution_norm
Real	max_residual_norm
unsigned int	_outer_iterations
unsigned int	_inner_iterations
sys_type &	_system
unsigned int	_solve_result
const Parallel::Communicator &	_communicator
Static Protected Attributes
static Counts	_counts
static Threads::atomic < unsigned int >	_n_objects
static Threads::spin_mutex	_mutex
static bool	_enable_print_counter = true

Detailed Description

This class defines a solver which uses the default libMesh linear solver in a quasiNewton method to handle a DifferentiableSystem

This class is part of the new DifferentiableSystem framework, which is still experimental. Users of this framework should beware of bugs and future API changes.

Author:: Roy H. Stogner 2006

Definition at line 48 of file newton_solver.h.

Member Typedef Documentation

typedef std::map<std::string, std::pair<unsigned int, unsigned int> > libMesh::ReferenceCounter::Counts [protected, inherited]

Data structure to log the information. The log is identified by the class name.

Definition at line 113 of file reference_counter.h.

typedef DiffSolver libMesh::NewtonSolver::Parent

Definition at line 63 of file newton_solver.h.

typedef ImplicitSystem libMesh::DiffSolver::sys_type [inherited]

The type of system

Definition at line 75 of file diff_solver.h.

Member Enumeration Documentation

enum libMesh::DiffSolver::SolveResult [inherited]

Enumeration return type for the solve() function. Multiple SolveResults may be combined (OR'd) in the single return. To test which ones are present, just AND the return value with any of the SolveResult flags defined below.

Enumerator:

INVALID_SOLVE_RESULT	A default or invalid solve result. This usually means no solve has occurred yet.
CONVERGED_NO_REASON	The solver converged but no particular reason is specified.
CONVERGED_ABSOLUTE_RESIDUAL	The DiffSolver achieved the desired absolute residual tolerance.
CONVERGED_RELATIVE_RESIDUAL	The DiffSolver achieved the desired relative residual tolerance.
CONVERGED_ABSOLUTE_STEP	The DiffSolver achieved the desired absolute step size tolerance.
CONVERGED_RELATIVE_STEP	The DiffSolver achieved the desired relative step size tolerance.
DIVERGED_NO_REASON	The DiffSolver diverged but no particular reason is specified.
DIVERGED_MAX_NONLINEAR_ITERATIONS	The DiffSolver reached the maximum allowed number of nonlinear iterations before satisfying any convergence tests.
DIVERGED_BACKTRACKING_FAILURE	The DiffSolver failed to find a descent direction by backtracking (See newton_solver.C)
DIVERGED_LINEAR_SOLVER_FAILURE	The linear solver used by the DiffSolver failed to find a solution.

Definition at line 218 of file diff_solver.h.

                   {
    INVALID_SOLVE_RESULT = 0,

    CONVERGED_NO_REASON = 1,

    CONVERGED_ABSOLUTE_RESIDUAL = 2,

    CONVERGED_RELATIVE_RESIDUAL = 4,

    CONVERGED_ABSOLUTE_STEP = 8,

    CONVERGED_RELATIVE_STEP = 16,

    DIVERGED_NO_REASON = 32,

    DIVERGED_MAX_NONLINEAR_ITERATIONS = 64,

    DIVERGED_BACKTRACKING_FAILURE = 128,

    DIVERGED_LINEAR_SOLVER_FAILURE = 256
  };

Constructor & Destructor Documentation

libMesh::NewtonSolver::NewtonSolver ( sys_type & system ) [explicit]

Constructor. Requires a reference to the system to be solved.

Definition at line 232 of file newton_solver.C.

  : Parent(s),
    require_residual_reduction(true),
    require_finite_residual(true),
    brent_line_search(true),
    track_linear_convergence(false),
    minsteplength(1e-5),
    linear_tolerance_multiplier(1e-3),
    linear_solver(LinearSolver<Number>::build(s.comm()))
{
}

libMesh::NewtonSolver::~NewtonSolver ( ) [virtual]

Destructor.

Definition at line 246 of file newton_solver.C.

{
}

Member Function Documentation

UniquePtr< DiffSolver > libMesh::DiffSolver::build ( sys_type & s ) [static, inherited]

Factory. Requires a reference to the system to be solved. Returns a NewtonSolver by default

Definition at line 53 of file diff_solver.C.

Referenced by libMesh::TimeSolver::init().

{
  return UniquePtr<DiffSolver>(new NewtonSolver(s));
}

const Parallel::Communicator& libMesh::ParallelObject::comm ( ) const [inline, inherited]

Returns:: a reference to the Parallel::Communicator object used by this mesh.

Definition at line 86 of file parallel_object.h.

References libMesh::ParallelObject::_communicator.

  { return _communicator; }

void libMesh::ReferenceCounter::disable_print_counter_info ( ) [static, inherited]

Definition at line 106 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

Referenced by libMesh::LibMeshInit::LibMeshInit().

{
  _enable_print_counter = false;
  return;
}

void libMesh::ReferenceCounter::enable_print_counter_info ( ) [static, inherited]

Methods to enable/disable the reference counter output from print_info()

Definition at line 100 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

{
  _enable_print_counter = true;
  return;
}

std::string libMesh::ReferenceCounter::get_info ( ) [static, inherited]

Gets a string containing the reference information.

Definition at line 47 of file reference_counter.C.

References libMesh::ReferenceCounter::_counts, and libMesh::Quality::name().

Referenced by libMesh::ReferenceCounter::print_info().

{
#if defined(LIBMESH_ENABLE_REFERENCE_COUNTING) && defined(DEBUG)

  std::ostringstream oss;

  oss << '\n'
      << " ---------------------------------------------------------------------------- \n"
      << "| Reference count information                                                |\n"
      << " ---------------------------------------------------------------------------- \n";

  for (Counts::iterator it = _counts.begin();
       it != _counts.end(); ++it)
    {
      const std::string name(it->first);
      const unsigned int creations    = it->second.first;
      const unsigned int destructions = it->second.second;

      oss << "| " << name << " reference count information:\n"
          << "|  Creations:    " << creations    << '\n'
          << "|  Destructions: " << destructions << '\n';
    }

  oss << " ---------------------------------------------------------------------------- \n";

  return oss.str();

#else

  return "";

#endif
}

void libMesh::ReferenceCounter::increment_constructor_count ( const std::string & name ) [inline, protected, inherited]

Increments the construction counter. Should be called in the constructor of any derived class that will be reference counted.

Definition at line 163 of file reference_counter.h.

References libMesh::ReferenceCounter::_counts, libMesh::Quality::name(), and libMesh::Threads::spin_mtx.

Referenced by libMesh::ReferenceCountedObject< RBParametrized >::ReferenceCountedObject().

{
  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
  std::pair<unsigned int, unsigned int>& p = _counts[name];

  p.first++;
}

void libMesh::ReferenceCounter::increment_destructor_count ( const std::string & name ) [inline, protected, inherited]

Increments the destruction counter. Should be called in the destructor of any derived class that will be reference counted.

Definition at line 176 of file reference_counter.h.

References libMesh::ReferenceCounter::_counts, libMesh::Quality::name(), and libMesh::Threads::spin_mtx.

Referenced by libMesh::ReferenceCountedObject< RBParametrized >::~ReferenceCountedObject().

{
  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
  std::pair<unsigned int, unsigned int>& p = _counts[name];

  p.second++;
}

void libMesh::NewtonSolver::init ( ) [virtual]

The initialization function. This method is used to initialize internal data structures before a simulation begins.

Reimplemented from libMesh::DiffSolver.

Definition at line 252 of file newton_solver.C.

References libMesh::DiffSolver::_system, libMesh::DiffSolver::init(), linear_solver, libMesh::System::name(), and libMesh::on_command_line().

{
  Parent::init();

  if (libMesh::on_command_line("--solver_system_names"))
    linear_solver->init((_system.name()+"_").c_str());
  else
    linear_solver->init();

  linear_solver->init_names(_system);
}

Real libMesh::NewtonSolver::line_search	(	Real	tol,
		Real	last_residual,
		Real &	current_residual,
		NumericVector< Number > &	newton_iterate,
		const NumericVector< Number > &	linear_solution
	)		`[protected]`

This does a line search in the direction opposite linear_solution to try and minimize the residual of newton_iterate. newton_iterate is moved to the end of the quasiNewton step, and the return value is the substep size.

Definition at line 38 of file newton_solver.C.

References libMesh::DiffSolver::_outer_iterations, libMesh::DiffSolver::_solve_result, libMesh::DiffSolver::_system, std::abs(), libMesh::NumericVector< T >::add(), libMesh::ImplicitSystem::assembly(), brent_line_search, libMesh::NumericVector< T >::close(), libMesh::DiffSolver::continue_after_backtrack_failure, libMesh::DiffSolver::DIVERGED_BACKTRACKING_FAILURE, libMesh::NumericVector< T >::l2_norm(), libMesh::libmesh_isnan(), std::max(), std::min(), minsteplength, libMesh::out, libMesh::DiffSolver::quiet, libMesh::Real, require_finite_residual, require_residual_reduction, libMesh::ExplicitSystem::rhs, libMesh::SIGN(), libMesh::DiffSolver::verbose, and libMesh::x.

Referenced by solve().

{
  // Take a full step if we got a residual reduction or if we
  // aren't substepping
  if ((current_residual < last_residual) ||
      (!require_residual_reduction &&
       (!require_finite_residual || !libmesh_isnan(current_residual))))
    return 1.;

  // The residual vector
  NumericVector<Number> &rhs = *(_system.rhs);

  Real ax = 0.;  // First abscissa, don't take negative steps
  Real cx = 1.;  // Second abscissa, don't extrapolate steps

  // Find bx, a step length that gives lower residual than ax or cx
  Real bx = 1.;

  while (libmesh_isnan(current_residual) ||
         (current_residual > last_residual &&
          require_residual_reduction))
    {
      // Reduce step size to 1/2, 1/4, etc.
      Real substepdivision;
      if (brent_line_search && !libmesh_isnan(current_residual))
        {
          substepdivision = std::min(0.5, last_residual/current_residual);
          substepdivision = std::max(substepdivision, tol*2.);
        }
      else
        substepdivision = 0.5;

      newton_iterate.add (bx * (1.-substepdivision),
                          linear_solution);
      newton_iterate.close();
      bx *= substepdivision;
      if (verbose)
        libMesh::out << "  Shrinking Newton step to "
                     << bx << std::endl;

      // Check residual with fractional Newton step
      _system.assembly (true, false);

      rhs.close();
      current_residual = rhs.l2_norm();
      if (verbose)
        libMesh::out << "  Current Residual: "
                     << current_residual << std::endl;

      if (bx/2. < minsteplength &&
          (libmesh_isnan(current_residual) ||
           (current_residual > last_residual)))
        {
          libMesh::out << "Inexact Newton step FAILED at step "
                       << _outer_iterations << std::endl;

          if (!continue_after_backtrack_failure)
            {
              libmesh_convergence_failure();
            }
          else
            {
              libMesh::out << "Continuing anyway ..." << std::endl;
              _solve_result = DiffSolver::DIVERGED_BACKTRACKING_FAILURE;
              return bx;
            }
        }
    } // end while (current_residual > last_residual)

  // Now return that reduced-residual step, or  use Brent's method to
  // find a more optimal step.

  if (!brent_line_search)
    return bx;

  // Brent's method adapted from Numerical Recipes in C, ch. 10.2
  Real e = 0.;

  Real x = bx, w = bx, v = bx;

  // Residuals at bx
  Real fx = current_residual,
    fw = current_residual,
    fv = current_residual;

  // Max iterations for Brent's method loop
  const unsigned int max_i = 20;

  // for golden ratio steps
  const Real golden_ratio = 1.-(std::sqrt(5.)-1.)/2.;

  for (unsigned int i=1; i <= max_i; i++)
    {
      Real xm = (ax+cx)*0.5;
      Real tol1 = tol * std::abs(x) + tol*tol;
      Real tol2 = 2.0 * tol1;

      // Test if we're done
      if (std::abs(x-xm) <= (tol2 - 0.5 * (cx - ax)))
        return x;

      Real d;

      // Construct a parabolic fit
      if (std::abs(e) > tol1)
        {
          Real r = (x-w)*(fx-fv);
          Real q = (x-v)*(fx-fw);
          Real p = (x-v)*q-(x-w)*r;
          q = 2. * (q-r);
          if (q > 0.)
            p = -p;
          else
            q = std::abs(q);
          if (std::abs(p) >= std::abs(0.5*q*e) ||
              p <= q * (ax-x) ||
              p >= q * (cx-x))
            {
              // Take a golden section step
              e = x >= xm ? ax-x : cx-x;
              d = golden_ratio * e;
            }
          else
            {
              // Take a parabolic fit step
              d = p/q;
              if (x+d-ax < tol2 || cx-(x+d) < tol2)
                d = SIGN(tol1, xm - x);
            }
        }
      else
        {
          // Take a golden section step
          e = x >= xm ? ax-x : cx-x;
          d = golden_ratio * e;
        }

      Real u = std::abs(d) >= tol1 ? x+d : x + SIGN(tol1,d);

      // Assemble the residual at the new steplength u
      newton_iterate.add (bx - u, linear_solution);
      newton_iterate.close();
      bx = u;
      if (verbose)
        libMesh::out << "  Shrinking Newton step to "
                     << bx << std::endl;

      _system.assembly (true, false);

      rhs.close();
      Real fu = current_residual = rhs.l2_norm();
      if (verbose)
        libMesh::out << "  Current Residual: "
                     << fu << std::endl;

      if (fu <= fx)
        {
          if (u >= x)
            ax = x;
          else
            cx = x;
          v = w;   w = x;   x = u;
          fv = fw; fw = fx; fx = fu;
        }
      else
        {
          if (u < x)
            ax = u;
          else
            cx = u;
          if (fu <= fw || w == x)
            {
              v = w;   w = u;
              fv = fw; fw = fu;
            }
          else if (fu <= fv || v == x || v == w)
            {
              v = u;
              fv = fu;
            }
        }
    }

  if (!quiet)
    libMesh::out << "Warning!  Too many iterations used in Brent line search!"
                 << std::endl;
  return bx;
}

static unsigned int libMesh::ReferenceCounter::n_objects ( ) [inline, static, inherited]

Prints the number of outstanding (created, but not yet destroyed) objects.

Definition at line 79 of file reference_counter.h.

References libMesh::ReferenceCounter::_n_objects.

Referenced by libMesh::LibMeshInit::~LibMeshInit().

  { return _n_objects; }

processor_id_type libMesh::ParallelObject::n_processors ( ) const [inline, inherited]

Returns:: the number of processors in the group.

Definition at line 92 of file parallel_object.h.

References libMesh::ParallelObject::_communicator, and libMesh::Parallel::Communicator::size().

  { return cast_int<processor_id_type>(_communicator.size()); }

void libMesh::NewtonSolver::print_convergence	(	unsigned int	step_num,
		Real	current_residual,
		Real	step_norm,
		bool	linear_solve_finished
	)		`[protected]`

This prints output for the convergence criteria based on by the given residual and step size.

Definition at line 603 of file newton_solver.C.

References libMesh::DiffSolver::absolute_residual_tolerance, libMesh::DiffSolver::absolute_step_tolerance, libMesh::DiffSolver::max_residual_norm, libMesh::DiffSolver::max_solution_norm, libMesh::out, libMesh::DiffSolver::relative_residual_tolerance, libMesh::DiffSolver::relative_step_tolerance, and libMesh::DiffSolver::verbose.

Referenced by solve().

{
  // Is our absolute residual low enough?
  if (current_residual < absolute_residual_tolerance)
    {
      libMesh::out << "  Nonlinear solver converged, step " << step_num
                   << ", residual " << current_residual
                   << std::endl;
    }
  else if (absolute_residual_tolerance)
    {
      if (verbose)
        libMesh::out << "  Nonlinear solver current_residual "
                     << current_residual << " > "
                     << (absolute_residual_tolerance) << std::endl;
    }

  // Is our relative residual low enough?
  if ((current_residual / max_residual_norm) <
      relative_residual_tolerance)
    {
      libMesh::out << "  Nonlinear solver converged, step " << step_num
                   << ", residual reduction "
                   << current_residual / max_residual_norm
                   << " < " << relative_residual_tolerance
                   << std::endl;
    }
  else if (relative_residual_tolerance)
    {
      if (verbose)
        libMesh::out << "  Nonlinear solver relative residual "
                     << (current_residual / max_residual_norm)
                     << " > " << relative_residual_tolerance
                     << std::endl;
    }

  // For incomplete linear solves, it's not safe to test step sizes
  if (!linear_solve_finished)
    return;

  // Is our absolute Newton step size small enough?
  if (step_norm < absolute_step_tolerance)
    {
      libMesh::out << "  Nonlinear solver converged, step " << step_num
                   << ", absolute step size "
                   << step_norm
                   << " < " << absolute_step_tolerance
                   << std::endl;
    }
  else if (absolute_step_tolerance)
    {
      if (verbose)
        libMesh::out << "  Nonlinear solver absolute step size "
                     << step_norm
                     << " > " << absolute_step_tolerance
                     << std::endl;
    }

  // Is our relative Newton step size small enough?
  if (step_norm / max_solution_norm <
      relative_step_tolerance)
    {
      libMesh::out << "  Nonlinear solver converged, step " << step_num
                   << ", relative step size "
                   << (step_norm / max_solution_norm)
                   << " < " << relative_step_tolerance
                   << std::endl;
    }
  else if (relative_step_tolerance)
    {
      if (verbose)
        libMesh::out << "  Nonlinear solver relative step size "
                     << (step_norm / max_solution_norm)
                     << " > " << relative_step_tolerance
                     << std::endl;
    }
}

void libMesh::ReferenceCounter::print_info ( std::ostream & out = libMesh::out ) [static, inherited]

Prints the reference information, by default to libMesh::out.

Definition at line 88 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter, and libMesh::ReferenceCounter::get_info().

Referenced by libMesh::LibMeshInit::~LibMeshInit().

{
  if( _enable_print_counter ) out_stream << ReferenceCounter::get_info();
}

processor_id_type libMesh::ParallelObject::processor_id ( ) const [inline, inherited]

Returns:: the rank of this processor in the group.

Definition at line 98 of file parallel_object.h.

References libMesh::ParallelObject::_communicator, and libMesh::Parallel::Communicator::rank().

  { return cast_int<processor_id_type>(_communicator.rank()); }

void libMesh::NewtonSolver::reinit ( ) [virtual]

The reinitialization function. This method is used after changes in the mesh.

Reimplemented from libMesh::DiffSolver.

Definition at line 266 of file newton_solver.C.

References libMesh::DiffSolver::_system, linear_solver, and libMesh::DiffSolver::reinit().

{
  Parent::reinit();

  linear_solver->clear();

  linear_solver->init_names(_system);
}

unsigned int libMesh::NewtonSolver::solve ( ) [virtual]

This method performs a solve, using an inexact Newton-Krylov method with line search.

Implements libMesh::DiffSolver.

Definition at line 277 of file newton_solver.C.

{
  START_LOG("solve()", "NewtonSolver");

  // Reset any prior solve result
  _solve_result = INVALID_SOLVE_RESULT;

  NumericVector<Number> &newton_iterate = *(_system.solution);

  UniquePtr<NumericVector<Number> > linear_solution_ptr = newton_iterate.zero_clone();
  NumericVector<Number> &linear_solution = *linear_solution_ptr;
  NumericVector<Number> &rhs = *(_system.rhs);

  newton_iterate.close();
  linear_solution.close();
  rhs.close();

#ifdef LIBMESH_ENABLE_CONSTRAINTS
  _system.get_dof_map().enforce_constraints_exactly(_system);
#endif

  SparseMatrix<Number> &matrix = *(_system.matrix);

  // Set starting linear tolerance
  Real current_linear_tolerance = initial_linear_tolerance;

  // Start counting our linear solver steps
  _inner_iterations = 0;

  // Now we begin the nonlinear loop
  for (_outer_iterations=0; _outer_iterations<max_nonlinear_iterations;
       ++_outer_iterations)
    {
      if (verbose)
        libMesh::out << "Assembling the System" << std::endl;

      _system.assembly(true, true);
      rhs.close();
      Real current_residual = rhs.l2_norm();

      if (libmesh_isnan(current_residual))
        {
          libMesh::out << "  Nonlinear solver DIVERGED at step "
                       << _outer_iterations
                       << " with residual Not-a-Number"
                       << std::endl;
          libmesh_convergence_failure();
          continue;
        }

      if (current_residual == 0)
        {
          if (verbose)
            libMesh::out << "Linear solve unnecessary; residual = 0"
                         << std::endl;

          // We're not doing a solve, but other code may reuse this
          // matrix.
          matrix.close();

          if (absolute_residual_tolerance > 0)
            _solve_result |= CONVERGED_ABSOLUTE_RESIDUAL;
          if (relative_residual_tolerance > 0)
            _solve_result |= CONVERGED_RELATIVE_RESIDUAL;
          if (absolute_step_tolerance > 0)
            _solve_result |= CONVERGED_ABSOLUTE_STEP;
          if (relative_step_tolerance > 0)
            _solve_result |= CONVERGED_RELATIVE_STEP;

          break;
        }

      // Prepare to take incomplete steps
      Real last_residual = current_residual;

      max_residual_norm = std::max (current_residual,
                                    max_residual_norm);

      // Compute the l2 norm of the whole solution
      Real norm_total = newton_iterate.l2_norm();

      max_solution_norm = std::max(max_solution_norm, norm_total);

      if (verbose)
        libMesh::out << "Nonlinear Residual: "
                     << current_residual << std::endl;

      // Make sure our linear tolerance is low enough
      current_linear_tolerance = std::min (current_linear_tolerance,
                                           current_residual * linear_tolerance_multiplier);

      // But don't let it be too small
      if (current_linear_tolerance < minimum_linear_tolerance)
        {
          current_linear_tolerance = minimum_linear_tolerance;
        }

      // At this point newton_iterate is the current guess, and
      // linear_solution is now about to become the NEGATIVE of the next
      // Newton step.

      // Our best initial guess for the linear_solution is zero!
      linear_solution.zero();

      if (verbose)
        libMesh::out << "Linear solve starting, tolerance "
                     << current_linear_tolerance << std::endl;

      // Solve the linear system.
      const std::pair<unsigned int, Real> rval =
        linear_solver->solve (matrix, _system.request_matrix("Preconditioner"),
                              linear_solution, rhs, current_linear_tolerance,
                              max_linear_iterations);

      if (track_linear_convergence)
        {
          LinearConvergenceReason linear_c_reason = linear_solver->get_converged_reason();

          // Check if something went wrong during the linear solve
          if (linear_c_reason < 0)
            {
              // The linear solver failed somehow
              _solve_result |= DiffSolver::DIVERGED_LINEAR_SOLVER_FAILURE;
              // Print a message
              libMesh::out << "Linear solver failed during Newton step, dropping out."
                           << std::endl;
              break;
            }
        }

      // We may need to localize a parallel solution
      _system.update ();
      // The linear solver may not have fit our constraints exactly
#ifdef LIBMESH_ENABLE_CONSTRAINTS
      _system.get_dof_map().enforce_constraints_exactly
        (_system, &linear_solution, /* homogeneous = */ true);
#endif

      const unsigned int linear_steps = rval.first;
      libmesh_assert_less_equal (linear_steps, max_linear_iterations);
      _inner_iterations += linear_steps;

      const bool linear_solve_finished =
        !(linear_steps == max_linear_iterations);

      if (verbose)
        libMesh::out << "Linear solve finished, step " << linear_steps
                     << ", residual " << rval.second
                     << std::endl;

      // Compute the l2 norm of the nonlinear update
      Real norm_delta = linear_solution.l2_norm();

      if (verbose)
        libMesh::out << "Trying full Newton step" << std::endl;
      // Take a full Newton step
      newton_iterate.add (-1., linear_solution);
      newton_iterate.close();

      if (this->linear_solution_monitor.get())
        {
          // Compute the l2 norm of the whole solution
          norm_total = newton_iterate.l2_norm();
          rhs.close();
          (*this->linear_solution_monitor)(linear_solution, norm_delta,
                                           newton_iterate, norm_total,
                                           rhs, rhs.l2_norm(), _outer_iterations);
        }

      // Check residual with full Newton step, if that's useful for determining
      // whether to line search, whether to quit early, or whether to die after
      // hitting our max iteration count
      if (this->require_residual_reduction ||
          this->require_finite_residual ||
          _outer_iterations+1 < max_nonlinear_iterations ||
          !continue_after_max_iterations)
        {
          _system.assembly(true, false);

          rhs.close();
          current_residual = rhs.l2_norm();
          if (verbose)
            libMesh::out << "  Current Residual: "
                         << current_residual << std::endl;

          // don't fiddle around if we've already converged
          if (test_convergence(current_residual, norm_delta,
                               linear_solve_finished &&
                               current_residual <= last_residual))
            {
              if (!quiet)
                print_convergence(_outer_iterations, current_residual,
                                  norm_delta, linear_solve_finished &&
                                  current_residual <= last_residual);
              _outer_iterations++;
              break; // out of _outer_iterations for loop
            }
        }

      // since we're not converged, backtrack if necessary
      Real steplength =
        this->line_search(std::sqrt(TOLERANCE),
                          last_residual, current_residual,
                          newton_iterate, linear_solution);
      norm_delta *= steplength;

      // Check to see if backtracking failed,
      // and break out of the nonlinear loop if so...
      if (_solve_result == DiffSolver::DIVERGED_BACKTRACKING_FAILURE)
        {
          _outer_iterations++;
          break; // out of _outer_iterations for loop
        }

      if (_outer_iterations + 1 >= max_nonlinear_iterations)
        {
          libMesh::out << "  Nonlinear solver reached maximum step "
                       << max_nonlinear_iterations << ", latest evaluated residual "
                       << current_residual << std::endl;
          if (continue_after_max_iterations)
            {
              _solve_result = DiffSolver::DIVERGED_MAX_NONLINEAR_ITERATIONS;
              libMesh::out << "  Continuing..." << std::endl;
            }
          else
            {
              libmesh_convergence_failure();
            }
          continue;
        }

      // Compute the l2 norm of the whole solution
      norm_total = newton_iterate.l2_norm();

      max_solution_norm = std::max(max_solution_norm, norm_total);

      // Print out information for the
      // nonlinear iterations.
      if (verbose)
        libMesh::out << "  Nonlinear step: |du|/|u| = "
                     << norm_delta / norm_total
                     << ", |du| = " << norm_delta
                     << std::endl;

      // Terminate the solution iteration if the difference between
      // this iteration and the last is sufficiently small.
      if (test_convergence(current_residual, norm_delta / steplength,
                           linear_solve_finished))
        {
          if (!quiet)
            print_convergence(_outer_iterations, current_residual,
                              norm_delta / steplength,
                              linear_solve_finished);
          _outer_iterations++;
          break; // out of _outer_iterations for loop
        }
    } // end nonlinear loop

  // The linear solver may not have fit our constraints exactly
#ifdef LIBMESH_ENABLE_CONSTRAINTS
  _system.get_dof_map().enforce_constraints_exactly(_system);
#endif

  // We may need to localize a parallel solution
  _system.update ();

  STOP_LOG("solve()", "NewtonSolver");

  // Make sure we are returning something sensible as the
  // _solve_result, except in the edge case where we weren't really asked to
  // solve.
  libmesh_assert (_solve_result != DiffSolver::INVALID_SOLVE_RESULT ||
                  !max_nonlinear_iterations);

  return _solve_result;
}

unsigned int libMesh::DiffSolver::solve_result ( ) [inline, inherited]

Returns:: the value of the SolveResult from the last solve.

Definition at line 128 of file diff_solver.h.

References libMesh::DiffSolver::_solve_result.

{ return _solve_result; }

const sys_type& libMesh::DiffSolver::system ( ) const [inline, inherited]

Returns:: a constant reference to the system we are solving.

Definition at line 133 of file diff_solver.h.

References libMesh::DiffSolver::_system.

Referenced by libMesh::__libmesh_petsc_diff_solver_residual().

{ return _system; }

sys_type& libMesh::DiffSolver::system ( ) [inline, inherited]

Returns:: a writeable reference to the system we are solving.

Definition at line 138 of file diff_solver.h.

References libMesh::DiffSolver::_system.

{ return _system; }

bool libMesh::NewtonSolver::test_convergence	(	Real	current_residual,
		Real	step_norm,
		bool	linear_solve_finished
	)		`[protected]`

This returns true if a convergence criterion has been passed by the given residual and step size; false otherwise.

Definition at line 556 of file newton_solver.C.

Referenced by solve().

{
  // We haven't converged unless we pass a convergence test
  bool has_converged = false;

  // Is our absolute residual low enough?
  if (current_residual < absolute_residual_tolerance)
    {
      _solve_result |= CONVERGED_ABSOLUTE_RESIDUAL;
      has_converged = true;
    }

  // Is our relative residual low enough?
  if ((current_residual / max_residual_norm) <
      relative_residual_tolerance)
    {
      _solve_result |= CONVERGED_RELATIVE_RESIDUAL;
      has_converged = true;
    }

  // For incomplete linear solves, it's not safe to test step sizes
  if (!linear_solve_finished)
    {
      return has_converged;
    }

  // Is our absolute Newton step size small enough?
  if (step_norm < absolute_step_tolerance)
    {
      _solve_result |= CONVERGED_ABSOLUTE_STEP;
      has_converged = true;
    }

  // Is our relative Newton step size small enough?
  if (step_norm / max_solution_norm <
      relative_step_tolerance)
    {
      _solve_result |= CONVERGED_RELATIVE_STEP;
      has_converged = true;
    }

  return has_converged;
}

unsigned int libMesh::DiffSolver::total_inner_iterations ( ) [inline, inherited]

Returns:: the number of "inner" (e.g. Krylov) iterations required by the last solve.

Definition at line 123 of file diff_solver.h.

References libMesh::DiffSolver::_inner_iterations.

{ return _inner_iterations; }

unsigned int libMesh::DiffSolver::total_outer_iterations ( ) [inline, inherited]

Returns:: the number of "outer" (e.g. quasi-Newton) iterations required by the last solve.

Definition at line 117 of file diff_solver.h.

References libMesh::DiffSolver::_outer_iterations.

{ return _outer_iterations; }

Member Data Documentation

const Parallel::Communicator& libMesh::ParallelObject::_communicator [protected, inherited]

Definition at line 104 of file parallel_object.h.

Referenced by libMesh::EquationSystems::build_solution_vector(), libMesh::ParallelObject::comm(), libMesh::EquationSystems::get_solution(), libMesh::ParallelObject::n_processors(), libMesh::ParallelObject::operator=(), and libMesh::ParallelObject::processor_id().

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts [static, protected, inherited]

Actually holds the data.

Definition at line 118 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::get_info(), libMesh::ReferenceCounter::increment_constructor_count(), and libMesh::ReferenceCounter::increment_destructor_count().

bool libMesh::ReferenceCounter::_enable_print_counter = true [static, protected, inherited]

Flag to control whether reference count information is printed when print_info is called.

Definition at line 137 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::disable_print_counter_info(), libMesh::ReferenceCounter::enable_print_counter_info(), and libMesh::ReferenceCounter::print_info().

unsigned int libMesh::DiffSolver::_inner_iterations [protected, inherited]

The number of inner iterations used by the last solve

Definition at line 309 of file diff_solver.h.

Referenced by solve(), and libMesh::DiffSolver::total_inner_iterations().

Threads::spin_mutex libMesh::ReferenceCounter::_mutex [static, protected, inherited]

Mutual exclusion object to enable thread-safe reference counting.

Definition at line 131 of file reference_counter.h.

Threads::atomic< unsigned int > libMesh::ReferenceCounter::_n_objects [static, protected, inherited]

The number of objects. Print the reference count information when the number returns to 0.

Definition at line 126 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::n_objects(), libMesh::ReferenceCounter::ReferenceCounter(), and libMesh::ReferenceCounter::~ReferenceCounter().

unsigned int libMesh::DiffSolver::_outer_iterations [protected, inherited]

The number of outer iterations used by the last solve

Definition at line 304 of file diff_solver.h.

Referenced by line_search(), solve(), and libMesh::DiffSolver::total_outer_iterations().

unsigned int libMesh::DiffSolver::_solve_result [protected, inherited]

Initialized to zero. solve_result is typically set internally in the solve() function before it returns. When non-zero, solve_result tells the result of the latest solve. See enum definition for description.

Definition at line 322 of file diff_solver.h.

Referenced by line_search(), solve(), libMesh::DiffSolver::solve_result(), and test_convergence().

sys_type& libMesh::DiffSolver::_system [protected, inherited]

A reference to the system we are solving.

Definition at line 314 of file diff_solver.h.

Referenced by init(), line_search(), reinit(), solve(), and libMesh::DiffSolver::system().

Real libMesh::DiffSolver::absolute_residual_tolerance [inherited]

The DiffSolver should exit after the residual is reduced to either less than absolute_residual_tolerance or less than relative_residual_tolerance times the initial residual.

Users should increase any of these tolerances that they want to use for a stopping condition.

Definition at line 187 of file diff_solver.h.

Referenced by print_convergence(), solve(), and test_convergence().

Real libMesh::DiffSolver::absolute_step_tolerance [inherited]

The DiffSolver should exit after the full nonlinear step norm is reduced to either less than absolute_step_tolerance or less than relative_step_tolerance times the largest nonlinear solution which has been seen so far.

Users should increase any of these tolerances that they want to use for a stopping condition.

Definition at line 199 of file diff_solver.h.

Referenced by print_convergence(), solve(), and test_convergence().

bool libMesh::NewtonSolver::brent_line_search

If require_residual_reduction is true, the solver may reduce step lengths when required. If so, brent_line_search is an option. If brent_line_search is set to false, the solver reduces the length of its steps by 1/2 iteratively until it finds residual reduction. If true, step lengths are first reduced by 1/2 or more to find some residual reduction, then Brent's method is used to find as much residual reduction as possible.

brent_line_search is currently set to true by default.

Definition at line 112 of file newton_solver.h.

Referenced by line_search().

bool libMesh::DiffSolver::continue_after_backtrack_failure [inherited]

Defaults to false, telling the DiffSolver to throw an error when the backtracking scheme fails to find a descent direction.

Definition at line 176 of file diff_solver.h.

Referenced by line_search().

bool libMesh::DiffSolver::continue_after_max_iterations [inherited]

Defaults to true, telling the DiffSolver to continue rather than exit when a solve has reached its maximum number of nonlinear iterations.

Definition at line 170 of file diff_solver.h.

Referenced by solve().

Real libMesh::DiffSolver::initial_linear_tolerance [inherited]

Any required linear solves will at first be done with this tolerance; the DiffSolver may tighten the tolerance for later solves.

Definition at line 206 of file diff_solver.h.

Referenced by solve().

UniquePtr<LinearSolutionMonitor> libMesh::DiffSolver::linear_solution_monitor [inherited]

Pointer to functor which is called right after each linear solve

Definition at line 284 of file diff_solver.h.

Referenced by libMesh::__libmesh_petsc_diff_solver_monitor(), and solve().

UniquePtr<LinearSolver<Number> > libMesh::NewtonSolver::linear_solver [protected]

The LinearSolver defines the interface used to solve the linear_implicit system. This class handles all the details of interfacing with various linear algebra packages like PETSc or LASPACK.

Definition at line 145 of file newton_solver.h.

Referenced by init(), reinit(), and solve().

Real libMesh::NewtonSolver::linear_tolerance_multiplier

The tolerance for linear solves is kept below this multiplier (which defaults to 1e-3) times the norm of the current nonlinear residual

Definition at line 135 of file newton_solver.h.

Referenced by solve().

unsigned int libMesh::DiffSolver::max_linear_iterations [inherited]

Each linear solver step should exit after max_linear_iterations is exceeded.

Definition at line 144 of file diff_solver.h.

Referenced by libMesh::ContinuationSystem::continuation_solve(), solve(), and libMesh::ContinuationSystem::solve_tangent().

unsigned int libMesh::DiffSolver::max_nonlinear_iterations [inherited]

The DiffSolver should exit in failure if max_nonlinear_iterations is exceeded and continue_after_max_iterations is false, or should end the nonlinear solve if max_nonlinear_iterations is exceeded and continue_after_max_iterations is true.

Definition at line 152 of file diff_solver.h.

Referenced by libMesh::ContinuationSystem::continuation_solve(), solve(), and libMesh::ContinuationSystem::update_solution().

Real libMesh::DiffSolver::max_residual_norm [protected, inherited]

The largest nonlinear residual which the DiffSolver has yet seen will be stored here, to be used for stopping criteria based on relative_residual_tolerance

Definition at line 299 of file diff_solver.h.

Referenced by libMesh::DiffSolver::init(), print_convergence(), libMesh::DiffSolver::reinit(), solve(), and test_convergence().

Real libMesh::DiffSolver::max_solution_norm [protected, inherited]

The largest solution norm which the DiffSolver has yet seen will be stored here, to be used for stopping criteria based on relative_step_tolerance

Definition at line 292 of file diff_solver.h.

Referenced by libMesh::DiffSolver::init(), print_convergence(), libMesh::DiffSolver::reinit(), solve(), and test_convergence().

Real libMesh::DiffSolver::minimum_linear_tolerance [inherited]

The tolerance for linear solves is kept above this minimum

Definition at line 211 of file diff_solver.h.

Referenced by solve().

Real libMesh::NewtonSolver::minsteplength

If the quasi-Newton step length must be reduced to below this factor to give a residual reduction, then the Newton solver dies with an error message. It is currently set to 1e-5 by default.

Definition at line 129 of file newton_solver.h.

Referenced by line_search().

bool libMesh::DiffSolver::quiet [inherited]

The DiffSolver should not print anything to libMesh::out unless quiet is set to false; default is true.

Definition at line 158 of file diff_solver.h.

Referenced by line_search(), and solve().

Real libMesh::DiffSolver::relative_residual_tolerance [inherited]

Definition at line 188 of file diff_solver.h.

Referenced by print_convergence(), solve(), and test_convergence().

Real libMesh::DiffSolver::relative_step_tolerance [inherited]

Definition at line 200 of file diff_solver.h.

Referenced by print_convergence(), solve(), and test_convergence().

bool libMesh::NewtonSolver::require_finite_residual

If this is set to true, the solver is forced to test the residual after each Newton step, and to reduce the length of its steps whenever necessary to avoid an infinite or NaN residual. It is currently set to true by default; set it to false to avoid unnecessary residual assembly on well-behaved systems.

Definition at line 99 of file newton_solver.h.

Referenced by line_search(), and solve().

bool libMesh::NewtonSolver::require_residual_reduction

If this is set to true, the solver is forced to test the residual after each Newton step, and to reduce the length of its steps whenever necessary to avoid a residual increase. It is currently set to true by default; set it to false to avoid unnecessary residual assembly on well-behaved systems.

Definition at line 90 of file newton_solver.h.

Referenced by line_search(), and solve().

bool libMesh::NewtonSolver::track_linear_convergence

If set to true, check for convergence of the linear solve. If no convergence is acquired during the linear solve, the nonlinear solve fails with DiffSolver::DIVERGED_LINEAR_SOLVER_FAILURE. Enabled by default as nonlinear convergence is very difficult, if the linear solver is not converged.

Definition at line 121 of file newton_solver.h.

Referenced by solve().

bool libMesh::DiffSolver::verbose [inherited]

The DiffSolver may print a lot more to libMesh::out if verbose is set to true; default is false.

Definition at line 164 of file diff_solver.h.

Referenced by libMesh::__libmesh_petsc_diff_solver_monitor(), libMesh::__libmesh_petsc_diff_solver_residual(), line_search(), print_convergence(), and solve().

The documentation for this class was generated from the following files:

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Types

Protected Member Functions

Protected Attributes

Static Protected Attributes

Detailed Description

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation