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

Public Member Functions

 OscRingNStProblem (const double &dt, FiniteElement::UnsteadyExactSolutionFctPt IC_fct_pt)
 
 ~OscRingNStProblem ()
 Destructor (empty) More...
 
GeomObject * wall_pt ()
 Get pointer to wall as geometric object. More...
 
void actions_after_newton_solve ()
 Update after solve (empty) More...
 
void actions_before_newton_solve ()
 Update the problem specs before solve (empty) More...
 
void actions_before_newton_convergence_check ()
 
void actions_after_adapt ()
 
void unsteady_run (const unsigned &ntsteps, const bool &restarted, DocInfo &doc_info)
 Run the time integration for ntsteps steps. More...
 
void set_initial_condition ()
 
void doc_solution (DocInfo &doc_info)
 Doc the solution. More...
 
AlgebraicRefineableQuarterCircleSectorMesh< ELEMENT > * fluid_mesh_pt ()
 Access function for the fluid mesh. More...
 
void dump_it (ofstream &dump_file, DocInfo doc_info)
 Dump problem data. More...
 
void restart (ifstream &restart_file)
 Read problem data. More...
 
 OscRingNStProblem (const double &dt, FiniteElement::UnsteadyExactSolutionFctPt IC_fct_pt)
 
 ~OscRingNStProblem ()
 Destructor (empty) More...
 
GeomObject * wall_pt ()
 Get pointer to wall as geometric object. More...
 
void actions_after_newton_solve ()
 Update after solve (empty) More...
 
void actions_before_newton_solve ()
 Update the problem specs before solve (empty) More...
 
void actions_before_newton_convergence_check ()
 
void actions_after_adapt ()
 
void unsteady_run (const unsigned &ntsteps, const bool &restarted, DocInfo &doc_info)
 Run the time integration for ntsteps steps. More...
 
void set_initial_condition ()
 
void doc_solution (DocInfo &doc_info)
 Doc the solution. More...
 
MacroElementNodeUpdateRefineableQuarterCircleSectorMesh< ELEMENT > * fluid_mesh_pt ()
 Access function for the fluid mesh. More...
 
void dump_it (ofstream &dump_file, DocInfo doc_info)
 Dump problem data. More...
 
void restart (ifstream &restart_file)
 Read problem data. More...
 
 OscRingNStProblem (const double &dt, FiniteElement::UnsteadyExactSolutionFctPt IC_fct_pt)
 
 ~OscRingNStProblem ()
 Destructor (empty) More...
 
GeomObject * wall_pt ()
 Get pointer to wall as geometric object. More...
 
void actions_after_newton_solve ()
 Update after solve (empty) More...
 
void actions_before_newton_solve ()
 Update the problem specs before solve (empty) More...
 
void actions_before_newton_convergence_check ()
 Update the fluid mesh and re-set velocity boundary conditions. More...
 
void finish_problem_setup ()
 
void actions_after_adapt ()
 Actions after adapt. More...
 
void unsteady_run (const unsigned &ntsteps, const bool &restarted, DocInfo &doc_info)
 Run the time integration for ntsteps steps. More...
 
void set_initial_condition ()
 
void doc_solution (DocInfo &doc_info)
 Doc the solution. More...
 
void doc_solution_historic (DocInfo &doc_info)
 
AlgebraicRefineableQuarterCircleSectorMesh< ELEMENT > * fluid_mesh_pt ()
 Access function for the fluid mesh. More...
 
void dump_it (ofstream &dump_file, DocInfo doc_info)
 Dump generic problem data. More...
 
void restart (ifstream &restart_file)
 Read generic problem data. More...
 
 OscRingNStProblem (const double &dt, FiniteElement::UnsteadyExactSolutionFctPt IC_fct_pt)
 
 ~OscRingNStProblem ()
 Destructor (empty) More...
 
GeomObject * wall_pt ()
 Get pointer to wall as geometric object. More...
 
void actions_after_newton_solve ()
 Update after solve (empty) More...
 
void actions_before_newton_solve ()
 Update before solve (empty) More...
 
void actions_before_implicit_timestep ()
 
void unsteady_run (const unsigned &ntsteps, const bool &restarted, DocInfo &doc_info)
 Run the time integration for ntsteps steps. More...
 
void set_initial_condition ()
 
void doc_solution (DocInfo &doc_info)
 Doc the solution. More...
 
RefineableQuarterCircleSectorMesh< ELEMENT > * mesh_pt ()
 Access function for the fluid mesh. More...
 
void dump_it (ofstream &dump_file)
 Dump generic problem data. More...
 
void restart (ifstream &restart_file)
 Read generic problem data. 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 ()
 
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 write_trace_file_header ()
 Write header for trace file. More...
 
void write_trace_file_header ()
 Write header for trace file. More...
 
void write_trace_file_header ()
 Write header for trace file. More...
 
void write_trace_file_header_historic ()
 
void write_trace_file_header ()
 Write header for trace file. More...
 

Private Attributes

FiniteElement::UnsteadyExactSolutionFctPt IC_Fct_pt
 Function pointer to set the intial condition. More...
 
GeomObject * Wall_pt
 Pointer to wall. More...
 
AlgebraicRefineableQuarterCircleSectorMesh< ELEMENT > * Fluid_mesh_pt
 Pointer to fluid mesh. More...
 
Mesh * Wall_mesh_pt
 Pointer to wall mesh (contains only a single GeneralisedElement) More...
 
ofstream Trace_file
 Trace file. More...
 
Node * Veloc_trace_node_pt
 Pointer to node on coarsest mesh on which velocity is traced. More...
 
Node * Sarah_veloc_trace_node_pt
 
MacroElementNodeUpdateRefineableQuarterCircleSectorMesh< ELEMENT > * Fluid_mesh_pt
 Pointer to fluid mesh. More...
 

Additional Inherited Members

- Public Types inherited from oomph::Problem
typedef void(* SpatialErrorEstimatorFctPt) (Mesh *&mesh_pt, Vector< double > &elemental_error)
 Function pointer for spatial error estimator. More...
 
typedef void(* SpatialErrorEstimatorWithDocFctPt) (Mesh *&mesh_pt, Vector< double > &elemental_error, DocInfo &doc_info)
 Function pointer for spatial error estimator with doc. More...
 
- 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_after_implicit_timestep ()
 
virtual void actions_after_implicit_timestep_and_error_estimation ()
 
virtual void actions_before_explicit_timestep ()
 Actions that should be performed before each explicit time step. More...
 
virtual void actions_after_explicit_timestep ()
 Actions that should be performed after each explicit time step. More...
 
virtual void actions_before_read_unstructured_meshes ()
 
virtual void actions_after_read_unstructured_meshes ()
 
virtual void actions_after_change_in_global_parameter (double *const &parameter_pt)
 
virtual void actions_after_change_in_bifurcation_parameter ()
 
virtual void actions_after_parameter_increase (double *const &parameter_pt)
 
double & dof_derivative (const unsigned &i)
 
double & dof_current (const unsigned &i)
 
virtual double global_temporal_error_norm ()
 
unsigned newton_solve_continuation (double *const &parameter_pt)
 
unsigned newton_solve_continuation (double *const &parameter_pt, DoubleVector &z)
 
void calculate_continuation_derivatives (double *const &parameter_pt)
 
void calculate_continuation_derivatives (const DoubleVector &z)
 
void calculate_continuation_derivatives_fd (double *const &parameter_pt)
 
bool does_pointer_correspond_to_problem_data (double *const &parameter_pt)
 
void set_consistent_pinned_values_for_continuation ()
 
- Protected Attributes inherited from 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 OscRingNStProblem< ELEMENT >

///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// Driver for oscillating ring problem: Wall performs oscillations that resemble eigenmodes of freely oscillating ring and drives viscous fluid flow. Mean radius of wall is adjustable and responds to a pressure value in the fluid to allow for mass conservation.

///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// Driver for oscillating ring problem: Wall performs oscillations that resemble eigenmodes of freely oscillating ring and drives viscous fluid flow.

///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// Driver for oscillating ring problem: Wall performs oscillations that resemble eigenmodes of freely oscillating ring and drives viscous fluid flow – we allow for outflow through the "left" symmetry plane to accomodate mass conservation...

Constructor & Destructor Documentation

◆ OscRingNStProblem() [1/4]

template<class ELEMENT , class TIMESTEPPER >
OscRingNStProblem< ELEMENT, TIMESTEPPER >::OscRingNStProblem ( const double &  dt,
FiniteElement::UnsteadyExactSolutionFctPt  IC_fct_pt 
)

Constructor: Pass timestep and function pointer to the solution that provides the initial conditions for the fluid

Constructor: Pass (constant) timestep and function pointer to the solution that provides the initial conditions for the fluid.

Pass initial time, initial timestep and function pointer to the solution that provides the initial conditions for the fluid.

