libMesh::PetscNonlinearSolver< T > Class Template Reference

#include <petsc_nonlinear_solver.h>

Inheritance diagram for libMesh::PetscNonlinearSolver< T >:

Public Types

typedef NonlinearImplicitSystem sys_type
 

Public Member Functions

 PetscNonlinearSolver (sys_type &system)
 
 ~PetscNonlinearSolver ()
 
virtual void clear () libmesh_override
 
virtual void init (const char *name=libmesh_nullptr) libmesh_override
 
SNES snes ()
 
virtual std::pair< unsigned int, Realsolve (SparseMatrix< T > &, NumericVector< T > &, NumericVector< T > &, const double, const unsigned int) libmesh_override
 
virtual void print_converged_reason () libmesh_override
 
SNESConvergedReason get_converged_reason ()
 
virtual int get_total_linear_iterations () libmesh_override
 
virtual unsigned get_current_nonlinear_iteration_number () const libmesh_override
 
void set_residual_zero_out (bool state)
 
void set_jacobian_zero_out (bool state)
 
void use_default_monitor (bool state)
 
bool initialized () const
 
const sys_typesystem () const
 
sys_typesystem ()
 
void attach_preconditioner (Preconditioner< T > *preconditioner)
 
void set_solver_configuration (SolverConfiguration &solver_configuration)
 
const Parallel::Communicatorcomm () const
 
processor_id_type n_processors () const
 
processor_id_type processor_id () const
 

Static Public Member Functions

static UniquePtr< NonlinearSolver< T > > build (sys_type &s, const SolverPackage solver_package=libMesh::default_solver_package())
 
static std::string get_info ()
 
static void print_info (std::ostream &out=libMesh::out)
 
static unsigned int n_objects ()
 
static void enable_print_counter_info ()
 
static void disable_print_counter_info ()
 

Public Attributes

void(* residual )(const NumericVector< Number > &X, NumericVector< Number > &R, sys_type &S)
 
NonlinearImplicitSystem::ComputeResidualresidual_object
 
void(* jacobian )(const NumericVector< Number > &X, SparseMatrix< Number > &J, sys_type &S)
 
NonlinearImplicitSystem::ComputeJacobianjacobian_object
 
void(* matvec )(const NumericVector< Number > &X, NumericVector< Number > *R, SparseMatrix< Number > *J, sys_type &S)
 
NonlinearImplicitSystem::ComputeResidualandJacobianresidual_and_jacobian_object
 
void(* bounds )(NumericVector< Number > &XL, NumericVector< Number > &XU, sys_type &S)
 
NonlinearImplicitSystem::ComputeBoundsbounds_object
 
void(* nullspace )(std::vector< NumericVector< Number > * > &sp, sys_type &S)
 
NonlinearImplicitSystem::ComputeVectorSubspacenullspace_object
 
void(* transpose_nullspace )(std::vector< NumericVector< Number > * > &sp, sys_type &S)
 
NonlinearImplicitSystem::ComputeVectorSubspacetranspose_nullspace_object
 
void(* nearnullspace )(std::vector< NumericVector< Number > * > &sp, sys_type &S)
 
NonlinearImplicitSystem::ComputeVectorSubspacenearnullspace_object
 
void(* user_presolve )(sys_type &S)
 
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)
 
NonlinearImplicitSystem::ComputePostCheckpostcheck_object
 
unsigned int max_nonlinear_iterations
 
unsigned int max_function_evaluations
 
Real absolute_residual_tolerance
 
Real relative_residual_tolerance
 
Real absolute_step_tolerance
 
Real relative_step_tolerance
 
unsigned int max_linear_iterations
 
Real initial_linear_tolerance
 
Real minimum_linear_tolerance
 
bool converged
 

Protected Types

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

Protected Member Functions

void build_mat_null_space (NonlinearImplicitSystem::ComputeVectorSubspace *computeSubspaceObject, void(*)(std::vector< NumericVector< Number > * > &, sys_type &), MatNullSpace *)
 
void increment_constructor_count (const std::string &name)
 
void increment_destructor_count (const std::string &name)
 

Protected Attributes

SNES _snes
 
SNESConvergedReason _reason
 
PetscInt _n_linear_iterations
 
unsigned _current_nonlinear_iteration_number
 
bool _zero_out_residual
 
bool _zero_out_jacobian
 
bool _default_monitor
 
sys_type_system
 
bool _is_initialized
 
Preconditioner< T > * _preconditioner
 
SolverConfiguration_solver_configuration
 
const Parallel::Communicator_communicator
 

Static Protected Attributes

static Counts _counts
 
static Threads::atomic< unsigned int > _n_objects
 
static Threads::spin_mutex _mutex
 
static bool _enable_print_counter = true
 

Friends

PetscErrorCode __libmesh_petsc_snes_residual (SNES snes, Vec x, Vec r, void *ctx)
 
PetscErrorCode __libmesh_petsc_snes_jacobian (SNES snes, Vec x, Mat *jac, Mat *pc, MatStructure *msflag, void *ctx)
 
PetscErrorCode __libmesh_petsc_snes_jacobian (SNES snes, Vec x, Mat jac, Mat pc, void *ctx)
 

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 67 of file petsc_nonlinear_solver.h.

Member Typedef Documentation

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

The type of system

Definition at line 73 of file petsc_nonlinear_solver.h.

Constructor & Destructor Documentation

template<typename T >
libMesh::PetscNonlinearSolver< T >::PetscNonlinearSolver ( sys_type system)
explicit

Constructor. Initializes Petsc data structures

Definition at line 357 of file petsc_nonlinear_solver.C.

357  :
358  NonlinearSolver<T>(system_in),
359  _reason(SNES_CONVERGED_ITERATING/*==0*/), // Arbitrary initial value...
362  _zero_out_residual(true),
363  _zero_out_jacobian(true),
364  _default_monitor(true)
365 {
366 }
template<typename T >
libMesh::PetscNonlinearSolver< T >::~PetscNonlinearSolver ( )

Destructor.

Definition at line 371 of file petsc_nonlinear_solver.C.

References libMesh::PetscNonlinearSolver< T >::clear().

372 {
373  this->clear ();
374 }
virtual void clear() libmesh_override

Member Function Documentation

template<typename T>
void libMesh::NonlinearSolver< T >::attach_preconditioner ( Preconditioner< T > *  preconditioner)
inherited

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

Definition at line 75 of file nonlinear_solver.C.

References libMesh::libMeshPrivateData::_is_initialized.

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

76 {
77  if (this->_is_initialized)
78  libmesh_error_msg("Preconditioner must be attached before the solver is initialized!");
79 
80  _preconditioner = preconditioner;
81 }
Preconditioner< T > * _preconditioner
template<typename T >
UniquePtr< 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 38 of file nonlinear_solver.C.

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

39 {
40  // Build the appropriate solver
41  switch (solver_package)
42  {
43 
44 #ifdef LIBMESH_HAVE_PETSC
45  case PETSC_SOLVERS:
46  return UniquePtr<NonlinearSolver<T> >(new PetscNonlinearSolver<T>(s));
47 #endif // LIBMESH_HAVE_PETSC
48 
49 #if defined(LIBMESH_TRILINOS_HAVE_NOX) && defined(LIBMESH_TRILINOS_HAVE_EPETRA)
50  case TRILINOS_SOLVERS:
51  return UniquePtr<NonlinearSolver<T> >(new NoxNonlinearSolver<T>(s));
52 #endif
53 
54  default:
55  libmesh_error_msg("ERROR: Unrecognized solver package: " << solver_package);
56  }
57 
58  libmesh_error_msg("We'll never get here!");
59  return UniquePtr<NonlinearSolver<T> >();
60 }
TRILINOS_SOLVERS
Definition: libmesh.C:258
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 509 of file petsc_nonlinear_solver.C.

