PressureWaveFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT > Class Template Reference

Problem class. More...

Inheritance diagram for PressureWaveFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >:

Public Member Functions
	PressureWaveFSIProblem ()
	Constructor. More...
void	create_fluid_traction_elements ()
	Create the fluid traction elements. More...
void	create_solid_traction_elements ()
	Create the solid traction elements. More...
void	actions_before_implicit_timestep ()
	Update the problem specs before next timestep: Emtpy. More...
void	doc_solution (DocInfo &doc_info)
	Doc solution. More...
	PressureWaveFSIProblem ()
	Constructor. More...
void	create_fluid_traction_elements ()
	Create the fluid traction elements. More...
void	create_poro_face_elements ()
	Create the poroelasticity traction/pressure elements. More...
void	actions_before_implicit_timestep ()
void	doc_solution (DocInfo &doc_info)
	Doc solution. 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 ()

Private Types
enum	{   Bottom_fluid_boundary , FSI_fluid_boundary , Top_fluid_boundary , Centreline_fluid_boundary ,   Internal_boundary_layer_fluid_boundary }
	Enumeration of fluid boundaries. More...
enum	{   Bottom_poro_boundary , Outer_poro_boundary , Top_poro_boundary , FSI_poro_boundary ,   Bottom_internal_poro_boundary , Top_internal_poro_boundary }
	Enumeration of poro-elastic boundaries. More...

Private Member Functions
void	setup_fsi ()
	setup fsi More...
void	setup_fsi ()
	Setup fsi. More...

Private Attributes
TriangleMesh< FLUID_ELEMENT > *	Fluid_mesh_pt
	Solid mesh. More...
TriangleMesh< SOLID_ELEMENT > *	Solid_mesh_pt
	Fluid mesh. More...
Mesh *	Solid_surface_mesh_pt
	Solid surface mesh on outside. More...
Mesh *	FSI_solid_surface_mesh_pt
	Solid surface mesh at FSI interface. More...
Mesh *	Inflow_fluid_surface_mesh_pt
	Inflow fluid surface mesh. More...
Mesh *	FSI_fluid_surface_mesh_pt
	FSI fluid surface mesh. More...
TimeStepper *	Solid_time_stepper_pt
	Pointer to wall timestepper. More...
TimeStepper *	Fluid_time_stepper_pt
	Pointer to fluid timestepper. More...
MeshAsGeomObject *	Fluid_mesh_geom_obj_pt
	Mesh as geom object representation of fluid mesh. More...
Vector< std::pair< FLUID_ELEMENT *, Vector< double > > >	Regularly_spaced_plot_point
unsigned	Lagrange_id
	Id for Lagrange multiplier constraint. More...
TriangleMesh< POROELASTICITY_ELEMENT > *	Poro_mesh_pt
	Poroelasticity mesh. More...
Mesh *	FSI_poro_surface_mesh_pt
	Poroelasticity surface mesh at FSI interface. More...
TimeStepper *	Poro_time_stepper_pt
	Pointer to the poroelasticity timestepper. More...
Vector< std::pair< FLUID_ELEMENT *, Vector< double > > >	Fluid_regularly_spaced_plot_point
MeshAsGeomObject *	Solid_mesh_geom_obj_pt
	Mesh as geom object representation of solid mesh. More...
Vector< std::pair< POROELASTICITY_ELEMENT *, Vector< double > > >	Solid_regularly_spaced_plot_point

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_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_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 FLUID_ELEMENT, class SOLID_ELEMENT>
class PressureWaveFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >

Problem class.

Member Enumeration Documentation

anonymous enum

template<class FLUID_ELEMENT , class SOLID_ELEMENT >

anonymous enum

private

Enumeration of fluid boundaries.

Enumerator
Bottom_fluid_boundary
FSI_fluid_boundary
Top_fluid_boundary
Centreline_fluid_boundary
Internal_boundary_layer_fluid_boundary

      {Bottom_fluid_boundary, 
       FSI_fluid_boundary,
       Top_fluid_boundary,
       Centreline_fluid_boundary,
       Internal_boundary_layer_fluid_boundary};

anonymous enum

template<class FLUID_ELEMENT , class SOLID_ELEMENT >

anonymous enum

private

Enumeration of poro-elastic boundaries.

Enumerator
Bottom_poro_boundary
Outer_poro_boundary
Top_poro_boundary
FSI_poro_boundary
Bottom_internal_poro_boundary
Top_internal_poro_boundary

      {Bottom_poro_boundary, 
       Outer_poro_boundary,
       Top_poro_boundary,
       FSI_poro_boundary,
       Bottom_internal_poro_boundary,
       Top_internal_poro_boundary};

Constructor & Destructor Documentation

PressureWaveFSIProblem() [1/2]

template<class FLUID_ELEMENT , class POROELASTICITY_ELEMENT >

PressureWaveFSIProblem< FLUID_ELEMENT, POROELASTICITY_ELEMENT >::PressureWaveFSIProblem

Constructor.

