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

Public Member Functions

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

Public Attributes

SingleLayerSpineMesh< ELEMENT > * Bulk_mesh_pt
 Mesh for the bulk fluid elements. More...
 
Mesh * Surface_mesh_pt
 The mesh for the interface elements. More...
 
Mesh * Point_mesh_pt
 The mesh for the element at the contact points. More...
 
- Public Attributes inherited from oomph::Problem
bool Shut_up_in_newton_solve
 

Protected Attributes

RectangularQuadMesh< NST_ELEMENT > * Nst_mesh_pt
 Mesh of Navier Stokes elements. More...
 
RectangularQuadMesh< AD_ELEMENT > * Adv_diff_mesh_pt
 Mesh of advection diffusion elements. 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
 

Private Attributes

DocInfo Doc_info
 DocInfo object. More...
 
bool Surface_pinned
 Boolean to indicate whether the surface is pinned. More...
 
Data * External_pressure_data_pt
 Pointer to the external data point. More...
 

Additional Inherited Members

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

/////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// 2D Convection problem on two rectangular domains, discretised with Navier-Stokes and Advection-Diffusion elements. The specific type of elements 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.

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

Constructor & Destructor Documentation

◆ ConvectionProblem() [1/8]

template<class ELEMENT , class INTERFACE_ELEMENT >
ConvectionProblem< ELEMENT, INTERFACE_ELEMENT >::ConvectionProblem

Constructor.

Constructor for convection problem.

156 {
157 
158  //Allocate a timestepper
159  add_time_stepper_pt(new BDF<2>);
160 
161 
162  // Set output directory
163 #ifdef USE_FD_JACOBIAN_NST_IN_MULTI_DOMAIN_BOUSSINESQ
164  Doc_info.set_directory("RESLT_FD");
165 #else
166  Doc_info.set_directory("RESLT");
167 #endif
168 
169  // # of elements in x-direction
170  unsigned n_x=8;
171 
172  // # of elements in y-direction
173  unsigned n_y=8;
174 
175  // Domain length in x-direction
176  double l_x=3.0;
177 
178  // Domain length in y-direction
179  double l_y=1.0;
180 
181  // Build two standard rectangular quadmesh
182  Nst_mesh_pt =
183  new RectangularQuadMesh<NST_ELEMENT>(n_x,n_y,l_x,l_y,time_stepper_pt());
184  Adv_diff_mesh_pt =
185  new RectangularQuadMesh<AD_ELEMENT>(n_x,n_y,l_x,l_y,time_stepper_pt());
186 
187  // Set the boundary conditions for this problem: All nodes are
188  // free by default -- only need to pin the ones that have Dirichlet
189  // conditions here
190 
191  //Loop over the boundaries
192  unsigned num_bound = nst_mesh_pt()->nboundary();
193  for(unsigned ibound=0;ibound<num_bound;ibound++)
194  {
195  //Set the maximum index to be pinned (all values by default)
196  unsigned val_max;//=3; (fine for combined element... !)
197 
198  //Loop over the number of nodes on the boundry
199  unsigned num_nod= nst_mesh_pt()->nboundary_node(ibound);
200  for (unsigned inod=0;inod<num_nod;inod++)
201  {
202  //If we are on the side-walls, the v-velocity and temperature
203  //satisfy natural boundary conditions, so we only pin the
204  //first value
205  if ((ibound==1) || (ibound==3))
206  {
207  val_max=1;
208  }
209  else // pin all values
210  {
211  val_max=nst_mesh_pt()->boundary_node_pt(ibound,inod)->nvalue();
212  }
213 
214  //Loop over the desired values stored at the nodes and pin
215  for(unsigned j=0;j<val_max;j++)
216  {
217  nst_mesh_pt()->boundary_node_pt(ibound,inod)->pin(j);
218  }
219  }
220  }
221 
222  //Pin the zero-th pressure dof in element 0 and set its value to
223  //zero:
224  fix_pressure(0,0,0.0);
225 
226  //Loop over the boundaries of the AD mesh
227  num_bound = adv_diff_mesh_pt()->nboundary();
228  for(unsigned ibound=0;ibound<num_bound;ibound++)
229  {
230  //Set the maximum index to be pinned (all values by default)
231  unsigned val_max=0;
232 
233  //Loop over the number of nodes on the boundry
234  unsigned num_nod= adv_diff_mesh_pt()->nboundary_node(ibound);
235  for (unsigned inod=0;inod<num_nod;inod++)
236  {
237  //If we are on the side-walls, the v-velocity and temperature
238  //satisfy natural boundary conditions, so we don't pin anything
239  // in this mesh
240  if ((ibound==1) || (ibound==3))
241  {
242  val_max=0;
243  }
244  else // pin all values
245  {
246  val_max=adv_diff_mesh_pt()->boundary_node_pt(ibound,inod)->nvalue();
247  //Loop over the desired values stored at the nodes and pin
248  for(unsigned j=0;j<val_max;j++)
249  {
250  adv_diff_mesh_pt()->boundary_node_pt(ibound,inod)->pin(j);
251  }
252  }
253  }
254  }
255 
256 
257  // Complete the build of all elements so they are fully functional
258 
259  // Loop over the elements to set up element-specific
260  // things that cannot be handled by the (argument-free!) ELEMENT
261  // constructors.
262  unsigned n_nst_element = nst_mesh_pt()->nelement();
263  for(unsigned i=0;i<n_nst_element;i++)
264  {
265  // Upcast from GeneralsedElement to the present element
266  NST_ELEMENT *el_pt = dynamic_cast<NST_ELEMENT*>
267  (nst_mesh_pt()->element_pt(i));
268 
269  // Set the Reynolds number (1/Pr in our non-dimensionalisation)
270  el_pt->re_pt() = &Global_Physical_Variables::Inverse_Prandtl;
271 
272  // Set ReSt (also 1/Pr in our non-dimensionalisation)
273  el_pt->re_st_pt() = &Global_Physical_Variables::Inverse_Prandtl;
274 
275  // Set the Rayleigh number
276  el_pt->ra_pt() = &Global_Physical_Variables::Rayleigh;
277 
278  //Set Gravity vector
279  el_pt->g_pt() = &Global_Physical_Variables::Direction_of_gravity;
280 
281  // We can ignore the external geometric data in the "external"
282  // advection diffusion element when computing the Jacobian matrix
283  // because the interaction does not involve spatial gradients of
284  // the temperature (and also because the mesh isn't moving!)
285  el_pt->ignore_external_geometric_data();
286 
287  //The mesh is fixed, so we can disable ALE
288  el_pt->disable_ALE();
289  }
290 
291  unsigned n_ad_element = adv_diff_mesh_pt()->nelement();
292  for(unsigned i=0;i<n_ad_element;i++)
293  {
294  // Upcast from GeneralsedElement to the present element
295  AD_ELEMENT *el_pt = dynamic_cast<AD_ELEMENT*>
296  (adv_diff_mesh_pt()->element_pt(i));
297 
298  // Set the Peclet number
299  el_pt->pe_pt() = &Global_Physical_Variables::Peclet;
300 
301  // Set the Peclet number multiplied by the Strouhal number
302  el_pt->pe_st_pt() =&Global_Physical_Variables::Peclet;
303 
304  //The mesh is fixed, so we can disable ALE
305  el_pt->disable_ALE();
306 
307  // We can ignore the external geometric data in the "external"
308  // advection diffusion element when computing the Jacobian matrix
309  // because the interaction does not involve spatial gradients of
310  // the temperature (and also because the mesh isn't moving!)
311  el_pt->ignore_external_geometric_data();
312  }
313 
314  // combine the submeshes
315  add_sub_mesh(Nst_mesh_pt);
316  add_sub_mesh(Adv_diff_mesh_pt);
317  build_global_mesh();
318 
319  // Setup multi-domain interaction
320  Multi_domain_functions::
321  setup_multi_domain_interactions<NST_ELEMENT,AD_ELEMENT>
322  (this,nst_mesh_pt(),adv_diff_mesh_pt());
323 
324  // Setup equation numbering scheme
325  cout <<"Number of equations: " << assign_eqn_numbers() << endl;
326 
327 } // end of constructor
i
int i
Definition: BiCGSTAB_step_by_step.cpp:9
AD_ELEMENT
ConvectionProblem::Doc_info
DocInfo Doc_info
DocInfo object.
Definition: mpi/multi_domain/boussinesq_convection/multi_domain_boussinesq_convection.cc:139
ConvectionProblem::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_boussinesq_convection.cc:110
ConvectionProblem::Nst_mesh_pt
RectangularQuadMesh< NST_ELEMENT > * Nst_mesh_pt
Mesh of Navier Stokes elements.
Definition: mpi/multi_domain/boussinesq_convection/multi_domain_boussinesq_convection.cc:144
ConvectionProblem::Adv_diff_mesh_pt
RectangularQuadMesh< AD_ELEMENT > * Adv_diff_mesh_pt
Mesh of advection diffusion elements.
Definition: mpi/multi_domain/boussinesq_convection/multi_domain_boussinesq_convection.cc:147
ConvectionProblem::nst_mesh_pt
RectangularQuadMesh< NST_ELEMENT > * nst_mesh_pt()
Access function to the Navier-Stokes mesh.
Definition: mpi/multi_domain/boussinesq_convection/multi_domain_boussinesq_convection.cc:125
ConvectionProblem::adv_diff_mesh_pt
RectangularQuadMesh< AD_ELEMENT > * adv_diff_mesh_pt()
Access function to the Advection-Diffusion mesh.
Definition: mpi/multi_domain/boussinesq_convection/multi_domain_boussinesq_convection.cc:131
NST_ELEMENT
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_time_stepper_pt
void add_time_stepper_pt(TimeStepper *const &time_stepper_pt)
Definition: problem.cc:1545
oomph::Problem::add_sub_mesh
unsigned add_sub_mesh(Mesh *const &mesh_pt)
Definition: problem.h:1330
oomph::Problem::build_global_mesh
void build_global_mesh()
Definition: problem.cc:1493
oomph::Problem::assign_eqn_numbers
unsigned long assign_eqn_numbers(const bool &assign_local_eqn_numbers=true)
Definition: problem.cc:1989
oomph::Problem::time_stepper_pt
TimeStepper *& time_stepper_pt()
Definition: problem.h:1524
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
j
std::ptrdiff_t j
Definition: tut_arithmetic_redux_minmax.cpp:2

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

