Poster of Linux kernelThe best gift for a Linux geek
NoxNonlinearSolver

NoxNonlinearSolver

Section: C Library Functions (3) Updated: Thu Apr 7 2011
Local index Up
 

NAME

NoxNonlinearSolver -  

SYNOPSIS


#include <trilinos_nox_nonlinear_solver.h>

Inherits NonlinearSolver< T >.  

Public Types


typedef NonlinearImplicitSystem sys_type
 

Public Member Functions


NoxNonlinearSolver (sys_type &system)

~NoxNonlinearSolver ()

virtual void clear ()

virtual void init ()

virtual std::pair< unsigned int, Real > solve (SparseMatrix< T > &, NumericVector< T > &, NumericVector< T > &, const double, const unsigned int)

bool initialized () const

const sys_type & system () const

sys_type & system ()

void attach_preconditioner (Preconditioner< T > *preconditioner)
 

Static Public Member Functions


static AutoPtr< NonlinearSolver< T > > build (sys_type &s, const SolverPackage solver_package=libMesh::default_solver_package())

static std::string get_info ()

static void print_info ()

static unsigned int n_objects ()
 

Public Attributes


void(* residual )(const NumericVector< Number > &X, NumericVector< Number > &R)

void(* jacobian )(const NumericVector< Number > &X, SparseMatrix< Number > &J)

void(* matvec )(const NumericVector< Number > &X, NumericVector< Number > *R, SparseMatrix< Number > *J)

unsigned int max_nonlinear_iterations

unsigned int max_function_evaluations

Real absolute_residual_tolerance

Real relative_residual_tolerance

Real absolute_step_tolerance

Real relative_step_tolerance

unsigned int max_linear_iterations

Real initial_linear_tolerance

Real minimum_linear_tolerance

bool converged
 

Protected Types


typedef std::map< std::string, std::pair< unsigned int, unsigned int > > Counts
 

Protected Member Functions


void increment_constructor_count (const std::string &name)

void increment_destructor_count (const std::string &name)
 

Protected Attributes


sys_type & _system

bool _is_initialized

Preconditioner< T > * _preconditioner
 

Static Protected Attributes


static Counts _counts

static Threads::atomic< unsigned int > _n_objects

static Threads::spin_mutex _mutex
 

Private Attributes


NOX::Solver::Generic * _solver

Problem_Interface * _interface
 

Detailed Description

 

template<typename T> class NoxNonlinearSolver< T >

This class provides an interface to nox iterative solvers that is compatible with the libMesh NonlinearSolver<>

Author:

Chris Newman, 2008

Definition at line 54 of file trilinos_nox_nonlinear_solver.h.  

Member Typedef Documentation

 

typedef std::map<std::string, std::pair<unsigned int, unsigned int> > ReferenceCounter::Counts [protected, inherited]Data structure to log the information. The log is identified by the class name.

Definition at line 105 of file reference_counter.h.  

template<typename T> typedef NonlinearImplicitSystem NoxNonlinearSolver< T >::sys_typeThe type of system

Reimplemented from NonlinearSolver< T >.

Definition at line 60 of file trilinos_nox_nonlinear_solver.h.  

Constructor & Destructor Documentation

 

template<typename T > NoxNonlinearSolver< T >::NoxNonlinearSolver (sys_type &system) [inline]Constructor. Initializes Nox data structures

Definition at line 109 of file trilinos_nox_nonlinear_solver.h.

                                                           :
  NonlinearSolver<T>(system)
{
}
 

template<typename T > NoxNonlinearSolver< T >::~NoxNonlinearSolver () [inline]Destructor.

Definition at line 118 of file trilinos_nox_nonlinear_solver.h.

{
  this->clear ();
}
 

Member Function Documentation

 

template<typename T> void NonlinearSolver< T >::attach_preconditioner (Preconditioner< T > *preconditioner) [inherited]Attaches a Preconditioner object to be used during the linear solves.

Definition at line 79 of file nonlinear_solver.C.

References libMesh::libMeshPrivateData::_is_initialized.

{
  if(this->_is_initialized)
  {
    std::cerr<<'Preconditioner must be attached before the solver is initialized!'<<std::endl;
    libmesh_error();
  }
  
  _preconditioner = preconditioner;
}
 

