RefineableUnsteadyHeatProblem< ELEMENT > Class Template Reference

Unsteady heat problem in deformable ellipse domain. More...

Inheritance diagram for RefineableUnsteadyHeatProblem< ELEMENT >:

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

Private Member Functions
void	generic_actions_before ()
	Actions before adapt/distribute: Wipe the mesh of prescribed flux elements. More...
void	generic_actions_after ()

Private Attributes
DocInfo	Doc_info
	Doc info object. More...
double	Next_dt
GeomObject *	Boundary_pt
	Pointer to GeomObject that specifies the domain bondary. More...
UnsteadyHeatEquations< 2 >::UnsteadyHeatSourceFctPt	Source_fct_pt
	Pointer to source function. More...
RefineableQuarterCircleSectorMesh< ELEMENT > *	Bulk_mesh_pt
	Pointer to the "bulk" mesh. More...
Mesh *	Surface_mesh_pt
	Pointer to the "surface" mesh. More...
Node *	Doc_node_pt
	Pointer to central node (exists at all refinement levels) for doc. More...
ofstream	Trace_file
	Trace file. More...
double	Epsilon_t
	Target error for adaptive timestepping. More...
bool	Use_ALE
	Flag to use ALE. 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_convergence_check ()
virtual void	actions_before_newton_step ()
virtual void	actions_after_newton_step ()
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)
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 RefineableUnsteadyHeatProblem< ELEMENT >

Unsteady heat problem in deformable ellipse domain.

Unsteady heat problem in quarter circle domain.

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

Constructor & Destructor Documentation

RefineableUnsteadyHeatProblem() [1/5]

template<class ELEMENT >

RefineableUnsteadyHeatProblem< ELEMENT >::RefineableUnsteadyHeatProblem

(

UnsteadyHeatEquations< 2 >::UnsteadyHeatSourceFctPt

source_fct_pt

)

Constructor: Pass pointer to source function and timestep.

Constructor for UnsteadyHeat problem on deformable ellipse domain. Pass pointer to source function.

Constructor for UnsteadyHeat problem in quarter circle domain. Pass pointer to source function.

 : Source_fct_pt(source_fct_pt)
{ 
 
 // Setup labels for output
 //------------------------
 
 // Output directory
 Doc_info.set_directory("RESLT");
 
 // Output number
 Doc_info.number()=0; 
 
 
 // Setup timestepping
 //-------------------
 
 // Allocate the timestepper -- this constructs the time object as well.
 // The boolean flag to the constructor enables adaptivity.
 add_time_stepper_pt(new BDF<2>(true));
 
 // Set target error for adaptive timestepping
 Epsilon_t=1.0e-2;
 
 // Setup parameters for tanh solution
 // ----------------------------------
 
 // Steepness of step
 GlobalParameters::Alpha=10.0;
 
 // Orientation of step
 GlobalParameters::TanPhi=1.0;
 
 // Amplitude for movement of step
 GlobalParameters::Beta=0.3; 
 
 // Parameter for time-dependence of step movement
 GlobalParameters::Gamma=5.0;
 
 // Setup mesh
 //-----------
 
 // Build geometric object that forms the curvilinear domain boundary:
 // an oscillating ellipse
 
 // Half axes
 double a=1.0;
 double b=1.0;
 
 // Variations of half axes
 double a_hat= 0.1; 
 double b_hat=-0.1;
 
 // Period of the oscillation
 double period=1.0;
 
 // Create GeomObject
 Boundary_pt=new MyEllipse(a,b,a_hat,b_hat,period,Problem::time_pt()); 
 
 // Now build the mesh
 build_mesh();
 
 // Do equation numbering
 oomph_info <<"Number of equations: " << assign_eqn_numbers() << std::endl; 
 
} // end of constructor

References a, oomph::Problem::add_time_stepper_pt(), GlobalParameters::Alpha, oomph::Problem::assign_eqn_numbers(), b, GlobalParameters::Beta, RefineableUnsteadyHeatProblem< ELEMENT >::Boundary_pt, RefineableUnsteadyHeatProblem< ELEMENT >::build_mesh(), RefineableUnsteadyHeatProblem< ELEMENT >::Doc_info, RefineableUnsteadyHeatProblem< ELEMENT >::Epsilon_t, GlobalParameters::Gamma, oomph::DocInfo::number(), oomph::oomph_info, oomph::DocInfo::set_directory(), and GlobalParameters::TanPhi.

~RefineableUnsteadyHeatProblem() [1/5]

template<class ELEMENT >

RefineableUnsteadyHeatProblem< ELEMENT >::~RefineableUnsteadyHeatProblem

Destructor: Close trace file.

{ 
 
 // Close trace file
 Trace_file.close();
 
} // end of destructor

References oomph::Problem_Parameter::Trace_file.

RefineableUnsteadyHeatProblem() [2/5]

template<class ELEMENT >

RefineableUnsteadyHeatProblem< ELEMENT >::RefineableUnsteadyHeatProblem	(	UnsteadyHeatEquations< 2 >::UnsteadyHeatSourceFctPt	source_fct_pt,
		const bool &	use_ale
	)

Constructor: Pass pointer to source function and flag to use ALE.

