Public Member Functions | Public Attributes | Private Member Functions | Private Attributes | List of all members
UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT > Class Template Reference

Unstructured 3D FSI problem. More...

+ Inheritance diagram for UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >:

Public Member Functions

 UnstructuredFSIProblem ()
 Constructor: More...
 
 ~UnstructuredFSIProblem ()
 Destructor (empty) More...
 
void doc_solution (DocInfo &doc_info)
 Doc the solution. More...
 
void create_parallel_flow_lagrange_elements ()
 Create Lagrange multiplier elements that impose parallel flow. More...
 
void create_fsi_traction_elements ()
 Create FSI traction elements. More...
 
void create_lagrange_multiplier_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 doc_parameters ()
 Doc parameters. More...
 
 UnstructuredFSIProblem ()
 Constructor: More...
 
 ~UnstructuredFSIProblem ()
 Destructor (empty) More...
 
void doc_solution (DocInfo &doc_info)
 Doc the solution. More...
 
void actions_before_adapt ()
 Actions before adapt. More...
 
void actions_after_adapt ()
 Actions after adapt. More...
 
void output_strain_and_dissipation (std::ostream &trace)
 
 UnstructuredFSIProblem ()
 Constructor. More...
 
 ~UnstructuredFSIProblem ()
 Destructor (empty) More...
 
FluidTriangleMesh< FLUID_ELEMENT > *& fluid_mesh_pt ()
 Access function for the fluid mesh. More...
 
MySolidTriangleMesh< SOLID_ELEMENT > *& solid_mesh_pt ()
 Access function for the solid mesh. More...
 
void doc_solution (DocInfo &doc_info)
 Doc the solution. More...
 
 UnstructuredFSIProblem ()
 Constructor: More...
 
 ~UnstructuredFSIProblem ()
 Destructor (empty) More...
 
void doc_solution (DocInfo &doc_info)
 Doc the solution. More...
 
void create_fluid_traction_elements ()
 Create fluid traction elements at inflow. More...
 
void create_fsi_traction_elements ()
 Create FSI traction elements. More...
 
void create_lagrange_multiplier_elements ()
 
 UnstructuredFSIProblem ()
 Constructor: More...
 
 ~UnstructuredFSIProblem ()
 Destructor (empty) More...
 
void doc_solution (DocInfo &doc_info)
 Doc the solution. More...
 
void create_parallel_flow_lagrange_elements ()
 Create Lagrange multiplier elements that impose parallel flow. More...
 
void create_fsi_traction_elements ()
 Create FSI traction elements. More...
 
void create_lagrange_multiplier_elements ()
 
- 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 ()
 

Public Attributes

RefineableSolidTriangleMesh< FLUID_ELEMENT > * Fluid_mesh_pt
 Bulk fluid mesh. More...
 
- Public Attributes inherited from oomph::Problem
bool Shut_up_in_newton_solve
 

Private Member Functions

void doc_solid_boundary_coordinates (const unsigned &i)
 Sanity check: Doc boundary coordinates on i-th solid FSI interface. More...
 
unsigned nfluid_inflow_traction_boundary ()
 
unsigned nfluid_outflow_traction_boundary ()
 
unsigned nfluid_traction_boundary ()
 
unsigned nsolid_fsi_boundary ()
 
unsigned nfluid_fsi_boundary ()
 
unsigned npinned_solid_boundary ()
 
void create_fsi_traction_elements ()
 Create the traction element. More...
 
void delete_fsi_traction_elements ()
 Delete the traction elements. More...
 
void create_lagrange_multiplier_elements ()
 
void delete_lagrange_multiplier_elements ()
 Delete the traction elements. More...
 
double get_solid_strain_energy ()
 Calculate the strain energy of the solid. More...
 
double get_fluid_dissipation ()
 Calculate the fluid dissipation. More...
 
void create_fsi_traction_elements ()
 Create FSI traction elements. More...
 
void create_lagrange_multiplier_elements ()
 
void doc_solid_boundary_coordinates ()
 Sanity check: Doc boundary coordinates from solid side. More...
 
void doc_solid_boundary_coordinates (const unsigned &i)
 Sanity check: Doc boundary coordinates on i-th solid FSI interface. More...
 
unsigned nfluid_inflow_traction_boundary ()
 
unsigned nfluid_outflow_traction_boundary ()
 
unsigned nfluid_traction_boundary ()
 
unsigned nsolid_fsi_boundary ()
 
unsigned nfluid_fsi_boundary ()
 
unsigned npinned_solid_boundary ()
 
void doc_solid_boundary_coordinates (const unsigned &i)
 Sanity check: Doc boundary coordinates on i-th solid FSI interface. More...
 
unsigned nfluid_inflow_traction_boundary ()
 
unsigned nfluid_outflow_traction_boundary ()
 
unsigned nfluid_traction_boundary ()
 
unsigned nsolid_fsi_boundary ()
 
unsigned nfluid_fsi_boundary ()
 
unsigned npinned_solid_boundary ()
 

Private Attributes

SolidTetgenMesh< SOLID_ELEMENT > * Solid_mesh_pt
 Bulk solid mesh. More...
 
Vector< SolidMesh * > Solid_fsi_traction_mesh_pt
 Meshes of FSI traction elements. More...
 
SolidTetgenMesh< FLUID_ELEMENT > * Fluid_mesh_pt
 Bulk fluid mesh. More...
 
Mesh * Inflow_flux_monitor_mesh_pt
 Mesh containing the FaceElements that monitor the inflow. More...
 
Mesh * Inflow_flux_control_mesh_pt
 Mesh of FaceElements that control the inflow. More...
 
Mesh * Inflow_flux_control_master_mesh_pt
 Mesh containing the master flux control element. More...
 
Vector< Mesh * > Parallel_flow_lagrange_multiplier_mesh_pt
 Meshes of Lagrange multiplier elements that impose parallel flow. More...
 
Vector< SolidMesh * > Lagrange_multiplier_mesh_pt
 Meshes of Lagrange multiplier elements. More...
 
Vector< MeshAsGeomObject * > Solid_fsi_boundary_pt
 GeomObject incarnations of the FSI boundary in the solid mesh. More...
 
Vector< unsigned > Pinned_solid_boundary_id
 IDs of solid mesh boundaries where displacements are pinned. More...
 
Vector< unsigned > Solid_fsi_boundary_id
 IDs of solid mesh boundaries which make up the FSI interface. More...
 
Vector< unsigned > Solid_outer_boundary_id
 IDs of solid mesh boundaries which make up the outer surface. More...
 
Vector< unsigned > Inflow_boundary_id
 
Vector< unsigned > Outflow_boundary_id
 
Vector< unsigned > Fluid_fsi_boundary_id
 IDs of fluid mesh boundaries which make up the FSI interface. More...
 
double Wall_thickness
 
RefineableSolidTriangleMesh< SOLID_ELEMENT > * Solid_mesh_pt
 Bulk solid mesh. More...
 
Vector< SolidMesh * > Traction_mesh_pt
 Vectors of pointers to mesh of traction elements. More...
 
TriangleMeshPolygon * Solid_outer_boundary_polyline_pt
 Triangle mesh polygon for outer boundary. More...
 
TriangleMeshPolygon * Fluid_outer_boundary_polyline_pt
 Triangle mesh polygon for outer boundary. More...
 
FluidTriangleMesh< FLUID_ELEMENT > * Fluid_mesh_pt
 Fluid mesh. More...
 
MySolidTriangleMesh< SOLID_ELEMENT > * Solid_mesh_pt
 Solid mesh. More...
 
SolidMesh * Lagrange_multiplier_mesh_pt
 Pointers to mesh of Lagrange multiplier elements. More...
 
SolidMesh * Traction_mesh_pt
 Vector of pointers to mesh of FSI traction elements. More...
 
MeshAsGeomObject * Solid_fsi_boundary_pt
 GeomObject incarnation of fsi boundary in solid mesh. More...
 
MySolidTetgenMesh< SOLID_ELEMENT > * Solid_mesh_pt
 Bulk solid mesh. More...
 
FluidTetMesh< FLUID_ELEMENT > * Fluid_mesh_pt
 Bulk fluid mesh. More...
 
Vector< Mesh * > Fluid_traction_mesh_pt
 Meshes of fluid traction elements that apply pressure at in/outflow. More...
 
MyFluidTetMesh< FLUID_ELEMENT > * Fluid_mesh_pt
 Bulk fluid 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...
 
- Static Public Attributes inherited from oomph::Problem
static bool Suppress_warning_about_actions_before_read_unstructured_meshes
 
- Protected Types inherited from oomph::Problem
enum  Assembly_method {
  Perform_assembly_using_vectors_of_pairs , Perform_assembly_using_two_vectors , Perform_assembly_using_maps , Perform_assembly_using_lists ,
  Perform_assembly_using_two_arrays
}
 Enumerated flags to determine which sparse assembly method is used. More...
 
- Protected Member Functions inherited from oomph::Problem
unsigned setup_element_count_per_dof ()
 
virtual void sparse_assemble_row_or_column_compressed (Vector< int * > &column_or_row_index, Vector< int * > &row_or_column_start, Vector< double * > &value, Vector< unsigned > &nnz, Vector< double * > &residual, bool compressed_row_flag)
 
virtual void actions_before_newton_solve ()
 
virtual void actions_after_newton_solve ()
 
virtual void actions_before_newton_step ()
 
virtual void actions_after_newton_step ()
 
virtual void actions_after_implicit_timestep ()
 
virtual void actions_after_implicit_timestep_and_error_estimation ()
 
virtual void actions_before_explicit_timestep ()
 Actions that should be performed before each explicit time step. More...
 
virtual void actions_after_explicit_timestep ()
 Actions that should be performed after each explicit time step. More...
 
virtual void actions_before_read_unstructured_meshes ()
 
virtual void actions_after_read_unstructured_meshes ()
 
virtual void actions_after_change_in_global_parameter (double *const &parameter_pt)
 
virtual void actions_after_change_in_bifurcation_parameter ()
 
virtual void actions_after_parameter_increase (double *const &parameter_pt)
 
double & dof_derivative (const unsigned &i)
 
double & dof_current (const unsigned &i)
 
virtual void set_initial_condition ()
 
virtual double global_temporal_error_norm ()
 
unsigned newton_solve_continuation (double *const &parameter_pt)
 
unsigned newton_solve_continuation (double *const &parameter_pt, DoubleVector &z)
 
void calculate_continuation_derivatives (double *const &parameter_pt)
 
void calculate_continuation_derivatives (const DoubleVector &z)
 
void calculate_continuation_derivatives_fd (double *const &parameter_pt)
 
bool does_pointer_correspond_to_problem_data (double *const &parameter_pt)
 
void set_consistent_pinned_values_for_continuation ()
 
- Protected Attributes inherited from oomph::Problem
Vector< Problem * > Copy_of_problem_pt
 
std::map< double *, bool > Calculate_dparameter_analytic
 
bool Calculate_hessian_products_analytic
 
LinearAlgebraDistribution * Dof_distribution_pt
 
Vector< double * > Dof_pt
 Vector of pointers to dofs. More...
 
DoubleVectorWithHaloEntries Element_count_per_dof
 
double Relaxation_factor
 
double Newton_solver_tolerance
 
unsigned Max_newton_iterations
 Maximum number of Newton iterations. More...
 
unsigned Nnewton_iter_taken
 
Vector< double > Max_res
 Maximum residuals at start and after each newton iteration. More...
 
double Max_residuals
 
bool Time_adaptive_newton_crash_on_solve_fail
 
bool Jacobian_reuse_is_enabled
 Is re-use of Jacobian in Newton iteration enabled? Default: false. More...
 
bool Jacobian_has_been_computed
 
bool Problem_is_nonlinear
 
bool Pause_at_end_of_sparse_assembly
 
bool Doc_time_in_distribute
 
unsigned Sparse_assembly_method
 
unsigned Sparse_assemble_with_arrays_initial_allocation
 
unsigned Sparse_assemble_with_arrays_allocation_increment
 
Vector< Vector< unsigned > > Sparse_assemble_with_arrays_previous_allocation
 
double Numerical_zero_for_sparse_assembly
 
double FD_step_used_in_get_hessian_vector_products
 
bool Mass_matrix_reuse_is_enabled
 
bool Mass_matrix_has_been_computed
 
bool Discontinuous_element_formulation
 
double Minimum_dt
 Minimum desired dt: if dt falls below this value, exit. More...
 
double Maximum_dt
 Maximum desired dt. More...
 
double DTSF_max_increase
 
double DTSF_min_decrease
 
double Minimum_dt_but_still_proceed
 
bool Scale_arc_length
 Boolean to control whether arc-length should be scaled. More...
 
double Desired_proportion_of_arc_length
 Proportion of the arc-length to taken by the parameter. More...
 
double Theta_squared
 
int Sign_of_jacobian
 Storage for the sign of the global Jacobian. More...
 