template<typename T > AutoPtr< NonlinearSolver< T > > NonlinearSolver< T >::build (sys_type &s, const SolverPackagesolver_package = libMesh::default_solver_package()) [static, inherited]Builds a NonlinearSolver using the nonlinear solver package specified by solver_package

Definition at line 36 of file nonlinear_solver.C.

References libMeshEnums::PETSC_SOLVERS, AutoPtr< Tp >::reset(), and TRILINOS_SOLVERS.

{
  AutoPtr<NonlinearSolver<T> > ap;

  // Build the appropriate solver
  switch (solver_package)
    {

#ifdef LIBMESH_HAVE_PETSC
    case PETSC_SOLVERS:
      ap.reset(new PetscNonlinearSolver<T>(s));
      break;
#endif
      
#ifdef LIBMESH_HAVE_NOX
    case TRILINOS_SOLVERS:
      ap.reset(new NoxNonlinearSolver<T>(s));
      break;
#endif

    default:
      std::cerr << 'ERROR:  Unrecognized solver package: '
                << solver_package
                << std::endl;
      libmesh_error();
    }
    
  return ap;    
}
 

template<typename T > void NoxNonlinearSolver< T >::clear () [virtual]Release all memory and clear data structures.

Reimplemented from NonlinearSolver< T >.

Definition at line 138 of file trilinos_nox_nonlinear_solver.C.

{
 //  if (this->initialized())
//     {
//       this->_is_initialized = false;

//       int ierr=0;

//       ierr = SNESDestroy(_snes);
//              CHKERRABORT(libMesh::COMM_WORLD,ierr);
//     }
}
 

std::string ReferenceCounter::get_info () [static, inherited]Gets a string containing the reference information.

Definition at line 45 of file reference_counter.C.

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

Referenced by ReferenceCounter::print_info().

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

  std::ostringstream out;
  
  out << '
      << ' ---------------------------------------------------------------------------- 
      << '| Reference count information                                                |
      << ' ---------------------------------------------------------------------------- ;
  
  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;

      out << '| ' << name << ' reference count information:
          << '|  Creations:    ' << creations    << '
          << '|  Destructions: ' << destructions << ';
    }
  
  out << ' ---------------------------------------------------------------------------- ;

  return out.str();

#else

  return '';
  
#endif
}
 

void 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 149 of file reference_counter.h.

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

Referenced by ReferenceCountedObject< Value >::ReferenceCountedObject().

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

  p.first++;
}
 

void 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 167 of file reference_counter.h.

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

Referenced by ReferenceCountedObject< Value >::~ReferenceCountedObject().

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

  p.second++;
}
 

template<typename T > void NoxNonlinearSolver< T >::init () [virtual]Initialize data structures if not done so already.

Implements NonlinearSolver< T >.

Definition at line 152 of file trilinos_nox_nonlinear_solver.C.

References libMesh::initialized().

{
  if (!this->initialized())
    _interface = new Problem_Interface(this);
}
 

template<typename T> bool NonlinearSolver< T >::initialized () const [inline, inherited]Returns:

true if the data structures are initialized, false otherwise.

Definition at line 83 of file nonlinear_solver.h.

{ return _is_initialized; }
 

static unsigned int ReferenceCounter::n_objects () [inline, static, inherited]Prints the number of outstanding (created, but not yet destroyed) objects.

Definition at line 76 of file reference_counter.h.

References ReferenceCounter::_n_objects.

Referenced by System::read_serialized_blocked_dof_objects(), and System::write_serialized_blocked_dof_objects().

  { return _n_objects; }
 

void ReferenceCounter::print_info () [static, inherited]Prints the reference information to std::cout.

Definition at line 83 of file reference_counter.C.

References ReferenceCounter::get_info().

{
#if defined(LIBMESH_ENABLE_REFERENCE_COUNTING) && defined(DEBUG)
  
  std::cout << ReferenceCounter::get_info();
  
#endif
}
 

template<typename T> std::pair< unsigned int, Real > NoxNonlinearSolver< T >::solve (SparseMatrix< T > &jac_in, NumericVector< T > &x_in, NumericVector< T > &r_in, const double, const unsignedint) [virtual]Call the Nox solver. It calls the method below, using the same matrix for the system and preconditioner matrices.