{
 
 // Create timesteppers
 Solid_time_stepper_pt = new NewmarkBDF<2>;
 add_time_stepper_pt(Solid_time_stepper_pt);
 Fluid_time_stepper_pt = new BDF<2>;
 add_time_stepper_pt(Fluid_time_stepper_pt);
 
 //Create the problem geometry - a hollow solid cylinder filled with fluid
 //-----------------------------------------------------------------------
 
 //Temporary storage for coords in required format
 Vector<Vector<double> > temp_coord(2,Vector<double>(2));
 
 //Fluid mesh
 //----------
 
 //Vector for the vertices
 Vector<Vector<double> > fluid_vertex_coords(5, Vector<double>(2));
 fluid_vertex_coords[0][0]=0.0;
 fluid_vertex_coords[0][1]=0.0;
 
 fluid_vertex_coords[1][0]=Global_Physical_Variables::Inner_radius;
 fluid_vertex_coords[1][1]=0.0;
 
 fluid_vertex_coords[2][0]=Global_Physical_Variables::Inner_radius;
 fluid_vertex_coords[2][1]=Global_Physical_Variables::Length;
 
 fluid_vertex_coords[3][0]=0.0;
 fluid_vertex_coords[3][1]=Global_Physical_Variables::Length;
 
 fluid_vertex_coords[4][0]=0.0;
 fluid_vertex_coords[4][1]=0.0;
 
 
 //Loop over the vertices and create a polyline between each consecutive pair
 Vector<TriangleMeshCurveSection*> fluid_outer_polyline_boundary_pt(4);
 for(unsigned i=0;i<4;i++)
  {
   temp_coord[0][0]=fluid_vertex_coords[i][0];
   temp_coord[0][1]=fluid_vertex_coords[i][1];
   temp_coord[1][0]=fluid_vertex_coords[i+1][0];
   temp_coord[1][1]=fluid_vertex_coords[i+1][1];
   fluid_outer_polyline_boundary_pt[i] =
    new TriangleMeshPolyLine(temp_coord,i);
  }
 
 //Create the outer boundary closed curve
 TriangleMeshClosedCurve* fluid_outer_boundary_pt =
  new TriangleMeshClosedCurve(fluid_outer_polyline_boundary_pt);
 
 //Target element area for Triangle
 double uniform_element_area = 0.002;
 
 // Use the TriangleMeshParameters object for gathering all
 // the necessary arguments for the TriangleMesh object
 TriangleMeshParameters fluid_triangle_mesh_parameters(
   fluid_outer_boundary_pt);
 
 // Take the maximum element area
 fluid_triangle_mesh_parameters.element_area() =
   uniform_element_area;
 
 // Create the mesh
 Fluid_mesh_pt = new TriangleMesh<FLUID_ELEMENT>(
   fluid_triangle_mesh_parameters, Fluid_time_stepper_pt);
 
 // Mesh as geom object representation of fluid mesh
 Fluid_mesh_geom_obj_pt=new MeshAsGeomObject(Fluid_mesh_pt);
 
 // Extract points
 unsigned nplot_r=5;
 unsigned nplot_z=unsigned(double(nplot_r)*Global_Physical_Variables::Length/
                           Global_Physical_Variables::Inner_radius);
 Regularly_spaced_plot_point.resize(nplot_r*nplot_z);
 Vector<double> x(2);
 Vector<double> s(2);
 unsigned count=0;
 for (unsigned ir=0;ir<nplot_r;ir++)
  {
   x[0]=double(ir)/double(nplot_r-1)*Global_Physical_Variables::Inner_radius;
   for (unsigned iz=0;iz<nplot_z;iz++)
    {
     x[1]=double(iz)/double(nplot_z-1)*Global_Physical_Variables::Length;
 
     // Pointer to GeomObject that contains this point
     GeomObject* geom_obj_pt=0;
 
     // Get it
     Fluid_mesh_geom_obj_pt->locate_zeta(x,geom_obj_pt,s);
 
     // Store it
     Regularly_spaced_plot_point[count].first=
      dynamic_cast<FLUID_ELEMENT*>(geom_obj_pt);
     Regularly_spaced_plot_point[count].second=s;
 
     count++;
    }
  }
 
 
 //-----------------------------------------------------------------------------
 
 //Solid mesh
 //----------
 
 //Vector for the vertices
 Vector<Vector<double> > solid_vertex_coords(5, Vector<double>(2));
 solid_vertex_coords[0][0]=Global_Physical_Variables::Inner_radius;
 solid_vertex_coords[0][1]=0.0;
 
 solid_vertex_coords[1][0]=Global_Physical_Variables::Outer_radius;
 solid_vertex_coords[1][1]=0.0;
 
 solid_vertex_coords[2][0]=Global_Physical_Variables::Outer_radius;
 solid_vertex_coords[2][1]=Global_Physical_Variables::Length;
 
 solid_vertex_coords[3][0]=Global_Physical_Variables::Inner_radius;
 solid_vertex_coords[3][1]=Global_Physical_Variables::Length;
 
 solid_vertex_coords[4][0]=Global_Physical_Variables::Inner_radius;
 solid_vertex_coords[4][1]=0.0;
 
 
 //Loop over the vertices and create a polyline between each consecutive pair
 Vector<TriangleMeshCurveSection*> solid_outer_polyline_boundary_pt(4);
 for(unsigned i=0;i<4;i++)
  {
   temp_coord[0][0]=solid_vertex_coords[i][0];
   temp_coord[0][1]=solid_vertex_coords[i][1];
   temp_coord[1][0]=solid_vertex_coords[i+1][0];
   temp_coord[1][1]=solid_vertex_coords[i+1][1];
   solid_outer_polyline_boundary_pt[i] =
    new TriangleMeshPolyLine(temp_coord,i);
  }
 
 //Create the outer boundary closed curve
 TriangleMeshClosedCurve* solid_outer_boundary_pt =
  new TriangleMeshClosedCurve(solid_outer_polyline_boundary_pt);
 
 //Target element area for Triangle
 //uniform_element_area = 0.02;
 
 // Use the TriangleMeshParameters object for gathering all
 // the necessary arguments for the TriangleMesh object
 TriangleMeshParameters solid_triangle_mesh_parameters(
   solid_outer_boundary_pt);
 
 // Take the maximum element area
 solid_triangle_mesh_parameters.element_area() =
   uniform_element_area;
 
 // Create the mesh
 Solid_mesh_pt = new TriangleMesh<SOLID_ELEMENT>(
   solid_triangle_mesh_parameters, Solid_time_stepper_pt);
 
 //-----------------------------------------------------------------------------
 
 // Create surface meshes
 Inflow_fluid_surface_mesh_pt = new Mesh;
 FSI_fluid_surface_mesh_pt = new Mesh;
 Solid_surface_mesh_pt = new Mesh;
 FSI_solid_surface_mesh_pt = new Mesh;
 
 // Set Id for Lagrange multiplier constraint
 Lagrange_id=99;
 
 // Make surface meshes
 create_fluid_traction_elements();
 create_solid_traction_elements();
 
 //-----------------------------------------------------------------------------
 
 //Loop over the elements in fluid mesh
 unsigned n_element = Fluid_mesh_pt->nelement();
 for(unsigned e=0;e<n_element;e++)
  {
   //Cast to the particular element type
   FLUID_ELEMENT *el_pt = dynamic_cast<FLUID_ELEMENT*>
    (Fluid_mesh_pt->element_pt(e));
 
   //There is no need for ALE
   el_pt->disable_ALE();
 
   //Set the Reynolds number for each element
   el_pt->re_pt() = &Global_Physical_Variables::Re;
 
   //Set the product of Reynolds and Strouhal numbers
   el_pt->re_st_pt() = &Global_Physical_Variables::Wo;
 
   //Pin u_theta at all nodes (no swirl velocity)
   unsigned n_node = el_pt->nnode();
   for(unsigned n=0;n<n_node;n++)
    {
     Node *nod_pt = el_pt->node_pt(n);
     nod_pt->pin(2);
    }
  }
 
 // Loop over the elements in solid mesh
 n_element = Solid_mesh_pt->nelement();
 for(unsigned e=0;e<n_element;e++)
  {
   // Cast to a bulk element
   SOLID_ELEMENT *el_pt = dynamic_cast<SOLID_ELEMENT*>
    (Solid_mesh_pt->element_pt(e));
 
   // Set the pointer to Poisson's ratio
   el_pt->nu_pt() = &Global_Physical_Variables::Nu;
 
   // Set the pointer to non-dim Young's modulus
   el_pt->youngs_modulus_pt() = &Global_Physical_Variables::E;
 
   // Set the pointer to the Lambda parameter
   el_pt->lambda_sq_pt() = &Global_Physical_Variables::Lambda_sq;
 
   // Loop over all nodes in the element and pin the theta displacement
   unsigned n_node = el_pt->nnode();
   for(unsigned i_node=0;i_node<n_node;i_node++)
    {
     Node *nod_pt = el_pt->node_pt(i_node);
     nod_pt->pin(2);
    }
  }// end_loop_over_elements
 
 
 //Set the fluid boundary conditions
 
 //Loop over the nodes on the fluid mesh boundary
 unsigned n_boundary = Fluid_mesh_pt->nboundary();
 
 //Pin the boundary nodes
 for(unsigned b=0;b<n_boundary;b++)
  {
   // Pin radial velocity at in and outflow (parallel flow)
   // and on centreline (symm); leave FSI boundary (b=1) free
   // [Doing the loop like this ensures that we pin nodes
   // that are simultaneously on fsi boundary and in/outflow boundaries]
   if (b!=1)
    {
     unsigned n_boundary_node = Fluid_mesh_pt->nboundary_node(b);
     for(unsigned n=0;n<n_boundary_node;++n)
      {
       Node* nod_pt=Fluid_mesh_pt->boundary_node_pt(b,n);
       nod_pt->pin(0);
 
 
       // If node is also on FSI boundary it must be on in/outflow:
       // Pin axial velocity too
       if (nod_pt->is_on_boundary(1))
        {
         nod_pt->pin(1);
        }
      }
    }
   // Completely pin the velocity on the FSI boundary
   else if (Global_Physical_Variables::Pin_fluid_on_fsi)
    {
     unsigned n_boundary_node = Fluid_mesh_pt->nboundary_node(b);
     for(unsigned n=0;n<n_boundary_node;++n)
      {
       Node* nod_pt=Fluid_mesh_pt->boundary_node_pt(b,n);
       nod_pt->pin(0);
       nod_pt->pin(1);
      }
    }
  }
 
 
 //Set the solid boundary conditions
 n_boundary = Solid_mesh_pt->nboundary();
 
 //Pin the boundary nodes
 for(unsigned b=0;b<n_boundary;b++)
  {
   unsigned n_boundary_node = Solid_mesh_pt->nboundary_node(b);
   for(unsigned n=0;n<n_boundary_node;++n)
    {
     // Pin solid at in and outflow
     if ((b==0)||(b==2))
      {
       Solid_mesh_pt->boundary_node_pt(b,n)->pin(0);
       Solid_mesh_pt->boundary_node_pt(b,n)->pin(1);
      }
    }
  }
 
 
 // Pin theta Lagrange multipliers (no swirl) and radial and axial Lagrange
 // multiplier for nodes on in and outflow boundaries (b=0 and 2)
 // because velocity is already constrained there
 unsigned nel=FSI_fluid_surface_mesh_pt->nelement();
 for(unsigned e=0;e<nel;e++)
  {
   // Get face element
   LinearisedFSIAxisymmetricNStNoSlipBCElementElement<FLUID_ELEMENT,SOLID_ELEMENT>*
    traction_element_pt=dynamic_cast<
    LinearisedFSIAxisymmetricNStNoSlipBCElementElement<FLUID_ELEMENT,SOLID_ELEMENT>*>
    (FSI_fluid_surface_mesh_pt->element_pt(e));
 
   // Loop over nodes
   unsigned n_node = traction_element_pt->nnode();
   for(unsigned n=0;n<n_node;n++)
    {
     Node *nod_pt = traction_element_pt->node_pt(n);
 
     // Cast to a boundary node
     BoundaryNodeBase *bnod_pt=dynamic_cast<BoundaryNodeBase*>(nod_pt);
 
     // Get the index of the first nodal value associated with
     // this FaceElement
     unsigned first_index=
      bnod_pt->index_of_first_value_assigned_by_face_element(Lagrange_id);
 
     // Pin swirl component
     nod_pt->pin(first_index+2);
 
     // Pin all Lagrange multipliers if we're pinning the fluid
     // on the fsi boundary (for validation)
     if (Global_Physical_Variables::Pin_fluid_on_fsi)
      {
       nod_pt->pin(first_index+0);
       nod_pt->pin(first_index+1);
      }
 
     // Pin radial and axial component if on in or outflow boundary
     if (bnod_pt->is_on_boundary(0))
      {
       nod_pt->pin(first_index+0);
       nod_pt->pin(first_index+1);
      }
     if (bnod_pt->is_on_boundary(2))
      {
       nod_pt->pin(first_index+0);
       nod_pt->pin(first_index+1);
      }
    }
  }
 
 
 // Setup fluid structure interaction
 setup_fsi();
 
 //Add submeshes and build global mesh
 add_sub_mesh(Fluid_mesh_pt);
 add_sub_mesh(Solid_mesh_pt);
 add_sub_mesh(Inflow_fluid_surface_mesh_pt);
 add_sub_mesh(FSI_fluid_surface_mesh_pt);
 add_sub_mesh(Solid_surface_mesh_pt);
 add_sub_mesh(FSI_solid_surface_mesh_pt);
 
 build_global_mesh();
 
 //Setup all the equation numbering and look-up schemes
 assign_eqn_numbers();
 
}

