#include <trilinos_nox_nonlinear_solver.h>

Inheritance diagram for libMesh::NoxNonlinearSolver< T >:

Public Types
typedef NonlinearImplicitSystem	sys_type
Public Member Functions
	NoxNonlinearSolver (sys_type &system)
virtual	~NoxNonlinearSolver ()
virtual void	clear ()
virtual void	init (const char *name=NULL)
virtual std::pair< unsigned int, Real >	solve (SparseMatrix< T > &, NumericVector< T > &, NumericVector< T > &, const double, const unsigned int)
virtual int	get_total_linear_iterations ()
virtual unsigned	get_current_nonlinear_iteration_number () const
bool	initialized () const
virtual void	print_converged_reason ()
const sys_type &	system () const
sys_type &	system ()
void	attach_preconditioner (Preconditioner< T > *preconditioner)
const Parallel::Communicator &	comm () const
processor_id_type	n_processors () const
processor_id_type	processor_id () const
Static Public Member Functions
static UniquePtr < NonlinearSolver< T > >	build (sys_type &s, const SolverPackage solver_package=libMesh::default_solver_package())
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
void(*	residual )(const NumericVector< Number > &X, NumericVector< Number > &R, sys_type &S)
NonlinearImplicitSystem::ComputeResidual *	residual_object
void(*	jacobian )(const NumericVector< Number > &X, SparseMatrix< Number > &J, sys_type &S)
NonlinearImplicitSystem::ComputeJacobian *	jacobian_object
void(*	matvec )(const NumericVector< Number > &X, NumericVector< Number > R, SparseMatrix< Number > J, sys_type &S)
NonlinearImplicitSystem::ComputeResidualandJacobian *	residual_and_jacobian_object
void(*	bounds )(NumericVector< Number > &XL, NumericVector< Number > &XU, sys_type &S)
NonlinearImplicitSystem::ComputeBounds *	bounds_object
void(*	nullspace )(std::vector< NumericVector< Number > * > &sp, sys_type &S)
NonlinearImplicitSystem::ComputeVectorSubspace *	nullspace_object
void(*	nearnullspace )(std::vector< NumericVector< Number > * > &sp, sys_type &S)
NonlinearImplicitSystem::ComputeVectorSubspace *	nearnullspace_object
void(*	user_presolve )(sys_type &S)
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
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
Private Attributes
NOX::Solver::Generic *	_solver
Problem_Interface *	_interface
int	_n_linear_iterations

Detailed Description

template<typename T>
class libMesh::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 56 of file trilinos_nox_nonlinear_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.

template<typename T>

typedef NonlinearImplicitSystem libMesh::NoxNonlinearSolver< T >::sys_type

The type of system

Reimplemented from libMesh::NonlinearSolver< T >.

Definition at line 62 of file trilinos_nox_nonlinear_solver.h.

Constructor & Destructor Documentation

template<typename T >

libMesh::NoxNonlinearSolver< T >::NoxNonlinearSolver ( sys_type & system ) [inline, explicit]

Constructor. Initializes Nox data structures

Definition at line 128 of file trilinos_nox_nonlinear_solver.h.

                                                           :
  NonlinearSolver<T>(system),
  _solver(NULL),
  _interface(NULL),
  _n_linear_iterations(0)
{
}

template<typename T >

libMesh::NoxNonlinearSolver< T >::~NoxNonlinearSolver ( ) [inline, virtual]

Destructor.

Definition at line 140 of file trilinos_nox_nonlinear_solver.h.

{
  this->clear ();
}

Member Function Documentation

template<typename T>

void libMesh::NonlinearSolver< T >::attach_preconditioner ( Preconditioner< T > * preconditioner ) [inherited]

Attaches a Preconditioner object to be used during the linear solves.

Definition at line 74 of file nonlinear_solver.C.

References libMesh::libMeshPrivateData::_is_initialized.

{
  if (this->_is_initialized)
    libmesh_error_msg("Preconditioner must be attached before the solver is initialized!");

  _preconditioner = preconditioner;
}

template<typename T >

UniquePtr< NonlinearSolver< T > > libMesh::NonlinearSolver< T >::build	(	sys_type &	s,
		const SolverPackage	solver_package = `libMesh::default_solver_package()`
	)		`[static, inherited]`

Builds a NonlinearSolver using the nonlinear solver package specified by solver_package

Definition at line 37 of file nonlinear_solver.C.

References libMesh::PETSC_SOLVERS, and libMesh::TRILINOS_SOLVERS.

{
  // Build the appropriate solver
  switch (solver_package)
    {

#ifdef LIBMESH_HAVE_PETSC
    case PETSC_SOLVERS:
      return UniquePtr<NonlinearSolver<T> >(new PetscNonlinearSolver<T>(s));
#endif // LIBMESH_HAVE_PETSC

#ifdef LIBMESH_HAVE_NOX
    case TRILINOS_SOLVERS:
      return UniquePtr<NonlinearSolver<T> >(new NoxNonlinearSolver<T>(s));
#endif

    default:
      libmesh_error_msg("ERROR:  Unrecognized solver package: " << solver_package);
    }

  libmesh_error_msg("We'll never get here!");
  return UniquePtr<NonlinearSolver<T> >();
}

template<typename T >

void libMesh::NoxNonlinearSolver< T >::clear ( ) [virtual]

Release all memory and clear data structures.

Reimplemented from libMesh::NonlinearSolver< T >.

Definition at line 242 of file trilinos_nox_nonlinear_solver.C.

{
}

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;
}

template<typename T>

virtual unsigned libMesh::NoxNonlinearSolver< T >::get_current_nonlinear_iteration_number ( ) const [inline, virtual]

If called *during* the solve(), for example by the user-specified residual or Jacobian function, returns the current nonlinear iteration number. Not currently implemented.

Implements libMesh::NonlinearSolver< T >.

Definition at line 104 of file trilinos_nox_nonlinear_solver.h.

{ libmesh_not_implemented(); return 0; }

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
}

template<typename T >

int libMesh::NoxNonlinearSolver< T >::get_total_linear_iterations ( ) [virtual]

Get the total number of linear iterations done in the last solve

Implements libMesh::NonlinearSolver< T >.

Definition at line 390 of file trilinos_nox_nonlinear_solver.C.

{
  return _n_linear_iterations;
}

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++;
}

template<typename T >

void libMesh::NoxNonlinearSolver< T >::init ( const char * name = NULL ) [virtual]

Initialize data structures if not done so already.

Implements libMesh::NonlinearSolver< T >.

Definition at line 247 of file trilinos_nox_nonlinear_solver.C.

References libMesh::initialized().

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

template<typename T>

bool libMesh::NonlinearSolver< T >::initialized ( ) const [inline, inherited]

Returns:: true if the data structures are initialized, false otherwise.

Definition at line 82 of file nonlinear_solver.h.

{ return _is_initialized; }

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()); }

template<typename T>

virtual void libMesh::NonlinearSolver< T >::print_converged_reason ( ) [inline, virtual, inherited]

Prints a useful message about why the latest nonlinear solve con(di)verged.

Reimplemented in libMesh::PetscNonlinearSolver< T >.

Definition at line 108 of file nonlinear_solver.h.

{ libmesh_not_implemented(); }

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()); }

template<typename T>

std::pair< unsigned int, Real > libMesh::NoxNonlinearSolver< T >::solve	(	SparseMatrix< T > &	,
		NumericVector< T > &	x_in,
		NumericVector< T > &	,
		const double	,
		const unsigned	int
	)		`[virtual]`

Call the Nox solver. It calls the method below, using the same matrix for the system and preconditioner matrices.

Implements libMesh::NonlinearSolver< T >.

Definition at line 255 of file trilinos_nox_nonlinear_solver.C.

References libMesh::NumericVector< T >::close(), libMesh::TriangleWrapper::init(), libMesh::EpetraMatrix< T >::mat(), libMesh::ImplicitSystem::matrix, libMesh::pc, libMesh::Real, libMesh::solver, libMesh::sys, libMesh::ImplicitSystem::system(), libMesh::EpetraVector< T >::vec(), and libMesh::x.

{
  this->init ();

  if (this->user_presolve)
    this->user_presolve(this->system());

  EpetraVector<T> * x_epetra = cast_ptr<EpetraVector<T>*>(&x_in);
  // Creating a Teuchos::RCP as they do in NOX examples does not work here - we get some invalid memory references
  // thus we make a local copy
  NOX::Epetra::Vector x(*x_epetra->vec());

  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);

  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("Size of Krylov Subspace", 1000);

  //create linear system
  Teuchos::RCP<NOX::Epetra::Interface::Required> iReq(_interface);
  Teuchos::RCP<NOX::Epetra::LinearSystemAztecOO> linSys;
  Teuchos::RCP<Epetra_Operator> pc;

  if (this->jacobian || this->jacobian_object || this->residual_and_jacobian_object)
    {
      if(this->_preconditioner)
        {
          // PJNFK
          lsParams.set("Preconditioner", "User Defined");

          TrilinosPreconditioner<Number> * trilinos_pc =
            cast_ptr<TrilinosPreconditioner<Number> *>(this->_preconditioner);
          pc = Teuchos::rcp(trilinos_pc);

          Teuchos::RCP<NOX::Epetra::Interface::Preconditioner> iPrec(_interface);
          linSys = Teuchos::rcp(new NOX::Epetra::LinearSystemAztecOO(printParams, lsParams, iReq, iPrec, pc, x));
        }
      else
        {
          lsParams.set("Preconditioner", "None");
          //      lsParams.set("Preconditioner", "Ifpack");
          //      lsParams.set("Preconditioner", "AztecOO");

          // full jacobian
          NonlinearImplicitSystem & sys = _interface->_solver->system();
          EpetraMatrix<Number> & jacSys = *cast_ptr<EpetraMatrix<Number>*>(sys.matrix);
          Teuchos::RCP<Epetra_RowMatrix> jacMat = Teuchos::rcp(jacSys.mat());

          Teuchos::RCP<NOX::Epetra::Interface::Jacobian> iJac(_interface);
          linSys = Teuchos::rcp(new NOX::Epetra::LinearSystemAztecOO(printParams, lsParams, iReq, iJac, jacMat, x));
        }
    }
  else
    {
      // matrix free
      Teuchos::RCP<NOX::Epetra::MatrixFree> MF = Teuchos::rcp(new NOX::Epetra::MatrixFree(printParams, iReq, x));

      Teuchos::RCP<NOX::Epetra::Interface::Jacobian> iJac(MF);
      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<Teuchos::ParameterList> finalPars = nlParamsPtr;

  Teuchos::RCP<NOX::Solver::Generic> solver = NOX::Solver::buildSolver(grpPtr, combo, nlParamsPtr);
  NOX::StatusTest::StatusType status = solver->solve();
  this->converged = (status == NOX::StatusTest::Converged);

  const NOX::Epetra::Group& finalGroup = dynamic_cast<const NOX::Epetra::Group&>(solver->getSolutionGroup());
  const NOX::Epetra::Vector& noxFinalSln = dynamic_cast<const NOX::Epetra::Vector&>(finalGroup.getX());

  *x_epetra->vec() = noxFinalSln.getEpetraVector();
  x_in.close();

  Real residual_norm = finalGroup.getNormF();
  unsigned int total_iters = solver->getNumIterations();
  _n_linear_iterations = finalPars->sublist("Direction").sublist("Newton").sublist("Linear Solver").sublist("Output").get("Total Number of Linear Iterations", -1);

  // do not let Trilinos to deallocate what we allocated
  pc.release();
  iReq.release();

  return std::make_pair(total_iters, residual_norm);
}

template<typename T>

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

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

Definition at line 216 of file nonlinear_solver.h.

Referenced by libMesh::__libmesh_petsc_snes_residual(), libMesh::Problem_Interface::computeF(), libMesh::Problem_Interface::computeJacobian(), and libMesh::Problem_Interface::computePreconditioner().

{ return _system; }

template<typename T>

sys_type& libMesh::NonlinearSolver< T >::system ( ) [inline, inherited]

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

Definition at line 221 of file nonlinear_solver.h.

{ return _system; }

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().

template<typename T>

Problem_Interface* libMesh::NoxNonlinearSolver< T >::_interface [private]

Solver interface

Definition at line 116 of file trilinos_nox_nonlinear_solver.h.

template<typename T>

bool libMesh::NonlinearSolver< T >::_is_initialized [protected, inherited]

Flag indicating if the data structures have been initialized.

Definition at line 297 of file nonlinear_solver.h.

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

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.

template<typename T>

int libMesh::NoxNonlinearSolver< T >::_n_linear_iterations [private]

Stores the total number of linear iterations from the last solve.

Definition at line 121 of file trilinos_nox_nonlinear_solver.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().

template<typename T>

Preconditioner<T>* libMesh::NonlinearSolver< T >::_preconditioner [protected, inherited]

Holds the Preconditioner object to be used for the linear solves.

Definition at line 302 of file nonlinear_solver.h.

template<typename T>

NOX::Solver::Generic* libMesh::NoxNonlinearSolver< T >::_solver [private]

Nonlinear solver context

Definition at line 111 of file trilinos_nox_nonlinear_solver.h.

template<typename T>

sys_type& libMesh::NonlinearSolver< T >::_system [protected, inherited]

A reference to the system we are solving.

Definition at line 292 of file nonlinear_solver.h.

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

template<typename T>

Real libMesh::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 248 of file nonlinear_solver.h.

template<typename T>

Real libMesh::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 262 of file nonlinear_solver.h.

template<typename T>

void(* libMesh::NonlinearSolver< T >::bounds)(NumericVector< Number > &XL, NumericVector< Number > &XU, sys_type &S) [inherited]

Function that computes the lower and upper bounds XL and XU on the solution of the nonlinear system.

Definition at line 172 of file nonlinear_solver.h.

template<typename T>

NonlinearImplicitSystem::ComputeBounds* libMesh::NonlinearSolver< T >::bounds_object [inherited]

Object that computes the bounds vectors $ XL $ and $ XU $ .

Definition at line 178 of file nonlinear_solver.h.

template<typename T>

bool libMesh::NonlinearSolver< T >::converged [inherited]

After a call to solve this will reflect whether or not the nonlinear solve was successful.

Definition at line 286 of file nonlinear_solver.h.

template<typename T>

Real libMesh::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 275 of file nonlinear_solver.h.

template<typename T>

void(* libMesh::NonlinearSolver< T >::jacobian)(const NumericVector< Number > &X, SparseMatrix< Number > &J, sys_type &S) [inherited]

Function that computes the Jacobian J(X) of the nonlinear system at the input iterate X.

Definition at line 140 of file nonlinear_solver.h.

Referenced by libMesh::Problem_Interface::computeJacobian(), and libMesh::Problem_Interface::computePreconditioner().

template<typename T>

NonlinearImplicitSystem::ComputeJacobian* libMesh::NonlinearSolver< T >::jacobian_object [inherited]

Object that computes the Jacobian J(X) of the nonlinear system at the input iterate X.

Definition at line 148 of file nonlinear_solver.h.

Referenced by libMesh::Problem_Interface::computeJacobian(), and libMesh::Problem_Interface::computePreconditioner().

template<typename T>