◆ ~ConvectionProblem() [1/8]

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

Destructor. Empty.

83 {}

◆ ConvectionProblem() [2/8]

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

Constructor.

◆ ~ConvectionProblem() [2/8]

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

Destructor. Empty.

84 {}

◆ ConvectionProblem() [3/8]

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

Constructor.

◆ ~ConvectionProblem() [3/8]

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

Destructor. Empty.

84 {}

◆ ConvectionProblem() [4/8]

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

Constructor.

◆ ~ConvectionProblem() [4/8]

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

Destructor. Empty.

93 {}

◆ ConvectionProblem() [5/8]

template<class ELEMENT , class INTERFACE_ELEMENT >
ConvectionProblem< ELEMENT, INTERFACE_ELEMENT >::ConvectionProblem ( const bool &  pin = true)

Constructor. The boolean indicates whether the free surface.

Constructor for convection problem.

765  : Surface_pinned(pin)
766 {
767  //Allocate a timestepper
768  add_time_stepper_pt(new BDF<2>);
769 
770  // Set output directory
771  Doc_info.set_directory("RESLT");
772 
773  // # of elements in x-direction
774  unsigned n_x=8;
775 
776  // # of elements in y-direction
777  unsigned n_y=8;
778 
779  // Domain length in x-direction
780  double l_x=3.0;
781 
782  // Domain length in y-direction
783  double l_y=1.0;
784 
785  // Build a standard rectangular quadmesh
786  Bulk_mesh_pt =
787  new SingleLayerSpineMesh<ELEMENT>(n_x,n_y,l_x,l_y,time_stepper_pt());
788 
789 
790  //Create the surface mesh that will contain the interface elements
791  //First create storage, but with no elements or nodes
792  Surface_mesh_pt = new Mesh;
793 
794  //Loop over the horizontal elements
795  for(unsigned i=0;i<n_x;i++)
796  {
797  //Construct a new 1D line element on the face on which the local
798  //coordinate 1 is fixed at its max. value (1) --- This is face 2
799  FiniteElement *interface_element_pt =
800  new INTERFACE_ELEMENT(
801  Bulk_mesh_pt->finite_element_pt(n_x*(n_y-1)+i),2);
802 
803  //Push it back onto the stack
804  this->Surface_mesh_pt->add_element_pt(interface_element_pt);
805  }
806  // Add the two sub-meshes to the problem
807  add_sub_mesh(Bulk_mesh_pt);
808  add_sub_mesh(Surface_mesh_pt);
809 
810  // Combine all sub-meshes into a single mesh
811  build_global_mesh();
812 
813 
814  //Pin the heights of all the spines if the surface is pinned
815  if(Surface_pinned)
816  {
817  unsigned n_spine = Bulk_mesh_pt->nspine();
818  for(unsigned n=0;n<n_spine;n++)
819  {
820  Bulk_mesh_pt->spine_pt(n)->spine_height_pt()->pin(0);
821  }
822  }
823 
824  // Set the boundary conditions for this problem: All nodes are
825  // free by default -- only need to pin the ones that have Dirichlet
826  // conditions here
827 
828  //Loop over the boundaries
829  unsigned num_bound = Bulk_mesh_pt->nboundary();
830  for(unsigned ibound=0;ibound<num_bound;ibound++)
831  {
832  //Set the minimum index to be pinned (all values by default)
833  unsigned val_min=0;
834  //Set the maximum index to be pinned (all values by default)
835  unsigned val_max=3;
836  //If we are on the side-walls, the v-velocity and temperature
837  //satisfy natural boundary conditions, so we only pin the
838  //first value
839  if((ibound==1) || (ibound==3)) {val_max=1;}
840 
841  //If we on the top wall, v velocity is pinned
842  if(ibound==2)
843  {
844  //If the surface is pinned, pin the v velocity
845  if(Surface_pinned) {val_min=1; val_max=2;}
846  //Otherwise pin nothing
847  else {val_min=0; val_max=0;}
848  }
849 
850  //Loop over the number of nodes on the boundary
851  unsigned num_nod= Bulk_mesh_pt->nboundary_node(ibound);
852  for (unsigned inod=0;inod<num_nod;inod++)
853  {
854  //Loop over the desired values stored at the nodes and pin
855  for(unsigned j=val_min;j<val_max;j++)
856  {
857  Bulk_mesh_pt->boundary_node_pt(ibound,inod)->pin(j);
858  }
859  }
860  }
861 
862  //Pin the zero-th pressure dof in element 0 and set its value to
863  //zero:
864  if(Surface_pinned) {fix_pressure(0,0,0.0);}
865 
866  // Complete the build of all elements so they are fully functional
867 
868  // Loop over the elements to set up element-specific
869  // things that cannot be handled by the (argument-free!) ELEMENT
870  // constructor.
871  unsigned n_element = Bulk_mesh_pt->nelement();
872  for(unsigned i=0;i<n_element;i++)
873  {
874  // Upcast from GeneralsedElement to the present element
875  ELEMENT *el_pt = dynamic_cast<ELEMENT*>(Bulk_mesh_pt->element_pt(i));
876 
877  // Set the Peclet number
878  el_pt->pe_pt() = &Global_Physical_Variables::Peclet;
879 
880  // Set the Peclet number multiplied by the Strouhal number
881  el_pt->pe_st_pt() =&Global_Physical_Variables::Peclet;
882 
883  // Set the Reynolds number (1/Pr in our non-dimensionalisation)
884  el_pt->re_pt() = &Global_Physical_Variables::Inverse_Prandtl;
885 
886  // Set ReSt (also 1/Pr in our non-dimensionalisation)
887  el_pt->re_st_pt() = &Global_Physical_Variables::Inverse_Prandtl;
888 
889  // Set the Re/Fr equal to Bo/Ca, the scaled Bond number
890  el_pt->re_invfr_pt() = &Global_Physical_Variables::Scaled_Bond;
891 
892  // Set the Rayleigh number
893  el_pt->ra_pt() = &Global_Physical_Variables::Rayleigh;
894 
895  //Set Gravity vector
896  el_pt->g_pt() = &Global_Physical_Variables::Direction_of_gravity;
897 
898  //If the mesh is fixed, we can disable ALE
899  if(Surface_pinned) {el_pt->disable_ALE();}
900  }
901 
902 
903  // Loop over the interface elements to set up element-specific
904  // things that cannot be handled by the (argument-free!) ELEMENT
905  // constructor.
906  unsigned n_interface = Surface_mesh_pt->nelement();
907  for(unsigned i=0;i<n_interface;i++)
908  {
909  // Upcast from GeneralsedElement to the present element
910  INTERFACE_ELEMENT *el_pt = dynamic_cast<INTERFACE_ELEMENT*>(
911  Surface_mesh_pt->element_pt(i));
912 
913  // Set the Biot number
914  el_pt->bi_pt() = &Global_Physical_Variables::Biot;
915 
916  // Set the Marangoni number
917  el_pt->ma_pt() =&Global_Physical_Variables::Marangoni;
918 
919  // Set the Capillary number
920  el_pt->ca_pt() = &Global_Physical_Variables::Capillary;
921 
922  // Set the surface elasticity number
923  el_pt->beta_pt() = &Global_Physical_Variables::Beta;
924 
925  // Set the surface peclect number
926  el_pt->peclet_s_pt() = &Global_Physical_Variables::Peclet_S;
927 
928  // Set the surface peclect number multiplied by strouhal number
929  el_pt->peclet_strouhal_s_pt() = &Global_Physical_Variables::Peclet_St_S;
930  }
931 
932  // Setup equation numbering scheme
933  cout <<"Number of equations: " << assign_eqn_numbers() << endl;
934 
935 } // end of constructor
n
const unsigned n
Definition: CG3DPackingUnitTest.cpp:11
ConvectionProblem::Surface_mesh_pt
Mesh * Surface_mesh_pt
The mesh for the interface elements.
Definition: surfactant.cc:748
ConvectionProblem::Bulk_mesh_pt
SingleLayerSpineMesh< ELEMENT > * Bulk_mesh_pt
Mesh for the bulk fluid elements.
Definition: surfactant.cc:746
ConvectionProblem::Surface_pinned
bool Surface_pinned
Boolean to indicate whether the surface is pinned.
Definition: surfactant.cc:756
oomph::FiniteElement
Definition: elements.h:1313
oomph::Mesh
Definition: mesh.h:67
oomph::Mesh::add_element_pt
void add_element_pt(GeneralisedElement *const &element_pt)
Add a (pointer to) an element to the mesh.
Definition: mesh.h:617
oomph::SingleLayerSpineMesh
Definition: single_layer_spine_mesh.template.h:47
Global_Physical_Variables::Scaled_Bond
double Scaled_Bond
Definition: surfactant.cc:608
Global_Physical_Variables::Biot
double Biot
Biot number.
Definition: surfactant.cc:611
Global_Physical_Variables::Beta
double Beta
Surface Elasticity number.
Definition: surfactant.cc:622
Global_Physical_Variables::Marangoni
double Marangoni
Marangoni number.
Definition: surfactant.cc:615
Global_Physical_Variables::Capillary
double Capillary
Capillary number.
Definition: surfactant.cc:619
Global_Physical_Variables::Peclet_S
double Peclet_S
Surface Peclet number.
Definition: surfactant.cc:625
Global_Physical_Variables::Peclet_St_S
double Peclet_St_S
\shorT Sufrace Peclet number multiplied by Strouhal number
Definition: surfactant.cc:628

