Public Member Functions | Private Member Functions | Private Attributes | List of all members
CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT > Class Template Reference

Coated sphere FSI. More...

+ Inheritance diagram for CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >:

Public Member Functions

 CoatedSphereProblem ()
 Constructor: More...
 
void actions_before_newton_solve ()
 Update function (empty) More...
 
void actions_after_newton_solve ()
 Update function (empty) More...
 
void actions_before_newton_convergence_check ()
 Recompute gamma integral before checking Newton residuals. More...
 
void doc_solution (DocInfo &doc_info)
 Doc the solution. More...
 
 CoatedSphereProblem ()
 Constructor: More...
 
void actions_before_newton_solve ()
 Update function (empty) More...
 
void actions_after_newton_solve ()
 Update function (empty) More...
 
void actions_before_adapt ()
 Actions before adapt: Wipe the face meshes. More...
 
void actions_after_adapt ()
 Actions after adapt: Rebuild the face meshes. More...
 
void actions_before_newton_convergence_check ()
 Recompute gamma integral before checking Newton residuals. More...
 
void doc_solution (DocInfo &doc_info)
 Doc the solution. More...
 
- Public Member Functions inherited from oomph::Problem
virtual void debug_hook_fct (const unsigned &i)
 
void set_analytic_dparameter (double *const &parameter_pt)
 
void unset_analytic_dparameter (double *const &parameter_pt)
 
bool is_dparameter_calculated_analytically (double *const &parameter_pt)
 
void set_analytic_hessian_products ()
 
void unset_analytic_hessian_products ()
 
bool are_hessian_products_calculated_analytically ()
 
void set_pinned_values_to_zero ()
 
bool distributed () const
 
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 create_fsi_traction_elements ()
 Create FSI traction elements. More...
 
void create_helmholtz_fsi_flux_elements ()
 Create Helmholtz FSI flux elements. More...
 
void setup_interaction ()
 Setup interaction. More...
 
void create_helmholtz_DtN_elements ()
 Create DtN elements on outer boundary. More...
 
void create_fsi_traction_elements ()
 Create FSI traction elements. More...
 
void create_helmholtz_fsi_flux_elements ()
 Create Helmholtz FSI flux elements. More...
 
void setup_interaction ()
 Setup interaction. More...
 
void create_helmholtz_DtN_elements ()
 Create DtN elements on outer boundary. More...
 
void create_solid_traction_elements ()
 Create solid traction elements. More...
 
void delete_face_elements (Mesh *const &boundary_mesh_pt)
 Delete (face) elements in specified mesh. More...
 
void complete_problem_setup ()
 

Private Attributes

TwoDAnnularMesh< ELASTICITY_ELEMENT > * Solid_mesh_pt
 Pointer to solid mesh. More...
 
Mesh * FSI_traction_mesh_pt
 Pointer to mesh of FSI traction elements. More...
 
TwoDAnnularMesh< HELMHOLTZ_ELEMENT > * Helmholtz_mesh_pt
 Pointer to Helmholtz mesh. More...
 
Mesh * Helmholtz_fsi_flux_mesh_pt
 Pointer to mesh of Helmholtz FSI flux elements. More...
 
FourierDecomposedHelmholtzDtNMesh< HELMHOLTZ_ELEMENT > * Helmholtz_DtN_mesh_pt
 Pointer to mesh containing the DtN elements. More...
 
ofstream Trace_file
 Trace file. More...
 
unsigned Upper_symmetry_boundary_id
 Boundary ID of upper symmetry boundary. More...
 
unsigned Lower_symmetry_boundary_id
 Boundary ID of lower symmetry boundary. More...
 
unsigned Upper_inner_boundary_id
 Boundary ID of upper inner boundary. More...
 
unsigned Lower_inner_boundary_id
 Boundary ID of lower inner boundary. More...
 
unsigned Outer_boundary_id
 Boundary ID of outer boundary. More...
 
unsigned Rib_divider_boundary_id
 Boundary ID of rib divider. More...
 
unsigned HH_outer_boundary_id
 Boundary ID of outer boundary in Helmholtz mesh. More...
 
unsigned HH_inner_boundary_id
 Boundary ID of inner boundary in Helmholtz mesh. More...
 
unsigned HH_upper_symmetry_boundary_id
 Boundary ID of upper boundary in Helmholtz mesh. More...
 
unsigned HH_lower_symmetry_boundary_id
 Boundary ID of lower boundary in Helmholtz mesh. More...
 
TriangleMesh< ELASTICITY_ELEMENT > * Solid_mesh_pt
 Pointer to solid mesh. More...
 
Mesh * Solid_traction_mesh_pt
 Pointer to mesh of solid traction elements. More...
 
TriangleMesh< HELMHOLTZ_ELEMENT > * Helmholtz_mesh_pt
 Pointer to Helmholtz mesh. More...
 

Additional Inherited Members

- Public Types inherited from oomph::Problem
typedef void(* SpatialErrorEstimatorFctPt) (Mesh *&mesh_pt, Vector< double > &elemental_error)
 Function pointer for spatial error estimator. More...
 
typedef void(* SpatialErrorEstimatorWithDocFctPt) (Mesh *&mesh_pt, Vector< double > &elemental_error, DocInfo &doc_info)
 Function pointer for spatial error estimator with doc. More...
 
- Public Attributes inherited from oomph::Problem
bool Shut_up_in_newton_solve
 
- Static Public Attributes inherited from oomph::Problem
static bool Suppress_warning_about_actions_before_read_unstructured_meshes
 
- Protected Types inherited from oomph::Problem
enum  Assembly_method {
  Perform_assembly_using_vectors_of_pairs , Perform_assembly_using_two_vectors , Perform_assembly_using_maps , Perform_assembly_using_lists ,
  Perform_assembly_using_two_arrays
}
 Enumerated flags to determine which sparse assembly method is used. More...
 
- Protected Member Functions inherited from oomph::Problem
unsigned setup_element_count_per_dof ()
 
virtual void sparse_assemble_row_or_column_compressed (Vector< int * > &column_or_row_index, Vector< int * > &row_or_column_start, Vector< double * > &value, Vector< unsigned > &nnz, Vector< double * > &residual, bool compressed_row_flag)
 
virtual void actions_before_newton_step ()
 
virtual void actions_after_newton_step ()
 
virtual void actions_before_implicit_timestep ()
 
virtual void actions_after_implicit_timestep ()
 
virtual void actions_after_implicit_timestep_and_error_estimation ()
 
virtual void actions_before_explicit_timestep ()
 Actions that should be performed before each explicit time step. More...
 
virtual void actions_after_explicit_timestep ()
 Actions that should be performed after each explicit time step. More...
 
virtual void actions_before_read_unstructured_meshes ()
 
virtual void actions_after_read_unstructured_meshes ()
 
virtual void actions_after_change_in_global_parameter (double *const &parameter_pt)
 
virtual void actions_after_change_in_bifurcation_parameter ()
 
virtual void actions_after_parameter_increase (double *const &parameter_pt)
 
double & dof_derivative (const unsigned &i)
 
double & dof_current (const unsigned &i)
 
virtual void set_initial_condition ()
 
virtual double global_temporal_error_norm ()
 
unsigned newton_solve_continuation (double *const &parameter_pt)
 
unsigned newton_solve_continuation (double *const &parameter_pt, DoubleVector &z)
 
