Public Member Functions | Protected Attributes | Private Attributes | List of all members
RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT > Class Template Reference
+ Inheritance diagram for RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >:

Public Member Functions

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

Protected Attributes

RefineableRectangularQuadMesh< NST_ELEMENT > * Nst_mesh_pt
 Navier Stokes mesh. More...
 
RefineableRectangularQuadMesh< AD_ELEMENT > * Adv_diff_mesh_pt
 Advection diffusion mesh. More...
 
RefineableSimpleCubicMesh< NST_ELEMENT > * Nst_mesh_pt
 
RefineableSimpleCubicMesh< AD_ELEMENT > * Adv_diff_mesh_pt
 
- 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
 

Private Attributes

DocInfo Doc_info
 DocInfo object. More...
 
bool Imperfect
 Is the boundary condition imperfect or not. More...
 
double Lz
 

Additional Inherited Members

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

/////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// 2D Convection problem on two rectangular domains, discretised with refineable Navier-Stokes and Advection-Diffusion elements. The specific type of element is specified via the template parameters.

/////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// 2D Convection problem on rectangular domain, discretised with refineable elements. The specific type of element is specified via the template parameter.

/////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// 3D Convection problem on two rectangular domains, discretised with refineable Navier-Stokes and Advection-Diffusion elements. The specific type of element is specified via the template parameters.

/////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// 3D Convection problem on rectangular domain, discretised with refineable elements. The specific type of element is specified via the template parameter.

Constructor & Destructor Documentation

◆ RefineableConvectionProblem() [1/6]

template<class ELEMENT >
RefineableConvectionProblem< ELEMENT >::RefineableConvectionProblem

Constructor.

Constructor for adaptive thermal convection problem.