Constructor for UnsteadyHeat problem in quarter circle domain. Pass pointer to source function and flag to use ALE.

                        : 
 Source_fct_pt(source_fct_pt), Use_ALE(use_ale)
{ 
 
 
 // Setup labels for output
 //------------------------
 // Output directory
 if (!use_ale)
  {
   Doc_info.set_directory("RESLT_adapt");
  }
 else
  {
   Doc_info.set_directory("RESLT_adapt_ALE");
  }
 
 // Output number
 Doc_info.number()=0; 
 
 // Open trace file
 char filename[100];   
 sprintf(filename,"%s/trace.dat",Doc_info.directory().c_str());
 Trace_file.open(filename);
 
 Trace_file << "VARIABLES=\"time t\",\"u<SUB>FE</SUB>\",\"u<SUB>exact</SUB>\","
            << "\"A\","
            << "\"X<SUB>step</SUB>\","
            << "\"N<SUB>element</SUB>\","
            << "\"N<SUB>refined</SUB>\","
            << "\"N<SUB>unrefined</SUB>\","
            << "\"norm of error\","
            << "\"norm of solution\""
            << std::endl;
 
 
 // Setup parameters for tanh solution
 // ----------------------------------
 
 // Steepness of step
 TanhSolnForUnsteadyHeat::Alpha=10.0;
 
 // Orientation of step
 TanhSolnForUnsteadyHeat::TanPhi=1.0;
 
 // Amplitude for movement of step
 TanhSolnForUnsteadyHeat::Beta=0.3; 
 
 // Parameter for time-dependence of step movement
 TanhSolnForUnsteadyHeat::Gamma=5.0;
 
 
 //Allocate the timestepper -- This constructs the time object as well
 add_time_stepper_pt(new BDF<2>());
 
 // Setup mesh
 //-----------
 
 // Build geometric object that forms the curvilinear domain boundary:
 // a unit circle 
 
 // Create GeomObject
 Boundary_pt=new MyUnitCircle;
 
 // Start and end coordinates of curvilinear domain boundary on circle
 double xi_lo=0.0;
 double xi_hi=MathematicalConstants::Pi/2.0;
 
 // Now create the bulk mesh. Separating line between the two 
 // elements next to the curvilinear boundary is located half-way
 // along the boundary.
 double fract_mid=0.5;
 Bulk_mesh_pt = new RefineableQuarterCircleSectorMesh<ELEMENT>(
  Boundary_pt,xi_lo,fract_mid,xi_hi,time_stepper_pt());
 
 // Create the surface mesh as an empty mesh
 Surface_mesh_pt=new Mesh;
 
 // Create prescribed-flux elements from all elements that are 
 // adjacent to boundary 0 (the horizontal lower boundary), and add them 
 // to the (so far empty) surface mesh.
 create_flux_elements(0,Bulk_mesh_pt,Surface_mesh_pt);
 
 // Add the two sub meshes to the problem
 add_sub_mesh(Bulk_mesh_pt);
 add_sub_mesh(Surface_mesh_pt);
 
 // Combine all submeshes into a single global Mesh
 build_global_mesh();
 
 // Set error estimator for bulk mesh
 Z2ErrorEstimator* error_estimator_pt=new Z2ErrorEstimator;
 Bulk_mesh_pt->spatial_error_estimator_pt()=error_estimator_pt;
 
 // Set the boundary conditions for this problem: All nodes are
 // free by default -- just pin the ones that have Dirichlet conditions
 // here. 
 unsigned n_bound = Bulk_mesh_pt->nboundary();
 for(unsigned b=0;b<n_bound;b++)
  {
   // Leave nodes on boundary 0 free -- this is where we apply the flux
   // boundary condition
   if (b!=0)
    {
     unsigned n_node = Bulk_mesh_pt->nboundary_node(b);
     for (unsigned n=0;n<n_node;n++)
      {
       Bulk_mesh_pt->boundary_node_pt(b,n)->pin(0); 
      }
    }
  }
 
 // Extract pointer to the central node (this exists at all refinement levels)
 // for doc of solution
 FiniteElement* el0_pt=Bulk_mesh_pt->finite_element_pt(0);
 unsigned nnod=el0_pt->nnode();
 Doc_node_pt=el0_pt->node_pt(nnod-1);
 
 
 // Complete the build of all elements so they are fully functional
 //----------------------------------------------------------------
 
 // Find number of elements in mesh
 unsigned n_element = Bulk_mesh_pt->nelement();
 
 // Loop over the elements to set up element-specific 
 // things that cannot be handled by constructor
 for(unsigned i=0;i<n_element;i++)
  {
   // Upcast from FiniteElement to the present element
   ELEMENT *el_pt = dynamic_cast<ELEMENT*>(Bulk_mesh_pt->element_pt(i));
 
   //Set the source function pointer
   el_pt->source_fct_pt() = Source_fct_pt;
  }
 
 // Loop over the flux elements to pass pointer to prescribed flux function
 n_element=Surface_mesh_pt->nelement();
 for(unsigned e=0;e<n_element;e++)
  {
   // Upcast from GeneralisedElement to UnsteadyHeat flux element
   UnsteadyHeatFluxElement<ELEMENT> *el_pt = 
    dynamic_cast<UnsteadyHeatFluxElement<ELEMENT>*>(
     Surface_mesh_pt->element_pt(e));
 
   // Set the pointer to the prescribed flux function
   el_pt->flux_fct_pt() = 
    &TanhSolnForUnsteadyHeat::prescribed_flux_on_fixed_y_boundary;
  }
 
 
 // Switch off ALE if required
 possibly_disable_ALE();
 
 // Do equation numbering
 cout <<"Number of equations: " << assign_eqn_numbers() << std::endl; 
 
} // end of constructor

References oomph::Problem::add_sub_mesh(), oomph::Problem::add_time_stepper_pt(), TanhSolnForUnsteadyHeat::Alpha, oomph::Problem::assign_eqn_numbers(), b, TanhSolnForUnsteadyHeat::Beta, RefineableUnsteadyHeatProblem< ELEMENT >::Boundary_pt, oomph::Problem::build_global_mesh(), RefineableUnsteadyHeatProblem< ELEMENT >::Bulk_mesh_pt, RefineableUnsteadyHeatProblem< ELEMENT >::create_flux_elements(), oomph::DocInfo::directory(), RefineableUnsteadyHeatProblem< ELEMENT >::Doc_info, RefineableUnsteadyHeatProblem< ELEMENT >::Doc_node_pt, e(), oomph::Mesh::element_pt(), MeshRefinement::error_estimator_pt, MergeRestartFiles::filename, oomph::UnsteadyHeatFluxElement< ELEMENT >::flux_fct_pt(), TanhSolnForUnsteadyHeat::Gamma, i, n, oomph::Mesh::nelement(), oomph::FiniteElement::nnode(), oomph::FiniteElement::node_pt(), oomph::DocInfo::number(), BiharmonicTestFunctions2::Pi, RefineableUnsteadyHeatProblem< ELEMENT >::possibly_disable_ALE(), TanhSolnForUnsteadyHeat::prescribed_flux_on_fixed_y_boundary(), oomph::DocInfo::set_directory(), RefineableUnsteadyHeatProblem< ELEMENT >::Source_fct_pt, RefineableUnsteadyHeatProblem< ELEMENT >::Surface_mesh_pt, TanhSolnForUnsteadyHeat::TanPhi, oomph::Problem::time_stepper_pt(), and RefineableUnsteadyHeatProblem< ELEMENT >::Trace_file.

~RefineableUnsteadyHeatProblem() [2/5]

template<class ELEMENT >

RefineableUnsteadyHeatProblem< ELEMENT >::~RefineableUnsteadyHeatProblem

(

)

Destructor: Close trace file.

RefineableUnsteadyHeatProblem() [3/5]

template<class ELEMENT >

RefineableUnsteadyHeatProblem< ELEMENT >::RefineableUnsteadyHeatProblem

(

UnsteadyHeatEquations< 2 >::UnsteadyHeatSourceFctPt

source_fct_pt

)

Constructor: Pass pointer to source function and timestep.

~RefineableUnsteadyHeatProblem() [3/5]

template<class ELEMENT >

RefineableUnsteadyHeatProblem< ELEMENT >::~RefineableUnsteadyHeatProblem

(

)

Destructor: Close trace file.

RefineableUnsteadyHeatProblem() [4/5]

template<class ELEMENT >

RefineableUnsteadyHeatProblem< ELEMENT >::RefineableUnsteadyHeatProblem

(

UnsteadyHeatEquations< 2 >::UnsteadyHeatSourceFctPt

source_fct_pt

)

Constructor: Pass pointer to source function.

~RefineableUnsteadyHeatProblem() [4/5]

template<class ELEMENT >

RefineableUnsteadyHeatProblem< ELEMENT >::~RefineableUnsteadyHeatProblem

(

)

Destructor: Close trace file.

RefineableUnsteadyHeatProblem() [5/5]

template<class ELEMENT >

RefineableUnsteadyHeatProblem< ELEMENT >::RefineableUnsteadyHeatProblem

(

UnsteadyHeatEquations< 2 >::UnsteadyHeatSourceFctPt

source_fct_pt

)

Constructor: Pass pointer to source function.

~RefineableUnsteadyHeatProblem() [5/5]

template<class ELEMENT >

RefineableUnsteadyHeatProblem< ELEMENT >::~RefineableUnsteadyHeatProblem

(

)

Destructor: Close trace file.

Member Function Documentation

actions_after_adapt() [1/5]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::actions_after_adapt

inlinevirtual

Actions after adapt: Rebuild the mesh of prescribed flux elements.

Reimplemented from oomph::Problem.

  {
   generic_actions_after();
  }

actions_after_adapt() [2/5]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::actions_after_adapt ( )

virtual

Actions after adapt: Rebuild the mesh of prescribed flux elements.

Reimplemented from oomph::Problem.

actions_after_adapt() [3/5]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::actions_after_adapt ( )

virtual

Actions after adapt: Rebuild the mesh of prescribed flux elements.

Reimplemented from oomph::Problem.

actions_after_adapt() [4/5]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::actions_after_adapt ( )

virtual

Actions after adapt: Rebuild the mesh of prescribed flux elements.

Reimplemented from oomph::Problem.

actions_after_adapt() [5/5]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::actions_after_adapt ( )

virtual

Actions after adapt: Rebuild the mesh of prescribed flux elements.

Reimplemented from oomph::Problem.

actions_after_distribute()

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::actions_after_distribute ( )

inline

Actions after distribute: Rebuild the mesh of prescribed flux elements.

  {
   generic_actions_after();
  }

actions_after_implicit_timestep() [1/5]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::actions_after_implicit_timestep ( )

inlinevirtual

Update the problem specs after timestep (empty)

