#include <my_problem.h>

Inheritance diagram for oomph::MyProblem:

Public Member Functions
	MyProblem ()
	Default constructor. More...

virtual	~MyProblem ()

double	smart_time_step (double dt, const double &tol)

virtual bool	finished () const

void	get_solver_parameters (SolverParameters &sp)

void	set_solver_parameters (SolverParameters &sp)

bool	explicit_flag ()

bool	is_steady ()

virtual void	actions_before_newton_step ()

unsigned	nnewton_step_this_solve () const

virtual void	actions_before_explicit_stage ()

virtual void	actions_after_explicit_stage ()

virtual void	actions_before_time_integration ()

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_after_implicit_timestep ()

virtual void	actions_before_implicit_timestep ()

virtual void	actions_after_newton_step ()

virtual void	actions_before_newton_solve ()

void	segregated_pin_indices (const Vector< unsigned > &indices)

void	undo_segregated_pinning ()
	Remove pinning set up by segregated_pin_indices. More...

void	check_not_segregated (const char *function) const
	Check that nothing is currently pinned for a segregated solve. More...

void	check_norm_limits ()

double	min_element_size ()
	??ds More...

void	write_trace (const unsigned &t_hist=0)

virtual void	write_additional_trace_data (const unsigned &t_hist, std::ofstream &trace_file) const

virtual void	write_additional_trace_headers (std::ofstream &trace_file) const

virtual void	output_solution (std::ofstream &soln_file) const
	Overload to write any problem specific data. More...

virtual void	final_doc_additional () const

virtual void	initial_doc_additional () const

void	initial_doc ()

void	final_doc ()

void	doc_solution (const unsigned &t_hist=0, const std::string &prefix="")

virtual void	output_solution (const unsigned &t, std::ostream &outstream, const unsigned &npoints=2) const

virtual void	doc_boundaries (const std::string &boundary_file_basename) const
	Output nodes with boundary number to csv file. More...

void	output_solution (std::ostream &outstream, const unsigned &npoints=2) const

virtual void	output_exact_solution (const unsigned &t_hist, std::ostream &outstream, const unsigned &npoints=2) const

virtual double	get_error_norm (const unsigned &t_hist=0) const
	Error norm calculator. More...

virtual double	get_solution_norm (const unsigned &t_hist=0) const
	Dummy solution norm calculator (overload in derived classes). More...

virtual bool	should_doc_this_step (const double &dt, const double &time) const

void	set_doc_times (Vector< double > &doc_times)
	Assign a vector of times to output the full solution at. More...

double	lte_norm ()

bool	doc_exact () const

virtual Vector< double >	trace_values (const unsigned &t_hist=0) const

void	dump_current_mm_or_jacobian_residuals (const std::string &label)

IterativeLinearSolver *	iterative_linear_solver_pt () const

virtual void	build (Vector< Mesh * > &bulk_mesh_pt)
	Perform set up of problem. More...

const unsigned	dim () const
	Get problem dimension (nodal dimension). More...

virtual std::string	problem_name () const

virtual void	set_up_impulsive_initial_condition ()
	Set all history values/dts to be the same as the present values/dt. More...

virtual void	my_set_initial_condition (const SolutionFunctorBase &ic)
	Assign initial conditions from function pointer. More...

virtual void	actions_after_set_initial_condition ()

virtual double	integrate_over_problem (const ElementalFunction func_pt, const Integral quadrature_pt=0) const

virtual void	dump (std::ofstream &dump_file) const

virtual void	read (std::ifstream &restart_file)

void	output_ltes (const unsigned &t_hist, std::ostream &output) const

Vector< double >	exact_solution (const double &t, const Vector< double > &x) const
	Get exact solution. More...

Public Member Functions inherited from oomph::Problem
virtual void	debug_hook_fct (const unsigned &i)

void	set_analytic_dparameter (double *const &parameter_pt)

void	unset_analytic_dparameter (double *const &parameter_pt)

bool	is_dparameter_calculated_analytically (double *const &parameter_pt)

void	set_analytic_hessian_products ()

void	unset_analytic_hessian_products ()

bool	are_hessian_products_calculated_analytically ()

void	set_pinned_values_to_zero ()

bool	distributed () const

virtual void	actions_before_adapt ()

virtual void	actions_after_adapt ()
	Actions that are to be performed after a mesh adaptation. More...

OomphCommunicator *	communicator_pt ()
	access function to the oomph-lib communicator More...

const OomphCommunicator *	communicator_pt () const
	access function to the oomph-lib communicator, const version More...

	Problem ()

	Problem (const Problem &dummy)=delete
	Broken copy constructor. More...

void	operator= (const Problem &)=delete
	Broken assignment operator. More...

virtual	~Problem ()
	Virtual destructor to clean up memory. More...

Mesh *&	mesh_pt ()
	Return a pointer to the global mesh. More...

Mesh *const &	mesh_pt () const
	Return a pointer to the global mesh (const version) More...

Mesh *&	mesh_pt (const unsigned &imesh)

Mesh *const &	mesh_pt (const unsigned &imesh) const
	Return a pointer to the i-th submesh (const version) More...

unsigned	nsub_mesh () const
	Return number of submeshes. More...

unsigned	add_sub_mesh (Mesh *const &mesh_pt)

void	flush_sub_meshes ()

void	build_global_mesh ()

void	rebuild_global_mesh ()

LinearSolver *&	linear_solver_pt ()
	Return a pointer to the linear solver object. More...

LinearSolver *const &	linear_solver_pt () const
	Return a pointer to the linear solver object (const version) More...

LinearSolver *&	mass_matrix_solver_for_explicit_timestepper_pt ()

LinearSolver *	mass_matrix_solver_for_explicit_timestepper_pt () const

EigenSolver *&	eigen_solver_pt ()
	Return a pointer to the eigen solver object. More...

EigenSolver *const &	eigen_solver_pt () const
	Return a pointer to the eigen solver object (const version) More...

Time *&	time_pt ()
	Return a pointer to the global time object. More...

Time *	time_pt () const
	Return a pointer to the global time object (const version). More...

double &	time ()
	Return the current value of continuous time. More...

double	time () const
	Return the current value of continuous time (const version) More...

TimeStepper *&	time_stepper_pt ()

const TimeStepper *	time_stepper_pt () const

TimeStepper *&	time_stepper_pt (const unsigned &i)
	Return a pointer to the i-th timestepper. More...

ExplicitTimeStepper *&	explicit_time_stepper_pt ()
	Return a pointer to the explicit timestepper. More...

unsigned long	set_timestepper_for_all_data (TimeStepper *const &time_stepper_pt, const bool &preserve_existing_data=false)

virtual void	shift_time_values ()
	Shift all values along to prepare for next timestep. More...

AssemblyHandler *&	assembly_handler_pt ()
	Return a pointer to the assembly handler object. More...

AssemblyHandler *const &	assembly_handler_pt () const
	Return a pointer to the assembly handler object (const version) More...

double &	minimum_dt ()
	Access function to min timestep in adaptive timestepping. More...

double &	maximum_dt ()
	Access function to max timestep in adaptive timestepping. More...

unsigned &	max_newton_iterations ()
	Access function to max Newton iterations before giving up. More...

void	problem_is_nonlinear (const bool &prob_lin)
	Access function to Problem_is_nonlinear. More...

double &	max_residuals ()

bool &	time_adaptive_newton_crash_on_solve_fail ()
	Access function for Time_adaptive_newton_crash_on_solve_fail. More...

double &	newton_solver_tolerance ()

void	add_time_stepper_pt (TimeStepper *const &time_stepper_pt)

void	set_explicit_time_stepper_pt (ExplicitTimeStepper *const &explicit_time_stepper_pt)

void	initialise_dt (const double &dt)

void	initialise_dt (const Vector< double > &dt)

Data *&	global_data_pt (const unsigned &i)
	Return a pointer to the the i-th global data object. More...

void	add_global_data (Data *const &global_data_pt)

void	flush_global_data ()

LinearAlgebraDistribution *const &	dof_distribution_pt () const
	Return the pointer to the dof distribution (read-only) More...

unsigned long	ndof () const
	Return the number of dofs. More...

unsigned	ntime_stepper () const
	Return the number of time steppers. More...

unsigned	nglobal_data () const
	Return the number of global data values. More...

unsigned	self_test ()
	Self-test: Check meshes and global data. Return 0 for OK. More...

void	enable_store_local_dof_pt_in_elements ()

void	disable_store_local_dof_pt_in_elements ()

unsigned long	assign_eqn_numbers (const bool &assign_local_eqn_numbers=true)

void	describe_dofs (std::ostream &out= *(oomph_info.stream_pt())) const

void	enable_discontinuous_formulation ()

void	disable_discontinuous_formulation ()

void	get_dofs (DoubleVector &dofs) const

void	get_dofs (const unsigned &t, DoubleVector &dofs) const
	Return vector of the t'th history value of all dofs. More...

void	set_dofs (const DoubleVector &dofs)
	Set the values of the dofs. More...

void	set_dofs (const unsigned &t, DoubleVector &dofs)
	Set the history values of the dofs. More...

void	set_dofs (const unsigned &t, Vector< double * > &dof_pt)

void	add_to_dofs (const double &lambda, const DoubleVector &increment_dofs)
	Add lambda x incremenet_dofs[l] to the l-th dof. More...

double *	global_dof_pt (const unsigned &i)

double &	dof (const unsigned &i)
	i-th dof in the problem More...

double	dof (const unsigned &i) const
	i-th dof in the problem (const version) More...

double *&	dof_pt (const unsigned &i)
	Pointer to i-th dof in the problem. More...

double *	dof_pt (const unsigned &i) const
	Pointer to i-th dof in the problem (const version) More...

virtual void	get_inverse_mass_matrix_times_residuals (DoubleVector &Mres)

virtual void	get_dvaluesdt (DoubleVector &f)

virtual void	get_residuals (DoubleVector &residuals)
	Get the total residuals Vector for the problem. More...

virtual void	get_jacobian (DoubleVector &residuals, DenseDoubleMatrix &jacobian)

virtual void	get_jacobian (DoubleVector &residuals, CRDoubleMatrix &jacobian)

virtual void	get_jacobian (DoubleVector &residuals, CCDoubleMatrix &jacobian)

virtual void	get_jacobian (DoubleVector &residuals, SumOfMatrices &jacobian)

void	get_fd_jacobian (DoubleVector &residuals, DenseMatrix< double > &jacobian)
	Get the full Jacobian by finite differencing. More...

void	get_derivative_wrt_global_parameter (double *const &parameter_pt, DoubleVector &result)

void	get_hessian_vector_products (DoubleVectorWithHaloEntries const &Y, Vector< DoubleVectorWithHaloEntries > const &C, Vector< DoubleVectorWithHaloEntries > &product)

