https://mooseframework.inl.gov
FixedPointSolve.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 
10 #include "FixedPointSolve.h"
11 
12 #include "FEProblem.h"
13 #include "Executioner.h"
14 #include "MooseMesh.h"
15 #include "NonlinearSystem.h"
16 #include "AuxiliarySystem.h"
18 #include "Console.h"
19 #include "EigenExecutionerBase.h"
20 #include "Convergence.h"
22 #include "MooseUtils.h"
23 
26 {
28 
29  params.addParam<unsigned int>(
30  "fixed_point_min_its", 1, "Specifies the minimum number of fixed point iterations.");
31  params.addParam<unsigned int>(
32  "fixed_point_max_its", 1, "Specifies the maximum number of fixed point iterations.");
33  params.addParam<bool>("disable_fixed_point_residual_norm_check",
34  false,
35  "Disable the residual norm evaluation thus the three parameters "
36  "fixed_point_rel_tol, fixed_point_abs_tol and fixed_point_force_norms.");
37  params.addParam<bool>(
38  "fixed_point_force_norms",
39  false,
40  "Force the evaluation of both the TIMESTEP_BEGIN and TIMESTEP_END norms regardless of the "
41  "existence of active MultiApps with those execute_on flags, default: false.");
42  params.addParam<bool>(
43  "accept_on_max_fixed_point_iteration",
44  false,
45  "True to treat reaching the maximum number of fixed point iterations as converged.");
46  params.addRangeCheckedParam<Real>("fixed_point_rel_tol",
47  1e-8,
48  "fixed_point_rel_tol>0",
49  "The relative nonlinear residual drop to shoot for "
50  "during fixed point iterations. This check is "
51  "performed based on the main app's nonlinear "
52  "residual.");
53  params.addRangeCheckedParam<Real>("fixed_point_abs_tol",
54  1e-50,
55  "fixed_point_abs_tol>0",
56  "The absolute nonlinear residual to shoot for "
57  "during fixed point iterations. This check is "
58  "performed based on the main app's nonlinear "
59  "residual.");
60 
61  params.addParam<PostprocessorName>("custom_pp",
62  "Postprocessor for custom fixed point convergence check.");
63  params.addParam<bool>("direct_pp_value",
64  false,
65  "True to use direct postprocessor value "
66  "(scaled by value on first iteration). "
67  "False (default) to use difference in postprocessor "
68  "value between fixed point iterations.");
69  params.addRangeCheckedParam<Real>("custom_rel_tol",
70  1e-8,
71  "custom_rel_tol>0",
72  "The relative nonlinear residual drop to shoot for "
73  "during fixed point iterations. This check is "
74  "performed based on the postprocessor defined by "
75  "custom_pp residual.");
76  params.addRangeCheckedParam<Real>("custom_abs_tol",
77  1e-50,
78  "custom_abs_tol>0",
79  "The absolute nonlinear residual to shoot for "
80  "during fixed point iterations. This check is "
81  "performed based on postprocessor defined by "
82  "the custom_pp residual.");
83 
84  params.addParamNamesToGroup(
85  "fixed_point_min_its fixed_point_max_its disable_fixed_point_residual_norm_check "
86  "accept_on_max_fixed_point_iteration fixed_point_rel_tol fixed_point_abs_tol "
87  "fixed_point_force_norms custom_pp direct_pp_value custom_abs_tol custom_rel_tol",
88  "Fixed point iterations");
89 
90  return params;
91 }
92 
95 {
98 
99  params.addParam<ConvergenceName>(
100  "multiapp_fixed_point_convergence",
101  "Name of the Convergence object to use to assess convergence of the "
102  "MultiApp fixed point solve. If not provided, a default Convergence "
103  "will be constructed internally from the executioner parameters.");
104 
105  // Parameters for relaxing the fixed point process
106  params.addRangeCheckedParam<Real>("relaxation_factor",
107  1.0,
108  "relaxation_factor>0 & relaxation_factor<2",
109  "Fraction of newly computed value to keep."
110  "Set between 0 and 2.");
111  params.addParam<std::vector<std::string>>(
112  "transformed_variables",
113  std::vector<std::string>(),
114  "List of main app variables to transform during fixed point iterations");
115  params.addParam<std::vector<PostprocessorName>>(
116  "transformed_postprocessors",
117  std::vector<PostprocessorName>(),
118  "List of main app postprocessors to transform during fixed point iterations");
119  params.addDeprecatedParam<std::vector<std::string>>(
120  "relaxed_variables",
121  std::vector<std::string>(),
122  "List of main app variables to relax during fixed point iterations",
123  "Relaxed variables is deprecated, use transformed_variables instead.");
124 
125  params.addParam<bool>("auto_advance",
126  "Whether to automatically advance sub-applications regardless of whether "
127  "their solve converges, for transient executioners only.");
128 
129  params.addParamNamesToGroup(
130  "multiapp_fixed_point_convergence "
131  "relaxation_factor transformed_variables transformed_postprocessors auto_advance",
132  "Fixed point iterations");
133 
134  params.addParam<unsigned int>(
135  "max_xfem_update",
137  "Maximum number of times to update XFEM crack topology in a step due to evolving cracks");
138  params.addParam<bool>("update_xfem_at_timestep_begin",
139  false,
140  "Should XFEM update the mesh at the beginning of the timestep");
141 
142  params.addParamNamesToGroup("max_xfem_update update_xfem_at_timestep_begin",
143  "XFEM fixed point iterations");
144 
145  return params;
146 }
147 
149  : SolveObject(ex),
150  _has_fixed_point_its(getParam<unsigned int>("fixed_point_max_its") > 1 ||
151  isParamSetByUser("multiapp_fixed_point_convergence")),
152  _relax_factor(getParam<Real>("relaxation_factor")),
153  _transformed_vars(getParam<std::vector<std::string>>("transformed_variables")),
154  _transformed_pps(getParam<std::vector<PostprocessorName>>("transformed_postprocessors")),
155  // this value will be set by MultiApp
156  _secondary_relaxation_factor(1.0),
157  _fixed_point_it(0),
158  _fixed_point_status(MooseFixedPointConvergenceReason::UNSOLVED),
159  _max_xfem_update(getParam<unsigned int>("max_xfem_update")),
160  _update_xfem_at_timestep_begin(getParam<bool>("update_xfem_at_timestep_begin")),
161  _xfem_update_count(0),
162  _xfem_repeat_step(false),
163  _old_entering_time(_problem.time() - 1),
164  _fail_step(false),
165  _auto_advance_set_by_user(isParamValid("auto_advance")),
166  _auto_advance_user_value(_auto_advance_set_by_user ? getParam<bool>("auto_advance") : true)
167 {
168  // Handle deprecated parameters
169  if (!parameters().isParamSetByAddParam("relaxed_variables"))
170  _transformed_vars = getParam<std::vector<std::string>>("relaxed_variables");
171 
172  if (_transformed_vars.size() > 0 && _transformed_pps.size() > 0)
173  mooseWarning(
174  "Both variable and postprocessor transformation are active. If the two share dofs, the "
175  "transformation will not be correct.");
176 
177  if (!_app.isUltimateMaster())
178  {
182  }
183 
184  if (isParamValid("multiapp_fixed_point_convergence"))
186  getParam<ConvergenceName>("multiapp_fixed_point_convergence"));
187  else
189 }
190 
191 void
193 {
195 
196  allocateStorage(true);
197 
199  {
202  }
203 }
204 
205 bool
207 {
208  TIME_SECTION("PicardSolve", 1);
209 
210  Real current_dt = _problem.dt();
211 
212  bool converged = true;
213 
214  // need to back up multi-apps even when not doing fixed point iteration for recovering from failed
215  // multiapp solve
220 
221  // Prepare to relax variables as a main app
222  std::set<dof_id_type> transformed_dofs;
223  if ((_relax_factor != 1.0 || !dynamic_cast<PicardSolve *>(this)) && _transformed_vars.size() > 0)
224  {
225  // Snag all of the local dof indices for all of these variables
228  Threads::parallel_reduce(elem_range, aldit);
229 
230  transformed_dofs = aldit.getDofIndices();
231  }
232 
233  // Prepare to relax variables as a subapp
234  std::set<dof_id_type> secondary_transformed_dofs;
235  if (_secondary_relaxation_factor != 1.0 || !dynamic_cast<PicardSolve *>(this))
236  {
237  if (_secondary_transformed_variables.size() > 0)
238  {
239  // Snag all of the local dof indices for all of these variables
242  Threads::parallel_reduce(elem_range, aldit);
243 
244  secondary_transformed_dofs = aldit.getDofIndices();
245  }
246 
247  // To detect a new time step
248  if (_old_entering_time == _problem.time() &&
250  {
251  // Keep track of the iteration number of the main app
253 
254  // Save variable values before the solve. Solving will provide new values
255  if (!_app.isUltimateMaster())
256  saveVariableValues(/*is parent app of this iteration=*/false);
257  }
258  else
260  }
261 
263  {
265  convergence.initialize();
266  }
267 
268  _fixed_point_it = 0;
269  while (true)
270  {
272  {
273  if (_fixed_point_it != 0)
274  {
275  // For every iteration other than the first, we need to restore the state of the MultiApps
278  }
279 
280  _console << COLOR_MAGENTA << "Beginning fixed point iteration " << _fixed_point_it
281  << COLOR_DEFAULT << std::endl
282  << std::endl;
283  }
284 
285  // Solve a single application for one time step
286  const bool solve_converged = solveStep(transformed_dofs);
287 
288  if (solve_converged)
289  {
291  {
293 
294  // Examine convergence metrics & properties and set the convergence reason
295  bool break_out = examineFixedPointConvergence(converged);
296 
297  if (break_out)
298  {
299  // Except DefaultMultiAppFixedPointConvergence, convergence objects will not
300  // update _fixed_point_status, so we give those cases generic values:
302  {
303  if (converged)
305  else
307  }
308 
309  break;
310  }
311  }
312  }
313  else
314  {
315  // If the last solve didn't converge then we need to exit this step completely (even in the
316  // case of coupling). So we can retry...
317  converged = false;
318  break;
319  }
320 
321  _problem.dt() =
322  current_dt; // _dt might be smaller than this at this point for multistep methods
323 
324  _fixed_point_it++;
325 
327  break;
328  }
329 
330  if (converged)
331  {
332  // Fixed point iteration loop ends right above
336  {
338  return false;
339  }
341  }
342 
343  // Save postprocessors after the solve and their potential timestep_end execution
344  // The postprocessors could be overwritten at timestep_begin, which is why they are saved
345  // after the solve. They could also be saved right after the transfers.
348 
349  if (converged)
350  {
351  // Update the subapp using the fixed point algorithm
352  if (_secondary_transformed_variables.size() > 0 &&
354  transformVariables(secondary_transformed_dofs, false);
355 
356  // Update the entering time, used to detect failed solves
358  }
359 
362 
363  return converged;
364 }
365 
366 void
368 {
369  saveVariableValues(primary);
370  savePostprocessorValues(primary);
371 }
372 
373 bool
374 FixedPointSolve::solveStep(const std::set<dof_id_type> & transformed_dofs)
375 {
376  bool auto_advance = autoAdvance();
377 
380 
381  if (_fixed_point_it == 0)
382  {
386  {
388  return false;
389  }
391  }
392 
393  if (!_problem.execMultiApps(EXEC_TIMESTEP_BEGIN, auto_advance))
394  {
396  return false;
397  }
398 
401 
403 
404  // Transform the fixed point postprocessors before solving, but after the timestep_begin transfers
405  // have been received
411 
413  {
415  convergence.preExecute();
416  }
417 
418  // Perform output for timestep begin
420 
421  // Update warehouse active objects
423 
424  // Save the current values of variables and postprocessors, before the solve
425  saveAllValues(true);
426 
427  // Save the previous fixed point iteration solution and aux variables
430 
432  _console << COLOR_MAGENTA << "\nMain app solve:" << COLOR_DEFAULT << std::endl;
433  if (!_inner_solve->solve())
434  {
436 
437  // Perform the output of the current, failed time step (this only occurs if desired)
439  return false;
440  }
441  else
443 
444  // Use the fixed point algorithm if the conditions (availability of values, etc) are met
446  transformVariables(transformed_dofs, true);
447 
449  {
450  _console << "\nXFEM modified mesh, repeating step" << std::endl;
451  _xfem_repeat_step = true;
453  }
454  else
455  {
456  if (_problem.haveXFEM())
457  {
458  _xfem_repeat_step = false;
459  _xfem_update_count = 0;
460  _console << "\nXFEM did not modify mesh, continuing" << std::endl;
461  }
462 
465 
467  if (!_problem.execMultiApps(EXEC_TIMESTEP_END, auto_advance))
468  {
470  return false;
471  }
472  }
473 
474  if (_fail_step)
475  {
476  _fail_step = false;
477  return false;
478  }
479 
481 
482  return true;
483 }
484 
485 bool
487 {
489 
491  const auto status = convergence.checkConvergence(_fixed_point_it);
492  switch (status)
493  {
495  converged = true;
496  return true;
498  converged = false;
499  return true;
501  converged = false;
502  return false;
503  default:
504  mooseError("Should not reach here");
505  }
506 }
507 
508 void
510 {
511  _console << "Fixed point convergence reason: ";
512  switch (_fixed_point_status)
513  {
515  _console << "CONVERGED_ABS";
516  break;
518  _console << "CONVERGED_RELATIVE";
519  break;
521  _console << "CONVERGED_PP";
522  break;
524  _console << "REACH_MAX_ITS";
525  break;
527  _console << "CONVERGED_OBJECT (see Convergence object)";
528  break;
530  _console << "DIVERGED_MAX_ITS";
531  break;
533  _console << "DIVERGED_NONLINEAR";
534  break;
536  _console << "DIVERGED_FAILED_MULTIAPP";
537  break;
539  _console << "DIVERGED_OBJECT (see Convergence object)";
540  break;
541  default:
542  // UNSOLVED and CONVERGED_NONLINEAR should not be hit when coupling
543  // iteration is not on here
544  mooseError("Internal error: wrong fixed point status!");
545  break;
546  }
547  _console << std::endl;
548 }
549 
550 bool
552 {
553  bool auto_advance = !(_has_fixed_point_its && _problem.isTransient());
554 
555  if (dynamic_cast<EigenExecutionerBase *>(&_executioner) && _has_fixed_point_its)
556  auto_advance = true;
557 
559  auto_advance = _auto_advance_user_value;
560 
561  return auto_advance;
562 }
563 
564 bool
565 FixedPointSolve::performingRelaxation(const bool primary) const
566 {
567  if (primary)
569  else
571 }
static InputParameters fixedPointDefaultConvergenceParams()
FEProblemBase & _problem
Reference to FEProblem.
Definition: SolveObject.h:47
const ExecFlagType EXEC_FAILED
Definition: Moose.C:48
libMesh::ConstElemRange * getActiveLocalElementRange()
Return pointers to range objects for various types of ranges (local nodes, boundary elems...
Definition: MooseMesh.C:1238
std::vector< std::string > sub_transformed_vars
The names of variables to transform for fixed point solve algorithms (e.g. secant, etc.).
Definition: MooseApp.h:118
bool isUltimateMaster() const
Whether or not this app is the ultimate master app.
Definition: MooseApp.h:813
virtual Real & time() const
FixedPointSolve(Executioner &ex)
std::vector< PostprocessorName > sub_transformed_pps
The names of postprocessors to transform for fixed point solve algorithms (e.g. secant, etc.).
Definition: MooseApp.h:120
bool absoluteFuzzyEqual(const T &var1, const T2 &var2, const T3 &tol=libMesh::TOLERANCE *libMesh::TOLERANCE)
Function to check whether two variables are equal within an absolute tolerance.
Definition: MooseUtils.h:380
void addDeprecatedParam(const std::string &name, const T &value, const std::string &doc_string, const std::string &deprecation_message)
virtual void saveVariableValues(const bool primary)=0
Saves the current values of the variables, and update the old(er) vectors.
void setNeedToAddDefaultMultiAppFixedPointConvergence()
Sets _need_to_add_default_multiapp_fixed_point_convergence to true.
bool examineFixedPointConvergence(bool &converged)
Examine the various convergence metrics.
virtual void initialize()
Method that gets called before each iteration loop.
Definition: Convergence.h:53
virtual void allocateStorage(const bool primary)=0
Allocate storage for the fixed point algorithm.
virtual void preSolve()
Override this for actions that should take place before execution, called by FixedPointSolve.
Definition: Executioner.h:83
virtual MooseConvergenceStatus checkConvergence(unsigned int iter)=0
Returns convergence status.
FixedPointConfig & fixedPointConfig()
This info is stored here because we need a "globalish" place to put it in order to allow communicatio...
Definition: MooseApp.h:379
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:127
virtual void updateActiveObjects()
Update the active objects in the warehouses.
AuxiliarySystem & _aux
Reference to auxiliary system for faster access.
Definition: SolveObject.h:57
virtual bool solve() override
Iteratively solves the FEProblem.
The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system...
const ExecFlagType EXEC_MULTIAPP_FIXED_POINT_END
Definition: Moose.C:40
virtual void onTimestepEnd() override
bool haveXFEM()
Find out whether the current analysis is using XFEM.
const ExecFlagType EXEC_TIMESTEP_END
Definition: Moose.C:36
MooseFixedPointConvergenceReason
Enumeration for fixed point convergence reasons.
virtual void initialSetup()
Method that should be executed once, before any solve calls.
Definition: SolveObject.h:32
virtual void saveAllValues(const bool primary)
Save both the variable and postprocessor values.
bool _fail_step
force the current step to fail, triggering are repeat with a cut dt
virtual void transformPostprocessors(const bool primary)=0
Use the fixed point algorithm to transform the postprocessors.
InputParameters emptyInputParameters()
const std::set< dof_id_type > & getDofIndices() const
std::vector< PostprocessorName > _secondary_transformed_pps
Postprocessors to be relaxed outside of fixed point iteration (used as a subapp)
auto max(const L &left, const R &right)
const std::vector< PostprocessorName > _transformed_pps
The postprocessors (transferred or not) that are going to be relaxed.
FP converged according to Convergence object.
virtual void savePostprocessorValues(const bool primary)=0
Saves the current values of the postprocessors, and update the old(er) vectors.
Grab all the (possibly semi)local dof indices for the variables passed in, in the system passed in...
MPI_Status status
unsigned int _xfem_update_count
Counter for number of xfem updates that have been performed in the current step.
virtual void execute(const ExecFlagType &exec_type)
Convenience function for performing execution of MOOSE systems.
Executioner & _executioner
Executioner used to construct this.
Definition: SolveObject.h:45
const Real _relax_factor
Relaxation factor for fixed point Iteration.
MooseFixedPointConvergenceReason _fixed_point_status
Status of fixed point solve.
virtual Convergence & getConvergence(const std::string &name, const THREAD_ID tid=0) const
Gets a Convergence object.
void setMultiAppFixedPointConvergenceName(const ConvergenceName &convergence_name)
Sets the MultiApp fixed point convergence object name if there is one.
const ConvergenceName & getMultiAppFixedPointConvergenceName() const
Gets the MultiApp fixed point convergence object name.
const ExecFlagType EXEC_TIMESTEP_BEGIN
Definition: Moose.C:37
SolveObject * _inner_solve
SolveObject wrapped by this solve object.
Definition: SolveObject.h:59
virtual void transformVariables(const std::set< dof_id_type > &transformed_dofs, const bool primary)=0
Use the fixed point algorithm to transform the variables.
virtual bool updateMeshXFEM()
Update the mesh due to changing XFEM cuts.
Executioners are objects that do the actual work of solving your problem.
Definition: Executioner.h:30
virtual void checkIterationType(IterationType) const
Perform checks related to the iteration type.
Definition: Convergence.h:48
Real _secondary_relaxation_factor
Relaxation factor outside of fixed point iteration (used as a subapp)
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:353
FP converged by relative residual tolerance.
void backupMultiApps(ExecFlagType type)
Backup the MultiApps associated with the ExecFlagType.
unsigned int _fixed_point_it
SystemBase & _solver_sys
Reference to a system for creating vectors as needed for the solve, etc.
Definition: SolveObject.h:55
static InputParameters validParams()
virtual bool useFixedPointAlgorithmUpdateInsteadOfPicard(const bool primary)=0
Use the fixed point algorithm transform instead of simply using the Picard update This routine can be...
Real sub_relaxation_factor
relaxation factor to be used for a MultiApp&#39;s subapps.
Definition: MooseApp.h:116
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
virtual void postSolve()
Override this for actions that should take place after execution, called by FixedPointSolve.
Definition: Executioner.h:88
const bool _auto_advance_set_by_user
Whether the user has set the auto_advance parameter for handling advancement of sub-applications in m...
const ExecFlagType EXEC_MULTIAPP_FIXED_POINT_BEGIN
Definition: Moose.C:42
void restoreMultiApps(ExecFlagType type, bool force=false)
Restore the MultiApps associated with the ExecFlagType.
std::vector< std::string > _secondary_transformed_variables
Variables to be relaxed outside of fixed point iteration (used as a subapp)
bool autoAdvance() const
Whether sub-applications are automatically advanced no matter what happens during their solves...
void mooseWarning(Args &&... args) const
Emits a warning prefixed with object name and type.
Definition: MooseBase.h:295
const ExecFlagType EXEC_MULTIAPP_FIXED_POINT_ITERATION_END
Definition: Moose.C:38
virtual MooseMesh & mesh() override
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type and optionally a file path to the top-level block p...
Definition: MooseBase.h:267
bool _xfem_repeat_step
Whether step should be repeated due to xfem modifying the mesh.
virtual void copyPreviousFixedPointSolutions()
Definition: SystemBase.C:1294
void addParam(const std::string &name, const S &value, const std::string &doc_string)
These methods add an optional parameter and a documentation string to the InputParameters object...
Real _old_entering_time
Time of previous fixed point solve as a subapp.
void addRangeCheckedParam(const std::string &name, const T &value, const std::string &parsed_function, const std::string &doc_string)
Main app nonlinear solve converged, FP unassessed.
bool isParamValid(const std::string &name) const
Test if the supplied parameter is valid.
Definition: MooseBase.h:195
const ConsoleStream _console
An instance of helper class to write streams to the Console objects.
bool execMultiApps(ExecFlagType type, bool auto_advance=true)
Execute the MultiApps associated with the ExecFlagType.
const unsigned int _max_xfem_update
Maximum number of xfem updates per step.
bool performingRelaxation(const bool primary) const
Returns true if there is relaxation.
virtual bool isTransient() const override
const ExecFlagType EXEC_MULTIAPP_FIXED_POINT_CONVERGENCE
Definition: Moose.C:44
void printFixedPointConvergenceReason()
Print information about the fixed point convergence.
FP converged by hitting max iterations and accepting.
virtual void initialSetup() override
Method that should be executed once, before any solve calls.
const bool _has_fixed_point_its
Whether or not we activate fixed point iteration.
virtual bool solve()=0
Solve routine provided by this object.
virtual Real & dt() const
virtual bool solveStep(const std::set< dof_id_type > &transformed_dofs)
Perform one fixed point iteration or a full solve.
virtual void preExecute()
Method that gets called in each iteration before the solve.
Definition: Convergence.h:58
const bool _auto_advance_user_value
The value of auto_advance set by the user for handling advancement of sub-applications in multi-app c...
void ErrorVector unsigned int
unsigned int _main_fixed_point_it
fixed point iteration counter for the main app
FP converged by absolute or relative PP tolerance.
virtual void outputStep(ExecFlagType type)
Output the current step.
const bool _update_xfem_at_timestep_begin
Controls whether xfem should update the mesh at the beginning of the time step.
void execTransfers(ExecFlagType type)
Execute the Transfers associated with the ExecFlagType.
void addParamNamesToGroup(const std::string &space_delim_names, const std::string group_name)
This method takes a space delimited list of parameter names and adds them to the specified group name...
std::vector< std::string > _transformed_vars
The variables (transferred or not) that are going to be relaxed.