Public Member Functions | Private Member Functions | Private Attributes | List of all members
FSIChannelWithLeafletProblem< ELEMENT > Class Template Reference

FSI leaflet in channel. More...

+ Inheritance diagram for FSIChannelWithLeafletProblem< ELEMENT >:

Public Member Functions

 FSIChannelWithLeafletProblem (const double &lleft, const double &lright, const double &hleaflet, const double &htot, const unsigned &nleft, const unsigned &nright, const unsigned &ny1, const unsigned &ny2, const double &x_0)
 Constructor. More...
 
 ~FSIChannelWithLeafletProblem ()
 Destructor empty. More...
 
void actions_after_newton_solve ()
 Actions after solve (empty) More...
 
void actions_before_newton_solve ()
 Actions before solve (empty) More...
 
void actions_after_adapt ()
 Actions after adaptation. More...
 
OneDLagrangianMesh< FSIHermiteBeamElement > * wall_mesh_pt ()
 Access function to the wall mesh. More...
 
RefineableAlgebraicChannelWithLeafletMesh< ELEMENT > * fluid_mesh_pt ()
 Access function to fluid mesh. More...
 
void doc_solution (DocInfo &doc_info, ofstream &trace)
 Doc the solution. More...
 
void actions_before_implicit_timestep ()
 Update the inflow velocity. More...
 
void actions_before_newton_convergence_check ()
 
 FSIChannelWithLeafletProblem (const unsigned &mesh_multiplier)
 Constructor: Pass multiplier for uniform mesh refinement. More...
 
 ~FSIChannelWithLeafletProblem ()
 Destructor empty. More...
 
void actions_after_newton_solve ()
 Actions after solve (empty) More...
 
void actions_before_newton_solve ()
 
void actions_before_newton_convergence_check ()
 Update no slip before Newton convergence check. More...
 
void actions_before_implicit_timestep ()
 Actions before implicit timestep: Update the inflow velocity. More...
 
void set_iterative_solver ()
 Set iterative solver. More...
 
void doc_solution (DocInfo &doc_info)
 Doc the solution. More...
 
void create_lagrange_multiplier_elements ()
 
void delete_lagrange_multiplier_elements ()
 
void doc_parameters ()
 Doc parameters. More...
 
 FSIChannelWithLeafletProblem (const double &lleft, const double &lright, const double &hleaflet, const double &htot, const unsigned &nleft, const unsigned &nright, const unsigned &ny1, const unsigned &ny2, const double &x_0)
 
 ~FSIChannelWithLeafletProblem ()
 Destructor empty. More...
 
void actions_after_newton_solve ()
 Actions after solve (empty) More...
 
void actions_before_newton_solve ()
 Actions before solve (empty) More...
 
void actions_after_adapt ()
 Actions after adaptation. More...
 
void actions_after_distribute ()
 Actions after distribution. More...
 
OneDLagrangianMesh< FSIHermiteBeamElement > * wall_mesh_pt ()
 Access function to the wall mesh. More...
 
RefineableAlgebraicChannelWithLeafletMesh< ELEMENT > * fluid_mesh_pt ()
 Access function to fluid mesh. More...
 
void doc_solution (DocInfo &doc_info, ofstream &trace)
 Doc the solution. More...
 
void actions_before_implicit_timestep ()
 Update the inflow velocity. More...
 
void actions_before_newton_convergence_check ()
 
 FSIChannelWithLeafletProblem (const double &lleft, const double &lright, const double &hleaflet, const double &htot, const unsigned &nleft, const unsigned &nright, const unsigned &ny1, const unsigned &ny2, const double &x_0)
 
 ~FSIChannelWithLeafletProblem ()
 Destructor empty. More...
 
void actions_after_newton_solve ()
 Actions after solve (empty) More...
 
void actions_before_newton_solve ()
 Actions before solve (empty) More...
 
void actions_after_adapt ()
 Actions after adaptation. More...
 
OneDLagrangianMesh< FSIHermiteBeamElement > * solid_mesh_pt ()
 Access function to the wall mesh. More...
 
RefineableAlgebraicChannelWithLeafletMesh< ELEMENT > * fluid_mesh_pt ()
 Access function to fluid mesh. More...
 
void doc_solution (DocInfo &doc_info)
 Doc the solution. More...
 
void actions_before_implicit_timestep ()
 Update the inflow velocity. More...
 
void actions_before_newton_convergence_check ()
 
- 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 ()
 
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 Member Functions

Node * tip_node_pt ()
 Helper fct; returns the node at the tip of the wall mesh. More...
 

Private Attributes

RefineableAlgebraicChannelWithLeafletMesh< ELEMENT > * Fluid_mesh_pt
 Pointer to the fluid mesh. More...
 
OneDLagrangianMesh< FSIHermiteBeamElement > * Wall_mesh_pt
 Pointer to the "wall" mesh. More...
 
GeomObject * Leaflet_pt
 Pointer to the GeomObject that represents the wall. More...
 
double Htot
 Total height of the domain. More...
 
PseudoElasticChannelWithLeafletMesh< ELEMENT > * Bulk_mesh_pt
 Pointer to the fluid mesh. More...
 
BDF< 2 > * Bulk_time_stepper_pt
 Bulk timestepper. More...
 
Newmark< 2 > * Wall_time_stepper_pt
 Wall time stepper pt. More...
 
SolidMesh * Lagrange_multiplier_mesh_pt
 Pointers to mesh of Lagrange multiplier elements. More...
 
ConstitutiveLaw * Constitutive_law_pt
 Constitutive law used to determine the mesh deformation. More...
 
MeshAsGeomObject * Wall_geom_object_pt
 Geometric object for the leaflet (to apply lagrange mult) More...
 
UndeformedLeaflet * Undeformed_wall_pt
 Geom object for the leaflet. More...
 
OneDLagrangianMesh< FSIHermiteBeamElement > * Solid_mesh_pt
 Pointer to the "wall" mesh. 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 FSIChannelWithLeafletProblem< ELEMENT >

FSI leaflet in channel.

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

///////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////// FSI leaflet in channel. Mesh update with pseudo-elasticity and solved with pseudo-elastic fsi preconditioner.

Constructor & Destructor Documentation

◆ FSIChannelWithLeafletProblem() [1/4]

template<class ELEMENT >
FSIChannelWithLeafletProblem< ELEMENT >::FSIChannelWithLeafletProblem ( const double &  lleft,
const double &  lright,
const double &  hleaflet,
const double &  htot,
const unsigned &  nleft,
const unsigned &  nright,
const unsigned &  ny1,
const unsigned &  ny2,
const double &  x_0 
)

Constructor.

Constructor: Pass the lenght of the domain at the left of the leaflet lleft,the lenght of the domain at the right of the leaflet lright,the height of the leaflet hleaflet, the total height of the domain htot, the number of macro-elements at the left of the leaflet nleft, the number of macro-elements at the right of the leaflet nright, the number of macro-elements under hleaflet ny1, the number of macro-elements above hleaflet ny2, the abscissa of the origin of the leaflet x_0.

