Public Member Functions | Private Member Functions | Private Attributes | List of all members
PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT > Class Template Reference
+ Inheritance diagram for PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >:

Public Member Functions

 PseudoElasticCollapsibleChannelProblem ()
 Constructor: More...
 
 ~PseudoElasticCollapsibleChannelProblem ()
 Destructor (empty) More...
 
void doc_solution (DocInfo &doc_info)
 Doc the solution. More...
 
void steady_run (DocInfo &doc_info)
 Do steady run. More...
 
void unsteady_run (DocInfo &doc_info)
 Do unsteady run. More...
 
void create_fsi_traction_elements ()
 Create FSI traction elements. More...
 
void create_lagrange_multiplier_elements ()
 
void create_solid_traction_elements ()
 
void actions_before_implicit_timestep ()
 Actions before timestep. More...
 
void actions_before_newton_convergence_check ()
 Update no slip bc after update of unknowns. More...
 
void actions_before_newton_solve ()
 Actions before Newton solve: Reset pseudo-elastic Lagrangian coordinates. More...
 
void actions_before_adapt ()
 Before adapt: Flush face element submeshes. More...
 
void actions_after_adapt ()
 After adapt: Rebuild face element submeshes and re-setup FSI. More...
 
void empty_mesh (Mesh *const &surface_mesh_pt)
 Helper function to delete elements from a mesh. More...
 
void doc_parameters ()
 Doc parameters. More...
 
WallMesh< SOLID_ELEMENT > * wall_mesh_pt ()
 Bulk solid mesh. More...
 
FluidMesh< FLUID_ELEMENT > * fluid_mesh_pt ()
 Bulk fluid mesh. More...
 
SolidMesh *& lagrange_multiplier_mesh_pt ()
 Meshes of Lagrange multiplier elements. More...
 
void set_initial_condition ()
 Set initial conditions. More...
 
 PseudoElasticCollapsibleChannelProblem ()
 Constructor: More...
 
 ~PseudoElasticCollapsibleChannelProblem ()
 Destructor (empty) More...
 
void doc_solution (DocInfo &doc_info)
 Doc the solution. More...
 
void steady_run (DocInfo &doc_info)
 Do steady run. More...
 
void unsteady_run (DocInfo &doc_info)
 Do unsteady run. More...
 
void create_fsi_traction_elements ()
 Create FSI traction elements. More...
 
void create_lagrange_multiplier_elements ()
 
void create_solid_traction_elements ()
 
void actions_before_implicit_timestep ()
 Actions before timestep. More...
 
void actions_before_newton_convergence_check ()
 Update no slip bc after update of unknowns. More...
 
void actions_before_newton_solve ()
 Actions before Newton solve: Reset pseudo-elastic Lagrangian coordinates. More...
 
void actions_before_adapt ()
 Before adapt: Flush face element submeshes. More...
 
void actions_after_adapt ()
 After adapt: Rebuild face element submeshes and re-setup FSI. More...
 
void empty_mesh (Mesh *const &surface_mesh_pt)
 Helper function to delete elements from a mesh. More...
 
void doc_parameters ()
 Doc parameters. More...
 
WallMesh< SOLID_ELEMENT > * wall_mesh_pt ()
 Bulk solid mesh. More...
 
FluidMesh< FLUID_ELEMENT > * fluid_mesh_pt ()
 Bulk fluid mesh. More...
 
SolidMesh *& lagrange_multiplier_mesh_pt ()
 Meshes of Lagrange multiplier elements. More...
 
void set_initial_condition ()
 Set initial conditions. More...
 
 PseudoElasticCollapsibleChannelProblem ()
 Constructor: More...
 
 ~PseudoElasticCollapsibleChannelProblem ()
 Destructor (empty) More...
 
void doc_solution (DocInfo &doc_info)
 Doc the solution. More...
 
void steady_run (DocInfo &doc_info)
 Do steady run. More...
 
void unsteady_run (DocInfo &doc_info)
 Do unsteady run. More...
 
void create_fsi_traction_elements ()
 Create FSI traction elements. More...
 
void create_lagrange_multiplier_elements ()
 
void create_solid_traction_elements ()
 
void actions_before_implicit_timestep ()
 Actions before timestep. More...
 
void actions_before_newton_convergence_check ()
 Update no slip bc after update of unknowns. More...
 
void actions_before_newton_solve ()
 Actions before Newton solve: Reset pseudo-elastic Lagrangian coordinates. More...
 
void actions_before_adapt ()
 Before adapt: Flush face element submeshes. More...
 
void actions_after_adapt ()
 After adapt: Rebuild face element submeshes and re-setup FSI. More...
 
void actions_before_distribute ()
 
void actions_after_distribute ()
 Recreate face elements and rebuild problem. More...
 
void empty_mesh (Mesh *const &surface_mesh_pt)
 Helper function to delete elements from a mesh. More...
 
void set_pseudo_elastic_fsi_solver ()
 
void doc_parameters ()
 Doc parameters. More...
 
WallMesh< SOLID_ELEMENT > * wall_mesh_pt ()
 Bulk solid mesh. More...
 
FluidMesh< FLUID_ELEMENT > * fluid_mesh_pt ()
 Bulk fluid mesh. More...
 
SolidMesh *& lagrange_multiplier_mesh_pt ()
 Meshes of Lagrange multiplier elements. More...
 
void set_initial_condition ()
 Set initial conditions. More...
 
- Public Member Functions inherited from oomph::Problem
virtual void debug_hook_fct (const unsigned &i)
 
void set_analytic_dparameter (double *const &parameter_pt)
 
void unset_analytic_dparameter (double *const &parameter_pt)
 
bool is_dparameter_calculated_analytically (double *const &parameter_pt)
 
void set_analytic_hessian_products ()
 
void unset_analytic_hessian_products ()
 
bool are_hessian_products_calculated_analytically ()
 
void set_pinned_values_to_zero ()
 
bool distributed () const
 
OomphCommunicator * communicator_pt ()
 access function to the oomph-lib communicator More...
 
const OomphCommunicator * communicator_pt () const
 access function to the oomph-lib communicator, const version More...
 
 Problem ()
 
 Problem (const Problem &dummy)=delete
 Broken copy constructor. More...
 
void operator= (const Problem &)=delete
 Broken assignment operator. More...
 
virtual ~Problem ()
 Virtual destructor to clean up memory. More...
 
Mesh *& mesh_pt ()
 Return a pointer to the global mesh. More...
 
Mesh *const & mesh_pt () const
 Return a pointer to the global mesh (const version) More...
 
Mesh *& mesh_pt (const unsigned &imesh)
 
Mesh *const & mesh_pt (const unsigned &imesh) const
 Return a pointer to the i-th submesh (const version) More...
 
unsigned nsub_mesh () const
 Return number of submeshes. More...
 
unsigned add_sub_mesh (Mesh *const &mesh_pt)
 
void flush_sub_meshes ()
 
void build_global_mesh ()
 
void rebuild_global_mesh ()
 
LinearSolver *& linear_solver_pt ()
 Return a pointer to the linear solver object. More...
 
LinearSolver *const & linear_solver_pt () const
 Return a pointer to the linear solver object (const version) More...
 
LinearSolver *& mass_matrix_solver_for_explicit_timestepper_pt ()
 
LinearSolver * mass_matrix_solver_for_explicit_timestepper_pt () const
 
EigenSolver *& eigen_solver_pt ()
 Return a pointer to the eigen solver object. More...
 
EigenSolver *const & eigen_solver_pt () const
 Return a pointer to the eigen solver object (const version) More...
 
Time *& time_pt ()
 Return a pointer to the global time object. More...
 
Time * time_pt () const
 Return a pointer to the global time object (const version). More...
 
double & time ()
 Return the current value of continuous time. More...
 
double time () const
 Return the current value of continuous time (const version) More...
 
TimeStepper *& time_stepper_pt ()
 
const TimeStepper * time_stepper_pt () const
 
TimeStepper *& time_stepper_pt (const unsigned &i)
 Return a pointer to the i-th timestepper. More...
 
ExplicitTimeStepper *& explicit_time_stepper_pt ()
 Return a pointer to the explicit timestepper. More...
 
unsigned long set_timestepper_for_all_data (TimeStepper *const &time_stepper_pt, const bool &preserve_existing_data=false)
 
virtual void shift_time_values ()
 Shift all values along to prepare for next timestep. More...
 
AssemblyHandler *& assembly_handler_pt ()
 Return a pointer to the assembly handler object. More...
 
AssemblyHandler *const & assembly_handler_pt () const
 Return a pointer to the assembly handler object (const version) More...
 
double & minimum_dt ()
 Access function to min timestep in adaptive timestepping. More...
 
double & maximum_dt ()
 Access function to max timestep in adaptive timestepping. More...
 
unsigned & max_newton_iterations ()
 Access function to max Newton iterations before giving up. More...
 
void problem_is_nonlinear (const bool &prob_lin)
 Access function to Problem_is_nonlinear. More...
 
double & max_residuals ()
 
bool & time_adaptive_newton_crash_on_solve_fail ()
 Access function for Time_adaptive_newton_crash_on_solve_fail. More...
 
double & newton_solver_tolerance ()
 
void add_time_stepper_pt (TimeStepper *const &time_stepper_pt)
 
void set_explicit_time_stepper_pt (ExplicitTimeStepper *const &explicit_time_stepper_pt)
 
void initialise_dt (const double &dt)
 
void initialise_dt (const Vector< double > &dt)
 
Data *& global_data_pt (const unsigned &i)
 Return a pointer to the the i-th global data object. More...
 
void add_global_data (Data *const &global_data_pt)
 
void flush_global_data ()
 
LinearAlgebraDistribution *const & dof_distribution_pt () const
 Return the pointer to the dof distribution (read-only) More...
 
unsigned long ndof () const
 Return the number of dofs. More...
 
unsigned ntime_stepper () const
 Return the number of time steppers. More...
 
unsigned nglobal_data () const
 Return the number of global data values. More...
 
unsigned self_test ()
 Self-test: Check meshes and global data. Return 0 for OK. More...
 
void enable_store_local_dof_pt_in_elements ()
 
void disable_store_local_dof_pt_in_elements ()
 
unsigned long assign_eqn_numbers (const bool &assign_local_eqn_numbers=true)
 
void describe_dofs (std::ostream &out= *(oomph_info.stream_pt())) const
 
void enable_discontinuous_formulation ()
 
void disable_discontinuous_formulation ()
 
void get_dofs (DoubleVector &dofs) const
 
void get_dofs (const unsigned &t, DoubleVector &dofs) const
 Return vector of the t'th history value of all dofs. More...
 
void set_dofs (const DoubleVector &dofs)
 Set the values of the dofs. More...
 
void set_dofs (const unsigned &t, DoubleVector &dofs)
 Set the history values of the dofs. More...
 
void set_dofs (const unsigned &t, Vector< double * > &dof_pt)
 
void add_to_dofs (const double &lambda, const DoubleVector &increment_dofs)
 Add lambda x incremenet_dofs[l] to the l-th dof. More...
 
double * global_dof_pt (const unsigned &i)
 
double & dof (const unsigned &i)
 i-th dof in the problem More...
 
double dof (const unsigned &i) const
 i-th dof in the problem (const version) More...
 
double *& dof_pt (const unsigned &i)
 Pointer to i-th dof in the problem. More...
 
double * dof_pt (const unsigned &i) const
 Pointer to i-th dof in the problem (const version) More...
 
virtual void get_inverse_mass_matrix_times_residuals (DoubleVector &Mres)
 
virtual void get_dvaluesdt (DoubleVector &f)
 
virtual void get_residuals (DoubleVector &residuals)
 Get the total residuals Vector for the problem. More...
 
virtual void get_jacobian (DoubleVector &residuals, DenseDoubleMatrix &jacobian)
 
virtual void get_jacobian (DoubleVector &residuals, CRDoubleMatrix &jacobian)
 
virtual void get_jacobian (DoubleVector &residuals, CCDoubleMatrix &jacobian)
 
virtual void get_jacobian (DoubleVector &residuals, SumOfMatrices &jacobian)
 
