Public Member Functions | List of all members
PreconditionedFSICollapsibleChannelProblem< ELEMENT > Class Template Reference

Problem class. More...

+ Inheritance diagram for PreconditionedFSICollapsibleChannelProblem< ELEMENT >:

Public Member Functions

 PreconditionedFSICollapsibleChannelProblem (const unsigned &nup, const unsigned &ncollapsible, const unsigned &ndown, const unsigned &ny, const double &lup, const double &lcollapsible, const double &ldown, const double &ly, const bool &displ_control, const bool &steady_flag, const unsigned &solver_flag, const unsigned &solver_sub_flag)
 
 ~PreconditionedFSICollapsibleChannelProblem ()
 Destructor (empty) More...
 
void actions_before_newton_convergence_check ()
 
void actions_before_newton_solve ()
 Actions before solve. Reset counter for number of Newton iterations. More...
 
void actions_after_newton_solve ()
 
- Public Member Functions inherited from FSICollapsibleChannelProblem< ELEMENT >
 FSICollapsibleChannelProblem (const unsigned &nup, const unsigned &ncollapsible, const unsigned &ndown, const unsigned &ny, const double &lup, const double &lcollapsible, const double &ldown, const double &ly, const bool &displ_control, const bool &steady_flag)
 Constructor for the collapsible channel problem. More...
 
 ~FSICollapsibleChannelProblem ()
 Destructor. More...
 
virtual void steady_run ()
 Steady run. More...
 
virtual void unsteady_run (const double &dt=0.1)
 Unsteady run. Specify timestep or use default of 0.1. More...
 
AlgebraicCollapsibleChannelMesh< ELEMENT > * bulk_mesh_pt ()
 Access function for the specific bulk (fluid) mesh. More...
 
OneDLagrangianMesh< FSIHermiteBeamElement > * wall_mesh_pt ()
 Access function for the wall mesh. More...
 
void actions_before_newton_solve ()
 Actions before solve. Reset counter for number of Newton iterations. More...
 
void actions_after_newton_solve ()
 Update the problem after solve (empty) More...
 
void actions_before_newton_convergence_check ()
 
virtual void doc_solution_steady (DocInfo &doc_info, ofstream &trace_file, const double &cpu, const unsigned &niter)
 Doc the steady solution. More...
 
virtual void doc_solution_unsteady (DocInfo &doc_info, ofstream &trace_file, const double &cpu, const unsigned &niter)
 Doc the unsteady solution. More...
 
void set_initial_condition ()
 Apply initial conditions. More...
 
 FSICollapsibleChannelProblem (const unsigned &nup, const unsigned &ncollapsible, const unsigned &ndown, const unsigned &ny, const double &lup, const double &lcollapsible, const double &ldown, const double &ly)
 Constructor for the collapsible channel problem. More...
 
 ~FSICollapsibleChannelProblem ()
 Destructor (empty) More...
 
AlgebraicCollapsibleChannelMesh< ELEMENT > * bulk_mesh_pt ()
 Access function for the specific bulk (fluid) mesh. More...
 
OneDLagrangianMesh< FSIHermiteBeamElement > * wall_mesh_pt ()
 Access function for the wall mesh. More...
 
void actions_before_newton_solve ()
 Update the problem specs before solve (empty) More...
 
void actions_after_newton_solve ()
 Update the problem after solve (empty) More...
 
void actions_before_newton_convergence_check ()
 
void doc_solution (DocInfo &doc_info, ofstream &trace_file)
 Doc the solution. More...
 
void set_initial_condition ()
 Apply initial conditions. More...
 
 FSICollapsibleChannelProblem (const unsigned &nup, const unsigned &ncollapsible, const unsigned &ndown, const unsigned &ny, const double &lup, const double &lcollapsible, const double &ldown, const double &ly)
 
 ~FSICollapsibleChannelProblem ()
 Destructor (empty) More...
 
RefineableAlgebraicCollapsibleChannelMesh< ELEMENT > * bulk_mesh_pt ()
 Access function for the specific bulk (fluid) mesh. More...
 
OneDLagrangianMesh< FSIHermiteBeamElement > * wall_mesh_pt ()
 Access function for the wall mesh. More...
 
void actions_before_adapt ()
 Actions before adapt: Wipe the mesh of prescribed traction elements. More...
 
void actions_after_adapt ()
 Actions after adapt: Rebuild the mesh of prescribed traction elements. More...
 
void actions_before_newton_solve ()
 Update the problem specs before solve (empty) More...
 
void actions_after_newton_solve ()
 Update the problem after solve (empty) More...
 
void actions_before_newton_convergence_check ()
 
void doc_solution (DocInfo &doc_info, ofstream &trace_file)
 Doc the solution. More...
 
void set_initial_condition ()
 Apply initial conditions. More...
 
 FSICollapsibleChannelProblem (const unsigned &nup, const unsigned &ncollapsible, const unsigned &ndown, const unsigned &ny, const double &lup, const double &lcollapsible, const double &ldown, const double &ly)
 
 ~FSICollapsibleChannelProblem ()
 Destructor (empty) More...
 
ElasticCollapsibleChannelMesh< ELEMENT > * bulk_mesh_pt ()
 Access function for the specific bulk (fluid) mesh. More...
 
OneDLagrangianMesh< FSIHermiteBeamElement > * wall_mesh_pt ()
 Access function for the wall mesh. More...
 
void actions_before_newton_solve ()
 Update the problem specs before solve (empty) More...
 
void actions_after_newton_solve ()
 Update the problem after solve (empty) More...
 
void actions_before_newton_convergence_check ()
 Update no slip before Newton convergence check. More...
 
void doc_solution (DocInfo &doc_info, ofstream &trace_file)
 Doc the solution. More...
 
void set_initial_condition ()
 Apply initial conditions. More...
 
 FSICollapsibleChannelProblem (const unsigned &nup, const unsigned &ncollapsible, const unsigned &ndown, const unsigned &ny, const double &lup, const double &lcollapsible, const double &ldown, const double &ly)
 
 ~FSICollapsibleChannelProblem ()
 Destructor (empty) More...
 
ElasticRefineableCollapsibleChannelMesh< ELEMENT > * bulk_mesh_pt ()
 Access function for the specific bulk (fluid) mesh. More...
 
OneDLagrangianMesh< FSIHermiteBeamElement > * wall_mesh_pt ()
 Access function for the wall mesh. More...
 
void actions_before_adapt ()
 Actions before adapt: Wipe the mesh of prescribed traction elements. More...
 
void actions_after_adapt ()
 
void actions_before_newton_solve ()
 Update the problem specs before solve (empty) More...
 
void actions_after_newton_solve ()
 Update the problem after solve (empty) More...
 
void actions_before_newton_convergence_check ()
 Update no slip before Newton convergence check. More...
 
void doc_solution (DocInfo &doc_info, ofstream &trace_file)
 Doc the solution. More...
 
void set_initial_condition ()
 Apply initial conditions. More...
 
 FSICollapsibleChannelProblem (const unsigned &nup, const unsigned &ncollapsible, const unsigned &ndown, const unsigned &ny, const double &lup, const double &lcollapsible, const double &ldown, const double &ly)
 
 ~FSICollapsibleChannelProblem ()
 Destructor (empty) More...
 
RefineableAlgebraicCollapsibleChannelMesh< ELEMENT > * bulk_mesh_pt ()
 Access function for the specific bulk (fluid) mesh. More...
 
OneDLagrangianMesh< FSIHermiteBeamElement > *& wall_mesh_pt ()
 Access function for the wall mesh. More...
 