void calculate_continuation_derivatives (double *const &parameter_pt)
 
void calculate_continuation_derivatives (const DoubleVector &z)
 
void calculate_continuation_derivatives_fd (double *const &parameter_pt)
 
bool does_pointer_correspond_to_problem_data (double *const &parameter_pt)
 
void set_consistent_pinned_values_for_continuation ()
 
- Protected Attributes 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 ELASTICITY_ELEMENT, class HELMHOLTZ_ELEMENT>
class CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >

Coated sphere FSI.

Constructor & Destructor Documentation

◆ CoatedSphereProblem() [1/2]

template<class ELASTICITY_ELEMENT , class HELMHOLTZ_ELEMENT >
CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::CoatedSphereProblem

Constructor:

190 {
191 
192  // Parameters for meshes
193  bool periodic=false;
194  double azimuthal_fraction_of_coating=0.5;
195  double phi=0.5*MathematicalConstants::Pi;
196 
197  // Solid mesh
198  //-----------
199  // Number of elements in azimuthal direction
200  unsigned ntheta_solid=10*Global_Parameters::El_multiplier;
201 
202  // Number of elements in radial direction
203  unsigned nr_solid=3*Global_Parameters::El_multiplier;
204 
205  // Innermost radius for solid mesh
206  double a=1.0-Global_Parameters::H_coating;
207 
208  // Build solid mesh
209  Solid_mesh_pt = new
210  TwoDAnnularMesh<ELASTICITY_ELEMENT>(periodic,azimuthal_fraction_of_coating,
211  ntheta_solid,nr_solid,a,
212  Global_Parameters::H_coating,phi);
213 
214 
215  // Helmholtz mesh
216  //---------------
217 
218  // Number of elements in azimuthal direction in Helmholtz mesh
219  unsigned ntheta_helmholtz=11*Global_Parameters::El_multiplier;
220 
221  // Number of elements in radial direction in Helmholtz mesh
222  unsigned nr_helmholtz=3*Global_Parameters::El_multiplier;
223 
224  // Innermost radius of Helmholtz mesh
225  a=1.0;
226 
227  // Thickness of Helmholtz mesh
228  double h_thick_helmholtz=Global_Parameters::Outer_radius-a;
229 
230  // Build mesh
231  Helmholtz_mesh_pt = new TwoDAnnularMesh<HELMHOLTZ_ELEMENT>
232  (periodic,azimuthal_fraction_of_coating,
233  ntheta_helmholtz,nr_helmholtz,a,h_thick_helmholtz,phi);
234 
235 
236  // Create mesh for DtN elements on outer boundary
237  unsigned nfourier=20;
238  Helmholtz_DtN_mesh_pt=
239  new FourierDecomposedHelmholtzDtNMesh<HELMHOLTZ_ELEMENT>(
240  Global_Parameters::Outer_radius,nfourier);
241 
242  // Complete the solid problem setup to make the elements fully functional
243  unsigned nel=Solid_mesh_pt->nelement();
244  for (unsigned e=0;e<nel;e++)
245  {
246  // Cast to a bulk element
247  ELASTICITY_ELEMENT* el_pt=dynamic_cast<ELASTICITY_ELEMENT*>(
248  Solid_mesh_pt->element_pt(e));
249 
250  // Set the pointer to Fourier wavenumber
251  el_pt->fourier_wavenumber_pt() = &Global_Parameters::Fourier_wavenumber;
252 
253  // Set the pointer to Poisson's ratio
254  el_pt->nu_pt() = &Global_Parameters::Nu;
255 
256  // Set the pointer to square of the angular frequency
257  el_pt->omega_sq_pt() = &Global_Parameters::Omega_sq;
258  }
259 
260  // Complete the build of all Helmholtz elements so they are fully functional
261  unsigned n_element = Helmholtz_mesh_pt->nelement();
262  for(unsigned i=0;i<n_element;i++)
263  {
264  // Upcast from GeneralsedElement to the present element
265  HELMHOLTZ_ELEMENT *el_pt = dynamic_cast<HELMHOLTZ_ELEMENT*>(
266  Helmholtz_mesh_pt->element_pt(i));
267 
268  //Set the k_squared pointer
269  el_pt->k_squared_pt()=&Global_Parameters::K_squared;
270 
271  // Set pointer to Fourier wave number
272  el_pt->fourier_wavenumber_pt()=&Global_Parameters::Fourier_wavenumber;
273  }
274 
275  // Output meshes and their boundaries so far so we can double
276  // check the boundary enumeration
277  Solid_mesh_pt->output("solid_mesh.dat");
278  Helmholtz_mesh_pt->output("helmholtz_mesh.dat");
279  Solid_mesh_pt->output_boundaries("solid_mesh_boundary.dat");
280  Helmholtz_mesh_pt->output_boundaries("helmholtz_mesh_boundary.dat");
281 
282  // Create FaceElement meshes for boundary conditions
283  //--------------------------------------------------
284 
285  // Construct the fsi traction element mesh
286  FSI_traction_mesh_pt=new Mesh;
287  create_fsi_traction_elements();
288 
289  // Construct the Helmholtz fsi flux element mesh
290  Helmholtz_fsi_flux_mesh_pt=new Mesh;
291  create_helmholtz_fsi_flux_elements();
292 
293  // Create DtN elements
294  create_helmholtz_DtN_elements();
295 
296 
297  // Combine sub meshes
298  //-------------------
299  add_sub_mesh(Solid_mesh_pt);
300  add_sub_mesh(FSI_traction_mesh_pt);
301  add_sub_mesh(Helmholtz_mesh_pt);
302  add_sub_mesh(Helmholtz_fsi_flux_mesh_pt);
303  add_sub_mesh(Helmholtz_DtN_mesh_pt);
304 
305  // Build the Problem's global mesh from its various sub-meshes
306  build_global_mesh();
307 
308 
309  // Solid boundary conditions:
310  //---------------------------
311 
312  // Pin the solid inner boundary (boundary 0) in all directions
313  unsigned b=0;
314  unsigned n_node = Solid_mesh_pt->nboundary_node(b);
315 
316  Vector<std::complex<double> > u(2);
317  Vector<double> x(2);
318 
319  //Loop over the nodes to pin and assign boundary displacements on
320  //solid boundary
321  for(unsigned i=0;i<n_node;i++)
322  {
323  Node* nod_pt=Solid_mesh_pt->boundary_node_pt(b,i);
324  nod_pt->pin(0);
325  nod_pt->pin(1);
326  nod_pt->pin(2);
327  nod_pt->pin(3);
328  nod_pt->pin(4);
329  nod_pt->pin(5);
330 
331  // Assign prescribed displacements
332  x[0]=nod_pt->x(0);
333  x[1]=nod_pt->x(1);
334  Global_Parameters::solid_boundary_displacement(x,u);
335 
336  // Real part of radial displacement
337  nod_pt->set_value(0,u[0].real());
338  // Real part of axial displacement
339  nod_pt->set_value(1,u[1].real());
340  // Real part of azimuthal displacement
341  nod_pt->set_value(2,0.0);
342  // Imag part of radial displacement
343  nod_pt->set_value(3,u[0].imag());
344  // Imag part of axial displacement
345  nod_pt->set_value(4,u[1].imag());
346  // Imag part of azimuthal displacement
347  nod_pt->set_value(5,0.0);
348  }
349 
350  // Vertical Symmetry boundary (r=0 and z<0)
351  {
352  unsigned ibound=1;
353  {
354  unsigned num_nod= Solid_mesh_pt->nboundary_node(ibound);
355  for (unsigned inod=0;inod<num_nod;inod++)
356  {
357  // Get pointer to node
358  Node* nod_pt=Solid_mesh_pt->boundary_node_pt(ibound,inod);
359 
360  // Pin radial displacement (u_0 (real) and u_3 (imag))
361  nod_pt->pin(0);
362  nod_pt->set_value(0,0.0);
363  nod_pt->pin(3);
364  nod_pt->set_value(3,0.0);
365 
366  // Pin azimuthal displacement (u_2 (real) and u_5 (imag))
367  nod_pt->pin(2);
368  nod_pt->set_value(2,0.0);
369  nod_pt->pin(5);
370  nod_pt->set_value(5,0.0);
371  }
372  }
373  }
374 
375 
376  // Vertical Symmetry boundary (r=0 and z>0)
377  {
378  unsigned ibound=3;
379  {
380  unsigned num_nod= Solid_mesh_pt->nboundary_node(ibound);
381  for (unsigned inod=0;inod<num_nod;inod++)
382  {
383  // Get pointer to node
384  Node* nod_pt=Solid_mesh_pt->boundary_node_pt(ibound,inod);
385 
386  // Pin radial displacement (u_0 (real) and u_3 (imag))
387  nod_pt->pin(0);
388  nod_pt->set_value(0,0.0);
389  nod_pt->pin(3);
390  nod_pt->set_value(3,0.0);
391 
392  // Pin azimuthal displacement (u_2 (real) and u_5 (imag))
393  nod_pt->pin(2);
394  nod_pt->set_value(2,0.0);
395  nod_pt->pin(5);
396  nod_pt->set_value(5,0.0);
397  }
398  }
399  } // done sym bc
400 
401  // Setup fluid-structure interaction
402  //----------------------------------
403  setup_interaction();
404 
405  // Open trace file
406  char filename[100];
407  sprintf(filename,"%s/trace.dat",Global_Parameters::Directory.c_str());
408  Trace_file.open(filename);
409 
410  // Setup equation numbering scheme
411  cout <<"Number of equations: " << assign_eqn_numbers() << std::endl;
412 
413 }//end_of_constructor
imag
AnnoyingScalar imag(const AnnoyingScalar &)
Definition: AnnoyingScalar.h:132
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
CoatedSphereProblem::create_fsi_traction_elements
void create_fsi_traction_elements()
Create FSI traction elements.
Definition: fourier_decomposed_acoustic_fsi.cc:506
CoatedSphereProblem::FSI_traction_mesh_pt
Mesh * FSI_traction_mesh_pt
Pointer to mesh of FSI traction elements.
Definition: fourier_decomposed_acoustic_fsi.cc:167
CoatedSphereProblem::Solid_mesh_pt
TwoDAnnularMesh< ELASTICITY_ELEMENT > * Solid_mesh_pt
Pointer to solid mesh.
Definition: fourier_decomposed_acoustic_fsi.cc:164
CoatedSphereProblem::Helmholtz_mesh_pt
TwoDAnnularMesh< HELMHOLTZ_ELEMENT > * Helmholtz_mesh_pt
Pointer to Helmholtz mesh.
Definition: fourier_decomposed_acoustic_fsi.cc:170
CoatedSphereProblem::Trace_file
ofstream Trace_file
Trace file.
Definition: fourier_decomposed_acoustic_fsi.cc:179
CoatedSphereProblem::create_helmholtz_DtN_elements
void create_helmholtz_DtN_elements()
Create DtN elements on outer boundary.
Definition: fourier_decomposed_acoustic_fsi.cc:422
CoatedSphereProblem::create_helmholtz_fsi_flux_elements
void create_helmholtz_fsi_flux_elements()
Create Helmholtz FSI flux elements.
Definition: fourier_decomposed_acoustic_fsi.cc:550
CoatedSphereProblem::Helmholtz_DtN_mesh_pt
FourierDecomposedHelmholtzDtNMesh< HELMHOLTZ_ELEMENT > * Helmholtz_DtN_mesh_pt
Pointer to mesh containing the DtN elements.
Definition: fourier_decomposed_acoustic_fsi.cc:176
CoatedSphereProblem::setup_interaction
void setup_interaction()
Setup interaction.
Definition: fourier_decomposed_acoustic_fsi.cc:463
CoatedSphereProblem::Helmholtz_fsi_flux_mesh_pt
Mesh * Helmholtz_fsi_flux_mesh_pt
Pointer to mesh of Helmholtz FSI flux elements.
Definition: fourier_decomposed_acoustic_fsi.cc:173
oomph::Data::pin
void pin(const unsigned &i)
Pin the i-th stored variable.
Definition: nodes.h:385
oomph::Data::set_value
void set_value(const unsigned &i, const double &value_)
Definition: nodes.h:271
oomph::Mesh
Definition: mesh.h:67
oomph::Mesh::nboundary_node
unsigned long nboundary_node(const unsigned &ibound) const
Return number of nodes on a particular boundary.
Definition: mesh.h:833
oomph::Mesh::element_pt
GeneralisedElement *& element_pt(const unsigned long &e)
Return pointer to element e.
Definition: mesh.h:448
oomph::Mesh::output
void output(std::ostream &outfile)
Output for all elements.
Definition: mesh.cc:2027
oomph::Mesh::boundary_node_pt
Node *& boundary_node_pt(const unsigned &b, const unsigned &n)
Return pointer to node n on boundary b.
Definition: mesh.h:493
oomph::Mesh::nelement
unsigned long nelement() const
Return number of elements in the mesh.
Definition: mesh.h:590
oomph::Mesh::output_boundaries
void output_boundaries(std::ostream &outfile)
Output the nodes on the boundaries (into separate tecplot zones)
Definition: mesh.cc:1064
oomph::Node
Definition: nodes.h:906
oomph::Node::x
double & x(const unsigned &i)
Return the i-th nodal coordinate.
Definition: nodes.h:1060
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::Vector
Definition: oomph-lib/src/generic/Vector.h:58
real
float real
Definition: datatypes.h:10
a
const Scalar * a
Definition: level2_cplx_impl.h:32
BiharmonicTestFunctions2::Pi
double Pi
Definition: two_d_biharmonic.cc:235
Global_Parameters::Nu
double Nu
Define Poisson's ratio Nu.
Definition: axisym_linear_elasticity/cylinder/cylinder.cc:46
Global_Parameters::Directory
string Directory
Output directory.
Definition: acoustic_fsi.cc:101
Global_Parameters::El_multiplier
unsigned El_multiplier
Multiplier for number of elements.
Definition: acoustic_fsi.cc:104
Global_Parameters::Outer_radius
double Outer_radius
Radius of outer boundary of Helmholtz domain.
Definition: acoustic_fsi.cc:55
Global_Parameters::K_squared
double K_squared
Square of wavenumber for the Helmholtz equation.
Definition: acoustic_fsi.cc:52
Global_Parameters::solid_boundary_displacement
void solid_boundary_displacement(const Vector< double > &x, Vector< std::complex< double > > &u)
Displacement field on inner boundary of solid.
Definition: acoustic_fsi.cc:86
Global_Parameters::Fourier_wavenumber
int Fourier_wavenumber
Define azimuthal Fourier wavenumber.
Definition: fourier_decomposed_acoustic_fsi.cc:76
Global_Parameters::H_coating
double H_coating
Non-dim thickness of elastic coating.
Definition: acoustic_fsi.cc:61
Global_Parameters::Omega_sq
double Omega_sq
Square of the frequency of the time dependence.
Definition: axisym_linear_elasticity/cylinder/cylinder.cc:56
MergeRestartFiles.filename
string filename
Definition: MergeRestartFiles.py:39
plotDoE.x
list x
Definition: plotDoE.py:28