References b, Global_Physical_Variables::E, e(), oomph::TriangleMeshParameters::element_area(), FLUID_ELEMENT, i, oomph::BoundaryNodeBase::index_of_first_value_assigned_by_face_element(), Global_Physical_Variables::Inner_radius, oomph::Node::is_on_boundary(), oomph::BoundaryNodeBase::is_on_boundary(), Global_Physical_Variables::Lambda_sq, Global_Physical_Variables::Length, oomph::GeomObject::locate_zeta(), n, oomph::FiniteElement::nnode(), oomph::FiniteElement::node_pt(), Global_Physical_Variables::Nu, Global_Physical_Variables::Outer_radius, oomph::Data::pin(), Global_Physical_Variables::Pin_fluid_on_fsi, Global_Physical_Variables::Re, s, Global_Physical_Variables::Wo, and plotDoE::x.

PressureWaveFSIProblem() [2/2]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >

PressureWaveFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::PressureWaveFSIProblem

(

)

Constructor.

Member Function Documentation

actions_before_implicit_timestep() [1/2]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >

void PressureWaveFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::actions_before_implicit_timestep ( )

inlinevirtual

Update the problem specs before next timestep: Emtpy.

Reimplemented from oomph::Problem.

{}

actions_before_implicit_timestep() [2/2]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >

void PressureWaveFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::actions_before_implicit_timestep ( )

inlinevirtual

Update the problem specs before next timestep. Increase inlet pressure

Reimplemented from oomph::Problem.

  {
   double time=time_pt()->time();
   Global_Physical_Variables::P_inlet_const =
    Global_Physical_Variables::P_inlet_initial + 
    Global_Physical_Variables::P_inlet_step*
    0.5*(1.0+tanh(Global_Physical_Variables::Alpha_tanh*
                  (time-Global_Physical_Variables::T_tanh)));
 
   oomph_info << "Updating inflow pressure for time " << time << " to " 
              << Global_Physical_Variables::P_inlet_const << std::endl;
  }

References Global_Physical_Variables::Alpha_tanh, oomph::oomph_info, Global_Physical_Variables::P_inlet_const, Global_Physical_Variables::P_inlet_initial, Global_Physical_Variables::P_inlet_step, Global_Physical_Variables::T_tanh, and Eigen::bfloat16_impl::tanh().

create_fluid_traction_elements() [1/2]

template<class FLUID_ELEMENT , class POROELASTICITY_ELEMENT >

void PressureWaveFSIProblem< FLUID_ELEMENT, POROELASTICITY_ELEMENT >::create_fluid_traction_elements

Create the fluid traction elements.