Reimplemented from oomph::Problem.

{}

actions_after_implicit_timestep() [2/5]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::actions_after_implicit_timestep ( )

inlinevirtual

Update the problem specs after timestep (empty)

Reimplemented from oomph::Problem.

{}

actions_after_implicit_timestep() [3/5]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::actions_after_implicit_timestep ( )

inlinevirtual

Update the problem specs after timestep (empty)

Reimplemented from oomph::Problem.

{}

actions_after_implicit_timestep() [4/5]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::actions_after_implicit_timestep ( )

inlinevirtual

Update the problem specs after timestep (empty)

Reimplemented from oomph::Problem.

{}

actions_after_implicit_timestep() [5/5]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::actions_after_implicit_timestep ( )

inlinevirtual

Update the problem specs after timestep (empty)

Reimplemented from oomph::Problem.

{}

actions_after_newton_solve() [1/5]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::actions_after_newton_solve ( )

inlinevirtual

Update the problem specs after solve (empty)

Reimplemented from oomph::Problem.

{}

actions_after_newton_solve() [2/5]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::actions_after_newton_solve ( )

inlinevirtual

Update the problem specs after solve (empty)

Reimplemented from oomph::Problem.

{}

actions_after_newton_solve() [3/5]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::actions_after_newton_solve ( )

inlinevirtual

Update the problem specs after solve (empty)

Reimplemented from oomph::Problem.

{}

actions_after_newton_solve() [4/5]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::actions_after_newton_solve ( )

inlinevirtual

Update the problem specs after solve (empty)

Reimplemented from oomph::Problem.

{}

actions_after_newton_solve() [5/5]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::actions_after_newton_solve ( )

inlinevirtual

Update the problem specs after solve (empty)

Reimplemented from oomph::Problem.

{}

actions_before_adapt() [1/5]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::actions_before_adapt

inlinevirtual

Actions before adapt: Wipe the mesh of prescribed flux elements.

Reimplemented from oomph::Problem.

  {
   generic_actions_before();
  }

actions_before_adapt() [2/5]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::actions_before_adapt ( )

virtual

Actions before adapt: Wipe the mesh of prescribed flux elements.

Reimplemented from oomph::Problem.

actions_before_adapt() [3/5]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::actions_before_adapt ( )

virtual

Actions before adapt: Wipe the mesh of prescribed flux elements.

Reimplemented from oomph::Problem.

actions_before_adapt() [4/5]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::actions_before_adapt ( )

virtual

Actions before adapt: Wipe the mesh of prescribed flux elements.

Reimplemented from oomph::Problem.

actions_before_adapt() [5/5]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::actions_before_adapt ( )

virtual

Actions before adapt: Wipe the mesh of prescribed flux elements.

Reimplemented from oomph::Problem.

actions_before_distribute()

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::actions_before_distribute ( )

inline

Actions before distribute: Wipe the mesh of prescribed flux elements.

  {
   generic_actions_before();
  }

actions_before_implicit_timestep() [1/5]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::actions_before_implicit_timestep

virtual

Update the problem specs before next timestep: Set Dirchlet boundary conditions from exact solution.

Actions before timestep: Update the domain shape, then set the boundary conditions for the current time.

Actions before timestep: Set the boundary conditions for the current time.

Reimplemented from oomph::Problem.

{
 // Update the domain shape
 Bulk_mesh_pt->node_update();
 
 // Get current time
 double time=time_pt()->time();
 
 //Loop over all boundaries
 unsigned num_bound = Bulk_mesh_pt->nboundary();
 for(unsigned b=0;b<num_bound;b++)
  {
   // Exclude flux boundary
   if (b!=0)
    {
     // Loop over the nodes on boundary
     unsigned num_nod=Bulk_mesh_pt->nboundary_node(b);
     for (unsigned j=0;j<num_nod;j++)
      {
       Node* nod_pt=Bulk_mesh_pt->boundary_node_pt(b,j);
       double u;
       Vector<double> x(2);
       x[0]=nod_pt->x(0);
       x[1]=nod_pt->x(1);
       GlobalParameters::get_exact_u(time,x,u);
       nod_pt->set_value(0,u);
      }
    }
  }
} // end of actions_before_implicit_timestep

References b, GlobalParameters::get_exact_u(), j, oomph::Data::set_value(), plotDoE::x, and oomph::Node::x().

actions_before_implicit_timestep() [2/5]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::actions_before_implicit_timestep ( )

virtual

Update the problem specs before next timestep: Set Dirchlet boundary conditions from exact solution.

Reimplemented from oomph::Problem.

actions_before_implicit_timestep() [3/5]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::actions_before_implicit_timestep ( )

virtual

Update the problem specs before next timestep: Set Dirchlet boundary conditions from exact solution.

Reimplemented from oomph::Problem.

actions_before_implicit_timestep() [4/5]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::actions_before_implicit_timestep ( )

virtual

Update the problem specs before next timestep: Set Dirchlet boundary conditions from exact solution.

Reimplemented from oomph::Problem.

actions_before_implicit_timestep() [5/5]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::actions_before_implicit_timestep ( )

virtual

Update the problem specs before next timestep: Set Dirchlet boundary conditions from exact solution.

Reimplemented from oomph::Problem.

actions_before_newton_solve() [1/5]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::actions_before_newton_solve ( )

inlinevirtual

Update the problem specs before solve (empty)

Reimplemented from oomph::Problem.

{}

actions_before_newton_solve() [2/5]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::actions_before_newton_solve ( )

inlinevirtual

Update the problem specs before solve (empty)

Reimplemented from oomph::Problem.

{}

actions_before_newton_solve() [3/5]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::actions_before_newton_solve ( )

inlinevirtual

Update the problem specs before solve (empty)

Reimplemented from oomph::Problem.

{}

actions_before_newton_solve() [4/5]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::actions_before_newton_solve ( )

inlinevirtual

Update the problem specs before solve (empty)

Reimplemented from oomph::Problem.

{}

actions_before_newton_solve() [5/5]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::actions_before_newton_solve ( )

inlinevirtual

Update the problem specs before solve (empty)

Reimplemented from oomph::Problem.

{}

build_mesh()

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::build_mesh

Build mesh function.

Build meshes (helper fct accessed from constructor and from the load balancing routines)