References oomph::Mesh::add_element_pt(), oomph::Problem::add_sub_mesh(), oomph::Problem::add_time_stepper_pt(), oomph::Problem::assign_eqn_numbers(), Global_Physical_Variables::Beta, Global_Physical_Variables::Biot, oomph::Problem::build_global_mesh(), ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::Bulk_mesh_pt, Global_Physical_Variables::Capillary, Global_Physical_Variables::Direction_of_gravity, ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::Doc_info, oomph::Mesh::element_pt(), ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::fix_pressure(), i, Global_Physical_Variables::Inverse_Prandtl, j, Global_Physical_Variables::Marangoni, n, oomph::Mesh::nelement(), Global_Physical_Variables::Peclet, Global_Physical_Variables::Peclet_S, Global_Physical_Variables::Peclet_St_S, Global_Physical_Variables::Rayleigh, Global_Physical_Variables::Scaled_Bond, oomph::DocInfo::set_directory(), ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::Surface_mesh_pt, ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::Surface_pinned, and oomph::Problem::time_stepper_pt().

◆ ~ConvectionProblem() [5/8]

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

Destructor. Empty.

655 {}

◆ ConvectionProblem() [6/8]

template<class NST_ELEMENT , class AD_ELEMENT >
ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::ConvectionProblem ( const bool &  pin = true)

Constructor. The boolean indicates whether the free surface.

◆ ~ConvectionProblem() [6/8]

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

Destructor. Empty.

346 {}

◆ ConvectionProblem() [7/8]

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

Constructor.

◆ ~ConvectionProblem() [7/8]

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

Destructor. Empty.

610 {}

◆ ConvectionProblem() [8/8]

template<class NST_ELEMENT , class AD_ELEMENT >
ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::ConvectionProblem ( const bool &  pin = true)

