Flow around a cylinder in rectangular domain. More...

Inheritance diagram for FlowAroundCylinderProblem< ELEMENT >:

Public Member Functions
Problem *	make_copy ()
	Make a copy for using in bifurcation tracking. More...

	FlowAroundCylinderProblem (GeomObject *cylinder_pt, const double &length, const double &height)
	Constructor. More...

	~FlowAroundCylinderProblem ()
	Destructor: clean up the memory. More...

void	set_boundary_conditions ()

void	actions_after_newton_solve ()
	Update the problem specs after solve (empty) More...

void	actions_before_newton_convergence_check ()

void	actions_before_newton_solve ()

void	actions_after_adapt ()
	After adaptation: Unpin pressure and pin redudant pressure dofs. More...

RefineableRectangleWithHoleMesh< ELEMENT > *	mesh_pt ()
	Access function for the specific mesh. More...

Mesh *&	mesh_pt (const unsigned &num)

	FlowAroundCylinderProblem (GeomObject *cylinder_pt, const double &length, const double &height)

	~FlowAroundCylinderProblem ()
	Destructor: clean up the memory. More...

void	set_boundary_conditions ()

void	actions_after_newton_solve ()
	Update the problem specs after solve (empty) More...

void	actions_before_newton_convergence_check ()

void	actions_before_newton_solve ()

void	actions_after_adapt ()
	After adaptation: Unpin pressure and pin redudant pressure dofs. More...

RefineableRectangleWithHoleMesh< BASE_ELEMENT > *	base_flow_mesh_pt ()
	Access function for the specific mesh. More...

RefineableRectangleWithHoleMesh< PERTURBED_ELEMENT > *	eigenproblem_mesh_pt ()
	Return a pointer to the specific mesh used. More...

void	add_eigenproblem ()

void	set_eigenvalue (const double &real, const double &imag)

void	pin_all_base_flow_dofs ()

void	unpin_all_base_flow_dofs ()

void	transfer_eigenfunction_as_initial_condition (DoubleVector &real, DoubleVector &imaginary)

void	doc_solution ()

	FlowAroundCylinderProblem (GeomObject *cylinder_pt, const double &length, const double &height)

void	actions_after_newton_solve ()
	Update the problem specs after solve (empty) More...

void	actions_before_newton_solve ()

void	actions_after_adapt ()
	After adaptation: Unpin pressure and pin redudant pressure dofs. More...

RefineableRectangleWithHoleMesh< ELEMENT > *	mesh_pt ()
	Access function for the specific mesh. More...

	FlowAroundCylinderProblem ()
	Constructor: More...

	~FlowAroundCylinderProblem ()
	Destructor: delete all dynamically allocated data. More...

void	apply_boundary_conditions ()
	Apply boundary conditions. More...

void	set_up_solver_and_preconditioner ()
	Set the chosen solver and preconditioner. More...

void	unsteady_simulation ()
	Timestep the problem. More...

void	actions_before_newton_solve ()
	Update the problem specs before solve. More...

void	actions_after_newton_solve ()
	Update the problem specs after solve (empty) More...

void	actions_before_adapt ()
	Actions before adapt: empty. More...

void	actions_after_adapt ()
	After adaptation: Unpin pressure and pin redundant pressure dofs. More...

void	actions_before_implicit_timestep ()

void	doc_solution (const bool &in_unsteady=false)
	Doc the solution. More...

void	doc_trace_node_velocities_and_pressure ()

void	dump_problem (char *filename) const
	Dump the entire problem. More...

void	read_problem (char *restart_file)
	Read the entire problem. 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

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

Private Types
enum	{ Lower_wall_boundary_id =0 , Outflow_boundary_id =1 , Upper_wall_boundary_id =2 , Inflow_boundary_id =3 , Cylinder_surface_boundary_id =4 }

Private Attributes
double	Domain_height
	Height of the domain. More...

double	Domain_length
	Length of the domain. More...

GeomObject *	Cylinder_pt
	The geometric cylinder. More...

bool	Eigenproblem_flag

Mesh *	Base_flow_mesh_pt

Mesh *	Eigenproblem_mesh_pt

Mesh *	Normalisation_mesh_pt

RefineableQuadMeshWithMovingCylinder< ELEMENT > *	Bulk_mesh_pt
	Pointer to the mesh with oscillating cylinder. More...

IterativeLinearSolver *	Solver_pt
	Oomph-lib iterative linear solver. More...

NavierStokesSchurComplementPreconditioner *	Prec_pt
	LSC Preconditioner for the linear solve. More...

Preconditioner *	F_matrix_preconditioner_pt
	Inexact solver for F block. More...

Additional Inherited Members
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 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...

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

virtual void	actions_after_newton_step ()

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

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

Detailed Description

template<class ELEMENT>
class FlowAroundCylinderProblem< ELEMENT >

Flow around a cylinder in rectangular domain.

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

Member Enumeration Documentation

◆ anonymous enum

template<class ELEMENT >

anonymous enum

private

Enumerator
Lower_wall_boundary_id
Outflow_boundary_id
Upper_wall_boundary_id
Inflow_boundary_id
Cylinder_surface_boundary_id

   {
     Lower_wall_boundary_id=0,
     Outflow_boundary_id=1,
     Upper_wall_boundary_id=2,
     Inflow_boundary_id=3,
     Cylinder_surface_boundary_id=4
   };

Constructor & Destructor Documentation

◆ FlowAroundCylinderProblem() [1/4]

template<class ELEMENT >

FlowAroundCylinderProblem< ELEMENT >::FlowAroundCylinderProblem	(	GeomObject *	cylinder_pt,
		const double &	length,
		const double &	height
	)

Constructor.

Constructor: Pass geometric object that represents central cylinder, and length and height of domain.

                                                                       :
  Domain_height(height), Domain_length(length), Cylinder_pt(cylinder_pt)
  
 {
  //Increase the maximum residuals so that we can get convergence on
  //the coarsest mesh
  Max_residuals = 100.0;
  
  if(!Global_Parameters::Read_in_eigenfunction_from_disk)
   {
    this->eigen_solver_pt() = new ARPACK;
    static_cast<ARPACK*>(eigen_solver_pt())->set_shift(50.0);
    static_cast<ARPACK*>(eigen_solver_pt())->narnoldi() = 70;
   }
  
  // Build mesh
  Problem::mesh_pt()=
   new RefineableRectangleWithHoleMesh<ELEMENT>(cylinder_pt,length,height);
  
  // Set error estimator
  Z2ErrorEstimator* error_estimator_pt=new Z2ErrorEstimator;
  mesh_pt()->spatial_error_estimator_pt()=error_estimator_pt;
  
  // Pin redudant pressure dofs
  RefineableNavierStokesEquations<2>::
   pin_redundant_nodal_pressures(mesh_pt()->element_pt());
  
  //Make the problem conventional form, so 
  //that the natural boundary condition is pseudo-traction-free
  NavierStokesEquations<2>::Gamma[0] = 0.0;
  NavierStokesEquations<2>::Gamma[1] = 0.0;
  
   using namespace Global_Parameters;
  
   // Pass pointer to Reynolds number to elements
   unsigned nelem=mesh_pt()->nelement();
   for (unsigned e=0;e<nelem;e++)
    {
     dynamic_cast<ELEMENT*>(mesh_pt()->element_pt(e))->re_pt()= &Re;
     dynamic_cast<ELEMENT*>(mesh_pt()->element_pt(e))->re_st_pt()=&Re;
    }
 }

References e(), oomph::Problem::eigen_solver_pt(), MeshRefinement::error_estimator_pt, Global_Physical_Variables::height(), oomph::Problem::Max_residuals, FlowAroundCylinderProblem< ELEMENT >::mesh_pt(), Global_Parameters::Re, and Global_Parameters::Read_in_eigenfunction_from_disk.

◆ ~FlowAroundCylinderProblem() [1/3]

template<class ELEMENT >

FlowAroundCylinderProblem< ELEMENT >::~FlowAroundCylinderProblem

Destructor: clean up the memory.

The destructor. Delete all dynamically allocated data.