Implements NonlinearSolver< T >.

Definition at line 160 of file trilinos_nox_nonlinear_solver.C.

References libMesh::init(), and EpetraVector< T >::vec().

{
  this->init ();

  EpetraVector<T> * x_epetra = libmesh_cast_ptr<EpetraVector<T>*>(&x_in);
  EpetraVector<T> * r_epetra = libmesh_cast_ptr<EpetraVector<T>*>(&r_in);

  Teuchos::RCP<Epetra_Vector> x_t(x_epetra->vec());
  Teuchos::RCP<Epetra_Vector> r_t(r_epetra->vec());

  NOX::Epetra::Vector x(x_t, NOX::Epetra::Vector::CreateView);
  NOX::Epetra::Vector r(r_t, NOX::Epetra::Vector::CreateView);
  
  Teuchos::RCP<Teuchos::ParameterList> nlParamsPtr =
    Teuchos::rcp(new Teuchos::ParameterList);
  Teuchos::ParameterList& nlParams = *(nlParamsPtr.get());
  nlParams.set('Nonlinear Solver', 'Line Search Based');

  //print params        
  Teuchos::ParameterList& printParams = nlParams.sublist('Printing');
  printParams.set('Output Precision', 3);
  printParams.set('Output Processor', 0);
  printParams.set('Output Information',
                  NOX::Utils::OuterIteration +
                  NOX::Utils::OuterIterationStatusTest +
                  NOX::Utils::InnerIteration +
                  NOX::Utils::LinearSolverDetails +
                  NOX::Utils::Parameters +
                  NOX::Utils::Details +
                  NOX::Utils::Warning);
  
  //create linear system
  Teuchos::RCP<NOX::Epetra::Interface::Required> iReq(_interface);      
  Teuchos::RCP<NOX::Epetra::MatrixFree> MF = 
    Teuchos::rcp(new NOX::Epetra::MatrixFree(printParams,
                                             iReq,
                                             x));
        
  Teuchos::ParameterList& dirParams = nlParams.sublist('Direction');
  dirParams.set('Method', 'Newton');
  Teuchos::ParameterList& newtonParams = dirParams.sublist('Newton');
  newtonParams.set('Forcing Term Method', 'Constant');
  
  Teuchos::ParameterList& lsParams = newtonParams.sublist('Linear Solver');
  lsParams.set('Aztec Solver', 'GMRES'); 
  lsParams.set('Max Iterations', static_cast<int>(this->max_linear_iterations));
  lsParams.set('Tolerance', this->initial_linear_tolerance);  lsParams.set('Output Frequency', 1);       
//  lsParams.set('Preconditioner', 'AztecOO');
  
  Teuchos::RCP<NOX::Epetra::Interface::Jacobian> iJac = MF;
  Teuchos::RCP<NOX::Epetra::LinearSystemAztecOO> linSys =
    Teuchos::rcp(new NOX::Epetra::LinearSystemAztecOO(printParams, lsParams,
                                                      iReq, iJac, MF,
                                                      x));
  //create group
  Teuchos::RCP<NOX::Epetra::Group> grpPtr =
    Teuchos::rcp(new NOX::Epetra::Group(printParams,
                                        iReq,
                                        x,
                                        linSys)); 
  NOX::Epetra::Group& grp = *(grpPtr.get());

  Teuchos::RCP<NOX::StatusTest::NormF> absresid =
    Teuchos::rcp(new NOX::StatusTest::NormF(this->absolute_residual_tolerance, NOX::StatusTest::NormF::Unscaled));
  Teuchos::RCP<NOX::StatusTest::NormF> relresid =
    Teuchos::rcp(new NOX::StatusTest::NormF(grp, this->relative_residual_tolerance));
  Teuchos::RCP<NOX::StatusTest::MaxIters> maxiters =
    Teuchos::rcp(new NOX::StatusTest::MaxIters(this->max_nonlinear_iterations));
  Teuchos::RCP<NOX::StatusTest::FiniteValue> finiteval =
    Teuchos::rcp(new NOX::StatusTest::FiniteValue());
  Teuchos::RCP<NOX::StatusTest::NormUpdate> normupdate =
    Teuchos::rcp(new NOX::StatusTest::NormUpdate(this->absolute_step_tolerance));
  Teuchos::RCP<NOX::StatusTest::Combo> combo =
    Teuchos::rcp(new NOX::StatusTest::Combo(NOX::StatusTest::Combo::OR));
  combo->addStatusTest(absresid);
  combo->addStatusTest(relresid);
  combo->addStatusTest(maxiters);
  combo->addStatusTest(finiteval);
  combo->addStatusTest(normupdate);
  
  Teuchos::RCP<NOX::Solver::Generic> solver =
    NOX::Solver::buildSolver(grpPtr, combo, nlParamsPtr);
  NOX::StatusTest::StatusType status = NOX::StatusTest::Unconverged;
  status = solver->solve();
  
  const NOX::Epetra::Group& finalGroup =
    dynamic_cast<const NOX::Epetra::Group&>(solver->getSolutionGroup());
  const NOX::Abstract::Vector& finalSolution = finalGroup.getX();
//  const Epetra_Vector& finalSolution =
//    (dynamic_cast<const NOX::Epetra::Vector&>(finalGroup.getX())).getEpetraVector();

  x = finalSolution;

  return std::make_pair(1, 0.);
}
 

