#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 Types inherited from oomph::Problem
typedef void(*	SpatialErrorEstimatorFctPt) (Mesh *&mesh_pt, Vector< double > &elemental_error)
	Function pointer for spatial error estimator. More...

typedef void(*	SpatialErrorEstimatorWithDocFctPt) (Mesh *&mesh_pt, Vector< double > &elemental_error, DocInfo &doc_info)
	Function pointer for spatial error estimator with doc. More...

Public Member Functions
	SegregatableFSIProblem ()

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

void	setup_segregated_solver (const bool &full_setup_of_fluid_and_solid_dofs=true)

PicardConvergenceData	segregated_solve ()

PicardConvergenceData	steady_segregated_solve ()

PicardConvergenceData	unsteady_segregated_solve (const double &dt)

PicardConvergenceData	unsteady_segregated_solve (const double &dt, const bool &shift_values)

void	assess_convergence_based_on_max_global_residual (const double &tol)

void	assess_convergence_based_on_max_global_residual ()

void	assess_convergence_based_on_absolute_solid_change (const double &tol)

void	assess_convergence_based_on_absolute_solid_change ()

void	assess_convergence_based_on_relative_solid_change (const double &tol)

void	assess_convergence_based_on_relative_solid_change ()

void	enable_pointwise_aitken (const unsigned &pointwise_aitken_start)

void	enable_pointwise_aitken ()

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

void	enable_under_relaxation (const double &omega=1.0)

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)

void	store_solid_dofs ()

void	reset_timer ()
	Reset timer. More...

void	restart_timer ()

void	halt_timer ()

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

Public Member Functions inherited from oomph::Problem
virtual void	debug_hook_fct (const unsigned &i)

void	set_analytic_dparameter (double *const &parameter_pt)

void	unset_analytic_dparameter (double *const &parameter_pt)

bool	is_dparameter_calculated_analytically (double *const &parameter_pt)

void	set_analytic_hessian_products ()

void	unset_analytic_hessian_products ()

bool	are_hessian_products_calculated_analytically ()

void	set_pinned_values_to_zero ()

bool	distributed () const

virtual void	actions_before_adapt ()

virtual void	actions_after_adapt ()
	Actions that are to be performed after a mesh adaptation. More...

OomphCommunicator *	communicator_pt ()
	access function to the oomph-lib communicator More...

const OomphCommunicator *	communicator_pt () const
	access function to the oomph-lib communicator, const version More...

	Problem ()

	Problem (const Problem &dummy)=delete
	Broken copy constructor. More...

void	operator= (const Problem &)=delete
	Broken assignment operator. More...

virtual	~Problem ()
	Virtual destructor to clean up memory. More...

Mesh *&	mesh_pt ()
	Return a pointer to the global mesh. More...

Mesh *const &	mesh_pt () const
	Return a pointer to the global mesh (const version) More...

Mesh *&	mesh_pt (const unsigned &imesh)

Mesh *const &	mesh_pt (const unsigned &imesh) const
	Return a pointer to the i-th submesh (const version) More...

unsigned	nsub_mesh () const
	Return number of submeshes. More...

unsigned	add_sub_mesh (Mesh *const &mesh_pt)

void	flush_sub_meshes ()

void	build_global_mesh ()

void	rebuild_global_mesh ()

LinearSolver *&	linear_solver_pt ()
	Return a pointer to the linear solver object. More...

LinearSolver *const &	linear_solver_pt () const
	Return a pointer to the linear solver object (const version) More...

LinearSolver *&	mass_matrix_solver_for_explicit_timestepper_pt ()

LinearSolver *	mass_matrix_solver_for_explicit_timestepper_pt () const

EigenSolver *&	eigen_solver_pt ()
	Return a pointer to the eigen solver object. More...

EigenSolver *const &	eigen_solver_pt () const
	Return a pointer to the eigen solver object (const version) More...

Time *&	time_pt ()
	Return a pointer to the global time object. More...

Time *	time_pt () const
	Return a pointer to the global time object (const version). More...

double &	time ()
	Return the current value of continuous time. More...

double	time () const
	Return the current value of continuous time (const version) More...

TimeStepper *&	time_stepper_pt ()

const TimeStepper *	time_stepper_pt () const

TimeStepper *&	time_stepper_pt (const unsigned &i)
	Return a pointer to the i-th timestepper. More...

ExplicitTimeStepper *&	explicit_time_stepper_pt ()
	Return a pointer to the explicit timestepper. More...

unsigned long	set_timestepper_for_all_data (TimeStepper *const &time_stepper_pt, const bool &preserve_existing_data=false)

virtual void	shift_time_values ()
	Shift all values along to prepare for next timestep. More...

AssemblyHandler *&	assembly_handler_pt ()
	Return a pointer to the assembly handler object. More...

AssemblyHandler *const &	assembly_handler_pt () const
	Return a pointer to the assembly handler object (const version) More...

double &	minimum_dt ()
	Access function to min timestep in adaptive timestepping. More...

double &	maximum_dt ()
	Access function to max timestep in adaptive timestepping. More...

unsigned &	max_newton_iterations ()
	Access function to max Newton iterations before giving up. More...

void	problem_is_nonlinear (const bool &prob_lin)
	Access function to Problem_is_nonlinear. More...

double &	max_residuals ()

bool &	time_adaptive_newton_crash_on_solve_fail ()
	Access function for Time_adaptive_newton_crash_on_solve_fail. More...

double &	newton_solver_tolerance ()

void	add_time_stepper_pt (TimeStepper *const &time_stepper_pt)

void	set_explicit_time_stepper_pt (ExplicitTimeStepper *const &explicit_time_stepper_pt)

void	initialise_dt (const double &dt)

void	initialise_dt (const Vector< double > &dt)

Data *&	global_data_pt (const unsigned &i)
	Return a pointer to the the i-th global data object. More...

void	add_global_data (Data *const &global_data_pt)

void	flush_global_data ()

LinearAlgebraDistribution *const &	dof_distribution_pt () const
	Return the pointer to the dof distribution (read-only) More...

unsigned long	ndof () const
	Return the number of dofs. More...

unsigned	ntime_stepper () const
	Return the number of time steppers. More...

unsigned	nglobal_data () const
	Return the number of global data values. More...

unsigned	self_test ()
	Self-test: Check meshes and global data. Return 0 for OK. More...

void	enable_store_local_dof_pt_in_elements ()

void	disable_store_local_dof_pt_in_elements ()

unsigned long	assign_eqn_numbers (const bool &assign_local_eqn_numbers=true)

void	describe_dofs (std::ostream &out= *(oomph_info.stream_pt())) const

void	enable_discontinuous_formulation ()

void	disable_discontinuous_formulation ()

void	get_dofs (DoubleVector &dofs) const

void	get_dofs (const unsigned &t, DoubleVector &dofs) const
	Return vector of the t'th history value of all dofs. More...

void	set_dofs (const DoubleVector &dofs)
	Set the values of the dofs. More...

void	set_dofs (const unsigned &t, DoubleVector &dofs)
	Set the history values of the dofs. More...

void	set_dofs (const unsigned &t, Vector< double * > &dof_pt)

void	add_to_dofs (const double &lambda, const DoubleVector &increment_dofs)
	Add lambda x incremenet_dofs[l] to the l-th dof. More...

double *	global_dof_pt (const unsigned &i)

double &	dof (const unsigned &i)
	i-th dof in the problem More...

double	dof (const unsigned &i) const
	i-th dof in the problem (const version) More...

double *&	dof_pt (const unsigned &i)
	Pointer to i-th dof in the problem. More...

double *	dof_pt (const unsigned &i) const
	Pointer to i-th dof in the problem (const version) More...

virtual void	get_inverse_mass_matrix_times_residuals (DoubleVector &Mres)

virtual void	get_dvaluesdt (DoubleVector &f)

virtual void	get_residuals (DoubleVector &residuals)
	Get the total residuals Vector for the problem. More...

virtual void	get_jacobian (DoubleVector &residuals, DenseDoubleMatrix &jacobian)

virtual void	get_jacobian (DoubleVector &residuals, CRDoubleMatrix &jacobian)

virtual void	get_jacobian (DoubleVector &residuals, CCDoubleMatrix &jacobian)

virtual void	get_jacobian (DoubleVector &residuals, SumOfMatrices &jacobian)

void	get_fd_jacobian (DoubleVector &residuals, DenseMatrix< double > &jacobian)
	Get the full Jacobian by finite differencing. More...

void	get_derivative_wrt_global_parameter (double *const &parameter_pt, DoubleVector &result)

void	get_hessian_vector_products (DoubleVectorWithHaloEntries const &Y, Vector< DoubleVectorWithHaloEntries > const &C, Vector< DoubleVectorWithHaloEntries > &product)