274  : Htot(htot)
275 {
276  // Timesteppers:
277  //--------------
278 
279  // Allocate the timestepper
280  BDF<2>* fluid_time_stepper_pt=new BDF<2>;
281  add_time_stepper_pt(fluid_time_stepper_pt);
282 
283  // Allocate the wall timestepper
284  Steady<2>* wall_time_stepper_pt=new Steady<2>;
285  add_time_stepper_pt(wall_time_stepper_pt);
286 
287 
288  // Discretise leaflet
289  //-------------------
290 
291  // Geometric object that represents the undeformed leaflet
292  UndeformedLeaflet* undeformed_wall_pt=new UndeformedLeaflet(x_0);
293 
294  //Create the "wall" mesh with FSI Hermite beam elements
295  unsigned n_wall_el=5;
296  Wall_mesh_pt = new OneDLagrangianMesh<FSIHermiteBeamElement>
297  (n_wall_el,hleaflet,undeformed_wall_pt,wall_time_stepper_pt);
298 
299 
300  // Provide GeomObject representation of leaflet mesh and build fluid mesh
301  //-----------------------------------------------------------------------
302 
303  // Build a geometric object (one Lagrangian, two Eulerian coordinates)
304  // from the wall mesh
305  MeshAsGeomObject* wall_geom_object_pt=
306  new MeshAsGeomObject(Wall_mesh_pt);
307 
308 //Build the mesh
309  Fluid_mesh_pt =new RefineableAlgebraicChannelWithLeafletMesh<ELEMENT>(
310  wall_geom_object_pt,
311  lleft, lright,
312  hleaflet,
313  htot,nleft,
314  nright,ny1,ny2,
315  fluid_time_stepper_pt);
316 
317  // Set error estimator
318  Z2ErrorEstimator* error_estimator_pt=new Z2ErrorEstimator;
319  Fluid_mesh_pt->spatial_error_estimator_pt()=error_estimator_pt;
320 
321 
322 
323  // Build global mesh
324  //------------------
325 
326  // Add the sub meshes to the problem
327  add_sub_mesh(Fluid_mesh_pt);
328  add_sub_mesh(Wall_mesh_pt);
329 
330  // Combine all submeshes into a single Mesh
331  build_global_mesh();
332 
333 
334 
335  // Fluid boundary conditions
336  //--------------------------
337 
338  //Pin the boundary nodes of the fluid mesh
339  unsigned num_bound = Fluid_mesh_pt->nboundary();
340  for(unsigned ibound=0;ibound<num_bound;ibound++)
341  {
342  unsigned num_nod= Fluid_mesh_pt->nboundary_node(ibound);
343  for (unsigned inod=0;inod<num_nod;inod++)
344  {
345  Fluid_mesh_pt->boundary_node_pt(ibound,inod)->pin(1);
346 
347  // Do not pin the x velocity of the outflow
348  if( ibound != 1)
349  {
350  Fluid_mesh_pt->boundary_node_pt(ibound,inod)->pin(0);
351  }
352  }
353  }
354  // end loop over boundaries
355 
356 
357  // Setup parabolic flow along boundary 3 (everything else that's
358  // pinned has homogenous boundary conditions so no action is required
359  // as that's the default assignment). Inflow profile is parabolic
360  // and this is interpolated correctly during mesh refinement so
361  // no re-assignment necessary after adaptation.
362  unsigned ibound=3;
363  unsigned num_nod= Fluid_mesh_pt->nboundary_node(ibound);
364  for (unsigned inod=0;inod<num_nod;inod++)
365  {
366  double ycoord = Fluid_mesh_pt->boundary_node_pt(ibound,inod)->x(1);
367  double uy = 6.0*ycoord/htot*(1.0-ycoord/htot);
368  Fluid_mesh_pt->boundary_node_pt(ibound,inod)->set_value(0,uy);
369  Fluid_mesh_pt->boundary_node_pt(ibound,inod)->set_value(1,0.0);
370  }// end of setup boundary condition
371 
372 
373 
374  // Boundary conditions for wall mesh
375  //----------------------------------
376 
377  // Set the boundary conditions: the lower end of the beam is fixed in space
378  unsigned b=0;
379 
380  // Pin displacements in both x and y directions
381  wall_mesh_pt()->boundary_node_pt(b,0)->pin_position(0);
382  wall_mesh_pt()->boundary_node_pt(b,0)->pin_position(1);
383 
384  // Infinite slope: Pin type 1 (slope) dof for displacement direction 0
385  wall_mesh_pt()->boundary_node_pt(b,0)->pin_position(1,0);
386 
387 
388 
389  // Complete build of fluid elements
390  //---------------------------------
391  unsigned n_element = Fluid_mesh_pt->nelement();
392 
393  // Loop over the elements to set up element-specific
394  // things that cannot be handled by constructor
395  for(unsigned e=0;e<n_element;e++)
396  {
397  // Upcast from GeneralisedElement to the present element
398  ELEMENT* el_pt = dynamic_cast<ELEMENT*>(Fluid_mesh_pt->element_pt(e));
399 
400  //Set the Reynolds number
401  el_pt->re_pt() = &Global_Physical_Variables::Re;
402 
403  //Set the Womersley number
404  el_pt->re_st_pt() = &Global_Physical_Variables::ReSt;
405 
406  }// end loop over elements
407 
408 
409  // Pin redudant pressure dofs
410  RefineableNavierStokesEquations<2>::
411  pin_redundant_nodal_pressures(Fluid_mesh_pt->element_pt());
412 
413 
414  // Complete build of wall elements
415  //--------------------------------
416  n_element = wall_mesh_pt()->nelement();
417  for(unsigned e=0;e<n_element;e++)
418  {
419  // Upcast to the specific element type
420  FSIHermiteBeamElement *elem_pt =
421  dynamic_cast<FSIHermiteBeamElement*>(wall_mesh_pt()->element_pt(e));
422 
423  // Set physical parameters for each element:
424  elem_pt->h_pt() = &Global_Physical_Variables::H;
425 
426  // Function that specifies the load ratios
427  elem_pt->q_pt() = &Global_Physical_Variables::Q;
428 
429  // Set the undeformed shape for each element
430  elem_pt->undeformed_beam_pt() = undeformed_wall_pt;
431 
432  // Leaflet is immersed and loaded by fluid on both sides
433  elem_pt->enable_fluid_loading_on_both_sides();
434 
435  // The normal to the leaflet, as computed by the
436  // FSIHermiteElements points away from the fluid rather than
437  // into the fluid (as assumed by default) when viewed from
438  // the "front" (face 0).
439  elem_pt->set_normal_pointing_out_of_fluid();
440 
441  } // end of loop over elements
442 
443 
444  // Setup FSI
445  //----------
446 
447  // The velocity of the fluid nodes on the wall (fluid mesh boundary 4,5)
448  // is set by the wall motion -- hence the no-slip condition must be
449  // re-applied whenever a node update is performed for these nodes.
450  // Such tasks may be performed automatically by the auxiliary node update
451  // function specified by a function pointer:
452  for(unsigned ibound=4;ibound<6;ibound++ )
453  {
454  unsigned num_nod= Fluid_mesh_pt->nboundary_node(ibound);
455  for (unsigned inod=0;inod<num_nod;inod++)
456  {
457  Fluid_mesh_pt->boundary_node_pt(ibound, inod)->
458  set_auxiliary_node_update_fct_pt(
459  FSI_functions::apply_no_slip_on_moving_wall);
460  }
461  }// aux node update fct has been set
462 
463  // Work out which fluid dofs affect the residuals of the wall elements:
464  // We pass the boundary between the fluid and solid meshes and
465  // pointers to the meshes. The interaction boundary is boundary 4 and 5
466  // of the 2D fluid mesh.
467 
468  // Front of leaflet: Set face=0 (which is also the default so this argument
469  // could be omitted)
470  unsigned face=0;
471  FSI_functions::setup_fluid_load_info_for_solid_elements<ELEMENT,2>
472  (this,4,Fluid_mesh_pt,Wall_mesh_pt,face);
473 
474  // Back of leaflet: face 1, needs to be specified explicitly
475  face=1;
476  FSI_functions::setup_fluid_load_info_for_solid_elements<ELEMENT,2>
477  (this,5,Fluid_mesh_pt,Wall_mesh_pt,face);
478 
479  // Setup equation numbering scheme
480  cout <<"Number of equations: " << assign_eqn_numbers() << std::endl;
481 
482 
483 
484  // Choose iterative solvers with FSI preconditioner (only if not test)
485  //====================================================================
486  if (CommandLineArgs::Argc==1)
487  {
488 
489  // Build iterative linear solver
490  //------------------------------
491  GMRES<CRDoubleMatrix>* iterative_linear_solver_pt =
492  new GMRES<CRDoubleMatrix>;
493 
494  // Set maximum number of iterations
495  iterative_linear_solver_pt->max_iter() = 200;
496 
497  // Pass solver to problem:
498  linear_solver_pt()=iterative_linear_solver_pt;
499 
500 
501  // Build preconditioner
502  //---------------------
503  FSIPreconditioner* prec_pt=new FSIPreconditioner(this);
504 
505  // Set Navier Stokes mesh:
506  prec_pt->set_navier_stokes_mesh(Fluid_mesh_pt);
507 
508  // Set solid mesh:
509  prec_pt->set_wall_mesh(Wall_mesh_pt);
510 
511  // By default, the Schur complement preconditioner uses SuperLU as
512  // an exact preconditioner (i.e. a solver) for the
513  // momentum and Schur complement blocks.
514  // Can overwrite this by passing pointers to
515  // other preconditioners that perform the (approximate)
516  // solves of these blocks
517 
518 
519 #ifdef OOMPH_HAS_HYPRE
520 
521  // Create internal preconditioner used on Schur block
522  //---------------------------------------------------
523  HyprePreconditioner* p_preconditioner_pt = new HyprePreconditioner;
524 
525  // Shut up!
526  p_preconditioner_pt->disable_doc_time();
527 
528  // Set defaults parameters for use as preconditioner on Poisson-type problem
529  Hypre_default_settings::
530  set_defaults_for_2D_poisson_problem(p_preconditioner_pt);
531 
532  // Pass to preconditioner
533  //prec_pt->set_p_preconditioner(p_preconditioner_pt);
534 
535 
536  // Create internal preconditioner used on momentum block
537  //------------------------------------------------------
538  HyprePreconditioner* f_preconditioner_pt = new HyprePreconditioner;
539 
540  // Shut up!
541  f_preconditioner_pt->disable_doc_time();
542 
543  // Set default parameters for use as preconditioner in for momentum
544  // block in Navier-Stokes problem
545  Hypre_default_settings::
546  set_defaults_for_navier_stokes_momentum_block(f_preconditioner_pt);
547 
548  // Use Hypre for momentum block
549  //prec_pt->set_f_preconditioner(f_preconditioner_pt);
550 
551 #endif
552 
553  // Retain fluid onto solid terms in FSI preconditioner
554  prec_pt->use_block_triangular_version_with_fluid_on_solid();
555 
556  // Pass preconditioner to iterative linear solver
557  iterative_linear_solver_pt->preconditioner_pt()= prec_pt;
558 
559  }
560 
561 
562 }//end of constructor
e
Array< double, 1, 3 > e(1./3., 0.5, 2.)
b
Scalar * b
Definition: benchVecAdd.cpp:17
FSIChannelWithLeafletProblem::Htot
double Htot
Total height of the domain.
Definition: interaction/fsi_channel_with_leaflet/fsi_channel_with_leaflet.cc:253
FSIChannelWithLeafletProblem::wall_mesh_pt
OneDLagrangianMesh< FSIHermiteBeamElement > * wall_mesh_pt()
Access function to the wall mesh.
Definition: interaction/fsi_channel_with_leaflet/fsi_channel_with_leaflet.cc:197
FSIChannelWithLeafletProblem::Fluid_mesh_pt
RefineableAlgebraicChannelWithLeafletMesh< ELEMENT > * Fluid_mesh_pt
Pointer to the fluid mesh.
Definition: interaction/fsi_channel_with_leaflet/fsi_channel_with_leaflet.cc:244
FSIChannelWithLeafletProblem::Wall_mesh_pt
OneDLagrangianMesh< FSIHermiteBeamElement > * Wall_mesh_pt
Pointer to the "wall" mesh.
Definition: interaction/fsi_channel_with_leaflet/fsi_channel_with_leaflet.cc:247
UndeformedLeaflet
GeomObject: Undeformed straight, vertical leaflet.
Definition: interaction/fsi_channel_with_leaflet/fsi_channel_with_leaflet.cc:91
oomph::FSIHermiteBeamElement
Definition: beam_elements.h:352
oomph::FSIHermiteBeamElement::set_normal_pointing_out_of_fluid
void set_normal_pointing_out_of_fluid()
Definition: beam_elements.h:384
oomph::FSIPreconditioner
Definition: fsi_preconditioners.h:51
oomph::FSIPreconditioner::set_navier_stokes_mesh
void set_navier_stokes_mesh(Mesh *mesh_pt, const bool &allow_multiple_element_type_in_navier_stokes_mesh=false)
Definition: fsi_preconditioners.h:164
oomph::FSIPreconditioner::set_wall_mesh
void set_wall_mesh(Mesh *mesh_pt, const bool &allow_multiple_element_type_in_wall_mesh=false)
Definition: fsi_preconditioners.h:179
oomph::FSIPreconditioner::use_block_triangular_version_with_fluid_on_solid
void use_block_triangular_version_with_fluid_on_solid()
Definition: fsi_preconditioners.h:147
oomph::FSIWallElement::enable_fluid_loading_on_both_sides
void enable_fluid_loading_on_both_sides()
Definition: fsi.cc:138
oomph::FSIWallElement::q_pt
double *& q_pt()
Definition: fsi.h:248
oomph::GMRES
The GMRES method.
Definition: iterative_linear_solver.h:1227
oomph::HyprePreconditioner
Definition: hypre_solver.h:826
oomph::HyprePreconditioner::disable_doc_time
void disable_doc_time()
Disable documentation of preconditioner timings.
Definition: hypre_solver.h:939
oomph::IterativeLinearSolver::preconditioner_pt
Preconditioner *& preconditioner_pt()
Access function to preconditioner.
Definition: iterative_linear_solver.h:95
oomph::IterativeLinearSolver::max_iter
unsigned & max_iter()
Access to max. number of iterations.
Definition: iterative_linear_solver.h:113
oomph::KirchhoffLoveBeamEquations::h_pt
double *& h_pt()
Return a pointer to non-dim. wall thickness.
Definition: beam_elements.h:240
oomph::KirchhoffLoveBeamEquations::undeformed_beam_pt
GeomObject *& undeformed_beam_pt()
Definition: beam_elements.h:253
oomph::MeshAsGeomObject
Definition: mesh_as_geometric_object.h:93
oomph::Mesh::element_pt
GeneralisedElement *& element_pt(const unsigned long &e)
Return pointer to element e.
Definition: mesh.h:448
oomph::Mesh::nelement
unsigned long nelement() const
Return number of elements in the mesh.
Definition: mesh.h:590
oomph::Problem::add_time_stepper_pt
void add_time_stepper_pt(TimeStepper *const &time_stepper_pt)
Definition: problem.cc:1545
oomph::Problem::add_sub_mesh
unsigned add_sub_mesh(Mesh *const &mesh_pt)
Definition: problem.h:1330
oomph::Problem::linear_solver_pt
LinearSolver *& linear_solver_pt()
Return a pointer to the linear solver object.
Definition: problem.h:1466
oomph::Problem::build_global_mesh
void build_global_mesh()
Definition: problem.cc:1493
oomph::Problem::assign_eqn_numbers
unsigned long assign_eqn_numbers(const bool &assign_local_eqn_numbers=true)
Definition: problem.cc:1989
oomph::RefineableAlgebraicChannelWithLeafletMesh
Refineable version of algebraic ChannelWithLeafletMesh.
Definition: channel_with_leaflet_mesh.template.h:472
oomph::RefineableNavierStokesEquations
Definition: refineable_navier_stokes_elements.h:322
oomph::SolidMesh::boundary_node_pt
SolidNode * boundary_node_pt(const unsigned &b, const unsigned &n)
Return n-th SolidNodes on b-th boundary.
Definition: mesh.h:2612
oomph::SolidNode::pin_position
void pin_position(const unsigned &i)
Pin the nodal position.
Definition: nodes.h:1816
oomph::Z2ErrorEstimator
Definition: error_estimator.h:266
Global_Physical_Variables::ReSt
double ReSt
Womersley number.
Definition: rayleigh_instability.cc:56
Global_Physical_Variables::Q
double Q
Ratio of scales.
Definition: elastic_bretherton.cc:131
Global_Physical_Variables::Re
double Re
Reynolds number.
Definition: fibre.cc:55
Global_Physical_Variables::H
double H
Nondim thickness.
Definition: steady_ring.cc:50
MeshRefinement::error_estimator_pt
Z2ErrorEstimator * error_estimator_pt
Definition: MortaringCantileverCompareToNonMortaring.cpp:190
oomph::CommandLineArgs::Argc
int Argc
Number of arguments + 1.
Definition: oomph_utilities.cc:407
oomph::FSI_functions::apply_no_slip_on_moving_wall
void apply_no_slip_on_moving_wall(Node *node_pt)
Definition: fsi.cc:48
oomph::Hypre_default_settings::set_defaults_for_navier_stokes_momentum_block
void set_defaults_for_navier_stokes_momentum_block(HyprePreconditioner *hypre_preconditioner_pt)
Definition: hypre_solver.cc:85
oomph::Hypre_default_settings::set_defaults_for_2D_poisson_problem
void set_defaults_for_2D_poisson_problem(HyprePreconditioner *hypre_preconditioner_pt)
Definition: hypre_solver.cc:45

