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 ()
 
virtual void init ()
 
SNES snes ()
 
virtual std::pair< unsigned
int, Real
solve (SparseMatrix< T > &, NumericVector< T > &, NumericVector< T > &, const double, const unsigned int)
 
virtual void print_converged_reason ()
 
SNESConvergedReason get_converged_reason ()
 
virtual int get_total_linear_iterations ()
 
virtual unsigned get_current_nonlinear_iteration_number () const
 
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)
 
const Parallel::Communicatorcomm () const
 
processor_id_type n_processors () const
 
processor_id_type processor_id () const
 

Static Public Member Functions

static AutoPtr
< 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(* nearnullspace )(std::vector< NumericVector< Number > * > &sp, sys_type &S)
 
NonlinearImplicitSystem::ComputeVectorSubspacenearnullspace_object
 
void(* user_presolve )(sys_type &S)
 
unsigned int max_nonlinear_iterations
 
unsigned int max_function_evaluations
 
Real absolute_residual_tolerance
 
Real relative_residual_tolerance
 
Real absolute_step_tolerance
 
Real relative_step_tolerance
 
unsigned int max_linear_iterations
 
Real initial_linear_tolerance
 
Real minimum_linear_tolerance
 
bool converged
 

Protected Types

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

Protected Member Functions

void increment_constructor_count (const std::string &name)
 
void increment_destructor_count (const std::string &name)
 

Protected Attributes

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
 
const Parallel::Communicator_communicator
 

Static Protected Attributes

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

Private Member Functions

void build_mat_null_space (NonlinearImplicitSystem::ComputeVectorSubspace *computeSubspaceObject, void(*)(std::vector< NumericVector< Number > * > &, sys_type &), MatNullSpace *)
 

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)
 

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, 2002-2007

Definition at line 59 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 113 of file reference_counter.h.

The type of system

Definition at line 65 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 244 of file petsc_nonlinear_solver.C.

244  :
245  NonlinearSolver<T>(system_in),
246  _reason(SNES_CONVERGED_ITERATING/*==0*/), // Arbitrary initial value...
249  _zero_out_residual(true),
250  _zero_out_jacobian(true),
251  _default_monitor(true)
252 {
253 }
template<typename T >
libMesh::PetscNonlinearSolver< T >::~PetscNonlinearSolver ( )

Destructor.

Definition at line 258 of file petsc_nonlinear_solver.C.

259 {
260  this->clear ();
261 }

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 91 of file nonlinear_solver.C.

References libMesh::libMeshPrivateData::_is_initialized, and libMesh::err.

92 {
93  if(this->_is_initialized)
94  {
95  libMesh::err << "Preconditioner must be attached before the solver is initialized!"<<std::endl;
96  libmesh_error();
97  }
98 
99  _preconditioner = preconditioner;
100 }
template<typename T >
AutoPtr< 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::err, libMesh::on_command_line(), libMeshEnums::PETSC_SOLVERS, libMesh::AutoPtr< Tp >::reset(), and libMesh::TRILINOS_SOLVERS.

39 {
40  AutoPtr<NonlinearSolver<T> > ap;
41 
42  // Build the appropriate solver
43  switch (solver_package)
44  {
45 
46 #ifdef LIBMESH_HAVE_PETSC
47  case PETSC_SOLVERS:
48 #if PETSC_VERSION_LESS_THAN(3,3,0)
49  ap.reset(new PetscNonlinearSolver<T>(s));
50  break;
51 #else
52  if (libMesh::on_command_line ("--use-petsc-dm")){
53  ap.reset(new PetscDMNonlinearSolver<T>(s));
54  }
55  else {
56  ap.reset(new PetscNonlinearSolver<T>(s));
57  }
58  break;
59 #endif
60 #endif // LIBMESH_HAVE_PETSC
61 
62 #ifdef LIBMESH_HAVE_NOX
63  case TRILINOS_SOLVERS:
64  ap.reset(new NoxNonlinearSolver<T>(s));
65  break;
66 #endif
67 
68  default:
69  libMesh::err << "ERROR: Unrecognized solver package: "
70  << solver_package
71  << std::endl;
72  libmesh_error();
73  }
74 
75  return ap;
76 }
template<typename T >
void libMesh::PetscNonlinearSolver< T >::build_mat_null_space ( NonlinearImplicitSystem::ComputeVectorSubspace computeSubspaceObject,
void(*)(std::vector< NumericVector< Number > * > &, sys_type &)  computeSubspace,
MatNullSpace *  msp 
)
private

Definition at line 354 of file petsc_nonlinear_solver.C.

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