Create the traction elements to the appropriate boundaries of the fluid mesh.

{
 // Inflow:
 unsigned bound=2;
 
 // Now loop over bulk elements and create the face elements
 unsigned nel=Fluid_mesh_pt->nboundary_element(bound);
 for(unsigned e=0;e<nel;e++)
  {
   // Create the face element
   AxisymmetricNavierStokesTractionElement<FLUID_ELEMENT>* traction_element_pt
    = new AxisymmetricNavierStokesTractionElement<FLUID_ELEMENT>
    (Fluid_mesh_pt->boundary_element_pt(bound,e),
     Fluid_mesh_pt->face_index_at_boundary(bound,e));
 
   // Add to mesh
   Inflow_fluid_surface_mesh_pt->add_element_pt(traction_element_pt);
 
   // Set the applied traction
   traction_element_pt->traction_fct_pt() =
    &Global_Physical_Variables::fluid_inflow_boundary_traction;
  }
 
 
 // FSI boundary:
 bound=1;
 
 // Now loop over bulk elements and create the face elements
 nel=Fluid_mesh_pt->nboundary_element(bound);
 for(unsigned e=0;e<nel;e++)
  {
 
#ifdef DO_FSI
 
   // Create the face element
   LinearisedFSIAxisymmetricNStNoSlipBCElementElement<FLUID_ELEMENT,SOLID_ELEMENT>*
    traction_element_pt = new
    LinearisedFSIAxisymmetricNStNoSlipBCElementElement<FLUID_ELEMENT,SOLID_ELEMENT>
    (Fluid_mesh_pt->boundary_element_pt(bound,e),
     Fluid_mesh_pt->face_index_at_boundary(bound,e),Lagrange_id);
 
   // Add to mesh
   FSI_fluid_surface_mesh_pt->add_element_pt(traction_element_pt);
 
   // Associate element with bulk boundary (to allow it to access
   // the boundary coordinates in the bulk mesh)
   traction_element_pt->set_boundary_number_in_bulk_mesh(bound);
 
   // Set Strouhal number
   traction_element_pt->st_pt()=&Global_Physical_Variables::St;
 
#else
 
   // Create the face element
   AxisymmetricNavierStokesTractionElement<FLUID_ELEMENT>* traction_element_pt
    = new AxisymmetricNavierStokesTractionElement<FLUID_ELEMENT>
    (Fluid_mesh_pt->boundary_element_pt(bound,e),
     Fluid_mesh_pt->face_index_at_boundary(bound,e));
 
   // Add to mesh
   FSI_fluid_surface_mesh_pt->add_element_pt(traction_element_pt);
 
   // Set the applied traction
   traction_element_pt->traction_fct_pt() =
    &Global_Physical_Variables::fluid_fsi_boundary_traction;
 
#endif
 
  }
 
}

References e(), Global_Physical_Variables::fluid_inflow_boundary_traction(), oomph::FaceElement::set_boundary_number_in_bulk_mesh(), Global_Physical_Variables::St, oomph::LinearisedFSIAxisymmetricNStNoSlipBCElementElement< FLUID_BULK_ELEMENT, SOLID_BULK_ELEMENT >::st_pt(), and oomph::AxisymmetricNavierStokesTractionElement< ELEMENT >::traction_fct_pt.

create_fluid_traction_elements() [2/2]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >

void PressureWaveFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::create_fluid_traction_elements

(

)

Create the fluid traction elements.

create_poro_face_elements()

template<class FLUID_ELEMENT , class POROELASTICITY_ELEMENT >

