libMesh::PetscNonlinearSolver< T > Class Template Reference

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

#include <petsc_nonlinear_solver.h>

Inheritance diagram for libMesh::PetscNonlinearSolver< T >:

Classes
class	ComputeLineSearchObject
	Abstract base class to be used to implement a custom line-search algorithm. More...

Public Types
typedef NonlinearImplicitSystem	sys_type
	The type of system.

Public Member Functions
	PetscNonlinearSolver (sys_type &system)
	Constructor.
	~PetscNonlinearSolver ()
	Destructor.
virtual void	clear () override
	Release all memory and clear data structures.
virtual void	init (const char *name=nullptr) override
	Initialize data structures if not done so already.
SNES	snes (const char *name=nullptr)
virtual std::pair< unsigned int, Real >	solve (SparseMatrix< T > &, NumericVector< T > &, NumericVector< T > &, const double, const unsigned int) override
	Call the Petsc solver.
virtual void	print_converged_reason () override
	Prints a useful message about why the latest nonlinear solve con(di)verged.
SNESConvergedReason	get_converged_reason ()
virtual int	get_total_linear_iterations () override
	Get the total number of linear iterations done in the last solve.
virtual unsigned	get_current_nonlinear_iteration_number () const override
void	set_residual_zero_out (bool state)
	Set if the residual should be zeroed out in the callback.
void	set_jacobian_zero_out (bool state)
	Set if the jacobian should be zeroed out in the callback.
void	use_default_monitor (bool state)
	Set to true to use the libMesh's default monitor, set to false to use your own.
void	set_snesmf_reuse_base (bool state)
	Set to true to let PETSc reuse the base vector.
bool	snes_mf_reuse_base () const
void	set_computing_base_vector (bool computing_base_vector)
	Set whether we are computing the base vector for matrix-free finite-differencing.
bool	computing_base_vector () const
void	setup_default_monitor ()
	Setup the default monitor if required.
virtual bool	reuse_preconditioner () const override
	Getter for preconditioner reuse.
virtual unsigned int	reuse_preconditioner_max_linear_its () const override
	Getter for the maximum iterations flag for preconditioner reuse.
virtual void	force_new_preconditioner () override
	Immediately force a new preconditioner, even if reuse is set.
bool	initialized () const
const sys_type &	system () const
sys_type &	system ()
void	attach_preconditioner (Preconditioner< T > *preconditioner)
	Attaches a Preconditioner object to be used during the linear solves.
void	set_solver_configuration (SolverConfiguration &solver_configuration)
	Set the solver configuration object.
virtual void	set_reuse_preconditioner (bool reuse)
	Set the reuse preconditioner flag.
virtual void	set_reuse_preconditioner_max_linear_its (unsigned int i)
	Set the reuse_preconditioner_max_linear_its parameter.
virtual void	set_exact_constraint_enforcement (bool enable)
	Enable (or disable; it is true by default) exact enforcement of constraints at the solver level, correcting any constrained DoF coefficients in current_local_solution as well as applying nonlinear residual and Jacobian terms based on constraint equations.
bool	exact_constraint_enforcement ()
const Parallel::Communicator &	comm () const
processor_id_type	n_processors () const
processor_id_type	processor_id () const

Static Public Member Functions
static std::unique_ptr< NonlinearSolver< T > >	build (sys_type &s, const SolverPackage solver_package=libMesh::default_solver_package())
	Builds a NonlinearSolver using the nonlinear solver package specified by solver_package.
static std::string	get_info ()
	Gets a string containing the reference information.
static void	print_info (std::ostream &out_stream=libMesh::out)
	Prints the reference information, by default to libMesh::out.
static unsigned int	n_objects ()
	Prints the number of outstanding (created, but not yet destroyed) objects.
static void	enable_print_counter_info ()
	Methods to enable/disable the reference counter output from print_info().
static void	disable_print_counter_info ()

Public Attributes
std::unique_ptr< ComputeLineSearchObject >	linesearch_object
	A callable object that can be used to specify a custom line-search.
void(*	residual )(const NumericVector< Number > &X, NumericVector< Number > &R, sys_type &S)
	Function that computes the residual R(X) of the nonlinear system at the input iterate X.
NonlinearImplicitSystem::ComputeResidual *	residual_object
	Object that computes the residual R(X) of the nonlinear system at the input iterate X.
NonlinearImplicitSystem::ComputeResidual *	fd_residual_object
	Object that computes the residual R(X) of the nonlinear system at the input iterate X for the purpose of forming a finite-differenced Jacobian.
NonlinearImplicitSystem::ComputeResidual *	mffd_residual_object
	Object that computes the residual R(X) of the nonlinear system at the input iterate X for the purpose of forming Jacobian-vector products via finite differencing.
void(*	jacobian )(const NumericVector< Number > &X, SparseMatrix< Number > &J, sys_type &S)
	Function that computes the Jacobian J(X) of the nonlinear system at the input iterate X.
NonlinearImplicitSystem::ComputeJacobian *	jacobian_object
	Object that computes the Jacobian J(X) of the nonlinear system at the input iterate X.
void(*	matvec )(const NumericVector< Number > &X, NumericVector< Number > *R, SparseMatrix< Number > *J, sys_type &S)
	Function that computes either the residual \( R(X) \) or the Jacobian \( J(X) \) of the nonlinear system at the input iterate \( X \).
NonlinearImplicitSystem::ComputeResidualandJacobian *	residual_and_jacobian_object
	Object that computes either the residual \( R(X) \) or the Jacobian \( J(X) \) of the nonlinear system at the input iterate \( X \).
void(*	bounds )(NumericVector< Number > &XL, NumericVector< Number > &XU, sys_type &S)
	Function that computes the lower and upper bounds XL and XU on the solution of the nonlinear system.
NonlinearImplicitSystem::ComputeBounds *	bounds_object
	Object that computes the bounds vectors \( XL \) and \( XU \).
void(*	nullspace )(std::vector< NumericVector< Number > * > &sp, sys_type &S)
	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).
NonlinearImplicitSystem::ComputeVectorSubspace *	nullspace_object
	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).
void(*	transpose_nullspace )(std::vector< NumericVector< Number > * > &sp, sys_type &S)
	Function that computes a basis for the transpose Jacobian's nullspace – when solving a degenerate problem iteratively, if the solver supports it (e.g., PETSc's KSP), it is used to remove contributions outside of R(jac)
NonlinearImplicitSystem::ComputeVectorSubspace *	transpose_nullspace_object
	A callable object that computes a basis for the transpose Jacobian's nullspace – when solving a degenerate problem iteratively, if the solver supports it (e.g., PETSc's KSP), it is used to remove contributions outside of R(jac)
void(*	nearnullspace )(std::vector< NumericVector< Number > * > &sp, sys_type &S)
	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).
NonlinearImplicitSystem::ComputeVectorSubspace *	nearnullspace_object
	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).
void(*	user_presolve )(sys_type &S)
	Customizable function pointer which users can attach to the solver.
void(*	postcheck )(const NumericVector< Number > &old_soln, NumericVector< Number > &search_direction, NumericVector< Number > &new_soln, bool &changed_search_direction, bool &changed_new_soln, sys_type &S)
	Function that performs a "check" on the Newton search direction and solution after each nonlinear step.
NonlinearImplicitSystem::ComputePostCheck *	postcheck_object
	A callable object that is executed after each nonlinear iteration.
NonlinearImplicitSystem::ComputePreCheck *	precheck_object
unsigned int	max_nonlinear_iterations
	Maximum number of non-linear iterations.
unsigned int	max_function_evaluations
	Maximum number of function evaluations.
double	absolute_residual_tolerance
	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.
double	relative_residual_tolerance
double	divergence_tolerance
	The NonlinearSolver should exit if the residual becomes greater than the initial residual times the divergence_tolerance.
double	absolute_step_tolerance
	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.
double	relative_step_tolerance
unsigned int	max_linear_iterations
	Each linear solver step should exit after max_linear_iterations is exceeded.
double	initial_linear_tolerance
	Any required linear solves will at first be done with this tolerance; the NonlinearSolver may tighten the tolerance for later solves.
double	minimum_linear_tolerance
	The tolerance for linear solves is kept above this minimum.
bool	converged
	After a call to solve this will reflect whether or not the nonlinear solve was successful.

Protected Types
typedef std::map< std::string, std::pair< unsigned int, unsigned int > >	Counts
	Data structure to log the information.

Protected Member Functions
void	build_mat_null_space (NonlinearImplicitSystem::ComputeVectorSubspace *computeSubspaceObject, void(*)(std::vector< NumericVector< Number > * > &, sys_type &), MatNullSpace *)
void	increment_constructor_count (const std::string &name) noexcept
	Increments the construction counter.
void	increment_destructor_count (const std::string &name) noexcept
	Increments the destruction counter.

Protected Attributes
WrappedPetsc< SNES >	_snes
	Nonlinear solver context.
SNESConvergedReason	_reason
	Store the reason for SNES convergence/divergence for use even after the _snes has been cleared.
PetscInt	_n_linear_iterations
	Stores the total number of linear iterations from the last solve.
unsigned	_current_nonlinear_iteration_number
	Stores the current nonlinear iteration number.
bool	_zero_out_residual
	true to zero out residual before going into application level call-back, otherwise false
bool	_zero_out_jacobian
	true to zero out jacobian before going into application level call-back, otherwise false
