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             : // MOOSE includes
      11             : #include "SteadyBase.h"
      12             : #include "FEProblem.h"
      13             : #include "Factory.h"
      14             : #include "MooseApp.h"
      15             : #include "NonlinearSystem.h"
      16             : 
      17             : #include "libmesh/equation_systems.h"
      18             : 
      19             : InputParameters
      20       78567 : SteadyBase::validParams()
      21             : {
      22       78567 :   InputParameters params = Executioner::validParams();
      23      235701 :   params.addParam<Real>("time", 0.0, "System time");
      24       78567 :   return params;
      25           0 : }
      26             : 
      27       29720 : SteadyBase::SteadyBase(const InputParameters & parameters)
      28             :   : Executioner(parameters),
      29       29720 :     _problem(_fe_problem),
      30       29720 :     _system_time(getParam<Real>("time")),
      31       29720 :     _time_step(_problem.timeStep()),
      32       59440 :     _time([this]() -> Real & { return this->_problem.time() = this->_system_time; }()),
      33       29720 :     _output_iteration_number(0)
      34             : {
      35       29720 : }
      36             : 
      37             : void
      38       28884 : SteadyBase::execute()
      39             : {
      40       28884 :   if (_app.isRecovering())
      41             :   {
      42        1771 :     _console << "\nCannot recover steady-state solves of type: " << this->type()
      43        1771 :              << "!\nExiting...\n"
      44        1771 :              << std::endl;
      45        1771 :     _last_solve_converged = true;
      46        1771 :     return;
      47             :   }
      48             : 
      49       27113 :   _time_step = 0;
      50       27113 :   _time = _time_step;
      51       27113 :   _problem.outputStep(EXEC_INITIAL);
      52       27113 :   _time = _system_time;
      53             : 
      54       27113 :   preExecute();
      55             : 
      56       27113 :   _problem.advanceState();
      57             : 
      58             :   // first step in any SteadyBase state solve is always 1 (preserving backwards compatibility)
      59       27113 :   _time_step = 1;
      60             : 
      61             : #ifdef LIBMESH_ENABLE_AMR
      62             : 
      63             :   // Define the refinement loop
      64       27113 :   unsigned int steps = _problem.adaptivity().getSteps();
      65       54729 :   for (unsigned int r_step = 0; r_step <= steps; r_step++)
      66             :   {
      67             : #endif // LIBMESH_ENABLE_AMR
      68       27949 :     _problem.timestepSetup();
      69             : 
      70       27949 :     _last_solve_converged = _fixed_point_solve->solve();
      71             : 
      72       27810 :     if (!lastSolveConverged())
      73             :     {
      74         185 :       _console << "Aborting as solve did not converge" << std::endl;
      75         185 :       break;
      76             :     }
      77             : 
      78       27625 :     _problem.computeIndicators();
      79       27625 :     _problem.computeMarkers();
      80             : 
      81             :     // need to keep _time in sync with _time_step to get correct output
      82       27622 :     _time = _time_step;
      83       27622 :     _problem.outputStep(EXEC_TIMESTEP_END);
      84       27616 :     _time = _system_time;
      85             : 
      86             : #ifdef LIBMESH_ENABLE_AMR
      87       27616 :     if (r_step != steps)
      88             :     {
      89         836 :       _problem.adaptMesh();
      90             :     }
      91             : 
      92       27616 :     _time_step++;
      93             :   }
      94             : #endif
      95             : 
      96             :   {
      97      134825 :     TIME_SECTION("final", 1, "Executing Final Objects")
      98       26965 :     _problem.execMultiApps(EXEC_FINAL);
      99       26965 :     _problem.finalizeMultiApps();
     100       26965 :     _problem.postExecute();
     101       26965 :     _problem.execute(EXEC_FINAL);
     102       26965 :     _time = _time_step;
     103       26965 :     _problem.outputStep(EXEC_FINAL);
     104       26965 :     _time = _system_time;
     105       26965 :   }
     106             : 
     107       26965 :   postExecute();
     108             : }