void actions_before_adapt ()
 Actions before adapt: Wipe the mesh of prescribed traction elements. More...
 
void actions_after_adapt ()
 
void actions_before_distribute ()
 Actions before distribute: wipe the mesh of prescribed traction elements. More...
 
void actions_after_distribute ()
 Actions after distribute: create traction elements and reset FSI. More...
 
void actions_before_newton_solve ()
 Update the problem specs before solve (empty) More...
 
void actions_after_newton_solve ()
 Update the problem after solve (empty) More...
 
void actions_before_newton_convergence_check ()
 
void doc_solution (DocInfo &doc_info, ofstream &trace_file)
 Doc the solution. More...
 
void set_initial_condition ()
 Apply initial conditions. More...
 
 FSICollapsibleChannelProblem (const unsigned &nup, const unsigned &ncollapsible, const unsigned &ndown, const unsigned &ny, const double &lup, const double &lcollapsible, const double &ldown, const double &ly, const bool &wall_jacobian_ignores_fluid_shear_stress_data, const bool &wall_jacobian_ignores_geometric_data, const bool &fluid_jacobian_ignores_geometric_data)
 Constructor for the collapsible channel problem. More...
 
 ~FSICollapsibleChannelProblem ()
 Destructor (empty) More...
 
AlgebraicCollapsibleChannelMesh< ELEMENT > * bulk_mesh_pt ()
 Access function for the specific bulk (fluid) mesh. More...
 
OneDLagrangianMesh< FSIHermiteBeamElement > * wall_mesh_pt ()
 Access function for the wall mesh. More...
 
void actions_before_newton_solve ()
 Update the problem specs before solve (empty) More...
 
void actions_after_newton_solve ()
 Update the problem after solve (empty) More...
 
void actions_before_newton_convergence_check ()
 
void doc_solution (DocInfo &doc_info, ofstream &trace_file)
 Doc the solution. More...
 
void set_initial_condition ()
 Apply initial conditions. More...
 
- Public Member Functions inherited from oomph::Problem
virtual void debug_hook_fct (const unsigned &i)
 
void set_analytic_dparameter (double *const &parameter_pt)
 
void unset_analytic_dparameter (double *const &parameter_pt)
 
bool is_dparameter_calculated_analytically (double *const &parameter_pt)
 
void set_analytic_hessian_products ()
 
void unset_analytic_hessian_products ()
 
bool are_hessian_products_calculated_analytically ()
 
void set_pinned_values_to_zero ()
 
bool distributed () const
 
OomphCommunicator * communicator_pt ()
 access function to the oomph-lib communicator More...
 
const OomphCommunicator * communicator_pt () const
 access function to the oomph-lib communicator, const version More...
 
 Problem ()
 
 Problem (const Problem &dummy)=delete
 Broken copy constructor. More...
 
void operator= (const Problem &)=delete
 Broken assignment operator. More...
 
virtual ~Problem ()
 Virtual destructor to clean up memory. More...
 
Mesh *& mesh_pt ()
 Return a pointer to the global mesh. More...
 
Mesh *const & mesh_pt () const
 Return a pointer to the global mesh (const version) More...
 
Mesh *& mesh_pt (const unsigned &imesh)
 
Mesh *const & mesh_pt (const unsigned &imesh) const
 Return a pointer to the i-th submesh (const version) More...
 
unsigned nsub_mesh () const
 Return number of submeshes. More...
 
unsigned add_sub_mesh (Mesh *const &mesh_pt)
 
void flush_sub_meshes ()
 
void build_global_mesh ()
 
void rebuild_global_mesh ()
 
LinearSolver *& linear_solver_pt ()
 Return a pointer to the linear solver object. More...
 
LinearSolver *const & linear_solver_pt () const
 Return a pointer to the linear solver object (const version) More...
 
LinearSolver *& mass_matrix_solver_for_explicit_timestepper_pt ()
 
LinearSolver * mass_matrix_solver_for_explicit_timestepper_pt () const
 
EigenSolver *& eigen_solver_pt ()
 Return a pointer to the eigen solver object. More...
 
EigenSolver *const & eigen_solver_pt () const
 Return a pointer to the eigen solver object (const version) More...
 
Time *& time_pt ()
 Return a pointer to the global time object. More...
 
Time * time_pt () const
 Return a pointer to the global time object (const version). More...
 
double & time ()
 Return the current value of continuous time. More...
 
double time () const
 Return the current value of continuous time (const version) More...
 
TimeStepper *& time_stepper_pt ()
 
const TimeStepper * time_stepper_pt () const
 
TimeStepper *& time_stepper_pt (const unsigned &i)
 Return a pointer to the i-th timestepper. More...
 
ExplicitTimeStepper *& explicit_time_stepper_pt ()
 Return a pointer to the explicit timestepper. More...
 
unsigned long set_timestepper_for_all_data (TimeStepper *const &time_stepper_pt, const bool &preserve_existing_data=false)
 
virtual void shift_time_values ()
 Shift all values along to prepare for next timestep. More...
 
AssemblyHandler *& assembly_handler_pt ()
 Return a pointer to the assembly handler object. More...
 
AssemblyHandler *const & assembly_handler_pt () const
 Return a pointer to the assembly handler object (const version) More...
 
double & minimum_dt ()
 Access function to min timestep in adaptive timestepping. More...
 
double & maximum_dt ()
 Access function to max timestep in adaptive timestepping. More...
 
unsigned & max_newton_iterations ()
 Access function to max Newton iterations before giving up. More...
 
void problem_is_nonlinear (const bool &prob_lin)
 Access function to Problem_is_nonlinear. More...
 
double & max_residuals ()
 
bool & time_adaptive_newton_crash_on_solve_fail ()
 Access function for Time_adaptive_newton_crash_on_solve_fail. More...
 
double & newton_solver_tolerance ()
 
void add_time_stepper_pt (TimeStepper *const &time_stepper_pt)
 
void set_explicit_time_stepper_pt (ExplicitTimeStepper *const &explicit_time_stepper_pt)
 
void initialise_dt (const double &dt)
 
void initialise_dt (const Vector< double > &dt)
 
Data *& global_data_pt (const unsigned &i)
 Return a pointer to the the i-th global data object. More...
 
void add_global_data (Data *const &global_data_pt)
 
void flush_global_data ()
 
LinearAlgebraDistribution *const & dof_distribution_pt () const
 Return the pointer to the dof distribution (read-only) More...
 
unsigned long ndof () const
 Return the number of dofs. More...
 
unsigned ntime_stepper () const
 Return the number of time steppers. More...
 
unsigned nglobal_data () const
 Return the number of global data values. More...
 
unsigned self_test ()
 Self-test: Check meshes and global data. Return 0 for OK. More...
 
void enable_store_local_dof_pt_in_elements ()
 
void disable_store_local_dof_pt_in_elements ()
 
unsigned long assign_eqn_numbers (const bool &assign_local_eqn_numbers=true)
 
void describe_dofs (std::ostream &out= *(oomph_info.stream_pt())) const
 
void enable_discontinuous_formulation ()
 
void disable_discontinuous_formulation ()
 
void get_dofs (DoubleVector &dofs) const
 
void get_dofs (const unsigned &t, DoubleVector &dofs) const
 Return vector of the t'th history value of all dofs. More...
 
void set_dofs (const DoubleVector &dofs)
 Set the values of the dofs. More...
 
void set_dofs (const unsigned &t, DoubleVector &dofs)
 Set the history values of the dofs. More...
 