357 {
359  std::vector<NumericVector<Number>* > sp;
360  if (computeSubspaceObject)
361  (*computeSubspaceObject)(sp, this->system());
362  else
363  (*computeSubspace)(sp, this->system());
364 
365  *msp = PETSC_NULL;
366  if (sp.size())
367  {
368  Vec *modes;
369  PetscScalar *dots;
370  PetscInt nmodes = sp.size();
371 
372 #if PETSC_RELEASE_LESS_THAN(3,5,0)
373  ierr = PetscMalloc2(nmodes,Vec,&modes,nmodes,PetscScalar,&dots);
374 #else
375  ierr = PetscMalloc2(nmodes,&modes,nmodes,&dots);
376 #endif
377  LIBMESH_CHKERRABORT(ierr);
378 
379  for (PetscInt i=0; i<nmodes; ++i)
380  {
381  PetscVector<T>* pv = libmesh_cast_ptr<PetscVector<T>*>(sp[i]);
382  Vec v = pv->vec();
383 
384  ierr = VecDuplicate(v, modes+i);
385  LIBMESH_CHKERRABORT(ierr);
386 
387  ierr = VecCopy(v,modes[i]);
388  LIBMESH_CHKERRABORT(ierr);
389  }
390 
391  // Normalize.
392  ierr = VecNormalize(modes[0],PETSC_NULL);
393  LIBMESH_CHKERRABORT(ierr);
394 
395  for (PetscInt i=1; i<nmodes; i++)
396  {
397  // Orthonormalize vec[i] against vec[0:i-1]
398  ierr = VecMDot(modes[i],i,modes,dots);
399  LIBMESH_CHKERRABORT(ierr);
400 
401  for (PetscInt j=0; j<i; j++)
402  dots[j] *= -1.;
403 
404  ierr = VecMAXPY(modes[i],i,dots,modes);
405  LIBMESH_CHKERRABORT(ierr);
406 
407  ierr = VecNormalize(modes[i],PETSC_NULL);
408  LIBMESH_CHKERRABORT(ierr);
409  }
410 
411  ierr = MatNullSpaceCreate(this->comm().get(), PETSC_FALSE, nmodes, modes, msp);
412  LIBMESH_CHKERRABORT(ierr);
413 
414  for (PetscInt i=0; i<nmodes; ++i)
415  {
416  ierr = VecDestroy(modes+i);
417  LIBMESH_CHKERRABORT(ierr);
418  }
419 
420  ierr = PetscFree2(modes,dots);
421  LIBMESH_CHKERRABORT(ierr);
422  }
423 }
template<typename T >
void libMesh::PetscNonlinearSolver< T >::clear ( )
virtual

Release all memory and clear data structures.

Reimplemented from libMesh::NonlinearSolver< T >.

Definition at line 266 of file petsc_nonlinear_solver.C.

References libMesh::libMeshPrivateData::_is_initialized, libMesh::ierr, and libMesh::initialized().

267 {
268  if (this->initialized())
269  {
270  this->_is_initialized = false;
271 
273 
274  ierr = LibMeshSNESDestroy(&_snes);
275  LIBMESH_CHKERRABORT(ierr);
276 
277  // Reset the nonlinear iteration counter. This information is only relevant
278  // *during* the solve(). After the solve is completed it should return to
279  // the default value of 0.
281  }
282 }
const Parallel::Communicator& libMesh::ParallelObject::comm ( ) const
inlineinherited
Returns
a reference to the Parallel::Communicator object used by this mesh.

Definition at line 86 of file parallel_object.h.

References libMesh::ParallelObject::_communicator.