References oomph::Problem::add_sub_mesh(), oomph::Problem::add_time_stepper_pt(), oomph::FSI_functions::apply_no_slip_on_moving_wall(), oomph::CommandLineArgs::Argc, oomph::Problem::assign_eqn_numbers(), b, oomph::SolidMesh::boundary_node_pt(), oomph::Problem::build_global_mesh(), oomph::HyprePreconditioner::disable_doc_time(), e(), oomph::Mesh::element_pt(), oomph::FSIWallElement::enable_fluid_loading_on_both_sides(), MeshRefinement::error_estimator_pt, FSIChannelWithLeafletProblem< ELEMENT >::Fluid_mesh_pt, Global_Physical_Variables::H, oomph::KirchhoffLoveBeamEquations::h_pt(), oomph::Problem::linear_solver_pt(), oomph::IterativeLinearSolver::max_iter(), oomph::Mesh::nelement(), oomph::SolidNode::pin_position(), oomph::IterativeLinearSolver::preconditioner_pt(), Global_Physical_Variables::Q, oomph::FSIWallElement::q_pt(), Global_Physical_Variables::Re, Global_Physical_Variables::ReSt, oomph::Hypre_default_settings::set_defaults_for_2D_poisson_problem(), oomph::Hypre_default_settings::set_defaults_for_navier_stokes_momentum_block(), oomph::FSIPreconditioner::set_navier_stokes_mesh(), oomph::FSIHermiteBeamElement::set_normal_pointing_out_of_fluid(), oomph::FSIPreconditioner::set_wall_mesh(), oomph::KirchhoffLoveBeamEquations::undeformed_beam_pt(), oomph::FSIPreconditioner::use_block_triangular_version_with_fluid_on_solid(), FSIChannelWithLeafletProblem< ELEMENT >::wall_mesh_pt(), and FSIChannelWithLeafletProblem< ELEMENT >::Wall_mesh_pt.

◆ ~FSIChannelWithLeafletProblem() [1/4]

template<class ELEMENT >
FSIChannelWithLeafletProblem< ELEMENT >::~FSIChannelWithLeafletProblem ( )
inline

Destructor empty.

185 {}

◆ FSIChannelWithLeafletProblem() [2/4]

template<class ELEMENT >
FSIChannelWithLeafletProblem< ELEMENT >::FSIChannelWithLeafletProblem ( const unsigned &  mesh_multiplier)

Constructor: Pass multiplier for uniform mesh refinement.

Constructor.

491 {
492 
493  // Allocate the timesteppers
494  Bulk_time_stepper_pt=new BDF<2>;
495  add_time_stepper_pt(Bulk_time_stepper_pt);
496  Wall_time_stepper_pt=new Newmark<2>;
497  add_time_stepper_pt(Wall_time_stepper_pt);
498 
499  // Wall mesh
500  //----------
501 
502  // Geometric object that represents the undeformed leaflet
503  Undeformed_wall_pt=new UndeformedLeaflet(Global_Parameters::Leaflet_x0);
504 
505  //Create the "wall" mesh with FSI Hermite beam elements
506  unsigned n_wall_el=Global_Parameters::Mesh_ny1*mesh_multiplier;
507  Wall_mesh_pt = new OneDLagrangianMesh<FSIHermiteBeamElement>
508  (n_wall_el,Global_Parameters::Leaflet_height,
509  Undeformed_wall_pt,Wall_time_stepper_pt);
510 
511 
512  // Fluid mesh
513  // ----------
514 
515  // Build a geometric object from the wall mesh
516  Wall_geom_object_pt=new MeshAsGeomObject(Wall_mesh_pt);
517 
518  //Build the fluid mesh
519  Bulk_mesh_pt =new PseudoElasticChannelWithLeafletMesh<ELEMENT>(
520  Wall_geom_object_pt,
521  Global_Parameters::Fluid_length_left,
522  Global_Parameters::Fluid_length_right,
523  Global_Parameters::Leaflet_height,
524  Global_Parameters::Fluid_height,
525  Global_Parameters::Mesh_nleft*mesh_multiplier,
526  Global_Parameters::Mesh_nright*mesh_multiplier,
527  Global_Parameters::Mesh_ny1*mesh_multiplier,
528  Global_Parameters::Mesh_ny2*mesh_multiplier,
529  Bulk_time_stepper_pt);
530 
531 
532  // Construct the mesh of elements that enforce prescribed boundary motion
533  //-----------------------------------------------------------------------
534  // by Lagrange multipliers
535  //------------------------
536  Lagrange_multiplier_mesh_pt=new SolidMesh;
537  create_lagrange_multiplier_elements();
538 
539 
540  // Build global mesh
541  //------------------
542  add_sub_mesh(Bulk_mesh_pt);
543  add_sub_mesh(Lagrange_multiplier_mesh_pt);
544  add_sub_mesh(Wall_mesh_pt);
545  build_global_mesh();
546 
547 
548 
549  // Fluid boundary conditions
550  //--------------------------
551 
552  // Apply no-slip condition on all boundary nodes of the fluid mesh
553  unsigned num_bound = Bulk_mesh_pt->nboundary();
554  for(unsigned ibound=0;ibound<num_bound;ibound++)
555  {
556  unsigned num_nod= Bulk_mesh_pt->nboundary_node(ibound);
557  for (unsigned inod=0;inod<num_nod;inod++)
558  {
559  Bulk_mesh_pt->boundary_node_pt(ibound,inod)->pin(1);
560 
561  // Do not pin the x velocity of the outflow
562  if( ibound != 1)
563  {
564  Bulk_mesh_pt->boundary_node_pt(ibound,inod)->pin(0);
565  }
566  }
567  }
568 
569  // Pin the nodal position on all boundaries apart from
570  // the moving wall
571  for (unsigned ibound=0;ibound<7;ibound++)
572  {
573  if (ibound==0||ibound==1||ibound==2||ibound==3||ibound==6)
574  {
575  unsigned num_nod=Bulk_mesh_pt->nboundary_node(ibound);
576  for (unsigned inod=0;inod<num_nod;inod++)
577  {
578  for(unsigned i=0;i<2;i++)
579  {
580  if (!( (ibound==2)&&(i==0) ))
581  {
582  dynamic_cast<SolidNode*>(Bulk_mesh_pt->
583  boundary_node_pt(ibound, inod))
584  ->pin_position(i);
585  }
586  }
587  }
588  }
589  }
590 
591  // Setup parabolic flow along boundary 3 (everything else that's
592  // pinned has homogeneous boundary conditions so no action is required
593  // as that's the default assignment).
594  unsigned ibound=3;
595  unsigned num_nod= Bulk_mesh_pt->nboundary_node(ibound);
596  for (unsigned inod=0;inod<num_nod;inod++)
597  {
598  double ycoord = Bulk_mesh_pt->boundary_node_pt(ibound,inod)->x(1);
599  double uy = 4.0*ycoord/Global_Parameters::Fluid_height*
600  (1.0-ycoord/Global_Parameters::Fluid_height);
601  Bulk_mesh_pt->boundary_node_pt(ibound,inod)->set_value(0,uy);
602  Bulk_mesh_pt->boundary_node_pt(ibound,inod)->set_value(1,0.0);
603  }
604 
605  // Boundary conditions for wall mesh
606  // ---------------------------------
607 
608  // Set the boundary conditions: the lower end of the beam is fixed in space
609  unsigned b=0;
610 
611  // Pin displacements in both x and y directions
612  Wall_mesh_pt->boundary_node_pt(b,0)->pin_position(0);
613  Wall_mesh_pt->boundary_node_pt(b,0)->pin_position(1);
614 
615  // Infinite slope: Pin type 1 (slope) dof for displacement direction 0
616  Wall_mesh_pt->boundary_node_pt(b,0)->pin_position(1,0);
617 
618 
619  // Complete build of fluid elements
620  // --------------------------------
621 
622  //Set the constitutive law
623  Constitutive_law_pt = new GeneralisedHookean(&Global_Parameters::Nu);
624 
625  // Loop over the elements to set up element-specific
626  // things that cannot be handled by constructor
627  unsigned n_element = Bulk_mesh_pt->nelement();
628  for(unsigned e=0;e<n_element;e++)
629  {
630  // Upcast from GeneralisedElement to the present element
631  ELEMENT* el_pt = dynamic_cast<ELEMENT*>(Bulk_mesh_pt->element_pt(e));
632 
633  //Set the Reynolds number
634  el_pt->re_pt() = &Global_Parameters::Re;
635 
636  //Set the Womersley number
637  el_pt->re_st_pt() = &Global_Parameters::ReSt;
638 
639  //Set the constitutive law
640  el_pt->constitutive_law_pt() = Constitutive_law_pt;
641 
642  // Density of pseudo-solid
643  el_pt->lambda_sq_pt()=&Global_Parameters::Lambda_sq;
644 
645  }// end loop over elements
646 
647 
648 
649  // Complete build of wall elements
650  // -------------------------------
651  n_element = Wall_mesh_pt->nelement();
652  for(unsigned e=0;e<n_element;e++)
653  {
654  // Upcast to the specific element type
655  FSIHermiteBeamElement *elem_pt =
656  dynamic_cast<FSIHermiteBeamElement*>(Wall_mesh_pt->element_pt(e));
657 
658  // Set physical parameters for each element:
659  elem_pt->h_pt() = &Global_Parameters::H;
660 
661  // Function that specifies the load ratios
662  elem_pt->q_pt() = &Global_Parameters::Q;
663 
664  // Set the undeformed shape for each element
665  elem_pt->undeformed_beam_pt() = Undeformed_wall_pt;
666 
667  // Density of beam
668  elem_pt->lambda_sq_pt()=&Global_Parameters::Lambda_sq_beam;
669 
670  // Leaflet is immersed and loaded by fluid on both sides
671  elem_pt->enable_fluid_loading_on_both_sides();
672 
673  // The normal to the leaflet, as computed by the
674  // FSIHermiteElements points out of the fluid rather than
675  // into the fluid (as assumed by default) when viewed from
676  // the "front" (face 0).
677  elem_pt->set_normal_pointing_out_of_fluid();
678 
679  }
680 
681  // Setup FSI
682  // ---------
683 
684  // The velocity of the fluid nodes on the wall (fluid mesh boundary 4,5)
685  // is set by the wall motion -- hence the no-slip condition must be
686  // re-applied whenever a node update is performed for these nodes.
687  // Such tasks may be performed automatically by the auxiliary node update
688  // function specified by a function pointer:
689  for(unsigned ibound=4;ibound<6;ibound++ )
690  {
691  unsigned num_nod= Bulk_mesh_pt->nboundary_node(ibound);
692  for (unsigned inod=0;inod<num_nod;inod++)
693  {
694  Bulk_mesh_pt->boundary_node_pt(ibound, inod)->
695  set_auxiliary_node_update_fct_pt(
696  FSI_functions::apply_no_slip_on_moving_wall);
697  }
698  }// aux node update fct has been set
699 
700 
701 
702  // Work out which fluid dofs affect the residuals of the wall elements:
703  // We pass the boundary between the fluid and solid meshes and
704  // pointers to the meshes. The interaction boundary is boundary 4 and 5
705  // of the 2D fluid mesh.
706 
707  // Front of leaflet (face=0, which is also the default so this argument
708  // could be omitted) meets boundary 4 of the fluid mesh.
709  unsigned face=0;
710  FSI_functions::setup_fluid_load_info_for_solid_elements<ELEMENT,2>
711  (this,
712  4,
713  Bulk_mesh_pt,
714  Wall_mesh_pt,
715  face);
716 
717  // Back of leaflet: face 1, meets boundary 5 of fluid mesh
718  face=1;
719  FSI_functions::setup_fluid_load_info_for_solid_elements<ELEMENT,2>
720  (this,5,Bulk_mesh_pt,Wall_mesh_pt,face);
721 
722  // Setup equation numbering scheme
723  //--------------------------------
724  oomph_info << "Number of equations: " << assign_eqn_numbers() << std::endl;
725 
726 }//end of constructor
i
int i
Definition: BiCGSTAB_step_by_step.cpp:9
FSIChannelWithLeafletProblem::Wall_geom_object_pt
MeshAsGeomObject * Wall_geom_object_pt
Geometric object for the leaflet (to apply lagrange mult)
Definition: fsi_channel_with_leaflet_precond.cc:477
FSIChannelWithLeafletProblem::Bulk_mesh_pt
PseudoElasticChannelWithLeafletMesh< ELEMENT > * Bulk_mesh_pt
Pointer to the fluid mesh.
Definition: fsi_channel_with_leaflet_precond.cc:459
FSIChannelWithLeafletProblem::Constitutive_law_pt
ConstitutiveLaw * Constitutive_law_pt
Constitutive law used to determine the mesh deformation.
Definition: fsi_channel_with_leaflet_precond.cc:474
FSIChannelWithLeafletProblem::create_lagrange_multiplier_elements
void create_lagrange_multiplier_elements()
Definition: fsi_channel_with_leaflet_precond.cc:868
FSIChannelWithLeafletProblem::Lagrange_multiplier_mesh_pt
SolidMesh * Lagrange_multiplier_mesh_pt
Pointers to mesh of Lagrange multiplier elements.
Definition: fsi_channel_with_leaflet_precond.cc:471
FSIChannelWithLeafletProblem::Bulk_time_stepper_pt
BDF< 2 > * Bulk_time_stepper_pt
Bulk timestepper.
Definition: fsi_channel_with_leaflet_precond.cc:465
FSIChannelWithLeafletProblem::Wall_time_stepper_pt
Newmark< 2 > * Wall_time_stepper_pt
Wall time stepper pt.
Definition: fsi_channel_with_leaflet_precond.cc:468
FSIChannelWithLeafletProblem::Undeformed_wall_pt
UndeformedLeaflet * Undeformed_wall_pt
Geom object for the leaflet.
Definition: fsi_channel_with_leaflet_precond.cc:480
oomph::GeneralisedHookean
Definition: constitutive_laws.h:699
oomph::KirchhoffLoveBeamEquations::lambda_sq_pt
double *& lambda_sq_pt()
Return a pointer to timescale ratio (nondim density)
Definition: beam_elements.h:246
oomph::PseudoElasticChannelWithLeafletMesh
Channel with leaflet mesh upgraded to (pseudo-)solid mesh.
Definition: channel_with_leaflet_mesh.template.h:537
oomph::SolidMesh
Definition: mesh.h:2562
oomph::SolidNode
Definition: nodes.h:1686
Global_Parameters::Fluid_length_right
double Fluid_length_right
length of fluid mesh to right of leaflet
Definition: fsi_channel_with_leaflet_precond.cc:204
Global_Parameters::Nu
double Nu
Define Poisson's ratio Nu.
Definition: axisym_linear_elasticity/cylinder/cylinder.cc:46
Global_Parameters::Lambda_sq
double Lambda_sq
Timescale ratio (non-dim density) for solid.
Definition: interaction/pseudo_solid_collapsible_tube/pseudo_solid_collapsible_tube.cc:409
Global_Parameters::Leaflet_height
double Leaflet_height
height of leaflet
Definition: fsi_channel_with_leaflet_precond.cc:198
Global_Parameters::Mesh_ny1
unsigned Mesh_ny1
Num elements in fluid mesh in y dirn adjacent to leaflet.
Definition: fsi_channel_with_leaflet_precond.cc:216
Global_Parameters::Q
double Q
FSI parameter.
Definition: acoustic_fsi.cc:58
Global_Parameters::ReSt
double ReSt
Womersley number: Product of Reynolds and Strouhal numbers.
Definition: fsi_channel_with_leaflet_precond.cc:225
Global_Parameters::Mesh_nright
unsigned Mesh_nright
Num elements to right of leaflet in coarse mesh.
Definition: fsi_channel_with_leaflet_precond.cc:213
Global_Parameters::Leaflet_x0
double Leaflet_x0
x-position of root of leaflet
Definition: fsi_channel_with_leaflet_precond.cc:195
Global_Parameters::Mesh_nleft
unsigned Mesh_nleft
Num elements to left of leaflet in coarse mesh.
Definition: fsi_channel_with_leaflet_precond.cc:210
Global_Parameters::Re
double Re
reynolds number
Definition: adaptive_hopf.cc:54
Global_Parameters::Mesh_ny2
unsigned Mesh_ny2
Num elements in fluid mesh in y dirn above leaflet.
Definition: fsi_channel_with_leaflet_precond.cc:219
Global_Parameters::H
double H
wall thickness
Definition: interaction/pseudo_solid_collapsible_tube/pseudo_solid_collapsible_tube.cc:353
Global_Parameters::Fluid_length_left
double Fluid_length_left
length of fluid mesh to left of leaflet
Definition: fsi_channel_with_leaflet_precond.cc:201
Global_Parameters::Fluid_height
double Fluid_height
height of fluid mesh
Definition: fsi_channel_with_leaflet_precond.cc:207
Global_Parameters::Lambda_sq_beam
double Lambda_sq_beam
Beam mass density.
Definition: fsi_channel_with_leaflet_precond.cc:253
oomph::oomph_info
OomphInfo oomph_info
Definition: oomph_definitions.cc:319