void set_dofs (const unsigned &t, Vector< double * > &dof_pt)
 
void add_to_dofs (const double &lambda, const DoubleVector &increment_dofs)
 Add lambda x incremenet_dofs[l] to the l-th dof. More...
 
double * global_dof_pt (const unsigned &i)
 
double & dof (const unsigned &i)
 i-th dof in the problem More...
 
double dof (const unsigned &i) const
 i-th dof in the problem (const version) More...
 
double *& dof_pt (const unsigned &i)
 Pointer to i-th dof in the problem. More...
 
double * dof_pt (const unsigned &i) const
 Pointer to i-th dof in the problem (const version) More...
 
virtual void get_inverse_mass_matrix_times_residuals (DoubleVector &Mres)
 
virtual void get_dvaluesdt (DoubleVector &f)
 
virtual void get_residuals (DoubleVector &residuals)
 Get the total residuals Vector for the problem. More...
 
virtual void get_jacobian (DoubleVector &residuals, DenseDoubleMatrix &jacobian)
 
virtual void get_jacobian (DoubleVector &residuals, CRDoubleMatrix &jacobian)
 
virtual void get_jacobian (DoubleVector &residuals, CCDoubleMatrix &jacobian)
 
virtual void get_jacobian (DoubleVector &residuals, SumOfMatrices &jacobian)
 
void get_fd_jacobian (DoubleVector &residuals, DenseMatrix< double > &jacobian)
 Get the full Jacobian by finite differencing. More...
 
void get_derivative_wrt_global_parameter (double *const &parameter_pt, DoubleVector &result)
 
void get_hessian_vector_products (DoubleVectorWithHaloEntries const &Y, Vector< DoubleVectorWithHaloEntries > const &C, Vector< DoubleVectorWithHaloEntries > &product)
 
void solve_eigenproblem (const unsigned &n_eval, Vector< std::complex< double >> &eigenvalue, Vector< DoubleVector > &eigenvector, const bool &steady=true)
 Solve the eigenproblem. More...
 
void solve_eigenproblem (const unsigned &n_eval, Vector< std::complex< double >> &eigenvalue, const bool &steady=true)
 
virtual void get_eigenproblem_matrices (CRDoubleMatrix &mass_matrix, CRDoubleMatrix &main_matrix, const double &shift=0.0)
 
void assign_eigenvector_to_dofs (DoubleVector &eigenvector)
 Assign the eigenvector passed to the function to the dofs. More...
 
void add_eigenvector_to_dofs (const double &epsilon, const DoubleVector &eigenvector)
 
void store_current_dof_values ()
 Store the current values of the degrees of freedom. More...
 
void restore_dof_values ()
 Restore the stored values of the degrees of freedom. More...
 
void enable_jacobian_reuse ()
 
void disable_jacobian_reuse ()
 Disable recycling of Jacobian in Newton iteration. More...
 
bool jacobian_reuse_is_enabled ()
 Is recycling of Jacobian in Newton iteration enabled? More...
 
bool & use_predictor_values_as_initial_guess ()
 
void newton_solve ()
 Use Newton method to solve the problem. More...
 
void enable_globally_convergent_newton_method ()
 enable globally convergent Newton method More...
 
void disable_globally_convergent_newton_method ()
 disable globally convergent Newton method More...
 
void newton_solve (unsigned const &max_adapt)
 
void steady_newton_solve (unsigned const &max_adapt=0)
 
void copy (Problem *orig_problem_pt)
 
virtual Problem * make_copy ()
 
virtual void read (std::ifstream &restart_file, bool &unsteady_restart)
 
virtual void read (std::ifstream &restart_file)
 
virtual void dump (std::ofstream &dump_file) const
 
void dump (const std::string &dump_file_name) const
 
void delete_all_external_storage ()
 
virtual void symmetrise_eigenfunction_for_adaptive_pitchfork_tracking ()
 
double * bifurcation_parameter_pt () const
 
void get_bifurcation_eigenfunction (Vector< DoubleVector > &eigenfunction)
 
void activate_fold_tracking (double *const &parameter_pt, const bool &block_solve=true)
 
void activate_bifurcation_tracking (double *const &parameter_pt, const DoubleVector &eigenvector, const bool &block_solve=true)
 
void activate_bifurcation_tracking (double *const &parameter_pt, const DoubleVector &eigenvector, const DoubleVector &normalisation, const bool &block_solve=true)
 
void activate_pitchfork_tracking (double *const &parameter_pt, const DoubleVector &symmetry_vector, const bool &block_solve=true)
 
void activate_hopf_tracking (double *const &parameter_pt, const bool &block_solve=true)
 
void activate_hopf_tracking (double *const &parameter_pt, const double &omega, const DoubleVector &null_real, const DoubleVector &null_imag, const bool &block_solve=true)
 
void deactivate_bifurcation_tracking ()
 
void reset_assembly_handler_to_default ()
 Reset the system to the standard non-augemented state. More...
 
double arc_length_step_solve (double *const &parameter_pt, const double &ds, const unsigned &max_adapt=0)
 
double arc_length_step_solve (Data *const &data_pt, const unsigned &data_index, const double &ds, const unsigned &max_adapt=0)
 
void reset_arc_length_parameters ()
 
int & sign_of_jacobian ()
 
void explicit_timestep (const double &dt, const bool &shift_values=true)
 Take an explicit timestep of size dt. More...
 
void unsteady_newton_solve (const double &dt)
 
void unsteady_newton_solve (const double &dt, const bool &shift_values)
 
void unsteady_newton_solve (const double &dt, const unsigned &max_adapt, const bool &first, const bool &shift=true)
 
double doubly_adaptive_unsteady_newton_solve (const double &dt, const double &epsilon, const unsigned &max_adapt, const bool &first, const bool &shift=true)
 
double doubly_adaptive_unsteady_newton_solve (const double &dt, const double &epsilon, const unsigned &max_adapt, const unsigned &suppress_resolve_after_spatial_adapt_flag, const bool &first, const bool &shift=true)
 
double adaptive_unsteady_newton_solve (const double &dt_desired, const double &epsilon)
 
double adaptive_unsteady_newton_solve (const double &dt_desired, const double &epsilon, const bool &shift_values)
 
void assign_initial_values_impulsive ()
 
void assign_initial_values_impulsive (const double &dt)
 
void calculate_predictions ()
 Calculate predictions. More...
 
void enable_mass_matrix_reuse ()
 
void disable_mass_matrix_reuse ()
 
bool mass_matrix_reuse_is_enabled ()
 Return whether the mass matrix is being reused. More...
 
void refine_uniformly (const Vector< unsigned > &nrefine_for_mesh)
 
void refine_uniformly (const Vector< unsigned > &nrefine_for_mesh, DocInfo &doc_info)
 
void refine_uniformly_and_prune (const Vector< unsigned > &nrefine_for_mesh)
 
void refine_uniformly_and_prune (const Vector< unsigned > &nrefine_for_mesh, DocInfo &doc_info)
 
void refine_uniformly (DocInfo &doc_info)
 
void refine_uniformly_and_prune (DocInfo &doc_info)
 
void refine_uniformly ()
 
void refine_uniformly (const unsigned &i_mesh, DocInfo &doc_info)
 Do uniform refinement for submesh i_mesh with documentation. More...
 
void refine_uniformly (const unsigned &i_mesh)
 Do uniform refinement for submesh i_mesh without documentation. More...
 
void p_refine_uniformly (const Vector< unsigned > &nrefine_for_mesh)
 