void PressureWaveFSIProblem< FLUID_ELEMENT, POROELASTICITY_ELEMENT >::create_poro_face_elements

Create the poroelasticity traction/pressure elements.

Create the traction/pressure elements to the appropriate boundaries of the poroelasticity mesh

{
 
 // FSI boundary 
 //-------------
 unsigned bound=FSI_poro_boundary;
 
 // Now loop over bulk elements and create the face elements
 unsigned nel=Poro_mesh_pt->nboundary_element(bound);
 for(unsigned n=0;n<nel;n++)
  {
   // Create the face element that applies fluid traction to poroelastic
   // solid
   FSILinearisedAxisymPoroelasticTractionElement
    <POROELASTICITY_ELEMENT,FLUID_ELEMENT>* face_element_pt=
    new FSILinearisedAxisymPoroelasticTractionElement
    <POROELASTICITY_ELEMENT,FLUID_ELEMENT>
    (Poro_mesh_pt->boundary_element_pt(bound,n),
     Poro_mesh_pt->face_index_at_boundary(bound,n));
 
   // Add to mesh
   FSI_poro_surface_mesh_pt->add_element_pt(face_element_pt);
 
   // Set the FSI parameter
   face_element_pt->q_pt()=&Global_Physical_Variables::Q;
 
   // Associate element with bulk boundary (to allow it to access
   // the boundary coordinates in the bulk mesh)
   face_element_pt->set_boundary_number_in_bulk_mesh(bound);
  }
 
} // end of create poro face elements

References FLUID_ELEMENT, n, and Global_Physical_Variables::Q.

create_solid_traction_elements()

template<class FLUID_ELEMENT , class SOLID_ELEMENT >

void PressureWaveFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::create_solid_traction_elements

Create the solid traction elements.

Create the traction elements to the appropriate boundaries of the solid mesh.

{
 
 //Prescribed traction on fsi boundary (b=3)
 unsigned bound=3;
 
 // Now loop over bulk elements and create the face elements
 unsigned nel=Solid_mesh_pt->nboundary_element(bound);
 for(unsigned n=0;n<nel;n++)
  {
 
#ifdef DO_FSI
 
   // Create the face element
   FSIAxisymmetricLinearElasticityTractionElement<SOLID_ELEMENT,FLUID_ELEMENT>*
    traction_element_pt = new
    FSIAxisymmetricLinearElasticityTractionElement<SOLID_ELEMENT,FLUID_ELEMENT>
    (Solid_mesh_pt->boundary_element_pt(bound,n),
     Solid_mesh_pt->face_index_at_boundary(bound,n));
 
   // Add to mesh
   FSI_solid_surface_mesh_pt->add_element_pt(traction_element_pt);
 
   // Set the FSI parameter
   traction_element_pt->q_pt() = &Global_Physical_Variables::Q;
 
   // Associate element with bulk boundary (to allow it to access
   // the boundary coordinates in the bulk mesh)
   traction_element_pt->set_boundary_number_in_bulk_mesh(bound);
 
#else
 
   // Create the face element
   AxisymmetricLinearElasticityTractionElement<SOLID_ELEMENT>*
    traction_element_pt
    = new AxisymmetricLinearElasticityTractionElement<SOLID_ELEMENT>
    (Solid_mesh_pt->boundary_element_pt(bound,n),
     Solid_mesh_pt->face_index_at_boundary(bound,n));
 
   // Add to mesh
   FSI_solid_surface_mesh_pt->add_element_pt(traction_element_pt);
 
   // Set the applied traction
   traction_element_pt->traction_fct_pt() =
    &Global_Physical_Variables::validation_solid_fsi_boundary_traction;
 
#endif
 
  }
 
 
 //Prescribed traction on outside wall (b=1)
 bound=1;
 
 // Now loop over bulk elements and create the face elements
 nel=Solid_mesh_pt->nboundary_element(bound);
 for(unsigned n=0;n<nel;n++)
  {
 
   // Create the face element
   AxisymmetricLinearElasticityTractionElement<SOLID_ELEMENT>*
    traction_element_pt
    = new AxisymmetricLinearElasticityTractionElement<SOLID_ELEMENT>
    (Solid_mesh_pt->boundary_element_pt(bound,n),
     Solid_mesh_pt->face_index_at_boundary(bound,n));
 
   // Add to mesh
   Solid_surface_mesh_pt->add_element_pt(traction_element_pt);
 
   // Set the applied traction
   traction_element_pt->traction_fct_pt() =
    &Global_Physical_Variables::outside_solid_boundary_traction;
  }
 
 
}

References n, Global_Physical_Variables::outside_solid_boundary_traction(), Global_Physical_Variables::Q, oomph::FSIAxisymmetricLinearElasticityTractionElement< ELASTICITY_BULK_ELEMENT, NAVIER_STOKES_BULK_ELEMENT >::q_pt(), oomph::FaceElement::set_boundary_number_in_bulk_mesh(), oomph::AxisymmetricLinearElasticityTractionElement< ELEMENT >::traction_fct_pt, and Global_Physical_Variables::validation_solid_fsi_boundary_traction().