double Continuation_direction
 
double Parameter_derivative
 Storage for the derivative of the global parameter wrt arc-length. More...
 
double Parameter_current
 Storage for the present value of the global parameter. More...
 
bool Use_continuation_timestepper
 Boolean to control original or new storage of dof stuff. More...
 
unsigned Dof_derivative_offset
 
unsigned Dof_current_offset
 
Vector< double > Dof_derivative
 Storage for the derivative of the problem variables wrt arc-length. More...
 
Vector< double > Dof_current
 Storage for the present values of the variables. More...
 
double Ds_current
 Storage for the current step value. More...
 
unsigned Desired_newton_iterations_ds
 
double Minimum_ds
 Minimum desired value of arc-length. More...
 
bool Bifurcation_detection
 Boolean to control bifurcation detection via determinant of Jacobian. More...
 
bool Bisect_to_find_bifurcation
 Boolean to control wheter bisection is used to located bifurcation. More...
 
bool First_jacobian_sign_change
 Boolean to indicate whether a sign change has occured in the Jacobian. More...
 
bool Arc_length_step_taken
 Boolean to indicate whether an arc-length step has been taken. More...
 
bool Use_finite_differences_for_continuation_derivatives
 
OomphCommunicator * Communicator_pt
 The communicator for this problem. More...
 
bool Always_take_one_newton_step
 
double Timestep_reduction_factor_after_nonconvergence
 
bool Keep_temporal_error_below_tolerance
 
- Static Protected Attributes inherited from oomph::Problem
static ContinuationStorageScheme Continuation_time_stepper
 Storage for the single static continuation timestorage object. More...
 

Detailed Description

template<class FLUID_ELEMENT, class SOLID_ELEMENT>
class UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >

Unstructured 3D FSI problem.

Unstructured FSI Problem.

Unstructured FSI problem.

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

Constructor & Destructor Documentation

◆ UnstructuredFSIProblem() [1/5]

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

Constructor:

Constructor for unstructured FSI problem.

Constructor for unstructured solid problem.

Constructor for unstructured 3D FSI problem.

IDs of solid mesh boundaries where displacements are pinned