void	solve_eigenproblem (const unsigned &n_eval, Vector< std::complex< double >> &eigenvalue, Vector< DoubleVector > &eigenvector, const bool &steady=true)
	Solve the eigenproblem. More...

void	solve_eigenproblem (const unsigned &n_eval, Vector< std::complex< double >> &eigenvalue, const bool &steady=true)

virtual void	get_eigenproblem_matrices (CRDoubleMatrix &mass_matrix, CRDoubleMatrix &main_matrix, const double &shift=0.0)

void	assign_eigenvector_to_dofs (DoubleVector &eigenvector)
	Assign the eigenvector passed to the function to the dofs. More...

void	add_eigenvector_to_dofs (const double &epsilon, const DoubleVector &eigenvector)

void	store_current_dof_values ()
	Store the current values of the degrees of freedom. More...

void	restore_dof_values ()
	Restore the stored values of the degrees of freedom. More...

void	enable_jacobian_reuse ()

void	disable_jacobian_reuse ()
	Disable recycling of Jacobian in Newton iteration. More...

bool	jacobian_reuse_is_enabled ()
	Is recycling of Jacobian in Newton iteration enabled? More...

bool &	use_predictor_values_as_initial_guess ()

void	newton_solve ()
	Use Newton method to solve the problem. More...

void	enable_globally_convergent_newton_method ()
	enable globally convergent Newton method More...

void	disable_globally_convergent_newton_method ()
	disable globally convergent Newton method More...

void	newton_solve (unsigned const &max_adapt)

void	steady_newton_solve (unsigned const &max_adapt=0)

void	copy (Problem *orig_problem_pt)

virtual Problem *	make_copy ()

virtual void	read (std::ifstream &restart_file, bool &unsteady_restart)

virtual void	read (std::ifstream &restart_file)

virtual void	dump (std::ofstream &dump_file) const

void	dump (const std::string &dump_file_name) const

void	delete_all_external_storage ()

virtual void	symmetrise_eigenfunction_for_adaptive_pitchfork_tracking ()

double *	bifurcation_parameter_pt () const

void	get_bifurcation_eigenfunction (Vector< DoubleVector > &eigenfunction)

void	activate_fold_tracking (double *const &parameter_pt, const bool &block_solve=true)

void	activate_bifurcation_tracking (double *const &parameter_pt, const DoubleVector &eigenvector, const bool &block_solve=true)

void	activate_bifurcation_tracking (double *const &parameter_pt, const DoubleVector &eigenvector, const DoubleVector &normalisation, const bool &block_solve=true)

void	activate_pitchfork_tracking (double *const &parameter_pt, const DoubleVector &symmetry_vector, const bool &block_solve=true)

void	activate_hopf_tracking (double *const &parameter_pt, const bool &block_solve=true)

void	activate_hopf_tracking (double *const &parameter_pt, const double &omega, const DoubleVector &null_real, const DoubleVector &null_imag, const bool &block_solve=true)

void	deactivate_bifurcation_tracking ()

void	reset_assembly_handler_to_default ()
	Reset the system to the standard non-augemented state. More...

double	arc_length_step_solve (double *const &parameter_pt, const double &ds, const unsigned &max_adapt=0)

double	arc_length_step_solve (Data *const &data_pt, const unsigned &data_index, const double &ds, const unsigned &max_adapt=0)

void	reset_arc_length_parameters ()

int &	sign_of_jacobian ()

void	explicit_timestep (const double &dt, const bool &shift_values=true)
	Take an explicit timestep of size dt. More...

void	unsteady_newton_solve (const double &dt)

void	unsteady_newton_solve (const double &dt, const bool &shift_values)

void	unsteady_newton_solve (const double &dt, const unsigned &max_adapt, const bool &first, const bool &shift=true)

double	doubly_adaptive_unsteady_newton_solve (const double &dt, const double &epsilon, const unsigned &max_adapt, const bool &first, const bool &shift=true)

double	doubly_adaptive_unsteady_newton_solve (const double &dt, const double &epsilon, const unsigned &max_adapt, const unsigned &suppress_resolve_after_spatial_adapt_flag, const bool &first, const bool &shift=true)

double	adaptive_unsteady_newton_solve (const double &dt_desired, const double &epsilon)

double	adaptive_unsteady_newton_solve (const double &dt_desired, const double &epsilon, const bool &shift_values)

void	assign_initial_values_impulsive ()

void	assign_initial_values_impulsive (const double &dt)

void	calculate_predictions ()
	Calculate predictions. More...

void	enable_mass_matrix_reuse ()

void	disable_mass_matrix_reuse ()

bool	mass_matrix_reuse_is_enabled ()
	Return whether the mass matrix is being reused. More...

void	refine_uniformly (const Vector< unsigned > &nrefine_for_mesh)

void	refine_uniformly (const Vector< unsigned > &nrefine_for_mesh, DocInfo &doc_info)

void	refine_uniformly_and_prune (const Vector< unsigned > &nrefine_for_mesh)

void	refine_uniformly_and_prune (const Vector< unsigned > &nrefine_for_mesh, DocInfo &doc_info)

void	refine_uniformly (DocInfo &doc_info)

void	refine_uniformly_and_prune (DocInfo &doc_info)

void	refine_uniformly ()

void	refine_uniformly (const unsigned &i_mesh, DocInfo &doc_info)
	Do uniform refinement for submesh i_mesh with documentation. More...

void	refine_uniformly (const unsigned &i_mesh)
	Do uniform refinement for submesh i_mesh without documentation. More...

void	p_refine_uniformly (const Vector< unsigned > &nrefine_for_mesh)

void	p_refine_uniformly (const Vector< unsigned > &nrefine_for_mesh, DocInfo &doc_info)

void	p_refine_uniformly_and_prune (const Vector< unsigned > &nrefine_for_mesh)

void	p_refine_uniformly_and_prune (const Vector< unsigned > &nrefine_for_mesh, DocInfo &doc_info)

void	p_refine_uniformly (DocInfo &doc_info)

void	p_refine_uniformly_and_prune (DocInfo &doc_info)

void	p_refine_uniformly ()

void	p_refine_uniformly (const unsigned &i_mesh, DocInfo &doc_info)
	Do uniform p-refinement for submesh i_mesh with documentation. More...

void	p_refine_uniformly (const unsigned &i_mesh)
	Do uniform p-refinement for submesh i_mesh without documentation. More...

void	refine_selected_elements (const Vector< unsigned > &elements_to_be_refined)

void	refine_selected_elements (const Vector< RefineableElement * > &elements_to_be_refined_pt)

void	refine_selected_elements (const unsigned &i_mesh, const Vector< unsigned > &elements_to_be_refined)

void	refine_selected_elements (const unsigned &i_mesh, const Vector< RefineableElement * > &elements_to_be_refined_pt)

void	refine_selected_elements (const Vector< Vector< unsigned >> &elements_to_be_refined)

void	refine_selected_elements (const Vector< Vector< RefineableElement * >> &elements_to_be_refined_pt)

void	p_refine_selected_elements (const Vector< unsigned > &elements_to_be_refined)

void	p_refine_selected_elements (const Vector< PRefineableElement * > &elements_to_be_refined_pt)

void	p_refine_selected_elements (const unsigned &i_mesh, const Vector< unsigned > &elements_to_be_refined)

void	p_refine_selected_elements (const unsigned &i_mesh, const Vector< PRefineableElement * > &elements_to_be_refined_pt)

void	p_refine_selected_elements (const Vector< Vector< unsigned >> &elements_to_be_refined)

void	p_refine_selected_elements (const Vector< Vector< PRefineableElement * >> &elements_to_be_refined_pt)

unsigned	unrefine_uniformly ()

unsigned	unrefine_uniformly (const unsigned &i_mesh)

void	p_unrefine_uniformly (DocInfo &doc_info)

void	p_unrefine_uniformly (const unsigned &i_mesh, DocInfo &doc_info)
	Do uniform p-unrefinement for submesh i_mesh without documentation. More...

void	adapt (unsigned &n_refined, unsigned &n_unrefined)

void	adapt ()

void	p_adapt (unsigned &n_refined, unsigned &n_unrefined)

void	p_adapt ()

void	adapt_based_on_error_estimates (unsigned &n_refined, unsigned &n_unrefined, Vector< Vector< double >> &elemental_error)

void	adapt_based_on_error_estimates (Vector< Vector< double >> &elemental_error)

void	get_all_error_estimates (Vector< Vector< double >> &elemental_error)

void	doc_errors (DocInfo &doc_info)
	Get max and min error for all elements in submeshes. More...

void	doc_errors ()
	Get max and min error for all elements in submeshes. More...

void	enable_info_in_newton_solve ()

void	disable_info_in_newton_solve ()
	Disable the output of information when in the newton solver. More...