Destructor clean up all memory allocated in the problem.

 {
  //Delete the error estimator
  delete mesh_pt()->spatial_error_estimator_pt();
  //Delete the mesh
  delete Problem::mesh_pt();
 }

References FlowAroundCylinderProblem< ELEMENT >::mesh_pt().

◆ FlowAroundCylinderProblem() [2/4]

template<class ELEMENT >

FlowAroundCylinderProblem< ELEMENT >::FlowAroundCylinderProblem	(	GeomObject *	cylinder_pt,
		const double &	length,
		const double &	height
	)

Constructor: Pass geometric object that represents central cylinder, and length and height of domain.

◆ ~FlowAroundCylinderProblem() [2/3]

template<class ELEMENT >

FlowAroundCylinderProblem< ELEMENT >::~FlowAroundCylinderProblem ( )

Destructor: clean up the memory.

◆ FlowAroundCylinderProblem() [3/4]

template<class ELEMENT >

FlowAroundCylinderProblem< ELEMENT >::FlowAroundCylinderProblem	(	GeomObject *	cylinder_pt,
		const double &	length,
		const double &	height
	)

Constructor: Pass geometric object that represents central cylinder, and length and height of domain.

◆ FlowAroundCylinderProblem() [4/4]

template<class ELEMENT >

FlowAroundCylinderProblem< ELEMENT >::FlowAroundCylinderProblem

Constructor:

Constructor.

                                                               :
   Bulk_mesh_pt(0),
   Solver_pt(0),
   Prec_pt(0),
   F_matrix_preconditioner_pt(0)
 {
   // Use BDF2
   add_time_stepper_pt(new BDF<2>);
  
   // Indicate that we're solving a steady problem
   time_stepper_pt(0)->make_steady();
  
   //-----------------
   // Set up the mesh:
   //-----------------
   // Create a OscillatingCylinder object to define the cylinder motion
   GlobalParameters::Cylinder_pt=
     new OscillatingCylinder(&GlobalParameters::Radius,
                             &GlobalParameters::Amplitude,
                             time_pt());
  
   // Make a new mesh and assign its pointer
   Bulk_mesh_pt=new RefineableQuadMeshWithMovingCylinder<ELEMENT>(
     GlobalParameters::Cylinder_pt,
     GlobalParameters::Annular_region_radius,
     GlobalParameters::Length_of_central_box,
     GlobalParameters::X_left,
     GlobalParameters::X_right,
     GlobalParameters::Height,
     time_stepper_pt());
  
   // Now assign its pointer
   Problem::mesh_pt()=Bulk_mesh_pt;
  
   // Set the error estimator: incase we want to use adaptive mesh refinement
   Bulk_mesh_pt->spatial_error_estimator_pt()=new Z2ErrorEstimator;
  
   // No limit on the number of refinements
   Bulk_mesh_pt->max_refinement_level()=100;
  
   // Set the maximum error bound
   Bulk_mesh_pt->max_permitted_error()=1.0e-04;
  
   // Set the minimum error bound
   Bulk_mesh_pt->min_permitted_error()=1.0e-08;
  
   //-----------------------------
   // Set the boundary conditions:
   //-----------------------------
   // Apply the boundary conditions
   apply_boundary_conditions();
  
   //-----------------------------------------------------------------
   // Complete the build of all elements so they are fully functional:
   //-----------------------------------------------------------------
   // Make it pseudo-traction-free
   NavierStokesEquations<2>::Gamma[0]=0.0;
   NavierStokesEquations<2>::Gamma[1]=0.0;
  
   // Pin redundant pressure dofs
   RefineableNavierStokesEquations<2>::
   pin_redundant_nodal_pressures(Bulk_mesh_pt->element_pt());
  
   // How many elements are there in the mesh?
   unsigned n_element=Bulk_mesh_pt->nelement();
  
   // Loop over the elements in the mesh
   for (unsigned e=0; e<n_element; e++)
   {
     // Upcast the e-th element in the mesh
     ELEMENT* el_pt=dynamic_cast<ELEMENT*>(Bulk_mesh_pt->element_pt(e));
  
     // Set the Reynolds number pointer
     el_pt->re_pt()=&GlobalParameters::Re;
  
     // Set the Womersley number (same as Re since St=1) pointer
     el_pt->re_st_pt()=&GlobalParameters::ReSt;
   }
  
   // Attach the boundary conditions to the mesh
   oomph_info << "Number of equations: " << assign_eqn_numbers() << std::endl;
 } // End of FlowAroundCylinderProblem

References oomph::Problem::add_time_stepper_pt(), GlobalParameters::Amplitude, GlobalParameters::Annular_region_radius, FlowAroundCylinderProblem< ELEMENT >::apply_boundary_conditions(), oomph::Problem::assign_eqn_numbers(), FlowAroundCylinderProblem< ELEMENT >::Bulk_mesh_pt, GlobalParameters::Cylinder_pt, e(), GlobalParameters::Height, GlobalParameters::Length_of_central_box, oomph::TimeStepper::make_steady(), oomph::oomph_info, GlobalParameters::Radius, GlobalParameters::Re, GlobalParameters::ReSt, oomph::Problem::time_pt(), oomph::Problem::time_stepper_pt(), GlobalParameters::X_left, and GlobalParameters::X_right.

◆ ~FlowAroundCylinderProblem() [3/3]

template<class ELEMENT >

FlowAroundCylinderProblem< ELEMENT >::~FlowAroundCylinderProblem ( )

Destructor: delete all dynamically allocated data.

Member Function Documentation

◆ actions_after_adapt() [1/4]

template<class ELEMENT >

void FlowAroundCylinderProblem< ELEMENT >::actions_after_adapt

inlinevirtual

After adaptation: Unpin pressure and pin redudant pressure dofs.

Actions after adaptation. Upin pressure dofs, pin all redundant pressure dofs, apply boundary conditions and pin the smoothed vorticity in any newly created elements.

Reimplemented from oomph::Problem.

   {
    //Pin both velocities at all boundaries
    //This is required in case the automatic stuff goes wrong
    unsigned num_bound = mesh_pt()->nboundary();
    for(unsigned ibound=0;ibound<num_bound;ibound++)
     {
      unsigned num_nod= mesh_pt()->nboundary_node(ibound);
      for (unsigned inod=0;inod<num_nod;inod++)
       {
        // Parallel, axially traction free outflow at downstream end
        if (ibound != 1)
         {
          mesh_pt()->boundary_node_pt(ibound,inod)->pin(0);
          mesh_pt()->boundary_node_pt(ibound,inod)->pin(1);
         }
       }
     }
    
    // Unpin all pressure dofs
    RefineableNavierStokesEquations<2>::
     unpin_all_pressure_dofs(mesh_pt()->element_pt());
     
     // Pin redundant pressure dofs
    RefineableNavierStokesEquations<2>::
     pin_redundant_nodal_pressures(mesh_pt()->element_pt());
   }

References oomph::RefineableNavierStokesEquations< DIM >::pin_redundant_nodal_pressures(), and oomph::RefineableNavierStokesEquations< DIM >::unpin_all_pressure_dofs().

◆ actions_after_adapt() [2/4]

template<class ELEMENT >

void FlowAroundCylinderProblem< ELEMENT >::actions_after_adapt ( )

inlinevirtual

After adaptation: Unpin pressure and pin redudant pressure dofs.

