////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////// More...

#include <segregated_fsi_solver.h>

Inheritance diagram for oomph::SegregatableFSIProblem:

Public Types
enum	convergence_criteria { Assess_convergence_based_on_absolute_solid_change , Assess_convergence_based_on_relative_solid_change , Assess_convergence_based_on_max_global_residual }
	Enumerated flags for convergence criteria. More...

enum	solve_type { Full_solve , Fluid_solve , Solid_solve }
	Enumerated flags to indicate which solve is taking place. More...

Public Member Functions
	SegregatableFSIProblem ()
	Constructor. Set default values for solver parameters: More...

virtual	~SegregatableFSIProblem ()
	Empty virtual destructor. More...

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 specific problem that is to be solved by the segregated solver. The two mesh pointers identify meshes that contain elements and nodes used during the fluid or solid solves respectively. Elements that feature during both phases of the segretated solution must be included in both. These pointers may be set to NULL. In this case, all elements in the global mesh (set up during the monolithic discretisation of the problem) contribute to the global Jacobian matrix and the residual vector, even if their contributions only contain zero entries. This can be costly, though the code will still compute the correct results. More...

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 internal storage based on the input provided by identify_fluid_and_solid_dofs(...) In addition, reset storage associated with convergence acceleration techniques. If the problem and degrees of freedom has not changed between calls to the solver then it is wasteful to call identify_fluid_and_solid_dofs(...) again and again. If the optional boolean flag is set to false then the storage for convergence acceleration techniques is reset, but the fluid and solid dofs are not altered. More...

PicardConvergenceData	segregated_solve ()
	Segregated solver. Peform a segregated step from the present state of the system. Returns PicardConvergenceData object that contains the vital stats of the iteration. More...

PicardConvergenceData	steady_segregated_solve ()
	Steady version of segregated solver. Makes all timesteppers steady before solving. Returns PicardConvergenceData object that contains the vital stats of the iteration. More...

PicardConvergenceData	unsteady_segregated_solve (const double &dt)
	Unsteady segregated solver, advance time by dt and solve by the segregated solver. The time values are always shifted by this function. Returns PicardConvergenceData object that contains the vital stats of the iteration. More...

PicardConvergenceData	unsteady_segregated_solve (const double &dt, const bool &shift_values)
	Unsteady segregated solver. Advance time by dt and solve the system by a segregated method. The boolean flag is used to control whether the time values should be shifted. If it is true the current data values will be shifted (stored as previous timesteps) before the solution step. Returns PicardConvergenceData object that contains the vital stats of the iteration. More...

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 convergence tolerance. More...

void	assess_convergence_based_on_max_global_residual ()
	Assess convergence based on max. residuals of coupled system of eqns. This interface has no argument and the default convergence tolerance for the Newton solver, Problem::Newton_solver_tolerance is used. More...

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 convergence tolerance. More...

void	assess_convergence_based_on_absolute_solid_change ()
	Assess convergence based on max. absolute change of solid dofs. This interface has no argument and the default convergence tolerance for the Newton solver, Problem::Newton_solver_tolerance is used. More...

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 convergence tolerance. More...

void	assess_convergence_based_on_relative_solid_change ()
	Assess convergence based on max. relative change of solid dofs. This interface has no argument and the default convergence tolerance for the Newton solver, Problem::Newton_solver_tolerance is used. More...

void	enable_pointwise_aitken (const unsigned &pointwise_aitken_start)
	Use pointwise Aitken extrapolation. The argument is used to specify the Picard iteration after which pointwise Aitken extrapolation is to be used for the first time. More...

void	enable_pointwise_aitken ()
	Use pointwise Aitken extrapolation. This interface has no argument and the current value of Pointwise_aitken_start will be used. The default is zero, extrapolation starts immediately. More...

void	disable_pointwise_aitken ()
	Disable the use of pointwise Aitken extrapolation. More...