References a, b, Global_Parameters::Directory, e(), Global_Parameters::El_multiplier, MergeRestartFiles::filename, Global_Parameters::Fourier_wavenumber, Global_Parameters::H_coating, i, imag(), Global_Parameters::K_squared, Global_Parameters::Nu, Global_Parameters::Omega_sq, Global_Parameters::Outer_radius, oomph::MathematicalConstants::Pi, oomph::Data::pin(), oomph::Data::set_value(), Global_Parameters::solid_boundary_displacement(), oomph::Problem_Parameter::Trace_file, plotDoE::x, and oomph::Node::x().

◆ CoatedSphereProblem() [2/2]

template<class ELASTICITY_ELEMENT , class HELMHOLTZ_ELEMENT >
CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::CoatedSphereProblem ( )

Constructor:

Member Function Documentation

◆ actions_after_adapt()

template<class ELASTICITY_ELEMENT , class HELMHOLTZ_ELEMENT >
void CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::actions_after_adapt
virtual

Actions after adapt: Rebuild the face meshes.

Actions after adapt: Rebuild the meshes of face elements.

Reimplemented from oomph::Problem.

844 {
845  // Complete problem setup
846  complete_problem_setup();
847 
848  // Construct the solid traction elements
849  create_solid_traction_elements();
850 
851  // Create fsi traction elements from all elements that are
852  // adjacent to FSI boundaries and add them to surface meshes
853  create_fsi_traction_elements();
854 
855  // Create Helmholtz fsi flux elements
856  create_helmholtz_fsi_flux_elements();
857 
858  // Create DtN elements from all elements that are
859  // adjacent to the outer boundary of Helmholtz mesh
860  create_helmholtz_DtN_elements();
861 
862  // Setup interaction
863  setup_interaction();
864 
865  // Rebuild the Problem's global mesh from its various sub-meshes
866  rebuild_global_mesh();
867 
868 }// end of actions_after_adapt
CoatedSphereProblem::complete_problem_setup
void complete_problem_setup()
Definition: unstructured_fourier_decomposed_acoustic_fsi.cc:878
CoatedSphereProblem::create_solid_traction_elements
void create_solid_traction_elements()
Create solid traction elements.
Definition: unstructured_fourier_decomposed_acoustic_fsi.cc:1186
oomph::Problem::rebuild_global_mesh
void rebuild_global_mesh()
Definition: problem.cc:1533