Reimplemented from oomph::Problem.

   {
    //Pin both velocities at all boundaries
    //This is required in case the automatic stuff goes wrong
    unsigned num_bound = Base_flow_mesh_pt->nboundary();
    for(unsigned ibound=0;ibound<num_bound;ibound++)
     {
      unsigned num_nod= Base_flow_mesh_pt->nboundary_node(ibound);
      for (unsigned inod=0;inod<num_nod;inod++)
       {
        // Parallel, axially traction free outflow at downstream end
        if (ibound != 1)
         {
          Base_flow_mesh_pt->boundary_node_pt(ibound,inod)->pin(0);
          Base_flow_mesh_pt->boundary_node_pt(ibound,inod)->pin(1);
         }
       }
     }
    
    // Unpin all pressure dofs
    RefineableNavierStokesEquations<2>::
     unpin_all_pressure_dofs(Base_flow_mesh_pt->element_pt());
     
     // Pin redundant pressure dofs
    RefineableNavierStokesEquations<2>::
     pin_redundant_nodal_pressures(Base_flow_mesh_pt->element_pt());
  
    if(Eigenproblem_flag)
     {
      // Unpin all pressure dofs
      RefineableLinearisedNavierStokesEquations::
       unpin_all_pressure_dofs(Eigenproblem_mesh_pt->element_pt());
      
      // Pin redudant pressure dofs
      RefineableLinearisedNavierStokesEquations::
       pin_redundant_nodal_pressures(Eigenproblem_mesh_pt->element_pt());
      
      // First interaction (base state velocities)
      Multi_domain_functions::
       setup_multi_domain_interaction<BASE_ELEMENT>
       (this,Eigenproblem_mesh_pt,Base_flow_mesh_pt,0);
      
      // Second interaction (base state velocity derivatives w.r.t. space)
      Multi_domain_functions::
       setup_multi_domain_interaction<BASE_ELEMENT>
       (this,Eigenproblem_mesh_pt,Base_flow_mesh_pt,1);
      
      //Reset the boundary conditions to be safe
      this->set_boundary_conditions();
      
      //Loop over all the (fluid) elements 
      unsigned n_element = Eigenproblem_mesh_pt->nelement();
      for(unsigned e=0;e<n_element;e++)
       {
        //Cast to the particular element type, this is necessary because
        //the base elements don't have the member functions that we're about
        //to call!
        PERTURBED_ELEMENT *el_pt = 
         dynamic_cast<PERTURBED_ELEMENT*>(Eigenproblem_mesh_pt->element_pt(e));
        
        //Pin the pressure normalisation dofs (can't be handled automatically
        //because it's a choice we've made)
        el_pt->pin_pressure_normalisation_dofs();
       }
  
      {
       //Pull out a pointer to the Reynolds number
       double* local_re_pt = Normalisation_mesh_pt->element_pt(0)
        ->internal_data_pt(0)->value_pt(2);
       
       // Pass pointer to Reynolds number to elements
       unsigned nelem=Base_flow_mesh_pt->nelement();
       for (unsigned e=0;e<nelem;e++)
        {
         BASE_ELEMENT* el_pt = 
          dynamic_cast<BASE_ELEMENT*>(Base_flow_mesh_pt->element_pt(e));
         
         //Set the Reynolds number for each element 
         //(yes we could have different Reynolds number in each element!!)
         el_pt->re_pt() = local_re_pt;//&Re;
         
         //Set the product of Reynolds and Strouhal numbers
         el_pt->re_st_pt() = local_re_pt; //&Re;
         
         //and add as external data
         el_pt->add_external_data(
          Normalisation_mesh_pt->element_pt(0)->internal_data_pt(0));
        }
      }
     }
  
   }

References e(), oomph::RefineableLinearisedNavierStokesEquations::pin_redundant_nodal_pressures(), oomph::RefineableNavierStokesEquations< DIM >::pin_redundant_nodal_pressures(), oomph::RefineableLinearisedNavierStokesEquations::unpin_all_pressure_dofs(), and oomph::RefineableNavierStokesEquations< DIM >::unpin_all_pressure_dofs().

◆ actions_after_adapt() [3/4]

template<class ELEMENT >

void FlowAroundCylinderProblem< ELEMENT >::actions_after_adapt ( )

inlinevirtual

After adaptation: Unpin pressure and pin redudant pressure dofs.

Reimplemented from oomph::Problem.

   {
    // Unpin all pressure dofs
    RefineableNavierStokesEquations<2>::
     unpin_all_pressure_dofs(mesh_pt()->element_pt());
     
     // Pin redundant pressure dofs
    RefineableNavierStokesEquations<2>::
     pin_redundant_nodal_pressures(mesh_pt()->element_pt());
     
    // Now set the first pressure dof in the last element to 0.0
    dynamic_cast<ELEMENT*>(mesh_pt()->element_pt((mesh_pt()->nelement())-1))->
     fix_pressure(0,0.0);
  
    // update the parabolic tangential inflow velocity
    //double height=0.41/0.1;
    unsigned ibound=3;
    double ycoord,uy;
    double um = 0.3; 
    unsigned num_nod= mesh_pt()->nboundary_node(ibound);
    for (unsigned inod=0;inod<num_nod;inod++)
     {
      ycoord = mesh_pt()->boundary_node_pt(ibound,inod)->x(1);
      uy = 1./0.2*4.0*um*ycoord*(Domain_height-ycoord)/
       Domain_height/Domain_height;
  
      // Tangential flow
      mesh_pt()->boundary_node_pt(ibound,inod)->set_value(0,uy);
     }
  
  
   } // end_of_actions_after_adapt

◆ actions_after_adapt() [4/4]

template<class ELEMENT >

void FlowAroundCylinderProblem< ELEMENT >::actions_after_adapt ( )

virtual

After adaptation: Unpin pressure and pin redundant pressure dofs.

Reimplemented from oomph::Problem.

◆ actions_after_newton_solve() [1/4]

template<class ELEMENT >

void FlowAroundCylinderProblem< ELEMENT >::actions_after_newton_solve ( )

inlinevirtual

Update the problem specs after solve (empty)

Reimplemented from oomph::Problem.

1110 {}

◆ actions_after_newton_solve() [2/4]

template<class ELEMENT >

void FlowAroundCylinderProblem< ELEMENT >::actions_after_newton_solve ( )

inlinevirtual

Update the problem specs after solve (empty)

Report the eigenvalue

Reimplemented from oomph::Problem.

   {
    //Dump out the eigenvalue
    if(Eigenproblem_flag)
     {
    std::cout << "Eigenvalue is " <<
     Normalisation_mesh_pt->element_pt(0)->internal_data_pt(0)->value(0)
              << " + " << 
     Normalisation_mesh_pt->element_pt(0)->internal_data_pt(0)->value(1)
              << "I\n";
  
    std::cout << "Critical Reynolds number is " <<
     Normalisation_mesh_pt->element_pt(0)->internal_data_pt(0)->value(2)
              << "\n";
     }
   }

◆ actions_after_newton_solve() [3/4]

template<class ELEMENT >

void FlowAroundCylinderProblem< ELEMENT >::actions_after_newton_solve ( )

inlinevirtual

Update the problem specs after solve (empty)

Reimplemented from oomph::Problem.

986 {}

◆ actions_after_newton_solve() [4/4]

template<class ELEMENT >

void FlowAroundCylinderProblem< ELEMENT >::actions_after_newton_solve ( )

inlinevirtual

Update the problem specs after solve (empty)

Reimplemented from oomph::Problem.

449 {}

◆ actions_before_adapt()

template<class ELEMENT >

void FlowAroundCylinderProblem< ELEMENT >::actions_before_adapt ( )

inlinevirtual

Actions before adapt: empty.

Reimplemented from oomph::Problem.

452 {}

◆ actions_before_implicit_timestep()

template<class ELEMENT >

void FlowAroundCylinderProblem< ELEMENT >::actions_before_implicit_timestep

virtual

Actions to complete before an implicit timestep: Provide a perturbation to the solution

Actions before implicit timestep: Update the nodal positions and update the no-slip condition on the cylinder boundary

Reimplemented from oomph::Problem.

 {
   // Update the domain shape
   Bulk_mesh_pt->node_update();
  
   // ID of the cylinder boundary
   unsigned b=4;
  
   // Find the number of nodes on the cylinder boundary
   unsigned num_nod=Bulk_mesh_pt->nboundary_node(b);
  
   // Cylinder boundary: No slip; this implies that the velocity needs to be
   // updated in response to wall motion
   for (unsigned n=0; n<num_nod; n++)
   {
     // Which node are we dealing with?
     Node* node_pt=Bulk_mesh_pt->boundary_node_pt(b,n);
  
     // Apply no slip
     FSI_functions::apply_no_slip_on_moving_wall(node_pt);
   }
 } // End of actions_before_implicit_timestep()

References oomph::FSI_functions::apply_no_slip_on_moving_wall(), b, and n.

◆ actions_before_newton_convergence_check() [1/2]

template<class ELEMENT >