299 {
300 
301  // We have a large number of sub-meshes with very few elements
302  // in this problem: Reduce the number of bins in the MeshAsGeomObject
303  // representations of these meshes to avoid memory problems
304  NonRefineableBinArray::Default_n_bin_1d=1;
305 
306  // Allocate the timestepper for the Navier-Stokes equations
307  BDF<2>* fluid_time_stepper_pt=new BDF<2>;
308 
309  // Add the fluid timestepper to the Problem's collection of timesteppers.
310  add_time_stepper_pt(fluid_time_stepper_pt);
311 
312  // Create a Steady timestepper that stores two history values
313  Steady<2>* wall_time_stepper_pt = new Steady<2>;
314 
315  // Add the wall timestepper to the Problem's collection of timesteppers.
316  add_time_stepper_pt(wall_time_stepper_pt);
317 
318 
319  // Read boundary enumeration
320  string input_string;
321 
322  // Open input file
323  ifstream* input_file_pt=new ifstream("boundary_enumeration.dat");
324 
325  // Check if it's been opened succesfully
326  if (input_file_pt==0)
327  {
328  oomph_info << "ERROR while trying to open boundary enumeration file "
329  << std::endl;
330  exit(1);
331  }
332 
333  getline(*input_file_pt,input_string,' ');
334  unsigned fluid_fsi_lo=atoi(input_string.c_str());
335  getline(*input_file_pt,input_string,'#');
336  unsigned fluid_fsi_hi=atoi(input_string.c_str());
337  input_file_pt->ignore(80,'\n');
338 
339  getline(*input_file_pt,input_string,' ');
340  unsigned fluid_in_lo=atoi(input_string.c_str());
341  getline(*input_file_pt,input_string,'#');
342  unsigned fluid_in_hi=atoi(input_string.c_str());
343  input_file_pt->ignore(80,'\n');
344 
345  getline(*input_file_pt,input_string,' ');
346  unsigned fluid_out_lo=atoi(input_string.c_str());
347  input_file_pt->ignore(80,'\n');
348  getline(*input_file_pt,input_string,' ');
349  getline(*input_file_pt,input_string,'#');
350  unsigned fluid_out_hi=atoi(input_string.c_str());
351  input_file_pt->ignore(80,'\n');
352 
353  getline(*input_file_pt,input_string,' ');
354  unsigned solid_fsi_lo=atoi(input_string.c_str());
355  getline(*input_file_pt,input_string,'#');
356  unsigned solid_fsi_hi=atoi(input_string.c_str());
357  input_file_pt->ignore(80,'\n');
358 
359  getline(*input_file_pt,input_string,' ');
360  unsigned solid_pin_lo=atoi(input_string.c_str());
361  input_file_pt->ignore(80,'\n');
362  input_file_pt->ignore(80,'\n');
363  getline(*input_file_pt,input_string,' ');
364  getline(*input_file_pt,input_string,'#');
365  unsigned solid_pin_hi=atoi(input_string.c_str());
366  input_file_pt->ignore(80,'\n');
367 
368  getline(*input_file_pt,input_string,' ');
369  unsigned solid_outer_lo=atoi(input_string.c_str());
370  getline(*input_file_pt,input_string,'#');
371  unsigned solid_outer_hi=atoi(input_string.c_str());
372  input_file_pt->ignore(80,'\n');
373 
374 
375  // Define fluid mesh and its distinguished boundaries
376  //---------------------------------------------------
377 
378  //Create fluid bulk mesh, sub-dividing "corner" elements
379  string node_file_name="fluid.1.node";
380  string element_file_name="fluid.1.ele";
381  string face_file_name="fluid.1.face";
382  bool split_corner_elements=true;
383  bool switch_normal=true;
384  Fluid_mesh_pt = new SolidTetgenMesh<FLUID_ELEMENT>(node_file_name,
385  element_file_name,
386  face_file_name,
387  split_corner_elements,
388  switch_normal,
389  fluid_time_stepper_pt);
390 
391 
392  // Now update the nodal positions
393  ifstream node_file;
394  node_file.open("fluid_quadratic_nodes.dat");
395  unsigned nnod=Fluid_mesh_pt->nnode();
396  for (unsigned j=0;j<nnod;j++)
397  {
398  Node* nod_pt=Fluid_mesh_pt->node_pt(j);
399  node_file >> nod_pt->x(0);
400  node_file >> nod_pt->x(1);
401  node_file >> nod_pt->x(2);
402  }
403  node_file.close();
404  Fluid_mesh_pt->set_lagrangian_nodal_coordinates();
405 
406  // The following corresponds to the boundaries as specified by
407  // facets in the xda input:
408 
409  // Fluid mesh inflow boundaries
410  unsigned nfluid_in=fluid_in_hi-fluid_in_lo+1;
411  Inflow_boundary_id.resize(nfluid_in);
412  for(unsigned i=0; i<nfluid_in; i++)
413  {
414  Inflow_boundary_id[i]=fluid_fsi_hi+1+i;
415  }
416 
417  // Fluid mesh outflow boundaries
418  unsigned nfluid_out=fluid_out_hi-fluid_out_lo+1;
419  Outflow_boundary_id.resize(nfluid_out);
420  for(unsigned i=0; i<nfluid_out; i++)
421  {
422  Outflow_boundary_id[i]=fluid_out_lo+i;
423  }
424 
425  // The FSI boundaries :
426  unsigned nfluid_fsi=fluid_fsi_hi-fluid_fsi_lo+1;
427  Fluid_fsi_boundary_id.resize(nfluid_fsi);
428  for(unsigned i=0; i<nfluid_fsi; i++)
429  {
430  Fluid_fsi_boundary_id[i]=fluid_fsi_lo+i;
431  }
432 
433 
434  // Define solid mesh and its distinguished boundaries
435  //---------------------------------------------------
436  //Create solid bulk mesh
437  node_file_name="solid.1.node";
438  element_file_name="solid.1.ele";
439  face_file_name="solid.1.face";
440  Solid_mesh_pt = new SolidTetgenMesh<SOLID_ELEMENT>(node_file_name,
441  element_file_name,
442  face_file_name,
443  wall_time_stepper_pt);
444 
445 
446  // Now update the nodal positions
447  node_file.open("solid_quadratic_nodes.dat");
448  nnod=Solid_mesh_pt->nnode();
449  for (unsigned j=0;j<nnod;j++)
450  {
451  Node* nod_pt=Solid_mesh_pt->node_pt(j);
452  node_file >> nod_pt->x(0);
453  node_file >> nod_pt->x(1);
454  node_file >> nod_pt->x(2);
455  }
456  node_file.close();
457  Solid_mesh_pt->set_lagrangian_nodal_coordinates();
458 
459  // The following corresponds to the boundaries as specified by
460  // facets in the Tetgen input:
461 
463  unsigned nsolid_pin=solid_pin_hi-solid_pin_lo+1;
464  Pinned_solid_boundary_id.resize(nsolid_pin);
465  for(unsigned i=0; i<nsolid_pin; i++)
466  {
467  Pinned_solid_boundary_id[i]=solid_pin_lo+i;
468  }
469 
470  // The solid and fluid fsi boundaries are numbered in the same way.
471  unsigned nsolid_fsi=solid_fsi_hi-solid_fsi_lo+1;
472  Solid_fsi_boundary_id.resize(nsolid_fsi);
473  for(unsigned i=0; i<nsolid_fsi; i++)
474  {
475  Solid_fsi_boundary_id[i]=solid_fsi_lo+i;
476  }
477 
478  // Outer solid boundary
479  unsigned nsolid_outer=solid_outer_hi-solid_outer_lo+1;
480  Solid_outer_boundary_id.resize(nsolid_outer);
481  for(unsigned i=0; i<nsolid_outer; i++)
482  {
483  Solid_outer_boundary_id[i]=solid_outer_lo+i;
484  }
485 
486 
487  // Scale
488  double factor=0.0666;
489  Fluid_mesh_pt->scale_mesh(factor);
490  Solid_mesh_pt->scale_mesh(factor);
491 
492 
493  // Create (empty) meshes of lagrange multiplier elements at inflow/outflow
494  //------------------------------------------------------------------------
495 
496  // Create the meshes
497  unsigned n=nfluid_traction_boundary();
498  Parallel_flow_lagrange_multiplier_mesh_pt.resize(n);
499  for (unsigned i=0;i<n;i++)
500  {
501  Parallel_flow_lagrange_multiplier_mesh_pt[i]=new Mesh;
502  }
503 
504 
505  // Meshes of inflow elements
506  Inflow_flux_monitor_mesh_pt=new Mesh;
507  Inflow_flux_control_mesh_pt=new Mesh;
508  Inflow_flux_control_master_mesh_pt=new Mesh;
509 
510  // Populate them with elements
511  create_parallel_flow_lagrange_elements();
512 
513  cout << "Number of inflow flux monitor elements: "
514  << Inflow_flux_monitor_mesh_pt->nelement() << std::endl;
515 
516 // Create FSI Traction elements
517 //-----------------------------
518 
519 // Create (empty) meshes of FSI traction elements
520  n=nsolid_fsi_boundary();
521  Solid_fsi_traction_mesh_pt.resize(n);
522  for (unsigned i=0;i<n;i++)
523  {
524  Solid_fsi_traction_mesh_pt[i]=new SolidMesh;
525  }
526 
527  // Build the FSI traction elements
528  create_fsi_traction_elements();
529 
530 
531  // Compute average wall thickness
532  //-------------------------------
533 
534  // Surface area of fsi interface
535  double fsi_area=0.0;
536  n=nsolid_fsi_boundary();
537  for (unsigned i=0;i<n;i++)
538  {
539  unsigned nel=Solid_fsi_traction_mesh_pt[i]->nelement();
540  for (unsigned e=0;e<nel;e++)
541  {
542  fsi_area+=Solid_fsi_traction_mesh_pt[i]->finite_element_pt(e)->size();
543  }
544  }
545 
546  // Volume of solid mesh
547  double solid_vol=0.0;
548  unsigned nel=Solid_mesh_pt->nelement();
549  for (unsigned e=0;e<nel;e++)
550  {
551  solid_vol+=Solid_mesh_pt->finite_element_pt(e)->size();
552  }
553  Wall_thickness=solid_vol/fsi_area;
554  std::cout << "Surface area : " << fsi_area << std::endl;
555  std::cout << "Solid volume : " << solid_vol << std::endl;
556 
557 
558  // Create Lagrange multiplier mesh for boundary motion of fluid mesh
559  //------------------------------------------------------------------
560 
561  // Construct the mesh of elements that enforce prescribed boundary motion
562  // of pseudo-solid fluid mesh by Lagrange multipliers
563  n=nfluid_fsi_boundary();
564  Lagrange_multiplier_mesh_pt.resize(n);
565  for (unsigned i=0;i<n;i++)
566  {
567  Lagrange_multiplier_mesh_pt[i]=new SolidMesh;
568  }
569 
570  // Create elements
571  create_lagrange_multiplier_elements();
572 
573 
574 
575  // Combine the lot
576  //----------------
577 
578  // Add sub meshes:
579 
580  // The solid bulk mesh
581  add_sub_mesh(Solid_mesh_pt);
582 
583  // Fluid bulk mesh
584  add_sub_mesh(Fluid_mesh_pt);
585 
586  // The fluid traction meshes
587  n=nfluid_traction_boundary();
588  for (unsigned i=0;i<n;i++)
589  {
590  add_sub_mesh(Parallel_flow_lagrange_multiplier_mesh_pt[i]);
591  }
592 
593  // The solid fsi traction meshes
594  n=nsolid_fsi_boundary();
595  for (unsigned i=0;i<n;i++)
596  {
597  add_sub_mesh(Solid_fsi_traction_mesh_pt[i]);
598  }
599 
600  // The Lagrange multiplier meshes for the fluid
601  n=nfluid_fsi_boundary();
602  for (unsigned i=0;i<n;i++)
603  {
604  add_sub_mesh(Lagrange_multiplier_mesh_pt[i]);
605  }
606 
607  // Add flux control meshes if required
608  if (!Global_Parameters::Prescribe_pressure)
609  {
610  add_sub_mesh(Inflow_flux_control_mesh_pt);
611  add_sub_mesh(Inflow_flux_control_master_mesh_pt);
612  }
613 
614  // Build global mesh
615  build_global_mesh();
616 
617 
618 
619 
620  // Apply BCs for fluid and Lagrange multiplier elements
621  //-----------------------------------------------------
622 
623  // Doc position of pinned pseudo solid nodes
624  std::ofstream pseudo_solid_bc_file("RESLT/pinned_pseudo_solid_nodes.dat");
625 
626  // Loop over inflow/outflow boundaries to pin pseudo-solid displacements
627  for (unsigned in_out=0;in_out<2;in_out++)
628  {
629  // Loop over in/outflow boundaries
630  unsigned n=nfluid_inflow_traction_boundary();
631  if (in_out==1) n=nfluid_outflow_traction_boundary();
632  for (unsigned i=0;i<n;i++)
633  {
634 
635  // Get boundary ID
636  unsigned b=0;
637  if (in_out==0)
638  {
639  b=Inflow_boundary_id[i];
640  }
641  else
642  {
643  b=Outflow_boundary_id[i];
644  }
645 
646  // Number of nodes on that boundary
647  unsigned num_nod=Fluid_mesh_pt->nboundary_node(b);
648  for (unsigned inod=0;inod<num_nod;inod++)
649  {
650  // Get the node
651  SolidNode* nod_pt=Fluid_mesh_pt->boundary_node_pt(b,inod);
652 
653  // Pin the nodal (pseudo-solid) displacements
654  for(unsigned i=0;i<3;i++)
655  {
656  nod_pt->pin_position(i);
657 
658  // Doc it as pinned
659  pseudo_solid_bc_file << nod_pt->x(i) << " ";
660  }
661  }
662  }
663  }
664 
665  // Close
666  pseudo_solid_bc_file.close();
667 
668 // Doc bcs for Lagrange multipliers
669  ofstream pinned_file("RESLT/pinned_lagrange_multiplier_nodes.dat");
670 
671  // Loop over nodes on the FSI boundary in the fluid mesh
672  unsigned nbound=nfluid_fsi_boundary();
673  for(unsigned i=0;i<nbound;i++)
674  {
675  //Get the mesh boundary
676  unsigned b = Fluid_fsi_boundary_id[i];
677  unsigned num_nod=Fluid_mesh_pt->nboundary_node(b);
678  for (unsigned inod=0;inod<num_nod;inod++)
679  {
680  // Get node
681  Node* nod_pt= Fluid_mesh_pt->boundary_node_pt(b,inod);
682 
683  // Pin all velocities
684  nod_pt->pin(0);
685  nod_pt->pin(1);
686  nod_pt->pin(2);
687 
688  // Find out whether node is also on in/outflow
689  bool is_in_or_outflow_node=false;
690  unsigned n=nfluid_inflow_traction_boundary();
691  for (unsigned k=0;k<n;k++)
692  {
693  if (nod_pt->is_on_boundary(Inflow_boundary_id[k]))
694  {
695  is_in_or_outflow_node=true;
696  break;
697  }
698  }
699  if (!is_in_or_outflow_node)
700  {
701  unsigned n=nfluid_outflow_traction_boundary();
702  for (unsigned k=0;k<n;k++)
703  {
704  if (nod_pt->is_on_boundary(Outflow_boundary_id[k]))
705  {
706  is_in_or_outflow_node=true;
707  break;
708  }
709  }
710  } // ...now we know if the node is on an in- or outflow boundary
711 
712  // Pin the Lagrange multipliers for the imposition of
713  // parallel flow if the nodes is also on the in/outflow boundaries
714  if(is_in_or_outflow_node)
715  {
716  //Cast to a boundary node
717  BoundaryNode<SolidNode> *bnod_pt =
718  dynamic_cast<BoundaryNode<SolidNode>*>
719  ( Fluid_mesh_pt->boundary_node_pt(b,inod) );
720 
721  // Get the index of the first Lagrange multiplier
722  unsigned first_index=bnod_pt->
723  index_of_first_value_assigned_by_face_element(
724  Global_Parameters::Parallel_flow_lagrange_multiplier_id);
725 
726  //Pin the Lagrange multipliers (as the velocity is already
727  //determined via the no slip condition on the fsi boundary
728  for (unsigned l=0;l<2;l++)
729  {
730  nod_pt->pin(first_index+l);
731  }
732 
733 
734  // Get the first index of the second Lagrange multiplier
735  first_index=bnod_pt->index_of_first_value_assigned_by_face_element(
736  Global_Parameters::FSI_interface_displacement_lagrange_multiplier_id);
737 
738  // Loop over the Lagrange multipliers that deform the FSI boundary
739  // of the pseudo-solid fluid mesh.
740  for (unsigned l=0;l<3;l++)
741  {
742  // Pin the Lagrange multipliers that impose the displacement
743  // because the positon of the fluid nodes at the in/outflow
744  // is already determined.
745  nod_pt->pin(first_index+l);
746  }
747 
748  // Doc that we've pinned the Lagrange multipliers at this node
749  pinned_file << nod_pt->x(0) << " "
750  << nod_pt->x(1) << " "
751  << nod_pt->x(2) << endl;
752  }
753  }
754  } // end of BC for fluid mesh
755 
756  // Done pinning Lagrange nultipliers
757  pinned_file.close();
758 
759 
760  // Complete the build of the fluid elements so they are fully functional
761  //----------------------------------------------------------------------
762  unsigned n_element = Fluid_mesh_pt->nelement();
763  for(unsigned e=0;e<n_element;e++)
764  {
765  // Upcast from GeneralisedElement to the present element
766  FLUID_ELEMENT* el_pt =
767  dynamic_cast<FLUID_ELEMENT*>(Fluid_mesh_pt->element_pt(e));
768 
769  //Set the Reynolds number
770  el_pt->re_pt() = &Global_Parameters::Re;
771  el_pt->re_st_pt() = &Global_Parameters::Re;
772 
773  // Set the constitutive law for pseudo-elastic mesh deformation
774  el_pt->constitutive_law_pt() =
775  Global_Parameters::Constitutive_law_pt;
776 
777  } // end loop over elements
778 
779 
780 
781  // Apply BCs for solid
782  //--------------------
783 
784  // Doc pinned solid nodes
785  std::ofstream bc_file("RESLT/pinned_solid_nodes.dat");
786 
787  // Pin positions at inflow boundary (boundaries 0 and 1)
788  n=npinned_solid_boundary();
789  for (unsigned i=0;i<n;i++)
790  {
791  // Get boundary ID
792  unsigned b=Pinned_solid_boundary_id[i];
793  unsigned num_nod= Solid_mesh_pt->nboundary_node(b);
794  for (unsigned inod=0;inod<num_nod;inod++)
795  {
796  // Get node
797  SolidNode* nod_pt=Solid_mesh_pt->boundary_node_pt(b,inod);
798 
799  // Pin all directions
800  for (unsigned i=0;i<3;i++)
801  {
802  nod_pt->pin_position(i);
803 
804  // ...and doc it as pinned
805  bc_file << nod_pt->x(i) << " ";
806  }
807 
808  bc_file << std::endl;
809  }
810  }
811  bc_file.close();
812 
813 
814 
815  // Complete the build of Solid elements so they are fully functional
816  //----------------------------------------------------------------
817  n_element = Solid_mesh_pt->nelement();
818  for(unsigned i=0;i<n_element;i++)
819  {
820  //Cast to a solid element
821  SOLID_ELEMENT *el_pt = dynamic_cast<SOLID_ELEMENT*>(
822  Solid_mesh_pt->element_pt(i));
823 
824  // Set the constitutive law
825  el_pt->constitutive_law_pt() =
826  Global_Parameters::Constitutive_law_pt;
827 
828  // Set the timescale ratio
829  el_pt->lambda_sq_pt() =
830  &Global_Parameters::Lambda_sq;
831  }
832 
833 
834  // Setup FSI
835  //----------
836 
837  // The velocity of the fluid nodes on the fsi boundary
838  // is set by the wall motion -- hence the no-slip condition must be
839  // re-applied whenever a node update is performed for these nodes.
840  // Such tasks may be performed automatically by the auxiliary node update
841  // function specified by a function pointer:
842  n=nfluid_fsi_boundary();
843  for (unsigned i=0;i<n;i++)
844  {
845  // Get boundary ID
846  unsigned b=Fluid_fsi_boundary_id[i];
847 
848  // How many nodes on boundary b?
849  unsigned num_nod = Fluid_mesh_pt->nboundary_node(b);
850 
851  for (unsigned inod=0;inod<num_nod;inod++)
852  {
853  Fluid_mesh_pt->boundary_node_pt(b,inod)->
854  set_auxiliary_node_update_fct_pt(
855  FSI_functions::apply_no_slip_on_moving_wall);
856  }
857  }
858 
859 
860  // Work out which fluid dofs affect the residuals of the wall elements:
861  // We pass the boundary between the fluid and solid meshes and
862  // pointers to the meshes.
863  n=nsolid_fsi_boundary();
864  for (unsigned i=0;i<n;i++)
865  {
866  // Sanity check: Doc boundary coordinates from solid side
867  doc_solid_boundary_coordinates(i);
868 
869  //Doc boundary coordinates in fluid
870  char filename[100];
871  sprintf(filename,"RESLT/fluid_boundary_coordinates%i.dat",i);
872  Multi_domain_functions::Doc_boundary_coordinate_file.open(filename);
873 
874  // Setup FSI: Pass ID of fluid FSI boundary and associated
875  // mesh of solid fsi traction elements.
876  FSI_functions::setup_fluid_load_info_for_solid_elements<FLUID_ELEMENT,3>
877  (this,Fluid_fsi_boundary_id[i],Fluid_mesh_pt,Solid_fsi_traction_mesh_pt[i]);
878 
879  // Close the doc file
880  Multi_domain_functions::Doc_boundary_coordinate_file.close();
881  }
882 
883  // Setup equation numbering scheme
884  std::cout <<"Number of equations: " << assign_eqn_numbers() << std::endl;
885 
886 }
i
int i
Definition: BiCGSTAB_step_by_step.cpp:9
n
const unsigned n
Definition: CG3DPackingUnitTest.cpp:11
e
Array< double, 1, 3 > e(1./3., 0.5, 2.)
b
Scalar * b
Definition: benchVecAdd.cpp:17
NonRefineableBinArray::Default_n_bin_1d
static unsigned Default_n_bin_1d
Default number of bins (in each coordinate direction)
Definition: sample_point_container.h:860
UnstructuredFSIProblem::Solid_outer_boundary_id
Vector< unsigned > Solid_outer_boundary_id
IDs of solid mesh boundaries which make up the outer surface.
Definition: unsteady_vmtk_fsi.cc:273
UnstructuredFSIProblem::Solid_mesh_pt
SolidTetgenMesh< SOLID_ELEMENT > * Solid_mesh_pt
Bulk solid mesh.
Definition: unsteady_vmtk_fsi.cc:240
UnstructuredFSIProblem::npinned_solid_boundary
unsigned npinned_solid_boundary()
Definition: unsteady_vmtk_fsi.cc:235
UnstructuredFSIProblem::Fluid_mesh_pt
SolidTetgenMesh< FLUID_ELEMENT > * Fluid_mesh_pt
Bulk fluid mesh.
Definition: unsteady_vmtk_fsi.cc:246
UnstructuredFSIProblem::nsolid_fsi_boundary
unsigned nsolid_fsi_boundary()
Definition: unsteady_vmtk_fsi.cc:225
UnstructuredFSIProblem::nfluid_traction_boundary
unsigned nfluid_traction_boundary()
Definition: unsteady_vmtk_fsi.cc:220
UnstructuredFSIProblem::Pinned_solid_boundary_id
Vector< unsigned > Pinned_solid_boundary_id
IDs of solid mesh boundaries where displacements are pinned.
Definition: unsteady_vmtk_fsi.cc:267
UnstructuredFSIProblem::Solid_fsi_boundary_id
Vector< unsigned > Solid_fsi_boundary_id
IDs of solid mesh boundaries which make up the FSI interface.
Definition: unsteady_vmtk_fsi.cc:270
UnstructuredFSIProblem::doc_solid_boundary_coordinates
void doc_solid_boundary_coordinates()
Sanity check: Doc boundary coordinates from solid side.
Definition: unstructured_two_d_fsi.cc:563
UnstructuredFSIProblem::create_lagrange_multiplier_elements
void create_lagrange_multiplier_elements()
Definition: unsteady_vmtk_fsi.cc:941
UnstructuredFSIProblem::nfluid_inflow_traction_boundary
unsigned nfluid_inflow_traction_boundary()
Definition: unsteady_vmtk_fsi.cc:210
UnstructuredFSIProblem::Lagrange_multiplier_mesh_pt
Vector< SolidMesh * > Lagrange_multiplier_mesh_pt
Meshes of Lagrange multiplier elements.
Definition: unsteady_vmtk_fsi.cc:261
UnstructuredFSIProblem::nfluid_fsi_boundary
unsigned nfluid_fsi_boundary()
Definition: unsteady_vmtk_fsi.cc:230
UnstructuredFSIProblem::Solid_fsi_traction_mesh_pt
Vector< SolidMesh * > Solid_fsi_traction_mesh_pt
Meshes of FSI traction elements.
Definition: unsteady_vmtk_fsi.cc:243
UnstructuredFSIProblem::create_parallel_flow_lagrange_elements
void create_parallel_flow_lagrange_elements()
Create Lagrange multiplier elements that impose parallel flow.
Definition: unsteady_vmtk_fsi.cc:995
UnstructuredFSIProblem::create_fsi_traction_elements
void create_fsi_traction_elements()
Create FSI traction elements.
Definition: unsteady_vmtk_fsi.cc:894
UnstructuredFSIProblem::Inflow_flux_monitor_mesh_pt
Mesh * Inflow_flux_monitor_mesh_pt
Mesh containing the FaceElements that monitor the inflow.
Definition: unsteady_vmtk_fsi.cc:249
UnstructuredFSIProblem::Inflow_boundary_id
Vector< unsigned > Inflow_boundary_id
Definition: unsteady_vmtk_fsi.cc:277
UnstructuredFSIProblem::Parallel_flow_lagrange_multiplier_mesh_pt
Vector< Mesh * > Parallel_flow_lagrange_multiplier_mesh_pt
Meshes of Lagrange multiplier elements that impose parallel flow.
Definition: unsteady_vmtk_fsi.cc:258
UnstructuredFSIProblem::Inflow_flux_control_mesh_pt
Mesh * Inflow_flux_control_mesh_pt
Mesh of FaceElements that control the inflow.
Definition: unsteady_vmtk_fsi.cc:252
UnstructuredFSIProblem::nfluid_outflow_traction_boundary
unsigned nfluid_outflow_traction_boundary()
Definition: unsteady_vmtk_fsi.cc:215
UnstructuredFSIProblem::Inflow_flux_control_master_mesh_pt
Mesh * Inflow_flux_control_master_mesh_pt
Mesh containing the master flux control element.
Definition: unsteady_vmtk_fsi.cc:255
UnstructuredFSIProblem::Wall_thickness
double Wall_thickness
Definition: unsteady_vmtk_fsi.cc:288
UnstructuredFSIProblem::Outflow_boundary_id
Vector< unsigned > Outflow_boundary_id
Definition: unsteady_vmtk_fsi.cc:281
UnstructuredFSIProblem::Fluid_fsi_boundary_id
Vector< unsigned > Fluid_fsi_boundary_id
IDs of fluid mesh boundaries which make up the FSI interface.
Definition: unsteady_vmtk_fsi.cc:284
oomph::BoundaryNodeBase::index_of_first_value_assigned_by_face_element
unsigned index_of_first_value_assigned_by_face_element(const unsigned &face_id=0) const
Definition: nodes.h:2061
oomph::BoundaryNode
Definition: nodes.h:2242
oomph::Data::pin
void pin(const unsigned &i)
Pin the i-th stored variable.
Definition: nodes.h:385
oomph::FiniteElement::size
double size() const
Definition: elements.cc:4290
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::finite_element_pt
FiniteElement * finite_element_pt(const unsigned &e) const
Definition: mesh.h:473
oomph::Mesh::element_pt
GeneralisedElement *& element_pt(const unsigned long &e)
Return pointer to element e.
Definition: mesh.h:448
oomph::Mesh::nnode
unsigned long nnode() const
Return number of nodes in the mesh.
Definition: mesh.h:596
oomph::Mesh::nelement
unsigned long nelement() const
Return number of elements in the mesh.
Definition: mesh.h:590
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::Node::is_on_boundary
virtual bool is_on_boundary() const
Definition: nodes.h:1373
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::SolidMesh
Definition: mesh.h:2562
oomph::SolidMesh::scale_mesh
void scale_mesh(const double &factor)
Definition: mesh.h:2669
oomph::SolidMesh::node_pt
SolidNode * node_pt(const unsigned long &n)
Return a pointer to the n-th global SolidNode.
Definition: mesh.h:2594
oomph::SolidMesh::set_lagrangian_nodal_coordinates
void set_lagrangian_nodal_coordinates()
Definition: mesh.cc:9564
oomph::SolidMesh::boundary_node_pt
SolidNode * boundary_node_pt(const unsigned &b, const unsigned &n)
Return n-th SolidNodes on b-th boundary.
Definition: mesh.h:2612
oomph::SolidNode
Definition: nodes.h:1686
oomph::SolidNode::pin_position
void pin_position(const unsigned &i)
Pin the nodal position.
Definition: nodes.h:1816
FLUID_ELEMENT
#define FLUID_ELEMENT
k
char char char int int * k
Definition: level2_impl.h:374
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::Parallel_flow_lagrange_multiplier_id
@ Parallel_flow_lagrange_multiplier_id
Definition: unsteady_vmtk_fsi.cc:93
Global_Parameters::FSI_interface_displacement_lagrange_multiplier_id
@ FSI_interface_displacement_lagrange_multiplier_id
Definition: unsteady_vmtk_fsi.cc:94
Global_Parameters::Re
double Re
reynolds number
Definition: adaptive_hopf.cc:54
Global_Parameters::Constitutive_law_pt
ConstitutiveLaw * Constitutive_law_pt
Pointer to constitutive law.
Definition: interaction/turek_flag/turek_flag.cc:87
Global_Parameters::Prescribe_pressure
bool Prescribe_pressure
Boolean to choose if inflow pressure (true) or volume flux are prescribed.
Definition: unsteady_vmtk_fsi.cc:67
MergeRestartFiles.filename
string filename
Definition: MergeRestartFiles.py:39
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
oomph::oomph_info
OomphInfo oomph_info
Definition: oomph_definitions.cc:319
j
std::ptrdiff_t j
Definition: tut_arithmetic_redux_minmax.cpp:2