◆ actions_after_newton_solve() [1/2]

template<class ELASTICITY_ELEMENT , class HELMHOLTZ_ELEMENT >
void CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::actions_after_newton_solve ( )
inlinevirtual

Update function (empty)

Reimplemented from oomph::Problem.

138 {}

◆ actions_after_newton_solve() [2/2]

template<class ELASTICITY_ELEMENT , class HELMHOLTZ_ELEMENT >
void CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::actions_after_newton_solve ( )
inlinevirtual

Update function (empty)

Reimplemented from oomph::Problem.

192 {}

◆ actions_before_adapt()

template<class ELASTICITY_ELEMENT , class HELMHOLTZ_ELEMENT >
void CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::actions_before_adapt
virtual

Actions before adapt: Wipe the face meshes.

Actions before adapt: Wipe the meshes face elements.

Reimplemented from oomph::Problem.

818 {
819  // Kill the solid traction elements and wipe surface mesh
820  delete_face_elements(Solid_traction_mesh_pt);
821 
822  // Kill the fsi traction elements and wipe surface mesh
823  delete_face_elements(FSI_traction_mesh_pt);
824 
825  // Kill Helmholtz FSI flux elements
826  delete_face_elements(Helmholtz_fsi_flux_mesh_pt);
827 
828  // Kill Helmholtz BC elements
829  delete_face_elements(Helmholtz_DtN_mesh_pt);
830 
831  // Rebuild the Problem's global mesh from its various sub-meshes
832  rebuild_global_mesh();
833 
834 }// end of actions_before_adapt
CoatedSphereProblem::delete_face_elements
void delete_face_elements(Mesh *const &boundary_mesh_pt)
Delete (face) elements in specified mesh.
Definition: unstructured_fourier_decomposed_acoustic_fsi.cc:992
CoatedSphereProblem::Solid_traction_mesh_pt
Mesh * Solid_traction_mesh_pt
Pointer to mesh of solid traction elements.
Definition: unstructured_fourier_decomposed_acoustic_fsi.cc:276

◆ actions_before_newton_convergence_check() [1/2]

template<class ELASTICITY_ELEMENT , class HELMHOLTZ_ELEMENT >
void CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::actions_before_newton_convergence_check ( )
inlinevirtual

Recompute gamma integral before checking Newton residuals.

Reimplemented from oomph::Problem.

142  {
143  Helmholtz_DtN_mesh_pt->setup_gamma();
144  }
oomph::FourierDecomposedHelmholtzDtNMesh::setup_gamma
void setup_gamma()
of the mesh's constituent elements
Definition: fourier_decomposed_helmholtz_bc_elements.h:936

◆ actions_before_newton_convergence_check() [2/2]

template<class ELASTICITY_ELEMENT , class HELMHOLTZ_ELEMENT >
void CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::actions_before_newton_convergence_check ( )
inlinevirtual

Recompute gamma integral before checking Newton residuals.

Reimplemented from oomph::Problem.

202  {
203  Helmholtz_DtN_mesh_pt->setup_gamma();
204  }

◆ actions_before_newton_solve() [1/2]

template<class ELASTICITY_ELEMENT , class HELMHOLTZ_ELEMENT >
void CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::actions_before_newton_solve ( )
inlinevirtual

Update function (empty)

Reimplemented from oomph::Problem.

135 {}

◆ actions_before_newton_solve() [2/2]

template<class ELASTICITY_ELEMENT , class HELMHOLTZ_ELEMENT >
void CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::actions_before_newton_solve ( )
inlinevirtual

Update function (empty)

Reimplemented from oomph::Problem.

189 {}

◆ complete_problem_setup()

template<class ELASTICITY_ELEMENT , class HELMHOLTZ_ELEMENT >
void CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::complete_problem_setup
private

Complete problem setup: Apply boundary conditions and set physical properties

