Line data    Source code

       1             : //* This file is part of the MOOSE framework
       2             : //* https://mooseframework.inl.gov
       3             : //*
       4             : //* All rights reserved, see COPYRIGHT for full restrictions
       5             : //* https://github.com/idaholab/moose/blob/master/COPYRIGHT
       6             : //*
       7             : //* Licensed under LGPL 2.1, please see LICENSE for details
       8             : //* https://www.gnu.org/licenses/lgpl-2.1.html
       9             : 
      10             : #include "NonlinearEigen.h"
      11             : #include "FEProblemBase.h"
      12             : 
      13             : registerMooseObject("MooseApp", NonlinearEigen);
      14             : 
      15             : InputParameters
      16       14475 : NonlinearEigen::validParams()
      17             : {
      18       14475 :   InputParameters params = EigenExecutionerBase::validParams();
      19       14475 :   params.addParam<unsigned int>("free_power_iterations", 4, "The number of free power iterations");
      20       14475 :   params.set<Real>("nl_abs_tol", true) = 1.0e-06;
      21       14475 :   params.set<Real>("nl_rel_tol", true) = 1e-50;
      22       14475 :   params.set<Real>("l_tol", true) = 1e-2;
      23       14475 :   params.addParam<Real>("free_l_tol", 1e-2, "Relative linear tolerance in free power iteration");
      24       43425 :   params.addParam<bool>(
      25       28950 :       "output_after_power_iterations", true, "True to output solution after free power iterations");
      26       14475 :   return params;
      27           0 : }
      28             : 
      29         105 : NonlinearEigen::NonlinearEigen(const InputParameters & parameters)
      30             :   : EigenExecutionerBase(parameters),
      31         105 :     _free_iter(getParam<unsigned int>("free_power_iterations")),
      32         105 :     _nl_abs_tol(getParam<Real>("nl_abs_tol")),
      33         105 :     _nl_rel_tol(getParam<Real>("nl_rel_tol")),
      34         105 :     _l_tol(getParam<Real>("l_tol")),
      35         105 :     _free_l_tol(getParam<Real>("free_l_tol")),
      36         210 :     _output_after_pi(getParam<bool>("output_after_power_iterations"))
      37             : {
      38         105 :   mooseInfo(
      39             :       "'NonlinearEigen' executioner is deprecated in favor of 'Eigenvalue' executioner.\n",
      40             :       "Few parameters such as 'bx_norm', 'k0', 'free_l_tol', 'output_before_normalization' and "
      41             :       "'output_after_power_iterations' are no longer supported.\n",
      42             :       "However, 'Eigenvalue' executioner supports more solving options by interfacing SLEPc.\n",
      43             :       "Most of the inputs will work by simply replacing the executioner type with 'Eigenvalue'.");
      44         105 : }
      45             : 
      46             : void
      47         105 : NonlinearEigen::init()
      48             : {
      49         105 :   if (_app.isRecovering())
      50             :   {
      51           1 :     _console << "\nCannot recover NonlinearEigen solves!\nExiting...\n" << std::endl;
      52           1 :     return;
      53             :   }
      54             : 
      55         104 :   EigenExecutionerBase::init();
      56             : 
      57             :   // Write the initial.
      58             :   // Note: We need to tempararily change the system time to make the output system work properly.
      59         104 :   _problem.timeStep() = 0;
      60         104 :   Real t = _problem.time();
      61         104 :   _problem.time() = _problem.timeStep();
      62         104 :   _problem.outputStep(EXEC_INITIAL);
      63         104 :   _problem.time() = t;
      64             : 
      65         104 :   if (_free_iter > 0)
      66             :   {
      67             :     // save the initial guess
      68         104 :     _problem.advanceState();
      69             : 
      70             :     // free power iterations
      71         104 :     _console << " Free power iteration starts" << std::endl;
      72             : 
      73             :     Real initial_res;
      74         208 :     inversePowerIteration(_free_iter,
      75         104 :                           _free_iter,
      76         104 :                           _free_l_tol,
      77             :                           false,
      78             :                           std::numeric_limits<Real>::min(),
      79             :                           true,
      80             :                           "",
      81             :                           std::numeric_limits<Real>::max(),
      82         104 :                           _eigenvalue,
      83             :                           initial_res);
      84             : 
      85         104 :     _problem.onTimestepEnd();
      86         104 :     _problem.execute(EXEC_TIMESTEP_END);
      87             : 
      88         104 :     if (_output_after_pi)
      89             :     {
      90             :       // output initial guess created by free power iterations
      91          50 :       _problem.timeStep()++;
      92          50 :       Real t = _problem.time();
      93          50 :       _problem.time() = _problem.timeStep();
      94          50 :       _problem.outputStep(EXEC_TIMESTEP_END);
      95          50 :       _problem.time() = t;
      96             :     }
      97             :   }
      98             : }
      99             : 
     100             : void
     101         105 : NonlinearEigen::execute()
     102             : {
     103         105 :   if (_app.isRecovering())
     104             :   {
     105           1 :     _last_solve_converged = true;
     106           1 :     return;
     107             :   }
     108             : 
     109         104 :   preExecute();
     110             : 
     111         104 :   takeStep();
     112             : 
     113         104 :   postExecute();
     114             : }
     115             : 
     116             : void
     117         104 : NonlinearEigen::takeStep()
     118             : {
     119         104 :   _console << " Nonlinear iteration starts" << std::endl;
     120             : 
     121         104 :   preSolve();
     122         104 :   _problem.timestepSetup();
     123         104 :   _problem.advanceState();
     124         104 :   _problem.execute(EXEC_TIMESTEP_BEGIN);
     125             : 
     126         104 :   _last_solve_converged = nonlinearSolve(_nl_rel_tol, _nl_abs_tol, _l_tol, _eigenvalue);
     127         104 :   postSolve();
     128             : 
     129         104 :   if (lastSolveConverged())
     130             :   {
     131         104 :     printEigenvalue();
     132             : 
     133         104 :     _problem.onTimestepEnd();
     134         104 :     _problem.execute(EXEC_TIMESTEP_END);
     135             :   }
     136         104 : }