void get_fd_jacobian (DoubleVector &residuals, DenseMatrix< double > &jacobian)
 Get the full Jacobian by finite differencing. More...
 
void get_derivative_wrt_global_parameter (double *const &parameter_pt, DoubleVector &result)
 
void get_hessian_vector_products (DoubleVectorWithHaloEntries const &Y, Vector< DoubleVectorWithHaloEntries > const &C, Vector< DoubleVectorWithHaloEntries > &product)
 
void solve_eigenproblem (const unsigned &n_eval, Vector< std::complex< double >> &eigenvalue, Vector< DoubleVector > &eigenvector, const bool &steady=true)
 Solve the eigenproblem. More...
 
void solve_eigenproblem (const unsigned &n_eval, Vector< std::complex< double >> &eigenvalue, const bool &steady=true)
 
virtual void get_eigenproblem_matrices (CRDoubleMatrix &mass_matrix, CRDoubleMatrix &main_matrix, const double &shift=0.0)
 
void assign_eigenvector_to_dofs (DoubleVector &eigenvector)
 Assign the eigenvector passed to the function to the dofs. More...
 
void add_eigenvector_to_dofs (const double &epsilon, const DoubleVector &eigenvector)
 
void store_current_dof_values ()
 Store the current values of the degrees of freedom. More...
 
void restore_dof_values ()
 Restore the stored values of the degrees of freedom. More...
 
void enable_jacobian_reuse ()
 
void disable_jacobian_reuse ()
 Disable recycling of Jacobian in Newton iteration. More...
 
bool jacobian_reuse_is_enabled ()
 Is recycling of Jacobian in Newton iteration enabled? More...
 
bool & use_predictor_values_as_initial_guess ()
 
void newton_solve ()
 Use Newton method to solve the problem. More...
 
void enable_globally_convergent_newton_method ()
 enable globally convergent Newton method More...
 
void disable_globally_convergent_newton_method ()
 disable globally convergent Newton method More...
 
void newton_solve (unsigned const &max_adapt)
 
void steady_newton_solve (unsigned const &max_adapt=0)
 
void copy (Problem *orig_problem_pt)
 
virtual 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

void doc_solid_boundary_coordinates ()
 Sanity check: Doc boundary coordinates on i-th solid FSI interface. More...
 
void doc_solid_boundary_coordinates ()
 Sanity check: Doc boundary coordinates on i-th solid FSI interface. More...
 
void doc_solid_boundary_coordinates ()
 Sanity check: Doc boundary coordinates on i-th solid FSI interface. More...
 

Private Attributes

WallMesh< SOLID_ELEMENT > * Solid_mesh_pt
 Bulk solid mesh. More...
 
SolidMesh * Solid_fsi_traction_mesh_pt
 Meshes of FSI traction elements (fluid traction onto solid) More...
 
FluidMesh< FLUID_ELEMENT > * Fluid_mesh_pt
 Bulk fluid mesh. More...
 
SolidMesh * Lagrange_multiplier_mesh_pt
 Mesh of Lagrange multiplier elements. More...
 
SolidMesh * Solid_traction_mesh_pt
 Solid traction elements (prescibed external pressure on solid wall) More...
 
MeshAsGeomObject * Solid_fsi_boundary_pt
 GeomObject incarnations of the FSI boundary in the solid mesh. More...
 
GeomObject * Wall_pt
 
BDF< 2 > * Fluid_time_stepper_pt
 Timestepper for the Navier-Stokes equations. More...
 
Steady< 2 > * Wall_time_stepper_pt
 Steady timestepper that stores two history values. 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_after_newton_solve ()
 
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 double global_temporal_error_norm ()
 
unsigned newton_solve_continuation (double *const &parameter_pt)
 
unsigned newton_solve_continuation (double *const &parameter_pt, DoubleVector &z)
 
void calculate_continuation_derivatives (double *const &parameter_pt)
 
void calculate_continuation_derivatives (const DoubleVector &z)
 
void calculate_continuation_derivatives_fd (double *const &parameter_pt)
 
bool does_pointer_correspond_to_problem_data (double *const &parameter_pt)
 
void set_consistent_pinned_values_for_continuation ()
 
- Protected Attributes inherited from oomph::Problem
Vector< Problem * > Copy_of_problem_pt
 
std::map< double *, bool > Calculate_dparameter_analytic
 
bool Calculate_hessian_products_analytic
 
LinearAlgebraDistribution * Dof_distribution_pt
 
Vector< double * > Dof_pt
 Vector of pointers to dofs. More...
 
DoubleVectorWithHaloEntries Element_count_per_dof
 
double Relaxation_factor
 
double Newton_solver_tolerance
 
unsigned Max_newton_iterations
 Maximum number of Newton iterations. More...
 
unsigned Nnewton_iter_taken
 
Vector< double > Max_res
 Maximum residuals at start and after each newton iteration. More...
 
double Max_residuals
 
bool Time_adaptive_newton_crash_on_solve_fail
 
bool Jacobian_reuse_is_enabled
 Is re-use of Jacobian in Newton iteration enabled? Default: false. More...
 
bool Jacobian_has_been_computed
 
bool Problem_is_nonlinear
 
bool Pause_at_end_of_sparse_assembly
 
bool Doc_time_in_distribute
 
unsigned Sparse_assembly_method
 
unsigned Sparse_assemble_with_arrays_initial_allocation
 
unsigned Sparse_assemble_with_arrays_allocation_increment
 
Vector< Vector< unsigned > > Sparse_assemble_with_arrays_previous_allocation
 
double Numerical_zero_for_sparse_assembly
 
double FD_step_used_in_get_hessian_vector_products
 
bool Mass_matrix_reuse_is_enabled
 
bool Mass_matrix_has_been_computed
 
bool Discontinuous_element_formulation
 
double Minimum_dt
 Minimum desired dt: if dt falls below this value, exit. More...
 
double Maximum_dt
 Maximum desired dt. More...
 
double DTSF_max_increase
 
double DTSF_min_decrease
 
double Minimum_dt_but_still_proceed
 
bool Scale_arc_length
 Boolean to control whether arc-length should be scaled. More...
 
double Desired_proportion_of_arc_length
 Proportion of the arc-length to taken by the parameter. More...
 
double Theta_squared
 
int Sign_of_jacobian
 Storage for the sign of the global Jacobian. More...
 
double Continuation_direction
 
double Parameter_derivative
 Storage for the derivative of the global parameter wrt arc-length. More...
 
double Parameter_current
 Storage for the present value of the global parameter. More...
 
bool Use_continuation_timestepper
 Boolean to control original or new storage of dof stuff. More...
 
unsigned Dof_derivative_offset
 
unsigned Dof_current_offset
 
Vector< double > Dof_derivative
 Storage for the derivative of the problem variables wrt arc-length. More...
 
Vector< double > Dof_current
 Storage for the present values of the variables. More...
 
double Ds_current
 Storage for the current step value. More...
 
unsigned Desired_newton_iterations_ds
 
double Minimum_ds
 Minimum desired value of arc-length. More...
 
bool Bifurcation_detection
 Boolean to control bifurcation detection via determinant of Jacobian. More...
 
bool Bisect_to_find_bifurcation
 Boolean to control wheter bisection is used to located bifurcation. More...
 
bool First_jacobian_sign_change
 Boolean to indicate whether a sign change has occured in the Jacobian. More...
 
bool Arc_length_step_taken
 Boolean to indicate whether an arc-length step has been taken. More...
 
bool Use_finite_differences_for_continuation_derivatives
 
OomphCommunicator * Communicator_pt
 The communicator for this problem. More...
 
bool Always_take_one_newton_step
 
double Timestep_reduction_factor_after_nonconvergence
 
bool Keep_temporal_error_below_tolerance
 
- Static Protected Attributes inherited from oomph::Problem
static ContinuationStorageScheme Continuation_time_stepper
 Storage for the single static continuation timestorage object. More...
 

Detailed Description

template<class FLUID_ELEMENT, class SOLID_ELEMENT>
class PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >

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

Constructor & Destructor Documentation