void p_refine_uniformly (const Vector< unsigned > &nrefine_for_mesh, DocInfo &doc_info)
 
void p_refine_uniformly_and_prune (const Vector< unsigned > &nrefine_for_mesh)
 
void p_refine_uniformly_and_prune (const Vector< unsigned > &nrefine_for_mesh, DocInfo &doc_info)
 
void p_refine_uniformly (DocInfo &doc_info)
 
void p_refine_uniformly_and_prune (DocInfo &doc_info)
 
void p_refine_uniformly ()
 
void p_refine_uniformly (const unsigned &i_mesh, DocInfo &doc_info)
 Do uniform p-refinement for submesh i_mesh with documentation. More...
 
void p_refine_uniformly (const unsigned &i_mesh)
 Do uniform p-refinement for submesh i_mesh without documentation. More...
 
void refine_selected_elements (const Vector< unsigned > &elements_to_be_refined)
 
void refine_selected_elements (const Vector< RefineableElement * > &elements_to_be_refined_pt)
 
void refine_selected_elements (const unsigned &i_mesh, const Vector< unsigned > &elements_to_be_refined)
 
void refine_selected_elements (const unsigned &i_mesh, const Vector< RefineableElement * > &elements_to_be_refined_pt)
 
void refine_selected_elements (const Vector< Vector< unsigned >> &elements_to_be_refined)
 
void refine_selected_elements (const Vector< Vector< RefineableElement * >> &elements_to_be_refined_pt)
 
void p_refine_selected_elements (const Vector< unsigned > &elements_to_be_refined)
 
void p_refine_selected_elements (const Vector< PRefineableElement * > &elements_to_be_refined_pt)
 
void p_refine_selected_elements (const unsigned &i_mesh, const Vector< unsigned > &elements_to_be_refined)
 
void p_refine_selected_elements (const unsigned &i_mesh, const Vector< PRefineableElement * > &elements_to_be_refined_pt)
 
void p_refine_selected_elements (const Vector< Vector< unsigned >> &elements_to_be_refined)
 
void p_refine_selected_elements (const Vector< Vector< PRefineableElement * >> &elements_to_be_refined_pt)
 
unsigned unrefine_uniformly ()
 
unsigned unrefine_uniformly (const unsigned &i_mesh)
 
void p_unrefine_uniformly (DocInfo &doc_info)
 
void p_unrefine_uniformly (const unsigned &i_mesh, DocInfo &doc_info)
 Do uniform p-unrefinement for submesh i_mesh without documentation. More...
 
void adapt (unsigned &n_refined, unsigned &n_unrefined)
 
void adapt ()
 
void p_adapt (unsigned &n_refined, unsigned &n_unrefined)
 
void p_adapt ()
 
void adapt_based_on_error_estimates (unsigned &n_refined, unsigned &n_unrefined, Vector< Vector< double >> &elemental_error)
 
void adapt_based_on_error_estimates (Vector< Vector< double >> &elemental_error)
 
void get_all_error_estimates (Vector< Vector< double >> &elemental_error)
 
void doc_errors (DocInfo &doc_info)
 Get max and min error for all elements in submeshes. More...
 
void doc_errors ()
 Get max and min error for all elements in submeshes. More...
 
void enable_info_in_newton_solve ()
 
void disable_info_in_newton_solve ()
 Disable the output of information when in the newton solver. More...
 
- Public Member Functions inherited from oomph::ExplicitTimeSteppableObject
 ExplicitTimeSteppableObject ()
 Empty constructor. More...
 
 ExplicitTimeSteppableObject (const ExplicitTimeSteppableObject &)=delete
 Broken copy constructor. More...
 
void operator= (const ExplicitTimeSteppableObject &)=delete
 Broken assignment operator. More...
 
virtual ~ExplicitTimeSteppableObject ()
 Empty destructor. More...
 
virtual void actions_before_explicit_stage ()
 
virtual void actions_after_explicit_stage ()
 

Additional Inherited Members

- Public Types inherited from oomph::Problem
typedef void(* SpatialErrorEstimatorFctPt) (Mesh *&mesh_pt, Vector< double > &elemental_error)
 Function pointer for spatial error estimator. More...
 
typedef void(* SpatialErrorEstimatorWithDocFctPt) (Mesh *&mesh_pt, Vector< double > &elemental_error, DocInfo &doc_info)
 Function pointer for spatial error estimator with doc. More...
 
- Public Attributes inherited from oomph::Problem
bool Shut_up_in_newton_solve
 
- Static Public Attributes inherited from oomph::Problem
static bool Suppress_warning_about_actions_before_read_unstructured_meshes
 
- Protected Types inherited from oomph::Problem
enum  Assembly_method {
  Perform_assembly_using_vectors_of_pairs , Perform_assembly_using_two_vectors , Perform_assembly_using_maps , Perform_assembly_using_lists ,
  Perform_assembly_using_two_arrays
}
 Enumerated flags to determine which sparse assembly method is used. More...
 
- Protected Member Functions inherited from FSICollapsibleChannelProblem< ELEMENT >
void dump_it (ofstream &dump_file)
 Dump problem to disk to allow for restart. More...
 
void restart (ifstream &restart_file)
 Read problem for restart from specified restart file. More...
 
- Protected Member Functions inherited from oomph::Problem
unsigned setup_element_count_per_dof ()
 
virtual void sparse_assemble_row_or_column_compressed (Vector< int * > &column_or_row_index, Vector< int * > &row_or_column_start, Vector< double * > &value, Vector< unsigned > &nnz, Vector< double * > &residual, bool compressed_row_flag)
 
virtual void actions_before_newton_step ()
 
virtual void actions_after_newton_step ()
 
virtual void actions_before_implicit_timestep ()
 
virtual void actions_after_implicit_timestep ()
 
virtual void actions_after_implicit_timestep_and_error_estimation ()
 
virtual void actions_before_explicit_timestep ()
 Actions that should be performed before each explicit time step. More...
 
virtual void actions_after_explicit_timestep ()
 Actions that should be performed after each explicit time step. More...
 
virtual void actions_before_read_unstructured_meshes ()
 
virtual void actions_after_read_unstructured_meshes ()
 
virtual void actions_after_change_in_global_parameter (double *const &parameter_pt)
 
virtual void actions_after_change_in_bifurcation_parameter ()
 
virtual void actions_after_parameter_increase (double *const &parameter_pt)
 
double & dof_derivative (const unsigned &i)
 
double & dof_current (const unsigned &i)
 
virtual 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 FSICollapsibleChannelProblem< ELEMENT >
unsigned Nup
 Number of elements in the x direction in the upstream part of the channel. More...
 
unsigned Ncollapsible
 
unsigned Ndown
 Number of elements in the x direction in the downstream part of the channel. More...
 
unsigned Ny
 Number of elements across the channel. More...
 
double Lup
 x-length in the upstream part of the channel More...
 
double Lcollapsible
 x-length in the collapsible part of the channel More...
 
double Ldown
 x-length in the downstream part of the channel More...
 
double Ly
 Transverse length. More...
 
AlgebraicCollapsibleChannelMesh< ELEMENT > * Bulk_mesh_pt
 Pointer to the "bulk" mesh. More...
 
Mesh * Displ_control_mesh_pt
 Pointer to the mesh that contains the displacement control element. More...
 
bool Displ_control
 Use displacement control? More...
 
OneDLagrangianMesh< FSIHermiteBeamElement > * Wall_mesh_pt
 Pointer to the "wall" mesh. More...
 
Node * Left_node_pt
 Pointer to the left control node. More...
 
Node * Right_node_pt
 Pointer to right control node. More...
 
Node * Wall_node_pt
 Pointer to control node on the wall. More...
 
bool Steady_flag
 Flag for steady run. More...
 
GeomObject * Ctrl_geom_obj_pt
 
Vector< double > S_displ_ctrl
 
MeshAsGeomObject * Wall_geom_object_pt
 Geometric object incarnation of the wall mesh. More...
 
unsigned Newton_iter
 Counter for Newton iterations. More...
 
DocInfo Doc_info
 DocInfo object. More...
 
- Protected Attributes inherited from oomph::Problem
Vector< Problem * > Copy_of_problem_pt
 
std::map< double *, bool > Calculate_dparameter_analytic
 
bool Calculate_hessian_products_analytic
 
LinearAlgebraDistribution * Dof_distribution_pt
 
Vector< double * > Dof_pt
 Vector of pointers to dofs. More...
 
DoubleVectorWithHaloEntries Element_count_per_dof
 
double Relaxation_factor
 
double Newton_solver_tolerance
 
unsigned Max_newton_iterations
 Maximum number of Newton iterations. More...
 
unsigned Nnewton_iter_taken
 
Vector< double > Max_res
 Maximum residuals at start and after each newton iteration. More...
 
double Max_residuals
 
bool Time_adaptive_newton_crash_on_solve_fail
 
bool Jacobian_reuse_is_enabled
 Is re-use of Jacobian in Newton iteration enabled? Default: false. More...
 
bool Jacobian_has_been_computed
 
bool Problem_is_nonlinear
 
bool Pause_at_end_of_sparse_assembly
 
bool Doc_time_in_distribute
 
unsigned Sparse_assembly_method
 
unsigned Sparse_assemble_with_arrays_initial_allocation
 
unsigned Sparse_assemble_with_arrays_allocation_increment
 
Vector< Vector< unsigned > > Sparse_assemble_with_arrays_previous_allocation
 
double Numerical_zero_for_sparse_assembly
 
double FD_step_used_in_get_hessian_vector_products
 
bool Mass_matrix_reuse_is_enabled
 
bool Mass_matrix_has_been_computed
 
bool Discontinuous_element_formulation
 
double Minimum_dt
 Minimum desired dt: if dt falls below this value, exit. More...
 
double Maximum_dt
 Maximum desired dt. More...
 
double DTSF_max_increase
 
double DTSF_min_decrease
 
double Minimum_dt_but_still_proceed
 
bool Scale_arc_length
 Boolean to control whether arc-length should be scaled. More...
 
double Desired_proportion_of_arc_length
 Proportion of the arc-length to taken by the parameter. More...
 
double Theta_squared
 
int Sign_of_jacobian
 Storage for the sign of the global Jacobian. More...
 
double Continuation_direction
 
double Parameter_derivative
 Storage for the derivative of the global parameter wrt arc-length. More...
 
double Parameter_current
 Storage for the present value of the global parameter. More...
 
bool Use_continuation_timestepper
 Boolean to control original or new storage of dof stuff. More...
 
unsigned Dof_derivative_offset
 
unsigned Dof_current_offset
 
Vector< double > Dof_derivative
 Storage for the derivative of the problem variables wrt arc-length. More...
 
Vector< double > Dof_current
 Storage for the present values of the variables. More...
 
double Ds_current
 Storage for the current step value. More...
 
unsigned Desired_newton_iterations_ds
 
double Minimum_ds
 Minimum desired value of arc-length. More...
 
bool Bifurcation_detection
 Boolean to control bifurcation detection via determinant of Jacobian. More...
 
bool Bisect_to_find_bifurcation
 Boolean to control wheter bisection is used to located bifurcation. More...
 
bool First_jacobian_sign_change
 Boolean to indicate whether a sign change has occured in the Jacobian. More...
 
bool Arc_length_step_taken
 Boolean to indicate whether an arc-length step has been taken. More...
 
bool Use_finite_differences_for_continuation_derivatives
 
OomphCommunicator * Communicator_pt
 The communicator for this problem. More...
 
bool Always_take_one_newton_step
 
double Timestep_reduction_factor_after_nonconvergence
 
bool Keep_temporal_error_below_tolerance
 
- Static Protected Attributes inherited from oomph::Problem
static ContinuationStorageScheme Continuation_time_stepper
 Storage for the single static continuation timestorage object. More...
 

Detailed Description

template<class ELEMENT>
class PreconditionedFSICollapsibleChannelProblem< ELEMENT >

Problem class.

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

Constructor & Destructor Documentation

◆ PreconditionedFSICollapsibleChannelProblem()

template<class ELEMENT >
PreconditionedFSICollapsibleChannelProblem< ELEMENT >::PreconditionedFSICollapsibleChannelProblem ( const unsigned &  nup,
const unsigned &  ncollapsible,
const unsigned &  ndown,
const unsigned &  ny,
const double &  lup,
const double &  lcollapsible,
const double &  ldown,
const double &  ly,
const bool &  displ_control,
const bool &  steady_flag,
const unsigned &  solver_flag,
const unsigned &  solver_sub_flag 
)
inline

Constructor: The arguments are the number of elements and the lengths of the domain.