References libMesh::ParallelObject::comm(), ierr, libMesh::NonlinearSolver< T >::system(), and libMesh::PetscVector< T >::vec().

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

512 {
513  PetscErrorCode ierr;
514  std::vector<NumericVector<Number> * > sp;
515  if (computeSubspaceObject)
516  (*computeSubspaceObject)(sp, this->system());
517  else
518  (*computeSubspace)(sp, this->system());
519 
520  *msp = PETSC_NULL;
521  if (sp.size())
522  {
523  Vec * modes;
524  PetscScalar * dots;
525  PetscInt nmodes = cast_int<PetscInt>(sp.size());
526 
527 #if PETSC_RELEASE_LESS_THAN(3,5,0)
528  ierr = PetscMalloc2(nmodes,Vec,&modes,nmodes,PetscScalar,&dots);
529 #else
530  ierr = PetscMalloc2(nmodes,&modes,nmodes,&dots);
531 #endif
532  LIBMESH_CHKERR(ierr);
533 
534  for (PetscInt i=0; i<nmodes; ++i)
535  {
536  PetscVector<T> * pv = cast_ptr<PetscVector<T> *>(sp[i]);
537  Vec v = pv->vec();
538 
539  ierr = VecDuplicate(v, modes+i);
540  LIBMESH_CHKERR(ierr);
541 
542  ierr = VecCopy(v,modes[i]);
543  LIBMESH_CHKERR(ierr);
544  }
545 
546  // Normalize.
547  ierr = VecNormalize(modes[0],PETSC_NULL);
548  LIBMESH_CHKERR(ierr);
549 
550  for (PetscInt i=1; i<nmodes; i++)
551  {
552  // Orthonormalize vec[i] against vec[0:i-1]
553  ierr = VecMDot(modes[i],i,modes,dots);
554  LIBMESH_CHKERR(ierr);
555 
556  for (PetscInt j=0; j<i; j++)
557  dots[j] *= -1.;
558 
559  ierr = VecMAXPY(modes[i],i,dots,modes);
560  LIBMESH_CHKERR(ierr);
561 
562  ierr = VecNormalize(modes[i],PETSC_NULL);
563  LIBMESH_CHKERR(ierr);
564  }
565 
566  ierr = MatNullSpaceCreate(this->comm().get(), PETSC_FALSE, nmodes, modes, msp);
567  LIBMESH_CHKERR(ierr);
568 
569  for (PetscInt i=0; i<nmodes; ++i)
570  {
571  ierr = VecDestroy(modes+i);
572  LIBMESH_CHKERR(ierr);
573  }
574 
575  ierr = PetscFree2(modes,dots);
576  LIBMESH_CHKERR(ierr);
577  }
578 }
const sys_type & system() const
PetscErrorCode ierr
const Parallel::Communicator & comm() const
template<typename T >
void libMesh::PetscNonlinearSolver< T >::clear ( )
virtual

Release all memory and clear data structures.

Reimplemented from libMesh::NonlinearSolver< T >.

Definition at line 379 of file petsc_nonlinear_solver.C.

References libMesh::PetscNonlinearSolver< T >::_current_nonlinear_iteration_number, libMesh::NonlinearSolver< T >::_is_initialized, libMesh::PetscNonlinearSolver< T >::_snes, ierr, and libMesh::NonlinearSolver< T >::initialized().

Referenced by libMesh::PetscNonlinearSolver< T >::solve(), and libMesh::PetscNonlinearSolver< T >::~PetscNonlinearSolver().

380 {
381  if (this->initialized())
382  {
383  this->_is_initialized = false;
384 
385  PetscErrorCode ierr=0;
386 
387  ierr = LibMeshSNESDestroy(&_snes);
388  LIBMESH_CHKERR(ierr);
389 
390  // Reset the nonlinear iteration counter. This information is only relevant
391  // *during* the solve(). After the solve is completed it should return to
392  // the default value of 0.
394  }
395 }
PetscErrorCode ierr
const Parallel::Communicator& libMesh::ParallelObject::comm ( ) const
inlineinherited
Returns
a reference to the Parallel::Communicator object used by this mesh.

Definition at line 87 of file parallel_object.h.

References libMesh::ParallelObject::_communicator.

Referenced by libMesh::__libmesh_petsc_diff_solver_monitor(), libMesh::__libmesh_petsc_diff_solver_residual(), libMesh::__libmesh_petsc_snes_jacobian(), libMesh::__libmesh_petsc_snes_postcheck(), libMesh::__libmesh_petsc_snes_residual(), libMesh::__libmesh_tao_equality_constraints(), libMesh::__libmesh_tao_equality_constraints_jacobian(), libMesh::__libmesh_tao_gradient(), libMesh::__libmesh_tao_hessian(), libMesh::__libmesh_tao_inequality_constraints(), libMesh::__libmesh_tao_inequality_constraints_jacobian(), libMesh::__libmesh_tao_objective(), libMesh::MeshRefinement::_coarsen_elements(), libMesh::ExactSolution::_compute_error(), libMesh::ParmetisPartitioner::_do_repartition(), libMesh::UniformRefinementEstimator::_estimate_error(), 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::EquationSystems::_read_impl(), libMesh::MeshRefinement::_refine_elements(), libMesh::MeshRefinement::_smooth_flags(), libMesh::ImplicitSystem::add_matrix(), libMesh::System::add_vector(), libMesh::EigenSparseLinearSolver< T >::adjoint_solve(), libMesh::UnstructuredMesh::all_second_order(), libMesh::MeshTools::Modification::all_tri(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::FEMSystem::assemble_qoi(), libMesh::MeshCommunication::assign_global_indices(), libMesh::ParmetisPartitioner::assign_partitioning(), libMesh::DofMap::attach_matrix(), libMesh::Parallel::BinSorter< KeyType, IdxType >::binsort(), libMesh::Parallel::Sort< KeyType, IdxType >::binsort(), libMesh::MeshTools::bounding_box(), libMesh::MeshCommunication::broadcast(), libMesh::SparseMatrix< T >::build(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::Parallel::Histogram< KeyType, IdxType >::build_histogram(), libMesh::PetscNonlinearSolver< T >::build_mat_null_space(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::MeshBase::cache_elem_dims(), libMesh::System::calculate_norm(), libMesh::DofMap::check_dirichlet_bcid_consistency(), libMesh::DistributedVector< T >::clone(), libMesh::EigenSparseVector< T >::clone(), libMesh::LaspackVector< T >::clone(), libMesh::EpetraVector< T >::clone(), libMesh::PetscVector< T >::clone(), libMesh::EpetraVector< T >::close(), libMesh::Parallel::Sort< KeyType, IdxType >::communicate_bins(), 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::Problem_Interface::computeF(), libMesh::Problem_Interface::computeJacobian(), libMesh::Problem_Interface::computePreconditioner(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::MeshRefinement::create_parent_error_vector(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::DofMap::distribute_dofs(), DMlibMeshFunction(), DMlibMeshJacobian(), DMlibMeshSetSystem_libMesh(), DMVariableBounds_libMesh(), libMesh::MeshRefinement::eliminate_unrefined_patches(), libMesh::EpetraVector< T >::EpetraVector(), libMesh::WeightedPatchRecoveryErrorEstimator::estimate_error(), libMesh::PatchRecoveryErrorEstimator::estimate_error(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::ExactErrorEstimator::estimate_error(), libMesh::MeshRefinement::flag_elements_by_elem_fraction(), libMesh::MeshRefinement::flag_elements_by_error_fraction(), libMesh::MeshRefinement::flag_elements_by_nelem_target(), libMesh::MeshCommunication::gather(), libMesh::MeshCommunication::gather_neighboring_elements(), libMesh::CondensedEigenSystem::get_eigenpair(), libMesh::DofMap::get_info(), libMesh::ImplicitSystem::get_linear_solver(), libMesh::EquationSystems::get_solution(), libMesh::LocationMap< T >::init(), libMesh::PetscDiffSolver::init(), libMesh::TimeSolver::init(), libMesh::TopologyMap::init(), libMesh::TaoOptimizationSolver< T >::init(), libMesh::PetscNonlinearSolver< T >::init(), libMesh::DistributedVector< T >::init(), libMesh::EpetraVector< T >::init(), libMesh::PetscVector< T >::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::EigenSystem::init_data(), libMesh::EigenSystem::init_matrices(), libMesh::ParmetisPartitioner::initialize(), libMesh::OptimizationSystem::initialize_equality_constraints_storage(), libMesh::OptimizationSystem::initialize_inequality_constraints_storage(), 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::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::MeshRefinement::limit_level_mismatch_at_edge(), libMesh::MeshRefinement::limit_level_mismatch_at_node(), libMesh::MeshRefinement::limit_overrefined_boundary(), libMesh::MeshRefinement::limit_underrefined_boundary(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshCommunication::make_elems_parallel_consistent(), libMesh::MeshRefinement::make_flags_parallel_consistent(), libMesh::MeshCommunication::make_new_node_proc_ids_parallel_consistent(), libMesh::MeshCommunication::make_new_nodes_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::MeshRefinement::make_refinement_compatible(), libMesh::DistributedVector< T >::max(), libMesh::FEMSystem::mesh_position_set(), libMesh::MeshSerializer::MeshSerializer(), libMesh::DistributedVector< T >::min(), libMesh::DistributedMesh::n_active_elem(), libMesh::MeshTools::n_active_levels(), libMesh::BoundaryInfo::n_boundary_conds(), libMesh::BoundaryInfo::n_edge_conds(), libMesh::CondensedEigenSystem::n_global_non_condensed_dofs(), libMesh::MeshTools::n_levels(), libMesh::BoundaryInfo::n_nodeset_conds(), libMesh::MeshTools::n_p_levels(), libMesh::BoundaryInfo::n_shellface_conds(), libMesh::DistributedMesh::parallel_max_elem_id(), libMesh::DistributedMesh::parallel_max_node_id(), libMesh::ReplicatedMesh::parallel_max_unique_id(), libMesh::DistributedMesh::parallel_max_unique_id(), libMesh::DistributedMesh::parallel_n_elem(), libMesh::DistributedMesh::parallel_n_nodes(), libMesh::SparsityPattern::Build::parallel_sync(), libMesh::MeshTools::paranoid_n_levels(), libMesh::Partitioner::partition(), libMesh::MetisPartitioner::partition_range(), libMesh::Partitioner::partition_unpartitioned_elements(), libMesh::petsc_auto_fieldsplit(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::MeshBase::prepare_for_use(), libMesh::SparseMatrix< T >::print(), libMesh::MeshTools::processor_bounding_box(), libMesh::Nemesis_IO::read(), libMesh::XdrIO::read(), libMesh::XdrIO::read_serialized_bc_names(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::MeshBase::recalculate_n_partitions(), libMesh::MeshCommunication::redistribute(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::MeshCommunication::send_coarse_ghosts(), libMesh::Partitioner::set_node_processor_ids(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::Partitioner::set_parent_processor_ids(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::Parallel::Sort< KeyType, IdxType >::sort(), libMesh::MeshTools::subdomain_bounding_box(), libMesh::MeshBase::subdomain_ids(), libMesh::BoundaryInfo::sync(), libMesh::Parallel::sync_element_data_by_parent_id(), libMesh::Parallel::sync_node_data_by_element_id(), libMesh::MeshRefinement::test_level_one(), libMesh::MeshRefinement::test_unflagged(), libMesh::MeshTools::total_weight(), libMesh::NameBasedIO::write(), libMesh::XdrIO::write(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), libMesh::XdrIO::write_serialized_nodesets(), libMesh::DistributedVector< T >::zero_clone(), libMesh::LaspackVector< T >::zero_clone(), libMesh::EigenSparseVector< T >::zero_clone(), libMesh::EpetraVector< T >::zero_clone(), and libMesh::PetscVector< T >::zero_clone().

88  { return _communicator; }
const Parallel::Communicator & _communicator
void libMesh::ReferenceCounter::disable_print_counter_info ( )
staticinherited
void libMesh::ReferenceCounter::enable_print_counter_info ( )
staticinherited

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

Definition at line 100 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

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

101 {
102  _enable_print_counter = true;
103  return;
104 }
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 751 of file petsc_nonlinear_solver.C.

References libMesh::PetscNonlinearSolver< T >::_reason, libMesh::PetscNonlinearSolver< T >::_snes, ierr, and libMesh::NonlinearSolver< T >::initialized().

Referenced by libMesh::PetscNonlinearSolver< T >::print_converged_reason(), and libMesh::PetscNonlinearSolver< T >::snes().

752 {
753  PetscErrorCode ierr=0;
754 
755  if (this->initialized())
756  {
757  ierr = SNESGetConvergedReason(_snes, &_reason);
758  LIBMESH_CHKERR(ierr);
759  }
760 
761  return _reason;
762 }
PetscErrorCode ierr
template<typename T>
virtual unsigned libMesh::PetscNonlinearSolver< T >::get_current_nonlinear_iteration_number ( ) const
inlinevirtual

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

Implements libMesh::NonlinearSolver< T >.

Definition at line 136 of file petsc_nonlinear_solver.h.

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

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

Gets a string containing the reference information.

Definition at line 47 of file reference_counter.C.

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

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

48 {
49 #if defined(LIBMESH_ENABLE_REFERENCE_COUNTING) && defined(DEBUG)
50 
51  std::ostringstream oss;
52 
53  oss << '\n'
54  << " ---------------------------------------------------------------------------- \n"
55  << "| Reference count information |\n"
56  << " ---------------------------------------------------------------------------- \n";
57 
58  for (Counts::iterator it = _counts.begin();
59  it != _counts.end(); ++it)
60  {
61  const std::string name(it->first);
62  const unsigned int creations = it->second.first;
63  const unsigned int destructions = it->second.second;
64 
65  oss << "| " << name << " reference count information:\n"
66  << "| Creations: " << creations << '\n'
67  << "| Destructions: " << destructions << '\n';
68  }
69 
70  oss << " ---------------------------------------------------------------------------- \n";
71 
72  return oss.str();
73 
74 #else
75 
76  return "";
77 
78 #endif
79 }
std::string name(const ElemQuality q)
Definition: elem_quality.C:39
template<typename T >
int libMesh::PetscNonlinearSolver< T >::get_total_linear_iterations ( )
virtual

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

Implements libMesh::NonlinearSolver< T >.

Definition at line 765 of file petsc_nonlinear_solver.C.

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

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

766 {
767  return _n_linear_iterations;
768 }
void libMesh::ReferenceCounter::increment_constructor_count ( const std::string &  name)
inlineprotectedinherited

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

Definition at line 160 of file reference_counter.h.

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

Referenced by libMesh::ReferenceCounter::n_objects(), and libMesh::ReferenceCountedObject< RBParametrized >::ReferenceCountedObject().

161 {
162  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
163  std::pair<unsigned int, unsigned int> & p = _counts[name];
164 
165  p.first++;
166 }
std::string name(const ElemQuality q)
Definition: elem_quality.C:39
spin_mutex spin_mtx
Definition: threads.C:29
void libMesh::ReferenceCounter::increment_destructor_count ( const std::string &  name)
inlineprotectedinherited

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

Definition at line 173 of file reference_counter.h.

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

Referenced by libMesh::ReferenceCounter::n_objects(), and libMesh::ReferenceCountedObject< RBParametrized >::~ReferenceCountedObject().

174 {
175  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
176  std::pair<unsigned int, unsigned int> & p = _counts[name];
177 
178  p.second++;
179 }
std::string name(const ElemQuality q)
Definition: elem_quality.C:39
spin_mutex spin_mtx
Definition: threads.C:29
template<typename T >
void libMesh::PetscNonlinearSolver< T >::init ( const char *  name = libmesh_nullptr)
virtual

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 400 of file petsc_nonlinear_solver.C.

References libMesh::__libmesh_petsc_preconditioner_apply(), libMesh::__libmesh_petsc_preconditioner_setup(), libMesh::__libmesh_petsc_snes_monitor(), libMesh::__libmesh_petsc_snes_postcheck(), libMesh::PetscNonlinearSolver< T >::_default_monitor, libMesh::NonlinearSolver< T >::_is_initialized, libMesh::NonlinearSolver< T >::_preconditioner, libMesh::PetscNonlinearSolver< T >::_snes, libMesh::NonlinearSolver< T >::_solver_configuration, libMesh::ParallelObject::comm(), DMlibMeshSetSystem(), ierr, libMesh::NonlinearSolver< T >::initialized(), libMesh::pc, libMesh::NonlinearSolver< T >::postcheck, libMesh::NonlinearSolver< T >::postcheck_object, libMesh::SolverConfiguration::set_options_during_init(), and libMesh::NonlinearSolver< T >::system().

Referenced by libMesh::PetscNonlinearSolver< T >::snes(), and libMesh::PetscNonlinearSolver< T >::solve().

401 {
402  // Initialize the data structures if not done so already.
403  if (!this->initialized())
404  {
405  this->_is_initialized = true;
406 
407  PetscErrorCode ierr=0;
408 
409  ierr = SNESCreate(this->comm().get(),&_snes);
410  LIBMESH_CHKERR(ierr);
411 
412  if (name)
413  {
414  ierr = SNESSetOptionsPrefix(_snes, name);
415  LIBMESH_CHKERR(ierr);
416  }
417 
418 #if !PETSC_RELEASE_LESS_THAN(3,3,0)
419  // Attaching a DM to SNES.
420  DM dm;
421  ierr = DMCreate(this->comm().get(), &dm);LIBMESH_CHKERR(ierr);
422  ierr = DMSetType(dm,DMLIBMESH);LIBMESH_CHKERR(ierr);
423  ierr = DMlibMeshSetSystem(dm,this->system());LIBMESH_CHKERR(ierr);
424  if (name)
425  {
426  ierr = DMSetOptionsPrefix(dm,name); LIBMESH_CHKERR(ierr);
427  }
428  ierr = DMSetFromOptions(dm); LIBMESH_CHKERR(ierr);
429  ierr = DMSetUp(dm); LIBMESH_CHKERR(ierr);
430  ierr = SNESSetDM(this->_snes, dm); LIBMESH_CHKERR(ierr);
431  // SNES now owns the reference to dm.
432  ierr = DMDestroy(&dm); LIBMESH_CHKERR(ierr);
433 
434 #endif
435 
436  if (_default_monitor)
437  {
438  ierr = SNESMonitorSet (_snes, __libmesh_petsc_snes_monitor,
439  this, PETSC_NULL);
440  LIBMESH_CHKERR(ierr);
441  }
442 
443  // If the SolverConfiguration object is provided, use it to set
444  // options during solver initialization.
445  if(this->_solver_configuration)
446  {
448  }
449 
450 #if PETSC_VERSION_LESS_THAN(3,1,0)
451  // Cannot call SNESSetOptions before SNESSetFunction when using
452  // any matrix free options with PETSc 3.1.0+
453  ierr = SNESSetFromOptions(_snes);
454  LIBMESH_CHKERR(ierr);
455 #endif
456 
457  if(this->_preconditioner)
458  {
459  KSP ksp;
460  ierr = SNESGetKSP (_snes, &ksp);
461  LIBMESH_CHKERR(ierr);
462  PC pc;
463  ierr = KSPGetPC(ksp,&pc);
464  LIBMESH_CHKERR(ierr);
465 
466  this->_preconditioner->init();
467 
468  PCSetType(pc, PCSHELL);
469  PCShellSetContext(pc,(void *)this->_preconditioner);
470 
471  //Re-Use the shell functions from petsc_linear_solver
472  PCShellSetSetUp(pc,__libmesh_petsc_preconditioner_setup);
473  PCShellSetApply(pc,__libmesh_petsc_preconditioner_apply);
474  }
475  }
476 
477 
478  // Tell PETSc about our linesearch "post-check" function, but only
479  // if the user has provided one. There seem to be extra,
480  // unnecessary residual calculations if a postcheck function is
481  // attached for no reason.
482  if (this->postcheck || this->postcheck_object)
483  {
484 #if PETSC_VERSION_LESS_THAN(3,3,0)
485  PetscErrorCode ierr = SNESLineSearchSetPostCheck(_snes, __libmesh_petsc_snes_postcheck, this);
486  LIBMESH_CHKERR(ierr);
487 
488 #else
489  // Pick the right version of the function name
490 #if PETSC_VERSION_LESS_THAN(3,4,0)
491 # define SNESGETLINESEARCH SNESGetSNESLineSearch
492 #else
493 # define SNESGETLINESEARCH SNESGetLineSearch
494 #endif
495 
496  SNESLineSearch linesearch;
497  PetscErrorCode ierr = SNESGETLINESEARCH(_snes, &linesearch);
498  LIBMESH_CHKERR(ierr);
499 
500  ierr = SNESLineSearchSetPostCheck(linesearch, __libmesh_petsc_snes_postcheck, this);
501  LIBMESH_CHKERR(ierr);
502 #endif
503  }
504 }
std::string name(const ElemQuality q)
Definition: elem_quality.C:39
Preconditioner< T > * _preconditioner
PetscErrorCode __libmesh_petsc_snes_monitor(SNES, PetscInt its, PetscReal fnorm, void *)
PetscErrorCode __libmesh_petsc_snes_postcheck(#if PETSC_VERSION_LESS_THAN(3, 3, 0) SNES, Vec x, Vec y, Vec w, void *context, PetscBool *changed_y, PetscBool *changed_w#else SNESLineSearch, Vec x, Vec y, Vec w, PetscBool *changed_y, PetscBool *changed_w, void *context#endif)
PetscErrorCode Vec Mat Mat pc
SolverConfiguration * _solver_configuration
PetscErrorCode __libmesh_petsc_preconditioner_setup(void *ctx)
PetscErrorCode DMlibMeshSetSystem(DM dm, libMesh::NonlinearImplicitSystem &sys)
const sys_type & system() const
NonlinearImplicitSystem::ComputePostCheck * postcheck_object
PetscErrorCode ierr
const Parallel::Communicator & comm() const
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)
PetscErrorCode __libmesh_petsc_preconditioner_apply(void *ctx, Vec x, Vec y)
template<typename T>
bool libMesh::NonlinearSolver< T >::initialized ( ) const
inlineinherited
Returns
true if the data structures are initialized, false otherwise.

Definition at line 84 of file nonlinear_solver.h.

Referenced by libMesh::PetscNonlinearSolver< T >::clear(), libMesh::PetscNonlinearSolver< T >::get_converged_reason(), and libMesh::PetscNonlinearSolver< T >::init().

static unsigned int libMesh::ReferenceCounter::n_objects ( )
inlinestaticinherited
processor_id_type libMesh::ParallelObject::n_processors ( ) const
inlineinherited
Returns
the number of processors in the group.

Definition at line 93 of file parallel_object.h.

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

Referenced by libMesh::ParmetisPartitioner::_do_repartition(), libMesh::BoundaryInfo::_find_id_maps(), libMesh::DistributedMesh::add_elem(), libMesh::DistributedMesh::add_node(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::FEMSystem::assembly(), libMesh::ParmetisPartitioner::assign_partitioning(), libMesh::AztecLinearSolver< T >::AztecLinearSolver(), libMesh::MeshCommunication::broadcast(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::DistributedMesh::clear(), libMesh::Nemesis_IO_Helper::compute_border_node_ids(), libMesh::Nemesis_IO_Helper::construct_nemesis_filename(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::UnstructuredMesh::create_pid_mesh(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::distribute_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), libMesh::DistributedMesh::DistributedMesh(), libMesh::EnsightIO::EnsightIO(), libMesh::MeshCommunication::gather(), libMesh::MeshCommunication::gather_neighboring_elements(), libMesh::MeshBase::get_info(), libMesh::EquationSystems::get_solution(), libMesh::DistributedVector< T >::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::ParmetisPartitioner::initialize(), libMesh::Nemesis_IO_Helper::initialize(), libMesh::DistributedMesh::insert_elem(), 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::DofMap::local_variable_indices(), libMesh::MeshBase::n_active_elem_on_proc(), libMesh::MeshBase::n_elem_on_proc(), libMesh::MeshBase::n_nodes_on_proc(), libMesh::SparsityPattern::Build::parallel_sync(), libMesh::Partitioner::partition(), libMesh::MeshBase::partition(), libMesh::Partitioner::partition_unpartitioned_elements(), libMesh::PetscLinearSolver< T >::PetscLinearSolver(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::SparseMatrix< T >::print(), libMesh::MeshTools::processor_bounding_box(), libMesh::NameBasedIO::read(), libMesh::Nemesis_IO::read(), libMesh::XdrIO::read(), libMesh::MeshCommunication::redistribute(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::Partitioner::repartition(), libMesh::MeshCommunication::send_coarse_ghosts(), libMesh::Partitioner::set_node_processor_ids(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::Parallel::Sort< KeyType, IdxType >::sort(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::GMVIO::write_binary(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), and libMesh::XdrIO::write_serialized_nodesets().

94  { return cast_int<processor_id_type>(_communicator.size()); }
unsigned int size() const
Definition: parallel.h:679
const Parallel::Communicator & _communicator
template<typename T >
void libMesh::PetscNonlinearSolver< T >::print_converged_reason ( )
virtual

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

Reimplemented from libMesh::NonlinearSolver< T >.

Definition at line 741 of file petsc_nonlinear_solver.C.

References libMesh::PetscNonlinearSolver< T >::get_converged_reason(), and libMesh::out.

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

742 {
743 
744  libMesh::out << "Nonlinear solver convergence/divergence reason: "
745  << SNESConvergedReasons[this->get_converged_reason()] << std::endl;
746 }
SNESConvergedReason get_converged_reason()
OStreamProxy out(std::cout)
void libMesh::ReferenceCounter::print_info ( std::ostream &  out = libMesh::out)
staticinherited

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

Definition at line 88 of file reference_counter.C.

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

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

89 {
91 }
static std::string get_info()
processor_id_type libMesh::ParallelObject::processor_id ( ) const
inlineinherited
Returns
the rank of this processor in the group.

Definition at line 99 of file parallel_object.h.

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

Referenced by libMesh::BoundaryInfo::_find_id_maps(), libMesh::EquationSystems::_read_impl(), libMesh::DistributedMesh::add_elem(), libMesh::BoundaryInfo::add_elements(), libMesh::DofMap::add_neighbors_to_send_list(), libMesh::DistributedMesh::add_node(), libMesh::MeshRefinement::add_node(), libMesh::MeshTools::Modification::all_tri(), libMesh::FEMSystem::assembly(), libMesh::ParmetisPartitioner::assign_partitioning(), libMesh::MeshCommunication::broadcast(), libMesh::EquationSystems::build_discontinuous_solution_vector(), libMesh::Nemesis_IO_Helper::build_element_and_node_maps(), libMesh::ParmetisPartitioner::build_graph(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::DofMap::build_sparsity(), libMesh::DistributedMesh::clear(), 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::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::MeshTools::correct_node_proc_ids(), libMesh::ExodusII_IO_Helper::create(), libMesh::DistributedMesh::delete_elem(), libMesh::DistributedMesh::delete_node(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::distribute_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), libMesh::DistributedMesh::DistributedMesh(), libMesh::EnsightIO::EnsightIO(), libMesh::MeshFunction::find_element(), libMesh::MeshFunction::find_elements(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::MeshCommunication::gather(), libMesh::MeshCommunication::gather_neighboring_elements(), 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::DofMap::get_info(), libMesh::Nemesis_IO_Helper::get_init_global(), libMesh::Nemesis_IO_Helper::get_init_info(), libMesh::Nemesis_IO_Helper::get_loadbal_param(), libMesh::Nemesis_IO_Helper::get_node_cmap(), libMesh::Nemesis_IO_Helper::get_node_map(), libMesh::Nemesis_IO_Helper::get_ns_param_global(), libMesh::EquationSystems::get_solution(), libMesh::Nemesis_IO_Helper::get_ss_param_global(), libMesh::SparsityPattern::Build::handle_vi_vj(), libMesh::DistributedVector< T >::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::ParmetisPartitioner::initialize(), 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::DofMap::is_evaluable(), libMesh::SparsityPattern::Build::join(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_object_ids(), libMesh::DofMap::local_variable_indices(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshBase::n_active_local_elem(), libMesh::BoundaryInfo::n_boundary_conds(), libMesh::BoundaryInfo::n_edge_conds(), libMesh::System::n_local_dofs(), libMesh::MeshBase::n_local_elem(), libMesh::MeshBase::n_local_nodes(), libMesh::BoundaryInfo::n_nodeset_conds(), libMesh::BoundaryInfo::n_shellface_conds(), libMesh::WeightedPatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::SparsityPattern::Build::operator()(), libMesh::PatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::SparsityPattern::Build::parallel_sync(), libMesh::MetisPartitioner::partition_range(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::SparseMatrix< T >::print(), libMesh::NumericVector< T >::print_global(), 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::NameBasedIO::read(), libMesh::Nemesis_IO::read(), libMesh::XdrIO::read(), libMesh::ExodusII_IO_Helper::read_elem_num_map(), libMesh::ExodusII_IO_Helper::read_node_num_map(), libMesh::XdrIO::read_serialized_bc_names(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::MeshCommunication::redistribute(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::MeshCommunication::send_coarse_ghosts(), libMesh::Partitioner::set_node_processor_ids(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::MeshTools::total_weight(), libMesh::Parallel::Packing< Node * >::unpack(), libMesh::Parallel::Packing< Elem * >::unpack(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::MeshTools::weight(), libMesh::NameBasedIO::write(), libMesh::XdrIO::write(), libMesh::EquationSystems::write(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::ExodusII_IO::write_element_data(), libMesh::ExodusII_IO_Helper::write_element_values(), libMesh::ExodusII_IO_Helper::write_elements(), libMesh::ExodusII_IO::write_global_data(), libMesh::ExodusII_IO_Helper::write_global_values(), libMesh::ExodusII_IO::write_information_records(), libMesh::ExodusII_IO_Helper::write_information_records(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates(), libMesh::UCDIO::write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data_discontinuous(), libMesh::ExodusII_IO_Helper::write_nodal_values(), libMesh::Nemesis_IO_Helper::write_nodesets(), libMesh::ExodusII_IO_Helper::write_nodesets(), libMesh::XdrIO::write_serialized_bc_names(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), libMesh::XdrIO::write_serialized_nodesets(), libMesh::XdrIO::write_serialized_subdomain_names(), libMesh::Nemesis_IO_Helper::write_sidesets(), libMesh::ExodusII_IO_Helper::write_sidesets(), libMesh::ExodusII_IO::write_timestep(), and libMesh::ExodusII_IO_Helper::write_timestep().

100  { return cast_int<processor_id_type>(_communicator.rank()); }
const Parallel::Communicator & _communicator
unsigned int rank() const
Definition: parallel.h:677
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 147 of file petsc_nonlinear_solver.h.

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

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 142 of file petsc_nonlinear_solver.h.

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

template<typename T >
void libMesh::NonlinearSolver< T >::set_solver_configuration ( SolverConfiguration solver_configuration)
inherited

Set the solver configuration object.

Definition at line 84 of file nonlinear_solver.C.

85 {
86  _solver_configuration = &solver_configuration;
87 }
SolverConfiguration * _solver_configuration
template<typename T >
std::pair< unsigned int, Real > libMesh::PetscNonlinearSolver< T >::solve ( SparseMatrix< T > &  jac_in,
NumericVector< T > &  x_in,
NumericVector< T > &  r_in,
const double  ,
const unsigned  int 
)
virtual

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 583 of file petsc_nonlinear_solver.C.

References libMesh::PetscNonlinearSolver< T >::__libmesh_petsc_snes_jacobian, libMesh::PetscNonlinearSolver< T >::__libmesh_petsc_snes_residual, libMesh::PetscNonlinearSolver< T >::_n_linear_iterations, libMesh::NonlinearSolver< T >::_preconditioner, libMesh::PetscNonlinearSolver< T >::_reason, libMesh::PetscNonlinearSolver< T >::_snes, libMesh::NonlinearSolver< T >::_solver_configuration, libMesh::NonlinearSolver< T >::absolute_residual_tolerance, libMesh::PetscNonlinearSolver< T >::build_mat_null_space(), libMesh::PetscNonlinearSolver< T >::clear(), libMesh::SolverConfiguration::configure_solver(), libMesh::NonlinearSolver< T >::converged, libMesh::DofMap::enforce_constraints_exactly(), libMesh::System::get_dof_map(), ierr, libMesh::PetscNonlinearSolver< T >::init(), libMesh::NonlinearSolver< T >::initial_linear_tolerance, libMesh::NonlinearSolver< T >::jacobian, libMesh::NonlinearSolver< T >::jacobian_object, libMesh::PetscMatrix< T >::mat(), libMesh::NonlinearSolver< T >::max_function_evaluations, libMesh::NonlinearSolver< T >::max_linear_iterations, libMesh::NonlinearSolver< T >::max_nonlinear_iterations, libMesh::NonlinearSolver< T >::nearnullspace, libMesh::NonlinearSolver< T >::nearnullspace_object, libMesh::NonlinearSolver< T >::nullspace, libMesh::NonlinearSolver< T >::nullspace_object, libMesh::Real, libMesh::NonlinearSolver< T >::relative_residual_tolerance, libMesh::NonlinearSolver< T >::relative_step_tolerance, libMesh::NonlinearSolver< T >::residual_and_jacobian_object, libMesh::NonlinearSolver< T >::system(), libMesh::NonlinearSolver< T >::transpose_nullspace, libMesh::NonlinearSolver< T >::transpose_nullspace_object, libMesh::NonlinearSolver< T >::user_presolve, and libMesh::x.

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

588 {
589  LOG_SCOPE("solve()", "PetscNonlinearSolver");
590  this->init ();
591 
592  // Make sure the data passed in are really of Petsc types
593  PetscMatrix<T> * jac = cast_ptr<PetscMatrix<T> *>(&jac_in);
594  PetscVector<T> * x = cast_ptr<PetscVector<T> *>(&x_in);
595  PetscVector<T> * r = cast_ptr<PetscVector<T> *>(&r_in);
596 
597  PetscErrorCode ierr=0;
598  PetscInt n_iterations =0;
599  // Should actually be a PetscReal, but I don't know which version of PETSc first introduced PetscReal
600  Real final_residual_norm=0.;
601 
602  ierr = SNESSetFunction (_snes, r->vec(), __libmesh_petsc_snes_residual, this);
603  LIBMESH_CHKERR(ierr);
604 
605  // Only set the jacobian function if we've been provided with something to call.
606  // This allows a user to set their own jacobian function if they want to
607  if (this->jacobian || this->jacobian_object || this->residual_and_jacobian_object)
608  {
609  ierr = SNESSetJacobian (_snes, jac->mat(), jac->mat(), __libmesh_petsc_snes_jacobian, this);
610  LIBMESH_CHKERR(ierr);
611  }
612 #if !PETSC_VERSION_LESS_THAN(3,3,0)
613  // Only set the nullspace if we have a way of computing it and the result is non-empty.
614  if (this->nullspace || this->nullspace_object)
615  {
616  MatNullSpace msp;
617  this->build_mat_null_space(this->nullspace_object, this->nullspace, &msp);
618  if (msp)
619  {
620  ierr = MatSetNullSpace(jac->mat(), msp);
621  LIBMESH_CHKERR(ierr);
622 
623  ierr = MatNullSpaceDestroy(&msp);
624  LIBMESH_CHKERR(ierr);
625  }
626  }
627 
628  // Only set the transpose nullspace if we have a way of computing it and the result is non-empty.
630  {
631 #if PETSC_VERSION_LESS_THAN(3,6,0)
632  libmesh_warning("MatSetTransposeNullSpace is only supported for PETSc >= 3.6, transpose nullspace will be ignored.");
633 #else
634  MatNullSpace msp = PETSC_NULL;
636  if (msp)
637  {
638  ierr = MatSetTransposeNullSpace(jac->mat(), msp);
639  LIBMESH_CHKERR(ierr);
640 
641  ierr = MatNullSpaceDestroy(&msp);
642  LIBMESH_CHKERR(ierr);
643  }
644 #endif
645  }
646 
647  // Only set the nearnullspace if we have a way of computing it and the result is non-empty.
648  if (this->nearnullspace || this->nearnullspace_object)
649  {
650  MatNullSpace msp = PETSC_NULL;
651  this->build_mat_null_space(this->nearnullspace_object, this->nearnullspace, &msp);
652 
653  if(msp) {
654  ierr = MatSetNearNullSpace(jac->mat(), msp);
655  LIBMESH_CHKERR(ierr);
656 
657  ierr = MatNullSpaceDestroy(&msp);
658  LIBMESH_CHKERR(ierr);
659  }
660  }
661 #endif
662  // Have the Krylov subspace method use our good initial guess rather than 0
663  KSP ksp;
664  ierr = SNESGetKSP (_snes, &ksp);
665  LIBMESH_CHKERR(ierr);
666 
667  // Set the tolerances for the iterative solver. Use the user-supplied
668  // tolerance for the relative residual & leave the others at default values
669  ierr = KSPSetTolerances (ksp, this->initial_linear_tolerance, PETSC_DEFAULT,
670  PETSC_DEFAULT, this->max_linear_iterations);
671  LIBMESH_CHKERR(ierr);
672 
673  // Set the tolerances for the non-linear solver.
674  ierr = SNESSetTolerances(_snes, this->absolute_residual_tolerance, this->relative_residual_tolerance,
676  LIBMESH_CHKERR(ierr);
677 
678  //Pull in command-line options
679 #if PETSC_VERSION_LESS_THAN(3,7,0)
680  KSPSetFromOptions(ksp);
681 #endif
682  SNESSetFromOptions(_snes);
683 
684  if (this->user_presolve)
685  this->user_presolve(this->system());
686 
687  //Set the preconditioning matrix
688  if(this->_preconditioner)
689  {
690  this->_preconditioner->set_matrix(jac_in);
691  this->_preconditioner->init();
692  }
693 
694  // If the SolverConfiguration object is provided, use it to override
695  // solver options.
696  if(this->_solver_configuration)
697  {
699  }
700 
701  ierr = SNESSolve (_snes, PETSC_NULL, x->vec());
702  LIBMESH_CHKERR(ierr);
703 
704  ierr = SNESGetIterationNumber(_snes,&n_iterations);
705  LIBMESH_CHKERR(ierr);
706 
707  ierr = SNESGetLinearSolveIterations(_snes, &_n_linear_iterations);
708  LIBMESH_CHKERR(ierr);
709 
710  // Enforce constraints exactly now that the solve is done. We have
711  // been enforcing them on the current_local_solution during the
712  // solve, but now need to be sure they are enforced on the parallel
713  // solution vector as well.
715 
716  // SNESGetFunction has been around forever and should work on all
717  // versions of PETSc. This is also now the recommended approach
718  // according to the documentation for the PETSc 3.5.1 release:
719  // http://www.mcs.anl.gov/petsc/documentation/changes/35.html
720  Vec f;
721  ierr = SNESGetFunction(_snes, &f, 0, 0);
722  LIBMESH_CHKERR(ierr);
723  ierr = VecNorm(f, NORM_2, &final_residual_norm);
724  LIBMESH_CHKERR(ierr);
725 
726  // Get and store the reason for convergence
727  SNESGetConvergedReason(_snes, &_reason);
728 
729  //Based on Petsc 2.3.3 documentation all diverged reasons are negative
730  this->converged = (_reason >= 0);
731 
732  this->clear();
733 
734  // return the # of its. and the final residual norm.
735  return std::make_pair(n_iterations, final_residual_norm);
736 }
virtual void clear() libmesh_override
NonlinearImplicitSystem::ComputeResidualandJacobian * residual_and_jacobian_object
void(* transpose_nullspace)(std::vector< NumericVector< Number > * > &sp, sys_type &S)
unsigned int max_function_evaluations
Preconditioner< T > * _preconditioner
void(* user_presolve)(sys_type &S)
void(* nullspace)(std::vector< NumericVector< Number > * > &sp, sys_type &S)
virtual void configure_solver()=0
unsigned int max_linear_iterations
SolverConfiguration * _solver_configuration
void(* jacobian)(const NumericVector< Number > &X, SparseMatrix< Number > &J, sys_type &S)
NonlinearImplicitSystem::ComputeJacobian * jacobian_object
PetscErrorCode Vec x
const DofMap & get_dof_map() const
Definition: system.h:2019
virtual void init(const char *name=libmesh_nullptr) libmesh_override
void enforce_constraints_exactly(const System &system, NumericVector< Number > *v=libmesh_nullptr, bool homogeneous=false) const
friend PetscErrorCode __libmesh_petsc_snes_residual(SNES snes, Vec x, Vec r, void *ctx)
void build_mat_null_space(NonlinearImplicitSystem::ComputeVectorSubspace *computeSubspaceObject, void(*)(std::vector< NumericVector< Number > * > &, sys_type &), MatNullSpace *)
friend PetscErrorCode __libmesh_petsc_snes_jacobian(SNES snes, Vec x, Mat *jac, Mat *pc, MatStructure *msflag, void *ctx)
const sys_type & system() const
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
void(* nearnullspace)(std::vector< NumericVector< Number > * > &sp, sys_type &S)
PetscErrorCode ierr
NonlinearImplicitSystem::ComputeVectorSubspace * nearnullspace_object
unsigned int max_nonlinear_iterations
NonlinearImplicitSystem::ComputeVectorSubspace * transpose_nullspace_object
NonlinearImplicitSystem::ComputeVectorSubspace * nullspace_object
template<typename T>
sys_type& libMesh::NonlinearSolver< T >::system ( )
inlineinherited
Returns
a writeable reference to the system we are solving.

Definition at line 260 of file nonlinear_solver.h.

260 { return _system; }
template<typename T>
void libMesh::PetscNonlinearSolver< T >::use_default_monitor ( bool  state)
inline

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

Definition at line 152 of file petsc_nonlinear_solver.h.

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

Friends And Related Function Documentation

template<typename T>
PetscErrorCode __libmesh_petsc_snes_jacobian ( SNES  snes,
Vec  x,
Mat *  jac,
Mat *  pc,
MatStructure *  msflag,
void *  ctx 
)
friend
template<typename T>
PetscErrorCode __libmesh_petsc_snes_jacobian ( SNES  snes,
Vec  x,
Mat  jac,
Mat  pc,
void *  ctx 
)
friend
template<typename T>
PetscErrorCode __libmesh_petsc_snes_residual ( SNES  snes,
Vec  x,
Vec  r,
void *  ctx 
)
friend

Definition at line 74 of file petsc_nonlinear_solver.C.

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

75  {
76  LOG_SCOPE("residual()", "PetscNonlinearSolver");
77 
78  PetscErrorCode ierr=0;
79 
81  libmesh_assert(r);
83 
84  // No way to safety-check this cast, since we got a void *...
85  PetscNonlinearSolver<Number> * solver =
86  static_cast<PetscNonlinearSolver<Number> *> (ctx);
87 
88  // Get the current iteration number from the snes object,
89  // store it in the PetscNonlinearSolver object for possible use
90  // by the user's residual function.
91  {
92  PetscInt n_iterations = 0;
93  ierr = SNESGetIterationNumber(snes, &n_iterations);
94  CHKERRABORT(solver->comm().get(),ierr);
95  solver->_current_nonlinear_iteration_number = cast_int<unsigned>(n_iterations);
96  }
97 
98  NonlinearImplicitSystem & sys = solver->system();
99 
100  PetscVector<Number> & X_sys = *cast_ptr<PetscVector<Number> *>(sys.solution.get());
101  PetscVector<Number> X_global(x, sys.comm()), R(r, sys.comm());
102 
103  // Use the system's update() to get a good local version of the
104  // parallel solution. This operation does not modify the incoming
105  // "x" vector, it only localizes information from "x" into
106  // sys.current_local_solution.
107  X_global.swap(X_sys);
108  sys.update();
109  X_global.swap(X_sys);
110 
111  // Enforce constraints (if any) exactly on the
112  // current_local_solution. This is the solution vector that is
113  // actually used in the computation of the residual below, and is
114  // not locked by debug-enabled PETSc the way that "x" is.
115  sys.get_dof_map().enforce_constraints_exactly(sys, sys.current_local_solution.get());
116 
117  if (solver->_zero_out_residual)
118  R.zero();
119 
120  //-----------------------------------------------------------------------------
121  // if the user has provided both function pointers and objects only the pointer
122  // will be used, so catch that as an error
123  if (solver->residual && solver->residual_object)
124  libmesh_error_msg("ERROR: cannot specifiy both a function and object to compute the Residual!");
125 
126  if (solver->matvec && solver->residual_and_jacobian_object)
127  libmesh_error_msg("ERROR: cannot specifiy both a function and object to compute the combined Residual & Jacobian!");
128 
129  if (solver->residual != libmesh_nullptr)
130  solver->residual(*sys.current_local_solution.get(), R, sys);
131 
132  else if (solver->residual_object != libmesh_nullptr)
133  solver->residual_object->residual(*sys.current_local_solution.get(), R, sys);
134 
135  else if (solver->matvec != libmesh_nullptr)
136  solver->matvec (*sys.current_local_solution.get(), &R, libmesh_nullptr, sys);
137 
138  else if (solver->residual_and_jacobian_object != libmesh_nullptr)
139  solver->residual_and_jacobian_object->residual_and_jacobian (*sys.current_local_solution.get(), &R, libmesh_nullptr, sys);
140 
141  else
142  libmesh_error_msg("Error! Unable to compute residual and/or Jacobian!");
143 
144  R.close();
145 
146  return ierr;
147  }
ImplicitSystem & sys
const class libmesh_nullptr_t libmesh_nullptr
libmesh_assert(j)
PetscDiffSolver & solver
PetscErrorCode Vec x
PetscErrorCode Vec Mat Mat void * ctx
virtual void update()
Definition: system.C:420
PetscErrorCode ierr

Member Data Documentation

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts
staticprotectedinherited
template<typename T>
unsigned libMesh::PetscNonlinearSolver< T >::_current_nonlinear_iteration_number
protected
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 192 of file petsc_nonlinear_solver.h.

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

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

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

template<typename T>
bool libMesh::NonlinearSolver< T >::_is_initialized
protectedinherited

Flag indicating if the data structures have been initialized.

Definition at line 341 of file nonlinear_solver.h.

Referenced by libMesh::PetscNonlinearSolver< T >::clear(), libMesh::PetscNonlinearSolver< T >::init(), and libMesh::NonlinearSolver< Number >::initialized().

Threads::spin_mutex libMesh::ReferenceCounter::_mutex
staticprotectedinherited

Mutual exclusion object to enable thread-safe reference counting.

Definition at line 128 of file reference_counter.h.

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 172 of file petsc_nonlinear_solver.h.

Referenced by libMesh::PetscNonlinearSolver< T >::get_total_linear_iterations(), and libMesh::PetscNonlinearSolver< T >::solve().

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

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

template<typename T>
Preconditioner<T>* libMesh::NonlinearSolver< T >::_preconditioner
protectedinherited

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

Definition at line 346 of file nonlinear_solver.h.

Referenced by libMesh::PetscNonlinearSolver< T >::init(), and libMesh::PetscNonlinearSolver< T >::solve().

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 that 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. Note that this value is therefore necessarily not cleared by the clear() function.

Definition at line 167 of file petsc_nonlinear_solver.h.

Referenced by libMesh::PetscNonlinearSolver< T >::get_converged_reason(), and libMesh::PetscNonlinearSolver< T >::solve().

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

Referenced by libMesh::PetscNonlinearSolver< T >::init(), and libMesh::PetscNonlinearSolver< T >::solve().

template<typename T>
sys_type& libMesh::NonlinearSolver< T >::_system
protectedinherited

A reference to the system we are solving.

Definition at line 336 of file nonlinear_solver.h.

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

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 187 of file petsc_nonlinear_solver.h.

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

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 182 of file petsc_nonlinear_solver.h.

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

template<typename T>
Real libMesh::NonlinearSolver< T >::absolute_residual_tolerance
inherited

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

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

Definition at line 287 of file nonlinear_solver.h.

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

template<typename T>
Real libMesh::NonlinearSolver< T >::absolute_step_tolerance
inherited

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

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

Note that not all NonlinearSolvers support relative_step_tolerance!

Definition at line 301 of file nonlinear_solver.h.

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

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

Definition at line 174 of file nonlinear_solver.h.

template<typename T>
NonlinearImplicitSystem::ComputeBounds* libMesh::NonlinearSolver< T >::bounds_object
inherited

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

Definition at line 180 of file nonlinear_solver.h.

template<typename T>
bool libMesh::NonlinearSolver< T >::converged
inherited

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

Definition at line 325 of file nonlinear_solver.h.

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

template<typename T>
Real libMesh::NonlinearSolver< T >::initial_linear_tolerance
inherited

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

Definition at line 314 of file nonlinear_solver.h.

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

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

Referenced by libMesh::__libmesh_petsc_snes_jacobian(), libMesh::Problem_Interface::computeJacobian(), libMesh::Problem_Interface::computePreconditioner(), and libMesh::PetscNonlinearSolver< T >::solve().

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

Referenced by libMesh::__libmesh_petsc_snes_jacobian(), libMesh::Problem_Interface::computeJacobian(), libMesh::Problem_Interface::computePreconditioner(), and libMesh::PetscNonlinearSolver< T >::solve().

template<typename T>
void(* libMesh::NonlinearSolver< T >::matvec) (const NumericVector< Number > &X, NumericVector< Number > *R, SparseMatrix< Number > *J, sys_type &S)
inherited

Function that computes either the residual $ R(X) $ or the Jacobian $ J(X) $ of the nonlinear system at the input iterate $ X $. Note that either R or J could be NULL.

Definition at line 158 of file nonlinear_solver.h.

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

template<typename T>
unsigned int libMesh::NonlinearSolver< T >::max_function_evaluations
inherited

Maximum number of function evaluations.

Definition at line 275 of file nonlinear_solver.h.

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

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

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

template<typename T>
unsigned int libMesh::NonlinearSolver< T >::max_nonlinear_iterations
inherited

Maximum number of non-linear iterations.

Definition at line 270 of file nonlinear_solver.h.

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

template<typename T>
Real libMesh::NonlinearSolver< T >::minimum_linear_tolerance
inherited

The tolerance for linear solves is kept above this minimum

Definition at line 319 of file nonlinear_solver.h.

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

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

Definition at line 217 of file nonlinear_solver.h.

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

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

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

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

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

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

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

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

Referenced by libMesh::__libmesh_petsc_snes_postcheck(), and libMesh::PetscNonlinearSolver< T >::init().

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

Referenced by libMesh::__libmesh_petsc_snes_postcheck(), and libMesh::PetscNonlinearSolver< T >::init().

template<typename T>
Real libMesh::NonlinearSolver< T >::relative_residual_tolerance
inherited

Definition at line 288 of file nonlinear_solver.h.

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

template<typename T>
Real libMesh::NonlinearSolver< T >::relative_step_tolerance
inherited

Definition at line 302 of file nonlinear_solver.h.

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

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

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

template<typename T>
NonlinearImplicitSystem::ComputeResidualandJacobian* libMesh::NonlinearSolver< T >::residual_and_jacobian_object
inherited

Object that computes either the residual $ R(X) $ or the Jacobian $ J(X) $ of the nonlinear system at the input iterate $ X $. Note that either R or J could be NULL.

Definition at line 169 of file nonlinear_solver.h.

Referenced by libMesh::__libmesh_petsc_snes_jacobian(), libMesh::__libmesh_petsc_snes_residual(), libMesh::Problem_Interface::computeF(), libMesh::Problem_Interface::computeJacobian(), libMesh::Problem_Interface::computePreconditioner(), and libMesh::PetscNonlinearSolver< T >::solve().

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

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

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

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

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

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

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

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


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