Constructor. The boolean indicates whether the free surface.

◆ ~ConvectionProblem() [8/8]

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

Destructor. Empty.

773 {}

Member Function Documentation

◆ actions_after_distribute()

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

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

96  {
97  // Re-setup multi-domain interaction
98  Multi_domain_functions::setup_multi_domain_interactions
99  <NST_ELEMENT,AD_ELEMENT>(this,nst_mesh_pt(),adv_diff_mesh_pt());
100  }
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_newton_solve() [1/8]

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

Update the problem after solve (empty)

Reimplemented from oomph::Problem.

89 {}

◆ actions_after_newton_solve() [2/8]

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

Update the problem after solve (empty)

Reimplemented from oomph::Problem.

90 {}

◆ actions_after_newton_solve() [3/8]

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

Update the problem after solve (empty)

Reimplemented from oomph::Problem.

90 {}

◆ actions_after_newton_solve() [4/8]

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

Update the problem after solve (empty)

Reimplemented from oomph::Problem.

99 {}

◆ actions_after_newton_solve() [5/8]

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

Update the problem after solve (empty)

Reimplemented from oomph::Problem.

707 {}

◆ actions_after_newton_solve() [6/8]

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

Update the problem after solve (empty)

Reimplemented from oomph::Problem.

398 {}

◆ actions_after_newton_solve() [7/8]

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

Update the problem after solve (empty)

Reimplemented from oomph::Problem.

630 {}

◆ actions_after_newton_solve() [8/8]

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

Update the problem after solve (empty)

Reimplemented from oomph::Problem.

825 {}

◆ actions_before_adapt() [1/5]

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

Actions before adapt:(empty)

Reimplemented from oomph::Problem.

92 {}

◆ actions_before_adapt() [2/5]

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

Actions before adapt:(empty)

Reimplemented from oomph::Problem.

93 {}

◆ actions_before_adapt() [3/5]

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

Actions before adapt:(empty)

Reimplemented from oomph::Problem.

93 {}

◆ actions_before_adapt() [4/5]

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

Actions before adapt:(empty)

Reimplemented from oomph::Problem.

102 {}

◆ actions_before_adapt() [5/5]

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

Actions before adapt:(empty)

Reimplemented from oomph::Problem.

653 {}

◆ actions_before_implicit_timestep() [1/8]

template<class NST_ELEMENT , class AD_ELEMENT >
void ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::actions_before_implicit_timestep ( )
inlinevirtual

Actions before the timestep (update the the time-dependent boundary conditions)

Reimplemented from oomph::Problem.

105  {
106  set_boundary_conditions(time_pt()->time());
107  }
ConvectionProblem::set_boundary_conditions
void set_boundary_conditions(const double &time)
Set the boundary conditions.
Definition: mpi/multi_domain/boussinesq_convection/multi_domain_boussinesq_convection.cc:336
oomph::Problem::time_pt
Time *& time_pt()
Return a pointer to the global time object.
Definition: problem.h:1504
oomph::Problem::time
double & time()
Return the current value of continuous time.
Definition: problem.cc:11531

◆ actions_before_implicit_timestep() [2/8]

template<class NST_ELEMENT , class AD_ELEMENT >
void ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::actions_before_implicit_timestep ( )
inlinevirtual

Actions before the timestep (update the the time-dependent boundary conditions)

Reimplemented from oomph::Problem.

98  {
99  set_boundary_conditions(time_pt()->time());
100  }

◆ actions_before_implicit_timestep() [3/8]

template<class NST_ELEMENT , class AD_ELEMENT >
void ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::actions_before_implicit_timestep ( )
inlinevirtual

Actions before the timestep (update the the time-dependent boundary conditions)

Reimplemented from oomph::Problem.

98  {
99  set_boundary_conditions(time_pt()->time());
100  }

◆ actions_before_implicit_timestep() [4/8]

template<class NST_ELEMENT , class AD_ELEMENT >
void ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::actions_before_implicit_timestep ( )
inlinevirtual

Actions before the timestep (update the the time-dependent boundary conditions)

Reimplemented from oomph::Problem.

107  {
108  set_boundary_conditions(time_pt()->time());
109  }

◆ actions_before_implicit_timestep() [5/8]

template<class NST_ELEMENT , class AD_ELEMENT >
void ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::actions_before_implicit_timestep ( )
inlinevirtual

Actions before the timestep (update the the time-dependent boundary conditions)

Reimplemented from oomph::Problem.

716  {set_boundary_conditions(time_pt()->time());}

◆ actions_before_implicit_timestep() [6/8]

template<class NST_ELEMENT , class AD_ELEMENT >
void ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::actions_before_implicit_timestep ( )
inlinevirtual

Actions before the timestep (update the the time-dependent boundary conditions)

Reimplemented from oomph::Problem.

423  {set_boundary_conditions(time_pt()->time());}

◆ actions_before_implicit_timestep() [7/8]

template<class NST_ELEMENT , class AD_ELEMENT >
void ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::actions_before_implicit_timestep ( )
inlinevirtual

Actions before the timestep (update the the time-dependent boundary conditions)

Reimplemented from oomph::Problem.

658  {
659  set_boundary_conditions(time_pt()->time());
660  }

◆ actions_before_implicit_timestep() [8/8]

template<class NST_ELEMENT , class AD_ELEMENT >
void ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::actions_before_implicit_timestep ( )
inlinevirtual

Actions before the timestep (update the the time-dependent boundary conditions)

Reimplemented from oomph::Problem.

834  {set_boundary_conditions(time_pt()->time());}

◆ actions_before_newton_convergence_check() [1/4]

template<class NST_ELEMENT , class AD_ELEMENT >
void ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::actions_before_newton_convergence_check ( )
inlinevirtual

Remember to update the nodes if the surface is not pinned.

Reimplemented from oomph::Problem.

711  {if(!Surface_pinned) {Bulk_mesh_pt->node_update();}}

◆ actions_before_newton_convergence_check() [2/4]

template<class NST_ELEMENT , class AD_ELEMENT >
void ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::actions_before_newton_convergence_check ( )
inlinevirtual

Remember to update the nodes if the surface is not pinned.

Reimplemented from oomph::Problem.

402  {
403  if(!Surface_pinned) {Bulk_mesh_pt->node_update();}
404 
405  // This driver code cannot be allowed to use the analytical form of
406  // get_dresidual_dnodal_coordinates(...) that is implemented in the
407  // NavierStokesEquations class, since the elemental residuals have
408  // contributions from external data which is not taken into account
409  // by that routine. We therefore force the bulk elements to use the
410  // fully-finite differenced version.
411  const unsigned n_element = Bulk_mesh_pt->nelement();
412  for(unsigned e=0;e<n_element;e++)
413  {
414  ElementWithMovingNodes* el_pt =
415  dynamic_cast<ElementWithMovingNodes*>(Bulk_mesh_pt->element_pt(e));
416  el_pt->evaluate_shape_derivs_by_direct_fd();
417  }
418  }
e
Array< double, 1, 3 > e(1./3., 0.5, 2.)
oomph::ElementWithMovingNodes
Definition: element_with_moving_nodes.h:65
oomph::ElementWithMovingNodes::evaluate_shape_derivs_by_direct_fd
void evaluate_shape_derivs_by_direct_fd()
Evaluate shape derivatives by direct finite differencing.
Definition: element_with_moving_nodes.h:210