References oomph::FSI_functions::apply_no_slip_on_moving_wall(), b, Global_Parameters::Constitutive_law_pt, NonRefineableBinArray::Default_n_bin_1d, oomph::Multi_domain_functions::Doc_boundary_coordinate_file, e(), MergeRestartFiles::filename, FLUID_ELEMENT, Global_Parameters::FSI_interface_displacement_lagrange_multiplier_id, i, oomph::BoundaryNodeBase::index_of_first_value_assigned_by_face_element(), oomph::Node::is_on_boundary(), j, k, Global_Parameters::Lambda_sq, n, oomph::oomph_info, Global_Parameters::Parallel_flow_lagrange_multiplier_id, oomph::Data::pin(), oomph::SolidNode::pin_position(), Global_Parameters::Prescribe_pressure, Global_Parameters::Re, and oomph::Node::x().

◆ ~UnstructuredFSIProblem() [1/5]

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

Destructor (empty)

116 {}

◆ UnstructuredFSIProblem() [2/5]

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

Constructor:

◆ ~UnstructuredFSIProblem() [2/5]

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

Destructor (empty)

117 {}

◆ UnstructuredFSIProblem() [3/5]

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

Constructor.

◆ ~UnstructuredFSIProblem() [3/5]

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

Destructor (empty)

282 {}

◆ UnstructuredFSIProblem() [4/5]

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

Constructor:

◆ ~UnstructuredFSIProblem() [4/5]

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

Destructor (empty)

221 {}

◆ UnstructuredFSIProblem() [5/5]

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

Constructor:

◆ ~UnstructuredFSIProblem() [5/5]

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

Destructor (empty)

203 {}

Member Function Documentation

◆ actions_after_adapt()

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::actions_after_adapt ( )
inlinevirtual

Actions after adapt.

Reimplemented from oomph::Problem.

136  {
137  //Ensure that the lagrangian coordinates of the mesh are set to be
138  //the same as the eulerian
139  Fluid_mesh_pt->set_lagrangian_nodal_coordinates();
140 
141  //Apply boundary conditions again
142 
143  // Pin both positions at lower boundary (boundary 3)
144  unsigned ibound=3;
145  unsigned num_nod= Solid_mesh_pt->nboundary_node(ibound);
146  for (unsigned inod=0;inod<num_nod;inod++)
147  {
148 
149  // Get node
150  SolidNode* nod_pt=Solid_mesh_pt->boundary_node_pt(ibound,inod);
151 
152  // Pin both directions
153  for (unsigned i=0;i<2;i++)
154  {
155  nod_pt->pin_position(i);
156  }
157  }
158 
159  // Complete the build of all elements so they are fully functional
160  unsigned n_element = Solid_mesh_pt->nelement();
161  for(unsigned i=0;i<n_element;i++)
162  {
163  //Cast to a solid element
164  SOLID_ELEMENT *el_pt =
165  dynamic_cast<SOLID_ELEMENT*>(Solid_mesh_pt->element_pt(i));
166 
167  // Set the constitutive law
168  el_pt->constitutive_law_pt() =
169  Global_Physical_Variables::Constitutive_law_pt;
170  } // end complete solid build
171 
172 
173  // Set the boundary conditions for fluid problem: All nodes are
174  // free by default
175  // --- just pin the ones that have Dirichlet conditions here.
176 
177  //Pin velocity everywhere apart from parallel outflow (boundary 4)
178  unsigned nbound=Fluid_mesh_pt->nboundary();
179  for(unsigned ibound=0;ibound<nbound;ibound++)
180  {
181  unsigned num_nod=Fluid_mesh_pt->nboundary_node(ibound);
182  for (unsigned inod=0;inod<num_nod;inod++)
183  {
184  // Pin velocity everywhere apart from outlet where we
185  // have parallel outflow
186  if (ibound!=4)
187  {
188  Fluid_mesh_pt->boundary_node_pt(ibound,inod)->pin(0);
189  }
190  Fluid_mesh_pt->boundary_node_pt(ibound,inod)->pin(1);
191 
192  // Pin pseudo-solid positions everywhere apart from boundaries 0, 1, 2
193  // the fsi boundaries
194  if(ibound > 2)
195  {
196  for(unsigned i=0;i<2;i++)
197  {
198  // Pin the node
199  SolidNode* nod_pt=Fluid_mesh_pt->boundary_node_pt(ibound,inod);
200  nod_pt->pin_position(i);
201  }
202  }
203  }
204  } // end loop over boundaries
205 
206 
207  // Complete the build of the fluid elements so they are fully functional
208  n_element = Fluid_mesh_pt->nelement();
209  for(unsigned e=0;e<n_element;e++)
210  {
211  // Upcast from GeneralisedElement to the present element
212  FLUID_ELEMENT* el_pt =
213  dynamic_cast<FLUID_ELEMENT*>(Fluid_mesh_pt->element_pt(e));
214 
215  //Set the Reynolds number
216  el_pt->re_pt() = &Global_Physical_Variables::Re;
217 
218  // Set the constitutive law for pseudo-elastic mesh deformation
219  el_pt->constitutive_law_pt() =
220  Global_Physical_Variables::Mesh_constitutive_law_pt;
221 
222  } // end loop over elements
223 
224 
225  // Apply fluid boundary conditions: Poiseuille at inflow
226  const unsigned n_boundary = Fluid_mesh_pt->nboundary();
227  for (unsigned ibound=0;ibound<n_boundary;ibound++)
228  {
229  const unsigned num_nod= Fluid_mesh_pt->nboundary_node(ibound);
230  for (unsigned inod=0;inod<num_nod;inod++)
231  {
232  // Parabolic inflow at the left boundary (boundary 6)
233  if(ibound==6)
234  {
235  double y=Fluid_mesh_pt->boundary_node_pt(ibound,inod)->x(1);
236  double veloc = y*(1.0-y);
237  Fluid_mesh_pt->boundary_node_pt(ibound,inod)->set_value(0,veloc);
238  Fluid_mesh_pt->boundary_node_pt(ibound,inod)->set_value(1,0.0);
239  }
240  // Zero flow elsewhere
241  else
242  {
243  Fluid_mesh_pt->boundary_node_pt(ibound,inod)->set_value(0,0.0);
244  Fluid_mesh_pt->boundary_node_pt(ibound,inod)->set_value(1,0.0);
245  }
246  }
247  } // end Poiseuille
248 
249  //Recreate the boundary elements
250  this->create_fsi_traction_elements();
251  this->create_lagrange_multiplier_elements();
252 
253  //Rebuild the global mesh
254  this->rebuild_global_mesh();
255 
256  // Setup FSI (again)
257  //------------------
258  // Work out which fluid dofs affect the residuals of the wall elements:
259  // We pass the boundary between the fluid and solid meshes and
260  // pointers to the meshes. The interaction boundary are boundaries 0, 1 and 2
261  // of the 2D fluid mesh.
262  for(unsigned b=0;b<3;b++)
263  {
264  FSI_functions::setup_fluid_load_info_for_solid_elements<FLUID_ELEMENT,2>
265  (this,b,Fluid_mesh_pt,Traction_mesh_pt[b]);
266  }
267 
268  }
UnstructuredFSIProblem::Traction_mesh_pt
Vector< SolidMesh * > Traction_mesh_pt
Vectors of pointers to mesh of traction elements.
Definition: unstructured_adaptive_2d_fsi.cc:477
oomph::Data::set_value
void set_value(const unsigned &i, const double &value_)
Definition: nodes.h:271
oomph::Mesh::nboundary
unsigned nboundary() const
Return number of boundaries.
Definition: mesh.h:827
oomph::Problem::rebuild_global_mesh
void rebuild_global_mesh()
Definition: problem.cc:1533
y
Scalar * y
Definition: level1_cplx_impl.h:128
Global_Physical_Variables::Constitutive_law_pt
ConstitutiveLaw * Constitutive_law_pt
Pointer to constitutive law.
Definition: TwenteMeshGluing.cpp:65
Global_Physical_Variables::Mesh_constitutive_law_pt
ConstitutiveLaw * Mesh_constitutive_law_pt
Pointer to constitutive law for the mesh.
Definition: unstructured_adaptive_2d_fsi.cc:98
Global_Physical_Variables::Re
double Re
Reynolds number.
Definition: fibre.cc:55