Public Member Functions inherited from oomph::ExplicitTimeSteppableObject
	ExplicitTimeSteppableObject ()
	Empty constructor. More...

	ExplicitTimeSteppableObject (const ExplicitTimeSteppableObject &)=delete
	Broken copy constructor. More...

void	operator= (const ExplicitTimeSteppableObject &)=delete
	Broken assignment operator. More...

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

virtual void	actions_before_explicit_stage ()

virtual void	actions_after_explicit_stage ()

Protected Member Functions
virtual void	actions_before_segregated_solve ()

virtual void	actions_after_segregated_solve ()

virtual void	actions_before_segregated_convergence_check ()

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 Member Functions inherited from oomph::Problem
unsigned	setup_element_count_per_dof ()

virtual void	sparse_assemble_row_or_column_compressed (Vector< int * > &column_or_row_index, Vector< int * > &row_or_column_start, Vector< double * > &value, Vector< unsigned > &nnz, Vector< double * > &residual, bool compressed_row_flag)

virtual void	actions_before_newton_solve ()

virtual void	actions_after_newton_solve ()

virtual void	actions_before_newton_convergence_check ()

virtual void	actions_before_newton_step ()

virtual void	actions_after_newton_step ()

virtual void	actions_before_implicit_timestep ()

virtual void	actions_after_implicit_timestep ()

virtual void	actions_after_implicit_timestep_and_error_estimation ()

virtual void	actions_before_explicit_timestep ()
	Actions that should be performed before each explicit time step. More...

virtual void	actions_after_explicit_timestep ()
	Actions that should be performed after each explicit time step. More...

virtual void	actions_before_read_unstructured_meshes ()

virtual void	actions_after_read_unstructured_meshes ()

virtual void	actions_after_change_in_global_parameter (double *const &parameter_pt)

virtual void	actions_after_change_in_bifurcation_parameter ()

virtual void	actions_after_parameter_increase (double *const &parameter_pt)

double &	dof_derivative (const unsigned &i)

double &	dof_current (const unsigned &i)

virtual void	set_initial_condition ()

virtual double	global_temporal_error_norm ()

unsigned	newton_solve_continuation (double *const &parameter_pt)

unsigned	newton_solve_continuation (double *const &parameter_pt, DoubleVector &z)

void	calculate_continuation_derivatives (double *const &parameter_pt)

void	calculate_continuation_derivatives (const DoubleVector &z)

void	calculate_continuation_derivatives_fd (double *const &parameter_pt)

bool	does_pointer_correspond_to_problem_data (double *const &parameter_pt)

void	set_consistent_pinned_values_for_continuation ()

Protected Attributes
int	Pointwise_aitken_counter

bool	Use_pointwise_aitken
	Use pointwise Aitken extrapolation? More...

unsigned	Pointwise_aitken_start

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< std::vector< bool > >	Fluid_value_is_pinned

Vector< Data * >	Solid_data_pt

Vector< std::vector< bool > >	Solid_value_is_pinned

Vector< double >	Previous_solid_value

Mesh *	Fluid_mesh_pt

Mesh *	Solid_mesh_pt

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

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

Protected Attributes inherited from oomph::Problem
Vector< Problem * >	Copy_of_problem_pt

std::map< double *, bool >	Calculate_dparameter_analytic

bool	Calculate_hessian_products_analytic

LinearAlgebraDistribution *	Dof_distribution_pt

Vector< double * >	Dof_pt
	Vector of pointers to dofs. More...

DoubleVectorWithHaloEntries	Element_count_per_dof

double	Relaxation_factor

double	Newton_solver_tolerance

unsigned	Max_newton_iterations
	Maximum number of Newton iterations. More...

unsigned	Nnewton_iter_taken

Vector< double >	Max_res
	Maximum residuals at start and after each newton iteration. More...

double	Max_residuals

bool	Time_adaptive_newton_crash_on_solve_fail

bool	Jacobian_reuse_is_enabled
	Is re-use of Jacobian in Newton iteration enabled? Default: false. More...

bool	Jacobian_has_been_computed

bool	Problem_is_nonlinear

bool	Pause_at_end_of_sparse_assembly

bool	Doc_time_in_distribute

unsigned	Sparse_assembly_method

unsigned	Sparse_assemble_with_arrays_initial_allocation

unsigned	Sparse_assemble_with_arrays_allocation_increment

Vector< Vector< unsigned > >	Sparse_assemble_with_arrays_previous_allocation

double	Numerical_zero_for_sparse_assembly

double	FD_step_used_in_get_hessian_vector_products

bool	Mass_matrix_reuse_is_enabled

bool	Mass_matrix_has_been_computed

bool	Discontinuous_element_formulation

double	Minimum_dt
	Minimum desired dt: if dt falls below this value, exit. More...

double	Maximum_dt
	Maximum desired dt. More...

double	DTSF_max_increase

double	DTSF_min_decrease

double	Minimum_dt_but_still_proceed

bool	Scale_arc_length
	Boolean to control whether arc-length should be scaled. More...

double	Desired_proportion_of_arc_length
	Proportion of the arc-length to taken by the parameter. More...

double	Theta_squared

int	Sign_of_jacobian
	Storage for the sign of the global Jacobian. More...

double	Continuation_direction

double	Parameter_derivative
	Storage for the derivative of the global parameter wrt arc-length. More...

double	Parameter_current
	Storage for the present value of the global parameter. More...

bool	Use_continuation_timestepper
	Boolean to control original or new storage of dof stuff. More...

unsigned	Dof_derivative_offset

unsigned	Dof_current_offset

Vector< double >	Dof_derivative
	Storage for the derivative of the problem variables wrt arc-length. More...

Vector< double >	Dof_current
	Storage for the present values of the variables. More...

double	Ds_current
	Storage for the current step value. More...

unsigned	Desired_newton_iterations_ds

double	Minimum_ds
	Minimum desired value of arc-length. More...

bool	Bifurcation_detection
	Boolean to control bifurcation detection via determinant of Jacobian. More...

bool	Bisect_to_find_bifurcation
	Boolean to control wheter bisection is used to located bifurcation. More...

bool	First_jacobian_sign_change
	Boolean to indicate whether a sign change has occured in the Jacobian. More...

bool	Arc_length_step_taken
	Boolean to indicate whether an arc-length step has been taken. More...

bool	Use_finite_differences_for_continuation_derivatives

OomphCommunicator *	Communicator_pt
	The communicator for this problem. More...

bool	Always_take_one_newton_step

double	Timestep_reduction_factor_after_nonconvergence

bool	Keep_temporal_error_below_tolerance

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

void	under_relax_solid ()
	Under-relax solid, either by classical relaxation or by Irons & Tuck. More...

void	use_only_fluid_elements ()

void	use_only_solid_elements ()

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

Private Attributes
double	Omega_relax

bool	Use_irons_and_tuck_extrapolation

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

clock_t	T_ref

double	T_spent_on_actual_solve

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

Additional Inherited Members
Public Attributes inherited from oomph::Problem
bool	Shut_up_in_newton_solve

Static Public Attributes inherited from oomph::Problem
static bool	Suppress_warning_about_actions_before_read_unstructured_meshes

Protected Types inherited from oomph::Problem
enum	Assembly_method { Perform_assembly_using_vectors_of_pairs , Perform_assembly_using_two_vectors , Perform_assembly_using_maps , Perform_assembly_using_lists , Perform_assembly_using_two_arrays }
	Enumerated flags to determine which sparse assembly method is used. More...

Static Protected Attributes inherited from oomph::Problem
static ContinuationStorageScheme	Continuation_time_stepper
	Storage for the single static continuation timestorage object. More...

Detailed Description

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

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

     {
       Assess_convergence_based_on_absolute_solid_change,
       Assess_convergence_based_on_relative_solid_change,
       Assess_convergence_based_on_max_global_residual
     };

◆ solve_type

enum oomph::SegregatableFSIProblem::solve_type

Enumerated flags to indicate which solve is taking place.

Enumerator
Full_solve
Fluid_solve
Solid_solve

     {
       Full_solve,
       Fluid_solve,
       Solid_solve
     };

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

     {
       // Use pointwise Aitken extrapolation?
       Use_pointwise_aitken = false;
  
       // Default: No under-relaxation
       Omega_relax = 1.0;
  
       // Don't use of Irons and Tuck's extrapolation for solid values
       Use_irons_and_tuck_extrapolation = false;
  
       // Start using pointwise Aitken immediately
       Pointwise_aitken_start = 0;
  
       // By default we don't recheck convergence
       Recheck_convergence_after_pointwise_aitken = false;
  
       // Default solve type is full solve
       Solve_type = Full_solve;
  
       // Convergence criterion
       Convergence_criterion = Assess_convergence_based_on_max_global_residual;
  
       // Convergence tolerance (as in global Newton solver)
       Convergence_tolerance = Problem::Newton_solver_tolerance;
  
       // Doc max. global residual during iteration?
       Doc_max_global_residual = false;
  
       // Max. number of Picard iterations
       Max_picard = 50;
  
       // Pointer to Mesh containing only fluid elements -- the elements in this
       // Mesh will be excluded from the assembly process when
       // the solid problem is solved
       Fluid_mesh_pt = 0;
  
       // Pointer to Mesh containing only solid elements -- the elements in this
       // mesh will be excluded from the assembly process when
       // the fluid problem is solved
       Solid_mesh_pt = 0;
  
       // Initialise timer that allows doc of iteration/cpu time
       T_ref = clock();
       T_spent_on_actual_solve = 0.0;
  
       Timer_has_been_halted = false;
     }

