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 "DefaultNonlinearConvergence.h"
      16             : #include "DefaultMultiAppFixedPointConvergence.h"
      17             : 
      18             : registerMooseAction("MooseApp", AddDefaultConvergenceAction, "add_default_nonlinear_convergence");
      19             : registerMooseAction("MooseApp",
      20             :                     AddDefaultConvergenceAction,
      21             :                     "add_default_multiapp_fixed_point_convergence");
      22             : 
      23             : InputParameters
      24       61934 : AddDefaultConvergenceAction::validParams()
      25             : {
      26       61934 :   InputParameters params = Action::validParams();
      27       61934 :   params.addClassDescription("Adds default Convergence objects to the simulation.");
      28       61934 :   return params;
      29           0 : }
      30             : 
      31       61934 : AddDefaultConvergenceAction::AddDefaultConvergenceAction(const InputParameters & params)
      32       61934 :   : Action(params)
      33             : {
      34       61934 : }
      35             : 
      36             : void
      37      115086 : AddDefaultConvergenceAction::act()
      38             : {
      39      115086 :   if (_current_task == "add_default_nonlinear_convergence")
      40       57549 :     addDefaultNonlinearConvergence();
      41       57537 :   else if (_current_task == "add_default_multiapp_fixed_point_convergence")
      42       57537 :     addDefaultMultiAppFixedPointConvergence();
      43      115062 : }
      44             : 
      45             : void
      46       57549 : AddDefaultConvergenceAction::addDefaultNonlinearConvergence()
      47             : {
      48       57549 :   if (_problem->needToAddDefaultNonlinearConvergence())
      49             :   {
      50       57119 :     const std::string default_name = "default_nonlinear_convergence";
      51             :     // Create a default convergence for every nonlinear system
      52       57119 :     std::vector<ConvergenceName> default_name_vec;
      53      113343 :     for (const auto & nl_sys_name : _problem->getNonlinearSystemNames())
      54       56224 :       default_name_vec.push_back(default_name + nl_sys_name);
      55       57119 :     _problem->setNonlinearConvergenceNames(default_name_vec);
      56       57119 :     _problem->addDefaultNonlinearConvergence(getMooseApp().getExecutioner()->parameters());
      57       57111 :   }
      58             : 
      59       57541 :   checkUnusedNonlinearConvergenceParameters();
      60       57537 : }
      61             : 
      62             : void
      63       57537 : AddDefaultConvergenceAction::addDefaultMultiAppFixedPointConvergence()
      64             : {
      65       57537 :   if (_problem->needToAddDefaultMultiAppFixedPointConvergence())
      66             :   {
      67       57465 :     const std::string conv_name = "default_multiapp_fixed_point_convergence";
      68       57465 :     _problem->setMultiAppFixedPointConvergenceName(conv_name);
      69       57465 :     _problem->addDefaultMultiAppFixedPointConvergence(getMooseApp().getExecutioner()->parameters());
      70       57453 :   }
      71             : 
      72       57525 :   checkUnusedMultiAppFixedPointConvergenceParameters();
      73       57525 : }
      74             : 
      75             : void
      76       57541 : AddDefaultConvergenceAction::checkUnusedNonlinearConvergenceParameters()
      77             : {
      78             :   // Only perform this check if the executioner uses Convergence objects
      79       57541 :   auto & executioner_params = getMooseApp().getExecutioner()->parameters();
      80       57541 :   if (!executioner_params.have_parameter<std::vector<ConvergenceName>>("nonlinear_convergence"))
      81         154 :     return;
      82             : 
      83             :   // Convergences may exist but be inactive
      84       57387 :   bool has_convergence = false;
      85      113879 :   for (const auto & cv_name : _problem->getNonlinearConvergenceNames())
      86       56492 :     if (_problem->hasConvergence(cv_name))
      87       56492 :       has_convergence = true;
      88       57387 :   if (!has_convergence)
      89        1097 :     return;
      90             : 
      91             :   // If a single convergence is a `DefaultNonlinearConvergence` they can handle the Executioner
      92             :   // parameters pertaining to the nonlinear system solve
      93       56290 :   bool has_a_default_nl_conv = false;
      94      112782 :   for (const auto & cv_name : _problem->getNonlinearConvergenceNames())
      95             :   {
      96       56492 :     if (!_problem->hasConvergence(cv_name))
      97           0 :       continue;
      98       56492 :     auto & conv = _problem->getConvergence(cv_name);
      99       56492 :     auto * default_nl_conv = dynamic_cast<DefaultNonlinearConvergence *>(&conv);
     100       56492 :     if (default_nl_conv)
     101       56394 :       has_a_default_nl_conv = true;
     102             :   }
     103             : 
     104             :   // Only Convergence objects deriving from DefaultNonlinearConvergence should
     105             :   // share parameters with the executioner.
     106       56290 :   if (!has_a_default_nl_conv)
     107             :   {
     108         192 :     for (const auto & cv_name : _problem->getNonlinearConvergenceNames())
     109             :     {
     110          98 :       if (!_problem->hasConvergence(cv_name))
     111           0 :         continue;
     112             : 
     113          98 :       auto nl_params = FEProblemSolve::feProblemDefaultConvergenceParams();
     114          98 :       std::vector<std::string> unused_params;
     115        1078 :       for (const auto & param : nl_params.getParametersList())
     116         980 :         if (executioner_params.isParamSetByUser(param))
     117         102 :           unused_params.push_back(param);
     118             : 
     119          98 :       if (unused_params.size() > 0)
     120             :       {
     121           4 :         std::stringstream msg;
     122             :         msg << "The following nonlinear convergence parameters were set in the executioner, but "
     123           4 :                "are not used:\n";
     124           8 :         for (const auto & param : unused_params)
     125           4 :           msg << "  " << param << "\n";
     126           4 :         mooseError(msg.str());
     127           0 :       }
     128          94 :     }
     129             :   }
     130             : }
     131             : 
     132             : void
     133       57525 : AddDefaultConvergenceAction::checkUnusedMultiAppFixedPointConvergenceParameters()
     134             : {
     135             :   // Abort check if executioner does not allow Convergence objects
     136       57525 :   auto & executioner_params = getMooseApp().getExecutioner()->parameters();
     137       57525 :   if (!executioner_params.have_parameter<ConvergenceName>("multiapp_fixed_point_convergence"))
     138           0 :     return;
     139             : 
     140             :   // Abort if there is no fixed point convergence. For example, Executors may not have them.
     141       57525 :   if (!_problem->hasSetMultiAppFixedPointConvergenceName())
     142          20 :     return;
     143             : 
     144       57505 :   const auto & conv_name = _problem->getMultiAppFixedPointConvergenceName();
     145             : 
     146             :   // Abort check if Convergence is inactive
     147       57505 :   if (!_problem->hasConvergence(conv_name))
     148           0 :     return;
     149             : 
     150             :   // If the convergence is a DefaultMultiAppFixedPointConvergence they can handle the Executioner
     151             :   // parameters pertaining to the fixed point solve
     152       57505 :   auto & conv = _problem->getConvergence(conv_name);
     153       57505 :   const auto * const default_conv = dynamic_cast<DefaultMultiAppFixedPointConvergence *>(&conv);
     154             : 
     155             :   // Only Convergence objects deriving from DefaultMultiAppFixedPointConvergence should
     156             :   // share parameters with the executioner
     157       57505 :   if (!default_conv)
     158             :   {
     159          24 :     auto fp_params = FixedPointSolve::fixedPointDefaultConvergenceParams();
     160          24 :     std::vector<std::string> unused_params;
     161         288 :     for (const auto & param : fp_params.getParametersList())
     162         264 :       if (executioner_params.isParamSetByUser(param))
     163          24 :         unused_params.push_back(param);
     164             : 
     165          24 :     if (unused_params.size() > 0)
     166             :     {
     167           0 :       std::stringstream msg;
     168             :       msg << "The following fixed point convergence parameters were set in the executioner, but "
     169           0 :              "are not used:\n";
     170           0 :       for (const auto & param : unused_params)
     171           0 :         msg << "  " << param << "\n";
     172           0 :       mooseError(msg.str());
     173           0 :     }
     174          24 :   }
     175             : }