bool	_default_monitor
	true if we want the default monitor to be set, false for no monitor (i.e.
bool	_snesmf_reuse_base
	True, If we want the base vector to be used for differencing even if the function provided to SNESSetFunction() is not the same as that provided to MatMFFDSetFunction().
bool	_computing_base_vector
	Whether we are computing the base vector for matrix-free finite differencing.
bool	_setup_reuse
	Whether we've triggered the preconditioner reuse.
PetscDMWrapper	_dm_wrapper
	Wrapper object for interacting with the "new" libMesh PETSc DM.
PetscMFFDMatrix< Number >	_mffd_jac
	Wrapper for matrix-free finite-difference Jacobians.
bool	_reuse_preconditioner
	Whether we should reuse the linear preconditioner.
bool	_exact_constraint_enforcement
	Whether we should enforce exact constraints globally during a solve.
unsigned int	_reuse_preconditioner_max_linear_its
	Number of linear iterations to retain the preconditioner.
sys_type &	_system
	A reference to the system we are solving.
bool	_is_initialized
	Flag indicating if the data structures have been initialized.
Preconditioner< T > *	_preconditioner
	Holds the Preconditioner object to be used for the linear solves.
SolverConfiguration *	_solver_configuration
	Optionally store a SolverOptions object that can be used to set parameters like solver type, tolerances and iteration limits.
const Parallel::Communicator &	_communicator

Static Protected Attributes
static Counts	_counts
	Actually holds the data.
static Threads::atomic< unsigned int >	_n_objects
	The number of objects.
static Threads::spin_mutex	_mutex
	Mutual exclusion object to enable thread-safe reference counting.
static bool	_enable_print_counter = true
	Flag to control whether reference count information is printed when print_info is called.

Friends
ResidualContext	libmesh_petsc_snes_residual_helper (SNES snes, Vec x, void *ctx)
PetscErrorCode	libmesh_petsc_snes_residual (SNES snes, Vec x, Vec r, void *ctx)
PetscErrorCode	libmesh_petsc_snes_fd_residual (SNES snes, Vec x, Vec r, void *ctx)
PetscErrorCode	libmesh_petsc_snes_mffd_residual (SNES snes, Vec x, Vec r, void *ctx)
PetscErrorCode	libmesh_petsc_snes_jacobian (SNES snes, Vec x, Mat jac, Mat pc, void *ctx)
PetscErrorCode	libmesh_petsc_snes_precheck (SNESLineSearch, Vec X, Vec Y, PetscBool *changed, void *context)

Detailed Description

template<typename T>
class libMesh::PetscNonlinearSolver< T >

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

Author

Benjamin Kirk

Date

2002-2007

Definition at line 73 of file petsc_nonlinear_solver.h.

Member Typedef Documentation

Counts

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

protectedinherited

Data structure to log the information.

The log is identified by the class name.

Definition at line 119 of file reference_counter.h.

sys_type

template<typename T >

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

The type of system.

Definition at line 79 of file petsc_nonlinear_solver.h.

Constructor & Destructor Documentation

PetscNonlinearSolver()

template<typename T >

libMesh::PetscNonlinearSolver< T >::PetscNonlinearSolver ( sys_type &  system )

explicit

Constructor.

Initializes Petsc data structures

Definition at line 688 of file petsc_nonlinear_solver.C.

                                                                   :
  NonlinearSolver<T>(system_in),
  linesearch_object(nullptr),
  _reason(SNES_CONVERGED_ITERATING/*==0*/), // Arbitrary initial value...
  _n_linear_iterations(0),
  _current_nonlinear_iteration_number(0),
  _zero_out_residual(true),
  _zero_out_jacobian(true),
  _default_monitor(true),
  _snesmf_reuse_base(true),
  _computing_base_vector(true),
  _setup_reuse(false),
  _mffd_jac(this->_communicator)
{
}

~PetscNonlinearSolver()

template<typename T >

libMesh::PetscNonlinearSolver< T >::~PetscNonlinearSolver ( )

default

Destructor.

Member Function Documentation

attach_preconditioner()

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.

{
  libmesh_error_msg_if(this->_is_initialized, "Preconditioner must be attached before the solver is initialized!");
 
  _preconditioner = preconditioner;
}

build()

template<typename T >

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

staticinherited

Builds a NonlinearSolver using the nonlinear solver package specified by solver_package.

Definition at line 40 of file nonlinear_solver.C.

{
  // Build the appropriate solver
  switch (solver_package)
    {
 
#ifdef LIBMESH_HAVE_PETSC
    case PETSC_SOLVERS:
      return std::make_unique<PetscNonlinearSolver<T>>(s);
#endif // LIBMESH_HAVE_PETSC
 
#if defined(LIBMESH_TRILINOS_HAVE_NOX) && defined(LIBMESH_TRILINOS_HAVE_EPETRA)
    case TRILINOS_SOLVERS:
      return std::make_unique<NoxNonlinearSolver<T>>(s);
#endif
 
    default:
      libmesh_error_msg("ERROR:  Unrecognized solver package: " << solver_package);
    }
}

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

build_mat_null_space()

template<typename T >

void libMesh::PetscNonlinearSolver< T >::build_mat_null_space ( NonlinearImplicitSystem::ComputeVectorSubspace *  computeSubspaceObject, void(*)(std::vector< NumericVector< Number > * > &, sys_type &)  computeSubspace, MatNullSpace *  msp  )

protected

Definition at line 847 of file petsc_nonlinear_solver.C.

{
  parallel_object_only();
 
  std::vector<NumericVector<Number> *> sp;
  if (computeSubspaceObject)
    (*computeSubspaceObject)(sp, this->system());
  else
    (*computeSubspace)(sp, this->system());
 
  *msp = LIBMESH_PETSC_NULLPTR;
  if (sp.size())
    {
      PetscInt nmodes = cast_int<PetscInt>(sp.size());
 
      std::vector<Vec> modes(nmodes);
      std::vector<PetscScalar> dots(nmodes);
 
      for (PetscInt i=0; i<nmodes; ++i)
        {
          auto pv = cast_ptr<PetscVector<T> *>(sp[i]);
 
          LibmeshPetscCall(VecDuplicate(pv->vec(), &modes[i]));
 
          LibmeshPetscCall(VecCopy(pv->vec(), modes[i]));
        }
 
      // Normalize.
      LibmeshPetscCall(VecNormalize(modes[0], LIBMESH_PETSC_NULLPTR));
 
      for (PetscInt i=1; i<nmodes; i++)
        {
          // Orthonormalize vec[i] against vec[0:i-1]
          LibmeshPetscCall(VecMDot(modes[i], i, modes.data(), dots.data()));
 
          for (PetscInt j=0; j<i; j++)
            dots[j] *= -1.;
 
          LibmeshPetscCall(VecMAXPY(modes[i], i, dots.data(), modes.data()));
 
          LibmeshPetscCall(VecNormalize(modes[i], LIBMESH_PETSC_NULLPTR));
        }
 
      LibmeshPetscCall(MatNullSpaceCreate(this->comm().get(), PETSC_FALSE, nmodes, modes.data(), msp));
 
      for (PetscInt i=0; i<nmodes; ++i)
        LibmeshPetscCall(VecDestroy(&modes[i]));
    }
}

clear()

template<typename T >

void libMesh::PetscNonlinearSolver< T >::clear ( )

overridevirtual

Release all memory and clear data structures.

Reimplemented from libMesh::NonlinearSolver< T >.

Definition at line 712 of file petsc_nonlinear_solver.C.

{
  if (this->initialized())
    {
      this->_is_initialized = false;
 
      // If we don't need the preconditioner next time
      // retain the original behavior of clearing the data
      // between solves.
      if (!(reuse_preconditioner()))
        {
        // SNESReset really ought to work but replacing destroy() with
        // SNESReset causes a very slight change in behavior that
        // manifests as two failed MOOSE tests...
        _snes.destroy();
        }
 
      // Reset the nonlinear iteration counter.  This information is only relevant
      // *during* the solve().  After the solve is completed it should return to
      // the default value of 0.
      _current_nonlinear_iteration_number = 0;
    }
}

References libMesh::initialized().

comm()

const Parallel::Communicator & libMesh::ParallelObject::comm ( ) const

inlineinherited

Returns

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

Definition at line 97 of file parallel_object.h.

  { return _communicator; }

References libMesh::ParallelObject::_communicator.

Referenced by libMesh::__libmesh_petsc_diff_solver_jacobian(), libMesh::__libmesh_petsc_diff_solver_monitor(), libMesh::__libmesh_petsc_diff_solver_residual(), libMesh::ExactSolution::_compute_error(), libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::Partitioner::_find_global_index_by_pid_map(), libMesh::BoundaryInfo::_find_id_maps(), libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_get_diagonal(), libMesh::SlepcEigenSolver< T >::_petsc_shell_matrix_get_diagonal(), libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_mult(), libMesh::SlepcEigenSolver< T >::_petsc_shell_matrix_mult(), libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_mult_add(), libMesh::DofMap::add_constraints_to_send_list(), add_cube_convex_hull_to_mesh(), libMesh::PetscDMWrapper::add_dofs_helper(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::TransientRBConstruction::add_IC_to_RB_space(), libMesh::RBEIMEvaluation::add_interpolation_data(), libMesh::CondensedEigenSystem::add_matrices(), libMesh::EigenSystem::add_matrices(), libMesh::System::add_matrix(), libMesh::System::add_matrix(), libMesh::System::add_matrix(), libMesh::RBConstruction::add_scaled_matrix_and_vector(), libMesh::System::add_vector(), libMesh::MeshTools::Modification::all_tri(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::RBConstruction::allocate_data_structures(), libMesh::TransientRBConstruction::allocate_data_structures(), libMesh::TransientRBConstruction::assemble_affine_expansion(), libMesh::AdvectionSystem::assemble_claw_rhs(), libMesh::FEMSystem::assemble_qoi(), libMesh::Nemesis_IO::assert_symmetric_cmaps(), libMesh::MeshCommunication::assign_global_indices(), libMesh::Partitioner::assign_partitioning(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::Partitioner::build_graph(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::PetscDMWrapper::build_section(), libMesh::PetscDMWrapper::build_sf(), libMesh::MeshBase::cache_elem_data(), libMesh::DofMap::check_dirichlet_bcid_consistency(), libMesh::MeshTetInterface::check_hull_integrity(), libMesh::MeshBase::complete_preparation(), libMesh::RBConstruction::compute_Fq_representor_innerprods(), libMesh::RBConstruction::compute_max_error_bound(), libMesh::Nemesis_IO_Helper::compute_num_global_elem_blocks(), libMesh::Nemesis_IO_Helper::compute_num_global_nodesets(), libMesh::Nemesis_IO_Helper::compute_num_global_sidesets(), libMesh::RBConstruction::compute_output_dual_innerprods(), libMesh::RBConstruction::compute_residual_dual_norm_slow(), libMesh::RBSCMConstruction::compute_SCM_bounds_on_training_set(), libMesh::DofMap::computed_sparsity_already(), libMesh::Problem_Interface::computeJacobian(), libMesh::Problem_Interface::computePreconditioner(), PetscSolverConfiguration::configure_solver(), libMesh::ContinuationSystem::ContinuationSystem(), libMesh::MeshBase::copy_constraint_rows(), libMesh::ExodusII_IO::copy_elemental_solution(), libMesh::ExodusII_IO::copy_nodal_solution(), libMesh::ExodusII_IO::copy_scalar_solution(), libMesh::CondensedEigenSystem::copy_super_to_sub(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::MeshTools::create_bounding_box(), libMesh::DofMap::create_dof_constraints(), libMesh::MeshTools::create_nodal_bounding_box(), libMesh::MeshRefinement::create_parent_error_vector(), libMesh::MeshTools::create_processor_bounding_box(), libMesh::MeshTools::create_subdomain_bounding_box(), libMesh::PetscMatrix< T >::create_submatrix_nosort(), create_wrapped_function(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::MeshBase::detect_interior_parents(), libMesh::RBEIMEvaluation::distribute_bfs(), DMlibMeshFunction(), DMlibMeshJacobian(), DMlibMeshSetSystem_libMesh(), DMVariableBounds_libMesh(), libMesh::DTKSolutionTransfer::DTKSolutionTransfer(), libMesh::MeshRefinement::eliminate_unrefined_patches(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_interiors(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_nodes(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_sides(), libMesh::TransientRBConstruction::enrich_RB_space(), libMesh::EpetraVector< T >::EpetraVector(), AssembleOptimization::equality_constraints(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::ExactErrorEstimator::estimate_error(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::PatchRecoveryErrorEstimator::estimate_error(), libMesh::WeightedPatchRecoveryErrorEstimator::estimate_error(), libMesh::SmoothnessEstimator::estimate_smoothness(), libMesh::MeshRefinement::flag_elements_by_elem_fraction(), libMesh::MeshRefinement::flag_elements_by_error_fraction(), libMesh::MeshRefinement::flag_elements_by_error_tolerance(), libMesh::MeshRefinement::flag_elements_by_mean_stddev(), libMesh::MeshRefinement::flag_elements_by_nelem_target(), libMesh::RBEIMEvaluation::gather_bfs(), libMesh::DofMap::gather_constraints(), libMesh::MeshfreeInterpolation::gather_remote_data(), libMesh::CondensedEigenSystem::get_eigenpair(), libMesh::RBEIMEvaluation::get_eim_basis_function_node_value(), libMesh::RBEIMEvaluation::get_eim_basis_function_side_value(), libMesh::RBEIMEvaluation::get_eim_basis_function_value(), libMesh::MeshBase::get_info(), libMesh::RBEIMEvaluation::get_interior_basis_functions_as_vecs(), libMesh::ImplicitSystem::get_linear_solver(), libMesh::RBEIMConstruction::get_max_abs_value(), libMesh::RBEIMConstruction::get_node_max_abs_value(), libMesh::RBEIMEvaluation::get_parametrized_function_node_value(), libMesh::RBEIMEvaluation::get_parametrized_function_side_value(), libMesh::RBEIMEvaluation::get_parametrized_function_value(), libMesh::RBEIMConstruction::get_random_point(), libMesh::RBEIMConstruction::get_random_point(), libMesh::RBEIMConstruction::get_random_point(), libMesh::MeshTetInterface::improve_hull_integrity(), AssembleOptimization::inequality_constraints(), AssembleOptimization::inequality_constraints_jacobian(), libMesh::StaticCondensation::init(), libMesh::TimeSolver::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::LocationMap< T >::init(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), ElasticitySystem::init_data(), libMesh::AdvectionSystem::init_data(), libMesh::ClawSystem::init_data(), libMesh::PetscDMWrapper::init_petscdm(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::OptimizationSystem::initialize_equality_constraints_storage(), libMesh::OptimizationSystem::initialize_inequality_constraints_storage(), libMesh::RBEIMConstruction::initialize_parametrized_functions_in_training_set(), libMesh::RBEIMConstruction::inner_product(), integrate_function(), libMesh::MeshTools::Modification::interpolate_surface(), libMesh::MeshTools::libmesh_assert_consistent_distributed(), libMesh::MeshTools::libmesh_assert_consistent_distributed_nodes(), libMesh::MeshTools::libmesh_assert_contiguous_dof_ids(), libMesh::MeshTools::libmesh_assert_equal_connectivity(), libMesh::MeshTools::libmesh_assert_equal_points(), libMesh::MeshTools::libmesh_assert_parallel_consistent_new_node_procids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_topology_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_valid_boundary_ids(), libMesh::MeshTools::libmesh_assert_valid_constraint_rows(), libMesh::MeshTools::libmesh_assert_valid_dof_ids(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_flags(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_object_ids(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_p_levels(), libMesh::MeshTools::libmesh_assert_valid_refinement_flags(), libMesh::MeshTools::libmesh_assert_valid_unique_ids(), libMesh::libmesh_petsc_linesearch_shellfunc(), libMesh::libmesh_petsc_preconditioner_apply(), libMesh::libmesh_petsc_snes_mffd_interface(), libMesh::libmesh_petsc_snes_postcheck(), libMesh::MeshRefinement::limit_level_mismatch_at_edge(), libMesh::MeshRefinement::limit_level_mismatch_at_node(), libMesh::MeshRefinement::limit_overrefined_boundary(), libMesh::MeshRefinement::limit_underrefined_boundary(), libMesh::LinearImplicitSystem::LinearImplicitSystem(), main(), libMesh::MeshCommunication::make_elems_parallel_consistent(), libMesh::MeshCommunication::make_new_node_proc_ids_parallel_consistent(), libMesh::MeshCommunication::make_new_nodes_parallel_consistent(), libMesh::MeshCommunication::make_node_bcids_parallel_consistent(), libMesh::MeshCommunication::make_node_ids_parallel_consistent(), libMesh::MeshCommunication::make_node_proc_ids_parallel_consistent(), libMesh::MeshCommunication::make_node_unique_ids_parallel_consistent(), libMesh::MeshCommunication::make_nodes_parallel_consistent(), libMesh::MeshCommunication::make_p_levels_parallel_consistent(), libMesh::TransientRBConstruction::mass_matrix_scaled_matvec(), libMesh::FEMSystem::mesh_position_set(), libMesh::TriangulatorInterface::MeshedHole::MeshedHole(), LinearElasticityWithContact::move_mesh(), libMesh::DistributedMesh::n_active_elem(), libMesh::MeshTools::n_active_levels(), libMesh::BoundaryInfo::n_boundary_conds(), libMesh::MeshTools::n_connected_components(), libMesh::DofMap::n_constrained_dofs(), libMesh::MeshBase::n_constraint_rows(), libMesh::DofMap::n_dofs(), libMesh::DofMap::n_dofs_per_processor(), libMesh::BoundaryInfo::n_edge_conds(), libMesh::CondensedEigenSystem::n_global_non_condensed_dofs(), libMesh::MeshTools::n_levels(), MixedOrderTest::n_neighbor_links(), libMesh::BoundaryInfo::n_nodeset_conds(), libMesh::SparsityPattern::Build::n_nonzeros(), libMesh::MeshTools::n_p_levels(), libMesh::BoundaryInfo::n_shellface_conds(), libMesh::RBEIMEvaluation::node_distribute_bfs(), libMesh::RBEIMEvaluation::node_gather_bfs(), libMesh::RBEIMConstruction::node_inner_product(), libMesh::PetscVector< T >::operator=(), libMesh::MeshBase::operator==(), libMesh::DistributedMesh::parallel_max_elem_id(), libMesh::DistributedMesh::parallel_max_node_id(), libMesh::DistributedMesh::parallel_max_unique_id(), libMesh::ReplicatedMesh::parallel_max_unique_id(), libMesh::DistributedMesh::parallel_n_elem(), libMesh::DistributedMesh::parallel_n_nodes(), libMesh::SparsityPattern::Build::parallel_sync(), libMesh::BoundaryInfo::parallel_sync_node_ids(), libMesh::BoundaryInfo::parallel_sync_side_ids(), libMesh::MeshTools::paranoid_n_levels(), libMesh::Partitioner::partition(), libMesh::Partitioner::partition_unpartitioned_elements(), libMesh::petsc_auto_fieldsplit(), LaplaceSystem::postprocess(), PoissonSystem::postprocess(), libMesh::MeshBase::print_constraint_rows(), libMesh::DofMap::print_dof_constraints(), libMesh::DofMap::process_mesh_constraint_rows(), libMesh::Partitioner::processor_pairs_to_interface_nodes(), libMesh::InterMeshProjection::project_system_vectors(), libMesh::XdrIO::read(), libMesh::Nemesis_IO::read(), FEMParameters::read(), libMesh::EquationSystems::read(), libMesh::CheckpointIO::read_header(), libMesh::ExodusII_IO::read_header(), libMesh::System::read_header(), libMesh::XdrIO::read_header(), libMesh::RBEIMEvaluation::read_in_interior_basis_functions(), libMesh::RBEIMEvaluation::read_in_node_basis_functions(), libMesh::RBEIMEvaluation::read_in_side_basis_functions(), libMesh::RBEvaluation::read_in_vectors_from_multiple_files(), libMesh::RBConstruction::read_riesz_representors_from_files(), libMesh::TransientRBConstruction::read_riesz_representors_from_files(), libMesh::System::read_SCALAR_dofs(), libMesh::XdrIO::read_serialized_bc_names(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::System::read_serialized_vector(), libMesh::Nemesis_IO_Helper::read_var_names_impl(), MeshFunctionTest::read_variable_info_from_output_data(), libMesh::MeshBase::recalculate_n_partitions(), libMesh::SimplexRefiner::refine_via_edges(), libMesh::StaticCondensationDofMap::reinit(), libMesh::BoundaryInfo::remove_edge_id(), libMesh::BoundaryInfo::remove_node_id(), libMesh::BoundaryInfo::remove_shellface_id(), libMesh::BoundaryInfo::remove_side_id(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::DistributedMesh::renumber_nodes_and_elements(), LinearElasticityWithContact::residual_and_jacobian(), OverlappingAlgebraicGhostingTest::run_ghosting_test(), OverlappingCouplingGhostingTest::run_sparsity_pattern_test(), scale_mesh_and_plot(), libMesh::DofMap::scatter_constraints(), libMesh::CheckpointIO::select_split_config(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::send_and_insert_dof_values(), libMesh::TransientRBConstruction::set_error_temporal_data(), libMesh::Partitioner::set_interface_node_processor_ids_BFS(), libMesh::Partitioner::set_interface_node_processor_ids_linear(), libMesh::Partitioner::set_interface_node_processor_ids_petscpartitioner(), libMesh::Partitioner::set_node_processor_ids(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::Partitioner::set_parent_processor_ids(), libMesh::PetscDMWrapper::set_point_range_in_section(), libMesh::PetscDiffSolver::setup_petsc_data(), libMesh::RBEIMEvaluation::side_distribute_bfs(), libMesh::RBEIMEvaluation::side_gather_bfs(), libMesh::RBEIMConstruction::side_inner_product(), libMesh::Partitioner::single_partition(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::VariationalMeshSmoother::smooth(), libMesh::NoxNonlinearSolver< Number >::solve(), libMesh::ClawSystem::solve_conservation_law(), libMesh::split_mesh(), libMesh::RBEIMConstruction::store_eim_solutions_for_training_set(), libMesh::MeshBase::subdomain_ids(), libMesh::BoundaryInfo::sync(), libMesh::MeshBase::sync_subdomain_name_map(), ConstraintOperatorTest::test1DCoarseningNewNodes(), ConstraintOperatorTest::test1DCoarseningOperator(), MeshFunctionTest::test_bad_gradient_var_with_out_of_mesh_value(), MeshFunctionTest::test_bad_hessian_var_with_out_of_mesh_value(), MeshfunctionDFEM::test_mesh_function_dfem(), MeshfunctionDFEM::test_mesh_function_dfem_grad(), MeshFunctionTest::test_p_level(), ExodusC0PolyhedronTest::test_write_and_read_hexagonal_prism(), ExodusC0PolygonTest::test_write_and_read_pentagon(), DofMapTest::testBadElemFECombo(), SystemsTest::testBlockRestrictedVarNDofs(), BoundaryInfoTest::testBoundaryOnChildrenErrors(), CheckpointIOTest::testC0PolygonCheckpoint(), VolumeTest::testC0PolygonMethods(), CheckpointIOTest::testC0PolyhedronCheckpoint(), VolumeTest::testC0PolyhedronMethods(), ConstraintOperatorTest::testCoreform(), ConnectedComponentsTest::testEdge(), MeshInputTest::testExodusIGASidesets(), MeshTriangulationTest::testFoundCenters(), PointLocatorTest::testLocator(), BoundaryInfoTest::testMesh(), BoundaryMeshSubdomainTest::testPerBoundarySubdomain(), PointLocatorTest::testPlanar(), MeshTriangulationTest::testPoly2TriEdge3ToTri7CenterFixup(), MeshTriangulationTest::testPoly2TriRefinementBase(), SystemsTest::testProjectCubeWithMeshFunction(), SystemsTest::testProjectScalarCoarsening(), BoundaryInfoTest::testRenumber(), BoundaryInfoTest::testSelectiveRenumber(), BoundaryMeshSubdomainTest::testSingleSubdomain(), CheckpointIOTest::testSplitter(), MeshInputTest::testTetgenIO(), MeshTriangulationTest::testTriangulatorInterp(), MeshTriangulationTest::testTriangulatorMeshedHoles(), MeshTriangulationTest::testTriangulatorRoundHole(), MeshSmootherTest::testVariationalSmoother(), libMesh::MeshTools::total_weight(), libMesh::RBConstruction::train_reduced_basis_with_POD(), libMesh::MeshfreeSolutionTransfer::transfer(), libMesh::MeshFunctionSolutionTransfer::transfer(), libMesh::Poly2TriTriangulator::triangulate(), libMesh::RBConstruction::truth_assembly(), libMesh::TransientRBConstruction::truth_assembly(), update_current_local_solution(), libMesh::TransientRBConstruction::update_RB_initial_condition_all_N(), libMesh::RBConstruction::update_RB_system_matrices(), libMesh::TransientRBConstruction::update_RB_system_matrices(), libMesh::TransientRBConstruction::update_residual_terms(), libMesh::RBConstruction::update_residual_terms(), libMesh::MeshTools::volume(), libMesh::STLIO::write(), libMesh::XdrIO::write(), libMesh::NameBasedIO::write(), libMesh::VTKIO::write_nodal_data(), libMesh::RBEIMEvaluation::write_out_interior_basis_functions(), libMesh::RBEIMEvaluation::write_out_node_basis_functions(), libMesh::RBEIMEvaluation::write_out_side_basis_functions(), libMesh::RBEvaluation::write_out_vectors(), libMesh::RBConstruction::write_riesz_representors_to_files(), libMesh::TransientRBConstruction::write_riesz_representors_to_files(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), libMesh::XdrIO::write_serialized_nodesets(), libMesh::RBDataSerialization::RBEvaluationSerialization::write_to_file(), libMesh::RBDataSerialization::TransientRBEvaluationSerialization::write_to_file(), libMesh::RBDataSerialization::RBEIMEvaluationSerialization::write_to_file(), and libMesh::RBDataSerialization::RBSCMEvaluationSerialization::write_to_file().

computing_base_vector()

template<typename T >

bool libMesh::PetscNonlinearSolver< T >::computing_base_vector ( ) const

inline

Returns

whether we are computing the base vector for matrix-free finite-differencing

Definition at line 182 of file petsc_nonlinear_solver.h.

{ return _computing_base_vector; }

References libMesh::PetscNonlinearSolver< T >::_computing_base_vector.

Referenced by libMesh::libmesh_petsc_snes_mffd_interface(), and libMesh::PetscNonlinearSolver< T >::set_computing_base_vector().

disable_print_counter_info()

void libMesh::ReferenceCounter::disable_print_counter_info ( )

staticinherited

Definition at line 100 of file reference_counter.C.

{
  _enable_print_counter = false;
  return;
}

References libMesh::ReferenceCounter::_enable_print_counter.

enable_print_counter_info()

void libMesh::ReferenceCounter::enable_print_counter_info ( )

staticinherited

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

Enabled by default.

Definition at line 94 of file reference_counter.C.

{
  _enable_print_counter = true;
  return;
}

References libMesh::ReferenceCounter::_enable_print_counter.

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

exact_constraint_enforcement()

template<typename T >

bool libMesh::NonlinearSolver< T >::exact_constraint_enforcement ( )

inlineinherited

Definition at line 403 of file nonlinear_solver.h.

  {
    return _exact_constraint_enforcement;
  }

References libMesh::NonlinearSolver< T >::_exact_constraint_enforcement.

force_new_preconditioner()

template<typename T >

void libMesh::PetscNonlinearSolver< T >::force_new_preconditioner ( )

overridevirtual

Immediately force a new preconditioner, even if reuse is set.

Reimplemented from libMesh::NonlinearSolver< T >.

Definition at line 1188 of file petsc_nonlinear_solver.C.

{
  // Easiest way is just to clear everything out
  this->_is_initialized = false;
  _snes.destroy();
  _setup_reuse = false;
}

get_converged_reason()

template<typename T >

SNESConvergedReason libMesh::PetscNonlinearSolver< T >::get_converged_reason

(

)

Returns

The currently-available (or most recently obtained, if the SNES object has been destroyed) convergence reason.

Refer to PETSc docs for the meaning of different SNESConvergedReasons.

Definition at line 1153 of file petsc_nonlinear_solver.C.

{
  if (this->initialized())
    LibmeshPetscCall(SNESGetConvergedReason(_snes, &_reason));
 
  return _reason;
}

References libMesh::initialized().

get_current_nonlinear_iteration_number()

template<typename T >

virtual unsigned libMesh::PetscNonlinearSolver< T >::get_current_nonlinear_iteration_number ( ) const

inlineoverridevirtual

Returns

The current nonlinear iteration number if called during the solve(), for example by the user-specified residual or Jacobian function.

Implements libMesh::NonlinearSolver< T >.

Definition at line 145 of file petsc_nonlinear_solver.h.

  { return _current_nonlinear_iteration_number; }

References libMesh::PetscNonlinearSolver< T >::_current_nonlinear_iteration_number.

get_info()

std::string libMesh::ReferenceCounter::get_info ( )

staticinherited

Gets a string containing the reference information.

Definition at line 47 of file reference_counter.C.

{
#if defined(LIBMESH_ENABLE_REFERENCE_COUNTING) && defined(DEBUG)
 
  std::ostringstream oss;
 
  oss << '\n'
      << " ---------------------------------------------------------------------------- \n"
      << "| Reference count information                                                |\n"
      << " ---------------------------------------------------------------------------- \n";
 
  for (const auto & [name, cd] : _counts)
    oss << "| " << name << " reference count information:\n"
        << "|  Creations:    " << cd.first    << '\n'
        << "|  Destructions: " << cd.second << '\n';
 
  oss << " ---------------------------------------------------------------------------- \n";
 
  return oss.str();
 
#else
 
  return "";
 
#endif
}

References libMesh::ReferenceCounter::_counts.

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

get_total_linear_iterations()

template<typename T >

int libMesh::PetscNonlinearSolver< T >::get_total_linear_iterations ( )

overridevirtual

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

Implements libMesh::NonlinearSolver< T >.

Definition at line 1162 of file petsc_nonlinear_solver.C.

{
  return _n_linear_iterations;
}

increment_constructor_count()

void libMesh::ReferenceCounter::increment_constructor_count ( const std::string &  name )

inlineprotectednoexceptinherited

Increments the construction counter.

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

Definition at line 183 of file reference_counter.h.

{
  libmesh_try
  {
    Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
    std::pair<unsigned int, unsigned int> & p = _counts[name];
    p.first++;
  }
  libmesh_catch (...)
  {
    auto stream = libMesh::err.get();
    stream->exceptions(stream->goodbit); // stream must not throw
    libMesh::err << "Encountered unrecoverable error while calling "
                 << "ReferenceCounter::increment_constructor_count() "
                 << "for a(n) " << name << " object." << std::endl;
    std::terminate();
  }
}

References libMesh::err, libMesh::BasicOStreamProxy< charT, traits >::get(), and libMesh::Threads::spin_mtx.

Referenced by libMesh::ReferenceCountedObject< T >::ReferenceCountedObject(), libMesh::ReferenceCountedObject< T >::ReferenceCountedObject(), and libMesh::ReferenceCountedObject< T >::ReferenceCountedObject().

increment_destructor_count()

void libMesh::ReferenceCounter::increment_destructor_count ( const std::string &  name )

inlineprotectednoexceptinherited

Increments the destruction counter.

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

Definition at line 207 of file reference_counter.h.

{
  libmesh_try
  {
    Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
    std::pair<unsigned int, unsigned int> & p = _counts[name];
    p.second++;
  }
  libmesh_catch (...)
  {
    auto stream = libMesh::err.get();
    stream->exceptions(stream->goodbit); // stream must not throw
    libMesh::err << "Encountered unrecoverable error while calling "
                 << "ReferenceCounter::increment_destructor_count() "
                 << "for a(n) " << name << " object." << std::endl;
    std::terminate();
  }
}

References libMesh::err, libMesh::BasicOStreamProxy< charT, traits >::get(), and libMesh::Threads::spin_mtx.

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

init()

template<typename T >

void libMesh::PetscNonlinearSolver< T >::init ( const char *  name = nullptr )

overridevirtual

Initialize data structures if not done so already.

May assign a name to the solver in some implementations

Implements libMesh::NonlinearSolver< T >.

Definition at line 737 of file petsc_nonlinear_solver.C.

{
  parallel_object_only();
 
  // Initialize the data structures if not done so already.
  if (!this->initialized())
    {
      this->_is_initialized = true;
 
      // Make only if we don't already have a retained snes
      // hanging around from the last solve
      if (!_snes)
        LibmeshPetscCall(SNESCreate(this->comm().get(), _snes.get()));
 
      // I believe all of the following can be safely repeated
      // even on an old snes instance from the last solve
 
      if (name)
        {
          libmesh_assert(std::string(name).front() != '-');
          libmesh_assert(std::string(name).back() == '_');
          LibmeshPetscCall(SNESSetOptionsPrefix(_snes, name));
        }
 
      // Attaching a DM to SNES.
#if defined(LIBMESH_ENABLE_AMR) && defined(LIBMESH_HAVE_METAPHYSICL)
      bool use_petsc_dm = libMesh::on_command_line(
          "--" + (name ? std::string(name) : std::string("")) + "use_petsc_dm");
 
      // This needs to be called before SNESSetFromOptions
      if (use_petsc_dm)
        this->_dm_wrapper.init_and_attach_petscdm(this->system(), _snes);
      else
#endif
      {
        WrappedPetsc<DM> dm;
        LibmeshPetscCall(DMCreate(this->comm().get(), dm.get()));
        LibmeshPetscCall(DMSetType(dm, DMLIBMESH));
        LibmeshPetscCall(DMlibMeshSetSystem(dm, this->system()));
 
        if (name)
          LibmeshPetscCall(DMSetOptionsPrefix(dm, name));
 
        LibmeshPetscCall(DMSetFromOptions(dm));
        LibmeshPetscCall(DMSetUp(dm));
        LibmeshPetscCall(SNESSetDM(_snes, dm));
        // SNES now owns the reference to dm.
      }
 
      setup_default_monitor();
 
      // If the SolverConfiguration object is provided, use it to set
      // options during solver initialization.
      if (this->_solver_configuration)
        {
          this->_solver_configuration->set_options_during_init();
        }
 
      if (this->_preconditioner)
        {
          KSP ksp;
          LibmeshPetscCall(SNESGetKSP (_snes, &ksp));
          PC pc;
          LibmeshPetscCall(KSPGetPC(ksp,&pc));
 
          this->_preconditioner->init();
 
          LibmeshPetscCall(PCSetType(pc, PCSHELL));
          LibmeshPetscCall(PCShellSetContext(pc,(void *)this->_preconditioner));
 
          //Re-Use the shell functions from petsc_linear_solver
          LibmeshPetscCall(PCShellSetSetUp(pc,libmesh_petsc_preconditioner_setup));
          LibmeshPetscCall(PCShellSetApply(pc,libmesh_petsc_preconditioner_apply));
        }
    }
 
 
  // Tell PETSc about our linesearch "post-check" function, but only
  // if the user has provided one.  There seem to be extra,
  // unnecessary residual calculations if a postcheck function is
  // attached for no reason.
  if (this->postcheck || this->postcheck_object)
    {
      SNESLineSearch linesearch;
      LibmeshPetscCall(SNESGetLineSearch(_snes, &linesearch));
 
      LibmeshPetscCall(SNESLineSearchSetPostCheck(linesearch, libmesh_petsc_snes_postcheck, this));
    }
 
  if (this->precheck_object)
    {
      SNESLineSearch linesearch;
      LibmeshPetscCall(SNESGetLineSearch(_snes, &linesearch));
 
      LibmeshPetscCall(SNESLineSearchSetPreCheck(linesearch, libmesh_petsc_snes_precheck, this));
    }
}

References DMlibMeshSetSystem(), libMesh::WrappedPetsc< T >::get(), libMesh::initialized(), libMesh::libmesh_assert(), libMesh::libmesh_petsc_preconditioner_apply(), libMesh::libmesh_petsc_preconditioner_setup(), libMesh::libmesh_petsc_snes_postcheck(), libMesh::libmesh_petsc_snes_precheck(), and libMesh::on_command_line().

initialized()

template<typename T >

bool libMesh::NonlinearSolver< T >::initialized ( ) const

inlineinherited

Returns

true if the data structures are initialized, false otherwise.

Definition at line 83 of file nonlinear_solver.h.

{ return _is_initialized; }

References libMesh::NonlinearSolver< T >::_is_initialized.

n_objects()

static unsigned int libMesh::ReferenceCounter::n_objects ( )

inlinestaticinherited

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

Definition at line 85 of file reference_counter.h.

  { return _n_objects; }

References libMesh::ReferenceCounter::_n_objects.

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

n_processors()

processor_id_type libMesh::ParallelObject::n_processors ( ) const

inlineinherited

Returns

The number of processors in the group.

Definition at line 103 of file parallel_object.h.

  {
    processor_id_type returnval =
      cast_int<processor_id_type>(_communicator.size());
    libmesh_assert(returnval); // We never have an empty comm
    return returnval;
  }

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

Referenced by libMesh::Partitioner::_find_global_index_by_pid_map(), libMesh::BoundaryInfo::_find_id_maps(), libMesh::DofMap::add_constraints_to_send_list(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::DistributedMesh::add_elem(), libMesh::DistributedMesh::add_node(), libMesh::System::add_vector(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::FEMSystem::assembly(), libMesh::Nemesis_IO::assert_symmetric_cmaps(), libMesh::Partitioner::assign_partitioning(), libMesh::AztecLinearSolver< T >::AztecLinearSolver(), libMesh::Partitioner::build_graph(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::DistributedMesh::clear(), libMesh::DistributedMesh::clear_elems(), libMesh::Nemesis_IO_Helper::compute_border_node_ids(), libMesh::Nemesis_IO_Helper::construct_nemesis_filename(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::ExodusII_IO::copy_scalar_solution(), libMesh::Nemesis_IO::copy_scalar_solution(), libMesh::UnstructuredMesh::create_pid_mesh(), libMesh::MeshTools::create_processor_bounding_box(), libMesh::DistributedMesh::DistributedMesh(), libMesh::EnsightIO::EnsightIO(), libMesh::RBEIMEvaluation::gather_bfs(), libMesh::MeshBase::get_info(), libMesh::StaticCondensation::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::PetscDMWrapper::init_petscdm(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::Nemesis_IO_Helper::initialize(), libMesh::DistributedMesh::insert_elem(), libMesh::NumericVector< T >::is_effectively_ghosted(), libMesh::NumericVector< T >::is_effectively_serial(), libMesh::MeshTools::libmesh_assert_contiguous_dof_ids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_new_node_procids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_topology_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_valid_boundary_ids(), libMesh::MeshTools::libmesh_assert_valid_dof_ids(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::MeshTools::libmesh_assert_valid_refinement_flags(), libMesh::MeshBase::n_active_elem_on_proc(), libMesh::DofMap::n_dofs_per_processor(), libMesh::MeshBase::n_elem_on_proc(), libMesh::MeshBase::n_nodes_on_proc(), libMesh::RBEIMEvaluation::node_gather_bfs(), libMesh::MeshBase::partition(), libMesh::Partitioner::partition(), libMesh::Partitioner::partition_unpartitioned_elements(), libMesh::Partitioner::partition_unpartitioned_elements(), libMesh::MeshBase::print_constraint_rows(), libMesh::DofMap::print_dof_constraints(), libMesh::Nemesis_IO::read(), libMesh::CheckpointIO::read(), libMesh::NameBasedIO::read(), libMesh::CheckpointIO::read_connectivity(), libMesh::XdrIO::read_header(), libMesh::CheckpointIO::read_nodes(), libMesh::System::read_parallel_data(), libMesh::System::read_SCALAR_dofs(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::System::read_serialized_vector(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::Partitioner::repartition(), OverlappingFunctorTest::run_partitioner_test(), libMesh::DofMap::scatter_constraints(), libMesh::DistributedMesh::set_next_unique_id(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::PetscDMWrapper::set_point_range_in_section(), WriteVecAndScalar::setupTests(), libMesh::RBEIMEvaluation::side_gather_bfs(), DistributedMeshTest::testRemoteElemError(), CheckpointIOTest::testSplitter(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::GMVIO::write_binary(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates(), libMesh::ExodusII_IO::write_nodal_data(), libMesh::VTKIO::write_nodal_data(), libMesh::System::write_parallel_data(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), and libMesh::XdrIO::write_serialized_nodesets().

print_converged_reason()

template<typename T >

void libMesh::PetscNonlinearSolver< T >::print_converged_reason ( )

overridevirtual

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

Reimplemented from libMesh::NonlinearSolver< T >.

Definition at line 1143 of file petsc_nonlinear_solver.C.

{
 
  libMesh::out << "Nonlinear solver convergence/divergence reason: "
               << SNESConvergedReasons[this->get_converged_reason()] << std::endl;
}

References libMesh::out.

print_info()

void libMesh::ReferenceCounter::print_info ( std::ostream &  out_stream = libMesh::out )

staticinherited

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

Definition at line 81 of file reference_counter.C.

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

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

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

processor_id()

processor_id_type libMesh::ParallelObject::processor_id ( ) const

inlineinherited

Returns

The rank of this processor in the group.

Definition at line 114 of file parallel_object.h.

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

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

Referenced by libMesh::BoundaryInfo::_find_id_maps(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::DistributedMesh::add_elem(), libMesh::BoundaryInfo::add_elements(), libMesh::DistributedMesh::add_node(), libMesh::MeshTools::Modification::all_tri(), libMesh::FEMSystem::assembly(), libMesh::Nemesis_IO::assert_symmetric_cmaps(), libMesh::Partitioner::assign_partitioning(), libMesh::Nemesis_IO_Helper::build_element_and_node_maps(), libMesh::Partitioner::build_graph(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::MeshFunction::check_found_elem(), libMesh::DistributedMesh::clear(), libMesh::DistributedMesh::clear_elems(), libMesh::ExodusII_IO_Helper::close(), libMesh::Nemesis_IO_Helper::compute_border_node_ids(), libMesh::Nemesis_IO_Helper::compute_communication_map_parameters(), libMesh::Nemesis_IO_Helper::compute_internal_and_border_elems_and_internal_nodes(), libMesh::RBConstruction::compute_max_error_bound(), libMesh::Nemesis_IO_Helper::compute_node_communication_maps(), libMesh::Nemesis_IO_Helper::compute_num_global_elem_blocks(), libMesh::Nemesis_IO_Helper::compute_num_global_nodesets(), libMesh::Nemesis_IO_Helper::compute_num_global_sidesets(), libMesh::Nemesis_IO_Helper::construct_nemesis_filename(), libMesh::ExodusII_IO::copy_elemental_solution(), libMesh::ExodusII_IO::copy_nodal_solution(), libMesh::ExodusII_IO::copy_scalar_solution(), libMesh::Nemesis_IO::copy_scalar_solution(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::ExodusII_IO_Helper::create(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::DistributedMesh::DistributedMesh(), libMesh::DistributedMesh::DistributedMesh(), libMesh::DofMapBase::end_dof(), libMesh::DofMapBase::end_old_dof(), libMesh::EnsightIO::EnsightIO(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::find_dofs_to_send(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::DofMapBase::first_dof(), libMesh::DofMapBase::first_old_dof(), libMesh::RBEIMEvaluation::gather_bfs(), libMesh::Nemesis_IO_Helper::get_cmap_params(), libMesh::Nemesis_IO_Helper::get_eb_info_global(), libMesh::Nemesis_IO_Helper::get_elem_cmap(), libMesh::Nemesis_IO_Helper::get_elem_map(), libMesh::MeshBase::get_info(), libMesh::Nemesis_IO_Helper::get_init_global(), libMesh::Nemesis_IO_Helper::get_init_info(), libMesh::RBEIMEvaluation::get_interior_basis_functions_as_vecs(), libMesh::Nemesis_IO_Helper::get_loadbal_param(), libMesh::DofMap::get_local_constraints(), libMesh::MeshBase::get_local_constraints(), libMesh::Nemesis_IO_Helper::get_node_cmap(), libMesh::Nemesis_IO_Helper::get_node_map(), libMesh::Nemesis_IO_Helper::get_ns_param_global(), libMesh::Nemesis_IO_Helper::get_ss_param_global(), libMesh::SparsityPattern::Build::handle_vi_vj(), libMesh::LaplaceMeshSmoother::init(), libMesh::SystemSubsetBySubdomain::init(), HeatSystem::init_data(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::ExodusII_IO_Helper::initialize_element_variables(), libMesh::ExodusII_IO_Helper::initialize_global_variables(), libMesh::ExodusII_IO_Helper::initialize_nodal_variables(), libMesh::DistributedMesh::insert_elem(), libMesh::MeshTools::Modification::interpolate_surface(), libMesh::SparsityPattern::Build::join(), libMesh::RBEvaluation::legacy_write_offline_data_to_files(), libMesh::RBSCMEvaluation::legacy_write_offline_data_to_files(), libMesh::TransientRBEvaluation::legacy_write_offline_data_to_files(), libMesh::MeshTools::libmesh_assert_consistent_distributed(), libMesh::MeshTools::libmesh_assert_consistent_distributed_nodes(), libMesh::MeshTools::libmesh_assert_contiguous_dof_ids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_object_ids(), main(), AugmentSparsityOnInterface::mesh_reinit(), libMesh::TriangulatorInterface::MeshedHole::MeshedHole(), libMesh::MeshBase::n_active_local_elem(), libMesh::BoundaryInfo::n_boundary_conds(), libMesh::MeshTools::n_connected_components(), libMesh::MeshBase::n_constraint_rows(), libMesh::BoundaryInfo::n_edge_conds(), libMesh::DofMapBase::n_local_dofs(), libMesh::MeshBase::n_local_elem(), libMesh::MeshBase::n_local_nodes(), libMesh::BoundaryInfo::n_nodeset_conds(), libMesh::BoundaryInfo::n_shellface_conds(), libMesh::RBEIMEvaluation::node_gather_bfs(), libMesh::DistributedMesh::own_node(), libMesh::BoundaryInfo::parallel_sync_node_ids(), libMesh::BoundaryInfo::parallel_sync_side_ids(), libMesh::MeshBase::print_constraint_rows(), libMesh::DofMap::print_dof_constraints(), libMesh::DofMap::process_mesh_constraint_rows(), libMesh::Nemesis_IO_Helper::put_cmap_params(), libMesh::Nemesis_IO_Helper::put_elem_cmap(), libMesh::Nemesis_IO_Helper::put_elem_map(), libMesh::Nemesis_IO_Helper::put_loadbal_param(), libMesh::Nemesis_IO_Helper::put_node_cmap(), libMesh::Nemesis_IO_Helper::put_node_map(), libMesh::XdrIO::read(), libMesh::Nemesis_IO::read(), libMesh::CheckpointIO::read(), libMesh::NameBasedIO::read(), libMesh::EquationSystems::read(), libMesh::EquationSystems::read(), libMesh::ExodusII_IO_Helper::read_elem_num_map(), libMesh::ExodusII_IO_Helper::read_global_values(), libMesh::CheckpointIO::read_header(), libMesh::ExodusII_IO::read_header(), libMesh::System::read_header(), libMesh::XdrIO::read_header(), libMesh::DynaIO::read_mesh(), libMesh::ExodusII_IO_Helper::read_node_num_map(), libMesh::System::read_parallel_data(), libMesh::RBConstruction::read_riesz_representors_from_files(), libMesh::TransientRBConstruction::read_riesz_representors_from_files(), libMesh::System::read_SCALAR_dofs(), libMesh::XdrIO::read_serialized_bc_names(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::System::read_serialized_data(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::System::read_serialized_vector(), libMesh::System::read_serialized_vectors(), libMesh::Nemesis_IO_Helper::read_var_names_impl(), libMesh::SimplexRefiner::refine_via_edges(), libMesh::SimplexRefiner::refine_via_edges(), libMesh::StaticCondensationDofMap::reinit(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::DistributedMesh::renumber_nodes_and_elements(), libMesh::DofMap::scatter_constraints(), libMesh::CheckpointIO::select_split_config(), libMesh::DistributedMesh::set_next_unique_id(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::PetscDMWrapper::set_point_range_in_section(), libMesh::RBEIMEvaluation::side_gather_bfs(), MeshFunctionTest::test_bad_gradient_var_with_out_of_mesh_value(), MeshFunctionTest::test_bad_hessian_var_with_out_of_mesh_value(), ExodusTest< elem_type >::test_read_gold(), ExodusTest< elem_type >::test_write(), ExodusC0PolyhedronTest::test_write_and_read_hexagonal_prism(), ExodusC0PolygonTest::test_write_and_read_pentagon(), MeshInputTest::testAbaqusRead(), MeshInputTest::testBadGmsh(), BoundaryInfoTest::testBoundaryIDs(), MeshInputTest::testCopyElementSolutionImpl(), MeshInputTest::testCopyElementVectorImpl(), MeshInputTest::testCopyNodalSolutionImpl(), DefaultCouplingTest::testCoupling(), PointNeighborCouplingTest::testCoupling(), MeshInputTest::testDynaFileMappings(), MeshInputTest::testDynaNoSplines(), MeshInputTest::testDynaReadElem(), MeshInputTest::testDynaReadPatch(), MeshInputTest::testExodusFileMappings(), MeshInputTest::testExodusIGASidesets(), MeshInputTest::testExodusWriteElementDataFromDiscontinuousNodalData(), MeshInputTest::testGmshBCIDOverlap(), MeshInputTest::testGoodGmsh(), MeshInputTest::testGoodSTL(), MeshInputTest::testGoodSTLBinary(), BoundaryInfoTest::testInternalBoundary(), MeshInputTest::testLowOrderEdgeBlocks(), BoundaryMeshSubdomainTest::testPerBoundarySubdomain(), SystemsTest::testProjectMatrix3D(), BoundaryInfoTest::testShellFaceConstraints(), MeshInputTest::testSingleElementImpl(), BoundaryMeshSubdomainTest::testSingleSubdomain(), WriteVecAndScalar::testSolution(), CheckpointIOTest::testSplitter(), MeshInputTest::testTetgenIO(), MeshSmootherTest::testVariationalSmoother(), libMesh::MeshTools::total_weight(), libMesh::NetGenMeshInterface::triangulate(), libMesh::Parallel::Packing< Elem * >::unpack(), libMesh::Parallel::Packing< Node * >::unpack(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::DTKAdapter::update_variable_values(), libMesh::MeshTools::volume(), libMesh::STLIO::write(), libMesh::XdrIO::write(), libMesh::NameBasedIO::write(), libMesh::CheckpointIO::write(), libMesh::EquationSystems::write(), libMesh::EquationSystems::write(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::ExodusII_IO::write_element_data(), libMesh::ExodusII_IO::write_element_data_from_discontinuous_nodal_data(), libMesh::ExodusII_IO_Helper::write_element_values(), libMesh::ExodusII_IO_Helper::write_element_values_element_major(), libMesh::ExodusII_IO_Helper::write_elements(), libMesh::ExodusII_IO_Helper::write_elemset_data(), libMesh::ExodusII_IO_Helper::write_elemsets(), libMesh::ExodusII_IO::write_global_data(), libMesh::ExodusII_IO_Helper::write_global_values(), libMesh::System::write_header(), libMesh::ExodusII_IO::write_information_records(), libMesh::ExodusII_IO_Helper::write_information_records(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates(), libMesh::ExodusII_IO::write_nodal_data(), libMesh::VTKIO::write_nodal_data(), libMesh::UCDIO::write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data_common(), libMesh::ExodusII_IO::write_nodal_data_discontinuous(), libMesh::ExodusII_IO_Helper::write_nodal_values(), libMesh::ExodusII_IO_Helper::write_nodeset_data(), libMesh::ExodusII_IO_Helper::write_nodesets(), libMesh::Nemesis_IO_Helper::write_nodesets(), libMesh::RBEIMEvaluation::write_out_interior_basis_functions(), libMesh::RBEIMEvaluation::write_out_node_basis_functions(), libMesh::RBEIMEvaluation::write_out_side_basis_functions(), write_output_solvedata(), libMesh::System::write_parallel_data(), libMesh::RBConstruction::write_riesz_representors_to_files(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bc_names(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::System::write_serialized_data(), libMesh::XdrIO::write_serialized_nodes(), libMesh::XdrIO::write_serialized_nodesets(), libMesh::XdrIO::write_serialized_subdomain_names(), libMesh::System::write_serialized_vector(), libMesh::System::write_serialized_vectors(), libMesh::ExodusII_IO_Helper::write_sideset_data(), libMesh::ExodusII_IO_Helper::write_sidesets(), libMesh::Nemesis_IO_Helper::write_sidesets(), libMesh::ExodusII_IO::write_timestep(), libMesh::ExodusII_IO_Helper::write_timestep(), and libMesh::ExodusII_IO::write_timestep_discontinuous().

reuse_preconditioner()

template<typename T >

bool libMesh::PetscNonlinearSolver< T >::reuse_preconditioner ( ) const

overridevirtual

Getter for preconditioner reuse.

Reimplemented from libMesh::NonlinearSolver< T >.

Definition at line 1176 of file petsc_nonlinear_solver.C.

{
  return this->_reuse_preconditioner;
}

reuse_preconditioner_max_linear_its()

template<typename T >

unsigned int libMesh::PetscNonlinearSolver< T >::reuse_preconditioner_max_linear_its ( ) const

overridevirtual

Getter for the maximum iterations flag for preconditioner reuse.

Reimplemented from libMesh::NonlinearSolver< T >.

Definition at line 1182 of file petsc_nonlinear_solver.C.

{
  return this->_reuse_preconditioner_max_linear_its;
}

set_computing_base_vector()

template<typename T >

void libMesh::PetscNonlinearSolver< T >::set_computing_base_vector ( bool  computing_base_vector )

inline

Set whether we are computing the base vector for matrix-free finite-differencing.

Definition at line 177 of file petsc_nonlinear_solver.h.

{ _computing_base_vector = computing_base_vector; }

References libMesh::PetscNonlinearSolver< T >::_computing_base_vector, and libMesh::PetscNonlinearSolver< T >::computing_base_vector().

Referenced by libMesh::libmesh_petsc_snes_mffd_interface().

set_exact_constraint_enforcement()

template<typename T >

virtual void libMesh::NonlinearSolver< T >::set_exact_constraint_enforcement ( bool  enable )

inlinevirtualinherited

Enable (or disable; it is true by default) exact enforcement of constraints at the solver level, correcting any constrained DoF coefficients in current_local_solution as well as applying nonlinear residual and Jacobian terms based on constraint equations.

This is probably only safe to disable if user code is setting nonlinear residual and Jacobian terms based on constraint equations at an element-by-element level, by combining the asymmetric_constraint_rows option with the residual_constrain_element_vector processing option in DofMap.

Definition at line 398 of file nonlinear_solver.h.

  {
    _exact_constraint_enforcement = enable;
  }

References libMesh::NonlinearSolver< T >::_exact_constraint_enforcement.

set_jacobian_zero_out()

template<typename T >

void libMesh::PetscNonlinearSolver< T >::set_jacobian_zero_out ( bool  state )

inline

Set if the jacobian should be zeroed out in the callback.

Definition at line 156 of file petsc_nonlinear_solver.h.

{ _zero_out_jacobian = state; }

References libMesh::PetscNonlinearSolver< T >::_zero_out_jacobian.

set_residual_zero_out()

template<typename T >

void libMesh::PetscNonlinearSolver< T >::set_residual_zero_out ( bool  state )

inline

Set if the residual should be zeroed out in the callback.

Definition at line 151 of file petsc_nonlinear_solver.h.

{ _zero_out_residual = state; }

References libMesh::PetscNonlinearSolver< T >::_zero_out_residual.

set_reuse_preconditioner()

template<typename T >

void libMesh::NonlinearSolver< T >::set_reuse_preconditioner ( bool  reuse )

virtualinherited

Set the reuse preconditioner flag.

Definition at line 94 of file nonlinear_solver.C.

{
  _reuse_preconditioner = reuse;
}

set_reuse_preconditioner_max_linear_its()

template<typename T >

void libMesh::NonlinearSolver< T >::set_reuse_preconditioner_max_linear_its ( unsigned int  i )

virtualinherited

Set the reuse_preconditioner_max_linear_its parameter.

Definition at line 106 of file nonlinear_solver.C.

{
  _reuse_preconditioner_max_linear_its = i;
}

set_snesmf_reuse_base()

template<typename T >

void libMesh::PetscNonlinearSolver< T >::set_snesmf_reuse_base ( bool  state )

inline

Set to true to let PETSc reuse the base vector.

Definition at line 166 of file petsc_nonlinear_solver.h.

{ _snesmf_reuse_base = state; }

References libMesh::PetscNonlinearSolver< T >::_snesmf_reuse_base.

set_solver_configuration()

template<typename T >

void libMesh::NonlinearSolver< T >::set_solver_configuration ( SolverConfiguration &  solver_configuration )

inherited

Set the solver configuration object.

Definition at line 82 of file nonlinear_solver.C.

{
  _solver_configuration = &solver_configuration;
}

setup_default_monitor()

template<typename T >

void libMesh::PetscNonlinearSolver< T >::setup_default_monitor

(

)

Setup the default monitor if required.

Definition at line 1168 of file petsc_nonlinear_solver.C.

{
  if (_default_monitor)
    LibmeshPetscCall(
      SNESMonitorSet(_snes, libmesh_petsc_snes_monitor, this, LIBMESH_PETSC_NULLPTR));
}

References libMesh::libmesh_petsc_snes_monitor().

snes()

template<typename T >

SNES libMesh::PetscNonlinearSolver< T >::snes

(

const char *

name = nullptr

)

Returns

The raw PETSc snes context pointer. This method calls init() so in that vein, we have an optional name prefix argument that if provided will be given to the SNES context

Definition at line 837 of file petsc_nonlinear_solver.C.

{
  this->init(name);
  return _snes;
}

Referenced by libMesh::libmesh_petsc_snes_mffd_interface().

snes_mf_reuse_base()

template<typename T >

bool libMesh::PetscNonlinearSolver< T >::snes_mf_reuse_base ( ) const

inline

Returns

Whether we are reusing the nonlinear function evaluation as the base for doing matrix-free approximation of the Jacobian action

Definition at line 172 of file petsc_nonlinear_solver.h.

{ return _snesmf_reuse_base; }

References libMesh::PetscNonlinearSolver< T >::_snesmf_reuse_base.

Referenced by libMesh::libmesh_petsc_snes_mffd_interface().

solve()

template<typename T >

std::pair< unsigned int, Real > libMesh::PetscNonlinearSolver< T >::solve ( SparseMatrix< T > &  pre_in, NumericVector< T > &  x_in, NumericVector< T > &  r_in, const double  , const unsigned int    )

overridevirtual

Call the Petsc solver.

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

Implements libMesh::NonlinearSolver< T >.

Definition at line 901 of file petsc_nonlinear_solver.C.

{
  parallel_object_only();
 
  LOG_SCOPE("solve()", "PetscNonlinearSolver");
  this->init ();
 
  // Make sure the data passed in are really of Petsc types
  PetscMatrixBase<T> * pre = cast_ptr<PetscMatrixBase<T> *>(&pre_in);
  PetscVector<T> * x   = cast_ptr<PetscVector<T> *>(&x_in);
  PetscVector<T> * r   = cast_ptr<PetscVector<T> *>(&r_in);
 
  PetscInt n_iterations =0;
  // Should actually be a PetscReal, but I don't know which version of PETSc first introduced PetscReal
  Real final_residual_norm=0.;
 
  // We don't want to do this twice because it resets
  // SNESSetLagPreconditioner
  if ((reuse_preconditioner()) && (!_setup_reuse))
    {
      _setup_reuse = true;
      LibmeshPetscCall(SNESSetLagPreconditionerPersists(_snes, PETSC_TRUE));
      // According to the PETSC 3.16.5 docs -2 is a magic number which
      // means "recalculate the next time you need it and then not again"
      LibmeshPetscCall(SNESSetLagPreconditioner(_snes, -2));
      // Add in our callback which will trigger recalculating
      // the preconditioner when we hit reuse_preconditioner_max_linear_its
      LibmeshPetscCall(SNESMonitorSet(_snes, &libmesh_petsc_recalculate_monitor,
                                      this,
                                      NULL));
    }
  else if (!(reuse_preconditioner()))
    // This covers the case where it was enabled but was then disabled
    {
      LibmeshPetscCall(SNESSetLagPreconditionerPersists(_snes, PETSC_FALSE));
      if (_setup_reuse)
        {
          _setup_reuse = false;
          LibmeshPetscCall(SNESMonitorCancel(_snes));
          // Readd default monitor
          setup_default_monitor();
        }
    }
 
  LibmeshPetscCall(SNESSetFunction (_snes, r->vec(), libmesh_petsc_snes_residual, this));
 
  // Only set the jacobian function if we've been provided with something to call.
  // This allows a user to set their own jacobian function if they want to
  if (this->jacobian || this->jacobian_object || this->residual_and_jacobian_object)
    LibmeshPetscCall(SNESSetJacobian (_snes, pre->mat(), pre->mat(), libmesh_petsc_snes_jacobian, this));
 
  // Have the Krylov subspace method use our good initial guess rather than 0
  KSP ksp;
  LibmeshPetscCall(SNESGetKSP (_snes, &ksp));
 
  // Set the tolerances for the iterative solver.  Use the user-supplied
  // tolerance for the relative residual & leave the others at default values
  LibmeshPetscCall(KSPSetTolerances (ksp, this->initial_linear_tolerance, PETSC_DEFAULT,
                                     PETSC_DEFAULT, this->max_linear_iterations));
 
  // Set the tolerances for the non-linear solver.
  LibmeshPetscCall(SNESSetTolerances(_snes,
                                     this->absolute_residual_tolerance,
                                     this->relative_residual_tolerance,
                                     this->relative_step_tolerance,
                                     this->max_nonlinear_iterations,
                                     this->max_function_evaluations));
 
  // Not supported by PETSc
  if (this->absolute_step_tolerance != 0) // 0 is default value, both in MOOSE and libMesh
    libmesh_warning("Setting the absolute step tolerance is not supported with the PETSc nonlinear solver.");
 
  // Set the divergence tolerance for the non-linear solver
#if !PETSC_VERSION_LESS_THAN(3,8,0)
  LibmeshPetscCall(SNESSetDivergenceTolerance(_snes, this->divergence_tolerance));
#endif
 
  //Pull in command-line options
#if PETSC_VERSION_LESS_THAN(3,7,0)
  LibmeshPetscCall(KSPSetFromOptions(ksp));
#endif
  LibmeshPetscCall(SNESSetFromOptions(_snes));
 
  PC pc;
  LibmeshPetscCall(KSPGetPC(ksp, &pc));
  PetscPreconditioner<T>::set_petsc_aux_data(pc, this->system());
 
#if defined(LIBMESH_HAVE_PETSC_HYPRE) && PETSC_VERSION_LESS_THAN(3, 23, 0) &&                      \
    !PETSC_VERSION_LESS_THAN(3, 12, 0) && defined(PETSC_HAVE_HYPRE_DEVICE)
  {
    // Make sure hypre has been initialized
    LibmeshPetscCallExternal(HYPRE_Initialize);
    PetscScalar * dummyarray;
    PetscMemType mtype;
    LibmeshPetscCall(VecGetArrayAndMemType(x->vec(), &dummyarray, &mtype));
    LibmeshPetscCall(VecRestoreArrayAndMemType(x->vec(), &dummyarray));
    if (PetscMemTypeHost(mtype))
      LibmeshPetscCallExternal(HYPRE_SetMemoryLocation, HYPRE_MEMORY_HOST);
  }
#endif
 
  if (this->user_presolve)
    this->user_presolve(this->system());
 
  //Set the preconditioning matrix
  if (this->_preconditioner)
    {
      this->_preconditioner->set_matrix(pre_in);
      this->_preconditioner->init();
    }
 
  // If the SolverConfiguration object is provided, use it to override
  // solver options.
  if (this->_solver_configuration)
    this->_solver_configuration->configure_solver();
 
  // In PETSc versions before 3.5.0, it is not possible to call
  // SNESSetUp() before the solution and rhs vectors are initialized, as
  // this triggers the
  //
  // "Solution vector cannot be right hand side vector!"
  //
  // error message. It is also not possible to call SNESSetSolution()
  // in those versions of PETSc to work around the problem, since that
  // API was removed in 3.0.0 and only restored in 3.6.0. The
  // overzealous check was moved out of SNESSetUp in PETSc 3.5.0
  // (petsc/petsc@154060b), so this code block should be safe to use
  // in 3.5.0 and later.
#if !PETSC_VERSION_LESS_THAN(3,6,0)
  LibmeshPetscCall(SNESSetSolution(_snes, x->vec()));
#endif
  LibmeshPetscCall(SNESSetUp(_snes));
 
  Mat J, P;
  LibmeshPetscCall(SNESGetJacobian(_snes, &J, &P,
                                   LIBMESH_PETSC_NULLPTR,
                                   LIBMESH_PETSC_NULLPTR));
  LibmeshPetscCall(MatMFFDSetFunction(J, libmesh_petsc_snes_mffd_interface, this));
#if !PETSC_VERSION_LESS_THAN(3,8,4)
#ifndef NDEBUG
  // If we're in debug mode, do not reuse the nonlinear function evaluation as the base for doing
  // matrix-free approximations of the Jacobian action. Instead if the user requested that we reuse
  // the base, we'll check the base function evaluation and compare it to the nonlinear residual
  // evaluation. If they are different, then we'll error and inform the user that it's unsafe to
  // reuse the base
  LibmeshPetscCall(MatSNESMFSetReuseBase(J, PETSC_FALSE));
#else
  // Resue the residual vector from SNES
  LibmeshPetscCall(MatSNESMFSetReuseBase(J, static_cast<PetscBool>(_snesmf_reuse_base)));
#endif
#endif
 
  // Only set the nullspace if we have a way of computing it and the result is non-empty.
  if (this->nullspace || this->nullspace_object)
    {
      WrappedPetsc<MatNullSpace> msp;
      this->build_mat_null_space(this->nullspace_object, this->nullspace, msp.get());
      if (msp)
        {
          LibmeshPetscCall(MatSetNullSpace(J, msp));
          if (P != J)
            LibmeshPetscCall(MatSetNullSpace(P, msp));
        }
    }
 
  // Only set the transpose nullspace if we have a way of computing it and the result is non-empty.
  if (this->transpose_nullspace || this->transpose_nullspace_object)
    {
#if PETSC_VERSION_LESS_THAN(3,6,0)
      libmesh_warning("MatSetTransposeNullSpace is only supported for PETSc >= 3.6, transpose nullspace will be ignored.");
#else
      WrappedPetsc<MatNullSpace> msp;
      this->build_mat_null_space(this->transpose_nullspace_object, this->transpose_nullspace, msp.get());
      if (msp)
        {
          LibmeshPetscCall(MatSetTransposeNullSpace(J, msp));
          if (P != J)
            LibmeshPetscCall(MatSetTransposeNullSpace(P, msp));
        }
#endif
    }
 
  // Only set the nearnullspace if we have a way of computing it and the result is non-empty.
  if (this->nearnullspace || this->nearnullspace_object)
    {
      WrappedPetsc<MatNullSpace> msp;
      this->build_mat_null_space(this->nearnullspace_object, this->nearnullspace, msp.get());
 
      if (msp)
        {
          LibmeshPetscCall(MatSetNearNullSpace(J, msp));
          if (P != J)
            LibmeshPetscCall(MatSetNearNullSpace(P, msp));
        }
    }
 
  SNESLineSearch linesearch;
  if (linesearch_object)
  {
    LibmeshPetscCall(SNESGetLineSearch(_snes, &linesearch));
    LibmeshPetscCall(SNESLineSearchSetType(linesearch, SNESLINESEARCHSHELL));
#if PETSC_RELEASE_GREATER_EQUALS(3, 21, 0)
    LibmeshPetscCall(SNESLineSearchShellSetApply(linesearch, libmesh_petsc_linesearch_shellfunc, this));
#else
    LibmeshPetscCall(SNESLineSearchShellSetUserFunc(linesearch, libmesh_petsc_linesearch_shellfunc, this));
#endif
  }
 
  LibmeshPetscCall(SNESSolve (_snes, LIBMESH_PETSC_NULLPTR, x->vec()));
 
  LibmeshPetscCall(SNESGetIterationNumber(_snes, &n_iterations));
 
  LibmeshPetscCall(SNESGetLinearSolveIterations(_snes, &_n_linear_iterations));
 
  // SNESGetFunction has been around forever and should work on all
  // versions of PETSc.  This is also now the recommended approach
  // according to the documentation for the PETSc 3.5.1 release:
  // http://www.mcs.anl.gov/petsc/documentation/changes/35.html
  Vec f;
  LibmeshPetscCall(SNESGetFunction(_snes, &f, 0, 0));
  LibmeshPetscCall(VecNorm(f, NORM_2, pPR(&final_residual_norm)));
 
  // Get and store the reason for convergence
  LibmeshPetscCall(SNESGetConvergedReason(_snes, &_reason));
 
  //Based on Petsc 2.3.3 documentation all diverged reasons are negative
  this->converged = (_reason >= 0);
 
  // Reset data structure
  this->clear();
 
  // return the # of its. and the final residual norm.
  return std::make_pair(n_iterations, final_residual_norm);
}

References libMesh::WrappedPetsc< T >::get(), libMesh::libmesh_petsc_linesearch_shellfunc(), libMesh::libmesh_petsc_recalculate_monitor(), libMesh::libmesh_petsc_snes_jacobian(), libMesh::libmesh_petsc_snes_mffd_interface(), libMesh::libmesh_petsc_snes_residual(), libMesh::PetscMatrixBase< T >::mat(), libMesh::pPR(), libMesh::Real, and libMesh::PetscPreconditioner< T >::set_petsc_aux_data().

system() [1/2]

template<typename T >

sys_type & libMesh::NonlinearSolver< T >::system ( )

inlineinherited

Returns

A writable reference to the system we are solving.

Definition at line 278 of file nonlinear_solver.h.

{ return _system; }

References libMesh::NonlinearSolver< T >::_system.

system() [2/2]

template<typename T >

const sys_type & libMesh::NonlinearSolver< T >::system ( ) const

inlineinherited

Returns

A constant reference to the system we are solving.

Definition at line 273 of file nonlinear_solver.h.

{ return _system; }

References libMesh::NonlinearSolver< T >::_system.

Referenced by libMesh::Problem_Interface::computeJacobian(), libMesh::Problem_Interface::computePreconditioner(), libMesh::libmesh_petsc_snes_postcheck(), and libMesh::NoxNonlinearSolver< Number >::solve().

use_default_monitor()

template<typename T >

void libMesh::PetscNonlinearSolver< T >::use_default_monitor ( bool  state )

inline

Set to true to use the libMesh's default monitor, set to false to use your own.

Definition at line 161 of file petsc_nonlinear_solver.h.

{ _default_monitor = state; }

References libMesh::PetscNonlinearSolver< T >::_default_monitor.

Friends And Related Symbol Documentation

libmesh_petsc_snes_fd_residual

template<typename T >

PetscErrorCode libmesh_petsc_snes_fd_residual ( SNES  snes, Vec  x, Vec  r, void *  ctx  )

friend

Definition at line 232 of file petsc_nonlinear_solver.C.

  {
    PetscFunctionBegin;
 
    ResidualContext rc = libmesh_petsc_snes_residual_helper(snes, x, ctx);
 
    libmesh_parallel_only(rc.sys.comm());
 
    libmesh_assert(r);
    PetscVector<Number> R(r, rc.sys.comm());
 
    if (rc.solver->_zero_out_residual)
      R.zero();
 
    if (rc.solver->fd_residual_object != nullptr)
      rc.solver->fd_residual_object->residual(*rc.sys.current_local_solution.get(), R, rc.sys);
 
    else if (rc.solver->residual_object != nullptr)
      rc.solver->residual_object->residual(*rc.sys.current_local_solution.get(), R, rc.sys);
 
    else
      libmesh_error_msg("Error! Unable to compute residual for forming finite difference Jacobian!");
 
    // Synchronize PETSc x to local solution since the local solution may be changed due to the constraints
    PetscVector<Number> & X_sys = *cast_ptr<PetscVector<Number> *>(rc.sys.solution.get());
    PetscVector<Number> X_global(x, rc.sys.comm());
 
    X_global.swap(X_sys);
    rc.sys.update();
    X_global.swap(X_sys);
 
    R.close();
 
    if (rc.solver->_exact_constraint_enforcement)
      {
        rc.sys.get_dof_map().enforce_constraints_on_residual(rc.sys, &R, rc.sys.current_local_solution.get());
        R.close();
      }
 
    PetscFunctionReturn(LIBMESH_PETSC_SUCCESS);
  }

libmesh_petsc_snes_jacobian

template<typename T >

PetscErrorCode libmesh_petsc_snes_jacobian ( SNES  snes, Vec  x, Mat  jac, Mat  pc, void *  ctx  )

friend

Definition at line 401 of file petsc_nonlinear_solver.C.

  {
    PetscFunctionBegin;
 
    LOG_SCOPE("jacobian()", "PetscNonlinearSolver");
 
    libmesh_assert(ctx);
 
    // No way to safety-check this cast, since we got a void *...
    PetscNonlinearSolver<Number> * solver =
      static_cast<PetscNonlinearSolver<Number> *> (ctx);
 
    libmesh_parallel_only(solver->comm());
 
    // Get the current iteration number from the snes object,
    // store it in the PetscNonlinearSolver object for possible use
    // by the user's Jacobian function.
    {
      PetscInt n_iterations = 0;
      LibmeshPetscCall2(solver->comm(), SNESGetIterationNumber(snes, &n_iterations));
      solver->_current_nonlinear_iteration_number = cast_int<unsigned>(n_iterations);
    }
 
    //-----------------------------------------------------------------------------
    // if the user has provided both function pointers and objects only the pointer
    // will be used, so catch that as an error
    libmesh_error_msg_if(solver->jacobian && solver->jacobian_object,
                         "ERROR: cannot specify both a function and object to compute the Jacobian!");
 
    libmesh_error_msg_if(solver->matvec && solver->residual_and_jacobian_object,
                         "ERROR: cannot specify both a function and object to compute the combined Residual & Jacobian!");
 
    NonlinearImplicitSystem & sys = solver->system();
 
    PetscMatrixBase<Number> * const PC = pc ? PetscMatrixBase<Number>::get_context(pc, sys.comm()) : nullptr;
    PetscMatrixBase<Number> * Jac = jac ? PetscMatrixBase<Number>::get_context(jac, sys.comm()) : nullptr;
    PetscVector<Number> & X_sys = *cast_ptr<PetscVector<Number> *>(sys.solution.get());
    PetscVector<Number> X_global(x, sys.comm());
 
    PetscMFFDMatrix<Number> mffd_jac(sys.comm());
    PetscBool p_is_shell = PETSC_FALSE;
    PetscBool j_is_mffd = PETSC_FALSE;
    PetscBool j_is_shell = PETSC_FALSE;
    if (pc)
      LibmeshPetscCall2(sys.comm(), PetscObjectTypeCompare((PetscObject)pc, MATSHELL, &p_is_shell));
    libmesh_assert(jac);
    LibmeshPetscCall2(sys.comm(), PetscObjectTypeCompare((PetscObject)jac, MATMFFD, &j_is_mffd));
    LibmeshPetscCall2(sys.comm(), PetscObjectTypeCompare((PetscObject)jac, MATSHELL, &j_is_shell));
    if (j_is_mffd == PETSC_TRUE)
      {
        libmesh_assert(!Jac);
        Jac = &mffd_jac;
        mffd_jac = jac;
      }
 
    // We already computed the Jacobian during the residual evaluation
    if (solver->residual_and_jacobian_object)
    {
      // We could be doing matrix-free in which case we cannot rely on closing of explicit matrices
      // that occurs during the PETSc residual callback
      if ((j_is_shell == PETSC_TRUE) || (j_is_mffd == PETSC_TRUE))
        Jac->close();
 
      if (pc && (p_is_shell == PETSC_TRUE))
        PC->close();
 
      PetscFunctionReturn(LIBMESH_PETSC_SUCCESS);
    }
 
    // Set the dof maps
    PC->attach_dof_map(sys.get_dof_map());
    Jac->attach_dof_map(sys.get_dof_map());
 
    // Use the systems update() to get a good local version of the parallel solution
    X_global.swap(X_sys);
    sys.update();
    X_global.swap(X_sys);
 
    // Enforce constraints (if any) exactly on the
    // current_local_solution.  This is the solution vector that is
    // actually used in the computation of the residual below, and is
    // not locked by debug-enabled PETSc the way that "x" is.
    if (solver->_exact_constraint_enforcement)
      sys.get_dof_map().enforce_constraints_exactly(sys, sys.current_local_solution.get());
 
    if (solver->_zero_out_jacobian)
      PC->zero();
 
 
    if (solver->jacobian != nullptr)
      solver->jacobian(*sys.current_local_solution.get(), *PC, sys);
 
    else if (solver->jacobian_object != nullptr)
      solver->jacobian_object->jacobian(*sys.current_local_solution.get(), *PC, sys);
 
    else if (solver->matvec != nullptr)
      solver->matvec(*sys.current_local_solution.get(), nullptr, PC, sys);
 
    else
      libmesh_error_msg("Error! Unable to compute residual and/or Jacobian!");
 
    PC->close();
    if (solver->_exact_constraint_enforcement)
      {
        sys.get_dof_map().enforce_constraints_on_jacobian(sys, PC);
        PC->close();
      }
 
    if (Jac != PC)
      {
        // Assume that shells know what they're doing
        libmesh_assert(!solver->_exact_constraint_enforcement || (j_is_mffd == PETSC_TRUE) ||
                       (j_is_shell == PETSC_TRUE));
        Jac->close();
      }
 
    PetscFunctionReturn(LIBMESH_PETSC_SUCCESS);
  }

libmesh_petsc_snes_mffd_residual

template<typename T >

PetscErrorCode libmesh_petsc_snes_mffd_residual ( SNES  snes, Vec  x, Vec  r, void *  ctx  )

friend

Definition at line 278 of file petsc_nonlinear_solver.C.

  {
    PetscFunctionBegin;
 
    ResidualContext rc = libmesh_petsc_snes_residual_helper(snes, x, ctx);
 
    libmesh_parallel_only(rc.sys.comm());
 
    libmesh_assert(r);
    PetscVector<Number> R(r, rc.sys.comm());
 
    if (rc.solver->_zero_out_residual)
      R.zero();
 
    if (rc.solver->mffd_residual_object != nullptr)
      rc.solver->mffd_residual_object->residual(*rc.sys.current_local_solution.get(), R, rc.sys);
 
    else if (rc.solver->residual_object != nullptr)
      rc.solver->residual_object->residual(*rc.sys.current_local_solution.get(), R, rc.sys);
 
    else
      libmesh_error_msg("Error! Unable to compute residual for forming finite differenced"
                        "Jacobian-vector products!");
 
    // Synchronize PETSc x to local solution since the local solution may be changed due to the constraints
    PetscVector<Number> & X_sys = *cast_ptr<PetscVector<Number> *>(rc.sys.solution.get());
    PetscVector<Number> X_global(x, rc.sys.comm());
 
    X_global.swap(X_sys);
    rc.sys.update();
    X_global.swap(X_sys);
 
    R.close();
 
    if (rc.solver->_exact_constraint_enforcement)
      {
        rc.sys.get_dof_map().enforce_constraints_on_residual(rc.sys, &R, rc.sys.current_local_solution.get());
        R.close();
      }
 
    PetscFunctionReturn(LIBMESH_PETSC_SUCCESS);
  }

libmesh_petsc_snes_precheck

template<typename T >

PetscErrorCode libmesh_petsc_snes_precheck ( SNESLineSearch  , Vec  X, Vec  Y, PetscBool *  changed, void *  context  )

friend

Definition at line 622 of file petsc_nonlinear_solver.C.

  {
    PetscFunctionBegin;
 
    LOG_SCOPE("precheck()", "PetscNonlinearSolver");
 
    // PETSc almost certainly initializes these to false already, but
    // it doesn't hurt to be explicit.
    *changed = PETSC_FALSE;
 
    libmesh_assert(context);
 
    // Cast the context to a NonlinearSolver object.
    PetscNonlinearSolver<Number> * solver =
      static_cast<PetscNonlinearSolver<Number> *> (context);
 
    libmesh_parallel_only(solver->comm());
 
    // It's possible that we don't need to do anything at all, in
    // that case return early...
    if (!solver->precheck_object)
      PetscFunctionReturn(LIBMESH_PETSC_SUCCESS);
 
    // The user sets these flags in his/her postcheck function to
    // indicate whether they changed something.
    bool
      petsc_changed = false;
 
    auto & sys = solver->system();
    auto & x_sys = *cast_ptr<PetscVector<Number> *>(sys.solution.get());
    PetscVector<Number> petsc_x(X, sys.comm());
    PetscVector<Number> petsc_y(Y, sys.comm());
 
    // Use the systems update() to get a good local version of the parallel solution
    petsc_x.swap(x_sys);
    sys.update();
    petsc_x.swap(x_sys);
 
    // Enforce constraints (if any) exactly on the
    // current_local_solution.  This is the solution vector that is
    // actually used in the computation of residuals and Jacobians, and is
    // not locked by debug-enabled PETSc the way that "x" is.
    libmesh_assert(sys.current_local_solution.get());
    auto & local_soln = *sys.current_local_solution.get();
    if (solver->_exact_constraint_enforcement)
      sys.get_dof_map().enforce_constraints_exactly(sys, &local_soln);
 
    solver->precheck_object->precheck(local_soln,
                                      petsc_y,
                                      petsc_changed,
                                      sys);
 
    // Record whether the user changed the solution or the search direction.
    if (petsc_changed)
      *changed = PETSC_TRUE;
 
    PetscFunctionReturn(LIBMESH_PETSC_SUCCESS);
  }

libmesh_petsc_snes_residual

template<typename T >

PetscErrorCode libmesh_petsc_snes_residual ( SNES  snes, Vec  x, Vec  r, void *  ctx  )

friend

Definition at line 156 of file petsc_nonlinear_solver.C.

  {
    PetscFunctionBegin;
 
    ResidualContext rc = libmesh_petsc_snes_residual_helper(snes, x, ctx);
 
    libmesh_parallel_only(rc.sys.comm());
 
    libmesh_assert(r);
    PetscVector<Number> R(r, rc.sys.comm());
 
    if (rc.solver->_zero_out_residual)
      R.zero();
 
    //-----------------------------------------------------------------------------
    // if the user has provided both function pointers and objects only the pointer
    // will be used, so catch that as an error
    libmesh_error_msg_if(rc.solver->residual && rc.solver->residual_object,
                         "ERROR: cannot specify both a function and object to compute the Residual!");
 
    libmesh_error_msg_if(rc.solver->matvec && rc.solver->residual_and_jacobian_object,
                         "ERROR: cannot specify both a function and object to compute the combined Residual & Jacobian!");
 
    if (rc.solver->residual != nullptr)
      rc.solver->residual(*rc.sys.current_local_solution.get(), R, rc.sys);
 
    else if (rc.solver->residual_object != nullptr)
      rc.solver->residual_object->residual(*rc.sys.current_local_solution.get(), R, rc.sys);
 
    else if (rc.solver->matvec != nullptr)
      rc.solver->matvec (*rc.sys.current_local_solution.get(), &R, nullptr, rc.sys);
 
    else if (rc.solver->residual_and_jacobian_object != nullptr)
    {
      auto & jac = rc.sys.get_system_matrix();
 
      if (rc.solver->_zero_out_jacobian)
        jac.zero();
 
      rc.solver->residual_and_jacobian_object->residual_and_jacobian(
          *rc.sys.current_local_solution.get(), &R, &jac, rc.sys);
 
      jac.close();
      if (rc.solver->_exact_constraint_enforcement)
        {
          rc.sys.get_dof_map().enforce_constraints_on_jacobian(rc.sys, &jac);
          jac.close();
        }
    }
 
    else
      libmesh_error_msg("Error! Unable to compute residual and/or Jacobian!");
 
 
    // Synchronize PETSc x to local solution since the local solution may be changed due to the constraints
    PetscVector<Number> & X_sys = *cast_ptr<PetscVector<Number> *>(rc.sys.solution.get());
    PetscVector<Number> X_global(x, rc.sys.comm());
 
    X_global.swap(X_sys);
    rc.sys.update();
    X_global.swap(X_sys);
 
    R.close();
 
    if (rc.solver->_exact_constraint_enforcement)
      {
        rc.sys.get_dof_map().enforce_constraints_on_residual(rc.sys, &R, rc.sys.current_local_solution.get());
        R.close();
      }
 
    PetscFunctionReturn(LIBMESH_PETSC_SUCCESS);
  }

libmesh_petsc_snes_residual_helper

template<typename T >

ResidualContext libmesh_petsc_snes_residual_helper ( SNES  snes, Vec  x, void *  ctx  )

friend

Definition at line 57 of file petsc_nonlinear_solver.C.

{
  LOG_SCOPE("residual()", "PetscNonlinearSolver");
 
  libmesh_assert(x);
  libmesh_assert(ctx);
 
  // No way to safety-check this cast, since we got a void *...
  PetscNonlinearSolver<Number> * solver =
    static_cast<PetscNonlinearSolver<Number> *> (ctx);
 
  libmesh_parallel_only(solver->comm());
 
  // Get the current iteration number from the snes object,
  // store it in the PetscNonlinearSolver object for possible use
  // by the user's residual function.
  {
    PetscInt n_iterations = 0;
    LibmeshPetscCall2(solver->comm(), SNESGetIterationNumber(snes, &n_iterations));
    solver->_current_nonlinear_iteration_number = cast_int<unsigned>(n_iterations);
  }
 
  NonlinearImplicitSystem & sys = solver->system();
 
  PetscVector<Number> & X_sys = *cast_ptr<PetscVector<Number> *>(sys.solution.get());
 
  PetscVector<Number> X_global(x, sys.comm());
 
  // Use the system's update() to get a good local version of the
  // parallel solution.  This operation does not modify the incoming
  // "x" vector, it only localizes information from "x" into
  // sys.current_local_solution.
  X_global.swap(X_sys);
  sys.update();
  X_global.swap(X_sys);
 
  // Enforce constraints (if any) exactly on the
  // current_local_solution.  This is the solution vector that is
  // actually used in the computation of the residual below, and is
  // not locked by debug-enabled PETSc the way that "x" is.
  if (solver->_exact_constraint_enforcement)
    sys.get_dof_map().enforce_constraints_exactly(sys, sys.current_local_solution.get());
 
  return ResidualContext(solver, sys);
}

Member Data Documentation

_communicator

const Parallel::Communicator& libMesh::ParallelObject::_communicator

protectedinherited

Definition at line 120 of file parallel_object.h.

Referenced by libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::StaticCondensation::close(), libMesh::ParallelObject::comm(), libMesh::CondensedEigenSystem::initialize_condensed_matrices(), libMesh::ParallelObject::n_processors(), libMesh::ParallelObject::operator=(), libMesh::ParallelObject::processor_id(), libMesh::BoundaryInfo::regenerate_id_sets(), libMesh::StaticCondensationDofMap::reinit(), and libMesh::BoundaryInfo::synchronize_global_id_set().

_computing_base_vector

template<typename T >

bool libMesh::PetscNonlinearSolver< T >::_computing_base_vector

protected

Whether we are computing the base vector for matrix-free finite differencing.

Definition at line 278 of file petsc_nonlinear_solver.h.

Referenced by libMesh::PetscNonlinearSolver< T >::computing_base_vector(), and libMesh::PetscNonlinearSolver< T >::set_computing_base_vector().

_counts

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts

staticprotectedinherited

Actually holds the data.

Definition at line 124 of file reference_counter.h.

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

_current_nonlinear_iteration_number

template<typename T >

unsigned libMesh::PetscNonlinearSolver< T >::_current_nonlinear_iteration_number

protected

Stores the current nonlinear iteration number.

Definition at line 247 of file petsc_nonlinear_solver.h.

Referenced by libMesh::PetscNonlinearSolver< T >::get_current_nonlinear_iteration_number().

_default_monitor

template<typename T >

bool libMesh::PetscNonlinearSolver< T >::_default_monitor

protected

true if we want the default monitor to be set, false for no monitor (i.e.

user code can use their own)

Definition at line 262 of file petsc_nonlinear_solver.h.

Referenced by libMesh::PetscNonlinearSolver< T >::use_default_monitor().

_dm_wrapper

template<typename T >

PetscDMWrapper libMesh::PetscNonlinearSolver< T >::_dm_wrapper

protected

Wrapper object for interacting with the "new" libMesh PETSc DM.

The new libMesh PETSc DM implementation is capable of geometric multigrid while the old implementation is not. The new implementation can be activated from the command line with –use_petsc_dm

Definition at line 291 of file petsc_nonlinear_solver.h.

_enable_print_counter

bool libMesh::ReferenceCounter::_enable_print_counter = true

staticprotectedinherited

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

Definition at line 143 of file reference_counter.h.

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

_exact_constraint_enforcement

template<typename T >

bool libMesh::NonlinearSolver< T >::_exact_constraint_enforcement

protectedinherited

Whether we should enforce exact constraints globally during a solve.

Definition at line 418 of file nonlinear_solver.h.

Referenced by libMesh::Problem_Interface::computeJacobian(), libMesh::NonlinearSolver< T >::exact_constraint_enforcement(), and libMesh::NonlinearSolver< T >::set_exact_constraint_enforcement().

_is_initialized

template<typename T >

bool libMesh::NonlinearSolver< T >::_is_initialized

protectedinherited

Flag indicating if the data structures have been initialized.

Definition at line 433 of file nonlinear_solver.h.

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

_mffd_jac

template<typename T >

PetscMFFDMatrix<Number> libMesh::PetscNonlinearSolver< T >::_mffd_jac

protected

Wrapper for matrix-free finite-difference Jacobians.

Definition at line 295 of file petsc_nonlinear_solver.h.

_mutex

Threads::spin_mutex libMesh::ReferenceCounter::_mutex

staticprotectedinherited

Mutual exclusion object to enable thread-safe reference counting.

Definition at line 137 of file reference_counter.h.

_n_linear_iterations

template<typename T >

PetscInt libMesh::PetscNonlinearSolver< T >::_n_linear_iterations

protected

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

Definition at line 242 of file petsc_nonlinear_solver.h.

_n_objects

Threads::atomic< unsigned int > libMesh::ReferenceCounter::_n_objects

staticprotectedinherited

The number of objects.

Print the reference count information when the number returns to 0.

Definition at line 132 of file reference_counter.h.

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

_preconditioner

template<typename T >

Preconditioner<T>* libMesh::NonlinearSolver< T >::_preconditioner

protectedinherited

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

Definition at line 438 of file nonlinear_solver.h.

_reason

template<typename T >

SNESConvergedReason libMesh::PetscNonlinearSolver< T >::_reason

protected

Store the reason for SNES convergence/divergence for use even after the _snes has been cleared.

Note

print_converged_reason() will always try to get the current reason with SNESGetConvergedReason(), but if the SNES object has already been cleared, it will fall back on this stored value. This value is therefore necessarily not cleared by the clear() function.

Definition at line 237 of file petsc_nonlinear_solver.h.

_reuse_preconditioner

template<typename T >

bool libMesh::NonlinearSolver< T >::_reuse_preconditioner

protectedinherited

Whether we should reuse the linear preconditioner.

Definition at line 412 of file nonlinear_solver.h.

_reuse_preconditioner_max_linear_its

template<typename T >

unsigned int libMesh::NonlinearSolver< T >::_reuse_preconditioner_max_linear_its

protectedinherited

Number of linear iterations to retain the preconditioner.

Definition at line 423 of file nonlinear_solver.h.

_setup_reuse

template<typename T >

bool libMesh::PetscNonlinearSolver< T >::_setup_reuse

protected

Whether we've triggered the preconditioner reuse.

Definition at line 283 of file petsc_nonlinear_solver.h.

_snes

template<typename T >

WrappedPetsc<SNES> libMesh::PetscNonlinearSolver< T >::_snes

protected

Nonlinear solver context.

Definition at line 225 of file petsc_nonlinear_solver.h.

_snesmf_reuse_base

template<typename T >

bool libMesh::PetscNonlinearSolver< T >::_snesmf_reuse_base

protected

True, If we want the base vector to be used for differencing even if the function provided to SNESSetFunction() is not the same as that provided to MatMFFDSetFunction().

https://www.mcs.anl.gov/petsc/petsc-current/docs/manualpages/SNES/MatSNESMFSetReuseBase.html

Definition at line 269 of file petsc_nonlinear_solver.h.

Referenced by libMesh::PetscNonlinearSolver< T >::set_snesmf_reuse_base(), and libMesh::PetscNonlinearSolver< T >::snes_mf_reuse_base().

_solver_configuration

template<typename T >

SolverConfiguration* libMesh::NonlinearSolver< T >::_solver_configuration

protectedinherited

Optionally store a SolverOptions object that can be used to set parameters like solver type, tolerances and iteration limits.

Definition at line 444 of file nonlinear_solver.h.

_system

template<typename T >

sys_type& libMesh::NonlinearSolver< T >::_system

protectedinherited

A reference to the system we are solving.

Definition at line 428 of file nonlinear_solver.h.

Referenced by libMesh::NonlinearSolver< T >::system(), and libMesh::NonlinearSolver< T >::system().

_zero_out_jacobian

template<typename T >

bool libMesh::PetscNonlinearSolver< T >::_zero_out_jacobian

protected

true to zero out jacobian before going into application level call-back, otherwise false

Definition at line 257 of file petsc_nonlinear_solver.h.

Referenced by libMesh::PetscNonlinearSolver< T >::set_jacobian_zero_out().

_zero_out_residual

template<typename T >

bool libMesh::PetscNonlinearSolver< T >::_zero_out_residual

protected

true to zero out residual before going into application level call-back, otherwise false

Definition at line 252 of file petsc_nonlinear_solver.h.

Referenced by libMesh::PetscNonlinearSolver< T >::set_residual_zero_out().

absolute_residual_tolerance

template<typename T >

double 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 305 of file nonlinear_solver.h.

absolute_step_tolerance

template<typename T >

double 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

Not all NonlinearSolvers support relative_step_tolerance!

Definition at line 328 of file nonlinear_solver.h.

bounds

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

bounds_object

template<typename T >

NonlinearImplicitSystem::ComputeBounds* libMesh::NonlinearSolver< T >::bounds_object

inherited

Object that computes the bounds vectors \( XL \) and \( XU \).

Definition at line 196 of file nonlinear_solver.h.

converged

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

divergence_tolerance

template<typename T >

double libMesh::NonlinearSolver< T >::divergence_tolerance

inherited

The NonlinearSolver should exit if the residual becomes greater than the initial residual times the divergence_tolerance.

Users should adjust this tolerances to prevent divergence of the NonlinearSolver.

Definition at line 315 of file nonlinear_solver.h.

fd_residual_object

template<typename T >

NonlinearImplicitSystem::ComputeResidual* libMesh::NonlinearSolver< T >::fd_residual_object

inherited

Object that computes the residual R(X) of the nonlinear system at the input iterate X for the purpose of forming a finite-differenced Jacobian.

Definition at line 143 of file nonlinear_solver.h.

initial_linear_tolerance

template<typename T >

double 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 341 of file nonlinear_solver.h.

jacobian

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

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

jacobian_object

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

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

linesearch_object

template<typename T >

std::unique_ptr<ComputeLineSearchObject> libMesh::PetscNonlinearSolver< T >::linesearch_object

A callable object that can be used to specify a custom line-search.

Definition at line 198 of file petsc_nonlinear_solver.h.

Referenced by libMesh::libmesh_petsc_linesearch_shellfunc().

matvec

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

Either R or J could be nullptr.

Definition at line 173 of file nonlinear_solver.h.

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

max_function_evaluations

template<typename T >

unsigned int libMesh::NonlinearSolver< T >::max_function_evaluations

inherited

Maximum number of function evaluations.

Definition at line 293 of file nonlinear_solver.h.

max_linear_iterations

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

max_nonlinear_iterations

template<typename T >

unsigned int libMesh::NonlinearSolver< T >::max_nonlinear_iterations

inherited

Maximum number of non-linear iterations.

Definition at line 288 of file nonlinear_solver.h.

mffd_residual_object

template<typename T >

NonlinearImplicitSystem::ComputeResidual* libMesh::NonlinearSolver< T >::mffd_residual_object

inherited

Object that computes the residual R(X) of the nonlinear system at the input iterate X for the purpose of forming Jacobian-vector products via finite differencing.

Definition at line 150 of file nonlinear_solver.h.

minimum_linear_tolerance

template<typename T >

double libMesh::NonlinearSolver< T >::minimum_linear_tolerance

inherited

The tolerance for linear solves is kept above this minimum.

Definition at line 346 of file nonlinear_solver.h.

nearnullspace

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

nearnullspace_object

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

nullspace

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

nullspace_object

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

postcheck

template<typename T >

void(* libMesh::NonlinearSolver< T >::postcheck) (const NumericVector< Number > &old_soln, NumericVector< Number > &search_direction, NumericVector< Number > &new_soln, bool &changed_search_direction, bool &changed_new_soln, sys_type &S)

inherited

Function that performs a "check" on the Newton search direction and solution after each nonlinear step.

See documentation for the NonlinearImplicitSystem::ComputePostCheck object for more information about the calling sequence.

Definition at line 254 of file nonlinear_solver.h.

Referenced by libMesh::libmesh_petsc_snes_postcheck().

postcheck_object

template<typename T >

NonlinearImplicitSystem::ComputePostCheck* libMesh::NonlinearSolver< T >::postcheck_object

inherited

A callable object that is executed after each nonlinear iteration.

Allows the user to modify both the search direction and the solution vector in an application-specific way.

Definition at line 266 of file nonlinear_solver.h.

Referenced by libMesh::libmesh_petsc_snes_postcheck().

precheck_object

template<typename T >

NonlinearImplicitSystem::ComputePreCheck* libMesh::NonlinearSolver< T >::precheck_object

inherited

Definition at line 268 of file nonlinear_solver.h.

relative_residual_tolerance

template<typename T >

double libMesh::NonlinearSolver< T >::relative_residual_tolerance

inherited

Definition at line 306 of file nonlinear_solver.h.

relative_step_tolerance

template<typename T >

double libMesh::NonlinearSolver< T >::relative_step_tolerance

inherited

Definition at line 329 of file nonlinear_solver.h.

residual

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

residual_and_jacobian_object

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

Either R or J could be nullptr.

Definition at line 185 of file nonlinear_solver.h.

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

residual_object

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

transpose_nullspace

template<typename T >

void(* libMesh::NonlinearSolver< T >::transpose_nullspace) (std::vector< NumericVector< Number > * > &sp, sys_type &S)

inherited

Function that computes a basis for the transpose Jacobian's nullspace – when solving a degenerate problem iteratively, if the solver supports it (e.g., PETSc's KSP), it is used to remove contributions outside of R(jac)

Definition at line 219 of file nonlinear_solver.h.

transpose_nullspace_object

template<typename T >

NonlinearImplicitSystem::ComputeVectorSubspace* libMesh::NonlinearSolver< T >::transpose_nullspace_object

inherited

A callable object that computes a basis for the transpose Jacobian's nullspace – when solving a degenerate problem iteratively, if the solver supports it (e.g., PETSc's KSP), it is used to remove contributions outside of R(jac)

Definition at line 226 of file nonlinear_solver.h.

user_presolve

template<typename T >

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

inherited

Customizable function pointer which users can attach to the solver.

Gets called prior to every call to solve().

Definition at line 246 of file nonlinear_solver.h.

---

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

• include/solvers/petsc_nonlinear_solver.h
• src/solvers/petsc_nonlinear_solver.C