void FlowAroundCylinderProblem< ELEMENT >::actions_before_newton_convergence_check ( )

inlinevirtual

Any actions that are to be performed before the residual is checked in the Newton method, e.g. update any boundary conditions that depend upon variables of the problem; update any ‘dependent’ variables; or perform an update of the nodal positions in SpineMeshes etc. CAREFUL: This step should (and if the FD-based LinearSolver FD_LU is used, must) only update values that are pinned!

Reimplemented from oomph::Problem.

1112 {set_boundary_conditions();}

◆ actions_before_newton_convergence_check() [2/2]

template<class ELEMENT >

void FlowAroundCylinderProblem< ELEMENT >::actions_before_newton_convergence_check ( )

inlinevirtual

Any actions that are to be performed before the residual is checked in the Newton method, e.g. update any boundary conditions that depend upon variables of the problem; update any ‘dependent’ variables; or perform an update of the nodal positions in SpineMeshes etc. CAREFUL: This step should (and if the FD-based LinearSolver FD_LU is used, must) only update values that are pinned!

Reimplemented from oomph::Problem.

1199 {set_boundary_conditions();}

◆ actions_before_newton_solve() [1/4]

template<class ELEMENT >

void FlowAroundCylinderProblem< ELEMENT >::actions_before_newton_solve ( )

inlinevirtual

Update the problem specs before solve (empty; all prescribed velocities are constant along their respective boundares, therefore their FE interpolation onto the newly created nodes is sufficiently accurate)

Reimplemented from oomph::Problem.

1118 {}

◆ actions_before_newton_solve() [2/4]

template<class ELEMENT >

void FlowAroundCylinderProblem< ELEMENT >::actions_before_newton_solve ( )

inlinevirtual

Update the problem specs before solve (empty; all prescribed velocities are constant along their respective boundares, therefore their FE interpolation onto the newly created nodes is sufficiently accurate)

Reimplemented from oomph::Problem.

1205 {}

◆ actions_before_newton_solve() [3/4]

template<class ELEMENT >

void FlowAroundCylinderProblem< ELEMENT >::actions_before_newton_solve ( )

inlinevirtual

Update the problem specs before solve (empty; all prescribed velocities are constant along their respective boundares, therefore their FE interpolation onto the newly created nodes is sufficiently accurate)

Reimplemented from oomph::Problem.

992 {}

◆ actions_before_newton_solve() [4/4]

template<class ELEMENT >

void FlowAroundCylinderProblem< ELEMENT >::actions_before_newton_solve ( )

inlinevirtual

Update the problem specs before solve.

Reimplemented from oomph::Problem.

446 {}

◆ add_eigenproblem()

template<class ELEMENT >

void FlowAroundCylinderProblem< ELEMENT >::add_eigenproblem ( )

inline

   {
    Eigenproblem_flag = true;
    using namespace Global_Parameters;
   
    GeomObject* cylinder_pt = base_flow_mesh_pt()->domain_pt()->cylinder_pt();
    double length = base_flow_mesh_pt()->length();
    double height = base_flow_mesh_pt()->height();
    
    // Build mesh
    Eigenproblem_mesh_pt =
     new RefineableRectangleWithHoleMesh<PERTURBED_ELEMENT>(cylinder_pt,
                                                            length,height);
    
    // Set error estimator (not sure this will work with the peturbed problem) 
    Z2ErrorEstimator* error_estimator_pt=new Z2ErrorEstimator;
    eigenproblem_mesh_pt()->spatial_error_estimator_pt()=error_estimator_pt;
  
    // Maximum number of refinements (increase this if you want a finer mesh)
    //eigenproblem_mesh_pt()->max_refinement_level() = max_refinement_level;
    
    // Error targets for adaptive refinement
    //eigenproblem_mesh_pt()->max_permitted_error() = max_error_target; 
    //eigenproblem_mesh_pt()->min_permitted_error() = min_error_target; 
  
    eigenproblem_mesh_pt()->max_refinement_level() = 10;
    
    //that the natural boundary condition is pseudo-traction-free
    LinearisedNavierStokesEquations::Gamma[0] = 0.0;
    LinearisedNavierStokesEquations::Gamma[1] = 0.0;
    
    //Sort out normalisation
    using namespace Global_Parameters;
    
    LinearisedNavierStokesEigenfunctionNormalisationElement*
     normalisation_element_pt =
     new LinearisedNavierStokesEigenfunctionNormalisationElement(
      &Eigenfunction_normalisation);
    
    Normalisation_mesh_pt = new Mesh;
    Normalisation_mesh_pt->add_element_pt(normalisation_element_pt);
    
    //Pull out a pointer to the Reynolds number
    double* local_re_pt = Normalisation_mesh_pt->element_pt(0)
     ->internal_data_pt(0)->value_pt(2);
    //Set the value
    *local_re_pt = Re;
    
    //Need to set the parameters in the elements in the base mesh
    unsigned n_element = Eigenproblem_mesh_pt->nelement();
    for(unsigned e=0;e<n_element;e++)
     {
      //Cast to the particular element type, this is necessary because
      //the base elements don't have the member functions that we're about
      //to call!
      PERTURBED_ELEMENT *el_pt = 
       dynamic_cast<PERTURBED_ELEMENT*>(Eigenproblem_mesh_pt->element_pt(e));
      
      //There is no need for ALE
      el_pt->disable_ALE();
      
      //Set the Reynolds number for each element 
      //(yes we could have different Reynolds number in each element!!)
      el_pt->re_pt() = local_re_pt;//&Re;
      
      //Set the product of Reynolds and Strouhal numbers
      el_pt->re_st_pt() = local_re_pt; //&Re;
      
      //Set the eigenfunction normalisation element
      el_pt->set_eigenfunction_normalisation_element(normalisation_element_pt);
     }
    
  
    //Also set the Reynolds number in the original elements to be variable
    {
     // Pass pointer to Reynolds number to elements
     unsigned nelem=Base_flow_mesh_pt->nelement();
     for (unsigned e=0;e<nelem;e++)
      {
       BASE_ELEMENT* el_pt = 
        dynamic_cast<BASE_ELEMENT*>(Base_flow_mesh_pt->element_pt(e));
       
       //Set the Reynolds number for each element 
       //(yes we could have different Reynolds number in each element!!)
       el_pt->re_pt() = local_re_pt;//&Re;
       
       //Set the product of Reynolds and Strouhal numbers
       el_pt->re_st_pt() = local_re_pt; //&Re;
  
       //and add as external data
       el_pt->add_external_data(
        Normalisation_mesh_pt->element_pt(0)->internal_data_pt(0));
  
      }
    }
    
    //Refine as the other mesh
    dynamic_cast<TreeBasedRefineableMeshBase*>(Eigenproblem_mesh_pt)
     ->refine_base_mesh_as_in_reference_mesh(
      dynamic_cast<TreeBasedRefineableMeshBase*>
      (Base_flow_mesh_pt));
    
    
    //Set the boundary conditions (no slip on the walls)
    //Loop over the nodes on the (only) mesh boundary
    unsigned n_boundary = Eigenproblem_mesh_pt->nboundary();
    for(unsigned b=0;b<n_boundary;++b)
     {
      unsigned n_boundary_node = Eigenproblem_mesh_pt->nboundary_node(b);
      for(unsigned n=0;n<n_boundary_node;n++)
       {
        if(b!=1)
         {
          //Pin all four (two real, two imaginary) velocity components on the
          //same boundaries as the base flow problem
          for(unsigned i=0;i<4;i++)
           {
            Eigenproblem_mesh_pt->boundary_node_pt(b,n)->pin(i);
           }
         }
       }
     }
    
    //Pin all normalisation degrees of freedom
    unsigned n_node = Eigenproblem_mesh_pt->nnode();
    for(unsigned n=0;n<n_node;++n)
     {
      for(unsigned i=0;i<4;++i)
       {
        Eigenproblem_mesh_pt->node_pt(n)->pin(4+i);
       }
     }
    
    //Loop over all the (fluid) elements 
    {unsigned n_element = Eigenproblem_mesh_pt->nelement();
     for(unsigned e=0;e<n_element;e++)
      {
       //Cast to the particular element type, this is necessary because
       //the base elements don't have the member functions that we're about
       //to call!
       PERTURBED_ELEMENT *el_pt = 
        dynamic_cast<PERTURBED_ELEMENT*>(Eigenproblem_mesh_pt->element_pt(e));
       
       //There is no need for ALE
       el_pt->disable_ALE();
       
       //Set the Reynolds number for each element 
       //(yes we could have different Reynolds number in each element!!)
       el_pt->re_pt() = local_re_pt;//&Re;
       
       //Set the product of Reynolds and Strouhal numbers
       el_pt->re_st_pt() = local_re_pt; //&Re;
       
       //Set the eigenfunction normalisation element
       el_pt->set_eigenfunction_normalisation_element(normalisation_element_pt);
       
       //Pin the pressure normalisation dofs
       el_pt->pin_pressure_normalisation_dofs();
      }
    }
    
    
 // Pin redudant pressure dofs
    RefineableLinearisedNavierStokesEquations::
     pin_redundant_nodal_pressures(Eigenproblem_mesh_pt->element_pt());
  
  //The setup of the interaction uses a binning approach that
  //works best if there are a reasonably large number of bins
  //in each direction. If there are ever problems, increasing
  //these numbers tends to fix them.
  
  // Change default number of bins in each dimension
  //Multi_domain_functions::Nx_bin=500;
  //Multi_domain_functions::Ny_bin=500;
  
  // Don't compute extreme bin coordinates
  //Multi_domain_functions::Compute_extreme_bin_coordinates=false;
  
  // Specify extreme bin coordinates directly
  //Multi_domain_functions::X_min= 1.0/Delta - 1.0;
  //Multi_domain_functions::X_max= 1.0/Delta + 1.0;
  //Multi_domain_functions::Y_min = -1.0;
  //Multi_domain_functions::Y_max= + 1.0;
  
  // First interaction (base state velocities)
  Multi_domain_functions::
   setup_multi_domain_interaction<BASE_ELEMENT>
   (this,Eigenproblem_mesh_pt,Base_flow_mesh_pt,0);
  
  // Second interaction (base state velocity derivatives w.r.t. space)
  Multi_domain_functions::
    setup_multi_domain_interaction<BASE_ELEMENT>
   (this,Eigenproblem_mesh_pt,Base_flow_mesh_pt,1);
  
  //Build the global mesh
  this->add_sub_mesh(Eigenproblem_mesh_pt);
  this->add_sub_mesh(Normalisation_mesh_pt);
  this->rebuild_global_mesh();
  
  Normalisation_mesh_pt->element_pt(0)->internal_data_pt(0)->pin(2);
  
  //Setup all the equation numbering and look-up schemes 
  std::cout << assign_eqn_numbers() << std::endl; 
   }