References b, Global_Physical_Variables::Constitutive_law_pt, e(), FLUID_ELEMENT, i, Global_Physical_Variables::Mesh_constitutive_law_pt, oomph::SolidNode::pin_position(), Global_Physical_Variables::Re, and y.

◆ actions_before_adapt()

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::actions_before_adapt ( )
inlinevirtual

Actions before adapt.

Reimplemented from oomph::Problem.

124  {
125  //Delete the boundary meshes
126  this->delete_lagrange_multiplier_elements();
127  this->delete_fsi_traction_elements();
128 
129  //Rebuild the global mesh
130  this->rebuild_global_mesh();
131  }
UnstructuredFSIProblem::delete_fsi_traction_elements
void delete_fsi_traction_elements()
Delete the traction elements.
Definition: unstructured_adaptive_2d_fsi.cc:320
UnstructuredFSIProblem::delete_lagrange_multiplier_elements
void delete_lagrange_multiplier_elements()
Delete the traction elements.
Definition: unstructured_adaptive_2d_fsi.cc:412

◆ actions_before_implicit_timestep()

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::actions_before_implicit_timestep ( )
inlinevirtual

Actions before timestep.

Reimplemented from oomph::Problem.

133  {
134  // Get the current time
135  double time=time_pt()->time();
136 
137  // Change inflow conditions
138  if (Global_Parameters::Prescribe_pressure)
139  {
140  Global_Parameters::P_in=Global_Parameters::P_in_max*
141  cos(2.0*MathematicalConstants::Pi/Global_Parameters::Period*time);
142  }
143  else
144  {
145  Global_Parameters::Prescribed_flow_rate=
146  Global_Parameters::Peak_prescribed_flow_rate*
147  cos(2.0*MathematicalConstants::Pi/Global_Parameters::Period*time);
148  cout << "New imposed prescribed flow rate: "
149  << Global_Parameters::Prescribed_flow_rate << std::endl;
150  }
151  }
cos
AnnoyingScalar cos(const AnnoyingScalar &x)
Definition: AnnoyingScalar.h:136
oomph::Problem::time_pt
Time *& time_pt()
Return a pointer to the global time object.
Definition: problem.h:1504
oomph::Problem::time
double & time()
Return the current value of continuous time.
Definition: problem.cc:11531
oomph::Time::time
double & time()
Return the current value of the continuous time.
Definition: timesteppers.h:123
BiharmonicTestFunctions2::Pi
double Pi
Definition: two_d_biharmonic.cc:235
Global_Parameters::P_in
double P_in
Fluid pressure on inflow boundary.
Definition: unsteady_vmtk_fsi.cc:76
Global_Parameters::P_in_max
double P_in_max
Max. inflow pressure (during periodic variation)
Definition: unsteady_vmtk_fsi.cc:70
Global_Parameters::Peak_prescribed_flow_rate
double Peak_prescribed_flow_rate
Peak prescribed flow rate.
Definition: unsteady_vmtk_fsi.cc:82
Global_Parameters::Prescribed_flow_rate
double Prescribed_flow_rate
Prescribed flow rate.
Definition: unsteady_vmtk_fsi.cc:85
Global_Parameters::Period
double Period
Period of periodic variation in inflow pressure.
Definition: unsteady_vmtk_fsi.cc:73

References cos(), Global_Parameters::P_in, Global_Parameters::P_in_max, Global_Parameters::Peak_prescribed_flow_rate, Global_Parameters::Period, BiharmonicTestFunctions2::Pi, Global_Parameters::Prescribe_pressure, and Global_Parameters::Prescribed_flow_rate.

◆ actions_before_newton_convergence_check()

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

Update no slip bc after update of unknowns.

Reimplemented from oomph::Problem.

156  {
157  // The velocity of the fluid nodes on the fsi boundary
158  // is set by the wall motion -- hence the no-slip condition must be
159  // re-applied whenever a node update is performed for these nodes.
160  // Such tasks may be performed automatically by the auxiliary node update
161  // function specified by a function pointer:
162  unsigned n=nfluid_fsi_boundary();
163  for (unsigned i=0;i<n;i++)
164  {
165  // Get boundary ID
166  unsigned b=Fluid_fsi_boundary_id[i];
167 
168  // How many nodes on boundary b?
169  unsigned num_nod = Fluid_mesh_pt->nboundary_node(b);
170  for (unsigned inod=0;inod<num_nod;inod++)
171  {
172  FSI_functions::apply_no_slip_on_moving_wall(
173  Fluid_mesh_pt->boundary_node_pt(b,inod));
174  }
175  }
176 
177 
178  }

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

◆ create_fluid_traction_elements()

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::create_fluid_traction_elements

Create fluid traction elements at inflow.

Create fluid traction elements.

807 {
808 
809  // Counter for number of fluid traction meshes
810  unsigned count=0;
811 
812  // Loop over inflow/outflow boundaries
813  for (unsigned in_out=0;in_out<2;in_out++)
814  {
815  // Loop over boundaries with fluid traction elements
816  unsigned n=nfluid_inflow_traction_boundary();
817  if (in_out==1) n=nfluid_outflow_traction_boundary();
818  for (unsigned i=0;i<n;i++)
819  {
820 
821  // Get boundary ID
822  unsigned b=0;
823  if (in_out==0)
824  {
825  b=Inflow_boundary_id[i];
826  }
827  else
828  {
829  b=Outflow_boundary_id[i];
830  }
831 
832  // How many bulk elements are adjacent to boundary b?
833  unsigned n_element = Fluid_mesh_pt->nboundary_element(b);
834 
835  // Loop over the bulk elements adjacent to boundary b
836  for(unsigned e=0;e<n_element;e++)
837  {
838  // Get pointer to the bulk element that is adjacent to boundary b
839  FLUID_ELEMENT* bulk_elem_pt = dynamic_cast<FLUID_ELEMENT*>(
840  Fluid_mesh_pt->boundary_element_pt(b,e));
841 
842  //What is the index of the face of the element e along boundary b
843  int face_index = Fluid_mesh_pt->face_index_at_boundary(b,e);
844 
845  // Create new element
846  NavierStokesTractionElement<FLUID_ELEMENT>* el_pt=
847  new NavierStokesTractionElement<FLUID_ELEMENT>(bulk_elem_pt,
848  face_index);
849 
850  // Add it to the mesh
851  Fluid_traction_mesh_pt[count]->add_element_pt(el_pt);
852 
853  // Set the pointer to the prescribed traction function
854  if (in_out==0)
855  {
856  el_pt->traction_fct_pt() =
857  &Global_Parameters::prescribed_inflow_traction;
858  }
859  else
860  {
861  el_pt->traction_fct_pt() =
862  &Global_Parameters::prescribed_outflow_traction;
863  }
864  }
865  // Bump up counter
866  count++;
867  }
868  }
869 
870  } // end of create_traction_elements
UnstructuredFSIProblem::Fluid_traction_mesh_pt
Vector< Mesh * > Fluid_traction_mesh_pt
Meshes of fluid traction elements that apply pressure at in/outflow.
Definition: unstructured_three_d_fsi.cc:284
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::NavierStokesTractionElement
Definition: fluid_traction_elements.h:55
oomph::NavierStokesTractionElement::traction_fct_pt
void(*&)(const double &t, const Vector< double > &x, const Vector< double > &n, Vector< double > &result) traction_fct_pt()
Definition: fluid_traction_elements.h:186
Global_Parameters::prescribed_outflow_traction
void prescribed_outflow_traction(const double &t, const Vector< double > &x, const Vector< double > &n, Vector< double > &traction)
Applied traction on fluid at the inflow boundary.
Definition: unstructured_three_d_fsi.cc:190
Global_Parameters::prescribed_inflow_traction
void prescribed_inflow_traction(const double &t, const Vector< double > &x, const Vector< double > &n, Vector< double > &traction)
Applied traction on fluid at the inflow boundary.
Definition: unstructured_three_d_fsi.cc:175

References b, e(), FLUID_ELEMENT, i, n, Global_Parameters::prescribed_inflow_traction(), Global_Parameters::prescribed_outflow_traction(), and oomph::NavierStokesTractionElement< ELEMENT >::traction_fct_pt.

◆ create_fsi_traction_elements() [1/5]

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

Create FSI traction elements.

895 {
896 
897  // Loop over FSI boundaries in solid
898  unsigned n=nsolid_fsi_boundary();
899  for (unsigned i=0;i<n;i++)
900  {
901  // Get boundary ID
902  unsigned b=Solid_fsi_boundary_id[i];
903 
904  // How many bulk elements are adjacent to boundary b?
905  unsigned n_element = Solid_mesh_pt->nboundary_element(b);
906 
907  // Loop over the bulk elements adjacent to boundary b
908  for(unsigned e=0;e<n_element;e++)
909  {
910  // Get pointer to the bulk element that is adjacent to boundary b
911  SOLID_ELEMENT* bulk_elem_pt = dynamic_cast<SOLID_ELEMENT*>(
912  Solid_mesh_pt->boundary_element_pt(b,e));
913 
914  //What is the index of the face of the element e along boundary b
915  int face_index = Solid_mesh_pt->face_index_at_boundary(b,e);
916 
917  // Create new element
918  FSISolidTractionElement<SOLID_ELEMENT,3>* el_pt=
919  new FSISolidTractionElement<SOLID_ELEMENT,3>(bulk_elem_pt,face_index);
920 
921  // Add it to the mesh
922  Solid_fsi_traction_mesh_pt[i]->add_element_pt(el_pt);
923 
924  // Specify boundary number
925  el_pt->set_boundary_number_in_bulk_mesh(b);
926 
927  // Function that specifies the load ratios
928  el_pt->q_pt() = &Global_Parameters::Q;
929  }
930  }
931 
932 } // end of create_fsi_traction_elements
oomph::FSISolidTractionElement
Definition: solid_traction_elements.h:780
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
Global_Parameters::Q
double Q
FSI parameter.
Definition: acoustic_fsi.cc:58

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

◆ create_fsi_traction_elements() [2/5]

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

Create the traction element.