210  : IC_Fct_pt(IC_fct_pt)
211 {
212 
213  // Period of oscillation
214  double T=1.0;
215 
216  //Allocate the timestepper
217  add_time_stepper_pt(new BDF<4>);
218 
219  // Initialise timestep -- also sets the weights for all timesteppers
220  // in the problem.
221  initialise_dt(dt);
222 
223  // Parameters for pseudo-buckling ring
224  double eps_buckl=0.1; // ADJUST_PRIORITY
225  double ampl_ratio=-0.5; // ADJUST_PRIORITY
226  unsigned n_buckl=2; // ADJUST_PRIORITY
227  double r_0=1.0;
228 
229  // Build wall geometric element
230  Wall_pt=new PseudoBucklingRingElement(eps_buckl,ampl_ratio,n_buckl,r_0,T,
231  time_stepper_pt());
232 
233  // Fluid mesh is suspended from wall between these two Lagrangian
234  // coordinates:
235  double xi_lo=0.0;
236  double xi_hi=2.0*atan(1.0);
237 
238  // Fractional position of dividing line for two outer blocks in fluid mesh
239  double fract_mid=0.5;
240 
241  // Build fluid mesh
242  Fluid_mesh_pt=new AlgebraicRefineableQuarterCircleSectorMesh<ELEMENT>(
243  Wall_pt,xi_lo,fract_mid,xi_hi,time_stepper_pt());
244 
245  // Set error estimator
246  Z2ErrorEstimator* error_estimator_pt=new Z2ErrorEstimator;
247  Fluid_mesh_pt->spatial_error_estimator_pt()=error_estimator_pt;
248 
249  // Fluid mesh is first sub-mesh
250  add_sub_mesh(Fluid_mesh_pt);
251 
252  // Build wall mesh
253  Wall_mesh_pt=new Mesh;
254 
255  // Wall mesh is completely empty: Add Wall element in its GeneralisedElement
256  // incarnation
257  Wall_mesh_pt->add_element_pt(dynamic_cast<GeneralisedElement*>(Wall_pt));
258 
259  // Wall mesh is second sub-mesh
260  add_sub_mesh(Wall_mesh_pt);
261 
262  // Combine all submeshes into a single Mesh
263  build_global_mesh();
264 
265  // Extract pointer to node at center of mesh (this node exists
266  // at all refinement levels and can be used to doc continuous timetrace
267  // of velocities)
268  unsigned nnode=fluid_mesh_pt()->finite_element_pt(0)->nnode();
269  Veloc_trace_node_pt=fluid_mesh_pt()->finite_element_pt(0)->node_pt(nnode-1);
270 
271  // Extract pointer to node in symmetry plane (this node exists
272  // at all refinement levels and can be used to doc continuous timetrace
273  // of velocities)
274  unsigned nnode_1d=dynamic_cast<ELEMENT*>(
275  fluid_mesh_pt()->finite_element_pt(0))->nnode_1d();
276  Sarah_veloc_trace_node_pt=fluid_mesh_pt()->
277  finite_element_pt(0)->node_pt(nnode_1d-1);
278 
279  // The "pseudo-elastic" wall element is "loaded" by a pressure.
280  // Use the "constant" pressure component in Crouzeix Raviart
281  // fluid element as that pressure.
282  dynamic_cast<PseudoBucklingRingElement*>(Wall_pt)
283  ->set_reference_pressure_pt(fluid_mesh_pt()
284  ->element_pt(0)->internal_data_pt(0));
285 
286 
287  // Set the boundary conditions for this problem:
288  //----------------------------------------------
289 
290  // All nodes are free by default -- just pin the ones that have
291  // Dirichlet conditions here.
292 
293  // Bottom boundary:
294  unsigned ibound=0;
295  {
296  unsigned num_nod= fluid_mesh_pt()->nboundary_node(ibound);
297  for (unsigned inod=0;inod<num_nod;inod++)
298  {
299  // Pin vertical velocity
300  {
301  fluid_mesh_pt()->boundary_node_pt(ibound,inod)->pin(1);
302  }
303  }
304  }
305 
306  // Ring boundary: No slip; this also implies that the velocity needs
307  // to be updated in response to wall motion
308  ibound=1;
309  {
310  unsigned num_nod=fluid_mesh_pt()->nboundary_node(ibound);
311  for (unsigned inod=0;inod<num_nod;inod++)
312  {
313  // Which node are we dealing with?
314  Node* node_pt=fluid_mesh_pt()->boundary_node_pt(ibound,inod);
315 
316  // Set auxiliary update function pointer to apply no-slip condition
317  // to velocities whenever nodal position is updated
318  node_pt->set_auxiliary_node_update_fct_pt(
319  FSI_functions::apply_no_slip_on_moving_wall);
320 
321  // Pin both velocities
322  for (unsigned i=0;i<2;i++)
323  {
324  node_pt->pin(i);
325  }
326  }
327  }
328 
329  // Left boundary:
330  ibound=2;
331  {
332  unsigned num_nod=fluid_mesh_pt()->nboundary_node(ibound);
333  for (unsigned inod=0;inod<num_nod;inod++)
334  {
335  // Pin horizontal velocity
336  {
337  fluid_mesh_pt()->boundary_node_pt(ibound,inod)->pin(0);
338  }
339  }
340  }
341 
342 
343  // Complete the build of all elements so they are fully functional
344  //----------------------------------------------------------------
345 
346  //Find number of elements in mesh
347  unsigned n_element = fluid_mesh_pt()->nelement();
348 
349  // Loop over the elements to set up element-specific
350  // things that cannot be handled by constructor
351  for(unsigned i=0;i<n_element;i++)
352  {
353  // Upcast from FiniteElement to the present element
354  ELEMENT *el_pt = dynamic_cast<ELEMENT*>(fluid_mesh_pt()->element_pt(i));
355 
356  //Set the Reynolds number, etc
357  el_pt->re_pt() = &Global_Physical_Variables::Re;
358  el_pt->re_st_pt() = &Global_Physical_Variables::ReSt;
359  }
360 
361 
362  //Attach the boundary conditions to the mesh
363  cout <<"Number of equations: " << assign_eqn_numbers() << std::endl;
364 
365 
366  // Set parameters for Sarah's asymptotic solution
367  //-----------------------------------------------
368 
369  // Amplitude of the oscillation
370  SarahBL::epsilon=static_cast<PseudoBucklingRingElement*>(Wall_pt)->
371  eps_buckl();
372 
373  // Womersley number is the same as square root of Reynolds number
374  SarahBL::alpha=sqrt(Global_Physical_Variables::Re);
375 
376  // Amplitude ratio
377  SarahBL::A=static_cast<PseudoBucklingRingElement*>(Wall_pt)->ampl_ratio();
378 
379  // Buckling wavenumber
380  SarahBL::N=static_cast<PseudoBucklingRingElement*>(Wall_pt)->n_buckl_float();
381 
382  // Frequency of oscillation (period is one)
383  SarahBL::Omega=2.0*MathematicalConstants::Pi;
384 
385 }
sqrt
AnnoyingScalar sqrt(const AnnoyingScalar &x)
Definition: AnnoyingScalar.h:134
i
int i
Definition: BiCGSTAB_step_by_step.cpp:9
OscRingNStProblem::Wall_pt
GeomObject * Wall_pt
Pointer to wall.
Definition: interaction/fsi_osc_ring/osc_ring_alg.cc:183
OscRingNStProblem::Fluid_mesh_pt
AlgebraicRefineableQuarterCircleSectorMesh< ELEMENT > * Fluid_mesh_pt
Pointer to fluid mesh.
Definition: interaction/fsi_osc_ring/osc_ring_alg.cc:186
OscRingNStProblem::Sarah_veloc_trace_node_pt
Node * Sarah_veloc_trace_node_pt
Definition: interaction/fsi_osc_ring/osc_ring_alg.cc:199
OscRingNStProblem::Wall_mesh_pt
Mesh * Wall_mesh_pt
Pointer to wall mesh (contains only a single GeneralisedElement)
Definition: interaction/fsi_osc_ring/osc_ring_alg.cc:189
OscRingNStProblem::IC_Fct_pt
FiniteElement::UnsteadyExactSolutionFctPt IC_Fct_pt
Function pointer to set the intial condition.
Definition: interaction/fsi_osc_ring/osc_ring_alg.cc:180
OscRingNStProblem::fluid_mesh_pt
AlgebraicRefineableQuarterCircleSectorMesh< ELEMENT > * fluid_mesh_pt()
Access function for the fluid mesh.
Definition: interaction/fsi_osc_ring/osc_ring_alg.cc:163
OscRingNStProblem::Veloc_trace_node_pt
Node * Veloc_trace_node_pt
Pointer to node on coarsest mesh on which velocity is traced.
Definition: interaction/fsi_osc_ring/osc_ring_alg.cc:195
oomph::AlgebraicRefineableQuarterCircleSectorMesh
Definition: quarter_circle_sector_mesh.template.h:442
oomph::BDF
Definition: timesteppers.h:1165
oomph::Data::pin
void pin(const unsigned &i)
Pin the i-th stored variable.
Definition: nodes.h:385
oomph::GeneralisedElement
Definition: elements.h:73
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::Node
Definition: nodes.h:906
oomph::Node::set_auxiliary_node_update_fct_pt
void set_auxiliary_node_update_fct_pt(AuxNodeUpdateFctPt aux_node_update_fct_pt)
Definition: nodes.h:1596
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::initialise_dt
void initialise_dt(const double &dt)
Definition: problem.cc:13231
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
oomph::PseudoBucklingRingElement
Definition: pseudo_buckling_ring.h:584
oomph::Z2ErrorEstimator
Definition: error_estimator.h:266
BiharmonicTestFunctions2::Pi
double Pi
Definition: two_d_biharmonic.cc:235
Eigen::bfloat16_impl::atan
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 atan(const bfloat16 &a)
Definition: BFloat16.h:636
Global_Physical_Variables::ReSt
double ReSt
Womersley number.
Definition: rayleigh_instability.cc:56
Global_Physical_Variables::Re
double Re
Reynolds number.
Definition: fibre.cc:55
MeshRefinement::error_estimator_pt
Z2ErrorEstimator * error_estimator_pt
Definition: MortaringCantileverCompareToNonMortaring.cpp:190
SarahBL::N
double N
Definition: navier_stokes/osc_ring/osc_ring_alg.cc:74
SarahBL::A
double A
Definition: navier_stokes/osc_ring/osc_ring_alg.cc:74
SarahBL::alpha
double alpha
Definition: navier_stokes/osc_ring/osc_ring_alg.cc:74
SarahBL::Omega
double Omega
Definition: navier_stokes/osc_ring/osc_ring_alg.cc:74
SarahBL::epsilon
double epsilon
Definition: navier_stokes/osc_ring/osc_ring_alg.cc:74
oomph::FSI_functions::apply_no_slip_on_moving_wall
void apply_no_slip_on_moving_wall(Node *node_pt)
Definition: fsi.cc:48