References Assess_convergence_based_on_max_global_residual, Convergence_criterion, Convergence_tolerance, Doc_max_global_residual, Fluid_mesh_pt, Full_solve, Max_picard, oomph::Problem::Newton_solver_tolerance, 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.

242 {}

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.

176 {}

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

Reimplemented in SegregatedFSICollapsibleChannelProblem< ELEMENT >, and SegregatedFSICollapsibleChannelProblem< ELEMENT >.

180 {}

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.

Reimplemented in SegregatedFSICollapsibleChannelProblem< ELEMENT >.

172 {}

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.

     {
       assess_convergence_based_on_absolute_solid_change(
         Problem::Newton_solver_tolerance);
     }

References oomph::Problem::Newton_solver_tolerance.

Referenced by SegregatedFSICollapsibleChannelProblem< ELEMENT >::SegregatedFSICollapsibleChannelProblem(), and SegregatedFSIDrivenCavityProblem< ELEMENT >::SegregatedFSIDrivenCavityProblem().

◆ 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.

     {
       Convergence_criterion = Assess_convergence_based_on_absolute_solid_change;
       Convergence_tolerance = tol;
     }

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.

     {
       assess_convergence_based_on_max_global_residual(
         Problem::Newton_solver_tolerance);
     }

References oomph::Problem::Newton_solver_tolerance.

Referenced by SegregatedFSICollapsibleChannelProblem< ELEMENT >::SegregatedFSICollapsibleChannelProblem().

◆ 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.

     {
       Convergence_criterion = Assess_convergence_based_on_max_global_residual;
       Convergence_tolerance = tol;
     }

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.

     {
       assess_convergence_based_on_relative_solid_change(
         Problem::Newton_solver_tolerance);
     }

References oomph::Problem::Newton_solver_tolerance.

Referenced by SegregatedFSICollapsibleChannelProblem< ELEMENT >::SegregatedFSICollapsibleChannelProblem().

◆ 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.

     {
       Convergence_criterion = Assess_convergence_based_on_relative_solid_change;
       Convergence_tolerance = tol;
     }

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.

     {
       Use_irons_and_tuck_extrapolation = false;
     }

References Use_irons_and_tuck_extrapolation.

Referenced by SegregatedFSICollapsibleChannelProblem< ELEMENT >::SegregatedFSICollapsibleChannelProblem().

◆ disable_pointwise_aitken()

void oomph::SegregatableFSIProblem::disable_pointwise_aitken ( )

inline

Disable the use of pointwise Aitken extrapolation.

     {
       Use_pointwise_aitken = false;
     }

References Use_pointwise_aitken.

Referenced by SegregatedFSICollapsibleChannelProblem< ELEMENT >::SegregatedFSICollapsibleChannelProblem(), and SegregatedFSIDrivenCavityProblem< ELEMENT >::SegregatedFSIDrivenCavityProblem().

◆ enable_irons_and_tuck_extrapolation()

void oomph::SegregatableFSIProblem::enable_irons_and_tuck_extrapolation ( )

inline

Use Irons and Tuck extrapolation for solid dofs.

     {
       Use_irons_and_tuck_extrapolation = true;
     }

References Use_irons_and_tuck_extrapolation.

Referenced by SegregatedFSICollapsibleChannelProblem< ELEMENT >::SegregatedFSICollapsibleChannelProblem().

◆ 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

     {
       Use_pointwise_aitken = true;
     }

References Use_pointwise_aitken.

Referenced by SegregatedFSICollapsibleChannelProblem< ELEMENT >::SegregatedFSICollapsibleChannelProblem().

◆ 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.

     {
       Pointwise_aitken_start = pointwise_aitken_start;
       Use_pointwise_aitken = true;
     }

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()

     {
       Omega_relax = omega;
     }

References Eigen::internal::omega(), and Omega_relax.

Referenced by SegregatedFSICollapsibleChannelProblem< ELEMENT >::SegregatedFSICollapsibleChannelProblem(), and SegregatedFSIDrivenCavityProblem< ELEMENT >::SegregatedFSIDrivenCavityProblem().

◆ 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.

   {
     // Number of solid Data items:
     unsigned n_data = Solid_data_pt.size();
  
     // Loop over all solid Data items:
     for (unsigned i = 0; i < n_data; i++)
     {
       // Number of values stored at this Data item:
       unsigned n_value = Solid_data_pt[i]->nvalue();
  
       // Number of values stored at this Data item:
       unsigned n_prev = Solid_data_pt[i]->time_stepper_pt()->nprev_values();
  
       // Can't use this extrapolation if we don't have at least two
       // history values; may be able to do better for higher order
       // timesteppers, though.
       if (n_prev >= 2)
       {
         // Extrapolate all values
         for (unsigned k = 0; k < n_value; k++)
         {
           // Linear extrapolation based on previous two values,
           // assuming constant timestep.
           double new_value =
             2.0 * Solid_data_pt[i]->value(1, k) - Solid_data_pt[i]->value(2, k);
           *(Solid_data_pt[i]->value_pt(0, k)) = new_value;
         }
       }
     }
  
     // Update fluid node position in response to changes in wall shape
     // (If fluid mesh was specified via non-NULL Fluid_mesh_pt
     // this node update will only act on the fluid nodes).
     if (Fluid_mesh_pt != 0)
     {
       Fluid_mesh_pt->node_update();
     }
     else
     {
       mesh_pt()->node_update();
     }
   }

References Fluid_mesh_pt, i, k, oomph::Problem::mesh_pt(), oomph::Mesh::node_update(), 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.

   {
     // Initialise
     rms_change = 0.0;
     max_change = 0.0;
     rms_norm = 0.0;
  
     // Counter for the number of values:
     unsigned value_count = 0;
  
     // Number of solid Data items:
     unsigned n_data = Solid_data_pt.size();
  
     // Loop over all solid Data items:
     for (unsigned i = 0; i < n_data; i++)
     {
       // Number of values stored at this Data item:
       unsigned n_value = Solid_data_pt[i]->nvalue();
  
       // Loop over all values
       for (unsigned k = 0; k < n_value; k++)
       {
         // Change
         double change =
           Previous_solid_value[value_count] - Solid_data_pt[i]->value(k);
  
         // Max change?
         if (std::fabs(change) > max_change) max_change = std::fabs(change);
  
         // Add square of change relative to previous value
         rms_change += pow(change, 2);
  
         // Add square of previous value
         rms_norm += pow(Previous_solid_value[value_count], 2);
  
         // Increment counter
         value_count++;
       }
     }
  
     // Turn into rms:
     rms_change = sqrt(rms_change / double(value_count));
     rms_norm = sqrt(rms_norm / double(value_count));
   }

References boost::multiprecision::fabs(), i, k, Eigen::bfloat16_impl::pow(), Previous_solid_value, Solid_data_pt, and sqrt().

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)

     {
       if (!Timer_has_been_halted)
       {
         T_spent_on_actual_solve += double(clock() - T_ref) / CLOCKS_PER_SEC;
         Timer_has_been_halted = true;
       }
     }

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.

Implemented in SegregatedFSIDrivenCavityProblem< ELEMENT >, SegregatedFSICollapsibleChannelProblem< ELEMENT >, and SegregatedFSICollapsibleChannelProblem< ELEMENT >.

Referenced by setup_segregated_solver().

◆ pin_fluid_dofs()

void oomph::SegregatableFSIProblem::pin_fluid_dofs ( )

private

Pin fluid dofs.

Pin all fluid dofs.

   {
     // Number of fluid Data items:
     unsigned n_data = Fluid_data_pt.size();
  
     // Loop over all fluid Data items:
     for (unsigned i = 0; i < n_data; i++)
     {
       // Number of values stored at this Data item:
       unsigned n_value = Fluid_data_pt[i]->nvalue();
  
       // Pin all values
       for (unsigned k = 0; k < n_value; k++)
       {
         Fluid_data_pt[i]->pin(k);
       }
     }
   }

References Fluid_data_pt, i, and k.

Referenced by segregated_solve().

◆ pin_solid_dofs()

void oomph::SegregatableFSIProblem::pin_solid_dofs ( )

protected

Pin solid dofs.