{ 
 
 // Start and end coordinates of curvilinear domain boundary on ellipse
 double xi_lo=0.0;
 double xi_hi=MathematicalConstants::Pi/2.0;
 
 // Now create the bulk mesh. Separating line between the two 
 // elements next to the curvilinear boundary is located half-way
 // along the boundary.
 double fract_mid=0.5;
 Bulk_mesh_pt = new RefineableQuarterCircleSectorMesh<ELEMENT>(
  Boundary_pt,xi_lo,fract_mid,xi_hi,time_stepper_pt());
 
 // Note: Mesh is completely rebuilt in here
 // so target errors etc need to be reassigned
 
 // Set targets for spatial adaptivity
 Bulk_mesh_pt->max_permitted_error()=0.001;
 Bulk_mesh_pt->min_permitted_error()=0.0001;
 
 // Need to do this in build_mesh() because it's supposed to
 // get the problem into the state it was when it was distributed.
 Bulk_mesh_pt->refine_uniformly();
 Bulk_mesh_pt->refine_uniformly();
 
 // Create the surface mesh as an empty mesh
 Surface_mesh_pt=new Mesh;
 
 // Create prescribed-flux elements from all elements that are 
 // adjacent to boundary 0 (the horizontal lower boundary), and add them 
 // to the (so far empty) surface mesh.
 create_flux_elements(0,Bulk_mesh_pt,Surface_mesh_pt);
 
 // Add the two sub meshes to the problem
 add_sub_mesh(Bulk_mesh_pt);
 add_sub_mesh(Surface_mesh_pt);
 
 // Combine all submeshes into a single global Mesh
 build_global_mesh();
 
 // Set error estimator for bulk mesh
 Z2ErrorEstimator* error_estimator_pt=new Z2ErrorEstimator;
 Bulk_mesh_pt->spatial_error_estimator_pt()=error_estimator_pt;
 
 // Set the boundary conditions for this problem: All nodes are
 // free by default -- just pin the ones that have Dirichlet conditions
 // here. 
 unsigned n_bound = Bulk_mesh_pt->nboundary();
 for(unsigned b=0;b<n_bound;b++)
  {
   // Leave nodes on boundary 0 free -- this is where we apply the flux
   // boundary condition
   if (b!=0)
    {
     unsigned n_node = Bulk_mesh_pt->nboundary_node(b);
     for (unsigned n=0;n<n_node;n++)
      {
       Bulk_mesh_pt->boundary_node_pt(b,n)->pin(0); 
      }
    }
  }
 
 // Extract pointer to the central node (this exists at all refinement levels)
 // for doc of solution
 FiniteElement* el0_pt=Bulk_mesh_pt->finite_element_pt(0);
 unsigned nnod=el0_pt->nnode();
 Doc_node_pt=el0_pt->node_pt(nnod-1);
 
 // In parallel make sure that we retain this element on all processors
 // so the node remains accessible for post-processing
 el0_pt->must_be_kept_as_halo();
 
 // Complete the build of all elements so they are fully functional
 //----------------------------------------------------------------
 
 // Find number of elements in mesh
 unsigned n_element = Bulk_mesh_pt->nelement();
 
 // Loop over the elements to set up element-specific 
 // things that cannot be handled by constructor
 for(unsigned i=0;i<n_element;i++)
  {
   // Upcast from FiniteElement to the present element
   ELEMENT *el_pt = dynamic_cast<ELEMENT*>(Bulk_mesh_pt->element_pt(i));
 
   //Set the source function pointer
   el_pt->source_fct_pt() = Source_fct_pt;
  }
 
 
 // Loop over the flux elements to pass pointer to prescribed flux function
 n_element=Surface_mesh_pt->nelement();
 for(unsigned e=0;e<n_element;e++)
  {
   // Upcast from GeneralisedElement to UnsteadyHeat flux element
   UnsteadyHeatFluxElement<ELEMENT> *el_pt = 
    dynamic_cast<UnsteadyHeatFluxElement<ELEMENT>*>(
     Surface_mesh_pt->element_pt(e));
 
   // Set the pointer to the prescribed flux function
   el_pt->flux_fct_pt() = 
    &GlobalParameters::prescribed_flux_on_fixed_y_boundary;
  }
 
} // end of build_mesh

References b, e(), MeshRefinement::error_estimator_pt, oomph::UnsteadyHeatFluxElement< ELEMENT >::flux_fct_pt(), i, n, oomph::FiniteElement::nnode(), oomph::FiniteElement::node_pt(), BiharmonicTestFunctions2::Pi, GlobalParameters::prescribed_flux_on_fixed_y_boundary(), and oomph::Source_fct_pt.

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

bulk_mesh_pt() [1/5]

template<class ELEMENT >

RefineableQuarterCircleSectorMesh<ELEMENT>* RefineableUnsteadyHeatProblem< ELEMENT >::bulk_mesh_pt ( )

inline

Pointer to bulk mesh.

  {
   return Bulk_mesh_pt;
  }

bulk_mesh_pt() [2/5]

template<class ELEMENT >

RefineableQuarterCircleSectorMesh<ELEMENT>* RefineableUnsteadyHeatProblem< ELEMENT >::bulk_mesh_pt ( )

inline

Pointer to bulk mesh.

  {
   return Bulk_mesh_pt;
  }

bulk_mesh_pt() [3/5]

template<class ELEMENT >

RefineableQuarterCircleSectorMesh<ELEMENT>* RefineableUnsteadyHeatProblem< ELEMENT >::bulk_mesh_pt ( )

inline

Pointer to bulk mesh.

  {
   return Bulk_mesh_pt;
  }

bulk_mesh_pt() [4/5]

template<class ELEMENT >

RefineableQuarterCircleSectorMesh<ELEMENT>* RefineableUnsteadyHeatProblem< ELEMENT >::bulk_mesh_pt ( )

inline

Pointer to bulk mesh.

  {
   return Bulk_mesh_pt;
  }

bulk_mesh_pt() [5/5]

template<class ELEMENT >

RefineableQuarterCircleSectorMesh<ELEMENT>* RefineableUnsteadyHeatProblem< ELEMENT >::bulk_mesh_pt ( )

inline

Pointer to bulk mesh.

  {
   return Bulk_mesh_pt;
  }

create_flux_elements() [1/5]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::create_flux_elements	(	const unsigned &	b,
		Mesh *const &	bulk_mesh_pt,
		Mesh *const &	surface_mesh_pt
	)

Create UnsteadyHeat 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 UnsteadyHeat 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 pointed to by surface_mesh_pt.

{
 // How many bulk elements are adjacent to boundary b?
 unsigned n_element = bulk_mesh_pt->nboundary_element(b);
 
 // Loop over the bulk elements adjacent to boundary b?
 for(unsigned e=0;e<n_element;e++)
  {
   // Get pointer to the bulk element that is adjacent to boundary b
   ELEMENT* bulk_elem_pt = dynamic_cast<ELEMENT*>(
    bulk_mesh_pt->boundary_element_pt(b,e));
   
   //What is the face index of element e on boundary b
   int face_index = bulk_mesh_pt->face_index_at_boundary(b,e);
 
   // Build the corresponding prescribed-flux element
   UnsteadyHeatFluxElement<ELEMENT>* flux_element_pt = new 
   UnsteadyHeatFluxElement<ELEMENT>(bulk_elem_pt,face_index);
 
   //Add the prescribed-flux element to the surface mesh
   surface_mesh_pt->add_element_pt(flux_element_pt);
 
  } //end of loop over bulk elements adjacent to boundary b
 
} // end of create_flux_elements

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 RefineableUnsteadyHeatProblem< ELEMENT >::RefineableUnsteadyHeatProblem().

create_flux_elements() [2/5]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::create_flux_elements	(	const unsigned &	b,
		Mesh *const &	bulk_mesh_pt,
		Mesh *const &	surface_mesh_pt
	)

Create UnsteadyHeat 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_flux_elements() [3/5]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::create_flux_elements	(	const unsigned &	b,
		Mesh *const &	bulk_mesh_pt,
		Mesh *const &	surface_mesh_pt
	)

Create UnsteadyHeat 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_flux_elements() [4/5]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::create_flux_elements	(	const unsigned &	b,
		Mesh *const &	bulk_mesh_pt,
		Mesh *const &	surface_mesh_pt
	)

Create UnsteadyHeat 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_flux_elements() [5/5]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::create_flux_elements	(	const unsigned &	b,
		Mesh *const &	bulk_mesh_pt,
		Mesh *const &	surface_mesh_pt
	)

Create UnsteadyHeat 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

delete_flux_elements() [1/5]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::delete_flux_elements

(

Mesh *const &

surface_mesh_pt

)

Delete UnsteadyHeat flux elements and wipe the surface mesh.

Delete UnsteadyHeat Flux Elements and wipe the surface mesh.

{
 // How many surface elements are in the surface mesh
 unsigned n_element = surface_mesh_pt->nelement();
 
 // Loop over the surface elements
 for(unsigned e=0;e<n_element;e++)
  {
   // Kill surface element
   delete surface_mesh_pt->element_pt(e);
  }
 
 // Wipe the mesh
 surface_mesh_pt->flush_element_and_node_storage();
 
} // end of delete_flux_elements

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

delete_flux_elements() [2/5]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::delete_flux_elements

(

Mesh *const &

surface_mesh_pt

)

Delete UnsteadyHeat flux elements and wipe the surface mesh.

delete_flux_elements() [3/5]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::delete_flux_elements

(

Mesh *const &

surface_mesh_pt

)

Delete UnsteadyHeat flux elements and wipe the surface mesh.

delete_flux_elements() [4/5]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::delete_flux_elements

(

Mesh *const &

surface_mesh_pt

)