References SarahBL::A, oomph::Mesh::add_element_pt(), oomph::Problem::add_sub_mesh(), oomph::Problem::add_time_stepper_pt(), SarahBL::alpha, oomph::FSI_functions::apply_no_slip_on_moving_wall(), oomph::Problem::assign_eqn_numbers(), Eigen::bfloat16_impl::atan(), oomph::Problem::build_global_mesh(), SarahBL::epsilon, MeshRefinement::error_estimator_pt, OscRingNStProblem< ELEMENT >::fluid_mesh_pt(), OscRingNStProblem< ELEMENT >::Fluid_mesh_pt, i, oomph::Problem::initialise_dt(), SarahBL::N, SarahBL::Omega, BiharmonicTestFunctions2::Pi, oomph::Data::pin(), Global_Physical_Variables::Re, Global_Physical_Variables::ReSt, OscRingNStProblem< ELEMENT >::Sarah_veloc_trace_node_pt, oomph::Node::set_auxiliary_node_update_fct_pt(), sqrt(), oomph::Problem::time_stepper_pt(), OscRingNStProblem< ELEMENT >::Veloc_trace_node_pt, OscRingNStProblem< ELEMENT >::Wall_mesh_pt, and OscRingNStProblem< ELEMENT >::Wall_pt.

◆ ~OscRingNStProblem() [1/4]

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

Destructor (empty)

96 {}

◆ OscRingNStProblem() [2/4]

template<class ELEMENT >
OscRingNStProblem< ELEMENT >::OscRingNStProblem ( const double &  dt,
FiniteElement::UnsteadyExactSolutionFctPt  IC_fct_pt 
)

Constructor: Pass timestep and function pointer to the solution that provides the initial conditions for the fluid

◆ ~OscRingNStProblem() [2/4]

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

Destructor (empty)

95 {}

◆ OscRingNStProblem() [3/4]

template<class ELEMENT >
OscRingNStProblem< ELEMENT >::OscRingNStProblem ( const double &  dt,
FiniteElement::UnsteadyExactSolutionFctPt  IC_fct_pt 
)

Constructor: Pass timestep and function pointer to the solution that provides the initial conditions for the fluid

◆ ~OscRingNStProblem() [3/4]

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

Destructor (empty)

645 {}

◆ OscRingNStProblem() [4/4]

template<class ELEMENT >
OscRingNStProblem< ELEMENT >::OscRingNStProblem ( const double &  dt,
FiniteElement::UnsteadyExactSolutionFctPt  IC_fct_pt 
)

Constructor: Pass timestep and function pointer to the solution that provides the initial conditions for the fluid

◆ ~OscRingNStProblem() [4/4]

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

Destructor (empty)

622 {}

Member Function Documentation

◆ actions_after_adapt() [1/3]

template<class ELEMENT >
void OscRingNStProblem< ELEMENT >::actions_after_adapt ( )
inlinevirtual

Update the problem specs after adaptation: Set auxiliary update function that applies no slip on all boundary nodes and choose fluid pressure dof that drives the wall deformation

Reimplemented from oomph::Problem.

127  {
128  // Ring boundary: No slip; this also implies that the velocity needs
129  // to be updated in response to wall motion. This needs to be reset
130  // every time the mesh is changed -- there's no mechanism by which
131  // auxiliary update functions are copied to newly created nodes.
132  // (that's because unlike boundary conditions, they don't
133  // occur exclusively at boundaries)
134  unsigned ibound=1;
135  {
136  unsigned num_nod= fluid_mesh_pt()->nboundary_node(ibound);
137  for (unsigned inod=0;inod<num_nod;inod++)
138  {
139  fluid_mesh_pt()->boundary_node_pt(ibound,inod)->
140  set_auxiliary_node_update_fct_pt(
141  FSI_functions::apply_no_slip_on_moving_wall);
142  }
143  }
144 
145  // Set the reference pressure as the constant pressure in element 0
146  dynamic_cast<PseudoBucklingRingElement*>(Wall_pt)
147  ->set_reference_pressure_pt(fluid_mesh_pt()->element_pt(0)
148  ->internal_data_pt(0));
149  }

References oomph::FSI_functions::apply_no_slip_on_moving_wall().

◆ actions_after_adapt() [2/3]

template<class ELEMENT >
void OscRingNStProblem< ELEMENT >::actions_after_adapt ( )
inlinevirtual

Update the problem specs after adaptation: Set auxiliary update function that applies no slip on all boundary nodes and choose fluid pressure dof that drives the wall deformation

Reimplemented from oomph::Problem.

126  {
127  // Ring boundary: No slip; this also implies that the velocity needs
128  // to be updated in response to wall motion. This needs to be reset
129  // every time the mesh is changed -- there's no mechanism by which
130  // auxiliary update functions are copied to newly created nodes.
131  // (that's because unlike boundary conditions, they don't
132  // occur exclusively at boundaries)
133  unsigned ibound=1;
134  {
135  unsigned num_nod= fluid_mesh_pt()->nboundary_node(ibound);
136  for (unsigned inod=0;inod<num_nod;inod++)
137  {
138  fluid_mesh_pt()->boundary_node_pt(ibound,inod)->
139  set_auxiliary_node_update_fct_pt(
140  FSI_functions::apply_no_slip_on_moving_wall);
141  }
142  }
143 
144  // Set the reference pressure as the constant pressure in element 0
145  dynamic_cast<PseudoBucklingRingElement*>(Wall_pt)
146  ->set_reference_pressure_pt(fluid_mesh_pt()->element_pt(0)
147  ->internal_data_pt(0));
148  }

References oomph::FSI_functions::apply_no_slip_on_moving_wall().

◆ actions_after_adapt() [3/3]

template<class ELEMENT >
void OscRingNStProblem< ELEMENT >::actions_after_adapt ( )
inlinevirtual

Actions after adapt.

Reimplemented from oomph::Problem.

673  {
674  finish_problem_setup();
675  }
OscRingNStProblem::finish_problem_setup
void finish_problem_setup()
Definition: navier_stokes/osc_ring/osc_ring_alg.cc:916

◆ actions_after_newton_solve() [1/4]

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

Update after solve (empty)

Reimplemented from oomph::Problem.

105 {}

◆ actions_after_newton_solve() [2/4]

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

Update after solve (empty)

Reimplemented from oomph::Problem.

104 {}

◆ actions_after_newton_solve() [3/4]

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

Update after solve (empty)

Reimplemented from oomph::Problem.

654 {}

◆ actions_after_newton_solve() [4/4]

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

Update after solve (empty)

Reimplemented from oomph::Problem.

631 {}

◆ actions_before_implicit_timestep()

template<class ELEMENT >
void OscRingNStProblem< ELEMENT >::actions_before_implicit_timestep ( )
inlinevirtual

Update the problem specs before next timestep: Update the fluid mesh and re-set velocity boundary conditions.

Reimplemented from oomph::Problem.

640  {
641  // Update the fluid mesh -- auxiliary update function for algebraic
642  // nodes automatically updates no slip condition.
643  mesh_pt()->node_update();
644 
645  // Ring boundary: No slip; this also implies that the velocity needs
646  // to be updated in response to wall motion
647  unsigned ibound=1;
648  {
649  unsigned num_nod=mesh_pt()->nboundary_node(ibound);
650  for (unsigned inod=0;inod<num_nod;inod++)
651  {
652  // Which node are we dealing with?
653  Node* node_pt=mesh_pt()->boundary_node_pt(ibound,inod);
654 
655  // Apply no slip
656  FSI_functions::apply_no_slip_on_moving_wall(node_pt);
657  }
658  }
659  }
OscRingNStProblem::mesh_pt
RefineableQuarterCircleSectorMesh< ELEMENT > * mesh_pt()
Access function for the fluid mesh.
Definition: navier_stokes/osc_ring/osc_ring_macro.cc:673

References oomph::FSI_functions::apply_no_slip_on_moving_wall().

◆ actions_before_newton_convergence_check() [1/3]

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

Update the problem specs before checking Newton convergence: Update the fluid mesh and re-set velocity boundary conditions – no slip velocity on the wall means that the velocity on the wall is dependent.

Reimplemented from oomph::Problem.

115  {
116  // Update the fluid mesh -- auxiliary update function for algebraic
117  // nodes automatically updates no slip condition.
118  fluid_mesh_pt()->node_update();
119  }

◆ actions_before_newton_convergence_check() [2/3]

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

Update the problem specs before checking Newton convergence: Update the fluid mesh and re-set velocity boundary conditions – no slip velocity on the wall means that the velocity on the wall is dependent.

Reimplemented from oomph::Problem.

114  {
115  // Update the fluid mesh -- auxiliary update function for algebraic
116  // nodes automatically updates no slip condition.
117  fluid_mesh_pt()->node_update();
118  }

◆ actions_before_newton_convergence_check() [3/3]

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

Update the fluid mesh and re-set velocity boundary conditions.

Reimplemented from oomph::Problem.

661  {
662  // Update the fluid mesh -- auxiliary update function for algebraic
663  // nodes automatically updates no slip condition.
664  fluid_mesh_pt()->node_update();
665  }

◆ actions_before_newton_solve() [1/4]

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

Update the problem specs before solve (empty)

Reimplemented from oomph::Problem.

108 {}

◆ actions_before_newton_solve() [2/4]

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

Update the problem specs before solve (empty)

Reimplemented from oomph::Problem.

107 {}

◆ actions_before_newton_solve() [3/4]

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

Update the problem specs before solve (empty)

Reimplemented from oomph::Problem.

657 {}

◆ actions_before_newton_solve() [4/4]

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

Update before solve (empty)

Reimplemented from oomph::Problem.

634 {}

◆ doc_solution() [1/4]

template<class ELEMENT , class TIMESTEPPER >
void OscRingNStProblem< ELEMENT, TIMESTEPPER >::doc_solution ( DocInfo &  doc_info)

Doc the solution.

Doc the solution

