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        3243 : NonlinearEigen::validParams()
      17             : {
      18        3243 :   InputParameters params = EigenExecutionerBase::validParams();
      19       12972 :   params.addParam<unsigned int>("free_power_iterations", 4, "The number of free power iterations");
      20        6486 :   params.set<Real>("nl_abs_tol", true) = 1.0e-06;
      21        6486 :   params.set<Real>("nl_rel_tol", true) = 1e-50;
      22        6486 :   params.set<Real>("l_tol", true) = 1e-2;
      23       12972 :   params.addParam<Real>("free_l_tol", 1e-2, "Relative linear tolerance in free power iteration");
      24        6486 :   params.addParam<bool>(
      25        6486 :       "output_after_power_iterations", true, "True to output solution after free power iterations");
      26        3243 :   return params;
      27           0 : }
      28             : 
      29          91 : NonlinearEigen::NonlinearEigen(const InputParameters & parameters)
      30             :   : EigenExecutionerBase(parameters),
      31          91 :     _free_iter(getParam<unsigned int>("free_power_iterations")),
      32         182 :     _nl_abs_tol(getParam<Real>("nl_abs_tol")),
      33         182 :     _nl_rel_tol(getParam<Real>("nl_rel_tol")),
      34         182 :     _l_tol(getParam<Real>("l_tol")),
      35         182 :     _free_l_tol(getParam<Real>("free_l_tol")),
      36         273 :     _output_after_pi(getParam<bool>("output_after_power_iterations"))
      37             : {
      38          91 :   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          91 : }
      45             : 
      46             : void
      47          91 : NonlinearEigen::init()
      48             : {
      49          91 :   if (_app.isRecovering())
      50             :   {
      51           1 :     _console << "\nCannot recover NonlinearEigen solves!\nExiting...\n" << std::endl;
      52           1 :     return;
      53             :   }
      54             : 
      55          90 :   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          90 :   _problem.timeStep() = 0;
      60          90 :   Real t = _problem.time();
      61          90 :   _problem.time() = _problem.timeStep();
      62          90 :   _problem.outputStep(EXEC_INITIAL);
      63          90 :   _problem.time() = t;
      64             : 
      65          90 :   if (_free_iter > 0)
      66             :   {
      67             :     // save the initial guess
      68          90 :     _problem.advanceState();
      69             : 
      70             :     // free power iterations
      71          90 :     _console << " Free power iteration starts" << std::endl;
      72             : 
      73             :     Real initial_res;
      74         180 :     inversePowerIteration(_free_iter,
      75          90 :                           _free_iter,
      76          90 :                           _free_l_tol,
      77             :                           false,
      78             :                           std::numeric_limits<Real>::min(),
      79             :                           true,
      80             :                           "",
      81             :                           std::numeric_limits<Real>::max(),
      82          90 :                           _eigenvalue,
      83             :                           initial_res);
      84             : 
      85          90 :     _problem.onTimestepEnd();
      86          90 :     _problem.execute(EXEC_TIMESTEP_END);
      87             : 
      88          90 :     if (_output_after_pi)
      89             :     {
      90             :       // output initial guess created by free power iterations
      91          41 :       _problem.timeStep()++;
      92          41 :       Real t = _problem.time();
      93          41 :       _problem.time() = _problem.timeStep();
      94          41 :       _problem.outputStep(EXEC_TIMESTEP_END);
      95          41 :       _problem.time() = t;
      96             :     }
      97             :   }
      98             : }
      99             : 
     100             : void
     101          91 : NonlinearEigen::execute()
     102             : {
     103          91 :   if (_app.isRecovering())
     104             :   {
     105           1 :     _last_solve_converged = true;
     106           1 :     return;
     107             :   }
     108             : 
     109          90 :   preExecute();
     110             : 
     111          90 :   takeStep();
     112             : 
     113          90 :   postExecute();
     114             : }
     115             : 
     116             : void
     117          90 : NonlinearEigen::takeStep()
     118             : {
     119          90 :   _console << " Nonlinear iteration starts" << std::endl;
     120             : 
     121          90 :   preSolve();
     122          90 :   _problem.timestepSetup();
     123          90 :   _problem.advanceState();
     124          90 :   _problem.execute(EXEC_TIMESTEP_BEGIN);
     125             : 
     126          90 :   _last_solve_converged = nonlinearSolve(_nl_rel_tol, _nl_abs_tol, _l_tol, _eigenvalue);
     127          90 :   postSolve();
     128             : 
     129          90 :   if (lastSolveConverged())
     130             :   {
     131          90 :     printEigenvalue();
     132             : 
     133          90 :     _problem.onTimestepEnd();
     134          90 :     _problem.execute(EXEC_TIMESTEP_END);
     135             :   }
     136          90 : }