void	solve_eigenproblem (const unsigned &n_eval, Vector< std::complex< double >> &eigenvalue, Vector< DoubleVector > &eigenvector, const bool &steady=true)
	Solve the eigenproblem. More...

void	solve_eigenproblem (const unsigned &n_eval, Vector< std::complex< double >> &eigenvalue, const bool &steady=true)

virtual void	get_eigenproblem_matrices (CRDoubleMatrix &mass_matrix, CRDoubleMatrix &main_matrix, const double &shift=0.0)

void	assign_eigenvector_to_dofs (DoubleVector &eigenvector)
	Assign the eigenvector passed to the function to the dofs. More...

void	add_eigenvector_to_dofs (const double &epsilon, const DoubleVector &eigenvector)

void	store_current_dof_values ()
	Store the current values of the degrees of freedom. More...

void	restore_dof_values ()
	Restore the stored values of the degrees of freedom. More...

void	enable_jacobian_reuse ()

void	disable_jacobian_reuse ()
	Disable recycling of Jacobian in Newton iteration. More...

bool	jacobian_reuse_is_enabled ()
	Is recycling of Jacobian in Newton iteration enabled? More...

bool &	use_predictor_values_as_initial_guess ()

void	newton_solve ()
	Use Newton method to solve the problem. More...

void	enable_globally_convergent_newton_method ()
	enable globally convergent Newton method More...

void	disable_globally_convergent_newton_method ()
	disable globally convergent Newton method More...

void	newton_solve (unsigned const &max_adapt)

void	steady_newton_solve (unsigned const &max_adapt=0)

void	copy (Problem *orig_problem_pt)

virtual Problem *	make_copy ()

virtual void	read (std::ifstream &restart_file, bool &unsteady_restart)

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...

Public Attributes
MyDocInfo	Doc_info

unsigned	Output_precision

unsigned	N_steps_taken

double	Total_step_time

std::string	Trace_filename

std::string	Info_filename

double	Error_norm_limit

double	Solution_norm_limit

bool	Disable_mass_matrix_solver_optimisations

bool	Always_write_trace
	Should we output to trace file every step? More...

bool	Want_doc_exact
	Should we try to output exact solution? More...

bool	Should_doc_boundaries
	Should we output the locations of the boundary nodes? More...

bool	Dump
	Should we dump ready for a restart? More...

bool	Output_ltes
	Should we output the local truncation error at each node as well? More...

bool	Output_predictor_values
	Should we output the predicted values too? More...

bool	Output_initial_condition
	Should we write output for initial conditions as though they are time steps as well? More...

SolutionFunctorBase *	Exact_solution_pt
	Function pointer for exact solution. More...

Public Attributes inherited from oomph::Problem
bool	Shut_up_in_newton_solve

Protected Attributes
const std::string	Trace_seperator

double	Dummy_doc_data

unsigned	Dim

Protected Attributes inherited from oomph::Problem
Vector< Problem * >	Copy_of_problem_pt

std::map< double *, bool >	Calculate_dparameter_analytic

bool	Calculate_hessian_products_analytic

LinearAlgebraDistribution *	Dof_distribution_pt

Vector< double * >	Dof_pt
	Vector of pointers to dofs. More...

DoubleVectorWithHaloEntries	Element_count_per_dof

double	Relaxation_factor

double	Newton_solver_tolerance

unsigned	Max_newton_iterations
	Maximum number of Newton iterations. More...

unsigned	Nnewton_iter_taken

Vector< double >	Max_res
	Maximum residuals at start and after each newton iteration. More...

double	Max_residuals

bool	Time_adaptive_newton_crash_on_solve_fail

bool	Jacobian_reuse_is_enabled
	Is re-use of Jacobian in Newton iteration enabled? Default: false. More...

bool	Jacobian_has_been_computed

bool	Problem_is_nonlinear

bool	Pause_at_end_of_sparse_assembly

bool	Doc_time_in_distribute

unsigned	Sparse_assembly_method

unsigned	Sparse_assemble_with_arrays_initial_allocation

unsigned	Sparse_assemble_with_arrays_allocation_increment

Vector< Vector< unsigned > >	Sparse_assemble_with_arrays_previous_allocation

double	Numerical_zero_for_sparse_assembly

double	FD_step_used_in_get_hessian_vector_products

bool	Mass_matrix_reuse_is_enabled

bool	Mass_matrix_has_been_computed

bool	Discontinuous_element_formulation

double	Minimum_dt
	Minimum desired dt: if dt falls below this value, exit. More...

double	Maximum_dt
	Maximum desired dt. More...

double	DTSF_max_increase

double	DTSF_min_decrease

double	Minimum_dt_but_still_proceed

bool	Scale_arc_length
	Boolean to control whether arc-length should be scaled. More...

double	Desired_proportion_of_arc_length
	Proportion of the arc-length to taken by the parameter. More...

double	Theta_squared

int	Sign_of_jacobian
	Storage for the sign of the global Jacobian. More...

double	Continuation_direction

double	Parameter_derivative
	Storage for the derivative of the global parameter wrt arc-length. More...

double	Parameter_current
	Storage for the present value of the global parameter. More...

bool	Use_continuation_timestepper
	Boolean to control original or new storage of dof stuff. More...

unsigned	Dof_derivative_offset

unsigned	Dof_current_offset

Vector< double >	Dof_derivative
	Storage for the derivative of the problem variables wrt arc-length. More...

Vector< double >	Dof_current
	Storage for the present values of the variables. More...

double	Ds_current
	Storage for the current step value. More...

unsigned	Desired_newton_iterations_ds

double	Minimum_ds
	Minimum desired value of arc-length. More...

bool	Bifurcation_detection
	Boolean to control bifurcation detection via determinant of Jacobian. More...

bool	Bisect_to_find_bifurcation
	Boolean to control wheter bisection is used to located bifurcation. More...

bool	First_jacobian_sign_change
	Boolean to indicate whether a sign change has occured in the Jacobian. More...

bool	Arc_length_step_taken
	Boolean to indicate whether an arc-length step has been taken. More...

bool	Use_finite_differences_for_continuation_derivatives

OomphCommunicator *	Communicator_pt
	The communicator for this problem. More...

bool	Always_take_one_newton_step

double	Timestep_reduction_factor_after_nonconvergence

bool	Keep_temporal_error_below_tolerance

Private Member Functions
	MyProblem (const MyProblem &dummy)
	Inaccessible copy constructor. More...

void	operator= (const MyProblem &dummy)
	Inaccessible assignment operator. More...

Private Attributes
Vector< double >	Jacobian_setup_times

Vector< double >	Solver_times

Vector< double >	Solver_iterations

Vector< double >	Preconditioner_setup_times

Vector< double >	Doc_times
	Times at which we want to output the full solution. More...

Additional Inherited Members
Public Types inherited from oomph::Problem
typedef void(*	SpatialErrorEstimatorFctPt) (Mesh *&mesh_pt, Vector< double > &elemental_error)
	Function pointer for spatial error estimator. More...

typedef void(*	SpatialErrorEstimatorWithDocFctPt) (Mesh *&mesh_pt, Vector< double > &elemental_error, DocInfo &doc_info)
	Function pointer for spatial error estimator with doc. More...

Static Public Attributes inherited from oomph::Problem
static bool	Suppress_warning_about_actions_before_read_unstructured_meshes

Protected Types inherited from oomph::Problem
enum	Assembly_method { Perform_assembly_using_vectors_of_pairs , Perform_assembly_using_two_vectors , Perform_assembly_using_maps , Perform_assembly_using_lists , Perform_assembly_using_two_arrays }
	Enumerated flags to determine which sparse assembly method is used. More...

Protected Member Functions inherited from oomph::Problem
unsigned	setup_element_count_per_dof ()

virtual void	sparse_assemble_row_or_column_compressed (Vector< int * > &column_or_row_index, Vector< int * > &row_or_column_start, Vector< double * > &value, Vector< unsigned > &nnz, Vector< double * > &residual, bool compressed_row_flag)

virtual void	actions_after_newton_solve ()

virtual void	actions_before_newton_convergence_check ()

virtual void	actions_after_implicit_timestep_and_error_estimation ()

virtual void	actions_before_read_unstructured_meshes ()

virtual void	actions_after_read_unstructured_meshes ()

virtual void	actions_after_change_in_global_parameter (double *const &parameter_pt)

virtual void	actions_after_change_in_bifurcation_parameter ()

virtual void	actions_after_parameter_increase (double *const &parameter_pt)

double &	dof_derivative (const unsigned &i)

double &	dof_current (const unsigned &i)

virtual void	set_initial_condition ()

virtual double	global_temporal_error_norm ()

unsigned	newton_solve_continuation (double *const &parameter_pt)

unsigned	newton_solve_continuation (double *const &parameter_pt, DoubleVector &z)

void	calculate_continuation_derivatives (double *const &parameter_pt)

void	calculate_continuation_derivatives (const DoubleVector &z)

void	calculate_continuation_derivatives_fd (double *const &parameter_pt)

bool	does_pointer_correspond_to_problem_data (double *const &parameter_pt)

void	set_consistent_pinned_values_for_continuation ()

Static Protected Attributes inherited from oomph::Problem
static ContinuationStorageScheme	Continuation_time_stepper
	Storage for the single static continuation timestorage object. More...

Constructor & Destructor Documentation

◆ MyProblem() [1/2]

oomph::MyProblem::MyProblem ( )

inline

Default constructor.

              :
   Trace_filename("trace"),
    Info_filename("info"),
    Trace_seperator("; "),
    Dummy_doc_data(-1)
    {
     Dim = 0;
     Output_precision = 8;
     Error_norm_limit = -1.0;
     Solution_norm_limit = -1.0;
  
     // Throw a real error (not just a warning) if the output directory
     // does not exist.
     Doc_info.enable_error_if_directory_does_not_exist();
  
     Disable_mass_matrix_solver_optimisations = false;
  
     // By default output to trace file every step
     Always_write_trace = true;
  
     Dump = false;
     Output_ltes = false;
     Output_predictor_values = false;
     Want_doc_exact = false;
     Output_initial_condition = false;
     Should_doc_boundaries = false;
  
     N_steps_taken = 0;
     Total_step_time= 0;
    }

References Global_Variables::Dim, and GlobalParameters::Doc_info.

◆ ~MyProblem()

virtual oomph::MyProblem::~MyProblem ( )

inlinevirtual

Virtual destructor. Policy decision: my problem classes won't call delete on anything. That's up to the driver code or whatever. Ideally we should just start using c++11 smart pointers and not have to worry so much about memory management!

169 {}

◆ MyProblem() [2/2]

oomph::MyProblem::MyProblem ( const MyProblem & dummy )