487 {
488 
489  cout << "Doc-ing step " << doc_info.number()
490  << " for time " << time_stepper_pt()->time_pt()->time() << std::endl;
491 
492  ofstream some_file;
493  char filename[100];
494 
495  // Number of plot points
496  unsigned npts;
497  npts=5;
498 
499 
500  // Output solution on fluid mesh
501  //-------------------------------
502  sprintf(filename,"%s/soln%i.dat",doc_info.directory().c_str(),
503  doc_info.number());
504  //some_file.precision(20);
505  some_file.open(filename);
506  unsigned nelem=fluid_mesh_pt()->nelement();
507  for (unsigned ielem=0;ielem<nelem;ielem++)
508  {
509  dynamic_cast<ELEMENT*>(fluid_mesh_pt()->element_pt(ielem))->
510  full_output(some_file,npts);
511  }
512  some_file.close();
513 
514 
515  // Plot wall posn
516  //---------------
517  sprintf(filename,"%s/Wall%i.dat",doc_info.directory().c_str(),
518  doc_info.number());
519  some_file.open(filename);
520 
521  unsigned nplot=100;
522  Vector<double > xi_wall(1);
523  Vector<double > r_wall(2);
524  for (unsigned iplot=0;iplot<nplot;iplot++)
525  {
526  xi_wall[0]=0.5*Pi*double(iplot)/double(nplot-1);
527  Wall_pt->position(xi_wall,r_wall);
528  some_file << r_wall[0] << " " << r_wall[1] << std::endl;
529  }
530  some_file.close();
531 
532 
533  // Doc Sarah's asymptotic solution
534  //--------------------------------
535  sprintf(filename,"%s/exact_soln%i.dat",doc_info.directory().c_str(),
536  doc_info.number());
537  some_file.open(filename);
538  fluid_mesh_pt()->output_fct(some_file,npts,
539  time_stepper_pt()->time_pt()->time(),
540  SarahBL::full_exact_soln);
541  some_file.close();
542 
543 
544 
545 
546  // Get position of control point
547  //------------------------------
548  Vector<double> r(2);
549  Vector<double> xi(1);
550  xi[0]=MathematicalConstants::Pi/2.0;
551  wall_pt()->position(xi,r);
552 
553 
554 
555  // Get total volume (area) of computational domain, energies and average
556  //----------------------------------------------------------------------
557  // pressure
558  //---------
559  double area=0.0;
560  double press_int=0.0;
561  double diss=0.0;
562  double kin_en=0.0;
563  nelem=fluid_mesh_pt()->nelement();
564 
565  for (unsigned ielem=0;ielem<nelem;ielem++)
566  {
567  area+=fluid_mesh_pt()->finite_element_pt(ielem)->size();
568  press_int+=dynamic_cast<ELEMENT*>(fluid_mesh_pt()->element_pt(ielem))
569  ->pressure_integral();
570  diss+=dynamic_cast<ELEMENT*>(fluid_mesh_pt()->element_pt(ielem))->
571  dissipation();
572  kin_en+=dynamic_cast<ELEMENT*>(fluid_mesh_pt()->element_pt(ielem))->
573  kin_energy();
574  }
575 
576  // Total kinetic energy in entire domain
577  double global_kin=4.0*kin_en;
578 
579  // Max/min refinement level
580  unsigned min_level;
581  unsigned max_level;
582  fluid_mesh_pt()->get_refinement_levels(min_level,max_level);
583 
584 
585  // Total dissipation for quarter domain
586  double time=time_pt()->time();
587  double diss_asympt=SarahBL::Total_Diss_sarah(time)/4.0;
588 
589  // Asymptotic predictions for velocities at control point
590  Vector<double> x_sarah(2);
591  Vector<double> soln_sarah(3);
592  x_sarah[0]=Sarah_veloc_trace_node_pt->x(0);
593  x_sarah[1]=Sarah_veloc_trace_node_pt->x(1);
594  SarahBL::exact_soln(time,x_sarah,soln_sarah);
595 
596  // Doc
597  Trace_file << time_pt()->time()
598  << " " << r[1]
599  << " " << global_kin
600  << " " << SarahBL::Kin_energy_sarah(time_pt()->time())
601  << " " << static_cast<PseudoBucklingRingElement*>(Wall_pt)->r_0()
602  << " " << area
603  << " " << press_int/area
604  << " " << diss
605  << " " << diss_asympt
606  << " " << Veloc_trace_node_pt->x(0)
607  << " " << Veloc_trace_node_pt->x(1)
608  << " " << Veloc_trace_node_pt->value(0)
609  << " " << Veloc_trace_node_pt->value(1)
610  << " " << fluid_mesh_pt()->nelement()
611  << " " << ndof()
612  << " " << min_level
613  << " " << max_level
614  << " " << fluid_mesh_pt()->nrefinement_overruled()
615  << " " << fluid_mesh_pt()->max_error()
616  << " " << fluid_mesh_pt()->min_error()
617  << " " << fluid_mesh_pt()->max_permitted_error()
618  << " " << fluid_mesh_pt()->min_permitted_error()
619  << " " << fluid_mesh_pt()->max_keep_unrefined()
620  << " " << doc_info.number()
621  << " " << Sarah_veloc_trace_node_pt->x(0)
622  << " " << Sarah_veloc_trace_node_pt->x(1)
623  << " " << Sarah_veloc_trace_node_pt->value(0)
624  << " " << Sarah_veloc_trace_node_pt->value(1)
625  << " " << x_sarah[0]
626  << " " << x_sarah[1]
627  << " " << soln_sarah[0]
628  << " " << soln_sarah[1]
629  << " "
630  << static_cast<PseudoBucklingRingElement*>(Wall_pt)->r_0()-1.0
631  << std::endl;
632 
633 
634  // Output fluid solution on coarse-ish mesh
635  //-----------------------------------------
636 
637  // Extract all elements from quadtree representation
638  Vector<Tree*> all_element_pt;
639  fluid_mesh_pt()->forest_pt()->
640  stick_all_tree_nodes_into_vector(all_element_pt);
641 
642  // Build a coarse mesh
643  Mesh* coarse_mesh_pt = new Mesh();
644 
645  //Loop over all elements and check if their refinement level is
646  //equal to the mesh's minimum refinement level
647  nelem=all_element_pt.size();
648  for (unsigned ielem=0;ielem<nelem;ielem++)
649  {
650  Tree* el_pt=all_element_pt[ielem];
651  if (el_pt->level()==min_level)
652  {
653  coarse_mesh_pt->add_element_pt(el_pt->object_pt());
654  }
655  }
656 
657  // Output fluid solution on coarse mesh
658  sprintf(filename,"%s/coarse_soln%i.dat",doc_info.directory().c_str(),
659  doc_info.number());
660  some_file.open(filename);
661  nelem=coarse_mesh_pt->nelement();
662  for (unsigned ielem=0;ielem<nelem;ielem++)
663  {
664  dynamic_cast<ELEMENT*>(coarse_mesh_pt->element_pt(ielem))->
665  full_output(some_file,npts);
666  }
667  some_file.close();
668 
669  // Write restart file
670  sprintf(filename,"%s/restart%i.dat",doc_info.directory().c_str(),
671  doc_info.number());
672  some_file.open(filename);
673  dump_it(some_file,doc_info);
674  some_file.close();
675 
676 }
OscRingNStProblem::Trace_file
ofstream Trace_file
Trace file.
Definition: interaction/fsi_osc_ring/osc_ring_alg.cc:192
OscRingNStProblem::wall_pt
GeomObject * wall_pt()
Get pointer to wall as geometric object.
Definition: interaction/fsi_osc_ring/osc_ring_alg.cc:99
OscRingNStProblem::dump_it
void dump_it(ofstream &dump_file, DocInfo doc_info)
Dump problem data.
Definition: interaction/fsi_osc_ring/osc_ring_alg.cc:687
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::GeomObject::position
virtual void position(const Vector< double > &zeta, Vector< double > &r) const =0
Parametrised position on object at current time: r(zeta).
oomph::Mesh::element_pt
GeneralisedElement *& element_pt(const unsigned long &e)
Return pointer to element e.
Definition: mesh.h:448
oomph::Mesh::nelement
unsigned long nelement() const
Return number of elements in the mesh.
Definition: mesh.h:590
oomph::Node::x
double & x(const unsigned &i)
Return the i-th nodal coordinate.
Definition: nodes.h:1060
oomph::Node::value
double value(const unsigned &i) const
Definition: nodes.cc:2408
oomph::Problem::ndof
unsigned long ndof() const
Return the number of dofs.
Definition: problem.h:1674
oomph::Problem::time_pt
Time *& time_pt()
Return a pointer to the global time object.
Definition: problem.h:1504
oomph::Problem::time
double & time()
Return the current value of continuous time.
Definition: problem.cc:11531
oomph::TimeStepper::time_pt
Time *const & time_pt() const
Access function for the pointer to time (const version)
Definition: timesteppers.h:572
oomph::Time::time
double & time()
Return the current value of the continuous time.
Definition: timesteppers.h:123
oomph::Tree
Definition: tree.h:74
oomph::Tree::object_pt
RefineableElement * object_pt() const
Definition: tree.h:88
oomph::Tree::level
unsigned level() const
Return the level of the Tree (root=0)
Definition: tree.h:247
MergeRestartFiles.filename
string filename
Definition: MergeRestartFiles.py:39
SarahBL::Kin_energy_sarah
double Kin_energy_sarah(double t)
Definition: navier_stokes/osc_ring/osc_ring_alg.cc:123
SarahBL::full_exact_soln
void full_exact_soln(const double &time, const Vector< double > &x, Vector< double > &soln)
Full exact solution: x,y,u,v,p,du/dt,dv/dt,diss.
Definition: navier_stokes/osc_ring/osc_ring_alg.cc:539
SarahBL::Total_Diss_sarah
double Total_Diss_sarah(double t)
Definition: navier_stokes/osc_ring/osc_ring_alg.cc:230
SarahBL::exact_soln
void exact_soln(const double &time, const Vector< double > &x, Vector< double > &soln)
Exact solution: x,y,u,v,p.
Definition: navier_stokes/osc_ring/osc_ring_alg.cc:470
UniformPSDSelfTest.r
r
Definition: UniformPSDSelfTest.py:20

References oomph::Mesh::add_element_pt(), oomph::DocInfo::directory(), oomph::Mesh::element_pt(), SarahBL::exact_soln(), MergeRestartFiles::filename, SarahBL::full_exact_soln(), SarahBL::Kin_energy_sarah(), oomph::Tree::level(), oomph::Mesh::nelement(), oomph::DocInfo::number(), oomph::Tree::object_pt(), BiharmonicTestFunctions2::Pi, UniformPSDSelfTest::r, SarahBL::Total_Diss_sarah(), and oomph::Problem_Parameter::Trace_file.

◆ doc_solution() [2/4]

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

Doc the solution.

◆ doc_solution() [3/4]

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

Doc the solution.

◆ doc_solution() [4/4]

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

Doc the solution.

◆ doc_solution_historic()

template<class ELEMENT , class TIMESTEPPER >
void OscRingNStProblem< ELEMENT, TIMESTEPPER >::doc_solution_historic ( DocInfo &  doc_info)

Doc the solution (historic version, maintained for backwards compatibility)

Doc the solution (historic) – maintained for backward compatibility

1273 {
1274 
1275  cout << "Doc-ing step " << doc_info.number()
1276  << " for time " << time_stepper_pt()->time_pt()->time() << std::endl;
1277 
1278 
1279  ofstream some_file;
1280  char filename[100];
1281 
1282  // Number of plot points
1283  unsigned npts;
1284  npts=5;
1285 
1286 
1287  // Output solution on fluid mesh
1288  //-------------------------------
1289  sprintf(filename,"%s/soln%i.dat",doc_info.directory().c_str(),
1290  doc_info.number());
1291  //some_file.precision(20);
1292  some_file.open(filename);
1293  unsigned nelem=fluid_mesh_pt()->nelement();
1294  for (unsigned ielem=0;ielem<nelem;ielem++)
1295  {
1296  dynamic_cast<ELEMENT*>(fluid_mesh_pt()->element_pt(ielem))->
1297  full_output(some_file,npts);
1298  }
1299  some_file.close();
1300 
1301 
1302  // Plot wall posn
1303  //---------------
1304  sprintf(filename,"%s/Wall%i.dat",doc_info.directory().c_str(),
1305  doc_info.number());
1306  some_file.open(filename);
1307 
1308  unsigned nplot=100;
1309  Vector<double > xi_wall(1);
1310  Vector<double > r_wall(2);
1311  for (unsigned iplot=0;iplot<nplot;iplot++)
1312  {
1313  xi_wall[0]=0.5*MathematicalConstants::Pi*double(iplot)/double(nplot-1);
1314  Wall_pt->position(xi_wall,r_wall);
1315  some_file << r_wall[0] << " " << r_wall[1] << std::endl;
1316  }
1317  some_file.close();
1318 
1319 
1320  // Doc Sarah's asymptotic solution
1321  //--------------------------------
1322  sprintf(filename,"%s/exact_soln%i.dat",doc_info.directory().c_str(),
1323  doc_info.number());
1324  some_file.open(filename);
1325  fluid_mesh_pt()->output_fct(some_file,npts,
1326  time_stepper_pt()->time_pt()->time(),
1327  SarahBL::full_exact_soln);
1328  some_file.close();
1329 
1330 
1331 
1332 
1333  // Get position of control point
1334  //------------------------------
1335  Vector<double> r(2);
1336  Vector<double> xi(1);
1337  xi[0]=MathematicalConstants::Pi/2.0;
1338  wall_pt()->position(xi,r);
1339 
1340 
1341 
1342  // Get total volume (area) of computational domain, energies and average
1343  //----------------------------------------------------------------------
1344  // pressure
1345  //---------
1346  double area=0.0;
1347  double press_int=0.0;
1348  double diss=0.0;
1349  double kin_en=0.0;
1350  nelem=fluid_mesh_pt()->nelement();
1351 
1352  for (unsigned ielem=0;ielem<nelem;ielem++)
1353  {
1354  area+=fluid_mesh_pt()->finite_element_pt(ielem)->size();
1355  press_int+=dynamic_cast<ELEMENT*>(fluid_mesh_pt()->element_pt(ielem))
1356  ->pressure_integral();
1357  diss+=dynamic_cast<ELEMENT*>(fluid_mesh_pt()->element_pt(ielem))->
1358  dissipation();
1359  kin_en+=dynamic_cast<ELEMENT*>(fluid_mesh_pt()->element_pt(ielem))->
1360  kin_energy();
1361  }
1362 
1363 
1364  // Total kinetic energy in entire domain
1365  double global_kin=4.0*kin_en;
1366  double sarah_global_kin= SarahBL::Kin_energy_sarah(time_pt()->time());
1367 
1368  // Use global length to store mean radius of osc. ellipse
1369  double global_length=static_cast<PseudoBucklingRingElement*>(Wall_pt)->r_0();;
1370 
1371  Trace_file << time_pt()->time() << " " << r[1]
1372  << " " << sarah_global_kin << " " << global_kin
1373  << " " << global_kin
1374  << " " << global_length << " " ;
1375 
1376 
1377  // Add to trace file
1378  Trace_file << area << " " ;
1379  Trace_file << press_int/area << " " ;
1380  Trace_file << diss << " " ;
1381  Trace_file << Veloc_trace_node_pt->x(0) << " " ;
1382  Trace_file << Veloc_trace_node_pt->x(1) << " " ;
1383  Trace_file << Veloc_trace_node_pt->value(0) << " " ;
1384  Trace_file << Veloc_trace_node_pt->value(1) << " " ;
1385 
1386  // Refinement statistics
1387 
1388  {
1389  // Extract all elements on a refinement level on which a uniform
1390  // mesh exists
1391  unsigned min_level;
1392  unsigned max_level;
1393  fluid_mesh_pt()->get_refinement_levels(min_level,max_level);
1394  Trace_file << fluid_mesh_pt()->nelement() << " ";
1395  Trace_file << ndof() << " ";
1396  Trace_file << min_level << " " << max_level << " " ;
1397  }
1398  Trace_file << fluid_mesh_pt()->nrefinement_overruled()
1399  << " ";
1400  Trace_file << fluid_mesh_pt()->max_error() << " ";
1401  Trace_file << fluid_mesh_pt()->min_error() << " ";
1402  Trace_file << fluid_mesh_pt()->max_permitted_error() << " ";
1403  Trace_file << fluid_mesh_pt()->min_permitted_error() << " ";
1404  Trace_file << fluid_mesh_pt()->max_keep_unrefined() << " ";
1405  Trace_file << doc_info.number() << " ";
1406 
1407  // Exact dissipation in oscillating ellipse
1408  double time=time_pt()->time();
1409 
1410  // dissipation in inviscid core
1411  double diss_inviscid=0.0;
1412 
1413 
1414  diss_inviscid=0.0;
1415 
1416  Trace_file << diss_inviscid << " ";
1417 
1418 
1419  // Sarah's dissipation in bl
1420  double bl_diss_sarah=0.0;
1421 
1422  Trace_file << bl_diss_sarah << " " ;
1423 
1424 
1425  // Total dissipation for quarter domain
1426  double diss_sarah=SarahBL::Total_Diss_sarah(time)/4.0;
1427 
1428  Trace_file << diss_sarah << " " ;
1429 
1430  // Doc veloc at point on symmetry line
1431  Trace_file << Sarah_veloc_trace_node_pt->x(0) << " " ;
1432  Trace_file << Sarah_veloc_trace_node_pt->x(1) << " " ;
1433  Trace_file << Sarah_veloc_trace_node_pt->value(0) << " " ;
1434  Trace_file << Sarah_veloc_trace_node_pt->value(1) << " " ;
1435 
1436  // Get veloc in Sarah's soln
1437  {
1438  double rho=0.5;
1439  double zeta=0.0;
1440  Trace_file
1441  <<SarahBL::X_sarah(rho,zeta,time_stepper_pt()->time_pt()->time())<< " " ;
1442  Trace_file
1443  <<SarahBL::Y_sarah(rho,zeta,time_stepper_pt()->time_pt()->time())<< " " ;
1444  Trace_file
1445  <<SarahBL::U_sarah(rho,zeta,time_stepper_pt()->time_pt()->time())<< " " ;
1446  Trace_file
1447  <<SarahBL::V_sarah(rho,zeta,time_stepper_pt()->time_pt()->time())<< " " ;
1448  }
1449 
1450 
1451  // Finally, write std::endline into tracefile
1452  Trace_file << std::endl;
1453 
1454 
1455  // Output fluid solution on coarse-ish mesh
1456  //-----------------------------------------
1457 
1458  // Extract all elements from quadtree representation
1459  Vector<QuadTree*> all_element_pt;
1460  fluid_mesh_pt()->forest_pt()->
1461  stick_all_tree_nodes_into_vector(all_element_pt);
1462 
1463  // Extract all elements on a refinement level on which a uniform
1464  // mesh exists
1465  unsigned min_level;
1466  unsigned max_level;
1467  fluid_mesh_pt()->get_refinement_levels(min_level,max_level);
1468 
1469  // Build a coarse mesh
1470  Mesh* coarse_mesh_pt = new Mesh();
1471 
1472  //Loop over all elements and check if their refinement level is
1473  //equal to the mesh's minimum refinement level
1474  nelem=all_element_pt.size();
1475  for (unsigned ielem=0;ielem<nelem;ielem++)
1476  {
1477  QuadTree* el_pt=all_element_pt[ielem];
1478  if (el_pt->level()==min_level)
1479  {
1480  coarse_mesh_pt->add_element_pt(el_pt->object_pt());
1481  }
1482  }
1483 
1484  // Output fluid solution on coarse mesh
1485  sprintf(filename,"%s/coarse_soln%i.dat",doc_info.directory().c_str(),
1486  doc_info.number());
1487  some_file.open(filename);
1488  nelem=coarse_mesh_pt->nelement();
1489  for (unsigned ielem=0;ielem<nelem;ielem++)
1490  {
1491  dynamic_cast<ELEMENT*>(coarse_mesh_pt->element_pt(ielem))->
1492  full_output(some_file,npts);
1493  }
1494  some_file.close();
1495 
1496 }
oomph::QuadTree
Definition: quadtree.h:104
Eigen::zeta
EIGEN_STRONG_INLINE const Eigen::CwiseBinaryOp< Eigen::internal::scalar_zeta_op< typename DerivedX::Scalar >, const DerivedX, const DerivedQ > zeta(const Eigen::ArrayBase< DerivedX > &x, const Eigen::ArrayBase< DerivedQ > &q)
Definition: SpecialFunctionsArrayAPI.h:152
SarahBL::Y_sarah
double Y_sarah(double rho, double zeta, double t)
Definition: navier_stokes/osc_ring/osc_ring_alg.cc:422
SarahBL::X_sarah
double X_sarah(double rho, double zeta, double t)
Definition: navier_stokes/osc_ring/osc_ring_alg.cc:401
SarahBL::V_sarah
double V_sarah(double rho, double zeta, double t)
Definition: navier_stokes/osc_ring/osc_ring_alg.cc:332
SarahBL::U_sarah
double U_sarah(double rho, double zeta, double t)
Definition: navier_stokes/osc_ring/osc_ring_alg.cc:263

References oomph::Mesh::add_element_pt(), oomph::DocInfo::directory(), oomph::Mesh::element_pt(), MergeRestartFiles::filename, SarahBL::full_exact_soln(), SarahBL::Kin_energy_sarah(), oomph::Tree::level(), oomph::Mesh::nelement(), oomph::DocInfo::number(), oomph::Tree::object_pt(), BiharmonicTestFunctions2::Pi, UniformPSDSelfTest::r, SarahBL::Total_Diss_sarah(), oomph::Problem_Parameter::Trace_file, SarahBL::U_sarah(), SarahBL::V_sarah(), SarahBL::X_sarah(), SarahBL::Y_sarah(), and Eigen::zeta().

◆ dump_it() [1/4]

template<class ELEMENT , class TIMESTEPPER >
void OscRingNStProblem< ELEMENT, TIMESTEPPER >::dump_it ( ofstream &  dump_file)

Dump generic problem data.

Dump the solution.

1145 {
1146 
1147  // Dump refinement status of mesh
1148  //mesh_pt()->dump_refinement(dump_file);
1149 
1150  // Call generic dump()
1151  Problem::dump(dump_file);
1152 
1153 }

◆ dump_it() [2/4]

template<class ELEMENT , class TIMESTEPPER >
void OscRingNStProblem< ELEMENT, TIMESTEPPER >::dump_it ( ofstream &  dump_file,
DocInfo  doc_info 
)

Dump problem data.

Dump the solution.

688 {
689 
690  // Dump refinement status of mesh
691  //fluid_mesh_pt()->dump_refinement(dump_file);
692 
693  // Call generic dump()
694  Problem::dump(dump_file);
695 
696 }

◆ dump_it() [3/4]

template<class ELEMENT >
void OscRingNStProblem< ELEMENT >::dump_it ( ofstream &  dump_file,
DocInfo  doc_info 
)

Dump problem data.

◆ dump_it() [4/4]

template<class ELEMENT >
void OscRingNStProblem< ELEMENT >::dump_it ( ofstream &  dump_file,
DocInfo  doc_info 
)

Dump generic problem data.

◆ finish_problem_setup()

template<class ELEMENT , class TIMESTEPPER >
void OscRingNStProblem< ELEMENT, TIMESTEPPER >::finish_problem_setup

Finish problem setup: Setup element-specific things (source fct pointers etc.)

Complete build of OscRingNSt problem on deformable ring mesh

Loop over elements and

  • setup pointers to physical parameters (Re, St, etc.)
  • pointers to time
  • free internal pressure variables

Then choose one element and fix an internal pressure degree .

917 {
918 
919 
920  //Find out how many timesteppers there are
921  unsigned Ntime_steppers = ntime_stepper();
922 
923  //Loop over them all and set the weights
924  for(unsigned i=0;i<Ntime_steppers;i++)
925  {
926  time_stepper_pt(i)->set_weights();
927  }
928 
929  //Find number of elements in mesh
930  unsigned Nelement = fluid_mesh_pt()->nelement();
931 
932  // Loop over the elements to set up element-specific
933  // things that cannot be handled by constructor
934  for(unsigned i=0;i<Nelement;i++)
935  {
936  // Upcast from FiniteElement to the present element
937  ELEMENT *el_pt = dynamic_cast<ELEMENT*>(fluid_mesh_pt()->element_pt(i));
938 
939  //Set the Reynolds number, etc
940  el_pt->re_pt() = &Global_Physical_Variables::Re;
941  el_pt->re_st_pt() = &Global_Physical_Variables::ReSt;
942  }
943 
944 
945  // Ring boundary: No slip; this also implies that the velocity needs
946  // to be updated in response to wall motion. This needs to be reset
947  // every time the mesh is changed -- there's no mechanism by which
948  // auxiliary update functions are copied to newly created nodes.
949  // (that's because unlike boundary conditions, they don't
950  // occur exclusively at boundaries)
951  unsigned ibound=1;
952  {
953  unsigned num_nod= fluid_mesh_pt()->nboundary_node(ibound);
954  for (unsigned inod=0;inod<num_nod;inod++)
955  {
956  fluid_mesh_pt()->boundary_node_pt(ibound,inod)->
957  set_auxiliary_node_update_fct_pt(
958  FSI_functions::apply_no_slip_on_moving_wall);
959  }
960  }
961 
962 
963  // Set the reference pressure as the constant pressure in element 0
964  dynamic_cast<PseudoBucklingRingElement*>(Wall_pt)
965  ->set_reference_pressure_pt(fluid_mesh_pt()->element_pt(0)
966  ->internal_data_pt(0));
967 
968 }
oomph::Problem::ntime_stepper
unsigned ntime_stepper() const
Return the number of time steppers.
Definition: problem.h:1680
oomph::TimeStepper::set_weights
virtual void set_weights()=0

References oomph::FSI_functions::apply_no_slip_on_moving_wall(), i, Global_Physical_Variables::Re, and Global_Physical_Variables::ReSt.

◆ fluid_mesh_pt() [1/3]

template<class ELEMENT >
AlgebraicRefineableQuarterCircleSectorMesh<ELEMENT>* OscRingNStProblem< ELEMENT >::fluid_mesh_pt ( )
inline

Access function for the fluid mesh.

164  {
165  return Fluid_mesh_pt;
166  }

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

◆ fluid_mesh_pt() [2/3]

template<class ELEMENT >
MacroElementNodeUpdateRefineableQuarterCircleSectorMesh<ELEMENT>* OscRingNStProblem< ELEMENT >::fluid_mesh_pt ( )
inline

Access function for the fluid mesh.

163  {
164  return Fluid_mesh_pt;
165  }

◆ fluid_mesh_pt() [3/3]

template<class ELEMENT >
AlgebraicRefineableQuarterCircleSectorMesh<ELEMENT>* OscRingNStProblem< ELEMENT >::fluid_mesh_pt ( )
inline

Access function for the fluid mesh.

695  {
696  return Fluid_mesh_pt;
697  }

◆ mesh_pt()

template<class ELEMENT >
RefineableQuarterCircleSectorMesh<ELEMENT>* OscRingNStProblem< ELEMENT >::mesh_pt ( )
inline

Access function for the fluid mesh.

674  {
675  return dynamic_cast<RefineableQuarterCircleSectorMesh<ELEMENT>*>(
676  Problem::mesh_pt());
677  }
oomph::RefineableQuarterCircleSectorMesh
Definition: quarter_circle_sector_mesh.template.h:188

◆ restart() [1/4]

template<class ELEMENT , class TIMESTEPPER >
void OscRingNStProblem< ELEMENT, TIMESTEPPER >::restart ( ifstream &  restart_file)

Read problem data.

Read solution from disk.

705 {
706  // Refine fluid mesh according to the instructions in restart file
707  //fluid_mesh_pt()->refine(restart_file);
708 
709  // Rebuild the global mesh
710  //rebuild_global_mesh();
711 
712  // Read generic problem data
713  Problem::read(restart_file);
714 
715 // // Complete build of all elements so they are fully functional
716 // finish_problem_setup();
717 
718  //Assign equation numbers
719  //cout <<"\nNumber of equations: " << assign_eqn_numbers()
720  // << std::endl<< std::endl;
721 }
Eigen::TensorSycl::internal::read
static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::enable_if_t< PacketLoad, PacketType > read(const TensorMapper &tensorMapper, const StorageIndex &NCIndex, const StorageIndex &CIndex, const StorageIndex &ld)
read, a template function used for loading the data from global memory. This function is used to guar...
Definition: TensorContractionSycl.h:162

References Eigen::TensorSycl::internal::read().

Referenced by main().

◆ restart() [2/4]

template<class ELEMENT >
void OscRingNStProblem< ELEMENT >::restart ( ifstream &  restart_file)

Read problem data.

◆ restart() [3/4]

template<class ELEMENT >
void OscRingNStProblem< ELEMENT >::restart ( ifstream &  restart_file)

Read generic problem data.

◆ restart() [4/4]

template<class ELEMENT >
void OscRingNStProblem< ELEMENT >::restart ( ifstream &  restart_file)

Read generic problem data.

◆ set_initial_condition() [1/4]

template<class ELEMENT , class TIMESTEPPER >
void OscRingNStProblem< ELEMENT, TIMESTEPPER >::set_initial_condition
virtual

Set initial condition (incl previous timesteps) according to specified function.

Set initial condition: Assign previous and current values of the velocity from the velocity field specified via the function pointer.

Values are assigned so that the velocities and accelerations are correct for current time.

Reimplemented from oomph::Problem.