200 {
201  // Set output directory
202  Doc_info.set_directory("RESLT_MULTI");
203 
204  // # of elements in x-direction
205  unsigned n_x=9;
206 
207  // # of elements in y-direction
208  unsigned n_y=8;
209 
210  // Domain length in x-direction
211  double l_x=3.0;
212 
213  // Domain length in y-direction
214  double l_y=1.0;
215 
216  // Build the meshes
217  Nst_mesh_pt =
218  new RefineableRectangularQuadMesh<NST_ELEMENT>(n_x,n_y,l_x,l_y);
219  Adv_diff_mesh_pt =
220  new RefineableRectangularQuadMesh<AD_ELEMENT>(n_x,n_y,l_x,l_y);
221 
222  // Create/set error estimator
223  Nst_mesh_pt->spatial_error_estimator_pt()=new Z2ErrorEstimator;
224  Adv_diff_mesh_pt->spatial_error_estimator_pt()=new Z2ErrorEstimator;
225 
226  // Set error targets for adaptive refinement
227  Nst_mesh_pt->max_permitted_error()=0.5e-3;
228  Nst_mesh_pt->min_permitted_error()=0.5e-4;
229  Adv_diff_mesh_pt->max_permitted_error()=0.5e-3;
230  Adv_diff_mesh_pt->min_permitted_error()=0.5e-4;
231 
232 
233  // Set the boundary conditions for this problem: All nodes are
234  // free by default -- only need to pin the ones that have Dirichlet
235  // conditions here
236 
237  //Loop over the boundaries of the NST mesh
238  unsigned num_bound = nst_mesh_pt()->nboundary();
239  for(unsigned ibound=0;ibound<num_bound;ibound++)
240  {
241  //Set the maximum index to be pinned (all values by default)
242  unsigned val_max;
243 
244  //Loop over the number of nodes on the boundry
245  unsigned num_nod= nst_mesh_pt()->nboundary_node(ibound);
246  for (unsigned inod=0;inod<num_nod;inod++)
247  {
248 
249  //If we are on the side-walls, the v-velocity and temperature
250  //satisfy natural boundary conditions, so we only pin the
251  //first value
252  if((ibound==1) || (ibound==3))
253  {
254  val_max=1;
255  }
256  else
257  {
258  val_max=nst_mesh_pt()->boundary_node_pt(ibound,inod)->nvalue();
259  }
260 
261  //Loop over the desired values stored at the nodes and pin
262  for(unsigned j=0;j<val_max;j++)
263  {
264  nst_mesh_pt()->boundary_node_pt(ibound,inod)->pin(j);
265  }
266  }
267  }
268 
269  // Pin the zero-th pressure value in the zero-th element and
270  // set its value to zero.
271  fix_pressure(0,0,0.0);
272 
273  //Loop over the boundaries of the AD mesh
274  num_bound = adv_diff_mesh_pt()->nboundary();
275  for(unsigned ibound=0;ibound<num_bound;ibound++)
276  {
277  //Set the maximum index to be pinned (all values by default)
278  unsigned val_max;
279 
280  //Loop over the number of nodes on the boundry
281  unsigned num_nod= adv_diff_mesh_pt()->nboundary_node(ibound);
282  for (unsigned inod=0;inod<num_nod;inod++)
283  {
284  //If we are on the side-walls, the v-velocity and temperature
285  //satisfy natural boundary conditions, so we don't pin anything
286  // in this mesh
287  if ((ibound==1) || (ibound==3))
288  {
289  val_max=0;
290  }
291  else // pin all values
292  {
293  val_max=adv_diff_mesh_pt()->boundary_node_pt(ibound,inod)->nvalue();
294  //Loop over the desired values stored at the nodes and pin
295  for(unsigned j=0;j<val_max;j++)
296  {
297  adv_diff_mesh_pt()->boundary_node_pt(ibound,inod)->pin(j);
298  }
299  }
300  }
301  } // end of loop over AD mesh boundaries
302 
303  // Complete the build of all elements so they are fully functional
304 
305  // Loop over the elements to set up element-specific
306  // things that cannot be handled by the (argument-free!) ELEMENT
307  // constructor.
308  unsigned n_nst_element = nst_mesh_pt()->nelement();
309  for(unsigned i=0;i<n_nst_element;i++)
310  {
311  // Upcast from GeneralsedElement to the present element
312  NST_ELEMENT *el_pt = dynamic_cast<NST_ELEMENT*>
313  (nst_mesh_pt()->element_pt(i));
314 
315  // Set the Reynolds number (1/Pr in our non-dimensionalisation)
316  el_pt->re_pt() = &Global_Physical_Variables::Inverse_Prandtl;
317 
318  // Set ReSt (also 1/Pr in our non-dimensionalisation)
319  el_pt->re_st_pt() = &Global_Physical_Variables::Inverse_Prandtl;
320 
321  // Set the Rayleigh number
322  el_pt->ra_pt() = &Global_Physical_Variables::Rayleigh;
323 
324  //Set Gravity vector
325  el_pt->g_pt() = &Global_Physical_Variables::Direction_of_gravity;
326 
327  // We can ignore the external geometric data in the "external"
328  // advection diffusion element when computing the Jacobian matrix
329  // because the interaction does not involve spatial gradients of
330  // the temperature (and also because the mesh isn't moving!)
331  el_pt->ignore_external_geometric_data();
332  }
333 
334  unsigned n_ad_element = adv_diff_mesh_pt()->nelement();
335  for(unsigned i=0;i<n_ad_element;i++)
336  {
337  // Upcast from GeneralsedElement to the present element
338  AD_ELEMENT *el_pt = dynamic_cast<AD_ELEMENT*>
339  (adv_diff_mesh_pt()->element_pt(i));
340 
341  // Set the Peclet number
342  el_pt->pe_pt() = &Global_Physical_Variables::Peclet;
343 
344  // Set the Peclet number multiplied by the Strouhal number
345  el_pt->pe_st_pt() =&Global_Physical_Variables::Peclet;
346 
347  // We can ignore the external geometric data in the "external"
348  // Navier Stokes element when computing the Jacobian matrix
349  // because the interaction does not involve spatial gradients of
350  // the velocities (and also because the mesh isn't moving!)
351  el_pt->ignore_external_geometric_data();
352 
353  } // end of setup for all AD elements
354 
355  // combine the submeshes
356  add_sub_mesh(Nst_mesh_pt);
357  add_sub_mesh(Adv_diff_mesh_pt);
358  build_global_mesh();
359 
360  // Change default parameters for setup of bins and doc stats
361  Multi_domain_functions::Doc_stats=true;
362 
363  // Set external elements for the multi-domain solution.
364  Multi_domain_functions::
365  setup_multi_domain_interactions<NST_ELEMENT,AD_ELEMENT>
366  (this,nst_mesh_pt(),adv_diff_mesh_pt());
367 
368  // Setup equation numbering scheme
369  cout << "Number of equations: " << assign_eqn_numbers() << endl;
370 
371  // Set this to higher than default (10)
372  Problem::Max_newton_iterations=20;
373 
374 } // end of constructor
i
int i
Definition: BiCGSTAB_step_by_step.cpp:9
AD_ELEMENT
NST_ELEMENT
RefineableConvectionProblem::fix_pressure
void fix_pressure(const unsigned &e, const unsigned &pdof, const double &pvalue)
Fix pressure in element e at pressure dof pdof and set to pvalue.
Definition: mpi/multi_domain/boussinesq_convection/multi_domain_ref_b_convection.cc:156
RefineableConvectionProblem::adv_diff_mesh_pt
RefineableRectangularQuadMesh< AD_ELEMENT > * adv_diff_mesh_pt()
Definition: mpi/multi_domain/boussinesq_convection/multi_domain_ref_b_convection.cc:108
RefineableConvectionProblem::Nst_mesh_pt
RefineableRectangularQuadMesh< NST_ELEMENT > * Nst_mesh_pt
Navier Stokes mesh.
Definition: mpi/multi_domain/boussinesq_convection/multi_domain_ref_b_convection.cc:186
RefineableConvectionProblem::nst_mesh_pt
RefineableRectangularQuadMesh< NST_ELEMENT > * nst_mesh_pt()
Definition: mpi/multi_domain/boussinesq_convection/multi_domain_ref_b_convection.cc:99
RefineableConvectionProblem::Adv_diff_mesh_pt
RefineableRectangularQuadMesh< AD_ELEMENT > * Adv_diff_mesh_pt
Advection diffusion mesh.
Definition: mpi/multi_domain/boussinesq_convection/multi_domain_ref_b_convection.cc:189
RefineableConvectionProblem::Doc_info
DocInfo Doc_info
DocInfo object.
Definition: mpi/multi_domain/boussinesq_convection/multi_domain_ref_b_convection.cc:178
oomph::Data::pin
void pin(const unsigned &i)
Pin the i-th stored variable.
Definition: nodes.h:385
oomph::Data::nvalue
unsigned nvalue() const
Return number of values stored in data object (incl pinned ones).
Definition: nodes.h:483
oomph::DocInfo::set_directory
void set_directory(const std::string &directory)
Definition: oomph_utilities.cc:298
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::nboundary
unsigned nboundary() const
Return number of boundaries.
Definition: mesh.h:827
oomph::Mesh::element_pt
GeneralisedElement *& element_pt(const unsigned long &e)
Return pointer to element e.
Definition: mesh.h:448
oomph::Mesh::boundary_node_pt
Node *& boundary_node_pt(const unsigned &b, const unsigned &n)
Return pointer to node n on boundary b.
Definition: mesh.h:493
oomph::Mesh::nelement
unsigned long nelement() const
Return number of elements in the mesh.
Definition: mesh.h:590
oomph::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::RefineableMeshBase::min_permitted_error
double & min_permitted_error()
Definition: refineable_mesh.h:156
oomph::RefineableMeshBase::max_permitted_error
double & max_permitted_error()
Definition: refineable_mesh.h:163
oomph::RefineableMeshBase::spatial_error_estimator_pt
ErrorEstimator *& spatial_error_estimator_pt()
Access to spatial error estimator.
Definition: refineable_mesh.h:143
oomph::Z2ErrorEstimator
Definition: error_estimator.h:266
Global_Physical_Variables::Direction_of_gravity
Vector< double > Direction_of_gravity(2)
Gravity vector.
Global_Physical_Variables::Rayleigh
double Rayleigh
Rayleigh number.
Definition: mpi/multi_domain/boussinesq_convection/multi_domain_boussinesq_convection.cc:57
Global_Physical_Variables::Inverse_Prandtl
double Inverse_Prandtl
1/Prandtl number
Definition: mpi/multi_domain/boussinesq_convection/multi_domain_boussinesq_convection.cc:53
Global_Physical_Variables::Peclet
double Peclet
Peclet number.
Definition: pipe.cc:49
oomph::Locate_zeta_helpers::Max_newton_iterations
unsigned Max_newton_iterations
Maximum number of newton iterations.
Definition: elements.cc:1654
oomph::Missing_masters_functions::Doc_stats
bool Doc_stats
Definition: missing_masters.cc:63
j
std::ptrdiff_t j
Definition: tut_arithmetic_redux_minmax.cpp:2

