https://mooseframework.inl.gov
AddDefaultConvergenceAction.C
Go to the documentation of this file.
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 
11 #include "FEProblem.h"
12 #include "Executioner.h"
13 #include "FEProblemSolve.h"
14 #include "FixedPointSolve.h"
15 #include "TransientBase.h"
19 
20 registerMooseAction("MooseApp", AddDefaultConvergenceAction, "add_default_nonlinear_convergence");
21 registerMooseAction("MooseApp",
23  "add_default_multiapp_fixed_point_convergence");
24 registerMooseAction("MooseApp",
26  "add_default_steady_state_convergence");
27 
30 {
32  params.addClassDescription("Adds default Convergence objects to the simulation.");
33  return params;
34 }
35 
37  : Action(params)
38 {
39 }
40 
41 void
43 {
44  if (_current_task == "add_default_nonlinear_convergence")
46  else if (_current_task == "add_default_multiapp_fixed_point_convergence")
48  else if (_current_task == "add_default_steady_state_convergence")
50 }
51 
52 void
54 {
55  if (_problem->needToAddDefaultNonlinearConvergence())
56  {
57  const std::string default_name = "default_nonlinear_convergence";
58  // Create a default convergence for every nonlinear system
59  std::vector<ConvergenceName> default_name_vec;
60  for (const auto & nl_sys_name : _problem->getNonlinearSystemNames())
61  default_name_vec.push_back(default_name + nl_sys_name);
62  _problem->setNonlinearConvergenceNames(default_name_vec);
63  _problem->addDefaultNonlinearConvergence(getMooseApp().getExecutioner()->parameters());
64  }
65 
67 }
68 
69 void
71 {
72  if (_problem->needToAddDefaultMultiAppFixedPointConvergence())
73  {
74  const std::string conv_name = "default_multiapp_fixed_point_convergence";
75  _problem->setMultiAppFixedPointConvergenceName(conv_name);
76  _problem->addDefaultMultiAppFixedPointConvergence(getMooseApp().getExecutioner()->parameters());
77  }
78 
80 }
81 
82 void
84 {
85  if (_problem->needToAddDefaultSteadyStateConvergence())
86  {
87  const std::string conv_name = "default_steady_state_convergence";
88  _problem->setSteadyStateConvergenceName(conv_name);
89  _problem->addDefaultSteadyStateConvergence(getMooseApp().getExecutioner()->parameters());
90  }
91 
93 }
94 
95 void
97 {
98  // Only perform this check if the executioner uses Convergence objects
99  auto & executioner_params = getMooseApp().getExecutioner()->parameters();
100  if (!executioner_params.have_parameter<std::vector<ConvergenceName>>("nonlinear_convergence"))
101  return;
102 
103  // Convergences may exist but be inactive
104  bool has_convergence = false;
105  for (const auto & cv_name : _problem->getNonlinearConvergenceNames())
106  if (_problem->hasConvergence(cv_name))
107  has_convergence = true;
108  if (!has_convergence)
109  return;
110 
111  // If a single convergence is a `DefaultNonlinearConvergence` they can handle the Executioner
112  // parameters pertaining to the nonlinear system solve
113  bool has_a_default_nl_conv = false;
114  for (const auto & cv_name : _problem->getNonlinearConvergenceNames())
115  {
116  if (!_problem->hasConvergence(cv_name))
117  continue;
118  auto & conv = _problem->getConvergence(cv_name);
119  auto * default_nl_conv = dynamic_cast<DefaultNonlinearConvergence *>(&conv);
120  if (default_nl_conv)
121  has_a_default_nl_conv = true;
122  }
123 
124  // Only Convergence objects deriving from DefaultNonlinearConvergence should
125  // share parameters with the executioner.
126  if (!has_a_default_nl_conv)
127  {
128  for (const auto & cv_name : _problem->getNonlinearConvergenceNames())
129  {
130  if (!_problem->hasConvergence(cv_name))
131  continue;
132 
134  std::vector<std::string> unused_params;
135  for (const auto & param : nl_params.getParametersList())
136  if (executioner_params.isParamSetByUser(param))
137  unused_params.push_back(param);
138 
139  if (unused_params.size() > 0)
140  {
141  std::stringstream msg;
142  msg << "The following nonlinear convergence parameters were set in the executioner, but "
143  "are not used:\n";
144  for (const auto & param : unused_params)
145  msg << " " << param << "\n";
146  mooseError(msg.str());
147  }
148  }
149  }
150 }
151 
152 void
154 {
155  // Abort check if executioner does not allow Convergence objects
156  auto & executioner_params = getMooseApp().getExecutioner()->parameters();
157  if (!executioner_params.have_parameter<ConvergenceName>("multiapp_fixed_point_convergence"))
158  return;
159 
160  // Abort if there is no fixed point convergence. For example, Executors may not have them.
161  if (!_problem->hasSetMultiAppFixedPointConvergenceName())
162  return;
163 
164  const auto & conv_name = _problem->getMultiAppFixedPointConvergenceName();
165 
166  // Abort check if Convergence is inactive
167  if (!_problem->hasConvergence(conv_name))
168  return;
169 
170  // If the convergence is a DefaultMultiAppFixedPointConvergence they can handle the Executioner
171  // parameters pertaining to the fixed point solve
172  auto & conv = _problem->getConvergence(conv_name);
173  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  if (!default_conv)
178  {
180  std::vector<std::string> unused_params;
181  for (const auto & param : fp_params.getParametersList())
182  if (executioner_params.isParamSetByUser(param))
183  unused_params.push_back(param);
184 
185  if (unused_params.size() > 0)
186  {
187  std::stringstream msg;
188  msg << "The following fixed point convergence parameters were set in the executioner, but "
189  "are not used:\n";
190  for (const auto & param : unused_params)
191  msg << " " << param << "\n";
192  mooseError(msg.str());
193  }
194  }
195 }
196 
197 void
199 {
200  // Abort check if executioner does not allow Convergence objects
201  auto & executioner_params = getMooseApp().getExecutioner()->parameters();
202  if (!executioner_params.have_parameter<ConvergenceName>("steady_state_convergence"))
203  return;
204 
205  const auto conv_name = _problem->getSteadyStateConvergenceName();
206 
207  // Abort check if Convergence is inactive
208  if (!_problem->hasConvergence(conv_name))
209  return;
210 
211  // If the convergence is a DefaultSteadyStateConvergence they can handle the Executioner
212  // parameters pertaining to the steady solve
213  auto & conv = _problem->getConvergence(conv_name);
214  auto * default_conv = dynamic_cast<DefaultSteadyStateConvergence *>(&conv);
215 
216  // Only Convergence objects deriving from DefaultSteadyStateConvergence should
217  // share parameters with the executioner
218  if (!default_conv)
219  {
221  std::vector<std::string> unused_params;
222  for (const auto & param : params.getParametersList())
223  if (executioner_params.isParamSetByUser(param))
224  unused_params.push_back(param);
225 
226  if (unused_params.size() > 0)
227  {
228  std::stringstream msg;
229  msg << "The following steady-state convergence parameters were set in the executioner, but "
230  "are not used:\n";
231  for (const auto & param : unused_params)
232  msg << " " << param << "\n";
233  mooseError(msg.str());
234  }
235  }
236 }
static InputParameters fixedPointDefaultConvergenceParams()
AddDefaultConvergenceAction(const InputParameters &params)
registerMooseAction("MooseApp", AddDefaultConvergenceAction, "add_default_nonlinear_convergence")
Adds default Convergence objects to the simulation.
The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system...
virtual void act() override
Method to add objects to the simulation or perform other setup tasks.
Base class for actions.
Definition: Action.h:33
MooseApp & getMooseApp() const
Get the MooseApp this class is associated with.
Definition: MooseBase.h:45
static InputParameters validParams()
void checkUnusedNonlinearConvergenceParameters()
Checks that nonlinear convergence parameters were not set in the executioner if using a Convergence o...
static InputParameters validParams()
Definition: Action.C:24
void addDefaultSteadyStateConvergence()
Adds the default steady-state Convergence object.
void checkUnusedMultiAppFixedPointConvergenceParameters()
Checks that fixed point convergence parameters were not set in the executioner if using a Convergence...
static InputParameters feProblemDefaultConvergenceParams()
const std::string & _current_task
The current action (even though we have separate instances for each action)
Definition: Action.h:162
Executioner * getExecutioner() const
Retrieve the Executioner for this App.
Definition: MooseApp.C:2118
void addDefaultNonlinearConvergence()
Adds the default nonlinear Convergence object(s)
Default convergence criteria for steady-state detection in a transient simulation.
static InputParameters defaultSteadyStateConvergenceParams()
Definition: TransientBase.C:42
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type.
void addClassDescription(const std::string &doc_string)
This method adds a description of the class that will be displayed in the input file syntax dump...
std::shared_ptr< FEProblemBase > & _problem
Convenience reference to a problem this action works on.
Definition: Action.h:168
const InputParameters & parameters() const
Get the parameters of the object.
void addDefaultMultiAppFixedPointConvergence()
Adds the default fixed point Convergence object.
void checkUnusedSteadyStateConvergenceParameters()
Checks that steady-state convergence parameters were not set in the executioner if using a Convergenc...
Default nonlinear convergence criteria for FEProblem.
Default fixed point convergence criteria.