libMesh
Public Types | Public Member Functions | Static Public Member Functions | Public Attributes | Protected Types | Protected Member Functions | Protected Attributes | Static Protected Attributes | List of all members
libMesh::NewtonSolver Class Reference

This class defines a solver which uses the default libMesh linear solver in a quasiNewton method to handle a DifferentiableSystem. More...

#include <newton_solver.h>

Inheritance diagram for libMesh::NewtonSolver:
[legend]

Public Types

typedef DiffSolver Parent
 
enum  SolveResult {
  INVALID_SOLVE_RESULT = 0, CONVERGED_NO_REASON = 1, CONVERGED_ABSOLUTE_RESIDUAL = 2, CONVERGED_RELATIVE_RESIDUAL = 4,
  CONVERGED_ABSOLUTE_STEP = 8, CONVERGED_RELATIVE_STEP = 16, DIVERGED_NO_REASON = 32, DIVERGED_MAX_NONLINEAR_ITERATIONS = 64,
  DIVERGED_BACKTRACKING_FAILURE = 128, DIVERGED_LINEAR_SOLVER_FAILURE = 256
}
 Enumeration return type for the solve() function. More...
 
typedef ImplicitSystem sys_type
 The type of system. More...
 

Public Member Functions

 NewtonSolver (sys_type &system)
 Constructor. More...
 
virtual ~NewtonSolver ()
 Destructor. More...
 
virtual void init () libmesh_override
 The initialization function. More...
 
virtual void reinit () libmesh_override
 The reinitialization function. More...
 
virtual unsigned int solve () libmesh_override
 This method performs a solve, using an inexact Newton-Krylov method with line search. More...
 
LinearSolver< Number > & get_linear_solver ()
 
const LinearSolver< Number > & get_linear_solver () const
 
unsigned int total_outer_iterations ()
 
unsigned int total_inner_iterations ()
 
unsigned int solve_result ()
 
const sys_typesystem () const
 
sys_typesystem ()
 
const Parallel::Communicatorcomm () const
 
processor_id_type n_processors () const
 
processor_id_type processor_id () const
 

Static Public Member Functions

static UniquePtr< DiffSolverbuild (sys_type &s)
 Factory method. More...
 
static std::string get_info ()
 Gets a string containing the reference information. More...
 
static void print_info (std::ostream &out=libMesh::out)
 Prints the reference information, by default to libMesh::out. More...
 
static unsigned int n_objects ()
 Prints the number of outstanding (created, but not yet destroyed) objects. More...
 
static void enable_print_counter_info ()
 Methods to enable/disable the reference counter output from print_info() More...
 
static void disable_print_counter_info ()
 

Public Attributes

bool require_residual_reduction
 If this is set to true, the solver is forced to test the residual after each Newton step, and to reduce the length of its steps whenever necessary to avoid a residual increase. More...
 
bool require_finite_residual
 If this is set to true, the solver is forced to test the residual after each Newton step, and to reduce the length of its steps whenever necessary to avoid an infinite or NaN residual. More...
 
bool brent_line_search
 If require_residual_reduction is true, the solver may reduce step lengths when required. More...
 
bool track_linear_convergence
 If set to true, check for convergence of the linear solve. More...
 
Real minsteplength
 If the quasi-Newton step length must be reduced to below this factor to give a residual reduction, then the Newton solver dies with an error message. More...
 
Real linear_tolerance_multiplier
 The tolerance for linear solves is kept below this multiplier (which defaults to 1e-3) times the norm of the current nonlinear residual. More...
 
unsigned int max_linear_iterations
 Each linear solver step should exit after max_linear_iterations is exceeded. More...
 
unsigned int max_nonlinear_iterations
 The DiffSolver should exit in failure if max_nonlinear_iterations is exceeded and continue_after_max_iterations is false, or should end the nonlinear solve if max_nonlinear_iterations is exceeded and continue_after_max_iterations is true. More...
 
bool quiet
 The DiffSolver should not print anything to libMesh::out unless quiet is set to false; default is true. More...
 
bool verbose
 The DiffSolver may print a lot more to libMesh::out if verbose is set to true; default is false. More...
 
bool continue_after_max_iterations
 Defaults to true, telling the DiffSolver to continue rather than exit when a solve has reached its maximum number of nonlinear iterations. More...
 
bool continue_after_backtrack_failure
 Defaults to false, telling the DiffSolver to throw an error when the backtracking scheme fails to find a descent direction. More...
 
Real absolute_residual_tolerance
 The DiffSolver should exit after the residual is reduced to either less than absolute_residual_tolerance or less than relative_residual_tolerance times the initial residual. More...
 
Real relative_residual_tolerance
 
Real absolute_step_tolerance
 The DiffSolver 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. More...
 
Real relative_step_tolerance
 
Real initial_linear_tolerance
 Any required linear solves will at first be done with this tolerance; the DiffSolver may tighten the tolerance for later solves. More...
 
Real minimum_linear_tolerance
 The tolerance for linear solves is kept above this minimum. More...
 
UniquePtr< LinearSolutionMonitorlinear_solution_monitor
 Pointer to functor which is called right after each linear solve. More...
 

Protected Types

typedef std::map< std::string, std::pair< unsigned int, unsigned int > > Counts
 Data structure to log the information. More...
 

Protected Member Functions

Real line_search (Real tol, Real last_residual, Real &current_residual, NumericVector< Number > &newton_iterate, const NumericVector< Number > &linear_solution)
 This does a line search in the direction opposite linear_solution to try and minimize the residual of newton_iterate. More...
 
void print_convergence (unsigned int step_num, Real current_residual, Real step_norm, bool linear_solve_finished)
 This prints output for the convergence criteria based on by the given residual and step size. More...
 
bool test_convergence (Real current_residual, Real step_norm, bool linear_solve_finished)
 
void increment_constructor_count (const std::string &name)
 Increments the construction counter. More...
 
void increment_destructor_count (const std::string &name)
 Increments the destruction counter. More...
 

Protected Attributes

UniquePtr< LinearSolver< Number > > _linear_solver
 The LinearSolver defines the interface used to solve the linear_implicit system. More...
 
Real max_solution_norm
 The largest solution norm which the DiffSolver has yet seen will be stored here, to be used for stopping criteria based on relative_step_tolerance. More...
 
Real max_residual_norm
 The largest nonlinear residual which the DiffSolver has yet seen will be stored here, to be used for stopping criteria based on relative_residual_tolerance. More...
 
unsigned int _outer_iterations
 The number of outer iterations used by the last solve. More...
 
unsigned int _inner_iterations
 The number of inner iterations used by the last solve. More...
 
sys_type_system
 A reference to the system we are solving. More...
 
unsigned int _solve_result
 Initialized to zero. More...
 
const Parallel::Communicator_communicator
 

Static Protected Attributes

static Counts _counts
 Actually holds the data. More...
 
static Threads::atomic< unsigned int_n_objects
 The number of objects. More...
 
static Threads::spin_mutex _mutex
 Mutual exclusion object to enable thread-safe reference counting. More...
 
static bool _enable_print_counter = true
 Flag to control whether reference count information is printed when print_info is called. More...
 

Detailed Description

This class defines a solver which uses the default libMesh linear solver in a quasiNewton method to handle a DifferentiableSystem.

This class is part of the new DifferentiableSystem framework, which is still experimental. Users of this framework should beware of bugs and future API changes.

Author
Roy H. Stogner
Date
2006

Definition at line 46 of file newton_solver.h.

Member Typedef Documentation

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

Data structure to log the information.

The log is identified by the class name.

Definition at line 119 of file reference_counter.h.

Definition at line 61 of file newton_solver.h.

The type of system.

Definition at line 77 of file diff_solver.h.

Member Enumeration Documentation

Enumeration return type for the solve() function.