References oomph::Global_Physical_Variables::Direction_of_gravity, GlobalParameters::Doc_info, oomph::Multi_domain_functions::Doc_stats, i, Global_Physical_Variables::Inverse_Prandtl, j, oomph::Problem::Max_newton_iterations, Global_Physical_Variables::Peclet, Global_Physical_Variables::Rayleigh, and oomph::DocInfo::set_directory().

◆ ~RefineableConvectionProblem() [1/6]

template<class NST_ELEMENT , class AD_ELEMENT >
RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::~RefineableConvectionProblem ( )
inline

Destructor. Empty.

88 {}

◆ RefineableConvectionProblem() [2/6]

template<class NST_ELEMENT , class AD_ELEMENT >
RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::RefineableConvectionProblem ( )

Constructor.

◆ ~RefineableConvectionProblem() [2/6]

template<class NST_ELEMENT , class AD_ELEMENT >
RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::~RefineableConvectionProblem ( )
inline

Destructor. Empty.

93 {}

◆ RefineableConvectionProblem() [3/6]

template<class NST_ELEMENT , class AD_ELEMENT >
RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::RefineableConvectionProblem ( )

Constructor.

◆ ~RefineableConvectionProblem() [3/6]

template<class NST_ELEMENT , class AD_ELEMENT >
RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::~RefineableConvectionProblem ( )
inline

Destructor. clean up after the allocated memory.

105  {
106  //Fluid mesh
107  //Delete the mesh's error estimator
108  delete Nst_mesh_pt->spatial_error_estimator_pt();
109  //Delete the mesh
110  delete Nst_mesh_pt;
111 
112  //Temperature mesh
113  //Delete the mesh's error estimator
114  delete Adv_diff_mesh_pt->spatial_error_estimator_pt();
115  //Delete the mesh
116  delete Adv_diff_mesh_pt;
117  }

◆ RefineableConvectionProblem() [4/6]

template<class NST_ELEMENT , class AD_ELEMENT >
RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::RefineableConvectionProblem ( )

Constructor.

◆ ~RefineableConvectionProblem() [4/6]

template<class NST_ELEMENT , class AD_ELEMENT >
RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::~RefineableConvectionProblem ( )
inline

Destructor. Clean up all allocated memory.

1415  {
1416  //Delete the mesh's error estimator
1417  delete mesh_pt()->spatial_error_estimator_pt();
1418  //Delete the mesh
1419  delete Problem::mesh_pt();
1420 
1421  //Can we cast the solver to an iterative linear solver
1422  GMRES<CRDoubleMatrix>* iterative_linear_solver_pt =
1423  dynamic_cast<GMRES<CRDoubleMatrix>*>(this->linear_solver_pt());
1424  //If so delete the preconditioner and the solver
1425  if(iterative_linear_solver_pt)
1426  {
1427  delete iterative_linear_solver_pt->preconditioner_pt();
1428  delete iterative_linear_solver_pt;
1429  }
1430  }
RefineableConvectionProblem::mesh_pt
RectangularQuadMesh< ELEMENT > * mesh_pt()
Definition: mpi/multi_domain/boussinesq_convection/refineable_b_convection.cc:104
oomph::GMRES
The GMRES method.
Definition: iterative_linear_solver.h:1227
oomph::IterativeLinearSolver::preconditioner_pt
Preconditioner *& preconditioner_pt()
Access function to preconditioner.
Definition: iterative_linear_solver.h:95
oomph::Problem::linear_solver_pt
LinearSolver *& linear_solver_pt()
Return a pointer to the linear solver object.
Definition: problem.h:1466

References oomph::Problem::mesh_pt(), and oomph::IterativeLinearSolver::preconditioner_pt().

◆ RefineableConvectionProblem() [5/6]

template<class NST_ELEMENT , class AD_ELEMENT >
RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::RefineableConvectionProblem ( )

Constructor.

◆ ~RefineableConvectionProblem() [5/6]

template<class NST_ELEMENT , class AD_ELEMENT >
RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::~RefineableConvectionProblem ( )
inline

Destructor. Empty.

89 {}

◆ RefineableConvectionProblem() [6/6]

template<class NST_ELEMENT , class AD_ELEMENT >
RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::RefineableConvectionProblem ( )

Constructor.

◆ ~RefineableConvectionProblem() [6/6]

template<class NST_ELEMENT , class AD_ELEMENT >
RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::~RefineableConvectionProblem ( )
inline

Destructor. Empty.

93 {}

Member Function Documentation

◆ actions_after_adapt() [1/6]

template<class NST_ELEMENT , class AD_ELEMENT >
void RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::actions_after_adapt ( )
inlinevirtual

Actions after adaptation, re-set all interactions, then re-pin a single pressure degree of freedom

Reimplemented from oomph::Problem.

120  {
121  //Unpin all the pressures in NST mesh to avoid pinning two pressures
122  RefineableNavierStokesEquations<2>::
123  unpin_all_pressure_dofs(nst_mesh_pt()->element_pt());
124 
125  //Pin the zero-th pressure dof in the zero-th element and set
126  // its value to zero
127  unsigned nnod=nst_mesh_pt()->nnode();
128  for (unsigned j=0; j<nnod; j++)
129  {
130  if (mesh_pt()->node_pt(j)->x(0)==0.0 &&
131  mesh_pt()->node_pt(j)->x(1)==0.0) // 2d problem only
132  {
133  fix_pressure(0,0,0.0);
134  break;
135  }
136  }
137 
138  // Set external elements for the multi-domain solution.
139  Multi_domain_functions::
140  setup_multi_domain_interactions<NST_ELEMENT,AD_ELEMENT>
141  (this,nst_mesh_pt(),adv_diff_mesh_pt());
142 
143  } //end_of_actions_after_adapt
oomph::Mesh::nnode
unsigned long nnode() const
Return number of nodes in the mesh.
Definition: mesh.h:596
oomph::RefineableNavierStokesEquations
Definition: refineable_navier_stokes_elements.h:322
plotDoE.x
list x
Definition: plotDoE.py:28

