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 () override
 The initialization function. More...
 
virtual void reinit () override
 The reinitialization function. More...
 
virtual unsigned int solve () 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_type & system () const
 
sys_type & system ()
 
const Parallel::Communicator & comm () const
 
processor_id_type n_processors () const
 
processor_id_type processor_id () const
 

Static Public Member Functions

static std::unique_ptr< DiffSolver > build (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...
 
double 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
 
double 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...
 
double minimum_linear_tolerance
 The tolerance for linear solves is kept above this minimum. More...
 
std::unique_ptr< LinearSolutionMonitor > linear_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

std::unique_ptr< 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

◆ 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.

◆ Parent

typedef DiffSolver libMesh::NewtonSolver::Parent

Definition at line 61 of file newton_solver.h.

◆ sys_type

typedef ImplicitSystem libMesh::DiffSolver::sys_type
inherited

The type of system.

Definition at line 77 of file diff_solver.h.

Member Enumeration Documentation

◆ SolveResult

enum libMesh::DiffSolver::SolveResult
inherited

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  {
227  INVALID_SOLVE_RESULT = 0,
228 
233  CONVERGED_NO_REASON = 1,
234 
239  CONVERGED_ABSOLUTE_RESIDUAL = 2,
240 
245  CONVERGED_RELATIVE_RESIDUAL = 4,
246 
251  CONVERGED_ABSOLUTE_STEP = 8,
252 
257  CONVERGED_RELATIVE_STEP = 16,
258 
263  DIVERGED_NO_REASON = 32,
264 
270  DIVERGED_MAX_NONLINEAR_ITERATIONS = 64,
271 
276  DIVERGED_BACKTRACKING_FAILURE = 128,
277 
282  DIVERGED_LINEAR_SOLVER_FAILURE = 256
283  };

Constructor & Destructor Documentation

◆ NewtonSolver()

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

Constructor.

Requires a reference to the system to be solved.

Definition at line 237 of file newton_solver.C.

238  : Parent(s),
239  require_residual_reduction(true),
240  require_finite_residual(true),
241  brent_line_search(true),
242  track_linear_convergence(false),
243  minsteplength(1e-5),
244  linear_tolerance_multiplier(1e-3),
245  _linear_solver(LinearSolver<Number>::build(s.comm()))
246 {
247 }

◆ ~NewtonSolver()

libMesh::NewtonSolver::~NewtonSolver ( )
virtual

Destructor.

Definition at line 251 of file newton_solver.C.

252 {
253 }

Member Function Documentation

◆ build()

std::unique_ptr< 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.

54 {
55  return libmesh_make_unique<NewtonSolver>(s);
56 }

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

◆ comm()

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

Definition at line 94 of file parallel_object.h.

95  { return _communicator; }

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::PetscLinearSolver< Number >::_petsc_shell_matrix_get_diagonal(), libMesh::SlepcEigenSolver< libMesh::Number >::_petsc_shell_matrix_get_diagonal(), libMesh::PetscLinearSolver< Number >::_petsc_shell_matrix_mult(), libMesh::SlepcEigenSolver< libMesh::Number >::_petsc_shell_matrix_mult(), libMesh::PetscLinearSolver< Number >::_petsc_shell_matrix_mult_add(), libMesh::EquationSystems::_read_impl(), libMesh::MeshRefinement::_refine_elements(), libMesh::MeshRefinement::_smooth_flags(), libMesh::DofMap::add_constraints_to_send_list(), add_cube_convex_hull_to_mesh(), libMesh::PetscDMWrapper::add_dofs_helper(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::TransientRBConstruction::add_IC_to_RB_space(), libMesh::ImplicitSystem::add_matrix(), libMesh::RBConstruction::add_scaled_matrix_and_vector(), libMesh::DynaIO::add_spline_constraints(), libMesh::System::add_vector(), libMesh::UnstructuredMesh::all_second_order(), libMesh::MeshTools::Modification::all_tri(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::DofMap::allgather_recursive_constraints(), 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::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::System::calculate_norm(), libMesh::DofMap::check_dirichlet_bcid_consistency(), 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::RBConstruction::compute_residual_dual_norm_slow(), 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::ExodusII_IO::copy_scalar_solution(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::MeshTools::create_bounding_box(), libMesh::DofMap::create_dof_constraints(), 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::DTKSolutionTransfer::DTKSolutionTransfer(), libMesh::MeshRefinement::eliminate_unrefined_patches(), libMesh::RBEIMConstruction::enrich_RB_space(), libMesh::TransientRBConstruction::enrich_RB_space(), libMesh::RBConstruction::enrich_RB_space(), libMesh::EpetraVector< T >::EpetraVector(), AssembleOptimization::equality_constraints(), libMesh::WeightedPatchRecoveryErrorEstimator::estimate_error(), libMesh::PatchRecoveryErrorEstimator::estimate_error(), libMesh::JumpErrorEstimator::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_error_tolerance(), libMesh::MeshRefinement::flag_elements_by_mean_stddev(), libMesh::MeshRefinement::flag_elements_by_nelem_target(), libMesh::DofMap::gather_constraints(), libMesh::MeshfreeInterpolation::gather_remote_data(), libMesh::CondensedEigenSystem::get_eigenpair(), libMesh::DofMap::get_info(), libMesh::ImplicitSystem::get_linear_solver(), AssembleOptimization::inequality_constraints(), AssembleOptimization::inequality_constraints_jacobian(), libMesh::LocationMap< T >::init(), libMesh::TimeSolver::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), libMesh::EigenSystem::init_matrices(), libMesh::OptimizationSystem::initialize_equality_constraints_storage(), libMesh::OptimizationSystem::initialize_inequality_constraints_storage(), libMesh::RBEIMConstruction::initialize_rb_construction(), integrate_function(), 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_preconditioner_apply(), 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(), 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(), LinearElasticityWithContact::move_mesh(), libMesh::DistributedMesh::n_active_elem(), libMesh::MeshTools::n_active_levels(), libMesh::BoundaryInfo::n_boundary_conds(), libMesh::DofMap::n_constrained_dofs(), 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::DofMap::print_dof_constraints(), FEMParameters::read(), libMesh::Nemesis_IO::read(), libMesh::XdrIO::read(), libMesh::CheckpointIO::read_header(), libMesh::XdrIO::read_header(), libMesh::System::read_header(), libMesh::RBEvaluation::read_in_vectors_from_multiple_files(), libMesh::System::read_legacy_data(), libMesh::TransientRBConstruction::read_riesz_representors_from_files(), libMesh::RBConstruction::read_riesz_representors_from_files(), 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::MeshRefinement::refine_and_coarsen_elements(), libMesh::DistributedMesh::renumber_dof_objects(), LinearElasticityWithContact::residual_and_jacobian(), OverlappingAlgebraicGhostingTest::run_ghosting_test(), OverlappingCouplingGhostingTest::run_sparsity_pattern_test(), libMesh::DofMap::scatter_constraints(), libMesh::CheckpointIO::select_split_config(), libMesh::TransientRBConstruction::set_error_temporal_data(), libMesh::RBEIMConstruction::set_explicit_sys_subvector(), 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::BoundaryInfo::sync(), libMesh::MeshRefinement::test_level_one(), MeshfunctionDFEM::test_mesh_function_dfem(), MeshfunctionDFEM::test_mesh_function_dfem_grad(), MeshFunctionTest::test_p_level(), libMesh::MeshRefinement::test_unflagged(), SystemsTest::testBlockRestrictedVarNDofs(), PointLocatorTest::testLocator(), BoundaryInfoTest::testMesh(), SystemsTest::testProjectCubeWithMeshFunction(), CheckpointIOTest::testSplitter(), 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::VTKIO::write_nodal_data(), libMesh::RBEvaluation::write_out_vectors(), libMesh::TransientRBConstruction::write_riesz_representors_to_files(), libMesh::RBConstruction::write_riesz_representors_to_files(), 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(), 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().

◆ disable_print_counter_info()

void libMesh::ReferenceCounter::disable_print_counter_info ( )
staticinherited

Definition at line 106 of file reference_counter.C.

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

References libMesh::ReferenceCounter::_enable_print_counter.

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

◆ 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.

101 {
102  _enable_print_counter = true;
103  return;
104 }

References libMesh::ReferenceCounter::_enable_print_counter.

◆ 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.

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 }

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

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

◆ get_linear_solver() [1/2]

LinearSolver<Number>& libMesh::NewtonSolver::get_linear_solver ( )
inline

Definition at line 81 of file newton_solver.h.

82  { libmesh_assert(_linear_solver);
83  return *_linear_solver;
84  }

References _linear_solver, and libMesh::libmesh_assert().

Referenced by main(), and TimeSolverTestImplementation< NewmarkSolver >::run_test_with_exact_soln().

◆ get_linear_solver() [2/2]

const LinearSolver<Number>& libMesh::NewtonSolver::get_linear_solver ( ) const
inline

Definition at line 86 of file newton_solver.h.

87  { libmesh_assert(_linear_solver);
88  return *_linear_solver;
89  }

References _linear_solver, and libMesh::libmesh_assert().

◆ 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.

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 }

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

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

◆ 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.

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 }

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

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