Pin all solid dofs.

   {
     // Number of solid Data items:
     unsigned n_data = Solid_data_pt.size();
  
     // Loop over all solid Data items:
     for (unsigned i = 0; i < n_data; i++)
     {
       // Number of values stored at this Data item:
       unsigned n_value = Solid_data_pt[i]->nvalue();
  
       // Pin all values
       for (unsigned k = 0; k < n_value; k++)
       {
         Solid_data_pt[i]->pin(k);
       }
     }
   }

References i, k, and 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.

   {
     // Counter for the number of values:
     unsigned value_count = 0;
  
     // Number of solid Data items:
     unsigned n_data = Solid_data_pt.size();
  
     // Loop over all solid Data items:
     for (unsigned i = 0; i < n_data; i++)
     {
       // Number of values stored at this Data item:
       unsigned n_value = Solid_data_pt[i]->nvalue();
  
       // Loop over all values
       for (unsigned k = 0; k < n_value; k++)
       {
         // Shorthand
         double v0 = Pointwise_aitken_solid_value[value_count][0];
         double v1 = Pointwise_aitken_solid_value[value_count][1];
         double v2 = Pointwise_aitken_solid_value[value_count][2];
  
         double new_value = v2;
  
         double max_diff = std::max(std::fabs(v1 - v0), std::fabs(v2 - v1));
         if (max_diff > 1.0e-10)
         {
           new_value = v2 - std::pow((v2 - v1), int(2)) / (v2 - 2.0 * v1 + v0);
         }
         Solid_data_pt[i]->set_value(k, new_value);
  
         // Increment counter
         value_count++;
       }
     }
  
     // Reset the counter for the Aitken convergence check
     // (setting counter to -1 forces three new genuine
     // iterates to be computed).
     Pointwise_aitken_counter = -1;
   }

References boost::multiprecision::fabs(), i, k, max, Pointwise_aitken_counter, Pointwise_aitken_solid_value, Eigen::bfloat16_impl::pow(), Solid_data_pt, v1(), and v2().

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.

   {
     // Get rid of the previous submeshes
     flush_sub_meshes();
  
     // Add original submeshes
     unsigned orig_n_sub_mesh = Orig_sub_mesh_pt.size();
     for (unsigned i = 0; i < orig_n_sub_mesh; i++)
     {
       add_sub_mesh(Orig_sub_mesh_pt[i]);
     }
  
     // Rebuild global mesh
     rebuild_global_mesh();
   }

References oomph::Problem::add_sub_mesh(), oomph::Problem::flush_sub_meshes(), i, Orig_sub_mesh_pt, and oomph::Problem::rebuild_global_mesh().

Referenced by segregated_solve().

◆ reset_timer()

void oomph::SegregatableFSIProblem::reset_timer ( )

inline

Reset timer.

     {
       T_spent_on_actual_solve = 0.0;
       T_ref = clock();
       Timer_has_been_halted = false;
     }

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)

     {
       T_ref = clock();
       Timer_has_been_halted = false;
     }

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.

   {
     // Number of fluid Data items:
     unsigned n_data = Fluid_data_pt.size();
  
     // Loop over all fluid Data items:
     for (unsigned i = 0; i < n_data; i++)
     {
       // Number of values stored at this Data item:
       unsigned n_value = Fluid_data_pt[i]->nvalue();
  
       // Pin all values
       for (unsigned k = 0; k < n_value; k++)
       {
         if (Fluid_value_is_pinned[i][k])
         {
           Fluid_data_pt[i]->pin(k);
         }
         else
         {
           Fluid_data_pt[i]->unpin(k);
         }
       }
     }
   }

References Fluid_data_pt, Fluid_value_is_pinned, i, and k.

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.

   {
     // Number of solid Data items:
     unsigned n_data = Solid_data_pt.size();
  
     // Loop over all solid Data items:
     for (unsigned i = 0; i < n_data; i++)
     {
       // Number of values stored at this Data item:
       unsigned n_value = Solid_data_pt[i]->nvalue();
  
       // Pin all values
       for (unsigned k = 0; k < n_value; k++)
       {
         if (Solid_value_is_pinned[i][k])
         {
           Solid_data_pt[i]->pin(k);
         }
         else
         {
           Solid_data_pt[i]->unpin(k);
         }
       }
     }
   }