References oomph::Mesh::add_element_pt(), b, e(), Global_Parameters::Eigenfunction_normalisation(), MeshRefinement::error_estimator_pt, oomph::LinearisedNavierStokesEquations::Gamma, Global_Physical_Variables::height(), i, n, oomph::Mesh::nboundary(), oomph::RefineableLinearisedNavierStokesEquations::pin_redundant_nodal_pressures(), and GlobalPhysicalVariables::Re.

◆ apply_boundary_conditions()

template<class ELEMENT >

void FlowAroundCylinderProblem< ELEMENT >::apply_boundary_conditions

Apply boundary conditions.

Apply boundary conditions (BX = boundary X): – Pin both velocities on the cylinder (B4) and the inlet (B3). – Zero vertical velocity on the upper (B2) and lower (B0) boundaries. – Do nothing (non-stress divergence form) on the outlet (B1):

 {
   // Get the number of boundaries in the mesh
   unsigned n_boundary=Bulk_mesh_pt->nboundary();
  
   // Loop over the boundaries
   for (unsigned b=0; b<n_boundary; b++)
   {
     // Find the number of nodes on the b-th boundary
     unsigned n_boundary_node=Bulk_mesh_pt->nboundary_node(b);
  
     // Inlet and side walls (tow-tank conditions)
     if ((b==Lower_wall_boundary_id)||
         (b==Upper_wall_boundary_id)||
         (b==Inflow_boundary_id)||
         (b==Cylinder_surface_boundary_id))
     {
       // Loop over the nodes
       for (unsigned n=0; n<n_boundary_node; n++)
       {
         // Pointer to the boundary node
         Node* boundary_node_pt=Bulk_mesh_pt->boundary_node_pt(b,n);
  
         // Pin the horizontal velocity
         boundary_node_pt->pin(0);
  
         // Pin the vertical velocity
         boundary_node_pt->pin(1);
  
         // Cylinder surface: enforce a no-slip condition
         // NOTE: the no-slip condition will be updated before each timestep in
         // response to the cylinder motion using the FSI helpers.
         if (b==Cylinder_surface_boundary_id)
         {
           // Set horizontal velocity to zero
           boundary_node_pt->set_value(0,0.0);
  
           // Set the vertical velocity to zero too
           boundary_node_pt->set_value(1,0.0);
         }
         // Inflow and sidewalls: enforce tow-tank boundary conditions
         else
         {
           // Tangential inflow
           boundary_node_pt->set_value(0,1.0);
  
           // No vertical velocity
           boundary_node_pt->set_value(1,0.0);
         }
       } // for (unsigned b=0;b<n_boundary_node;b++)
     } // if ((b==Lower_wall_boundary_id)||...
   } // for (unsigned b=0; b<n_boundary; b++)
 } // End of apply_boundary_conditions

References b, n, oomph::Data::pin(), and oomph::Data::set_value().

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

◆ base_flow_mesh_pt()

template<class ELEMENT >

RefineableRectangleWithHoleMesh<BASE_ELEMENT>* FlowAroundCylinderProblem< ELEMENT >::base_flow_mesh_pt ( )

inline

Access function for the specific mesh.

   {
    return dynamic_cast<RefineableRectangleWithHoleMesh<BASE_ELEMENT>*>
     (Base_flow_mesh_pt);
   }

◆ doc_solution() [1/2]

template<class ELEMENT >

void FlowAroundCylinderProblem< ELEMENT >::doc_solution ( )

inline

Report the eigenvalue

   {
    Base_flow_mesh_pt->output("final_base_flow.dat",5);
    //Output the eigenproblem
    Eigenproblem_mesh_pt->output("final_eigenfunction.dat",5);
    std::cout << "Eigenvalue is " <<
     Normalisation_mesh_pt->element_pt(0)->internal_data_pt(0)->value(0)
              << " + " << 
     Normalisation_mesh_pt->element_pt(0)->internal_data_pt(0)->value(1)
              << "I\n";
  
    std::cout << "Critical Reynolds number is " <<
     Normalisation_mesh_pt->element_pt(0)->internal_data_pt(0)->value(2)
              << "\n";
   }

◆ doc_solution() [2/2]

template<class ELEMENT >

void FlowAroundCylinderProblem< ELEMENT >::doc_solution ( const bool & in_unsteady = false )

Doc the solution.

Document the solution.

 {
   // Tell the user
   oomph_info << "Documentation step: " << GlobalParameters::Doc_info.number()
              << std::endl;
  
   // Only output on root processor
   if (this->communicator_pt()->my_rank()==0)
   {
     // Create an output stream
     std::ofstream some_file;
  
     // Allocate space for the filename
     char filename[10000];
  
     // Number of plot points
     unsigned n_plot=GlobalParameters::N_plot_point;
  
     // If we're in the unsteady simulation
     if (in_unsteady)
     {
       // Output solution
       sprintf(filename,"%s/unsteady%i.dat",
               GlobalParameters::Doc_info.directory().c_str(),
               GlobalParameters::Doc_info.number());
     }
     else
     {
       // Output solution
       sprintf(filename,"%s/soln%i.dat",
               GlobalParameters::Doc_info.directory().c_str(),
               GlobalParameters::Doc_info.number());
     }
  
     // Open a file with the formed filename
     some_file.open(filename);
  
     // Output solution
     Bulk_mesh_pt->output(some_file,n_plot);
  
     // Close the file
     some_file.close();
   } // if (this->communicator_pt()->my_rank()==0)
  
   // Increment the documentation number
   GlobalParameters::Doc_info.number()++;
 } // End of doc_solution