Delete UnsteadyHeat flux elements and wipe the surface mesh.

delete_flux_elements() [5/5]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::delete_flux_elements

(

Mesh *const &

surface_mesh_pt

)

Delete UnsteadyHeat flux elements and wipe the surface mesh.

doc_info()

template<class ELEMENT >

DocInfo& RefineableUnsteadyHeatProblem< ELEMENT >::doc_info ( )

inline

Return DocInfo object.

{return Doc_info;}

References GlobalParameters::Doc_info.

doc_solution() [1/5]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::doc_solution

Doc the solution.

{ 
 ofstream some_file;
 char filename[100];
 
 // Number of plot points
 unsigned npts;
 npts=5;
 
 cout << std::endl;
 cout << "=================================================" << std::endl;
 cout << "Docing solution for t=" << time_pt()->time() << std::endl;
 cout << "=================================================" << std::endl;
 
 // Output solution 
 //-----------------
 sprintf(filename,"%s/soln%i.dat",Doc_info.directory().c_str(),
         Doc_info.number());
 some_file.open(filename);
 Bulk_mesh_pt->output(some_file,npts);
 some_file << "TEXT X=2.5,Y=93.6,F=HELV,HU=POINT,C=BLUE,H=26,T=\"time = " 
           << time_pt()->time() << "\"";
 some_file << "GEOMETRY X=2.5,Y=98,T=LINE,C=BLUE,LT=0.4" << std::endl;
 some_file << "1" << std::endl;
 some_file << "2" << std::endl;
 some_file << " 0 0" << std::endl;
 some_file << time_pt()->time()*20.0 << " 0" << std::endl;
 
 // Write dummy zones
 some_file << "ZONE I=2,J=2" << std::endl;
 some_file << "0.0 0.0 -1.2" << std::endl;
 some_file << "1.3 0.0 -1.2" << std::endl;
 some_file << "0.0 1.3 -1.2" << std::endl;
 some_file << "1.3 1.3 -1.2" << std::endl;
 some_file << "ZONE I=2,J=2" << std::endl;
 some_file << "0.0 0.0 1.2" << std::endl;
 some_file << "1.3 0.0 1.2" << std::endl;
 some_file << "0.0 1.3 1.2" << std::endl;
 some_file << "1.3 1.3 1.2" << std::endl;
 
 some_file.close();
 
 
 // Output exact solution 
 //----------------------
 sprintf(filename,"%s/exact_soln%i.dat",Doc_info.directory().c_str(),
         Doc_info.number());
 some_file.open(filename);
 Bulk_mesh_pt->output_fct(some_file,npts,time_pt()->time(),
                       TanhSolnForUnsteadyHeat::get_exact_u); 
 
 // Write dummy zones
 some_file << "ZONE I=2,J=2" << std::endl;
 some_file << "0.0 0.0 -1.2" << std::endl;
 some_file << "1.3 0.0 -1.2" << std::endl;
 some_file << "0.0 1.3 -1.2" << std::endl;
 some_file << "1.3 1.3 -1.2" << std::endl;
 some_file << "ZONE I=2,J=2" << std::endl;
 some_file << "0.0 0.0 1.2" << std::endl;
 some_file << "1.3 0.0 1.2" << std::endl;
 some_file << "0.0 1.3 1.2" << std::endl;
 some_file << "1.3 1.3 1.2" << std::endl;
 
 some_file.close();
 
 
 // Doc error
 //----------
 double error,norm;
 sprintf(filename,"%s/error%i.dat",Doc_info.directory().c_str(),
         Doc_info.number());
 some_file.open(filename);
 Bulk_mesh_pt->compute_error(some_file,
                          TanhSolnForUnsteadyHeat::get_exact_u,
                          time_pt()->time(),
                          error,norm); 
 some_file.close();
 
 
 
 // Doc error and write trace file
 //--------------------------------
 cout << "error: " << error << std::endl; 
 cout << "norm : " << norm << std::endl << std::endl;
 
 Vector<double> x(2);
 x[0]=Doc_node_pt->x(0);
 x[1]=Doc_node_pt->x(1);
 double u_exact;
 TanhSolnForUnsteadyHeat::get_exact_u(time_pt()->time(),x,u_exact);
 Vector<double > xi_wall(1);
 Vector<double > r_wall(2);
 xi_wall[0]=0.0;
 Boundary_pt->position(xi_wall,r_wall);
 Trace_file << time_pt()->time() 
            << " " << Doc_node_pt->value(0)
            << " " << u_exact
            << " " << r_wall[0]
            << " " << TanhSolnForUnsteadyHeat::step_position(time_pt()->time())
            << " " << Bulk_mesh_pt->nelement() 
            << " " << Bulk_mesh_pt->nrefined()
            << " " << Bulk_mesh_pt->nunrefined() 
            << " " << error 
            << " " << norm << std::endl;
 
 // Plot wall posn
 //---------------
 sprintf(filename,"%s/Wall%i.dat",Doc_info.directory().c_str(),
         Doc_info.number());
 some_file.open(filename);
 
 unsigned nplot=100;
 for (unsigned iplot=0;iplot<nplot;iplot++)
  {
   xi_wall[0]=0.5*Pi*double(iplot)/double(nplot-1);
   Boundary_pt->position(xi_wall,r_wall);
   some_file << r_wall[0] << " " << r_wall[1] << std::endl;
  }
 some_file.close();
 
 // Write restart file
 sprintf(filename,"%s/restart%i.dat",Doc_info.directory().c_str(),
         Doc_info.number());
 some_file.open(filename);
 dump_it(some_file);
 some_file.close();
 
 // Increment number of doc
 Doc_info.number()++;
 
 
} // end of doc_solution

References oomph::DocInfo::directory(), GlobalParameters::Doc_info, calibrate::error, MergeRestartFiles::filename, TanhSolnForUnsteadyHeat::get_exact_u(), oomph::DocInfo::number(), BiharmonicTestFunctions2::Pi, TanhSolnForUnsteadyHeat::step_position(), oomph::Problem_Parameter::Trace_file, and plotDoE::x.

doc_solution() [2/5]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::doc_solution

(

)

Doc the solution.

doc_solution() [3/5]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::doc_solution

(

)

Doc the solution.

doc_solution() [4/5]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::doc_solution

(

)

Doc the solution.

doc_solution() [5/5]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::doc_solution

(

const std::string &

comment = ""

)

Doc the solution.