References oomph::FSI_functions::apply_no_slip_on_moving_wall(), b, Constitutive::Constitutive_law_pt, e(), oomph::FSIWallElement::enable_fluid_loading_on_both_sides(), Global_Parameters::Fluid_height, Global_Parameters::Fluid_length_left, Global_Parameters::Fluid_length_right, Global_Parameters::H, oomph::KirchhoffLoveBeamEquations::h_pt(), i, Global_Parameters::Lambda_sq, Global_Parameters::Lambda_sq_beam, oomph::KirchhoffLoveBeamEquations::lambda_sq_pt(), Global_Parameters::Leaflet_height, Global_Parameters::Leaflet_x0, Global_Parameters::Mesh_nleft, Global_Parameters::Mesh_nright, Global_Parameters::Mesh_ny1, Global_Parameters::Mesh_ny2, Global_Parameters::Nu, oomph::oomph_info, Global_Parameters::Q, oomph::FSIWallElement::q_pt(), Global_Parameters::Re, Global_Parameters::ReSt, oomph::FSIHermiteBeamElement::set_normal_pointing_out_of_fluid(), oomph::KirchhoffLoveBeamEquations::undeformed_beam_pt(), and oomph::Node::x().

◆ ~FSIChannelWithLeafletProblem() [2/4]

template<class ELEMENT >
FSIChannelWithLeafletProblem< ELEMENT >::~FSIChannelWithLeafletProblem ( )
inline

Destructor empty.

357  {
358  delete Bulk_mesh_pt;
359  delete Lagrange_multiplier_mesh_pt;
360  delete Wall_mesh_pt;
361  delete Bulk_time_stepper_pt;
362  delete Wall_time_stepper_pt;
363  delete Wall_geom_object_pt;
364  delete Undeformed_wall_pt;
365  delete Constitutive_law_pt;
366  }

References Constitutive::Constitutive_law_pt.

◆ FSIChannelWithLeafletProblem() [3/4]

template<class ELEMENT >
FSIChannelWithLeafletProblem< ELEMENT >::FSIChannelWithLeafletProblem ( const double &  lleft,
const double &  lright,
const double &  hleaflet,
const double &  htot,
const unsigned &  nleft,
const unsigned &  nright,
const unsigned &  ny1,
const unsigned &  ny2,
const double &  x_0 
)

Constructor: Pass the lenght of the domain at the left of the leaflet lleft,the lenght of the domain at the right of the leaflet lright,the height of the leaflet hleaflet, the total height of the domain htot, the number of macro-elements at the left of the leaflet nleft, the number of macro-elements at the right of the leaflet nright, the number of macro-elements under hleaflet ny1, the number of macro-elements above hleaflet ny2, the abscissa of the origin of the leaflet x_0.

◆ ~FSIChannelWithLeafletProblem() [3/4]

template<class ELEMENT >
FSIChannelWithLeafletProblem< ELEMENT >::~FSIChannelWithLeafletProblem ( )
inline

Destructor empty.

185 {}

◆ FSIChannelWithLeafletProblem() [4/4]

template<class ELEMENT >
FSIChannelWithLeafletProblem< ELEMENT >::FSIChannelWithLeafletProblem ( const double &  lleft,
const double &  lright,
const double &  hleaflet,
const double &  htot,
const unsigned &  nleft,
const unsigned &  nright,
const unsigned &  ny1,
const unsigned &  ny2,
const double &  x_0 
)

Constructor: Pass the lenght of the domain at the left of the leaflet lleft,the lenght of the domain at the right of the leaflet lright,the height of the leaflet hleaflet, the total height of the domain htot, the number of macro-elements at the left of the leaflet nleft, the number of macro-elements at the right of the leaflet nright, the number of macro-elements under hleaflet ny1, the number of macro-elements above hleaflet ny2, the abscissa of the origin of the leaflet x_0.

◆ ~FSIChannelWithLeafletProblem() [4/4]

template<class ELEMENT >
FSIChannelWithLeafletProblem< ELEMENT >::~FSIChannelWithLeafletProblem ( )
inline

Destructor empty.

184 {}

Member Function Documentation

◆ actions_after_adapt() [1/3]

template<class ELEMENT >
void FSIChannelWithLeafletProblem< ELEMENT >::actions_after_adapt
virtual

Actions after adaptation.

Actions_after_adapt()

Reimplemented from oomph::Problem.

