segregated_fsi_solver.h
Go to the documentation of this file.
1 // LIC// ====================================================================
2 // LIC// This file forms part of oomph-lib, the object-oriented,
3 // LIC// multi-physics finite-element library, available
4 // LIC// at http://www.oomph-lib.org.
5 // LIC//
6 // LIC// Copyright (C) 2006-2024 Matthias Heil and Andrew Hazel
7 // LIC//
8 // LIC// This library is free software; you can redistribute it and/or
9 // LIC// modify it under the terms of the GNU Lesser General Public
10 // LIC// License as published by the Free Software Foundation; either
11 // LIC// version 2.1 of the License, or (at your option) any later version.
12 // LIC//
13 // LIC// This library is distributed in the hope that it will be useful,
14 // LIC// but WITHOUT ANY WARRANTY; without even the implied warranty of
15 // LIC// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 // LIC// Lesser General Public License for more details.
17 // LIC//
18 // LIC// You should have received a copy of the GNU Lesser General Public
19 // LIC// License along with this library; if not, write to the Free Software
20 // LIC// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
21 // LIC// 02110-1301 USA.
22 // LIC//
23 // LIC// The authors may be contacted at oomph-lib@maths.man.ac.uk.
24 // LIC//
25 // LIC//====================================================================
26 #ifndef OOMPH_SEGREGATED_FSI_SOLVER
27 #define OOMPH_SEGREGATED_FSI_SOLVER
28 
29 
30 #include "../generic/problem.h"
31 #include "../generic/geom_objects.h"
32 #include "../generic/mesh.h"
33 
34 namespace oomph
35 {
36  //===============================================================
37  /// Object that collates convergence data of Picard iteration
38  //===============================================================
40  {
41  public:
42  /// Constructor initialises all data
44  : Niter(0),
45  CPU_total(0.0),
48  Tol_achieved(0.0),
49  Has_converged(false)
50  {
51  }
52 
53  /// Empty destructor
55 
56  /// Number of iterations performed
57  unsigned& niter()
58  {
59  return Niter;
60  }
61 
62  /// Total CPU time for segregated solve
63  double& cpu_total()
64  {
65  return CPU_total;
66  }
67 
68  /// Total essential CPU time for segregated solve
69  /// (excluding any actions that merely doc the progress
70  /// of the iteration, etc.)
72  {
73  return Essential_cpu_total;
74  }
75 
76  /// CPU time for computation of global residual vectors
77  /// Note: This time is contained in Total_CPU and is
78  /// only used if convergence is based on the residual
79  /// of the fully coupled system.
81  {
83  }
84 
85  /// Final tolerance achieved by the iteration
86  double& tol_achieved()
87  {
88  return Tol_achieved;
89  }
90 
91  /// Flag to indicate if the solver has converged
92  bool has_converged() const
93  {
94  return Has_converged;
95  }
96 
97  /// Set the flag to indicate that the solver has converged
99  {
100  Has_converged = true;
101  }
102 
103  /// Set the flag to indicate that the solver has not converged
105  {
106  Has_converged = false;
107  }
108 
109  private:
110  /// Number of iterations performed
111  unsigned Niter;
112 
113  /// Total CPU time for segregated solve
114  double CPU_total;
115 
116  /// Total essential CPU time for segregated solve
117  /// (excluding any actions that merely doc the progress
118  /// of the iteration, etc.)
120 
121  /// CPU time for computation of global residual vectors
122  /// Note: This time is contained in Total_CPU and is
123  /// only used if convergence is based on the residual
124  /// of the fully coupled system
126 
127  /// Final tolerance achieved by the iteration
128  double Tol_achieved;
129 
130  /// Flag to indicate if the solver has converged
132  };
133 
134 
135  /// //////////////////////////////////////////////////////////////////
136  /// //////////////////////////////////////////////////////////////////
137  /// //////////////////////////////////////////////////////////////////
138 
139 
140  //=======================================================================
141  /// A class to handle errors in the Segregated solver
142  //=======================================================================
144  {
145  public:
146  /// Default constructor, does nothing
147  SegregatedSolverError(const std::string& error_description,
148  const std::string& function_name,
149  const char* location)
150  : OomphLibError(error_description, function_name, location)
151  {
152  }
153  };
154 
155  /// //////////////////////////////////////////////////////////////////
156  /// //////////////////////////////////////////////////////////////////
157  /// //////////////////////////////////////////////////////////////////
158 
159  //=======================================================================
160  /// A class to handle errors in the Segregated solver
161  //=======================================================================
163  {
164  public:
165  /// Default constructor, does nothing
167  const std::string& error_description,
168  const std::string& function_name,
169  const char* location)
170  : SegregatedSolverError(error_description, function_name, location)
171  {
172  }
173  };
174 
175 
176  /// //////////////////////////////////////////////////////////////////
177  /// //////////////////////////////////////////////////////////////////
178  /// //////////////////////////////////////////////////////////////////
179 
180 
181  //===============================================================
182  /// Base class for problems that can be solved by segregated
183  /// FSI solver
184  //===============================================================
185  class SegregatableFSIProblem : public virtual Problem
186  {
187  protected:
188  /// This function is called once at the start of each
189  /// segregated solve.
191 
192  /// This function is called once at the end of each
193  /// segregated solve.
195 
196  /// This function is to be filled with actions that take place
197  /// before the check for convergence of the entire segregated solve
199 
200  public:
201  /// Constructor. Set default values for solver parameters:
202  /// - Don't use pointwise Aitken extrapolation but if it's used at
203  /// all, it's used immediately.
204  /// - No under-relaxation at all (neither classical nor Irons&Tuck)
205  /// - Base convergence on max. residual of coupled system of eqns
206  /// - Convergence tolerance = tolerance for Newton solver
207  /// defined in Problem base class
208  /// - Max. 50 Picard iterations
210  {
211  // Use pointwise Aitken extrapolation?
212  Use_pointwise_aitken = false;
213 
214  // Default: No under-relaxation
215  Omega_relax = 1.0;
216 
217  // Don't use of Irons and Tuck's extrapolation for solid values
219 
220  // Start using pointwise Aitken immediately
222 
223  // By default we don't recheck convergence
225 
226  // Default solve type is full solve
228 
229  // Convergence criterion
231 
232  // Convergence tolerance (as in global Newton solver)
234 
235  // Doc max. global residual during iteration?
236  Doc_max_global_residual = false;
237 
238  // Max. number of Picard iterations
239  Max_picard = 50;
240 
241  // Pointer to Mesh containing only fluid elements -- the elements in this
242  // Mesh will be excluded from the assembly process when
243  // the solid problem is solved
244  Fluid_mesh_pt = 0;
245 
246  // Pointer to Mesh containing only solid elements -- the elements in this
247  // mesh will be excluded from the assembly process when
248  // the fluid problem is solved
249  Solid_mesh_pt = 0;
250 
251  // Initialise timer that allows doc of iteration/cpu time
252  T_ref = clock();
254 
255  /// boolean flag to indicate if timer has been halted
256  Timer_has_been_halted = false;
257  }
258 
259  /// Empty virtual destructor
261 
262  /// Identify the fluid and solid Data. This is a pure virtual
263  /// function that MUST be implemented for every specific problem that
264  /// is to be solved by the segregated solver.
265  /// The two mesh pointers identify meshes that contain
266  /// elements and nodes used during the fluid
267  /// or solid solves respectively. Elements that feature during
268  /// both phases of the segretated solution must be included in both.
269  /// These pointers may be set to NULL. In this case, all elements
270  /// in the global mesh (set up during the monolithic discretisation
271  /// of the problem) contribute to the global Jacobian matrix
272  /// and the residual vector, even if their contributions only contain
273  /// zero entries. This can be costly, though the code will
274  /// still compute the correct results.
275  virtual void identify_fluid_and_solid_dofs(Vector<Data*>& fluid_data_pt,
276  Vector<Data*>& solid_data_pt,
277  Mesh*& fluid_mesh_pt,
278  Mesh*& solid_mesh_pt) = 0;
279 
280  /// Setup the segregated solver: Backup the pinned status of
281  /// the fluid and solid dofs and allocate the internal storage
282  /// based on the input provided by identify_fluid_and_solid_dofs(...)
283  /// In addition, reset storage associated with convergence acceleration
284  /// techniques.
285  /// If the problem and degrees of freedom has not changed between
286  /// calls to the solver then it is wasteful to call
287  /// identify_fluid_and_solid_dofs(...) again and again. If the optional
288  /// boolean flag is set to false then the storage for convergence
289  /// acceleration techniques is reset, but the fluid and solid dofs
290  /// are not altered.
292  const bool& full_setup_of_fluid_and_solid_dofs = true);
293 
294  /// Segregated solver. Peform a segregated step from
295  /// the present state of the system.
296  /// Returns PicardConvergenceData object that contains the vital
297  /// stats of the iteration
299 
300  /// Steady version of segregated solver. Makes all
301  /// timesteppers steady before solving.
302  /// Returns PicardConvergenceData object that contains the
303  /// vital stats of the iteration.
305 
306 
307  /// Unsteady segregated solver, advance time by dt and solve
308  /// by the segregated solver. The time values are always shifted by
309  /// this function.
310  /// Returns PicardConvergenceData object that contains the
311  /// vital stats of the iteration.
313 
314 
315  /// Unsteady segregated solver. Advance time by dt and solve
316  /// the system by a segregated method. The boolean flag is used to
317  /// control whether the time values should be shifted. If it is true
318  /// the current data values will be shifted (stored as previous
319  /// timesteps) before the solution step.
320  /// Returns PicardConvergenceData object that contains the
321  /// vital stats of the iteration.
323  const bool& shift_values);
324 
325 
326  /// Assess convergence based on max. residual of coupled system of
327  /// eqns. The argument specifies the convergence tolerance.
329  {
331  Convergence_tolerance = tol;
332  }
333 
334  /// Assess convergence based on max. residuals of coupled
335  /// system of eqns. This interface has no argument
336  /// and the default convergence tolerance
337  /// for the Newton solver, Problem::Newton_solver_tolerance is used.
339  {
342  }
343 
344  /// Assess convergence based on max. absolute change of solid
345  /// dofs. The argument specifies the convergence tolerance.
347  {
349  Convergence_tolerance = tol;
350  }
351 
352  /// Assess convergence based on max. absolute change of solid
353  /// dofs. This interface has no argument and the default
354  /// convergence tolerance
355  /// for the Newton solver, Problem::Newton_solver_tolerance is used.
357  {
360  }
361 
362  /// Assess convergence based on max. relative change of solid
363  /// dofs. The argument specifies the convergence tolerance.
365  {
367  Convergence_tolerance = tol;
368  }
369 
370  /// Assess convergence based on max. relative change of solid
371  /// dofs. This interface has no argument and the default
372  /// convergence tolerance
373  /// for the Newton solver, Problem::Newton_solver_tolerance is used.
375  {
378  }
379 
380 
381  /// Use pointwise Aitken extrapolation. The argument is used to
382  /// specify the Picard iteration after which pointwise Aitken extrapolation
383  /// is to be used for the first time.
384  void enable_pointwise_aitken(const unsigned& pointwise_aitken_start)
385  {
386  Pointwise_aitken_start = pointwise_aitken_start;
387  Use_pointwise_aitken = true;
388  }
389 
390  /// Use pointwise Aitken extrapolation. This interface has
391  /// no argument and the current value of Pointwise_aitken_start will
392  /// be used. The default is zero, extrapolation starts immediately
394  {
395  Use_pointwise_aitken = true;
396  }
397 
398  /// Disable the use of pointwise Aitken extrapolation
400  {
401  Use_pointwise_aitken = false;
402  }
403 
404  /// Use under-relaxation and (optionally) specify under-relaxation
405  /// parameter. Default: omega=1.0 (i.e. no actual under-relaxation;
406  /// Other extreme: omega=0.0 (freeze wall shape). Under-relaxation
407  /// parameter can also be computed dynamically by setting
408  /// use_irons_and_tuck_extrapolation()
409  void enable_under_relaxation(const double& omega = 1.0)
410  {
411  Omega_relax = omega;
412  }
413 
414  /// Use Irons and Tuck extrapolation for solid dofs
416  {
418  }
419 
420  /// Do not use Irons and Tuck extrapolation for solid dofs
422  {
424  }
425 
426  /// Enumerated flags for convergence criteria
428  {
432  };
433 
434 
435  /// Enumerated flags to indicate which solve is taking place
437  {
441  };
442 
443  /// Get rms of change in the solid dofs; the max. change of the
444  /// solid dofs and the rms norm of the solid dofs themselves.
445  /// Change is computed relative to the reference values stored when
446  /// store_solid_dofs() was last called.
447  void get_solid_change(double& rms_change,
448  double& max_change,
449  double& rms_norm);
450 
451  /// Store the current solid values as reference values for
452  /// future convergence check. Also add another entry to pointwise
453  /// Aitken history if required.
454  void store_solid_dofs();
455 
456  /// Reset timer
457  void reset_timer()
458  {
460  T_ref = clock();
461  Timer_has_been_halted = false;
462  }
463 
464 
465  /// (Re-)start timer (e.g. after completing non-essential
466  /// parts of the code such as documentation of the iteration's
467  /// progress)
469  {
470  T_ref = clock();
471  Timer_has_been_halted = false;
472  }
473 
474 
475  /// Halt timer (e.g. before performing non-essential
476  /// parts of the code such as documentation of the iteration's
477  /// progress)
478  void halt_timer()
479  {
481  {
482  T_spent_on_actual_solve += double(clock() - T_ref) / CLOCKS_PER_SEC;
483  Timer_has_been_halted = true;
484  }
485  }
486 
487 
488  /// Total elapsed time since start of solve
490  {
491  halt_timer();
492  double time = T_spent_on_actual_solve;
493  restart_timer();
494  return time;
495  }
496 
497 
498  protected:
499  /// Rebuild global mesh for monolithic discretisation
501 
502  /// Number of Aitken histories available (int because after
503  /// extrapolation it's re-initialised to -1 to force the computation
504  /// of three new genuine iterates).
506 
507  /// Use pointwise Aitken extrapolation?
509 
510  /// Start pointwise Aitken extrpolation after specified number
511  /// of Picard iterations
513 
514  /// Solve that is taking place (enumerated flag)
516 
517  /// Convergence tolerance for Picard iteration
519 
520  /// Max. number of Picard iterations
521  unsigned Max_picard;
522 
523  /// Doc maximum global residual during iteration? (default: false)
525 
526  /// Restore pinned status of fluid dofs
527  void restore_fluid_dofs();
528 
529  /// Pin solid dofs
530  void pin_solid_dofs();
531 
532  /// Restore pinned status of solid dofs
533  void restore_solid_dofs();
534 
535 
536  /// Do pointwise Aitken extrapolation for solid
538 
539  /// Vector storing the Data objects associated with the fluid
540  /// problem: Tyically the nodal and internal data of the elements in the
541  /// fluid bulk mesh
543 
544  /// Vector of vectors that store the pinned status of
545  /// fluid Data values
547 
548  /// Vector storing the Data objects associated with the solid
549  /// problem: Typically the positional data of solid nodes and
550  /// any quantities associated with displacement control, say.
552 
553  /// Vector of vectors that store the pinned status of
554  /// solid Data values
556 
557  /// Vector storing the previous solid values -- used for
558  /// convergence check
560 
561  /// Mesh containing only fluid elements -- the elements in this
562  /// Mesh will be excluded from the assembly process when
563  /// the solid problem is solved
565 
566  /// Mesh containing only solid elements -- the elements in this
567  /// mesh will be excluded from the assembly process when
568  /// the fluid problem is solved
570 
571  /// Backup for the pointers to the submeshes in the original problem
573 
574  /// Vector of changes in Irons and Tuck under-relaxation
576 
577  /// Irons and Tuck relaxation factor
579 
580  /// Vector of Vectors containing up to three previous
581  /// iterates for the solid dofs; used for pointwise Aitken extrapolation
583 
584  /// Have we just done a pointwise Aitken step
586 
587  private:
588  /// Extrapolate solid data and update fluid mesh during unsteady run
589  void extrapolate_solid_data();
590 
591  /// Under-relax the most recently computed solid variables, either
592  /// by classical relaxation or by Irons & Tuck
593  void under_relax_solid();
594 
595  /// Only include fluid elements in the Problem's mesh. This is
596  /// called before the segregated fluid solve. The fluid elements are
597  /// identified by the user via the fluid_mesh_pt argument
598  /// in the pure virtual function identify_fluid_and_solid_dofs(...).
599  /// If a NULL pointer is returned by this function (i.e. if the user
600  /// hasn't bothered to identify the fluids elements in a submesh, then
601  /// no stripping of non-fluid elements is performed. The result
602  /// of the computation will be correct but
603  /// it won't be very efficient.
605 
606  /// Only include solid elements in the Problem's mesh. This is
607  /// called before the segregated solid solve. The solid elements are
608  /// identified by the user via the solid_mesh_pt argument
609  /// in the pure virtual function identify_fluid_and_solid_dofs(...).
610  /// If a NULL pointer is returned by this function (i.e. if the user
611  /// hasn't bothered to identify the solid elements in a submesh, then
612  /// no stripping of non-solid elements is performed. The result
613  /// of the computation will be correct but
614  /// it won't be very efficient.
616 
617  /// Pin fluid dofs
618  void pin_fluid_dofs();
619 
620  /// Under-relaxation parameter. (1.0: no under-relaxation;
621  /// 0.0: Freeze wall shape)
622  double Omega_relax;
623 
624  /// Boolean flag to indicate use of Irons and Tuck's extrapolation
625  /// for solid values
627 
628  /// Convergence criterion (enumerated flag)
630 
631  /// Reference time for segregated solve. Can be
632  /// re-initialised whenever total elapsed time has been stored
633  /// (before entering non-essential doc sections of the code)
634  clock_t T_ref;
635 
636  /// Total elapsed time since start of solve, can be
637  /// accumulated by adding bits of time spent in relevant parts of
638  /// code (bypassing sections that only document the progress)
640 
641  /// boolean flag to indicate if timer has been halted
643  };
644 
645 } // namespace oomph
646 
647 
648 #endif
A general mesh class.
Definition: mesh.h:67
An OomphLibError object which should be thrown when an run-time error is encountered....
Object that collates convergence data of Picard iteration.
void set_solver_converged()
Set the flag to indicate that the solver has converged.
void set_solver_not_converged()
Set the flag to indicate that the solver has not converged.
unsigned & niter()
Number of iterations performed.
double & cpu_for_global_residual()
CPU time for computation of global residual vectors Note: This time is contained in Total_CPU and is ...
double & tol_achieved()
Final tolerance achieved by the iteration.
PicardConvergenceData()
Constructor initialises all data.
~PicardConvergenceData()
Empty destructor.
bool Has_converged
Flag to indicate if the solver has converged.
bool has_converged() const
Flag to indicate if the solver has converged.
double Essential_cpu_total
Total essential CPU time for segregated solve (excluding any actions that merely doc the progress of ...
double & essential_cpu_total()
Total essential CPU time for segregated solve (excluding any actions that merely doc the progress of ...
unsigned Niter
Number of iterations performed.
double CPU_total
Total CPU time for segregated solve.
double CPU_for_global_residual
CPU time for computation of global residual vectors Note: This time is contained in Total_CPU and is ...
double & cpu_total()
Total CPU time for segregated solve.
double Tol_achieved
Final tolerance achieved by the iteration.
////////////////////////////////////////////////////////////////// //////////////////////////////////...
Definition: problem.h:154
double Newton_solver_tolerance
The Tolerance below which the Newton Method is deemed to have converged.
Definition: problem.h:599
double & time()
Return the current value of continuous time.
Definition: problem.cc:11594
////////////////////////////////////////////////////////////////// //////////////////////////////////...
RanOutOfIterationsInSegregatedSolverError(const std::string &error_description, const std::string &function_name, const char *location)
Default constructor, does nothing.
////////////////////////////////////////////////////////////////// //////////////////////////////////...
convergence_criteria
Enumerated flags for convergence criteria.
void enable_pointwise_aitken(const unsigned &pointwise_aitken_start)
Use pointwise Aitken extrapolation. The argument is used to specify the Picard iteration after which ...
void enable_irons_and_tuck_extrapolation()
Use Irons and Tuck extrapolation for solid dofs.
bool Recheck_convergence_after_pointwise_aitken
Have we just done a pointwise Aitken step.
void extrapolate_solid_data()
Extrapolate solid data and update fluid mesh during unsteady run.
Vector< std::vector< bool > > Solid_value_is_pinned
Vector of vectors that store the pinned status of solid Data values.
void setup_segregated_solver(const bool &full_setup_of_fluid_and_solid_dofs=true)
Setup the segregated solver: Backup the pinned status of the fluid and solid dofs and allocate the in...
void use_only_fluid_elements()
Only include fluid elements in the Problem's mesh. This is called before the segregated fluid solve....
Vector< Mesh * > Orig_sub_mesh_pt
Backup for the pointers to the submeshes in the original problem.
bool Use_pointwise_aitken
Use pointwise Aitken extrapolation?
Vector< Data * > Fluid_data_pt
Vector storing the Data objects associated with the fluid problem: Tyically the nodal and internal da...
bool Use_irons_and_tuck_extrapolation
Boolean flag to indicate use of Irons and Tuck's extrapolation for solid values.
solve_type
Enumerated flags to indicate which solve is taking place.
virtual void actions_after_segregated_solve()
This function is called once at the end of each segregated solve.
void restart_timer()
(Re-)start timer (e.g. after completing non-essential parts of the code such as documentation of the ...
void assess_convergence_based_on_max_global_residual()
Assess convergence based on max. residuals of coupled system of eqns. This interface has no argument ...
void use_only_solid_elements()
Only include solid elements in the Problem's mesh. This is called before the segregated solid solve....
void disable_pointwise_aitken()
Disable the use of pointwise Aitken extrapolation.
Mesh * Solid_mesh_pt
Mesh containing only solid elements – the elements in this mesh will be excluded from the assembly pr...
void enable_pointwise_aitken()
Use pointwise Aitken extrapolation. This interface has no argument and the current value of Pointwise...
unsigned Pointwise_aitken_start
Start pointwise Aitken extrpolation after specified number of Picard iterations.
void rebuild_monolithic_mesh()
Rebuild global mesh for monolithic discretisation.
void halt_timer()
Halt timer (e.g. before performing non-essential parts of the code such as documentation of the itera...
virtual void identify_fluid_and_solid_dofs(Vector< Data * > &fluid_data_pt, Vector< Data * > &solid_data_pt, Mesh *&fluid_mesh_pt, Mesh *&solid_mesh_pt)=0
Identify the fluid and solid Data. This is a pure virtual function that MUST be implemented for every...
void restore_solid_dofs()
Restore pinned status of solid dofs.
Vector< double > Previous_solid_value
Vector storing the previous solid values – used for convergence check.
double R_irons_and_tuck
Irons and Tuck relaxation factor.
void enable_under_relaxation(const double &omega=1.0)
Use under-relaxation and (optionally) specify under-relaxation parameter. Default: omega=1....
void disable_irons_and_tuck_extrapolation()
Do not use Irons and Tuck extrapolation for solid dofs.
double T_spent_on_actual_solve
Total elapsed time since start of solve, can be accumulated by adding bits of time spent in relevant ...
clock_t T_ref
Reference time for segregated solve. Can be re-initialised whenever total elapsed time has been store...
PicardConvergenceData segregated_solve()
Segregated solver. Peform a segregated step from the present state of the system. Returns PicardConve...
void assess_convergence_based_on_max_global_residual(const double &tol)
Assess convergence based on max. residual of coupled system of eqns. The argument specifies the conve...
Vector< double > Del_irons_and_tuck
Vector of changes in Irons and Tuck under-relaxation.
PicardConvergenceData steady_segregated_solve()
Steady version of segregated solver. Makes all timesteppers steady before solving....
int Convergence_criterion
Convergence criterion (enumerated flag)
void pointwise_aitken_extrapolate()
Do pointwise Aitken extrapolation for solid.
void under_relax_solid()
Under-relax the most recently computed solid variables, either by classical relaxation or by Irons & ...
void assess_convergence_based_on_absolute_solid_change(const double &tol)
Assess convergence based on max. absolute change of solid dofs. The argument specifies the convergenc...
Vector< Vector< double > > Pointwise_aitken_solid_value
Vector of Vectors containing up to three previous iterates for the solid dofs; used for pointwise Ait...
unsigned Max_picard
Max. number of Picard iterations.
Vector< std::vector< bool > > Fluid_value_is_pinned
Vector of vectors that store the pinned status of fluid Data values.
virtual ~SegregatableFSIProblem()
Empty virtual destructor.
SegregatableFSIProblem()
Constructor. Set default values for solver parameters:
bool Doc_max_global_residual
Doc maximum global residual during iteration? (default: false)
PicardConvergenceData unsteady_segregated_solve(const double &dt)
Unsteady segregated solver, advance time by dt and solve by the segregated solver....
bool Timer_has_been_halted
boolean flag to indicate if timer has been halted
void restore_fluid_dofs()
Restore pinned status of fluid dofs.
virtual void actions_before_segregated_convergence_check()
This function is to be filled with actions that take place before the check for convergence of the en...
void assess_convergence_based_on_relative_solid_change(const double &tol)
Assess convergence based on max. relative change of solid dofs. The argument specifies the convergenc...
Vector< Data * > Solid_data_pt
Vector storing the Data objects associated with the solid problem: Typically the positional data of s...
void get_solid_change(double &rms_change, double &max_change, double &rms_norm)
Get rms of change in the solid dofs; the max. change of the solid dofs and the rms norm of the solid ...
int Pointwise_aitken_counter
Number of Aitken histories available (int because after extrapolation it's re-initialised to -1 to fo...
double Convergence_tolerance
Convergence tolerance for Picard iteration.
Mesh * Fluid_mesh_pt
Mesh containing only fluid elements – the elements in this Mesh will be excluded from the assembly pr...
double t_spent_on_actual_solve()
Total elapsed time since start of solve.
double Omega_relax
Under-relaxation parameter. (1.0: no under-relaxation; 0.0: Freeze wall shape)
void assess_convergence_based_on_absolute_solid_change()
Assess convergence based on max. absolute change of solid dofs. This interface has no argument and th...
virtual void actions_before_segregated_solve()
This function is called once at the start of each segregated solve.
int Solve_type
Solve that is taking place (enumerated flag)
void store_solid_dofs()
Store the current solid values as reference values for future convergence check. Also add another ent...
void assess_convergence_based_on_relative_solid_change()
Assess convergence based on max. relative change of solid dofs. This interface has no argument and th...
////////////////////////////////////////////////////////////////// //////////////////////////////////...
SegregatedSolverError(const std::string &error_description, const std::string &function_name, const char *location)
Default constructor, does nothing.
A slight extension to the standard template vector class so that we can include "graceful" array rang...
Definition: Vector.h:58
std::string string(const unsigned &i)
Return the i-th string or "" if the relevant string hasn't been defined.
//////////////////////////////////////////////////////////////////// ////////////////////////////////...