References GlobalParameters::Doc_info, MergeRestartFiles::filename, GlobalParameters::N_plot_point, oomph::DocInfo::number(), and oomph::oomph_info.

◆ doc_trace_node_velocities_and_pressure()

template<class ELEMENT >

void FlowAroundCylinderProblem< ELEMENT >::doc_trace_node_velocities_and_pressure ( )

Output the velocity components at a point on the centerline to observe the oscillating behaviour without having to output all the data (i.e. V1, V2 etc.):

◆ dump_problem()

template<class ELEMENT >

void FlowAroundCylinderProblem< ELEMENT >::dump_problem ( char * filename ) const

Dump the entire problem.

◆ eigenproblem_mesh_pt()

template<class ELEMENT >

RefineableRectangleWithHoleMesh<PERTURBED_ELEMENT>* FlowAroundCylinderProblem< ELEMENT >::eigenproblem_mesh_pt ( )

inline

Return a pointer to the specific mesh used.

1310 {return dynamic_cast<RefineableRectangleWithHoleMesh<PERTURBED_ELEMENT>*>

1311 (this->Eigenproblem_mesh_pt);}

◆ make_copy()

template<class ELEMENT >

Problem* FlowAroundCylinderProblem< ELEMENT >::make_copy ( )

inlinevirtual

Make a copy for using in bifurcation tracking.

Reimplemented from oomph::Problem.

   {
    //Make a copy based on the current parameters
    return(new FlowAroundCylinderProblem<ELEMENT>(
            Cylinder_pt,Domain_length,Domain_height));
   }

References GlobalParameters::Cylinder_pt.

◆ mesh_pt() [1/3]

template<class ELEMENT >

RefineableRectangleWithHoleMesh<ELEMENT>* FlowAroundCylinderProblem< ELEMENT >::mesh_pt ( )

inline

Access function for the specific mesh.

   {
    return dynamic_cast<RefineableRectangleWithHoleMesh<ELEMENT>*>
     (Problem::mesh_pt());
   }

References oomph::Problem::mesh_pt().

Referenced by FlowAroundCylinderProblem< ELEMENT >::FlowAroundCylinderProblem(), and FlowAroundCylinderProblem< ELEMENT >::~FlowAroundCylinderProblem().

◆ mesh_pt() [2/3]

template<class ELEMENT >

RefineableRectangleWithHoleMesh<ELEMENT>* FlowAroundCylinderProblem< ELEMENT >::mesh_pt ( )

inline

Access function for the specific mesh.

   {
    return dynamic_cast<RefineableRectangleWithHoleMesh<ELEMENT>*>
     (Problem::mesh_pt());
   }

◆ mesh_pt() [3/3]

template<class ELEMENT >

Mesh* & FlowAroundCylinderProblem< ELEMENT >::mesh_pt ( const unsigned & num )

inline

   {
    return Problem::mesh_pt(num);
   }

References oomph::Problem::mesh_pt().

◆ pin_all_base_flow_dofs()

template<class ELEMENT >

void FlowAroundCylinderProblem< ELEMENT >::pin_all_base_flow_dofs ( )

inline

   {
    const unsigned n_node = Base_flow_mesh_pt->nnode();
    for(unsigned n=0;n<n_node;++n)
     {
      Node* nod_pt = Base_flow_mesh_pt->node_pt(n);
      unsigned n_value = nod_pt->nvalue();
      for(unsigned i=0;i<n_value;++i)
       {
        if(!nod_pt->is_constrained(i))
         {
          nod_pt->pin(i);
         }
       }
     }
    const unsigned n_element = Base_flow_mesh_pt->nelement();
    for(unsigned e=0;e<n_element;++e)
     {
      GeneralisedElement* el_pt = Base_flow_mesh_pt->element_pt(e);
      unsigned n_internal = el_pt->ninternal_data();
      for(unsigned i=0;i<n_internal;++i)
       {
        Data* data_pt = el_pt->internal_data_pt(i);
        unsigned n_value = data_pt->nvalue();
        for(unsigned j=0;j<n_value;++j)
         {
          if(!data_pt->is_constrained(j))
           {
            data_pt->pin(j);
           }
         }
       }
     }
   }

References e(), i, oomph::GeneralisedElement::internal_data_pt(), oomph::Data::is_constrained(), j, n, oomph::GeneralisedElement::ninternal_data(), oomph::Data::nvalue(), and oomph::Data::pin().

◆ read_problem()

template<class ELEMENT >

void FlowAroundCylinderProblem< ELEMENT >::read_problem ( char * restart_file )

Read the entire problem.

◆ set_boundary_conditions() [1/2]

template<class ELEMENT >

void FlowAroundCylinderProblem< ELEMENT >::set_boundary_conditions ( )

inline

Set the boundary conditions on the cylinder and at the inlet

   {
    using namespace Global_Parameters;
    
    //Set the boundary conditions on the cylinder
    unsigned ibound=4;
    unsigned n_node = mesh_pt()->nboundary_node(ibound);
    for(unsigned n=0;n<n_node;n++)
     {
      double x = mesh_pt()->boundary_node_pt(ibound,n)->x(0);
      double y = mesh_pt()->boundary_node_pt(ibound,n)->x(1);
      
      //Now find the vector distance to the centre
      double len_x = x - mesh_pt()->domain_pt()->centre_x();
      double len_y = y - mesh_pt()->domain_pt()->centre_y();
      
      //Calculate the angle and radius
      double theta = atan2(len_y,len_x);
      
      double u_x = -Alpha*sin(theta);
      double u_y =  Alpha*cos(theta);
  
      //Now set the velocities
      mesh_pt()->boundary_node_pt(ibound,n)->set_value(0,u_x);
      mesh_pt()->boundary_node_pt(ibound,n)->set_value(1,u_y);
     } 
    
    // update the parabolic tangential inflow velocity
    ibound=3;
    double ycoord,uy;
    n_node = mesh_pt()->nboundary_node(ibound);
    double um = 1.0/12.0 - 0.25*Domain_height*Domain_height;
    for (unsigned n=0;n<n_node;n++)
     {
      ycoord = mesh_pt()->boundary_node_pt(ibound,n)->x(1);
      uy = (ycoord*ycoord - 0.25*Domain_height*Domain_height)/um;
  
      // Tangential flow
      mesh_pt()->boundary_node_pt(ibound,n)->set_value(0,uy);
      //No penetration
      mesh_pt()->boundary_node_pt(ibound,n)->set_value(1,0.0);
     }
   }

References Global_Parameters::Alpha, atan2(), cos(), n, sin(), BiharmonicTestFunctions2::theta, plotDoE::x, and y.

◆ set_boundary_conditions() [2/2]

template<class ELEMENT >

void FlowAroundCylinderProblem< ELEMENT >::set_boundary_conditions ( )

inline