573 {
574  // Unpin all pressure dofs
575  RefineableNavierStokesEquations<2>::
576  unpin_all_pressure_dofs(Fluid_mesh_pt->element_pt());
577 
578  // Pin redundant pressure dofs
579  RefineableNavierStokesEquations<2>::
580  pin_redundant_nodal_pressures(Fluid_mesh_pt->element_pt());
581 
582 
583  // (Re-)apply the no slip condition on the moving wall
584  //-----------------------------------------------------
585 
586  // The velocity of the fluid nodes on the wall (fluid mesh boundary 4,5)
587  // is set by the wall motion -- hence the no-slip condition must be
588  // re-applied whenever a node update is performed for these nodes.
589  // Such tasks may be performed automatically by the auxiliary node update
590  // function specified by a function pointer:
591  for(unsigned ibound=4;ibound<6;ibound++ )
592  {
593  unsigned num_nod= Fluid_mesh_pt->nboundary_node(ibound);
594  for (unsigned inod=0;inod<num_nod;inod++)
595  {
596  Fluid_mesh_pt->boundary_node_pt(ibound, inod)->
597  set_auxiliary_node_update_fct_pt(
598  FSI_functions::apply_no_slip_on_moving_wall);
599  }
600  } // aux node update fct has been (re-)set
601 
602 
603 
604  // Re-setup FSI
605  //-------------
606 
607  // Work out which fluid dofs affect the residuals of the wall elements:
608  // We pass the boundary between the fluid and solid meshes and
609  // pointers to the meshes. The interaction boundary is boundary 4 and 5
610  // of the 2D fluid mesh.
611 
612  // Front of leaflet: Set face=0 (which is also the default so this argument
613  // could be omitted)
614  unsigned face=0;
615  FSI_functions::setup_fluid_load_info_for_solid_elements<ELEMENT,2>
616  (this,4,Fluid_mesh_pt,Wall_mesh_pt,face);
617 
618  // Back of leaflet: face 1, needs to be specified explicitly
619  face=1;
620  FSI_functions::setup_fluid_load_info_for_solid_elements<ELEMENT,2>
621  (this,5,Fluid_mesh_pt,Wall_mesh_pt,face);
622 
623 } // end_of_actions_after_adapt

References oomph::FSI_functions::apply_no_slip_on_moving_wall().

◆ actions_after_adapt() [2/3]

template<class ELEMENT >
void FSIChannelWithLeafletProblem< ELEMENT >::actions_after_adapt ( )
virtual

Actions after adaptation.

Reimplemented from oomph::Problem.

◆ actions_after_adapt() [3/3]

template<class ELEMENT >
void FSIChannelWithLeafletProblem< ELEMENT >::actions_after_adapt ( )
virtual

Actions after adaptation.

Reimplemented from oomph::Problem.

◆ actions_after_distribute()

template<class ELEMENT >
void FSIChannelWithLeafletProblem< ELEMENT >::actions_after_distribute

Actions after distribution.

Actions_after_distribute()

630 {
631  // Re-setup FSI
632  //-------------
633 
634  // Work out which fluid dofs affect the residuals of the wall elements:
635  // We pass the boundary between the fluid and solid meshes and
636  // pointers to the meshes. The interaction boundary is boundary 4 and 5
637  // of the 2D fluid mesh.
638 
639  // Front of leaflet: Set face=0 (which is also the default so this argument
640  // could be omitted)
641  unsigned face=0;
642  FSI_functions::setup_fluid_load_info_for_solid_elements<ELEMENT,2>
643  (this,4,Fluid_mesh_pt,Wall_mesh_pt,face);
644 
645  // Back of leaflet: face 1, needs to be specified explicitly
646  face=1;
647  FSI_functions::setup_fluid_load_info_for_solid_elements<ELEMENT,2>
648  (this,5,Fluid_mesh_pt,Wall_mesh_pt,face);
649 
650  // (Re-)apply the no slip condition on the moving wall
651  //-----------------------------------------------------
652 
653  // The velocity of the fluid nodes on the wall (fluid mesh boundary 4,5)
654  // is set by the wall motion -- hence the no-slip condition must be
655  // re-applied whenever a node update is performed for these nodes.
656  // Such tasks may be performed automatically by the auxiliary node update
657  // function specified by a function pointer:
658  for(unsigned ibound=4;ibound<6;ibound++ )
659  {
660  unsigned num_nod= Fluid_mesh_pt->nboundary_node(ibound);
661  for (unsigned inod=0;inod<num_nod;inod++)
662  {
663  Fluid_mesh_pt->boundary_node_pt(ibound, inod)->
664  set_auxiliary_node_update_fct_pt(
665  FSI_functions::apply_no_slip_on_moving_wall);
666  }
667  } // aux node update fct has been (re-)set
668 
669 
670 } // end_of_actions_after_distribute

References oomph::FSI_functions::apply_no_slip_on_moving_wall().

◆ actions_after_newton_solve() [1/4]

template<class ELEMENT >
void FSIChannelWithLeafletProblem< ELEMENT >::actions_after_newton_solve ( )
inlinevirtual

Actions after solve (empty)

Reimplemented from oomph::Problem.

188 {}

◆ actions_after_newton_solve() [2/4]

template<class ELEMENT >
void FSIChannelWithLeafletProblem< ELEMENT >::actions_after_newton_solve ( )
inlinevirtual

Actions after solve (empty)

Reimplemented from oomph::Problem.

369 {}

◆ actions_after_newton_solve() [3/4]

template<class ELEMENT >
void FSIChannelWithLeafletProblem< ELEMENT >::actions_after_newton_solve ( )
inlinevirtual

Actions after solve (empty)

Reimplemented from oomph::Problem.

188 {}

◆ actions_after_newton_solve() [4/4]

template<class ELEMENT >
void FSIChannelWithLeafletProblem< ELEMENT >::actions_after_newton_solve ( )
inlinevirtual

Actions after solve (empty)

Reimplemented from oomph::Problem.

187 {}

◆ actions_before_implicit_timestep() [1/4]

template<class ELEMENT >
void FSIChannelWithLeafletProblem< ELEMENT >::actions_before_implicit_timestep ( )
inlinevirtual

Update the inflow velocity.

Reimplemented from oomph::Problem.

214  {
215  // Actual time
216  double t=time_pt()->time();
217 
218  // Amplitude of flow
219  double ampl=Global_Physical_Variables::flux(t);
220 
221  // Update parabolic flow along boundary 3
222  unsigned ibound=3;
223  unsigned num_nod= Fluid_mesh_pt->nboundary_node(ibound);
224  for (unsigned inod=0;inod<num_nod;inod++)
225  {
226  double ycoord = Fluid_mesh_pt->boundary_node_pt(ibound,inod)->x(1);
227  double uy = ampl*6.0*ycoord/Htot*(1.0-ycoord/Htot);
228  Fluid_mesh_pt->boundary_node_pt(ibound,inod)->set_value(0,uy);
229  Fluid_mesh_pt->boundary_node_pt(ibound,inod)->set_value(1,0.0);
230  }
231  } // end of actions_before_implicit_timestep
oomph::Problem::time_pt
Time *& time_pt()
Return a pointer to the global time object.
Definition: problem.h:1504
oomph::Time::time
double & time()
Return the current value of the continuous time.
Definition: timesteppers.h:123
Global_Physical_Variables::flux
double flux(const double &t)
Definition: interaction/fsi_channel_with_leaflet/fsi_channel_with_leaflet.cc:72
plotPSD.t
t
Definition: plotPSD.py:36

References Global_Physical_Variables::flux(), and plotPSD::t.

◆ actions_before_implicit_timestep() [2/4]

template<class ELEMENT >
void FSIChannelWithLeafletProblem< ELEMENT >::actions_before_implicit_timestep ( )
inlinevirtual

Actions before implicit timestep: Update the inflow velocity.

Reimplemented from oomph::Problem.

393  {
394  // Actual time
395  double t=time_pt()->time();
396 
397  // Amplitude of flow
398  double ampl=Global_Parameters::flux(t);
399 
400  // Update parabolic flow along boundary 3
401  unsigned ibound=3;
402  unsigned num_nod= Bulk_mesh_pt->nboundary_node(ibound);
403  for (unsigned inod=0;inod<num_nod;inod++)
404  {
405  double ycoord = Bulk_mesh_pt->boundary_node_pt(ibound,inod)->x(1);
406  double uy = ampl*4.0*ycoord/Global_Parameters::Fluid_height*
407  (1.0-ycoord/Global_Parameters::Fluid_height);
408  Bulk_mesh_pt->boundary_node_pt(ibound,inod)->set_value(0,uy);
409  Bulk_mesh_pt->boundary_node_pt(ibound,inod)->set_value(1,0.0);
410  }
411  } // end of actions_before_implicit_timestep
Global_Parameters::flux
double flux(const double &t)
Flux: Pulsatile flow.
Definition: fsi_channel_with_leaflet_precond.cc:244

References Global_Parameters::Fluid_height, Global_Parameters::flux(), and plotPSD::t.

◆ actions_before_implicit_timestep() [3/4]

template<class ELEMENT >
void FSIChannelWithLeafletProblem< ELEMENT >::actions_before_implicit_timestep ( )
inlinevirtual

Update the inflow velocity.

Reimplemented from oomph::Problem.

217  {
218  // Actual time
219  double t=time_pt()->time();
220 
221  // Amplitude of flow
222  double ampl=Global_Physical_Variables::flux(t);
223 
224  // Update parabolic flow along boundary 3
225  unsigned ibound=3;
226  unsigned num_nod= Fluid_mesh_pt->nboundary_node(ibound);
227  for (unsigned inod=0;inod<num_nod;inod++)
228  {
229  double ycoord = Fluid_mesh_pt->boundary_node_pt(ibound,inod)->x(1);
230  double uy = ampl*6.0*ycoord/Htot*(1.0-ycoord/Htot);
231  Fluid_mesh_pt->boundary_node_pt(ibound,inod)->set_value(0,uy);
232  Fluid_mesh_pt->boundary_node_pt(ibound,inod)->set_value(1,0.0);
233  }
234  } // end of actions_before_implicit_timestep

References Global_Physical_Variables::flux(), and plotPSD::t.

◆ actions_before_implicit_timestep() [4/4]

template<class ELEMENT >
void FSIChannelWithLeafletProblem< ELEMENT >::actions_before_implicit_timestep ( )
inlinevirtual

Update the inflow velocity.

Reimplemented from oomph::Problem.

213  {
214  // Actual time
215  double t=time_pt()->time();
216 
217  // Amplitude of flow
218  double ampl=Global_Physical_Variables::flux(t);
219 
220  // Update parabolic flow along boundary 3
221  unsigned ibound=3;
222  unsigned num_nod= Fluid_mesh_pt->nboundary_node(ibound);
223  for (unsigned inod=0;inod<num_nod;inod++)
224  {
225  double ycoord = Fluid_mesh_pt->boundary_node_pt(ibound,inod)->x(1);
226  double uy = ampl*6.0*ycoord/Htot*(1.0-ycoord/Htot);
227  Fluid_mesh_pt->boundary_node_pt(ibound,inod)->set_value(0,uy);
228  Fluid_mesh_pt->boundary_node_pt(ibound,inod)->set_value(1,0.0);
229  }
230  } // end of actions_before_implicit_timestep

References Global_Physical_Variables::flux(), and plotPSD::t.

◆ actions_before_newton_convergence_check() [1/4]

template<class ELEMENT >
void FSIChannelWithLeafletProblem< ELEMENT >::actions_before_newton_convergence_check ( )
inlinevirtual

Update before checking Newton convergence: Update the nodal positions in the fluid mesh in response to possible changes in the wall shape

Reimplemented from oomph::Problem.

237  {
238  Fluid_mesh_pt->node_update();
239  }

◆ actions_before_newton_convergence_check() [2/4]

template<class ELEMENT >
void FSIChannelWithLeafletProblem< ELEMENT >::actions_before_newton_convergence_check ( )
inlinevirtual

Update no slip before Newton convergence check.

Reimplemented from oomph::Problem.

381  {
382  // Loop over the nodes to perform auxiliary node update (no slip)
383  unsigned nnod=Bulk_mesh_pt->nnode();
384  for (unsigned j=0;j<nnod;j++)
385  {
386  Bulk_mesh_pt->node_pt(j)->perform_auxiliary_node_update_fct();
387  }
388 
389  }
j
std::ptrdiff_t j
Definition: tut_arithmetic_redux_minmax.cpp:2

References j.

◆ actions_before_newton_convergence_check() [3/4]

template<class ELEMENT >
void FSIChannelWithLeafletProblem< ELEMENT >::actions_before_newton_convergence_check ( )
inlinevirtual

Update before checking Newton convergence: Update the nodal positions in the fluid mesh in response to possible changes in the wall shape

Reimplemented from oomph::Problem.

