libMesh::NoxNonlinearSolver< T > Class Template Reference

#include <trilinos_nox_nonlinear_solver.h>

Inheritance diagram for libMesh::NoxNonlinearSolver< T >:

Public Types

typedef NonlinearImplicitSystem sys_type
 

Public Member Functions

 NoxNonlinearSolver (sys_type &system)
 
virtual ~NoxNonlinearSolver ()
 
virtual void clear () override
 
virtual void init (const char *name=nullptr) override
 
virtual std::pair< unsigned int, Realsolve (SparseMatrix< T > &, NumericVector< T > &, NumericVector< T > &, const double, const unsigned int) override
 
virtual int get_total_linear_iterations () override
 
virtual unsigned get_current_nonlinear_iteration_number () const override
 
bool initialized () const
 
virtual void print_converged_reason ()
 
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 increment_constructor_count (const std::string &name)
 
void increment_destructor_count (const std::string &name)
 

Protected Attributes

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
 

Private Attributes

NOX::Solver::Generic * _solver
 
Problem_Interface_interface
 
int _n_linear_iterations
 

Detailed Description

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

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

Author
Chris Newman
Date
2008

Definition at line 61 of file trilinos_nox_nonlinear_solver.h.

Member Typedef Documentation

◆ Counts

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

Data structure to log the information. The log is identified by the class name.

Definition at line 117 of file reference_counter.h.

◆ sys_type

template<typename T>
typedef NonlinearImplicitSystem libMesh::NoxNonlinearSolver< T >::sys_type

The type of system

Definition at line 67 of file trilinos_nox_nonlinear_solver.h.

Constructor & Destructor Documentation

◆ NoxNonlinearSolver()

template<typename T >
libMesh::NoxNonlinearSolver< T >::NoxNonlinearSolver ( sys_type system)
inlineexplicit

Constructor. Initializes Nox data structures

Definition at line 137 of file trilinos_nox_nonlinear_solver.h.

137  :
138  NonlinearSolver<T>(system),
139  _solver(nullptr),
140  _interface(nullptr),
142 {
143 }
const sys_type & system() const

◆ ~NoxNonlinearSolver()

template<typename T >
libMesh::NoxNonlinearSolver< T >::~NoxNonlinearSolver ( )
inlinevirtual

Destructor.

Definition at line 149 of file trilinos_nox_nonlinear_solver.h.

150 {
151  this->clear ();
152 }

Member Function Documentation

◆ attach_preconditioner()

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

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

Definition at line 71 of file nonlinear_solver.C.

72 {
73  if (this->_is_initialized)
74  libmesh_error_msg("Preconditioner must be attached before the solver is initialized!");
75 
76  _preconditioner = preconditioner;
77 }
Preconditioner< T > * _preconditioner

◆ build()

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

Builds a NonlinearSolver using the nonlinear solver package specified by solver_package

Definition at line 37 of file nonlinear_solver.C.

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

◆ clear()

template<typename T >
void libMesh::NoxNonlinearSolver< T >::clear ( )
overridevirtual

Release all memory and clear data structures.

Reimplemented from libMesh::NonlinearSolver< T >.

Definition at line 276 of file trilinos_nox_nonlinear_solver.C.

277 {
278 }

◆ comm()

const Parallel::Communicator& libMesh::ParallelObject::comm ( ) const
inlineinherited
Returns
A reference to the Parallel::Communicator object used by this mesh.

