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 "AddDefaultConvergenceAction.h"
      11             : #include "FEProblem.h"
      12             : #include "Executioner.h"
      13             : #include "FEProblemSolve.h"
      14             : #include "FixedPointSolve.h"
      15             : #include "TransientBase.h"
      16             : #include "DefaultNonlinearConvergence.h"
      17             : #include "DefaultMultiAppFixedPointConvergence.h"
      18             : #include "DefaultSteadyStateConvergence.h"
      19             : 
      20             : registerMooseAction("MooseApp", AddDefaultConvergenceAction, "add_default_nonlinear_convergence");
      21             : registerMooseAction("MooseApp",
      22             :                     AddDefaultConvergenceAction,
      23             :                     "add_default_multiapp_fixed_point_convergence");
      24             : registerMooseAction("MooseApp",
      25             :                     AddDefaultConvergenceAction,
      26             :                     "add_default_steady_state_convergence");
      27             : 
      28             : InputParameters
      29       68786 : AddDefaultConvergenceAction::validParams()
      30             : {
      31       68786 :   InputParameters params = Action::validParams();
      32       68786 :   params.addClassDescription("Adds default Convergence objects to the simulation.");
      33       68786 :   return params;
      34           0 : }
      35             : 
      36       68786 : AddDefaultConvergenceAction::AddDefaultConvergenceAction(const InputParameters & params)
      37       68786 :   : Action(params)
      38             : {
      39       68786 : }
      40             : 
      41             : void
      42      191763 : AddDefaultConvergenceAction::act()
      43             : {
      44      191763 :   if (_current_task == "add_default_nonlinear_convergence")
      45       63933 :     addDefaultNonlinearConvergence();
      46      127830 :   else if (_current_task == "add_default_multiapp_fixed_point_convergence")
      47       63921 :     addDefaultMultiAppFixedPointConvergence();
      48       63909 :   else if (_current_task == "add_default_steady_state_convergence")
      49       63909 :     addDefaultSteadyStateConvergence();
      50      191739 : }
      51             : 
      52             : void
      53       63933 : AddDefaultConvergenceAction::addDefaultNonlinearConvergence()
      54             : {
      55       63933 :   if (_problem->needToAddDefaultNonlinearConvergence())
      56             :   {
      57       63236 :     const std::string default_name = "default_nonlinear_convergence";
      58             :     // Create a default convergence for every nonlinear system
      59       63236 :     std::vector<ConvergenceName> default_name_vec;
      60      125411 :     for (const auto & nl_sys_name : _problem->getNonlinearSystemNames())
      61       62175 :       default_name_vec.push_back(default_name + nl_sys_name);
      62       63236 :     _problem->setNonlinearConvergenceNames(default_name_vec);
      63       63236 :     _problem->addDefaultNonlinearConvergence(getMooseApp().getExecutioner()->parameters());
      64       63228 :   }
      65             : 
      66       63925 :   checkUnusedNonlinearConvergenceParameters();
      67       63921 : }
      68             : 
      69             : void
      70       63921 : AddDefaultConvergenceAction::addDefaultMultiAppFixedPointConvergence()
      71             : {
      72       63921 :   if (_problem->needToAddDefaultMultiAppFixedPointConvergence())
      73             :   {
      74       63811 :     const std::string conv_name = "default_multiapp_fixed_point_convergence";
      75       63811 :     _problem->setMultiAppFixedPointConvergenceName(conv_name);
      76       63811 :     _problem->addDefaultMultiAppFixedPointConvergence(getMooseApp().getExecutioner()->parameters());
      77       63799 :   }
      78             : 
      79       63909 :   checkUnusedMultiAppFixedPointConvergenceParameters();
      80       63909 : }
      81             : 
      82             : void
      83       63909 : AddDefaultConvergenceAction::addDefaultSteadyStateConvergence()
      84             : {
      85       63909 :   if (_problem->needToAddDefaultSteadyStateConvergence())
      86             :   {
      87       31731 :     const std::string conv_name = "default_steady_state_convergence";
      88       31731 :     _problem->setSteadyStateConvergenceName(conv_name);
      89       31731 :     _problem->addDefaultSteadyStateConvergence(getMooseApp().getExecutioner()->parameters());
      90       31731 :   }
      91             : 
      92       63909 :   checkUnusedSteadyStateConvergenceParameters();
      93       63909 : }
      94             : 
      95             : void
      96       63925 : AddDefaultConvergenceAction::checkUnusedNonlinearConvergenceParameters()
      97             : {
      98             :   // Only perform this check if the executioner uses Convergence objects
      99       63925 :   auto & executioner_params = getMooseApp().getExecutioner()->parameters();
     100       63925 :   if (!executioner_params.have_parameter<std::vector<ConvergenceName>>("nonlinear_convergence"))
     101         369 :     return;
     102             : 
     103             :   // Convergences may exist but be inactive
     104       63556 :   bool has_convergence = false;
     105      126051 :   for (const auto & cv_name : _problem->getNonlinearConvergenceNames())
     106       62495 :     if (_problem->hasConvergence(cv_name))
     107       62495 :       has_convergence = true;
     108       63556 :   if (!has_convergence)
     109        1277 :     return;
     110             : 
     111             :   // If a single convergence is a `DefaultNonlinearConvergence` they can handle the Executioner
     112             :   // parameters pertaining to the nonlinear system solve
     113       62279 :   bool has_a_default_nl_conv = false;
     114      124774 :   for (const auto & cv_name : _problem->getNonlinearConvergenceNames())
     115             :   {
     116       62495 :     if (!_problem->hasConvergence(cv_name))
     117           0 :       continue;
     118       62495 :     auto & conv = _problem->getConvergence(cv_name);
     119       62495 :     auto * default_nl_conv = dynamic_cast<DefaultNonlinearConvergence *>(&conv);
     120       62495 :     if (default_nl_conv)
     121       62358 :       has_a_default_nl_conv = true;
     122             :   }
     123             : 
     124             :   // Only Convergence objects deriving from DefaultNonlinearConvergence should
     125             :   // share parameters with the executioner.
     126       62279 :   if (!has_a_default_nl_conv)
     127             :   {
     128         270 :     for (const auto & cv_name : _problem->getNonlinearConvergenceNames())
     129             :     {
     130         137 :       if (!_problem->hasConvergence(cv_name))
     131           0 :         continue;
     132             : 
     133         137 :       auto nl_params = FEProblemSolve::feProblemDefaultConvergenceParams();
     134         137 :       std::vector<std::string> unused_params;
     135        1507 :       for (const auto & param : nl_params.getParametersList())
     136        1370 :         if (executioner_params.isParamSetByUser(param))
     137         141 :           unused_params.push_back(param);
     138             : 
     139         137 :       if (unused_params.size() > 0)
     140             :       {
     141           4 :         std::stringstream msg;
     142             :         msg << "The following nonlinear convergence parameters were set in the executioner, but "
     143           4 :                "are not used:\n";
     144           8 :         for (const auto & param : unused_params)
     145           4 :           msg << "  " << param << "\n";
     146           4 :         mooseError(msg.str());
     147           0 :       }
     148         133 :     }
     149             :   }
     150             : }
     151             : 
     152             : void
     153       63909 : AddDefaultConvergenceAction::checkUnusedMultiAppFixedPointConvergenceParameters()
     154             : {
     155             :   // Abort check if executioner does not allow Convergence objects
     156       63909 :   auto & executioner_params = getMooseApp().getExecutioner()->parameters();
     157       63909 :   if (!executioner_params.have_parameter<ConvergenceName>("multiapp_fixed_point_convergence"))
     158           0 :     return;
     159             : 
     160             :   // Abort if there is no fixed point convergence. For example, Executors may not have them.
     161       63909 :   if (!_problem->hasSetMultiAppFixedPointConvergenceName())
     162          20 :     return;
     163             : 
     164       63889 :   const auto & conv_name = _problem->getMultiAppFixedPointConvergenceName();
     165             : 
     166             :   // Abort check if Convergence is inactive
     167       63889 :   if (!_problem->hasConvergence(conv_name))
     168           0 :     return;
     169             : 
     170             :   // If the convergence is a DefaultMultiAppFixedPointConvergence they can handle the Executioner
     171             :   // parameters pertaining to the fixed point solve
     172       63889 :   auto & conv = _problem->getConvergence(conv_name);
     173       63889 :   const auto * const default_conv = dynamic_cast<DefaultMultiAppFixedPointConvergence *>(&conv);
     174             : 
     175             :   // Only Convergence objects deriving from DefaultMultiAppFixedPointConvergence should
     176             :   // share parameters with the executioner
     177       63889 :   if (!default_conv)
     178             :   {
     179          56 :     auto fp_params = FixedPointSolve::fixedPointDefaultConvergenceParams();
     180          56 :     std::vector<std::string> unused_params;
     181         672 :     for (const auto & param : fp_params.getParametersList())
     182         616 :       if (executioner_params.isParamSetByUser(param))
     183          56 :         unused_params.push_back(param);
     184             : 
     185          56 :     if (unused_params.size() > 0)
     186             :     {
     187           0 :       std::stringstream msg;
     188             :       msg << "The following fixed point convergence parameters were set in the executioner, but "
     189           0 :              "are not used:\n";
     190           0 :       for (const auto & param : unused_params)
     191           0 :         msg << "  " << param << "\n";
     192           0 :       mooseError(msg.str());
     193           0 :     }
     194          56 :   }
     195             : }
     196             : 
     197             : void
     198       63909 : AddDefaultConvergenceAction::checkUnusedSteadyStateConvergenceParameters()
     199             : {
     200             :   // Abort check if executioner does not allow Convergence objects
     201       63909 :   auto & executioner_params = getMooseApp().getExecutioner()->parameters();
     202       63909 :   if (!executioner_params.have_parameter<ConvergenceName>("steady_state_convergence"))
     203       32140 :     return;
     204             : 
     205       31769 :   const auto conv_name = _problem->getSteadyStateConvergenceName();
     206             : 
     207             :   // Abort check if Convergence is inactive
     208       31769 :   if (!_problem->hasConvergence(conv_name))
     209           0 :     return;
     210             : 
     211             :   // If the convergence is a DefaultSteadyStateConvergence they can handle the Executioner
     212             :   // parameters pertaining to the steady solve
     213       31769 :   auto & conv = _problem->getConvergence(conv_name);
     214       31769 :   auto * default_conv = dynamic_cast<DefaultSteadyStateConvergence *>(&conv);
     215             : 
     216             :   // Only Convergence objects deriving from DefaultSteadyStateConvergence should
     217             :   // share parameters with the executioner
     218       31769 :   if (!default_conv)
     219             :   {
     220          17 :     auto params = TransientBase::defaultSteadyStateConvergenceParams();
     221          17 :     std::vector<std::string> unused_params;
     222          68 :     for (const auto & param : params.getParametersList())
     223          51 :       if (executioner_params.isParamSetByUser(param))
     224          17 :         unused_params.push_back(param);
     225             : 
     226          17 :     if (unused_params.size() > 0)
     227             :     {
     228           0 :       std::stringstream msg;
     229             :       msg << "The following steady-state convergence parameters were set in the executioner, but "
     230           0 :              "are not used:\n";
     231           0 :       for (const auto & param : unused_params)
     232           0 :         msg << "  " << param << "\n";
     233           0 :       mooseError(msg.str());
     234           0 :     }
     235          17 :   }
     236       31769 : }