References i, k, 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.

   {
     // Initialise timer for essential bits of code
     reset_timer();
     // Start timer for overall solve
     clock_t t_total_start = clock();
  
     // If convergence is based on max. global residual we may as well
     // document it...
     bool get_max_global_residual = Doc_max_global_residual;
     if (Convergence_criterion ==
         Assess_convergence_based_on_max_global_residual)
     {
       get_max_global_residual = true;
     }
  
     // Create object to doc convergence stats
     PicardConvergenceData conv_data;
  
     // Initialise total time for computation of global residuals
     double cpu_for_global_residual = 0.0;
  
     // Update anything that needs updating
     actions_before_segregated_solve();
  
     // Set flags to values that are appropriate if Picard iteration
     // does not converge with Max_picard iterations
     bool converged = false;
     unsigned iter_taken = Max_picard;
  
     // This one will be overwritten during the convergence checks
     double tol_achieved = 0.0;
  
     // Store the current values of the solid dofs as reference values
     // and for the pointwise Aitken extrapolation
     store_solid_dofs();
  
     // Loop over Picard iterations
     //----------------------------
     for (unsigned iter = 1; iter <= Max_picard; iter++)
     {
       // Calculate the initial residuals
       if (iter == 1)
       {
         // Problem is always non-linear?
         // Perform any actions before the convergence check
         actions_before_segregated_convergence_check();
  
         double max_res = 0.0;
         if (get_max_global_residual)
         {
           clock_t t_start = clock();
           restore_solid_dofs();
           restore_fluid_dofs();
           rebuild_monolithic_mesh();
           assign_eqn_numbers();
           // This is now a full problem
           Solve_type = Full_solve;
           DoubleVector residual;
           get_residuals(residual);
           // Get maximum residuals using our own abscmp function
           max_res = residual.max();
           clock_t t_end = clock();
           cpu_for_global_residual += double(t_end - t_start) / CLOCKS_PER_SEC;
         }
  
         oomph_info << "==================================================\n";
         oomph_info << "Initial iteration             : " << 0 << std::endl;
         oomph_info << "RMS  change           :       " << 0 << std::endl;
         oomph_info << "Max. change           :       " << 0 << std::endl;
         oomph_info << "RMS norm              :       " << 0 << std::endl;
         if (get_max_global_residual)
         {
           oomph_info << "Max. global residual  :       " << max_res
                      << std::endl;
         }
         oomph_info << "==================================================\n\n";
  
         // Check for convergence, but this only makes sense
         // for the maximum (rather than relative case)
         if ((Convergence_criterion ==
              Assess_convergence_based_on_max_global_residual) &&
             (max_res < Convergence_tolerance))
         {
           oomph_info
             << "\n\n\n////////////////////////////////////////////////////////"
             << "\nPicard iteration converged after " << 0 << " steps!"
             << std::endl
             << "Convergence was based on max. residual of coupled eqns \n"
             << "being less than " << Convergence_tolerance << "." << std::endl
             << "////////////////////////////////////////////////////////\n\n\n"
             << std::endl;
  
           // Converged, so bail out
           // Number of iterations taken
           iter_taken = 0;
  
           // We have converged (overwrites default of false)
           conv_data.set_solver_converged();
  
           // Break loop using a GO TO! This is the first (and hopefully
           // the last) one in the whole of oomph-lib. Here it's
           // it's actually the cleanest way to exit from these
           // nested control structures
           goto jump_out_of_picard;
         }
       }
  
       // Stage 1: Freeze wall and solve single-physics fluid problem
       //------------------------------------------------------------
       // Pin the solid dofs, restore the pinned status of the fluid dofs
       // and re-assign the equation numbers
       restore_fluid_dofs();
       pin_solid_dofs();
       use_only_fluid_elements();
       assign_eqn_numbers();
  
       // Solve the fluid problem for the current wall geometry
       oomph_info << "\n\nDOING FLUID SOLVE\n\n";
       // This is a fluid solve at the moment done by a newton solve
       Solve_type = Fluid_solve;
       newton_solve();
  
       // Stage 2: Freeze fluid variables and update wall shape
       //------------------------------------------------------
  
       // Now restore the pinned status of the wall and pin the fluid
       // dofs in anticipation of the wall update:
       restore_solid_dofs();
       pin_fluid_dofs();
       use_only_solid_elements();
       assign_eqn_numbers();
  
       // Solve the solid problem for the wall solution
       oomph_info << "\n\nDOING SOLID SOLVE\n\n";
       // This is a solid solve, at the moment done by a newton method
       Solve_type = Solid_solve;
       newton_solve();
  
       // Under-relax, either by classical relaxation or by Irons & Tuck
       // Note that we are under-relaxing before the convergence check
       // because under-relaxtion may be required to acheieve any
       // kind of convergence. If the convergence check is on the RELATIVE
       // change of the residuals, however, then a small under-relaxation
       // parameter will cause a false convergence. You have been warned!
       under_relax_solid();
  
       // Stage 3: Convergence check (possibly again after pointwise Aitken
       //------------------------------------------------------------------
       // extrapolation)
       //---------------
       // Assume that we are not doing Aitken acceleration
       Recheck_convergence_after_pointwise_aitken = false;
       do
       {
         // Perform any actions before the convergence check
         actions_before_segregated_convergence_check();
  
         // Get the change in the solid variables
         double rms_change;
         double max_change;
         double rms_norm;
         double max_res = 0.0;
         get_solid_change(rms_change, max_change, rms_norm);
  
  
         // If we are computing the maximum global residual, do so
         if (get_max_global_residual)
         {
           clock_t t_start = clock();
  
           // Free all dofs so the residuals of the global equations are computed
           restore_solid_dofs();
           restore_fluid_dofs();
           rebuild_monolithic_mesh();
           assign_eqn_numbers();
  
           // We are now treating this as a full solve
           Solve_type = Full_solve;
  
           // Get the residuals
           DoubleVector residual;
           get_residuals(residual);
  
           // Get maximum residuals, using our own abscmp function
           max_res = residual.max();
  
           clock_t t_end = clock();
           cpu_for_global_residual += double(t_end - t_start) / CLOCKS_PER_SEC;
         }
  
         oomph_info << "==================================================\n";
         oomph_info << "Iteration             : " << iter << std::endl;
         oomph_info << "RMS  change           :       " << rms_change
                    << std::endl;
         oomph_info << "Max. change           :       " << max_change
                    << std::endl;
         oomph_info << "RMS norm              :       " << rms_norm << std::endl;
         if (get_max_global_residual)
         {
           oomph_info << "Max. global residual  :       " << max_res
                      << std::endl;
         }
         oomph_info << "==================================================\n\n";
  
         // Check for convergence
         switch (Convergence_criterion)
         {
           case Assess_convergence_based_on_absolute_solid_change:
             tol_achieved = max_change;
             if (tol_achieved < Convergence_tolerance)
             {
               oomph_info
                 << "\n\n\n/////////////////////////////////////////////////////"
                    "///"
                 << "\nPicard iteration converged after " << iter << " steps!"
                 << std::endl
                 << "Convergence was based on absolute change in solid dofs \n"
                 << "being less than " << Convergence_tolerance << "."
                 << std::endl
                 << "////////////////////////////////////////////////////////"
                    "\n\n\n"
                 << std::endl;
               converged = true;
             }
             break;
  
  
           case Assess_convergence_based_on_relative_solid_change:
             tol_achieved = std::fabs(rms_change / rms_norm);
             if (tol_achieved < Convergence_tolerance)
             {
               oomph_info
                 << "\n\n\n/////////////////////////////////////////////////////"
                    "//"
                 << "\nPicard iteration converged after " << iter << " steps!"
                 << std::endl
                 << "Convergence was based on relative change in solid dofs \n"
                 << "being less than " << Convergence_tolerance << "."
                 << std::endl
                 << "////////////////////////////////////////////////////////"
                    "\n\n\n"
                 << std::endl;
               converged = true;
             }
             break;
  
           case Assess_convergence_based_on_max_global_residual:
             tol_achieved = max_res;
             if (tol_achieved < Convergence_tolerance)
             {
               oomph_info
                 << "\n\n\n/////////////////////////////////////////////////////"
                    "///"
                 << "\nPicard iteration converged after " << iter << " steps!"
                 << std::endl
                 << "Convergence was based on max. residual of coupled eqns \n"
                 << "being less than " << Convergence_tolerance << "."
                 << std::endl
                 << "////////////////////////////////////////////////////////"
                    "\n\n\n"
                 << std::endl;
               converged = true;
             }
             break;
         }
  
         // If converged bail out
         if (converged)
         {
           // Number of iterations taken
           iter_taken = iter;
  
           // We have converged (overwrites default of false)
           conv_data.set_solver_converged();
  
           // Break loop using a GO TO! This is the first (and hopefully
           // the last) one in the whole of oomph-lib. Here it's
           // it's actually the cleanest way to exit from these
           // nested control structures
           goto jump_out_of_picard;
         }
  
         // Store the current values of the solid dofs as reference values
         // and for the pointwise Aitken extrapolation
         store_solid_dofs();
  
         // Correct wall shape by pointwise Aitken extrapolation if possible
         //-----------------------------------------------------------------
         // and desired
         //------------
         // This is an acceleration method for the (possibly under-relaxed)
         // sequence of iterates.
         if ((3 == Pointwise_aitken_counter) && (Use_pointwise_aitken) &&
             (iter > Pointwise_aitken_start))
         {
           pointwise_aitken_extrapolate();
  
           // Repeat the convergence check
           Recheck_convergence_after_pointwise_aitken = true;
         }
         else
         {
           // Didn't change anything: Don't repeat the convergence check
           Recheck_convergence_after_pointwise_aitken = false;
         }
       }
       // Repeat convergence while we are doing aitken extrapolation
       while (Recheck_convergence_after_pointwise_aitken);
  
     } // End of loop over iterations
  
  
     // Jump address for converged or diverged iteration
   jump_out_of_picard:
  
     // Reset everything
     restore_solid_dofs();
     restore_fluid_dofs();
     rebuild_monolithic_mesh();
     assign_eqn_numbers();
     // This is a full solve again
     Solve_type = Full_solve;
  
     // Do any updates that are required
     actions_after_segregated_solve();
  
     // Number of iterations (either this is still Max_iter from
     // the initialisation or it's been overwritten on convergence)
     conv_data.niter() = iter_taken;
  
     // Total cpu time
     clock_t t_total_end = clock();
     conv_data.cpu_total() =
       double(t_total_end - t_total_start) / CLOCKS_PER_SEC;
  
     // Total essential cpu time (exluding doc etc)
     conv_data.essential_cpu_total() = t_spent_on_actual_solve();
  
     // cpu time for check/doc of global residual
     conv_data.cpu_for_global_residual() = cpu_for_global_residual;
  
     // Final tolerance achieved by the iteration
     conv_data.tol_achieved() = tol_achieved;
  
     // Doc non-convergence
     if (!converged)
     {
       switch (Convergence_criterion)
       {
         case Assess_convergence_based_on_absolute_solid_change:
           oomph_info
             << "\n\n\n////////////////////////////////////////////////////////"
             << "\nPicard iteration did not converge after " << iter_taken
             << " steps!" << std::endl
             << "Convergence was based on absolute change in solid dofs \n"
             << "being less than " << Convergence_tolerance << " " << std::endl
             << "but we achieved only " << tol_achieved << "." << std::endl
             << "////////////////////////////////////////////////////////\n\n\n"
             << std::endl;
           // Throw an error indicating if we ran out of iterations
           if (iter_taken == Max_picard)
           {
             throw SegregatedSolverError(true);
           }
           else
           {
             throw SegregatedSolverError(false);
           }
           break;
  
  
         case Assess_convergence_based_on_relative_solid_change:
           oomph_info
             << "\n\n\n///////////////////////////////////////////////////////"
             << "\nPicard iteration did not converge after " << iter_taken
             << " steps!" << std::endl
             << "Convergence was based on relative change in solid dofs \n"
             << "being less than " << Convergence_tolerance << " " << std::endl
             << "but we achieved only " << tol_achieved << "." << std::endl
             << "////////////////////////////////////////////////////////\n\n\n"
             << std::endl;
           // Throw an error indicating if we ran out of iterations
           if (iter_taken == Max_picard)
           {
             throw SegregatedSolverError(true);
           }
           else
           {
             throw SegregatedSolverError(false);
           }
           break;
  
         case Assess_convergence_based_on_max_global_residual:
           oomph_info
             << "\n\n\n////////////////////////////////////////////////////////"
             << "\nPicard iteration did not converge after " << iter_taken
             << " steps!" << std::endl
             << "Convergence was based on max. residual of coupled eqns \n"
             << "being less than " << Convergence_tolerance << " " << std::endl
             << "but we achieved only " << tol_achieved << "." << std::endl
  
             << "////////////////////////////////////////////////////////\n\n\n"
             << std::endl;
           // Throw an error indicating if we ran out of iterations
           if (iter_taken == Max_picard)
           {
             throw SegregatedSolverError(true);
           }
           else
           {
             throw SegregatedSolverError(false);
           }
           break;
       }
     }
  
     return conv_data;
   }

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, oomph::Problem::assign_eqn_numbers(), Convergence_criterion, Convergence_tolerance, oomph::PicardConvergenceData::cpu_for_global_residual(), oomph::PicardConvergenceData::cpu_total(), Doc_max_global_residual, oomph::PicardConvergenceData::essential_cpu_total(), boost::multiprecision::fabs(), Fluid_solve, Full_solve, oomph::Problem::get_residuals(), get_solid_change(), oomph::DoubleVector::max(), Max_picard, oomph::Problem::newton_solve(), oomph::PicardConvergenceData::niter(), oomph::oomph_info, 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(...).

   {
     // If we are doing a full setup
     if (full_setup_of_fluid_and_solid_dofs)
     {
       // Identify the fluid and solid Data
       Vector<Data*> fluid_data_pt;
       Vector<Data*> solid_data_pt;
       identify_fluid_and_solid_dofs(
         fluid_data_pt, solid_data_pt, Fluid_mesh_pt, Solid_mesh_pt);
  
       if (Fluid_mesh_pt == 0)
       {
         oomph_info
           << std::endl
           << std::endl
           << "Warning: Your implementation of the pure virtual\n"
           << "         function identify_fluid_and_solid_dofs(...)\n"
           << "         returned a NULL pointer for Fluid_mesh_pt.\n"
           << "         --> The fluid elements will remain activated\n"
           << "         during the solid solve. This is inefficient!\n"
           << "         You should combine all fluid elements into a combined\n"
           << "         mesh and specify this mesh in your\n"
           << "         implementation of \n\n"
           << "         "
              "SegregatableFSIProblem::identify_fluid_and_solid_dofs(...)"
           << std::endl
           << std::endl;
       }
  
  
       if (Solid_mesh_pt == 0)
       {
         oomph_info
           << std::endl
           << std::endl
           << "Warning: Your implementation of the pure virtual\n"
           << "         function identify_fluid_and_solid_dofs(...)\n"
           << "         returned a NULL pointer for Solid_mesh_pt.\n"
           << "         --> The solid elements will remain activated\n"
           << "         during the fluid solve. This is inefficient!\n"
           << "         You should combine all solid elements into a combined\n"
           << "         mesh and specify this mesh in your\n"
           << "         implementation of \n\n"
           << "         "
              "SegregatableFSIProblem::identify_fluid_and_solid_dofs(...)"
           << std::endl
           << std::endl;
       }
  
       // Back up the pointers to the submeshes in the original problem
       // so we can restore the problem when we're done
       unsigned orig_n_sub_mesh = nsub_mesh();
       Orig_sub_mesh_pt.resize(orig_n_sub_mesh);
       for (unsigned i = 0; i < orig_n_sub_mesh; i++)
       {
         Orig_sub_mesh_pt[i] = mesh_pt(i);
       }
  
       // Fluid
       //------
  
       // Reset
       Fluid_data_pt.clear();
       Fluid_value_is_pinned.clear();
  
       // Make space for fluid data items
       unsigned n_fluid_data = fluid_data_pt.size();
       Fluid_data_pt.resize(n_fluid_data);
       Fluid_value_is_pinned.resize(n_fluid_data);
  
       // Counter for number of fluid values
       unsigned n_fluid_values = 0;
  
       // Loop over fluid data
       for (unsigned i = 0; i < n_fluid_data; i++)
       {
         // Copy data
         Fluid_data_pt[i] = fluid_data_pt[i];
  
         // Number of values stored at this Data item:
         unsigned n_value = fluid_data_pt[i]->nvalue();
         Fluid_value_is_pinned[i].resize(n_value);
  
         // Copy pinned status for all values
         for (unsigned k = 0; k < n_value; k++)
         {
           Fluid_value_is_pinned[i][k] = fluid_data_pt[i]->is_pinned(k);
  
           // Increment counter for number of fluid values
           n_fluid_values++;
         }
       }
  
  
       // Solid
       //------
  
       // Reset
       Solid_data_pt.clear();
       Solid_value_is_pinned.clear();
       Previous_solid_value.clear();
       Pointwise_aitken_solid_value.clear();
       Del_irons_and_tuck.clear();
  
  
       unsigned n_solid_data = solid_data_pt.size();
  
       // Make space for solid data items
       unsigned nsolid_data = solid_data_pt.size();
       Solid_data_pt.resize(nsolid_data);
       Solid_value_is_pinned.resize(nsolid_data);
  
       // Counter for number of solid values
       unsigned n_solid_values = 0;
  
       // Loop over solid data
       for (unsigned i = 0; i < n_solid_data; i++)
       {
         // Copy data
         Solid_data_pt[i] = solid_data_pt[i];
  
         // Number of values stored at this Data item:
         unsigned n_value = solid_data_pt[i]->nvalue();
         Solid_value_is_pinned[i].resize(n_value);
  
         // Copy pinned status for all values
         for (unsigned k = 0; k < n_value; k++)
         {
           Solid_value_is_pinned[i][k] = solid_data_pt[i]->is_pinned(k);
  
           // Increment counter for number of solid values
           n_solid_values++;
         }
       }
  
       // Make space for previous solid values
       Previous_solid_value.resize(n_solid_values);
  
       // Allocate storage and initialise Irons and Tuck extrapolation
       if (Use_irons_and_tuck_extrapolation)
       {
         Del_irons_and_tuck.resize(n_solid_values);
       }
  
       // Make space for pointwise Aitken extrapolation
       if (Use_pointwise_aitken)
       {
         Pointwise_aitken_solid_value.resize(n_solid_values);
         for (unsigned i = 0; i < n_solid_values; i++)
         {
           Pointwise_aitken_solid_value[i].resize(3);
         }
       }
  
     } // End of full setup
  
  
     // Initialise Irons and Tuck relaxation factor
     R_irons_and_tuck = 1.0 - Omega_relax;
  
     // Initialise Irons and Tuck delta values
     unsigned n_del = Del_irons_and_tuck.size();
     for (unsigned i = 0; i < n_del; i++)
     {
       Del_irons_and_tuck[i] = 1.0e20;
     }
  
     // Initialise counter for the number of pointwise Aitken values stored
     Pointwise_aitken_counter = 0;
   }