286  {
287  // Traction elements are located on boundaries 0 1 and 2 of solid bulk mesh
288  for(unsigned b=0;b<3;++b)
289  {
290  // How many bulk elements are adjacent to boundary b?
291  const unsigned n_element = Solid_mesh_pt->nboundary_element(b);
292 
293  // Loop over the bulk elements adjacent to boundary b
294  for(unsigned e=0;e<n_element;e++)
295  {
296  // Get pointer to the bulk element that is adjacent to boundary b
297  SOLID_ELEMENT* bulk_elem_pt = dynamic_cast<SOLID_ELEMENT*>(
298  Solid_mesh_pt->boundary_element_pt(b,e));
299 
300  //What is the index of the face of the element e along boundary b
301  int face_index = Solid_mesh_pt->face_index_at_boundary(b,e);
302 
303  // Create new element
304  FSISolidTractionElement<SOLID_ELEMENT,2>* el_pt=
305  new FSISolidTractionElement<SOLID_ELEMENT,2>(bulk_elem_pt,face_index);
306 
307  // Add it to the mesh
308  Traction_mesh_pt[b]->add_element_pt(el_pt);
309 
310  // Specify boundary number
311  el_pt->set_boundary_number_in_bulk_mesh(b);
312 
313  // Function that specifies the load ratios
314  el_pt->q_pt() = &Global_Physical_Variables::Q;
315  }
316  }
317  }
Global_Physical_Variables::Q
double Q
Ratio of scales.
Definition: elastic_bretherton.cc:131

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

◆ create_fsi_traction_elements() [3/5]

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

Create FSI traction elements.

◆ create_fsi_traction_elements() [4/5]

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

Create FSI traction elements.

◆ create_fsi_traction_elements() [5/5]

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

Create FSI traction elements.

◆ create_lagrange_multiplier_elements() [1/5]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void UnstructuredFSIProblem< 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

942 {
943  // Make space
944  unsigned n=nfluid_fsi_boundary();
945  Solid_fsi_boundary_pt.resize(n);
946 
947  // Loop over FSI interfaces in fluid
948  for (unsigned i=0;i<n;i++)
949  {
950  // Get boundary ID
951  unsigned b=Fluid_fsi_boundary_id[i];
952 
953  // Create GeomObject incarnation of fsi boundary in solid mesh
954  Solid_fsi_boundary_pt[i]=
955  new MeshAsGeomObject(Solid_fsi_traction_mesh_pt[i]);
956 
957  // How many bulk fluid elements are adjacent to boundary b?
958  unsigned n_element = Fluid_mesh_pt->nboundary_element(b);
959 
960  // Loop over the bulk fluid elements adjacent to boundary b?
961  for(unsigned e=0;e<n_element;e++)
962  {
963  // Get pointer to the bulk fluid element that is adjacent to boundary b
964  FLUID_ELEMENT* bulk_elem_pt = dynamic_cast<FLUID_ELEMENT*>(
965  Fluid_mesh_pt->boundary_element_pt(b,e));
966 
967  //Find the index of the face of element e along boundary b
968  int face_index = Fluid_mesh_pt->face_index_at_boundary(b,e);
969 
970  // Create new element
971  ImposeDisplacementByLagrangeMultiplierElement<FLUID_ELEMENT>* el_pt =
972  new ImposeDisplacementByLagrangeMultiplierElement<FLUID_ELEMENT>(
973  bulk_elem_pt,face_index,
974  Global_Parameters::FSI_interface_displacement_lagrange_multiplier_id);
975 
976  // Add it to the mesh
977  Lagrange_multiplier_mesh_pt[i]->add_element_pt(el_pt);
978 
979  // Set the GeomObject that defines the boundary shape and set
980  // which bulk boundary we are attached to (needed to extract
981  // the boundary coordinate from the bulk nodes)
982  el_pt->set_boundary_shape_geom_object_pt(Solid_fsi_boundary_pt[i],b);
983  }
984  }
985 
986 } // end of create_lagrange_multiplier_elements
UnstructuredFSIProblem::Solid_fsi_boundary_pt
Vector< MeshAsGeomObject * > Solid_fsi_boundary_pt
GeomObject incarnations of the FSI boundary in the solid mesh.
Definition: unsteady_vmtk_fsi.cc:264
oomph::ImposeDisplacementByLagrangeMultiplierElement
Definition: solid_traction_elements.h:1107
oomph::ImposeDisplacementByLagrangeMultiplierElement::set_boundary_shape_geom_object_pt
void set_boundary_shape_geom_object_pt(GeomObject *boundary_shape_geom_object_pt, const unsigned &boundary_number_in_bulk_mesh)
Definition: solid_traction_elements.h:1209
oomph::MeshAsGeomObject
Definition: mesh_as_geometric_object.h:93

References b, e(), FLUID_ELEMENT, Global_Parameters::FSI_interface_displacement_lagrange_multiplier_id, i, n, and oomph::ImposeDisplacementByLagrangeMultiplierElement< ELEMENT >::set_boundary_shape_geom_object_pt().

◆ create_lagrange_multiplier_elements() [2/5]

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

Create the multipliers that add lagrange multipliers to the fluid elements that apply the solid displacement conditions

341  {
342  //Loop over the FSI boundaries
343  for(unsigned b=0;b<3;b++)
344  {
345  // Create GeomObject incarnation of fsi boundary in solid mesh
346  Solid_fsi_boundary_pt[b] = new MeshAsGeomObject(Traction_mesh_pt[b]);
347 
348  // How many bulk fluid elements are adjacent to boundary b?
349  unsigned n_element = Fluid_mesh_pt->nboundary_element(b);
350 
351  // Loop over the bulk fluid elements adjacent to boundary b?
352  for(unsigned e=0;e<n_element;e++)
353  {
354  // Get pointer to the bulk fluid element that is adjacent to boundary b
355  FLUID_ELEMENT* bulk_elem_pt = dynamic_cast<FLUID_ELEMENT*>(
356  Fluid_mesh_pt->boundary_element_pt(b,e));
357 
358  //Find the index of the face of element e along boundary b
359  int face_index = Fluid_mesh_pt->face_index_at_boundary(b,e);
360 
361  // Create new element
362  ImposeDisplacementByLagrangeMultiplierElement<FLUID_ELEMENT>* el_pt =
363  new ImposeDisplacementByLagrangeMultiplierElement<FLUID_ELEMENT>(
364  bulk_elem_pt,face_index);
365 
366  // Add it to the mesh
367  Lagrange_multiplier_mesh_pt[b]->add_element_pt(el_pt);
368 
369  // Set the GeomObject that defines the boundary shape and set
370  // which bulk boundary we are attached to (needed to extract
371  // the boundary coordinate from the bulk nodes)
372  el_pt->set_boundary_shape_geom_object_pt(Solid_fsi_boundary_pt[b],b);
373 
374  // Loop over the nodes to apply boundary conditions
375  unsigned nnod=el_pt->nnode();
376  for (unsigned j=0;j<nnod;j++)
377  {
378  Node* nod_pt = el_pt->node_pt(j);
379 
380  // How many nodal values were used by the "bulk" element
381  // that originally created this node?
382  unsigned n_bulk_value=el_pt->nbulk_value(j);
383 
384  // The remaining ones are Lagrange multipliers
385  unsigned nval=nod_pt->nvalue();
386  //If we have more than two Lagrange multipliers, pin the rest
387  if(nval > n_bulk_value + 2)
388  {
389  for (unsigned j=n_bulk_value+2;j<nval;j++)
390  {
391  nod_pt->pin(j);
392  }
393  }
394 
395  //If I'm also on one of the base boundaries, pin the Lagrange
396  //Multipliers
397  if((nod_pt->is_on_boundary(7)) || (nod_pt->is_on_boundary(3)))
398  {
399  for(unsigned j=n_bulk_value;j<nval;j++)
400  {
401  nod_pt->pin(j);
402  }
403  }
404 
405  }
406  }
407  }
408  } // end of create_lagrange_multiplier_elements
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

References b, e(), FLUID_ELEMENT, 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() [3/5]

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

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

◆ create_lagrange_multiplier_elements() [4/5]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void UnstructuredFSIProblem< 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() [5/5]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void UnstructuredFSIProblem< 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_parallel_flow_lagrange_elements() [1/2]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::create_parallel_flow_lagrange_elements

Create Lagrange multiplier elements that impose parallel flow.

996 {
997  // Counter for number of Lagrange multiplier elements
998  unsigned count=0;
999 
1000  // Loop over inflow/outflow boundaries
1001  for (unsigned in_out=0;in_out<2;in_out++)
1002  {
1003  // Loop over boundaries with fluid traction elements
1004  unsigned n=nfluid_inflow_traction_boundary();
1005  if (in_out==1) n=nfluid_outflow_traction_boundary();
1006  for (unsigned i=0;i<n;i++)
1007  {
1008  // Get boundary ID
1009  unsigned b=0;
1010  if (in_out==0)
1011  {
1012  b=Inflow_boundary_id[i];
1013  }
1014  else
1015  {
1016  b=Outflow_boundary_id[i];
1017  }
1018 
1019  // How many bulk elements are adjacent to boundary b?
1020  unsigned n_element = Fluid_mesh_pt->nboundary_element(b);
1021 
1022  // Loop over the bulk elements adjacent to boundary b
1023  for(unsigned e=0;e<n_element;e++)
1024  {
1025  // Get pointer to the bulk element that is adjacent to boundary b
1026  FLUID_ELEMENT* bulk_elem_pt = dynamic_cast<FLUID_ELEMENT*>(
1027  Fluid_mesh_pt->boundary_element_pt(b,e));
1028 
1029  //What is the index of the face of the element e along boundary b
1030  int face_index = Fluid_mesh_pt->face_index_at_boundary(b,e);
1031 
1032  // Build the corresponding Lagrange multiplier element
1033  ImposeParallelOutflowElement<FLUID_ELEMENT>* el_pt
1034  = new ImposeParallelOutflowElement<FLUID_ELEMENT>
1035  (bulk_elem_pt, face_index,
1036  Global_Parameters::Parallel_flow_lagrange_multiplier_id);
1037 
1038  // Add it to the mesh
1039  Parallel_flow_lagrange_multiplier_mesh_pt[count]->add_element_pt(el_pt);
1040 
1041  // Set the pointer to the prescribed pressure
1042  if (in_out==0)
1043  {
1044 
1045  // Attach elements that monitor volume flux (etc).
1046  NavierStokesSurfacePowerElement<FLUID_ELEMENT>* power_element_pt = new
1047  NavierStokesSurfacePowerElement<FLUID_ELEMENT>(
1048  bulk_elem_pt,face_index);
1049 
1050  //Add the elements to the mesh
1051  Inflow_flux_monitor_mesh_pt->add_element_pt(power_element_pt);
1052 
1053  // Pressure or flux control
1054  if (Global_Parameters::Prescribe_pressure)
1055  {
1056  // Set inflow pressure
1057  el_pt->pressure_pt()= &Global_Parameters::P_in;
1058  }
1059  else
1060  {
1061  // Build the flux control element
1062  NavierStokesFluxControlElement<FLUID_ELEMENT>* flux_element_pt = new
1063  NavierStokesFluxControlElement<FLUID_ELEMENT>(bulk_elem_pt,
1064  face_index);
1065 
1066  //Add the new element to its mesh
1067  Inflow_flux_control_mesh_pt->add_element_pt(flux_element_pt);
1068  }
1069  }
1070  else
1071  {
1072  el_pt->pressure_pt()= &Global_Parameters::P_out;
1073  }
1074  //end of element setup
1075 
1076 
1077  }
1078  // Bump up counter
1079  count++;
1080  }
1081  }
1082 
1083  // Build master flux control element
1084  if (!Global_Parameters::Prescribe_pressure)
1085  {
1086  // Build master element
1087  NetFluxControlElement* flux_control_el_pt =
1088  new NetFluxControlElement(Inflow_flux_control_mesh_pt,
1089  &Global_Parameters::Prescribed_flow_rate);
1090 
1091  // Add NetFluxControlElement to its own mesh
1092  Inflow_flux_control_master_mesh_pt->add_element_pt(flux_control_el_pt);
1093 
1094  // Get pointer to the inflow pressure data
1095  Global_Parameters::P_in_data_pt = flux_control_el_pt->pressure_data_pt();
1096 
1097  // Loop over the elements in the sub mesh and add P_in_data_pt
1098  // to external data
1099  unsigned n_el = Inflow_flux_control_mesh_pt->nelement();
1100  for (unsigned e=0; e< n_el; e++)
1101  {
1102  // Get pointer to the element
1103  GeneralisedElement* el_pt = Inflow_flux_control_mesh_pt->element_pt(e);
1104 
1105  // Dynamic cast
1106  dynamic_cast<NavierStokesFluxControlElement<FLUID_ELEMENT>* >(el_pt)->
1107  add_pressure_data(Global_Parameters::P_in_data_pt);
1108  }
1109 
1110  }
1111 
1112 } // end of create_parallel_flow_lagrange_elements
oomph::GeneralisedElement
Definition: elements.h:73
oomph::ImposeParallelOutflowElement
Definition: impose_parallel_outflow_element.h:46
oomph::ImposeParallelOutflowElement::pressure_pt
double *& pressure_pt()
Access function for the pressure.
Definition: impose_parallel_outflow_element.h:129
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::NavierStokesFluxControlElement
Definition: navier_stokes_flux_control_elements.h:351
oomph::NavierStokesSurfacePowerElement
Definition: navier_stokes_surface_power_elements.h:52
oomph::NetFluxControlElement
Definition: flux_control_elements_bk.h:54
oomph::NetFluxControlElement::pressure_data_pt
Data * pressure_data_pt() const
Definition: flux_control_elements_bk.h:104
Global_Parameters::P_out
double P_out
Fluid pressure on outflow boundary.
Definition: unsteady_vmtk_fsi.cc:79
Global_Parameters::P_in_data_pt
Data * P_in_data_pt
Definition: unsteady_vmtk_fsi.cc:89

