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 std::unique_ptr< 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
 
NonlinearImplicitSystem::ComputeResidualfd_residual_object
 
NonlinearImplicitSystem::ComputeResidualmffd_residual_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

ResidualContext libmesh_petsc_snes_residual_helper (SNES snes, Vec x, void *ctx)
 
PetscErrorCode __libmesh_petsc_snes_residual (SNES snes, Vec x, Vec r, void *ctx)
 
PetscErrorCode __libmesh_petsc_snes_fd_residual (SNES snes, Vec x, Vec r, void *ctx)
 
PetscErrorCode __libmesh_petsc_snes_mffd_interface (void *ctx, Vec x, Vec r)
 
PetscErrorCode __libmesh_petsc_snes_mffd_residual (SNES snes, Vec x, Vec r, void *ctx)
 
PetscErrorCode __libmesh_petsc_snes_jacobian (SNES snes, Vec x, Mat *jac, Mat *pc, 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 72 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 78 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 453 of file petsc_nonlinear_solver.C.

453  :
454  NonlinearSolver<T>(system_in),
455  _reason(SNES_CONVERGED_ITERATING/*==0*/), // Arbitrary initial value...
458  _zero_out_residual(true),
459  _zero_out_jacobian(true),
460  _default_monitor(true)
461 {
462 }
template<typename T >
libMesh::PetscNonlinearSolver< T >::~PetscNonlinearSolver ( )

Destructor.

Definition at line 467 of file petsc_nonlinear_solver.C.

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

468 {
469  this->clear ();
470 }
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 70 of file nonlinear_solver.C.

References libMesh::libMeshPrivateData::_is_initialized.

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

71 {
72  if (this->_is_initialized)
73  libmesh_error_msg("Preconditioner must be attached before the solver is initialized!");
74 
75  _preconditioner = preconditioner;
76 }
Preconditioner< T > * _preconditioner
template<typename T >
std::unique_ptr< NonlinearSolver< T > > libMesh::NonlinearSolver< T >::build ( sys_type s,
const SolverPackage  solver_package = libMesh::default_solver_package() 
)
staticinherited

Builds a NonlinearSolver using the nonlinear solver package specified by solver_package

Definition at line 36 of file nonlinear_solver.C.

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

37 {
38  // Build the appropriate solver
39  switch (solver_package)
40  {
41 
42 #ifdef LIBMESH_HAVE_PETSC
43  case PETSC_SOLVERS:
44  return libmesh_make_unique<PetscNonlinearSolver<T>>(s);
45 #endif // LIBMESH_HAVE_PETSC
46 
47 #if defined(LIBMESH_TRILINOS_HAVE_NOX) && defined(LIBMESH_TRILINOS_HAVE_EPETRA)
48  case TRILINOS_SOLVERS:
49  return libmesh_make_unique<NoxNonlinearSolver<T>>(s);
50 #endif
51 
52  default:
53  libmesh_error_msg("ERROR: Unrecognized solver package: " << solver_package);
54  }
55 }
TRILINOS_SOLVERS
Definition: libmesh.C:259
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 605 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().

608 {
609  PetscErrorCode ierr;
610  std::vector<NumericVector<Number> *> sp;
611  if (computeSubspaceObject)
612  (*computeSubspaceObject)(sp, this->system());
613  else
614  (*computeSubspace)(sp, this->system());
615 
616  *msp = PETSC_NULL;
617  if (sp.size())
618  {
619  Vec * modes;
620  PetscScalar * dots;
621  PetscInt nmodes = cast_int<PetscInt>(sp.size());
622 
623 #if PETSC_RELEASE_LESS_THAN(3,5,0)
624  ierr = PetscMalloc2(nmodes,Vec,&modes,nmodes,PetscScalar,&dots);
625 #else
626  ierr = PetscMalloc2(nmodes,&modes,nmodes,&dots);
627 #endif
628  LIBMESH_CHKERR(ierr);
629 
630  for (PetscInt i=0; i<nmodes; ++i)
631  {
632  PetscVector<T> * pv = cast_ptr<PetscVector<T> *>(sp[i]);
633  Vec v = pv->vec();
634 
635  ierr = VecDuplicate(v, modes+i);
636  LIBMESH_CHKERR(ierr);
637 
638  ierr = VecCopy(v,modes[i]);
639  LIBMESH_CHKERR(ierr);
640  }
641 
642  // Normalize.
643  ierr = VecNormalize(modes[0],PETSC_NULL);
644  LIBMESH_CHKERR(ierr);
645 
646  for (PetscInt i=1; i<nmodes; i++)
647  {
648  // Orthonormalize vec[i] against vec[0:i-1]
649  ierr = VecMDot(modes[i],i,modes,dots);
650  LIBMESH_CHKERR(ierr);
651 
652  for (PetscInt j=0; j<i; j++)
653  dots[j] *= -1.;
654 
655  ierr = VecMAXPY(modes[i],i,dots,modes);
656  LIBMESH_CHKERR(ierr);
657 
658  ierr = VecNormalize(modes[i],PETSC_NULL);
659  LIBMESH_CHKERR(ierr);
660  }
661 
662  ierr = MatNullSpaceCreate(this->comm().get(), PETSC_FALSE, nmodes, modes, msp);
663  LIBMESH_CHKERR(ierr);
664 
665  for (PetscInt i=0; i<nmodes; ++i)
666  {
667  ierr = VecDestroy(modes+i);
668  LIBMESH_CHKERR(ierr);
669  }
670 
671  ierr = PetscFree2(modes,dots);
672  LIBMESH_CHKERR(ierr);
673  }
674 }
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 475 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().

476 {
477  if (this->initialized())
478  {
479  this->_is_initialized = false;
480 
481  PetscErrorCode ierr=0;
482 
483  ierr = LibMeshSNESDestroy(&_snes);
484  LIBMESH_CHKERR(ierr);
485 
486  // Reset the nonlinear iteration counter. This information is only relevant
487  // *during* the solve(). After the solve is completed it should return to
488  // the default value of 0.
490  }
491 }
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_jacobian(), libMesh::__libmesh_petsc_diff_solver_monitor(), libMesh::__libmesh_petsc_diff_solver_residual(), libMesh::__libmesh_petsc_snes_fd_residual(), libMesh::__libmesh_petsc_snes_jacobian(), libMesh::__libmesh_petsc_snes_mffd_residual(), 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::ExodusII_IO::copy_elemental_solution(), 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::TopologyMap::init(), libMesh::TimeSolver::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::libmesh_petsc_snes_residual_helper(), 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::LinearPartitioner::partition_range(), 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::XdrIO::read(), libMesh::CheckpointIO::read_header(), libMesh::XdrIO::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::MeshRefinement::refine_and_coarsen_elements(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::CheckpointIO::select_split_config(), libMesh::MeshCommunication::send_coarse_ghosts(), libMesh::Partitioner::set_node_processor_ids(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::Partitioner::set_parent_processor_ids(), libMesh::PetscDiffSolver::setup_petsc_data(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::Parallel::Sort< KeyType, IdxType >::sort(), libMesh::split_mesh(), 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::EigenSparseVector< T >::zero_clone(), libMesh::LaspackVector< 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 862 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< Number >::snes().

863 {
864  PetscErrorCode ierr=0;
865 
866  if (this->initialized())
867  {
868  ierr = SNESGetConvergedReason(_snes, &_reason);
869  LIBMESH_CHKERR(ierr);
870  }
871 
872  return _reason;
873 }
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 143 of file petsc_nonlinear_solver.h.

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

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

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

877 {
878  return _n_linear_iterations;
879 }
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 496 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::NonlinearSolver< T >::postcheck, libMesh::NonlinearSolver< T >::postcheck_object, libMesh::SolverConfiguration::set_options_during_init(), and libMesh::NonlinearSolver< T >::system().

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

497 {
498  // Initialize the data structures if not done so already.
499  if (!this->initialized())
500  {
501  this->_is_initialized = true;
502 
503  PetscErrorCode ierr=0;
504 
505  ierr = SNESCreate(this->comm().get(),&_snes);
506  LIBMESH_CHKERR(ierr);
507 
508  if (name)
509  {
510  ierr = SNESSetOptionsPrefix(_snes, name);
511  LIBMESH_CHKERR(ierr);
512  }
513 
514 #if !PETSC_RELEASE_LESS_THAN(3,3,0)
515  // Attaching a DM to SNES.
516  DM dm;
517  ierr = DMCreate(this->comm().get(), &dm);LIBMESH_CHKERR(ierr);
518  ierr = DMSetType(dm,DMLIBMESH);LIBMESH_CHKERR(ierr);
519  ierr = DMlibMeshSetSystem(dm,this->system());LIBMESH_CHKERR(ierr);
520  if (name)
521  {
522  ierr = DMSetOptionsPrefix(dm,name); LIBMESH_CHKERR(ierr);
523  }
524  ierr = DMSetFromOptions(dm); LIBMESH_CHKERR(ierr);
525  ierr = DMSetUp(dm); LIBMESH_CHKERR(ierr);
526  ierr = SNESSetDM(this->_snes, dm); LIBMESH_CHKERR(ierr);
527  // SNES now owns the reference to dm.
528  ierr = DMDestroy(&dm); LIBMESH_CHKERR(ierr);
529 
530 #endif
531 
532  if (_default_monitor)
533  {
534  ierr = SNESMonitorSet (_snes, __libmesh_petsc_snes_monitor,
535  this, PETSC_NULL);
536  LIBMESH_CHKERR(ierr);
537  }
538 
539  // If the SolverConfiguration object is provided, use it to set
540  // options during solver initialization.
541  if (this->_solver_configuration)
542  {
544  }
545 
546 #if PETSC_VERSION_LESS_THAN(3,1,0)
547  // Cannot call SNESSetOptions before SNESSetFunction when using
548  // any matrix free options with PETSc 3.1.0+
549  ierr = SNESSetFromOptions(_snes);
550  LIBMESH_CHKERR(ierr);
551 #endif
552 
553  if (this->_preconditioner)
554  {
555  KSP ksp;
556  ierr = SNESGetKSP (_snes, &ksp);
557  LIBMESH_CHKERR(ierr);
558  PC pc;
559  ierr = KSPGetPC(ksp,&pc);
560  LIBMESH_CHKERR(ierr);
561 
562  this->_preconditioner->init();
563 
564  PCSetType(pc, PCSHELL);
565  PCShellSetContext(pc,(void *)this->_preconditioner);
566 
567  //Re-Use the shell functions from petsc_linear_solver
568  PCShellSetSetUp(pc,__libmesh_petsc_preconditioner_setup);
569  PCShellSetApply(pc,__libmesh_petsc_preconditioner_apply);
570  }
571  }
572 
573 
574  // Tell PETSc about our linesearch "post-check" function, but only
575  // if the user has provided one. There seem to be extra,
576  // unnecessary residual calculations if a postcheck function is
577  // attached for no reason.
578  if (this->postcheck || this->postcheck_object)
579  {
580 #if PETSC_VERSION_LESS_THAN(3,3,0)
581  PetscErrorCode ierr = SNESLineSearchSetPostCheck(_snes, __libmesh_petsc_snes_postcheck, this);
582  LIBMESH_CHKERR(ierr);
583 
584 #else
585  // Pick the right version of the function name
586 #if PETSC_VERSION_LESS_THAN(3,4,0)
587 # define SNESGETLINESEARCH SNESGetSNESLineSearch
588 #else
589 # define SNESGETLINESEARCH SNESGetLineSearch
590 #endif
591 
592  SNESLineSearch linesearch;
593  PetscErrorCode ierr = SNESGETLINESEARCH(_snes, &linesearch);
594  LIBMESH_CHKERR(ierr);
595 
596  ierr = SNESLineSearchSetPostCheck(linesearch, __libmesh_petsc_snes_postcheck, this);
597  LIBMESH_CHKERR(ierr);
598 #endif
599  }
600 }
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)
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::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::CheckpointIO::read_connectivity(), libMesh::XdrIO::read_header(), 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:725
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 852 of file petsc_nonlinear_solver.C.

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

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

853 {
854 
855  libMesh::out << "Nonlinear solver convergence/divergence reason: "
856  << SNESConvergedReasons[this->get_converged_reason()] << std::endl;
857 }
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::XdrIO::read(), libMesh::CheckpointIO::read(), libMesh::ExodusII_IO_Helper::read_elem_num_map(), libMesh::ExodusII_IO_Helper::read_global_values(), libMesh::CheckpointIO::read_header(), libMesh::XdrIO::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::CheckpointIO::select_split_config(), 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::XdrIO::write(), libMesh::CheckpointIO::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(), libMesh::ExodusII_IO_Helper::write_timestep(), and libMesh::ExodusII_IO::write_timestep_discontinuous().

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

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

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

Set the solver configuration object.

Definition at line 79 of file nonlinear_solver.C.

80 {
81  _solver_configuration = &solver_configuration;
82 }
SolverConfiguration * _solver_configuration
template<typename T>
SNES libMesh::PetscNonlinearSolver< T >::snes ( )
inline
Returns
The raw PETSc snes context pointer.

Definition at line 105 of file petsc_nonlinear_solver.h.

Referenced by libMesh::__libmesh_petsc_snes_mffd_interface().

105 { this->init(); return _snes; }
virtual void init(const char *name=libmesh_nullptr) libmesh_override
template<typename T>
std::pair< unsigned int, Real > libMesh::PetscNonlinearSolver< T >::solve ( SparseMatrix< T > &  pre_in,
NumericVector< T > &  x_in,
NumericVector< T > &  r_in,
const double  ,
const unsigned  int 
)
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 679 of file petsc_nonlinear_solver.C.

References libMesh::PetscNonlinearSolver< T >::__libmesh_petsc_snes_jacobian, libMesh::PetscNonlinearSolver< T >::__libmesh_petsc_snes_mffd_interface, 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, and libMesh::NonlinearSolver< T >::user_presolve.

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

684 {
685  LOG_SCOPE("solve()", "PetscNonlinearSolver");
686  this->init ();
687 
688  // Make sure the data passed in are really of Petsc types
689  PetscMatrix<T> * pre = cast_ptr<PetscMatrix<T> *>(&pre_in);
690  PetscVector<T> * x = cast_ptr<PetscVector<T> *>(&x_in);
691  PetscVector<T> * r = cast_ptr<PetscVector<T> *>(&r_in);
692 
693  PetscErrorCode ierr=0;
694  PetscInt n_iterations =0;
695  // Should actually be a PetscReal, but I don't know which version of PETSc first introduced PetscReal
696  Real final_residual_norm=0.;
697 
698  ierr = SNESSetFunction (_snes, r->vec(), __libmesh_petsc_snes_residual, this);
699  LIBMESH_CHKERR(ierr);
700 
701  // Only set the jacobian function if we've been provided with something to call.
702  // This allows a user to set their own jacobian function if they want to
703  if (this->jacobian || this->jacobian_object || this->residual_and_jacobian_object)
704  {
705  ierr = SNESSetJacobian (_snes, pre->mat(), pre->mat(), __libmesh_petsc_snes_jacobian, this);
706  LIBMESH_CHKERR(ierr);
707  }
708 
709 
710 #if !PETSC_VERSION_LESS_THAN(3,3,0)
711  // Only set the nullspace if we have a way of computing it and the result is non-empty.
712  if (this->nullspace || this->nullspace_object)
713  {
714  MatNullSpace msp;
715  this->build_mat_null_space(this->nullspace_object, this->nullspace, &msp);
716  if (msp)
717  {
718  ierr = MatSetNullSpace(pre->mat(), msp);
719  LIBMESH_CHKERR(ierr);
720  ierr = MatNullSpaceDestroy(&msp);
721  LIBMESH_CHKERR(ierr);
722  }
723  }
724 
725  // Only set the transpose nullspace if we have a way of computing it and the result is non-empty.
727  {
728 #if PETSC_VERSION_LESS_THAN(3,6,0)
729  libmesh_warning("MatSetTransposeNullSpace is only supported for PETSc >= 3.6, transpose nullspace will be ignored.");
730 #else
731  MatNullSpace msp = PETSC_NULL;
733  if (msp)
734  {
735  ierr = MatSetTransposeNullSpace(pre->mat(), msp);
736  LIBMESH_CHKERR(ierr);
737  ierr = MatNullSpaceDestroy(&msp);
738  LIBMESH_CHKERR(ierr);
739  }
740 #endif
741  }
742 
743  // Only set the nearnullspace if we have a way of computing it and the result is non-empty.
744  if (this->nearnullspace || this->nearnullspace_object)
745  {
746  MatNullSpace msp = PETSC_NULL;
747  this->build_mat_null_space(this->nearnullspace_object, this->nearnullspace, &msp);
748 
749  if (msp)
750  {
751  ierr = MatSetNearNullSpace(pre->mat(), msp);
752  LIBMESH_CHKERR(ierr);
753  ierr = MatNullSpaceDestroy(&msp);
754  LIBMESH_CHKERR(ierr);
755  }
756  }
757 #endif
758 
759  // Have the Krylov subspace method use our good initial guess rather than 0
760  KSP ksp;
761  ierr = SNESGetKSP (_snes, &ksp);
762  LIBMESH_CHKERR(ierr);
763 
764  // Set the tolerances for the iterative solver. Use the user-supplied
765  // tolerance for the relative residual & leave the others at default values
766  ierr = KSPSetTolerances (ksp, this->initial_linear_tolerance, PETSC_DEFAULT,
767  PETSC_DEFAULT, this->max_linear_iterations);
768  LIBMESH_CHKERR(ierr);
769 
770  // Set the tolerances for the non-linear solver.
771  ierr = SNESSetTolerances(_snes, this->absolute_residual_tolerance, this->relative_residual_tolerance,
773  LIBMESH_CHKERR(ierr);
774 
775  //Pull in command-line options
776 #if PETSC_VERSION_LESS_THAN(3,7,0)
777  KSPSetFromOptions(ksp);
778 #endif
779  SNESSetFromOptions(_snes);
780 
781  if (this->user_presolve)
782  this->user_presolve(this->system());
783 
784  //Set the preconditioning matrix
785  if (this->_preconditioner)
786  {
787  this->_preconditioner->set_matrix(pre_in);
788  this->_preconditioner->init();
789  }
790 
791  // If the SolverConfiguration object is provided, use it to override
792  // solver options.
793  if (this->_solver_configuration)
794  {
796  }
797 
798  ierr = SNESSetUp(_snes);
799  LIBMESH_CHKERR(ierr);
800 
801  Mat J;
802  ierr = SNESGetJacobian(_snes,&J,PETSC_NULL,PETSC_NULL,PETSC_NULL);
803  LIBMESH_CHKERR(ierr);
804  ierr = MatMFFDSetFunction(J, __libmesh_petsc_snes_mffd_interface, this);
805  LIBMESH_CHKERR(ierr);
806 #if !PETSC_RELEASE_LESS_THAN(3, 8, 4)
807  // Resue the residual vector from SNES
808  ierr = MatSNESMFSetReuseBase(J, PETSC_TRUE);
809  LIBMESH_CHKERR(ierr);
810 #endif
811 
812  ierr = SNESSolve (_snes, PETSC_NULL, x->vec());
813  LIBMESH_CHKERR(ierr);
814 
815  ierr = SNESGetIterationNumber(_snes,&n_iterations);
816  LIBMESH_CHKERR(ierr);
817 
818  ierr = SNESGetLinearSolveIterations(_snes, &_n_linear_iterations);
819  LIBMESH_CHKERR(ierr);
820 
821  // Enforce constraints exactly now that the solve is done. We have
822  // been enforcing them on the current_local_solution during the
823  // solve, but now need to be sure they are enforced on the parallel
824  // solution vector as well.
826 
827  // SNESGetFunction has been around forever and should work on all
828  // versions of PETSc. This is also now the recommended approach
829  // according to the documentation for the PETSc 3.5.1 release:
830  // http://www.mcs.anl.gov/petsc/documentation/changes/35.html
831  Vec f;
832  ierr = SNESGetFunction(_snes, &f, 0, 0);
833  LIBMESH_CHKERR(ierr);
834  ierr = VecNorm(f, NORM_2, &final_residual_norm);
835  LIBMESH_CHKERR(ierr);
836 
837  // Get and store the reason for convergence
838  SNESGetConvergedReason(_snes, &_reason);
839 
840  //Based on Petsc 2.3.3 documentation all diverged reasons are negative
841  this->converged = (_reason >= 0);
842 
843  this->clear();
844 
845  // return the # of its. and the final residual norm.
846  return std::make_pair(n_iterations, final_residual_norm);
847 }
virtual void clear() libmesh_override
friend PetscErrorCode __libmesh_petsc_snes_mffd_interface(void *ctx, Vec x, Vec r)
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
const DofMap & get_dof_map() const
Definition: system.h:2030
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 277 of file nonlinear_solver.h.

277 { 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 159 of file petsc_nonlinear_solver.h.

Friends And Related Function Documentation

template<typename T>
PetscErrorCode __libmesh_petsc_snes_fd_residual ( SNES  snes,
Vec  x,
Vec  r,
void *  ctx 
)
friend

Definition at line 178 of file petsc_nonlinear_solver.C.

179  {
180  ResidualContext rc = libmesh_petsc_snes_residual_helper(snes, x, ctx);
181 
182  libmesh_assert(r);
183  PetscVector<Number> R(r, rc.sys.comm());
184 
185  if (rc.solver->_zero_out_residual)
186  R.zero();
187 
188  if (rc.solver->fd_residual_object != libmesh_nullptr)
189  rc.solver->fd_residual_object->residual(*rc.sys.current_local_solution.get(), R, rc.sys);
190 
191  else if (rc.solver->residual_object != libmesh_nullptr)
192  rc.solver->residual_object->residual(*rc.sys.current_local_solution.get(), R, rc.sys);
193 
194  else
195  libmesh_error_msg("Error! Unable to compute residual for forming finite difference Jacobian!");
196 
197  R.close();
198 
199  return rc.ierr;
200  }
const class libmesh_nullptr_t libmesh_nullptr
friend ResidualContext libmesh_petsc_snes_residual_helper(SNES snes, Vec x, void *ctx)
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_mffd_interface ( void *  ctx,
Vec  x,
Vec  r 
)
friend

Definition at line 207 of file petsc_nonlinear_solver.C.

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

208  {
209  PetscErrorCode ierr = 0;
210  // No way to safety-check this cast, since we got a void *...
211  PetscNonlinearSolver<Number> * solver =
212  static_cast<PetscNonlinearSolver<Number> *> (ctx);
213 
214  ierr = __libmesh_petsc_snes_mffd_residual(solver->snes(), x, r, ctx);
215  return ierr;
216  }
friend PetscErrorCode __libmesh_petsc_snes_mffd_residual(SNES snes, Vec x, Vec r, void *ctx)
PetscErrorCode ierr
template<typename T>
PetscErrorCode __libmesh_petsc_snes_mffd_residual ( SNES  snes,
Vec  x,
Vec  r,
void *  ctx 
)
friend

Definition at line 222 of file petsc_nonlinear_solver.C.

223  {
224  ResidualContext rc = libmesh_petsc_snes_residual_helper(snes, x, ctx);
225 
226  libmesh_assert(r);
227  PetscVector<Number> R(r, rc.sys.comm());
228 
229  if (rc.solver->_zero_out_residual)
230  R.zero();
231 
232  if (rc.solver->mffd_residual_object != libmesh_nullptr)
233  rc.solver->mffd_residual_object->residual(*rc.sys.current_local_solution.get(), R, rc.sys);
234 
235  else if (rc.solver->residual_object != libmesh_nullptr)
236  rc.solver->residual_object->residual(*rc.sys.current_local_solution.get(), R, rc.sys);
237 
238  else
239  libmesh_error_msg("Error! Unable to compute residual for forming finite differenced"
240  "Jacobian-vector products!");
241 
242  R.close();
243 
244  return rc.ierr;
245  }
const class libmesh_nullptr_t libmesh_nullptr
friend ResidualContext libmesh_petsc_snes_residual_helper(SNES snes, Vec x, void *ctx)
template<typename T>
PetscErrorCode __libmesh_petsc_snes_residual ( SNES  snes,
Vec  x,
Vec  r,
void *  ctx 
)
friend

Definition at line 136 of file petsc_nonlinear_solver.C.

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

137  {
138  ResidualContext rc = libmesh_petsc_snes_residual_helper(snes, x, ctx);
139 
140  libmesh_assert(r);
141  PetscVector<Number> R(r, rc.sys.comm());
142 
143  if (rc.solver->_zero_out_residual)
144  R.zero();
145 
146  //-----------------------------------------------------------------------------
147  // if the user has provided both function pointers and objects only the pointer
148  // will be used, so catch that as an error
149  if (rc.solver->residual && rc.solver->residual_object)
150  libmesh_error_msg("ERROR: cannot specify both a function and object to compute the Residual!");
151 
152  if (rc.solver->matvec && rc.solver->residual_and_jacobian_object)
153  libmesh_error_msg("ERROR: cannot specify both a function and object to compute the combined Residual & Jacobian!");
154 
155  if (rc.solver->residual != libmesh_nullptr)
156  rc.solver->residual(*rc.sys.current_local_solution.get(), R, rc.sys);
157 
158  else if (rc.solver->residual_object != libmesh_nullptr)
159  rc.solver->residual_object->residual(*rc.sys.current_local_solution.get(), R, rc.sys);
160 
161  else if (rc.solver->matvec != libmesh_nullptr)
162  rc.solver->matvec (*rc.sys.current_local_solution.get(), &R, libmesh_nullptr, rc.sys);
163 
164  else if (rc.solver->residual_and_jacobian_object != libmesh_nullptr)
165  rc.solver->residual_and_jacobian_object->residual_and_jacobian (*rc.sys.current_local_solution.get(), &R, libmesh_nullptr, rc.sys);
166 
167  else
168  libmesh_error_msg("Error! Unable to compute residual and/or Jacobian!");
169 
170  R.close();
171 
172  return rc.ierr;
173  }
const class libmesh_nullptr_t libmesh_nullptr
friend ResidualContext libmesh_petsc_snes_residual_helper(SNES snes, Vec x, void *ctx)
template<typename T>
ResidualContext libmesh_petsc_snes_residual_helper ( SNES  snes,
Vec  x,
void *  ctx 
)
friend

Definition at line 58 of file petsc_nonlinear_solver.C.

59 {
60  LOG_SCOPE("residual()", "PetscNonlinearSolver");
61 
62  PetscErrorCode ierr = 0;
63 
64  libmesh_assert(x);
65  libmesh_assert(ctx);
66 
67  // No way to safety-check this cast, since we got a void *...
68  PetscNonlinearSolver<Number> * solver =
69  static_cast<PetscNonlinearSolver<Number> *> (ctx);
70 
71  // Get the current iteration number from the snes object,
72  // store it in the PetscNonlinearSolver object for possible use
73  // by the user's residual function.
74  {
75  PetscInt n_iterations = 0;
76  ierr = SNESGetIterationNumber(snes, &n_iterations);
77  CHKERRABORT(solver->comm().get(),ierr);
78  solver->_current_nonlinear_iteration_number = cast_int<unsigned>(n_iterations);
79  }
80 
81  NonlinearImplicitSystem & sys = solver->system();
82 
83  PetscVector<Number> & X_sys = *cast_ptr<PetscVector<Number> *>(sys.solution.get());
84 
85  PetscVector<Number> X_global(x, sys.comm());
86 
87  // Use the system's update() to get a good local version of the
88  // parallel solution. This operation does not modify the incoming
89  // "x" vector, it only localizes information from "x" into
90  // sys.current_local_solution.
91  X_global.swap(X_sys);
92  sys.update();
93  X_global.swap(X_sys);
94 
95  // Enforce constraints (if any) exactly on the
96  // current_local_solution. This is the solution vector that is
97  // actually used in the computation of the residual below, and is
98  // not locked by debug-enabled PETSc the way that "x" is.
99  sys.get_dof_map().enforce_constraints_exactly(sys, sys.current_local_solution.get());
100 
101  return ResidualContext(solver, sys, ierr);
102 }
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 203 of file petsc_nonlinear_solver.h.

Referenced by libMesh::PetscNonlinearSolver< T >::init(), and libMesh::PetscNonlinearSolver< Number >::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 358 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 183 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 363 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 178 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 369 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 353 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 198 of file petsc_nonlinear_solver.h.

Referenced by libMesh::__libmesh_petsc_snes_jacobian(), and libMesh::PetscNonlinearSolver< Number >::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 193 of file petsc_nonlinear_solver.h.

Referenced by libMesh::__libmesh_petsc_snes_fd_residual(), libMesh::__libmesh_petsc_snes_mffd_residual(), libMesh::__libmesh_petsc_snes_residual(), and libMesh::PetscNonlinearSolver< Number >::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 304 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 318 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 191 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 197 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 342 of file nonlinear_solver.h.

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

template<typename T>
NonlinearImplicitSystem::ComputeResidual* libMesh::NonlinearSolver< T >::fd_residual_object
inherited

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

Definition at line 144 of file nonlinear_solver.h.

Referenced by libMesh::__libmesh_petsc_snes_fd_residual().

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 331 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 157 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 165 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 174 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 292 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 325 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 287 of file nonlinear_solver.h.

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

template<typename T>
NonlinearImplicitSystem::ComputeResidual* libMesh::NonlinearSolver< T >::mffd_residual_object
inherited

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

Definition at line 151 of file nonlinear_solver.h.

Referenced by libMesh::__libmesh_petsc_snes_mffd_residual().

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

The tolerance for linear solves is kept above this minimum

Definition at line 336 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 234 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 241 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 205 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 213 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 255 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 267 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 305 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 319 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 130 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 186 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 138 of file nonlinear_solver.h.

Referenced by libMesh::__libmesh_petsc_snes_fd_residual(), libMesh::__libmesh_petsc_snes_mffd_residual(), 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 220 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 227 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 247 of file nonlinear_solver.h.

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


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