void
NonlinearEigenSystem::solve()
{
// Clear the iteration counters
_current_l_its.clear();
_current_nl_its = 0;
// Initialize the solution vector using a predictor and known values from nodal bcs
setInitialSolution();
_time_integrator->solve();
_time_integrator->postSolve();
// store eigenvalues
unsigned int n_converged_eigenvalues = getNumConvergedEigenvalues();
if (_n_eigen_pairs_required < n_converged_eigenvalues)
n_converged_eigenvalues = _n_eigen_pairs_required;
_eigen_values.resize(n_converged_eigenvalues);
for (unsigned int n = 0; n < n_converged_eigenvalues; n++)
_eigen_values[n] = getNthConvergedEigenvalue(n);
}
void
NonlinearEigenSystem::solve()
{
// Clear the iteration counters
_current_l_its.clear();
_current_nl_its = 0;
// Initialize the solution vector using a predictor and known values from nodal bcs
setInitialSolution();
// In DEBUG mode, Libmesh will check the residual automatically. This may cause
// an error because B does not need to assembly by default.
#ifdef DEBUG
if (_eigen_problem.isGeneralizedEigenvalueProblem())
sys().matrix_B->close();
#endif
// Solve the transient problem if we have a time integrator; the
// steady problem if not.
if (_time_integrator)
{
_time_integrator->solve();
_time_integrator->postSolve();
}
else
system().solve();
// store eigenvalues
unsigned int n_converged_eigenvalues = getNumConvergedEigenvalues();
_n_eigen_pairs_required = _eigen_problem.getNEigenPairsRequired();
if (_n_eigen_pairs_required < n_converged_eigenvalues)
n_converged_eigenvalues = _n_eigen_pairs_required;
_eigen_values.resize(n_converged_eigenvalues);
for (unsigned int n = 0; n < n_converged_eigenvalues; n++)
_eigen_values[n] = getNthConvergedEigenvalue(n);
}
void
NonlinearSystem::solve()
{
// Only attach the postcheck function to the solver if we actually
// have dampers or if the FEProblemBase needs to update the solution,
// which is also done during the linesearch postcheck. It doesn't
// hurt to do this multiple times, it is just setting a pointer.
if (_fe_problem.hasDampers() || _fe_problem.shouldUpdateSolution() ||
_fe_problem.needsPreviousNewtonIteration())
_transient_sys.nonlinear_solver->postcheck = Moose::compute_postcheck;
if (_fe_problem.solverParams()._type != Moose::ST_LINEAR)
{
// Calculate the initial residual for use in the convergence criterion.
_computing_initial_residual = true;
_fe_problem.computeResidualSys(_transient_sys, *_current_solution, *_transient_sys.rhs);
_computing_initial_residual = false;
_transient_sys.rhs->close();
_initial_residual_before_preset_bcs = _transient_sys.rhs->l2_norm();
if (_compute_initial_residual_before_preset_bcs)
_console << "Initial residual before setting preset BCs: "
<< _initial_residual_before_preset_bcs << '\n';
}
// Clear the iteration counters
_current_l_its.clear();
_current_nl_its = 0;
// Initialize the solution vector using a predictor and known values from nodal bcs
setInitialSolution();
if (_use_finite_differenced_preconditioner)
{
_transient_sys.nonlinear_solver->fd_residual_object = &_fd_residual_functor;
setupFiniteDifferencedPreconditioner();
}
#ifdef LIBMESH_HAVE_PETSC
PetscNonlinearSolver<Real> & solver =
static_cast<PetscNonlinearSolver<Real> &>(*_transient_sys.nonlinear_solver);
solver.mffd_residual_object = &_fd_residual_functor;
#endif
if (_time_integrator)
{
_time_integrator->solve();
_time_integrator->postSolve();
_n_iters = _time_integrator->getNumNonlinearIterations();
_n_linear_iters = _time_integrator->getNumLinearIterations();
}
else
{
system().solve();
_n_iters = _transient_sys.n_nonlinear_iterations();
#ifdef LIBMESH_HAVE_PETSC
_n_linear_iters = solver.get_total_linear_iterations();
#endif
}
// store info about the solve
_final_residual = _transient_sys.final_nonlinear_residual();
#ifdef LIBMESH_HAVE_PETSC
if (_use_coloring_finite_difference)
#if PETSC_VERSION_LESS_THAN(3, 2, 0)
MatFDColoringDestroy(_fdcoloring);
#else
MatFDColoringDestroy(&_fdcoloring);
#endif
#endif
}