References j, oomph::RefineableNavierStokesEquations< DIM >::unpin_all_pressure_dofs(), and plotDoE::x.

◆ actions_after_adapt() [2/6]

template<class NST_ELEMENT , class AD_ELEMENT >
void RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::actions_after_adapt ( )
inlinevirtual

Actions after adaptation, Re-pin a single pressure degree of freedom

Reimplemented from oomph::Problem.

116  {
117  //Unpin all the pressures to avoid pinning two pressures
118  RefineableNavierStokesEquations<2>::
119  unpin_all_pressure_dofs(mesh_pt()->element_pt());
120 
121  //Pin the zero-th pressure dof in the zero-th element and set
122  // its value to zero
123  unsigned nnod=mesh_pt()->nnode();
124  for (unsigned j=0; j<nnod; j++)
125  {
126  if (mesh_pt()->node_pt(j)->x(0)==0 &&
127  mesh_pt()->node_pt(j)->x(1)==0) // 2d problem only
128  {
129  fix_pressure(0,0,0.0);
130  break;
131  }
132  }
133  }

References j, oomph::RefineableNavierStokesEquations< DIM >::unpin_all_pressure_dofs(), and plotDoE::x.

◆ actions_after_adapt() [3/6]

template<class NST_ELEMENT , class AD_ELEMENT >
void RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::actions_after_adapt ( )
inlinevirtual

Actions after adaptation, reset all sources, then re-pin a single pressure degree of freedom

Reimplemented from oomph::Problem.

149  {
150  // Setup all interactions
151  Multi_domain_functions::setup_multi_domain_interactions
152  <NST_ELEMENT,AD_ELEMENT>(this,nst_mesh_pt(),adv_diff_mesh_pt());
153  }
oomph::Multi_domain_functions::setup_multi_domain_interactions
void setup_multi_domain_interactions(Problem *problem_pt, Mesh *const &first_mesh_pt, Mesh *const &second_mesh_pt, const unsigned &first_interaction=0, const unsigned &second_interaction=0)
Definition: multi_domain.template.cc:244

References oomph::Multi_domain_functions::setup_multi_domain_interactions().

◆ actions_after_adapt() [4/6]

template<class NST_ELEMENT , class AD_ELEMENT >
void RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::actions_after_adapt ( )
inlinevirtual

Actions after adaptation (empty)

Reimplemented from oomph::Problem.

1451 {}

◆ actions_after_adapt() [5/6]

template<class NST_ELEMENT , class AD_ELEMENT >
void RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::actions_after_adapt ( )
inlinevirtual

Actions after adaptation, reset all sources, then re-pin a single pressure degree of freedom

Reimplemented from oomph::Problem.

121  {
122  //Unpin all the pressures in NST mesh to avoid pinning two pressures
123  RefineableNavierStokesEquations<2>::
124  unpin_all_pressure_dofs(nst_mesh_pt()->element_pt());
125 
126  //Pin the zero-th pressure dof in the zero-th element and set
127  // its value to zero
128  fix_pressure(0,0,0.0);
129 
130  // Set external elements for the multi-domain solution.
131  Multi_domain_functions::
132  setup_multi_domain_interactions<NST_ELEMENT,AD_ELEMENT>
133  (this,nst_mesh_pt(),adv_diff_mesh_pt());
134 
135  } //end_of_actions_after_adapt

References oomph::RefineableNavierStokesEquations< DIM >::unpin_all_pressure_dofs().

◆ actions_after_adapt() [6/6]

template<class NST_ELEMENT , class AD_ELEMENT >
void RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::actions_after_adapt ( )
inlinevirtual

Actions after adaptation, Re-pin a single pressure degree of freedom

Reimplemented from oomph::Problem.

116  {
117  //Unpin all the pressures to avoid pinning two pressures
118  RefineableNavierStokesEquations<2>::
119  unpin_all_pressure_dofs(mesh_pt()->element_pt());
120 
121  //Pin the zero-th pressure dof in the zero-th element and set
122  // its value to zero
123  fix_pressure(0,0,0.0);
124  }

References oomph::RefineableNavierStokesEquations< DIM >::unpin_all_pressure_dofs().

◆ actions_after_distribute()

template<class NST_ELEMENT , class AD_ELEMENT >
void RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::actions_after_distribute ( )
inline

Actions after distribute: Re-setup multi-domain interaction.

148  {
149  // Re-set all the interactions in the problem
150  Multi_domain_functions::setup_multi_domain_interactions
151  <NST_ELEMENT,AD_ELEMENT>(this,nst_mesh_pt(),adv_diff_mesh_pt());
152  }

References oomph::Multi_domain_functions::setup_multi_domain_interactions().

◆ actions_after_newton_solve() [1/6]

template<class NST_ELEMENT , class AD_ELEMENT >
void RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::actions_after_newton_solve ( )
inlinevirtual

Update the problem after solve (empty)

Reimplemented from oomph::Problem.

94 {}

◆ actions_after_newton_solve() [2/6]

template<class NST_ELEMENT , class AD_ELEMENT >
void RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::actions_after_newton_solve ( )
inlinevirtual

Update the problem after solve (empty)

Reimplemented from oomph::Problem.

99 {}

◆ actions_after_newton_solve() [3/6]

template<class NST_ELEMENT , class AD_ELEMENT >
void RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::actions_after_newton_solve ( )
inlinevirtual

Update the problem after solve (empty)

Reimplemented from oomph::Problem.

123 {}

◆ actions_after_newton_solve() [4/6]

template<class NST_ELEMENT , class AD_ELEMENT >
void RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::actions_after_newton_solve ( )
inlinevirtual

Update the problem after solve (empty)