Set the boundary conditions on the cylinder and at the inlet

   {
    using namespace Global_Parameters;
    
    //Set the boundary conditions on the cylinder
    unsigned ibound=4;
    unsigned n_node = Base_flow_mesh_pt->nboundary_node(ibound);
    for(unsigned n=0;n<n_node;n++)
     {
      double x = Base_flow_mesh_pt->boundary_node_pt(ibound,n)->x(0);
      double y = Base_flow_mesh_pt->boundary_node_pt(ibound,n)->x(1);
      
      //Now find the vector distance to the centre
      double len_x = x - base_flow_mesh_pt()->domain_pt()->centre_x();
      double len_y = y - base_flow_mesh_pt()->domain_pt()->centre_y();
      
      //Calculate the angle and radius
      double theta = atan2(len_y,len_x);
      
      double u_x = -Alpha*sin(theta);
      double u_y =  Alpha*cos(theta);
  
      //Now set the velocities
      Base_flow_mesh_pt->boundary_node_pt(ibound,n)->set_value(0,u_x);
      Base_flow_mesh_pt->boundary_node_pt(ibound,n)->set_value(1,u_y);
     } 
    
    // update the parabolic tangential inflow velocity
    ibound=3;
    double ycoord,uy;
    n_node = Base_flow_mesh_pt->nboundary_node(ibound);
    double um = 1.0/12.0 - 0.25*Domain_height*Domain_height;
    for (unsigned n=0;n<n_node;n++)
     {
      ycoord = Base_flow_mesh_pt->boundary_node_pt(ibound,n)->x(1);
      uy = (ycoord*ycoord - 0.25*Domain_height*Domain_height)/um;
  
      // Tangential flow
      Base_flow_mesh_pt->boundary_node_pt(ibound,n)->set_value(0,uy);
      //No penetration
      Base_flow_mesh_pt->boundary_node_pt(ibound,n)->set_value(1,0.0);
     }
  
    if(Eigenproblem_flag)
     {
  
  unsigned n_boundary = Eigenproblem_mesh_pt->nboundary();
  for(unsigned b=0;b<n_boundary;++b)
   {
    unsigned n_boundary_node = Eigenproblem_mesh_pt->nboundary_node(b);
    for(unsigned n=0;n<n_boundary_node;n++)
     {
      if(b!=1)
       {
        //Pin all four (two real, two imaginary) velocity components on the
        //same boundaries as the base flow problem
        for(unsigned i=0;i<4;i++)
         {
          Eigenproblem_mesh_pt->boundary_node_pt(b,n)->pin(i);
          Eigenproblem_mesh_pt->boundary_node_pt(b,n)->set_value(i,0.0);
         }
       }
     }
   }
  
  //Pin all normalisation degrees of freedom
  unsigned n_node = Eigenproblem_mesh_pt->nnode();
  for(unsigned n=0;n<n_node;++n)
   {
    for(unsigned i=0;i<4;++i)
     {
      Eigenproblem_mesh_pt->node_pt(n)->pin(4+i);
     }
   }
     }
   }

References TanhSolnForAdvectionDiffusion::Alpha, atan2(), b, cos(), i, n, sin(), BiharmonicTestFunctions2::theta, plotDoE::x, and y.

◆ set_eigenvalue()

template<class ELEMENT >

void FlowAroundCylinderProblem< ELEMENT >::set_eigenvalue	(	const double &	real,
		const double &	imag
	)

inline

   {
    Data* dat_pt =
     Normalisation_mesh_pt->element_pt(0)->internal_data_pt(0);
    dat_pt->set_value(0,real);
    dat_pt->set_value(1,imag);
   }

References oomph::Data::set_value().

◆ set_up_solver_and_preconditioner()

template<class ELEMENT >

void FlowAroundCylinderProblem< ELEMENT >::set_up_solver_and_preconditioner

Set the chosen solver and preconditioner.

Set up the linear solver and preconditioner.

 {
   // Use GMRES
   Solver_pt=new GMRES<CRDoubleMatrix>;
  
   // Set linear solver
   linear_solver_pt()=Solver_pt;
  
   // Create and assign the Navier-Stokes preconditioner
   Prec_pt=new NavierStokesSchurComplementPreconditioner(this);
  
   // Pass the Navier-Stokes mesh to the preconditioner
   Prec_pt->set_navier_stokes_mesh(this->Bulk_mesh_pt);
  
   // Pass the preconditioner to the solver
   Solver_pt->preconditioner_pt()=Prec_pt;
  
   // By default, the LSC Preconditioner uses SuperLU as an exact
   // preconditioner (i.e. a solver) for the momentum and Schur complement
   // blocks. Can overwrite this by passing pointers to other preconditioners
   // that perform the (approximate) solves of these blocks:
  
   // Create internal preconditioners used on momentum block
   F_matrix_preconditioner_pt=new BlockDiagonalPreconditioner<CRDoubleMatrix>;
  
   // Assign the subsidiary preconditioner to the linear solver preconditioner
   Prec_pt->set_f_preconditioner(F_matrix_preconditioner_pt);
 } // End of set_up_solver_and_preconditioner

◆ transfer_eigenfunction_as_initial_condition()

template<class ELEMENT >

void FlowAroundCylinderProblem< ELEMENT >::transfer_eigenfunction_as_initial_condition	(	DoubleVector &	real,
		DoubleVector &	imaginary
	)

inline

   {
    this->pin_all_base_flow_dofs();
  
    //Pin the eigenvalues
    Normalisation_mesh_pt->element_pt(0)->internal_data_pt(0)->pin_all();
    
    //Pin everything apart from the real part of the eigenfunction
    unsigned n_element = Eigenproblem_mesh_pt->nelement();
    for(unsigned e=0;e<n_element;++e)
     {
      PERTURBED_ELEMENT* el_pt = dynamic_cast<PERTURBED_ELEMENT*>
       (Eigenproblem_mesh_pt->element_pt(e));
  
      //Pin the imaginary parts
      el_pt->pin_real_or_imag(1);
     }
  
    
      //Reassign the equation numbers
      std::cout << "Assigning real part" << this->assign_eqn_numbers()
                << std::endl;
  
      //Transfer it over
      this->assign_eigenvector_to_dofs(real);
      Eigenproblem_mesh_pt->output("E1.dat",5);
      
      
      //Pin everything apart from the imaginary part of the eigenfunction
      for(unsigned e=0;e<n_element;++e)
       {
        PERTURBED_ELEMENT* el_pt = dynamic_cast<PERTURBED_ELEMENT*>
       (Eigenproblem_mesh_pt->element_pt(e));
  
        el_pt->unpin_real_or_imag(1);
        //Pin the real parts
        el_pt->pin_real_or_imag(0);
       }
  
      //Reapply the boundary conditions
      this->set_boundary_conditions();
    
      //Reassign the equation numbers
      std::cout << "Assigning imaginary part" << this->assign_eqn_numbers()
                << std::endl;
  
      //Transfer it over
      this->assign_eigenvector_to_dofs(imaginary);
  
      //Now we convert things over to the normalisation function
      //Pin everything apart from the imaginary part of the eigenfunction
      for(unsigned e=0;e<n_element;++e)
       {
        PERTURBED_ELEMENT* el_pt = dynamic_cast<PERTURBED_ELEMENT*>
         (Eigenproblem_mesh_pt->element_pt(e));
        //Unpin the real part
        el_pt->unpin_real_or_imag(0);
        //Transfer the normalisation
        el_pt->copy_efunction_to_normalisation();
       }
      
      //Reapply the boundary conditions
      this->set_boundary_conditions();
  
      //Unpin the eigenvalues
      Normalisation_mesh_pt->element_pt(0)->internal_data_pt(0)->unpin_all();
      //Pin the Reynolds number
      //Normalisation_mesh_pt->element_pt(0)->internal_data_pt(0)->pin(2);
  
      unpin_all_base_flow_dofs();
      this->actions_after_adapt();
  
      //Reassign the equation numbers
      std::cout << "Re-assigning the equation numbers"
                << this->assign_eqn_numbers()
                << std::endl;
  
      //Let's output
      Eigenproblem_mesh_pt->output("Initial_mesh.dat",5);
      
      
   }

References e().

◆ unpin_all_base_flow_dofs()

template<class ELEMENT >

void FlowAroundCylinderProblem< ELEMENT >::unpin_all_base_flow_dofs ( )

inline

   {
    const unsigned n_node = Base_flow_mesh_pt->nnode();
    for(unsigned n=0;n<n_node;++n)
     {
      Node* nod_pt = Base_flow_mesh_pt->node_pt(n);
      unsigned n_value = nod_pt->nvalue();
      for(unsigned i=0;i<n_value;++i)
       {
        if(!nod_pt->is_constrained(i))
         {
          nod_pt->unpin(i);
         }
       }
     }
    const unsigned n_element = Base_flow_mesh_pt->nelement();
    for(unsigned e=0;e<n_element;++e)
     {
      GeneralisedElement* el_pt = Base_flow_mesh_pt->element_pt(e);
      unsigned n_internal = el_pt->ninternal_data();
      for(unsigned i=0;i<n_internal;++i)
       {
        Data* data_pt = el_pt->internal_data_pt(i);
        unsigned n_value = data_pt->nvalue();
        for(unsigned j=0;j<n_value;++j)
         {
          if(!data_pt->is_constrained(j))
           {
            data_pt->unpin(j);
           }
         }
       }
     }
   }

References e(), i, oomph::GeneralisedElement::internal_data_pt(), oomph::Data::is_constrained(), j, n, oomph::GeneralisedElement::ninternal_data(), oomph::Data::nvalue(), and oomph::Data::unpin().

◆ unsteady_simulation()

template<class ELEMENT >

void FlowAroundCylinderProblem< ELEMENT >::unsteady_simulation

Timestep the problem.

 {
   // The FSI_Functions namespace enforces the no-slip condition on the
   // cylinder boundary as the nodes on this boundary move with time. This
   // requires a handle to the Strouhal number value, so set it here
   FSI_functions::Strouhal_for_no_slip=GlobalParameters::St;
  
   // Make the problem unsteady again
   time_stepper_pt()->undo_make_steady();
  
   // Set the period (working on the non-dimensionalised time)
   double period=1.0;
  
   // Timestep
   double dt=period/double(GlobalParameters::N_step_per_period_unsteady);
  
   // Initialise the timestep value
   initialise_dt(dt);
  
   // Doc the number of timesteps per period and timestep size
   oomph_info << "\nTimestepping with "
              << GlobalParameters::N_step_per_period_unsteady
              << " steps per period, corresponding to a timestep of "
              << dt << std::endl;
  
   // Make the problem unsteady again
   time_stepper_pt()->undo_make_steady();
  
   // Assign history values for an impulsive start
   assign_initial_values_impulsive();
  
   // Reset the documentation counter so the file indexing (re)starts from zero
   GlobalParameters::Doc_info.number()=0;
  
   // Set up the solver and preconditioner
   set_up_solver_and_preconditioner();
  
   // Make sure that the Reynolds number is exactly equal to our target value
   GlobalParameters::Re=GlobalParameters::Re_target;
  
   // Document the Reynolds number and Womersley number
   GlobalParameters::doc_navier_stokes_parameters();
  
   // Initialise the number of timesteps
   unsigned n_timestep=
     GlobalParameters::N_period_unsteady*GlobalParameters::round(period/dt);
  
   // Tell the user
   oomph_info << "\nTotal number of timesteps: " << n_timestep << std::endl;
  
   // Target global temporal error
   double epsilon_t=1.0e-04;
  
   // Max. number of spatial adaptations
   unsigned max_adapt=0;
  
   // Inform the user
   oomph_info << "\nRunning until time: " << GlobalParameters::N_period_unsteady
              << std::endl;
  
   // Loop over the timesteps
   for (unsigned t=1; t<=n_timestep; t++)
   {
     // Run the bastard...
     doubly_adaptive_unsteady_newton_solve(dt,epsilon_t,max_adapt,false);
  
     // Tell the user
     oomph_info << "Obtained solution at timestep " << t
                << " out of " << n_timestep << "." << std::endl;
   }
 } // End of unsteady_simulation

References GlobalParameters::Doc_info, GlobalParameters::doc_navier_stokes_parameters(), GlobalParameters::N_period_unsteady, GlobalParameters::N_step_per_period_unsteady, oomph::DocInfo::number(), oomph::oomph_info, GlobalParameters::Re, GlobalParameters::Re_target, GlobalParameters::round(), GlobalParameters::St, oomph::FSI_functions::Strouhal_for_no_slip, and plotPSD::t.

Member Data Documentation

◆ Base_flow_mesh_pt

template<class ELEMENT >

Mesh* FlowAroundCylinderProblem< ELEMENT >::Base_flow_mesh_pt

private

◆ Bulk_mesh_pt

template<class ELEMENT >

RefineableQuadMeshWithMovingCylinder<ELEMENT>* FlowAroundCylinderProblem< ELEMENT >::Bulk_mesh_pt

private

Pointer to the mesh with oscillating cylinder.

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

◆ Cylinder_pt

template<class ELEMENT >

GeomObject * FlowAroundCylinderProblem< ELEMENT >::Cylinder_pt

private

The geometric cylinder.

◆ Domain_height

template<class ELEMENT >

double FlowAroundCylinderProblem< ELEMENT >::Domain_height

private

Height of the domain.

◆ Domain_length

template<class ELEMENT >

double FlowAroundCylinderProblem< ELEMENT >::Domain_length

private

Length of the domain.

◆ Eigenproblem_flag

template<class ELEMENT >

bool FlowAroundCylinderProblem< ELEMENT >::Eigenproblem_flag

private

◆ Eigenproblem_mesh_pt

template<class ELEMENT >

Mesh* FlowAroundCylinderProblem< ELEMENT >::Eigenproblem_mesh_pt

private

◆ F_matrix_preconditioner_pt

template<class ELEMENT >

Preconditioner* FlowAroundCylinderProblem< ELEMENT >::F_matrix_preconditioner_pt

private

Inexact solver for F block.

◆ Normalisation_mesh_pt

template<class ELEMENT >

Mesh* FlowAroundCylinderProblem< ELEMENT >::Normalisation_mesh_pt

private

◆ Prec_pt

template<class ELEMENT >

NavierStokesSchurComplementPreconditioner* FlowAroundCylinderProblem< ELEMENT >::Prec_pt

private

LSC Preconditioner for the linear solve.

◆ Solver_pt

template<class ELEMENT >

IterativeLinearSolver* FlowAroundCylinderProblem< ELEMENT >::Solver_pt

private

Oomph-lib iterative linear solver.

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

Public Member Functions

Private Types

Private Attributes

Additional Inherited Members

Detailed Description

template<class ELEMENT> class FlowAroundCylinderProblem< ELEMENT >

Member Enumeration Documentation

◆ anonymous enum

Constructor & Destructor Documentation

◆ FlowAroundCylinderProblem() [1/4]

◆ ~FlowAroundCylinderProblem() [1/3]

◆ FlowAroundCylinderProblem() [2/4]

◆ ~FlowAroundCylinderProblem() [2/3]

◆ FlowAroundCylinderProblem() [3/4]

◆ FlowAroundCylinderProblem() [4/4]

◆ ~FlowAroundCylinderProblem() [3/3]

Member Function Documentation

◆ actions_after_adapt() [1/4]

◆ actions_after_adapt() [2/4]

◆ actions_after_adapt() [3/4]

◆ actions_after_adapt() [4/4]

◆ actions_after_newton_solve() [1/4]

◆ actions_after_newton_solve() [2/4]

◆ actions_after_newton_solve() [3/4]

◆ actions_after_newton_solve() [4/4]

◆ actions_before_adapt()

◆ actions_before_implicit_timestep()

◆ actions_before_newton_convergence_check() [1/2]

◆ actions_before_newton_convergence_check() [2/2]

◆ actions_before_newton_solve() [1/4]

◆ actions_before_newton_solve() [2/4]

◆ actions_before_newton_solve() [3/4]

◆ actions_before_newton_solve() [4/4]

◆ add_eigenproblem()

◆ apply_boundary_conditions()

◆ base_flow_mesh_pt()

◆ doc_solution() [1/2]

◆ doc_solution() [2/2]

◆ doc_trace_node_velocities_and_pressure()

◆ dump_problem()

◆ eigenproblem_mesh_pt()

◆ make_copy()

◆ mesh_pt() [1/3]

◆ mesh_pt() [2/3]

◆ mesh_pt() [3/3]

◆ pin_all_base_flow_dofs()

◆ read_problem()

◆ set_boundary_conditions() [1/2]

◆ set_boundary_conditions() [2/2]

◆ set_eigenvalue()

◆ set_up_solver_and_preconditioner()

◆ transfer_eigenfunction_as_initial_condition()

◆ unpin_all_base_flow_dofs()

◆ unsteady_simulation()

Member Data Documentation

◆ Base_flow_mesh_pt

◆ Bulk_mesh_pt

◆ Cylinder_pt

◆ Domain_height

◆ Domain_length

◆ Eigenproblem_flag

◆ Eigenproblem_mesh_pt

◆ F_matrix_preconditioner_pt

◆ Normalisation_mesh_pt

◆ Prec_pt

◆ Solver_pt

template<class ELEMENT>
class FlowAroundCylinderProblem< ELEMENT >