401 {
402 
403  // Elastic wall: We're starting from a given initial state in which
404  // the wall is undeformed. If set_initial_condition() is called again
405  // after mesh refinement for first timestep, this needs to be reset.
406  dynamic_cast<PseudoBucklingRingElement*>(Wall_pt)->set_R_0(1.0);
407 
408  // Backup time in global timestepper
409  double backed_up_time=time_pt()->time();
410 
411  // Past history for velocities needs to be established for t=time0-deltat, ...
412  // Then provide current values (at t=time0) which will also form
413  // the initial guess for first solve at t=time0+deltat
414 
415  // Vector of exact solution values (includes pressure)
416  Vector<double> soln(3);
417  Vector<double> x(2);
418 
419  //Find number of nodes in mesh
420  unsigned num_nod = fluid_mesh_pt()->nnode();
421 
422  // Get continuous times at previous timesteps
423  int nprev_steps=time_stepper_pt()->nprev_values();
424  Vector<double> prev_time(nprev_steps+1);
425  for (int itime=nprev_steps;itime>=0;itime--)
426  {
427  prev_time[itime]=time_pt()->time(unsigned(itime));
428  }
429 
430  // Loop over current & previous timesteps (in outer loop because
431  // the mesh might also move)
432  for (int itime=nprev_steps;itime>=0;itime--)
433  {
434  double time=prev_time[itime];
435 
436  // Set global time (because this is how the geometric object refers
437  // to continous time
438  time_pt()->time()=time;
439 
440  cout << "setting IC at time =" << time << std::endl;
441 
442  // Update the fluid mesh for this value of the continuous time
443  // (The wall object reads the continous time from the same
444  // global time object)
445  fluid_mesh_pt()->node_update();
446 
447  // Loop over the nodes to set initial guess everywhere
448  for (unsigned jnod=0;jnod<num_nod;jnod++)
449  {
450 
451  // Get nodal coordinates
452  x[0]=fluid_mesh_pt()->node_pt(jnod)->x(0);
453  x[1]=fluid_mesh_pt()->node_pt(jnod)->x(1);
454 
455  // Get intial solution
456  (*IC_Fct_pt)(time,x,soln);
457 
458  // Loop over velocity directions (velocities are in soln[0] and soln[1]).
459  for (unsigned i=0;i<2;i++)
460  {
461  fluid_mesh_pt()->node_pt(jnod)->set_value(itime,i,soln[i]);
462  }
463 
464  // Loop over coordinate directions
465  for (unsigned i=0;i<2;i++)
466  {
467  fluid_mesh_pt()->node_pt(jnod)->x(itime,i)=x[i];
468  }
469  }
470  }
471 
472  // Reset backed up time for global timestepper
473  time_pt()->time()=backed_up_time;
474 
475 }
oomph::TimeStepper::nprev_values
virtual unsigned nprev_values() const =0
Number of previous values available: 0 for static, 1 for BDF<1>,...
plotDoE.x
list x
Definition: plotDoE.py:28

References i, and plotDoE::x.

◆ set_initial_condition() [2/4]

template<class ELEMENT >
void OscRingNStProblem< ELEMENT >::set_initial_condition ( )
virtual

Set initial condition (incl previous timesteps) according to specified function.

Reimplemented from oomph::Problem.

◆ set_initial_condition() [3/4]

template<class ELEMENT >
void OscRingNStProblem< ELEMENT >::set_initial_condition ( )
virtual

Set initial condition (incl previous timesteps) according to specified function.

Reimplemented from oomph::Problem.

◆ set_initial_condition() [4/4]

template<class ELEMENT >
void OscRingNStProblem< ELEMENT >::set_initial_condition ( )
virtual

Set initial condition (incl previous timesteps) according to specified function.

Reimplemented from oomph::Problem.

◆ unsteady_run() [1/4]

template<class ELEMENT , class TIMESTEPPER >
void OscRingNStProblem< ELEMENT, TIMESTEPPER >::unsteady_run ( const unsigned &  ntsteps,
const bool &  restarted,
DocInfo &  doc_info 
)

Run the time integration for ntsteps steps.

Driver for timestepping the problem: Fixed timestep but guaranteed spatial accuracy. Beautiful, innit?

734 {
735 
736  // Open trace file
737  char filename[100];
738  sprintf(filename,"%s/trace.dat",doc_info.directory().c_str());
739  Trace_file.open(filename);
740 
741  // Max. number of adaptations per solve
742  unsigned max_adapt;
743 
744  // Max. number of adaptations per solve
745  if (restarted)
746  {
747  max_adapt=0;
748  }
749  else
750  {
751  max_adapt=1;
752  }
753 
754  // Max. and min. error for adaptive refinement/unrefinement
755  fluid_mesh_pt()->max_permitted_error()= 0.5e-2;
756  fluid_mesh_pt()->min_permitted_error()= 0.5e-3;
757 
758  // Don't allow refinement to drop under given level
759  fluid_mesh_pt()->min_refinement_level()=2;
760 
761  // Don't allow refinement beyond given level
762  fluid_mesh_pt()->max_refinement_level()=6;
763 
764  // Don't bother adapting the mesh if no refinement is required
765  // and if less than ... elements are to be merged.
766  fluid_mesh_pt()->max_keep_unrefined()=20;
767 
768 
769  // Get max/min refinement levels in mesh
770  unsigned min_refinement_level;
771  unsigned max_refinement_level;
772  fluid_mesh_pt()->get_refinement_levels(min_refinement_level,
773  max_refinement_level);
774 
775  cout << "\n Initial mesh: min/max refinement levels: "
776  << min_refinement_level << " " << max_refinement_level << std::endl << std::endl;
777 
778  // Doc refinement targets
779  fluid_mesh_pt()->doc_adaptivity_targets(cout);
780 
781  // Write header for trace file
782  write_trace_file_header();
783 
784  // Doc initial condition
785  doc_solution(doc_info);
786  doc_info.number()++;
787 
788  // Switch off doc during solve
789  doc_info.disable_doc();
790 
791  // If we set first to true, then initial guess will be re-assigned
792  // after mesh adaptation. Don't want this if we've done a restart.
793  bool first;
794  bool shift;
795  if (restarted)
796  {
797  first=false;
798  shift=false;
799  // Move time back by dt to make sure we're re-solving the read-in solution
800  time_pt()->time()-=time_pt()->dt();
801  }
802  else
803  {
804  first=true;
805  shift=true;
806  }
807 
808  //Take the first fixed timestep with specified tolerance for Newton solver
809  double dt=time_pt()->dt();
810  unsteady_newton_solve(dt,max_adapt,first,shift);
811 
812  // Switch doc back on
813  doc_info.enable_doc();
814 
815  // Doc initial solution
816  doc_solution(doc_info);
817  doc_info.number()++;
818 
819  // Now do normal run; allow for one mesh adaptation per timestep
820  max_adapt=1;
821 
822  //Loop over the remaining timesteps
823  for(unsigned t=2;t<=ntsteps;t++)
824  {
825 
826  // Switch off doc during solve
827  doc_info.disable_doc();
828 
829  //Take fixed timestep
830  first=false;
831  unsteady_newton_solve(dt,max_adapt,first);
832 
833  // Switch doc back on
834  doc_info.enable_doc();
835 
836  // Doc solution
837  //if (icount%10==0)
838  {
839  doc_solution(doc_info);
840  doc_info.number()++;
841  }
842  }
843 
844  // Close trace file
845  Trace_file.close();
846 
847 }
OscRingNStProblem::write_trace_file_header
void write_trace_file_header()
Write header for trace file.
Definition: interaction/fsi_osc_ring/osc_ring_alg.cc:856
OscRingNStProblem::doc_solution
void doc_solution(DocInfo &doc_info)
Doc the solution.
Definition: interaction/fsi_osc_ring/osc_ring_alg.cc:486
oomph::DocInfo::enable_doc
void enable_doc()
Enable documentation.
Definition: oomph_utilities.h:536
oomph::DocInfo::disable_doc
void disable_doc()
Disable documentation.
Definition: oomph_utilities.h:542
oomph::Problem::unsteady_newton_solve
void unsteady_newton_solve(const double &dt)
Definition: problem.cc:10953
oomph::Time::dt
double & dt(const unsigned &t=0)
Definition: timesteppers.h:136
plotPSD.t
t
Definition: plotPSD.py:36

References oomph::DocInfo::directory(), oomph::DocInfo::disable_doc(), oomph::DocInfo::enable_doc(), MergeRestartFiles::filename, oomph::DocInfo::number(), plotPSD::t, and oomph::Problem_Parameter::Trace_file.

Referenced by main().

◆ unsteady_run() [2/4]

template<class ELEMENT >
void OscRingNStProblem< ELEMENT >::unsteady_run ( const unsigned &  ntsteps,
const bool &  restarted,
DocInfo &  doc_info 
)

Run the time integration for ntsteps steps.

◆ unsteady_run() [3/4]

template<class ELEMENT >
void OscRingNStProblem< ELEMENT >::unsteady_run ( const unsigned &  ntsteps,
const bool &  restarted,
DocInfo &  doc_info 
)

Run the time integration for ntsteps steps.

◆ unsteady_run() [4/4]

template<class ELEMENT >
void OscRingNStProblem< ELEMENT >::unsteady_run ( const unsigned &  ntsteps,
const bool &  restarted,
DocInfo &  doc_info 
)

Run the time integration for ntsteps steps.

◆ wall_pt() [1/4]

template<class ELEMENT >
GeomObject* OscRingNStProblem< ELEMENT >::wall_pt ( )
inline

Get pointer to wall as geometric object.

100  {
101  return Wall_pt;
102  }

◆ wall_pt() [2/4]

template<class ELEMENT >
GeomObject* OscRingNStProblem< ELEMENT >::wall_pt ( )
inline

Get pointer to wall as geometric object.

99  {
100  return Wall_pt;
101  }

◆ wall_pt() [3/4]

template<class ELEMENT >
GeomObject* OscRingNStProblem< ELEMENT >::wall_pt ( )
inline

Get pointer to wall as geometric object.

649  {
650  return Wall_pt;
651  }

◆ wall_pt() [4/4]

template<class ELEMENT >
GeomObject* OscRingNStProblem< ELEMENT >::wall_pt ( )
inline

Get pointer to wall as geometric object.