Reimplemented from oomph::Problem.

1436 {}

◆ actions_after_newton_solve() [5/6]

template<class NST_ELEMENT , class AD_ELEMENT >
void RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::actions_after_newton_solve ( )
inlinevirtual

Update the problem after solve (empty)

Reimplemented from oomph::Problem.

95 {}

◆ actions_after_newton_solve() [6/6]

template<class NST_ELEMENT , class AD_ELEMENT >
void RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::actions_after_newton_solve ( )
inlinevirtual

Update the problem after solve (empty)

Reimplemented from oomph::Problem.

99 {}

◆ actions_before_adapt() [1/6]

template<class NST_ELEMENT , class AD_ELEMENT >
void RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::actions_before_adapt ( )
inlinevirtual

Actions before adapt:(empty)

Reimplemented from oomph::Problem.

115 {}

◆ actions_before_adapt() [2/6]

template<class NST_ELEMENT , class AD_ELEMENT >
void RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::actions_before_adapt ( )
inlinevirtual

Actions before adapt:(empty)

Reimplemented from oomph::Problem.

111 {}

◆ actions_before_adapt() [3/6]

template<class NST_ELEMENT , class AD_ELEMENT >
void RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::actions_before_adapt ( )
inlinevirtual

Actions before adapt:(empty)

Reimplemented from oomph::Problem.

144 {}

◆ actions_before_adapt() [4/6]

template<class NST_ELEMENT , class AD_ELEMENT >
void RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::actions_before_adapt ( )
inlinevirtual

Actions before adapt:(empty)

Reimplemented from oomph::Problem.

1448 {}

◆ actions_before_adapt() [5/6]

template<class NST_ELEMENT , class AD_ELEMENT >
void RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::actions_before_adapt ( )
inlinevirtual

Actions before adapt:(empty)

Reimplemented from oomph::Problem.

116 {}

◆ actions_before_adapt() [6/6]

template<class NST_ELEMENT , class AD_ELEMENT >
void RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::actions_before_adapt ( )
inlinevirtual

Actions before adapt:(empty)

Reimplemented from oomph::Problem.

111 {}

◆ actions_before_newton_solve() [1/6]

template<class ELEMENT >
void RefineableConvectionProblem< ELEMENT >::actions_before_newton_solve
virtual

Update the problem specs before solve:

Update the problem specs before solve: (Re-)set boundary conditions.

Update the problem specs before solve: (Re-)set boundary conditions to include an imperfection (or not) depending on the control flag.

Reimplemented from oomph::Problem.

383 {
384  // Loop over the boundaries on the NST mesh
385  unsigned num_bound = nst_mesh_pt()->nboundary();
386  for(unsigned ibound=0;ibound<num_bound;ibound++)
387  {
388  // Loop over the nodes on boundary
389  unsigned num_nod=nst_mesh_pt()->nboundary_node(ibound);
390  for(unsigned inod=0;inod<num_nod;inod++)
391  {
392  // Get pointer to node
393  Node* nod_pt=nst_mesh_pt()->boundary_node_pt(ibound,inod);
394 
395  //Set the number of velocity components
396  unsigned vel_max=2;
397  //If we are on the side walls we only pin the x-velocity.
398  if((ibound==1) || (ibound==3)) {vel_max = 1;}
399  //Set the pinned velocities to zero
400  for(unsigned j=0;j<vel_max;j++) {nod_pt->set_value(j,0.0);}
401 
402  //If we are on the top boundary
403  if(ibound==2)
404  {
405  //Add small velocity imperfection if desired
406  if(Imperfect)
407  {
408  //Read out the x position
409  double x = nod_pt->x(0);
410  //Set a sinusoidal perturbation in the vertical velocity
411  //This perturbation is mass conserving
412  double value = sin(2.0*3.141592654*x/3.0);
413  nod_pt->set_value(1,value);
414  }
415  }
416 
417  }
418  }
419 
420  // Loop over all the boundaries on the AD mesh
421  num_bound=adv_diff_mesh_pt()->nboundary();
422  for(unsigned ibound=0;ibound<num_bound;ibound++)
423  {
424  // Loop over the nodes on boundary
425  unsigned num_nod=adv_diff_mesh_pt()->nboundary_node(ibound);
426  for(unsigned inod=0;inod<num_nod;inod++)
427  {
428  // Get pointer to node
429  Node* nod_pt=adv_diff_mesh_pt()->boundary_node_pt(ibound,inod);
430 
431  //If we are on the top boundary, set the temperature
432  //to -0.5 (cooled)
433  if(ibound==2) {nod_pt->set_value(0,-0.5);}
434 
435  //If we are on the bottom boundary, set the temperature
436  //to 0.5 (heated)
437  if(ibound==0) {nod_pt->set_value(0,0.5);}
438  }
439  }
440 
441 
442 } // end of actions before solve
sin
AnnoyingScalar sin(const AnnoyingScalar &x)
Definition: AnnoyingScalar.h:137
RefineableConvectionProblem::Imperfect
bool Imperfect
Is the boundary condition imperfect or not.
Definition: mpi/multi_domain/boussinesq_convection/multi_domain_ref_b_convection.cc:181
oomph::Data::set_value
void set_value(const unsigned &i, const double &value_)
Definition: nodes.h:271
oomph::Node
Definition: nodes.h:906
oomph::Node::x
double & x(const unsigned &i)
Return the i-th nodal coordinate.
Definition: nodes.h:1060
Eigen::value
squared absolute value
Definition: GlobalFunctions.h:87

References j, oomph::Data::set_value(), sin(), Eigen::value, plotDoE::x, and oomph::Node::x().

◆ actions_before_newton_solve() [2/6]

template<class NST_ELEMENT , class AD_ELEMENT >
void RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::actions_before_newton_solve ( )
virtual

Update the problem specs before solve:

Reimplemented from oomph::Problem.

◆ actions_before_newton_solve() [3/6]

template<class NST_ELEMENT , class AD_ELEMENT >
void RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::actions_before_newton_solve ( )
virtual

Update the problem specs before solve:

Reimplemented from oomph::Problem.

◆ actions_before_newton_solve() [4/6]