References b, e(), FLUID_ELEMENT, i, n, Global_Parameters::P_in, Global_Parameters::P_in_data_pt, Global_Parameters::P_out, Global_Parameters::Parallel_flow_lagrange_multiplier_id, Global_Parameters::Prescribe_pressure, Global_Parameters::Prescribed_flow_rate, oomph::NetFluxControlElement< ELEMENT >::pressure_data_pt(), and oomph::ImposeParallelOutflowElement< ELEMENT >::pressure_pt().

◆ create_parallel_flow_lagrange_elements() [2/2]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::create_parallel_flow_lagrange_elements ( )

Create Lagrange multiplier elements that impose parallel flow.

◆ delete_fsi_traction_elements()

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::delete_fsi_traction_elements ( )
inlineprivate

Delete the traction elements.

321  {
322  //There are three traction element boundaries
323  for(unsigned b=0;b<3;++b)
324  {
325  const unsigned n_element = Traction_mesh_pt[b]->nelement();
326  //Delete the elements
327  for(unsigned e=0;e<n_element;e++)
328  {
329  delete Traction_mesh_pt[b]->element_pt(e);
330  }
331  //Wipe the mesh
332  Traction_mesh_pt[b]->flush_element_and_node_storage();
333  //Also wipe out the Mesh as Geometric objects
334  delete Solid_fsi_boundary_pt[b]; Solid_fsi_boundary_pt[b] = 0;
335  }
336  }

References b, and e().

◆ delete_lagrange_multiplier_elements()

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::delete_lagrange_multiplier_elements ( )
inlineprivate

Delete the traction elements.

413  {
414  //There are three Lagrange-multiplier element boundaries
415  for(unsigned b=0;b<3;++b)
416  {
417  const unsigned n_element = Lagrange_multiplier_mesh_pt[b]->nelement();
418  //Delete the elements
419  for(unsigned e=0;e<n_element;e++)
420  {
421  delete Lagrange_multiplier_mesh_pt[b]->element_pt(e);
422  }
423  //Wipe the mesh
424  Lagrange_multiplier_mesh_pt[b]->flush_element_and_node_storage();
425  }
426  }

References b, and e().

◆ doc_parameters()

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

Doc parameters.

182  {
183  std::cout << "\n\n=================================================\n";
184  std::cout << "Average wall thickness: " << Wall_thickness
185  << std::endl << std::endl;
186  double speed_index=
187  sqrt(Global_Parameters::Q/(0.5*Wall_thickness*Global_Parameters::Re));
188  std::cout << "Q : " << Global_Parameters::Q << std::endl;
189  std::cout << "Re : " << Global_Parameters::Re
190  << std::endl;
191  std::cout << "Period : " << Global_Parameters::Period
192  <<std::endl;
193  std::cout << "Speed index : " << speed_index << std::endl;
194  std::cout << "Wavelength : "
195  << Global_Parameters::Period/speed_index << std::endl;
196  double alpha_sq=Global_Parameters::Re/Global_Parameters::Period;
197  std::cout << "Square of Womersley : "
198  << alpha_sq << std::endl;
199  std::cout << "=================================================\n\n";
200  }
sqrt
AnnoyingScalar sqrt(const AnnoyingScalar &x)
Definition: AnnoyingScalar.h:134

References Global_Parameters::Period, Global_Parameters::Q, Global_Parameters::Re, and sqrt().

◆ doc_solid_boundary_coordinates() [1/4]

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

Sanity check: Doc boundary coordinates from solid side.

Doc boundary coordinates in solid and plot GeomObject representation of FSI boundary.

564 {
565 
566  // Doc boundary coordinates for fsi boundary in solid mesh
567  std::ofstream the_file("solid_boundary_test.dat");
568 
569  // Initialise max/min boundary coordinate
570  double zeta_min= 1.0e40;
571  double zeta_max=-1.0e40;
572 
573  // Loop over FSI traction elements
574  unsigned n_face_element = Traction_mesh_pt->nelement();
575  for(unsigned e=0;e<n_face_element;e++)
576  {
577  //Cast the element pointer
578  FSISolidTractionElement<SOLID_ELEMENT,2>* el_pt=
579  dynamic_cast<FSISolidTractionElement<SOLID_ELEMENT,2>*>
580  (Traction_mesh_pt->element_pt(e));
581 
582  // Doc boundary coordinate
583  Vector<double> s(1);
584  Vector<double> zeta(1);
585  Vector<double> x(2);
586  unsigned n_plot=5;
587  the_file << el_pt->tecplot_zone_string(n_plot);
588 
589  // Loop over plot points
590  unsigned num_plot_points=el_pt->nplot_points(n_plot);
591  for (unsigned iplot=0;iplot<num_plot_points;iplot++)
592  {
593  // Get local coordinates of plot point
594  el_pt->get_s_plot(iplot,n_plot,s);
595  el_pt->interpolated_zeta(s,zeta);
596  el_pt->interpolated_x(s,x);
597  for (unsigned i=0;i<2;i++)
598  {
599  the_file << x[i] << " ";
600  }
601  the_file << zeta[0] << " ";
602 
603  // Update max/min boundary coordinate
604  if (zeta[0]<zeta_min) zeta_min=zeta[0];
605  if (zeta[0]>zeta_max) zeta_max=zeta[0];
606 
607  the_file << std::endl;
608  }
609  }
610 
611  // Close doc file
612  the_file.close();
613 
614 
615  // Doc compound GeomObject
616  the_file.open("fsi_geom_object.dat");
617  unsigned nplot=10000;
618  Vector<double> zeta(1);
619  Vector<double> r(2);
620  for (unsigned i=0;i<nplot;i++)
621  {
622  zeta[0]=zeta_min+(zeta_max-zeta_min)*double(i)/double(nplot-1);
623  Solid_fsi_boundary_pt->position(zeta,r);
624  the_file << r[0] << " " << r[1] << std::endl;
625  }
626  the_file.close();
627 
628 } //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
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
UniformPSDSelfTest.r
r
Definition: UniformPSDSelfTest.py:20
plotDoE.x
list x
Definition: plotDoE.py:28

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

◆ doc_solid_boundary_coordinates() [2/4]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::doc_solid_boundary_coordinates ( const unsigned &  i)
private

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

Doc boundary coordinates of i-th solid FSI boundary.

1122 {
1123 
1124  //Doc boundary coordinates in fluid
1125  char filename[100];
1126  sprintf(filename,"RESLT/solid_boundary_coordinates%i.dat",i);
1127  std::ofstream the_file(filename);
1128 
1129  // Loop over traction elements
1130  unsigned n_face_element = Solid_fsi_traction_mesh_pt[i]->nelement();
1131  for(unsigned e=0;e<n_face_element;e++)
1132  {
1133  //Cast the element pointer
1134  FSISolidTractionElement<SOLID_ELEMENT,3>* el_pt=
1135  dynamic_cast<FSISolidTractionElement<SOLID_ELEMENT,3>*>
1136  (Solid_fsi_traction_mesh_pt[i]->element_pt(e));
1137 
1138  // Doc boundary coordinate
1139  Vector<double> s(2);
1140  Vector<double> zeta(2);
1141  Vector<double> x(3);
1142  unsigned n_plot=3;
1143  the_file << el_pt->tecplot_zone_string(n_plot);
1144 
1145  // Loop over plot points
1146  unsigned num_plot_points=el_pt->nplot_points(n_plot);
1147  for (unsigned iplot=0;iplot<num_plot_points;iplot++)
1148  {
1149  // Get local coordinates of plot point
1150  el_pt->get_s_plot(iplot,n_plot,s);
1151  el_pt->interpolated_zeta(s,zeta);
1152  el_pt->interpolated_x(s,x);
1153  for (unsigned i=0;i<3;i++)
1154  {
1155  the_file << x[i] << " ";
1156  }
1157  for (unsigned i=0;i<2;i++)
1158  {
1159  the_file << zeta[i] << " ";
1160  }
1161 
1162  the_file << std::endl;
1163  }
1164  el_pt->write_tecplot_zone_footer(the_file,n_plot);
1165  }
1166 
1167  // Close doc file
1168  the_file.close();
1169 
1170 } // end doc_solid_zeta
oomph::FiniteElement::write_tecplot_zone_footer
virtual void write_tecplot_zone_footer(std::ostream &outfile, const unsigned &nplot) const
Definition: elements.h:3174

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() [3/4]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::doc_solid_boundary_coordinates ( const unsigned &  i)
private

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

◆ doc_solid_boundary_coordinates() [4/4]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::doc_solid_boundary_coordinates ( const unsigned &  i)
private

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

◆ doc_solution() [1/5]

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

Doc the solution.

1179 {
1180 
1181 
1182  // Elements can still be inverted near boundary
1183  // even if they're non-inverted at the 3D Gauss points
1184  // thus code can die here when evaluating the fluid traction
1185  // Deal with this later...
1186  FiniteElement::Accept_negative_jacobian=true;
1187 
1188  ofstream some_file;
1189  char filename[100];
1190 
1191  // Number of plot points
1192  unsigned npts;
1193  npts=5;
1194 
1195  // Output solid boundaries
1196  //------------------------
1197  sprintf(filename,"%s/solid_boundaries%i.dat",doc_info.directory().c_str(),
1198  doc_info.number());
1199  some_file.open(filename);
1200  Solid_mesh_pt->output_boundaries(some_file);
1201  some_file.close();
1202 
1203 
1204  // Output solid solution
1205  //-----------------------
1206  sprintf(filename,"%s/solid_soln%i.dat",doc_info.directory().c_str(),
1207  doc_info.number());
1208  some_file.open(filename);
1209  Solid_mesh_pt->output(some_file,npts);
1210  some_file.close();
1211 
1212 
1213  // Output fluid boundaries
1214  //------------------------
1215  sprintf(filename,"%s/fluid_boundaries%i.dat",doc_info.directory().c_str(),
1216  doc_info.number());
1217  some_file.open(filename);
1218  Fluid_mesh_pt->output_boundaries(some_file);
1219  some_file.close();
1220 
1221 
1222  // Output fluid solution
1223  //-----------------------
1224  sprintf(filename,"%s/fluid_soln%i.dat",doc_info.directory().c_str(),
1225  doc_info.number());
1226  some_file.open(filename);
1227  Fluid_mesh_pt->output(some_file,npts);
1228  some_file.close();
1229 
1230 
1231  // Output fsi traction
1232  //--------------------
1233  sprintf(filename,"%s/fsi_traction%i.dat",doc_info.directory().c_str(),
1234  doc_info.number());
1235  some_file.open(filename);
1236  unsigned n=nsolid_fsi_boundary();
1237  for (unsigned i=0;i<n;i++)
1238  {
1239  Solid_fsi_traction_mesh_pt[i]->output(some_file,npts);
1240  }
1241  some_file.close();
1242 
1243 
1244 
1245  // Document the volume flux at inflow
1246  double inflow_volume_flux = 0.0;
1247  unsigned nel = Inflow_flux_monitor_mesh_pt->nelement();
1248  for (unsigned e=0;e<nel;e++)
1249  {
1250  NavierStokesSurfacePowerElement<FLUID_ELEMENT>* el_pt=dynamic_cast<
1251  NavierStokesSurfacePowerElement<FLUID_ELEMENT>*>(
1252  Inflow_flux_monitor_mesh_pt->element_pt(e));
1253  inflow_volume_flux += el_pt->get_volume_flux();
1254  }
1255  cout << "Volume flux at inflow: " << inflow_volume_flux << std::endl;
1256 
1257 
1258 } // 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
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::NavierStokesSurfacePowerElement::get_volume_flux
double get_volume_flux()
Get integral of volume flux.
Definition: navier_stokes_surface_power_elements.h:704