101  :
102  FSICollapsibleChannelProblem<ELEMENT>(nup,
103  ncollapsible,
104  ndown,
105  ny,
106  lup,
107  lcollapsible,
108  ldown,
109  ly,
110  displ_control,
111  steady_flag)
112  {
113 
114  // Build iterative linear solver
115  GMRES<CRDoubleMatrix>* iterative_linear_solver_pt =
116  new GMRES<CRDoubleMatrix>;
117 
118  // Set maximum number of iterations
119  iterative_linear_solver_pt->max_iter() = 100;
120 
121  // Set tolerance
122  iterative_linear_solver_pt->tolerance() = 1.0e-6;
123 
124  // Choose solver: Direct vs. iterative
125  if (solver_flag==0)
126  {
127  std::cout << "Using default direct solver." << std::endl;
128  }
129  else
130  {
131  std::cout << "Using iterative linear solver." << std::endl;
132  this->linear_solver_pt()=iterative_linear_solver_pt;
133  } //solver chosen
134 
135 
136  // Choose solver/preconditioner
137  switch (solver_flag)
138  {
139 
140  // Direct solver -- no action required
141  //====================================
142  case 0:
143 
144  Flags::Run_identifier_string="Direct solver";
145 
146  break;
147 
148 
149  // Exact preconditioner (re-arranged Jacobian)
150  //============================================
151  case 1:
152 
153  std::cout << "Using ExactFSIPreconditioner (re-arranged Jacobian)"
154  << std::endl;
155 
156  Flags::Run_identifier_string=
157  "Exact preconditioner (re-arranged Jacobian)";
158 
159  {
160  ExactBlockPreconditioner<CRDoubleMatrix>* prec_pt=
161  new ExactBlockPreconditioner<CRDoubleMatrix>;
162 
163  // With GeneralPurposeBlockPreconditioner, we set meshes with
164  // add_mesh(...). The order of the meshes matter if we want to
165  // use different subsidiary preconditioners for different blocks.
166 
167  // Set Navier Stokes mesh.
168  prec_pt->add_mesh(this->bulk_mesh_pt());
169 
170  // Build the mesh that contains all solid elements:
171 
172  // Create a vector of pointers to submeshes. Start with the solid
173  // mesh itself.
174  Vector<Mesh*> s_mesh_pt(1);
175  s_mesh_pt[0]=this->wall_mesh_pt();
176 
177  // Add the displacement control mesh if required
178  if (this->Displ_control)
179  s_mesh_pt.push_back(this->Displ_control_mesh_pt);
180 
181  // Build "combined" mesh from vector of solid submeshes
182  Mesh* solid_mesh_pt = new Mesh(s_mesh_pt);
183 
184  // Set solid mesh with "true" to tolerate multiple element types
185  // in the mesh.
186  prec_pt->add_mesh(solid_mesh_pt,true);
187 
188 
189  // Set preconditioner
190  iterative_linear_solver_pt->preconditioner_pt()= prec_pt;
191  }
192 
193  break;
194 
195  // Simple preconditioner (block triangular Jacobian, solved exactly)
196  //==================================================================
197  case 2:
198 
199  std::cout << "Using SimpleFSIPreconditioner (block-triangular Jacobian)"
200  << std::endl;
201 
202  {
203  SimpleFSIPreconditioner<CRDoubleMatrix>* prec_pt=
204  new SimpleFSIPreconditioner<CRDoubleMatrix>;
205 
206  // Set Navier Stokes mesh:
207  prec_pt->set_navier_stokes_mesh(this->bulk_mesh_pt());
208 
209  // Build a compound mesh that contains all solid elements:
210 
211  // Create a vector of pointers to submeshes. Start with the solid
212  // mesh itself.
213  Vector<Mesh*> s_mesh_pt(1);
214  s_mesh_pt[0]=this->wall_mesh_pt();
215 
216  // Add the displacement control mesh if required
217  if (this->Displ_control)
218  s_mesh_pt.push_back(this->Displ_control_mesh_pt);
219 
220  // Build "combined" mesh from vector of solid submeshes
221  Mesh* solid_mesh_pt = new Mesh(s_mesh_pt);
222 
223  // Set solid mesh with "true" to tolerate multiple element types in
224  // the mesh.
225  prec_pt->set_wall_mesh(solid_mesh_pt,true);
226 
227 
228  switch (solver_sub_flag)
229  {
230 
231  // Block diagonal
232  //---------------
233  case 0:
234 
235  std::cout << "(diagonal version)" << std::endl;
236  Flags::Run_identifier_string=
237  "Simple FSI preconditioner (diagonal)";
238  prec_pt->use_block_diagonal_version();
239  break;
240 
241 
242  // Retain fluid onto solid terms
243  //------------------------------
244  case 1:
245 
246  std::cout << "(retaining fluid onto solid terms)" << std::endl;
247  Flags::Run_identifier_string=
248  "Simple FSI preconditioner (retaining fluid onto solid terms)";
249  prec_pt->use_block_triangular_version_with_fluid_on_solid();
250  break;
251 
252  // Retain solid onto fluid terms
253  //------------------------------
254  case 2:
255 
256  std::cout << "(retaining solid onto fluid terms)" << std::endl;
257 
258  Flags::Run_identifier_string=
259  "Simple FSI preconditioner (retaining solid onto fluid terms)";
260  prec_pt->use_block_triangular_version_with_solid_on_fluid();
261  break;
262 
263  // Error
264  //------
265  default:
266 
267  std::ostringstream error_stream;
268  error_stream << "Error: Wrong solver_sub_flag: "
269  << solver_sub_flag << std::endl;
270  throw OomphLibError(error_stream.str(),
271  OOMPH_CURRENT_FUNCTION,
272  OOMPH_EXCEPTION_LOCATION);
273  break;
274 
275  }
276 
277  iterative_linear_solver_pt->preconditioner_pt()= prec_pt;
278  }
279  break;
280 
281 
282  // FSI preconditioner (block triangular Jacobian, solved with
283  //===========================================================
284  // block decomposition, using least-squares-commutator (BFBt)
285  //===========================================================
286  // Navier-Stokes preconditioner for fluid block
287  //=============================================
288 
289  case 3:
290 
291  std::cout << "Using FSIPreconditioner (block-triangular Jacobian + LSC)"
292  << std::endl;
293 
294  {
295 
296  // Create an instance of the FSI preconditioner -- pass the pointer
297  // to the problem
298  FSIPreconditioner* prec_pt=new FSIPreconditioner(this);
299 
300  // Set Navier Stokes mesh:
301  prec_pt->set_navier_stokes_mesh(this->bulk_mesh_pt());
302 
303  // Build a compound mesh that contains all solid elements:
304 
305  // Create a vector of pointers to submeshes. Start with the solid
306  // mesh itself.
307  Vector<Mesh*> s_mesh_pt(1);
308  s_mesh_pt[0]=this->wall_mesh_pt();
309 
310  // Add the displacement control mesh if required
311  if (this->Displ_control)
312  {
313  s_mesh_pt.push_back(this->Displ_control_mesh_pt);
314  }
315 
316  // Build compound mesh from vector of solid submeshes
317  Mesh* combined_solid_mesh_pt = new Mesh(s_mesh_pt);
318 
319  // Set solid mesh and tolerate multiple element types this is mesh.
320  prec_pt->set_wall_mesh(combined_solid_mesh_pt,true);
321 
322 
323  switch (solver_sub_flag)
324  {
325 
326  // Block diagonal
327  //---------------
328  case 0:
329 
330  std::cout << "(diagonal version)" << std::endl;
331  Flags::Run_identifier_string=
332  "LSC FSI preconditioner (diagonal)";
333 
334  // Use block-diagonal preconditioner
335  prec_pt->use_block_diagonal_version();
336  break;
337 
338 
339  // Retain fluid onto solid terms
340  //------------------------------
341  case 1:
342 
343  std::cout << "(retaining fluid onto solid terms)" << std::endl;
344  Flags::Run_identifier_string=
345  "LSC FSI preconditioner (retaining fluid onto solid terms)";
346 
347  // Choose preconditioner that retains fluid on solid terms
348  prec_pt->use_block_triangular_version_with_fluid_on_solid();
349 
350  break;
351 
352  // Retain solid onto fluid terms
353  //------------------------------
354  case 2:
355 
356  std::cout << "(retaining solid onto fluid terms)" << std::endl;
357 
358  Flags::Run_identifier_string=
359  "LSC FSI preconditioner (retaining solid onto fluid terms)";
360 
361  // Choose preconditioner that retains solid on fluid terms
362  prec_pt->use_block_triangular_version_with_solid_on_fluid();
363  break;
364 
365  // Error
366  //------
367  default:
368 
369  std::ostringstream error_stream;
370  error_stream << "Error: Wrong solver_sub_flag: "
371  << solver_sub_flag << std::endl;
372  throw OomphLibError(error_stream.str(),
373  OOMPH_CURRENT_FUNCTION,
374  OOMPH_EXCEPTION_LOCATION);
375  break;
376 
377  }
378 
379  // Pass preconditioner to iterative linear solver
380  iterative_linear_solver_pt->preconditioner_pt()= prec_pt;
381  }
382 
383  break;
384 
385  // FSI preconditioner (block triangular Jacobian, solved with
386  //===========================================================
387  // block decomposition, using least-squares-commutator (BFBt)
388  //===========================================================
389  // Navier-Stokes preconditioner for fluid block, Hypre AMG
390  //========================================================
391  // for P
392  //======
393 
394  case 4:
395 
396  std::cout << "Using FSIPreconditioner (block-triangular Jacobian + LSC)"
397  << std::endl;
398 
399  {
400 
401  // Create an instance of the FSI preconditioner -- pass the pointer
402  // to the problem
403  FSIPreconditioner* prec_pt=new FSIPreconditioner(this);
404 
405  // Set Navier Stokes mesh:
406  prec_pt->set_navier_stokes_mesh(this->bulk_mesh_pt());
407 
408  // Build a compound mesh that contains all solid elements:
409 
410  // Create a vector of pointers to submeshes. Start with the solid
411  // mesh itself.
412  Vector<Mesh*> s_mesh_pt(1);
413  s_mesh_pt[0]=this->wall_mesh_pt();
414 
415  // Add the displacement control mesh if required
416  if (this->Displ_control)
417  {
418  s_mesh_pt.push_back(this->Displ_control_mesh_pt);
419  }
420 
421  // Build compound mesh from vector of solid submeshes
422  Mesh* combined_solid_mesh_pt = new Mesh(s_mesh_pt);
423 
424  // Set solid mesh with true to tolerate multiple element types in
425  // the mesh.
426  prec_pt->set_wall_mesh(combined_solid_mesh_pt,true);
427 
428 #ifdef OOMPH_HAS_HYPRE
429 //If we are using MPI, then only use HYPRE if it has been initialised
430 #ifdef OOMPH_HAS_MPI
431  if(MPI_Helpers::mpi_has_been_initialised())
432 #endif
433  {
434 
435  // By default, the LSC Preconditioner uses SuperLU as
436  // an exact preconditioner (i.e. a solver) for the
437  // momentum and Schur complement blocks.
438  // Can overwrite this by passing pointers to
439  // other preconditioners that perform the (approximate)
440  // solves of these blocks.
441 
442  // Create internal preconditioners used on Schur block
443  HyprePreconditioner* P_matrix_preconditioner_pt =
444  new HyprePreconditioner;
445 
446  // Set defaults parameters for use as preconditioner on Poisson-type
447  // problem
448  Hypre_default_settings::set_defaults_for_2D_poisson_problem(
449  P_matrix_preconditioner_pt);
450 
451  // Use Hypre for the Schur complement block
452  prec_pt->navier_stokes_preconditioner_pt()->
453  set_p_preconditioner(P_matrix_preconditioner_pt);
454 
455  // Shut up
456  P_matrix_preconditioner_pt->disable_doc_time();
457  }
458 #endif // endif for we have hypre...
459 
460  switch (solver_sub_flag)
461  {
462 
463  // Block diagonal
464  //---------------
465  case 0:
466 
467  std::cout << "(diagonal version)" << std::endl;
468  Flags::Run_identifier_string=
469  "LSC FSI preconditioner (diagonal)";
470 
471  // Use block-diagonal preconditioner
472  prec_pt->use_block_diagonal_version();
473  break;
474 
475 
476  // Retain fluid onto solid terms
477  //------------------------------
478  case 1:
479 
480  std::cout << "(retaining fluid onto solid terms)" << std::endl;
481  Flags::Run_identifier_string=
482  "LSC FSI preconditioner (retaining fluid onto solid terms)";
483 
484  // Choose preconditioner that retains fluid on solid terms
485  prec_pt->use_block_triangular_version_with_fluid_on_solid();
486 
487  break;
488 
489  // Retain solid onto fluid terms
490  //------------------------------
491  case 2:
492 
493  std::cout << "(retaining solid onto fluid terms)" << std::endl;
494 
495  Flags::Run_identifier_string=
496  "LSC FSI preconditioner (retaining solid onto fluid terms)";
497 
498  // Choose preconditioner that retains solid on fluid terms
499  prec_pt->use_block_triangular_version_with_solid_on_fluid();
500  break;
501 
502  // Error
503  //------
504  default:
505 
506  std::ostringstream error_stream;
507  error_stream << "Error: Wrong solver_sub_flag: "
508  << solver_sub_flag << std::endl;
509  throw OomphLibError(error_stream.str(),
510  OOMPH_CURRENT_FUNCTION,
511  OOMPH_EXCEPTION_LOCATION);
512  break;
513 
514  }
515 
516  // Pass preconditioner to iterative linear solver
517  iterative_linear_solver_pt->preconditioner_pt()= prec_pt;
518  }
519 
520  break;
521 
522 
523  // Error
524  //======
525  default:
526 
527  std::ostringstream error_stream;
528  error_stream << "Error: Wrong solver_flag: "
529  << solver_flag << std::endl;
530  throw OomphLibError(error_stream.str(),
531  OOMPH_CURRENT_FUNCTION,
532  OOMPH_EXCEPTION_LOCATION);
533  break;
534  }
535 
536  }
FSICollapsibleChannelProblem
Problem class.
Definition: fsi_chan_problem.h:315
FSICollapsibleChannelProblem::bulk_mesh_pt
AlgebraicCollapsibleChannelMesh< ELEMENT > * bulk_mesh_pt()
Access function for the specific bulk (fluid) mesh.
Definition: fsi_chan_problem.h:347
FSICollapsibleChannelProblem::Displ_control_mesh_pt
Mesh * Displ_control_mesh_pt
Pointer to the mesh that contains the displacement control element.
Definition: fsi_chan_problem.h:436
FSICollapsibleChannelProblem::wall_mesh_pt
OneDLagrangianMesh< FSIHermiteBeamElement > * wall_mesh_pt()
Access function for the wall mesh.
Definition: fsi_chan_problem.h:357
FSICollapsibleChannelProblem::Displ_control
bool Displ_control
Use displacement control?
Definition: fsi_chan_problem.h:439
oomph::ExactBlockPreconditioner
Definition: general_purpose_block_preconditioners.h:542
oomph::FSIPreconditioner
Definition: fsi_preconditioners.h:51
oomph::FSIPreconditioner::use_block_triangular_version_with_solid_on_fluid
void use_block_triangular_version_with_solid_on_fluid()
Definition: fsi_preconditioners.h:155
oomph::FSIPreconditioner::set_navier_stokes_mesh
void set_navier_stokes_mesh(Mesh *mesh_pt, const bool &allow_multiple_element_type_in_navier_stokes_mesh=false)
Definition: fsi_preconditioners.h:164
oomph::FSIPreconditioner::set_wall_mesh
void set_wall_mesh(Mesh *mesh_pt, const bool &allow_multiple_element_type_in_wall_mesh=false)
Definition: fsi_preconditioners.h:179
oomph::FSIPreconditioner::navier_stokes_preconditioner_pt
NavierStokesSchurComplementPreconditioner * navier_stokes_preconditioner_pt() const
Access function to the Navier Stokes preconditioner (inexact solver)
Definition: fsi_preconditioners.h:198
oomph::FSIPreconditioner::use_block_diagonal_version
void use_block_diagonal_version()
Switch to block-diagonal preconditioner.
Definition: fsi_preconditioners.h:139
oomph::FSIPreconditioner::use_block_triangular_version_with_fluid_on_solid
void use_block_triangular_version_with_fluid_on_solid()
Definition: fsi_preconditioners.h:147
oomph::GMRES
The GMRES method.
Definition: iterative_linear_solver.h:1227
oomph::GeneralPurposeBlockPreconditioner::add_mesh
void add_mesh(const Mesh *mesh_pt, const bool &allow_multiple_element_type_in_mesh=false)
Definition: general_purpose_block_preconditioners.h:191
oomph::HyprePreconditioner
Definition: hypre_solver.h:826
oomph::HyprePreconditioner::disable_doc_time
void disable_doc_time()
Disable documentation of preconditioner timings.
Definition: hypre_solver.h:939
oomph::IterativeLinearSolver::preconditioner_pt
Preconditioner *& preconditioner_pt()
Access function to preconditioner.
Definition: iterative_linear_solver.h:95
oomph::IterativeLinearSolver::tolerance
double & tolerance()
Access to convergence tolerance.
Definition: iterative_linear_solver.h:107
oomph::IterativeLinearSolver::max_iter
unsigned & max_iter()
Access to max. number of iterations.
Definition: iterative_linear_solver.h:113
oomph::Mesh
Definition: mesh.h:67
oomph::OomphLibError
Definition: oomph_definitions.h:222
oomph::Problem::linear_solver_pt
LinearSolver *& linear_solver_pt()
Return a pointer to the linear solver object.
Definition: problem.h:1466
oomph::SimpleFSIPreconditioner
Definition: fsi_preconditioners.h:485
oomph::SimpleFSIPreconditioner::set_wall_mesh
void set_wall_mesh(Mesh *mesh_pt, const bool &allow_multiple_element_type_in_wall_mesh=false)
Definition: fsi_preconditioners.h:545
oomph::SimpleFSIPreconditioner::use_block_triangular_version_with_solid_on_fluid
void use_block_triangular_version_with_solid_on_fluid()
Definition: fsi_preconditioners.h:580
oomph::SimpleFSIPreconditioner::use_block_diagonal_version
void use_block_diagonal_version()
Switch to block-diagonal preconditioner.
Definition: fsi_preconditioners.h:564
oomph::SimpleFSIPreconditioner::set_navier_stokes_mesh
void set_navier_stokes_mesh(Mesh *mesh_pt, const bool &allow_multiple_element_type_in_navier_stokes_mesh=false)
Broken assignment operator.
Definition: fsi_preconditioners.h:531
oomph::SimpleFSIPreconditioner::use_block_triangular_version_with_fluid_on_solid
void use_block_triangular_version_with_fluid_on_solid()
Definition: fsi_preconditioners.h:572
Flags::Run_identifier_string
string Run_identifier_string
String to identify the run type in trace file.
Definition: fsi_chan_problem.h:248
Mesh_Parameters::ly
const double ly
Definition: ConstraintElementsUnitTest.cpp:34
Mesh_Parameters::ny
const unsigned ny
Definition: ConstraintElementsUnitTest.cpp:31
oomph::Hypre_default_settings::set_defaults_for_2D_poisson_problem
void set_defaults_for_2D_poisson_problem(HyprePreconditioner *hypre_preconditioner_pt)
Definition: hypre_solver.cc:45
OOMPH_EXCEPTION_LOCATION
#define OOMPH_EXCEPTION_LOCATION
Definition: oomph_definitions.h:61
OOMPH_CURRENT_FUNCTION
#define OOMPH_CURRENT_FUNCTION
Definition: oomph_definitions.h:86