{ 
 ofstream some_file;
 char filename[100];
 
 // Number of plot points
 unsigned npts;
 npts=5;
 
 oomph_info << std::endl;
 oomph_info << "=================================================" 
            << std::endl;
 oomph_info << "Docing solution " << Doc_info.number() << " for t=" 
      << time_pt()->time() << " [ndof=" << ndof() << "]\n";
 oomph_info << "=================================================" 
            << std::endl;
 
 // Doc halo schemes 
 //-----------------
 Bulk_mesh_pt->doc_mesh_distribution(Doc_info);
 
 // Output solution 
 //-----------------
 sprintf(filename,"%s/soln%i_on_proc%i.dat",Doc_info.directory().c_str(),
         Doc_info.number(),this->communicator_pt()->my_rank());
 some_file.open(filename);
 Bulk_mesh_pt->output(some_file,npts);
 some_file << "TEXT X=2.5,Y=93.6,F=HELV,HU=POINT,C=BLUE,H=26,T=\"time = " 
           << time_pt()->time() << "; "<< comment << "\"";
 some_file << "GEOMETRY X=2.5,Y=98,T=LINE,C=BLUE,LT=0.4" << std::endl;
 some_file << "1" << std::endl;
 some_file << "2" << std::endl;
 some_file << " 0 0" << std::endl;
 some_file << time_pt()->time()*20.0 << " 0" << std::endl;
 
 // Write dummy zones
 some_file << "ZONE I=2,J=2" << std::endl;
 some_file << "0.0 0.0 -1.2" << std::endl;
 some_file << "1.3 0.0 -1.2" << std::endl;
 some_file << "0.0 1.3 -1.2" << std::endl;
 some_file << "1.3 1.3 -1.2" << std::endl;
 some_file << "ZONE I=2,J=2" << std::endl;
 some_file << "0.0 0.0 1.2" << std::endl;
 some_file << "1.3 0.0 1.2" << std::endl;
 some_file << "0.0 1.3 1.2" << std::endl;
 some_file << "1.3 1.3 1.2" << std::endl;
 
 some_file.close();
 
 
 // Output exact solution 
 //----------------------
 sprintf(filename,"%s/exact_soln%i_on_proc%i.dat",Doc_info.directory().c_str(),
         Doc_info.number(),this->communicator_pt()->my_rank());
 some_file.open(filename);
 Bulk_mesh_pt->output_fct(some_file,npts,time_pt()->time(),
                       GlobalParameters::get_exact_u); 
 
 // Write dummy zones
 some_file << "ZONE I=2,J=2" << std::endl;
 some_file << "0.0 0.0 -1.2" << std::endl;
 some_file << "1.3 0.0 -1.2" << std::endl;
 some_file << "0.0 1.3 -1.2" << std::endl;
 some_file << "1.3 1.3 -1.2" << std::endl;
 some_file << "ZONE I=2,J=2" << std::endl;
 some_file << "0.0 0.0 1.2" << std::endl;
 some_file << "1.3 0.0 1.2" << std::endl;
 some_file << "0.0 1.3 1.2" << std::endl;
 some_file << "1.3 1.3 1.2" << std::endl;
 
 some_file.close();
 
 
 // Doc error
 //----------
 double error,norm;
 
 sprintf(filename,"%s/error%i_on_proc%i.dat",Doc_info.directory().c_str(),
         Doc_info.number(),this->communicator_pt()->my_rank());
 some_file.open(filename);
 Bulk_mesh_pt->compute_error(some_file,
                          GlobalParameters::get_exact_u,
                          time_pt()->time(),
                          error,norm); 
 some_file.close();
 
 
 // Collect error and norm from all processors
 Vector<double> local_stuff(2);
 local_stuff[0]=error;
 local_stuff[1]=norm;
 Vector<double> global_stuff(2);
#ifdef OOMPH_HAS_MPI
 MPI_Allreduce(&local_stuff[0],&global_stuff[0],2,MPI_DOUBLE,MPI_SUM,
               communicator_pt()->mpi_comm());
#else
 global_stuff[0]=error;
 global_stuff[1]=norm;
#endif
 
 // Doc solution and error
 //-----------------------
 oomph_info << "error: " << global_stuff[0] << std::endl; 
 oomph_info << "norm : " << global_stuff[1] << std::endl << std::endl;
 
 // Get global error norm (on all processors as it involves comms)
 double temp_error_norm=global_temporal_error_norm();
 
 // Gather refinement stats
 Vector<int> ref_stats(3);
 ref_stats[0]=Bulk_mesh_pt->nnon_halo_element();
 ref_stats[1]=Bulk_mesh_pt->nrefined();
 ref_stats[2]=Bulk_mesh_pt->nunrefined();
 Vector<int> global_ref_stats(3);
 MPI_Allreduce(&ref_stats[0],&global_ref_stats[0],3,MPI_INT,MPI_SUM,
               communicator_pt()->mpi_comm());
 
 // Write trace file on root only
 if (Communicator_pt->my_rank()==0)
  {
   Vector<double> x(2,0.0);
   double u_exact;
   GlobalParameters::get_exact_u(time_pt()->time(),x,u_exact);
   Vector<double > xi_wall(1);
   Vector<double > r_wall(2);
   xi_wall[0]=0.0;
   Boundary_pt->position(xi_wall,r_wall);
   Trace_file << time_pt()->time() 
              << " " << u_exact
              << " " << r_wall[0]
              << " " << time_pt()->dt()
              << " " << temp_error_norm
              << " " << GlobalParameters::step_position(time_pt()->
                                                               time())
              << " " << global_ref_stats[0] 
              << " " << global_ref_stats[1]
              << " " << global_ref_stats[2] 
              << " " << error 
              << " " << norm << std::endl;
   
   // Plot wall posn
   //---------------
   sprintf(filename,"%s/Wall%i.dat",Doc_info.directory().c_str(),
           Doc_info.number());
   some_file.open(filename);
   
   unsigned nplot=100;
   for (unsigned iplot=0;iplot<nplot;iplot++)
    {
     xi_wall[0]=0.5*Pi*double(iplot)/double(nplot-1);
     Boundary_pt->position(xi_wall,r_wall);
     some_file << r_wall[0] << " " << r_wall[1] << std::endl;
    }
   some_file.close();
  }
 
 
 // Write restart file
 sprintf(filename,"%s/restart%i_on_proc%i.dat",Doc_info.directory().c_str(),
         Doc_info.number(),this->communicator_pt()->my_rank());
 some_file.open(filename);
 some_file.precision(20); 
 dump_it(some_file);
 some_file.close();
 
 // Increment number of doc
 Doc_info.number()++;
 
} // end of doc_solution

References oomph::DocInfo::directory(), GlobalParameters::Doc_info, calibrate::error, MergeRestartFiles::filename, GlobalParameters::get_exact_u(), oomph::DocInfo::number(), oomph::oomph_info, BiharmonicTestFunctions2::Pi, GlobalParameters::step_position(), oomph::Problem_Parameter::Trace_file, and plotDoE::x.

dump_it() [1/5]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::dump_it

(

ofstream &

dump_file

)

Dump problem data to allow for later restart.

Dump the solution to disk.

{
 
 // Write step number
 dump_file << Doc_info.number() << " # step number" << std::endl;
 
 // Write suggested next timestep
 dump_file << Next_dt << " # suggested next timestep" << std::endl;
 
 // Dump the refinement pattern and the generic problem data
 Problem::dump(dump_file);
  
} // end of dump_it

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

dump_it() [2/5]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::dump_it

(

ofstream &

dump_file

)

Dump problem data to allow for later restart.

dump_it() [3/5]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::dump_it

(

ofstream &

dump_file

)

Dump problem data to allow for later restart.

dump_it() [4/5]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::dump_it

(

ofstream &

dump_file

)

Dump problem data to allow for later restart.

dump_it() [5/5]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::dump_it

(

ofstream &

dump_file

)

Dump problem data to allow for later restart.

epsilon_t() [1/2]

template<class ELEMENT >

double& RefineableUnsteadyHeatProblem< ELEMENT >::epsilon_t ( )

inline

Target error for adaptive timestepping.

{return Epsilon_t;}

epsilon_t() [2/2]

template<class ELEMENT >

double& RefineableUnsteadyHeatProblem< ELEMENT >::epsilon_t ( )

inline

Target error for adaptive timestepping.

{return Epsilon_t;}

generic_actions_after()

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::generic_actions_after

private

Actions after adapt/distribute: Rebuild the mesh of prescribed flux elements

{
 
 // Create prescribed-flux elements from all elements that are 
 // adjacent to boundary 0 and add them to surface mesh
 create_flux_elements(0,Bulk_mesh_pt,Surface_mesh_pt);
 
 // Rebuild the global mesh
 rebuild_global_mesh();
 
 // Loop over the flux elements to pass pointer to prescribed flux function
 unsigned n_element=Surface_mesh_pt->nelement();
 for(unsigned e=0;e<n_element;e++)
  {
   // Upcast from GeneralisedElement to UnsteadyHeat flux element
   UnsteadyHeatFluxElement<ELEMENT> *el_pt = 
    dynamic_cast<UnsteadyHeatFluxElement<ELEMENT>*>(
     Surface_mesh_pt->element_pt(e));
   
   // Set the pointer to the prescribed flux function
   el_pt->flux_fct_pt() = 
    &GlobalParameters::prescribed_flux_on_fixed_y_boundary;
  }
 
} // end of generic_actions_after