Definition at line 89 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_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::UniformRefinementEstimator::_estimate_error(), libMesh::BoundaryInfo::_find_id_maps(), 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::MeshRefinement::_smooth_flags(), libMesh::PetscDMWrapper::add_dofs_helper(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::ImplicitSystem::add_matrix(), libMesh::System::add_vector(), libMesh::UnstructuredMesh::all_second_order(), libMesh::MeshTools::Modification::all_tri(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::FEMSystem::assemble_qoi(), libMesh::MeshCommunication::assign_global_indices(), libMesh::DofMap::attach_matrix(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::PetscDMWrapper::build_section(), libMesh::PetscDMWrapper::build_sf(), libMesh::MeshBase::cache_elem_dims(), libMesh::System::calculate_norm(), libMesh::DofMap::check_dirichlet_bcid_consistency(), libMesh::PetscDMWrapper::check_section_n_dofs(), 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::CondensedEigenSystem::get_eigenpair(), libMesh::DofMap::get_info(), libMesh::ImplicitSystem::get_linear_solver(), libMesh::LocationMap< T >::init(), libMesh::TimeSolver::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), libMesh::EigenSystem::init_data(), libMesh::EigenSystem::init_matrices(), libMesh::OptimizationSystem::initialize_equality_constraints_storage(), libMesh::OptimizationSystem::initialize_inequality_constraints_storage(), libMesh::MeshTools::libmesh_assert_consistent_distributed(), libMesh::MeshTools::libmesh_assert_consistent_distributed_nodes(), libMesh::MeshTools::libmesh_assert_contiguous_dof_ids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_new_node_procids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_topology_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_valid_boundary_ids(), libMesh::MeshTools::libmesh_assert_valid_dof_ids(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::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_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_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::FEMSystem::mesh_position_set(), 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::petsc_auto_fieldsplit(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::MeshBase::prepare_for_use(), libMesh::Nemesis_IO::read(), libMesh::XdrIO::read(), libMesh::CheckpointIO::read_header(), libMesh::XdrIO::read_header(), 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_helper(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::System::read_serialized_vector(), libMesh::MeshBase::recalculate_n_partitions(), libMesh::MeshRefinement::refine_and_coarsen_elements(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::CheckpointIO::select_split_config(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::PetscDMWrapper::set_point_range_in_section(), libMesh::PetscDiffSolver::setup_petsc_data(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::split_mesh(), libMesh::MeshBase::subdomain_ids(), libMesh::BoundaryInfo::sync(), libMesh::MeshRefinement::test_level_one(), libMesh::MeshRefinement::test_unflagged(), libMesh::MeshTools::total_weight(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::NameBasedIO::write(), libMesh::XdrIO::write(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), and libMesh::XdrIO::write_serialized_nodesets().

90  { return _communicator; }
const Parallel::Communicator & _communicator

◆ disable_print_counter_info()

void libMesh::ReferenceCounter::disable_print_counter_info ( )
staticinherited

Definition at line 106 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

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

107 {
108  _enable_print_counter = false;
109  return;
110 }

◆ enable_print_counter_info()

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 }

◆ get_current_nonlinear_iteration_number()

template<typename T>
virtual unsigned libMesh::NoxNonlinearSolver< T >::get_current_nonlinear_iteration_number ( ) const
inlineoverridevirtual
Returns
The current nonlinear iteration number if called during the solve(), for example by the user-specified residual or Jacobian function.
Note
Not currently implemented for the NoxNonlinearSolver.

Implements libMesh::NonlinearSolver< T >.

Definition at line 112 of file trilinos_nox_nonlinear_solver.h.

113  { libmesh_not_implemented(); return 0; }

◆ get_info()

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

Gets a string containing the reference information.

Definition at line 47 of file reference_counter.C.

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 (const auto & pr : _counts)
59  {
60  const std::string name(pr.first);
61  const unsigned int creations = pr.second.first;
62  const unsigned int destructions = pr.second.second;
63 
64  oss << "| " << name << " reference count information:\n"
65  << "| Creations: " << creations << '\n'
66  << "| Destructions: " << destructions << '\n';
67  }
68 
69  oss << " ---------------------------------------------------------------------------- \n";
70 
71  return oss.str();
72 
73 #else
74 
75  return "";
76 
77 #endif
78 }
std::string name(const ElemQuality q)
Definition: elem_quality.C:42

◆ get_total_linear_iterations()

template<typename T >
int libMesh::NoxNonlinearSolver< T >::get_total_linear_iterations ( )
overridevirtual

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

Implements libMesh::NonlinearSolver< T >.

Definition at line 430 of file trilinos_nox_nonlinear_solver.C.

◆ increment_constructor_count()

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

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

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

182 {
183  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
184  std::pair<unsigned int, unsigned int> & p = _counts[name];
185 
186  p.first++;
187 }
std::string name(const ElemQuality q)
Definition: elem_quality.C:42
spin_mutex spin_mtx
Definition: threads.C:29

◆ increment_destructor_count()

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

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

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

195 {
196  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
197  std::pair<unsigned int, unsigned int> & p = _counts[name];
198 
199  p.second++;
200 }
std::string name(const ElemQuality q)
Definition: elem_quality.C:42
spin_mutex spin_mtx
Definition: threads.C:29

◆ init()

template<typename T >
void libMesh::NoxNonlinearSolver< T >::init ( const char *  name = nullptr)
overridevirtual

Initialize data structures if not done so already.

Implements libMesh::NonlinearSolver< T >.

Definition at line 283 of file trilinos_nox_nonlinear_solver.C.

284 {
285  if (!this->initialized())
286  _interface = new Problem_Interface(this);
287 }

◆ initialized()

template<typename T>
bool libMesh::NonlinearSolver< T >::initialized ( ) const
inlineinherited
Returns
true if the data structures are initialized, false otherwise.

Definition at line 92 of file nonlinear_solver.h.

◆ n_objects()

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

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

Definition at line 83 of file reference_counter.h.

References libMesh::ReferenceCounter::_n_objects.

84  { return _n_objects; }
static Threads::atomic< unsigned int > _n_objects

◆ n_processors()

processor_id_type libMesh::ParallelObject::n_processors ( ) const
inlineinherited
Returns
The number of processors in the group.

Definition at line 95 of file parallel_object.h.

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

Referenced by libMesh::BoundaryInfo::_find_id_maps(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::DistributedMesh::add_elem(), libMesh::DistributedMesh::add_node(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::FEMSystem::assembly(), libMesh::AztecLinearSolver< T >::AztecLinearSolver(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::DistributedMesh::clear(), libMesh::Nemesis_IO_Helper::compute_border_node_ids(), libMesh::Nemesis_IO_Helper::construct_nemesis_filename(), 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::EnsightIO::EnsightIO(), libMesh::MeshBase::get_info(), libMesh::SystemSubsetBySubdomain::init(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), libMesh::Nemesis_IO_Helper::initialize(), libMesh::DistributedMesh::insert_elem(), libMesh::MeshTools::libmesh_assert_contiguous_dof_ids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_new_node_procids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_topology_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_valid_boundary_ids(), libMesh::MeshTools::libmesh_assert_valid_dof_ids(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::MeshTools::libmesh_assert_valid_refinement_flags(), libMesh::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::MeshBase::partition(), libMesh::PetscLinearSolver< T >::PetscLinearSolver(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::NameBasedIO::read(), libMesh::Nemesis_IO::read(), libMesh::CheckpointIO::read(), libMesh::CheckpointIO::read_connectivity(), libMesh::XdrIO::read_header(), libMesh::CheckpointIO::read_nodes(), libMesh::System::read_parallel_data(), libMesh::System::read_SCALAR_dofs(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::System::read_serialized_vector(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::PetscDMWrapper::set_point_range_in_section(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::GMVIO::write_binary(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::System::write_parallel_data(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), and libMesh::XdrIO::write_serialized_nodesets().

96  { return cast_int<processor_id_type>(_communicator.size()); }
processor_id_type size() const
Definition: communicator.h:175
const Parallel::Communicator & _communicator

◆ print_converged_reason()

template<typename T>
virtual void libMesh::NonlinearSolver< T >::print_converged_reason ( )
inlinevirtualinherited

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

Reimplemented in libMesh::PetscNonlinearSolver< T >, and libMesh::PetscNonlinearSolver< Number >.

Definition at line 118 of file nonlinear_solver.h.

118 { libmesh_not_implemented(); }

◆ print_info()

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

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

Definition at line 87 of file reference_counter.C.

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

88 {
90  out_stream << ReferenceCounter::get_info();
91 }
static std::string get_info()

◆ processor_id()

processor_id_type libMesh::ParallelObject::processor_id ( ) const
inlineinherited
Returns
The rank of this processor in the group.

Definition at line 101 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::PetscDMWrapper::add_dofs_to_section(), libMesh::DistributedMesh::add_elem(), libMesh::BoundaryInfo::add_elements(), libMesh::DofMap::add_neighbors_to_send_list(), libMesh::DistributedMesh::add_node(), libMesh::UnstructuredMesh::all_second_order(), libMesh::MeshTools::Modification::all_tri(), libMesh::FEMSystem::assembly(), libMesh::EquationSystems::build_discontinuous_solution_vector(), libMesh::Nemesis_IO_Helper::build_element_and_node_maps(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), 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::DofMap::end_dof(), libMesh::DofMap::end_old_dof(), libMesh::EnsightIO::EnsightIO(), libMesh::MeshFunction::find_element(), libMesh::MeshFunction::find_elements(), 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::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::Nemesis_IO_Helper::get_ss_param_global(), libMesh::SparsityPattern::Build::handle_vi_vj(), libMesh::SystemSubsetBySubdomain::init(), 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::DofMap::last_dof(), libMesh::MeshTools::libmesh_assert_consistent_distributed(), libMesh::MeshTools::libmesh_assert_consistent_distributed_nodes(), libMesh::MeshTools::libmesh_assert_contiguous_dof_ids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_object_ids(), 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::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::BoundaryInfo::n_shellface_conds(), libMesh::SparsityPattern::Build::operator()(), libMesh::DistributedMesh::own_node(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), 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::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_helper(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::System::read_serialized_data(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::System::read_serialized_vector(), libMesh::System::read_serialized_vectors(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::CheckpointIO::select_split_config(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::PetscDMWrapper::set_point_range_in_section(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::MeshTools::total_weight(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::Parallel::Packing< T >::unpack(), libMesh::DistributedMesh::update_parallel_id_counts(), 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::System::write_header(), 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::System::write_parallel_data(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bc_names(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::System::write_serialized_data(), libMesh::XdrIO::write_serialized_nodes(), libMesh::XdrIO::write_serialized_nodesets(), libMesh::XdrIO::write_serialized_subdomain_names(), libMesh::System::write_serialized_vector(), libMesh::System::write_serialized_vectors(), libMesh::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().

102  { return cast_int<processor_id_type>(_communicator.rank()); }
const Parallel::Communicator & _communicator
processor_id_type rank() const
Definition: communicator.h:173

◆ set_solver_configuration()

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

Set the solver configuration object.

Definition at line 80 of file nonlinear_solver.C.

81 {
82  _solver_configuration = &solver_configuration;
83 }
SolverConfiguration * _solver_configuration

◆ solve()

template<typename T>
std::pair< unsigned int, Real > libMesh::NoxNonlinearSolver< T >::solve ( SparseMatrix< T > &  ,
NumericVector< T > &  x_in,
NumericVector< T > &  ,
const double  ,
const unsigned  int 
)
overridevirtual

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

Implements libMesh::NonlinearSolver< T >.

Definition at line 293 of file trilinos_nox_nonlinear_solver.C.

298 {
299  this->init ();
300 
301  if (this->user_presolve)
302  this->user_presolve(this->system());
303 
304  EpetraVector<T> * x_epetra = cast_ptr<EpetraVector<T> *>(&x_in);
305  // Creating a Teuchos::RCP as they do in NOX examples does not work here - we get some invalid memory references
306  // thus we make a local copy
307  NOX::Epetra::Vector x(*x_epetra->vec());
308 
309  Teuchos::RCP<Teuchos::ParameterList> nlParamsPtr = Teuchos::rcp(new Teuchos::ParameterList);
310  Teuchos::ParameterList & nlParams = *(nlParamsPtr.get());
311  nlParams.set("Nonlinear Solver", "Line Search Based");
312 
313  //print params
314  Teuchos::ParameterList & printParams = nlParams.sublist("Printing");
315  printParams.set("Output Precision", 3);
316  printParams.set("Output Processor", 0);
317  printParams.set("Output Information",
318  NOX::Utils::OuterIteration +
319  NOX::Utils::OuterIterationStatusTest +
320  NOX::Utils::InnerIteration +
321  NOX::Utils::LinearSolverDetails +
322  NOX::Utils::Parameters +
323  NOX::Utils::Details +
324  NOX::Utils::Warning);
325 
326  Teuchos::ParameterList & dirParams = nlParams.sublist("Direction");
327  dirParams.set("Method", "Newton");
328  Teuchos::ParameterList & newtonParams = dirParams.sublist("Newton");
329  newtonParams.set("Forcing Term Method", "Constant");
330 
331  Teuchos::ParameterList & lsParams = newtonParams.sublist("Linear Solver");
332  lsParams.set("Aztec Solver", "GMRES");
333  lsParams.set("Max Iterations", static_cast<int>(this->max_linear_iterations));
334  lsParams.set("Tolerance", this->initial_linear_tolerance);
335  lsParams.set("Output Frequency", 1);
336  lsParams.set("Size of Krylov Subspace", 1000);
337 
338  //create linear system
339  Teuchos::RCP<NOX::Epetra::Interface::Required> iReq(_interface);
340  Teuchos::RCP<NOX::Epetra::LinearSystemAztecOO> linSys;
341  Teuchos::RCP<Epetra_Operator> pc;
342 
343  if (this->jacobian || this->jacobian_object || this->residual_and_jacobian_object)
344  {
345  if (this->_preconditioner)
346  {
347  // PJNFK
348  lsParams.set("Preconditioner", "User Defined");
349 
350  TrilinosPreconditioner<Number> * trilinos_pc =
351  cast_ptr<TrilinosPreconditioner<Number> *>(this->_preconditioner);
352  pc = Teuchos::rcp(trilinos_pc);
353 
354  Teuchos::RCP<NOX::Epetra::Interface::Preconditioner> iPrec(_interface);
355  linSys = Teuchos::rcp(new NOX::Epetra::LinearSystemAztecOO(printParams, lsParams, iReq, iPrec, pc, x));
356  }
357  else
358  {
359  lsParams.set("Preconditioner", "None");
360  // lsParams.set("Preconditioner", "Ifpack");
361  // lsParams.set("Preconditioner", "AztecOO");
362 
363  // full jacobian
364  NonlinearImplicitSystem & sys = _interface->_solver->system();
365  EpetraMatrix<Number> & jacSys = *cast_ptr<EpetraMatrix<Number> *>(sys.matrix);
366  Teuchos::RCP<Epetra_RowMatrix> jacMat = Teuchos::rcp(jacSys.mat());
367 
368  Teuchos::RCP<NOX::Epetra::Interface::Jacobian> iJac(_interface);
369  linSys = Teuchos::rcp(new NOX::Epetra::LinearSystemAztecOO(printParams, lsParams, iReq, iJac, jacMat, x));
370  }
371  }
372  else
373  {
374  // matrix free
375  Teuchos::RCP<NOX::Epetra::MatrixFree> MF = Teuchos::rcp(new NOX::Epetra::MatrixFree(printParams, iReq, x));
376 
377  Teuchos::RCP<NOX::Epetra::Interface::Jacobian> iJac(MF);
378  linSys = Teuchos::rcp(new NOX::Epetra::LinearSystemAztecOO(printParams, lsParams, iReq, iJac, MF, x));
379  }
380 
381  //create group
382  Teuchos::RCP<NOX::Epetra::Group> grpPtr = Teuchos::rcp(new NOX::Epetra::Group(printParams, iReq, x, linSys));
383  NOX::Epetra::Group & grp = *(grpPtr.get());
384 
385  Teuchos::RCP<NOX::StatusTest::NormF> absresid =
386  Teuchos::rcp(new NOX::StatusTest::NormF(this->absolute_residual_tolerance, NOX::StatusTest::NormF::Unscaled));
387  Teuchos::RCP<NOX::StatusTest::NormF> relresid =
388  Teuchos::rcp(new NOX::StatusTest::NormF(grp, this->relative_residual_tolerance));
389  Teuchos::RCP<NOX::StatusTest::MaxIters> maxiters =
390  Teuchos::rcp(new NOX::StatusTest::MaxIters(this->max_nonlinear_iterations));
391  Teuchos::RCP<NOX::StatusTest::FiniteValue> finiteval =
392  Teuchos::rcp(new NOX::StatusTest::FiniteValue());
393  Teuchos::RCP<NOX::StatusTest::NormUpdate> normupdate =
394  Teuchos::rcp(new NOX::StatusTest::NormUpdate(this->absolute_step_tolerance));
395  Teuchos::RCP<NOX::StatusTest::Combo> combo =
396  Teuchos::rcp(new NOX::StatusTest::Combo(NOX::StatusTest::Combo::OR));
397  combo->addStatusTest(absresid);
398  combo->addStatusTest(relresid);
399  combo->addStatusTest(maxiters);
400  combo->addStatusTest(finiteval);
401  combo->addStatusTest(normupdate);
402 
403  Teuchos::RCP<Teuchos::ParameterList> finalPars = nlParamsPtr;
404 
405  Teuchos::RCP<NOX::Solver::Generic> solver = NOX::Solver::buildSolver(grpPtr, combo, nlParamsPtr);
406  NOX::StatusTest::StatusType status = solver->solve();
407  this->converged = (status == NOX::StatusTest::Converged);
408 
409  const NOX::Epetra::Group & finalGroup = dynamic_cast<const NOX::Epetra::Group &>(solver->getSolutionGroup());
410  const NOX::Epetra::Vector & noxFinalSln = dynamic_cast<const NOX::Epetra::Vector &>(finalGroup.getX());
411 
412  *x_epetra->vec() = noxFinalSln.getEpetraVector();
413  x_in.close();
414 
415  Real residual_norm = finalGroup.getNormF();
416  unsigned int total_iters = solver->getNumIterations();
417  _n_linear_iterations = finalPars->sublist("Direction").sublist("Newton").sublist("Linear Solver").sublist("Output").get("Total Number of Linear Iterations", -1);
418 
419  // do not let Trilinos to deallocate what we allocated
420  pc.release();
421  iReq.release();
422 
423  return std::make_pair(total_iters, residual_norm);
424 }
NonlinearImplicitSystem::ComputeResidualandJacobian * residual_and_jacobian_object
virtual void init(const char *name=nullptr) override
Preconditioner< T > * _preconditioner
void(* user_presolve)(sys_type &S)
NoxNonlinearSolver< Number > * _solver
unsigned int max_linear_iterations
void(* jacobian)(const NumericVector< Number > &X, SparseMatrix< Number > &J, sys_type &S)
const sys_type & system() const
NonlinearImplicitSystem::ComputeJacobian * jacobian_object
MPI_Status status
Definition: status.h:41
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
unsigned int max_nonlinear_iterations

◆ system() [1/2]

◆ system() [2/2]

template<typename T>
sys_type& libMesh::NonlinearSolver< T >::system ( )
inlineinherited
Returns
A writable reference to the system we are solving.

Definition at line 285 of file nonlinear_solver.h.

285 { return _system; }

Member Data Documentation

◆ _communicator

◆ _counts

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts
staticprotectedinherited

◆ _enable_print_counter

bool libMesh::ReferenceCounter::_enable_print_counter = true
staticprotectedinherited

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

Definition at line 141 of file reference_counter.h.

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

◆ _interface

template<typename T>
Problem_Interface* libMesh::NoxNonlinearSolver< T >::_interface
private

Solver interface

Definition at line 125 of file trilinos_nox_nonlinear_solver.h.

◆ _is_initialized

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

Flag indicating if the data structures have been initialized.

Definition at line 366 of file nonlinear_solver.h.

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

◆ _mutex

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

Mutual exclusion object to enable thread-safe reference counting.

Definition at line 135 of file reference_counter.h.

◆ _n_linear_iterations

template<typename T>
int libMesh::NoxNonlinearSolver< T >::_n_linear_iterations
private

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

Definition at line 130 of file trilinos_nox_nonlinear_solver.h.

◆ _n_objects

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

The number of objects. Print the reference count information when the number returns to 0.

Definition at line 130 of file reference_counter.h.

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

◆ _preconditioner

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

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

Definition at line 371 of file nonlinear_solver.h.

◆ _solver

template<typename T>
NOX::Solver::Generic* libMesh::NoxNonlinearSolver< T >::_solver
private

Nonlinear solver context

Definition at line 120 of file trilinos_nox_nonlinear_solver.h.

◆ _solver_configuration

template<typename T>
SolverConfiguration* libMesh::NonlinearSolver< T >::_solver_configuration
protectedinherited

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

Definition at line 377 of file nonlinear_solver.h.

◆ _system

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

A reference to the system we are solving.

Definition at line 361 of file nonlinear_solver.h.

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

◆ absolute_residual_tolerance

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

◆ absolute_step_tolerance

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

◆ bounds

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

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

Definition at line 199 of file nonlinear_solver.h.

◆ bounds_object

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

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

Definition at line 205 of file nonlinear_solver.h.

◆ converged

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

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

Definition at line 350 of file nonlinear_solver.h.

◆ fd_residual_object

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

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

Definition at line 152 of file nonlinear_solver.h.

Referenced by libMesh::libmesh_petsc_snes_fd_residual().

◆ initial_linear_tolerance

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

◆ jacobian

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

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

Definition at line 165 of file nonlinear_solver.h.

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

◆ jacobian_object

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

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

Definition at line 173 of file nonlinear_solver.h.

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

◆ matvec

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

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

Note
Either R or J could be nullptr.

Definition at line 182 of file nonlinear_solver.h.

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

◆ max_function_evaluations

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

Maximum number of function evaluations.

Definition at line 300 of file nonlinear_solver.h.

◆ max_linear_iterations

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

Each linear solver step should exit after max_linear_iterations is exceeded.

Definition at line 333 of file nonlinear_solver.h.

◆ max_nonlinear_iterations

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

Maximum number of non-linear iterations.

Definition at line 295 of file nonlinear_solver.h.

◆ mffd_residual_object

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

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

Definition at line 159 of file nonlinear_solver.h.

Referenced by libMesh::libmesh_petsc_snes_mffd_residual().

◆ minimum_linear_tolerance

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

The tolerance for linear solves is kept above this minimum

Definition at line 344 of file nonlinear_solver.h.

◆ nearnullspace

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

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

Definition at line 242 of file nonlinear_solver.h.

◆ nearnullspace_object

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

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

Definition at line 249 of file nonlinear_solver.h.

◆ nullspace

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

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

Definition at line 213 of file nonlinear_solver.h.

◆ nullspace_object

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

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

Definition at line 221 of file nonlinear_solver.h.

◆ postcheck

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

Function that performs a "check" on the Newton search direction and solution after each nonlinear step. See documentation for the NonlinearImplicitSystem::ComputePostCheck object for more information about the calling sequence.

Definition at line 263 of file nonlinear_solver.h.

Referenced by libMesh::libmesh_petsc_snes_postcheck().

◆ postcheck_object

template<typename T>
NonlinearImplicitSystem::ComputePostCheck* libMesh::NonlinearSolver< T >::postcheck_object
inherited

A callable object that is executed after each nonlinear iteration. Allows the user to modify both the search direction and the solution vector in an application-specific way.

Definition at line 275 of file nonlinear_solver.h.

Referenced by libMesh::libmesh_petsc_snes_postcheck().

◆ relative_residual_tolerance

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

Definition at line 313 of file nonlinear_solver.h.

◆ relative_step_tolerance

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

Definition at line 327 of file nonlinear_solver.h.

◆ residual

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

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

Definition at line 138 of file nonlinear_solver.h.

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

◆ residual_and_jacobian_object

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

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

Note
Either R or J could be nullptr.

Definition at line 194 of file nonlinear_solver.h.

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

◆ residual_object

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

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

Definition at line 146 of file nonlinear_solver.h.

Referenced by libMesh::Problem_Interface::computeF(), libMesh::libmesh_petsc_snes_fd_residual(), libMesh::libmesh_petsc_snes_mffd_residual(), and libMesh::libmesh_petsc_snes_residual().

◆ transpose_nullspace

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

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

Definition at line 228 of file nonlinear_solver.h.

◆ transpose_nullspace_object

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

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

Definition at line 235 of file nonlinear_solver.h.

◆ user_presolve

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

Customizable function pointer which users can attach to the solver. Gets called prior to every call to solve().

Definition at line 255 of file nonlinear_solver.h.


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