240  {
241  Fluid_mesh_pt->node_update();
242  }

◆ actions_before_newton_convergence_check() [4/4]

template<class ELEMENT >
void FSIChannelWithLeafletProblem< ELEMENT >::actions_before_newton_convergence_check ( )
inlinevirtual

Update before checking Newton convergence: Update the nodal positions in the fluid mesh in response to possible changes in the wall shape

Reimplemented from oomph::Problem.

236  {
237  Fluid_mesh_pt->node_update();
238  }

◆ actions_before_newton_solve() [1/4]

template<class ELEMENT >
void FSIChannelWithLeafletProblem< ELEMENT >::actions_before_newton_solve ( )
inlinevirtual

Actions before solve (empty)

Reimplemented from oomph::Problem.

191 {}

◆ actions_before_newton_solve() [2/4]

template<class ELEMENT >
void FSIChannelWithLeafletProblem< ELEMENT >::actions_before_newton_solve ( )
inlinevirtual

Actions before Newton solve: Reset the pseudo-elastic undeformed configuration

Reimplemented from oomph::Problem.

374  {
375  // Reset undeformed configuration for pseudo-solid
376  Bulk_mesh_pt->set_lagrangian_nodal_coordinates();
377  }

◆ actions_before_newton_solve() [3/4]

template<class ELEMENT >
void FSIChannelWithLeafletProblem< ELEMENT >::actions_before_newton_solve ( )
inlinevirtual

Actions before solve (empty)

Reimplemented from oomph::Problem.

191 {}

◆ actions_before_newton_solve() [4/4]

template<class ELEMENT >
void FSIChannelWithLeafletProblem< ELEMENT >::actions_before_newton_solve ( )
inlinevirtual

Actions before solve (empty)

Reimplemented from oomph::Problem.

190 {}

◆ create_lagrange_multiplier_elements()

template<class ELEMENT >
void FSIChannelWithLeafletProblem< ELEMENT >::create_lagrange_multiplier_elements

Create elements that enforce prescribed boundary motion by Lagrange multipliers

Create elements that impose the prescribed boundary displacement by Lagrange multipliers

869 {
870  // Lagrange multiplier elements are located on boundary 4 and 5
871  for (unsigned b=4;b<=5;b++)
872  {
873  // How many bulk elements are adjacent to boundary b?
874  unsigned n_bulk_element = Bulk_mesh_pt->nboundary_element(b);
875 
876  // Loop over the bulk elements adjacent to boundary b?
877  for(unsigned e=0;e<n_bulk_element;e++)
878  {
879  // Get pointer to the bulk element that is adjacent to boundary b
880  ELEMENT* bulk_elem_pt = dynamic_cast<ELEMENT*>(
881  Bulk_mesh_pt->boundary_element_pt(b,e));
882 
883  //Find the index of the face of element e along boundary b
884  int face_index = Bulk_mesh_pt->face_index_at_boundary(b,e);
885 
886  // Create new element
887  ImposeDisplacementByLagrangeMultiplierElement<ELEMENT> *el_pt =
888  new ImposeDisplacementByLagrangeMultiplierElement<ELEMENT>(
889  bulk_elem_pt,face_index);
890 
891  // Add to mesh
892  Lagrange_multiplier_mesh_pt->add_element_pt(el_pt);
893 
894  // Set the GeomObject that defines the boundary shape and set
895  // which bulk boundary we are attached to(needed to extract
896  // the boundary coordinate from the bulk nodes)
897  el_pt->set_boundary_shape_geom_object_pt(Wall_geom_object_pt,b);
898  }
899  }
900 
901  // Pin Lagrange multiplier unknowns for fluid nodes whose position
902  // is already pinned
903  unsigned n_element=Lagrange_multiplier_mesh_pt->nelement();
904  for(unsigned i=0;i<n_element;i++)
905  {
906  //Cast to a Lagrange multiplier element
907  ImposeDisplacementByLagrangeMultiplierElement<ELEMENT> *el_pt =
908  dynamic_cast<ImposeDisplacementByLagrangeMultiplierElement<ELEMENT>*>
909  (Lagrange_multiplier_mesh_pt->element_pt(i));
910 
911  // Loop over the nodes
912  unsigned nnod=el_pt->nnode();
913  for (unsigned j=0;j<nnod;j++)
914  {
915  Node* nod_pt = el_pt->node_pt(j);
916 
917  // Is the node also on boundary 0 or 6 (i.e. on bottom wall)>
918  if ((nod_pt->is_on_boundary(0))||(nod_pt->is_on_boundary(6)))
919  {
920  // How many nodal values were used by the "bulk" element
921  // that originally created this node?
922  unsigned n_bulk_value=el_pt->nbulk_value(j);
923 
924  // The remaining ones are Lagrange multipliers and we pin them.
925  unsigned nval=nod_pt->nvalue();
926  for (unsigned k=n_bulk_value;k<nval;k++)
927  {
928  nod_pt->pin(k);
929  }
930  }
931  }
932  }
933 }
oomph::Data::pin
void pin(const unsigned &i)
Pin the i-th stored variable.
Definition: nodes.h:385
oomph::Data::nvalue
unsigned nvalue() const
Return number of values stored in data object (incl pinned ones).
Definition: nodes.h:483
oomph::FaceElement::nbulk_value
unsigned & nbulk_value(const unsigned &n)
Definition: elements.h:4845
oomph::FiniteElement::node_pt
Node *& node_pt(const unsigned &n)
Return a pointer to the local node n.
Definition: elements.h:2175
oomph::FiniteElement::nnode
unsigned nnode() const
Return the number of nodes.
Definition: elements.h:2210
oomph::ImposeDisplacementByLagrangeMultiplierElement
Definition: solid_traction_elements.h:1107
oomph::ImposeDisplacementByLagrangeMultiplierElement::set_boundary_shape_geom_object_pt
void set_boundary_shape_geom_object_pt(GeomObject *boundary_shape_geom_object_pt, const unsigned &boundary_number_in_bulk_mesh)
Definition: solid_traction_elements.h:1209
oomph::Mesh::add_element_pt
void add_element_pt(GeneralisedElement *const &element_pt)
Add a (pointer to) an element to the mesh.
Definition: mesh.h:617
oomph::Node
Definition: nodes.h:906
oomph::Node::is_on_boundary
virtual bool is_on_boundary() const
Definition: nodes.h:1373
k
char char char int int * k
Definition: level2_impl.h:374

References b, e(), i, oomph::Node::is_on_boundary(), j, k, oomph::FaceElement::nbulk_value(), oomph::FiniteElement::nnode(), oomph::FiniteElement::node_pt(), oomph::Data::nvalue(), oomph::Data::pin(), and oomph::ImposeDisplacementByLagrangeMultiplierElement< ELEMENT >::set_boundary_shape_geom_object_pt().

◆ delete_lagrange_multiplier_elements()

template<class ELEMENT >
void FSIChannelWithLeafletProblem< ELEMENT >::delete_lagrange_multiplier_elements

Delete elements that enforce prescribed boundary motion by Lagrange multipliers

Delete elements that impose the prescribed boundary displacement and wipe the associated mesh

944 {
945  // How many surface elements are in the surface mesh
946  unsigned n_element = Lagrange_multiplier_mesh_pt->nelement();
947 
948  // Loop over the surface elements
949  for(unsigned e=0;e<n_element;e++)
950  {
951  // Kill surface element
952  delete Lagrange_multiplier_mesh_pt->element_pt(e);
953  }
954 
955  // Wipe the mesh
956  Lagrange_multiplier_mesh_pt->flush_element_and_node_storage();
957 
958 } // end of delete_lagrange_multiplier_elements
oomph::Mesh::flush_element_and_node_storage
void flush_element_and_node_storage()
Definition: mesh.h:407

References e().

◆ doc_parameters()

template<class ELEMENT >
void FSIChannelWithLeafletProblem< ELEMENT >::doc_parameters ( )
inline

Doc parameters.

429  {
430  oomph_info << "\n\n=================================================\n";
431  oomph_info << "Q : " << Global_Parameters::Q
432  << std::endl;
433  oomph_info << "Re : " << Global_Parameters::Re
434  << std::endl;
435  oomph_info << "Lambda_sq_beam : " << Global_Parameters::Lambda_sq_beam
436  << std::endl;
437  oomph_info << "T : " << Global_Parameters::T
438  <<std::endl;
439  oomph_info << "t : " << time_pt()->time()
440  << std::endl;
441  oomph_info << "tip x : "
442  << tip_node_pt()->x(0) << std::endl;
443  oomph_info << "tip y : "
444  << tip_node_pt()->x(1) << std::endl;
445  oomph_info << "=================================================\n\n";
446  }
FSIChannelWithLeafletProblem::tip_node_pt
Node * tip_node_pt()
Helper fct; returns the node at the tip of the wall mesh.
Definition: fsi_channel_with_leaflet_precond.cc:451
oomph::Node::x
double & x(const unsigned &i)
Return the i-th nodal coordinate.
Definition: nodes.h:1060
Global_Parameters::T
double T
Period of periodic variation in inflow pressure.
Definition: interaction/pseudo_solid_collapsible_tube/pseudo_solid_collapsible_tube.cc:412

References Global_Parameters::Lambda_sq_beam, oomph::oomph_info, Global_Parameters::Q, Global_Parameters::Re, and Global_Parameters::T.

◆ doc_solution() [1/4]

template<class ELEMENT >
void FSIChannelWithLeafletProblem< ELEMENT >::doc_solution ( DocInfo &  doc_info)

Doc the solution.

967 {
968  ofstream some_file;
969  char filename[100];
970 
971  // Number of plot points
972  unsigned npts;
973  npts=5;
974 
975  // Output fluid solution
976  sprintf(filename,"%s/soln%i.dat",doc_info.directory().c_str(),
977  doc_info.number());
978  some_file.open(filename);
979  Bulk_mesh_pt->output(some_file,npts);
980  some_file.close();
981 
982  // Output wall solution
983  sprintf(filename,"%s/wall_soln%i.dat",doc_info.directory().c_str(),
984  doc_info.number());
985  some_file.open(filename);
986  Wall_mesh_pt->output(some_file,npts);
987  some_file.close();
988 
989  // Help me figure out what the "front" and "back" faces of the leaflet are
990  //------------------------------------------------------------------------
991 
992  // Output fluid elements on fluid mesh boundary 4 (associated with
993  // the "front")
994  unsigned bound=4;
995  sprintf(filename,"%s/bulk_boundary_elements_front_%i.dat",
996  doc_info.directory().c_str(),
997  doc_info.number());
998  some_file.open(filename);
999  unsigned nel= Bulk_mesh_pt->nboundary_element(bound);
1000  for (unsigned e=0;e<nel;e++)
1001  {
1002  dynamic_cast<ELEMENT*>(Bulk_mesh_pt->boundary_element_pt(bound,e))
1003  ->output(some_file,npts);
1004  }
1005  some_file.close();
1006 
1007 
1008  // Output fluid elements on fluid mesh boundary 5 (associated with
1009  // the "back")
1010  bound=5;
1011  sprintf(filename,"%s/bulk_boundary_elements_back_%i.dat",
1012  doc_info.directory().c_str(),
1013  doc_info.number());
1014  some_file.open(filename);
1015  nel= Bulk_mesh_pt->nboundary_element(bound);
1016  for (unsigned e=0;e<nel;e++)
1017  {
1018  dynamic_cast<ELEMENT*>(Bulk_mesh_pt->boundary_element_pt(bound,e))
1019  ->output(some_file,npts);
1020  }
1021  some_file.close();
1022 
1023 
1024  // Output normal vector on wall elements
1025  sprintf(filename,"%s/wall_normal_%i.dat",
1026  doc_info.directory().c_str(),
1027  doc_info.number());
1028  some_file.open(filename);
1029  nel=Wall_mesh_pt->nelement();
1030  Vector<double> s(1);
1031  Vector<double> x(2);
1032  Vector<double> xi(1);
1033  Vector<double> N(2);
1034  for (unsigned e=0;e<nel;e++)
1035  {
1036  // Get pointer to element
1037  FSIHermiteBeamElement* el_pt=
1038  dynamic_cast<FSIHermiteBeamElement*>(Wall_mesh_pt->element_pt(e));
1039 
1040  // Loop over plot points
1041  for (unsigned i=0;i<npts;i++)
1042  {
1043  s[0]=-1.0+2.0*double(i)/double(npts-1);
1044 
1045  // Get Eulerian position
1046  el_pt->interpolated_x(s,x);
1047 
1048  // Get unit normal
1049  el_pt->get_normal(s,N);
1050 
1051  // Get Lagrangian coordinate
1052  el_pt->interpolated_xi(s,xi);
1053 
1054  some_file << x[0] << " " << x[1] << " "
1055  << N[0] << " " << N[1] << " "
1056  << xi[0] << std::endl;
1057  }
1058  }
1059  some_file.close();
1060 
1061 } // end_of_doc_solution
oomph::DocInfo::directory
std::string directory() const
Output directory.
Definition: oomph_utilities.h:524
oomph::DocInfo::number
unsigned & number()
Number used (e.g.) for labeling output files.
Definition: oomph_utilities.h:554
oomph::FiniteElement::interpolated_x
virtual double interpolated_x(const Vector< double > &s, const unsigned &i) const
Return FE interpolated coordinate x[i] at local coordinate s.
Definition: elements.cc:3962
oomph::KirchhoffLoveBeamEquations::get_normal
void get_normal(const Vector< double > &s, Vector< double > &N)
Get normal vector on wall.
Definition: beam_elements.h:259
oomph::Mesh::output
void output(std::ostream &outfile)
Output for all elements.
Definition: mesh.cc:2027
oomph::SolidFiniteElement::interpolated_xi
virtual double interpolated_xi(const Vector< double > &s, const unsigned &i) const
Definition: elements.cc:7104
N
@ N
Definition: constructor.cpp:22
s
RealScalar s
Definition: level1_cplx_impl.h:130
MergeRestartFiles.filename
string filename
Definition: MergeRestartFiles.py:39
plotDoE.x
list x
Definition: plotDoE.py:28
output
void output(std::ostream &outfile, const unsigned &nplot)
Overload output function.
Definition: overloaded_element_body.h:490