References e(), oomph::UnsteadyHeatFluxElement< ELEMENT >::flux_fct_pt(), and GlobalParameters::prescribed_flux_on_fixed_y_boundary().

generic_actions_before()

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::generic_actions_before

private

Actions before adapt/distribute: Wipe the mesh of prescribed flux elements.

Actions before adapt/distribute: Wipe the mesh of prescribed flux elements

{
 
 // Kill the flux elements and wipe surface mesh
 delete_flux_elements(Surface_mesh_pt);
 
 // Rebuild the global mesh. 
 rebuild_global_mesh();
 
} // end of generic_actions_before

global_temporal_error_norm() [1/2]

template<class ELEMENT >

double RefineableUnsteadyHeatProblem< ELEMENT >::global_temporal_error_norm

virtual

Global error norm for adaptive time-stepping.

Global error norm for adaptive timestepping: RMS error, based on difference between predicted and actual value at all nodes.

Reimplemented from oomph::Problem.

{
 
#ifdef OOMPH_HAS_MPI
 
 double global_error = 0.0;
   
 //Find out how many nodes there are in the problem
 unsigned n_node = Bulk_mesh_pt->nnode();
 
 // Loop over the nodes and calculate the estimated error in the values
 // for non-haloes
 int count=0;
 for(unsigned i=0;i<n_node;i++)
  {
   Node* nod_pt=Bulk_mesh_pt->node_pt(i);
   if (!(nod_pt->is_halo()))
    {
     // Get error in solution: Difference between predicted and actual
     // value for nodal value 0
     double error = nod_pt->time_stepper_pt()->
      temporal_error_in_value(nod_pt,0);
     
     //Add the square of the individual error to the global error
     global_error += error*error;
     count++;
    }
  }
 
 // Accumulate
 int n_node_local=count;
 int n_node_total=0;
 MPI_Allreduce(&n_node_local,&n_node_total,1,MPI_INT,MPI_SUM,
               communicator_pt()->mpi_comm());
 
 double global_error_total=0.0;
 MPI_Allreduce(&global_error,&global_error_total,1,MPI_DOUBLE,MPI_SUM,
               communicator_pt()->mpi_comm());
 
 // Divide by the number of nodes
 global_error_total /= double(n_node_total);
 
 // Return square root...
 oomph_info << "Total error " << n_node_total << " " 
            <<  sqrt(global_error_total) << std::endl;
 return sqrt(global_error_total);
 
#else
 
 double global_error = 0.0;
 
 //Find out how many nodes there are in the problem
 unsigned n_node = Bulk_mesh_pt->nnode();
 
 //Loop over the nodes and calculate the errors in the values
 for(unsigned i=0;i<n_node;i++)
  {
   // Get error in solution: Difference between predicted and actual
   // value for nodal value 0
   double error = 
    Bulk_mesh_pt->node_pt(i)->time_stepper_pt()->
    temporal_error_in_value(Bulk_mesh_pt->node_pt(i),0);
   
   //Add the square of the individual error to the global error
   global_error += error*error;
  }
    
   //Now the global error must be divided by the number of nodes
 global_error /= double(n_node);
 
 //Return the square root of the error
 return sqrt(global_error);
 
#endif
 
 
} // end of global_temporal_error_norm

References calibrate::error, i, oomph::oomph_info, sqrt(), and oomph::Data::time_stepper_pt().

global_temporal_error_norm() [2/2]

template<class ELEMENT >

double RefineableUnsteadyHeatProblem< ELEMENT >::global_temporal_error_norm ( )

virtual

Global error norm for adaptive time-stepping.

Reimplemented from oomph::Problem.

next_dt() [1/2]

template<class ELEMENT >

double& RefineableUnsteadyHeatProblem< ELEMENT >::next_dt ( )

inline

Suggestion for next timestep (stored to allow it to be written to (or read from) restart file)

{return Next_dt;}

next_dt() [2/2]

template<class ELEMENT >

double& RefineableUnsteadyHeatProblem< ELEMENT >::next_dt ( )

inline

Suggestion for next timestep (stored to allow it to be written to (or read from) restart file)

{return Next_dt;}

possibly_disable_ALE()

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::possibly_disable_ALE ( )

inline

Switch off ALE terms.

  {
   if (!Use_ALE)
    {
     std::cout << "Disabling ALE " << std::endl;
    }  
   // Loop over the elements 
   unsigned n_element = Bulk_mesh_pt->nelement();
   for(unsigned i=0;i<n_element;i++)
    {
     // Upcast from FiniteElement to the present element
     ELEMENT *el_pt = dynamic_cast<ELEMENT*>(Bulk_mesh_pt->element_pt(i));
     
     //Disable/enable ALE  (just to make sure both versions of the
     // code to the same amount of setup work...)
     if (Use_ALE)
      {
       el_pt->enable_ALE();
      }
     else
      {
       el_pt->disable_ALE();
      }
    }
  }

References i.

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

restart() [1/6]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::restart

Restart.

{ 
 
 // Pointer to restart file
 ifstream* restart_file_pt=0;
 
 // Open restart file from stem
 char filename[100];
 sprintf(filename,"%s_on_proc%i.dat",GlobalParameters::Restart_file.c_str(),
         this->communicator_pt()->my_rank());
 restart_file_pt= new ifstream(filename,ios_base::in);
 if (restart_file_pt!=0)
  {
   oomph_info << "Have opened " << filename << 
    " for restart. " << std::endl;
  }
 else
  {
   std::ostringstream error_stream;
   error_stream
    << "ERROR while trying to open " << filename
    << " for restart." << std::endl;
   
   throw OomphLibError(
    error_stream.str(),
    OOMPH_CURRENT_FUNCTION,
    OOMPH_EXCEPTION_LOCATION);
  }
 
 
 // Read restart data:
 //-------------------
 if (restart_file_pt!=0)
  {
   // Read the data from restart file and find out if the restart file
   // was from an unsteady run
   restart(*restart_file_pt);
  }
 
} // end of restart

References MergeRestartFiles::filename, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::oomph_info, and GlobalParameters::Restart_file.

restart() [2/6]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::restart

(

ifstream &

restart_file

)

Read problem data for restart.

Read solution from disk.

{
 
 double local_next_dt=0.0;
 unsigned local_doc_info_number=0;
 
 if (restart_file.is_open())
  {
   oomph_info <<"restart file exists"<<endl;
     
   // Read line up to termination sign
   string input_string;
   getline(restart_file,input_string,'#');
   
   // Ignore rest of line
   restart_file.ignore(80,'\n');
   
   // Read in step number
   local_doc_info_number=unsigned(atof(input_string.c_str()));
   
   // Read line up to termination sign
   getline(restart_file,input_string,'#');
   
   // Ignore rest of line
   restart_file.ignore(80,'\n');
   
   // Read suggested next timestep
   local_next_dt=double(atof(input_string.c_str()));
   
  }
 else
  {
   oomph_info <<"restart file does not exist"<<endl;
  }
 
 // Get next dt
 double next_dt=0.0;
 MPI_Allreduce(&local_next_dt,&next_dt,1,MPI_DOUBLE,MPI_MAX,
               communicator_pt()->mpi_comm());
 Next_dt=next_dt;
 oomph_info << "Next dt: " << Next_dt << std::endl;
 
 // Get doc info
 unsigned doc_info_number=0; 
 MPI_Allreduce(&local_doc_info_number,&doc_info_number,1,MPI_UNSIGNED,MPI_MAX,
               communicator_pt()->mpi_comm());
 Doc_info.number()=doc_info_number;
 oomph_info << "Restarted doc_info.number(): " << doc_info_number << std::endl;
 
 
 // Refine the mesh and read in the generic problem data
 Problem::read(restart_file);
 
 // Output restarted solution
 std::stringstream comment_stream;
 comment_stream << "Restarted; Step " 
                << doc_info().number();
 doc_solution(comment_stream.str());
 
 
} // end of restart

References GlobalParameters::Doc_info, oomph::DocInfo::number(), oomph::oomph_info, and Eigen::TensorSycl::internal::read().