void	enable_under_relaxation (const double &omega=1.0)
	Use under-relaxation and (optionally) specify under-relaxation parameter. Default: omega=1.0 (i.e. no actual under-relaxation; Other extreme: omega=0.0 (freeze wall shape). Under-relaxation parameter can also be computed dynamically by setting use_irons_and_tuck_extrapolation() More...

void	enable_irons_and_tuck_extrapolation ()
	Use Irons and Tuck extrapolation for solid dofs. More...

void	disable_irons_and_tuck_extrapolation ()
	Do not use Irons and Tuck extrapolation for solid dofs. More...

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 dofs themselves. Change is computed relative to the reference values stored when store_solid_dofs() was last called. More...

void	store_solid_dofs ()
	Store the current solid values as reference values for future convergence check. Also add another entry to pointwise Aitken history if required. More...

void	reset_timer ()
	Reset timer. More...

void	restart_timer ()
	(Re-)start timer (e.g. after completing non-essential parts of the code such as documentation of the iteration's progress) More...

void	halt_timer ()
	Halt timer (e.g. before performing non-essential parts of the code such as documentation of the iteration's progress) More...

double	t_spent_on_actual_solve ()
	Total elapsed time since start of solve. More...

Protected Member Functions
virtual void	actions_before_segregated_solve ()
	This function is called once at the start of each segregated solve. More...

virtual void	actions_after_segregated_solve ()
	This function is called once at the end of each segregated solve. More...

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 entire segregated solve. More...

void	rebuild_monolithic_mesh ()
	Rebuild global mesh for monolithic discretisation. More...

void	restore_fluid_dofs ()
	Restore pinned status of fluid dofs. More...

void	pin_solid_dofs ()
	Pin solid dofs. More...

void	restore_solid_dofs ()
	Restore pinned status of solid dofs. More...

void	pointwise_aitken_extrapolate ()
	Do pointwise Aitken extrapolation for solid. More...

Protected Attributes
int	Pointwise_aitken_counter
	Number of Aitken histories available (int because after extrapolation it's re-initialised to -1 to force the computation of three new genuine iterates). More...

bool	Use_pointwise_aitken
	Use pointwise Aitken extrapolation? More...

unsigned	Pointwise_aitken_start
	Start pointwise Aitken extrpolation after specified number of Picard iterations. More...

int	Solve_type
	Solve that is taking place (enumerated flag) More...

double	Convergence_tolerance
	Convergence tolerance for Picard iteration. More...

unsigned	Max_picard
	Max. number of Picard iterations. More...

bool	Doc_max_global_residual
	Doc maximum global residual during iteration? (default: false) More...

Vector< Data * >	Fluid_data_pt
	Vector storing the Data objects associated with the fluid problem: Tyically the nodal and internal data of the elements in the fluid bulk mesh. More...

Vector< std::vector< bool > >	Fluid_value_is_pinned
	Vector of vectors that store the pinned status of fluid Data values. More...

Vector< Data * >	Solid_data_pt
	Vector storing the Data objects associated with the solid problem: Typically the positional data of solid nodes and any quantities associated with displacement control, say. More...

Vector< std::vector< bool > >	Solid_value_is_pinned
	Vector of vectors that store the pinned status of solid Data values. More...

Vector< double >	Previous_solid_value
	Vector storing the previous solid values – used for convergence check. More...

Mesh *	Fluid_mesh_pt
	Mesh containing only fluid elements – the elements in this Mesh will be excluded from the assembly process when the solid problem is solved. More...

Mesh *	Solid_mesh_pt
	Mesh containing only solid elements – the elements in this mesh will be excluded from the assembly process when the fluid problem is solved. More...

Vector< Mesh * >	Orig_sub_mesh_pt
	Backup for the pointers to the submeshes in the original problem. More...

Vector< double >	Del_irons_and_tuck
	Vector of changes in Irons and Tuck under-relaxation. More...

double	R_irons_and_tuck
	Irons and Tuck relaxation factor. More...

Vector< Vector< double > >	Pointwise_aitken_solid_value
	Vector of Vectors containing up to three previous iterates for the solid dofs; used for pointwise Aitken extrapolation. More...

bool	Recheck_convergence_after_pointwise_aitken
	Have we just done a pointwise Aitken step. More...

Private Member Functions
void	extrapolate_solid_data ()
	Extrapolate solid data and update fluid mesh during unsteady run. More...

void	under_relax_solid ()
	Under-relax the most recently computed solid variables, either by classical relaxation or by Irons & Tuck. More...

void	use_only_fluid_elements ()
	Only include fluid elements in the Problem's mesh. This is called before the segregated fluid solve. The fluid elements are identified by the user via the fluid_mesh_pt argument in the pure virtual function identify_fluid_and_solid_dofs(...). If a NULL pointer is returned by this function (i.e. if the user hasn't bothered to identify the fluids elements in a submesh, then no stripping of non-fluid elements is performed. The result of the computation will be correct but it won't be very efficient. More...

void	use_only_solid_elements ()
	Only include solid elements in the Problem's mesh. This is called before the segregated solid solve. The solid elements are identified by the user via the solid_mesh_pt argument in the pure virtual function identify_fluid_and_solid_dofs(...). If a NULL pointer is returned by this function (i.e. if the user hasn't bothered to identify the solid elements in a submesh, then no stripping of non-solid elements is performed. The result of the computation will be correct but it won't be very efficient. More...

void	pin_fluid_dofs ()
	Pin fluid dofs. More...

Private Attributes
double	Omega_relax
	Under-relaxation parameter. (1.0: no under-relaxation; 0.0: Freeze wall shape) More...

bool	Use_irons_and_tuck_extrapolation
	Boolean flag to indicate use of Irons and Tuck's extrapolation for solid values. More...

int	Convergence_criterion
	Convergence criterion (enumerated flag) More...

clock_t	T_ref
	Reference time for segregated solve. Can be re-initialised whenever total elapsed time has been stored (before entering non-essential doc sections of the code) More...

double	T_spent_on_actual_solve
	Total elapsed time since start of solve, can be accumulated by adding bits of time spent in relevant parts of code (bypassing sections that only document the progress) More...

bool	Timer_has_been_halted
	boolean flag to indicate if timer has been halted More...

Detailed Description

////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////

Base class for problems that can be solved by segregated FSI solver

Definition at line 185 of file segregated_fsi_solver.h.

Member Enumeration Documentation

◆ convergence_criteria

enum oomph::SegregatableFSIProblem::convergence_criteria

Enumerated flags for convergence criteria.

Enumerator
Assess_convergence_based_on_absolute_solid_change
Assess_convergence_based_on_relative_solid_change
Assess_convergence_based_on_max_global_residual

Definition at line 427 of file segregated_fsi_solver.h.

◆ solve_type

enum oomph::SegregatableFSIProblem::solve_type

Enumerated flags to indicate which solve is taking place.

Enumerator
Full_solve
Fluid_solve
Solid_solve

Definition at line 436 of file segregated_fsi_solver.h.

Constructor & Destructor Documentation

◆ SegregatableFSIProblem()

oomph::SegregatableFSIProblem::SegregatableFSIProblem ( )

inline

Constructor. Set default values for solver parameters:

Don't use pointwise Aitken extrapolation but if it's used at all, it's used immediately.
No under-relaxation at all (neither classical nor Irons&Tuck)
Base convergence on max. residual of coupled system of eqns
Convergence tolerance = tolerance for Newton solver defined in Problem base class
Max. 50 Picard iterations

boolean flag to indicate if timer has been halted

Definition at line 209 of file segregated_fsi_solver.h.

References Assess_convergence_based_on_max_global_residual, Convergence_criterion, Convergence_tolerance, Doc_max_global_residual, Fluid_mesh_pt, Full_solve, Max_picard, Omega_relax, Pointwise_aitken_start, Recheck_convergence_after_pointwise_aitken, Solid_mesh_pt, Solve_type, T_ref, T_spent_on_actual_solve, Timer_has_been_halted, Use_irons_and_tuck_extrapolation, and Use_pointwise_aitken.

◆ ~SegregatableFSIProblem()

virtual oomph::SegregatableFSIProblem::~SegregatableFSIProblem ( )

inlinevirtual

Empty virtual destructor.

Definition at line 260 of file segregated_fsi_solver.h.

Member Function Documentation

◆ actions_after_segregated_solve()

virtual void oomph::SegregatableFSIProblem::actions_after_segregated_solve ( )

inlineprotectedvirtual

This function is called once at the end of each segregated solve.

Definition at line 194 of file segregated_fsi_solver.h.

Referenced by segregated_solve().

◆ actions_before_segregated_convergence_check()

virtual void oomph::SegregatableFSIProblem::actions_before_segregated_convergence_check ( )

inlineprotectedvirtual

This function is to be filled with actions that take place before the check for convergence of the entire segregated solve.

Definition at line 198 of file segregated_fsi_solver.h.

Referenced by segregated_solve().

◆ actions_before_segregated_solve()

virtual void oomph::SegregatableFSIProblem::actions_before_segregated_solve ( )

inlineprotectedvirtual

This function is called once at the start of each segregated solve.

Definition at line 190 of file segregated_fsi_solver.h.

Referenced by segregated_solve().

◆ assess_convergence_based_on_absolute_solid_change() [1/2]

void oomph::SegregatableFSIProblem::assess_convergence_based_on_absolute_solid_change ( )

inline

Assess convergence based on max. absolute change of solid dofs. This interface has no argument and the default convergence tolerance for the Newton solver, Problem::Newton_solver_tolerance is used.

Definition at line 356 of file segregated_fsi_solver.h.

◆ assess_convergence_based_on_absolute_solid_change() [2/2]

void oomph::SegregatableFSIProblem::assess_convergence_based_on_absolute_solid_change ( const double & tol )

inline

Assess convergence based on max. absolute change of solid dofs. The argument specifies the convergence tolerance.

Definition at line 346 of file segregated_fsi_solver.h.

References Assess_convergence_based_on_absolute_solid_change, Convergence_criterion, and Convergence_tolerance.

◆ assess_convergence_based_on_max_global_residual() [1/2]

void oomph::SegregatableFSIProblem::assess_convergence_based_on_max_global_residual ( )

inline

Assess convergence based on max. residuals of coupled system of eqns. This interface has no argument and the default convergence tolerance for the Newton solver, Problem::Newton_solver_tolerance is used.

Definition at line 338 of file segregated_fsi_solver.h.

◆ assess_convergence_based_on_max_global_residual() [2/2]

void oomph::SegregatableFSIProblem::assess_convergence_based_on_max_global_residual ( const double & tol )

inline

Assess convergence based on max. residual of coupled system of eqns. The argument specifies the convergence tolerance.

Definition at line 328 of file segregated_fsi_solver.h.

References Assess_convergence_based_on_max_global_residual, Convergence_criterion, and Convergence_tolerance.

◆ assess_convergence_based_on_relative_solid_change() [1/2]

void oomph::SegregatableFSIProblem::assess_convergence_based_on_relative_solid_change ( )

inline

Assess convergence based on max. relative change of solid dofs. This interface has no argument and the default convergence tolerance for the Newton solver, Problem::Newton_solver_tolerance is used.

Definition at line 374 of file segregated_fsi_solver.h.

◆ assess_convergence_based_on_relative_solid_change() [2/2]

void oomph::SegregatableFSIProblem::assess_convergence_based_on_relative_solid_change ( const double & tol )

inline

Assess convergence based on max. relative change of solid dofs. The argument specifies the convergence tolerance.

Definition at line 364 of file segregated_fsi_solver.h.

References Assess_convergence_based_on_relative_solid_change, Convergence_criterion, and Convergence_tolerance.

◆ disable_irons_and_tuck_extrapolation()

void oomph::SegregatableFSIProblem::disable_irons_and_tuck_extrapolation ( )

inline

Do not use Irons and Tuck extrapolation for solid dofs.

Definition at line 421 of file segregated_fsi_solver.h.

References Use_irons_and_tuck_extrapolation.

◆ disable_pointwise_aitken()

void oomph::SegregatableFSIProblem::disable_pointwise_aitken ( )

inline

Disable the use of pointwise Aitken extrapolation.

Definition at line 399 of file segregated_fsi_solver.h.

References Use_pointwise_aitken.

◆ enable_irons_and_tuck_extrapolation()

void oomph::SegregatableFSIProblem::enable_irons_and_tuck_extrapolation ( )

inline

Use Irons and Tuck extrapolation for solid dofs.

Definition at line 415 of file segregated_fsi_solver.h.

References Use_irons_and_tuck_extrapolation.

◆ enable_pointwise_aitken() [1/2]

void oomph::SegregatableFSIProblem::enable_pointwise_aitken ( )

inline

Use pointwise Aitken extrapolation. This interface has no argument and the current value of Pointwise_aitken_start will be used. The default is zero, extrapolation starts immediately.

Definition at line 393 of file segregated_fsi_solver.h.

References Use_pointwise_aitken.

◆ enable_pointwise_aitken() [2/2]

void oomph::SegregatableFSIProblem::enable_pointwise_aitken ( const unsigned & pointwise_aitken_start )

inline

Use pointwise Aitken extrapolation. The argument is used to specify the Picard iteration after which pointwise Aitken extrapolation is to be used for the first time.

Definition at line 384 of file segregated_fsi_solver.h.

References Pointwise_aitken_start, and Use_pointwise_aitken.

◆ enable_under_relaxation()

void oomph::SegregatableFSIProblem::enable_under_relaxation ( const double & omega = 1.0 )

inline

Use under-relaxation and (optionally) specify under-relaxation parameter. Default: omega=1.0 (i.e. no actual under-relaxation; Other extreme: omega=0.0 (freeze wall shape). Under-relaxation parameter can also be computed dynamically by setting use_irons_and_tuck_extrapolation()

Definition at line 409 of file segregated_fsi_solver.h.

References Omega_relax.

◆ extrapolate_solid_data()

void oomph::SegregatableFSIProblem::extrapolate_solid_data ( )

private

Extrapolate solid data and update fluid mesh during unsteady run.

Extrapolate solid data and update fluid mesh. Extrapolation is based on previous history values and is therefore only called in time-dependent runs.

Definition at line 39 of file segregated_fsi_solver.cc.

References Fluid_mesh_pt, and Solid_data_pt.

Referenced by unsteady_segregated_solve().

◆ get_solid_change()

void oomph::SegregatableFSIProblem::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 dofs themselves. Change is computed relative to the reference values stored when store_solid_dofs() was last called.

Definition at line 303 of file segregated_fsi_solver.cc.

References Previous_solid_value, and Solid_data_pt.

Referenced by segregated_solve().

◆ halt_timer()

void oomph::SegregatableFSIProblem::halt_timer ( )

inline

Halt timer (e.g. before performing non-essential parts of the code such as documentation of the iteration's progress)

Definition at line 478 of file segregated_fsi_solver.h.

References T_ref, T_spent_on_actual_solve, and Timer_has_been_halted.

Referenced by t_spent_on_actual_solve().

◆ identify_fluid_and_solid_dofs()

virtual void oomph::SegregatableFSIProblem::identify_fluid_and_solid_dofs	(	Vector< Data * > &	fluid_data_pt,
		Vector< Data * > &	solid_data_pt,
		Mesh *&	fluid_mesh_pt,
		Mesh *&	solid_mesh_pt
	)

pure virtual

Identify the fluid and solid Data. This is a pure virtual function that MUST be implemented for every specific problem that is to be solved by the segregated solver. The two mesh pointers identify meshes that contain elements and nodes used during the fluid or solid solves respectively. Elements that feature during both phases of the segretated solution must be included in both. These pointers may be set to NULL. In this case, all elements in the global mesh (set up during the monolithic discretisation of the problem) contribute to the global Jacobian matrix and the residual vector, even if their contributions only contain zero entries. This can be costly, though the code will still compute the correct results.

Referenced by setup_segregated_solver().

◆ pin_fluid_dofs()

void oomph::SegregatableFSIProblem::pin_fluid_dofs ( )

private

Pin fluid dofs.

Pin all fluid dofs.

Definition at line 153 of file segregated_fsi_solver.cc.

References Fluid_data_pt.

Referenced by segregated_solve().

◆ pin_solid_dofs()

void oomph::SegregatableFSIProblem::pin_solid_dofs ( )

protected

Pin solid dofs.

Pin all solid dofs.

Definition at line 206 of file segregated_fsi_solver.cc.

References Solid_data_pt.

Referenced by segregated_solve().

◆ pointwise_aitken_extrapolate()

void oomph::SegregatableFSIProblem::pointwise_aitken_extrapolate ( )

protected

Do pointwise Aitken extrapolation for solid.

Pointwise Aitken extrapolation for solid variables.

Definition at line 490 of file segregated_fsi_solver.cc.

References Pointwise_aitken_counter, Pointwise_aitken_solid_value, and Solid_data_pt.

Referenced by segregated_solve().

◆ rebuild_monolithic_mesh()

void oomph::SegregatableFSIProblem::rebuild_monolithic_mesh ( )

protected

Rebuild global mesh for monolithic discretisation.

Rebuild global mesh for monolithic problem.

Definition at line 87 of file segregated_fsi_solver.cc.

References Orig_sub_mesh_pt.

Referenced by segregated_solve().

◆ reset_timer()

void oomph::SegregatableFSIProblem::reset_timer ( )

inline

Reset timer.

Definition at line 457 of file segregated_fsi_solver.h.

References T_ref, T_spent_on_actual_solve, and Timer_has_been_halted.

Referenced by segregated_solve().

◆ restart_timer()

void oomph::SegregatableFSIProblem::restart_timer ( )

inline

(Re-)start timer (e.g. after completing non-essential parts of the code such as documentation of the iteration's progress)

Definition at line 468 of file segregated_fsi_solver.h.

References T_ref, and Timer_has_been_halted.

Referenced by t_spent_on_actual_solve().

◆ restore_fluid_dofs()

void oomph::SegregatableFSIProblem::restore_fluid_dofs ( )

protected

Restore pinned status of fluid dofs.

Restore the pinned status of all fluid dofs.

Definition at line 176 of file segregated_fsi_solver.cc.

References Fluid_data_pt, and Fluid_value_is_pinned.

Referenced by segregated_solve().

◆ restore_solid_dofs()

void oomph::SegregatableFSIProblem::restore_solid_dofs ( )

protected

Restore pinned status of solid dofs.

Restore the pinned status of all solid dofs.

Definition at line 229 of file segregated_fsi_solver.cc.

References Solid_data_pt, and Solid_value_is_pinned.

Referenced by segregated_solve().

◆ segregated_solve()

PicardConvergenceData oomph::SegregatableFSIProblem::segregated_solve ( )

Segregated solver. Peform a segregated step from the present state of the system. Returns PicardConvergenceData object that contains the vital stats of the iteration.

Segregated fixed point solver with optional pointwise Aitken acceleration on selected solid dofs. Returns PicardConvergenceData object that contains the vital stats of the iteration.

Definition at line 538 of file segregated_fsi_solver.cc.

References actions_after_segregated_solve(), actions_before_segregated_convergence_check(), actions_before_segregated_solve(), Assess_convergence_based_on_absolute_solid_change, Assess_convergence_based_on_max_global_residual, Assess_convergence_based_on_relative_solid_change, Convergence_criterion, Convergence_tolerance, oomph::PicardConvergenceData::cpu_for_global_residual(), oomph::PicardConvergenceData::cpu_total(), Doc_max_global_residual, oomph::PicardConvergenceData::essential_cpu_total(), Fluid_solve, Full_solve, get_solid_change(), Max_picard, oomph::PicardConvergenceData::niter(), pin_fluid_dofs(), pin_solid_dofs(), Pointwise_aitken_counter, pointwise_aitken_extrapolate(), Pointwise_aitken_start, rebuild_monolithic_mesh(), Recheck_convergence_after_pointwise_aitken, reset_timer(), restore_fluid_dofs(), restore_solid_dofs(), oomph::PicardConvergenceData::set_solver_converged(), Solid_solve, Solve_type, store_solid_dofs(), t_spent_on_actual_solve(), oomph::PicardConvergenceData::tol_achieved(), under_relax_solid(), use_only_fluid_elements(), use_only_solid_elements(), and Use_pointwise_aitken.

Referenced by steady_segregated_solve(), and unsteady_segregated_solve().

◆ setup_segregated_solver()

void oomph::SegregatableFSIProblem::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 internal storage based on the input provided by identify_fluid_and_solid_dofs(...) In addition, reset storage associated with convergence acceleration techniques. If the problem and degrees of freedom has not changed between calls to the solver then it is wasteful to call identify_fluid_and_solid_dofs(...) again and again. If the optional boolean flag is set to false then the storage for convergence acceleration techniques is reset, but the fluid and solid dofs are not altered.

Setup segregated solver, using the information provided by the user in his/her implementation of the pure virtual function identify_fluid_and_solid_dofs(...).

Definition at line 1111 of file segregated_fsi_solver.cc.

References Del_irons_and_tuck, Fluid_data_pt, Fluid_mesh_pt, Fluid_value_is_pinned, identify_fluid_and_solid_dofs(), Omega_relax, Orig_sub_mesh_pt, Pointwise_aitken_counter, Pointwise_aitken_solid_value, Previous_solid_value, R_irons_and_tuck, Solid_data_pt, Solid_mesh_pt, Solid_value_is_pinned, Use_irons_and_tuck_extrapolation, and Use_pointwise_aitken.

◆ steady_segregated_solve()

PicardConvergenceData oomph::SegregatableFSIProblem::steady_segregated_solve ( )

Steady version of segregated solver. Makes all timesteppers steady before solving. Returns PicardConvergenceData object that contains the vital stats of the iteration.

Segregated fixed point solver with optional pointwise Aitken acceleration on selected solid dofs. Returns PicardConvergenceData object that contains the vital stats of the iteration.

Definition at line 982 of file segregated_fsi_solver.cc.

References segregated_solve().

◆ store_solid_dofs()

void oomph::SegregatableFSIProblem::store_solid_dofs ( )

Store the current solid values as reference values for future convergence check. Also add another entry to pointwise Aitken history if required.

Store the current solid values as reference values for future convergence check. Also add another entry to pointwise Aitken history.

Definition at line 260 of file segregated_fsi_solver.cc.

References Pointwise_aitken_counter, Pointwise_aitken_solid_value, Previous_solid_value, Solid_data_pt, and Use_pointwise_aitken.

Referenced by segregated_solve().

◆ t_spent_on_actual_solve()

double oomph::SegregatableFSIProblem::t_spent_on_actual_solve ( )

inline

Total elapsed time since start of solve.

Definition at line 489 of file segregated_fsi_solver.h.

References halt_timer(), restart_timer(), and T_spent_on_actual_solve.

Referenced by segregated_solve().

◆ under_relax_solid()

void oomph::SegregatableFSIProblem::under_relax_solid ( )

private

Under-relax the most recently computed solid variables, either by classical relaxation or by Irons & Tuck.

Under-relax solid, either by classical relaxation or by Irons & Tuck.

Definition at line 354 of file segregated_fsi_solver.cc.

References Del_irons_and_tuck, Omega_relax, Previous_solid_value, R_irons_and_tuck, Solid_data_pt, and Use_irons_and_tuck_extrapolation.

Referenced by segregated_solve().

◆ unsteady_segregated_solve() [1/2]

PicardConvergenceData oomph::SegregatableFSIProblem::unsteady_segregated_solve ( const double & dt )

Unsteady segregated solver, advance time by dt and solve by the segregated solver. The time values are always shifted by this function. Returns PicardConvergenceData object that contains the vital stats of the iteration.

Segregated fixed point solver with optional pointwise Aitken acceleration on selected solid dofs. Returns PicardConvergenceData object that contains the vital stats of the iteration.

Definition at line 1042 of file segregated_fsi_solver.cc.

◆ unsteady_segregated_solve() [2/2]

PicardConvergenceData oomph::SegregatableFSIProblem::unsteady_segregated_solve	(	const double &	dt,
		const bool &	shift_values
	)

Unsteady segregated solver. Advance time by dt and solve the system by a segregated method. The boolean flag is used to control whether the time values should be shifted. If it is true the current data values will be shifted (stored as previous timesteps) before the solution step. Returns PicardConvergenceData object that contains the vital stats of the iteration.

Segregated fixed point solver with optional pointwise Aitken acceleration on selected solid dofs. Returns PicardConvergenceData object that contains the vital stats of the iteration.

Definition at line 1054 of file segregated_fsi_solver.cc.

References extrapolate_solid_data(), and segregated_solve().

◆ use_only_fluid_elements()

void oomph::SegregatableFSIProblem::use_only_fluid_elements ( )

private

Only include fluid elements in the Problem's mesh. This is called before the segregated fluid solve. The fluid elements are identified by the user via the fluid_mesh_pt argument in the pure virtual function identify_fluid_and_solid_dofs(...). If a NULL pointer is returned by this function (i.e. if the user hasn't bothered to identify the fluids elements in a submesh, then no stripping of non-fluid elements is performed. The result of the computation will be correct but it won't be very efficient.

Definition at line 138 of file segregated_fsi_solver.cc.

References Fluid_mesh_pt.

Referenced by segregated_solve().

◆ use_only_solid_elements()

void oomph::SegregatableFSIProblem::use_only_solid_elements ( )

private

Only include solid elements in the Problem's mesh. This is called before the segregated solid solve. The solid elements are identified by the user via the solid_mesh_pt argument in the pure virtual function identify_fluid_and_solid_dofs(...). If a NULL pointer is returned by this function (i.e. if the user hasn't bothered to identify the solid elements in a submesh, then no stripping of non-solid elements is performed. The result of the computation will be correct but it won't be very efficient.

Only include solid elements in the Problem's mesh. This is called before the segregated solid solve. The solid elements are identified by the user via the solid_mesh_pt argument in the pure virtual function identify_fluid_and_solid_dofs(...). If a NULL pointer is returned by this function (i.e. if the user hasn't bothered to identify the solids elements in a submesh, then no stripping of non-solid elements is performed. The result of the computation will be correct but it won't be very efficient.

Definition at line 115 of file segregated_fsi_solver.cc.

References Solid_mesh_pt.

Referenced by segregated_solve().

Member Data Documentation

◆ Convergence_criterion

int oomph::SegregatableFSIProblem::Convergence_criterion

private

Convergence criterion (enumerated flag)

Definition at line 629 of file segregated_fsi_solver.h.

Referenced by assess_convergence_based_on_absolute_solid_change(), assess_convergence_based_on_max_global_residual(), assess_convergence_based_on_relative_solid_change(), SegregatableFSIProblem(), and segregated_solve().

◆ Convergence_tolerance

double oomph::SegregatableFSIProblem::Convergence_tolerance

protected

Convergence tolerance for Picard iteration.

Definition at line 518 of file segregated_fsi_solver.h.

Referenced by assess_convergence_based_on_absolute_solid_change(), assess_convergence_based_on_max_global_residual(), assess_convergence_based_on_relative_solid_change(), SegregatableFSIProblem(), and segregated_solve().

◆ Del_irons_and_tuck

Vector<double> oomph::SegregatableFSIProblem::Del_irons_and_tuck

protected

Vector of changes in Irons and Tuck under-relaxation.

Definition at line 575 of file segregated_fsi_solver.h.

Referenced by setup_segregated_solver(), and under_relax_solid().

◆ Doc_max_global_residual

bool oomph::SegregatableFSIProblem::Doc_max_global_residual

protected

Doc maximum global residual during iteration? (default: false)

Definition at line 524 of file segregated_fsi_solver.h.

Referenced by SegregatableFSIProblem(), and segregated_solve().

◆ Fluid_data_pt

Vector<Data*> oomph::SegregatableFSIProblem::Fluid_data_pt

protected

Vector storing the Data objects associated with the fluid problem: Tyically the nodal and internal data of the elements in the fluid bulk mesh.

Definition at line 542 of file segregated_fsi_solver.h.

Referenced by pin_fluid_dofs(), restore_fluid_dofs(), and setup_segregated_solver().

◆ Fluid_mesh_pt

Mesh* oomph::SegregatableFSIProblem::Fluid_mesh_pt

protected

Mesh containing only fluid elements – the elements in this Mesh will be excluded from the assembly process when the solid problem is solved.

Definition at line 564 of file segregated_fsi_solver.h.

Referenced by extrapolate_solid_data(), SegregatableFSIProblem(), setup_segregated_solver(), and use_only_fluid_elements().

◆ Fluid_value_is_pinned

Vector<std::vector<bool> > oomph::SegregatableFSIProblem::Fluid_value_is_pinned

protected

Vector of vectors that store the pinned status of fluid Data values.

Definition at line 546 of file segregated_fsi_solver.h.

Referenced by restore_fluid_dofs(), and setup_segregated_solver().

◆ Max_picard

unsigned oomph::SegregatableFSIProblem::Max_picard

protected

Max. number of Picard iterations.

Definition at line 521 of file segregated_fsi_solver.h.

Referenced by SegregatableFSIProblem(), and segregated_solve().

◆ Omega_relax

double oomph::SegregatableFSIProblem::Omega_relax

private

Under-relaxation parameter. (1.0: no under-relaxation; 0.0: Freeze wall shape)

Definition at line 622 of file segregated_fsi_solver.h.

Referenced by enable_under_relaxation(), SegregatableFSIProblem(), setup_segregated_solver(), and under_relax_solid().

◆ Orig_sub_mesh_pt

Vector<Mesh*> oomph::SegregatableFSIProblem::Orig_sub_mesh_pt

protected

Backup for the pointers to the submeshes in the original problem.

Definition at line 572 of file segregated_fsi_solver.h.

Referenced by rebuild_monolithic_mesh(), and setup_segregated_solver().

◆ Pointwise_aitken_counter

int oomph::SegregatableFSIProblem::Pointwise_aitken_counter

protected

Number of Aitken histories available (int because after extrapolation it's re-initialised to -1 to force the computation of three new genuine iterates).

Definition at line 505 of file segregated_fsi_solver.h.

Referenced by pointwise_aitken_extrapolate(), segregated_solve(), setup_segregated_solver(), and store_solid_dofs().

◆ Pointwise_aitken_solid_value

Vector<Vector<double> > oomph::SegregatableFSIProblem::Pointwise_aitken_solid_value

protected

Vector of Vectors containing up to three previous iterates for the solid dofs; used for pointwise Aitken extrapolation.

Definition at line 582 of file segregated_fsi_solver.h.

Referenced by pointwise_aitken_extrapolate(), setup_segregated_solver(), and store_solid_dofs().

◆ Pointwise_aitken_start

unsigned oomph::SegregatableFSIProblem::Pointwise_aitken_start

protected

Start pointwise Aitken extrpolation after specified number of Picard iterations.

Definition at line 512 of file segregated_fsi_solver.h.

Referenced by enable_pointwise_aitken(), SegregatableFSIProblem(), and segregated_solve().

◆ Previous_solid_value

Vector<double> oomph::SegregatableFSIProblem::Previous_solid_value

protected

Vector storing the previous solid values – used for convergence check.

Definition at line 559 of file segregated_fsi_solver.h.

Referenced by get_solid_change(), setup_segregated_solver(), store_solid_dofs(), and under_relax_solid().

◆ R_irons_and_tuck

double oomph::SegregatableFSIProblem::R_irons_and_tuck

protected

Irons and Tuck relaxation factor.

Definition at line 578 of file segregated_fsi_solver.h.

Referenced by setup_segregated_solver(), and under_relax_solid().

◆ Recheck_convergence_after_pointwise_aitken

bool oomph::SegregatableFSIProblem::Recheck_convergence_after_pointwise_aitken

protected

Have we just done a pointwise Aitken step.

Definition at line 585 of file segregated_fsi_solver.h.

Referenced by SegregatableFSIProblem(), and segregated_solve().

◆ Solid_data_pt

Vector<Data*> oomph::SegregatableFSIProblem::Solid_data_pt

protected

Vector storing the Data objects associated with the solid problem: Typically the positional data of solid nodes and any quantities associated with displacement control, say.

Definition at line 551 of file segregated_fsi_solver.h.

Referenced by extrapolate_solid_data(), get_solid_change(), pin_solid_dofs(), pointwise_aitken_extrapolate(), restore_solid_dofs(), setup_segregated_solver(), store_solid_dofs(), and under_relax_solid().

◆ Solid_mesh_pt

Mesh* oomph::SegregatableFSIProblem::Solid_mesh_pt

protected

Mesh containing only solid elements – the elements in this mesh will be excluded from the assembly process when the fluid problem is solved.

Definition at line 569 of file segregated_fsi_solver.h.

Referenced by SegregatableFSIProblem(), setup_segregated_solver(), and use_only_solid_elements().

◆ Solid_value_is_pinned

Vector<std::vector<bool> > oomph::SegregatableFSIProblem::Solid_value_is_pinned

protected

Vector of vectors that store the pinned status of solid Data values.

Definition at line 555 of file segregated_fsi_solver.h.

Referenced by restore_solid_dofs(), and setup_segregated_solver().

◆ Solve_type

int oomph::SegregatableFSIProblem::Solve_type

protected

Solve that is taking place (enumerated flag)

Definition at line 515 of file segregated_fsi_solver.h.

Referenced by SegregatableFSIProblem(), and segregated_solve().

◆ T_ref

clock_t oomph::SegregatableFSIProblem::T_ref

private

Reference time for segregated solve. Can be re-initialised whenever total elapsed time has been stored (before entering non-essential doc sections of the code)

Definition at line 634 of file segregated_fsi_solver.h.

Referenced by halt_timer(), reset_timer(), restart_timer(), and SegregatableFSIProblem().

◆ T_spent_on_actual_solve

double oomph::SegregatableFSIProblem::T_spent_on_actual_solve

private

Total elapsed time since start of solve, can be accumulated by adding bits of time spent in relevant parts of code (bypassing sections that only document the progress)

Definition at line 639 of file segregated_fsi_solver.h.

Referenced by halt_timer(), reset_timer(), SegregatableFSIProblem(), and t_spent_on_actual_solve().

◆ Timer_has_been_halted

bool oomph::SegregatableFSIProblem::Timer_has_been_halted

private

boolean flag to indicate if timer has been halted

Definition at line 642 of file segregated_fsi_solver.h.

Referenced by halt_timer(), reset_timer(), restart_timer(), and SegregatableFSIProblem().

◆ Use_irons_and_tuck_extrapolation

bool oomph::SegregatableFSIProblem::Use_irons_and_tuck_extrapolation

private

Boolean flag to indicate use of Irons and Tuck's extrapolation for solid values.

Definition at line 626 of file segregated_fsi_solver.h.

Referenced by disable_irons_and_tuck_extrapolation(), enable_irons_and_tuck_extrapolation(), SegregatableFSIProblem(), setup_segregated_solver(), and under_relax_solid().

◆ Use_pointwise_aitken

bool oomph::SegregatableFSIProblem::Use_pointwise_aitken

protected

Use pointwise Aitken extrapolation?

Definition at line 508 of file segregated_fsi_solver.h.

Referenced by disable_pointwise_aitken(), enable_pointwise_aitken(), SegregatableFSIProblem(), segregated_solve(), setup_segregated_solver(), and store_solid_dofs().

The documentation for this class was generated from the following files:

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Member Enumeration Documentation

◆ convergence_criteria

◆ solve_type

Constructor & Destructor Documentation

◆ SegregatableFSIProblem()

◆ ~SegregatableFSIProblem()

Member Function Documentation

◆ actions_after_segregated_solve()

◆ actions_before_segregated_convergence_check()

◆ actions_before_segregated_solve()

◆ assess_convergence_based_on_absolute_solid_change() [1/2]

◆ assess_convergence_based_on_absolute_solid_change() [2/2]

◆ assess_convergence_based_on_max_global_residual() [1/2]

◆ assess_convergence_based_on_max_global_residual() [2/2]

◆ assess_convergence_based_on_relative_solid_change() [1/2]

◆ assess_convergence_based_on_relative_solid_change() [2/2]

◆ disable_irons_and_tuck_extrapolation()

◆ disable_pointwise_aitken()

◆ enable_irons_and_tuck_extrapolation()

◆ enable_pointwise_aitken() [1/2]

◆ enable_pointwise_aitken() [2/2]

◆ enable_under_relaxation()

◆ extrapolate_solid_data()

◆ get_solid_change()

◆ halt_timer()

◆ identify_fluid_and_solid_dofs()

◆ pin_fluid_dofs()

◆ pin_solid_dofs()

◆ pointwise_aitken_extrapolate()

◆ rebuild_monolithic_mesh()

◆ reset_timer()

◆ restart_timer()

◆ restore_fluid_dofs()

◆ restore_solid_dofs()

◆ segregated_solve()

◆ setup_segregated_solver()

◆ steady_segregated_solve()

◆ store_solid_dofs()

◆ t_spent_on_actual_solve()

◆ under_relax_solid()

◆ unsteady_segregated_solve() [1/2]

◆ unsteady_segregated_solve() [2/2]

◆ use_only_fluid_elements()

◆ use_only_solid_elements()

Member Data Documentation

◆ Convergence_criterion

◆ Convergence_tolerance

◆ Del_irons_and_tuck

◆ Doc_max_global_residual

◆ Fluid_data_pt

◆ Fluid_mesh_pt

◆ Fluid_value_is_pinned

◆ Max_picard

◆ Omega_relax

◆ Orig_sub_mesh_pt

◆ Pointwise_aitken_counter

◆ Pointwise_aitken_solid_value

◆ Pointwise_aitken_start

◆ Previous_solid_value

◆ R_irons_and_tuck

◆ Recheck_convergence_after_pointwise_aitken

◆ Solid_data_pt

◆ Solid_mesh_pt

◆ Solid_value_is_pinned

◆ Solve_type

◆ T_ref

◆ T_spent_on_actual_solve

◆ Timer_has_been_halted

◆ Use_irons_and_tuck_extrapolation

◆ Use_pointwise_aitken