void(* libMesh::NonlinearSolver< T >::matvec)(const NumericVector< Number > &X, NumericVector< Number > *R, SparseMatrix< Number > *J, sys_type &S) [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 156 of file nonlinear_solver.h.

Referenced by libMesh::__libmesh_petsc_snes_residual(), libMesh::Problem_Interface::computeF(), libMesh::Problem_Interface::computeJacobian(), and libMesh::Problem_Interface::computePreconditioner().

template<typename T>

unsigned int libMesh::NonlinearSolver< T >::max_function_evaluations [inherited]

Maximum number of function evaluations.

Definition at line 236 of file nonlinear_solver.h.

template<typename T>

unsigned int libMesh::NonlinearSolver< T >::max_linear_iterations [inherited]

Each linear solver step should exit after max_linear_iterations is exceeded.

Definition at line 269 of file nonlinear_solver.h.

template<typename T>

unsigned int libMesh::NonlinearSolver< T >::max_nonlinear_iterations [inherited]

Maximum number of non-linear iterations.

Definition at line 231 of file nonlinear_solver.h.

template<typename T>

Real libMesh::NonlinearSolver< T >::minimum_linear_tolerance [inherited]

The tolerance for linear solves is kept above this minimum

Definition at line 280 of file nonlinear_solver.h.

template<typename T>

void(* libMesh::NonlinearSolver< T >::nearnullspace)(std::vector< NumericVector< Number > * > &sp, sys_type &S) [inherited]

Function that computes a basis for the Jacobian's near nullspace -- the set of "low energy modes" -- that can be used for AMG coarsening, if the solver supports it (e.g., ML, PETSc's GAMG).

Definition at line 201 of file nonlinear_solver.h.

template<typename T>

NonlinearImplicitSystem::ComputeVectorSubspace* libMesh::NonlinearSolver< T >::nearnullspace_object [inherited]

A callable object that computes a basis for the Jacobian's near nullspace -- the set of "low energy modes" -- that can be used for AMG coarsening, if the solver supports it (e.g., ML, PETSc's GAMG).

Definition at line 208 of file nonlinear_solver.h.

template<typename T>

void(* libMesh::NonlinearSolver< T >::nullspace)(std::vector< NumericVector< Number > * > &sp, sys_type &S) [inherited]

Function that computes a basis for the Jacobian's nullspace -- the kernel or the "zero energy modes" -- that can be used in solving a degenerate problem iteratively, if the solver supports it (e.g., PETSc's KSP).

Definition at line 186 of file nonlinear_solver.h.

template<typename T>

NonlinearImplicitSystem::ComputeVectorSubspace* libMesh::NonlinearSolver< T >::nullspace_object [inherited]

A callable object that computes a basis for the Jacobian's nullspace -- the kernel or the "zero energy modes" -- that can be used in solving a degenerate problem iteratively, if the solver supports it (e.g., PETSc's KSP).

Definition at line 194 of file nonlinear_solver.h.

template<typename T>

Real libMesh::NonlinearSolver< T >::relative_residual_tolerance [inherited]

Definition at line 249 of file nonlinear_solver.h.

template<typename T>

Real libMesh::NonlinearSolver< T >::relative_step_tolerance [inherited]

Definition at line 263 of file nonlinear_solver.h.

template<typename T>

void(* libMesh::NonlinearSolver< T >::residual)(const NumericVector< Number > &X, NumericVector< Number > &R, sys_type &S) [inherited]

Function that computes the residual R(X) of the nonlinear system at the input iterate X.

Definition at line 126 of file nonlinear_solver.h.

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

template<typename T>

NonlinearImplicitSystem::ComputeResidualandJacobian* libMesh::NonlinearSolver< T >::residual_and_jacobian_object [inherited]

Object 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 167 of file nonlinear_solver.h.

Referenced by libMesh::__libmesh_petsc_snes_residual(), libMesh::Problem_Interface::computeF(), libMesh::Problem_Interface::computeJacobian(), and libMesh::Problem_Interface::computePreconditioner().

template<typename T>

NonlinearImplicitSystem::ComputeResidual* libMesh::NonlinearSolver< T >::residual_object [inherited]

Object that computes the residual R(X) of the nonlinear system at the input iterate X.

Definition at line 134 of file nonlinear_solver.h.

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

template<typename T>

void(* libMesh::NonlinearSolver< T >::user_presolve)(sys_type &S) [inherited]

Definition at line 211 of file nonlinear_solver.h.

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