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 "DefaultSteadyStateConvergence.h"
      11             : #include "FEProblemBase.h"
      12             : #include "TransientBase.h"
      13             : #include "AuxiliarySystem.h"
      14             : #include "ConvergenceIterationTypes.h"
      15             : 
      16             : registerMooseObject("MooseApp", DefaultSteadyStateConvergence);
      17             : 
      18             : InputParameters
      19       81182 : DefaultSteadyStateConvergence::validParams()
      20             : {
      21       81182 :   InputParameters params = DefaultConvergenceBase::validParams();
      22       81182 :   params += TransientBase::defaultSteadyStateConvergenceParams();
      23             : 
      24       81182 :   params.addClassDescription(
      25             :       "Default convergence criteria for steady-state detection in a transient simulation.");
      26             : 
      27       81182 :   return params;
      28           0 : }
      29             : 
      30       34771 : DefaultSteadyStateConvergence::DefaultSteadyStateConvergence(const InputParameters & parameters)
      31             :   : DefaultConvergenceBase(parameters),
      32             : 
      33       34771 :     _steady_state_tolerance(getSharedExecutionerParam<Real>("steady_state_tolerance")),
      34       69542 :     _check_aux(getSharedExecutionerParam<bool>("check_aux")),
      35       69542 :     _normalize_norm_by_dt(getSharedExecutionerParam<bool>("normalize_solution_diff_norm_by_dt")),
      36             : 
      37      139084 :     _fe_problem(*getCheckedPointerParam<FEProblemBase *>("_fe_problem_base")),
      38       34771 :     _transient_executioner(dynamic_cast<TransientBase * const>(getMooseApp().getExecutioner())),
      39       69542 :     _aux_system(_fe_problem.getAuxiliarySystem())
      40             : {
      41       34771 :   if (!_transient_executioner)
      42           0 :     mooseError("DefaultSteadyStateConvergence can only be used for Executioners derived from "
      43             :                "TransientBase.");
      44       34771 : }
      45             : 
      46             : void
      47       30684 : DefaultSteadyStateConvergence::checkIterationType(IterationType it_type) const
      48             : {
      49       30684 :   DefaultConvergenceBase::checkIterationType(it_type);
      50             : 
      51       30684 :   if (it_type != ConvergenceIterationTypes::STEADY_STATE)
      52           4 :     mooseError("DefaultSteadyStateConvergence can only be used with steady-state detection.");
      53       30680 : }
      54             : 
      55             : Convergence::MooseConvergenceStatus
      56       13823 : DefaultSteadyStateConvergence::checkConvergence(unsigned int /*iter*/)
      57             : {
      58       13823 :   TIME_SECTION(_perfid_check_convergence);
      59             : 
      60       13823 :   Real norm = 0.0;
      61       13823 :   if (_check_aux)
      62             :   {
      63         553 :     std::vector<Number> aux_var_diff_norms;
      64         553 :     _aux_system.variableWiseRelativeSolutionDifferenceNorm(aux_var_diff_norms);
      65        1659 :     for (auto & aux_var_diff_norm : aux_var_diff_norms)
      66        1106 :       aux_var_diff_norm /= (_normalize_norm_by_dt ? _fe_problem.dt() : Real(1));
      67             : 
      68         553 :     norm = *std::max_element(aux_var_diff_norms.begin(), aux_var_diff_norms.end());
      69         553 :   }
      70             :   else
      71       13270 :     norm = _transient_executioner->computeSolutionChangeNorm(false, _normalize_norm_by_dt);
      72             : 
      73       13823 :   _console << "Steady-State Relative Differential Norm: " << norm << std::endl;
      74             : 
      75       13823 :   if (norm < _steady_state_tolerance)
      76         387 :     return MooseConvergenceStatus::CONVERGED;
      77             :   else
      78       13436 :     return MooseConvergenceStatus::ITERATING;
      79       13823 : }