DefaultSteadyStateConvergence.C

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
 
#include "DefaultSteadyStateConvergence.h"
#include "FEProblemBase.h"
#include "TransientBase.h"
#include "AuxiliarySystem.h"
#include "ConvergenceIterationTypes.h"
 
registerMooseObject("MooseApp", DefaultSteadyStateConvergence);
 
InputParameters
DefaultSteadyStateConvergence::validParams()
{
  InputParameters params = DefaultConvergenceBase::validParams();
  params += TransientBase::defaultSteadyStateConvergenceParams();
 
  params.addClassDescription(
      "Default convergence criteria for steady-state detection in a transient simulation.");
 
  return params;
}
 
DefaultSteadyStateConvergence::DefaultSteadyStateConvergence(const InputParameters & parameters)
  : DefaultConvergenceBase(parameters),
 
    _steady_state_tolerance(getSharedExecutionerParam<Real>("steady_state_tolerance")),
    _check_aux(getSharedExecutionerParam<bool>("check_aux")),
    _normalize_norm_by_dt(getSharedExecutionerParam<bool>("normalize_solution_diff_norm_by_dt")),
 
    _fe_problem(*getCheckedPointerParam<FEProblemBase *>("_fe_problem_base")),
    _transient_executioner(dynamic_cast<TransientBase * const>(getMooseApp().getExecutioner())),
    _aux_system(_fe_problem.getAuxiliarySystem())
{
  if (!_transient_executioner)
    mooseError("DefaultSteadyStateConvergence can only be used for Executioners derived from "
               "TransientBase.");
}
 
void
DefaultSteadyStateConvergence::checkIterationType(IterationType it_type) const
{
  DefaultConvergenceBase::checkIterationType(it_type);
 
  if (it_type != ConvergenceIterationTypes::STEADY_STATE)
    mooseError("DefaultSteadyStateConvergence can only be used with steady-state detection.");
}
 
Convergence::MooseConvergenceStatus
DefaultSteadyStateConvergence::checkConvergence(unsigned int /*n_iter*/)
{
  TIME_SECTION(_perfid_check_convergence);
 
  Real norm = 0.0;
  if (_check_aux)
  {
    std::vector<Number> aux_var_diff_norms;
    _aux_system.variableWiseRelativeSolutionDifferenceNorm(aux_var_diff_norms);
    for (auto & aux_var_diff_norm : aux_var_diff_norms)
      aux_var_diff_norm /= (_normalize_norm_by_dt ? _fe_problem.dt() : Real(1));
 
    norm = *std::max_element(aux_var_diff_norms.begin(), aux_var_diff_norms.end());
  }
  else
    norm = _transient_executioner->computeSolutionChangeNorm(false, _normalize_norm_by_dt);
 
  _console << "Steady-State Relative Differential Norm: " << norm << std::endl;
 
  if (norm < _steady_state_tolerance)
    return MooseConvergenceStatus::CONVERGED;
  else
    return MooseConvergenceStatus::ITERATING;
}