template<typename T> const sys_type& NonlinearSolver< T >::system () const [inline, inherited]Returns:

a constant reference to the system we are solving.

Definition at line 131 of file nonlinear_solver.h.

Referenced by __libmesh_petsc_snes_jacobian(), __libmesh_petsc_snes_residual(), and Problem_Interface::computeF().

{ return _system; }
 

template<typename T> sys_type& NonlinearSolver< T >::system () [inline, inherited]Returns:

a writeable reference to the system we are solving.

Definition at line 136 of file nonlinear_solver.h.

{ return _system; }
 

Member Data Documentation

 

ReferenceCounter::Counts ReferenceCounter::_counts [static, protected, inherited]Actually holds the data.

Definition at line 110 of file reference_counter.h.

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

template<typename T> Problem_Interface* NoxNonlinearSolver< T >::_interface [private]Solver interface

Definition at line 101 of file trilinos_nox_nonlinear_solver.h.  

template<typename T> bool NonlinearSolver< T >::_is_initialized [protected, inherited]Flag indicating if the data structures have been initialized.

Definition at line 212 of file nonlinear_solver.h.

Referenced by NonlinearSolver< Number >::initialized().  

Threads::spin_mutex ReferenceCounter::_mutex [static, protected, inherited]Mutual exclusion object to enable thread-safe reference counting.

Definition at line 123 of file reference_counter.h.  

Threads::atomic< unsigned int > ReferenceCounter::_n_objects [static, protected, inherited]The number of objects. Print the reference count information when the number returns to 0.

Definition at line 118 of file reference_counter.h.

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

template<typename T> Preconditioner<T>* NonlinearSolver< T >::_preconditioner [protected, inherited]Holds the Preconditioner object to be used for the linear solves.

Definition at line 217 of file nonlinear_solver.h.  

template<typename T> NOX::Solver::Generic* NoxNonlinearSolver< T >::_solver [private]Nonlinear solver context

Definition at line 96 of file trilinos_nox_nonlinear_solver.h.  

template<typename T> sys_type& NonlinearSolver< T >::_system [protected, inherited]A reference to the system we are solving.

Definition at line 207 of file nonlinear_solver.h.

Referenced by NonlinearSolver< Number >::system().  

template<typename T> Real NonlinearSolver< T >::absolute_residual_tolerance [inherited]The NonlinearSolver 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 163 of file nonlinear_solver.h.  

template<typename T> Real NonlinearSolver< T >::absolute_step_tolerance [inherited]The NonlinearSolver 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.

Note that not all NonlinearSolvers support relative_step_tolerance!

Definition at line 177 of file nonlinear_solver.h.  

template<typename T> bool NonlinearSolver< T >::converged [inherited]After a call to solve this will reflect whether or not the nonlinear solve was successful.

Definition at line 201 of file nonlinear_solver.h.  

template<typename T> Real NonlinearSolver< T >::initial_linear_tolerance [inherited]Any required linear solves will at first be done with this tolerance; the NonlinearSolver may tighten the tolerance for later solves.

Definition at line 190 of file nonlinear_solver.h.  

template<typename T> void(* NonlinearSolver< T >::jacobian)(const NumericVector< Number > &X, SparseMatrix< Number > &J) [inherited]Function that computes the Jacobian J(X) of the nonlinear system at the input iterate X.

Definition at line 115 of file nonlinear_solver.h.

Referenced by __libmesh_petsc_snes_jacobian().  

template<typename T> void(* NonlinearSolver< T >::matvec)(const NumericVector< Number > &X, NumericVector< Number > *R, SparseMatrix< Number > *J) [inherited]Function that computes either the residual $ R(X) $ or the Jacobian $ J(X) $ of the nonlinear system at the input iterate $ X $. Note that either R or J could be XSNULL.

Definition at line 124 of file nonlinear_solver.h.

Referenced by __libmesh_petsc_snes_jacobian(), and __libmesh_petsc_snes_residual().  

template<typename T> unsigned int NonlinearSolver< T >::max_function_evaluations [inherited]Maximum number of function evaluations.

Definition at line 151 of file nonlinear_solver.h.  

template<typename T> unsigned int NonlinearSolver< T >::max_linear_iterations [inherited]Each linear solver step should exit after max_linear_iterations is exceeded.

Definition at line 184 of file nonlinear_solver.h.  

template<typename T> unsigned int NonlinearSolver< T >::max_nonlinear_iterations [inherited]Maximum number of non-linear iterations.

Definition at line 146 of file nonlinear_solver.h.  

template<typename T> Real NonlinearSolver< T >::minimum_linear_tolerance [inherited]The tolerance for linear solves is kept above this minimum

Definition at line 195 of file nonlinear_solver.h.  

template<typename T> Real NonlinearSolver< T >::relative_residual_tolerance [inherited]

Definition at line 164 of file nonlinear_solver.h.  

template<typename T> Real NonlinearSolver< T >::relative_step_tolerance [inherited]

Definition at line 178 of file nonlinear_solver.h.  

template<typename T> void(* NonlinearSolver< T >::residual)(const NumericVector< Number > &X, NumericVector< Number > &R) [inherited]Function that computes the residual R(X) of the nonlinear system at the input iterate X.

Definition at line 108 of file nonlinear_solver.h.

Referenced by __libmesh_petsc_snes_residual(), and Problem_Interface::computeF().

 

Author

Generated automatically by Doxygen for libMesh from the source code.


 

Index