doc_solution() [1/2]

template<class FLUID_ELEMENT , class POROELASTICITY_ELEMENT >

void PressureWaveFSIProblem< FLUID_ELEMENT, POROELASTICITY_ELEMENT >::doc_solution

(

DocInfo &

doc_info

)

Doc solution.

{
 
 //Define a string that we can set to be the name of the output file
 char filename[100];
 
 //Define an output filestream
 ofstream file;
 
 // Fluid
 sprintf(filename,"%s/soln-fluid%i.dat",
         doc_info.directory().c_str(),
         doc_info.number());
 file.open(filename);
 Fluid_mesh_pt->output(file,5);
 file.close();
 
 // Fluid traction
 sprintf(filename,"%s/fluid_traction%i.dat",
         doc_info.directory().c_str(),
         doc_info.number());
 file.open(filename);
 Inflow_fluid_surface_mesh_pt->output(file,5);
 file.close();
 
 
 // Fluid traction
 sprintf(filename,"%s/fluid_fsi_traction%i.dat",
         doc_info.directory().c_str(),
         doc_info.number());
 file.open(filename);
 FSI_fluid_surface_mesh_pt->output(file,5);
 file.close();
 
 
 // // Fluid traction
 // sprintf(filename,"%s/tmp_fluid_fsi_traction%i.dat",
 //         doc_info.directory().c_str(),
 //         doc_info.number());
 // file.open(filename);
 // tmp_FSI_fluid_surface_mesh_pt->output(file,5);
 // file.close();
 
 // Solid
 sprintf(filename,"%s/soln-solid%i.dat",
         doc_info.directory().c_str(),
         doc_info.number());
 file.open(filename);
 Solid_mesh_pt->output(file,5);
 file.close();
 
 
 // Solid traction
 sprintf(filename,"%s/solid_traction%i.dat",
         doc_info.directory().c_str(),
         doc_info.number());
 file.open(filename);
 FSI_solid_surface_mesh_pt->output(file,5);
 file.close();
 
 
 // Solid traction
 sprintf(filename,"%s/outside_solid_traction%i.dat",
         doc_info.directory().c_str(),
         doc_info.number());
 file.open(filename);
 Solid_surface_mesh_pt->output(file,5);
 file.close();
 
 
 // Fluid at regularly spaced points
 sprintf(filename,"%s/regular_fluid%i.dat",
         doc_info.directory().c_str(),
         doc_info.number());
 file.open(filename);
 unsigned npts=Regularly_spaced_plot_point.size();
 Vector<double> x(2);
 Vector<double> s(2);
 Vector<double> veloc(3);
 for (unsigned i=0;i<npts;i++)
  {
   // Pointer to element
   FLUID_ELEMENT* el_pt=Regularly_spaced_plot_point[i].first;
 
   // Coordinates in it
   s=Regularly_spaced_plot_point[i].second;
 
   // Get coords
   el_pt->interpolated_x(s,x);
 
   // Get velocity
   el_pt->interpolated_u_axi_nst(s,veloc);
 
   file << x[0] << " "
        << x[1] << " "
        << veloc[0] << " "
        << veloc[1] << " "
        << veloc[2] << " "
        << std::endl;
  }
 file.close();
 
 
 // Output "exact" pulse wave solution
 //-----------------------------------
 sprintf(filename,"%s/pulse_wave%i.dat",
         doc_info.directory().c_str(),
         doc_info.number());
 file.open(filename);
 Fluid_mesh_pt->output_fct(file,5,time_pt()->time(),
                           Global_Physical_Variables::pulse_wave_solution);
 file.close();
 
 // Bump up counter
 doc_info.number()++;
 
}

References oomph::DocInfo::directory(), MergeRestartFiles::filename, FLUID_ELEMENT, i, oomph::DocInfo::number(), Global_Physical_Variables::pulse_wave_solution(), s, and plotDoE::x.

doc_solution() [2/2]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >

void PressureWaveFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::doc_solution

(

DocInfo &

doc_info

)

Doc solution.

setup_fsi() [1/2]

template<class FLUID_ELEMENT , class POROELASTICITY_ELEMENT >

void PressureWaveFSIProblem< FLUID_ELEMENT, POROELASTICITY_ELEMENT >::setup_fsi

private

setup fsi

Setup interaction between two fields.

{
 // Setup fluid traction on FSI wall elements
 //------------------------------------------
 unsigned boundary_in_fluid_mesh=1;
  Multi_domain_functions::setup_bulk_elements_adjacent_to_face_mesh
  <FLUID_ELEMENT,2>
  (this,boundary_in_fluid_mesh,Fluid_mesh_pt,FSI_solid_surface_mesh_pt);
 
 // Setup no slip bc for axisym Navier Stokes from adjacent axisym
 //---------------------------------------------------------------
 // elasticity elements
 //-------------------
  unsigned boundary_in_solid_mesh=3;
  Multi_domain_functions::setup_bulk_elements_adjacent_to_face_mesh
   <SOLID_ELEMENT,2>(
    this,boundary_in_solid_mesh,Solid_mesh_pt,FSI_fluid_surface_mesh_pt);
 
}