Multiple SolveResults may be combined (OR'd) in the single return. To test which ones are present, just AND the return value with any of the SolveResult flags defined below.

Enumerator
INVALID_SOLVE_RESULT 

A default or invalid solve result.

This usually means no solve has occurred yet.

CONVERGED_NO_REASON 

The solver converged but no particular reason is specified.

CONVERGED_ABSOLUTE_RESIDUAL 

The DiffSolver achieved the desired absolute residual tolerance.

CONVERGED_RELATIVE_RESIDUAL 

The DiffSolver achieved the desired relative residual tolerance.

CONVERGED_ABSOLUTE_STEP 

The DiffSolver achieved the desired absolute step size tolerance.

CONVERGED_RELATIVE_STEP 

The DiffSolver achieved the desired relative step size tolerance.

DIVERGED_NO_REASON 

The DiffSolver diverged but no particular reason is specified.

DIVERGED_MAX_NONLINEAR_ITERATIONS 

The DiffSolver reached the maximum allowed number of nonlinear iterations before satisfying any convergence tests.

DIVERGED_BACKTRACKING_FAILURE 

The DiffSolver failed to find a descent direction by backtracking (See newton_solver.C)

DIVERGED_LINEAR_SOLVER_FAILURE 

The linear solver used by the DiffSolver failed to find a solution.

Definition at line 222 of file diff_solver.h.

222  {
228 
234 
240 
246 
252 
258 
263  DIVERGED_NO_REASON = 32,
264 
271 
277 
283  };
The DiffSolver achieved the desired absolute step size tolerance.
Definition: diff_solver.h:251
The linear solver used by the DiffSolver failed to find a solution.
Definition: diff_solver.h:282
The DiffSolver reached the maximum allowed number of nonlinear iterations before satisfying any conve...
Definition: diff_solver.h:270
The DiffSolver achieved the desired relative step size tolerance.
Definition: diff_solver.h:257
The DiffSolver achieved the desired relative residual tolerance.
Definition: diff_solver.h:245
The solver converged but no particular reason is specified.
Definition: diff_solver.h:233
The DiffSolver achieved the desired absolute residual tolerance.
Definition: diff_solver.h:239
The DiffSolver failed to find a descent direction by backtracking (See newton_solver.C)
Definition: diff_solver.h:276
The DiffSolver diverged but no particular reason is specified.
Definition: diff_solver.h:263
A default or invalid solve result.
Definition: diff_solver.h:227

Constructor & Destructor Documentation

libMesh::NewtonSolver::NewtonSolver ( sys_type system)
explicit

Constructor.

Requires a reference to the system to be solved.

Definition at line 232 of file newton_solver.C.

233  : Parent(s),
236  brent_line_search(true),
238  minsteplength(1e-5),
241 {
242 }
static UniquePtr< LinearSolver< Number > > build(const libMesh::Parallel::Communicator &comm_in, const SolverPackage solver_package=libMesh::default_solver_package())
Builds a LinearSolver using the linear solver package specified by solver_package.
bool require_finite_residual
If this is set to true, the solver is forced to test the residual after each Newton step...
bool track_linear_convergence
If set to true, check for convergence of the linear solve.
Real linear_tolerance_multiplier
The tolerance for linear solves is kept below this multiplier (which defaults to 1e-3) times the norm...
Real minsteplength
If the quasi-Newton step length must be reduced to below this factor to give a residual reduction...
UniquePtr< LinearSolver< Number > > _linear_solver
The LinearSolver defines the interface used to solve the linear_implicit system.
bool brent_line_search
If require_residual_reduction is true, the solver may reduce step lengths when required.
bool require_residual_reduction
If this is set to true, the solver is forced to test the residual after each Newton step...
Definition: newton_solver.h:98
libMesh::NewtonSolver::~NewtonSolver ( )
virtual

Destructor.

Definition at line 246 of file newton_solver.C.

247 {
248 }

Member Function Documentation

UniquePtr< DiffSolver > libMesh::DiffSolver::build ( sys_type s)
staticinherited

Factory method.

Requires a reference to the system to be solved.

Returns
A NewtonSolver by default.

Definition at line 53 of file diff_solver.C.

Referenced by libMesh::TimeSolver::init().

54 {
55  return UniquePtr<DiffSolver>(new NewtonSolver(s));
56 }
const Parallel::Communicator& libMesh::ParallelObject::comm ( ) const
inherited
Returns
A reference to the Parallel::Communicator object used by this mesh.

Definition at line 87 of file parallel_object.h.

References libMesh::ParallelObject::_communicator.

Referenced by libMesh::__libmesh_petsc_diff_solver_monitor(), libMesh::__libmesh_petsc_diff_solver_residual(), libMesh::__libmesh_petsc_preconditioner_apply(), libMesh::__libmesh_petsc_snes_jacobian(), libMesh::__libmesh_petsc_snes_postcheck(), libMesh::__libmesh_petsc_snes_residual(), libMesh::__libmesh_tao_equality_constraints(), libMesh::__libmesh_tao_equality_constraints_jacobian(), libMesh::__libmesh_tao_gradient(), libMesh::__libmesh_tao_hessian(), libMesh::__libmesh_tao_inequality_constraints(), libMesh::__libmesh_tao_inequality_constraints_jacobian(), libMesh::__libmesh_tao_objective(), libMesh::MeshRefinement::_coarsen_elements(), libMesh::ExactSolution::_compute_error(), libMesh::ParmetisPartitioner::_do_repartition(), libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::BoundaryInfo::_find_id_maps(), libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_get_diagonal(), libMesh::SlepcEigenSolver< T >::_petsc_shell_matrix_get_diagonal(), libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_mult(), libMesh::SlepcEigenSolver< T >::_petsc_shell_matrix_mult(), libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_mult_add(), libMesh::EquationSystems::_read_impl(), libMesh::MeshRefinement::_refine_elements(), libMesh::MeshRefinement::_smooth_flags(), add_cube_convex_hull_to_mesh(), libMesh::TransientRBConstruction::add_IC_to_RB_space(), libMesh::ImplicitSystem::add_matrix(), libMesh::RBConstruction::add_scaled_matrix_and_vector(), libMesh::System::add_vector(), libMesh::EigenSparseLinearSolver< T >::adjoint_solve(), libMesh::UnstructuredMesh::all_second_order(), libMesh::MeshTools::Modification::all_tri(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::TransientRBConstruction::allocate_data_structures(), libMesh::RBConstruction::allocate_data_structures(), libMesh::TransientRBConstruction::assemble_affine_expansion(), libMesh::FEMSystem::assemble_qoi(), libMesh::MeshCommunication::assign_global_indices(), libMesh::ParmetisPartitioner::assign_partitioning(), libMesh::DofMap::attach_matrix(), libMesh::Parallel::BinSorter< KeyType, IdxType >::binsort(), libMesh::Parallel::Sort< KeyType, IdxType >::binsort(), libMesh::MeshCommunication::broadcast(), libMesh::SparseMatrix< T >::build(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::Parallel::Histogram< KeyType, IdxType >::build_histogram(), libMesh::PetscNonlinearSolver< T >::build_mat_null_space(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::MeshBase::cache_elem_dims(), libMesh::System::calculate_norm(), libMesh::DofMap::check_dirichlet_bcid_consistency(), libMesh::Parallel::Sort< KeyType, IdxType >::communicate_bins(), libMesh::RBConstruction::compute_Fq_representor_innerprods(), libMesh::RBConstruction::compute_max_error_bound(), 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::RBConstruction::compute_output_dual_innerprods(), libMesh::RBSCMConstruction::compute_SCM_bounds_on_training_set(), 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::RBEIMConstruction::enrich_RB_space(), libMesh::TransientRBConstruction::enrich_RB_space(), libMesh::RBConstruction::enrich_RB_space(), AssembleOptimization::equality_constraints(), libMesh::WeightedPatchRecoveryErrorEstimator::estimate_error(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::PatchRecoveryErrorEstimator::estimate_error(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::ExactErrorEstimator::estimate_error(), libMesh::RBEIMConstruction::evaluate_mesh_function(), libMesh::MeshRefinement::flag_elements_by_elem_fraction(), libMesh::MeshRefinement::flag_elements_by_error_fraction(), libMesh::MeshRefinement::flag_elements_by_nelem_target(), libMesh::MeshCommunication::gather(), libMesh::MeshCommunication::gather_neighboring_elements(), libMesh::MeshfreeInterpolation::gather_remote_data(), libMesh::CondensedEigenSystem::get_eigenpair(), libMesh::DofMap::get_info(), libMesh::ImplicitSystem::get_linear_solver(), libMesh::EquationSystems::get_solution(), AssembleOptimization::inequality_constraints(), AssembleOptimization::inequality_constraints_jacobian(), libMesh::LocationMap< T >::init(), libMesh::TopologyMap::init(), libMesh::PetscDiffSolver::init(), libMesh::TimeSolver::init(), libMesh::TaoOptimizationSolver< T >::init(), libMesh::PetscNonlinearSolver< T >::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::EigenSystem::init_data(), libMesh::EigenSystem::init_matrices(), libMesh::ParmetisPartitioner::initialize(), libMesh::OptimizationSystem::initialize_equality_constraints_storage(), libMesh::OptimizationSystem::initialize_inequality_constraints_storage(), libMesh::RBEIMConstruction::initialize_rb_construction(), integrate_function(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_topology_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_valid_boundary_ids(), libMesh::MeshTools::libmesh_assert_valid_dof_ids(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_flags(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_object_ids(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_p_levels(), libMesh::MeshTools::libmesh_assert_valid_refinement_flags(), libMesh::MeshTools::libmesh_assert_valid_unique_ids(), libMesh::MeshRefinement::limit_level_mismatch_at_edge(), libMesh::MeshRefinement::limit_level_mismatch_at_node(), libMesh::MeshRefinement::limit_overrefined_boundary(), libMesh::MeshRefinement::limit_underrefined_boundary(), main(), 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::TransientRBConstruction::mass_matrix_scaled_matvec(), libMesh::FEMSystem::mesh_position_set(), libMesh::MeshSerializer::MeshSerializer(), LinearElasticityWithContact::move_mesh(), 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(), new_function_base(), libMesh::DistributedMesh::parallel_max_elem_id(), libMesh::DistributedMesh::parallel_max_node_id(), libMesh::ReplicatedMesh::parallel_max_unique_id(), libMesh::DistributedMesh::parallel_max_unique_id(), libMesh::DistributedMesh::parallel_n_elem(), libMesh::DistributedMesh::parallel_n_nodes(), libMesh::SparsityPattern::Build::parallel_sync(), libMesh::MeshTools::paranoid_n_levels(), libMesh::Partitioner::partition(), libMesh::MetisPartitioner::partition_range(), libMesh::Partitioner::partition_unpartitioned_elements(), libMesh::petsc_auto_fieldsplit(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::MeshBase::prepare_for_use(), libMesh::SparseMatrix< T >::print(), FEMParameters::read(), libMesh::Nemesis_IO::read(), libMesh::CheckpointIO::read(), libMesh::XdrIO::read(), libMesh::CheckpointIO::read_header(), libMesh::XdrIO::read_header(), libMesh::RBEvaluation::read_in_vectors_from_multiple_files(), libMesh::TransientRBConstruction::read_riesz_representors_from_files(), libMesh::RBConstruction::read_riesz_representors_from_files(), libMesh::XdrIO::read_serialized_bc_names(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::MeshBase::recalculate_n_partitions(), libMesh::MeshCommunication::redistribute(), libMesh::MeshRefinement::refine_and_coarsen_elements(), libMesh::DistributedMesh::renumber_dof_objects(), LinearElasticityWithContact::residual_and_jacobian(), libMesh::MeshCommunication::send_coarse_ghosts(), libMesh::TransientRBConstruction::set_error_temporal_data(), libMesh::RBEIMConstruction::set_explicit_sys_subvector(), libMesh::Partitioner::set_node_processor_ids(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::Partitioner::set_parent_processor_ids(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::Parallel::Sort< KeyType, IdxType >::sort(), libMesh::MeshBase::subdomain_ids(), libMesh::BoundaryInfo::sync(), libMesh::Parallel::sync_element_data_by_parent_id(), libMesh::Parallel::sync_node_data_by_element_id(), libMesh::MeshRefinement::test_level_one(), MeshfunctionDFEM::test_mesh_function_dfem(), MeshfunctionDFEM::test_mesh_function_dfem_grad(), libMesh::MeshRefinement::test_unflagged(), PointLocatorTest::testLocator(), BoundaryInfoTest::testMesh(), SystemsTest::testProjectCubeWithMeshFunction(), libMesh::MeshTools::total_weight(), libMesh::MeshFunctionSolutionTransfer::transfer(), libMesh::MeshfreeSolutionTransfer::transfer(), libMesh::TransientRBConstruction::truth_assembly(), libMesh::RBConstruction::truth_assembly(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::TransientRBConstruction::update_RB_initial_condition_all_N(), libMesh::RBEIMConstruction::update_RB_system_matrices(), libMesh::TransientRBConstruction::update_RB_system_matrices(), libMesh::RBConstruction::update_RB_system_matrices(), libMesh::TransientRBConstruction::update_residual_terms(), libMesh::RBConstruction::update_residual_terms(), libMesh::NameBasedIO::write(), libMesh::XdrIO::write(), libMesh::RBEvaluation::write_out_vectors(), libMesh::TransientRBConstruction::write_riesz_representors_to_files(), libMesh::RBConstruction::write_riesz_representors_to_files(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), libMesh::XdrIO::write_serialized_nodesets(), libMesh::RBDataSerialization::RBEvaluationSerialization::write_to_file(), libMesh::RBDataSerialization::TransientRBEvaluationSerialization::write_to_file(), libMesh::RBDataSerialization::RBEIMEvaluationSerialization::write_to_file(), and libMesh::RBDataSerialization::RBSCMEvaluationSerialization::write_to_file().

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

Definition at line 107 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

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

108 {
109  _enable_print_counter = false;
110  return;
111 }
static bool _enable_print_counter
Flag to control whether reference count information is printed when print_info is called...
void libMesh::ReferenceCounter::enable_print_counter_info ( )
staticinherited

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

Definition at line 101 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

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

102 {
103  _enable_print_counter = true;
104  return;
105 }
static bool _enable_print_counter
Flag to control whether reference count information is printed when print_info is called...
std::string libMesh::ReferenceCounter::get_info ( )
staticinherited

Gets a string containing the reference information.

Definition at line 47 of file reference_counter.C.

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

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

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

Definition at line 81 of file newton_solver.h.

References _linear_solver, and libMesh::libmesh_assert().

Referenced by main().

83  return *_linear_solver;
84  }
libmesh_assert(j)
UniquePtr< LinearSolver< Number > > _linear_solver
The LinearSolver defines the interface used to solve the linear_implicit system.
const LinearSolver<Number>& libMesh::NewtonSolver::get_linear_solver ( ) const

Definition at line 86 of file newton_solver.h.

References _linear_solver, and libMesh::libmesh_assert().

88  return *_linear_solver;
89  }
libmesh_assert(j)
UniquePtr< LinearSolver< Number > > _linear_solver
The LinearSolver defines the interface used to solve the linear_implicit system.
void libMesh::ReferenceCounter::increment_constructor_count ( const std::string &  name)
protectedinherited

Increments the construction counter.

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

Definition at line 185 of file reference_counter.h.

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

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

186 {
187  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
188  std::pair<unsigned int, unsigned int> & p = _counts[name];
189 
190  p.first++;
191 }
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:39
spin_mutex spin_mtx
A convenient spin mutex object which can be used for obtaining locks.
Definition: threads.C:29
static Counts _counts
Actually holds the data.
void libMesh::ReferenceCounter::increment_destructor_count ( const std::string &  name)
protectedinherited

Increments the destruction counter.

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

Definition at line 198 of file reference_counter.h.

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

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

199 {
200  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
201  std::pair<unsigned int, unsigned int> & p = _counts[name];
202 
203  p.second++;
204 }
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:39
spin_mutex spin_mtx
A convenient spin mutex object which can be used for obtaining locks.
Definition: threads.C:29
static Counts _counts
Actually holds the data.
void libMesh::NewtonSolver::init ( )
virtual

The initialization function.

This method is used to initialize internal data structures before a simulation begins.

Reimplemented from libMesh::DiffSolver.

Definition at line 252 of file newton_solver.C.

References _linear_solver, libMesh::DiffSolver::_system, libMesh::DiffSolver::init(), libMesh::System::name(), and libMesh::on_command_line().

253 {
254  Parent::init();
255 
256  if (libMesh::on_command_line("--solver_system_names"))
257  _linear_solver->init((_system.name()+"_").c_str());
258  else
259  _linear_solver->init();
260 
261  _linear_solver->init_names(_system);
262 }
const std::string & name() const
Definition: system.h:1998
virtual void init()
The initialization function.
Definition: diff_solver.C:69
sys_type & _system
A reference to the system we are solving.
Definition: diff_solver.h:318
bool on_command_line(const std::string &arg)
Definition: libmesh.C:921
UniquePtr< LinearSolver< Number > > _linear_solver
The LinearSolver defines the interface used to solve the linear_implicit system.
Real libMesh::NewtonSolver::line_search ( Real  tol,
Real  last_residual,
Real current_residual,
NumericVector< Number > &  newton_iterate,
const NumericVector< Number > &  linear_solution 
)
protected

This does a line search in the direction opposite linear_solution to try and minimize the residual of newton_iterate.

newton_iterate is moved to the end of the quasiNewton step.

Returns
The substep size.

Definition at line 38 of file newton_solver.C.

References libMesh::DiffSolver::_outer_iterations, libMesh::DiffSolver::_solve_result, libMesh::DiffSolver::_system, std::abs(), libMesh::NumericVector< T >::add(), libMesh::ImplicitSystem::assembly(), brent_line_search, libMesh::NumericVector< T >::close(), libMesh::DiffSolver::continue_after_backtrack_failure, libMesh::DiffSolver::DIVERGED_BACKTRACKING_FAILURE, libMesh::NumericVector< T >::l2_norm(), libMesh::libmesh_isnan(), std::max(), std::min(), minsteplength, libMesh::out, libMesh::DiffSolver::quiet, libMesh::Real, require_finite_residual, require_residual_reduction, libMesh::ExplicitSystem::rhs, libMesh::SIGN(), libMesh::DiffSolver::verbose, and libMesh::x.

Referenced by solve().

43 {
44  // Take a full step if we got a residual reduction or if we
45  // aren't substepping
46  if ((current_residual < last_residual) ||
48  (!require_finite_residual || !libmesh_isnan(current_residual))))
49  return 1.;
50 
51  // The residual vector
52  NumericVector<Number> & rhs = *(_system.rhs);
53 
54  Real ax = 0.; // First abscissa, don't take negative steps
55  Real cx = 1.; // Second abscissa, don't extrapolate steps
56 
57  // Find bx, a step length that gives lower residual than ax or cx
58  Real bx = 1.;
59 
60  while (libmesh_isnan(current_residual) ||
61  (current_residual > last_residual &&
63  {
64  // Reduce step size to 1/2, 1/4, etc.
65  Real substepdivision;
66  if (brent_line_search && !libmesh_isnan(current_residual))
67  {
68  substepdivision = std::min(0.5, last_residual/current_residual);
69  substepdivision = std::max(substepdivision, tol*2.);
70  }
71  else
72  substepdivision = 0.5;
73 
74  newton_iterate.add (bx * (1.-substepdivision),
75  linear_solution);
76  newton_iterate.close();
77  bx *= substepdivision;
78  if (verbose)
79  libMesh::out << " Shrinking Newton step to "
80  << bx << std::endl;
81 
82  // Check residual with fractional Newton step
83  _system.assembly (true, false);
84 
85  rhs.close();
86  current_residual = rhs.l2_norm();
87  if (verbose)
88  libMesh::out << " Current Residual: "
89  << current_residual << std::endl;
90 
91  if (bx/2. < minsteplength &&
92  (libmesh_isnan(current_residual) ||
93  (current_residual > last_residual)))
94  {
95  libMesh::out << "Inexact Newton step FAILED at step "
96  << _outer_iterations << std::endl;
97 
99  {
100  libmesh_convergence_failure();
101  }
102  else
103  {
104  libMesh::out << "Continuing anyway ..." << std::endl;
106  return bx;
107  }
108  }
109  } // end while (current_residual > last_residual)
110 
111  // Now return that reduced-residual step, or use Brent's method to
112  // find a more optimal step.
113 
114  if (!brent_line_search)
115  return bx;
116 
117  // Brent's method adapted from Numerical Recipes in C, ch. 10.2
118  Real e = 0.;
119 
120  Real x = bx, w = bx, v = bx;
121 
122  // Residuals at bx
123  Real fx = current_residual,
124  fw = current_residual,
125  fv = current_residual;
126 
127  // Max iterations for Brent's method loop
128  const unsigned int max_i = 20;
129 
130  // for golden ratio steps
131  const Real golden_ratio = 1.-(std::sqrt(5.)-1.)/2.;
132 
133  for (unsigned int i=1; i <= max_i; i++)
134  {
135  Real xm = (ax+cx)*0.5;
136  Real tol1 = tol * std::abs(x) + tol*tol;
137  Real tol2 = 2.0 * tol1;
138 
139  // Test if we're done
140  if (std::abs(x-xm) <= (tol2 - 0.5 * (cx - ax)))
141  return x;
142 
143  Real d;
144 
145  // Construct a parabolic fit
146  if (std::abs(e) > tol1)
147  {
148  Real r = (x-w)*(fx-fv);
149  Real q = (x-v)*(fx-fw);
150  Real p = (x-v)*q-(x-w)*r;
151  q = 2. * (q-r);
152  if (q > 0.)
153  p = -p;
154  else
155  q = std::abs(q);
156  if (std::abs(p) >= std::abs(0.5*q*e) ||
157  p <= q * (ax-x) ||
158  p >= q * (cx-x))
159  {
160  // Take a golden section step
161  e = x >= xm ? ax-x : cx-x;
162  d = golden_ratio * e;
163  }
164  else
165  {
166  // Take a parabolic fit step
167  d = p/q;
168  if (x+d-ax < tol2 || cx-(x+d) < tol2)
169  d = SIGN(tol1, xm - x);
170  }
171  }
172  else
173  {
174  // Take a golden section step
175  e = x >= xm ? ax-x : cx-x;
176  d = golden_ratio * e;
177  }
178 
179  Real u = std::abs(d) >= tol1 ? x+d : x + SIGN(tol1,d);
180 
181  // Assemble the residual at the new steplength u
182  newton_iterate.add (bx - u, linear_solution);
183  newton_iterate.close();
184  bx = u;
185  if (verbose)
186  libMesh::out << " Shrinking Newton step to "
187  << bx << std::endl;
188 
189  _system.assembly (true, false);
190 
191  rhs.close();
192  Real fu = current_residual = rhs.l2_norm();
193  if (verbose)
194  libMesh::out << " Current Residual: "
195  << fu << std::endl;
196 
197  if (fu <= fx)
198  {
199  if (u >= x)
200  ax = x;
201  else
202  cx = x;
203  v = w; w = x; x = u;
204  fv = fw; fw = fx; fx = fu;
205  }
206  else
207  {
208  if (u < x)
209  ax = u;
210  else
211  cx = u;
212  if (fu <= fw || w == x)
213  {
214  v = w; w = u;
215  fv = fw; fw = fu;
216  }
217  else if (fu <= fv || v == x || v == w)
218  {
219  v = u;
220  fv = fu;
221  }
222  }
223  }
224 
225  if (!quiet)
226  libMesh::out << "Warning! Too many iterations used in Brent line search!"
227  << std::endl;
228  return bx;
229 }
double abs(double a)
bool quiet
The DiffSolver should not print anything to libMesh::out unless quiet is set to false; default is tru...
Definition: diff_solver.h:162
NumericVector< Number > * rhs
The system matrix.
long double max(long double a, double b)
unsigned int _solve_result
Initialized to zero.
Definition: diff_solver.h:326
T SIGN(T a, T b)
Definition: newton_solver.C:33
virtual void assembly(bool, bool, bool=false, bool=false)
Assembles a residual in rhs and/or a jacobian in matrix, as requested.
PetscErrorCode Vec x
sys_type & _system
A reference to the system we are solving.
Definition: diff_solver.h:318
bool require_finite_residual
If this is set to true, the solver is forced to test the residual after each Newton step...
virtual void close()=0
Calls the NumericVector&#39;s internal assembly routines, ensuring that the values are consistent across ...
bool verbose
The DiffSolver may print a lot more to libMesh::out if verbose is set to true; default is false...
Definition: diff_solver.h:168
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
bool continue_after_backtrack_failure
Defaults to false, telling the DiffSolver to throw an error when the backtracking scheme fails to fin...
Definition: diff_solver.h:180
bool libmesh_isnan(float a)
Real minsteplength
If the quasi-Newton step length must be reduced to below this factor to give a residual reduction...
unsigned int _outer_iterations
The number of outer iterations used by the last solve.
Definition: diff_solver.h:308
OStreamProxy out
bool brent_line_search
If require_residual_reduction is true, the solver may reduce step lengths when required.
The DiffSolver failed to find a descent direction by backtracking (See newton_solver.C)
Definition: diff_solver.h:276
bool require_residual_reduction
If this is set to true, the solver is forced to test the residual after each Newton step...
Definition: newton_solver.h:98
virtual void add(const numeric_index_type i, const T value)=0
Adds value to each entry of the vector.
long double min(long double a, double b)
static unsigned int libMesh::ReferenceCounter::n_objects ( )
staticinherited
processor_id_type libMesh::ParallelObject::n_processors ( ) const
inherited
Returns
The number of processors in the group.

Definition at line 93 of file parallel_object.h.

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

Referenced by libMesh::ParmetisPartitioner::_do_repartition(), libMesh::BoundaryInfo::_find_id_maps(), libMesh::DistributedMesh::add_elem(), libMesh::DistributedMesh::add_node(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::FEMSystem::assembly(), libMesh::ParmetisPartitioner::assign_partitioning(), libMesh::AztecLinearSolver< T >::AztecLinearSolver(), libMesh::MeshCommunication::broadcast(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::DistributedMesh::clear(), libMesh::Nemesis_IO_Helper::compute_border_node_ids(), libMesh::Nemesis_IO_Helper::construct_nemesis_filename(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::UnstructuredMesh::create_pid_mesh(), libMesh::MeshTools::create_processor_bounding_box(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::distribute_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), libMesh::DistributedMesh::DistributedMesh(), libMesh::EnsightIO::EnsightIO(), libMesh::MeshCommunication::gather(), libMesh::MeshCommunication::gather_neighboring_elements(), libMesh::MeshBase::get_info(), libMesh::EquationSystems::get_solution(), libMesh::SystemSubsetBySubdomain::init(), libMesh::ParmetisPartitioner::initialize(), libMesh::Nemesis_IO_Helper::initialize(), libMesh::DistributedMesh::insert_elem(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_topology_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_valid_boundary_ids(), libMesh::MeshTools::libmesh_assert_valid_dof_ids(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::MeshTools::libmesh_assert_valid_refinement_flags(), libMesh::DofMap::local_variable_indices(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshBase::n_active_elem_on_proc(), libMesh::MeshBase::n_elem_on_proc(), libMesh::MeshBase::n_nodes_on_proc(), libMesh::SparsityPattern::Build::parallel_sync(), libMesh::Partitioner::partition(), libMesh::MeshBase::partition(), libMesh::Partitioner::partition_unpartitioned_elements(), libMesh::PetscLinearSolver< T >::PetscLinearSolver(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::SparseMatrix< T >::print(), libMesh::NameBasedIO::read(), libMesh::Nemesis_IO::read(), libMesh::CheckpointIO::read(), libMesh::CheckpointIO::read_connectivity(), libMesh::XdrIO::read_header(), libMesh::CheckpointIO::read_nodes(), libMesh::MeshCommunication::redistribute(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::Partitioner::repartition(), libMesh::MeshCommunication::send_coarse_ghosts(), libMesh::Partitioner::set_node_processor_ids(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::Parallel::Sort< KeyType, IdxType >::sort(), WriteVecAndScalar::testWrite(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::GMVIO::write_binary(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), and libMesh::XdrIO::write_serialized_nodesets().

94  { return cast_int<processor_id_type>(_communicator.size()); }
unsigned int size() const
Definition: parallel.h:726
const Parallel::Communicator & _communicator
void libMesh::NewtonSolver::print_convergence ( unsigned int  step_num,
Real  current_residual,
Real  step_norm,
bool  linear_solve_finished 
)
protected

This prints output for the convergence criteria based on by the given residual and step size.

Definition at line 609 of file newton_solver.C.

References libMesh::DiffSolver::absolute_residual_tolerance, libMesh::DiffSolver::absolute_step_tolerance, libMesh::DiffSolver::max_residual_norm, libMesh::DiffSolver::max_solution_norm, libMesh::out, libMesh::DiffSolver::relative_residual_tolerance, libMesh::DiffSolver::relative_step_tolerance, and libMesh::DiffSolver::verbose.

Referenced by solve().

613 {
614  // Is our absolute residual low enough?
615  if (current_residual < absolute_residual_tolerance)
616  {
617  libMesh::out << " Nonlinear solver converged, step " << step_num
618  << ", residual " << current_residual
619  << std::endl;
620  }
622  {
623  if (verbose)
624  libMesh::out << " Nonlinear solver current_residual "
625  << current_residual << " > "
626  << (absolute_residual_tolerance) << std::endl;
627  }
628 
629  // Is our relative residual low enough?
630  if ((current_residual / max_residual_norm) <
632  {
633  libMesh::out << " Nonlinear solver converged, step " << step_num
634  << ", residual reduction "
635  << current_residual / max_residual_norm
636  << " < " << relative_residual_tolerance
637  << std::endl;
638  }
640  {
641  if (verbose)
642  libMesh::out << " Nonlinear solver relative residual "
643  << (current_residual / max_residual_norm)
644  << " > " << relative_residual_tolerance
645  << std::endl;
646  }
647 
648  // For incomplete linear solves, it's not safe to test step sizes
649  if (!linear_solve_finished)
650  return;
651 
652  // Is our absolute Newton step size small enough?
653  if (step_norm < absolute_step_tolerance)
654  {
655  libMesh::out << " Nonlinear solver converged, step " << step_num
656  << ", absolute step size "
657  << step_norm
658  << " < " << absolute_step_tolerance
659  << std::endl;
660  }
661  else if (absolute_step_tolerance)
662  {
663  if (verbose)
664  libMesh::out << " Nonlinear solver absolute step size "
665  << step_norm
666  << " > " << absolute_step_tolerance
667  << std::endl;
668  }
669 
670  // Is our relative Newton step size small enough?
671  if (step_norm / max_solution_norm <
673  {
674  libMesh::out << " Nonlinear solver converged, step " << step_num
675  << ", relative step size "
676  << (step_norm / max_solution_norm)
677  << " < " << relative_step_tolerance
678  << std::endl;
679  }
680  else if (relative_step_tolerance)
681  {
682  if (verbose)
683  libMesh::out << " Nonlinear solver relative step size "
684  << (step_norm / max_solution_norm)
685  << " > " << relative_step_tolerance
686  << std::endl;
687  }
688 }
Real absolute_step_tolerance
The DiffSolver should exit after the full nonlinear step norm is reduced to either less than absolute...
Definition: diff_solver.h:203
Real absolute_residual_tolerance
The DiffSolver should exit after the residual is reduced to either less than absolute_residual_tolera...
Definition: diff_solver.h:191
Real max_solution_norm
The largest solution norm which the DiffSolver has yet seen will be stored here, to be used for stopp...
Definition: diff_solver.h:296
Real max_residual_norm
The largest nonlinear residual which the DiffSolver has yet seen will be stored here, to be used for stopping criteria based on relative_residual_tolerance.
Definition: diff_solver.h:303
bool verbose
The DiffSolver may print a lot more to libMesh::out if verbose is set to true; default is false...
Definition: diff_solver.h:168
OStreamProxy out
Real relative_residual_tolerance
Definition: diff_solver.h:192
void libMesh::ReferenceCounter::print_info ( std::ostream &  out = libMesh::out)
staticinherited

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

Definition at line 88 of file reference_counter.C.

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

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

89 {
91  out_stream << ReferenceCounter::get_info();
92 }
static std::string get_info()
Gets a string containing the reference information.
static bool _enable_print_counter
Flag to control whether reference count information is printed when print_info is called...
processor_id_type libMesh::ParallelObject::processor_id ( ) const
inherited
Returns
The rank of this processor in the group.

Definition at line 99 of file parallel_object.h.

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

Referenced by libMesh::BoundaryInfo::_find_id_maps(), libMesh::EquationSystems::_read_impl(), libMesh::DistributedMesh::add_elem(), libMesh::BoundaryInfo::add_elements(), libMesh::DofMap::add_neighbors_to_send_list(), libMesh::DistributedMesh::add_node(), libMesh::MeshRefinement::add_node(), libMesh::MeshTools::Modification::all_tri(), libMesh::FEMSystem::assembly(), libMesh::ParmetisPartitioner::assign_partitioning(), libMesh::MeshCommunication::broadcast(), libMesh::EquationSystems::build_discontinuous_solution_vector(), libMesh::Nemesis_IO_Helper::build_element_and_node_maps(), libMesh::ParmetisPartitioner::build_graph(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::DofMap::build_sparsity(), libMesh::DistributedMesh::clear(), libMesh::ExodusII_IO_Helper::close(), libMesh::Nemesis_IO_Helper::compute_border_node_ids(), libMesh::Nemesis_IO_Helper::compute_communication_map_parameters(), libMesh::Nemesis_IO_Helper::compute_internal_and_border_elems_and_internal_nodes(), libMesh::RBConstruction::compute_max_error_bound(), libMesh::Nemesis_IO_Helper::compute_node_communication_maps(), libMesh::Nemesis_IO_Helper::compute_num_global_elem_blocks(), libMesh::Nemesis_IO_Helper::compute_num_global_nodesets(), libMesh::Nemesis_IO_Helper::compute_num_global_sidesets(), libMesh::Nemesis_IO_Helper::construct_nemesis_filename(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::ExodusII_IO_Helper::create(), libMesh::DistributedMesh::delete_elem(), libMesh::DistributedMesh::delete_node(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::distribute_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), libMesh::DistributedMesh::DistributedMesh(), libMesh::EnsightIO::EnsightIO(), libMesh::RBEIMConstruction::evaluate_mesh_function(), libMesh::MeshFunction::find_element(), libMesh::MeshFunction::find_elements(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::MeshCommunication::gather(), libMesh::MeshCommunication::gather_neighboring_elements(), libMesh::Nemesis_IO_Helper::get_cmap_params(), libMesh::Nemesis_IO_Helper::get_eb_info_global(), libMesh::Nemesis_IO_Helper::get_elem_cmap(), libMesh::Nemesis_IO_Helper::get_elem_map(), libMesh::MeshBase::get_info(), libMesh::DofMap::get_info(), libMesh::Nemesis_IO_Helper::get_init_global(), libMesh::Nemesis_IO_Helper::get_init_info(), libMesh::Nemesis_IO_Helper::get_loadbal_param(), libMesh::Nemesis_IO_Helper::get_node_cmap(), libMesh::Nemesis_IO_Helper::get_node_map(), libMesh::Nemesis_IO_Helper::get_ns_param_global(), libMesh::EquationSystems::get_solution(), libMesh::Nemesis_IO_Helper::get_ss_param_global(), libMesh::SparsityPattern::Build::handle_vi_vj(), libMesh::SystemSubsetBySubdomain::init(), HeatSystem::init_data(), libMesh::ParmetisPartitioner::initialize(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::ExodusII_IO_Helper::initialize_element_variables(), libMesh::ExodusII_IO_Helper::initialize_global_variables(), libMesh::ExodusII_IO_Helper::initialize_nodal_variables(), libMesh::DistributedMesh::insert_elem(), libMesh::DofMap::is_evaluable(), libMesh::SparsityPattern::Build::join(), libMesh::TransientRBEvaluation::legacy_write_offline_data_to_files(), libMesh::RBEIMEvaluation::legacy_write_offline_data_to_files(), libMesh::RBEvaluation::legacy_write_offline_data_to_files(), libMesh::RBSCMEvaluation::legacy_write_offline_data_to_files(), libMesh::RBEIMEvaluation::legacy_write_out_interpolation_points_elem(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_object_ids(), libMesh::DofMap::local_variable_indices(), main(), libMesh::MeshRefinement::make_coarsening_compatible(), AugmentSparsityOnInterface::mesh_reinit(), libMesh::MeshBase::n_active_local_elem(), libMesh::BoundaryInfo::n_boundary_conds(), libMesh::BoundaryInfo::n_edge_conds(), libMesh::System::n_local_dofs(), libMesh::MeshBase::n_local_elem(), libMesh::MeshBase::n_local_nodes(), libMesh::BoundaryInfo::n_nodeset_conds(), libMesh::BoundaryInfo::n_shellface_conds(), libMesh::WeightedPatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::SparsityPattern::Build::operator()(), libMesh::PatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::SparsityPattern::Build::parallel_sync(), libMesh::MetisPartitioner::partition_range(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::SparseMatrix< T >::print(), libMesh::NumericVector< T >::print_global(), libMesh::Nemesis_IO_Helper::put_cmap_params(), libMesh::Nemesis_IO_Helper::put_elem_cmap(), libMesh::Nemesis_IO_Helper::put_elem_map(), libMesh::Nemesis_IO_Helper::put_loadbal_param(), libMesh::Nemesis_IO_Helper::put_node_cmap(), libMesh::Nemesis_IO_Helper::put_node_map(), libMesh::NameBasedIO::read(), libMesh::Nemesis_IO::read(), libMesh::CheckpointIO::read(), libMesh::XdrIO::read(), libMesh::ExodusII_IO_Helper::read_elem_num_map(), libMesh::CheckpointIO::read_header(), libMesh::XdrIO::read_header(), libMesh::RBEvaluation::read_in_vectors_from_multiple_files(), libMesh::ExodusII_IO_Helper::read_node_num_map(), libMesh::TransientRBConstruction::read_riesz_representors_from_files(), libMesh::RBConstruction::read_riesz_representors_from_files(), libMesh::XdrIO::read_serialized_bc_names(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::MeshCommunication::redistribute(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::MeshCommunication::send_coarse_ghosts(), libMesh::Partitioner::set_node_processor_ids(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::LaplaceMeshSmoother::smooth(), DefaultCouplingTest::testCoupling(), PointNeighborCouplingTest::testCoupling(), BoundaryInfoTest::testShellFaceConstraints(), WriteVecAndScalar::testWrite(), libMesh::MeshTools::total_weight(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::Parallel::Packing< Node * >::unpack(), libMesh::Parallel::Packing< Elem * >::unpack(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::DTKAdapter::update_variable_values(), libMesh::MeshTools::weight(), libMesh::NameBasedIO::write(), libMesh::CheckpointIO::write(), libMesh::XdrIO::write(), libMesh::EquationSystems::write(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::ExodusII_IO::write_element_data(), libMesh::ExodusII_IO_Helper::write_element_values(), libMesh::ExodusII_IO_Helper::write_elements(), libMesh::ExodusII_IO::write_global_data(), libMesh::ExodusII_IO_Helper::write_global_values(), libMesh::ExodusII_IO::write_information_records(), libMesh::ExodusII_IO_Helper::write_information_records(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates(), libMesh::UCDIO::write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data_discontinuous(), libMesh::ExodusII_IO_Helper::write_nodal_values(), libMesh::Nemesis_IO_Helper::write_nodesets(), libMesh::ExodusII_IO_Helper::write_nodesets(), libMesh::RBEvaluation::write_out_vectors(), write_output_solvedata(), libMesh::RBConstruction::write_riesz_representors_to_files(), libMesh::XdrIO::write_serialized_bc_names(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), libMesh::XdrIO::write_serialized_nodesets(), libMesh::XdrIO::write_serialized_subdomain_names(), libMesh::Nemesis_IO_Helper::write_sidesets(), libMesh::ExodusII_IO_Helper::write_sidesets(), libMesh::ExodusII_IO::write_timestep(), and libMesh::ExodusII_IO_Helper::write_timestep().

100  { return cast_int<processor_id_type>(_communicator.rank()); }
const Parallel::Communicator & _communicator
unsigned int rank() const
Definition: parallel.h:724
void libMesh::NewtonSolver::reinit ( )
virtual

The reinitialization function.

This method is used after changes in the mesh.

Reimplemented from libMesh::DiffSolver.

Definition at line 266 of file newton_solver.C.

References _linear_solver, libMesh::DiffSolver::_system, and libMesh::DiffSolver::reinit().

267 {
268  Parent::reinit();
269 
270  _linear_solver->clear();
271 
272  _linear_solver->init_names(_system);
273 }
virtual void reinit()
The reinitialization function.
Definition: diff_solver.C:60
sys_type & _system
A reference to the system we are solving.
Definition: diff_solver.h:318
UniquePtr< LinearSolver< Number > > _linear_solver
The LinearSolver defines the interface used to solve the linear_implicit system.
unsigned int libMesh::NewtonSolver::solve ( )
virtual

This method performs a solve, using an inexact Newton-Krylov method with line search.

Implements libMesh::DiffSolver.

Definition at line 277 of file newton_solver.C.

References libMesh::DiffSolver::_inner_iterations, _linear_solver, libMesh::DiffSolver::_outer_iterations, libMesh::DiffSolver::_solve_result, libMesh::DiffSolver::_system, libMesh::DiffSolver::absolute_residual_tolerance, libMesh::DiffSolver::absolute_step_tolerance, libMesh::NumericVector< T >::add(), libMesh::ImplicitSystem::assembly(), libMesh::NumericVector< T >::close(), libMesh::SparseMatrix< T >::close(), libMesh::DiffSolver::continue_after_max_iterations, libMesh::DiffSolver::CONVERGED_ABSOLUTE_RESIDUAL, libMesh::DiffSolver::CONVERGED_ABSOLUTE_STEP, libMesh::DiffSolver::CONVERGED_RELATIVE_RESIDUAL, libMesh::DiffSolver::CONVERGED_RELATIVE_STEP, libMesh::DiffSolver::DIVERGED_BACKTRACKING_FAILURE, libMesh::DiffSolver::DIVERGED_LINEAR_SOLVER_FAILURE, libMesh::DiffSolver::DIVERGED_MAX_NONLINEAR_ITERATIONS, libMesh::DofMap::enforce_constraints_exactly(), libMesh::System::get_dof_map(), libMesh::DiffSolver::initial_linear_tolerance, libMesh::DiffSolver::INVALID_SOLVE_RESULT, libMesh::NumericVector< T >::l2_norm(), libMesh::libmesh_assert(), libMesh::libmesh_isnan(), line_search(), libMesh::DiffSolver::linear_solution_monitor, linear_tolerance_multiplier, libMesh::ImplicitSystem::matrix, std::max(), libMesh::DiffSolver::max_linear_iterations, libMesh::DiffSolver::max_nonlinear_iterations, libMesh::DiffSolver::max_residual_norm, libMesh::DiffSolver::max_solution_norm, std::min(), libMesh::DiffSolver::minimum_linear_tolerance, libMesh::out, print_convergence(), libMesh::DiffSolver::quiet, libMesh::Real, libMesh::DiffSolver::relative_residual_tolerance, libMesh::DiffSolver::relative_step_tolerance, libMesh::ImplicitSystem::request_matrix(), require_finite_residual, require_residual_reduction, libMesh::ExplicitSystem::rhs, libMesh::System::solution, test_convergence(), libMesh::TOLERANCE, track_linear_convergence, libMesh::System::update(), libMesh::DiffSolver::verbose, libMesh::NumericVector< T >::zero(), and libMesh::NumericVector< T >::zero_clone().

278 {
279  LOG_SCOPE("solve()", "NewtonSolver");
280 
281  // Reset any prior solve result
283 
284  NumericVector<Number> & newton_iterate = *(_system.solution);
285 
286  UniquePtr<NumericVector<Number>> linear_solution_ptr = newton_iterate.zero_clone();
287  NumericVector<Number> & linear_solution = *linear_solution_ptr;
288  NumericVector<Number> & rhs = *(_system.rhs);
289 
290  newton_iterate.close();
291  linear_solution.close();
292  rhs.close();
293 
294 #ifdef LIBMESH_ENABLE_CONSTRAINTS
296 #endif
297 
298  SparseMatrix<Number> & matrix = *(_system.matrix);
299 
300  // Set starting linear tolerance
301  Real current_linear_tolerance = initial_linear_tolerance;
302 
303  // Start counting our linear solver steps
304  _inner_iterations = 0;
305 
306  // Now we begin the nonlinear loop
309  {
310  if (verbose)
311  libMesh::out << "Assembling the System" << std::endl;
312 
313  _system.assembly(true, true);
314  rhs.close();
315  Real current_residual = rhs.l2_norm();
316 
317  if (libmesh_isnan(current_residual))
318  {
319  libMesh::out << " Nonlinear solver DIVERGED at step "
321  << " with residual Not-a-Number"
322  << std::endl;
323  libmesh_convergence_failure();
324  continue;
325  }
326 
327  if (current_residual <= absolute_residual_tolerance)
328  {
329  if (verbose)
330  libMesh::out << "Linear solve unnecessary; residual "
331  << current_residual
332  << " meets absolute tolerance "
334  << std::endl;
335 
336  // We're not doing a solve, but other code may reuse this
337  // matrix.
338  matrix.close();
339 
341  if (current_residual == 0)
342  {
345  if (absolute_step_tolerance > 0)
347  if (relative_step_tolerance > 0)
349  }
350 
351  break;
352  }
353 
354  // Prepare to take incomplete steps
355  Real last_residual = current_residual;
356 
357  max_residual_norm = std::max (current_residual,
359 
360  // Compute the l2 norm of the whole solution
361  Real norm_total = newton_iterate.l2_norm();
362 
364 
365  if (verbose)
366  libMesh::out << "Nonlinear Residual: "
367  << current_residual << std::endl;
368 
369  // Make sure our linear tolerance is low enough
370  current_linear_tolerance = std::min (current_linear_tolerance,
371  current_residual * linear_tolerance_multiplier);
372 
373  // But don't let it be too small
374  if (current_linear_tolerance < minimum_linear_tolerance)
375  {
376  current_linear_tolerance = minimum_linear_tolerance;
377  }
378 
379  // If starting the nonlinear solve with a really good initial guess, we dont want to set an absurd linear tolerance
380  current_linear_tolerance = std::max(current_linear_tolerance, absolute_residual_tolerance / current_residual / 10.0);
381 
382  // At this point newton_iterate is the current guess, and
383  // linear_solution is now about to become the NEGATIVE of the next
384  // Newton step.
385 
386  // Our best initial guess for the linear_solution is zero!
387  linear_solution.zero();
388 
389  if (verbose)
390  libMesh::out << "Linear solve starting, tolerance "
391  << current_linear_tolerance << std::endl;
392 
393  // Solve the linear system.
394  const std::pair<unsigned int, Real> rval =
395  _linear_solver->solve (matrix, _system.request_matrix("Preconditioner"),
396  linear_solution, rhs, current_linear_tolerance,
398 
400  {
401  LinearConvergenceReason linear_c_reason = _linear_solver->get_converged_reason();
402 
403  // Check if something went wrong during the linear solve
404  if (linear_c_reason < 0)
405  {
406  // The linear solver failed somehow
408  // Print a message
409  libMesh::out << "Linear solver failed during Newton step, dropping out."
410  << std::endl;
411  break;
412  }
413  }
414 
415  // We may need to localize a parallel solution
416  _system.update ();
417  // The linear solver may not have fit our constraints exactly
418 #ifdef LIBMESH_ENABLE_CONSTRAINTS
420  (_system, &linear_solution, /* homogeneous = */ true);
421 #endif
422 
423  const unsigned int linear_steps = rval.first;
424  libmesh_assert_less_equal (linear_steps, max_linear_iterations);
425  _inner_iterations += linear_steps;
426 
427  const bool linear_solve_finished =
428  !(linear_steps == max_linear_iterations);
429 
430  if (verbose)
431  libMesh::out << "Linear solve finished, step " << linear_steps
432  << ", residual " << rval.second
433  << std::endl;
434 
435  // Compute the l2 norm of the nonlinear update
436  Real norm_delta = linear_solution.l2_norm();
437 
438  if (verbose)
439  libMesh::out << "Trying full Newton step" << std::endl;
440  // Take a full Newton step
441  newton_iterate.add (-1., linear_solution);
442  newton_iterate.close();
443 
444  if (this->linear_solution_monitor.get())
445  {
446  // Compute the l2 norm of the whole solution
447  norm_total = newton_iterate.l2_norm();
448  rhs.close();
449  (*this->linear_solution_monitor)(linear_solution, norm_delta,
450  newton_iterate, norm_total,
451  rhs, rhs.l2_norm(), _outer_iterations);
452  }
453 
454  // Check residual with full Newton step, if that's useful for determining
455  // whether to line search, whether to quit early, or whether to die after
456  // hitting our max iteration count
457  if (this->require_residual_reduction ||
458  this->require_finite_residual ||
459  _outer_iterations+1 < max_nonlinear_iterations ||
461  {
462  _system.assembly(true, false);
463 
464  rhs.close();
465  current_residual = rhs.l2_norm();
466  if (verbose)
467  libMesh::out << " Current Residual: "
468  << current_residual << std::endl;
469 
470  // don't fiddle around if we've already converged
471  if (test_convergence(current_residual, norm_delta,
472  linear_solve_finished &&
473  current_residual <= last_residual))
474  {
475  if (!quiet)
476  print_convergence(_outer_iterations, current_residual,
477  norm_delta, linear_solve_finished &&
478  current_residual <= last_residual);
480  break; // out of _outer_iterations for loop
481  }
482  }
483 
484  // since we're not converged, backtrack if necessary
485  Real steplength =
486  this->line_search(std::sqrt(TOLERANCE),
487  last_residual, current_residual,
488  newton_iterate, linear_solution);
489  norm_delta *= steplength;
490 
491  // Check to see if backtracking failed,
492  // and break out of the nonlinear loop if so...
494  {
496  break; // out of _outer_iterations for loop
497  }
498 
499  if (_outer_iterations + 1 >= max_nonlinear_iterations)
500  {
501  libMesh::out << " Nonlinear solver reached maximum step "
502  << max_nonlinear_iterations << ", latest evaluated residual "
503  << current_residual << std::endl;
505  {
507  libMesh::out << " Continuing..." << std::endl;
508  }
509  else
510  {
511  libmesh_convergence_failure();
512  }
513  continue;
514  }
515 
516  // Compute the l2 norm of the whole solution
517  norm_total = newton_iterate.l2_norm();
518 
520 
521  // Print out information for the
522  // nonlinear iterations.
523  if (verbose)
524  libMesh::out << " Nonlinear step: |du|/|u| = "
525  << norm_delta / norm_total
526  << ", |du| = " << norm_delta
527  << std::endl;
528 
529  // Terminate the solution iteration if the difference between
530  // this iteration and the last is sufficiently small.
531  if (test_convergence(current_residual, norm_delta / steplength,
532  linear_solve_finished))
533  {
534  if (!quiet)
535  print_convergence(_outer_iterations, current_residual,
536  norm_delta / steplength,
537  linear_solve_finished);
539  break; // out of _outer_iterations for loop
540  }
541  } // end nonlinear loop
542 
543  // The linear solver may not have fit our constraints exactly
544 #ifdef LIBMESH_ENABLE_CONSTRAINTS
546 #endif
547 
548  // We may need to localize a parallel solution
549  _system.update ();
550 
551  // Make sure we are returning something sensible as the
552  // _solve_result, except in the edge case where we weren't really asked to
553  // solve.
555  !max_nonlinear_iterations);
556 
557  return _solve_result;
558 }
bool continue_after_max_iterations
Defaults to true, telling the DiffSolver to continue rather than exit when a solve has reached its ma...
Definition: diff_solver.h:174
Real minimum_linear_tolerance
The tolerance for linear solves is kept above this minimum.
Definition: diff_solver.h:215
Real absolute_step_tolerance
The DiffSolver should exit after the full nonlinear step norm is reduced to either less than absolute...
Definition: diff_solver.h:203
bool quiet
The DiffSolver should not print anything to libMesh::out unless quiet is set to false; default is tru...
Definition: diff_solver.h:162
unsigned int max_nonlinear_iterations
The DiffSolver should exit in failure if max_nonlinear_iterations is exceeded and continue_after_max_...
Definition: diff_solver.h:156
Real absolute_residual_tolerance
The DiffSolver should exit after the residual is reduced to either less than absolute_residual_tolera...
Definition: diff_solver.h:191
Real max_solution_norm
The largest solution norm which the DiffSolver has yet seen will be stored here, to be used for stopp...
Definition: diff_solver.h:296
Real max_residual_norm
The largest nonlinear residual which the DiffSolver has yet seen will be stored here, to be used for stopping criteria based on relative_residual_tolerance.
Definition: diff_solver.h:303
The DiffSolver achieved the desired absolute step size tolerance.
Definition: diff_solver.h:251
NumericVector< Number > * rhs
The system matrix.
static const Real TOLERANCE
Real initial_linear_tolerance
Any required linear solves will at first be done with this tolerance; the DiffSolver may tighten the ...
Definition: diff_solver.h:210
The linear solver used by the DiffSolver failed to find a solution.
Definition: diff_solver.h:282
long double max(long double a, double b)
unsigned int _solve_result
Initialized to zero.
Definition: diff_solver.h:326
unsigned int _inner_iterations
The number of inner iterations used by the last solve.
Definition: diff_solver.h:313
libmesh_assert(j)
The DiffSolver reached the maximum allowed number of nonlinear iterations before satisfying any conve...
Definition: diff_solver.h:270
The DiffSolver achieved the desired relative step size tolerance.
Definition: diff_solver.h:257
virtual void assembly(bool, bool, bool=false, bool=false)
Assembles a residual in rhs and/or a jacobian in matrix, as requested.
const DofMap & get_dof_map() const
Definition: system.h:2030
sys_type & _system
A reference to the system we are solving.
Definition: diff_solver.h:318
unsigned int max_linear_iterations
Each linear solver step should exit after max_linear_iterations is exceeded.
Definition: diff_solver.h:148
bool require_finite_residual
If this is set to true, the solver is forced to test the residual after each Newton step...
The DiffSolver achieved the desired relative residual tolerance.
Definition: diff_solver.h:245
bool track_linear_convergence
If set to true, check for convergence of the linear solve.
UniquePtr< NumericVector< Number > > solution
Data structure to hold solution values.
Definition: system.h:1523
void enforce_constraints_exactly(const System &system, NumericVector< Number > *v=libmesh_nullptr, bool homogeneous=false) const
Constrains the numeric vector v, which represents a solution defined on the mesh. ...
Definition: dof_map.h:1816
Real linear_tolerance_multiplier
The tolerance for linear solves is kept below this multiplier (which defaults to 1e-3) times the norm...
const SparseMatrix< Number > * request_matrix(const std::string &mat_name) const
bool verbose
The DiffSolver may print a lot more to libMesh::out if verbose is set to true; default is false...
Definition: diff_solver.h:168
virtual void update()
Update the local values to reflect the solution on neighboring processors.
Definition: system.C:425
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
The DiffSolver achieved the desired absolute residual tolerance.
Definition: diff_solver.h:239
bool libmesh_isnan(float a)
unsigned int _outer_iterations
The number of outer iterations used by the last solve.
Definition: diff_solver.h:308
OStreamProxy out
SparseMatrix< Number > * matrix
The system matrix.
UniquePtr< LinearSolver< Number > > _linear_solver
The LinearSolver defines the interface used to solve the linear_implicit system.
bool test_convergence(Real current_residual, Real step_norm, bool linear_solve_finished)
LinearConvergenceReason
Linear solver convergence flags (taken from the PETSc flags)
UniquePtr< LinearSolutionMonitor > linear_solution_monitor
Pointer to functor which is called right after each linear solve.
Definition: diff_solver.h:288
The DiffSolver failed to find a descent direction by backtracking (See newton_solver.C)
Definition: diff_solver.h:276
bool require_residual_reduction
If this is set to true, the solver is forced to test the residual after each Newton step...
Definition: newton_solver.h:98
A default or invalid solve result.
Definition: diff_solver.h:227
Real line_search(Real tol, Real last_residual, Real &current_residual, NumericVector< Number > &newton_iterate, const NumericVector< Number > &linear_solution)
This does a line search in the direction opposite linear_solution to try and minimize the residual of...
Definition: newton_solver.C:38
void print_convergence(unsigned int step_num, Real current_residual, Real step_norm, bool linear_solve_finished)
This prints output for the convergence criteria based on by the given residual and step size...
long double min(long double a, double b)
Real relative_residual_tolerance
Definition: diff_solver.h:192
unsigned int libMesh::DiffSolver::solve_result ( )
inherited
Returns
The value of the SolveResult from the last solve.

Definition at line 132 of file diff_solver.h.

132 { return _solve_result; }
unsigned int _solve_result
Initialized to zero.
Definition: diff_solver.h:326
const sys_type& libMesh::DiffSolver::system ( ) const
inherited
Returns
A constant reference to the system we are solving.

Definition at line 137 of file diff_solver.h.

Referenced by libMesh::__libmesh_petsc_diff_solver_residual().

137 { return _system; }
sys_type & _system
A reference to the system we are solving.
Definition: diff_solver.h:318
sys_type& libMesh::DiffSolver::system ( )
inherited
Returns
A writable reference to the system we are solving.

Definition at line 142 of file diff_solver.h.

142 { return _system; }
sys_type & _system
A reference to the system we are solving.
Definition: diff_solver.h:318
bool libMesh::NewtonSolver::test_convergence ( Real  current_residual,
Real  step_norm,
bool  linear_solve_finished 
)
protected
Returns
true if a convergence criterion has been passed by the given residual and step size; false otherwise.

Definition at line 562 of file newton_solver.C.

References libMesh::DiffSolver::_solve_result, libMesh::DiffSolver::absolute_residual_tolerance, libMesh::DiffSolver::absolute_step_tolerance, libMesh::DiffSolver::CONVERGED_ABSOLUTE_RESIDUAL, libMesh::DiffSolver::CONVERGED_ABSOLUTE_STEP, libMesh::DiffSolver::CONVERGED_RELATIVE_RESIDUAL, libMesh::DiffSolver::CONVERGED_RELATIVE_STEP, libMesh::DiffSolver::max_residual_norm, libMesh::DiffSolver::max_solution_norm, libMesh::DiffSolver::relative_residual_tolerance, and libMesh::DiffSolver::relative_step_tolerance.

Referenced by solve().

565 {
566  // We haven't converged unless we pass a convergence test
567  bool has_converged = false;
568 
569  // Is our absolute residual low enough?
570  if (current_residual < absolute_residual_tolerance)
571  {
573  has_converged = true;
574  }
575 
576  // Is our relative residual low enough?
577  if ((current_residual / max_residual_norm) <
579  {
581  has_converged = true;
582  }
583 
584  // For incomplete linear solves, it's not safe to test step sizes
585  if (!linear_solve_finished)
586  {
587  return has_converged;
588  }
589 
590  // Is our absolute Newton step size small enough?
591  if (step_norm < absolute_step_tolerance)
592  {
594  has_converged = true;
595  }
596 
597  // Is our relative Newton step size small enough?
598  if (step_norm / max_solution_norm <
600  {
602  has_converged = true;
603  }
604 
605  return has_converged;
606 }
Real absolute_step_tolerance
The DiffSolver should exit after the full nonlinear step norm is reduced to either less than absolute...
Definition: diff_solver.h:203
Real absolute_residual_tolerance
The DiffSolver should exit after the residual is reduced to either less than absolute_residual_tolera...
Definition: diff_solver.h:191
Real max_solution_norm
The largest solution norm which the DiffSolver has yet seen will be stored here, to be used for stopp...
Definition: diff_solver.h:296
Real max_residual_norm
The largest nonlinear residual which the DiffSolver has yet seen will be stored here, to be used for stopping criteria based on relative_residual_tolerance.
Definition: diff_solver.h:303
The DiffSolver achieved the desired absolute step size tolerance.
Definition: diff_solver.h:251
unsigned int _solve_result
Initialized to zero.
Definition: diff_solver.h:326
The DiffSolver achieved the desired relative step size tolerance.
Definition: diff_solver.h:257
The DiffSolver achieved the desired relative residual tolerance.
Definition: diff_solver.h:245
The DiffSolver achieved the desired absolute residual tolerance.
Definition: diff_solver.h:239
Real relative_residual_tolerance
Definition: diff_solver.h:192
unsigned int libMesh::DiffSolver::total_inner_iterations ( )
inherited
Returns
The number of "inner" (e.g. Krylov) iterations required by the last solve.

Definition at line 127 of file diff_solver.h.

127 { return _inner_iterations; }
unsigned int _inner_iterations
The number of inner iterations used by the last solve.
Definition: diff_solver.h:313
unsigned int libMesh::DiffSolver::total_outer_iterations ( )
inherited
Returns
The number of "outer" (e.g. quasi-Newton) iterations required by the last solve.

Definition at line 121 of file diff_solver.h.

121 { return _outer_iterations; }
unsigned int _outer_iterations
The number of outer iterations used by the last solve.
Definition: diff_solver.h:308

Member Data Documentation

const Parallel::Communicator& libMesh::ParallelObject::_communicator
protectedinherited
ReferenceCounter::Counts libMesh::ReferenceCounter::_counts
staticprotectedinherited
bool libMesh::ReferenceCounter::_enable_print_counter = true
staticprotectedinherited

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

Definition at line 143 of file reference_counter.h.

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

unsigned int libMesh::DiffSolver::_inner_iterations
protectedinherited

The number of inner iterations used by the last solve.

Definition at line 313 of file diff_solver.h.

Referenced by solve().

UniquePtr<LinearSolver<Number> > libMesh::NewtonSolver::_linear_solver
protected

The LinearSolver defines the interface used to solve the linear_implicit system.

This class handles all the details of interfacing with various linear algebra packages like PETSc or LASPACK.

Definition at line 153 of file newton_solver.h.

Referenced by get_linear_solver(), init(), reinit(), and solve().

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

Mutual exclusion object to enable thread-safe reference counting.

Definition at line 137 of file reference_counter.h.

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

The number of objects.

Print the reference count information when the number returns to 0.

Definition at line 132 of file reference_counter.h.

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

unsigned int libMesh::DiffSolver::_outer_iterations
protectedinherited

The number of outer iterations used by the last solve.

Definition at line 308 of file diff_solver.h.

Referenced by line_search(), and solve().

unsigned int libMesh::DiffSolver::_solve_result
protectedinherited

Initialized to zero.

solve_result is typically set internally in the solve() function before it returns. When non-zero, solve_result tells the result of the latest solve. See enum definition for description.

Definition at line 326 of file diff_solver.h.

Referenced by line_search(), solve(), and test_convergence().

sys_type& libMesh::DiffSolver::_system
protectedinherited

A reference to the system we are solving.

Definition at line 318 of file diff_solver.h.

Referenced by init(), libMesh::PetscDiffSolver::init(), line_search(), libMesh::PetscDiffSolver::reinit(), reinit(), solve(), and libMesh::PetscDiffSolver::solve().

Real libMesh::DiffSolver::absolute_residual_tolerance
inherited

The DiffSolver 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 191 of file diff_solver.h.

Referenced by SolidSystem::init_data(), main(), print_convergence(), TimeSolverTestImplementation< NewmarkSolver >::run_test_with_exact_soln(), solve(), and test_convergence().

Real libMesh::DiffSolver::absolute_step_tolerance
inherited

The DiffSolver 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.

Definition at line 203 of file diff_solver.h.

Referenced by print_convergence(), solve(), and test_convergence().

bool libMesh::NewtonSolver::brent_line_search

If require_residual_reduction is true, the solver may reduce step lengths when required.

If so, brent_line_search is an option. If brent_line_search is set to false, the solver reduces the length of its steps by 1/2 iteratively until it finds residual reduction. If true, step lengths are first reduced by 1/2 or more to find some residual reduction, then Brent's method is used to find as much residual reduction as possible.

brent_line_search is currently set to true by default.

Definition at line 120 of file newton_solver.h.

Referenced by line_search().

bool libMesh::DiffSolver::continue_after_backtrack_failure
inherited

Defaults to false, telling the DiffSolver to throw an error when the backtracking scheme fails to find a descent direction.

Definition at line 180 of file diff_solver.h.

Referenced by line_search(), and set_system_parameters().

bool libMesh::DiffSolver::continue_after_max_iterations
inherited

Defaults to true, telling the DiffSolver to continue rather than exit when a solve has reached its maximum number of nonlinear iterations.

Definition at line 174 of file diff_solver.h.

Referenced by set_system_parameters(), and solve().

Real libMesh::DiffSolver::initial_linear_tolerance
inherited

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

Definition at line 210 of file diff_solver.h.

Referenced by SolidSystem::init_data(), main(), set_system_parameters(), and solve().

UniquePtr<LinearSolutionMonitor> libMesh::DiffSolver::linear_solution_monitor
inherited

Pointer to functor which is called right after each linear solve.

Definition at line 288 of file diff_solver.h.

Referenced by libMesh::__libmesh_petsc_diff_solver_monitor(), and solve().

Real libMesh::NewtonSolver::linear_tolerance_multiplier

The tolerance for linear solves is kept below this multiplier (which defaults to 1e-3) times the norm of the current nonlinear residual.

Definition at line 143 of file newton_solver.h.

Referenced by set_system_parameters(), and solve().

unsigned int libMesh::DiffSolver::max_linear_iterations
inherited

Each linear solver step should exit after max_linear_iterations is exceeded.

Definition at line 148 of file diff_solver.h.

Referenced by libMesh::ContinuationSystem::continuation_solve(), SolidSystem::init_data(), main(), set_system_parameters(), solve(), and libMesh::ContinuationSystem::solve_tangent().

unsigned int libMesh::DiffSolver::max_nonlinear_iterations
inherited

The DiffSolver should exit in failure if max_nonlinear_iterations is exceeded and continue_after_max_iterations is false, or should end the nonlinear solve if max_nonlinear_iterations is exceeded and continue_after_max_iterations is true.

Definition at line 156 of file diff_solver.h.

Referenced by libMesh::ContinuationSystem::continuation_solve(), SolidSystem::init_data(), main(), set_system_parameters(), solve(), and libMesh::ContinuationSystem::update_solution().

Real libMesh::DiffSolver::max_residual_norm
protectedinherited

The largest nonlinear residual which the DiffSolver has yet seen will be stored here, to be used for stopping criteria based on relative_residual_tolerance.

Definition at line 303 of file diff_solver.h.

Referenced by libMesh::DiffSolver::init(), print_convergence(), libMesh::DiffSolver::reinit(), solve(), and test_convergence().

Real libMesh::DiffSolver::max_solution_norm
protectedinherited

The largest solution norm which the DiffSolver has yet seen will be stored here, to be used for stopping criteria based on relative_step_tolerance.

Definition at line 296 of file diff_solver.h.

Referenced by libMesh::DiffSolver::init(), print_convergence(), libMesh::DiffSolver::reinit(), solve(), and test_convergence().

Real libMesh::DiffSolver::minimum_linear_tolerance
inherited

The tolerance for linear solves is kept above this minimum.

Definition at line 215 of file diff_solver.h.

Referenced by set_system_parameters(), and solve().

Real libMesh::NewtonSolver::minsteplength

If the quasi-Newton step length must be reduced to below this factor to give a residual reduction, then the Newton solver dies with an error message.

It is currently set to 1e-5 by default.

Definition at line 137 of file newton_solver.h.

Referenced by line_search(), and set_system_parameters().

bool libMesh::DiffSolver::quiet
inherited

The DiffSolver should not print anything to libMesh::out unless quiet is set to false; default is true.

Definition at line 162 of file diff_solver.h.

Referenced by SolidSystem::init_data(), line_search(), main(), set_system_parameters(), and solve().

Real libMesh::DiffSolver::relative_residual_tolerance
inherited
Real libMesh::DiffSolver::relative_step_tolerance
inherited
bool libMesh::NewtonSolver::require_finite_residual

If this is set to true, the solver is forced to test the residual after each Newton step, and to reduce the length of its steps whenever necessary to avoid an infinite or NaN residual.

It is currently set to true by default; set it to false to avoid unnecessary residual assembly on well-behaved systems.

Definition at line 107 of file newton_solver.h.

Referenced by line_search(), and solve().

bool libMesh::NewtonSolver::require_residual_reduction

If this is set to true, the solver is forced to test the residual after each Newton step, and to reduce the length of its steps whenever necessary to avoid a residual increase.

It is currently set to true by default; set it to false to avoid unnecessary residual assembly on well-behaved systems.

Definition at line 98 of file newton_solver.h.

Referenced by line_search(), set_system_parameters(), and solve().

bool libMesh::NewtonSolver::track_linear_convergence

If set to true, check for convergence of the linear solve.

If no convergence is acquired during the linear solve, the nonlinear solve fails with DiffSolver::DIVERGED_LINEAR_SOLVER_FAILURE. Enabled by default as nonlinear convergence is very difficult, if the linear solver is not converged.

Definition at line 129 of file newton_solver.h.

Referenced by solve().

bool libMesh::DiffSolver::verbose
inherited

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