Referenced by libMesh::__libmesh_petsc_diff_solver_jacobian(), libMesh::__libmesh_petsc_diff_solver_monitor(), libMesh::__libmesh_petsc_diff_solver_residual(), libMesh::__libmesh_petsc_snes_jacobian(), libMesh::__libmesh_petsc_snes_residual(), libMesh::MeshRefinement::_coarsen_elements(), libMesh::ExactSolution::_compute_error(), libMesh::MetisPartitioner::_do_partition(), libMesh::ParmetisPartitioner::_do_repartition(), libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::SlepcEigenSolver< T >::_petsc_shell_matrix_get_diagonal(), libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_get_diagonal(), libMesh::SlepcEigenSolver< T >::_petsc_shell_matrix_mult(), libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_mult(), libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_mult_add(), libMesh::EquationSystems::_read_impl(), libMesh::MeshRefinement::_refine_elements(), libMesh::ParallelMesh::add_elem(), libMesh::ImplicitSystem::add_matrix(), libMesh::ParallelMesh::add_node(), libMesh::System::add_vector(), libMesh::UnstructuredMesh::all_second_order(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::FEMSystem::assemble_qoi(), libMesh::MeshCommunication::assign_global_indices(), libMesh::ParmetisPartitioner::assign_partitioning(), libMesh::DofMap::attach_matrix(), libMesh::MeshTools::bounding_box(), libMesh::System::calculate_norm(), libMesh::MeshRefinement::coarsen_elements(), 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::MeshCommunication::delete_remote_elements(), libMesh::DofMap::distribute_dofs(), DMlibMeshFunction(), DMlibMeshJacobian(), DMLibMeshSetSystem(), DMVariableBounds_libMesh(), libMesh::MeshRefinement::eliminate_unrefined_patches(), libMesh::WeightedPatchRecoveryErrorEstimator::estimate_error(), libMesh::PatchRecoveryErrorEstimator::estimate_error(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::MeshRefinement::flag_elements_by_elem_fraction(), libMesh::MeshRefinement::flag_elements_by_error_fraction(), libMesh::MeshRefinement::flag_elements_by_nelem_target(), libMesh::for(), libMesh::CondensedEigenSystem::get_eigenpair(), libMesh::ImplicitSystem::get_linear_solver(), libMesh::LocationMap< T >::init(), libMesh::PetscDiffSolver::init(), libMesh::TimeSolver::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::EigenSystem::init_data(), libMesh::EigenSystem::init_matrices(), libMesh::ParmetisPartitioner::initialize(), libMesh::MeshTools::libmesh_assert_valid_dof_ids(), libMesh::ParallelMesh::libmesh_assert_valid_parallel_flags(), libMesh::MeshTools::libmesh_assert_valid_procids< Elem >(), libMesh::MeshTools::libmesh_assert_valid_procids< Node >(), libMesh::MeshTools::libmesh_assert_valid_refinement_flags(), libMesh::MeshRefinement::limit_level_mismatch_at_edge(), libMesh::MeshRefinement::limit_level_mismatch_at_node(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshCommunication::make_elems_parallel_consistent(), libMesh::MeshRefinement::make_flags_parallel_consistent(), libMesh::MeshCommunication::make_node_ids_parallel_consistent(), libMesh::MeshCommunication::make_node_proc_ids_parallel_consistent(), libMesh::MeshCommunication::make_nodes_parallel_consistent(), libMesh::MeshRefinement::make_refinement_compatible(), libMesh::FEMSystem::mesh_position_set(), libMesh::MeshSerializer::MeshSerializer(), libMesh::ParallelMesh::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::ParallelMesh::parallel_max_elem_id(), libMesh::ParallelMesh::parallel_max_node_id(), libMesh::ParallelMesh::parallel_n_elem(), libMesh::ParallelMesh::parallel_n_nodes(), libMesh::Partitioner::partition(), libMesh::Partitioner::partition_unpartitioned_elements(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::MeshBase::prepare_for_use(), libMesh::System::project_vector(), libMesh::Nemesis_IO::read(), libMesh::XdrIO::read(), libMesh::System::read_header(), libMesh::System::read_legacy_data(), libMesh::System::read_SCALAR_dofs(), libMesh::XdrIO::read_serialized_bc_names(), libMesh::XdrIO::read_serialized_bcs(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::System::read_serialized_vector(), libMesh::MeshBase::recalculate_n_partitions(), libMesh::MeshRefinement::refine_and_coarsen_elements(), libMesh::MeshRefinement::refine_elements(), libMesh::Partitioner::set_node_processor_ids(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::MeshBase::subdomain_ids(), libMesh::BoundaryInfo::sync(), libMesh::Parallel::sync_element_data_by_parent_id(), libMesh::MeshRefinement::test_level_one(), libMesh::MeshRefinement::test_unflagged(), libMesh::MeshTools::total_weight(), libMesh::CheckpointIO::write(), libMesh::XdrIO::write(), libMesh::UnstructuredMesh::write(), libMesh::LegacyXdrIO::write_mesh(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bcs(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), libMesh::XdrIO::write_serialized_nodesets(), and libMesh::DivaIO::write_stream().

87  { return _communicator; }
void libMesh::ReferenceCounter::disable_print_counter_info ( )
staticinherited

Definition at line 106 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

107 {
108  _enable_print_counter = false;
109  return;
110 }
void libMesh::ReferenceCounter::enable_print_counter_info ( )
staticinherited

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

Definition at line 100 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

101 {
102  _enable_print_counter = true;
103  return;
104 }
template<typename T >
SNESConvergedReason libMesh::PetscNonlinearSolver< T >::get_converged_reason ( )

Returns the currently-available (or most recently obtained, if the SNES object has been destroyed) convergence reason. Refer to PETSc docs for the meaning of different SNESConvergedReasons.

Definition at line 578 of file petsc_nonlinear_solver.C.

References libMesh::ierr, and libMesh::initialized().

579 {
581 
582  if (this->initialized())
583  {
584  ierr = SNESGetConvergedReason(_snes, &_reason);
585  LIBMESH_CHKERRABORT(ierr);
586  }
587 
588  return _reason;
589 }
template<typename T>
virtual unsigned libMesh::PetscNonlinearSolver< T >::get_current_nonlinear_iteration_number ( ) const
inlinevirtual

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

Implements libMesh::NonlinearSolver< T >.

Definition at line 126 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 }
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 592 of file petsc_nonlinear_solver.C.

593 {
594  return _n_linear_iterations;
595 }
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 163 of file reference_counter.h.

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

Referenced by libMesh::ReferenceCountedObject< RBParametrized >::ReferenceCountedObject().

164 {
165  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
166  std::pair<unsigned int, unsigned int>& p = _counts[name];
167 
168  p.first++;
169 }
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 176 of file reference_counter.h.

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

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

177 {
178  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
179  std::pair<unsigned int, unsigned int>& p = _counts[name];
180 
181  p.second++;
182 }
template<typename T >
void libMesh::PetscNonlinearSolver< T >::init ( )
virtual

Initialize data structures if not done so already.

Implements libMesh::NonlinearSolver< T >.

Reimplemented in libMesh::PetscDMNonlinearSolver< T >.

Definition at line 287 of file petsc_nonlinear_solver.C.

References libMesh::__libmesh_petsc_preconditioner_apply(), libMesh::__libmesh_petsc_preconditioner_setup(), libMesh::__libmesh_petsc_snes_monitor(), libMesh::libMeshPrivateData::_is_initialized, libMesh::comm, libMesh::ierr, and libMesh::initialized().

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

288 {
289  // Initialize the data structures if not done so already.
290  if (!this->initialized())
291  {
292  this->_is_initialized = true;
293 
295 
296 #if PETSC_VERSION_LESS_THAN(2,1,2)
297  // At least until Petsc 2.1.1, the SNESCreate had a different calling syntax.
298  // The second argument was of type SNESProblemType, and could have a value of
299  // either SNES_NONLINEAR_EQUATIONS or SNES_UNCONSTRAINED_MINIMIZATION.
300  ierr = SNESCreate(this->comm().get(), SNES_NONLINEAR_EQUATIONS, &_snes);
301  LIBMESH_CHKERRABORT(ierr);
302 
303 #else
304 
305  ierr = SNESCreate(this->comm().get(),&_snes);
306  LIBMESH_CHKERRABORT(ierr);
307 
308 #endif
309 
310  if (_default_monitor)
311  {
312 #if PETSC_VERSION_LESS_THAN(2,3,3)
313  ierr = SNESSetMonitor (_snes, __libmesh_petsc_snes_monitor,
314  this, PETSC_NULL);
315 #else
316  // API name change in PETSc 2.3.3
317  ierr = SNESMonitorSet (_snes, __libmesh_petsc_snes_monitor,
318  this, PETSC_NULL);
319 #endif
320  LIBMESH_CHKERRABORT(ierr);
321  }
322 
323 #if PETSC_VERSION_LESS_THAN(3,1,0)
324  // Cannot call SNESSetOptions before SNESSetFunction when using
325  // any matrix free options with PETSc 3.1.0+
326  ierr = SNESSetFromOptions(_snes);
327  LIBMESH_CHKERRABORT(ierr);
328 #endif
329 
330  if(this->_preconditioner)
331  {
332  KSP ksp;
333  ierr = SNESGetKSP (_snes, &ksp);
334  LIBMESH_CHKERRABORT(ierr);
335  PC pc;
336  ierr = KSPGetPC(ksp,&pc);
337  LIBMESH_CHKERRABORT(ierr);
338 
339  this->_preconditioner->init();
340 
341  PCSetType(pc, PCSHELL);
342  PCShellSetContext(pc,(void*)this->_preconditioner);
343 
344  //Re-Use the shell functions from petsc_linear_solver
345  PCShellSetSetUp(pc,__libmesh_petsc_preconditioner_setup);
346  PCShellSetApply(pc,__libmesh_petsc_preconditioner_apply);
347  }
348  }
349 }
template<typename T>
bool libMesh::NonlinearSolver< T >::initialized ( ) const
inlineinherited
Returns
true if the data structures are initialized, false otherwise.

Definition at line 86 of file nonlinear_solver.h.

86 { return _is_initialized; }
static unsigned int libMesh::ReferenceCounter::n_objects ( )
inlinestaticinherited

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

Definition at line 79 of file reference_counter.h.

References libMesh::ReferenceCounter::_n_objects.

80  { return _n_objects; }
processor_id_type libMesh::ParallelObject::n_processors ( ) const
inlineinherited
Returns
the number of processors in the group.

Definition at line 92 of file parallel_object.h.

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

Referenced by libMesh::ParmetisPartitioner::_do_repartition(), libMesh::ParallelMesh::add_elem(), libMesh::ParallelMesh::add_node(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::ParmetisPartitioner::assign_partitioning(), libMesh::ParallelMesh::assign_unique_ids(), libMesh::AztecLinearSolver< T >::AztecLinearSolver(), libMesh::ParallelMesh::clear(), libMesh::Nemesis_IO_Helper::compute_border_node_ids(), libMesh::Nemesis_IO_Helper::construct_nemesis_filename(), libMesh::UnstructuredMesh::create_pid_mesh(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::distribute_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), libMesh::EnsightIO::EnsightIO(), libMesh::MeshBase::get_info(), libMesh::EquationSystems::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::ParmetisPartitioner::initialize(), libMesh::Nemesis_IO_Helper::initialize(), libMesh::MeshTools::libmesh_assert_valid_dof_ids(), libMesh::MeshTools::libmesh_assert_valid_procids< Elem >(), libMesh::MeshTools::libmesh_assert_valid_procids< Node >(), libMesh::MeshTools::libmesh_assert_valid_refinement_flags(), libMesh::MeshBase::n_active_elem_on_proc(), libMesh::MeshBase::n_elem_on_proc(), libMesh::MeshBase::n_nodes_on_proc(), 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::MeshTools::processor_bounding_box(), libMesh::System::project_vector(), libMesh::Nemesis_IO::read(), libMesh::CheckpointIO::read(), libMesh::UnstructuredMesh::read(), libMesh::System::read_parallel_data(), libMesh::System::read_SCALAR_dofs(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::System::read_serialized_vector(), libMesh::Partitioner::repartition(), libMesh::Partitioner::set_node_processor_ids(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::BoundaryInfo::sync(), libMesh::ParallelMesh::update_parallel_id_counts(), libMesh::CheckpointIO::write(), libMesh::GMVIO::write_binary(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::System::write_parallel_data(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bcs(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), and libMesh::XdrIO::write_serialized_nodesets().

93  { return libmesh_cast_int<processor_id_type>(_communicator.size()); }
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 568 of file petsc_nonlinear_solver.C.

References libMesh::out.

569 {
570 
571  libMesh::out << "Nonlinear solver convergence/divergence reason: "
572  << SNESConvergedReasons[this->get_converged_reason()] << std::endl;
573 }
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().

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

Definition at line 98 of file parallel_object.h.

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

Referenced by libMesh::MetisPartitioner::_do_partition(), libMesh::EquationSystems::_read_impl(), libMesh::SerialMesh::active_local_elements_begin(), libMesh::ParallelMesh::active_local_elements_begin(), libMesh::SerialMesh::active_local_elements_end(), libMesh::ParallelMesh::active_local_elements_end(), libMesh::SerialMesh::active_local_subdomain_elements_begin(), libMesh::ParallelMesh::active_local_subdomain_elements_begin(), libMesh::SerialMesh::active_local_subdomain_elements_end(), libMesh::ParallelMesh::active_local_subdomain_elements_end(), libMesh::SerialMesh::active_not_local_elements_begin(), libMesh::ParallelMesh::active_not_local_elements_begin(), libMesh::SerialMesh::active_not_local_elements_end(), libMesh::ParallelMesh::active_not_local_elements_end(), libMesh::ParallelMesh::add_elem(), libMesh::DofMap::add_neighbors_to_send_list(), libMesh::ParallelMesh::add_node(), libMesh::UnstructuredMesh::all_second_order(), libMesh::ParmetisPartitioner::assign_partitioning(), 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::DofMap::build_sparsity(), libMesh::ParallelMesh::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::ExodusII_IO_Helper::create(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::distribute_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), libMesh::DofMap::end_dof(), libMesh::DofMap::end_old_dof(), libMesh::EnsightIO::EnsightIO(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::DofMap::first_dof(), libMesh::DofMap::first_old_dof(), libMesh::Nemesis_IO_Helper::get_cmap_params(), libMesh::Nemesis_IO_Helper::get_eb_info_global(), libMesh::Nemesis_IO_Helper::get_elem_cmap(), libMesh::Nemesis_IO_Helper::get_elem_map(), libMesh::MeshBase::get_info(), libMesh::Nemesis_IO_Helper::get_init_global(), libMesh::Nemesis_IO_Helper::get_init_info(), libMesh::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::Nemesis_IO_Helper::get_ss_param_global(), libMesh::MeshFunction::gradient(), libMesh::MeshFunction::hessian(), libMesh::SystemSubsetBySubdomain::init(), libMesh::ParmetisPartitioner::initialize(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::ExodusII_IO_Helper::initialize_discontinuous(), libMesh::ExodusII_IO_Helper::initialize_element_variables(), libMesh::ExodusII_IO_Helper::initialize_global_variables(), libMesh::ExodusII_IO_Helper::initialize_nodal_variables(), libMesh::SparsityPattern::Build::join(), libMesh::DofMap::last_dof(), libMesh::MeshTools::libmesh_assert_valid_procids< Elem >(), libMesh::MeshTools::libmesh_assert_valid_procids< Node >(), libMesh::SerialMesh::local_elements_begin(), libMesh::ParallelMesh::local_elements_begin(), libMesh::SerialMesh::local_elements_end(), libMesh::ParallelMesh::local_elements_end(), libMesh::SerialMesh::local_level_elements_begin(), libMesh::ParallelMesh::local_level_elements_begin(), libMesh::SerialMesh::local_level_elements_end(), libMesh::ParallelMesh::local_level_elements_end(), libMesh::SerialMesh::local_nodes_begin(), libMesh::ParallelMesh::local_nodes_begin(), libMesh::SerialMesh::local_nodes_end(), libMesh::ParallelMesh::local_nodes_end(), libMesh::SerialMesh::local_not_level_elements_begin(), libMesh::ParallelMesh::local_not_level_elements_begin(), libMesh::SerialMesh::local_not_level_elements_end(), libMesh::ParallelMesh::local_not_level_elements_end(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshBase::n_active_local_elem(), libMesh::BoundaryInfo::n_boundary_conds(), libMesh::BoundaryInfo::n_edge_conds(), libMesh::DofMap::n_local_dofs(), libMesh::System::n_local_dofs(), libMesh::MeshBase::n_local_elem(), libMesh::MeshBase::n_local_nodes(), libMesh::BoundaryInfo::n_nodeset_conds(), libMesh::SerialMesh::not_local_elements_begin(), libMesh::ParallelMesh::not_local_elements_begin(), libMesh::SerialMesh::not_local_elements_end(), libMesh::ParallelMesh::not_local_elements_end(), libMesh::WeightedPatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::SparsityPattern::Build::operator()(), libMesh::PatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::MeshFunction::operator()(), libMesh::ParallelMesh::ParallelMesh(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::System::project_vector(), 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::Nemesis_IO::read(), libMesh::CheckpointIO::read(), libMesh::XdrIO::read(), libMesh::UnstructuredMesh::read(), libMesh::CheckpointIO::read_connectivity(), libMesh::ExodusII_IO_Helper::read_elem_num_map(), libMesh::System::read_header(), libMesh::System::read_legacy_data(), libMesh::ExodusII_IO_Helper::read_node_num_map(), libMesh::System::read_parallel_data(), libMesh::System::read_SCALAR_dofs(), libMesh::XdrIO::read_serialized_bc_names(), libMesh::XdrIO::read_serialized_bcs(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::System::read_serialized_data(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::System::read_serialized_vector(), libMesh::System::read_serialized_vectors(), libMesh::MeshData::read_xdr(), libMesh::Partitioner::set_node_processor_ids(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::BoundaryInfo::sync(), libMesh::MeshTools::total_weight(), libMesh::ParallelMesh::update_parallel_id_counts(), libMesh::MeshTools::weight(), libMesh::ExodusII_IO::write(), libMesh::CheckpointIO::write(), libMesh::XdrIO::write(), libMesh::UnstructuredMesh::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_Helper::write_elements_discontinuous(), libMesh::ExodusII_IO::write_global_data(), libMesh::ExodusII_IO_Helper::write_global_values(), libMesh::System::write_header(), libMesh::ExodusII_IO::write_information_records(), libMesh::ExodusII_IO_Helper::write_information_records(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates_discontinuous(), 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::ExodusII_IO_Helper::write_nodesets(), libMesh::Nemesis_IO_Helper::write_nodesets(), libMesh::System::write_parallel_data(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bc_names(), libMesh::XdrIO::write_serialized_bcs(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::System::write_serialized_data(), libMesh::XdrIO::write_serialized_nodes(), libMesh::XdrIO::write_serialized_nodesets(), libMesh::XdrIO::write_serialized_subdomain_names(), libMesh::System::write_serialized_vector(), libMesh::System::write_serialized_vectors(), libMesh::ExodusII_IO_Helper::write_sidesets(), libMesh::Nemesis_IO_Helper::write_sidesets(), libMesh::ExodusII_IO::write_timestep(), and libMesh::ExodusII_IO_Helper::write_timestep().

99  { return libmesh_cast_int<processor_id_type>(_communicator.rank()); }
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 136 of file petsc_nonlinear_solver.h.

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

136 { _zero_out_jacobian = state; }
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 131 of file petsc_nonlinear_solver.h.

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

131 { _zero_out_residual = state; }
template<typename T>
SNES libMesh::PetscNonlinearSolver< T >::snes ( )
inline

Returns the raw PETSc snes context pointer.

Definition at line 91 of file petsc_nonlinear_solver.h.

References libMesh::PetscNonlinearSolver< T >::_snes, and libMesh::PetscNonlinearSolver< T >::init().

91 { this->init(); return _snes; }
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 >.

Reimplemented in libMesh::PetscDMNonlinearSolver< T >.

Definition at line 428 of file petsc_nonlinear_solver.C.

References libMesh::__libmesh_petsc_snes_jacobian(), libMesh::__libmesh_petsc_snes_residual(), libMesh::ierr, libMesh::TriangleWrapper::init(), libMesh::PetscMatrix< T >::mat(), libMesh::Real, libMesh::START_LOG(), and libMesh::STOP_LOG().

433 {
434  START_LOG("solve()", "PetscNonlinearSolver");
435  this->init ();
436 
437  // Make sure the data passed in are really of Petsc types
438  PetscMatrix<T>* jac = libmesh_cast_ptr<PetscMatrix<T>*>(&jac_in);
439  PetscVector<T>* x = libmesh_cast_ptr<PetscVector<T>*>(&x_in);
440  PetscVector<T>* r = libmesh_cast_ptr<PetscVector<T>*>(&r_in);
441 
443  PetscInt n_iterations =0;
444  // Should actually be a PetscReal, but I don't know which version of PETSc first introduced PetscReal
445  Real final_residual_norm=0.;
446 
447  ierr = SNESSetFunction (_snes, r->vec(), __libmesh_petsc_snes_residual, this);
448  LIBMESH_CHKERRABORT(ierr);
449 
450  // Only set the jacobian function if we've been provided with something to call.
451  // This allows a user to set their own jacobian function if they want to
452  if (this->jacobian || this->jacobian_object || this->residual_and_jacobian_object)
453  {
454  ierr = SNESSetJacobian (_snes, jac->mat(), jac->mat(), __libmesh_petsc_snes_jacobian, this);
455  LIBMESH_CHKERRABORT(ierr);
456  }
457 #if !PETSC_VERSION_LESS_THAN(3,3,0)
458  // Only set the nullspace if we have a way of computing it and the result is non-empty.
459  if (this->nullspace || this->nullspace_object)
460  {
461  MatNullSpace msp;
462  this->build_mat_null_space(this->nullspace_object, this->nullspace, &msp);
463  if (msp)
464  {
465  ierr = MatSetNullSpace(jac->mat(), msp);
466  LIBMESH_CHKERRABORT(ierr);
467 
468  ierr = MatNullSpaceDestroy(&msp);
469  LIBMESH_CHKERRABORT(ierr);
470  }
471  }
472 
473  // Only set the nearnullspace if we have a way of computing it and the result is non-empty.
474  if (this->nearnullspace || this->nearnullspace_object)
475  {
476  MatNullSpace msp = PETSC_NULL;
477  this->build_mat_null_space(this->nearnullspace_object, this->nearnullspace, &msp);
478 
479  if(msp) {
480  ierr = MatSetNearNullSpace(jac->mat(), msp);
481  LIBMESH_CHKERRABORT(ierr);
482 
483  ierr = MatNullSpaceDestroy(&msp);
484  LIBMESH_CHKERRABORT(ierr);
485  }
486  }
487 #endif
488  // Have the Krylov subspace method use our good initial guess rather than 0
489  KSP ksp;
490  ierr = SNESGetKSP (_snes, &ksp);
491  LIBMESH_CHKERRABORT(ierr);
492 
493  // Set the tolerances for the iterative solver. Use the user-supplied
494  // tolerance for the relative residual & leave the others at default values
495  ierr = KSPSetTolerances (ksp, this->initial_linear_tolerance, PETSC_DEFAULT,
496  PETSC_DEFAULT, this->max_linear_iterations);
497  LIBMESH_CHKERRABORT(ierr);
498 
499  // Set the tolerances for the non-linear solver.
500  ierr = SNESSetTolerances(_snes, this->absolute_residual_tolerance, this->relative_residual_tolerance,
502  LIBMESH_CHKERRABORT(ierr);
503 
504  //Pull in command-line options
505  KSPSetFromOptions(ksp);
506  SNESSetFromOptions(_snes);
507 
508  if (this->user_presolve)
509  this->user_presolve(this->system());
510 
511  //Set the preconditioning matrix
512  if(this->_preconditioner)
513  {
514  this->_preconditioner->set_matrix(jac_in);
515  this->_preconditioner->init();
516  }
517 
518 // ierr = KSPSetInitialGuessNonzero (ksp, PETSC_TRUE);
519 // LIBMESH_CHKERRABORT(ierr);
520 
521 // Older versions (at least up to 2.1.5) of SNESSolve took 3 arguments,
522 // the last one being a pointer to an int to hold the number of iterations required.
523 # if PETSC_VERSION_LESS_THAN(2,2,0)
524 
525  ierr = SNESSolve (_snes, x->vec(), &n_iterations);
526  LIBMESH_CHKERRABORT(ierr);
527 
528 // 2.2.x style
529 #elif PETSC_VERSION_LESS_THAN(2,3,0)
530 
531  ierr = SNESSolve (_snes, x->vec());
532  LIBMESH_CHKERRABORT(ierr);
533 
534 // 2.3.x & newer style
535 #else
536 
537  ierr = SNESSolve (_snes, PETSC_NULL, x->vec());
538  LIBMESH_CHKERRABORT(ierr);
539 
540  ierr = SNESGetIterationNumber(_snes,&n_iterations);
541  LIBMESH_CHKERRABORT(ierr);
542 
543  ierr = SNESGetLinearSolveIterations(_snes, &_n_linear_iterations);
544  LIBMESH_CHKERRABORT(ierr);
545 
546  ierr = SNESGetFunctionNorm(_snes,&final_residual_norm);
547  LIBMESH_CHKERRABORT(ierr);
548 
549 #endif
550 
551  // Get and store the reason for convergence
552  SNESGetConvergedReason(_snes, &_reason);
553 
554  //Based on Petsc 2.3.3 documentation all diverged reasons are negative
555  this->converged = (_reason >= 0);
556 
557  this->clear();
558 
559  STOP_LOG("solve()", "PetscNonlinearSolver");
560 
561  // return the # of its. and the final residual norm.
562  return std::make_pair(n_iterations, final_residual_norm);
563 }
template<typename T>
const sys_type& libMesh::NonlinearSolver< T >::system ( ) const
inlineinherited
template<typename T>
sys_type& libMesh::NonlinearSolver< T >::system ( )
inlineinherited
Returns
a writeable reference to the system we are solving.

Definition at line 224 of file nonlinear_solver.h.

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

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

Definition at line 141 of file petsc_nonlinear_solver.h.

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

141 { _default_monitor = state; }

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

Definition at line 157 of file petsc_nonlinear_solver.C.

158  {
159  START_LOG("jacobian()", "PetscNonlinearSolver");
160 
162 
163  libmesh_assert(ctx);
164 
165  PetscNonlinearSolver<Number>* solver =
166  static_cast<PetscNonlinearSolver<Number>*> (ctx);
167 
168  // Get the current iteration number from the snes object,
169  // store it in the PetscNonlinearSolver object for possible use
170  // by the user's Jacobian function.
171  {
172  PetscInt n_iterations = 0;
173  ierr = SNESGetIterationNumber(snes, &n_iterations);
174  CHKERRABORT(solver->comm().get(),ierr);
175  solver->_current_nonlinear_iteration_number = static_cast<unsigned>(n_iterations);
176  }
177 
178  NonlinearImplicitSystem &sys = solver->system();
179 
180  PetscMatrix<Number> PC(*pc, sys.comm());
181  PetscMatrix<Number> Jac(*jac, sys.comm());
182  PetscVector<Number>& X_sys = *libmesh_cast_ptr<PetscVector<Number>*>(sys.solution.get());
183  PetscMatrix<Number>& Jac_sys = *libmesh_cast_ptr<PetscMatrix<Number>*>(sys.matrix);
184  PetscVector<Number> X_global(x, sys.comm());
185 
186  // Set the dof maps
187  PC.attach_dof_map(sys.get_dof_map());
188  Jac.attach_dof_map(sys.get_dof_map());
189 
190  // Use the systems update() to get a good local version of the parallel solution
191  X_global.swap(X_sys);
192  Jac.swap(Jac_sys);
193 
194  sys.get_dof_map().enforce_constraints_exactly(sys);
195  sys.update();
196 
197  X_global.swap(X_sys);
198  Jac.swap(Jac_sys);
199 
200  if (solver->_zero_out_jacobian)
201  PC.zero();
202 
203  //-----------------------------------------------------------------------------
204  // if the user has provided both function pointers and objects only the pointer
205  // will be used, so catch that as an error
206  if (solver->jacobian && solver->jacobian_object)
207  {
208  libMesh::err << "ERROR: cannot specify both a function and object to compute the Jacobian!" << std::endl;
209  libmesh_error();
210  }
211 
212  if (solver->matvec && solver->residual_and_jacobian_object)
213  {
214  libMesh::err << "ERROR: cannot specify both a function and object to compute the combined Residual & Jacobian!" << std::endl;
215  libmesh_error();
216  }
217  //-----------------------------------------------------------------------------
218 
219  if (solver->jacobian != NULL) solver->jacobian (*sys.current_local_solution.get(), PC, sys);
220  else if (solver->jacobian_object != NULL) solver->jacobian_object->jacobian (*sys.current_local_solution.get(), PC, sys);
221  else if (solver->matvec != NULL) solver->matvec (*sys.current_local_solution.get(), NULL, &PC, sys);
222  else if (solver->residual_and_jacobian_object != NULL) solver->residual_and_jacobian_object->residual_and_jacobian (*sys.current_local_solution.get(), NULL, &PC, sys);
223  else libmesh_error();
224 
225  PC.close();
226  Jac.close();
227  X_global.close();
228 
229  *msflag = SAME_NONZERO_PATTERN;
230 
231  STOP_LOG("jacobian()", "PetscNonlinearSolver");
232 
233  return ierr;
234  }
template<typename T>
PetscErrorCode __libmesh_petsc_snes_residual ( SNES  snes,
Vec  x,
Vec  r,
void *  ctx 
)
friend

Definition at line 78 of file petsc_nonlinear_solver.C.

79  {
80  START_LOG("residual()", "PetscNonlinearSolver");
81 
83 
84  libmesh_assert(x);
85  libmesh_assert(r);
86  libmesh_assert(ctx);
87 
88  PetscNonlinearSolver<Number>* solver =
89  static_cast<PetscNonlinearSolver<Number>*> (ctx);
90 
91  // Get the current iteration number from the snes object,
92  // store it in the PetscNonlinearSolver object for possible use
93  // by the user's residual function.
94  {
95  PetscInt n_iterations = 0;
96  ierr = SNESGetIterationNumber(snes, &n_iterations);
97  CHKERRABORT(solver->comm().get(),ierr);
98  solver->_current_nonlinear_iteration_number = static_cast<unsigned>(n_iterations);
99  }
100 
101  NonlinearImplicitSystem &sys = solver->system();
102 
103  PetscVector<Number>& X_sys = *libmesh_cast_ptr<PetscVector<Number>*>(sys.solution.get());
104  PetscVector<Number>& R_sys = *libmesh_cast_ptr<PetscVector<Number>*>(sys.rhs);
105  PetscVector<Number> X_global(x, sys.comm()), R(r, sys.comm());
106 
107  // Use the systems update() to get a good local version of the parallel solution
108  X_global.swap(X_sys);
109  R.swap(R_sys);
110 
111  sys.get_dof_map().enforce_constraints_exactly(sys);
112 
113  sys.update();
114 
115  //Swap back
116  X_global.swap(X_sys);
117  R.swap(R_sys);
118 
119  if (solver->_zero_out_residual)
120  R.zero();
121 
122  //-----------------------------------------------------------------------------
123  // if the user has provided both function pointers and objects only the pointer
124  // will be used, so catch that as an error
125  if (solver->residual && solver->residual_object)
126  {
127  libMesh::err << "ERROR: cannot specifiy both a function and object to compute the Residual!" << std::endl;
128  libmesh_error();
129  }
130 
131  if (solver->matvec && solver->residual_and_jacobian_object)
132  {
133  libMesh::err << "ERROR: cannot specifiy both a function and object to compute the combined Residual & Jacobian!" << std::endl;
134  libmesh_error();
135  }
136  //-----------------------------------------------------------------------------
137 
138  if (solver->residual != NULL) solver->residual (*sys.current_local_solution.get(), R, sys);
139  else if (solver->residual_object != NULL) solver->residual_object->residual (*sys.current_local_solution.get(), R, sys);
140  else if (solver->matvec != NULL) solver->matvec (*sys.current_local_solution.get(), &R, NULL, sys);
141  else if (solver->residual_and_jacobian_object != NULL) solver->residual_and_jacobian_object->residual_and_jacobian (*sys.current_local_solution.get(), &R, NULL, sys);
142  else libmesh_error();
143 
144  R.close();
145  X_global.close();
146 
147  STOP_LOG("residual()", "PetscNonlinearSolver");
148 
149  return ierr;
150  }

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

Referenced by 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 137 of file reference_counter.h.

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

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

Flag indicating if the data structures have been initialized.

Definition at line 300 of file nonlinear_solver.h.

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

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

Mutual exclusion object to enable thread-safe reference counting.

Definition at line 131 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 161 of file petsc_nonlinear_solver.h.

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

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

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

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

Definition at line 305 of file nonlinear_solver.h.

template<typename T>
SNESConvergedReason libMesh::PetscNonlinearSolver< T >::_reason
protected

Store the reason for SNES convergence/divergence for use even after the _snes has been cleared. Note that print_converged_reason() will always try to get the current reason with SNESGetConvergedReason(), but if the SNES object has already been cleared, it will fall back on this stored value. Note that this value is therefore necessarily not cleared by the clear() function.

Definition at line 156 of file petsc_nonlinear_solver.h.

template<typename T>
SNES libMesh::PetscNonlinearSolver< T >::_snes
protected

Nonlinear solver context

Definition at line 147 of file petsc_nonlinear_solver.h.

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

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

A reference to the system we are solving.

Definition at line 295 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 176 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 171 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 251 of file nonlinear_solver.h.

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

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

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

Note that not all NonlinearSolvers support relative_step_tolerance!

Definition at line 265 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 175 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 181 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 289 of file nonlinear_solver.h.

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

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

Definition at line 278 of file nonlinear_solver.h.

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

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

Definition at line 143 of file nonlinear_solver.h.

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

template<typename T>
NonlinearImplicitSystem::ComputeJacobian* libMesh::NonlinearSolver< T >::jacobian_object
inherited

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

Definition at line 151 of file nonlinear_solver.h.

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

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

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

Definition at line 159 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 239 of file nonlinear_solver.h.

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

Each linear solver step should exit after max_linear_iterations is exceeded.

Definition at line 272 of file nonlinear_solver.h.

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

Maximum number of non-linear iterations.

Definition at line 234 of file nonlinear_solver.h.

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

The tolerance for linear solves is kept above this minimum

Definition at line 283 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 204 of file nonlinear_solver.h.

template<typename T>
NonlinearImplicitSystem::ComputeVectorSubspace* libMesh::NonlinearSolver< T >::nearnullspace_object
inherited

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

Definition at line 211 of file nonlinear_solver.h.

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

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

Definition at line 189 of file nonlinear_solver.h.

template<typename T>
NonlinearImplicitSystem::ComputeVectorSubspace* libMesh::NonlinearSolver< T >::nullspace_object
inherited

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

Definition at line 197 of file nonlinear_solver.h.

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

Definition at line 252 of file nonlinear_solver.h.

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

Definition at line 266 of file nonlinear_solver.h.

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

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

Definition at line 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 that either R or J could be XSNULL.

Definition at line 170 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>
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 >::user_presolve)(sys_type &S)
inherited

Definition at line 214 of file nonlinear_solver.h.


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

Site Created By: libMesh Developers
Last modified: February 07 2014 16:58:01 UTC

Hosted By:
SourceForge.net Logo