626  {
627  return Wall_pt;
628  }

◆ write_trace_file_header() [1/4]

template<class ELEMENT , class TIMESTEPPER >
void OscRingNStProblem< ELEMENT, TIMESTEPPER >::write_trace_file_header
private

Write header for trace file.

Write trace file header.

857 {
858 
859  // Doc parameters in trace file
860  Trace_file << "# err_max " << fluid_mesh_pt()->max_permitted_error() << std::endl;
861  Trace_file << "# err_min " << fluid_mesh_pt()->min_permitted_error() << std::endl;
862  Trace_file << "# Re " << Global_Physical_Variables::Re << std::endl;
863  Trace_file << "# St " << Global_Physical_Variables::ReSt/
864  Global_Physical_Variables::Re << std::endl;
865  Trace_file << "# dt " << time_stepper_pt()->time_pt()->dt() << std::endl;
866  Trace_file << "# initial # elements " << mesh_pt()->nelement() << std::endl;
867  Trace_file << "# min_refinement_level "
868  << fluid_mesh_pt()->min_refinement_level() << std::endl;
869  Trace_file << "# max_refinement_level "
870  << fluid_mesh_pt()->max_refinement_level() << std::endl;
871 
872 
873 
874  Trace_file << "VARIABLES=\"time\",\"V_c_t_r_l\",\"e_k_i_n\"";
875  Trace_file << ",\"e_k_i_n_(_a_s_y_m_p_t_)\",\"R_0\",\"Area\"" ;
876  Trace_file << ",\"Average pressure\",\"Total dissipation (quarter domain)\"";
877  Trace_file << ",\"Asymptotic dissipation (quarter domain)\"";
878  Trace_file << ",\"x<sub>1</sub><sup>(track)</sup>\"";
879  Trace_file << ",\"x<sub>2</sub><sup>(track)</sup>\"";
880  Trace_file << ",\"u<sub>1</sub><sup>(track)</sup>\"";
881  Trace_file << ",\"u<sub>2</sub><sup>(track)</sup>\"";
882  Trace_file << ",\"N<sub>element</sub>\"";
883  Trace_file << ",\"N<sub>dof</sub>\"";
884  Trace_file << ",\"max. refinement level\"";
885  Trace_file << ",\"min. refinement level\"";
886  Trace_file << ",\"# of elements whose refinement was over-ruled\"";
887  Trace_file << ",\"max. error\"";
888  Trace_file << ",\"min. error\"";
889  Trace_file << ",\"max. permitted error\"";
890  Trace_file << ",\"min. permitted error\"";
891  Trace_file << ",\"max. permitted # of unrefined elements\"";
892  Trace_file << ",\"doc number\"";
893  Trace_file << ",\"x<sub>1</sub><sup>(track2 FE)</sup>\"";
894  Trace_file << ",\"x<sub>2</sub><sup>(track2 FE)</sup>\"";
895  Trace_file << ",\"u<sub>1</sub><sup>(track2 FE)</sup>\"";
896  Trace_file << ",\"u<sub>2</sub><sup>(track2 FE)</sup>\"";
897  Trace_file << ",\"x<sub>1</sub><sup>(track2 Sarah)</sup>\"";
898  Trace_file << ",\"x<sub>2</sub><sup>(track2 Sarah)</sup>\"";
899  Trace_file << ",\"u<sub>1</sub><sup>(track2 Sarah)</sup>\"";
900  Trace_file << ",\"u<sub>2</sub><sup>(track2 Sarah)</sup>\"";
901  Trace_file << ",\"R<sub>0</sub>-1\"";
902  Trace_file << std::endl;
903 
904 }

References Global_Physical_Variables::Re, Global_Physical_Variables::ReSt, and oomph::Problem_Parameter::Trace_file.

◆ write_trace_file_header() [2/4]

template<class ELEMENT >
void OscRingNStProblem< ELEMENT >::write_trace_file_header ( )
private

Write header for trace file.

◆ write_trace_file_header() [3/4]

template<class ELEMENT >
void OscRingNStProblem< ELEMENT >::write_trace_file_header ( )
private

Write header for trace file.

◆ write_trace_file_header() [4/4]

template<class ELEMENT >
void OscRingNStProblem< ELEMENT >::write_trace_file_header ( )
private

Write header for trace file.

◆ write_trace_file_header_historic()

template<class ELEMENT , class TIMESTEPPER >
void OscRingNStProblem< ELEMENT, TIMESTEPPER >::write_trace_file_header_historic
private

Write header for trace file (historic version, maintained for backwards compatibility)

Write header for (historic) trace file – maintained for backwards compatibility

1743 {
1744 
1745  // Doc parameters in trace file
1746  Trace_file << "# err_max " << fluid_mesh_pt()->max_permitted_error() << std::endl;
1747  Trace_file << "# err_min " << fluid_mesh_pt()->min_permitted_error() << std::endl;
1748  Trace_file << "# Re " << Global_Physical_Variables::Re << std::endl;
1749  Trace_file << "# St " << Global_Physical_Variables::ReSt/
1750  Global_Physical_Variables::Re << std::endl;
1751  Trace_file << "# dt " << time_stepper_pt()->time_pt()->dt() << std::endl;
1752  Trace_file << "# initial # elements " << mesh_pt()->nelement() << std::endl;
1753  Trace_file << "# min_refinement_level "
1754  << fluid_mesh_pt()->min_refinement_level() << std::endl;
1755  Trace_file << "# max_refinement_level "
1756  << fluid_mesh_pt()->max_refinement_level() << std::endl;
1757  Trace_file << "# max_adapt "
1758  << 1 << std::endl;
1759 
1760 
1761  Trace_file << "VARIABLES=\"time\",\"V_c_t_r_l\",\"e_p_o_t\"";
1762  Trace_file << ",\"e_k_i_n\",\"e_p_o_t + e_k_i_n\",\"Length\",\"Area\"" ;
1763  Trace_file << ",\"Average pressure\",\"Total dissipation\"";
1764  Trace_file << ",\"x<sub>1</sub><sup>(track)</sup>\"";
1765  Trace_file << ",\"x<sub>2</sub><sup>(track)</sup>\"";
1766  Trace_file << ",\"u<sub>1</sub><sup>(track)</sup>\"";
1767  Trace_file << ",\"u<sub>2</sub><sup>(track)</sup>\"";
1768  Trace_file << ",\"N<sub>element</sub>\"";
1769  Trace_file << ",\"N<sub>dof</sub>\"";
1770  Trace_file << ",\"max. refinement level\"";
1771  Trace_file << ",\"min. refinement level\"";
1772  Trace_file << ",\"# of under-refined elements\"";
1773  Trace_file << ",\"max. error\"";
1774  Trace_file << ",\"min. error\"";
1775  Trace_file << ",\"max. permitted error\"";
1776  Trace_file << ",\"min. permitted error\"";
1777  Trace_file << ",\"max. permitted # of unrefined elements\"";
1778  Trace_file << ",\"doc number\"";
1779  Trace_file << ",\"Exact dissipation in core (fluid scale)\"";
1780  Trace_file << ",\"Exact dissipation in BL (fluid scale)\"";
1781  Trace_file << ",\"Exact dissipation total (fluid scale)\"";
1782 
1783  Trace_file << ",\"x<sub>1</sub><sup>(track2 FE)</sup>\"";
1784  Trace_file << ",\"x<sub>2</sub><sup>(track2 FE)</sup>\"";
1785  Trace_file << ",\"u<sub>1</sub><sup>(track2 FE)</sup>\"";
1786  Trace_file << ",\"u<sub>2</sub><sup>(track2 FE)</sup>\"";
1787 
1788  Trace_file << ",\"x<sub>1</sub><sup>(track2 Sarah)</sup>\"";
1789  Trace_file << ",\"x<sub>2</sub><sup>(track2 Sarah)</sup>\"";
1790  Trace_file << ",\"u<sub>1</sub><sup>(track2 Sarah)</sup>\"";
1791  Trace_file << ",\"u<sub>2</sub><sup>(track2 Sarah)</sup>\"";
1792 
1793  Trace_file << std::endl;
1794 
1795 }

References Global_Physical_Variables::Re, Global_Physical_Variables::ReSt, and oomph::Problem_Parameter::Trace_file.

Member Data Documentation

◆ Fluid_mesh_pt [1/2]

template<class ELEMENT >
AlgebraicRefineableQuarterCircleSectorMesh< ELEMENT > * OscRingNStProblem< ELEMENT >::Fluid_mesh_pt
private

Pointer to fluid mesh.

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

◆ Fluid_mesh_pt [2/2]

template<class ELEMENT >
MacroElementNodeUpdateRefineableQuarterCircleSectorMesh<ELEMENT>* OscRingNStProblem< ELEMENT >::Fluid_mesh_pt
private

Pointer to fluid mesh.

◆ IC_Fct_pt

template<class ELEMENT >
FiniteElement::UnsteadyExactSolutionFctPt OscRingNStProblem< ELEMENT >::IC_Fct_pt
private

Function pointer to set the intial condition.

◆ Sarah_veloc_trace_node_pt

template<class ELEMENT >
Node * OscRingNStProblem< ELEMENT >::Sarah_veloc_trace_node_pt
private

Pointer to node in symmetry plane on coarsest mesh at which velocity is traced

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

◆ Trace_file

template<class ELEMENT >
ofstream OscRingNStProblem< ELEMENT >::Trace_file
private

Trace file.

◆ Veloc_trace_node_pt

template<class ELEMENT >
Node * OscRingNStProblem< ELEMENT >::Veloc_trace_node_pt
private

Pointer to node on coarsest mesh on which velocity is traced.

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

◆ Wall_mesh_pt

template<class ELEMENT >
Mesh * OscRingNStProblem< ELEMENT >::Wall_mesh_pt
private

Pointer to wall mesh (contains only a single GeneralisedElement)

Pointer to wall mesh.

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

◆ Wall_pt

template<class ELEMENT >
GeomObject * OscRingNStProblem< ELEMENT >::Wall_pt
private

Pointer to wall.

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

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