References e(), and oomph::ElementWithMovingNodes::evaluate_shape_derivs_by_direct_fd().

◆ actions_before_newton_convergence_check() [3/4]

template<class NST_ELEMENT , class AD_ELEMENT >
void ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::actions_before_newton_convergence_check ( )
inlinevirtual

Remember to update the nodes!

Reimplemented from oomph::Problem.

634  {
635  Bulk_mesh_pt->node_update();
636 
637  // This driver code cannot be allowed to use the analytical form of
638  // get_dresidual_dnodal_coordinates(...) that is implemented in the
639  // NavierStokesEquations class, since the elemental residuals have
640  // contributions from external data which is not taken into account
641  // by that routine. We therefore force the bulk elements to use the
642  // fully-finite differenced version.
643  const unsigned n_element = Bulk_mesh_pt->nelement();
644  for(unsigned e=0;e<n_element;e++)
645  {
646  ElementWithMovingNodes* el_pt =
647  dynamic_cast<ElementWithMovingNodes*>(Bulk_mesh_pt->element_pt(e));
648  el_pt->evaluate_shape_derivs_by_direct_fd();
649  }
650  }

References e(), and oomph::ElementWithMovingNodes::evaluate_shape_derivs_by_direct_fd().

◆ actions_before_newton_convergence_check() [4/4]

template<class NST_ELEMENT , class AD_ELEMENT >
void ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::actions_before_newton_convergence_check ( )
inlinevirtual

Remember to update the nodes if the surface is not pinned.

Reimplemented from oomph::Problem.

829  {if(!Surface_pinned) {Bulk_mesh_pt->node_update();}}

◆ actions_before_newton_solve() [1/8]

template<class NST_ELEMENT , class AD_ELEMENT >
void ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::actions_before_newton_solve ( )
inlinevirtual

Update the problem specs before solve (empty)

Reimplemented from oomph::Problem.

86 {}

◆ actions_before_newton_solve() [2/8]

template<class NST_ELEMENT , class AD_ELEMENT >
void ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::actions_before_newton_solve ( )
inlinevirtual

Update the problem specs before solve (empty)

Reimplemented from oomph::Problem.

87 {}

◆ actions_before_newton_solve() [3/8]

template<class NST_ELEMENT , class AD_ELEMENT >
void ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::actions_before_newton_solve ( )
inlinevirtual

Update the problem specs before solve (empty)

Reimplemented from oomph::Problem.

87 {}

◆ actions_before_newton_solve() [4/8]

template<class NST_ELEMENT , class AD_ELEMENT >
void ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::actions_before_newton_solve ( )
inlinevirtual

Update the problem specs before solve (empty)

Reimplemented from oomph::Problem.

96 {}

◆ actions_before_newton_solve() [5/8]

template<class NST_ELEMENT , class AD_ELEMENT >
void ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::actions_before_newton_solve ( )
inlinevirtual

Update the problem specs before solve (empty)

Reimplemented from oomph::Problem.

704 {}

◆ actions_before_newton_solve() [6/8]

template<class NST_ELEMENT , class AD_ELEMENT >
void ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::actions_before_newton_solve ( )
inlinevirtual

Update the problem specs before solve (empty)

Reimplemented from oomph::Problem.

395 {}

◆ actions_before_newton_solve() [7/8]

template<class NST_ELEMENT , class AD_ELEMENT >
void ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::actions_before_newton_solve ( )
inlinevirtual

Update the problem specs before solve (empty)

Reimplemented from oomph::Problem.

627 {}

◆ actions_before_newton_solve() [8/8]

template<class NST_ELEMENT , class AD_ELEMENT >
void ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::actions_before_newton_solve ( )
inlinevirtual

Update the problem specs before solve (empty)

Reimplemented from oomph::Problem.

822 {}

◆ adv_diff_mesh_pt() [1/2]

template<class NST_ELEMENT , class AD_ELEMENT >
RectangularQuadMesh<AD_ELEMENT>* ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::adv_diff_mesh_pt ( )
inline

Access function to the Advection-Diffusion mesh.

132  {
133  return dynamic_cast<RectangularQuadMesh<AD_ELEMENT>*>(Adv_diff_mesh_pt);
134  }

◆ adv_diff_mesh_pt() [2/2]

template<class NST_ELEMENT , class AD_ELEMENT >
RectangularQuadMesh<AD_ELEMENT>* ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::adv_diff_mesh_pt ( )
inline

Access function to the Advection-Diffusion mesh.

125  {
126  return dynamic_cast<RectangularQuadMesh<AD_ELEMENT>*>(Adv_diff_mesh_pt);
127  }

◆ doc_solution() [1/8]

template<class ELEMENT , class INTERFACE_ELEMENT >
void ConvectionProblem< ELEMENT, INTERFACE_ELEMENT >::doc_solution

Doc the solution.

407 {
408  //Declare an output stream and filename
409  ofstream some_file;
410  char filename[100];
411 
412  // Number of plot points: npts x npts
413  unsigned npts=5;
414 
415  // Output Navier-Stokes solution
416  sprintf(filename,"%s/fluid_soln%i_on_proc%i.dat",
417  Doc_info.directory().c_str(),
418  Doc_info.number(),
419  this->communicator_pt()->my_rank());
420  some_file.open(filename);
421  nst_mesh_pt()->output(some_file,npts);
422  some_file.close();
423 
424  // Output advection diffusion solution
425  sprintf(filename,"%s/temperature_soln%i_on_proc%i.dat",
426  Doc_info.directory().c_str(),
427  Doc_info.number(),
428  this->communicator_pt()->my_rank());
429  some_file.open(filename);
430  adv_diff_mesh_pt()->output(some_file,npts);
431  some_file.close();
432 
433  Doc_info.number()++;
434 
435 } // end of doc
oomph::DocInfo::directory
std::string directory() const
Output directory.
Definition: oomph_utilities.h:524
oomph::DocInfo::number
unsigned & number()
Number used (e.g.) for labeling output files.
Definition: oomph_utilities.h:554
oomph::Mesh::output
void output(std::ostream &outfile)
Output for all elements.
Definition: mesh.cc:2027
MergeRestartFiles.filename
string filename
Definition: MergeRestartFiles.py:39

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

◆ doc_solution() [2/8]

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

Doc the solution.

◆ doc_solution() [3/8]

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

Doc the solution.

◆ doc_solution() [4/8]

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

Doc the solution.

◆ doc_solution() [5/8]

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

Doc the solution.

◆ doc_solution() [6/8]

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

Doc the solution.

◆ doc_solution() [7/8]

template<class ELEMENT , class INTERFACE_ELEMENT >
void ConvectionProblem< ELEMENT, INTERFACE_ELEMENT >::doc_solution ( std::ofstream &  trace)

Doc the solution.

1024 {
1025  //Declare an output stream and filename
1026  ofstream some_file;
1027  char filename[100];
1028 
1029  // Number of plot points: npts x npts
1030  unsigned npts=5;
1031 
1032  // Output solution
1033  //-----------------
1034  sprintf(filename,"%s/soln%i.dat",Doc_info.directory().c_str(),
1035  Doc_info.number());
1036  some_file.open(filename);
1037  unsigned n_element = Bulk_mesh_pt->nelement();
1038  for(unsigned e=0;e<n_element;e++)
1039  {
1040  Bulk_mesh_pt->finite_element_pt(e)->output(some_file,npts);
1041  }
1042  some_file.close();
1043 
1044  //Output the interface
1045  sprintf(filename,"%s/int%i.dat",Doc_info.directory().c_str(),
1046  Doc_info.number());
1047  some_file.open(filename);
1048 
1049  unsigned n_interface = Surface_mesh_pt->nelement();
1050  for(unsigned i=0;i<n_interface;i++)
1051  {
1052  Surface_mesh_pt->finite_element_pt(i)->output(some_file,npts);
1053  }
1054  some_file.close();
1055 
1056  trace << time_pt()->time() << " "
1057  << Bulk_mesh_pt->boundary_node_pt(2,8)->value(2) << " "
1058  << Bulk_mesh_pt->boundary_node_pt(2,8)->value(3) << std::endl;
1059 
1060 
1061  Doc_info.number()++;
1062 } // end of doc
oomph::FiniteElement::output
virtual void output(std::ostream &outfile)
Definition: elements.h:3050
oomph::Mesh::finite_element_pt
FiniteElement * finite_element_pt(const unsigned &e) const
Definition: mesh.h:473
oomph::Time::time
double & time()
Return the current value of the continuous time.
Definition: timesteppers.h:123

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

◆ doc_solution() [8/8]

template<class NST_ELEMENT , class AD_ELEMENT >
void ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::doc_solution ( std::ofstream &  trace)

Doc the solution.

◆ fix_pressure() [1/8]

template<class NST_ELEMENT , class AD_ELEMENT >
void ConvectionProblem< 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.

112  {
113  //Cast to specific element and fix pressure
114  dynamic_cast<NST_ELEMENT*>(nst_mesh_pt()->element_pt(e))->
115  fix_pressure(pdof,pvalue);
116  } // end_of_fix_pressure

References e().

Referenced by ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::ConvectionProblem().

◆ fix_pressure() [2/8]

template<class NST_ELEMENT , class AD_ELEMENT >
void ConvectionProblem< 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.

105  {
106  //Cast to specific element and fix pressure
107  dynamic_cast<ELEMENT*>(mesh_pt()->element_pt(e))->
108  fix_pressure(pdof,pvalue);
109  } // end_of_fix_pressure
ConvectionProblem::mesh_pt
RectangularQuadMesh< ELEMENT > * mesh_pt()
Definition: boussinesq_convection.cc:120

References e().

◆ fix_pressure() [3/8]

template<class NST_ELEMENT , class AD_ELEMENT >
void ConvectionProblem< 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.

105  {
106  //Cast to specific element and fix pressure
107  dynamic_cast<NST_ELEMENT*>(nst_mesh_pt()->element_pt(e))->
108  fix_pressure(pdof,pvalue);
109  } // end_of_fix_pressure

References e().

◆ fix_pressure() [4/8]

template<class NST_ELEMENT , class AD_ELEMENT >
void ConvectionProblem< 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.

114  {
115  //Cast to specific element and fix pressure
116  dynamic_cast<ELEMENT*>(mesh_pt()->element_pt(e))->
117  fix_pressure(pdof,pvalue);
118  } // end_of_fix_pressure

References e().

◆ fix_pressure() [5/8]

template<class NST_ELEMENT , class AD_ELEMENT >
void ConvectionProblem< 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.

721  {
722  //Cast to specific element and fix pressure
723  dynamic_cast<ELEMENT*>(Bulk_mesh_pt->element_pt(e))->
724  fix_pressure(pdof,pvalue);
725  } // end_of_fix_pressure

References e().

◆ fix_pressure() [6/8]

template<class NST_ELEMENT , class AD_ELEMENT >
void ConvectionProblem< 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.

428  {
429  //Cast to specific element and fix pressure
430  dynamic_cast<ELEMENT*>(Bulk_mesh_pt->element_pt(e))->
431  fix_pressure(pdof,pvalue);
432  } // end_of_fix_pressure

References e().

◆ fix_pressure() [7/8]

template<class NST_ELEMENT , class AD_ELEMENT >
void ConvectionProblem< 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.

665  {
666  //Cast to specific element and fix pressure
667  dynamic_cast<ELEMENT*>(Bulk_mesh_pt->element_pt(e))->
668  fix_pressure(pdof,pvalue);
669  } // end_of_fix_pressure

References e().

◆ fix_pressure() [8/8]

template<class NST_ELEMENT , class AD_ELEMENT >
void ConvectionProblem< 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.

839  {
840  //Cast to specific element and fix pressure
841  dynamic_cast<ELEMENT*>(Bulk_mesh_pt->element_pt(e))->
842  fix_pressure(pdof,pvalue);
843  } // end_of_fix_pressure

References e().

◆ get_kinetic_energy()

template<class ELEMENT >
void ConvectionProblem< ELEMENT >::get_kinetic_energy ( double &  E,
double &  Edot 
)

Get kinetic energy and kinetic energy flux.

260 {
261  //Reset values to zero
262  E = 0.0; Edot=0.0;
263 
264  //Loop over the elements
265  unsigned n_element = mesh_pt()->nelement();
266  for(unsigned e=0;e<n_element;e++)
267  {
268  ELEMENT* elem_pt = dynamic_cast<ELEMENT*>(mesh_pt()->element_pt(e));
269 
270  E += elem_pt->kin_energy();
271  Edot += elem_pt->d_kin_energy_dt();
272  }
273 }
Global_Physical_Variables::E
double E
Elastic modulus.
Definition: TwenteMeshGluing.cpp:68

References Global_Physical_Variables::E, and e().

◆ mesh_pt() [1/2]

template<class NST_ELEMENT , class AD_ELEMENT >
RectangularQuadMesh<ELEMENT>* ConvectionProblem< 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.

121  {
122  return dynamic_cast<RectangularQuadMesh<ELEMENT>*>(
123  Problem::mesh_pt());
124  }

References oomph::Problem::mesh_pt().

◆ mesh_pt() [2/2]

template<class NST_ELEMENT , class AD_ELEMENT >
RectangularQuadMesh<ELEMENT>* ConvectionProblem< 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.

130  {
131  return dynamic_cast<RectangularQuadMesh<ELEMENT>*>(
132  Problem::mesh_pt());
133  }

References oomph::Problem::mesh_pt().

◆ nst_mesh_pt() [1/2]

template<class NST_ELEMENT , class AD_ELEMENT >
RectangularQuadMesh<NST_ELEMENT>* ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::nst_mesh_pt ( )
inline

Access function to the Navier-Stokes mesh.

126  {
127  return dynamic_cast<RectangularQuadMesh<NST_ELEMENT>*>(Nst_mesh_pt);
128  }

◆ nst_mesh_pt() [2/2]

template<class NST_ELEMENT , class AD_ELEMENT >
RectangularQuadMesh<NST_ELEMENT>* ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::nst_mesh_pt ( )
inline

Access function to the Navier-Stokes mesh.

119  {
120  return dynamic_cast<RectangularQuadMesh<NST_ELEMENT>*>(Nst_mesh_pt);
121  }