References Del_irons_and_tuck, Fluid_data_pt, Fluid_mesh_pt, Fluid_value_is_pinned, i, identify_fluid_and_solid_dofs(), k, oomph::Problem::mesh_pt(), oomph::Problem::nsub_mesh(), Omega_relax, oomph::oomph_info, 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.

   {
     // Find out how many timesteppers there are
     unsigned n_time_steppers = ntime_stepper();
  
     // Vector of bools to store the is_steady status of the various
     // timesteppers when we came in here
     std::vector<bool> was_steady(n_time_steppers);
  
     // Loop over them all and make them (temporarily) static
     for (unsigned i = 0; i < n_time_steppers; i++)
     {
       was_steady[i] = time_stepper_pt(i)->is_steady();
       time_stepper_pt(i)->make_steady();
     }
  
     // Create object to doc convergence stats
     PicardConvergenceData conv_data;
  
     // Solve the non-linear problem by the segregated solver
     try
     {
       conv_data = segregated_solve();
     }
     // Catch any exceptions thrown in the segregated solver
     catch (SegregatedSolverError& error)
     {
       if (!error.Ran_out_of_iterations)
       {
         std::ostringstream error_stream;
         error_stream << "Error occured in Segregated solver. " << std::endl;
         throw OomphLibError(
           error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
       }
       else
       {
         oomph_info << "Note: Ran out of iterations but continuing anyway"
                    << std::endl;
       }
     }
  
     // Reset the is_steady status of all timesteppers that
     // weren't already steady when we came in here and reset their
     // weights
     for (unsigned i = 0; i < n_time_steppers; i++)
     {
       if (!was_steady[i])
       {
         time_stepper_pt(i)->undo_make_steady();
       }
     }
  
     // Since we performed a steady solve, the history values
     // now have to be set as if we had performed an impulsive start from
     // the current solution. This ensures that the time-derivatives
     // evaluate to zero even now that the timesteppers have been
     // reactivated.
     assign_initial_values_impulsive();
  
     // Return the convergence data
     return conv_data;
   }

References oomph::Problem::assign_initial_values_impulsive(), calibrate::error, i, oomph::TimeStepper::is_steady(), oomph::TimeStepper::make_steady(), oomph::Problem::ntime_stepper(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::oomph_info, segregated_solve(), oomph::Problem::time_stepper_pt(), and oomph::TimeStepper::undo_make_steady().

◆ 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.

   {
     // Counter for the number of values:
     unsigned value_count = 0;
  
     // Number of solid Data items:
     unsigned n_data = Solid_data_pt.size();
  
     // Loop over all solid Data items:
     for (unsigned i = 0; i < n_data; i++)
     {
       // Number of values stored at this Data item:
       unsigned n_value = Solid_data_pt[i]->nvalue();
  
       // Loop over all values
       for (unsigned k = 0; k < n_value; k++)
       {
         // Make backup
         Previous_solid_value[value_count] = Solid_data_pt[i]->value(k);
  
         // Store in pointwise Aitken history
         if (Use_pointwise_aitken && (Pointwise_aitken_counter >= 0))
         {
           Pointwise_aitken_solid_value[value_count][Pointwise_aitken_counter] =
             Solid_data_pt[i]->value(k);
         }
  
         // Increment counter
         value_count++;
       }
     }
  
     // We stored another level of Aitken history values
     Pointwise_aitken_counter++;
   }

References i, k, 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.

     {
       halt_timer();
       double time = T_spent_on_actual_solve;
       restart_timer();
       return time;
     }

References halt_timer(), restart_timer(), T_spent_on_actual_solve, and oomph::Problem::time().

Referenced by segregated_solve().

◆ under_relax_solid()

void oomph::SegregatableFSIProblem::under_relax_solid ( )

private

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

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

   {
     // Irons and Tuck extrapolation/relaxation; an extension of Aitken's method
     //-------------------------------------------------------------------------
     if (Use_irons_and_tuck_extrapolation)
     {
       double top = 0.0;
       double den = 0.0;
       double crit = 0.0;
  
       // Counter for the number of values:
       unsigned value_count = 0;
  
       // Number of solid Data items:
       unsigned n_data = Solid_data_pt.size();
  
       // Loop over all solid Data items:
       for (unsigned i = 0; i < n_data; i++)
       {
         // Number of values stored at this Data item:
         unsigned n_value = Solid_data_pt[i]->nvalue();
  
         // Loop over all values
         for (unsigned k = 0; k < n_value; k++)
         {
           // Prediction from solid solver
           double new_solid_value = Solid_data_pt[i]->value(k);
  
           // Previus value
           double old_solid_value = Previous_solid_value[value_count];
  
           // Change
           double change = old_solid_value - new_solid_value;
  
           // Change of change
           double del2 = Del_irons_and_tuck[value_count] - change;
  
           // Update change
           Del_irons_and_tuck[value_count] = change;
  
           // Update top
           top += del2 * change;
  
           // Update denominator
           den += del2 * del2;
  
           // Update convergence criterion
           crit += std::fabs(change);
  
           // Increment counter
           value_count++;
         }
       }
  
       // Update relaxation factor. The if buffers the case in which
       // we haven't realised that we've converged (so that den=0).
       // This can happen, e.g. if the convergence assessment is based on the
       // global residual or during validation. In that case we
       // obviously don't want any changes to the iterates.
       if (den != 0.0)
       {
         double new_r = R_irons_and_tuck + (R_irons_and_tuck - 1.0) * top / den;
         R_irons_and_tuck = new_r;
       }
       else
       {
         R_irons_and_tuck = 0.0;
       }
  
       // Loop over all solid Data items for update
       value_count = 0;
       for (unsigned i = 0; i < n_data; i++)
       {
         // Number of values stored at this Data item:
         unsigned n_value = Solid_data_pt[i]->nvalue();
  
         // Loop over all values
         for (unsigned k = 0; k < n_value; k++)
         {
           // Compute relaxed/extrapolated value
           double new_value = Solid_data_pt[i]->value(k) +
                              R_irons_and_tuck * Del_irons_and_tuck[value_count];
  
           // Assign
           Solid_data_pt[i]->set_value(k, new_value);
  
           // Increment counter
           value_count++;
         }
       }
       return;
     }
  
     // Standard relaxation
     //--------------------
     else
     {
       // No relaxation: Can return immediately
       if (Omega_relax == 1.0) return;
  
       // Counter for the number of values:
       unsigned value_count = 0;
  
       // Number of solid Data items:
       unsigned n_data = Solid_data_pt.size();
  
       // Loop over all solid Data items:
       for (unsigned i = 0; i < n_data; i++)
       {
         // Number of values stored at this Data item:
         unsigned n_value = Solid_data_pt[i]->nvalue();
  
         // Loop over all values
         for (unsigned k = 0; k < n_value; k++)
         {
           // Prediction from solid solver
           double new_solid_value = Solid_data_pt[i]->value(k);
  
           // Previus value
           double old_solid_value = Previous_solid_value[value_count];
  
           // Relax
           Solid_data_pt[i]->set_value(k,
                                       Omega_relax * new_solid_value +
                                         (1.0 - Omega_relax) * old_solid_value);
  
           // Increment counter
           value_count++;
         }
       }
     }
   }

References Del_irons_and_tuck, boost::multiprecision::fabs(), i, k, 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.

   {
     // We shift the values, so shift_values is true
     return unsteady_segregated_solve(dt, true);
   }

◆ 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.

   {
     // Shift the time values and the dts according to the control flag
     if (shift_values)
     {
       shift_time_values();
     }
  
     // Advance global time and set current value of dt
     time_pt()->time() += dt;
     time_pt()->dt() = dt;
  
     // Find out how many timesteppers there are
     unsigned n_time_steppers = ntime_stepper();
  
     // Loop over them all and set the weights
     for (unsigned i = 0; i < n_time_steppers; i++)
     {
       time_stepper_pt(i)->set_weights();
     }
  
     // Now update anything that needs updating before the timestep
     // This could be time-dependent boundary conditions, for example.
     actions_before_implicit_timestep();
  
     // Extrapolate the solid data and then update fluid mesh during unsteady run
     extrapolate_solid_data();
  
     // Create object to doc convergence stats
     PicardConvergenceData conv_data;
  
     try
     {
       // Solve the non-linear problem for this timestep with Newton's method
       conv_data = segregated_solve();
     }
     // Catch any exceptions thrown in the segregated solver
     catch (SegregatedSolverError& error)
     {
       if (!error.Ran_out_of_iterations)
       {
         std::ostringstream error_stream;
         error_stream << "Error occured in Segregated solver. " << std::endl;
         throw OomphLibError(
           error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
       }
       else
       {
         oomph_info << "Note: Ran out of iterations but continuing anyway"
                    << std::endl;
       }
     }
  
     // Now update anything that needs updating after the timestep
     actions_after_implicit_timestep();
  
     return conv_data;
   }

References oomph::Problem::actions_after_implicit_timestep(), oomph::Problem::actions_before_implicit_timestep(), oomph::Time::dt(), calibrate::error, extrapolate_solid_data(), i, oomph::Problem::ntime_stepper(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::oomph_info, segregated_solve(), oomph::TimeStepper::set_weights(), oomph::Problem::shift_time_values(), oomph::Time::time(), oomph::Problem::time_pt(), and oomph::Problem::time_stepper_pt().

◆ 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.

   {
     // Wipe global mesh and rebuild it with just the fluid elements in it
     if (Fluid_mesh_pt != 0)
     {
       flush_sub_meshes();
       add_sub_mesh(Fluid_mesh_pt);
       rebuild_global_mesh();
     }
   }

References oomph::Problem::add_sub_mesh(), Fluid_mesh_pt, oomph::Problem::flush_sub_meshes(), and oomph::Problem::rebuild_global_mesh().

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.

   {
     // Wipe global mesh and rebuild it with just the solid elements in it
     if (Solid_mesh_pt != 0)
     {
       flush_sub_meshes();
       add_sub_mesh(Solid_mesh_pt);
       rebuild_global_mesh();
     }
   }

References oomph::Problem::add_sub_mesh(), oomph::Problem::flush_sub_meshes(), oomph::Problem::rebuild_global_mesh(), and Solid_mesh_pt.

Referenced by segregated_solve().

Member Data Documentation

◆ Convergence_criterion

int oomph::SegregatableFSIProblem::Convergence_criterion

private

Convergence criterion (enumerated flag)

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.

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.

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)

Referenced by SegregatableFSIProblem(), segregated_solve(), SegregatedFSICollapsibleChannelProblem< ELEMENT >::SegregatedFSICollapsibleChannelProblem(), and SegregatedFSIDrivenCavityProblem< ELEMENT >::SegregatedFSIDrivenCavityProblem().

◆ 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

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

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

Referenced by restore_fluid_dofs(), and setup_segregated_solver().

◆ Max_picard

unsigned oomph::SegregatableFSIProblem::Max_picard

protected

Max. number of Picard iterations.

Referenced by SegregatableFSIProblem(), segregated_solve(), and SegregatedFSIDrivenCavityProblem< ELEMENT >::SegregatedFSIDrivenCavityProblem().

◆ Omega_relax

double oomph::SegregatableFSIProblem::Omega_relax

private

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

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.

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).

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

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

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

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.

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.

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.

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

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

Referenced by restore_solid_dofs(), and setup_segregated_solver().

◆ Solve_type

int oomph::SegregatableFSIProblem::Solve_type

protected

Solve that is taking place (enumerated flag)

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)

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)

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

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

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?

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

Additional Inherited Members

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