879 {
880 
881  // Solid boundary conditions:
882  //---------------------------
883  // Pin real and imag part of horizontal and azimuthal displacement components
884  //---------------------------------------------------------------------------
885  // on vertical boundaries
886  //-----------------------
887  {
888  //Loop over the nodes to pin and assign boundary displacements on
889  //solid boundary
890  unsigned n_node = Solid_mesh_pt->nboundary_node(Upper_symmetry_boundary_id);
891  for(unsigned i=0;i<n_node;i++)
892  {
893  Node* nod_pt=Solid_mesh_pt->boundary_node_pt(Upper_symmetry_boundary_id,i);
894 
895  // Real part of r-displacement
896  nod_pt->pin(0);
897  nod_pt->set_value(0,0.0);
898 
899  // Imag part of r-displacement
900  nod_pt->pin(3);
901  nod_pt->set_value(3,0.0);
902 
903  // Real part of phi-displacement
904  nod_pt->pin(2);
905  nod_pt->set_value(2,0.0);
906 
907  // Imag part of phi-displacement
908  nod_pt->pin(5);
909  nod_pt->set_value(5,0.0);
910  }
911  }
912  {
913  //Loop over the nodes to pin and assign boundary displacements on
914  //solid boundary
915  unsigned n_node = Solid_mesh_pt->nboundary_node(Lower_symmetry_boundary_id);
916  for(unsigned i=0;i<n_node;i++)
917  {
918  Node* nod_pt=Solid_mesh_pt->boundary_node_pt(Lower_symmetry_boundary_id,i);
919 
920  // Real part of r-displacement
921  nod_pt->pin(0);
922  nod_pt->set_value(0,0.0);
923 
924  // Imag part of r-displacement
925  nod_pt->pin(3);
926  nod_pt->set_value(3,0.0);
927 
928  // Real part of phi-displacement
929  nod_pt->pin(2);
930  nod_pt->set_value(2,0.0);
931 
932  // Imag part of phi-displacement
933  nod_pt->pin(5);
934  nod_pt->set_value(5,0.0);
935  }
936  }
937 
938 
939  //Assign the physical properties to the elements
940  //----------------------------------------------
941  unsigned nreg=Solid_mesh_pt->nregion();
942  for (unsigned r=0;r<nreg;r++)
943  {
944  unsigned nel=Solid_mesh_pt->nregion_element(r);
945  for (unsigned e=0;e<nel;e++)
946  {
947  //Cast to a solid element
948  ELASTICITY_ELEMENT *el_pt =
949  dynamic_cast<ELASTICITY_ELEMENT*>(Solid_mesh_pt->
950  region_element_pt(r,e));
951 
952  // Set the pointer to Fourier wavenumber
953  el_pt->fourier_wavenumber_pt() = &Global_Parameters::Fourier_wavenumber;
954 
955  // Set the pointer to Poisson's ratio
956  el_pt->nu_pt() = &Global_Parameters::Nu;
957 
958  // Square of non-dim frequency
959  el_pt->omega_sq_pt()= &Global_Parameters::Omega_sq[r];
960 
961  // Set the pointer to non-dim Young's modulus
962  el_pt->youngs_modulus_pt() = &Global_Parameters::E[r];
963 
964  }
965  }
966 
967 
968  // Complete the build of all Helmholtz elements so they are fully functional
969  unsigned n_element = Helmholtz_mesh_pt->nelement();
970  for(unsigned i=0;i<n_element;i++)
971  {
972  // Upcast from GeneralsedElement to the present element
973  HELMHOLTZ_ELEMENT *el_pt = dynamic_cast<HELMHOLTZ_ELEMENT*>(
974  Helmholtz_mesh_pt->element_pt(i));
975 
976  //Set the k_squared pointer
977  el_pt->k_squared_pt()=&Global_Parameters::K_squared;
978 
979  // Set pointer to Fourier wave number
980  el_pt->fourier_wavenumber_pt()=&Global_Parameters::Fourier_wavenumber;
981  }
982 
983 }
CoatedSphereProblem::Lower_symmetry_boundary_id
unsigned Lower_symmetry_boundary_id
Boundary ID of lower symmetry boundary.
Definition: unstructured_fourier_decomposed_acoustic_fsi.cc:236
CoatedSphereProblem::Upper_symmetry_boundary_id
unsigned Upper_symmetry_boundary_id
Boundary ID of upper symmetry boundary.
Definition: unstructured_fourier_decomposed_acoustic_fsi.cc:233
Global_Parameters::E
double E
Define the non-dimensional Young's modulus.
Definition: axisym_linear_elasticity/cylinder/cylinder.cc:49
UniformPSDSelfTest.r
r
Definition: UniformPSDSelfTest.py:20

References e(), Global_Parameters::E, Global_Parameters::Fourier_wavenumber, i, Global_Parameters::K_squared, Global_Parameters::Nu, Global_Parameters::Omega_sq, oomph::Data::pin(), UniformPSDSelfTest::r, and oomph::Data::set_value().

◆ create_fsi_traction_elements() [1/2]

template<class ELASTICITY_ELEMENT , class HELMHOLTZ_ELEMENT >
void CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::create_fsi_traction_elements
private

Create FSI traction elements.

Create fsi traction elements.

507 {
508  // We're on boundary 2 of the solid mesh
509  unsigned b=2;
510 
511  // How many bulk elements are adjacent to boundary b?
512  unsigned n_element = Solid_mesh_pt->nboundary_element(b);
513 
514  // Loop over the bulk elements adjacent to boundary b
515  for(unsigned e=0;e<n_element;e++)
516  {
517  // Get pointer to the bulk element that is adjacent to boundary b
518  ELASTICITY_ELEMENT* bulk_elem_pt = dynamic_cast<ELASTICITY_ELEMENT*>(
519  Solid_mesh_pt->boundary_element_pt(b,e));
520 
521  //Find the index of the face of element e along boundary b
522  int face_index = Solid_mesh_pt->face_index_at_boundary(b,e);
523 
524  // Create element
525  FourierDecomposedTimeHarmonicLinElastLoadedByHelmholtzPressureBCElement
526  <ELASTICITY_ELEMENT,HELMHOLTZ_ELEMENT>* el_pt=
527  new FourierDecomposedTimeHarmonicLinElastLoadedByHelmholtzPressureBCElement
528  <ELASTICITY_ELEMENT,HELMHOLTZ_ELEMENT>(bulk_elem_pt,
529  face_index);
530  // Add to mesh
531  FSI_traction_mesh_pt->add_element_pt(el_pt);
532 
533  // Associate element with bulk boundary (to allow it to access
534  // the boundary coordinates in the bulk mesh)
535  el_pt->set_boundary_number_in_bulk_mesh(b);
536 
537  // Set FSI parameter
538  el_pt->q_pt()=&Global_Parameters::Q;
539  }
540 
541 } // end_of_create_fsi_traction_elements
oomph::FourierDecomposedTimeHarmonicLinElastLoadedByHelmholtzPressureBCElement
Definition: fourier_decomposed_helmholtz_time_harmonic_linear_elasticity_interaction.h:51
oomph::Mesh::face_index_at_boundary
int face_index_at_boundary(const unsigned &b, const unsigned &e) const
Definition: mesh.h:896
oomph::Mesh::nboundary_element
unsigned nboundary_element(const unsigned &b) const
Return number of finite elements that are adjacent to boundary b.
Definition: mesh.h:878
oomph::Mesh::boundary_element_pt
FiniteElement * boundary_element_pt(const unsigned &b, const unsigned &e) const
Return pointer to e-th finite element on boundary b.
Definition: mesh.h:840
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
Global_Parameters::Q
double Q
FSI parameter.
Definition: acoustic_fsi.cc:58

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

◆ create_fsi_traction_elements() [2/2]

template<class ELASTICITY_ELEMENT , class HELMHOLTZ_ELEMENT >
void CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::create_fsi_traction_elements ( )
private

Create FSI traction elements.

◆ create_helmholtz_DtN_elements() [1/2]

template<class ELASTICITY_ELEMENT , class HELMHOLTZ_ELEMENT >
void CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::create_helmholtz_DtN_elements
private

Create DtN elements on outer boundary.

Create BC elements on outer boundary.

423 {
424  // Outer boundary is boundary 2:
425  unsigned b=2;
426 
427  // Loop over the bulk elements adjacent to boundary b?
428  unsigned n_element = Helmholtz_mesh_pt->nboundary_element(b);
429  for(unsigned e=0;e<n_element;e++)
430  {
431  // Get pointer to the bulk element that is adjacent to boundary b
432  HELMHOLTZ_ELEMENT* bulk_elem_pt = dynamic_cast<HELMHOLTZ_ELEMENT*>(
433  Helmholtz_mesh_pt->boundary_element_pt(b,e));
434 
435  //Find the index of the face of element e along boundary b
436  int face_index = Helmholtz_mesh_pt->face_index_at_boundary(b,e);
437 
438  // Build the corresponding DtN element
439  FourierDecomposedHelmholtzDtNBoundaryElement<HELMHOLTZ_ELEMENT>*
440  flux_element_pt = new
441  FourierDecomposedHelmholtzDtNBoundaryElement<HELMHOLTZ_ELEMENT>
442  (bulk_elem_pt,face_index);
443 
444  //Add the flux boundary element to the helmholtz_DtN_mesh
445  Helmholtz_DtN_mesh_pt->add_element_pt(flux_element_pt);
446 
447  // Set pointer to the mesh that contains all the boundary condition
448  // elements on this boundary
449  flux_element_pt->set_outer_boundary_mesh_pt(Helmholtz_DtN_mesh_pt);
450  }
451 
452 } // end_of_create_outer_bc_elements
oomph::FourierDecomposedHelmholtzDtNBoundaryElement
Definition: fourier_decomposed_helmholtz_bc_elements.h:422
oomph::FourierDecomposedHelmholtzDtNBoundaryElement::set_outer_boundary_mesh_pt
void set_outer_boundary_mesh_pt(FourierDecomposedHelmholtzDtNMesh< ELEMENT > *mesh_pt)
Set mesh of all DtN boundary condition elements.
Definition: fourier_decomposed_helmholtz_bc_elements.h:472

References b, e(), and oomph::FourierDecomposedHelmholtzDtNBoundaryElement< ELEMENT >::set_outer_boundary_mesh_pt().

◆ create_helmholtz_DtN_elements() [2/2]

template<class ELASTICITY_ELEMENT , class HELMHOLTZ_ELEMENT >
void CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::create_helmholtz_DtN_elements ( )
private

Create DtN elements on outer boundary.

◆ create_helmholtz_fsi_flux_elements() [1/2]

template<class ELASTICITY_ELEMENT , class HELMHOLTZ_ELEMENT >
void CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::create_helmholtz_fsi_flux_elements
private

Create Helmholtz FSI flux elements.

Create Helmholtz fsi flux elements.

551 {
552 
553  // Attach to inner boundary of Helmholtz mesh (0)
554  unsigned b=0;
555 
556  // How many bulk elements are adjacent to boundary b?
557  unsigned n_element = Helmholtz_mesh_pt->nboundary_element(b);
558 
559  // Loop over the bulk elements adjacent to boundary b
560  for(unsigned e=0;e<n_element;e++)
561  {
562  // Get pointer to the bulk element that is adjacent to boundary b
563  HELMHOLTZ_ELEMENT* bulk_elem_pt = dynamic_cast<HELMHOLTZ_ELEMENT*>(
564  Helmholtz_mesh_pt->boundary_element_pt(b,e));
565 
566  //Find the index of the face of element e along boundary b
567  int face_index = Helmholtz_mesh_pt->face_index_at_boundary(b,e);
568 
569  // Create element
570  FourierDecomposedHelmholtzFluxFromNormalDisplacementBCElement
571  <HELMHOLTZ_ELEMENT,ELASTICITY_ELEMENT>* el_pt=
572  new FourierDecomposedHelmholtzFluxFromNormalDisplacementBCElement
573  <HELMHOLTZ_ELEMENT,ELASTICITY_ELEMENT>(bulk_elem_pt,
574  face_index);
575 
576  // Add to mesh
577  Helmholtz_fsi_flux_mesh_pt->add_element_pt(el_pt);
578 
579  // Associate element with bulk boundary (to allow it to access
580  // the boundary coordinates in the bulk mesh)
581  el_pt->set_boundary_number_in_bulk_mesh(b);
582  }
583 
584 } // end_of_create_helmholtz_fsi_flux_elements
oomph::FourierDecomposedHelmholtzFluxFromNormalDisplacementBCElement
Definition: fourier_decomposed_helmholtz_time_harmonic_linear_elasticity_interaction.h:455

References b, e(), and oomph::FaceElement::set_boundary_number_in_bulk_mesh().

◆ create_helmholtz_fsi_flux_elements() [2/2]

template<class ELASTICITY_ELEMENT , class HELMHOLTZ_ELEMENT >
void CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::create_helmholtz_fsi_flux_elements ( )
private

Create Helmholtz FSI flux elements.

◆ create_solid_traction_elements()

template<class ELASTICITY_ELEMENT , class HELMHOLTZ_ELEMENT >
void CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::create_solid_traction_elements
private

Create solid traction elements.

1187 {
1188  // Loop over pressure loaded boundaries
1189  unsigned b=0;
1190  unsigned nb=3;
1191  for (unsigned i=0;i<nb;i++)
1192  {
1193  switch(i)
1194  {
1195  case 0:
1196  b=Upper_inner_boundary_id;
1197  break;
1198 
1199  case 1:
1200  b=Lower_inner_boundary_id;
1201  break;
1202 
1203  case 2:
1204  b=Rib_divider_boundary_id;
1205  break;
1206  }
1207 
1208  // We're attaching face elements to region 0
1209  unsigned r=0;
1210 
1211  // How many bulk elements are adjacent to boundary b?
1212  unsigned n_element = Solid_mesh_pt->nboundary_element_in_region(b,r);
1213 
1214  // Loop over the bulk elements adjacent to boundary b
1215  for(unsigned e=0;e<n_element;e++)
1216  {
1217  // Get pointer to the bulk element that is adjacent to boundary b
1218  ELASTICITY_ELEMENT* bulk_elem_pt = dynamic_cast<ELASTICITY_ELEMENT*>(
1219  Solid_mesh_pt->boundary_element_in_region_pt(b,r,e));
1220 
1221  //Find the index of the face of element e along boundary b
1222  int face_index = Solid_mesh_pt->face_index_at_boundary_in_region(b,r,e);
1223 
1224  // Create element
1225  TimeHarmonicFourierDecomposedLinearElasticityTractionElement
1226  <ELASTICITY_ELEMENT>* el_pt=
1227  new TimeHarmonicFourierDecomposedLinearElasticityTractionElement
1228  <ELASTICITY_ELEMENT>(bulk_elem_pt,face_index);
1229 
1230  // Add to mesh
1231  Solid_traction_mesh_pt->add_element_pt(el_pt);
1232 
1233  // Associate element with bulk boundary (to allow it to access
1234  // the boundary coordinates in the bulk mesh)
1235  el_pt->set_boundary_number_in_bulk_mesh(b);
1236 
1237  //Set the traction function
1238  el_pt->traction_fct_pt() = Global_Parameters::pressure_load;
1239  }
1240  }
1241 } // end of create_traction_elements
CoatedSphereProblem::Rib_divider_boundary_id
unsigned Rib_divider_boundary_id
Boundary ID of rib divider.
Definition: unstructured_fourier_decomposed_acoustic_fsi.cc:248
CoatedSphereProblem::Upper_inner_boundary_id
unsigned Upper_inner_boundary_id
Boundary ID of upper inner boundary.
Definition: unstructured_fourier_decomposed_acoustic_fsi.cc:239
CoatedSphereProblem::Lower_inner_boundary_id
unsigned Lower_inner_boundary_id
Boundary ID of lower inner boundary.
Definition: unstructured_fourier_decomposed_acoustic_fsi.cc:242
oomph::TimeHarmonicFourierDecomposedLinearElasticityTractionElement
Definition: time_harmonic_fourier_decomposed_linear_elasticity_traction_elements.h:79
nb
int nb
Definition: level2_impl.h:286
Global_Parameters::pressure_load
void pressure_load(const Vector< double > &x, const Vector< double > &n, Vector< std::complex< double > > &traction)
Pressure load (real and imag part)
Definition: unstructured_acoustic_fsi.cc:151

References b, e(), i, nb, Global_Parameters::pressure_load(), UniformPSDSelfTest::r, and oomph::FaceElement::set_boundary_number_in_bulk_mesh().

◆ delete_face_elements()

template<class ELASTICITY_ELEMENT , class HELMHOLTZ_ELEMENT >
void CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::delete_face_elements ( Mesh *const &  boundary_mesh_pt)
private

Delete (face) elements in specified mesh.

Delete face elements and wipe the mesh.

993 {
994  // How many surface elements are in the surface mesh
995  unsigned n_element = boundary_mesh_pt->nelement();
996 
997  // Loop over the surface elements
998  for(unsigned e=0;e<n_element;e++)
999  {
1000  // Kill surface element
1001  delete boundary_mesh_pt->element_pt(e);
1002  }
1003 
1004  // Wipe the mesh
1005  boundary_mesh_pt->flush_element_and_node_storage();
1006 
1007 } // end of delete_face_elements
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().

◆ doc_solution() [1/2]

template<class ELASTICITY_ELEMENT , class HELMHOLTZ_ELEMENT >
void CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::doc_solution ( DocInfo &  doc_info)

Doc the solution.

594 {
595 
596  // Doc parameters
597  oomph_info << "Writing result for step " << doc_info.number()
598  << ". Parameters: "<< std::endl;
599  oomph_info << "Fourier mode number : N = "
600  << Global_Parameters::Fourier_wavenumber << std::endl;
601  oomph_info << "FSI parameter : Q = " << Global_Parameters::Q << std::endl;
602  oomph_info << "Fluid outer radius : R = " << Global_Parameters::Outer_radius
603  << std::endl;
604  oomph_info << "Fluid wavenumber : k^2 = " << Global_Parameters::K_squared
605  << std::endl;
606  oomph_info << "Solid wavenumber : Omega_sq = " << Global_Parameters::Omega_sq
607  << std::endl << std::endl;
608 
609 
610  ofstream some_file,some_file2;
611  char filename[100];
612 
613  // Number of plot points
614  unsigned n_plot=5;
615 
616  // Compute/output the radiated power
617  //----------------------------------
618  sprintf(filename,"%s/power%i.dat",doc_info.directory().c_str(),
619  doc_info.number());
620  some_file.open(filename);
621 
622  // Accumulate contribution from elements
623  double power=0.0;
624  unsigned nn_element=Helmholtz_DtN_mesh_pt->nelement();
625  for(unsigned e=0;e<nn_element;e++)
626  {
627  FourierDecomposedHelmholtzBCElementBase<HELMHOLTZ_ELEMENT> *el_pt =
628  dynamic_cast<FourierDecomposedHelmholtzBCElementBase<HELMHOLTZ_ELEMENT>*>(
629  Helmholtz_DtN_mesh_pt->element_pt(e));
630  power += el_pt->global_power_contribution(some_file);
631  }
632  some_file.close();
633  oomph_info << "Radiated power: " << power << std::endl;
634 
635  // Output displacement field
636  //--------------------------
637  sprintf(filename,"%s/elast_soln%i.dat",doc_info.directory().c_str(),
638  doc_info.number());
639  some_file.open(filename);
640  Solid_mesh_pt->output(some_file,n_plot);
641  some_file.close();
642 
643  // Output Helmholtz
644  //-----------------
645  sprintf(filename,"%s/helmholtz_soln%i.dat",doc_info.directory().c_str(),
646  doc_info.number());
647  some_file.open(filename);
648  Helmholtz_mesh_pt->output(some_file,n_plot);
649  some_file.close();
650 
651 
652  // Output fsi traction elements
653  //-----------------------------
654  sprintf(filename,"%s/fsi_traction_soln%i.dat",doc_info.directory().c_str(),
655  doc_info.number());
656  some_file.open(filename);
657  FSI_traction_mesh_pt->output(some_file,n_plot);
658  some_file.close();
659 
660 
661  // Output Helmholtz fsi flux elements
662  //-----------------------------------
663  sprintf(filename,"%s/fsi_flux_bc_soln%i.dat",doc_info.directory().c_str(),
664  doc_info.number());
665  some_file.open(filename);
666  Helmholtz_fsi_flux_mesh_pt->output(some_file,n_plot);
667  some_file.close();
668 
669  // Write trace file
670  Trace_file << Global_Parameters::Q << " "
671  << Global_Parameters::K_squared << " "
672  << Global_Parameters::Density_ratio << " "
673  << Global_Parameters::Omega_sq.real() << " "
674  << power << " "
675  << std::endl;
676 
677  // Bump up counter
678  doc_info.number()++;
679 
680 } //end_of_doc_solution
oomph::DocInfo::directory
std::string directory() const
Output directory.
Definition: oomph_utilities.h:524
oomph::DocInfo::number
unsigned & number()
Number used (e.g.) for labeling output files.
Definition: oomph_utilities.h:554
oomph::FourierDecomposedHelmholtzBCElementBase
Definition: fourier_decomposed_helmholtz_bc_elements.h:62
oomph::FourierDecomposedHelmholtzBCElementBase::global_power_contribution
double global_power_contribution()
Definition: fourier_decomposed_helmholtz_bc_elements.h:145
Global_Parameters::Density_ratio
double Density_ratio
Density ratio: solid to fluid.
Definition: acoustic_fsi.cc:70
oomph::oomph_info
OomphInfo oomph_info
Definition: oomph_definitions.cc:319

References Global_Parameters::Density_ratio, oomph::DocInfo::directory(), e(), MergeRestartFiles::filename, Global_Parameters::Fourier_wavenumber, oomph::FourierDecomposedHelmholtzBCElementBase< ELEMENT >::global_power_contribution(), Global_Parameters::K_squared, oomph::DocInfo::number(), Global_Parameters::Omega_sq, oomph::oomph_info, Global_Parameters::Outer_radius, Global_Parameters::Q, and oomph::Problem_Parameter::Trace_file.

◆ doc_solution() [2/2]

template<class ELASTICITY_ELEMENT , class HELMHOLTZ_ELEMENT >
void CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::doc_solution ( DocInfo &  doc_info)

Doc the solution.

◆ setup_interaction() [1/2]

template<class ELASTICITY_ELEMENT , class HELMHOLTZ_ELEMENT >
void CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::setup_interaction
private

Setup interaction.

Setup interaction between two fields.

464 {
465 
466  // Setup Helmholtz "pressure" load on traction elements
467  unsigned boundary_in_helmholtz_mesh=0;
468 
469  // Doc boundary coordinate for Helmholtz
470  ofstream the_file;
471  the_file.open("boundary_coordinate_hh.dat");
472  Helmholtz_mesh_pt->Mesh::template doc_boundary_coordinates<HELMHOLTZ_ELEMENT>
473  (boundary_in_helmholtz_mesh, the_file);
474  the_file.close();
475 
476  // Setup interaction
477  Multi_domain_functions::setup_bulk_elements_adjacent_to_face_mesh
478  <HELMHOLTZ_ELEMENT,2>
479  (this,boundary_in_helmholtz_mesh,Helmholtz_mesh_pt,FSI_traction_mesh_pt);
480 
481  // Setup Helmholtz flux from normal displacement interaction
482  unsigned boundary_in_solid_mesh=2;
483 
484  // Doc boundary coordinate for solid mesh
485  the_file.open("boundary_coordinate_solid.dat");
486  Solid_mesh_pt->Mesh::template doc_boundary_coordinates<ELASTICITY_ELEMENT>
487  (boundary_in_solid_mesh, the_file);
488  the_file.close();
489 
490  // Setup interaction
491  Multi_domain_functions::setup_bulk_elements_adjacent_to_face_mesh
492  <ELASTICITY_ELEMENT,2>(
493  this,boundary_in_solid_mesh,Solid_mesh_pt,Helmholtz_fsi_flux_mesh_pt);
494 
495 }// end_of_setup_interaction
oomph::Multi_domain_functions::setup_bulk_elements_adjacent_to_face_mesh
void setup_bulk_elements_adjacent_to_face_mesh(Problem *problem_pt, Vector< unsigned > &boundary_in_bulk_mesh, Mesh *const &bulk_mesh_pt, Vector< Mesh * > &face_mesh_pt, const unsigned &interaction=0)
/ Templated helper functions for multi-domain methods using locate_zeta
Definition: multi_domain.template.cc:72

References oomph::Multi_domain_functions::setup_bulk_elements_adjacent_to_face_mesh().

◆ setup_interaction() [2/2]

template<class ELASTICITY_ELEMENT , class HELMHOLTZ_ELEMENT >
void CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::setup_interaction ( )
private

Setup interaction.

Member Data Documentation

◆ FSI_traction_mesh_pt

template<class ELASTICITY_ELEMENT , class HELMHOLTZ_ELEMENT >
Mesh * CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::FSI_traction_mesh_pt
private

Pointer to mesh of FSI traction elements.

◆ Helmholtz_DtN_mesh_pt

template<class ELASTICITY_ELEMENT , class HELMHOLTZ_ELEMENT >
FourierDecomposedHelmholtzDtNMesh< HELMHOLTZ_ELEMENT > * CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::Helmholtz_DtN_mesh_pt
private

Pointer to mesh containing the DtN elements.

◆ Helmholtz_fsi_flux_mesh_pt

template<class ELASTICITY_ELEMENT , class HELMHOLTZ_ELEMENT >
Mesh * CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::Helmholtz_fsi_flux_mesh_pt
private

Pointer to mesh of Helmholtz FSI flux elements.

◆ Helmholtz_mesh_pt [1/2]

template<class ELASTICITY_ELEMENT , class HELMHOLTZ_ELEMENT >
TwoDAnnularMesh<HELMHOLTZ_ELEMENT>* CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::Helmholtz_mesh_pt
private

Pointer to Helmholtz mesh.

◆ Helmholtz_mesh_pt [2/2]

template<class ELASTICITY_ELEMENT , class HELMHOLTZ_ELEMENT >
TriangleMesh<HELMHOLTZ_ELEMENT>* CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::Helmholtz_mesh_pt
private

Pointer to Helmholtz mesh.

◆ HH_inner_boundary_id

template<class ELASTICITY_ELEMENT , class HELMHOLTZ_ELEMENT >
unsigned CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::HH_inner_boundary_id
private

Boundary ID of inner boundary in Helmholtz mesh.

◆ HH_lower_symmetry_boundary_id

template<class ELASTICITY_ELEMENT , class HELMHOLTZ_ELEMENT >
unsigned CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::HH_lower_symmetry_boundary_id
private

Boundary ID of lower boundary in Helmholtz mesh.

◆ HH_outer_boundary_id

template<class ELASTICITY_ELEMENT , class HELMHOLTZ_ELEMENT >
unsigned CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::HH_outer_boundary_id
private

Boundary ID of outer boundary in Helmholtz mesh.

◆ HH_upper_symmetry_boundary_id

template<class ELASTICITY_ELEMENT , class HELMHOLTZ_ELEMENT >
unsigned CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::HH_upper_symmetry_boundary_id
private

Boundary ID of upper boundary in Helmholtz mesh.

◆ Lower_inner_boundary_id

template<class ELASTICITY_ELEMENT , class HELMHOLTZ_ELEMENT >
unsigned CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::Lower_inner_boundary_id
private

Boundary ID of lower inner boundary.

◆ Lower_symmetry_boundary_id

template<class ELASTICITY_ELEMENT , class HELMHOLTZ_ELEMENT >
unsigned CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::Lower_symmetry_boundary_id
private

Boundary ID of lower symmetry boundary.

◆ Outer_boundary_id

template<class ELASTICITY_ELEMENT , class HELMHOLTZ_ELEMENT >
unsigned CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::Outer_boundary_id
private

Boundary ID of outer boundary.

◆ Rib_divider_boundary_id

template<class ELASTICITY_ELEMENT , class HELMHOLTZ_ELEMENT >
unsigned CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::Rib_divider_boundary_id
private

Boundary ID of rib divider.

◆ Solid_mesh_pt [1/2]

template<class ELASTICITY_ELEMENT , class HELMHOLTZ_ELEMENT >
TwoDAnnularMesh<ELASTICITY_ELEMENT>* CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::Solid_mesh_pt
private

Pointer to solid mesh.

◆ Solid_mesh_pt [2/2]

template<class ELASTICITY_ELEMENT , class HELMHOLTZ_ELEMENT >
TriangleMesh<ELASTICITY_ELEMENT>* CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::Solid_mesh_pt
private

Pointer to solid mesh.

◆ Solid_traction_mesh_pt

template<class ELASTICITY_ELEMENT , class HELMHOLTZ_ELEMENT >
Mesh* CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::Solid_traction_mesh_pt
private

Pointer to mesh of solid traction elements.

◆ Trace_file

template<class ELASTICITY_ELEMENT , class HELMHOLTZ_ELEMENT >
ofstream CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::Trace_file
private

Trace file.

◆ Upper_inner_boundary_id

template<class ELASTICITY_ELEMENT , class HELMHOLTZ_ELEMENT >
unsigned CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::Upper_inner_boundary_id
private

Boundary ID of upper inner boundary.

◆ Upper_symmetry_boundary_id

template<class ELASTICITY_ELEMENT , class HELMHOLTZ_ELEMENT >
unsigned CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::Upper_symmetry_boundary_id
private

Boundary ID of upper symmetry boundary.

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