References FLUID_ELEMENT, and oomph::Multi_domain_functions::setup_bulk_elements_adjacent_to_face_mesh().

setup_fsi() [2/2]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >

void PressureWaveFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::setup_fsi ( )

private

Setup fsi.

Member Data Documentation

Fluid_mesh_geom_obj_pt

template<class FLUID_ELEMENT , class SOLID_ELEMENT >

MeshAsGeomObject * PressureWaveFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::Fluid_mesh_geom_obj_pt

private

Mesh as geom object representation of fluid mesh.

Fluid_mesh_pt

template<class FLUID_ELEMENT , class SOLID_ELEMENT >

TriangleMesh< FLUID_ELEMENT > * PressureWaveFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::Fluid_mesh_pt

private

Solid mesh.

Fluid mesh.

Fluid_regularly_spaced_plot_point

template<class FLUID_ELEMENT , class SOLID_ELEMENT >

Vector<std::pair<FLUID_ELEMENT*,Vector<double> > > PressureWaveFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::Fluid_regularly_spaced_plot_point

private

Vector of pairs containing pointers to elements and local coordinates within them for regularly spaced plot points

Fluid_time_stepper_pt

template<class FLUID_ELEMENT , class SOLID_ELEMENT >

TimeStepper * PressureWaveFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::Fluid_time_stepper_pt

private

Pointer to fluid timestepper.

Pointer to the fluid timestepper.

FSI_fluid_surface_mesh_pt

template<class FLUID_ELEMENT , class SOLID_ELEMENT >

Mesh * PressureWaveFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::FSI_fluid_surface_mesh_pt

private

FSI fluid surface mesh.

FSI_poro_surface_mesh_pt

template<class FLUID_ELEMENT , class SOLID_ELEMENT >

Mesh* PressureWaveFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::FSI_poro_surface_mesh_pt

private

Poroelasticity surface mesh at FSI interface.

FSI_solid_surface_mesh_pt

template<class FLUID_ELEMENT , class SOLID_ELEMENT >

Mesh* PressureWaveFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::FSI_solid_surface_mesh_pt

private

Solid surface mesh at FSI interface.

Inflow_fluid_surface_mesh_pt

template<class FLUID_ELEMENT , class SOLID_ELEMENT >

Mesh * PressureWaveFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::Inflow_fluid_surface_mesh_pt

private

Inflow fluid surface mesh.

Lagrange_id

template<class FLUID_ELEMENT , class SOLID_ELEMENT >

unsigned PressureWaveFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::Lagrange_id

private

Id for Lagrange multiplier constraint.

Id for Lagrange multiplier that enforces (no-)slip on fluid.

Poro_mesh_pt

template<class FLUID_ELEMENT , class SOLID_ELEMENT >

TriangleMesh<POROELASTICITY_ELEMENT>* PressureWaveFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::Poro_mesh_pt

private

Poroelasticity mesh.

Poro_time_stepper_pt

template<class FLUID_ELEMENT , class SOLID_ELEMENT >

TimeStepper* PressureWaveFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::Poro_time_stepper_pt

private

Pointer to the poroelasticity timestepper.

Regularly_spaced_plot_point

template<class FLUID_ELEMENT , class SOLID_ELEMENT >

Vector<std::pair<FLUID_ELEMENT*,Vector<double> > > PressureWaveFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::Regularly_spaced_plot_point

private

Vector of pairs containing pointers to elements and local coordinates within them for regularly spaced plot points

Solid_mesh_geom_obj_pt

template<class FLUID_ELEMENT , class SOLID_ELEMENT >

MeshAsGeomObject* PressureWaveFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::Solid_mesh_geom_obj_pt

private

Mesh as geom object representation of solid mesh.

Solid_mesh_pt

template<class FLUID_ELEMENT , class SOLID_ELEMENT >

TriangleMesh<SOLID_ELEMENT>* PressureWaveFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::Solid_mesh_pt

private

Fluid mesh.

Solid_regularly_spaced_plot_point

template<class FLUID_ELEMENT , class SOLID_ELEMENT >

Vector<std::pair<POROELASTICITY_ELEMENT*,Vector<double> > > PressureWaveFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::Solid_regularly_spaced_plot_point

private

Vector of pairs containing pointers to elements and local coordinates within them for regularly spaced plot points

Solid_surface_mesh_pt

template<class FLUID_ELEMENT , class SOLID_ELEMENT >

Mesh* PressureWaveFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::Solid_surface_mesh_pt

private

Solid surface mesh on outside.

Solid_time_stepper_pt

template<class FLUID_ELEMENT , class SOLID_ELEMENT >

TimeStepper* PressureWaveFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::Solid_time_stepper_pt

private

Pointer to wall timestepper.

---

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

• linearised_fsi_pulsewave.cc
• linearised_poroelastic_fsi_pulsewave.cc