References oomph::DocInfo::directory(), e(), MergeRestartFiles::filename, oomph::KirchhoffLoveBeamEquations::get_normal(), i, oomph::FiniteElement::interpolated_x(), oomph::SolidFiniteElement::interpolated_xi(), N, oomph::DocInfo::number(), output(), s, and plotDoE::x.

◆ doc_solution() [2/4]

template<class ELEMENT >
void FSIChannelWithLeafletProblem< ELEMENT >::doc_solution ( DocInfo &  doc_info)

Doc the solution.

◆ doc_solution() [3/4]

template<class ELEMENT >
void FSIChannelWithLeafletProblem< ELEMENT >::doc_solution ( DocInfo &  doc_info,
ofstream &  trace 
)

Doc the solution.

635 {
636  ofstream some_file;
637  char filename[100];
638 
639  // Number of plot points
640  unsigned npts;
641  npts=5;
642 
643  // Output fluid solution
644  sprintf(filename,"%s/soln%i.dat",doc_info.directory().c_str(),
645  doc_info.number());
646  some_file.open(filename);
647  Fluid_mesh_pt->output(some_file,npts);
648  some_file.close();
649 
650  // Output wall solution
651  sprintf(filename,"%s/wall_soln%i.dat",doc_info.directory().c_str(),
652  doc_info.number());
653  some_file.open(filename);
654  Wall_mesh_pt->output(some_file,npts);
655  some_file.close();
656 
657  // Get node at tip of leaflet
658  unsigned n_el_wall=Wall_mesh_pt->nelement();
659  Node* tip_node_pt=Wall_mesh_pt->finite_element_pt(n_el_wall-1)->node_pt(1);
660 
661  // Get time:
662  double time=time_pt()->time();
663 
664  // Write trace file
665  trace << time << " "
666  << Global_Physical_Variables::flux(time) << " "
667  << tip_node_pt->x(0) << " "
668  << tip_node_pt->x(1) << " "
669  << tip_node_pt->dposition_dt(0) << " "
670  << tip_node_pt->dposition_dt(1) << " "
671  << doc_info.number() << " "
672  << std::endl;
673 
674 
675  // Help me figure out what the "front" and "back" faces of the leaflet are
676  //------------------------------------------------------------------------
677 
678  // Output fluid elements on fluid mesh boundary 4 (associated with
679  // the "front")
680  unsigned bound=4;
681  sprintf(filename,"%s/fluid_boundary_elements_front_%i.dat",
682  doc_info.directory().c_str(),
683  doc_info.number());
684  some_file.open(filename);
685  unsigned nel= Fluid_mesh_pt->nboundary_element(bound);
686  for (unsigned e=0;e<nel;e++)
687  {
688  dynamic_cast<ELEMENT*>(Fluid_mesh_pt->boundary_element_pt(bound,e))
689  ->output(some_file,npts);
690  }
691  some_file.close();
692 
693 
694  // Output fluid elements on fluid mesh boundary 5 (associated with
695  // the "back")
696  bound=5;
697  sprintf(filename,"%s/fluid_boundary_elements_back_%i.dat",
698  doc_info.directory().c_str(),
699  doc_info.number());
700  some_file.open(filename);
701  nel= Fluid_mesh_pt->nboundary_element(bound);
702  for (unsigned e=0;e<nel;e++)
703  {
704  dynamic_cast<ELEMENT*>(Fluid_mesh_pt->boundary_element_pt(bound,e))
705  ->output(some_file,npts);
706  }
707  some_file.close();
708 
709 
710  // Output normal vector on wall elements
711  sprintf(filename,"%s/wall_normal_%i.dat",
712  doc_info.directory().c_str(),
713  doc_info.number());
714  some_file.open(filename);
715  nel=Wall_mesh_pt->nelement();
716  Vector<double> s(1);
717  Vector<double> x(2);
718  Vector<double> xi(1);
719  Vector<double> N(2);
720  for (unsigned e=0;e<nel;e++)
721  {
722  // Get pointer to element
723  FSIHermiteBeamElement* el_pt=
724  dynamic_cast<FSIHermiteBeamElement*>(Wall_mesh_pt->element_pt(e));
725 
726  // Loop over plot points
727  for (unsigned i=0;i<npts;i++)
728  {
729  s[0]=-1.0+2.0*double(i)/double(npts-1);
730 
731  // Get Eulerian position
732  el_pt->interpolated_x(s,x);
733 
734  // Get unit normal
735  el_pt->get_normal(s,N);
736 
737  // Get Lagrangian coordinate
738  el_pt->interpolated_xi(s,xi);
739 
740  some_file << x[0] << " " << x[1] << " "
741  << N[0] << " " << N[1] << " "
742  << xi[0] << std::endl;
743  }
744  }
745  some_file.close();
746 
747 } // end_of_doc_solution
oomph::Mesh::finite_element_pt
FiniteElement * finite_element_pt(const unsigned &e) const
Definition: mesh.h:473
oomph::Node::dposition_dt
double dposition_dt(const unsigned &i) const
Definition: nodes.cc:2659
oomph::Problem::time
double & time()
Return the current value of continuous time.
Definition: problem.cc:11531

References oomph::DocInfo::directory(), oomph::Node::dposition_dt(), e(), MergeRestartFiles::filename, Global_Physical_Variables::flux(), oomph::KirchhoffLoveBeamEquations::get_normal(), i, oomph::FiniteElement::interpolated_x(), oomph::SolidFiniteElement::interpolated_xi(), N, oomph::DocInfo::number(), output(), s, plotDoE::x, and oomph::Node::x().

◆ doc_solution() [4/4]

template<class ELEMENT >
void FSIChannelWithLeafletProblem< ELEMENT >::doc_solution ( DocInfo &  doc_info,
ofstream &  trace 
)

Doc the solution.

◆ fluid_mesh_pt() [1/3]

template<class ELEMENT >
RefineableAlgebraicChannelWithLeafletMesh<ELEMENT>* FSIChannelWithLeafletProblem< ELEMENT >::fluid_mesh_pt ( )
inline

Access function to fluid mesh.

204  {
205  return Fluid_mesh_pt;
206  }

◆ fluid_mesh_pt() [2/3]

template<class ELEMENT >
RefineableAlgebraicChannelWithLeafletMesh<ELEMENT>* FSIChannelWithLeafletProblem< ELEMENT >::fluid_mesh_pt ( )
inline

Access function to fluid mesh.

207  {
208  return Fluid_mesh_pt;
209  }

◆ fluid_mesh_pt() [3/3]

template<class ELEMENT >
RefineableAlgebraicChannelWithLeafletMesh<ELEMENT>* FSIChannelWithLeafletProblem< ELEMENT >::fluid_mesh_pt ( )
inline

Access function to fluid mesh.

203  {
204  return Fluid_mesh_pt;
205  }

◆ set_iterative_solver()

template<class ELEMENT >
void FSIChannelWithLeafletProblem< ELEMENT >::set_iterative_solver

Set iterative solver.