inlineprivate

Inaccessible copy constructor.

942 {BrokenCopy::broken_copy("MyProblem");}

oomph::BrokenCopy::broken_copy

void broken_copy(const std::string &class_name)

Issue error message and terminate execution.

Definition: oomph_utilities.cc:212

References oomph::BrokenCopy::broken_copy().

Member Function Documentation

◆ actions_after_explicit_stage()

virtual void oomph::MyProblem::actions_after_explicit_stage ( )

inlinevirtual

Empty virtual function that should be overloaded to update any dependent data or boundary conditions that should be advanced after each stage of an explicit time step (Runge-Kutta steps contain multiple stages per time step, most others only contain one).

Reimplemented from oomph::ExplicitTimeSteppableObject.

   {
    Jacobian_setup_times.push_back
     (this->mass_matrix_solver_for_explicit_timestepper_pt()->jacobian_setup_time());
    Solver_times.push_back
     (this->mass_matrix_solver_for_explicit_timestepper_pt()->linear_solver_solution_time());
  
    // No non-linear residuals to store
  
    const IterativeLinearSolver* its_pt
     = dynamic_cast<const IterativeLinearSolver*>(this->mass_matrix_solver_for_explicit_timestepper_pt());
    if(its_pt != 0)
    {
     Solver_iterations.push_back(its_pt->iterations());
     Preconditioner_setup_times.push_back(its_pt->preconditioner_setup_time());
    }
    else
    {
     // Fill in dummy data
     Solver_iterations.push_back(Dummy_doc_data);
     Preconditioner_setup_times.push_back(Dummy_doc_data);
    }
  
    // Not quite the same as actions after newton step because we are
    // interested in what happened in the explicit solver instead of the
    // main solver.
   }

References oomph::IterativeLinearSolver::iterations(), and oomph::IterativeLinearSolver::preconditioner_setup_time().

◆ actions_after_explicit_timestep()

virtual void oomph::MyProblem::actions_after_explicit_timestep ( )

inlinevirtual

Actions that should be performed after each explicit time step.

Reimplemented from oomph::Problem.

   {
    MyProblem::actions_after_newton_solve();
   }

References oomph::Problem::actions_after_newton_solve().

◆ actions_after_implicit_timestep()

virtual void oomph::MyProblem::actions_after_implicit_timestep ( )

inlinevirtual

Actions that should be performed after each implicit time step. This is needed when one wants to solve a steady problem before timestepping and needs to distinguish between the two cases

Reimplemented from oomph::Problem.

331 {}

◆ actions_after_newton_step()

virtual void oomph::MyProblem::actions_after_newton_step ( )

inlinevirtual

Any actions that are to be performed after each individual Newton step. Most likely to be used for diagnostic purposes to doc the solution during a non-converging iteration, say.

Reimplemented from oomph::Problem.

   {
    Jacobian_setup_times.push_back
     (this->linear_solver_pt()->jacobian_setup_time());
    Solver_times.push_back
     (this->linear_solver_pt()->linear_solver_solution_time());
  
    const IterativeLinearSolver* its_pt
     = dynamic_cast<const IterativeLinearSolver*>(this->linear_solver_pt());
    if(its_pt != 0)
    {
     Solver_iterations.push_back(its_pt->iterations());
     Preconditioner_setup_times.push_back(its_pt->preconditioner_setup_time());
    }
    else
    {
     // Fill in dummy data
     Solver_iterations.push_back(Dummy_doc_data);
     Preconditioner_setup_times.push_back(Dummy_doc_data);
    }
   }

References oomph::IterativeLinearSolver::iterations(), and oomph::IterativeLinearSolver::preconditioner_setup_time().

◆ actions_after_set_initial_condition()

void MyProblem::actions_after_set_initial_condition ( )

virtual

Hook to be overloaded with any calculations needed after setting of initial conditions.

  {
   // If using TR calculate initial derivative with these initial conditions
   TR* tr_pt = dynamic_cast<TR*>(time_stepper_pt());
   if(tr_pt != 0)
   {
    tr_pt->setup_initial_derivative(this);
   }
  }

References oomph::TR::setup_initial_derivative().

Referenced by oomph::ODEProblem::my_set_initial_condition().

◆ actions_before_explicit_stage()

virtual void oomph::MyProblem::actions_before_explicit_stage ( )

inlinevirtual

Empty virtual function to do anything needed before a stage of an explicit time step (Runge-Kutta steps contain multiple stages per time step, most others only contain one).

Reimplemented from oomph::ExplicitTimeSteppableObject.

288 {MyProblem::actions_before_newton_step();}

oomph::MyProblem::actions_before_newton_step

virtual void actions_before_newton_step()

Definition: my_problem.h:268

References actions_before_newton_step().

◆ actions_before_explicit_timestep()

virtual void oomph::MyProblem::actions_before_explicit_timestep ( )

inlinevirtual

Actions that should be performed before each explicit time step.

Reimplemented from oomph::Problem.

   {
    MyProblem::actions_before_newton_solve();
    check_norm_limits();
   }

References actions_before_newton_solve().

◆ actions_before_implicit_timestep()

virtual void oomph::MyProblem::actions_before_implicit_timestep ( )

inlinevirtual

Actions that should be performed before each implicit time step. This is needed when one wants to solve a steady problem before timestepping and needs to distinguish between the two cases

Reimplemented from oomph::Problem.

   {
    check_norm_limits();
   }

◆ actions_before_newton_solve()

virtual void oomph::MyProblem::actions_before_newton_solve ( )

inlinevirtual

Any actions that are to be performed before a complete Newton solve (e.g. adjust boundary conditions). CAREFUL: This step should (and if the FD-based LinearSolver FD_LU is used, must) only update values that are pinned!

Reimplemented from oomph::Problem.

   {
    // Clean up times vectors
    Jacobian_setup_times.clear();
    Solver_times.clear();
    Solver_iterations.clear();
    Preconditioner_setup_times.clear();
   }

Referenced by actions_before_explicit_timestep().

◆ actions_before_newton_step()

virtual void oomph::MyProblem::actions_before_newton_step ( )

inlinevirtual

Any actions that are to be performed before each individual Newton step. Most likely to be used for diagnostic purposes to doc the solution during a non-converging iteration, say.

Reimplemented from oomph::Problem.

   {
    // Output Jacobian and residuals if requested
    if(to_lower(Doc_info.output_jacobian) == "always")
    {
     // label with doc_info number and the newton step number
     std::string label = to_string(Doc_info.number())
      + "_"
      + to_string(nnewton_step_this_solve() + 1);
  
     dump_current_mm_or_jacobian_residuals(label);
    }
   }

References GlobalParameters::Doc_info, UniformPSDSelfTest::label, oomph::Global_string_for_annotation::string(), oomph::StringConversion::to_lower(), and oomph::StringConversion::to_string().

Referenced by actions_before_explicit_stage().

◆ actions_before_time_integration()

virtual void oomph::MyProblem::actions_before_time_integration ( )

inlinevirtual

318 {}

◆ build()

void MyProblem::build ( Vector< Mesh * > & bulk_mesh_pt )

virtual

Perform set up of problem.

Reimplemented in oomph::ODEProblem.

  {
   // Copy the first mesh's first timestepper to the problem
  
   FiniteElement* fele_pt = dynamic_cast<FiniteElement*>
    (bulk_mesh_pt[0]->element_pt(0));
  
   // Finite element mesh: grab ts from node
   if(fele_pt != 0)
   {
    TimeStepper* ts_pt = bulk_mesh_pt[0]->node_pt(0)->time_stepper_pt();
    this->add_time_stepper_pt(ts_pt);
  
    // ??ds assumed any timesteppers hiding somewhere else are added elsewhere
  
 #ifdef PARANOID
    for(unsigned j=0; j<bulk_mesh_pt.size(); j++)
    {
     if(bulk_mesh_pt[j]->node_pt(0)->time_stepper_pt()
        != ts_pt)
     {
      std::string err = "Multiple timesteppers, you need to do somedhing more fancy here";
      throw OomphLibError(err, OOMPH_EXCEPTION_LOCATION,
              OOMPH_CURRENT_FUNCTION);
     }
    }
 #endif
   }
  
   // Non finite element mesh: grab ts from internal data
   else
   {
    TimeStepper* ts_pt = bulk_mesh_pt[0]->element_pt(0)->
     internal_data_pt(0)->time_stepper_pt();
    this->add_time_stepper_pt(ts_pt);
  
    // ??ds again assumed any timesteppers hiding somewhere else are added elsewhere
  
 #ifdef PARANOID
    for(unsigned j=0; j<bulk_mesh_pt.size(); j++)
    {
     if(bulk_mesh_pt[j]->element_pt(0)->
        internal_data_pt(0)->time_stepper_pt() != ts_pt)
     {
      std::string err = "Multiple timesteppers? you need to do somedhing more fancy here";
      throw OomphLibError(err, OOMPH_EXCEPTION_LOCATION,
              OOMPH_CURRENT_FUNCTION);
     }
    }
 #endif
   }
  
  
   // Push all the meshes into the problem's sub mesh list
   for(unsigned j=0; j<bulk_mesh_pt.size(); j++)
   {
    add_sub_mesh(bulk_mesh_pt[j]);
   }
  
   // If we have an iterative solver with a block preconditioner then
   // add all the meshes to the block preconditioner as well.
   IterativeLinearSolver* its_pt = iterative_linear_solver_pt();
   if(its_pt != 0)
   {
 // RRR add comments to why this is incorrect:
 // We cannot call set_nmesh and set_mesh, this is handled by the derived
 // classes.
    // Try to get a block preconditioner from the preconditioner
    BlockPreconditioner<CRDoubleMatrix>* bp_pt
     = smart_cast_preconditioner<BlockPreconditioner<CRDoubleMatrix>*>
     (its_pt->preconditioner_pt());
  
    if(bp_pt != 0)
    {
 #ifdef PARANOID
     {
      std::string err = "IS THIS EVER USED?";
      throw OomphLibError(err, OOMPH_CURRENT_FUNCTION,
              OOMPH_EXCEPTION_LOCATION);
     }
 #endif
  
     // This part of the code is never executed in the driver code.
     // Commented out since it no longer make sense. The functions
     // set_nmesh() and set_mesh() are made protected. Each derived
     // block preconditioner has to call set_nmesh() and set_mesh(), 
     // since the preconditioner knows which mesh goes where, the 
     // writer of the driver code does not necessarily know.
  
 //            // Set up meshes
 //            bp_pt->set_nmesh(nsub_mesh());
 //            for(unsigned i=0; i< nsub_mesh(); i++)
 //              {
 //                bp_pt->set_mesh(i, mesh_pt(i));
 //              }
    }
   }
  
   // Get the problem dimension
   if(fele_pt != 0)
   {
    Dim = fele_pt->nodal_dimension();
   }
   else
   {
    // Presumably if a "bulk" mesh contains non-finite elements
    // then this is not a pde, so no dimension as such.
    Dim = 0;
   }
  
   if(!Disable_mass_matrix_solver_optimisations)
   {
    // Set the solver for explicit timesteps (mass matrix) to CG with a
    // diagonal predconditioner.
    IterativeLinearSolver* expl_solver_pt = new CG<CRDoubleMatrix>;
    expl_solver_pt->preconditioner_pt() =
     new MatrixBasedLumpedPreconditioner<CRDoubleMatrix>;
  
    // If it takes more than 100 iterations then something has almost
    // certainly gone wrong!
    expl_solver_pt->max_iter() = 100;
    expl_solver_pt->enable_error_after_max_iter();
    mass_matrix_solver_for_explicit_timestepper_pt() = expl_solver_pt;
  
    // expl_solver_pt->enable_doc_convergence_history();
  
    // Store + re-use the mass matrix used in explicit steps (since we
    // are almost certainly not going to do spatially adaptivity
    // anytime soon this is safe).
    this->enable_mass_matrix_reuse();
   }
  
  
   // If we requested exact solution output then check we have a solution
   if(Want_doc_exact && Exact_solution_pt == 0)
   {
    std::string warning = "Requested doc'ing exact solution, but we don't have an exact solution function pointer.";
    OomphLibWarning(warning, OOMPH_CURRENT_FUNCTION,
            OOMPH_EXCEPTION_LOCATION);
  
   }
  }

References Global_Variables::Dim, oomph::IterativeLinearSolver::enable_error_after_max_iter(), j, oomph::IterativeLinearSolver::max_iter(), oomph::FiniteElement::nodal_dimension(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::IterativeLinearSolver::preconditioner_pt(), and oomph::Global_string_for_annotation::string().

Referenced by oomph::ODEProblem::build().

◆ check_norm_limits()

void oomph::MyProblem::check_norm_limits ( )

inline

   {
    // If a limit has been set
    if(Error_norm_limit != -1.0)
    {
     double error_norm = get_error_norm();
  
     if((error_norm != Dummy_doc_data)
        && (error_norm > Error_norm_limit))
     {
      std::string err = "Error norm " + to_string(error_norm);
      err += " exceeds the limit " + to_string(Error_norm_limit);
      throw OomphLibError(err, OOMPH_EXCEPTION_LOCATION,
              OOMPH_CURRENT_FUNCTION);
     }
    }
  
    // Same for solution norm
    if(Solution_norm_limit != -1.0)
    {
     double solution_norm = get_solution_norm();
  
     if((solution_norm != Dummy_doc_data)
        && (solution_norm > Solution_norm_limit))
     {
      std::string err = "Solution norm " + to_string(solution_norm);
      err += " exceeds the limit " + to_string(Solution_norm_limit);
      throw OomphLibError(err, OOMPH_EXCEPTION_LOCATION,
              OOMPH_CURRENT_FUNCTION);
     }
    }
   }

References OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::Global_string_for_annotation::string(), and oomph::StringConversion::to_string().

◆ check_not_segregated()

void oomph::MyProblem::check_not_segregated ( const char * function ) const

inline

Check that nothing is currently pinned for a segregated solve.

   {
 #ifdef PARANOID
    for(unsigned msh=0, nmsh=nsub_mesh(); msh<nmsh; msh++)
    {
     Mesh* mesh_pt = this->mesh_pt(msh);
     for(unsigned nd=0, nnd=mesh_pt->nnode(); nd<nnd; nd++)
     {
      Node* nd_pt = mesh_pt->node_pt(nd);
      for(unsigned j=0; j<nd_pt->nvalue(); j++)
      {
       if(nd_pt->eqn_number(j) == Data::Is_segregated_solve_pinned)
       {
        throw OomphLibError("Some dofs already segregated",
                OOMPH_EXCEPTION_LOCATION,
                function);
       }
      }
     }
    }
 #endif
   }

References oomph::Data::eqn_number(), oomph::Data::Is_segregated_solve_pinned, j, oomph::Mesh::nnode(), oomph::Mesh::node_pt(), oomph::Data::nvalue(), and OOMPH_EXCEPTION_LOCATION.

◆ dim()

const unsigned oomph::MyProblem::dim ( ) const

inline

Get problem dimension (nodal dimension).

762 {return this->Dim;}

References Global_Variables::Dim.

◆ doc_boundaries()

void MyProblem::doc_boundaries ( const std::string & boundary_file_basename ) const

virtual

Output nodes with boundary number to csv file.

  {
   const unsigned n_boundary = mesh_pt()->nboundary();
   for(unsigned b=0; b<n_boundary; b++)
   {
    std::ofstream boundary_file((boundary_file_basename +
                 to_string(b) + ".csv").c_str(),
                    std::ios::out);
  
    // write headers
    boundary_file << "x,y,z,b" << std::endl;
  
    const unsigned n_boundary_node = mesh_pt()->nboundary_node(b);
    for(unsigned nd=0; nd<n_boundary_node; nd++)
    {
     Node* node_pt = mesh_pt()->boundary_node_pt(b, nd);
     Vector<double> position = node_pt->position();
  
     // Write out this node
     for(unsigned i=0; i<dim(); i++)
     {
      boundary_file << position[i] << ",";
     }
     for(unsigned i=dim(); i<3; i++)
     {
      boundary_file << 0.0 << ",";
     }
     boundary_file << b << std::endl;
    }
  
    boundary_file.close();
   }
  }

References b, i, out(), oomph::Node::position(), and oomph::StringConversion::to_string().

◆ doc_exact()

bool oomph::MyProblem::doc_exact ( ) const

inline

   {
    return Want_doc_exact && (Exact_solution_pt != 0);
   }

◆ doc_solution()

void MyProblem::doc_solution	(	const unsigned &	t_hist = `0`,
		const std::string &	prefix = `""`
	)

General output function: output to trace file. Maybe output Jacobian depending on Doc_info.output_jacobian. Maybe output full solution depending on should_doc_this_step(..) function. Maybe output ltes depending on value of Output_ltes. Extend by overloading output_solution(...). Optional prefix for special outputs (special outputs don't go in pvd file, yet? too messy...)

  {
   bool doc_this_step = true;
   if(!is_steady())
   {
    doc_this_step = should_doc_this_step(time_pt()->dt(t_hist),
                     time_pt()->time(t_hist));
   }
  
   const std::string dir = Doc_info.directory();
   const std::string num = to_string(Doc_info.number());
  
   if(Always_write_trace || doc_this_step)
   {
    // Always output trace file data
    write_trace(t_hist);
   }
  
   // Output full set of data if requested for this timestep
   if(doc_this_step)
   {
  
    // Solution itself
    std::ofstream soln_file((dir + "/" + prefix + "soln" + num + ".dat").c_str(),
                std::ios::out);
    soln_file.precision(Output_precision);
    output_solution(t_hist, soln_file);
    soln_file.close();
  
    // Exact solution if available and requested
    if(doc_exact())
    {
     std::ofstream exact_file((dir + "/" + prefix + "exact" + num + ".dat").c_str(),
                  std::ios::out);
     exact_file.precision(Output_precision);
     output_exact_solution(t_hist, exact_file);
     exact_file.close();
    }
  
    // If not a steady state problem then write time information
    if(!is_steady() && prefix == "")
    {
     // Write the simulation time and filename to the solution pvd
     // file
     std::ofstream pvd_file((dir + "/" + "soln.pvd").c_str(),
                std::ios::app);
     pvd_file.precision(Output_precision);
  
     pvd_file << "<DataSet timestep=\"" << time_pt()->time(t_hist)
          << "\" group=\"\" part=\"0\" file=\"" << "soln"
          << num << ".vtu"
          << "\"/>" << std::endl;
  
     pvd_file.close();
  
  
     // Write the simulation time and filename to the exact solution
     // pvd file
     if(doc_exact())
     {
      std::ofstream exact_pvd_file((dir + "/" + "exact.pvd").c_str(),
                   std::ios::app);
      exact_pvd_file.precision(Output_precision);
  
      exact_pvd_file << "<DataSet timestep=\"" << time()
             << "\" group=\"\" part=\"0\" file=\"" <<  "exact"
             << num << ".vtu"
             << "\"/>" << std::endl;
  
      exact_pvd_file.close();
     }
    }
  
  
    // Maybe dump the restart data
    if(Dump)
    {
     std::ofstream dump_file((dir + "/" + "dump" + num + ".dat").c_str(),
                 std::ios::out);
     this->dump(dump_file);
     dump_file.close();
    }
  
    // Maybe dump ltes
    if(Output_ltes)
    {
     std::ofstream ltefile((dir + "/ltes" + num + ".csv").c_str(),
               std::ios::out);
     output_ltes(t_hist, ltefile);
     ltefile.close();
    }
  
    // Maybe write out predicted values, check we only have one time
    // stepper first though.
 #ifdef PARANOID
    if(Output_predictor_values && ntime_stepper() != 1)
    {
     std::string err = "Can only output predictor values for a single time stepper";
     throw OomphLibError(err, OOMPH_CURRENT_FUNCTION,
             OOMPH_EXCEPTION_LOCATION);
  
     // Otherwise we would have multiple "predictor_time" values
     // below.
    }
 #endif
  
    if(t_hist != 0)
    {
     std::string err = "Can't output history of predicted value: they aren't stored.";
     OomphLibWarning(err, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
    }
    else if(Output_predictor_values && time_stepper_pt()->adaptive_flag())
    {
     const unsigned predictor_time =
      time_stepper_pt()->predictor_storage_index();
  
     std::ofstream pred_file((dir + "/" + "predsoln" + num + ".dat").c_str(),
                 std::ios::out);
     pred_file.precision(Output_precision);
     output_solution(predictor_time, pred_file, 2);
     pred_file.close();
    }
  
  
    Doc_info.number()++;
   }
  }

References GlobalParameters::Doc_info, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, out(), oomph::Global_string_for_annotation::string(), and oomph::StringConversion::to_string().

◆ dump()

virtual void oomph::MyProblem::dump ( std::ofstream & dump_file ) const

inlinevirtual

Dump refinement pattern of all refineable meshes and all generic Problem data to file for restart.

Reimplemented from oomph::Problem.

   {
    // Set very high precision to avoid any issues
    dump_file.precision(14);
  
    dump_file << Doc_info.number() << " # Doc_info.number()" << std::endl;
    dump_file << N_steps_taken << " # N_steps_taken" << std::endl;
    Problem::dump(dump_file);
   }

References GlobalParameters::Doc_info, and oomph::Problem::dump().

◆ dump_current_mm_or_jacobian_residuals()

void MyProblem::dump_current_mm_or_jacobian_residuals ( const std::string & label )

  {
   throw OomphLibError("Not implemented (yet?).", OOMPH_CURRENT_FUNCTION, 
               OOMPH_EXCEPTION_LOCATION);
  }

References OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

◆ exact_solution()

Vector<double> oomph::MyProblem::exact_solution	(	const double &	t,
		const Vector< double > &	x
	)		const

inline

Get exact solution.

   {
 #ifdef PARANOID
    if(Exact_solution_pt == 0)
    {
     std::string err = "Exact_solution_pt is null!";
     throw OomphLibError(err, OOMPH_EXCEPTION_LOCATION,
             OOMPH_CURRENT_FUNCTION);
    }
 #endif
    return (*Exact_solution_pt)(t, x);
   }

References OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::Global_string_for_annotation::string(), plotPSD::t, and plotDoE::x.

◆ explicit_flag()

bool oomph::MyProblem::explicit_flag ( )

inline

   {
    return (explicit_time_stepper_pt() != 0)
     && (time_stepper_pt()->is_steady());
   }

◆ final_doc()

void oomph::MyProblem::final_doc ( )

inline

Outputs to be done at the end of a run (e.g. closing tags for XML files).

   {
    // Output Jacobian if requested
    if((to_lower(Doc_info.output_jacobian) == "at_end")
       || (to_lower(Doc_info.output_jacobian) == "always"))
    {
     dump_current_mm_or_jacobian_residuals("at_end");
    }
  
    // Write end of .pvd XML file
    std::ofstream pvd_file((Doc_info.directory() + "/" + "soln.pvd").c_str(),
               std::ios::app);
    pvd_file << "</Collection>" << std::endl
         << "</VTKFile>" << std::endl;
    pvd_file.close();
  
    // Write end of exact.pvd XML file
    if(doc_exact())
    {
     std::ofstream pvd_file((Doc_info.directory() + "/" + "exact.pvd").c_str(),
                std::ios::app);
     pvd_file << "</Collection>" << std::endl
          << "</VTKFile>" << std::endl;
     pvd_file.close();
    }
  
    // Write out anything requested from an inheriting class.
    final_doc_additional();
   }

References GlobalParameters::Doc_info, and oomph::StringConversion::to_lower().

◆ final_doc_additional()

virtual void oomph::MyProblem::final_doc_additional ( ) const

inlinevirtual

522 {}

◆ finished()

virtual bool oomph::MyProblem::finished ( ) const

inlinevirtual

Use to specify a condition for time stepping to halt early. By default never halt early.

   {
    return false;
   }

◆ get_error_norm()

virtual double oomph::MyProblem::get_error_norm ( const unsigned & t_hist = 0 ) const

inlinevirtual

Error norm calculator.

Reimplemented in oomph::ODEProblem.

   {
    if(Exact_solution_pt != 0)
    {
     // ExactFunctionDiffSquared f;
     // f.Exact_pt = Exact_solution_pt;
     // return std::sqrt(integrate_over_problem(&f));
  
     // Nodal rms difference
     const double t = time_pt()->time(t_hist);
  
     double diffsq = 0;
  
     const unsigned n_node = mesh_pt()->nnode();
     for(unsigned nd=0; nd<n_node; nd++)
     {
      Node* nd_pt = mesh_pt()->node_pt(nd);
      Vector<double> values(nd_pt->nvalue(), 0.0), x(dim(), 0.0);
      nd_pt->position(t_hist, x);
      nd_pt->value(t_hist, values);
  
      Vector<double> exact = exact_solution(t, x);
  
      const unsigned ni = values.size();
      for(unsigned i=0; i<ni; i++)
      {
       diffsq += std::pow(values[i] - exact[i], 2);
      }
     }
  
     return std::sqrt(diffsq);
    }
    else
    {
     return Dummy_doc_data;
    }
   }

References Global_Parameters::exact_solution(), i, oomph::Data::nvalue(), oomph::Node::position(), Eigen::bfloat16_impl::pow(), sqrt(), plotPSD::t, oomph::Node::value(), and plotDoE::x.

◆ get_solution_norm()

virtual double oomph::MyProblem::get_solution_norm ( const unsigned & t_hist = 0 ) const

inlinevirtual

Dummy solution norm calculator (overload in derived classes).

   {
    DoubleVector dofs;
    get_dofs(t_hist, dofs);
    return dofs.norm();
   }

References oomph::DoubleVector::norm().

◆ get_solver_parameters()

void oomph::MyProblem::get_solver_parameters ( SolverParameters & sp )

inline

   {
    sp.linear_solver_pt = linear_solver_pt();
  
    // Newton options
    sp.newton_solver_tolerance = newton_solver_tolerance();
    sp.max_newton_iterations = max_newton_iterations();
    sp.max_residuals = max_residuals();
    sp.shut_up_in_newton_solve = Shut_up_in_newton_solve;
    sp.always_take_one_newton_step = Always_take_one_newton_step;
  
    // Linear optimisations
    sp.jacobian_reuse_is_enabled = jacobian_reuse_is_enabled();
    sp.jacobian_has_been_computed = Jacobian_has_been_computed;
    sp.problem_is_nonlinear = Problem_is_nonlinear;
  
    // Explicit solver
    sp.mass_matrix_solver_for_explicit_timestepper_pt = mass_matrix_solver_for_explicit_timestepper_pt();
    sp.mass_matrix_reuse_is_enabled = mass_matrix_reuse_is_enabled();
    sp.mass_matrix_has_been_computed = Mass_matrix_has_been_computed;
    sp.discontinuous_element_formulation = Discontinuous_element_formulation;
   }

◆ initial_doc()

void MyProblem::initial_doc ( )

Outputs to be done at the start of a run (i.e. outputing basic info on command line args etc, writing trace file headers, outputting initial conditions).

  {
 #ifdef PARANOID
   if(*(Doc_info.directory().end()-1) == '/')
   {
    std::string error_msg = "Don't put a / on the end of results dir";
    throw OomphLibError(error_msg, OOMPH_CURRENT_FUNCTION,
                OOMPH_EXCEPTION_LOCATION);
   }
 #endif
  
   const std::string& dir = Doc_info.directory();
  
   // Output Jacobian if requested
   if((to_lower(Doc_info.output_jacobian) == "at_start")
      || (to_lower(Doc_info.output_jacobian) == "always"))
   {
    dump_current_mm_or_jacobian_residuals("at_start");
   }
  
   // pvd files
   // ============================================================
   // Write start of .pvd XML file
   std::ofstream pvd_file((dir + "/" + "soln.pvd").c_str(),
              std::ios::out);
   pvd_file << "<?xml version=\"1.0\"?>" << std::endl
        << "<VTKFile type=\"Collection\" version=\"0.1\" byte_order=\"LittleEndian\">"
        << std::endl
        << "<Collection>" << std::endl;
   pvd_file.close();
  
   // Write start of exact.pvd XML file
   if(doc_exact())
   {
    std::ofstream pvd_file((dir + "/" + "exact.pvd").c_str(),
               std::ios::out);
    pvd_file << "<?xml version=\"1.0\"?>" << std::endl
         << "<VTKFile type=\"Collection\" version=\"0.1\" byte_order=\"LittleEndian\">"
         << std::endl
         << "<Collection>" << std::endl;
    pvd_file.close();
   }
  
   // Trace file
   // ============================================================
  
   // Clear (by overwriting) and write headers
   std::ofstream trace_file((dir + "/" + Trace_filename).c_str());
   trace_file
    << "DocInfo_numbers"
    << Trace_seperator << "times"
    << Trace_seperator << "dts"
    << Trace_seperator << "error_norms"
  
    << Trace_seperator << "n_newton_iters"
    << Trace_seperator << "n_solver_iters"
  
    << Trace_seperator << "solver_times"
    << Trace_seperator << "jacobian_setup_times"
    << Trace_seperator << "preconditioner_setup_times"
  
    << Trace_seperator << "LTE_norms"
    << Trace_seperator << "trace_values"
  
    << Trace_seperator << "unix_timestamp"
    << Trace_seperator << "newton_residuals"
    << Trace_seperator << "solution_norms"
    << Trace_seperator << "total_step_time"
  
  
    // Reserved slots in case I think of more things to add later
    << Trace_seperator << "dummy"
    << Trace_seperator << "dummy"
    << Trace_seperator << "dummy"
    << Trace_seperator << "dummy"
    << Trace_seperator << "dummy"
    << Trace_seperator << "dummy";
  
   // Other headers depending on the derived class
   write_additional_trace_headers(trace_file);
  
   // Finish the line and close
   trace_file << std::endl;
   trace_file.close();
  
  
   // Info file
   // ============================================================
   std::ofstream info_file((dir + "/" + Info_filename).c_str());
   info_file
    << "real_time " << real_date_time() << std::endl
    << "unix_time " << std::time(0) << std::endl
    << "driver_name " << problem_name() << std::endl
    << "initial_nnode " << mesh_pt()->nnode() << std::endl
    << "initial_nelement " << mesh_pt()->nelement() << std::endl
    << "initial_nsub_mesh " << nsub_mesh() << std::endl;
  
   info_file << Doc_info.args_str;
   info_file.close();
  
   // If requested then output history values before t=0.
   if(Output_initial_condition)
   {
 #ifdef PARANOID
    if(ntime_stepper() != 1)
    {
     std::string err = "More/less that 1 time stepper, not sure what to output.";
     throw OomphLibError(err, OOMPH_CURRENT_FUNCTION,
             OOMPH_EXCEPTION_LOCATION);
    }
 #endif
  
    // Output info for each history value in order.
    const unsigned nval = time_stepper_pt()->nprev_values();
    for(unsigned it=nval-1; it>0; it--)
    {
     doc_solution(it);
    }
   }
  
   // Output boundary numbers for each boundary node
   // ============================================================
   if(Should_doc_boundaries)
   {
    this->doc_boundaries(dir + "/nodes_on_boundary");
   }
  
  
   // Write initial solution and anything else problem specific
   // (e.g. more trace file headers)
   initial_doc_additional();
  
   // Doc the initial condition
   this->doc_solution();
  }

References GlobalParameters::Doc_info, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, out(), oomph::real_date_time(), oomph::Global_string_for_annotation::string(), and oomph::StringConversion::to_lower().

◆ initial_doc_additional()

virtual void oomph::MyProblem::initial_doc_additional ( ) const

inlinevirtual

523 {}

◆ integrate_over_problem()

double MyProblem::integrate_over_problem	(	const ElementalFunction *	func_pt,
		const Integral *	quadrature_pt = `0`
	)		const

virtual

Integrate a function given by func_pt over every element in every bulk mesh in this problem.

  {
   throw OomphLibError("Not implemented (yet?).", OOMPH_CURRENT_FUNCTION, 
               OOMPH_EXCEPTION_LOCATION);
  
  }

References OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

◆ is_steady()

bool oomph::MyProblem::is_steady ( )

inline

   {
    return (explicit_time_stepper_pt() == 0)
     && (time_stepper_pt()->is_steady());
   }

◆ iterative_linear_solver_pt()

IterativeLinearSolver* oomph::MyProblem::iterative_linear_solver_pt ( ) const

inline

   {
    return dynamic_cast<IterativeLinearSolver*>
     (this->linear_solver_pt());
   }

◆ lte_norm()

double oomph::MyProblem::lte_norm ( )

inline

Get an lte error norm using the same norm and values as the adaptive time stepper used.

   {
    if(time_stepper_pt()->adaptive_flag())
    {
     // Just return the error that would be used for adaptivity.
     return global_temporal_error_norm();
    }
    else
    {
     return Dummy_doc_data;
    }
   }

◆ min_element_size()

double MyProblem::min_element_size ( )

??ds

  {
   // Check that we have finite elements ??ds this will still go wrong
   // if there are only some none finite elements in the mesh...
  
   //??ds what happens with face elements?
   FiniteElement* test_pt = dynamic_cast<FiniteElement*>
    (mesh_pt(0)->element_pt(0));
  
   if(test_pt != 0)
   {
    double min_size = mesh_pt(0)->finite_element_pt(0)->compute_physical_size();
  
    // Loop over all meshes in problem
    for(unsigned msh=0, nmsh=nsub_mesh(); msh<nmsh; msh++)
    {
     Mesh* mesh_pt = this->mesh_pt(msh);
     for(unsigned ele=0, nele=mesh_pt->nelement(); ele<nele; ele++)
     {
      FiniteElement* ele_pt = mesh_pt->finite_element_pt(ele);
      double new_size = ele_pt->compute_physical_size();
      if(new_size < min_size)
      {
       min_size = new_size;
      }
     }
    }
  
    return min_size;
   }
   // If it's not a finite element then we can't get a size so return
   // a dummy value.
   else
   {
    return Dummy_doc_data;
   }
  }

References oomph::FiniteElement::compute_physical_size(), oomph::Mesh::finite_element_pt(), and oomph::Mesh::nelement().

◆ my_set_initial_condition()

void MyProblem::my_set_initial_condition ( const SolutionFunctorBase & ic )

virtual

Assign initial conditions from function pointer.

Reimplemented in oomph::ODEProblem.

  {
 #ifdef PARANOID
   // Can't set global data from a function of space... have to overload this
   // if you have any
   if(nglobal_data() != 0)
   {
    std::string err = "Problem has global data which cannot be set from function pt.";
    throw OomphLibError(err, OOMPH_EXCEPTION_LOCATION,
                OOMPH_CURRENT_FUNCTION);
   }
 #endif
  
   // Loop over current & previous timesteps (so we need t<nprev_values+1).
   const int nprev_values = this->time_stepper_pt()->nprev_values();
   for(int tindex=0; tindex<nprev_values+1; tindex++)
   {
    double time = time_pt()->time(tindex);
  
    // Loop over all nodes in all meshes in problem and set values.
    const unsigned nmsh = nsub_mesh();
    for(unsigned msh=0; msh<nmsh; msh++)
    {
     Mesh* mesh_pt = this->mesh_pt(msh);
  
     for(unsigned nd=0, nnd=mesh_pt->nnode(); nd<nnd; nd++)
     {
      Node* nd_pt = mesh_pt->node_pt(nd);
  
      // Get the position at present time
      const unsigned dim = nd_pt->ndim();
      Vector<double> x(dim);
      nd_pt->position(x);
  
      // Set position at tindex time to be the same as at present
      // (impulsive positions).
      for(unsigned j=0; j<dim; j++)
      {
       nd_pt->x(tindex, j) = x[j];
      }
  
      // Get the values
      Vector<double> values = ic(time, x);
  
 #ifdef PARANOID
      if(values.size() != nd_pt->nvalue())
      {
       std::string err = "Wrong number of values in initial condition.";
       throw OomphLibError(err, OOMPH_EXCEPTION_LOCATION,
               OOMPH_CURRENT_FUNCTION);
      }
 #endif
      // Copy into dofs
      for(unsigned j=0, nj=values.size(); j<nj; j++)
      {
       nd_pt->set_value(tindex, j, values[j]);
      }
     }
  
 #ifdef PARANOID
     // Can't set internal data like this so check that we have none.
     for(unsigned ele=0, nele=mesh_pt->nelement(); ele<nele; ele++)
     {
      FiniteElement* ele_pt = mesh_pt->finite_element_pt(ele);
      if(ele_pt->ninternal_data() != 0)
      {
       std::string err =
        "Element with non-nodal data, cannot set via function...";
       throw OomphLibError(err, OOMPH_EXCEPTION_LOCATION,
               OOMPH_CURRENT_FUNCTION);
      }
     }
 #endif
    }
   }
  
   actions_after_set_initial_condition();
  }

References oomph::Mesh::finite_element_pt(), j, oomph::Node::ndim(), oomph::Mesh::nelement(), oomph::GeneralisedElement::ninternal_data(), oomph::Mesh::nnode(), oomph::Mesh::node_pt(), oomph::Data::nvalue(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::Node::position(), oomph::Data::set_value(), oomph::Global_string_for_annotation::string(), plotDoE::x, and oomph::Node::x().

◆ nnewton_step_this_solve()

unsigned oomph::MyProblem::nnewton_step_this_solve ( ) const

inline

   {
    return Jacobian_setup_times.size();
   }

◆ operator=()

void oomph::MyProblem::operator= ( const MyProblem & dummy )

inlineprivate

Inaccessible assignment operator.

946 {BrokenCopy::broken_assign("MyProblem");}

oomph::BrokenCopy::broken_assign

void broken_assign(const std::string &class_name)

Issue error message and terminate execution.

Definition: oomph_utilities.cc:195

References oomph::BrokenCopy::broken_assign().

◆ output_exact_solution()

virtual void oomph::MyProblem::output_exact_solution	(	const unsigned &	t_hist,
		std::ostream &	outstream,
		const unsigned &	npoints = `2`
	)		const

inlinevirtual

Standard output function: loop over all elements in all meshes and output exact solution.

   {
    const double time = time_pt()->time();
  
    const unsigned n_msh = nsub_mesh();
    for(unsigned msh=0; msh<n_msh; msh++)
    {
     Mesh* msh_pt = mesh_pt(msh);
  
     const unsigned n_ele = msh_pt->nelement();
     for(unsigned ele=0; ele<n_ele; ele++)
     {
      FiniteElement* ele_pt = msh_pt->finite_element_pt(ele);
      ele_pt->output_fct(outstream, npoints, time,
             *Exact_solution_pt);
     }
    }
   }

References oomph::Mesh::finite_element_pt(), oomph::Mesh::nelement(), and oomph::FiniteElement::output_fct().

◆ output_ltes()

void oomph::MyProblem::output_ltes	(	const unsigned &	t_hist,
		std::ostream &	output
	)		const

inline

Output lte values of each nodal value along with spatial position for plotting with paraview. To plot load the csv file, use "Table To Points", add a 3D view, set the ltes to visible and color by the lte of interest. Useful to set "Representation" to "Points" and increase point size so that things are easily visible. Not implemented for nodes with varying numbers of values (you might need something fancier than a csv file for this).

   {
    // Output position labels
    for(unsigned j=0; j<Dim; j++)
    {
     output << "x" << j << ", ";
    }
  
    // Output labels for ltes, assuming that all nodes have the same
    // number of values...
    for(unsigned j=0; j<mesh_pt()->node_pt(0)->nvalue(); j++)
    {
     output << "error" << j << ", ";
    }
  
    output << std::endl;
  
    // Output actual positions and ltes
    for(unsigned i=0, ni=mesh_pt()->nnode(); i<ni; i++)
    {
     Node* nd_pt = mesh_pt()->node_pt(i);
  
     // Output position of node
     for(unsigned j=0; j<Dim; j++)
     {
      output << nd_pt->x(j) << ", ";
     }
  
     // Output ltes of node
     for(unsigned j=0; j<nd_pt->nvalue(); j++)
     {
      // Get timestepper's error estimate for this direction of m
      // at this point.
      double error = nd_pt->time_stepper_pt()->
       temporal_error_in_value(nd_pt, j);
  
      output << error << ", ";
     }
  
     output << std::endl;
    }
   }

References Global_Variables::Dim, calibrate::error, i, j, oomph::Data::nvalue(), oomph::output(), oomph::Data::time_stepper_pt(), and oomph::Node::x().

◆ output_solution() [1/3]

virtual void oomph::MyProblem::output_solution	(	const unsigned &	t,
		std::ostream &	outstream,
		const unsigned &	npoints = `2`
	)		const

inlinevirtual

Standard output function: loop over all elements in all meshes and output.

Reimplemented in oomph::ODEProblem.

   {
    const unsigned n_msh = nsub_mesh();
    for(unsigned msh=0; msh<n_msh; msh++)
    {
     Mesh* msh_pt = mesh_pt(msh);
  
     const unsigned n_ele = msh_pt->nelement();
     for(unsigned ele=0; ele<n_ele; ele++)
     {
      FiniteElement* ele_pt = msh_pt->finite_element_pt(ele);
      ele_pt->output(t, outstream, npoints);
     }
    }
   }

References oomph::Mesh::finite_element_pt(), oomph::Mesh::nelement(), oomph::FiniteElement::output(), and plotPSD::t.

◆ output_solution() [2/3]

virtual void oomph::MyProblem::output_solution ( std::ofstream & soln_file ) const

inlinevirtual

Overload to write any problem specific data.

521 {}

◆ output_solution() [3/3]

void oomph::MyProblem::output_solution	(	std::ostream &	outstream,
		const unsigned &	npoints = `2`
	)		const

inline

output_solution(...) with default output time step = 0 = current time.

   {
    output_solution(0, outstream, npoints);
   }

◆ problem_name()

virtual std::string oomph::MyProblem::problem_name ( ) const

inlinevirtual

764 {return "unknown";}

◆ read()

virtual void oomph::MyProblem::read ( std::ifstream & restart_file )

inlinevirtual

Read refinement pattern of all refineable meshes and refine them accordingly, then read all Data and nodal position info from file for restart.

Reimplemented from oomph::Problem.

   {
    // buffer
    std::string input_string;
  
    // Read in Doc_info number. Read line up to termination sign then
    // ignore.
    getline(restart_file, input_string, '#');
    restart_file.ignore(80,'\n');
    Doc_info.number() = std::atoi(input_string.c_str());
  
    // Read in number of steps taken. Read line up to termination sign
    // then ignore.
    getline(restart_file, input_string, '#');
    restart_file.ignore(80,'\n');
    N_steps_taken = std::atoi(input_string.c_str());
  
    // Let base class handle the rest
    Problem::read(restart_file);
  
    // Decrement doc info number so that it is correct after initial doc
    // Doc_info.number()--;
   }

References GlobalParameters::Doc_info, oomph::Problem::read(), and oomph::Global_string_for_annotation::string().

◆ segregated_pin_indices()

void oomph::MyProblem::segregated_pin_indices ( const Vector< unsigned > & indices )

inline

Pin all dofs with index in node one of indices in all nodes. Uses a different magic pinning number so that it can be easily undone using undo_segregated_pinning(). Does not handle: global data, element data, nodes with varying nvalue.

   {
    for(unsigned msh=0, nmsh=nsub_mesh(); msh<nmsh; msh++)
    {
     Mesh* mesh_pt = this->mesh_pt(msh);
     for(unsigned nd=0, nnd=mesh_pt->nnode(); nd<nnd; nd++)
     {
      Node* nd_pt = mesh_pt->node_pt(nd);
      for(unsigned j=0; j<indices.size(); j++)
      {
       if(!nd_pt->is_pinned(indices[j]))
       {
        nd_pt->eqn_number(indices[j])
     = Data::Is_segregated_solve_pinned;
       }
      }
     }
    }
    // Output information
    oomph_info << "Segregated solve, without indices:\n";
  
    // Loop over the entries of indices and output
    unsigned indices_length=indices.size();
    if (indices_length==0)
    {
     oomph_info << Trace_seperator << "[]";
    }
    else
    {
     oomph_info << Trace_seperator << "[" << indices[0];
     if (indices_length>1)
     {
      for (unsigned i=1;i<indices_length;i++)
      {
       oomph_info << ", " << indices[i];
      }
     }
     oomph_info << "]";
    }
   
    // Output the number of equations
    oomph_info << "Number of equations: " << assign_eqn_numbers()  << std::endl;
   }

References oomph::Data::eqn_number(), i, oomph::Data::is_pinned(), oomph::Data::Is_segregated_solve_pinned, j, oomph::Mesh::nnode(), oomph::Mesh::node_pt(), and oomph::oomph_info.

◆ set_doc_times()

void oomph::MyProblem::set_doc_times ( Vector< double > & doc_times )

inline

Assign a vector of times to output the full solution at.

   {
    Doc_times = doc_times;
   }

◆ set_solver_parameters()

void oomph::MyProblem::set_solver_parameters ( SolverParameters & sp )

inline

   {
    linear_solver_pt() = sp.linear_solver_pt;
  
    // Newton options
    newton_solver_tolerance() = sp.newton_solver_tolerance;
    max_newton_iterations() = sp.max_newton_iterations;
    max_residuals() = sp.max_residuals;
    Shut_up_in_newton_solve = sp.shut_up_in_newton_solve;
    Always_take_one_newton_step = sp.always_take_one_newton_step;
  
    // Linear optimisations
    Jacobian_reuse_is_enabled = sp.jacobian_reuse_is_enabled;
    Jacobian_has_been_computed = sp.jacobian_has_been_computed;
    Problem_is_nonlinear = sp.problem_is_nonlinear;
  
    // Explicit solver
    mass_matrix_solver_for_explicit_timestepper_pt() = sp.mass_matrix_solver_for_explicit_timestepper_pt;
    Mass_matrix_reuse_is_enabled = sp.mass_matrix_reuse_is_enabled;
    Mass_matrix_has_been_computed = sp.mass_matrix_has_been_computed;
    Discontinuous_element_formulation = sp.discontinuous_element_formulation;
   }

◆ set_up_impulsive_initial_condition()

void MyProblem::set_up_impulsive_initial_condition ( )

virtual

Set all history values/dts to be the same as the present values/dt.

  {
  
 #ifdef PARANOID
   if(nglobal_data() != 0)
   {
    std::string err = "Problem has global data which cannot be set from function pt.";
    throw OomphLibError(err, OOMPH_EXCEPTION_LOCATION,
                OOMPH_CURRENT_FUNCTION);
   }
 #endif
   unsigned nprev_steps=this->time_stepper_pt()->nprev_values();
   for(unsigned t=0; t< nprev_steps; t++)
   {
    // Loop over all nodes in all meshes in problem and set values.
    for(unsigned msh=0, nmsh=nsub_mesh(); msh<nmsh; msh++)
    {
     Mesh* mesh_pt = this->mesh_pt(msh);
  
     for(unsigned nd=0, nnd=mesh_pt->nnode(); nd<nnd; nd++)
     {
      Node* nd_pt = mesh_pt->node_pt(nd);
      for(unsigned j=0, nj=nd_pt->nvalue(); j<nj; j++)
      {
       nd_pt->set_value(t, j, nd_pt->value(0, j));
      }
     }
  
 #ifdef PARANOID
     for(unsigned ele=0, nele=mesh_pt->nelement(); ele<nele; ele++)
     {
      FiniteElement* ele_pt = mesh_pt->finite_element_pt(ele);
      if(ele_pt->ninternal_data() != 0)
      {
       std::string err =
        "Element with non-nodal data, cannot set via function...";
       throw OomphLibError(err, OOMPH_EXCEPTION_LOCATION,
               OOMPH_CURRENT_FUNCTION);
      }
     }
 #endif
  
    }
   }
  
   actions_after_set_initial_condition();
  }

References oomph::Mesh::finite_element_pt(), j, oomph::Mesh::nelement(), oomph::GeneralisedElement::ninternal_data(), oomph::Mesh::nnode(), oomph::Mesh::node_pt(), oomph::Data::nvalue(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::Data::set_value(), oomph::Global_string_for_annotation::string(), plotPSD::t, and oomph::Node::value().

◆ should_doc_this_step()

virtual bool oomph::MyProblem::should_doc_this_step	(	const double &	dt,
		const double &	time
	)		const

inlinevirtual

should the previous step be doc'ed? Check if we went past an entry of Doc_times in the last step. If no Doc_times have been set then always output.

   {
    // I'm sure there should be a more efficient way to do this if we
    // know that Doc_times is ordered, but it shouldn't really matter I
    // guess--Jacobian calculation and solve times will always be far
    // far larger than this brute force search.
  
    // If no Doc_times have been set then always output.
    if(Doc_times.empty()) return true;
  
    // Loop over entries of Doc_times and check if they are in the
    // range (t - dt, t].
    for(unsigned j=0; j<Doc_times.size(); j++)
    {
     if(( time >= Doc_times[j]) && ((time - dt) < Doc_times[j]))
     {
      return true;
     }
    }
    return false;
   }

References j.

◆ smart_time_step()

double oomph::MyProblem::smart_time_step	(	double	dt,
		const double &	tol
	)

inline

Do the newton solve or explicit step (different ones depending flags set).

   {
    double step_time_start = TimingHelpers::timer();
  
    // The Newton step itself, adaptive if requested.
    if(explicit_flag())
    {
     explicit_timestep(dt);
    }
    else if(tol != 0.0)
    {
     dt = adaptive_unsteady_newton_solve(dt, tol);
    }
    else
    {
     unsteady_newton_solve(dt);
    }
  
    double step_time_stop = TimingHelpers::timer();
    Total_step_time = step_time_stop - step_time_start;
  
  
    oomph_info << "Time for step " << Total_step_time
           << std::endl;
  
    N_steps_taken++;
  
    return dt;
   }

References oomph::oomph_info, and oomph::TimingHelpers::timer().

◆ trace_values()

virtual Vector<double> oomph::MyProblem::trace_values ( const unsigned & t_hist = 0 ) const

inlinevirtual

Reimplemented in oomph::ODEProblem.

   {
    unsigned nele = mesh_pt()->nelement();
    unsigned e = nele/2;
  
    Vector<double> values;
    if(dynamic_cast<FiniteElement*>(mesh_pt()->element_pt(e)))
    {
     // Just use an element somewhere in the middle...
     Node* nd_pt = mesh_pt()->finite_element_pt(e)->node_pt(0);
     values.assign(nd_pt->nvalue(), 0.0);
     nd_pt->value(t_hist, values);
    }
    else
    {
     // Not finite elements so no idea what to use
     values.assign(1, Dummy_doc_data);
    }
  
    return values;
   }

References e(), oomph::Data::nvalue(), and oomph::Node::value().

◆ undo_segregated_pinning()

void oomph::MyProblem::undo_segregated_pinning ( )

inline

Remove pinning set up by segregated_pin_indices.

   {
    for(unsigned msh=0, nmsh=nsub_mesh(); msh<nmsh; msh++)
    {
     Mesh* mesh_pt = this->mesh_pt(msh);
     for(unsigned nd=0, nnd=mesh_pt->nnode(); nd<nnd; nd++)
     {
      Node* nd_pt = mesh_pt->node_pt(nd);
      for(unsigned j=0; j<nd_pt->nvalue(); j++)
      {
       if(nd_pt->eqn_number(j) == Data::Is_segregated_solve_pinned)
       {
        nd_pt->eqn_number(j) = Data::Is_unclassified;
       }
      }
     }
    }
    oomph_info << "un-segregated n eqn " << assign_eqn_numbers() << std::endl;
   }

References oomph::Data::eqn_number(), oomph::Data::Is_segregated_solve_pinned, oomph::Data::Is_unclassified, j, oomph::Mesh::nnode(), oomph::Mesh::node_pt(), oomph::Data::nvalue(), and oomph::oomph_info.

◆ write_additional_trace_data()

virtual void oomph::MyProblem::write_additional_trace_data	(	const unsigned &	t_hist,
		std::ofstream &	trace_file
	)		const

inlinevirtual

Overload to write problem specific data into trace file. Note: don't add any line endings, seperate data with the Trace_seperator string (BEFORE each data entry).

Reimplemented in oomph::ODEProblem.

512 {}

◆ write_additional_trace_headers()

virtual void oomph::MyProblem::write_additional_trace_headers ( std::ofstream & trace_file ) const

inlinevirtual

Overload to write problem specific headers into trace file. Note: don't add any line endings, seperate headers with the Trace_seperator string (BEFORE each data entry).

Reimplemented in oomph::ODEProblem.

518 {}

◆ write_trace()

void MyProblem::write_trace ( const unsigned & t_hist = 0 )

Write some general data about the previous time step to a trace file. Extend by overloading write_additional_trace_data(...).

  {
   std::ofstream trace_file((Doc_info.directory() + "/" + Trace_filename).c_str(),
                std::ios::app);
   trace_file.precision(Output_precision);
  
   double time = Dummy_doc_data, dt = Dummy_doc_data;
   if(!is_steady())
   {
    time = this->time_pt()->time(t_hist);
    dt = this->time_pt()->dt(t_hist);
   }
  
   // Some values are impossible to get for history values, print dummy
   // values instead.
   double nnewton_iter_taken = Dummy_doc_data,
    lte_norm = Dummy_doc_data,
    real_time = Dummy_doc_data,
    total_step_time = Dummy_doc_data;
  
   Vector<double> solver_iterations(1, Dummy_doc_data),
    solver_times(1, Dummy_doc_data),
    jacobian_setup_times(1, Dummy_doc_data),
    preconditioner_setup_times(1, Dummy_doc_data),
    max_res(1, Dummy_doc_data);
  
   if(t_hist == 0)
   {
    nnewton_iter_taken = Nnewton_iter_taken;
    solver_iterations = Solver_iterations;
    solver_times = Solver_times;
    jacobian_setup_times = Jacobian_setup_times;
    preconditioner_setup_times = Preconditioner_setup_times;
    real_time = std::time(0);
    total_step_time = Total_step_time;
    max_res = Max_res;
  
    if(!is_steady())
    {
     lte_norm = this->lte_norm();
    }
   }
  
   // Write out data that can be done for every problem
   trace_file
    << Doc_info.number()
    << Trace_seperator << time
    << Trace_seperator << dt
    << Trace_seperator << get_error_norm(t_hist)
  
    << Trace_seperator << nnewton_iter_taken;
      
   // Loop over the entries of solver_iterations and output
   unsigned solver_iterations_length=solver_iterations.size();
   if (solver_iterations_length==0)
   {
    trace_file << Trace_seperator << "[]";
   }
   else
   {
    trace_file << Trace_seperator << "[" << solver_iterations[0];
    if (solver_iterations_length>1)
    {
     for (unsigned i=1;i<solver_iterations_length;i++)
     {
      trace_file << ", " << solver_iterations[i];
     }
    }
    trace_file << "]";
   }
     
   // Loop over the entries of solver_times and output
   unsigned solver_times_length=solver_times.size();
   if (solver_times_length==0)
   {
    trace_file << Trace_seperator << "[]";
   }
   else
   {
    trace_file << Trace_seperator << "[" << solver_times[0];
    if (solver_times_length>1)
    {
     for (unsigned i=1;i<solver_times_length;i++)
     {
      trace_file << ", " << solver_times[i];
     }
    }
    trace_file << "]";
   }
     
   // Loop over the entries of jacobian_setup_times and output
   unsigned jacobian_setup_times_length=jacobian_setup_times.size();
   if (jacobian_setup_times_length==0)
   {
    trace_file << Trace_seperator << "[]";
   }
   else
   {
    trace_file << Trace_seperator << "[" << jacobian_setup_times[0];
    if (jacobian_setup_times_length>1)
    {
     for (unsigned i=1;i<jacobian_setup_times_length;i++)
     {
      trace_file << ", " << jacobian_setup_times[i];
     }
    }
    trace_file << "]";
   }
     
   // Loop over the entries of preconditioner_setup_times and output
   unsigned preconditioner_setup_times_length=preconditioner_setup_times.size();
   if (preconditioner_setup_times_length==0)
   {
    trace_file << Trace_seperator << "[]";
   }
   else
   {
    trace_file << Trace_seperator << "[" << preconditioner_setup_times[0];
    if (preconditioner_setup_times_length>1)
    {
     for (unsigned i=1;i<preconditioner_setup_times_length;i++)
     {
      trace_file << ", " << preconditioner_setup_times[i];
     }
    }
    trace_file << "]";
   }
  
   trace_file << Trace_seperator << lte_norm;
  
   // Create a temporary vector
   Vector<double> output_vector=trace_values(t_hist);
  
   // Loop over the entries of output_vector and output
   unsigned output_vector_length=output_vector.size();
   if (output_vector_length==0)
   {
    trace_file << Trace_seperator << "[]";
   }
   else
   {
    trace_file << Trace_seperator << "[" << output_vector[0];
    if (output_vector_length>1)
    {
     for (unsigned i=1;i<output_vector_length;i++)
     {
      trace_file << ", " << output_vector[i];
     }
    }
    trace_file << "]";
   }
   
   trace_file << Trace_seperator << real_time;
  
   // Loop over the entries of output_vector and output
   unsigned max_res_length=max_res.size();
   if (max_res_length==0)
   {
    trace_file << Trace_seperator << "[]";
   }
   else
   {
    trace_file << Trace_seperator << "[" << max_res[0];
    if (max_res_length>1)
    {
     for (unsigned i=1;i<max_res_length;i++)
     {
      trace_file << ", " << max_res[i];
     }
    }
    trace_file << "]";
   }
     
   trace_file << Trace_seperator << get_solution_norm(t_hist)
          << Trace_seperator << total_step_time
      
    // Reserved slots in case I think of more things to add later
          << Trace_seperator << Dummy_doc_data
          << Trace_seperator << Dummy_doc_data
          << Trace_seperator << Dummy_doc_data
          << Trace_seperator << Dummy_doc_data
          << Trace_seperator << Dummy_doc_data
          << Trace_seperator << Dummy_doc_data;
  
  
   // Add problem specific data
   write_additional_trace_data(t_hist, trace_file);
  
   // Finish off this line
   trace_file << std::endl;
   trace_file.close();
  }

References GlobalParameters::Doc_info, i, and output_vector().

Member Data Documentation

◆ Always_write_trace

bool oomph::MyProblem::Always_write_trace

Should we output to trace file every step?

Referenced by oomph::ODEProblem::ODEProblem().

◆ Dim

unsigned oomph::MyProblem::Dim

protected

◆ Disable_mass_matrix_solver_optimisations

bool oomph::MyProblem::Disable_mass_matrix_solver_optimisations

Option to turn off optimisation of the linear solves needed for explicit timestepping (for debugging purposes).

◆ Doc_info

MyDocInfo oomph::MyProblem::Doc_info

◆ Doc_times

Vector<double> oomph::MyProblem::Doc_times

private

Times at which we want to output the full solution.

◆ Dummy_doc_data

double oomph::MyProblem::Dummy_doc_data

protected

◆ Dump

bool oomph::MyProblem::Dump

Should we dump ready for a restart?

◆ Error_norm_limit

double oomph::MyProblem::Error_norm_limit

◆ Exact_solution_pt

SolutionFunctorBase* oomph::MyProblem::Exact_solution_pt

Function pointer for exact solution.

◆ Info_filename

std::string oomph::MyProblem::Info_filename

◆ Jacobian_setup_times

Vector<double> oomph::MyProblem::Jacobian_setup_times

private

◆ N_steps_taken

unsigned oomph::MyProblem::N_steps_taken

◆ Output_initial_condition

bool oomph::MyProblem::Output_initial_condition

Should we write output for initial conditions as though they are time steps as well?

◆ Output_ltes

bool oomph::MyProblem::Output_ltes

Should we output the local truncation error at each node as well?

◆ Output_precision

unsigned oomph::MyProblem::Output_precision

◆ Output_predictor_values

bool oomph::MyProblem::Output_predictor_values

Should we output the predicted values too?

◆ Preconditioner_setup_times

Vector<double> oomph::MyProblem::Preconditioner_setup_times

private

◆ Should_doc_boundaries

bool oomph::MyProblem::Should_doc_boundaries

Should we output the locations of the boundary nodes?

◆ Solution_norm_limit

double oomph::MyProblem::Solution_norm_limit

◆ Solver_iterations

Vector<double> oomph::MyProblem::Solver_iterations

private

◆ Solver_times

Vector<double> oomph::MyProblem::Solver_times

private

◆ Total_step_time

double oomph::MyProblem::Total_step_time

◆ Trace_filename

std::string oomph::MyProblem::Trace_filename

◆ Trace_seperator

const std::string oomph::MyProblem::Trace_seperator

protected

String to insert between fields in trace file. Use "; " by default (so that "," or " " can be used for lists if needed).

Referenced by oomph::ODEProblem::output_solution(), oomph::ODEProblem::write_additional_trace_data(), and oomph::ODEProblem::write_additional_trace_headers().

◆ Want_doc_exact

bool oomph::MyProblem::Want_doc_exact

Should we try to output exact solution?

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

my_problem.h

Public Member Functions

Public Attributes

Protected Attributes

Private Member Functions

Private Attributes

Additional Inherited Members

Constructor & Destructor Documentation

◆ MyProblem() [1/2]

◆ ~MyProblem()

◆ MyProblem() [2/2]

Member Function Documentation

◆ actions_after_explicit_stage()

◆ actions_after_explicit_timestep()

◆ actions_after_implicit_timestep()

◆ actions_after_newton_step()

◆ actions_after_set_initial_condition()

◆ actions_before_explicit_stage()

◆ actions_before_explicit_timestep()

◆ actions_before_implicit_timestep()

◆ actions_before_newton_solve()

◆ actions_before_newton_step()

◆ actions_before_time_integration()

◆ build()

◆ check_norm_limits()

◆ check_not_segregated()

◆ dim()

◆ doc_boundaries()

◆ doc_exact()

◆ doc_solution()

◆ dump()

◆ dump_current_mm_or_jacobian_residuals()

◆ exact_solution()

◆ explicit_flag()

◆ final_doc()

◆ final_doc_additional()

◆ finished()

◆ get_error_norm()

◆ get_solution_norm()

◆ get_solver_parameters()

◆ initial_doc()

◆ initial_doc_additional()

◆ integrate_over_problem()

◆ is_steady()

◆ iterative_linear_solver_pt()

◆ lte_norm()

◆ min_element_size()

◆ my_set_initial_condition()

◆ nnewton_step_this_solve()

◆ operator=()

◆ output_exact_solution()

◆ output_ltes()

◆ output_solution() [1/3]

◆ output_solution() [2/3]

◆ output_solution() [3/3]

◆ problem_name()

◆ read()

◆ segregated_pin_indices()

◆ set_doc_times()

◆ set_solver_parameters()

◆ set_up_impulsive_initial_condition()

◆ should_doc_this_step()

◆ smart_time_step()

◆ trace_values()

◆ undo_segregated_pinning()

◆ write_additional_trace_data()

◆ write_additional_trace_headers()

◆ write_trace()

Member Data Documentation

◆ Always_write_trace

◆ Dim

◆ Disable_mass_matrix_solver_optimisations

◆ Doc_info

◆ Doc_times

◆ Dummy_doc_data

◆ Dump

◆ Error_norm_limit

◆ Exact_solution_pt

◆ Info_filename

◆ Jacobian_setup_times

◆ N_steps_taken