References oomph::DocInfo::directory(), e(), MergeRestartFiles::filename, oomph::NavierStokesSurfacePowerElement< ELEMENT >::get_volume_flux(), i, n, and oomph::DocInfo::number().

◆ doc_solution() [2/5]

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

Doc the solution.

◆ doc_solution() [3/5]

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

Doc the solution.

◆ doc_solution() [4/5]

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

Doc the solution.

◆ doc_solution() [5/5]

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

Doc the solution.

◆ fluid_mesh_pt()

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
FluidTriangleMesh<FLUID_ELEMENT>*& UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::fluid_mesh_pt ( )
inline

Access function for the fluid mesh.

286  {
287  return Fluid_mesh_pt;
288  }

◆ get_fluid_dissipation()

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
double UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::get_fluid_dissipation ( )
inlineprivate

Calculate the fluid dissipation.

450  {
451  double dissipation=0.0;
452  const unsigned n_element = Fluid_mesh_pt->nelement();
453  for(unsigned e=0;e<n_element;e++)
454  {
455  //Cast to a fluid element
456  FLUID_ELEMENT *el_pt =
457  dynamic_cast<FLUID_ELEMENT*>(Fluid_mesh_pt->element_pt(e));
458  //Add to the dissipation
459  dissipation += el_pt->dissipation();
460  }
461  return dissipation;
462  }

References e(), and FLUID_ELEMENT.

◆ get_solid_strain_energy()

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
double UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::get_solid_strain_energy ( )
inlineprivate

Calculate the strain energy of the solid.

432  {
433  double strain_energy=0.0;
434  const unsigned n_element = Solid_mesh_pt->nelement();
435  for(unsigned e=0;e<n_element;e++)
436  {
437  //Cast to a solid element
438  SOLID_ELEMENT *el_pt =
439  dynamic_cast<SOLID_ELEMENT*>(Solid_mesh_pt->element_pt(e));
440 
441  double pot_en, kin_en;
442  el_pt->get_energy(pot_en,kin_en);
443  strain_energy += pot_en;
444  }
445  return strain_energy;
446  }

References e().

◆ nfluid_fsi_boundary() [1/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
unsigned UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::nfluid_fsi_boundary ( )
inlineprivate

Return total number of mesh boundaries in the fluid mesh that make up the FSI interface

231  {return Fluid_fsi_boundary_id.size();}

◆ nfluid_fsi_boundary() [2/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
unsigned UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::nfluid_fsi_boundary ( )
inlineprivate

Return total number of mesh boundaries in the fluid mesh that make up the FSI interface

265  {return Fluid_fsi_boundary_id.size();}

◆ nfluid_fsi_boundary() [3/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
unsigned UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::nfluid_fsi_boundary ( )
inlineprivate

Return total number of mesh boundaries in the fluid mesh that make up the FSI interface

247  {return Fluid_fsi_boundary_id.size();}

◆ nfluid_inflow_traction_boundary() [1/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
unsigned UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::nfluid_inflow_traction_boundary ( )
inlineprivate

Return total number of mesh boundaries that make up the inflow boundary

211  {return Inflow_boundary_id.size();}

◆ nfluid_inflow_traction_boundary() [2/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
unsigned UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::nfluid_inflow_traction_boundary ( )
inlineprivate

Return total number of mesh boundaries that make up the inflow boundary

245  {return Inflow_boundary_id.size();}

◆ nfluid_inflow_traction_boundary() [3/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
unsigned UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::nfluid_inflow_traction_boundary ( )
inlineprivate

Return total number of mesh boundaries that make up the inflow boundary

227  {return Inflow_boundary_id.size();}

◆ nfluid_outflow_traction_boundary() [1/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
unsigned UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::nfluid_outflow_traction_boundary ( )
inlineprivate

Return total number of mesh boundaries that make up the outflow boundary

216  {return Outflow_boundary_id.size();}

◆ nfluid_outflow_traction_boundary() [2/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
unsigned UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::nfluid_outflow_traction_boundary ( )
inlineprivate

Return total number of mesh boundaries that make up the outflow boundary

250  {return Outflow_boundary_id.size();}

◆ nfluid_outflow_traction_boundary() [3/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
unsigned UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::nfluid_outflow_traction_boundary ( )
inlineprivate

Return total number of mesh boundaries that make up the outflow boundary

232  {return Outflow_boundary_id.size();}

◆ nfluid_traction_boundary() [1/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
unsigned UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::nfluid_traction_boundary ( )
inlineprivate

Return total number of mesh boundaries that make up the in- and outflow boundaries where a traction has to be applied

221  {return Inflow_boundary_id.size()+Outflow_boundary_id.size();}

◆ nfluid_traction_boundary() [2/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
unsigned UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::nfluid_traction_boundary ( )
inlineprivate

Return total number of mesh boundaries that make up the in- and outflow boundaries where a traction has to be applied

255  {return Inflow_boundary_id.size()+Outflow_boundary_id.size();}

◆ nfluid_traction_boundary() [3/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
unsigned UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::nfluid_traction_boundary ( )
inlineprivate

Return total number of mesh boundaries that make up the in- and outflow boundaries where a traction has to be applied

237  {return Inflow_boundary_id.size()+Outflow_boundary_id.size();}

◆ npinned_solid_boundary() [1/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
unsigned UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::npinned_solid_boundary ( )
inlineprivate

Return total number of mesh boundaries in the solid mesh where the position is pinned.

236  {return Pinned_solid_boundary_id.size();}

◆ npinned_solid_boundary() [2/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
unsigned UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::npinned_solid_boundary ( )
inlineprivate

Return total number of mesh boundaries in the solid mesh where the position is pinned.

270  {return Pinned_solid_boundary_id.size();}

◆ npinned_solid_boundary() [3/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
unsigned UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::npinned_solid_boundary ( )
inlineprivate

Return total number of mesh boundaries in the solid mesh where the position is pinned.

252  {return Pinned_solid_boundary_id.size();}

◆ nsolid_fsi_boundary() [1/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
unsigned UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::nsolid_fsi_boundary ( )
inlineprivate

Return total number of mesh boundaries in the solid mesh that make up the FSI interface

226  {return Solid_fsi_boundary_id.size();}

◆ nsolid_fsi_boundary() [2/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
unsigned UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::nsolid_fsi_boundary ( )
inlineprivate

Return total number of mesh boundaries in the solid mesh that make up the FSI interface

260  {return Solid_fsi_boundary_id.size();}

◆ nsolid_fsi_boundary() [3/3]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
unsigned UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::nsolid_fsi_boundary ( )
inlineprivate

Return total number of mesh boundaries in the solid mesh that make up the FSI interface

242  {return Solid_fsi_boundary_id.size();}

◆ output_strain_and_dissipation()

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
void UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::output_strain_and_dissipation ( std::ostream &  trace)
inline

Output function to compute the strain energy in the solid and the dissipation in the fluid and write to the output stream trace

273  {
274  double strain_energy = this->get_solid_strain_energy();
275  double dissipation = this->get_fluid_dissipation();
276 
277  trace << Global_Physical_Variables::Q <<
278  " " << dissipation << " " << strain_energy << std::endl;
279  }
UnstructuredFSIProblem::get_solid_strain_energy
double get_solid_strain_energy()
Calculate the strain energy of the solid.
Definition: unstructured_adaptive_2d_fsi.cc:431
UnstructuredFSIProblem::get_fluid_dissipation
double get_fluid_dissipation()
Calculate the fluid dissipation.
Definition: unstructured_adaptive_2d_fsi.cc:449

References Global_Physical_Variables::Q.

◆ solid_mesh_pt()

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
MySolidTriangleMesh<SOLID_ELEMENT>*& UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::solid_mesh_pt ( )
inline

Access function for the solid mesh.

292  {
293  return Solid_mesh_pt;
294  }

Member Data Documentation

◆ Fluid_fsi_boundary_id

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
Vector< unsigned > UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::Fluid_fsi_boundary_id
private

IDs of fluid mesh boundaries which make up the FSI interface.

◆ Fluid_mesh_pt [1/5]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
SolidTetgenMesh<FLUID_ELEMENT>* UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::Fluid_mesh_pt
private

Bulk fluid mesh.

◆ Fluid_mesh_pt [2/5]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
RefineableSolidTriangleMesh<FLUID_ELEMENT>* UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::Fluid_mesh_pt

Bulk fluid mesh.

◆ Fluid_mesh_pt [3/5]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
FluidTriangleMesh<FLUID_ELEMENT>* UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::Fluid_mesh_pt
private

Fluid mesh.

◆ Fluid_mesh_pt [4/5]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
FluidTetMesh<FLUID_ELEMENT>* UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::Fluid_mesh_pt
private

Bulk fluid mesh.

◆ Fluid_mesh_pt [5/5]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
MyFluidTetMesh<FLUID_ELEMENT>* UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::Fluid_mesh_pt
private

Bulk fluid mesh.

◆ Fluid_outer_boundary_polyline_pt

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
TriangleMeshPolygon* UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::Fluid_outer_boundary_polyline_pt
private

Triangle mesh polygon for outer boundary.

◆ Fluid_traction_mesh_pt

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
Vector<Mesh*> UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::Fluid_traction_mesh_pt
private

Meshes of fluid traction elements that apply pressure at in/outflow.

◆ Inflow_boundary_id

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
Vector< unsigned > UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::Inflow_boundary_id
private

IDs of fluid mesh boundaries along which inflow boundary conditions are applied

◆ Inflow_flux_control_master_mesh_pt

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
Mesh* UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::Inflow_flux_control_master_mesh_pt
private

Mesh containing the master flux control element.

◆ Inflow_flux_control_mesh_pt

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
Mesh* UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::Inflow_flux_control_mesh_pt
private

Mesh of FaceElements that control the inflow.

◆ Inflow_flux_monitor_mesh_pt

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
Mesh* UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::Inflow_flux_monitor_mesh_pt
private

Mesh containing the FaceElements that monitor the inflow.

◆ Lagrange_multiplier_mesh_pt [1/2]

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

Meshes of Lagrange multiplier elements.

Vector of pointers to mesh of Lagrange multiplier elements.

◆ Lagrange_multiplier_mesh_pt [2/2]

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

Pointers to mesh of Lagrange multiplier elements.

◆ Outflow_boundary_id

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
Vector< unsigned > UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::Outflow_boundary_id
private

IDs of fluid mesh boundaries along which inflow boundary conditions are applied

◆ Parallel_flow_lagrange_multiplier_mesh_pt

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
Vector< Mesh * > UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::Parallel_flow_lagrange_multiplier_mesh_pt
private

Meshes of Lagrange multiplier elements that impose parallel flow.

◆ Pinned_solid_boundary_id

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
Vector< unsigned > UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::Pinned_solid_boundary_id
private

IDs of solid mesh boundaries where displacements are pinned.

◆ Solid_fsi_boundary_id

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
Vector< unsigned > UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::Solid_fsi_boundary_id
private

IDs of solid mesh boundaries which make up the FSI interface.

◆ Solid_fsi_boundary_pt [1/2]

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

GeomObject incarnations of the FSI boundary in the solid mesh.

◆ Solid_fsi_boundary_pt [2/2]

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

GeomObject incarnation of fsi boundary in solid mesh.

◆ Solid_fsi_traction_mesh_pt

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

Meshes of FSI traction elements.

◆ Solid_mesh_pt [1/4]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
MySolidTetgenMesh< SOLID_ELEMENT > * UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::Solid_mesh_pt
private

Bulk solid mesh.

◆ Solid_mesh_pt [2/4]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
RefineableSolidTriangleMesh<SOLID_ELEMENT>* UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::Solid_mesh_pt
private

Bulk solid mesh.

◆ Solid_mesh_pt [3/4]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
MySolidTriangleMesh<SOLID_ELEMENT>* UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::Solid_mesh_pt
private

Solid mesh.

◆ Solid_mesh_pt [4/4]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
MySolidTetgenMesh<SOLID_ELEMENT>* UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::Solid_mesh_pt
private

Bulk solid mesh.

◆ Solid_outer_boundary_id

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
Vector<unsigned> UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::Solid_outer_boundary_id
private

IDs of solid mesh boundaries which make up the outer surface.

◆ Solid_outer_boundary_polyline_pt

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
TriangleMeshPolygon* UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::Solid_outer_boundary_polyline_pt
private

Triangle mesh polygon for outer boundary.

◆ Traction_mesh_pt [1/2]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
Vector<SolidMesh*> UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::Traction_mesh_pt
private

Vectors of pointers to mesh of traction elements.

◆ Traction_mesh_pt [2/2]

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
SolidMesh* UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::Traction_mesh_pt
private

Vector of pointers to mesh of FSI traction elements.

◆ Wall_thickness

template<class FLUID_ELEMENT , class SOLID_ELEMENT >
double UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::Wall_thickness
private

Average wall thickness (computed from area of fsi interface and volume of solid mesh.

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