◆ init()

void libMesh::NewtonSolver::init ( )
overridevirtual

The initialization function.

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

Reimplemented from libMesh::DiffSolver.

Definition at line 257 of file newton_solver.C.

258 {
259  Parent::init();
260 
261  if (libMesh::on_command_line("--solver-system-names"))
262  _linear_solver->init((_system.name()+"_").c_str());
263  else
264  _linear_solver->init();
265 
266  _linear_solver->init_names(_system);
267 }

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

◆ line_search()

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.

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) ||
47  (!require_residual_reduction &&
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 &&
62  require_residual_reduction))
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  // We may need to localize a parallel solution
83  _system.update();
84 
85  // Check residual with fractional Newton step
86  _system.assembly (true, false);
87 
88  rhs.close();
89  current_residual = rhs.l2_norm();
90  if (verbose)
91  libMesh::out << " Current Residual: "
92  << current_residual << std::endl;
93 
94  if (bx/2. < minsteplength &&
95  (libmesh_isnan(current_residual) ||
96  (current_residual > last_residual)))
97  {
98  libMesh::out << "Inexact Newton step FAILED at step "
99  << _outer_iterations << std::endl;
100 
101  if (!continue_after_backtrack_failure)
102  {
103  libmesh_convergence_failure();
104  }
105  else
106  {
107  libMesh::out << "Continuing anyway ..." << std::endl;
108  _solve_result = DiffSolver::DIVERGED_BACKTRACKING_FAILURE;
109  return bx;
110  }
111  }
112  } // end while (current_residual > last_residual)
113 
114  // Now return that reduced-residual step, or use Brent's method to
115  // find a more optimal step.
116 
117  if (!brent_line_search)
118  return bx;
119 
120  // Brent's method adapted from Numerical Recipes in C, ch. 10.2
121  Real e = 0.;
122 
123  Real x = bx, w = bx, v = bx;
124 
125  // Residuals at bx
126  Real fx = current_residual,
127  fw = current_residual,
128  fv = current_residual;
129 
130  // Max iterations for Brent's method loop
131  const unsigned int max_i = 20;
132 
133  // for golden ratio steps
134  const Real golden_ratio = 1.-(std::sqrt(5.)-1.)/2.;
135 
136  for (unsigned int i=1; i <= max_i; i++)
137  {
138  Real xm = (ax+cx)*0.5;
139  Real tol1 = tol * std::abs(x) + tol*tol;
140  Real tol2 = 2.0 * tol1;
141 
142  // Test if we're done
143  if (std::abs(x-xm) <= (tol2 - 0.5 * (cx - ax)))
144  return x;
145 
146  Real d;
147 
148  // Construct a parabolic fit
149  if (std::abs(e) > tol1)
150  {
151  Real r = (x-w)*(fx-fv);
152  Real q = (x-v)*(fx-fw);
153  Real p = (x-v)*q-(x-w)*r;
154  q = 2. * (q-r);
155  if (q > 0.)
156  p = -p;
157  else
158  q = std::abs(q);
159  if (std::abs(p) >= std::abs(0.5*q*e) ||
160  p <= q * (ax-x) ||
161  p >= q * (cx-x))
162  {
163  // Take a golden section step
164  e = x >= xm ? ax-x : cx-x;
165  d = golden_ratio * e;
166  }
167  else
168  {
169  // Take a parabolic fit step
170  d = p/q;
171  if (x+d-ax < tol2 || cx-(x+d) < tol2)
172  d = SIGN(tol1, xm - x);
173  }
174  }
175  else
176  {
177  // Take a golden section step
178  e = x >= xm ? ax-x : cx-x;
179  d = golden_ratio * e;
180  }
181 
182  Real u = std::abs(d) >= tol1 ? x+d : x + SIGN(tol1,d);
183 
184  // Assemble the residual at the new steplength u
185  newton_iterate.add (bx - u, linear_solution);
186  newton_iterate.close();
187  bx = u;
188  if (verbose)
189  libMesh::out << " Shrinking Newton step to "
190  << bx << std::endl;
191 
192  // We may need to localize a parallel solution
193  _system.update();
194  _system.assembly (true, false);
195 
196  rhs.close();
197  Real fu = current_residual = rhs.l2_norm();
198  if (verbose)
199  libMesh::out << " Current Residual: "
200  << fu << std::endl;
201 
202  if (fu <= fx)
203  {
204  if (u >= x)
205  ax = x;
206  else
207  cx = x;
208  v = w; w = x; x = u;
209  fv = fw; fw = fx; fx = fu;
210  }
211  else
212  {
213  if (u < x)
214  ax = u;
215  else
216  cx = u;
217  if (fu <= fw || w == x)
218  {
219  v = w; w = u;
220  fv = fw; fw = fu;
221  }
222  else if (fu <= fv || v == x || v == w)
223  {
224  v = u;
225  fv = fu;
226  }
227  }
228  }
229 
230  if (!quiet)
231  libMesh::out << "Warning! Too many iterations used in Brent line search!"
232  << std::endl;
233  return bx;
234 }

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(), minsteplength, libMesh::out, libMesh::DiffSolver::quiet, libMesh::Real, require_finite_residual, require_residual_reduction, libMesh::ExplicitSystem::rhs, libMesh::SIGN(), std::sqrt(), libMesh::System::update(), and libMesh::DiffSolver::verbose.

