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 119 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:260
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::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::MeshTools::create_bounding_box(), 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::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::Nemesis_IO::read(), libMesh::CheckpointIO::read(), libMesh::XdrIO::read(), libMesh::CheckpointIO::read_header(), 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::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::MeshRefinement::uniformly_coarsen(), 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 101 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

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

102 {
103  _enable_print_counter = true;
104  return;
105 }
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 752 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().

753 {
754  PetscErrorCode ierr=0;
755 
756  if (this->initialized())
757  {
758  ierr = SNESGetConvergedReason(_snes, &_reason);
759  LIBMESH_CHKERR(ierr);
760  }
761 
762  return _reason;
763 }
PetscErrorCode ierr
template<typename T>
virtual unsigned libMesh::PetscNonlinearSolver< T >::get_current_nonlinear_iteration_number ( ) const
inlinevirtual
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 138 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 766 of file petsc_nonlinear_solver.C.

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

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

767 {
768  return _n_linear_iterations;
769 }
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 185 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().

186 {
187  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
188  std::pair<unsigned int, unsigned int> & p = _counts[name];
189 
190  p.first++;
191 }
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 198 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().

199 {
200  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
201  std::pair<unsigned int, unsigned int> & p = _counts[name];
202 
203  p.second++;
204 }
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 83 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::MeshTools::create_processor_bounding_box(), 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::MeshRefinement::make_coarsening_compatible(), 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::NameBasedIO::read(), libMesh::Nemesis_IO::read(), libMesh::CheckpointIO::read(), libMesh::XdrIO::read(), libMesh::CheckpointIO::read_connectivity(), libMesh::CheckpointIO::read_nodes(), 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::MeshRefinement::uniformly_coarsen(), 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:722
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 742 of file petsc_nonlinear_solver.C.

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

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

743 {
744 
745  libMesh::out << "Nonlinear solver convergence/divergence reason: "
746  << SNESConvergedReasons[this->get_converged_reason()] << std::endl;
747 }
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  out_stream << ReferenceCounter::get_info();
92 }
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::CheckpointIO::read(), libMesh::XdrIO::read(), libMesh::ExodusII_IO_Helper::read_elem_num_map(), libMesh::CheckpointIO::read_header(), 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::MeshRefinement::uniformly_coarsen(), libMesh::Parallel::Packing< Node * >::unpack(), libMesh::Parallel::Packing< Elem * >::unpack(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::MeshTools::weight(), libMesh::NameBasedIO::write(), libMesh::CheckpointIO::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:720
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 149 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 144 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  {
655  ierr = MatSetNearNullSpace(jac->mat(), msp);
656  LIBMESH_CHKERR(ierr);
657 
658  ierr = MatNullSpaceDestroy(&msp);
659  LIBMESH_CHKERR(ierr);
660  }
661  }
662 #endif
663  // Have the Krylov subspace method use our good initial guess rather than 0
664  KSP ksp;
665  ierr = SNESGetKSP (_snes, &ksp);
666  LIBMESH_CHKERR(ierr);
667 
668  // Set the tolerances for the iterative solver. Use the user-supplied
669  // tolerance for the relative residual & leave the others at default values
670  ierr = KSPSetTolerances (ksp, this->initial_linear_tolerance, PETSC_DEFAULT,
671  PETSC_DEFAULT, this->max_linear_iterations);
672  LIBMESH_CHKERR(ierr);
673 
674  // Set the tolerances for the non-linear solver.
675  ierr = SNESSetTolerances(_snes, this->absolute_residual_tolerance, this->relative_residual_tolerance,
677  LIBMESH_CHKERR(ierr);
678 
679  //Pull in command-line options
680 #if PETSC_VERSION_LESS_THAN(3,7,0)
681  KSPSetFromOptions(ksp);
682 #endif
683  SNESSetFromOptions(_snes);
684 
685  if (this->user_presolve)
686  this->user_presolve(this->system());
687 
688  //Set the preconditioning matrix
689  if (this->_preconditioner)
690  {
691  this->_preconditioner->set_matrix(jac_in);
692  this->_preconditioner->init();
693  }
694 
695  // If the SolverConfiguration object is provided, use it to override
696  // solver options.
697  if (this->_solver_configuration)
698  {
700  }
701 
702  ierr = SNESSolve (_snes, PETSC_NULL, x->vec());
703  LIBMESH_CHKERR(ierr);
704 
705  ierr = SNESGetIterationNumber(_snes,&n_iterations);
706  LIBMESH_CHKERR(ierr);
707 
708  ierr = SNESGetLinearSolveIterations(_snes, &_n_linear_iterations);
709  LIBMESH_CHKERR(ierr);
710 
711  // Enforce constraints exactly now that the solve is done. We have
712  // been enforcing them on the current_local_solution during the
713  // solve, but now need to be sure they are enforced on the parallel
714  // solution vector as well.
716 
717  // SNESGetFunction has been around forever and should work on all
718  // versions of PETSc. This is also now the recommended approach
719  // according to the documentation for the PETSc 3.5.1 release:
720  // http://www.mcs.anl.gov/petsc/documentation/changes/35.html
721  Vec f;
722  ierr = SNESGetFunction(_snes, &f, 0, 0);
723  LIBMESH_CHKERR(ierr);
724  ierr = VecNorm(f, NORM_2, &final_residual_norm);
725  LIBMESH_CHKERR(ierr);
726 
727  // Get and store the reason for convergence
728  SNESGetConvergedReason(_snes, &_reason);
729 
730  //Based on Petsc 2.3.3 documentation all diverged reasons are negative
731  this->converged = (_reason >= 0);
732 
733  this->clear();
734 
735  // return the # of its. and the final residual norm.
736  return std::make_pair(n_iterations, final_residual_norm);
737 }
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:2028
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 writable reference to the system we are solving.

Definition at line 263 of file nonlinear_solver.h.

263 { return _system; }
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 154 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 specify 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 specify 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:423
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 197 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 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().

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

Flag indicating if the data structures have been initialized.

Definition at line 344 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 137 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 177 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 132 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 349 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
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 172 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 355 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 339 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 192 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 187 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 290 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
Not all NonlinearSolvers support relative_step_tolerance!

Definition at line 304 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 177 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 183 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 328 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 317 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 143 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 151 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
Either R or J could be NULL.

Definition at line 160 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 278 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 311 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 273 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 322 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 220 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 227 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 191 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 199 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 241 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 253 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 291 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 305 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 129 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
Either R or J could be NULL.

Definition at line 172 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 137 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 206 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 213 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 233 of file nonlinear_solver.h.

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


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