734 {
735  // Create the linear solver
736  IterativeLinearSolver* solver_pt=0;
737 
738  // If we have trilinos, use it
739 #ifdef OOMPH_HAS_TRILINOS
740 
741  // Create solver
742  solver_pt = new TrilinosAztecOOSolver;
743 
744  // Use GMRES
745  dynamic_cast<TrilinosAztecOOSolver*>(solver_pt)->solver_type()
746  = TrilinosAztecOOSolver::GMRES;
747 
748 #else
749 
750  // Use oomph-lib's own GMRES
751  solver_pt = new GMRES<CRDoubleMatrix>;
752 
753 #endif
754 
755  // Set solver
756  linear_solver_pt() = solver_pt;
757 
758  // Create preconditioner for 2D problem
759  unsigned dim=2;
760  PseudoElasticFSIPreconditioner* prec_pt=
761  new PseudoElasticFSIPreconditioner(dim, this);
762 
763  // Set preconditioner
764  solver_pt->preconditioner_pt() = prec_pt;
765 
766 
767  // Specify meshes that contain elements which classify the various
768  // degrees of freedom:
769  prec_pt->set_fluid_and_pseudo_elastic_mesh_pt(Bulk_mesh_pt);
770  prec_pt->set_solid_mesh_pt(Wall_mesh_pt);
771  prec_pt->set_lagrange_multiplier_mesh_pt(Lagrange_multiplier_mesh_pt);
772 
773 
774  // Use oomph-lib's Schur complement preconditioner as Navier-Stokes
775  // subsidiary preconditioner
776  if (!CommandLineArgs::command_line_flag_has_been_set("--suppress_lsc"))
777  {
778  oomph_info << "Enabling LSC preconditioner\n";
779  prec_pt->enable_navier_stokes_schur_complement_preconditioner();
780  }
781  else
782  {
783  prec_pt->disable_navier_stokes_schur_complement_preconditioner();
784  oomph_info << "Not using LSC preconditioner\n";
785  } // done disable lsc
786 
787 
788  // Use approximate block solves?
789  //------------------------------
790  if (CommandLineArgs::command_line_flag_has_been_set("--superlu_for_blocks"))
791  {
792  oomph_info << "Use SuperLU for block solves\n";
793  }
794  else
795  {
796  oomph_info << "Use optimal block solves\n";
797 
798  // Get pointer to Navier-Stokes Schur complement preconditioner
799  NavierStokesSchurComplementPreconditioner* ns_prec_pt =
800  prec_pt->navier_stokes_schur_complement_preconditioner_pt();
801 
802  // Navier Stokes momentum block
803  //-----------------------------
804 
805  // Block triangular for momentum block in LSC precond
806  BlockTriangularPreconditioner<CRDoubleMatrix>*
807  f_prec_pt = new BlockTriangularPreconditioner<CRDoubleMatrix>;
808 
809  // Set it
810  ns_prec_pt->set_f_preconditioner(f_prec_pt);
811 
812 #ifdef OOMPH_HAS_HYPRE
813 
814  // Use Hypre for diagonal blocks
815  f_prec_pt->set_subsidiary_preconditioner_function
816  (LSC_Preconditioner_Helper::set_hypre_preconditioner);
817 
818 
819  // Navier Stokes Schur complement/pressure block
820  //----------------------------------------------
821 
822  // Build/set Hypre for Schur complement (pressure) block
823  HyprePreconditioner* p_prec_pt = new HyprePreconditioner;
824  p_prec_pt->disable_doc_time();
825  Hypre_default_settings::set_defaults_for_2D_poisson_problem(p_prec_pt);
826  ns_prec_pt->set_p_preconditioner(p_prec_pt);
827 
828 #endif
829 
830  // Pseudo elastic block
831  //---------------------
832 
833  // Use block upper triangular preconditioner for (pseudo-)elastic block
834  prec_pt->pseudo_elastic_preconditioner_pt()->elastic_preconditioner_type()
835  = PseudoElasticPreconditioner::Block_upper_triangular_preconditioner;
836 
837 #ifdef OOMPH_HAS_HYPRE
838 
839  // Use Hypre for diagonal blocks of (pseudo-)elastic preconditioner
840  prec_pt->pseudo_elastic_preconditioner_pt()->
841  set_elastic_subsidiary_preconditioner(
842  Pseudo_Elastic_Preconditioner_Subsidiary_Operator_Helper::
843  get_elastic_preconditioner_hypre);
844 
845 #endif
846 
847 #ifdef OOMPH_HAS_TRILINOS
848 
849  // Use Trilinos CG as subsidiary preconditioner (inexact solver) for
850  // linear (sub-)systems to be solved in the Lagrange multiplier block
851  prec_pt->pseudo_elastic_preconditioner_pt()->
852  set_lagrange_multiplier_subsidiary_preconditioner
853  (Pseudo_Elastic_Preconditioner_Subsidiary_Operator_Helper::
854  get_lagrange_multiplier_preconditioner);
855 
856 #endif
857  }
858 
859 } //end set_iterative_solver
oomph::BlockTriangularPreconditioner
Definition: general_purpose_block_preconditioners.h:459
oomph::GeneralPurposeBlockPreconditioner::set_subsidiary_preconditioner_function
void set_subsidiary_preconditioner_function(SubsidiaryPreconditionerFctPt sub_prec_fn)
access function to set the subsidiary preconditioner function.
Definition: general_purpose_block_preconditioners.h:136
oomph::IterativeLinearSolver
Definition: iterative_linear_solver.h:54
oomph::NavierStokesSchurComplementPreconditioner
Definition: navier_stokes_preconditioners.h:607
oomph::NavierStokesSchurComplementPreconditioner::set_p_preconditioner
void set_p_preconditioner(Preconditioner *new_p_preconditioner_pt)
Function to set a new pressure matrix preconditioner (inexact solver)
Definition: navier_stokes_preconditioners.h:745
oomph::NavierStokesSchurComplementPreconditioner::set_f_preconditioner
void set_f_preconditioner(Preconditioner *new_f_preconditioner_pt)
Function to set a new momentum matrix preconditioner (inexact solver)
Definition: navier_stokes_preconditioners.h:769
oomph::PseudoElasticFSIPreconditioner
Definition: pseudo_elastic_fsi_preconditioner.h:62
oomph::PseudoElasticFSIPreconditioner::enable_navier_stokes_schur_complement_preconditioner
void enable_navier_stokes_schur_complement_preconditioner()
Definition: pseudo_elastic_fsi_preconditioner.h:193
oomph::PseudoElasticFSIPreconditioner::navier_stokes_schur_complement_preconditioner_pt
NavierStokesSchurComplementPreconditioner *const navier_stokes_schur_complement_preconditioner_pt()
Access function to the Navier Stokes Schur complement preconditioner.
Definition: pseudo_elastic_fsi_preconditioner.h:186
oomph::PseudoElasticFSIPreconditioner::set_fluid_and_pseudo_elastic_mesh_pt
void set_fluid_and_pseudo_elastic_mesh_pt(Mesh *mesh_pt)
specify the mesh containing the combined fluid/pseudo solid elements
Definition: pseudo_elastic_fsi_preconditioner.h:150
oomph::PseudoElasticFSIPreconditioner::set_lagrange_multiplier_mesh_pt
void set_lagrange_multiplier_mesh_pt(Mesh *mesh_pt)
specify the mesh containing the lagrange multiplier elements
Definition: pseudo_elastic_fsi_preconditioner.h:162
oomph::PseudoElasticFSIPreconditioner::pseudo_elastic_preconditioner_pt
PseudoElasticPreconditioner *const pseudo_elastic_preconditioner_pt()
Access function to the pseudo elastic subsidiary preconditioner.
Definition: pseudo_elastic_fsi_preconditioner.h:180
oomph::PseudoElasticFSIPreconditioner::disable_navier_stokes_schur_complement_preconditioner
void disable_navier_stokes_schur_complement_preconditioner()
Definition: pseudo_elastic_fsi_preconditioner.h:200
oomph::PseudoElasticFSIPreconditioner::set_solid_mesh_pt
void set_solid_mesh_pt(Mesh *mesh_pt)
specify the mesh containing the solid elements
Definition: pseudo_elastic_fsi_preconditioner.h:156
oomph::PseudoElasticPreconditioner::elastic_preconditioner_type
Elastic_preconditioner_type & elastic_preconditioner_type()
Definition: pseudo_elastic_preconditioner.h:229
oomph::TrilinosAztecOOSolver
Definition: trilinos_solver.h:267
oomph::CommandLineArgs::command_line_flag_has_been_set
bool command_line_flag_has_been_set(const std::string &flag)
Definition: oomph_utilities.cc:501

References oomph::CommandLineArgs::command_line_flag_has_been_set(), oomph::HyprePreconditioner::disable_doc_time(), oomph::PseudoElasticFSIPreconditioner::disable_navier_stokes_schur_complement_preconditioner(), oomph::PseudoElasticPreconditioner::elastic_preconditioner_type(), oomph::PseudoElasticFSIPreconditioner::enable_navier_stokes_schur_complement_preconditioner(), oomph::PseudoElasticFSIPreconditioner::navier_stokes_schur_complement_preconditioner_pt(), oomph::oomph_info, oomph::IterativeLinearSolver::preconditioner_pt(), oomph::PseudoElasticFSIPreconditioner::pseudo_elastic_preconditioner_pt(), oomph::Hypre_default_settings::set_defaults_for_2D_poisson_problem(), oomph::NavierStokesSchurComplementPreconditioner::set_f_preconditioner(), oomph::PseudoElasticFSIPreconditioner::set_fluid_and_pseudo_elastic_mesh_pt(), oomph::PseudoElasticFSIPreconditioner::set_lagrange_multiplier_mesh_pt(), oomph::NavierStokesSchurComplementPreconditioner::set_p_preconditioner(), oomph::PseudoElasticFSIPreconditioner::set_solid_mesh_pt(), and oomph::GeneralPurposeBlockPreconditioner< MATRIX >::set_subsidiary_preconditioner_function().

◆ solid_mesh_pt()

template<class ELEMENT >
OneDLagrangianMesh<FSIHermiteBeamElement>* FSIChannelWithLeafletProblem< ELEMENT >::solid_mesh_pt ( )
inline

Access function to the wall mesh.

197  {
198  return Solid_mesh_pt;
199  }
FSIChannelWithLeafletProblem::Solid_mesh_pt
OneDLagrangianMesh< FSIHermiteBeamElement > * Solid_mesh_pt
Pointer to the "wall" mesh.
Definition: mpi/solvers/fsi_channel_with_leaflet.cc:246

◆ tip_node_pt()

template<class ELEMENT >
Node* FSIChannelWithLeafletProblem< ELEMENT >::tip_node_pt ( )
inlineprivate

Helper fct; returns the node at the tip of the wall mesh.

452  {
453  unsigned n_el_wall=Wall_mesh_pt->nelement();
454  return Wall_mesh_pt->finite_element_pt(n_el_wall-1)->node_pt(1);
455  }

◆ wall_mesh_pt() [1/2]

template<class ELEMENT >
OneDLagrangianMesh<FSIHermiteBeamElement>* FSIChannelWithLeafletProblem< ELEMENT >::wall_mesh_pt ( )
inline

Access function to the wall mesh.

198  {
199  return Wall_mesh_pt;
200  }

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

◆ wall_mesh_pt() [2/2]

template<class ELEMENT >
OneDLagrangianMesh<FSIHermiteBeamElement>* FSIChannelWithLeafletProblem< ELEMENT >::wall_mesh_pt ( )
inline

Access function to the wall mesh.

201  {
202  return Wall_mesh_pt;
203  }

Member Data Documentation

◆ Bulk_mesh_pt

template<class ELEMENT >
PseudoElasticChannelWithLeafletMesh<ELEMENT>* FSIChannelWithLeafletProblem< ELEMENT >::Bulk_mesh_pt
private

Pointer to the fluid mesh.

◆ Bulk_time_stepper_pt

template<class ELEMENT >
BDF<2>* FSIChannelWithLeafletProblem< ELEMENT >::Bulk_time_stepper_pt
private

Bulk timestepper.

◆ Constitutive_law_pt

template<class ELEMENT >
ConstitutiveLaw* FSIChannelWithLeafletProblem< ELEMENT >::Constitutive_law_pt
private

Constitutive law used to determine the mesh deformation.

◆ Fluid_mesh_pt

template<class ELEMENT >
RefineableAlgebraicChannelWithLeafletMesh< ELEMENT > * FSIChannelWithLeafletProblem< ELEMENT >::Fluid_mesh_pt
private

Pointer to the fluid mesh.

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

◆ Htot

template<class ELEMENT >
double FSIChannelWithLeafletProblem< ELEMENT >::Htot
private

Total height of the domain.

◆ Lagrange_multiplier_mesh_pt

template<class ELEMENT >
SolidMesh* FSIChannelWithLeafletProblem< ELEMENT >::Lagrange_multiplier_mesh_pt
private

Pointers to mesh of Lagrange multiplier elements.

◆ Leaflet_pt

template<class ELEMENT >
GeomObject * FSIChannelWithLeafletProblem< ELEMENT >::Leaflet_pt
private

Pointer to the GeomObject that represents the wall.

◆ Solid_mesh_pt

template<class ELEMENT >
OneDLagrangianMesh<FSIHermiteBeamElement>* FSIChannelWithLeafletProblem< ELEMENT >::Solid_mesh_pt
private

Pointer to the "wall" mesh.

◆ Undeformed_wall_pt

template<class ELEMENT >
UndeformedLeaflet* FSIChannelWithLeafletProblem< ELEMENT >::Undeformed_wall_pt
private

Geom object for the leaflet.

◆ Wall_geom_object_pt

template<class ELEMENT >
MeshAsGeomObject* FSIChannelWithLeafletProblem< ELEMENT >::Wall_geom_object_pt
private

Geometric object for the leaflet (to apply lagrange mult)

◆ Wall_mesh_pt

template<class ELEMENT >
OneDLagrangianMesh< FSIHermiteBeamElement > * FSIChannelWithLeafletProblem< ELEMENT >::Wall_mesh_pt
private

Pointer to the "wall" mesh.

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

◆ Wall_time_stepper_pt

template<class ELEMENT >
Newmark<2>* FSIChannelWithLeafletProblem< ELEMENT >::Wall_time_stepper_pt
private

Wall time stepper pt.

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