◆ PseudoElasticCollapsibleChannelProblem() [1/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::PseudoElasticCollapsibleChannelProblem

Constructor:

Constructor for unstructured 3D FSI problem.

593 {
594  // DEBUG: doc full stats for the multi-domain interaction
595  //Multi_domain_functions::Doc_full_stats=true;
596  //Multi_domain_functions::Doc_stats=true;
597 
598  // Allocate the timestepper for the Navier-Stokes equations
599  Fluid_time_stepper_pt=new BDF<2>;
600 
601  // Add the fluid timestepper to the Problem's collection of timesteppers.
602  add_time_stepper_pt(Fluid_time_stepper_pt);
603 
604  // Create a Steady timestepper that stores two history values
605  Wall_time_stepper_pt = new Steady<2>;
606 
607  // Add the wall timestepper to the Problem's collection of timesteppers.
608  add_time_stepper_pt(Wall_time_stepper_pt);
609 
610  // Domain size and shape parameters
611  //---------------------------------
612 
613  // Create geometric object that defines curvilinear boundary of
614  // fluid domain: Elliptical tube with half axes = radius = 1.0
615  Wall_pt=new EllipticalTube(1.0,1.0);
616 
617  // Bounding Lagrangian coordinates
618  Vector<double> xi_lo(2);
619  xi_lo[0]=0.0;
620  xi_lo[1]=0.0;
621  Vector<double> xi_hi(2);
622  xi_hi[0]= Global_Parameters::L;
623  xi_hi[1]= 0.5*MathematicalConstants::Pi;
624 
625  //Radial divider is located half-way along the circumference
626  double frac_mid=0.5;
627 
628  // Define fluid mesh
629  //------------------
630 
631  // create the fluid mesh
632  Fluid_mesh_pt = new FluidMesh<FLUID_ELEMENT>
633  (Wall_pt,xi_lo,frac_mid,xi_hi,Global_Parameters::N_slice,
634  Fluid_time_stepper_pt);
635 
636 
637  // Setup error estimator
638  if (CommandLineArgs::Argc==1)
639  {
640  Fluid_mesh_pt->spatial_error_estimator_pt()=new Z2ErrorEstimator;
641  Fluid_mesh_pt->max_permitted_error()=0.004;
642  Fluid_mesh_pt->min_permitted_error()=0.0001;
643  }
644  // Validation: Fake
645  else
646  {
647  // Setup fake error estimator: Refine one element on the outer
648  // and one on the inner surface of the wall
649  Vector<unsigned> elements_to_refine(2);
650  elements_to_refine[0]=3;
651  elements_to_refine[1]=8;
652 
653  unsigned central_node_number=13;
654  bool use_lagrangian_coordinates=false;
655  Fluid_mesh_pt->spatial_error_estimator_pt()=
656  new DummyErrorEstimator(Fluid_mesh_pt,elements_to_refine,
657  central_node_number,
658  use_lagrangian_coordinates);
659  }
660 
661 
662  // Define solid mesh
663  //------------------
664 
665  //Create solid bulk mesh with a slightly different number of elements
666  //in the axial direction
667  double r_min=1.0;
668  double r_max=1.0+Global_Parameters::H;
669  double& lz=Global_Parameters::L;
670  unsigned nr=2;
671  unsigned nphi=2;
672  unsigned nz=Global_Parameters::N_slice;
673  // Try non-matching discretisation if validation
674  if (CommandLineArgs::Argc!=1)
675  {
676  nz=unsigned(double(nz)*1.5);
677  }
678  Solid_mesh_pt = new WallMesh<SOLID_ELEMENT>(r_min,r_max,lz,
679  nr,nphi,nz,Wall_time_stepper_pt);
680 
681 
682  // Setup error estimator
683  if (CommandLineArgs::Argc==1)
684  {
685  Solid_mesh_pt->spatial_error_estimator_pt()=new Z2ErrorEstimator;
686  Solid_mesh_pt->max_permitted_error()=0.21;
687  Solid_mesh_pt->min_permitted_error()=0.001;
688  }
689  // Validation: Fake
690  else
691  {
692  // Setup fake error estimator: This refines two elements
693  Vector<unsigned> elements_to_refine(1);
694  elements_to_refine[0]=9;
695 
696  unsigned central_node_number=13;
697  bool use_lagrangian_coordinates=true;
698  Solid_mesh_pt->spatial_error_estimator_pt()=
699  new DummyErrorEstimator(Solid_mesh_pt,elements_to_refine,
700  central_node_number,
701  use_lagrangian_coordinates);
702  }
703 
704 
705  // Create FSI Traction elements
706  //-----------------------------
707 
708  // Build the FSI traction elements
709  Solid_fsi_traction_mesh_pt=new SolidMesh;
710  create_fsi_traction_elements();
711 
712  // Create Lagrange multiplier mesh for boundary motion of fluid mesh
713  //------------------------------------------------------------------
714 
715  // Create elements
716  Lagrange_multiplier_mesh_pt = new SolidMesh;
717  //initialise pointer to solid boundary
718  Solid_fsi_boundary_pt=0;
719  create_lagrange_multiplier_elements();
720 
721  // Create solid traction elements for external pressure
722  //-----------------------------------------------------
723 
724  Solid_traction_mesh_pt = new SolidMesh;
725  create_solid_traction_elements();
726 
727  // Combine the lot
728  //----------------
729 
730  // Add sub meshes:
731 
732  // The fluid bulk mesh
733  add_sub_mesh(Fluid_mesh_pt);
734 
735  // Solid bulk mesh
736  add_sub_mesh(Solid_mesh_pt);
737 
738  // The solid fsi traction mesh
739  add_sub_mesh(Solid_fsi_traction_mesh_pt);
740 
741  // the solid traction elements
742  add_sub_mesh(Solid_traction_mesh_pt);
743 
744  // The Lagrange multiplier mesh for the fluid
745  add_sub_mesh(Lagrange_multiplier_mesh_pt);
746 
747  // Build global mesh
748  build_global_mesh();
749 
750  // Apply BCs for fluid/pseudo-elastic elements
751  //--------------------------------------------
752 
753  unsigned nbound_fluid = Fluid_mesh_pt->nboundary();
754  for(unsigned b=0;b<nbound_fluid;b++)
755  {
756  unsigned nnode = Fluid_mesh_pt->nboundary_node(b);
757  for (unsigned i = 0; i < nnode; i++)
758  {
759 
760  // Fluid velocity BCs
761 
762  // Boundary 1 is the vertical symmetry boundary (y=const) where
763  // we allow flow in the y-direction. Elsewhere, pin the y velocity
764  if(b!=1) Fluid_mesh_pt->boundary_node_pt(b,i)->pin(1);
765 
766  // Boundary 2 is the horizontal symmetry boundary (x=const) where
767  // we allow flow in the x-direction. Elsewhere, pin the x velocity
768  if(b!=2) Fluid_mesh_pt->boundary_node_pt(b,i)->pin(0);
769 
770  // Boundaries 0 and 3 are the inflow and the wall respectively.
771  // Pin the axial velocity because of the prescribed inflow
772  // profile and the no slip on the wall (where the velocity is imposed
773  // by the node update), respectively
774  if((b==0)||(b==3))
775  {
776  Fluid_mesh_pt->boundary_node_pt(b,i)->pin(2);
777  }
778 
779  // Pseudo solid BCs
780  SolidNode* solid_node_pt = dynamic_cast<SolidNode*>
781  (Fluid_mesh_pt->boundary_node_pt(b,i));
782 
783  // Inflow, vertical symmetry BC (y=const), outflow: Suppress x-displ
784  if((b==0)||(b==1)||(b==4)) { solid_node_pt->pin_position(0); }
785 
786  // Inflow, horizontal symmetry BC (x=const), outflow: Suppress y-displ
787  if((b==0)||(b==2)||(b==4)) { solid_node_pt->pin_position(1); }
788 
789  // Inflow and outflow: Suppress z-displacement
790  if((b==0)||(b==4)) { solid_node_pt->pin_position(2); }
791  }
792  }
793 
794 
795  // Complete the build of the fluid elements so they are fully functional
796  //----------------------------------------------------------------------
797 
798  unsigned n_element = Fluid_mesh_pt->nelement();
799  for(unsigned e=0;e<n_element;e++)
800  {
801  // Upcast from GeneralisedElement to the present element
802  FLUID_ELEMENT* el_pt =
803  dynamic_cast<FLUID_ELEMENT*>(Fluid_mesh_pt->element_pt(e));
804 
805  //Set the Reynolds number
806  el_pt->re_pt() = &Global_Parameters::Re;
807  el_pt->re_st_pt() = &Global_Parameters::Re;
808 
809  // Set the constitutive law for pseudo-elastic mesh deformation
810  el_pt->constitutive_law_pt() =
811  Global_Parameters::Constitutive_law_pseudo_elastic_pt;
812 
813  // Set the timescale ratio
814  el_pt->lambda_sq_pt() =
815  &Global_Parameters::Lambda_sq;
816 
817  } // end loop over elements
818 
819  // pin the rundundant nodal pressures
820  RefineableNavierStokesEquations<3>::
821  pin_redundant_nodal_pressures(Fluid_mesh_pt->element_pt());
822 
823  // Apply BCs for solid
824  //--------------------
825 
826  unsigned nbound_solid = Solid_mesh_pt->nboundary();
827  for(unsigned b=0;b<nbound_solid;b++)
828  {
829  unsigned nnode = Solid_mesh_pt->nboundary_node(b);
830  for (unsigned i = 0; i < nnode; i++)
831  {
832  SolidNode* solid_node_pt=
833  dynamic_cast<SolidNode*>(Solid_mesh_pt->boundary_node_pt(b,i));
834 
835  // Inflow, vertical symmetry (y=const) and outflow: Pin x-displ
836  if((b==0)||(b==3)||(b==5)){solid_node_pt->pin_position(0);}
837 
838  // Inflow, horizontal symmetry (x=const) and outflow: Pin y-displ
839  if((b==0)||(b==1)||(b==5)){solid_node_pt->pin_position(1);}
840 
841  // Inflow and outflow: Pin z-displ
842  if((b==0)||(b==5)){solid_node_pt->pin_position(2);}
843 
844  // Pin all positions in "rigid sections"
845  double z = solid_node_pt->x(2);
846  if (z<=Global_Parameters::Lup||
847  z>=(Global_Parameters::L-Global_Parameters::Ldown))
848  {
849  solid_node_pt->pin_position(0);
850  solid_node_pt->pin_position(1);
851  solid_node_pt->pin_position(2);
852  }
853  }
854  }
855 
856  // Complete the build of Solid elements so they are fully functional
857  //----------------------------------------------------------------
858 
859  n_element = Solid_mesh_pt->nelement();
860  for(unsigned i=0;i<n_element;i++)
861  {
862  //Cast to a solid element
863  SOLID_ELEMENT *el_pt = dynamic_cast<SOLID_ELEMENT*>(
864  Solid_mesh_pt->element_pt(i));
865 
866  // Set the constitutive law
867  el_pt->constitutive_law_pt() =
868  Global_Parameters::Constitutive_law_wall_pt;
869 
870  // Set the timescale ratio
871  el_pt->lambda_sq_pt() =
872  &Global_Parameters::Lambda_sq;
873  }
874 
875  // Setup FSI
876  //----------
877 
878  // The velocity of the fluid nodes on the fsi boundary
879  // is set by the wall motion -- hence the no-slip condition must be
880  // re-applied whenever a node update is performed for these nodes.
881  // Such tasks may be performed automatically by the auxiliary node update
882  // function specified by a function pointer:
883 
884  // Get boundary ID
885  unsigned b=3;
886 
887  // How many nodes on boundary b?
888  unsigned nnode_fsi_fluid = Fluid_mesh_pt->nboundary_node(b);
889 
890  for (unsigned i=0;i<nnode_fsi_fluid;i++)
891  {
892  Fluid_mesh_pt->
893  boundary_node_pt(b,i)->set_auxiliary_node_update_fct_pt(
894  FSI_functions::apply_no_slip_on_moving_wall);
895  }
896 
897  // Work out which fluid dofs affect the residuals of the wall elements:
898  // We pass the boundary between the fluid and solid meshes and
899  // pointers to the meshes.
900 
901  //Doc boundary coordinates in fluid
902  char filename[100];
903  sprintf(filename,"RESLT/fluid_boundary_coordinates.dat");
904  Multi_domain_functions::Doc_boundary_coordinate_file.open(filename);
905 
906  // Setup FSI: Pass ID of fluid FSI boundary and associated
907  // mesh of solid fsi traction elements.
908  FSI_functions::setup_fluid_load_info_for_solid_elements<FLUID_ELEMENT,3>
909  (this,3,Fluid_mesh_pt,Solid_fsi_traction_mesh_pt);
910 
911  // Close the doc file
912  Multi_domain_functions::Doc_boundary_coordinate_file.close();
913 
914  // Setup equation numbering scheme
915  std::cout <<"Number of equations: " << assign_eqn_numbers() << std::endl;
916 }
i
int i
Definition: BiCGSTAB_step_by_step.cpp:9
e
Array< double, 1, 3 > e(1./3., 0.5, 2.)
b
Scalar * b
Definition: benchVecAdd.cpp:17
PseudoElasticCollapsibleChannelProblem::Solid_fsi_boundary_pt
MeshAsGeomObject * Solid_fsi_boundary_pt
GeomObject incarnations of the FSI boundary in the solid mesh.
Definition: interaction/pseudo_solid_collapsible_tube/pseudo_solid_collapsible_tube.cc:571
PseudoElasticCollapsibleChannelProblem::Solid_mesh_pt
WallMesh< SOLID_ELEMENT > * Solid_mesh_pt
Bulk solid mesh.
Definition: interaction/pseudo_solid_collapsible_tube/pseudo_solid_collapsible_tube.cc:555
PseudoElasticCollapsibleChannelProblem::Fluid_time_stepper_pt
BDF< 2 > * Fluid_time_stepper_pt
Timestepper for the Navier-Stokes equations.
Definition: interaction/pseudo_solid_collapsible_tube/pseudo_solid_collapsible_tube.cc:578
PseudoElasticCollapsibleChannelProblem::create_fsi_traction_elements
void create_fsi_traction_elements()
Create FSI traction elements.
Definition: interaction/pseudo_solid_collapsible_tube/pseudo_solid_collapsible_tube.cc:951
PseudoElasticCollapsibleChannelProblem::create_lagrange_multiplier_elements
void create_lagrange_multiplier_elements()
Definition: interaction/pseudo_solid_collapsible_tube/pseudo_solid_collapsible_tube.cc:1029
PseudoElasticCollapsibleChannelProblem::Wall_time_stepper_pt
Steady< 2 > * Wall_time_stepper_pt
Steady timestepper that stores two history values.
Definition: interaction/pseudo_solid_collapsible_tube/pseudo_solid_collapsible_tube.cc:581
PseudoElasticCollapsibleChannelProblem::Wall_pt
GeomObject * Wall_pt
Definition: interaction/pseudo_solid_collapsible_tube/pseudo_solid_collapsible_tube.cc:575
PseudoElasticCollapsibleChannelProblem::Lagrange_multiplier_mesh_pt
SolidMesh * Lagrange_multiplier_mesh_pt
Mesh of Lagrange multiplier elements.
Definition: interaction/pseudo_solid_collapsible_tube/pseudo_solid_collapsible_tube.cc:564
PseudoElasticCollapsibleChannelProblem::Solid_fsi_traction_mesh_pt
SolidMesh * Solid_fsi_traction_mesh_pt
Meshes of FSI traction elements (fluid traction onto solid)
Definition: interaction/pseudo_solid_collapsible_tube/pseudo_solid_collapsible_tube.cc:558
PseudoElasticCollapsibleChannelProblem::create_solid_traction_elements
void create_solid_traction_elements()
Definition: interaction/pseudo_solid_collapsible_tube/pseudo_solid_collapsible_tube.cc:992
PseudoElasticCollapsibleChannelProblem::Solid_traction_mesh_pt
SolidMesh * Solid_traction_mesh_pt
Solid traction elements (prescibed external pressure on solid wall)
Definition: interaction/pseudo_solid_collapsible_tube/pseudo_solid_collapsible_tube.cc:567
PseudoElasticCollapsibleChannelProblem::Fluid_mesh_pt
FluidMesh< FLUID_ELEMENT > * Fluid_mesh_pt
Bulk fluid mesh.
Definition: interaction/pseudo_solid_collapsible_tube/pseudo_solid_collapsible_tube.cc:561
oomph::DummyErrorEstimator
Definition: error_estimator.h:435
oomph::EllipticalTube
Definition: geom_objects.h:1131
oomph::Node::x
double & x(const unsigned &i)
Return the i-th nodal coordinate.
Definition: nodes.h:1060
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::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::RefineableNavierStokesEquations
Definition: refineable_navier_stokes_elements.h:322
oomph::SolidMesh
Definition: mesh.h:2562
oomph::SolidNode
Definition: nodes.h:1686
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
FLUID_ELEMENT
#define FLUID_ELEMENT
BiharmonicTestFunctions2::r_min
double r_min
Definition: two_d_biharmonic.cc:237
BiharmonicTestFunctions2::r_max
double r_max
Definition: two_d_biharmonic.cc:238
BiharmonicTestFunctions2::Pi
double Pi
Definition: two_d_biharmonic.cc:235
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::N_slice
unsigned N_slice
number of axial slices in fluid mesh
Definition: interaction/pseudo_solid_collapsible_tube/pseudo_solid_collapsible_tube.cc:356
Global_Parameters::Constitutive_law_pseudo_elastic_pt
ConstitutiveLaw * Constitutive_law_pseudo_elastic_pt
Pointer to constitutive law for the pseudo elastic node update elements.
Definition: interaction/pseudo_solid_collapsible_tube/pseudo_solid_collapsible_tube.cc:368
Global_Parameters::Re
double Re
reynolds number
Definition: adaptive_hopf.cc:54
Global_Parameters::H
double H
wall thickness
Definition: interaction/pseudo_solid_collapsible_tube/pseudo_solid_collapsible_tube.cc:353
Global_Parameters::Constitutive_law_wall_pt
ConstitutiveLaw * Constitutive_law_wall_pt
Pointer to constitutive law for the wall.
Definition: interaction/pseudo_solid_collapsible_tube/pseudo_solid_collapsible_tube.cc:365
Global_Parameters::L
double L
tube length
Definition: interaction/pseudo_solid_collapsible_tube/pseudo_solid_collapsible_tube.cc:344
Global_Parameters::Lup
double Lup
upstream length
Definition: interaction/pseudo_solid_collapsible_tube/pseudo_solid_collapsible_tube.cc:347
Global_Parameters::Ldown
double Ldown
downstream length
Definition: interaction/pseudo_solid_collapsible_tube/pseudo_solid_collapsible_tube.cc:350
MergeRestartFiles.filename
string filename
Definition: MergeRestartFiles.py:39
Mesh_Parameters::nz
const unsigned nz
Definition: ConstraintElementsUnitTest.cpp:32
Mesh_Parameters::lz
const double lz
Definition: ConstraintElementsUnitTest.cpp:35
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::Multi_domain_functions::Doc_boundary_coordinate_file
std::ofstream Doc_boundary_coordinate_file
Definition: multi_domain.cc:47

References oomph::FSI_functions::apply_no_slip_on_moving_wall(), oomph::CommandLineArgs::Argc, b, Global_Parameters::Constitutive_law_pseudo_elastic_pt, Global_Parameters::Constitutive_law_wall_pt, oomph::Multi_domain_functions::Doc_boundary_coordinate_file, e(), MergeRestartFiles::filename, FLUID_ELEMENT, Global_Parameters::H, i, Global_Parameters::L, Global_Parameters::Lambda_sq, Global_Parameters::Ldown, Global_Parameters::Lup, Mesh_Parameters::lz, Global_Parameters::N_slice, Mesh_Parameters::nz, BiharmonicTestFunctions2::Pi, oomph::SolidNode::pin_position(), BiharmonicTestFunctions2::r_max, BiharmonicTestFunctions2::r_min, Global_Parameters::Re, and oomph::Node::x().

◆ ~PseudoElasticCollapsibleChannelProblem() [1/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::~PseudoElasticCollapsibleChannelProblem ( )
inline

Destructor (empty)

445  {
446  delete Fluid_time_stepper_pt;
447  delete Wall_pt;
448  delete Wall_time_stepper_pt;
449  delete Fluid_mesh_pt->spatial_error_estimator_pt();
450  delete Fluid_mesh_pt;
451  delete Solid_mesh_pt->spatial_error_estimator_pt();
452  delete Solid_mesh_pt;
453  delete Solid_fsi_traction_mesh_pt;
454  delete Lagrange_multiplier_mesh_pt;
455  delete Solid_fsi_boundary_pt;
456  delete Solid_traction_mesh_pt;
457  }

◆ PseudoElasticCollapsibleChannelProblem() [2/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::PseudoElasticCollapsibleChannelProblem ( )

Constructor:

◆ ~PseudoElasticCollapsibleChannelProblem() [2/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::~PseudoElasticCollapsibleChannelProblem ( )
inline

Destructor (empty)

445  {
446  delete Fluid_time_stepper_pt;
447  delete Wall_pt;
448  delete Wall_time_stepper_pt;
449  delete Fluid_mesh_pt->spatial_error_estimator_pt();
450  delete Fluid_mesh_pt;
451  delete Solid_mesh_pt->spatial_error_estimator_pt();
452  delete Solid_mesh_pt;
453  delete Solid_fsi_traction_mesh_pt;
454  delete Lagrange_multiplier_mesh_pt;
455  delete Solid_fsi_boundary_pt;
456  delete Solid_traction_mesh_pt;
457  }

◆ PseudoElasticCollapsibleChannelProblem() [3/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::PseudoElasticCollapsibleChannelProblem ( )

Constructor:

◆ ~PseudoElasticCollapsibleChannelProblem() [3/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::~PseudoElasticCollapsibleChannelProblem ( )
inline

Destructor (empty)

451  {
452  delete Fluid_time_stepper_pt;
453  delete Wall_pt;
454  delete Wall_time_stepper_pt;
455  delete Fluid_mesh_pt->spatial_error_estimator_pt();
456  delete Fluid_mesh_pt;
457  delete Solid_mesh_pt->spatial_error_estimator_pt();
458  delete Solid_mesh_pt;
459  delete Solid_fsi_traction_mesh_pt;
460  delete Lagrange_multiplier_mesh_pt;
461  delete Solid_traction_mesh_pt;
462  }

Member Function Documentation

◆ actions_after_adapt() [1/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::actions_after_adapt
virtual

After adapt: Rebuild face element submeshes and re-setup FSI.

Re-create face elements and re-setup problem.

Reimplemented from oomph::Problem.

1144 {
1145  // delete and recreate meshes
1146  this->empty_mesh(Lagrange_multiplier_mesh_pt);
1147  this->empty_mesh(Solid_fsi_traction_mesh_pt);
1148  this->empty_mesh(Solid_traction_mesh_pt);
1149 
1150  // Build the FSI traction elements
1151  create_fsi_traction_elements();
1152 
1153  // Create Lagrange multiplier mesh for boundary motion of fluid mesh
1154  create_lagrange_multiplier_elements();
1155 
1156  // create solid traction elements for external pressure
1157  create_solid_traction_elements();
1158 
1159  // Add these meshes as submeshes
1160  add_sub_mesh(Solid_fsi_traction_mesh_pt);
1161  add_sub_mesh(Solid_traction_mesh_pt);
1162  add_sub_mesh(Lagrange_multiplier_mesh_pt);
1163 
1164  // Rebuild the global mesh
1165  rebuild_global_mesh();
1166 
1167  // Unpin all pressure dofs
1168  RefineableNavierStokesEquations<3>::
1169  unpin_all_pressure_dofs(Fluid_mesh_pt->element_pt());
1170 
1171  // Pin redundant pressure dofs
1172  RefineableNavierStokesEquations<3>::
1173  pin_redundant_nodal_pressures(Fluid_mesh_pt->element_pt());
1174 
1175 
1176  // Re-apply BCs for solid (just to be on the safe side, because of the
1177  //--------------------------------------------------------------------
1178  // way we're keeping the upstream and downstream sections rigid)
1179  //--------------------------------------------------------------
1180 
1181  unsigned nbound_solid = Solid_mesh_pt->nboundary();
1182  for(unsigned b=0;b<nbound_solid;b++)
1183  {
1184  unsigned nnode = Solid_mesh_pt->nboundary_node(b);
1185  for (unsigned i = 0; i < nnode; i++)
1186  {
1187  SolidNode* solid_node_pt=
1188  dynamic_cast<SolidNode*>(Solid_mesh_pt->boundary_node_pt(b,i));
1189 
1190  // Inflow, vertical symmetry (y=const) and outflow: Pin x-displ
1191  if((b==0)||(b==3)||(b==5)){solid_node_pt->pin_position(0);}
1192 
1193  // Inflow, horizontal symmetry (x=const) and outflow: Pin y-displ
1194  if((b==0)||(b==1)||(b==5)){solid_node_pt->pin_position(1);}
1195 
1196  // Inflow and outflow: Pin z-displ
1197  if((b==0)||(b==5)){solid_node_pt->pin_position(2);}
1198 
1199  // Pin all positions in "rigid sections"
1200  double z = solid_node_pt->x(2);
1201  if (z<=Global_Parameters::Lup||
1202  z>=(Global_Parameters::L-Global_Parameters::Ldown))
1203  {
1204  solid_node_pt->pin_position(0);
1205  solid_node_pt->pin_position(1);
1206  solid_node_pt->pin_position(2);
1207  }
1208  }
1209  }
1210 
1211  // Setup FSI
1212  //----------
1213 
1214  unsigned b=3;
1215 
1216  FSI_functions::setup_fluid_load_info_for_solid_elements<FLUID_ELEMENT,3>
1217  (this,3,Fluid_mesh_pt,Solid_fsi_traction_mesh_pt);
1218 
1219  unsigned nnode_fsi_fluid = Fluid_mesh_pt->nboundary_node(b);
1220  for (unsigned i=0;i<nnode_fsi_fluid;i++)
1221  {
1222  Fluid_mesh_pt->
1223  boundary_node_pt(b,i)->set_auxiliary_node_update_fct_pt(
1224  FSI_functions::apply_no_slip_on_moving_wall);
1225  }
1226 }
PseudoElasticCollapsibleChannelProblem::empty_mesh
void empty_mesh(Mesh *const &surface_mesh_pt)
Helper function to delete elements from a mesh.
Definition: interaction/pseudo_solid_collapsible_tube/pseudo_solid_collapsible_tube.cc:1326
oomph::Problem::rebuild_global_mesh
void rebuild_global_mesh()
Definition: problem.cc:1533

References oomph::FSI_functions::apply_no_slip_on_moving_wall(), b, i, Global_Parameters::L, Global_Parameters::Ldown, Global_Parameters::Lup, oomph::SolidNode::pin_position(), and oomph::Node::x().

◆ actions_after_adapt() [2/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::actions_after_adapt ( )
virtual

After adapt: Rebuild face element submeshes and re-setup FSI.

Reimplemented from oomph::Problem.

◆ actions_after_adapt() [3/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::actions_after_adapt ( )
virtual

After adapt: Rebuild face element submeshes and re-setup FSI.

Reimplemented from oomph::Problem.

◆ actions_after_distribute()

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::actions_after_distribute

Recreate face elements and rebuild problem.

After distribute: Rebuild face element submeshes and re-setup FSI

1274 {
1275  // delete and recreate meshes
1276  this->empty_mesh(Lagrange_multiplier_mesh_pt);
1277  this->empty_mesh(Solid_fsi_traction_mesh_pt);
1278  this->empty_mesh(Solid_traction_mesh_pt);
1279  create_fsi_traction_elements();
1280  create_lagrange_multiplier_elements();
1281  create_solid_traction_elements();
1282  add_sub_mesh(Solid_fsi_traction_mesh_pt);
1283  add_sub_mesh(Solid_traction_mesh_pt);
1284  add_sub_mesh(Lagrange_multiplier_mesh_pt);
1285 
1286  // Rebuild the global mesh
1287  rebuild_global_mesh();
1288 
1289  // Unpin all pressure dofs
1290  RefineableNavierStokesEquations<3>::
1291  unpin_all_pressure_dofs(Fluid_mesh_pt->element_pt());
1292 
1293  // Pin redundant pressure dofs
1294  RefineableNavierStokesEquations<3>::
1295  pin_redundant_nodal_pressures(Fluid_mesh_pt->element_pt());
1296 
1297  // Setup FSI
1298  //----------
1299 
1300  unsigned b=3;
1301 
1302  FSI_functions::setup_fluid_load_info_for_solid_elements<FLUID_ELEMENT,3>
1303  (this,3,Fluid_mesh_pt,Solid_fsi_traction_mesh_pt);
1304 
1305  unsigned nnode_fsi_fluid = Fluid_mesh_pt->nboundary_node(b);
1306  for (unsigned i=0;i<nnode_fsi_fluid;i++)
1307  {
1308  Fluid_mesh_pt->
1309  boundary_node_pt(b,i)->set_auxiliary_node_update_fct_pt(
1310  FSI_functions::apply_no_slip_on_moving_wall);
1311  }
1312 }

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

◆ actions_before_adapt() [1/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::actions_before_adapt
virtual

Before adapt: Flush face element submeshes.

Flush mesh of face elements.

Reimplemented from oomph::Problem.

1119 {
1120  // Flush all the submeshes out but keep the meshes of
1121  // RefineableFSISolidTractionElements alive (i.e. don't delete them)
1122  flush_sub_meshes();
1123 
1124  // Add the fluid mesh and the solid mesh back again
1125  // Remember that it's important that the fluid mesh is
1126  // added before the solid mesh!
1127  add_sub_mesh(Fluid_mesh_pt);
1128  add_sub_mesh(Solid_mesh_pt);
1129 
1130  // Rebuild the global mesh
1131  this->rebuild_global_mesh();
1132 }
oomph::Problem::flush_sub_meshes
void flush_sub_meshes()
Definition: problem.h:1339

◆ actions_before_adapt() [2/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::actions_before_adapt ( )
virtual

Before adapt: Flush face element submeshes.

Reimplemented from oomph::Problem.

◆ actions_before_adapt() [3/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::actions_before_adapt ( )
virtual

Before adapt: Flush face element submeshes.

Reimplemented from oomph::Problem.

◆ actions_before_distribute()

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::actions_before_distribute

Before distribute: Flush face submeshes and keep all solid elements adjacent to the fluid as halos.

Retain all bulk solid elements adjacent to fluid mesh as halos then remove face-elements from problem.

1252 {
1253 
1254  // Flush all the submeshes out but keep the meshes of
1255  // RefineableFSISolidTractionElements alive (i.e. don't delete them)
1256  flush_sub_meshes();
1257 
1258  // Add the fluid mesh and the solid mesh back again
1259  // Remember that it's important that the fluid mesh is
1260  // added before the solid mesh!
1261  add_sub_mesh(Fluid_mesh_pt);
1262  add_sub_mesh(Solid_mesh_pt);
1263 
1264  // Rebuild global mesh
1265  rebuild_global_mesh();
1266 }

◆ actions_before_implicit_timestep() [1/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::actions_before_implicit_timestep
virtual

Actions before timestep.

Actions before implicit timestep.

Reimplemented from oomph::Problem.

1352 {
1353  // Get current time
1354  double t=time_pt()->time();
1355 
1356  // Factor for volume flux
1357  double fact=1.0+0.5*sin(MathematicalConstants::Pi*t/Global_Parameters::T);
1358  oomph_info << "Time, volume flux factor: " << t << " " << fact << std::endl;
1359 
1360  // Set inflow (bc 0)
1361  unsigned nnode= fluid_mesh_pt()->nboundary_node(0);
1362  for (unsigned i=0;i<nnode;i++)
1363  {
1364  double x = Fluid_mesh_pt->boundary_node_pt(0,i)->x(0);
1365  double y = Fluid_mesh_pt->boundary_node_pt(0,i)->x(1);
1366  double r = sqrt(x*x+y*y);
1367  double v = 2.0*(1.0-r*r);
1368  v*=fact;
1369  fluid_mesh_pt()->boundary_node_pt(0,i)->set_value(2,v);
1370  }
1371 
1372 }// end of actions_before_implicit_timestep
sin
AnnoyingScalar sin(const AnnoyingScalar &x)
Definition: AnnoyingScalar.h:137
sqrt
AnnoyingScalar sqrt(const AnnoyingScalar &x)
Definition: AnnoyingScalar.h:134
v
Array< int, Dynamic, 1 > v
Definition: Array_initializer_list_vector_cxx11.cpp:1
PseudoElasticCollapsibleChannelProblem::fluid_mesh_pt
FluidMesh< FLUID_ELEMENT > * fluid_mesh_pt()
Bulk fluid mesh.
Definition: interaction/pseudo_solid_collapsible_tube/pseudo_solid_collapsible_tube.cc:540
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
y
Scalar * y
Definition: level1_cplx_impl.h:128
Global_Parameters::T
double T
Period of periodic variation in inflow pressure.
Definition: interaction/pseudo_solid_collapsible_tube/pseudo_solid_collapsible_tube.cc:412
UniformPSDSelfTest.r
r
Definition: UniformPSDSelfTest.py:20
oomph::oomph_info
OomphInfo oomph_info
Definition: oomph_definitions.cc:319
plotDoE.x
list x
Definition: plotDoE.py:28
plotPSD.t
t
Definition: plotPSD.py:36

References i, oomph::oomph_info, BiharmonicTestFunctions2::Pi, UniformPSDSelfTest::r, sin(), sqrt(), Global_Parameters::T, plotPSD::t, v, plotDoE::x, and y.

◆ actions_before_implicit_timestep() [2/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::actions_before_implicit_timestep ( )
virtual

Actions before timestep.

Reimplemented from oomph::Problem.

◆ actions_before_implicit_timestep() [3/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::actions_before_implicit_timestep ( )
virtual

Actions before timestep.

Reimplemented from oomph::Problem.

◆ actions_before_newton_convergence_check() [1/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::actions_before_newton_convergence_check ( )
inlinevirtual

Update no slip bc after update of unknowns.

Reimplemented from oomph::Problem.

484  {
485  Fluid_mesh_pt->node_update();
486  }

◆ actions_before_newton_convergence_check() [2/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::actions_before_newton_convergence_check ( )
inlinevirtual

Update no slip bc after update of unknowns.

Reimplemented from oomph::Problem.

484  {
485  Fluid_mesh_pt->node_update();
486  }

◆ actions_before_newton_convergence_check() [3/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::actions_before_newton_convergence_check ( )
inlinevirtual

Update no slip bc after update of unknowns.

Reimplemented from oomph::Problem.

489  {
490  Fluid_mesh_pt->node_update();
491  }

◆ actions_before_newton_solve() [1/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::actions_before_newton_solve ( )
inlinevirtual

Actions before Newton solve: Reset pseudo-elastic Lagrangian coordinates.

Reimplemented from oomph::Problem.

491  {
492  Fluid_mesh_pt->set_lagrangian_nodal_coordinates();
493  }

◆ actions_before_newton_solve() [2/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::actions_before_newton_solve ( )
inlinevirtual

Actions before Newton solve: Reset pseudo-elastic Lagrangian coordinates.

Reimplemented from oomph::Problem.

491  {
492  Fluid_mesh_pt->set_lagrangian_nodal_coordinates();
493  }

◆ actions_before_newton_solve() [3/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::actions_before_newton_solve ( )
inlinevirtual

Actions before Newton solve: Reset pseudo-elastic Lagrangian coordinates.

Reimplemented from oomph::Problem.

496  {
497  Fluid_mesh_pt->set_lagrangian_nodal_coordinates();
498  }

◆ create_fsi_traction_elements() [1/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::create_fsi_traction_elements

Create FSI traction elements.

Create FSI traction elements that apply fluid traction onto wall.

952 {
953  // Boundary 4 is the is the fsi boundary of solid mesh
954  unsigned b=4;
955 
956  // How many bulk elements are adjacent to boundary b?
957  unsigned n_element = Solid_mesh_pt->nboundary_element(b);
958 
959  // Loop over the bulk elements adjacent to boundary b
960  for(unsigned e=0;e<n_element;e++)
961  {
962  // Get pointer to the bulk element that is adjacent to boundary b
963  SOLID_ELEMENT* bulk_elem_pt = dynamic_cast<SOLID_ELEMENT*>(
964  Solid_mesh_pt->boundary_element_pt(b,e));
965 
966  //What is the index of the face of the element e along boundary b
967  int face_index = Solid_mesh_pt->face_index_at_boundary(b,e);
968 
969  // Create new element
970  RefineableFSISolidTractionElement<SOLID_ELEMENT,3>* el_pt=
971  new RefineableFSISolidTractionElement<SOLID_ELEMENT,3>(bulk_elem_pt,
972  face_index);
973 
974  // Add it to the mesh
975  Solid_fsi_traction_mesh_pt->add_element_pt(el_pt);
976 
977  // Specify boundary number
978  el_pt->set_boundary_number_in_bulk_mesh(b);
979 
980  // Specify FSI parameter
981  el_pt->q_pt() = &Global_Parameters::Q;
982  }
983 } // end of create_fsi_traction_elements
oomph::FSIWallElement::q_pt
double *& q_pt()
Definition: fsi.h:248
oomph::FaceElement::set_boundary_number_in_bulk_mesh
void set_boundary_number_in_bulk_mesh(const unsigned &b)
Set function for the boundary number in bulk mesh.
Definition: elements.h:4482
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::RefineableFSISolidTractionElement
Definition: solid_traction_elements.h:1046
Global_Parameters::Q
double Q
FSI parameter.
Definition: acoustic_fsi.cc:58

References b, e(), Global_Parameters::Q, oomph::FSIWallElement::q_pt(), and oomph::FaceElement::set_boundary_number_in_bulk_mesh().

◆ create_fsi_traction_elements() [2/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::create_fsi_traction_elements ( )

Create FSI traction elements.

◆ create_fsi_traction_elements() [3/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::create_fsi_traction_elements ( )

Create FSI traction elements.

◆ create_lagrange_multiplier_elements() [1/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::create_lagrange_multiplier_elements

Create elements that enforce prescribed boundary motion for the pseudo-solid fluid mesh by Lagrange multipliers

Create elements that impose the prescribed boundary displacement for the pseudo-solid fluid mesh

1030 {
1031  // boundary 3 of fluid mesh
1032  unsigned b=3;
1033 
1034  // create the geom object for the wall
1035  //delete existing object, if it already exists
1036  if(Solid_fsi_boundary_pt!=0) {delete Solid_fsi_boundary_pt;}
1037  //Now create new object
1038  Solid_fsi_boundary_pt= new MeshAsGeomObject(Solid_fsi_traction_mesh_pt);
1039 
1040  // How many bulk fluid elements are adjacent to boundary b?
1041  unsigned n_element = Fluid_mesh_pt->nboundary_element(b);
1042 
1043  // Loop over the bulk fluid elements adjacent to boundary b?
1044  for(unsigned e=0;e<n_element;e++)
1045  {
1046  // Get pointer to the bulk fluid element that is adjacent to boundary b
1047  FLUID_ELEMENT* bulk_elem_pt = dynamic_cast<FLUID_ELEMENT*>(
1048  Fluid_mesh_pt->boundary_element_pt(b,e));
1049 
1050  //Find the index of the face of element e along boundary b
1051  int face_index = Fluid_mesh_pt->face_index_at_boundary(b,e);
1052 
1053  // Create new element
1054  RefineableImposeDisplacementByLagrangeMultiplierElement<FLUID_ELEMENT>*
1055  el_pt =
1056  new RefineableImposeDisplacementByLagrangeMultiplierElement<FLUID_ELEMENT>(
1057  bulk_elem_pt,face_index);
1058 
1059  // Add it to the mesh
1060  Lagrange_multiplier_mesh_pt->add_element_pt(el_pt);
1061 
1062  // Set the GeomObject that defines the boundary shape and set
1063  // which bulk boundary we are attached to (needed to extract
1064  // the boundary coordinate from the bulk nodes)
1065  el_pt->set_boundary_shape_geom_object_pt(Solid_fsi_boundary_pt,b);
1066 
1067  // Loop over the nodes
1068  unsigned nnod=el_pt->nnode();
1069  for (unsigned i=0;i<nnod;i++)
1070  {
1071  // How many nodal values were used by the "bulk" element
1072  // that originally created this node?
1073  unsigned n_bulk_value=el_pt->nbulk_value(i);
1074  Node* node_pt = el_pt->node_pt(i);
1075 
1076  // The remaining ones are Lagrange multipliers and we pin them.
1077  unsigned nval=node_pt->nvalue();
1078  for (unsigned j=n_bulk_value;j<nval;j++)
1079  {
1080  // Direction of Lagrange multiplier force
1081  int d=j-n_bulk_value;
1082 
1083 
1084  // Boundary 0 (inflow): Pseudo-solid displacement is fixed so pin
1085  // all Lagrange multipliers
1086  if (node_pt->is_on_boundary(0))
1087  {
1088  if (d==0||d==1||d==2) node_pt->pin(j);
1089  }
1090  // Boundary 1 (symm BC, x=const.): Pseudo-solid displacement is
1091  // fixed in x-direction so pin corresponding Lagrange multiplier
1092  if (node_pt->is_on_boundary(1))
1093  {
1094  if (d==0) node_pt->pin(j);
1095  }
1096  // Boundary 2 (symm BC, y=const.): Pseudo-solid displacement is
1097  // fixed in y-direction so pin corresponding Lagrange multiplier
1098  if (node_pt->is_on_boundary(2))
1099  {
1100  if (d==1) node_pt->pin(j);
1101  }
1102  // Boundary 4 (outflow): Pseudo-solid displacement is fixed so pin
1103  // all Lagrange multipliers
1104  if (node_pt->is_on_boundary(4))
1105  {
1106  if (d==0||d==1||d==2) node_pt->pin(j);
1107  }
1108  }
1109  }
1110  }
1111 } // end of create_lagrange_multiplier_elements
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::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::MeshAsGeomObject
Definition: mesh_as_geometric_object.h:93
oomph::Node
Definition: nodes.h:906
oomph::Node::is_on_boundary
virtual bool is_on_boundary() const
Definition: nodes.h:1373
oomph::RefineableImposeDisplacementByLagrangeMultiplierElement
Definition: solid_traction_elements.h:2013
j
std::ptrdiff_t j
Definition: tut_arithmetic_redux_minmax.cpp:2

References b, e(), FLUID_ELEMENT, i, oomph::Node::is_on_boundary(), j, 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().

◆ create_lagrange_multiplier_elements() [2/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::create_lagrange_multiplier_elements ( )

Create elements that enforce prescribed boundary motion for the pseudo-solid fluid mesh by Lagrange multipliers

◆ create_lagrange_multiplier_elements() [3/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::create_lagrange_multiplier_elements ( )

Create elements that enforce prescribed boundary motion for the pseudo-solid fluid mesh by Lagrange multipliers

◆ create_solid_traction_elements() [1/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::create_solid_traction_elements

create solid traction elements (to apply pressure to external solid wall)

Create face elements that apply external pressure load onto wall

993 {
994  // Set boundary
995  unsigned b=2;
996 
997  // How many bulk elements are adjacent to boundary b?
998  unsigned n_element = Solid_mesh_pt->nboundary_element(b);
999 
1000  // Loop over the bulk elements adjacent to boundary b
1001  for(unsigned e=0;e<n_element;e++)
1002  {
1003  // Get pointer to the bulk element that is adjacent to boundary b
1004  SOLID_ELEMENT* bulk_elem_pt = dynamic_cast<SOLID_ELEMENT*>(
1005  Solid_mesh_pt->boundary_element_pt(b,e));
1006 
1007  //Find the index of the face of element e along boundary b
1008  int face_index = Solid_mesh_pt->face_index_at_boundary(b,e);
1009 
1010  // Create new element
1011  RefineableSolidTractionElement<SOLID_ELEMENT>* el_pt =
1012  new RefineableSolidTractionElement<SOLID_ELEMENT>(bulk_elem_pt,
1013  face_index);
1014 
1015  //Set the traction function
1016  el_pt->traction_fct_pt() = &Global_Parameters::press_load;
1017 
1018  // add to mesh
1019  Solid_traction_mesh_pt->add_element_pt(el_pt);
1020  }
1021 }
oomph::RefineableSolidTractionElement
Definition: solid_traction_elements.h:474
oomph::SolidTractionElement::traction_fct_pt
void(*&)(const Vector< double > &xi, const Vector< double > &x, const Vector< double > &n, Vector< double > &traction) traction_fct_pt()
Reference to the traction function pointer.
Definition: solid_traction_elements.h:159
Global_Parameters::press_load
void press_load(const Vector< double > &xi, const Vector< double > &x, const Vector< double > &N, Vector< double > &load)
Load function for wall.
Definition: interaction/pseudo_solid_collapsible_tube/pseudo_solid_collapsible_tube.cc:391

References b, e(), Global_Parameters::press_load(), and oomph::SolidTractionElement< ELEMENT >::traction_fct_pt.

◆ create_solid_traction_elements() [2/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::create_solid_traction_elements ( )

create solid traction elements (to apply pressure to external solid wall)

◆ create_solid_traction_elements() [3/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::create_solid_traction_elements ( )

create solid traction elements (to apply pressure to external solid wall)

◆ doc_parameters() [1/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::doc_parameters ( )
inline

Doc parameters.

519  {
520  std::cout << "\n\n=================================================\n";
521  std::cout << "Q : " << Global_Parameters::Q
522  << std::endl;
523  std::cout << "Re : " << Global_Parameters::Re
524  << std::endl;
525  std::cout << "P : " << Global_Parameters::P
526  << std::endl;
527  std::cout << "Pcos : " << Global_Parameters::Pcos
528  << std::endl;
529  std::cout << "T : " << Global_Parameters::T
530  <<std::endl;
531  std::cout << "t : " << time_pt()->time()
532  << std::endl;
533  std::cout << "=================================================\n\n";
534  }
Global_Parameters::P
double P
Uniform pressure.
Definition: unstructured_acoustic_fsi.cc:145
Global_Parameters::Pcos
double Pcos
Perturbation pressure.
Definition: interaction/pseudo_solid_collapsible_tube/pseudo_solid_collapsible_tube.cc:382

References Global_Parameters::P, Global_Parameters::Pcos, Global_Parameters::Q, Global_Parameters::Re, and Global_Parameters::T.

◆ doc_parameters() [2/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::doc_parameters ( )
inline

Doc parameters.

519  {
520  std::cout << "\n\n=================================================\n";
521  std::cout << "Q : " << Global_Parameters::Q
522  << std::endl;
523  std::cout << "Re : " << Global_Parameters::Re
524  << std::endl;
525  std::cout << "P : " << Global_Parameters::P
526  << std::endl;
527  std::cout << "Pcos : " << Global_Parameters::Pcos
528  << std::endl;
529  std::cout << "T : " << Global_Parameters::T
530  <<std::endl;
531  std::cout << "t : " << time_pt()->time()
532  << std::endl;
533  std::cout << "=================================================\n\n";
534  }

References Global_Parameters::P, Global_Parameters::Pcos, Global_Parameters::Q, Global_Parameters::Re, and Global_Parameters::T.

◆ doc_parameters() [3/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::doc_parameters ( )
inline

Doc parameters.

525  {
526  std::cout << "\n\n=================================================\n";
527  std::cout << "Q : " << Global_Parameters::Q
528  << std::endl;
529  std::cout << "Re : " << Global_Parameters::Re
530  << std::endl;
531  std::cout << "P : " << Global_Parameters::P
532  << std::endl;
533  std::cout << "Pcos : " << Global_Parameters::Pcos
534  << std::endl;
535  std::cout << "T : " << Global_Parameters::T
536  <<std::endl;
537  std::cout << "t : " << time_pt()->time()
538  << std::endl;
539  std::cout << "=================================================\n\n";
540  }

References Global_Parameters::P, Global_Parameters::Pcos, Global_Parameters::Q, Global_Parameters::Re, and Global_Parameters::T.

◆ doc_solid_boundary_coordinates() [1/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::doc_solid_boundary_coordinates
private

Sanity check: Doc boundary coordinates on i-th solid FSI interface.

Doc boundary coordinates of i-th solid FSI boundary.

1381 {
1382 
1383  //Doc boundary coordinates in fluid
1384  char filename[100];
1385  sprintf(filename,"RESLT/solid_boundary_coordinates.dat");
1386  std::ofstream the_file(filename);
1387 
1388  // Loop over traction elements
1389  unsigned n_face_element = Solid_fsi_traction_mesh_pt->nelement();
1390  for(unsigned e=0;e<n_face_element;e++)
1391  {
1392  //Cast the element pointer
1393  RefineableFSISolidTractionElement<SOLID_ELEMENT,3>* el_pt=
1394  dynamic_cast<RefineableFSISolidTractionElement<SOLID_ELEMENT,3>*>
1395  (Solid_fsi_traction_mesh_pt->element_pt(e));
1396 
1397  // Doc boundary coordinate
1398  Vector<double> s(2);
1399  Vector<double> zeta(2);
1400  Vector<double> x(3);
1401  unsigned n_plot=3;
1402  the_file << el_pt->tecplot_zone_string(n_plot);
1403 
1404  // Loop over plot points
1405  unsigned num_plot_points=el_pt->nplot_points(n_plot);
1406  for (unsigned iplot=0;iplot<num_plot_points;iplot++)
1407  {
1408  // Get local coordinates of plot point
1409  el_pt->get_s_plot(iplot,n_plot,s);
1410  el_pt->interpolated_zeta(s,zeta);
1411  el_pt->interpolated_x(s,x);
1412  for (unsigned i=0;i<3;i++)
1413  {
1414  the_file << x[i] << " ";
1415  }
1416  for (unsigned i=0;i<2;i++)
1417  {
1418  the_file << zeta[i] << " ";
1419  }
1420 
1421  the_file << std::endl;
1422  }
1423  el_pt->write_tecplot_zone_footer(the_file,n_plot);
1424  }
1425 
1426  // Close doc file
1427  the_file.close();
1428 
1429 } // end doc_solid_zeta
oomph::FaceElement::interpolated_x
double interpolated_x(const Vector< double > &s, const unsigned &i) const
Definition: elements.h:4528
oomph::FiniteElement::interpolated_zeta
void interpolated_zeta(const Vector< double > &s, Vector< double > &zeta) const
Definition: elements.cc:4675
oomph::FiniteElement::tecplot_zone_string
virtual std::string tecplot_zone_string(const unsigned &nplot) const
Definition: elements.h:3161
oomph::FiniteElement::get_s_plot
virtual void get_s_plot(const unsigned &i, const unsigned &nplot, Vector< double > &s, const bool &shifted_to_interior=false) const
Definition: elements.h:3148
oomph::FiniteElement::nplot_points
virtual unsigned nplot_points(const unsigned &nplot) const
Definition: elements.h:3186
oomph::FiniteElement::write_tecplot_zone_footer
virtual void write_tecplot_zone_footer(std::ostream &outfile, const unsigned &nplot) const
Definition: elements.h:3174
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
s
RealScalar s
Definition: level1_cplx_impl.h:130
Eigen::zeta
EIGEN_STRONG_INLINE const Eigen::CwiseBinaryOp< Eigen::internal::scalar_zeta_op< typename DerivedX::Scalar >, const DerivedX, const DerivedQ > zeta(const Eigen::ArrayBase< DerivedX > &x, const Eigen::ArrayBase< DerivedQ > &q)
Definition: SpecialFunctionsArrayAPI.h:152

References e(), MergeRestartFiles::filename, oomph::FiniteElement::get_s_plot(), i, oomph::FaceElement::interpolated_x(), oomph::FiniteElement::interpolated_zeta(), oomph::FiniteElement::nplot_points(), s, oomph::FiniteElement::tecplot_zone_string(), oomph::FiniteElement::write_tecplot_zone_footer(), plotDoE::x, and Eigen::zeta().

◆ doc_solid_boundary_coordinates() [2/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::doc_solid_boundary_coordinates ( )
private

Sanity check: Doc boundary coordinates on i-th solid FSI interface.

◆ doc_solid_boundary_coordinates() [3/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::doc_solid_boundary_coordinates ( )
private

Sanity check: Doc boundary coordinates on i-th solid FSI interface.

◆ doc_solution() [1/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::doc_solution ( DocInfo &  doc_info)

Doc the solution.

1438 {
1439 
1440  ofstream some_file;
1441  char filename[100];
1442 
1443  // Number of plot points
1444  unsigned npts;
1445  npts=5;
1446 
1447  // Output solid boundaries
1448  //------------------------
1449  sprintf(filename,"%s/solid_boundaries%i.dat",doc_info.directory().c_str(),
1450  doc_info.number());
1451  some_file.open(filename);
1452  Solid_mesh_pt->output_boundaries(some_file);
1453  some_file.close();
1454 
1455 
1456  // Output solid solution
1457  //-----------------------
1458  sprintf(filename,"%s/solid_soln%i.dat",doc_info.directory().c_str(),
1459  doc_info.number());
1460  some_file.open(filename);
1461  Solid_mesh_pt->output(some_file,npts);
1462  some_file.close();
1463 
1464 
1465  // Output fluid boundaries
1466  //------------------------
1467  sprintf(filename,"%s/fluid_boundaries%i.dat",doc_info.directory().c_str(),
1468  doc_info.number());
1469  some_file.open(filename);
1470  Fluid_mesh_pt->output_boundaries(some_file);
1471  some_file.close();
1472 
1473 
1474  // Output fluid solution
1475  //-----------------------
1476  sprintf(filename,"%s/fluid_soln%i.dat",doc_info.directory().c_str(),
1477  doc_info.number());
1478  some_file.open(filename);
1479  Fluid_mesh_pt->output(some_file,npts);
1480  some_file.close();
1481 
1482 
1483  // Output fsi traction
1484  //--------------------
1485  sprintf(filename,"%s/fsi_traction%i.dat",doc_info.directory().c_str(),
1486  doc_info.number());
1487  some_file.open(filename);
1488  Solid_fsi_traction_mesh_pt->output(some_file,npts);
1489  some_file.close();
1490 
1491  // Output fsi traction
1492  //--------------------
1493  sprintf(filename,"%s/solid_traction%i.dat",doc_info.directory().c_str(),
1494  doc_info.number());
1495  some_file.open(filename);
1496  Solid_traction_mesh_pt->output(some_file,npts);
1497  some_file.close();
1498 
1499 
1500  // Output Lagrange multipliers
1501  //----------------------------
1502  sprintf(filename,"%s/lagrange%i.dat",doc_info.directory().c_str(),
1503  doc_info.number());
1504  some_file.open(filename);
1505  Lagrange_multiplier_mesh_pt->output(some_file,npts);
1506  some_file.close();
1507 
1508 } // end_of_doc
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::Mesh::output
void output(std::ostream &outfile)
Output for all elements.
Definition: mesh.cc:2027

References oomph::DocInfo::directory(), MergeRestartFiles::filename, and oomph::DocInfo::number().

◆ doc_solution() [2/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::doc_solution ( DocInfo &  doc_info)

Doc the solution.

◆ doc_solution() [3/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::doc_solution ( DocInfo &  doc_info)

Doc the solution.

◆ empty_mesh() [1/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::empty_mesh ( Mesh *const &  surface_mesh_pt)

Helper function to delete elements from a mesh.

Delete elements in specified mesh of face elements.

1327 {
1328  // How many surface elements are in the surface mesh
1329  unsigned n_element = surface_mesh_pt->nelement();
1330 
1331  // Loop over the surface elements
1332  for(unsigned e=0;e<n_element;e++)
1333  {
1334  // Kill surface element
1335  delete surface_mesh_pt->element_pt(e);
1336  }
1337 
1338  // Wipe the mesh
1339  surface_mesh_pt->flush_element_and_node_storage();
1340 
1341 } // end of empty_mesh
oomph::Mesh::flush_element_and_node_storage
void flush_element_and_node_storage()
Definition: mesh.h:407

References e(), oomph::Mesh::element_pt(), oomph::Mesh::flush_element_and_node_storage(), and oomph::Mesh::nelement().

◆ empty_mesh() [2/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::empty_mesh ( Mesh *const &  surface_mesh_pt)

Helper function to delete elements from a mesh.

◆ empty_mesh() [3/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::empty_mesh ( Mesh *const &  surface_mesh_pt)

Helper function to delete elements from a mesh.

◆ fluid_mesh_pt() [1/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
FluidMesh<FLUID_ELEMENT>* PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::fluid_mesh_pt ( )
inline

Bulk fluid mesh.

540 {return Fluid_mesh_pt; }

◆ fluid_mesh_pt() [2/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
FluidMesh<FLUID_ELEMENT>* PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::fluid_mesh_pt ( )
inline

Bulk fluid mesh.

540 {return Fluid_mesh_pt; }

◆ fluid_mesh_pt() [3/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
FluidMesh<FLUID_ELEMENT>* PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::fluid_mesh_pt ( )
inline

Bulk fluid mesh.

546 {return Fluid_mesh_pt; }

◆ lagrange_multiplier_mesh_pt() [1/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
SolidMesh*& PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::lagrange_multiplier_mesh_pt ( )
inline

Meshes of Lagrange multiplier elements.

544  {return Lagrange_multiplier_mesh_pt; }

◆ lagrange_multiplier_mesh_pt() [2/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
SolidMesh*& PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::lagrange_multiplier_mesh_pt ( )
inline

Meshes of Lagrange multiplier elements.

544  {return Lagrange_multiplier_mesh_pt; }

◆ lagrange_multiplier_mesh_pt() [3/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
SolidMesh*& PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::lagrange_multiplier_mesh_pt ( )
inline

Meshes of Lagrange multiplier elements.

550  {return Lagrange_multiplier_mesh_pt; }

◆ set_initial_condition() [1/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::set_initial_condition
virtual

Set initial conditions.

Apply initial conditions.

Reimplemented from oomph::Problem.

925 {
926  // Set Poiseuille flow
927  unsigned nnode = Fluid_mesh_pt->nnode();
928  for (unsigned i = 0; i < nnode; i++)
929  {
930  double x = Fluid_mesh_pt->node_pt(i)->x(0);
931  double y = Fluid_mesh_pt->node_pt(i)->x(1);
932  double r = sqrt(x*x+y*y);
933  double v = 2.0*(1.0-r*r);
934  Fluid_mesh_pt->node_pt(i)->set_value(0,0.0);
935  Fluid_mesh_pt->node_pt(i)->set_value(1,0.0);
936  Fluid_mesh_pt->node_pt(i)->set_value(2,v);
937  }
938 
939 
940  // Assign initial values for an impulsive start
941  Fluid_mesh_pt->assign_initial_values_impulsive();
942  Solid_mesh_pt->assign_initial_values_impulsive();
943 
944 }

References i, UniformPSDSelfTest::r, sqrt(), v, plotDoE::x, and y.

◆ set_initial_condition() [2/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::set_initial_condition ( )
virtual

Set initial conditions.

Reimplemented from oomph::Problem.

◆ set_initial_condition() [3/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::set_initial_condition ( )
virtual

Set initial conditions.

Reimplemented from oomph::Problem.

◆ set_pseudo_elastic_fsi_solver()

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::set_pseudo_elastic_fsi_solver

Switch to GMRES preconditioned with the pseudo-elastic FSI preconditioner

1591 {
1592 
1593 //setup the solver
1594 #ifdef OOMPH_HAS_TRILINOS
1595 
1596  TrilinosAztecOOSolver* solver_pt = new
1597  TrilinosAztecOOSolver;
1598  solver_pt->solver_type() = TrilinosAztecOOSolver::GMRES;
1599 
1600 #else
1601 
1602  GMRES<CRDoubleMatrix>* solver_pt = new GMRES<CRDoubleMatrix>;
1603 
1604 #endif
1605 
1606  // Set tolerance
1607  solver_pt->tolerance()=1.0e-8;
1608 
1609  // Max. number of iterations
1610  solver_pt->max_iter()=200;
1611 
1612  // preconditioner
1613  PseudoElasticFSIPreconditioner* prec_pt = new
1614  PseudoElasticFSIPreconditioner(3,this);
1615 
1616  // meshes
1617  prec_pt->set_fluid_and_pseudo_elastic_mesh_pt(fluid_mesh_pt());
1618  prec_pt->set_solid_mesh_pt(wall_mesh_pt());
1619  prec_pt->set_lagrange_multiplier_mesh_pt(lagrange_multiplier_mesh_pt());
1620 
1621  // inexact pseudo-solid preconditioning
1622  prec_pt->pseudo_elastic_preconditioner_pt()->elastic_preconditioner_type()
1623  = PseudoElasticPreconditioner::
1624  Block_upper_triangular_preconditioner;
1625 
1626 #ifdef OOMPH_HAS_HYPRE
1627 
1628  prec_pt->pseudo_elastic_preconditioner_pt()
1629  ->set_elastic_subsidiary_preconditioner
1630  (Pseudo_Elastic_Preconditioner_Subsidiary_Operator_Helper
1631  ::get_elastic_preconditioner);
1632 
1633 #endif
1634 
1635 
1636 #ifdef OOMPH_HAS_TRILINOS
1637 
1638  prec_pt->pseudo_elastic_preconditioner_pt()
1639  ->set_lagrange_multiplier_subsidiary_preconditioner
1640  (Pseudo_Elastic_Preconditioner_Subsidiary_Operator_Helper
1641  ::get_lagrange_multiplier_preconditioner);
1642 
1643 #endif
1644 
1645  // inexact "real" solid preconditioning
1646  BlockTriangularPreconditioner<CRDoubleMatrix>*
1647  solid_prec_pt = new BlockTriangularPreconditioner<CRDoubleMatrix>;
1648  prec_pt->set_solid_preconditioner(solid_prec_pt);
1649 
1650 #ifdef OOMPH_HAS_HYPRE
1651 
1652  solid_prec_pt->set_subsidiary_preconditioner_function
1653  (Real_Solid_Preconditioner_Helper::get_preconditioner);
1654 
1655 #endif
1656 
1657  // inexact navier stokes preconditioning
1658  NavierStokesSchurComplementPreconditioner*
1659  ns_prec_pt = prec_pt->navier_stokes_schur_complement_preconditioner_pt();
1660  prec_pt->enable_navier_stokes_schur_complement_preconditioner();
1661 
1662  // ns momentum
1663  BlockDiagonalPreconditioner<CRDoubleMatrix>*
1664  f_prec_pt = new BlockDiagonalPreconditioner<CRDoubleMatrix>;
1665 
1666 #ifdef OOMPH_HAS_HYPRE
1667 
1668  f_prec_pt->set_subsidiary_preconditioner_function
1669  (LSC_Preconditioner_Helper::set_hypre_preconditioner);
1670 
1671 #endif
1672 
1673  ns_prec_pt->set_f_preconditioner(f_prec_pt);
1674 
1675 #ifdef OOMPH_HAS_HYPRE
1676 
1677  // ns pressure poisson
1678  HyprePreconditioner* p_prec_pt = new HyprePreconditioner;
1679  p_prec_pt->set_amg_iterations(2);
1680  p_prec_pt->amg_using_simple_smoothing();
1681  p_prec_pt->amg_simple_smoother() = 3;
1682  p_prec_pt->hypre_method() = HyprePreconditioner::BoomerAMG;
1683  p_prec_pt->amg_strength() = 0.25;
1684  // Use 6 for parallel (Falgout) or 3 (Ruge Stuben) for serial
1685  p_prec_pt->amg_coarsening() = 6;
1686  p_prec_pt->disable_doc_time();
1687  ns_prec_pt->set_p_preconditioner(p_prec_pt);
1688 
1689 #endif
1690 
1691  // and pass prec to solver and solver to problem
1692  solver_pt->preconditioner_pt() = prec_pt;
1693  linear_solver_pt() = solver_pt;
1694  }
PseudoElasticCollapsibleChannelProblem::wall_mesh_pt
WallMesh< SOLID_ELEMENT > * wall_mesh_pt()
Bulk solid mesh.
Definition: interaction/pseudo_solid_collapsible_tube/pseudo_solid_collapsible_tube.cc:537
PseudoElasticCollapsibleChannelProblem::lagrange_multiplier_mesh_pt
SolidMesh *& lagrange_multiplier_mesh_pt()
Meshes of Lagrange multiplier elements.
Definition: interaction/pseudo_solid_collapsible_tube/pseudo_solid_collapsible_tube.cc:543
oomph::BlockDiagonalPreconditioner
Definition: general_purpose_block_preconditioners.h:321
oomph::BlockTriangularPreconditioner
Definition: general_purpose_block_preconditioners.h:459
oomph::GMRES
The GMRES method.
Definition: iterative_linear_solver.h:1227
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::HyprePreconditioner
Definition: hypre_solver.h:826
oomph::HyprePreconditioner::amg_simple_smoother
unsigned & amg_simple_smoother()
Access function to AMG_simple_smoother flag.
Definition: hypre_solver.h:983
oomph::HyprePreconditioner::amg_strength
double & amg_strength()
Access function to AMG_strength.
Definition: hypre_solver.h:1038
oomph::HyprePreconditioner::set_amg_iterations
void set_amg_iterations(const unsigned &amg_iterations)
Function to set the number of times to apply BoomerAMG.
Definition: hypre_solver.h:964
oomph::HyprePreconditioner::hypre_method
unsigned & hypre_method()
Access function to Hypre_method flag – specified via enumeration.
Definition: hypre_solver.h:945
oomph::HyprePreconditioner::disable_doc_time
void disable_doc_time()
Disable documentation of preconditioner timings.
Definition: hypre_solver.h:939
oomph::HyprePreconditioner::amg_using_simple_smoothing
void amg_using_simple_smoothing()
Definition: hypre_solver.h:977
oomph::HyprePreconditioner::amg_coarsening
unsigned & amg_coarsening()
Access function to AMG_coarsening flag.
Definition: hypre_solver.h:1020
oomph::IterativeLinearSolver::preconditioner_pt
Preconditioner *& preconditioner_pt()
Access function to preconditioner.
Definition: iterative_linear_solver.h:95
oomph::IterativeLinearSolver::tolerance
double & tolerance()
Access to convergence tolerance.
Definition: iterative_linear_solver.h:107
oomph::IterativeLinearSolver::max_iter
unsigned & max_iter()
Access to max. number of iterations.
Definition: iterative_linear_solver.h:113
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::Problem::linear_solver_pt
LinearSolver *& linear_solver_pt()
Return a pointer to the linear solver object.
Definition: problem.h:1466
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_solid_preconditioner
void set_solid_preconditioner(Preconditioner *prec_pt)
Definition: pseudo_elastic_fsi_preconditioner.h:169
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::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::PseudoElasticPreconditioner::set_lagrange_multiplier_subsidiary_preconditioner
void set_lagrange_multiplier_subsidiary_preconditioner(SubsidiaryPreconditionerFctPt prec_fn)
Definition: pseudo_elastic_preconditioner.h:206
oomph::PseudoElasticPreconditioner::set_elastic_subsidiary_preconditioner
void set_elastic_subsidiary_preconditioner(SubsidiaryPreconditionerFctPt prec_fn)
Definition: pseudo_elastic_preconditioner.h:216
oomph::TrilinosAztecOOSolver
Definition: trilinos_solver.h:267
oomph::TrilinosAztecOOSolver::solver_type
unsigned & solver_type()
Access function to Solver_type.
Definition: trilinos_solver.h:442

References oomph::HyprePreconditioner::amg_coarsening(), oomph::HyprePreconditioner::amg_simple_smoother(), oomph::HyprePreconditioner::amg_strength(), oomph::HyprePreconditioner::amg_using_simple_smoothing(), oomph::HyprePreconditioner::disable_doc_time(), oomph::PseudoElasticPreconditioner::elastic_preconditioner_type(), oomph::PseudoElasticFSIPreconditioner::enable_navier_stokes_schur_complement_preconditioner(), oomph::HyprePreconditioner::hypre_method(), oomph::TrilinosAztecOOSolver::max_iter(), oomph::PseudoElasticFSIPreconditioner::navier_stokes_schur_complement_preconditioner_pt(), oomph::IterativeLinearSolver::preconditioner_pt(), oomph::PseudoElasticFSIPreconditioner::pseudo_elastic_preconditioner_pt(), oomph::HyprePreconditioner::set_amg_iterations(), oomph::PseudoElasticPreconditioner::set_elastic_subsidiary_preconditioner(), oomph::NavierStokesSchurComplementPreconditioner::set_f_preconditioner(), oomph::PseudoElasticFSIPreconditioner::set_fluid_and_pseudo_elastic_mesh_pt(), oomph::PseudoElasticFSIPreconditioner::set_lagrange_multiplier_mesh_pt(), oomph::PseudoElasticPreconditioner::set_lagrange_multiplier_subsidiary_preconditioner(), oomph::NavierStokesSchurComplementPreconditioner::set_p_preconditioner(), oomph::PseudoElasticFSIPreconditioner::set_solid_mesh_pt(), oomph::PseudoElasticFSIPreconditioner::set_solid_preconditioner(), oomph::GeneralPurposeBlockPreconditioner< MATRIX >::set_subsidiary_preconditioner_function(), oomph::TrilinosAztecOOSolver::solver_type(), and oomph::TrilinosAztecOOSolver::tolerance().

◆ steady_run() [1/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::steady_run ( DocInfo &  doc_info)

Do steady run.

1519 {
1520 
1521  //Output initial configuration
1522  this->doc_solution(doc_info);
1523  doc_info.number()++;
1524 
1525  // increment P
1526  double p_increment=5.0e-4;
1527  unsigned count=0;
1528  while (this->wall_mesh_pt()->min_deformation() > 0.9)
1529  {
1530  oomph_info << "Min wall position: "
1531  << this->wall_mesh_pt()->min_deformation() << std::endl;
1532  Global_Parameters::P+=p_increment;
1533 
1534  cout << "Doing steady solve: " << count << std::endl;
1535  if (CommandLineArgs::Argc!=1)
1536  {
1537  this->steady_newton_solve();
1538  }
1539  else
1540  {
1541  unsigned max_adapt=1;
1542  this->steady_newton_solve(max_adapt);
1543  }
1544  this->doc_parameters();
1545  this->doc_solution(doc_info);
1546  doc_info.number()++;
1547  count++;
1548  if (CommandLineArgs::Argc!=1)
1549  {
1550  oomph_info << "Just doing one steady solve during validation.\n";
1551  break;
1552  }
1553  }
1554 
1555 }
PseudoElasticCollapsibleChannelProblem::doc_solution
void doc_solution(DocInfo &doc_info)
Doc the solution.
Definition: interaction/pseudo_solid_collapsible_tube/pseudo_solid_collapsible_tube.cc:1437
PseudoElasticCollapsibleChannelProblem::doc_parameters
void doc_parameters()
Doc parameters.
Definition: interaction/pseudo_solid_collapsible_tube/pseudo_solid_collapsible_tube.cc:518
WallMesh::min_deformation
double min_deformation()
Definition: interaction/pseudo_solid_collapsible_tube/pseudo_solid_collapsible_tube.cc:263
oomph::Problem::steady_newton_solve
void steady_newton_solve(unsigned const &max_adapt=0)
Definition: problem.cc:9292

References oomph::CommandLineArgs::Argc, oomph::DocInfo::number(), oomph::oomph_info, and Global_Parameters::P.

◆ steady_run() [2/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::steady_run ( DocInfo &  doc_info)

Do steady run.

◆ steady_run() [3/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::steady_run ( DocInfo &  doc_info)

Do steady run.

◆ unsteady_run() [1/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::unsteady_run ( DocInfo &  doc_info)

Do unsteady run.

1564 {
1565 
1566  // Set number of timesteps
1567  unsigned nstep=Global_Parameters::Nstep_per_period*Global_Parameters::Nperiod;
1568  if (CommandLineArgs::Argc!=1)
1569  {
1570  oomph_info << "Just doing one timestep during validation.\n";
1571  nstep=1;
1572  }
1573 
1574  // Do unsteady run
1575  for (unsigned r = 0; r < nstep; r++)
1576  {
1577  cout << "Doing unsteady solve: " << r << std::endl;
1578  this->unsteady_newton_solve(Global_Parameters::Dt);
1579  this->doc_parameters();
1580  this->doc_solution(doc_info);
1581  doc_info.number()++;
1582  }
1583 
1584 }
oomph::Problem::unsteady_newton_solve
void unsteady_newton_solve(const double &dt)
Definition: problem.cc:10953
Global_Parameters::Nperiod
unsigned Nperiod
Number of periods.
Definition: interaction/pseudo_solid_collapsible_tube/pseudo_solid_collapsible_tube.cc:421
Global_Parameters::Dt
double Dt
Timestep.
Definition: interaction/pseudo_solid_collapsible_tube/pseudo_solid_collapsible_tube.cc:415
Global_Parameters::Nstep_per_period
unsigned Nstep_per_period
Number of steps per period.
Definition: interaction/pseudo_solid_collapsible_tube/pseudo_solid_collapsible_tube.cc:418

References oomph::CommandLineArgs::Argc, Global_Parameters::Dt, Global_Parameters::Nperiod, Global_Parameters::Nstep_per_period, oomph::DocInfo::number(), oomph::oomph_info, and UniformPSDSelfTest::r.

◆ unsteady_run() [2/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::unsteady_run ( DocInfo &  doc_info)

Do unsteady run.

◆ unsteady_run() [3/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::unsteady_run ( DocInfo &  doc_info)

Do unsteady run.

◆ wall_mesh_pt() [1/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
WallMesh<SOLID_ELEMENT>* PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::wall_mesh_pt ( )
inline

Bulk solid mesh.

537 {return Solid_mesh_pt; }

◆ wall_mesh_pt() [2/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
WallMesh<SOLID_ELEMENT>* PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::wall_mesh_pt ( )
inline

Bulk solid mesh.

537 {return Solid_mesh_pt; }

◆ wall_mesh_pt() [3/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
WallMesh<SOLID_ELEMENT>* PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::wall_mesh_pt ( )
inline

Bulk solid mesh.

543 {return Solid_mesh_pt; }

Member Data Documentation

◆ Fluid_mesh_pt

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
FluidMesh< FLUID_ELEMENT > * PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::Fluid_mesh_pt
private

Bulk fluid mesh.

◆ Fluid_time_stepper_pt

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
BDF< 2 > * PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::Fluid_time_stepper_pt
private

Timestepper for the Navier-Stokes equations.

◆ Lagrange_multiplier_mesh_pt

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
SolidMesh * PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::Lagrange_multiplier_mesh_pt
private

Mesh of Lagrange multiplier elements.

◆ Solid_fsi_boundary_pt

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
MeshAsGeomObject * PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::Solid_fsi_boundary_pt
private

GeomObject incarnations of the FSI boundary in the solid mesh.

◆ Solid_fsi_traction_mesh_pt

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
SolidMesh * PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::Solid_fsi_traction_mesh_pt
private

Meshes of FSI traction elements (fluid traction onto solid)

◆ Solid_mesh_pt

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
WallMesh< SOLID_ELEMENT > * PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::Solid_mesh_pt
private

Bulk solid mesh.

◆ Solid_traction_mesh_pt

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
SolidMesh * PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::Solid_traction_mesh_pt
private

Solid traction elements (prescibed external pressure on solid wall)

◆ Wall_pt

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
GeomObject * PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::Wall_pt
private

Geometric Object defining the undeformed boundary of the fluid mesh

◆ Wall_time_stepper_pt

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
Steady< 2 > * PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::Wall_time_stepper_pt
private

Steady timestepper that stores two history values.

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