template<class NST_ELEMENT , class AD_ELEMENT >
void RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::actions_before_newton_solve ( )
virtual

Update the problem specs before solve:

Reimplemented from oomph::Problem.

◆ actions_before_newton_solve() [5/6]

template<class NST_ELEMENT , class AD_ELEMENT >
void RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::actions_before_newton_solve ( )
virtual

Update the problem specs before solve:

Reimplemented from oomph::Problem.

◆ actions_before_newton_solve() [6/6]

template<class NST_ELEMENT , class AD_ELEMENT >
void RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::actions_before_newton_solve ( )
virtual

Update the problem specs before solve:

Reimplemented from oomph::Problem.

◆ adv_diff_mesh_pt() [1/3]

template<class NST_ELEMENT , class AD_ELEMENT >
RefineableRectangularQuadMesh<AD_ELEMENT>* RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::adv_diff_mesh_pt ( )
inline

Access function to the AD mesh. Casts the pointer to the base Mesh object to the actual mesh type.

109  {
110  return dynamic_cast<RefineableRectangularQuadMesh<AD_ELEMENT>*>
111  (Adv_diff_mesh_pt);
112  } // end_of_ad_mesh

◆ adv_diff_mesh_pt() [2/3]

template<class NST_ELEMENT , class AD_ELEMENT >
RefineableSimpleCubicMesh<AD_ELEMENT>* RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::adv_diff_mesh_pt ( )
inline

Overloaded version of the problem's access function to the AD mesh. Recasts the pointer to the base Mesh object to the actual mesh type.

138  {
139  return dynamic_cast<RefineableSimpleCubicMesh<AD_ELEMENT>*>
140  (Adv_diff_mesh_pt);
141  }

◆ adv_diff_mesh_pt() [3/3]

template<class NST_ELEMENT , class AD_ELEMENT >
RefineableRectangularQuadMesh<AD_ELEMENT>* RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::adv_diff_mesh_pt ( )
inline

Access function to the AD mesh. Casts the pointer to the base Mesh object to the actual mesh type.

110  {
111  return dynamic_cast<RefineableRectangularQuadMesh<AD_ELEMENT>*>
112  (Adv_diff_mesh_pt);
113  } // end_of_ad_mesh

◆ disable_imperfection() [1/4]

template<class NST_ELEMENT , class AD_ELEMENT >
void RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::disable_imperfection ( )
inline

Set the boundary condition on the upper wall to be unperturbed.

170 {Imperfect = false;}

◆ disable_imperfection() [2/4]

template<class NST_ELEMENT , class AD_ELEMENT >
void RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::disable_imperfection ( )
inline

Set the boundary condition on the upper wall to be unperturbed.

151 {Imperfect = false;}

◆ disable_imperfection() [3/4]

template<class NST_ELEMENT , class AD_ELEMENT >
void RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::disable_imperfection ( )
inline

Set th boundary condition on the upper wall to be unperturbed.

158 {Imperfect = false;}

◆ disable_imperfection() [4/4]

template<class NST_ELEMENT , class AD_ELEMENT >
void RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::disable_imperfection ( )
inline

Set the boundary condition on the upper wall to be unperturbed.

142 {Imperfect = false;}

◆ doc_solution() [1/6]

template<class ELEMENT >
void RefineableConvectionProblem< ELEMENT >::doc_solution

Doc the solution.

Doc the mesh distribution

Doc the mesh distribution

451 {
452  //Declare an output stream and filename
453  ofstream some_file;
454  char filename[100];
455 
456  // Number of plot points: npts x npts
457  unsigned npts=5;
458 
459  Doc_info.label()="";
460 
461  // Output Navier-Stokes solution
462  sprintf(filename,"%s/fluid_soln%i_on_proc%i.dat",Doc_info.directory().c_str(),
463  Doc_info.number(),this->communicator_pt()->my_rank());
464  some_file.open(filename);
465  nst_mesh_pt()->output(some_file,npts);
466  some_file.close();
467 
468  // Output advection diffusion solution
469  sprintf(filename,"%s/temperature_soln%i_on_proc%i.dat",
470  Doc_info.directory().c_str(),
471  Doc_info.number(),this->communicator_pt()->my_rank());
472  some_file.open(filename);
473  adv_diff_mesh_pt()->output(some_file,npts);
474  some_file.close();
475 
477  Doc_info.label()="temperature_";
478  adv_diff_mesh_pt()->doc_mesh_distribution(Doc_info);
479 
481  Doc_info.label()="fluid_";
482  nst_mesh_pt()->doc_mesh_distribution(Doc_info);
483 
484 
485 
486  Doc_info.number()++;
487 
488 } // end of doc
oomph::DocInfo::label
std::string & label()
String used (e.g.) for labeling output files.
Definition: oomph_utilities.h:572
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
MergeRestartFiles.filename
string filename
Definition: MergeRestartFiles.py:39

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

◆ doc_solution() [2/6]

template<class NST_ELEMENT , class AD_ELEMENT >
void RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::doc_solution ( )

Doc the solution.

◆ doc_solution() [3/6]

template<class NST_ELEMENT , class AD_ELEMENT >
void RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::doc_solution ( )

Doc the solution.

◆ doc_solution() [4/6]

template<class NST_ELEMENT , class AD_ELEMENT >
void RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::doc_solution ( )

Doc the solution.

◆ doc_solution() [5/6]

template<class NST_ELEMENT , class AD_ELEMENT >
void RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::doc_solution ( )

Doc the solution.

◆ doc_solution() [6/6]

template<class NST_ELEMENT , class AD_ELEMENT >
void RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::doc_solution ( )

Doc the solution.

◆ enable_imperfection() [1/4]

template<class NST_ELEMENT , class AD_ELEMENT >
void RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::enable_imperfection ( )
inline

Set the boundary condition on the upper wall to be perturbed slightly to force the solution into the symmetry broken state.

166 {Imperfect = true;}

◆ enable_imperfection() [2/4]

template<class NST_ELEMENT , class AD_ELEMENT >
void RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::enable_imperfection ( )
inline

Set the boundary condition on the upper wall to be perturbed slightly to force the solution into the symmetry broken state.

147 {Imperfect = true;}

◆ enable_imperfection() [3/4]