Referenced by solve().

◆ 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.

84  { return _n_objects; }

References libMesh::ReferenceCounter::_n_objects.

◆ n_processors()

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

Definition at line 100 of file parallel_object.h.

101  { return cast_int<processor_id_type>(_communicator.size()); }

References libMesh::ParallelObject::_communicator.

Referenced by libMesh::BoundaryInfo::_find_id_maps(), libMesh::DofMap::add_constraints_to_send_list(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::DistributedMesh::add_elem(), libMesh::DofMap::add_neighbors_to_send_list(), libMesh::DistributedMesh::add_node(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::DofMap::allgather_recursive_constraints(), 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::ExodusII_IO::copy_scalar_solution(), 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::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::partition(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::DofMap::prepare_send_list(), libMesh::DofMap::print_dof_constraints(), 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(), OverlappingFunctorTest::run_partitioner_test(), libMesh::DofMap::scatter_constraints(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::PetscDMWrapper::set_point_range_in_section(), CheckpointIOTest::testSplitter(), WriteVecAndScalar::testWrite(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::GMVIO::write_binary(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::VTKIO::write_nodal_data(), 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().

◆ print_convergence()

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 622 of file newton_solver.C.

626 {
627  // Is our absolute residual low enough?
628  if (current_residual < absolute_residual_tolerance)
629  {
630  libMesh::out << " Nonlinear solver converged, step " << step_num
631  << ", residual " << current_residual
632  << std::endl;
633  }
634  else if (absolute_residual_tolerance)
635  {
636  if (verbose)
637  libMesh::out << " Nonlinear solver current_residual "
638  << current_residual << " > "
639  << (absolute_residual_tolerance) << std::endl;
640  }
641 
642  // Is our relative residual low enough?
643  if ((current_residual / max_residual_norm) <
644  relative_residual_tolerance)
645  {
646  libMesh::out << " Nonlinear solver converged, step " << step_num
647  << ", residual reduction "
648  << current_residual / max_residual_norm
649  << " < " << relative_residual_tolerance
650  << std::endl;
651  }
652  else if (relative_residual_tolerance)
653  {
654  if (verbose)
655  libMesh::out << " Nonlinear solver relative residual "
656  << (current_residual / max_residual_norm)
657  << " > " << relative_residual_tolerance
658  << std::endl;
659  }
660 
661  // For incomplete linear solves, it's not safe to test step sizes
662  if (!linear_solve_finished)
663  return;
664 
665  // Is our absolute Newton step size small enough?
666  if (step_norm < absolute_step_tolerance)
667  {
668  libMesh::out << " Nonlinear solver converged, step " << step_num
669  << ", absolute step size "
670  << step_norm
671  << " < " << absolute_step_tolerance
672  << std::endl;
673  }
674  else if (absolute_step_tolerance)
675  {
676  if (verbose)
677  libMesh::out << " Nonlinear solver absolute step size "
678  << step_norm
679  << " > " << absolute_step_tolerance
680  << std::endl;
681  }
682 
683  // Is our relative Newton step size small enough?
684  if (step_norm / max_solution_norm <
685  relative_step_tolerance)
686  {
687  libMesh::out << " Nonlinear solver converged, step " << step_num
688  << ", relative step size "
689  << (step_norm / max_solution_norm)
690  << " < " << relative_step_tolerance
691  << std::endl;
692  }
693  else if (relative_step_tolerance)
694  {
695  if (verbose)
696  libMesh::out << " Nonlinear solver relative step size "
697  << (step_norm / max_solution_norm)
698  << " > " << relative_step_tolerance
699  << std::endl;
700  }
701 }

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().

◆ 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.

88 {
89  if (_enable_print_counter)
90  out_stream << ReferenceCounter::get_info();
91 }

References libMesh::ReferenceCounter::_enable_print_counter, and libMesh::ReferenceCounter::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 106 of file parallel_object.h.

107  { return cast_int<processor_id_type>(_communicator.rank()); }

References libMesh::ParallelObject::_communicator.

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::DofMap::allgather_recursive_constraints(), libMesh::FEMSystem::assembly(), 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::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::ExodusII_IO::copy_scalar_solution(), 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::RBEIMConstruction::evaluate_mesh_function(), 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::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::DofMap::get_local_constraints(), 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::PetscDMWrapper::init_and_attach_petscdm(), HeatSystem::init_data(), 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::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_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(), 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::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::DofMap::print_dof_constraints(), 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::RBEvaluation::read_in_vectors_from_multiple_files(), libMesh::System::read_legacy_data(), libMesh::ExodusII_IO_Helper::read_node_num_map(), libMesh::System::read_parallel_data(), libMesh::TransientRBConstruction::read_riesz_representors_from_files(), libMesh::RBConstruction::read_riesz_representors_from_files(), 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::DofMap::scatter_constraints(), libMesh::CheckpointIO::select_split_config(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::PetscDMWrapper::set_point_range_in_section(), libMesh::LaplaceMeshSmoother::smooth(), DefaultCouplingTest::testCoupling(), PointNeighborCouplingTest::testCoupling(), MeshInputTest::testDynaReadElem(), MeshInputTest::testDynaReadPatch(), MeshInputTest::testExodusCopyElementSolution(), MeshInputTest::testExodusWriteElementDataFromDiscontinuousNodalData(), SystemsTest::testProjectMatrix1D(), SystemsTest::testProjectMatrix2D(), SystemsTest::testProjectMatrix3D(), BoundaryInfoTest::testShellFaceConstraints(), CheckpointIOTest::testSplitter(), 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::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_element_values_element_major(), 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::VTKIO::write_nodal_data(), 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::System::write_parallel_data(), libMesh::RBConstruction::write_riesz_representors_to_files(), 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::ExodusII_IO_Helper::write_sideset_data(), 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().

◆ reinit()

void libMesh::NewtonSolver::reinit ( )
overridevirtual

The reinitialization function.

This method is used after changes in the mesh.

Reimplemented from libMesh::DiffSolver.

Definition at line 271 of file newton_solver.C.

272 {
273  Parent::reinit();
274 
275  _linear_solver->clear();
276 
277  _linear_solver->init_names(_system);
278 }

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

◆ solve()

unsigned int libMesh::NewtonSolver::solve ( )
overridevirtual

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

Implements libMesh::DiffSolver.

Definition at line 282 of file newton_solver.C.

283 {
284  LOG_SCOPE("solve()", "NewtonSolver");
285 
286  // Reset any prior solve result
287  _solve_result = INVALID_SOLVE_RESULT;
288 
289  NumericVector<Number> & newton_iterate = *(_system.solution);
290 
291  std::unique_ptr<NumericVector<Number>> linear_solution_ptr = newton_iterate.zero_clone();
292  NumericVector<Number> & linear_solution = *linear_solution_ptr;
293  NumericVector<Number> & rhs = *(_system.rhs);
294 
295  newton_iterate.close();
296  linear_solution.close();
297  rhs.close();
298 
299 #ifdef LIBMESH_ENABLE_CONSTRAINTS
300  _system.get_dof_map().enforce_constraints_exactly(_system);
301 #endif
302 
303  SparseMatrix<Number> & matrix = *(_system.matrix);
304 
305  // Set starting linear tolerance
306  double current_linear_tolerance = initial_linear_tolerance;
307 
308  // Start counting our linear solver steps
309  _inner_iterations = 0;
310 
311  // Now we begin the nonlinear loop
312  for (_outer_iterations=0; _outer_iterations<max_nonlinear_iterations;
313  ++_outer_iterations)
314  {
315  // We may need to localize a parallel solution
316  _system.update();
317 
318  if (verbose)
319  libMesh::out << "Assembling the System" << std::endl;
320 
321  _system.assembly(true, true);
322  rhs.close();
323  Real current_residual = rhs.l2_norm();
324 
325  if (libmesh_isnan(current_residual))
326  {
327  libMesh::out << " Nonlinear solver DIVERGED at step "
328  << _outer_iterations
329  << " with residual Not-a-Number"
330  << std::endl;
331  libmesh_convergence_failure();
332  continue;
333  }
334 
335  if (current_residual <= absolute_residual_tolerance)
336  {
337  if (verbose)
338  libMesh::out << "Linear solve unnecessary; residual "
339  << current_residual
340  << " meets absolute tolerance "
341  << absolute_residual_tolerance
342  << std::endl;
343 
344  // We're not doing a solve, but other code may reuse this
345  // matrix.
346  matrix.close();
347 
348  _solve_result |= CONVERGED_ABSOLUTE_RESIDUAL;
349  if (current_residual == 0)
350  {
351  if (relative_residual_tolerance > 0)
352  _solve_result |= CONVERGED_RELATIVE_RESIDUAL;
353  if (absolute_step_tolerance > 0)
354  _solve_result |= CONVERGED_ABSOLUTE_STEP;
355  if (relative_step_tolerance > 0)
356  _solve_result |= CONVERGED_RELATIVE_STEP;
357  }
358 
359  break;
360  }
361 
362  // Prepare to take incomplete steps
363  Real last_residual = current_residual;
364 
365  max_residual_norm = std::max (current_residual,
366  max_residual_norm);
367 
368  // Compute the l2 norm of the whole solution
369  Real norm_total = newton_iterate.l2_norm();
370 
371  max_solution_norm = std::max(max_solution_norm, norm_total);
372 
373  if (verbose)
374  libMesh::out << "Nonlinear Residual: "
375  << current_residual << std::endl;
376 
377  // Make sure our linear tolerance is low enough
378  current_linear_tolerance =
379  double(std::min (current_linear_tolerance,
380  current_residual * linear_tolerance_multiplier));
381 
382  // But don't let it be too small
383  if (current_linear_tolerance < minimum_linear_tolerance)
384  {
385  current_linear_tolerance = minimum_linear_tolerance;
386  }
387 
388  // If starting the nonlinear solve with a really good initial guess, we dont want to set an absurd linear tolerance
389  current_linear_tolerance =
390  double(std::max(current_linear_tolerance,
391  absolute_residual_tolerance / current_residual
392  / 10.0));
393 
394  // At this point newton_iterate is the current guess, and
395  // linear_solution is now about to become the NEGATIVE of the next
396  // Newton step.
397 
398  // Our best initial guess for the linear_solution is zero!
399  linear_solution.zero();
400 
401  if (verbose)
402  libMesh::out << "Linear solve starting, tolerance "
403  << current_linear_tolerance << std::endl;
404 
405  // Solve the linear system.
406  const std::pair<unsigned int, Real> rval =
407  _linear_solver->solve (matrix, _system.request_matrix("Preconditioner"),
408  linear_solution, rhs, current_linear_tolerance,
409  max_linear_iterations);
410 
411  if (track_linear_convergence)
412  {
413  LinearConvergenceReason linear_c_reason = _linear_solver->get_converged_reason();
414 
415  // Check if something went wrong during the linear solve
416  if (linear_c_reason < 0)
417  {
418  // The linear solver failed somehow
419  _solve_result |= DiffSolver::DIVERGED_LINEAR_SOLVER_FAILURE;
420  // Print a message
421  libMesh::out << "Linear solver failed during Newton step, dropping out."
422  << std::endl;
423  break;
424  }
425  }
426 
427  // We may need to localize a parallel solution
428  _system.update ();
429  // The linear solver may not have fit our constraints exactly
430 #ifdef LIBMESH_ENABLE_CONSTRAINTS
431  _system.get_dof_map().enforce_constraints_exactly
432  (_system, &linear_solution, /* homogeneous = */ true);
433 #endif
434 
435  const unsigned int linear_steps = rval.first;
436  libmesh_assert_less_equal (linear_steps, max_linear_iterations);
437  _inner_iterations += linear_steps;
438 
439  const bool linear_solve_finished =
440  !(linear_steps == max_linear_iterations);
441 
442  if (verbose)
443  libMesh::out << "Linear solve finished, step " << linear_steps
444  << ", residual " << rval.second
445  << std::endl;
446 
447  // Compute the l2 norm of the nonlinear update
448  Real norm_delta = linear_solution.l2_norm();
449 
450  if (verbose)
451  libMesh::out << "Trying full Newton step" << std::endl;
452  // Take a full Newton step
453  newton_iterate.add (-1., linear_solution);
454  newton_iterate.close();
455 
456  if (this->linear_solution_monitor.get())
457  {
458  // Compute the l2 norm of the whole solution
459  norm_total = newton_iterate.l2_norm();
460  rhs.close();
461  (*this->linear_solution_monitor)(linear_solution, norm_delta,
462  newton_iterate, norm_total,
463  rhs, rhs.l2_norm(), _outer_iterations);
464  }
465 
466  // Check residual with full Newton step, if that's useful for determining
467  // whether to line search, whether to quit early, or whether to die after
468  // hitting our max iteration count
469  if (this->require_residual_reduction ||
470  this->require_finite_residual ||
471  _outer_iterations+1 < max_nonlinear_iterations ||
472  !continue_after_max_iterations)
473  {
474  _system.update ();
475  _system.assembly(true, false);
476 
477  rhs.close();
478  current_residual = rhs.l2_norm();
479  if (verbose)
480  libMesh::out << " Current Residual: "
481  << current_residual << std::endl;
482 
483  // don't fiddle around if we've already converged
484  if (test_convergence(current_residual, norm_delta,
485  linear_solve_finished &&
486  current_residual <= last_residual))
487  {
488  if (!quiet)
489  print_convergence(_outer_iterations, current_residual,
490  norm_delta, linear_solve_finished &&
491  current_residual <= last_residual);
492  _outer_iterations++;
493  break; // out of _outer_iterations for loop
494  }
495  }
496 
497  // since we're not converged, backtrack if necessary
498  Real steplength =
499  this->line_search(std::sqrt(TOLERANCE),
500  last_residual, current_residual,
501  newton_iterate, linear_solution);
502  norm_delta *= steplength;
503 
504  // Check to see if backtracking failed,
505  // and break out of the nonlinear loop if so...
506  if (_solve_result == DiffSolver::DIVERGED_BACKTRACKING_FAILURE)
507  {
508  _outer_iterations++;
509  break; // out of _outer_iterations for loop
510  }
511 
512  if (_outer_iterations + 1 >= max_nonlinear_iterations)
513  {
514  libMesh::out << " Nonlinear solver reached maximum step "
515  << max_nonlinear_iterations << ", latest evaluated residual "
516  << current_residual << std::endl;
517  if (continue_after_max_iterations)
518  {
519  _solve_result = DiffSolver::DIVERGED_MAX_NONLINEAR_ITERATIONS;
520  libMesh::out << " Continuing..." << std::endl;
521  }
522  else
523  {
524  libmesh_convergence_failure();
525  }
526  continue;
527  }
528 
529  // Compute the l2 norm of the whole solution
530  norm_total = newton_iterate.l2_norm();
531 
532  max_solution_norm = std::max(max_solution_norm, norm_total);
533 
534  // Print out information for the
535  // nonlinear iterations.
536  if (verbose)
537  libMesh::out << " Nonlinear step: |du|/|u| = "
538  << norm_delta / norm_total
539  << ", |du| = " << norm_delta
540  << std::endl;
541 
542  // Terminate the solution iteration if the difference between
543  // this iteration and the last is sufficiently small.
544  if (test_convergence(current_residual, norm_delta / steplength,
545  linear_solve_finished))
546  {
547  if (!quiet)
548  print_convergence(_outer_iterations, current_residual,
549  norm_delta / steplength,
550  linear_solve_finished);
551  _outer_iterations++;
552  break; // out of _outer_iterations for loop
553  }
554  } // end nonlinear loop
555 
556  // The linear solver may not have fit our constraints exactly
557 #ifdef LIBMESH_ENABLE_CONSTRAINTS
558  _system.get_dof_map().enforce_constraints_exactly(_system);
559 #endif
560 
561  // We may need to localize a parallel solution
562  _system.update ();
563 
564  // Make sure we are returning something sensible as the
565  // _solve_result, except in the edge case where we weren't really asked to
566  // solve.
567  libmesh_assert (_solve_result != DiffSolver::INVALID_SOLVE_RESULT ||
568  !max_nonlinear_iterations);
569 
570  return _solve_result;
571 }

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::SparseMatrix< T >::close(), libMesh::NumericVector< 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, libMesh::DiffSolver::max_linear_iterations, libMesh::DiffSolver::max_nonlinear_iterations, libMesh::DiffSolver::max_residual_norm, libMesh::DiffSolver::max_solution_norm, 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, std::sqrt(), test_convergence(), libMesh::TOLERANCE, track_linear_convergence, libMesh::System::update(), libMesh::DiffSolver::verbose, libMesh::NumericVector< T >::zero(), and libMesh::NumericVector< T >::zero_clone().

◆ solve_result()

unsigned int libMesh::DiffSolver::solve_result ( )
inlineinherited
Returns
The value of the SolveResult from the last solve.

Definition at line 132 of file diff_solver.h.

132 { return _solve_result; }

References libMesh::DiffSolver::_solve_result.

◆ system() [1/2]

sys_type& libMesh::DiffSolver::system ( )
inlineinherited
Returns
A writable reference to the system we are solving.

Definition at line 142 of file diff_solver.h.

142 { return _system; }

References libMesh::DiffSolver::_system.

◆ system() [2/2]

const sys_type& libMesh::DiffSolver::system ( ) const
inlineinherited
Returns
A constant reference to the system we are solving.

Definition at line 137 of file diff_solver.h.

137 { return _system; }

References libMesh::DiffSolver::_system.

Referenced by libMesh::__libmesh_petsc_diff_solver_jacobian(), and libMesh::__libmesh_petsc_diff_solver_residual().

◆ test_convergence()

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 575 of file newton_solver.C.

578 {
579  // We haven't converged unless we pass a convergence test
580  bool has_converged = false;
581 
582  // Is our absolute residual low enough?
583  if (current_residual < absolute_residual_tolerance)
584  {
585  _solve_result |= CONVERGED_ABSOLUTE_RESIDUAL;
586  has_converged = true;
587  }
588 
589  // Is our relative residual low enough?
590  if ((current_residual / max_residual_norm) <
591  relative_residual_tolerance)
592  {
593  _solve_result |= CONVERGED_RELATIVE_RESIDUAL;
594  has_converged = true;
595  }
596 
597  // For incomplete linear solves, it's not safe to test step sizes
598  if (!linear_solve_finished)
599  {
600  return has_converged;
601  }
602 
603  // Is our absolute Newton step size small enough?
604  if (step_norm < absolute_step_tolerance)
605  {
606  _solve_result |= CONVERGED_ABSOLUTE_STEP;
607  has_converged = true;
608  }
609 
610  // Is our relative Newton step size small enough?
611  if (step_norm / max_solution_norm <
612  relative_step_tolerance)
613  {
614  _solve_result |= CONVERGED_RELATIVE_STEP;
615  has_converged = true;
616  }
617 
618  return has_converged;
619 }

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().

◆ total_inner_iterations()

unsigned int libMesh::DiffSolver::total_inner_iterations ( )
inlineinherited
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; }

References libMesh::DiffSolver::_inner_iterations.

◆ total_outer_iterations()

unsigned int libMesh::DiffSolver::total_outer_iterations ( )
inlineinherited
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; }

References libMesh::DiffSolver::_outer_iterations.

Member Data Documentation

◆ _communicator

const Parallel::Communicator& libMesh::ParallelObject::_communicator
protectedinherited

Definition at line 112 of file parallel_object.h.

Referenced by libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::ParallelObject::comm(), libMesh::ParallelObject::n_processors(), libMesh::ParallelObject::operator=(), and libMesh::ParallelObject::processor_id().

◆ _counts

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

Actually holds the data.

Definition at line 122 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::get_info(), libMesh::ReferenceCounter::increment_constructor_count(), and libMesh::ReferenceCounter::increment_destructor_count().

◆ _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().

◆ _inner_iterations

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(), libMesh::PetscDiffSolver::solve(), and libMesh::DiffSolver::total_inner_iterations().

◆ _linear_solver

std::unique_ptr<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().

◆ _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_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().

◆ _outer_iterations

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(), solve(), libMesh::PetscDiffSolver::solve(), and libMesh::DiffSolver::total_outer_iterations().

◆ _solve_result

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(), libMesh::DiffSolver::solve_result(), and test_convergence().

◆ _system

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(), line_search(), reinit(), libMesh::PetscDiffSolver::setup_petsc_data(), solve(), libMesh::PetscDiffSolver::solve(), and libMesh::DiffSolver::system().

◆ absolute_residual_tolerance

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().

◆ absolute_step_tolerance

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().

◆ brent_line_search

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().

◆ continue_after_backtrack_failure

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().

◆ continue_after_max_iterations

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().

◆ initial_linear_tolerance

double 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().

◆ linear_solution_monitor

std::unique_ptr<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().

◆ linear_tolerance_multiplier

double 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().

◆ max_linear_iterations

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().

◆ max_nonlinear_iterations

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().

◆ max_residual_norm

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().

◆ max_solution_norm

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().

◆ minimum_linear_tolerance

double 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().

◆ minsteplength

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().

◆ quiet

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().

◆ relative_residual_tolerance

Real libMesh::DiffSolver::relative_residual_tolerance
inherited

Definition at line 192 of file diff_solver.h.

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

◆ relative_step_tolerance

Real libMesh::DiffSolver::relative_step_tolerance
inherited

Definition at line 204 of file diff_solver.h.

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

◆ require_finite_residual

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().

◆ require_residual_reduction

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().

◆ track_linear_convergence

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().

◆ verbose

bool libMesh::DiffSolver::verbose
inherited

The DiffSolver may print a lot more to libMesh::out if verbose is set to true; default is false.

Definition at line 168 of file diff_solver.h.

Referenced by libMesh::__libmesh_petsc_diff_solver_jacobian(), libMesh::__libmesh_petsc_diff_solver_monitor(), libMesh::__libmesh_petsc_diff_solver_residual(), SolidSystem::init_data(), line_search(), main(), print_convergence(), set_system_parameters(), and solve().

The documentation for this class was generated from the following files:
libMesh::DiffSolver::reinit
virtual void reinit()
The reinitialization function.
Definition: diff_solver.C:60
libMesh::DiffSolver::CONVERGED_ABSOLUTE_STEP
The DiffSolver achieved the desired absolute step size tolerance.
Definition: diff_solver.h:251
libMesh::ImplicitSystem::request_matrix
const SparseMatrix< Number > * request_matrix(const std::string &mat_name) const
Definition: implicit_system.C:236
libMesh::NumericVector::add
virtual void add(const numeric_index_type i, const T value)=0
Adds value to each entry of the vector.
libMesh::ExplicitSystem::rhs
NumericVector< Number > * rhs
The system matrix.
Definition: explicit_system.h:114
libMesh::NewtonSolver::track_linear_convergence
bool track_linear_convergence
If set to true, check for convergence of the linear solve.
Definition: newton_solver.h:129
libMesh::NewtonSolver::require_residual_reduction
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::DiffSolver::CONVERGED_RELATIVE_STEP
The DiffSolver achieved the desired relative step size tolerance.
Definition: diff_solver.h:257
libMesh::DiffSolver::continue_after_backtrack_failure
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
libMesh::NumericVector::close
virtual void close()=0
Calls the NumericVector's internal assembly routines, ensuring that the values are consistent across ...
libMesh::DiffSolver::absolute_step_tolerance
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
libMesh::NewtonSolver::_linear_solver
std::unique_ptr< LinearSolver< Number > > _linear_solver
The LinearSolver defines the interface used to solve the linear_implicit system.
Definition: newton_solver.h:153
libMesh::ReferenceCounter::_counts
static Counts _counts
Actually holds the data.
Definition: reference_counter.h:122
std::sqrt
MetaPhysicL::DualNumber< T, D > sqrt(const MetaPhysicL::DualNumber< T, D > &in)
libMesh::TOLERANCE
static const Real TOLERANCE
Definition: libmesh_common.h:128
libMesh::DiffSolver::DIVERGED_LINEAR_SOLVER_FAILURE
The linear solver used by the DiffSolver failed to find a solution.
Definition: diff_solver.h:282
libMesh::DiffSolver::DIVERGED_BACKTRACKING_FAILURE
The DiffSolver failed to find a descent direction by backtracking (See newton_solver....
Definition: diff_solver.h:276
libMesh::DiffSolver::CONVERGED_RELATIVE_RESIDUAL
The DiffSolver achieved the desired relative residual tolerance.
Definition: diff_solver.h:245
libMesh::ReferenceCounter::_n_objects
static Threads::atomic< unsigned int > _n_objects
The number of objects.
Definition: reference_counter.h:130
libMesh::DiffSolver::_solve_result
unsigned int _solve_result
Initialized to zero.
Definition: diff_solver.h:326
libMesh::NewtonSolver::linear_tolerance_multiplier
double linear_tolerance_multiplier
The tolerance for linear solves is kept below this multiplier (which defaults to 1e-3) times the norm...
Definition: newton_solver.h:143
libMesh::DiffSolver::_inner_iterations
unsigned int _inner_iterations
The number of inner iterations used by the last solve.
Definition: diff_solver.h:313
libMesh::ReferenceCounter::get_info
static std::string get_info()
Gets a string containing the reference information.
Definition: reference_counter.C:47
libMesh::DiffSolver::init
virtual void init()
The initialization function.
Definition: diff_solver.C:69
libMesh::NewtonSolver::line_search
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
libMesh::libmesh_assert
libmesh_assert(ctx)
libMesh::SIGN
T SIGN(T a, T b)
Definition: newton_solver.C:33
libMesh::LinearSolver< Number >::build
static std::unique_ptr< 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.
Definition: linear_solver.C:57
libMesh::LinearConvergenceReason
LinearConvergenceReason
Linear solver convergence flags (taken from the PETSc flags).
Definition: enum_convergence_flags.h:33
std::abs
MetaPhysicL::DualNumber< T, D > abs(const MetaPhysicL::DualNumber< T, D > &in)
libMesh::DiffSolver::minimum_linear_tolerance
double minimum_linear_tolerance
The tolerance for linear solves is kept above this minimum.
Definition: diff_solver.h:215
libMesh::NewtonSolver::print_convergence
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.
Definition: newton_solver.C:622
libMesh::DiffSolver::relative_step_tolerance
Real relative_step_tolerance
Definition: diff_solver.h:204
libMesh::DiffSolver::verbose
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
libMesh::libmesh_isnan
bool libmesh_isnan(T x)
Definition: libmesh_common.h:177
libMesh::Threads::spin_mtx
spin_mutex spin_mtx
A convenient spin mutex object which can be used for obtaining locks.
Definition: threads.C:29
libMesh::ImplicitSystem::assembly
virtual void assembly(bool, bool, bool=false, bool=false)
Assembles a residual in rhs and/or a jacobian in matrix, as requested.
Definition: implicit_system.h:161
libMesh::DofMap::enforce_constraints_exactly
void enforce_constraints_exactly(const System &system, NumericVector< Number > *v=nullptr, bool homogeneous=false) const
Constrains the numeric vector v, which represents a solution defined on the mesh.
Definition: dof_map.h:2054
libMesh::ParallelObject::_communicator
const Parallel::Communicator & _communicator
Definition: parallel_object.h:112
libMesh::DiffSolver::continue_after_max_iterations
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
libMesh::ImplicitSystem::matrix
SparseMatrix< Number > * matrix
The system matrix.
Definition: implicit_system.h:393
libMesh::DiffSolver::CONVERGED_NO_REASON
The solver converged but no particular reason is specified.
Definition: diff_solver.h:233
libMesh::DiffSolver::CONVERGED_ABSOLUTE_RESIDUAL
The DiffSolver achieved the desired absolute residual tolerance.
Definition: diff_solver.h:239
libMesh::DiffSolver::DIVERGED_NO_REASON
The DiffSolver diverged but no particular reason is specified.
Definition: diff_solver.h:263
libMesh::DiffSolver::DIVERGED_MAX_NONLINEAR_ITERATIONS
The DiffSolver reached the maximum allowed number of nonlinear iterations before satisfying any conve...
Definition: diff_solver.h:270
libMesh::DiffSolver::quiet
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
libMesh::DiffSolver::relative_residual_tolerance
Real relative_residual_tolerance
Definition: diff_solver.h:192
libMesh::System::solution
std::unique_ptr< NumericVector< Number > > solution
Data structure to hold solution values.
Definition: system.h:1539
libMesh::DiffSolver::linear_solution_monitor
std::unique_ptr< LinearSolutionMonitor > linear_solution_monitor
Pointer to functor which is called right after each linear solve.
Definition: diff_solver.h:288
libMesh::DiffSolver::_outer_iterations
unsigned int _outer_iterations
The number of outer iterations used by the last solve.
Definition: diff_solver.h:308
libMesh::DiffSolver::absolute_residual_tolerance
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
libMesh::NewtonSolver::test_convergence
bool test_convergence(Real current_residual, Real step_norm, bool linear_solve_finished)
Definition: newton_solver.C:575
libMesh::System::name
const std::string & name() const
Definition: system.h:2067
libMesh::DiffSolver::max_linear_iterations
unsigned int max_linear_iterations
Each linear solver step should exit after max_linear_iterations is exceeded.
Definition: diff_solver.h:148
libMesh::on_command_line
bool on_command_line(std::string arg)
Definition: libmesh.C:898
libMesh::System::get_dof_map
const DofMap & get_dof_map() const
Definition: system.h:2099
libMesh::NewtonSolver::Parent
DiffSolver Parent
Definition: newton_solver.h:61
libMesh::Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
Definition: libmesh_common.h:121
libMesh::DiffSolver::max_nonlinear_iterations
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
libMesh::ReferenceCounter::_enable_print_counter
static bool _enable_print_counter
Flag to control whether reference count information is printed when print_info is called.
Definition: reference_counter.h:141
libMesh::DiffSolver::max_solution_norm
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
libMesh::NewtonSolver::require_finite_residual
bool require_finite_residual
If this is set to true, the solver is forced to test the residual after each Newton step,...
Definition: newton_solver.h:107
libMesh::NewtonSolver::minsteplength
Real minsteplength
If the quasi-Newton step length must be reduced to below this factor to give a residual reduction,...
Definition: newton_solver.h:137
libMesh::out
OStreamProxy out
libMesh::System::update
virtual void update()
Update the local values to reflect the solution on neighboring processors.
Definition: system.C:408
libMesh::NewtonSolver::brent_line_search
bool brent_line_search
If require_residual_reduction is true, the solver may reduce step lengths when required.
Definition: newton_solver.h:120
libMesh::DiffSolver::max_residual_norm
Real max_residual_norm
The largest nonlinear residual which the DiffSolver has yet seen will be stored here,...
Definition: diff_solver.h:303
libMesh::DiffSolver::_system
sys_type & _system
A reference to the system we are solving.
Definition: diff_solver.h:318
libMesh::Quality::name
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42
libMesh::DiffSolver::INVALID_SOLVE_RESULT
A default or invalid solve result.
Definition: diff_solver.h:227
libMesh::DiffSolver::initial_linear_tolerance
double 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
Generated on Sat Jan 25 2020 12:08:31 for libMesh by   doxygen 1.8.16