References oomph::GeneralPurposeBlockPreconditioner< MATRIX >::add_mesh(), oomph::HyprePreconditioner::disable_doc_time(), oomph::IterativeLinearSolver::max_iter(), oomph::FSIPreconditioner::navier_stokes_preconditioner_pt(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::IterativeLinearSolver::preconditioner_pt(), Flags::Run_identifier_string, oomph::Hypre_default_settings::set_defaults_for_2D_poisson_problem(), oomph::FSIPreconditioner::set_navier_stokes_mesh(), oomph::SimpleFSIPreconditioner< MATRIX >::set_navier_stokes_mesh(), oomph::FSIPreconditioner::set_wall_mesh(), oomph::SimpleFSIPreconditioner< MATRIX >::set_wall_mesh(), oomph::IterativeLinearSolver::tolerance(), oomph::FSIPreconditioner::use_block_diagonal_version(), oomph::SimpleFSIPreconditioner< MATRIX >::use_block_diagonal_version(), oomph::FSIPreconditioner::use_block_triangular_version_with_fluid_on_solid(), oomph::SimpleFSIPreconditioner< MATRIX >::use_block_triangular_version_with_fluid_on_solid(), oomph::FSIPreconditioner::use_block_triangular_version_with_solid_on_fluid(), and oomph::SimpleFSIPreconditioner< MATRIX >::use_block_triangular_version_with_solid_on_fluid().

◆ ~PreconditionedFSICollapsibleChannelProblem()

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

Destructor (empty)

540 {}

Member Function Documentation

◆ actions_after_newton_solve()

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

Update the problem after solve: Close convergence file for iterative linear solver

Reimplemented from oomph::Problem.

593  {
594  // Try to cast to IterativeLinearSolver
595  IterativeLinearSolver* it_lin_solver_pt=
596  dynamic_cast<IterativeLinearSolver*>(this->linear_solver_pt());
597 
598  // Close convergence history file
599  if (it_lin_solver_pt!=0)
600  {
601  it_lin_solver_pt->close_convergence_history_file_stream();
602  }
603  }
oomph::IterativeLinearSolver
Definition: iterative_linear_solver.h:54
oomph::IterativeLinearSolver::close_convergence_history_file_stream
void close_convergence_history_file_stream()
Close convergence history output stream.
Definition: iterative_linear_solver.h:161

References oomph::IterativeLinearSolver::close_convergence_history_file_stream().

◆ actions_before_newton_convergence_check()

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

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

Reimplemented from oomph::Problem.

548  {
549  // Update mesh
550  this->Bulk_mesh_pt->node_update();
551 
552  // Try to cast to IterativeLinearSolver
553  IterativeLinearSolver* it_lin_solver_pt=
554  dynamic_cast<IterativeLinearSolver*>(this->linear_solver_pt());
555 
556  // Open convergence history file
557  if (it_lin_solver_pt!=0)
558  {
559  // Close it first
560  it_lin_solver_pt->close_convergence_history_file_stream();
561 
562  // File name
563  std::ostringstream some_stream;
564  some_stream << this->Doc_info.directory() << "/convergence_history"
565  << this->Doc_info.number() << "-" << this->Newton_iter
566  << ".dat";
567 
568  // Zone title
569  std::ostringstream some_stream2;
570  some_stream2 << "Step: " << this->Doc_info.number()
571  << "; Newton iteration:" << this->Newton_iter
572  << "; " << Flags::Run_identifier_string;
573 
574  it_lin_solver_pt->open_convergence_history_file_stream(
575  some_stream.str(),some_stream2.str());
576  }
577 
578  // Increment counter
579  this->Newton_iter++;
580  }
FSICollapsibleChannelProblem::Doc_info
DocInfo Doc_info
DocInfo object.
Definition: fsi_chan_problem.h:472
FSICollapsibleChannelProblem::Newton_iter
unsigned Newton_iter
Counter for Newton iterations.
Definition: fsi_chan_problem.h:469
FSICollapsibleChannelProblem::Bulk_mesh_pt
AlgebraicCollapsibleChannelMesh< ELEMENT > * Bulk_mesh_pt
Pointer to the "bulk" mesh.
Definition: fsi_chan_problem.h:433
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::IterativeLinearSolver::open_convergence_history_file_stream
void open_convergence_history_file_stream(const std::string &file_name, const std::string &zone_title="")
Definition: iterative_linear_solver.h:138

References oomph::IterativeLinearSolver::close_convergence_history_file_stream(), oomph::DocInfo::directory(), GlobalParameters::Doc_info, oomph::DocInfo::number(), oomph::IterativeLinearSolver::open_convergence_history_file_stream(), and Flags::Run_identifier_string.

◆ actions_before_newton_solve()

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

Actions before solve. Reset counter for number of Newton iterations.

Reimplemented from oomph::Problem.

585  {
586  this->Newton_iter=0;
587  }
The documentation for this class was generated from the following file: