Public Member Functions | Private Member Functions | Private Attributes | List of all members
AxisymFreeSurfaceNozzleAdvDiffRobinProblem< ELEMENT > Class Template Reference
+ Inheritance diagram for AxisymFreeSurfaceNozzleAdvDiffRobinProblem< ELEMENT >:

Public Member Functions

 AxisymFreeSurfaceNozzleAdvDiffRobinProblem (const unsigned &n_r, const unsigned &n_z, const double &l_r, const double &h)
 Constructor for convection problem. More...
 
 ~AxisymFreeSurfaceNozzleAdvDiffRobinProblem ()
 Destructor. Empty. More...
 
void actions_before_newton_convergence_check ()
 
void doc_solution (DocInfo &doc_info)
 Doc the solution. More...
 
void steady_run ()
 Do steady run up to maximum time t_max with given timestep dt. 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_before_adapt ()
 
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 ()
 

Private Member Functions

void actions_before_newton_solve ()
 
void actions_after_newton_solve ()
 Update the problem after solve (empty) More...
 
void create_flux_elements (const unsigned &b, Mesh *const &bulk_mesh_pt, Mesh *const &surface_mesh_pt)
 
void delete_flux_elements (Mesh *const &surface_mesh_pt)
 Delete Axisymmetric Advection Diffusion flux elements and wipe the surface mesh. More...
 
void deform_free_surface (const double &Dr)
 Deform the mesh/free surface to a prescribed function. More...
 

Private Attributes

HorizontalSingleLayerSpineMesh< ELEMENT > * Bulk_mesh_pt
 Pointer to the "bulk" mesh. More...
 
Mesh * Surface_mesh_pt
 Pointer to the "surface" mesh of flux elements. More...
 
Mesh * Interface_mesh_pt
 Pointer to the mesh of interface elements. More...
 
double Lr
 Pointer to viscosity ratio function. More...
 
double Height
 Height of the domain. More...
 

Additional Inherited Members

- Public Types inherited from oomph::Problem
typedef void(* SpatialErrorEstimatorFctPt) (Mesh *&mesh_pt, Vector< double > &elemental_error)
 Function pointer for spatial error estimator. More...
 
typedef void(* SpatialErrorEstimatorWithDocFctPt) (Mesh *&mesh_pt, Vector< double > &elemental_error, DocInfo &doc_info)
 Function pointer for spatial error estimator with doc. More...
 
- Public Attributes inherited from oomph::Problem
bool Shut_up_in_newton_solve
 
- Static Public Attributes inherited from oomph::Problem
static bool Suppress_warning_about_actions_before_read_unstructured_meshes
 
- Protected Types inherited from oomph::Problem
enum  Assembly_method {
  Perform_assembly_using_vectors_of_pairs , Perform_assembly_using_two_vectors , Perform_assembly_using_maps , Perform_assembly_using_lists ,
  Perform_assembly_using_two_arrays
}
 Enumerated flags to determine which sparse assembly method is used. More...
 
- Protected Member Functions inherited from oomph::Problem
unsigned setup_element_count_per_dof ()
 
virtual void sparse_assemble_row_or_column_compressed (Vector< int * > &column_or_row_index, Vector< int * > &row_or_column_start, Vector< double * > &value, Vector< unsigned > &nnz, Vector< double * > &residual, bool compressed_row_flag)
 
virtual void actions_before_newton_step ()
 
virtual void actions_after_newton_step ()
 
virtual void actions_before_implicit_timestep ()
 
virtual void actions_after_implicit_timestep ()
 
virtual void actions_after_implicit_timestep_and_error_estimation ()
 
virtual void actions_before_explicit_timestep ()
 Actions that should be performed before each explicit time step. More...
 
virtual void actions_after_explicit_timestep ()
 Actions that should be performed after each explicit time step. More...
 
virtual void actions_before_read_unstructured_meshes ()
 
virtual void actions_after_read_unstructured_meshes ()
 
virtual void actions_after_change_in_global_parameter (double *const &parameter_pt)
 
virtual void actions_after_change_in_bifurcation_parameter ()
 
virtual void actions_after_parameter_increase (double *const &parameter_pt)
 
double & dof_derivative (const unsigned &i)
 
double & dof_current (const unsigned &i)
 
virtual void set_initial_condition ()
 
virtual double global_temporal_error_norm ()
 
unsigned newton_solve_continuation (double *const &parameter_pt)
 
unsigned newton_solve_continuation (double *const &parameter_pt, DoubleVector &z)
 
void calculate_continuation_derivatives (double *const &parameter_pt)
 
void calculate_continuation_derivatives (const DoubleVector &z)
 
void calculate_continuation_derivatives_fd (double *const &parameter_pt)
 
bool does_pointer_correspond_to_problem_data (double *const &parameter_pt)
 
void set_consistent_pinned_values_for_continuation ()
 
- Protected Attributes inherited from oomph::Problem
Vector< Problem * > Copy_of_problem_pt
 
std::map< double *, bool > Calculate_dparameter_analytic
 
bool Calculate_hessian_products_analytic
 
LinearAlgebraDistribution * Dof_distribution_pt
 
Vector< double * > Dof_pt
 Vector of pointers to dofs. More...
 
DoubleVectorWithHaloEntries Element_count_per_dof
 
double Relaxation_factor
 
double Newton_solver_tolerance
 
unsigned Max_newton_iterations
 Maximum number of Newton iterations. More...
 
unsigned Nnewton_iter_taken
 
Vector< double > Max_res
 Maximum residuals at start and after each newton iteration. More...
 
double Max_residuals
 
bool Time_adaptive_newton_crash_on_solve_fail
 
bool Jacobian_reuse_is_enabled
 Is re-use of Jacobian in Newton iteration enabled? Default: false. More...
 
bool Jacobian_has_been_computed
 
bool Problem_is_nonlinear
 
bool Pause_at_end_of_sparse_assembly
 
bool Doc_time_in_distribute
 
unsigned Sparse_assembly_method
 
unsigned Sparse_assemble_with_arrays_initial_allocation
 
unsigned Sparse_assemble_with_arrays_allocation_increment
 
Vector< Vector< unsigned > > Sparse_assemble_with_arrays_previous_allocation
 
double Numerical_zero_for_sparse_assembly
 
double FD_step_used_in_get_hessian_vector_products
 
bool Mass_matrix_reuse_is_enabled
 
bool Mass_matrix_has_been_computed
 
bool Discontinuous_element_formulation
 
double Minimum_dt
 Minimum desired dt: if dt falls below this value, exit. More...
 
double Maximum_dt
 Maximum desired dt. More...
 
double DTSF_max_increase
 
double DTSF_min_decrease
 
double Minimum_dt_but_still_proceed
 
bool Scale_arc_length
 Boolean to control whether arc-length should be scaled. More...
 
double Desired_proportion_of_arc_length
 Proportion of the arc-length to taken by the parameter. More...
 
double Theta_squared
 
int Sign_of_jacobian
 Storage for the sign of the global Jacobian. More...
 
double Continuation_direction
 
double Parameter_derivative
 Storage for the derivative of the global parameter wrt arc-length. More...
 
double Parameter_current
 Storage for the present value of the global parameter. More...
 
bool Use_continuation_timestepper
 Boolean to control original or new storage of dof stuff. More...
 
unsigned Dof_derivative_offset
 
unsigned Dof_current_offset
 
Vector< double > Dof_derivative
 Storage for the derivative of the problem variables wrt arc-length. More...
 
Vector< double > Dof_current
 Storage for the present values of the variables. More...
 
double Ds_current
 Storage for the current step value. More...
 
unsigned Desired_newton_iterations_ds
 
double Minimum_ds
 Minimum desired value of arc-length. More...
 
bool Bifurcation_detection
 Boolean to control bifurcation detection via determinant of Jacobian. More...
 
bool Bisect_to_find_bifurcation
 Boolean to control wheter bisection is used to located bifurcation. More...
 
bool First_jacobian_sign_change
 Boolean to indicate whether a sign change has occured in the Jacobian. More...
 
bool Arc_length_step_taken
 Boolean to indicate whether an arc-length step has been taken. More...
 
bool Use_finite_differences_for_continuation_derivatives
 
OomphCommunicator * Communicator_pt
 The communicator for this problem. More...
 
bool Always_take_one_newton_step
 
double Timestep_reduction_factor_after_nonconvergence
 
bool Keep_temporal_error_below_tolerance
 
- Static Protected Attributes inherited from oomph::Problem
static ContinuationStorageScheme Continuation_time_stepper
 Storage for the single static continuation timestorage object. More...
 

Detailed Description

template<class ELEMENT>
class AxisymFreeSurfaceNozzleAdvDiffRobinProblem< ELEMENT >

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

Constructor & Destructor Documentation

◆ AxisymFreeSurfaceNozzleAdvDiffRobinProblem()

template<class ELEMENT >
AxisymFreeSurfaceNozzleAdvDiffRobinProblem< ELEMENT >::AxisymFreeSurfaceNozzleAdvDiffRobinProblem ( const unsigned &  n_r,
const unsigned &  n_z,
const double &  l_r,
const double &  h 
)

Constructor for convection problem.

Constructor: Pass the number of elements and the lengths of the domain in the r and z directions (h is the height of the fluid layer i.e. the length of the domain in the z direction)

238  : Lr(l_r),
239  Height(h)
240 {
241  // Build and assign mesh
242  Bulk_mesh_pt =
243  new HorizontalSingleLayerSpineMesh<ELEMENT>(n_r,n_z,l_r,h);
244 
245  //Create "surface mesh" that will only contain the interface elements
246  Interface_mesh_pt = new Mesh;
247  {
248  // How many bulk elements are adjacent to boundary b?
249  unsigned n_element = Bulk_mesh_pt->nboundary_element(1);
250 
251  // Loop over the bulk elements adjacent to boundary b?
252  for(unsigned e=0;e<n_element;e++)
253  {
254  // Get pointer to the bulk element that is adjacent to boundary b
255  ELEMENT* bulk_elem_pt = dynamic_cast<ELEMENT*>(
256  Bulk_mesh_pt->boundary_element_pt(1,e));
257 
258  // Find the index of the face of element e along boundary b
259  int face_index = Bulk_mesh_pt->face_index_at_boundary(1,e);
260 
261  // Build the corresponding free surface element
262  SpineAxisymmetricFluidInterfaceElement<ELEMENT>* interface_element_pt = new
263  SpineAxisymmetricFluidInterfaceElement<ELEMENT>(bulk_elem_pt,face_index);
264 
265  //Add the prescribed-flux element to the surface mesh
266  Interface_mesh_pt->add_element_pt(interface_element_pt);
267 
268  } //end of loop over bulk elements adjacent to boundary b
269  }
270 
271 
272  // Create "surface mesh" that will contain only the prescribed-flux
273  // elements. The constructor just creates the mesh without
274  // giving it any elements, nodes, etc.
275  Surface_mesh_pt = new Mesh;
276 
277  // Create prescribed-flux elements from all elements that are
278  // adjacent to boundary 1, but add them to a separate mesh.
279  // Note that this is exactly the same function as used in the
280  // single mesh version of the problem, we merely pass different Mesh pointers.
281  create_flux_elements(1,Bulk_mesh_pt,Surface_mesh_pt);
282 
283  // Add the two sub meshes to the problem
284  add_sub_mesh(Bulk_mesh_pt);
285  add_sub_mesh(Interface_mesh_pt);
286  add_sub_mesh(Surface_mesh_pt);
287 
288  // Combine all submeshes into a single Mesh
289  build_global_mesh();
290 
291  // --------------------------------------------
292  // Set the boundary conditions for this problem
293  // --------------------------------------------
294 
295  // All nodes are free by default -- only need to pin the ones
296  // that have Dirichlet conditions here
297 
298  //Loop over the boundaries
299  unsigned num_bound = Bulk_mesh_pt->nboundary();
300  for(unsigned ibound=0;ibound<num_bound;ibound++)
301  {
302  //Loop over the number of nodes on the boundary
303  unsigned num_nod= Bulk_mesh_pt->nboundary_node(ibound);
304  switch (ibound)
305  {
306  case 0:
307  for (unsigned inod=0;inod<num_nod;inod++)
308  {
309  //Pin all velocities (Outlet zone)
310  //Bulk_mesh_pt->boundary_node_pt(ibound,inod)->pin(0);
311  Bulk_mesh_pt->boundary_node_pt(ibound,inod)->pin(1);
312  Bulk_mesh_pt->boundary_node_pt(ibound,inod)->pin(2);
313  }
314  break;
315  case 1:
316  for (unsigned inod=0;inod<num_nod;inod++)
317  {
318  double z_value = Bulk_mesh_pt->boundary_node_pt(ibound,inod)->x(1);
319  //Pin all velocities (Wall)
320  Bulk_mesh_pt->boundary_node_pt(ibound,inod)->pin(2);
321  if (z_value>=(Height/1.1))
322  {
323  Bulk_mesh_pt->boundary_node_pt(ibound,inod)->pin(0);
324  Bulk_mesh_pt->boundary_node_pt(ibound,inod)->pin(1);
325  //Bulk_mesh_pt->boundary_node_pt(ibound,inod)->pin(3);
326  }
327  }
328  break;
329  case 2:
330  for (unsigned inod=0;inod<num_nod;inod++)
331  {
332  //Pin all velocities (Inlet zone) and temperature
333  Bulk_mesh_pt->boundary_node_pt(ibound,inod)->pin(0);
334  Bulk_mesh_pt->boundary_node_pt(ibound,inod)->pin(1);
335  Bulk_mesh_pt->boundary_node_pt(ibound,inod)->pin(2);
336  Bulk_mesh_pt->boundary_node_pt(ibound,inod)->pin(3);
337  }
338  break;
339  default:
340  for (unsigned inod=0;inod<num_nod;inod++)
341  {
342  //Pin all velocities (axis of simmetry)
343  Bulk_mesh_pt->boundary_node_pt(ibound,inod)->pin(0);
344  Bulk_mesh_pt->boundary_node_pt(ibound,inod)->pin(2);
345  }
346  break;
347  }
348  }
349 
350  // Pin spine height at top of domain
351  unsigned first_spine = Bulk_mesh_pt->nspine()-5;
352  unsigned last_spine = Bulk_mesh_pt->nspine()-1;
353  for (unsigned num_spine=first_spine;num_spine<=last_spine;num_spine++)
354  {
355  Bulk_mesh_pt->spine_pt(num_spine)->spine_height_pt()->pin(0);
356  }
357 
358  // ----------------------------------------------------------------
359  // Complete the problem setup to make the elements fully functional
360  // ----------------------------------------------------------------
361 
362  //Find number of elements in mesh
363  unsigned n_element = Bulk_mesh_pt->nelement();
364 
365  // Loop over the elements to set up element-specific
366  // things that cannot be handled by constructor
367  // Loop over the bulk elements
368  for(unsigned e=0;e<n_element;e++)
369  {
370  // Upcast from GeneralisedElement to the present element
371  ELEMENT *el_pt = dynamic_cast<ELEMENT*>(Bulk_mesh_pt->element_pt(e));
372 
373  // Set the Reynolds number
374  el_pt->re_pt() = &Global_Physical_Variables::Re;
375 
376  // Set the product of the Reynolds number and the inverse of the
377  // Froude number
378  el_pt->re_invfr_pt() = &Global_Physical_Variables::ReInvFr;
379 
380  // Set the direction of gravity
381  el_pt->g_pt() = &Global_Physical_Variables::Direction_of_gravity;
382 
383  // Set the Reynolds number
384  el_pt->pe_pt() = &Global_Physical_Variables::Pe;
385 
386  // Set the viscosity ratio functino
387  el_pt->viscosity_ratio_fct_pt() =
388  &Global_Physical_Variables::viscosity_ratio_function;
389 
390  } // End of loop over elements
391 
392  // Create a Data object whose single value stores the external pressure
393  Data* external_pressure_data_pt = new Data(1);
394 
395  // Pin and set the external pressure to some arbitrary value
396  double p_ext = Global_Physical_Variables::P_ext;
397 
398  external_pressure_data_pt->pin(0);
399  external_pressure_data_pt->set_value(0,p_ext);
400 
401  // Determine number of 1D interface elements in mesh
402  const unsigned n_interface_element = Interface_mesh_pt->nelement();
403 
404  // Loop over the interface elements
405  for(unsigned e=0;e<n_interface_element;e++)
406  {
407  // Upcast from GeneralisedElement to the present element
408  SpineAxisymmetricFluidInterfaceElement<ELEMENT>* el_pt =
409  dynamic_cast<SpineAxisymmetricFluidInterfaceElement<ELEMENT>*>
410  (Interface_mesh_pt->element_pt(e));
411 
412  // Set the Capillary number
413  el_pt->ca_pt() = &Global_Physical_Variables::Ca;
414 
415  // Pass the Data item that contains the single external pressure value
416  el_pt->set_external_pressure_data(external_pressure_data_pt);
417 
418  } // End of loop over interface elements
419 
420  // Loop over the flux elements to pass pointer to prescribed flux function
421  n_element = Surface_mesh_pt->nelement()-2; //2 elements at the nozzle
422 
423  for(unsigned e=0;e<n_element;e++)
424  {
425  // Upcast from GeneralisedElement to AdvectionDiffusion flux element
426  SteadyAxisymAdvectionDiffusionFluxElement<ELEMENT> *el_pt =
427  dynamic_cast< SteadyAxisymAdvectionDiffusionFluxElement<ELEMENT>*>(
428  Surface_mesh_pt->element_pt(e));
429  if (e<n_element) //Free surface
430  {
431  // Set the pointer to the prescribed beta function
432  el_pt->beta_fct_pt() =
433  &Global_Physical_Variables::prescribed_beta_on_fixed_r_boundary;
434  // Set the pointer to the prescribed alpha function
435  el_pt->alpha_fct_pt() =
436  &Global_Physical_Variables::prescribed_alpha_on_fixed_r_boundary;
437  }
438  }
439 
440  // Setup equation numbering scheme
441  cout <<"Number of equations: " << assign_eqn_numbers() << endl;
442 
443 } // end of constructor
e
Array< double, 1, 3 > e(1./3., 0.5, 2.)
AxisymFreeSurfaceNozzleAdvDiffRobinProblem::Interface_mesh_pt
Mesh * Interface_mesh_pt
Pointer to the mesh of interface elements.
Definition: thermal_fibre.cc:193
AxisymFreeSurfaceNozzleAdvDiffRobinProblem::Bulk_mesh_pt
HorizontalSingleLayerSpineMesh< ELEMENT > * Bulk_mesh_pt
Pointer to the "bulk" mesh.
Definition: thermal_fibre.cc:187
AxisymFreeSurfaceNozzleAdvDiffRobinProblem::Surface_mesh_pt
Mesh * Surface_mesh_pt
Pointer to the "surface" mesh of flux elements.
Definition: thermal_fibre.cc:190
AxisymFreeSurfaceNozzleAdvDiffRobinProblem::create_flux_elements
void create_flux_elements(const unsigned &b, Mesh *const &bulk_mesh_pt, Mesh *const &surface_mesh_pt)
Definition: thermal_fibre.cc:589
AxisymFreeSurfaceNozzleAdvDiffRobinProblem::Height
double Height
Height of the domain.
Definition: thermal_fibre.cc:226
AxisymFreeSurfaceNozzleAdvDiffRobinProblem::Lr
double Lr
Pointer to viscosity ratio function.
Definition: thermal_fibre.cc:223
oomph::Data
Definition: nodes.h:86
oomph::Data::pin
void pin(const unsigned &i)
Pin the i-th stored variable.
Definition: nodes.h:385
oomph::Data::set_value
void set_value(const unsigned &i, const double &value_)
Definition: nodes.h:271
oomph::FluidInterfaceElement::ca_pt
double *& ca_pt()
Pointer to the Capillary number.
Definition: interface_elements.h:492
oomph::FluidInterfaceElement::set_external_pressure_data
void set_external_pressure_data(Data *external_pressure_data_pt)
Definition: interface_elements.h:539
oomph::HorizontalSingleLayerSpineMesh
Definition: horizontal_single_layer_spine_mesh.template.h:47
oomph::Mesh
Definition: mesh.h:67
oomph::Mesh::element_pt
GeneralisedElement *& element_pt(const unsigned long &e)
Return pointer to element e.
Definition: mesh.h:448
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::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::SpineAxisymmetricFluidInterfaceElement
Definition: specific_node_update_interface_elements.h:592
oomph::SteadyAxisymAdvectionDiffusionFluxElement
Definition: steady_axisym_advection_diffusion_elements.h:609
oomph::SteadyAxisymAdvectionDiffusionFluxElement::alpha_fct_pt
SteadyAxisymAdvectionDiffusionPrescribedAlphaFctPt & alpha_fct_pt()
Access function for the prescribed-alpha function pointer.
Definition: steady_axisym_advection_diffusion_elements.h:652
oomph::SteadyAxisymAdvectionDiffusionFluxElement::beta_fct_pt
SteadyAxisymAdvectionDiffusionPrescribedBetaFctPt & beta_fct_pt()
Broken assignment operator.
Definition: steady_axisym_advection_diffusion_elements.h:646
Global_Physical_Variables::P_ext
double P_ext
External pressure.
Definition: fibre.cc:64
Global_Physical_Variables::viscosity_ratio_function
void viscosity_ratio_function(double &temperature, double &result)
Viscosity ratio function modeled following a Arrhenius fashion.
Definition: thermal_fibre.cc:102
Global_Physical_Variables::Direction_of_gravity
Vector< double > Direction_of_gravity(2)
Gravity vector.
Global_Physical_Variables::prescribed_alpha_on_fixed_r_boundary
void prescribed_alpha_on_fixed_r_boundary(const Vector< double > &x_vect, double &alpha)
Alfa on a boundary on which r is fixed.
Definition: thermal_fibre.cc:116
Global_Physical_Variables::Ca
double Ca
Capillary number.
Definition: fibre.cc:61
Global_Physical_Variables::ReInvFr
double ReInvFr
Product of Reynolds number and inverse of Froude number.
Definition: fibre.cc:58
Global_Physical_Variables::Re
double Re
Reynolds number.
Definition: fibre.cc:55
Global_Physical_Variables::prescribed_beta_on_fixed_r_boundary
void prescribed_beta_on_fixed_r_boundary(const Vector< double > &x_vector, double &beta)
Beta on a boundary on which r is fixed.
Definition: thermal_fibre.cc:109
Global_Physical_Variables::Pe
double Pe
Peclet number.
Definition: rayleigh_instability_soluble_surfactant.cc:103

References oomph::Mesh::add_element_pt(), oomph::Problem::add_sub_mesh(), oomph::SteadyAxisymAdvectionDiffusionFluxElement< ELEMENT >::alpha_fct_pt(), oomph::Problem::assign_eqn_numbers(), oomph::SteadyAxisymAdvectionDiffusionFluxElement< ELEMENT >::beta_fct_pt(), oomph::Problem::build_global_mesh(), AxisymFreeSurfaceNozzleAdvDiffRobinProblem< ELEMENT >::Bulk_mesh_pt, Global_Physical_Variables::Ca, oomph::FluidInterfaceElement::ca_pt(), AxisymFreeSurfaceNozzleAdvDiffRobinProblem< ELEMENT >::create_flux_elements(), Global_Physical_Variables::Direction_of_gravity, e(), oomph::Mesh::element_pt(), AxisymFreeSurfaceNozzleAdvDiffRobinProblem< ELEMENT >::Height, AxisymFreeSurfaceNozzleAdvDiffRobinProblem< ELEMENT >::Interface_mesh_pt, oomph::Mesh::nelement(), Global_Physical_Variables::P_ext, Global_Physical_Variables::Pe, oomph::Data::pin(), Global_Physical_Variables::prescribed_alpha_on_fixed_r_boundary(), Global_Physical_Variables::prescribed_beta_on_fixed_r_boundary(), Global_Physical_Variables::Re, Global_Physical_Variables::ReInvFr, oomph::FluidInterfaceElement::set_external_pressure_data(), oomph::Data::set_value(), AxisymFreeSurfaceNozzleAdvDiffRobinProblem< ELEMENT >::Surface_mesh_pt, and Global_Physical_Variables::viscosity_ratio_function().

◆ ~AxisymFreeSurfaceNozzleAdvDiffRobinProblem()

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

Destructor. Empty.

150 {}

Member Function Documentation

◆ actions_after_newton_solve()

template<class ELEMENT >
void AxisymFreeSurfaceNozzleAdvDiffRobinProblem< ELEMENT >::actions_after_newton_solve ( )
inlineprivatevirtual

Update the problem after solve (empty)

Reimplemented from oomph::Problem.

174 {}

◆ actions_before_newton_convergence_check()

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

Spine heights/lengths are unknowns in the problem so their values get corrected during each Newton step. However, changing their value does not automatically change the nodal positions, so we need to update all of them here.

Reimplemented from oomph::Problem.

157  {
158  Bulk_mesh_pt->node_update();
159  }

◆ actions_before_newton_solve()

template<class ELEMENT >
void AxisymFreeSurfaceNozzleAdvDiffRobinProblem< ELEMENT >::actions_before_newton_solve
privatevirtual

Update the problem specs before solve Re-set velocity boundary conditions just to be on the safe side...

Update the problem specs before solve: (Re-)set boundary conditions just to be on the safe side...

Reimplemented from oomph::Problem.

452 {
453  const double Dr = 10.0;
454  const double t_inlet = Global_Physical_Variables::T_inlet;
455 
456  // Determine number of nodes in mesh
457  const unsigned n_node = Bulk_mesh_pt->nnode();
458 
459  // Loop over all nodes in mesh
460  for(unsigned n=0;n<n_node;n++)
461  {
462  // Determine r coordinate of node
463  double r_value = Bulk_mesh_pt->node_pt(n)->x(0);
464  // Determine z coordinate of node
465  double z_value = Bulk_mesh_pt->node_pt(n)->x(1);
466 
467  // Initial guess for ur (Multiply by epsilon)
468  double ur_value = -0.5*r_value*(1.0/Height)*log(Dr)*exp(log(Dr)*(1.0-(1.1*z_value/Height)));
469  //Initial guess for uz
470  double uz_value = -exp(log(Dr)*(1.0-(1.1*z_value/Height)));
471 
472  // Set velocity component i of node n to guess
473  Bulk_mesh_pt->node_pt(n)->set_value(0,ur_value);
474  Bulk_mesh_pt->node_pt(n)->set_value(1,uz_value);
475  // Set theta velocity component of node n to zero
476  Bulk_mesh_pt->node_pt(n)->set_value(2,0.0);
477  // Set temperature of node n to one
478  Bulk_mesh_pt->node_pt(n)->set_value(3,t_inlet);
479  }
480 
481  // Correct the value in order to imposse boundary conditions
482  unsigned num_bound = Bulk_mesh_pt->nboundary();
483  for(unsigned ibound=0;ibound<num_bound;ibound++)
484  {
485  // Determine number of nodes in the bound mesh
486  const unsigned n_node = Bulk_mesh_pt->nboundary_node(ibound);
487  switch (ibound)
488  {
489  case 0:
490  for (unsigned inod=0;inod<n_node;inod++)
491  {
492  // Determine r coordinate of node
493  double r_value = Bulk_mesh_pt->boundary_node_pt(ibound,inod)->x(0);
494  double w_bound0 = -Dr*(1.0 - 0.0*pow(r_value,2.0));
495  //Set the velocities at the bottom zone
496  Bulk_mesh_pt->boundary_node_pt(ibound,inod)->set_value(0,0.0);
497  Bulk_mesh_pt->boundary_node_pt(ibound,inod)->set_value(1,w_bound0);
498  //Bulk_mesh_pt->boundary_node_pt(ibound,inod)->set_value(2,0.0);
499  //Bulk_mesh_pt->boundary_node_pt(ibound,inod)->set_value(3,t_bound0);
500  }
501  break;
502  case 1:
503  for (unsigned inod=0;inod<n_node;inod++)
504  {
505  // Determine r coordinate of node
506  double z_value = Bulk_mesh_pt->boundary_node_pt(ibound,inod)->x(1);
507  //Set the azimuthal velocity at the outer wall
508  //Bulk_mesh_pt->boundary_node_pt(ibound,inod)->set_value(2,0.0);
509  if (z_value>=(Height/1.1))
510  {
511  Bulk_mesh_pt->boundary_node_pt(ibound,inod)->set_value(0,0.0);
512  Bulk_mesh_pt->boundary_node_pt(ibound,inod)->set_value(1,0.0);
513  }
514  }
515  break;
516  case 2:
517  for (unsigned inod=0;inod<n_node;inod++)
518  {
519  // Determine r coordinate of node
520  double r_value = Bulk_mesh_pt->boundary_node_pt(ibound,inod)->x(0);
521  double w_bound2 = -2.0*(1.0 - 1.0*pow(r_value,2.0));
522  double t_bound2 = t_inlet - 0.0*pow(r_value,2.0);
523  //Set all of the magnitudes at the top zone
524  Bulk_mesh_pt->boundary_node_pt(ibound,inod)->set_value(0,0.0);
525  Bulk_mesh_pt->boundary_node_pt(ibound,inod)->set_value(1,w_bound2);
526  //Bulk_mesh_pt->boundary_node_pt(ibound,inod)->set_value(2,0.0);
527  Bulk_mesh_pt->boundary_node_pt(ibound,inod)->set_value(3,t_bound2);
528  }
529  break;
530  default: // simmetry axis
531  for (unsigned inod=0;inod<n_node;inod++)
532  {
533  //Set the radial and azimuthal velocity at the axis
534  Bulk_mesh_pt->boundary_node_pt(ibound,inod)->set_value(0,0.0);
535  //Bulk_mesh_pt->boundary_node_pt(ibound,inod)->set_value(2,0.0);
536  }
537  break;
538  }
539  }
540 }
n
const unsigned n
Definition: CG3DPackingUnitTest.cpp:11
Eigen::bfloat16_impl::exp
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 exp(const bfloat16 &a)
Definition: BFloat16.h:615
Eigen::bfloat16_impl::pow
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 pow(const bfloat16 &a, const bfloat16 &b)
Definition: BFloat16.h:625
Eigen::bfloat16_impl::log
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 log(const bfloat16 &a)
Definition: BFloat16.h:618
Global_Physical_Variables::T_inlet
double T_inlet
Inlet temperature.
Definition: thermal_fibre.cc:91

References Eigen::bfloat16_impl::exp(), GlobalParameters::Height, Eigen::bfloat16_impl::log(), n, Eigen::ArrayBase< Derived >::pow(), and Global_Physical_Variables::T_inlet.

◆ create_flux_elements()

template<class ELEMENT >
void AxisymFreeSurfaceNozzleAdvDiffRobinProblem< ELEMENT >::create_flux_elements ( const unsigned &  b,
Mesh *const &  bulk_mesh_pt,
Mesh *const &  surface_mesh_pt 
)
private

Create Axisymmetric Advection Diffusion flux elements on boundary b of the Mesh pointed to by bulk_mesh_pt and add them to the Mesh object pointed to by surface_mesh_pt

Create AdvectionDiffusion Flux Elements on the b-th boundary of the Mesh object pointed to by bulk_mesh_pt and add the elements to the Mesh object pointeed to by surface_mesh_pt.

592 {
593  // How many bulk elements are adjacent to boundary b?
594  unsigned n_element = bulk_mesh_pt->nboundary_element(b);
595 
596  // Loop over the bulk elements adjacent to boundary b?
597  for(unsigned e=0;e<n_element;e++)
598  {
599  // Get pointer to the bulk element that is adjacent to boundary b
600  ELEMENT* bulk_elem_pt = dynamic_cast<ELEMENT*>(
601  bulk_mesh_pt->boundary_element_pt(b,e));
602 
603  // Find the index of the face of element e along boundary b
604  int face_index = bulk_mesh_pt->face_index_at_boundary(b,e);
605 
606  // Build the corresponding prescribed-flux element
607  SteadyAxisymAdvectionDiffusionFluxElement<ELEMENT>* flux_element_pt = new
608  SteadyAxisymAdvectionDiffusionFluxElement<ELEMENT>(bulk_elem_pt,face_index);
609 
610  //Add the prescribed-flux element to the surface mesh
611  surface_mesh_pt->add_element_pt(flux_element_pt);
612 
613  } //end of loop over bulk elements adjacent to boundary b
614 
615 } // end of create_flux_elements
b
Scalar * b
Definition: benchVecAdd.cpp:17
oomph::Mesh::face_index_at_boundary
int face_index_at_boundary(const unsigned &b, const unsigned &e) const
Definition: mesh.h:896
oomph::Mesh::nboundary_element
unsigned nboundary_element(const unsigned &b) const
Return number of finite elements that are adjacent to boundary b.
Definition: mesh.h:878
oomph::Mesh::boundary_element_pt
FiniteElement * boundary_element_pt(const unsigned &b, const unsigned &e) const
Return pointer to e-th finite element on boundary b.
Definition: mesh.h:840

References oomph::Mesh::add_element_pt(), b, oomph::Mesh::boundary_element_pt(), e(), oomph::Mesh::face_index_at_boundary(), and oomph::Mesh::nboundary_element().

Referenced by AxisymFreeSurfaceNozzleAdvDiffRobinProblem< ELEMENT >::AxisymFreeSurfaceNozzleAdvDiffRobinProblem().

◆ deform_free_surface()

template<class ELEMENT >
void AxisymFreeSurfaceNozzleAdvDiffRobinProblem< ELEMENT >::deform_free_surface ( const double &  Dr)
inlineprivate

Deform the mesh/free surface to a prescribed function.

197  {
198  // Determine number of spines in mesh
199  const unsigned n_spine = Bulk_mesh_pt->nspine();
200 
201  // Loop over spines in mesh
202  for(unsigned i=0;i<n_spine;i++)
203  {
204  // Determine z coordinate of spine
205  double z_value = Bulk_mesh_pt->boundary_node_pt(1,i)->x(1);
206 
207  if (z_value<=(Height/1.1))
208  {
209  // Set spine height
210  Bulk_mesh_pt->spine_pt(i)->height() = sqrt( exp(-log(Dr)*(1.0 - (1.1*z_value/Height))) );
211  }
212  } // End of loop over spines
213 
214  // Update nodes in bulk mesh
215  Bulk_mesh_pt->node_update();
216 
217  } // End of deform_free_surface
sqrt
AnnoyingScalar sqrt(const AnnoyingScalar &x)
Definition: AnnoyingScalar.h:134
i
int i
Definition: BiCGSTAB_step_by_step.cpp:9

References oomph::Mesh::boundary_node_pt(), Eigen::bfloat16_impl::exp(), GlobalParameters::Height, oomph::Spine::height(), i, Eigen::bfloat16_impl::log(), oomph::SpineMesh::node_update(), oomph::SpineMesh::nspine(), oomph::SpineMesh::spine_pt(), sqrt(), and oomph::Node::x().

◆ delete_flux_elements()

template<class ELEMENT >
void AxisymFreeSurfaceNozzleAdvDiffRobinProblem< ELEMENT >::delete_flux_elements ( Mesh *const &  surface_mesh_pt)
private

Delete Axisymmetric Advection Diffusion flux elements and wipe the surface mesh.

Delete Advection Diffusion Flux Elements and wipe the surface mesh.

623 {
624  // How many surface elements are in the surface mesh
625  unsigned n_element = surface_mesh_pt->nelement();
626 
627  // Loop over the surface elements
628  for(unsigned e=0;e<n_element;e++)
629  {
630  // Kill surface element
631  delete surface_mesh_pt->element_pt(e);
632  }
633 
634  // Wipe the mesh
635  surface_mesh_pt->flush_element_and_node_storage();
636 
637 } // end of delete_flux_elements
oomph::Mesh::flush_element_and_node_storage
void flush_element_and_node_storage()
Definition: mesh.h:407

References e(), oomph::Mesh::element_pt(), oomph::Mesh::flush_element_and_node_storage(), and oomph::Mesh::nelement().

◆ doc_solution()

template<class ELEMENT >
void AxisymFreeSurfaceNozzleAdvDiffRobinProblem< ELEMENT >::doc_solution ( DocInfo &  doc_info)

Doc the solution.

549 {
550  //Declare an output stream and filename
551  ofstream some_file;
552  char filename[100];
553 
554  // Number of plot points: npts x npts
555  unsigned npts = 5;
556 
557  // Output solution
558  //-----------------
559  sprintf(filename,"%s/soln%i.dat",doc_info.directory().c_str(),
560  doc_info.number());
561  some_file.open(filename);
562 
563  //Find number of elements in mesh
564  unsigned n_element = Bulk_mesh_pt->nelement();
565 
566  // Loop over the bulk elements
567  for(unsigned e=0;e<n_element;e++)
568  {
569  // Upcast from GeneralisedElement to the present element
570  ELEMENT *el_pt = dynamic_cast<ELEMENT*>(Bulk_mesh_pt->element_pt(e));
571 
572  // Set the Reynolds number
573  el_pt->output(some_file,npts);
574  }
575 
576 
577 // Bulk_mesh_pt->output(some_file,npts);
578  some_file.close();
579 
580 } // end of doc_solution
oomph::DocInfo::directory
std::string directory() const
Output directory.
Definition: oomph_utilities.h:524
oomph::DocInfo::number
unsigned & number()
Number used (e.g.) for labeling output files.
Definition: oomph_utilities.h:554
MergeRestartFiles.filename
string filename
Definition: MergeRestartFiles.py:39

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

◆ steady_run()

template<class ELEMENT >
void AxisymFreeSurfaceNozzleAdvDiffRobinProblem< ELEMENT >::steady_run

Do steady run up to maximum time t_max with given timestep dt.

Perform run.

645 {
646  // Increase maximum residual and iteration number
647  Problem::Max_residuals=3000.0;
648  Problem::Max_newton_iterations=200;
649 
650  // Set value of Dr
651  const double Dr = 10.0;
652 
653  // Deform the mesh/free surface
654  deform_free_surface(Dr);
655 
656  // Initialise DocInfo object
657  DocInfo doc_info;
658 
659  // Set output directory
660  doc_info.set_directory("RESLT");
661 
662  // Initialise counter for solutions
663  doc_info.number()=0;
664 
665  // Doc solution
666  doc_solution(doc_info);
667 
668  // Step number
669  doc_info.number()++;
670 
671  for (unsigned i=0;i<2;i++)
672  {
673 
674  cout << "Solving for Re = "
675  << Global_Physical_Variables::Re
676  << " Ca = "
677  << Global_Physical_Variables::Ca
678  << " Pe = "
679  << Global_Physical_Variables::Pe
680  << " Bi = "
681  << Global_Physical_Variables::Bi
682  << std::endl;
683 
684  // Solve the problem
685  newton_solve();
686 
687  // Doc solution
688  doc_solution(doc_info);
689 
690  // Step number
691  doc_info.number()++;
692 
693  // Bump up parameter
694  Global_Physical_Variables::Pe+=1.0;
695  Global_Physical_Variables::eta+=5.0;
696 
697  }
698 
699 } // End of steady_run
AxisymFreeSurfaceNozzleAdvDiffRobinProblem::deform_free_surface
void deform_free_surface(const double &Dr)
Deform the mesh/free surface to a prescribed function.
Definition: thermal_fibre.cc:196
AxisymFreeSurfaceNozzleAdvDiffRobinProblem::doc_solution
void doc_solution(DocInfo &doc_info)
Doc the solution.
Definition: thermal_fibre.cc:548
oomph::DocInfo
Definition: oomph_utilities.h:499
oomph::DocInfo::set_directory
void set_directory(const std::string &directory)
Definition: oomph_utilities.cc:298
oomph::Problem::newton_solve
void newton_solve()
Use Newton method to solve the problem.
Definition: problem.cc:8783
Global_Physical_Variables::eta
double eta
Eta factor (exponent of the exponecial function)
Definition: thermal_fibre.cc:99
Global_Physical_Variables::Bi
double Bi
Biot number.
Definition: thermal_fibre.cc:85
oomph::Locate_zeta_helpers::Max_newton_iterations
unsigned Max_newton_iterations
Maximum number of newton iterations.
Definition: elements.cc:1654

References Global_Physical_Variables::Bi, Global_Physical_Variables::Ca, Global_Physical_Variables::eta, i, oomph::Locate_zeta_helpers::Max_newton_iterations, oomph::DocInfo::number(), Global_Physical_Variables::Pe, Global_Physical_Variables::Re, and oomph::DocInfo::set_directory().

Member Data Documentation

◆ Bulk_mesh_pt

template<class ELEMENT >
HorizontalSingleLayerSpineMesh<ELEMENT>* AxisymFreeSurfaceNozzleAdvDiffRobinProblem< ELEMENT >::Bulk_mesh_pt
private

Pointer to the "bulk" mesh.

Referenced by AxisymFreeSurfaceNozzleAdvDiffRobinProblem< ELEMENT >::AxisymFreeSurfaceNozzleAdvDiffRobinProblem().

◆ Height

template<class ELEMENT >
double AxisymFreeSurfaceNozzleAdvDiffRobinProblem< ELEMENT >::Height
private

Height of the domain.

Referenced by AxisymFreeSurfaceNozzleAdvDiffRobinProblem< ELEMENT >::AxisymFreeSurfaceNozzleAdvDiffRobinProblem().

◆ Interface_mesh_pt

template<class ELEMENT >
Mesh* AxisymFreeSurfaceNozzleAdvDiffRobinProblem< ELEMENT >::Interface_mesh_pt
private

Pointer to the mesh of interface elements.

Referenced by AxisymFreeSurfaceNozzleAdvDiffRobinProblem< ELEMENT >::AxisymFreeSurfaceNozzleAdvDiffRobinProblem().

◆ Lr

template<class ELEMENT >
double AxisymFreeSurfaceNozzleAdvDiffRobinProblem< ELEMENT >::Lr
private

Pointer to viscosity ratio function.

Width of domain

◆ Surface_mesh_pt

template<class ELEMENT >
Mesh* AxisymFreeSurfaceNozzleAdvDiffRobinProblem< ELEMENT >::Surface_mesh_pt
private

Pointer to the "surface" mesh of flux elements.

Referenced by AxisymFreeSurfaceNozzleAdvDiffRobinProblem< ELEMENT >::AxisymFreeSurfaceNozzleAdvDiffRobinProblem().

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