NAME
SYNOPSIS
Public Types
Public Member Functions
Static Public Member Functions
Public Attributes
Protected Types
Protected Member Functions
Protected Attributes
Static Protected Attributes
Private Attributes
Detailed Description
template<typename T> class NoxNonlinearSolver< T >
Member Typedef Documentation
typedef std::map<std::string, std::pair<unsigned int, unsigned int> > ReferenceCounter::Counts [protected, inherited]Data structure to log the information. The log is identified by the class name.
template<typename T> typedef NonlinearImplicitSystem NoxNonlinearSolver< T >::sys_typeThe type of system
Constructor & Destructor Documentation
template<typename T > NoxNonlinearSolver< T >::NoxNonlinearSolver (sys_type &system) [inline]Constructor. Initializes Nox data structures
template<typename T > NoxNonlinearSolver< T >::~NoxNonlinearSolver () [inline]Destructor.
Member Function Documentation
template<typename T> void NonlinearSolver< T >::attach_preconditioner (Preconditioner< T > *preconditioner) [inherited]Attaches a Preconditioner object to be used during the linear solves.
template<typename T > AutoPtr< NonlinearSolver< T > > NonlinearSolver< T >::build (sys_type &s, const SolverPackagesolver_package = libMesh::default_solver_package()) [static, inherited]Builds a NonlinearSolver using the nonlinear solver package specified by solver_package
template<typename T > void NoxNonlinearSolver< T >::clear () [virtual]Release all memory and clear data structures.
std::string ReferenceCounter::get_info () [static, inherited]Gets a string containing the reference information.
void 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.
void 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.
template<typename T > void NoxNonlinearSolver< T >::init () [virtual]Initialize data structures if not done so already.
template<typename T> bool NonlinearSolver< T >::initialized () const [inline, inherited]Returns:
static unsigned int ReferenceCounter::n_objects () [inline, static, inherited]Prints the number of outstanding (created, but not yet destroyed) objects.
void ReferenceCounter::print_info () [static, inherited]Prints the reference information to std::cout.
template<typename T> std::pair< unsigned int, Real > NoxNonlinearSolver< T >::solve (SparseMatrix< T > &jac_in, NumericVector< T > &x_in, NumericVector< T > &r_in, const double, const unsignedint) [virtual]Call the Nox solver. It calls the method below, using the same matrix for the system and preconditioner matrices.
template<typename T> const sys_type& NonlinearSolver< T >::system () const [inline, inherited]Returns:
template<typename T> sys_type& NonlinearSolver< T >::system () [inline, inherited]Returns:
Member Data Documentation
ReferenceCounter::Counts ReferenceCounter::_counts [static, protected, inherited]Actually holds the data.
template<typename T> Problem_Interface* NoxNonlinearSolver< T >::_interface [private]Solver interface
template<typename T> bool NonlinearSolver< T >::_is_initialized [protected, inherited]Flag indicating if the data structures have been initialized.
Threads::spin_mutex ReferenceCounter::_mutex [static, protected, inherited]Mutual exclusion object to enable thread-safe reference counting.
Threads::atomic< unsigned int > ReferenceCounter::_n_objects [static, protected, inherited]The number of objects. Print the reference count information when the number returns to 0.
template<typename T> Preconditioner<T>* NonlinearSolver< T >::_preconditioner [protected, inherited]Holds the Preconditioner object to be used for the linear solves.
template<typename T> NOX::Solver::Generic* NoxNonlinearSolver< T >::_solver [private]Nonlinear solver context
template<typename T> sys_type& NonlinearSolver< T >::_system [protected, inherited]A reference to the system we are solving.
template<typename T> Real NonlinearSolver< T >::absolute_residual_tolerance [inherited]The NonlinearSolver should exit after the residual is reduced to either less than absolute_residual_tolerance or less than relative_residual_tolerance times the initial residual.
template<typename T> Real NonlinearSolver< T >::absolute_step_tolerance [inherited]The NonlinearSolver 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.
template<typename T> bool NonlinearSolver< T >::converged [inherited]After a call to solve this will reflect whether or not the nonlinear solve was successful.
template<typename T> Real NonlinearSolver< T >::initial_linear_tolerance [inherited]Any required linear solves will at first be done with this tolerance; the NonlinearSolver may tighten the tolerance for later solves.
template<typename T> void(* NonlinearSolver< T >::jacobian)(const NumericVector< Number > &X, SparseMatrix< Number > &J) [inherited]Function that computes the Jacobian J(X) of the nonlinear system at the input iterate X.
template<typename T> void(* NonlinearSolver< T >::matvec)(const NumericVector< Number > &X, NumericVector< Number > *R, SparseMatrix< Number > *J) [inherited]Function that computes either the residual $ R(X) $ or the Jacobian $ J(X) $ of the nonlinear system at the input iterate $ X $. Note that either R or J could be XSNULL.
template<typename T> unsigned int NonlinearSolver< T >::max_function_evaluations [inherited]Maximum number of function evaluations.
template<typename T> unsigned int NonlinearSolver< T >::max_linear_iterations [inherited]Each linear solver step should exit after max_linear_iterations is exceeded.
template<typename T> unsigned int NonlinearSolver< T >::max_nonlinear_iterations [inherited]Maximum number of non-linear iterations.
template<typename T> Real NonlinearSolver< T >::minimum_linear_tolerance [inherited]The tolerance for linear solves is kept above this minimum
template<typename T> Real NonlinearSolver< T >::relative_residual_tolerance [inherited]
template<typename T> Real NonlinearSolver< T >::relative_step_tolerance [inherited]
template<typename T> void(* NonlinearSolver< T >::residual)(const NumericVector< Number > &X, NumericVector< Number > &R) [inherited]Function that computes the residual R(X) of the nonlinear system at the input iterate X.
Author

This document was created by man2html, using the manual pages.
Time: 21:51:27 GMT, April 16, 2011