restart() [3/6]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::restart

(

ifstream &

restart_file

)

Read problem data for restart.

restart() [4/6]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::restart

(

ifstream &

restart_file

)

Read problem data for restart.

restart() [5/6]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::restart

(

ifstream &

restart_file

)

Read problem data for restart.

restart() [6/6]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::restart

(

ifstream &

restart_file

)

Read problem data for restart.

set_initial_condition() [1/5]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::set_initial_condition

virtual

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

Set initial condition: Assign previous and current values from exact solution.

Reimplemented from oomph::Problem.

{ 
 
 // Choose initial timestep
 double dt0=0.005;
 
 // Initialise timestep -- also sets the weights for all timesteppers
 // in the problem.
 initialise_dt(dt0);
 
 // Use this as the first "suggested" timestep
 Next_dt=dt0;
 
 // Backup time in global timestepper
 double backed_up_time=time_pt()->time();
 
 // Past history for velocities must be established for t=time0-deltat, ...
 // Then provide current values (at t=time0) which will also form
 // the initial guess for first solve at t=time0+deltat
 
 // Vector of exact solution value
 Vector<double> soln(1);
 Vector<double> x(2);
 
 //Find number of nodes in mesh
 unsigned num_nod = Bulk_mesh_pt->nnode();
 
 // Get continuous times at previous timesteps
 int nprev_steps=time_stepper_pt()->nprev_values();
 Vector<double> prev_time(nprev_steps+1);
 for (int itime=nprev_steps;itime>=0;itime--)
  {
   prev_time[itime]=time_pt()->time(unsigned(itime));
  }
 
 // Loop over current & previous timesteps (in outer loop because
 // the mesh also moves!)
 for (int itime=nprev_steps;itime>=0;itime--)
  {
   double time=prev_time[itime];
   
   // Set global time (because this is how the geometric object refers 
   // to continous time 
   time_pt()->time()=time;
   
   oomph_info << "setting IC at time =" << time << std::endl;
   
   // Update the mesh for this value of the continuous time
   // (The wall object reads the continous time from the same
   // global time object)
   Bulk_mesh_pt->node_update(); 
   
   // Loop over the nodes to set initial guess everywhere
   for (unsigned jnod=0;jnod<num_nod;jnod++)
    {
     // Get nodal coordinates
     x[0]=Bulk_mesh_pt->node_pt(jnod)->x(0);
     x[1]=Bulk_mesh_pt->node_pt(jnod)->x(1);
     
     // Get intial solution
     GlobalParameters::get_exact_u(time,x,soln);
     
     // Assign solution
     Bulk_mesh_pt->node_pt(jnod)->set_value(itime,0,soln[0]);
     
     // Loop over coordinate directions
     for (unsigned i=0;i<2;i++)
      {
       Bulk_mesh_pt->node_pt(jnod)->x(itime,i)=x[i];
      }
    } 
  }
 
 // Reset backed up time for global timestepper
 time_pt()->time()=backed_up_time;
 
} // end of set_initial_condition

References GlobalParameters::get_exact_u(), i, oomph::oomph_info, and plotDoE::x.

set_initial_condition() [2/5]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::set_initial_condition ( )

virtual

Set initial condition (incl previous timesteps) according to specified function. Note that his overloads the virtual function in the Problem base class and is therefore executed automatically to re-assign the initial conditions during the spatially adaptive solution at the first timestep.

Reimplemented from oomph::Problem.

set_initial_condition() [3/5]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::set_initial_condition ( )

virtual

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

Reimplemented from oomph::Problem.

set_initial_condition() [4/5]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::set_initial_condition ( )

virtual

Set initial condition (incl previous timesteps) according to specified function. Note that his overloads the virtual function in the Problem base class and is therefore executed automatically to re-assign the initial conditions during the spatially adaptive solution at the first timestep.

Reimplemented from oomph::Problem.

set_initial_condition() [5/5]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::set_initial_condition ( )

virtual

Set initial condition (incl previous timesteps) according to specified function. Note that his overloads the virtual function in the Problem base class and is therefore executed automatically to re-assign the initial conditions during the spatially adaptive solution at the first timestep.

Reimplemented from oomph::Problem.

write_trace_file_header() [1/2]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::write_trace_file_header

Write header for trace file.

Write the tecplot header for the trace file.

{
 // Open trace file on root only
 if (communicator_pt()->my_rank()==0)
  {
   char filename[100];   
   sprintf(filename,"%s/trace.dat",Doc_info.directory().c_str());
   Trace_file.open(filename);
   
   Trace_file << "VARIABLES=\"time t\","
              << "\"u<SUB>FE</SUB>\","
              << "\"u<SUB>exact</SUB>\","
              << "\"A\","
              << "\"dt\","
              << "\"global temporal error norm\","
              << "\"X<SUB>step</SUB>\","
              << "\"N<SUB>element</SUB>\","
              << "\"N<SUB>refined</SUB>\","
              << "\"N<SUB>unrefined</SUB>\","
              << "\"norm of error\","
              << "\"norm of solution\""
              << std::endl;
   Trace_file << "ZONE T=\"" << time_stepper_pt()->type() 
              << time_stepper_pt()->nprev_values()
              << "; initial dt="
              <<  time_pt()->dt() << "; ";
   if (time_stepper_pt()->adaptive_flag())
    {
     Trace_file << "adaptive; target error " << Epsilon_t 
                << " \"" << std::endl;
    }
   else
    {
     Trace_file << "(fixed timestep)\"" << std::endl;
    }
  }
 
} // end of write_trace_file_header

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

write_trace_file_header() [2/2]

template<class ELEMENT >

void RefineableUnsteadyHeatProblem< ELEMENT >::write_trace_file_header

(

)

Write header for trace file.

Member Data Documentation

Boundary_pt

template<class ELEMENT >

GeomObject * RefineableUnsteadyHeatProblem< ELEMENT >::Boundary_pt

private

Pointer to GeomObject that specifies the domain bondary.

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

Bulk_mesh_pt

template<class ELEMENT >

RefineableQuarterCircleSectorMesh< ELEMENT > * RefineableUnsteadyHeatProblem< ELEMENT >::Bulk_mesh_pt

private

Pointer to the "bulk" mesh.

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

Doc_info

template<class ELEMENT >

DocInfo RefineableUnsteadyHeatProblem< ELEMENT >::Doc_info

private

Doc info object.

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

Doc_node_pt

template<class ELEMENT >

Node * RefineableUnsteadyHeatProblem< ELEMENT >::Doc_node_pt

private

Pointer to central node (exists at all refinement levels) for doc.

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

Epsilon_t

template<class ELEMENT >

double RefineableUnsteadyHeatProblem< ELEMENT >::Epsilon_t

private

Target error for adaptive timestepping.

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

Next_dt

template<class ELEMENT >

double RefineableUnsteadyHeatProblem< ELEMENT >::Next_dt

private

Suggestion for next timestep (stored to allow it to be written to (or read from) restart file)

Source_fct_pt

template<class ELEMENT >

UnsteadyHeatEquations< 2 >::UnsteadyHeatSourceFctPt RefineableUnsteadyHeatProblem< ELEMENT >::Source_fct_pt

private

Pointer to source function.

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

Surface_mesh_pt

template<class ELEMENT >

Mesh * RefineableUnsteadyHeatProblem< ELEMENT >::Surface_mesh_pt

private

Pointer to the "surface" mesh.

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

Trace_file

template<class ELEMENT >

ofstream RefineableUnsteadyHeatProblem< ELEMENT >::Trace_file

private

Trace file.

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

Use_ALE

template<class ELEMENT >

bool RefineableUnsteadyHeatProblem< ELEMENT >::Use_ALE

private

Flag to use ALE.

---

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

• two_d_unsteady_heat_2adapt_load_balance.cc
• optimisation/disable_ALE/unsteady_heat/two_d_unsteady_heat_adapt.cc
• two_d_unsteady_heat_2adapt.cc
• two_d_unsteady_heat_ALE.cc