template<class NST_ELEMENT , class AD_ELEMENT >
void RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::enable_imperfection ( )
inline

Set the boundary condition on the upper wall to be perturbed slightly to force the solution into the symmetry broken state.

154 {Imperfect = true;}

◆ enable_imperfection() [4/4]

template<class NST_ELEMENT , class AD_ELEMENT >
void RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::enable_imperfection ( )
inline

Set the boundary condition on the upper wall to be perturbed slightly to force the solution into the symmetry broken state.

138 {Imperfect = true;}

◆ fix_pressure() [1/4]

template<class NST_ELEMENT , class AD_ELEMENT >
void RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::fix_pressure ( const unsigned &  e,
const unsigned &  pdof,
const double &  pvalue 
)
inline

Fix pressure in element e at pressure dof pdof and set to pvalue.

158  {
159  dynamic_cast<NST_ELEMENT*>(nst_mesh_pt()->element_pt(e))->
160  fix_pressure(pdof,pvalue);
161  }
e
Array< double, 1, 3 > e(1./3., 0.5, 2.)

References e().

◆ fix_pressure() [2/4]

template<class NST_ELEMENT , class AD_ELEMENT >
void RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::fix_pressure ( const unsigned &  e,
const unsigned &  pdof,
const double &  pvalue 
)
inline

Fix pressure in element e at pressure dof pdof and set to pvalue.

138  {
139  //Cast to specific element and fix pressure
140  dynamic_cast<ELEMENT*>(mesh_pt()->element_pt(e))->
141  fix_pressure(pdof,pvalue);
142  } // end_of_fix_pressure

References e().

◆ fix_pressure() [3/4]

template<class NST_ELEMENT , class AD_ELEMENT >
void RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::fix_pressure ( const unsigned &  e,
const unsigned &  pdof,
const double &  pvalue 
)
inline

Fix pressure in element e at pressure dof pdof and set to pvalue.

141  {
142  //Cast to specific element and fix pressure in NST element
143  if (nst_mesh_pt()->nelement()>0)
144  {
145  dynamic_cast<NST_ELEMENT*>(nst_mesh_pt()->element_pt(e))->
146  fix_pressure(pdof,pvalue);
147  }
148  } // end_of_fix_pressure

References e().

◆ fix_pressure() [4/4]

template<class NST_ELEMENT , class AD_ELEMENT >
void RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::fix_pressure ( const unsigned &  e,
const unsigned &  pdof,
const double &  pvalue 
)
inline

Fix pressure in element e at pressure dof pdof and set to pvalue.

129  {
130  //Cast to specific element and fix pressure
131  dynamic_cast<ELEMENT*>(mesh_pt()->element_pt(e))->
132  fix_pressure(pdof,pvalue);
133  } // end_of_fix_pressure

References e().

◆ mesh_pt() [1/3]

template<class NST_ELEMENT , class AD_ELEMENT >
RectangularQuadMesh<ELEMENT>* RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::mesh_pt ( )
inline

Overloaded version of the problem's access function to the mesh. Recasts the pointer to the base Mesh object to the actual mesh type.

105  {
106  return dynamic_cast<RectangularQuadMesh<ELEMENT>*>(
107  Problem::mesh_pt());
108  } //end of access function to specic mesh
oomph::RectangularQuadMesh
Definition: rectangular_quadmesh.template.h:59

References oomph::Problem::mesh_pt().

◆ mesh_pt() [2/3]

template<class NST_ELEMENT , class AD_ELEMENT >
RefineableSimpleCubicMesh<ELEMENT>* RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::mesh_pt ( )
inline

Overloaded version of the problem's access function to the mesh. Recasts the pointer to the base Mesh object to the actual mesh type.

1442  {
1443  return dynamic_cast<RefineableSimpleCubicMesh<ELEMENT>*>(
1444  Problem::mesh_pt());
1445  } //end of access function to specic mesh

References oomph::Problem::mesh_pt().

◆ mesh_pt() [3/3]

template<class NST_ELEMENT , class AD_ELEMENT >
RectangularQuadMesh<ELEMENT>* RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::mesh_pt ( )
inline

Overloaded version of the problem's access function to the mesh. Recasts the pointer to the base Mesh object to the actual mesh type.

105  {
106  return dynamic_cast<RectangularQuadMesh<ELEMENT>*>(
107  Problem::mesh_pt());
108  } //end of access function to specic mesh

References oomph::Problem::mesh_pt().

◆ nst_mesh_pt() [1/3]

template<class NST_ELEMENT , class AD_ELEMENT >
RefineableRectangularQuadMesh<NST_ELEMENT>* RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::nst_mesh_pt ( )
inline

Access function to the NST mesh. Casts the pointer to the base Mesh object to the actual mesh type.

100  {
101  return dynamic_cast<RefineableRectangularQuadMesh<NST_ELEMENT>*>
102  (Nst_mesh_pt);
103  } // end_of_nst_mesh

◆ nst_mesh_pt() [2/3]

template<class NST_ELEMENT , class AD_ELEMENT >
RefineableSimpleCubicMesh<NST_ELEMENT>* RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::nst_mesh_pt ( )
inline

Overloaded version of the problem's access function to the NST mesh. Recasts the pointer to the base Mesh object to the actual mesh type.

129  {
130  return dynamic_cast<RefineableSimpleCubicMesh<NST_ELEMENT>*>
131  (Nst_mesh_pt);
132  }

◆ nst_mesh_pt() [3/3]

template<class NST_ELEMENT , class AD_ELEMENT >
RefineableRectangularQuadMesh<NST_ELEMENT>* RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::nst_mesh_pt ( )
inline

Access function to the NST mesh. Casts the pointer to the base Mesh object to the actual mesh type.

101  {
102  return dynamic_cast<RefineableRectangularQuadMesh<NST_ELEMENT>*>
103  (Nst_mesh_pt);
104  } // end_of_nst_mesh

◆ switch_to_iterative_linear_solver()

template<class NST_ELEMENT , class AD_ELEMENT >
void RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::switch_to_iterative_linear_solver

Switch to the iterative linear solve.

Switch to an iterative linear solver.