◆ set_boundary_conditions() [1/8]

template<class ELEMENT , class INTERFACE_ELEMENT >
void ConvectionProblem< ELEMENT, INTERFACE_ELEMENT >::set_boundary_conditions ( const double &  time)

Set the boundary conditions.

Set the boundary conditions as a function of continuous time

338 {
339  // Loop over all the boundaries on the NST mesh
340  unsigned num_bound=nst_mesh_pt()->nboundary();
341  for(unsigned ibound=0;ibound<num_bound;ibound++)
342  {
343  // Loop over the nodes on boundary
344  unsigned num_nod=nst_mesh_pt()->nboundary_node(ibound);
345  for(unsigned inod=0;inod<num_nod;inod++)
346  {
347  // Get pointer to node
348  Node* nod_pt=nst_mesh_pt()->boundary_node_pt(ibound,inod);
349 
350  //Set the number of velocity components
351  unsigned vel_max=2;
352 
353  //If we are on the side walls we only set the x-velocity.
354  if((ibound==1) || (ibound==3)) {vel_max = 1;}
355 
356  //Set the pinned velocities to zero on NST mesh
357  for(unsigned j=0;j<vel_max;j++) {nod_pt->set_value(j,0.0);}
358 
359  //If we are on the top boundary
360  if(ibound==2)
361  {
362  //Add small velocity imperfection if desired
363  double epsilon = 0.01;
364 
365  //Read out the x position
366  double x = nod_pt->x(0);
367 
368  //Set a sinusoidal perturbation in the vertical velocity
369  //This perturbation is mass conserving
370  double value = sin(2.0*MathematicalConstants::Pi*x/3.0)*
371  epsilon*time*exp(-time);
372  nod_pt->set_value(1,value);
373  }
374 
375  }
376  }
377 
378  // Loop over all the boundaries on the AD mesh
379  num_bound=adv_diff_mesh_pt()->nboundary();
380  for(unsigned ibound=0;ibound<num_bound;ibound++)
381  {
382  // Loop over the nodes on boundary
383  unsigned num_nod=adv_diff_mesh_pt()->nboundary_node(ibound);
384  for(unsigned inod=0;inod<num_nod;inod++)
385  {
386  // Get pointer to node
387  Node* nod_pt=adv_diff_mesh_pt()->boundary_node_pt(ibound,inod);
388 
389  //If we are on the top boundary, set the temperature
390  //to -0.5 (cooled)
391  if(ibound==2) {nod_pt->set_value(0,-0.5);}
392 
393  //If we are on the bottom boundary, set the temperature
394  //to 0.5 (heated)
395  if(ibound==0) {nod_pt->set_value(0,0.5);}
396  }
397  }
398 
399 
400 } // end_of_set_boundary_conditions
sin
AnnoyingScalar sin(const AnnoyingScalar &x)
Definition: AnnoyingScalar.h:137
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
BiharmonicTestFunctions2::Pi
double Pi
Definition: two_d_biharmonic.cc:235
Eigen::bfloat16_impl::exp
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 exp(const bfloat16 &a)
Definition: BFloat16.h:615
Eigen::value
squared absolute value
Definition: GlobalFunctions.h:87
oomph::SarahBL::epsilon
double epsilon
Definition: osc_ring_sarah_asymptotics.h:43
plotDoE.x
list x
Definition: plotDoE.py:28

References oomph::SarahBL::epsilon, Eigen::bfloat16_impl::exp(), j, oomph::MathematicalConstants::Pi, oomph::Data::set_value(), sin(), Eigen::value, plotDoE::x, and oomph::Node::x().

◆ set_boundary_conditions() [2/8]

template<class NST_ELEMENT , class AD_ELEMENT >
void ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::set_boundary_conditions ( const double &  time)

Set the boundary conditions.

◆ set_boundary_conditions() [3/8]

template<class NST_ELEMENT , class AD_ELEMENT >
void ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::set_boundary_conditions ( const double &  time)

Set the boundary conditions.

◆ set_boundary_conditions() [4/8]

template<class NST_ELEMENT , class AD_ELEMENT >
void ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::set_boundary_conditions ( const double &  time)

Set the boundary conditions.

◆ set_boundary_conditions() [5/8]

template<class NST_ELEMENT , class AD_ELEMENT >
void ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::set_boundary_conditions ( const double &  time)

Set the boundary conditions.

◆ set_boundary_conditions() [6/8]

template<class NST_ELEMENT , class AD_ELEMENT >
void ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::set_boundary_conditions ( const double &  time)

Set the boundary conditions.

◆ set_boundary_conditions() [7/8]

template<class NST_ELEMENT , class AD_ELEMENT >
void ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::set_boundary_conditions ( const double &  time)

Set the boundary conditions.

◆ set_boundary_conditions() [8/8]

template<class NST_ELEMENT , class AD_ELEMENT >
void ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::set_boundary_conditions ( const double &  time)

Set the boundary conditions.

◆ switch_boundary_conditions()

template<class NST_ELEMENT , class AD_ELEMENT >
void ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::switch_boundary_conditions ( )
inline

Unpin things for timestepping.

614  {
615  //Pin the external pressure
616  External_pressure_data_pt->pin(0);
617  //Release the internal pressure
618  unfix_pressure(0,0);
619 
620  //Set the new number of unknowns
621  std::cout << "Preparing to timestep: "
622  << assign_eqn_numbers() << "\n";
623  }
ConvectionProblem::External_pressure_data_pt
Data * External_pressure_data_pt
Pointer to the external data point.
Definition: marangoni_convection_box.cc:702
ConvectionProblem::unfix_pressure
void unfix_pressure(const unsigned &e, const unsigned &pdof)
UnFix pressure in element e at pressure dof pdof and set to pvalue.
Definition: surfactant.cc:729

◆ unfix_pressure() [1/4]

template<class NST_ELEMENT , class AD_ELEMENT >
void ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::unfix_pressure ( const unsigned &  e,
const unsigned &  pdof 
)
inline

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

730  {
731  //Cast to specific element and fix pressure
732  dynamic_cast<ELEMENT*>(Bulk_mesh_pt->element_pt(e))->
733  unfix_pressure(pdof);
734  } // end_of_unfix_pressure

References e().

◆ unfix_pressure() [2/4]

template<class NST_ELEMENT , class AD_ELEMENT >
void ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::unfix_pressure ( const unsigned &  e,
const unsigned &  pdof 
)
inline

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

437  {
438  //Cast to specific element and fix pressure
439  dynamic_cast<ELEMENT*>(Bulk_mesh_pt->element_pt(e))->
440  unfix_pressure(pdof);
441  } // end_of_unfix_pressure

References e().

◆ unfix_pressure() [3/4]

template<class NST_ELEMENT , class AD_ELEMENT >
void ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::unfix_pressure ( const unsigned &  e,
const unsigned &  pdof 
)
inline

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

674  {
675  //Cast to specific element and fix pressure
676  dynamic_cast<ELEMENT*>(Bulk_mesh_pt->element_pt(e))->
677  unfix_pressure(pdof);
678  } // end_of_unfix_pressure

References e().

◆ unfix_pressure() [4/4]

template<class NST_ELEMENT , class AD_ELEMENT >
void ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::unfix_pressure ( const unsigned &  e,
const unsigned &  pdof 
)
inline

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

848  {
849  //Cast to specific element and fix pressure
850  dynamic_cast<ELEMENT*>(Bulk_mesh_pt->element_pt(e))->
851  unfix_pressure(pdof);
852  } // end_of_unfix_pressure

References e().

◆ unpin_surface() [1/3]

template<class NST_ELEMENT , class AD_ELEMENT >
void ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::unpin_surface ( )
inline

Release the free surface so that it can move.

659  {
660  //Only bother if the surface is pinned
661  if(Surface_pinned)
662  {
663  Surface_pinned = false;
664 
665  //Unpin the heights of all the spines in the middle
666  unsigned n_spine = Bulk_mesh_pt->nspine();
667  for(unsigned n=0;n<n_spine;n++)
668  {
669  Bulk_mesh_pt->spine_pt(n)->spine_height_pt()->unpin(0);
670  }
671 
672  //If we on the top wall, v velocity is no longer pinned
673  unsigned ibound=2;
674  //Loop over the number of nodes on the boundary
675  unsigned num_nod= Bulk_mesh_pt->nboundary_node(ibound);
676  for (unsigned inod=0;inod<num_nod;inod++)
677  {
678  //Loop over the desired values stored at the nodes and unpin
679  Bulk_mesh_pt->boundary_node_pt(ibound,inod)->unpin(1);
680  }
681 
682  //Unfix the pressure
683  unfix_pressure(0,0);
684 
685  // Loop over the elements to set up element-specific
686  // and re-enable ALE
687  unsigned n_element = Bulk_mesh_pt->nelement();
688  for(unsigned i=0;i<n_element;i++)
689  {
690  // Upcast from GeneralsedElement to the present element
691  ELEMENT *el_pt = dynamic_cast<ELEMENT*>(Bulk_mesh_pt->element_pt(i));
692 
693  el_pt->enable_ALE();
694  }
695 
696  //Reassign the equation number
697  std::cout << "Surface unpinned to give "
698  << assign_eqn_numbers() << " equation numbers\n";
699  }
700  }

References i, and n.

◆ unpin_surface() [2/3]

template<class NST_ELEMENT , class AD_ELEMENT >
void ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::unpin_surface ( )
inline

Release the free surface so that it can move.

350  {
351  //Only bother if the surface is pinned
352  if(Surface_pinned)
353  {
354  Surface_pinned = false;
355 
356  //Unpin the heights of all the spines in the middle
357  unsigned n_spine = Bulk_mesh_pt->nspine();
358  for(unsigned n=0;n<n_spine;n++)
359  {
360  Bulk_mesh_pt->spine_pt(n)->spine_height_pt()->unpin(0);
361  }
362 
363  //If we on the top wall, v velocity is no longer pinned
364  unsigned ibound=2;
365  //Loop over the number of nodes on the boundary
366  unsigned num_nod= Bulk_mesh_pt->nboundary_node(ibound);
367  for (unsigned inod=0;inod<num_nod;inod++)
368  {
369  //Loop over the desired values stored at the nodes and unpin
370  Bulk_mesh_pt->boundary_node_pt(ibound,inod)->unpin(1);
371  }
372 
373  //Unfix the pressure
374  unfix_pressure(0,0);
375 
376  // Loop over the elements to set up element-specific
377  // and re-enable ALE
378  unsigned n_element = Bulk_mesh_pt->nelement();
379  for(unsigned i=0;i<n_element;i++)
380  {
381  // Upcast from GeneralsedElement to the present element
382  ELEMENT *el_pt = dynamic_cast<ELEMENT*>(Bulk_mesh_pt->element_pt(i));
383 
384  el_pt->enable_ALE();
385  }
386 
387  //Reassign the equation number
388  std::cout << "Surface unpinned to give "
389  << assign_eqn_numbers() << " equation numbers\n";
390  }
391  }

References i, and n.

◆ unpin_surface() [3/3]

template<class NST_ELEMENT , class AD_ELEMENT >
void ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::unpin_surface ( )
inline

Release the free surface so that it can move.

777  {
778  //Only bother if the surface is pinned
779  if(Surface_pinned)
780  {
781  Surface_pinned = false;
782 
783  //Unpin the heights of all the spines in the middle
784  unsigned n_spine = Bulk_mesh_pt->nspine();
785  for(unsigned n=0;n<n_spine;n++)
786  {
787  Bulk_mesh_pt->spine_pt(n)->spine_height_pt()->unpin(0);
788  }
789 
790  //If we on the top wall, v velocity is no longer pinned
791  unsigned ibound=2;
792  //Loop over the number of nodes on the boundary
793  unsigned num_nod= Bulk_mesh_pt->nboundary_node(ibound);
794  for (unsigned inod=0;inod<num_nod;inod++)
795  {
796  //Loop over the desired values stored at the nodes and unpin
797  Bulk_mesh_pt->boundary_node_pt(ibound,inod)->unpin(1);
798  }
799 
800  //Unfix the pressure
801  unfix_pressure(0,0);
802 
803  // Loop over the elements to set up element-specific
804  // and re-enable ALE
805  unsigned n_element = Bulk_mesh_pt->nelement();
806  for(unsigned i=0;i<n_element;i++)
807  {
808  // Upcast from GeneralsedElement to the present element
809  ELEMENT *el_pt = dynamic_cast<ELEMENT*>(Bulk_mesh_pt->element_pt(i));
810 
811  el_pt->enable_ALE();
812  }
813 
814  //Reassign the equation number
815  std::cout << "Surface unpinned to give "
816  << assign_eqn_numbers() << " equation numbers\n";
817  }
818  }

References i, and n.

Member Data Documentation

◆ Adv_diff_mesh_pt

template<class NST_ELEMENT , class AD_ELEMENT >
RectangularQuadMesh< AD_ELEMENT > * ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::Adv_diff_mesh_pt
protected

Mesh of advection diffusion elements.

◆ Bulk_mesh_pt

template<class NST_ELEMENT , class AD_ELEMENT >
SingleLayerSpineMesh< ELEMENT > * ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::Bulk_mesh_pt

Mesh for the bulk fluid elements.

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

Referenced by ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::ConvectionProblem().

◆ Doc_info

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

DocInfo object.

Referenced by ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::ConvectionProblem().

◆ External_pressure_data_pt

template<class NST_ELEMENT , class AD_ELEMENT >
Data* ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::External_pressure_data_pt
private

Pointer to the external data point.

◆ Nst_mesh_pt

template<class NST_ELEMENT , class AD_ELEMENT >
RectangularQuadMesh< NST_ELEMENT > * ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::Nst_mesh_pt
protected

Mesh of Navier Stokes elements.

◆ Point_mesh_pt

template<class NST_ELEMENT , class AD_ELEMENT >
Mesh* ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::Point_mesh_pt

The mesh for the element at the contact points.

◆ Surface_mesh_pt

template<class NST_ELEMENT , class AD_ELEMENT >
Mesh * ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::Surface_mesh_pt

The mesh for the interface elements.

Referenced by ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::ConvectionProblem().

◆ Surface_pinned

template<class NST_ELEMENT , class AD_ELEMENT >
bool ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::Surface_pinned
private

Boolean to indicate whether the surface is pinned.

Referenced by ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::ConvectionProblem().

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