336 {
337  // Set this to higher than default (10)
338  Problem::Max_newton_iterations=20;
339  //Build iterative linear solver
340  GMRES<CRDoubleMatrix>* iterative_linear_solver_pt = new
341  GMRES<CRDoubleMatrix>;
342 
343  // Set maximum number of iterations
344  iterative_linear_solver_pt->max_iter() = 100;
345 
346  // Set tolerance
347  iterative_linear_solver_pt->tolerance() = 1.0e-8;
348 
349  FSIPreconditioner* prec_pt=new FSIPreconditioner(this);
350 
351  // Tell preconditioner about meshes
352  prec_pt->set_navier_stokes_mesh(Nst_mesh_pt);
353  prec_pt->set_wall_mesh(Adv_diff_mesh_pt);
354 
355  // This is probably the most important because the temperature will
356  // affect the fluid motion more than the other way round.
357  prec_pt->use_block_triangular_version_with_solid_on_fluid();
358 
359  //Set the preconditioner
360  iterative_linear_solver_pt->preconditioner_pt() = prec_pt;
361 
362  // Set linear solver
363  linear_solver_pt() = iterative_linear_solver_pt;
364 
365 #ifdef OOMPH_HAS_HYPRE
366 //If compiled with MPI, only use HYPRE if MPI has been initialised
367 #ifdef OOMPH_HAS_MPI
368  if(MPI_Helpers::mpi_has_been_initialised())
369 #endif
370  {
371  // Need to create a SuperLUDistPreconditioner for the temperature ("solid")
372  HyprePreconditioner* Temperature_prec_pt = new HyprePreconditioner;
373  Hypre_default_settings::set_defaults_for_navier_stokes_momentum_block(
374  static_cast<HyprePreconditioner*>(Temperature_prec_pt));
375  //SuperLUPreconditioner* Temperature_prec_pt =new SuperLUPreconditioner;
376  prec_pt->set_solid_preconditioner_pt(Temperature_prec_pt);
377 
378  //Set up the internal preconditioners
379  Preconditioner* P_matrix_preconditioner_pt = new HyprePreconditioner;
380 
381  // Set parameters for use as preconditioner on Poisson-type problem
382  Hypre_default_settings::set_defaults_for_3D_poisson_problem(
383  static_cast<HyprePreconditioner*>(P_matrix_preconditioner_pt));
384 
385  // Use Hypre for the Schur complement block
386  prec_pt->navier_stokes_preconditioner_pt()->
387  set_p_preconditioner(P_matrix_preconditioner_pt);
388 
389  Preconditioner* F_matrix_preconditioner_pt = new HyprePreconditioner;
390 
391  // Set parameters for use as preconditioner in for momentum
392  // block in Navier-Stokes problem
393  Hypre_default_settings::set_defaults_for_navier_stokes_momentum_block(
394  static_cast<HyprePreconditioner*>(F_matrix_preconditioner_pt));
395 
396  // Use Hypre for momentum block
397  prec_pt->navier_stokes_preconditioner_pt()->
398  set_f_preconditioner(F_matrix_preconditioner_pt);
399  }
400 #endif
401 }
oomph::FSIPreconditioner
Definition: fsi_preconditioners.h:51
oomph::FSIPreconditioner::set_solid_preconditioner_pt
void set_solid_preconditioner_pt(Preconditioner *solid_preconditioner_pt)
Broken assignment operator.
Definition: fsi_preconditioners.h:121
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::HyprePreconditioner
Definition: hypre_solver.h:826
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::Preconditioner
Definition: preconditioner.h:54
oomph::Hypre_default_settings::set_defaults_for_navier_stokes_momentum_block
void set_defaults_for_navier_stokes_momentum_block(HyprePreconditioner *hypre_preconditioner_pt)
Definition: hypre_solver.cc:85
oomph::Hypre_default_settings::set_defaults_for_3D_poisson_problem
void set_defaults_for_3D_poisson_problem(HyprePreconditioner *hypre_preconditioner_pt)
Definition: hypre_solver.cc:72

References oomph::IterativeLinearSolver::max_iter(), oomph::Problem::Max_newton_iterations, oomph::MPI_Helpers::mpi_has_been_initialised(), oomph::FSIPreconditioner::navier_stokes_preconditioner_pt(), oomph::IterativeLinearSolver::preconditioner_pt(), oomph::Hypre_default_settings::set_defaults_for_3D_poisson_problem(), oomph::Hypre_default_settings::set_defaults_for_navier_stokes_momentum_block(), oomph::FSIPreconditioner::set_navier_stokes_mesh(), oomph::FSIPreconditioner::set_solid_preconditioner_pt(), oomph::FSIPreconditioner::set_wall_mesh(), oomph::IterativeLinearSolver::tolerance(), and oomph::FSIPreconditioner::use_block_triangular_version_with_solid_on_fluid().

Member Data Documentation

◆ Adv_diff_mesh_pt [1/2]

template<class NST_ELEMENT , class AD_ELEMENT >
RefineableRectangularQuadMesh< AD_ELEMENT > * RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::Adv_diff_mesh_pt
protected

Advection diffusion mesh.

◆ Adv_diff_mesh_pt [2/2]

template<class NST_ELEMENT , class AD_ELEMENT >
RefineableSimpleCubicMesh<AD_ELEMENT>* RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::Adv_diff_mesh_pt
protected

◆ Doc_info

template<class NST_ELEMENT , class AD_ELEMENT >
DocInfo RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::Doc_info
private

DocInfo object.

◆ Imperfect

template<class NST_ELEMENT , class AD_ELEMENT >
bool RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::Imperfect
private

Is the boundary condition imperfect or not.

◆ Lz

template<class NST_ELEMENT , class AD_ELEMENT >
double RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::Lz
private

◆ Nst_mesh_pt [1/2]

template<class NST_ELEMENT , class AD_ELEMENT >
RefineableRectangularQuadMesh< NST_ELEMENT > * RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::Nst_mesh_pt
protected

Navier Stokes mesh.

◆ Nst_mesh_pt [2/2]

template<class NST_ELEMENT , class AD_ELEMENT >
RefineableSimpleCubicMesh<NST_ELEMENT>* RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::Nst_mesh_pt
protected
The documentation for this class was generated from the following files: