#include <problem.h>

Inheritance diagram for oomph::Problem:

Public Types
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 Member Functions
virtual void	debug_hook_fct (const unsigned &i)

void	set_analytic_dparameter (double *const &parameter_pt)

void	unset_analytic_dparameter (double *const &parameter_pt)

bool	is_dparameter_calculated_analytically (double *const &parameter_pt)

void	set_analytic_hessian_products ()

void	unset_analytic_hessian_products ()

bool	are_hessian_products_calculated_analytically ()

void	set_pinned_values_to_zero ()

bool	distributed () const

virtual void	actions_before_adapt ()

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

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

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

	Problem ()

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

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

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

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

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

Mesh *&	mesh_pt (const unsigned &imesh)

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

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

unsigned	add_sub_mesh (Mesh *const &mesh_pt)

void	flush_sub_meshes ()

void	build_global_mesh ()

void	rebuild_global_mesh ()

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

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

LinearSolver *&	mass_matrix_solver_for_explicit_timestepper_pt ()

LinearSolver *	mass_matrix_solver_for_explicit_timestepper_pt () const

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

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

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

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

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

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

TimeStepper *&	time_stepper_pt ()

const TimeStepper *	time_stepper_pt () const

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

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

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

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

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

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

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

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

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

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

double &	max_residuals ()

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

double &	newton_solver_tolerance ()

void	add_time_stepper_pt (TimeStepper *const &time_stepper_pt)

void	set_explicit_time_stepper_pt (ExplicitTimeStepper *const &explicit_time_stepper_pt)

void	initialise_dt (const double &dt)

void	initialise_dt (const Vector< double > &dt)

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

void	add_global_data (Data *const &global_data_pt)

void	flush_global_data ()

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

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

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

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

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

void	enable_store_local_dof_pt_in_elements ()

void	disable_store_local_dof_pt_in_elements ()

unsigned long	assign_eqn_numbers (const bool &assign_local_eqn_numbers=true)

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

void	enable_discontinuous_formulation ()

void	disable_discontinuous_formulation ()

void	get_dofs (DoubleVector &dofs) const

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

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

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

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

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

double *	global_dof_pt (const unsigned &i)

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

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

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

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

virtual void	get_inverse_mass_matrix_times_residuals (DoubleVector &Mres)

virtual void	get_dvaluesdt (DoubleVector &f)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void	enable_jacobian_reuse ()

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

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

bool &	use_predictor_values_as_initial_guess ()

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

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

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

void	newton_solve (unsigned const &max_adapt)

void	steady_newton_solve (unsigned const &max_adapt=0)

void	copy (Problem *orig_problem_pt)

virtual Problem *	make_copy ()

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

virtual void	read (std::ifstream &restart_file)

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

void	dump (const std::string &dump_file_name) const

void	delete_all_external_storage ()

virtual void	symmetrise_eigenfunction_for_adaptive_pitchfork_tracking ()

double *	bifurcation_parameter_pt () const

void	get_bifurcation_eigenfunction (Vector< DoubleVector > &eigenfunction)

void	activate_fold_tracking (double *const &parameter_pt, const bool &block_solve=true)

void	activate_bifurcation_tracking (double *const &parameter_pt, const DoubleVector &eigenvector, const bool &block_solve=true)

void	activate_bifurcation_tracking (double *const &parameter_pt, const DoubleVector &eigenvector, const DoubleVector &normalisation, const bool &block_solve=true)

void	activate_pitchfork_tracking (double *const &parameter_pt, const DoubleVector &symmetry_vector, const bool &block_solve=true)

void	activate_hopf_tracking (double *const &parameter_pt, const bool &block_solve=true)

void	activate_hopf_tracking (double *const &parameter_pt, const double &omega, const DoubleVector &null_real, const DoubleVector &null_imag, const bool &block_solve=true)

void	deactivate_bifurcation_tracking ()

void	reset_assembly_handler_to_default ()
	Reset the system to the standard non-augemented state. More...

double	arc_length_step_solve (double *const &parameter_pt, const double &ds, const unsigned &max_adapt=0)

double	arc_length_step_solve (Data *const &data_pt, const unsigned &data_index, const double &ds, const unsigned &max_adapt=0)

void	reset_arc_length_parameters ()

int &	sign_of_jacobian ()

void	explicit_timestep (const double &dt, const bool &shift_values=true)
	Take an explicit timestep of size dt. More...

void	unsteady_newton_solve (const double &dt)

void	unsteady_newton_solve (const double &dt, const bool &shift_values)

void	unsteady_newton_solve (const double &dt, const unsigned &max_adapt, const bool &first, const bool &shift=true)

double	doubly_adaptive_unsteady_newton_solve (const double &dt, const double &epsilon, const unsigned &max_adapt, const bool &first, const bool &shift=true)

double	doubly_adaptive_unsteady_newton_solve (const double &dt, const double &epsilon, const unsigned &max_adapt, const unsigned &suppress_resolve_after_spatial_adapt_flag, const bool &first, const bool &shift=true)

double	adaptive_unsteady_newton_solve (const double &dt_desired, const double &epsilon)

double	adaptive_unsteady_newton_solve (const double &dt_desired, const double &epsilon, const bool &shift_values)

void	assign_initial_values_impulsive ()

void	assign_initial_values_impulsive (const double &dt)

void	calculate_predictions ()
	Calculate predictions. More...

void	enable_mass_matrix_reuse ()

void	disable_mass_matrix_reuse ()

bool	mass_matrix_reuse_is_enabled ()
	Return whether the mass matrix is being reused. More...

void	refine_uniformly (const Vector< unsigned > &nrefine_for_mesh)

void	refine_uniformly (const Vector< unsigned > &nrefine_for_mesh, DocInfo &doc_info)

void	refine_uniformly_and_prune (const Vector< unsigned > &nrefine_for_mesh)

void	refine_uniformly_and_prune (const Vector< unsigned > &nrefine_for_mesh, DocInfo &doc_info)

void	refine_uniformly (DocInfo &doc_info)

void	refine_uniformly_and_prune (DocInfo &doc_info)

void	refine_uniformly ()

void	refine_uniformly (const unsigned &i_mesh, DocInfo &doc_info)
	Do uniform refinement for submesh i_mesh with documentation. More...

void	refine_uniformly (const unsigned &i_mesh)
	Do uniform refinement for submesh i_mesh without documentation. More...

void	p_refine_uniformly (const Vector< unsigned > &nrefine_for_mesh)

void	p_refine_uniformly (const Vector< unsigned > &nrefine_for_mesh, DocInfo &doc_info)

void	p_refine_uniformly_and_prune (const Vector< unsigned > &nrefine_for_mesh)

void	p_refine_uniformly_and_prune (const Vector< unsigned > &nrefine_for_mesh, DocInfo &doc_info)

void	p_refine_uniformly (DocInfo &doc_info)

void	p_refine_uniformly_and_prune (DocInfo &doc_info)

void	p_refine_uniformly ()

void	p_refine_uniformly (const unsigned &i_mesh, DocInfo &doc_info)
	Do uniform p-refinement for submesh i_mesh with documentation. More...

void	p_refine_uniformly (const unsigned &i_mesh)
	Do uniform p-refinement for submesh i_mesh without documentation. More...

void	refine_selected_elements (const Vector< unsigned > &elements_to_be_refined)

void	refine_selected_elements (const Vector< RefineableElement * > &elements_to_be_refined_pt)

void	refine_selected_elements (const unsigned &i_mesh, const Vector< unsigned > &elements_to_be_refined)

void	refine_selected_elements (const unsigned &i_mesh, const Vector< RefineableElement * > &elements_to_be_refined_pt)

void	refine_selected_elements (const Vector< Vector< unsigned >> &elements_to_be_refined)

void	refine_selected_elements (const Vector< Vector< RefineableElement * >> &elements_to_be_refined_pt)

void	p_refine_selected_elements (const Vector< unsigned > &elements_to_be_refined)

void	p_refine_selected_elements (const Vector< PRefineableElement * > &elements_to_be_refined_pt)

void	p_refine_selected_elements (const unsigned &i_mesh, const Vector< unsigned > &elements_to_be_refined)

void	p_refine_selected_elements (const unsigned &i_mesh, const Vector< PRefineableElement * > &elements_to_be_refined_pt)

void	p_refine_selected_elements (const Vector< Vector< unsigned >> &elements_to_be_refined)

void	p_refine_selected_elements (const Vector< Vector< PRefineableElement * >> &elements_to_be_refined_pt)

unsigned	unrefine_uniformly ()

unsigned	unrefine_uniformly (const unsigned &i_mesh)

void	p_unrefine_uniformly (DocInfo &doc_info)

void	p_unrefine_uniformly (const unsigned &i_mesh, DocInfo &doc_info)
	Do uniform p-unrefinement for submesh i_mesh without documentation. More...

void	adapt (unsigned &n_refined, unsigned &n_unrefined)

void	adapt ()

void	p_adapt (unsigned &n_refined, unsigned &n_unrefined)

void	p_adapt ()

void	adapt_based_on_error_estimates (unsigned &n_refined, unsigned &n_unrefined, Vector< Vector< double >> &elemental_error)

void	adapt_based_on_error_estimates (Vector< Vector< double >> &elemental_error)

void	get_all_error_estimates (Vector< Vector< double >> &elemental_error)

void	doc_errors (DocInfo &doc_info)
	Get max and min error for all elements in submeshes. More...

void	doc_errors ()
	Get max and min error for all elements in submeshes. More...

void	enable_info_in_newton_solve ()

void	disable_info_in_newton_solve ()
	Disable the output of information when in the newton solver. More...

Public Member Functions inherited from oomph::ExplicitTimeSteppableObject
	ExplicitTimeSteppableObject ()
	Empty constructor. More...

	ExplicitTimeSteppableObject (const ExplicitTimeSteppableObject &)=delete
	Broken copy constructor. More...

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

virtual	~ExplicitTimeSteppableObject ()
	Empty destructor. More...

virtual void	actions_before_explicit_stage ()

virtual void	actions_after_explicit_stage ()

Public Attributes
bool	Shut_up_in_newton_solve

Static Public Attributes
static bool	Suppress_warning_about_actions_before_read_unstructured_meshes

Protected Types
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
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_solve ()

virtual void	actions_after_newton_solve ()

virtual void	actions_before_newton_convergence_check ()

virtual void	actions_before_newton_step ()

virtual void	actions_after_newton_step ()

virtual void	actions_before_implicit_timestep ()

virtual void	actions_after_implicit_timestep ()

virtual void	actions_after_implicit_timestep_and_error_estimation ()

virtual void	actions_before_explicit_timestep ()
	Actions that should be performed before each explicit time step. More...

virtual void	actions_after_explicit_timestep ()
	Actions that should be performed after each explicit time step. More...

virtual void	actions_before_read_unstructured_meshes ()

virtual void	actions_after_read_unstructured_meshes ()

virtual void	actions_after_change_in_global_parameter (double *const &parameter_pt)

virtual void	actions_after_change_in_bifurcation_parameter ()

virtual void	actions_after_parameter_increase (double *const &parameter_pt)

double &	dof_derivative (const unsigned &i)

double &	dof_current (const unsigned &i)

virtual void	set_initial_condition ()

virtual double	global_temporal_error_norm ()

unsigned	newton_solve_continuation (double *const &parameter_pt)

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

void	calculate_continuation_derivatives (double *const &parameter_pt)

void	calculate_continuation_derivatives (const DoubleVector &z)

void	calculate_continuation_derivatives_fd (double *const &parameter_pt)

bool	does_pointer_correspond_to_problem_data (double *const &parameter_pt)

void	set_consistent_pinned_values_for_continuation ()

Protected Attributes
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
static ContinuationStorageScheme	Continuation_time_stepper
	Storage for the single static continuation timestorage object. More...

Private Member Functions
double	doubly_adaptive_unsteady_newton_solve_helper (const double &dt, const double &epsilon, const unsigned &max_adapt, const unsigned &suppress_resolve_after_spatial_adapt, const bool &first, const bool &shift=true)

void	refine_uniformly_aux (const Vector< unsigned > &nrefine_for_mesh, DocInfo &doc_info, const bool &prune)

void	p_refine_uniformly_aux (const Vector< unsigned > &nrefine_for_mesh, DocInfo &doc_info, const bool &prune)

void	setup_base_mesh_info_after_pruning ()

virtual void	sparse_assemble_row_or_column_compressed_with_vectors_of_pairs (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	sparse_assemble_row_or_column_compressed_with_two_vectors (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	sparse_assemble_row_or_column_compressed_with_maps (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	sparse_assemble_row_or_column_compressed_with_lists (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	sparse_assemble_row_or_column_compressed_with_two_arrays (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)

void	calculate_continuation_derivatives_helper (const DoubleVector &z)

void	calculate_continuation_derivatives_fd_helper (double *const &parameter_pt)

void	bifurcation_adapt_helper (unsigned &n_refined, unsigned &n_unrefined, const unsigned &bifurcation_type, const bool &actually_adapt=true)

void	bifurcation_adapt_doc_errors (const unsigned &bifurcation_type)

void	globally_convergent_line_search (const Vector< double > &x_old, const double &half_residual_squared_old, DoubleVector &gradient, DoubleVector &newton_dir, double &half_residual_squared, const double &stpmax)
	Line search helper for globally convergent Newton method. More...

double	arc_length_step_solve_helper (double *const &parameter_pt, const double &ds, const unsigned &max_adapt)

Private Attributes
Mesh *	Mesh_pt
	The mesh pointer. More...

Vector< Mesh * >	Sub_mesh_pt
	Vector of pointers to submeshes. More...

LinearSolver *	Linear_solver_pt
	Pointer to the linear solver for the problem. More...

LinearSolver *	Mass_matrix_solver_for_explicit_timestepper_pt

EigenSolver *	Eigen_solver_pt
	Pointer to the eigen solver for the problem. More...

AssemblyHandler *	Assembly_handler_pt

LinearSolver *	Default_linear_solver_pt
	Pointer to the default linear solver. More...

EigenSolver *	Default_eigen_solver_pt
	Pointer to the default eigensolver. More...

AssemblyHandler *	Default_assembly_handler_pt
	Pointer to the default assembly handler. More...

Time *	Time_pt
	Pointer to global time for the problem. More...

Vector< TimeStepper * >	Time_stepper_pt

ExplicitTimeStepper *	Explicit_time_stepper_pt
	Pointer to a single explicit timestepper. More...

Vector< double > *	Saved_dof_pt
	Pointer to vector for backup of dofs. More...

bool	Default_set_initial_condition_called

bool	Use_globally_convergent_newton_method
	Use the globally convergent newton method. More...

bool	Empty_actions_before_read_unstructured_meshes_has_been_called

bool	Empty_actions_after_read_unstructured_meshes_has_been_called

bool	Store_local_dof_pt_in_elements

bool	Use_predictor_values_as_initial_guess
	Use values from the time stepper predictor as an initial guess. More...

Vector< Data * >	Global_data_pt

Friends
class	FoldHandler

class	PitchForkHandler

class	HopfHandler

template<unsigned NNODE_1D>
class	PeriodicOrbitAssemblyHandler

class	BlockFoldLinearSolver

class	BlockPitchForkLinearSolver

class	AugmentedBlockFoldLinearSolver

class	AugmentedBlockPitchForkLinearSolver

class	BlockHopfLinearSolver

Detailed Description

////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////// The Problem class

The main components of a Problem are:

a pointer to the (global) Mesh (which provides ordered access to the nodes, elements, etc of all submeshes in the problem – if there are any)
pointers to the submeshes (if there are any)
pointers to any global Data
a pointer to the global Time
pointers to the Timestepper used in the problem
a pointer to the linear solver that will be used in Newton's method
pointers to all DOFs in the problem.

Obviously, at this level in the code hierarchy, many things become very problem-dependent but when setting up a specific problem (as a class that inherits from Problem), the problem constructor will/should typically have a structure similar to this:

// Set up a timestepper
 TimeStepper* time_stepper_pt=new Steady;
 
// Add timestepper to problem
 add_time_stepper_pt(time_stepper_pt);
 
// Build and assign mesh
 Problem::mesh_pt() = new
 SomeMesh<ELEMENT_TYPE>(Nelement,time_stepper_pt);
 
// Set the boundary conditions for this problem: All nodes are
// free by default -- just pin the ones that have Dirichlet conditions
// here (boundary 0 in this example)
unsigned i_bound = 0
unsigned num_nod= mesh_pt()->nboundary_node(ibound);
  for (unsigned inod=0;inod<num_nod;inod++)
   {
     mesh_pt()->boundary_node_pt(ibound,inod)->pin(0);
   }
 
// Complete the build of all elements so they are fully functional
 
 // Setup equation numbering scheme
 oomph_info <<"Number of equations: " << assign_eqn_numbers() <<
 std::endl;

For time-dependent problems, we can then use

assign_initial_values_impulsive ();

oomph::Problem::assign_initial_values_impulsive

void assign_initial_values_impulsive()

Definition: problem.cc:11499

to generate an initial guess (for an impulsive start) and the problem can then be solved, e.g. using the steady or unsteady Newton solvers

newton_solve()

oomph::Problem::newton_solve

void newton_solve()

Use Newton method to solve the problem.

Definition: problem.cc:8783

or

unsteady_newton_solve(...)

oomph::Problem::unsteady_newton_solve

void unsteady_newton_solve(const double &dt)

Definition: problem.cc:10953

Member Typedef Documentation

◆ SpatialErrorEstimatorFctPt

typedef void(* oomph::Problem::SpatialErrorEstimatorFctPt) (Mesh *&mesh_pt, Vector< double > &elemental_error)

Function pointer for spatial error estimator.

◆ SpatialErrorEstimatorWithDocFctPt

typedef void(* oomph::Problem::SpatialErrorEstimatorWithDocFctPt) (Mesh *&mesh_pt, Vector< double > &elemental_error, DocInfo &doc_info)

Function pointer for spatial error estimator with doc.

Member Enumeration Documentation

◆ Assembly_method

enum oomph::Problem::Assembly_method

protected

Enumerated flags to determine which sparse assembly method is used.

Enumerator
Perform_assembly_using_vectors_of_pairs
Perform_assembly_using_two_vectors
Perform_assembly_using_maps
Perform_assembly_using_lists
Perform_assembly_using_two_arrays

     {
       Perform_assembly_using_vectors_of_pairs,
       Perform_assembly_using_two_vectors,
       Perform_assembly_using_maps,
       Perform_assembly_using_lists,
       Perform_assembly_using_two_arrays
     };

Constructor & Destructor Documentation

◆ Problem() [1/2]

Problem::Problem ( )

Constructor: Allocate space for one time stepper and set all pointers to NULL and set defaults for all parameters.

Setup terminate helper

     : Mesh_pt(0),
       Time_pt(0),
       Explicit_time_stepper_pt(0),
       Saved_dof_pt(0),
       Default_set_initial_condition_called(false),
       Use_globally_convergent_newton_method(false),
       Empty_actions_before_read_unstructured_meshes_has_been_called(false),
       Empty_actions_after_read_unstructured_meshes_has_been_called(false),
       Store_local_dof_pt_in_elements(false),
       Calculate_hessian_products_analytic(false),
 #ifdef OOMPH_HAS_MPI
       Doc_imbalance_in_parallel_assembly(false),
       Use_default_partition_in_load_balance(false),
       Must_recompute_load_balance_for_assembly(true),
       Halo_scheme_pt(0),
 #endif
       Relaxation_factor(1.0),
       Newton_solver_tolerance(1.0e-8),
       Max_newton_iterations(10),
       Nnewton_iter_taken(0),
       Max_residuals(10.0),
       Time_adaptive_newton_crash_on_solve_fail(false),
       Jacobian_reuse_is_enabled(false),
       Jacobian_has_been_computed(false),
       Problem_is_nonlinear(true),
       Pause_at_end_of_sparse_assembly(false),
       Doc_time_in_distribute(false),
       Sparse_assembly_method(Perform_assembly_using_vectors_of_pairs),
       Sparse_assemble_with_arrays_initial_allocation(400),
       Sparse_assemble_with_arrays_allocation_increment(150),
       Numerical_zero_for_sparse_assembly(0.0),
       FD_step_used_in_get_hessian_vector_products(1.0e-8),
       Mass_matrix_reuse_is_enabled(false),
       Mass_matrix_has_been_computed(false),
       Discontinuous_element_formulation(false),
       Minimum_dt(1.0e-12),
       Maximum_dt(1.0e12),
       DTSF_max_increase(4.0),
       DTSF_min_decrease(0.8),
       Minimum_dt_but_still_proceed(-1.0),
       Scale_arc_length(true),
       Desired_proportion_of_arc_length(0.5),
       Theta_squared(1.0),
       Sign_of_jacobian(0),
       Continuation_direction(1.0),
       Parameter_derivative(1.0),
       Parameter_current(0.0),
       Use_continuation_timestepper(false),
       Dof_derivative_offset(1),
       Dof_current_offset(2),
       Ds_current(0.0),
       Desired_newton_iterations_ds(5),
       Minimum_ds(1.0e-10),
       Bifurcation_detection(false),
       Bisect_to_find_bifurcation(false),
       First_jacobian_sign_change(false),
       Arc_length_step_taken(false),
       Use_finite_differences_for_continuation_derivatives(false),
 #ifdef OOMPH_HAS_MPI
       Dist_problem_matrix_distribution(Uniform_matrix_distribution),
       Parallel_sparse_assemble_previous_allocation(0),
       Problem_has_been_distributed(false),
       Bypass_increase_in_dof_check_during_pruning(false),
       Max_permitted_error_for_halo_check(1.0e-14),
 #endif
       Shut_up_in_newton_solve(false),
       Always_take_one_newton_step(false),
       Timestep_reduction_factor_after_nonconvergence(0.5),
       Keep_temporal_error_below_tolerance(true)
   {
     Use_predictor_values_as_initial_guess = false;
  
     TerminateHelper::setup();
  
     // By default no submeshes:
     Sub_mesh_pt.resize(0);
     // No timesteppers
     Time_stepper_pt.resize(0);
  
     // Set the linear solvers, eigensolver and assembly handler
     Linear_solver_pt = Default_linear_solver_pt = new SuperLUSolver;
     Mass_matrix_solver_for_explicit_timestepper_pt = Linear_solver_pt;
  
     Eigen_solver_pt = Default_eigen_solver_pt = new ARPACK;
  
     Assembly_handler_pt = Default_assembly_handler_pt = new AssemblyHandler;
  
     // setup the communicator
 #ifdef OOMPH_HAS_MPI
     if (MPI_Helpers::mpi_has_been_initialised())
     {
       Communicator_pt = new OomphCommunicator(MPI_Helpers::communicator_pt());
     }
     else
     {
       Communicator_pt = new OomphCommunicator();
     }
 #else
     Communicator_pt = new OomphCommunicator();
 #endif
  
     // just create an empty linear algebra distribution for the
     // DOFs
     // this is setup when assign_eqn_numbers(...) is called.
     Dof_distribution_pt = new LinearAlgebraDistribution;
   }

References Assembly_handler_pt, oomph::MPI_Helpers::communicator_pt(), Communicator_pt, Default_assembly_handler_pt, Default_eigen_solver_pt, Default_linear_solver_pt, Dof_distribution_pt, Eigen_solver_pt, Linear_solver_pt, Mass_matrix_solver_for_explicit_timestepper_pt, oomph::MPI_Helpers::mpi_has_been_initialised(), oomph::TerminateHelper::setup(), Sub_mesh_pt, Time_stepper_pt, and Use_predictor_values_as_initial_guess.

◆ Problem() [2/2]

oomph::Problem::Problem ( const Problem & dummy )

delete

Broken copy constructor.

◆ ~Problem()

Problem::~Problem ( )

virtual

Virtual destructor to clean up memory.

Destructor to clean up memory.

   {
     // Delete the memory assigned for the global time
     // (it's created on the fly in Problem::add_time_stepper_pt()
     // so we are entitled to delete it.
     if (Time_pt != 0)
     {
       delete Time_pt;
       Time_pt = 0;
     }
  
     // We're not using the default linear solver,
     // somebody else must have built it, so that person
     // must be in charge of killing it.
     // We can safely delete the defaults, however
     delete Default_linear_solver_pt;
  
     delete Default_eigen_solver_pt;
     delete Default_assembly_handler_pt;
     delete Communicator_pt;
     delete Dof_distribution_pt;
  
     // Delete any copies of the problem that have been created for
     // use in adaptive bifurcation tracking.
     // ALH: This will eventually go
     unsigned n_copies = Copy_of_problem_pt.size();
     for (unsigned c = 0; c < n_copies; c++)
     {
       delete Copy_of_problem_pt[c];
     }
  
     // if this problem has sub meshes then we must delete the Mesh_pt
     if (Sub_mesh_pt.size() != 0)
     {
       Mesh_pt->flush_element_and_node_storage();
       delete Mesh_pt;
     }
  
     // Since we called the TerminateHelper setup function in the constructor,
     // we need to delete anything that was dynamically allocated (as it's
     // just a namespace and so doesn't have it's own destructor) in the function
     TerminateHelper::clean_up_memory();
   }

References calibrate::c, oomph::TerminateHelper::clean_up_memory(), Communicator_pt, Copy_of_problem_pt, Default_assembly_handler_pt, Default_eigen_solver_pt, Default_linear_solver_pt, Dof_distribution_pt, oomph::Mesh::flush_element_and_node_storage(), Mesh_pt, Sub_mesh_pt, and Time_pt.

Member Function Documentation

◆ actions_after_adapt()

virtual void oomph::Problem::actions_after_adapt ( )

inlinevirtual

Actions that are to be performed after a mesh adaptation.

1025 {}

Referenced by adapt(), adapt_based_on_error_estimates(), p_adapt(), p_refine_selected_elements(), p_refine_uniformly(), p_refine_uniformly_aux(), p_unrefine_uniformly(), read(), refine_selected_elements(), refine_uniformly(), refine_uniformly_aux(), oomph::MGSolver< DIM >::setup_mg_hierarchy(), oomph::HelmholtzMGPreconditioner< DIM >::setup_mg_hierarchy(), and unrefine_uniformly().

◆ actions_after_change_in_bifurcation_parameter()

virtual void oomph::Problem::actions_after_change_in_bifurcation_parameter ( )

inlineprotectedvirtual

Actions that are to be performed after a change in the parameter that is being varied as part of the solution of a bifurcation detection problem. The default is to call actions_before_newton_solve(), actions_before_newton_convergence_check() and actions_after_newton_solve(). This could be amazingly inefficient in certain problems and should be overloaded in such cases. An example would be when a remesh is required in general, but the global parameter does not affect the mesh directly.

Reimplemented in RotatingProblem< ELEMENT >, RotatingProblem< ELEMENT >, and RefineablePorousChannelProblem< ELEMENT >.

     {
       // Default action should cover all possibilities
       actions_before_newton_solve();
       actions_before_newton_convergence_check();
       actions_after_newton_solve();
     }

References actions_after_newton_solve(), actions_before_newton_convergence_check(), and actions_before_newton_solve().

Referenced by oomph::FoldHandler::get_jacobian(), oomph::PitchForkHandler::get_jacobian(), oomph::HopfHandler::get_jacobian(), oomph::AugmentedBlockFoldLinearSolver::resolve(), oomph::AugmentedBlockPitchForkLinearSolver::resolve(), oomph::AugmentedBlockFoldLinearSolver::solve(), oomph::AugmentedBlockPitchForkLinearSolver::solve(), oomph::BlockHopfLinearSolver::solve(), and oomph::BlockHopfLinearSolver::solve_for_two_rhs().

◆ actions_after_change_in_global_parameter()

virtual void oomph::Problem::actions_after_change_in_global_parameter ( double *const & parameter_pt )

inlineprotectedvirtual

Actions that are to be performed when the global parameter addressed by parameter_pt has been changed in the function get_derivative_wrt_global_parameter() The default is to call actions_before_newton_solve(), actions_before_newton_convergence_check() and actions_after_newton_solve(). This could be amazingly inefficient in certain problems and should be overloaded in such cases. An example would be when a remesh is required in general, but the global parameter does not affect the mesh directly.

Reimplemented in AirwayReopeningProblem< ELEMENT >.

     {
       // Default action should cover all possibilities
       actions_before_newton_solve();
       actions_before_newton_convergence_check();
       actions_after_newton_solve();
     }

References actions_after_newton_solve(), actions_before_newton_convergence_check(), and actions_before_newton_solve().

Referenced by get_derivative_wrt_global_parameter().

◆ actions_after_explicit_timestep()

virtual void oomph::Problem::actions_after_explicit_timestep ( )

inlineprotectedvirtual

Actions that should be performed after each explicit time step.

Reimplemented from oomph::ExplicitTimeSteppableObject.

Reimplemented in oomph::MyProblem.

1081 {}

◆ actions_after_implicit_timestep()

virtual void oomph::Problem::actions_after_implicit_timestep ( )

inlineprotectedvirtual

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

1070 {}

Referenced by adaptive_unsteady_newton_solve(), unsteady_newton_solve(), and oomph::SegregatableFSIProblem::unsteady_segregated_solve().

◆ actions_after_implicit_timestep_and_error_estimation()

virtual void oomph::Problem::actions_after_implicit_timestep_and_error_estimation ( )

inlineprotectedvirtual

Actions that should be performed after each implicit time step. This is needed if your actions_after_implicit_timestep() modify the solution in a way that affects the error estimate.

1075 {}

Referenced by adaptive_unsteady_newton_solve(), and unsteady_newton_solve().

◆ actions_after_newton_solve()

virtual void oomph::Problem::actions_after_newton_solve ( )

inlineprotectedvirtual

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

1038 {}

Referenced by actions_after_change_in_bifurcation_parameter(), actions_after_change_in_global_parameter(), oomph::MyProblem::actions_after_explicit_timestep(), adaptive_unsteady_newton_solve(), get_fd_jacobian(), newton_solve(), and newton_solve_continuation().

◆ actions_after_newton_step()

virtual void oomph::Problem::actions_after_newton_step ( )

inlineprotectedvirtual

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 in oomph::MyProblem, FpTestProblem, FpTestProblem, and TiltedCavityProblem< ELEMENT >.

1058 {}

Referenced by adaptive_unsteady_newton_solve(), newton_solve(), and newton_solve_continuation().

◆ actions_after_parameter_increase()

virtual void oomph::Problem::actions_after_parameter_increase ( double *const & parameter_pt )

inlineprotectedvirtual

Empty virtual function; provides hook to perform actions after the increase in the arclength parameter (during continuation)

Reimplemented in NavierStokesProblem< ELEMENT >.

1162 {

1163 }

Referenced by arc_length_step_solve_helper().

◆ actions_after_read_unstructured_meshes()

virtual void oomph::Problem::actions_after_read_unstructured_meshes ( )

inlineprotectedvirtual

Actions that are to be performed before reading in restart data for problems involving unstructured bulk meshes. Typically used to re-attach FaceElements, say, that were stripped out in actions_before_read_unstructured_meshes(). This function is virtual and (practically) empty but toggles a flag to indicate that it has been called. This is used to issue a warning, prompting the user to consider overloading it if the problem is found to contain unstructured bulk meshes during restarts.

     {
       Empty_actions_after_read_unstructured_meshes_has_been_called = true;
     }

References Empty_actions_after_read_unstructured_meshes_has_been_called.

Referenced by read().

◆ actions_before_adapt()

virtual void oomph::Problem::actions_before_adapt ( )

inlinevirtual

Actions that are to be performed before a mesh adaptation. These might include removing any additional elements, such as traction boundary elements before the adaptation.

1022 {}

Referenced by adapt(), adapt_based_on_error_estimates(), p_adapt(), p_refine_selected_elements(), p_refine_uniformly(), p_refine_uniformly_aux(), p_unrefine_uniformly(), read(), refine_selected_elements(), refine_uniformly(), refine_uniformly_aux(), oomph::MGSolver< DIM >::setup_mg_hierarchy(), oomph::HelmholtzMGPreconditioner< DIM >::setup_mg_hierarchy(), and unrefine_uniformly().

◆ actions_before_explicit_timestep()

virtual void oomph::Problem::actions_before_explicit_timestep ( )

inlineprotectedvirtual

Actions that should be performed before each explicit time step.

Reimplemented from oomph::ExplicitTimeSteppableObject.

Reimplemented in oomph::MyProblem.

1078 {}

◆ actions_before_implicit_timestep()

virtual void oomph::Problem::actions_before_implicit_timestep ( )

inlineprotectedvirtual

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

1064 {}

Referenced by adaptive_unsteady_newton_solve(), unsteady_newton_solve(), and oomph::SegregatableFSIProblem::unsteady_segregated_solve().

◆ actions_before_newton_convergence_check()

virtual void oomph::Problem::actions_before_newton_convergence_check ( )

inlineprotectedvirtual

Any actions that are to be performed before the residual is checked in the Newton method, e.g. update any boundary conditions that depend upon variables of the problem; update any ‘dependent’ variables; or perform an update of the nodal positions in SpineMeshes etc. CAREFUL: This step should (and if the FD-based LinearSolver FD_LU is used, must) only update values that are pinned!

1048 {}

Referenced by actions_after_change_in_bifurcation_parameter(), actions_after_change_in_global_parameter(), adaptive_unsteady_newton_solve(), oomph::PitchForkHandler::get_dresiduals_dparameter(), get_fd_jacobian(), get_hessian_vector_products(), oomph::FoldHandler::get_jacobian(), oomph::PitchForkHandler::get_jacobian(), newton_solve(), and newton_solve_continuation().

◆ actions_before_newton_solve()

virtual void oomph::Problem::actions_before_newton_solve ( )

inlineprotectedvirtual

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!

1032 {}

Referenced by actions_after_change_in_bifurcation_parameter(), actions_after_change_in_global_parameter(), get_fd_jacobian(), newton_solve(), and newton_solve_continuation().

◆ actions_before_newton_step()

virtual void oomph::Problem::actions_before_newton_step ( )

inlineprotectedvirtual

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 in oomph::MyProblem, RectangularDrivenCavityProblem< ELEMENT >, SegregatedFSIDrivenCavityProblem< ELEMENT >, and SegregatedFSICollapsibleChannelProblem< ELEMENT >.

1053 {}

Referenced by newton_solve(), and newton_solve_continuation().

◆ actions_before_read_unstructured_meshes()

virtual void oomph::Problem::actions_before_read_unstructured_meshes ( )

inlineprotectedvirtual

Actions that are to be performed before reading in restart data for problems involving unstructured bulk meshes. If the problem contains such meshes we need to strip out any face elements that are attached to them because restart of unstructured meshes re-creates their elements and nodes from scratch, leading to dangling pointers from the face elements to the old elements and nodes. This function is virtual and (practically) empty but toggles a flag to indicate that it has been called. This is used to issue a warning, prompting the user to consider overloading it if the problem is found to contain unstructured bulk meshes during restarts.

     {
       Empty_actions_before_read_unstructured_meshes_has_been_called = true;
     }

References Empty_actions_before_read_unstructured_meshes_has_been_called.

Referenced by read().

◆ activate_bifurcation_tracking() [1/2]

void Problem::activate_bifurcation_tracking	(	double *const &	parameter_pt,
		const DoubleVector &	eigenvector,
		const bool &	block_solve = `true`
	)

Activate generic bifurcation tracking for a single (real) eigenvalue where the initial guess for the eigenvector can be specified.

Activate the generic bifurcation ///tracking system by changing the assembly handler and initialising it using the parameter addressed by parameter_pt.

   {
     // Reset the assembly handler to default
     reset_assembly_handler_to_default();
     // Set the new assembly handler. Note that the constructor actually
     // solves the original problem to get some initial conditions, but
     // this is OK because the RHS is always evaluated before assignment.
     Assembly_handler_pt = new FoldHandler(this, parameter_pt, eigenvector);
  
     // If we are using a block solver, we must set the linear solver pointer
     // to the block fold solver. The present linear solver is
     // used by the block solver and so must be passed as an argument.
     // The destructor of the Fold handler returns the linear
     // solver to the original non-block version.
     if (block_solve)
     {
       Linear_solver_pt = new AugmentedBlockFoldLinearSolver(Linear_solver_pt);
     }
   }

References Assembly_handler_pt, AugmentedBlockFoldLinearSolver, FoldHandler, Linear_solver_pt, and reset_assembly_handler_to_default().

◆ activate_bifurcation_tracking() [2/2]

void Problem::activate_bifurcation_tracking	(	double *const &	parameter_pt,
		const DoubleVector &	eigenvector,
		const DoubleVector &	normalisation,
		const bool &	block_solve = `true`
	)

Activate generic bifurcation tracking for a single (real) eigenvalue where the initial guess for the eigenvector can be specified and the normalisation condition can also be specified.

Activate the generic bifurcation ///tracking system by changing the assembly handler and initialising it using the parameter addressed by parameter_pt.

   {
     // Reset the assembly handler to default
     reset_assembly_handler_to_default();
     // Set the new assembly handler. Note that the constructor actually
     // solves the original problem to get some initial conditions, but
     // this is OK because the RHS is always evaluated before assignment.
     Assembly_handler_pt =
       new FoldHandler(this, parameter_pt, eigenvector, normalisation);
  
     // If we are using a block solver, we must set the linear solver pointer
     // to the block fold solver. The present linear solver is
     // used by the block solver and so must be passed as an argument.
     // The destructor of the Fold handler returns the linear
     // solver to the original non-block version.
     if (block_solve)
     {
       Linear_solver_pt = new AugmentedBlockFoldLinearSolver(Linear_solver_pt);
     }
   }

References Assembly_handler_pt, AugmentedBlockFoldLinearSolver, FoldHandler, Linear_solver_pt, and reset_assembly_handler_to_default().

◆ activate_fold_tracking()

void Problem::activate_fold_tracking	(	double *const &	parameter_pt,
		const bool &	block_solve = `true`
	)

Turn on fold tracking using the augmented system specified in the FoldHandler class. After a call to this function subsequent calls of the standard solution methods will converge to a fold (limit) point at a particular value of the variable addressed by parameter_pt. The system may not converge if the initial guess is sufficiently poor or, alternatively, if finite differencing is used to calculate the jacobian matrix in the elements. If the boolean flag block_solver is true (the default) then a block factorisation is used to solve the augmented system which is both faster and uses less memory.

Activate the fold tracking system by changing the assembly handler and initialising it using the parameter addressed by parameter_pt.

   {
     // Reset the assembly handler to default
     reset_assembly_handler_to_default();
     // Set the new assembly handler. Note that the constructor actually
     // solves the original problem to get some initial conditions, but
     // this is OK because the RHS is always evaluated before assignment.
     Assembly_handler_pt = new FoldHandler(this, parameter_pt);
  
     // If we are using a block solver, we must set the linear solver pointer
     // to the block fold solver. The present linear solver is
     // used by the block solver and so must be passed as an argument.
     // The destructor of the Fold handler returns the linear
     // solver to the original non-block version.
     if (block_solve)
     {
       Linear_solver_pt = new AugmentedBlockFoldLinearSolver(Linear_solver_pt);
     }
   }

References Assembly_handler_pt, AugmentedBlockFoldLinearSolver, FoldHandler, Linear_solver_pt, and reset_assembly_handler_to_default().

Referenced by bifurcation_adapt_helper().

◆ activate_hopf_tracking() [1/2]

void Problem::activate_hopf_tracking	(	double *const &	parameter_pt,
		const bool &	block_solve = `true`
	)

Turn on Hopf bifurcation tracking using the augmented system specified in the HopfHandler class. After a call to this function subsequent calls of the standard solution methods will converge to a Hopf bifuraction at a particular value of the variable addressed by parameter_pt. The system may not converge if the initial guess is sufficiently poor or, alternatively, if finite differencing is used to calculate the jacobian matrix in the elements.

Activate the hopf tracking system by changing the assembly handler and initialising it using the parameter addressed by parameter_pt.

   {
     // Reset the assembly handler to default
     reset_assembly_handler_to_default();
     // Set the new assembly handler. Note that the constructor actually
     // solves the original problem to get some initial conditions, but
     // this is OK because the RHS is always evaluated before assignment.
     Assembly_handler_pt = new HopfHandler(this, parameter_pt);
  
     // If we are using a block solver, we must set the linear solver pointer
     // to the block hopf solver. The present linear solver is
     // used by the block solver and so must be passed as an argument.
     // The destructor of the Hopf handler returns the linear
     // solver to the original non-block version.
     if (block_solve)
     {
       Linear_solver_pt = new BlockHopfLinearSolver(Linear_solver_pt);
     }
   }

References Assembly_handler_pt, BlockHopfLinearSolver, HopfHandler, Linear_solver_pt, and reset_assembly_handler_to_default().

Referenced by bifurcation_adapt_helper().

◆ activate_hopf_tracking() [2/2]

void Problem::activate_hopf_tracking	(	double *const &	parameter_pt,
		const double &	omega,
		const DoubleVector &	null_real,
		const DoubleVector &	null_imag,
		const bool &	block_solve = `true`
	)

Turn on Hopf bifurcation tracking using the augmented system specified in the HopfHandler class. After a call to this function subsequent calls of the standard solution methods will converge to a Hopf bifuraction at a particular value of the variable addressed by parameter_pt. The system may not converge if the initial guess is sufficiently poor or, alternatively, if finite differencing is used to calculate the jacobian matrix in the elements. This interface allows specification of an inital guess for the frequency and real and imaginary parts of the null vector, such as might be obtained from an eigensolve

Activate the hopf tracking system by changing the assembly handler and initialising it using the parameter addressed by parameter_pt and the frequency and null vectors specified.

   {
     // Reset the assembly handler to default
     reset_assembly_handler_to_default();
     // Set the new assembly handler. Note that the constructor actually
     // solves the original problem to get some initial conditions, but
     // this is OK because the RHS is always evaluated before assignment.
     Assembly_handler_pt =
       new HopfHandler(this, parameter_pt, omega, null_real, null_imag);
  
     // If we are using a block solver, we must set the linear solver pointer
     // to the block hopf solver. The present linear solver is
     // used by the block solver and so must be passed as an argument.
     // The destructor of the Hopf handler returns the linear
     // solver to the original non-block version.
     if (block_solve)
     {
       Linear_solver_pt = new BlockHopfLinearSolver(Linear_solver_pt);
     }
   }

References Assembly_handler_pt, BlockHopfLinearSolver, HopfHandler, Linear_solver_pt, Eigen::internal::omega(), and reset_assembly_handler_to_default().

◆ activate_pitchfork_tracking()

void Problem::activate_pitchfork_tracking	(	double *const &	parameter_pt,
		const DoubleVector &	symmetry_vector,
		const bool &	block_solve = `true`
	)

Turn on pitchfork tracking using the augmented system specified in the PitchForkHandler class. After a call to this function subsequent calls of the standard solution methods will converge to a pitchfork bifurcation at a particular value of the variable addressed by parameter_pt. The symmetry that is to be broken must be specified by supplying a symmetry_vector(ndof). The easiest way to determine such a vector is to solve the associated eigenproblem \( Jx = \lambda M x\) and pass in the eigenvector. This is not always necessary however, if the symmetry is easy to construct. The system may not converge if the initial guess is sufficiently poor or, alternatively, if finite differencing is used to calculate the jacobian matrix in the elements. If the boolean flag block_solver is true (the default) then a block factorisation is used to solve the augmented system which is both faster and requires less memory.

Activate the pitchfork tracking system by changing the assembly handler and initialising it using the parameter addressed by parameter_pt and a symmetry vector. The boolean flag is used to specify whether a block solver is used, default is true.

   {
     // Reset the assembly handler to default
     reset_assembly_handler_to_default();
  
     // Set the new assembly handler. Note that the constructor actually
     // solves the original problem to get some initial conditions, but
     // this is OK because the RHS is always evaluated before assignment.
     Assembly_handler_pt = new PitchForkHandler(
       this, this->assembly_handler_pt(), parameter_pt, symmetry_vector);
  
     // If we are using a block solver, we must set the linear solver pointer
     // to the block pitchfork solver. The present linear solver is
     // used by the block solver and so must be passed as an argument.
     // The destructor of the PitchFork handler returns the linear
     // solver to the original non-block version.
     if (block_solve)
     {
       Linear_solver_pt = new BlockPitchForkLinearSolver(Linear_solver_pt);
     }
   }

References Assembly_handler_pt, assembly_handler_pt(), BlockPitchForkLinearSolver, Linear_solver_pt, PitchForkHandler, and reset_assembly_handler_to_default().

Referenced by bifurcation_adapt_helper().

◆ adapt() [1/2]

void oomph::Problem::adapt ( )

inline

Adapt problem: Perform mesh adaptation for (all) refineable (sub)mesh(es), based on their own error estimates and the target errors specified in the mesh(es). Following mesh adaptation, update global mesh, and re-assign equation numbers. On return from this function, Problem can immediately be solved again. [Argument-free wrapper]

     {
       unsigned n_refined, n_unrefined;
       adapt(n_refined, n_unrefined);
     }

Referenced by UnsteadyHeatProblem< ELEMENT >::adapt(), arc_length_step_solve_helper(), doubly_adaptive_unsteady_newton_solve_helper(), newton_solve(), and unsteady_newton_solve().

◆ adapt() [2/2]

void Problem::adapt	(	unsigned &	n_refined,
		unsigned &	n_unrefined
	)

Adapt problem: Perform mesh adaptation for (all) refineable (sub)mesh(es), based on their own error estimates and the target errors specified in the mesh(es). Following mesh adaptation, update global mesh, and re-assign equation numbers. Return # of refined/unrefined elements. On return from this function, Problem can immediately be solved again.

   {
     double t_start_total = 0.0;
     if (Global_timings::Doc_comprehensive_timings)
     {
       t_start_total = TimingHelpers::timer();
     }
  
     // Get the bifurcation type
     int bifurcation_type = this->Assembly_handler_pt->bifurcation_type();
  
     bool continuation_problem = false;
  
     // If we have continuation data then we need to project that across to the
     // new mesh
     if (!Use_continuation_timestepper)
     {
       if (Dof_derivative.size() != 0)
       {
         continuation_problem = true;
       }
     }
  
     // If we are tracking a bifurcation then call the bifurcation adapt function
     if (bifurcation_type != 0)
     {
       this->bifurcation_adapt_helper(n_refined, n_unrefined, bifurcation_type);
       // Return immediately
       return;
     }
  
     if (continuation_problem)
     {
       // Create a copy of the problem
       Copy_of_problem_pt.resize(2);
       // If we don't already have a copy
       for (unsigned c = 0; c < 2; c++)
       {
         if (Copy_of_problem_pt[c] == 0)
         {
           // Create the copy
           Copy_of_problem_pt[c] = this->make_copy();
  
           // Refine the copy to the same level as the current problem
           // Must call actions before adapt
           Copy_of_problem_pt[c]->actions_before_adapt();
  
           // Find number of submeshes
           const unsigned N_mesh = Copy_of_problem_pt[c]->nsub_mesh();
  
           // If there is only one mesh
           if (N_mesh == 0)
           {
             // Can we refine the mesh
             if (TreeBasedRefineableMeshBase* mmesh_pt =
                   dynamic_cast<TreeBasedRefineableMeshBase*>(
                     Copy_of_problem_pt[c]->mesh_pt(0)))
             {
               // Is the adapt flag set
               if (mmesh_pt->is_adaptation_enabled())
               {
                 // Now get the original problem's mesh if it's refineable
                 if (TreeBasedRefineableMeshBase* original_mesh_pt =
                       dynamic_cast<TreeBasedRefineableMeshBase*>(
                         this->mesh_pt(0)))
                 {
                   if (dynamic_cast<SolidMesh*>(original_mesh_pt) != 0)
                   {
                     oomph_info
                       << "Info/Warning: Adaptive Continuation is broken in "
                       << "SolidElement" << std::endl;
                   }
                   mmesh_pt->refine_base_mesh_as_in_reference_mesh(
                     original_mesh_pt);
                 }
                 else
                 {
                   oomph_info << "Info/Warning: Mesh in orginal problem is not "
                                 "refineable."
                              << std::endl;
                 }
               }
               else
               {
                 oomph_info
                   << "Info/Warning: Mesh adaptation is disabled in copy."
                   << std::endl;
               }
             }
             else if (TriangleMeshBase* tmesh_pt =
                        dynamic_cast<TriangleMeshBase*>(
                          Copy_of_problem_pt[c]->mesh_pt(0)))
             {
               if (TriangleMeshBase* original_mesh_pt =
                     dynamic_cast<TriangleMeshBase*>(this->mesh_pt(0)))
               {
                 if (dynamic_cast<SolidMesh*>(original_mesh_pt) != 0)
                 {
                   oomph_info
                     << "Info/Warning: Adaptive Continuation is broken in "
                     << "SolidElement" << std::endl;
                 }
  
                 // Remesh using the triangulateIO of the base mesh
                 // Done via a file, so a bit hacky but this will be
                 // superseded very soon
                 std::ofstream tri_dump("triangle_mesh.dmp");
                 original_mesh_pt->dump_triangulateio(tri_dump);
                 tri_dump.close();
                 std::ifstream tri_read("triangle_mesh.dmp");
                 tmesh_pt->remesh_from_triangulateio(tri_read);
                 tri_read.close();
  
  
                 // Set the nodes to be at the same positions
                 // as the original just in case the
                 // triangulatio is out of sync with the real data
                 const unsigned n_node = original_mesh_pt->nnode();
                 for (unsigned n = 0; n < n_node; ++n)
                 {
                   Node* const nod_pt = original_mesh_pt->node_pt(n);
                   Node* const new_node_pt = tmesh_pt->node_pt(n);
                   unsigned n_dim = nod_pt->ndim();
                   for (unsigned i = 0; i < n_dim; ++i)
                   {
                     new_node_pt->x(i) = nod_pt->x(i);
                   }
                 }
               }
               else
               {
                 oomph_info
                   << "Info/warning: Original Mesh is not TriangleBased\n"
                   << "... but the copy is!" << std::endl;
               }
             }
             else
             {
               oomph_info << "Info/Warning: Mesh cannot be adapted in copy."
                          << std::endl;
             }
           } // End of single mesh case
           // Otherwise loop over the submeshes
           else
           {
             for (unsigned m = 0; m < N_mesh; m++)
             {
               // Can we refine the submesh
               if (TreeBasedRefineableMeshBase* mmesh_pt =
                     dynamic_cast<TreeBasedRefineableMeshBase*>(
                       Copy_of_problem_pt[c]->mesh_pt(m)))
               {
                 // Is the adapt flag set
                 if (mmesh_pt->is_adaptation_enabled())
                 {
                   // Now get the original problem's mesh
                   if (TreeBasedRefineableMeshBase* original_mesh_pt =
                         dynamic_cast<TreeBasedRefineableMeshBase*>(
                           this->mesh_pt(m)))
                   {
                     if (dynamic_cast<SolidMesh*>(original_mesh_pt) != 0)
                     {
                       oomph_info
                         << "Info/Warning: Adaptive Continuation is broken in "
                         << "SolidElement" << std::endl;
                     }
  
                     mmesh_pt->refine_base_mesh_as_in_reference_mesh(
                       original_mesh_pt);
                   }
                   else
                   {
                     oomph_info << "Info/Warning: Mesh in orginal problem is "
                                   "not refineable."
                                << std::endl;
                   }
                 }
                 else
                 {
                   oomph_info
                     << "Info/Warning: Mesh adaptation is disabled in copy."
                     << std::endl;
                 }
               }
               else if (TriangleMeshBase* tmesh_pt =
                          dynamic_cast<TriangleMeshBase*>(
                            Copy_of_problem_pt[c]->mesh_pt(m)))
               {
                 if (TriangleMeshBase* original_mesh_pt =
                       dynamic_cast<TriangleMeshBase*>(this->mesh_pt(m)))
                 {
                   if (dynamic_cast<SolidMesh*>(original_mesh_pt) != 0)
                   {
                     oomph_info
                       << "Info/Warning: Adaptive Continuation is broken in "
                       << "SolidElement" << std::endl;
                   }
  
                   // Remesh using the triangulateIO of the base mesh
                   // Done via a file, so a bit hacky but this will be
                   // superseded very soon
                   std::ofstream tri_dump("triangle_mesh.dmp");
                   original_mesh_pt->dump_triangulateio(tri_dump);
                   tri_dump.close();
                   std::ifstream tri_read("triangle_mesh.dmp");
                   tmesh_pt->remesh_from_triangulateio(tri_read);
                   tri_read.close();
  
                   // Set the nodes to be at the same positions
                   // as the original just in case the
                   // triangulatio is out of sync with the real data
                   const unsigned n_node = original_mesh_pt->nnode();
                   for (unsigned n = 0; n < n_node; ++n)
                   {
                     Node* const nod_pt = original_mesh_pt->node_pt(n);
                     Node* const new_node_pt = tmesh_pt->node_pt(n);
                     unsigned n_dim = nod_pt->ndim();
                     for (unsigned i = 0; i < n_dim; ++i)
                     {
                       new_node_pt->x(i) = nod_pt->x(i);
                     }
                   }
                 }
                 else
                 {
                   oomph_info
                     << "Info/warning: Original Mesh is not TriangleBased\n"
                     << "... but the copy is!" << std::endl;
                 }
               }
               else
               {
                 oomph_info << "Info/Warning: Mesh cannot be adapted in copy."
                            << std::endl;
               }
             }
  
  
             // Must call actions after adapt
             Copy_of_problem_pt[c]->actions_after_adapt();
  
             // rebuild the global mesh in the copy
             Copy_of_problem_pt[c]->rebuild_global_mesh();
  
           } // End of multiple mesh case
  
           // Must call actions after adapt
           Copy_of_problem_pt[c]->actions_after_adapt();
  
           // Assign the equation numbers to the copy (quietly)
           (void)Copy_of_problem_pt[c]->assign_eqn_numbers();
         }
  
         // Check that the dofs match for each copy
 #ifdef PARANOID
         // If the problems don't match then complain
         if (Copy_of_problem_pt[c]->ndof() != this->ndof())
         {
           std::ostringstream error_stream;
           error_stream << "Number of unknowns in the problem copy " << c << " "
                        << "not equal to number in the original:\n"
                        << this->ndof() << " (original) "
                        << Copy_of_problem_pt[c]->ndof() << " (copy)\n";
  
           throw OomphLibError(error_stream.str(),
                               OOMPH_CURRENT_FUNCTION,
                               OOMPH_EXCEPTION_LOCATION);
         }
 #endif
       }
  
       // Need to set the Dof derivatives to the copied problem
       // Assign the eigenfunction(s) to the copied problems
       unsigned ndof_local = Dof_distribution_pt->nrow_local();
       for (unsigned i = 0; i < ndof_local; i++)
       {
         Copy_of_problem_pt[0]->dof(i) = this->dof_derivative(i);
         Copy_of_problem_pt[1]->dof(i) = this->dof_current(i);
       }
       // Set all pinned values to zero
       Copy_of_problem_pt[0]->set_pinned_values_to_zero();
       // Don't need to for the current dofs that are actuall the dofs
  
       // Now adapt
       Vector<Vector<double>> base_error;
       this->get_all_error_estimates(base_error);
       this->adapt_based_on_error_estimates(n_refined, n_unrefined, base_error);
       Copy_of_problem_pt[0]->adapt_based_on_error_estimates(
         n_refined, n_unrefined, base_error);
       Copy_of_problem_pt[1]->adapt_based_on_error_estimates(
         n_refined, n_unrefined, base_error);
  
       // Now sort out the Dof pointer
       ndof_local = Dof_distribution_pt->nrow_local();
       if (Dof_derivative.size() != ndof_local)
       {
         Dof_derivative.resize(ndof_local, 0.0);
       }
       if (Dof_current.size() != ndof_local)
       {
         Dof_current.resize(ndof_local, 0.0);
       }
       for (unsigned i = 0; i < ndof_local; i++)
       {
         Dof_derivative[i] = Copy_of_problem_pt[0]->dof(i);
         Dof_current[i] = Copy_of_problem_pt[1]->dof(i);
       }
       // Return immediately
       return;
     }
  
     oomph_info << std::endl << std::endl;
     oomph_info << "Adapting problem:" << std::endl;
     oomph_info << "=================" << std::endl;
  
     double t_start = 0.0;
     if (Global_timings::Doc_comprehensive_timings)
     {
       t_start = TimingHelpers::timer();
     }
  
     // Call the actions before adaptation
     actions_before_adapt();
  
     double t_end = 0.0;
     if (Global_timings::Doc_comprehensive_timings)
     {
       t_end = TimingHelpers::timer();
       oomph_info << "Time for actions before adapt: " << t_end - t_start
                  << std::endl;
       t_start = TimingHelpers::timer();
     }
  
     // Initialise counters
     n_refined = 0;
     n_unrefined = 0;
  
     // Number of submeshes?
     unsigned Nmesh = nsub_mesh();
  
     // Single mesh:
     //------------
     if (Nmesh == 0)
     {
       // Refine single mesh if possible
       if (RefineableMeshBase* mmesh_pt =
             dynamic_cast<RefineableMeshBase*>(mesh_pt(0)))
       {
         if (mmesh_pt->is_adaptation_enabled())
         {
           double t_start = TimingHelpers::timer();
  
           // Get pointer to error estimator
           ErrorEstimator* error_estimator_pt =
             mmesh_pt->spatial_error_estimator_pt();
  
 #ifdef PARANOID
           if (error_estimator_pt == 0)
           {
             throw OomphLibError("Error estimator hasn't been set yet",
                                 OOMPH_CURRENT_FUNCTION,
                                 OOMPH_EXCEPTION_LOCATION);
           }
 #endif
  
           // Get error for all elements
           Vector<double> elemental_error(mmesh_pt->nelement());
  
           if (mmesh_pt->doc_info_pt() == 0)
           {
             error_estimator_pt->get_element_errors(mesh_pt(0), elemental_error);
           }
           else
           {
             error_estimator_pt->get_element_errors(
               mesh_pt(0), elemental_error, *mmesh_pt->doc_info_pt());
           }
  
           // Store max./min actual error
           mmesh_pt->max_error() = std::fabs(*std::max_element(
             elemental_error.begin(), elemental_error.end(), AbsCmp<double>()));
  
           mmesh_pt->min_error() = std::fabs(*std::min_element(
             elemental_error.begin(), elemental_error.end(), AbsCmp<double>()));
  
           oomph_info << "\n Max/min error: " << mmesh_pt->max_error() << " "
                      << mmesh_pt->min_error() << std::endl
                      << std::endl;
  
  
           if (Global_timings::Doc_comprehensive_timings)
           {
             t_end = TimingHelpers::timer();
             oomph_info << "Time for error estimation: " << t_end - t_start
                        << std::endl;
             t_start = TimingHelpers::timer();
           }
  
           // Adapt mesh
           mmesh_pt->adapt(elemental_error);
  
           // Add to counters
           n_refined += mmesh_pt->nrefined();
           n_unrefined += mmesh_pt->nunrefined();
  
           if (Global_timings::Doc_comprehensive_timings)
           {
             t_end = TimingHelpers::timer();
             oomph_info << "Time for complete mesh adaptation "
                        << "(but excluding comp of error estimate): "
                        << t_end - t_start << std::endl;
             t_start = TimingHelpers::timer();
           }
         }
         else
         {
           oomph_info << "Info/Warning: Mesh adaptation is disabled."
                      << std::endl;
         }
       }
       else
       {
         oomph_info << "Info/Warning: Mesh cannot be adapted" << std::endl;
       }
     }
     // Multiple submeshes
     //------------------
     else
     {
       // Loop over submeshes
       for (unsigned imesh = 0; imesh < Nmesh; imesh++)
       {
         // Refine single mesh uniformly if possible
         if (RefineableMeshBase* mmesh_pt =
               dynamic_cast<RefineableMeshBase*>(mesh_pt(imesh)))
         {
           double t_start = TimingHelpers::timer();
  
           // Get pointer to error estimator
           ErrorEstimator* error_estimator_pt =
             mmesh_pt->spatial_error_estimator_pt();
  
 #ifdef PARANOID
           if (error_estimator_pt == 0)
           {
             throw OomphLibError("Error estimator hasn't been set yet",
                                 OOMPH_CURRENT_FUNCTION,
                                 OOMPH_EXCEPTION_LOCATION);
           }
 #endif
  
           if (mmesh_pt->is_adaptation_enabled())
           {
             // Get error for all elements
             Vector<double> elemental_error(mmesh_pt->nelement());
             if (mmesh_pt->doc_info_pt() == 0)
             {
               error_estimator_pt->get_element_errors(mesh_pt(imesh),
                                                      elemental_error);
             }
             else
             {
               error_estimator_pt->get_element_errors(
                 mesh_pt(imesh), elemental_error, *mmesh_pt->doc_info_pt());
             }
  
             // Store max./min error if the mesh has any elements
             if (mesh_pt(imesh)->nelement() > 0)
             {
               mmesh_pt->max_error() =
                 std::fabs(*std::max_element(elemental_error.begin(),
                                             elemental_error.end(),
                                             AbsCmp<double>()));
  
               mmesh_pt->min_error() =
                 std::fabs(*std::min_element(elemental_error.begin(),
                                             elemental_error.end(),
                                             AbsCmp<double>()));
             }
  
             oomph_info << "\n Max/min error: " << mmesh_pt->max_error() << " "
                        << mmesh_pt->min_error() << std::endl;
  
  
             if (Global_timings::Doc_comprehensive_timings)
             {
               t_end = TimingHelpers::timer();
               oomph_info << "Time for error estimation: " << t_end - t_start
                          << std::endl;
               t_start = TimingHelpers::timer();
             }
  
             // Adapt mesh
             mmesh_pt->adapt(elemental_error);
  
             // Add to counters
             n_refined += mmesh_pt->nrefined();
             n_unrefined += mmesh_pt->nunrefined();
  
  
             if (Global_timings::Doc_comprehensive_timings)
             {
               t_end = TimingHelpers::timer();
               oomph_info << "Time for complete mesh adaptation "
                          << "(but excluding comp of error estimate): "
                          << t_end - t_start << std::endl;
               t_start = TimingHelpers::timer();
             }
           }
           else
           {
             oomph_info << "Info/Warning: Mesh adaptation is disabled."
                        << std::endl;
           }
         }
         else
         {
           oomph_info << "Info/Warning: Mesh cannot be adapted." << std::endl;
         }
  
       } // End of loop over submeshes
  
       // Rebuild the global mesh
       rebuild_global_mesh();
     }
  
  
     if (Global_timings::Doc_comprehensive_timings)
     {
       t_end = TimingHelpers::timer();
       oomph_info << "Total time for actual adaptation "
                  << "(all meshes; incl error estimates): " << t_end - t_start
                  << std::endl;
       t_start = TimingHelpers::timer();
     }
  
     // Any actions after adapt
     actions_after_adapt();
  
  
     if (Global_timings::Doc_comprehensive_timings)
     {
       t_end = TimingHelpers::timer();
       oomph_info << "Time for actions after adapt: " << t_end - t_start
                  << std::endl;
       t_start = TimingHelpers::timer();
  
       oomph_info << "About to start re-assigning eqn numbers "
                  << "with Problem::assign_eqn_numbers() at end of "
                  << "Problem::adapt().\n";
     }
  
     // Attach the boundary conditions to the mesh
     oomph_info << "\nNumber of equations: " << assign_eqn_numbers() << std::endl
                << std::endl;
  
  
     if (Global_timings::Doc_comprehensive_timings)
     {
       t_end = TimingHelpers::timer();
       oomph_info << "Time for re-assigning eqn numbers with "
                  << "Problem::assign_eqn_numbers() at end of Problem::adapt(): "
                  << t_end - t_start << std::endl;
       oomph_info << "Total time for adapt: " << t_end - t_start_total
                  << std::endl;
     }
   }

References actions_after_adapt(), actions_before_adapt(), adapt_based_on_error_estimates(), Assembly_handler_pt, assign_eqn_numbers(), bifurcation_adapt_helper(), oomph::AssemblyHandler::bifurcation_type(), calibrate::c, Copy_of_problem_pt, oomph::Global_timings::Doc_comprehensive_timings, Dof_current, dof_current(), Dof_derivative, dof_derivative(), Dof_distribution_pt, MeshRefinement::error_estimator_pt, boost::multiprecision::fabs(), get_all_error_estimates(), i, m, make_copy(), mesh_pt(), n, oomph::Node::ndim(), ndof(), oomph::LinearAlgebraDistribution::nrow_local(), nsub_mesh(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::oomph_info, rebuild_global_mesh(), oomph::TimingHelpers::timer(), Use_continuation_timestepper, and oomph::Node::x().

Referenced by main().

◆ adapt_based_on_error_estimates() [1/2]

void Problem::adapt_based_on_error_estimates	(	unsigned &	n_refined,
		unsigned &	n_unrefined,
		Vector< Vector< double >> &	elemental_error
	)

Adapt problem: Perform mesh adaptation for (all) refineable (sub)mesh(es), based on the error estimates in elemental_error and the target errors specified in the mesh(es). Following mesh adaptation, update global mesh, and re-assign equation numbers. Return # of refined/unrefined elements. On return from this function, Problem can immediately be solved again.

Perform mesh adaptation for (all) refineable (sub)mesh(es), based on the error estimates in elemental_error and the target errors specified in the mesh(es). Following mesh adaptation, update global mesh, and re-assign equation numbers. Return # of refined/unrefined elements. On return from this function, Problem can immediately be solved again.

   {
     oomph_info << std::endl << std::endl;
     oomph_info << "Adapting problem:" << std::endl;
     oomph_info << "=================" << std::endl;
  
     // Call the actions before adaptation
     actions_before_adapt();
  
     // Initialise counters
     n_refined = 0;
     n_unrefined = 0;
  
     // Number of submeshes?
     unsigned Nmesh = nsub_mesh();
  
     // Single mesh:
     //------------
     if (Nmesh == 0)
     {
       // Refine single mesh uniformly if possible
       if (RefineableMeshBase* mmesh_pt =
             dynamic_cast<RefineableMeshBase*>(Problem::mesh_pt(0)))
       {
         if (mmesh_pt->is_adaptation_enabled())
         {
           // Adapt mesh
           mmesh_pt->adapt(elemental_error[0]);
  
           // Add to counters
           n_refined += mmesh_pt->nrefined();
           n_unrefined += mmesh_pt->nunrefined();
         }
         else
         {
           oomph_info << "Info/Warning: Mesh adaptation is disabled."
                      << std::endl;
         }
       }
       else
       {
         oomph_info << "Info/Warning: Mesh cannot be adapted" << std::endl;
       }
     }
  
     // Multiple submeshes
     //------------------
     else
     {
       // Loop over submeshes
       for (unsigned imesh = 0; imesh < Nmesh; imesh++)
       {
         // Refine single mesh uniformly if possible
         if (RefineableMeshBase* mmesh_pt =
               dynamic_cast<RefineableMeshBase*>(Problem::mesh_pt(imesh)))
         {
           if (mmesh_pt->is_adaptation_enabled())
           {
             // Adapt mesh
             mmesh_pt->adapt(elemental_error[imesh]);
  
             // Add to counters
             n_refined += mmesh_pt->nrefined();
             n_unrefined += mmesh_pt->nunrefined();
           }
           else
           {
             oomph_info << "Info/Warning: Mesh adaptation is disabled."
                        << std::endl;
           }
         }
         else
         {
           oomph_info << "Info/Warning: Mesh cannot be adapted." << std::endl;
         }
  
       } // End of loop over submeshes
  
       // Rebuild the global mesh
       rebuild_global_mesh();
     }
  
     // Any actions after adapt
     actions_after_adapt();
  
     // Attach the boundary conditions to the mesh
     oomph_info << "\nNumber of equations: " << assign_eqn_numbers() << std::endl
                << std::endl;
   }

References actions_after_adapt(), actions_before_adapt(), assign_eqn_numbers(), mesh_pt(), nsub_mesh(), oomph::oomph_info, and rebuild_global_mesh().

Referenced by adapt(), adapt_based_on_error_estimates(), and bifurcation_adapt_helper().

◆ adapt_based_on_error_estimates() [2/2]

void oomph::Problem::adapt_based_on_error_estimates ( Vector< Vector< double >> & elemental_error )

inline

Adapt problem: Perform mesh adaptation for (all) refineable (sub)mesh(es), based on the error estimates in elemental_error and the target errors specified in the mesh(es). Following mesh adaptation, update global mesh, and re-assign equation numbers. Return # of refined/unrefined elements. On return from this function, Problem can immediately be solved again. [Wrapper without n_refined and n_unrefined arguments]

     {
       unsigned n_refined, n_unrefined;
       adapt_based_on_error_estimates(n_refined, n_unrefined, elemental_error);
     }

References adapt_based_on_error_estimates().

◆ adaptive_unsteady_newton_solve() [1/2]

double Problem::adaptive_unsteady_newton_solve	(	const double &	dt_desired,
		const double &	epsilon
	)

Attempt to advance timestep by dt_desired. If the solution fails the timestep will be halved until convergence is achieved, or the timestep falls below NewtonSolverParameters::Minimum_time_step. The error control parameter epsilon represents the (approximate) desired magnitude of the global error at each timestep. The routine returns a double that is the suggested next timestep and should be passed as dt_desired the next time the routine is called. This version always shifts the time values.

Attempt to take one timestep forward using dt_desired. The error control parameter, epsilon, is used to specify the desired approximate value of the global error norm per timestep. The routine returns the value an estimate of the next value of dt that should be taken.

   {
     // We always want to shift the time values
     return adaptive_unsteady_newton_solve(dt_desired, epsilon, true);
   }

References oomph::SarahBL::epsilon.

Referenced by doubly_adaptive_unsteady_newton_solve_helper().

◆ adaptive_unsteady_newton_solve() [2/2]

double Problem::adaptive_unsteady_newton_solve	(	const double &	dt_desired,
		const double &	epsilon,
		const bool &	shift_values
	)

Attempt to advance timestep by dt_desired. If the solution fails the timestep will be halved until convergence is achieved, or the timestep falls below NewtonSolverParameters::Minimum_time_step. The error control parameter epsilon represents the (approximate) desired magnitude of the global error at each timestep. The routine returns a double that is the suggested next timestep and should be passed as dt_desired the next time the routine is called. Once again the boolean flag, shift_values, is used to control whether the time values are shifted.

Attempt to take one timestep forward using the dt_desired. This is the driver for a number of adaptive solvers. If the solution fails to converge at a given timestep, the routine will automatically halve the time step and try again, until the time step falls below the specified minimum value. The routine returns the value an estimate of the next value of dt that should be taken. Timestep is also rejected if the error estimate post-solve (computed by global_temporal_error_norm()) exceeds epsilon. This behaviour can be over-ruled by setting the protected boolean Problem::Keep_temporal_error_below_tolerance to false.

   {
     // First, we need to backup the existing dofs, in case the timestep is
     // rejected
  
     // Find total number of dofs on current processor
     unsigned n_dof_local = dof_distribution_pt()->nrow_local();
  
     // Now set up a Vector to hold current values
     Vector<double> dofs_current(n_dof_local);
  
     // Load values into dofs_current
     for (unsigned i = 0; i < n_dof_local; i++) dofs_current[i] = dof(i);
  
     // Store the time
     double time_current = time_pt()->time();
  
     // Flag to detect whether the timestep has been rejected or not
     bool reject_timestep = 0;
  
     // Flag to detect whether any of the timesteppers are adaptive
     unsigned adaptive_flag = 0;
  
     // The value of the actual timestep, by default the same as desired timestep
     double dt_actual = dt_desired;
  
     // Find out whether any of the timesteppers are adaptive
     unsigned n_time_steppers = ntime_stepper();
     for (unsigned i = 0; i < n_time_steppers; i++)
     {
       if (time_stepper_pt(i)->adaptive_flag())
       {
         adaptive_flag = 1;
         break;
       }
     }
  
     // Shift the time_values according to the control flag
     if (shift_values)
     {
       shift_time_values();
     }
  
     // This loop surrounds the adaptive time-stepping and will not be broken
     // until a timestep is accepted
     do
     {
       // Initially we assume that this step will succeed and that this dt
       // value is ok.
       reject_timestep = 0;
       double dt_rescaling_factor = 1.0;
  
       // Set the new time and value of dt
       time_pt()->time() += dt_actual;
       time_pt()->dt() = dt_actual;
  
       // Loop over all timesteppers and set the weights and predictor weights
       for (unsigned i = 0; i < n_time_steppers; i++)
       {
         // If the time_stepper is non-adaptive, this will be zero
         time_stepper_pt(i)->set_predictor_weights();
         time_stepper_pt(i)->set_weights();
       }
  
       // Now calculate the predicted values for the all data and all positions
       calculate_predictions();
  
       // Run the individual timesteppers actions before timestep. These need to
       // be before the problem's actions_before_implicit_timestep so that the
       // boundary conditions are set consistently.
       for (unsigned i = 0; i < n_time_steppers; i++)
       {
         time_stepper_pt(i)->actions_before_timestep(this);
       }
  
       // Do any updates/boundary conditions changes here
       actions_before_implicit_timestep();
  
       // Attempt to solve the non-linear system
       try
       {
         // Solve the non-linear problem at this timestep
         newton_solve();
       }
       // Catch any exceptions thrown
       catch (NewtonSolverError& error)
       {
         // If it's a solver error then die
         if (error.linear_solver_error ||
             Time_adaptive_newton_crash_on_solve_fail)
         {
           std::string error_message = "USER-DEFINED ERROR IN NEWTON SOLVER\n";
           error_message += "ERROR IN THE LINEAR SOLVER\n";
  
           // Die
           throw OomphLibError(
             error_message, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
         }
         else
         {
           // Reject the timestep, if we have an exception
           oomph_info << "TIMESTEP REJECTED" << std::endl;
           reject_timestep = 1;
  
           // Half the time step
           dt_rescaling_factor = Timestep_reduction_factor_after_nonconvergence;
         }
       }
  
       // Run the individual timesteppers actions, these need to be before the
       // problem's actions_after_implicit_timestep so that the time step is
       // finished before the problem does any auxiliary calculations (e.g. in
       // semi-implicit micromagnetics the calculation of magnetostatic field).
       for (unsigned i = 0; i < n_time_steppers; i++)
       {
         time_stepper_pt(i)->actions_after_timestep(this);
       }
  
       // Update anything that needs updating after the timestep
       actions_after_implicit_timestep();
  
       // If we have an adapative timestepper (and we haven't already failed)
       // then calculate the error estimate and rescaling factor.
       if (adaptive_flag && !reject_timestep)
       {
         // Once timestep has been accepted can do fancy error processing
         // Set the error weights
         for (unsigned i = 0; i < n_time_steppers; i++)
         {
           time_stepper_pt(i)->set_error_weights();
         }
  
         // Get a global error norm to use in adaptivity (as specified by the
         // problem sub-class writer). Prevent a divide by zero if the solution
         // gives very close to zero error. Error norm should never be negative
         // but use absolute value just in case.
         double error = std::max(std::abs(global_temporal_error_norm()), 1e-12);
  
         // Calculate the scaling  factor
         dt_rescaling_factor = std::pow(
           (epsilon / error), (1.0 / (1.0 + time_stepper_pt()->order())));
  
         oomph_info << "Timestep scaling factor is  " << dt_rescaling_factor
                    << std::endl;
         oomph_info << "Estimated timestepping error is " << error << std::endl;
  
  
         // Do we have to do it again?
         if (error > epsilon)
         {
           oomph_info << "Estimated timestepping error " << error
                      << " exceeds tolerance " << epsilon << " ";
           if (Keep_temporal_error_below_tolerance)
           {
             oomph_info << " --> rejecting timestep." << std::endl;
             reject_timestep = 1;
           }
           else
           {
             oomph_info << " ...but we're not rejecting the timestep"
                        << std::endl;
           }
           oomph_info
             << "Note: This behaviour can be adjusted by changing the protected "
             << "boolean" << std::endl
             << std::endl
             << "    Problem::Keep_temporal_error_below_tolerance" << std::endl;
         }
  
  
       } // End of if adaptive flag
  
  
       // Calculate the next time step size and check it's ok
       // ============================================================
  
       // Calculate the possible next time step, if no error conditions
       // trigger.
       double new_dt_candidate = dt_rescaling_factor * dt_actual;
  
       // Check that the scaling factor is within the allowed range
       if (dt_rescaling_factor > DTSF_max_increase)
       {
         oomph_info << "Tried to increase dt by the ratio "
                    << dt_rescaling_factor << " which is above the maximum ("
                    << DTSF_max_increase
                    << "). Attempting to increase by the maximum ratio instead."
                    << std::endl;
         new_dt_candidate = DTSF_max_increase * dt_actual;
       }
       // If we have already rejected the timestep then don't do this check
       // because DTSF will definitely be too small.
       else if ((!reject_timestep) && (dt_rescaling_factor <= DTSF_min_decrease))
       {
         // Handle this special case where we want to continue anyway (usually
         // Minimum_dt_but_still_proceed = -1 so this has no effect).
         if (new_dt_candidate < Minimum_dt_but_still_proceed)
         {
           oomph_info
             << "Warning: Adaptation of timestep to ensure satisfaction\n"
             << "         of error bounds during adaptive timestepping\n"
             << "         would lower dt below \n"
             << "         Problem::Minimum_dt_but_still_proceed="
             << Minimum_dt_but_still_proceed << "\n"
             << "         ---> We're continuing with present timestep.\n"
             << std::endl;
           dt_rescaling_factor = 1.0;
           // ??ds shouldn't we set new_dt_candidate =
           // Minimum_dt_but_still_proceed here, rather than not changing dt at
           // all?
         }
         else
         {
           // Otherwise reject
           oomph_info << "Timestep would decrease by " << dt_rescaling_factor
                      << " which is less than the minimum scaling factor "
                      << DTSF_min_decrease << std::endl;
           oomph_info << "TIMESTEP REJECTED" << std::endl;
           reject_timestep = 1;
         }
       }
  
       // Now check that the new dt is within the allowed range
       if (new_dt_candidate > Maximum_dt)
       {
         oomph_info << "Tried to increase dt to " << new_dt_candidate
                    << " which is above the maximum (" << Maximum_dt
                    << "). I increased it to the maximum value instead.";
         dt_actual = Maximum_dt;
       }
       else if (new_dt_candidate < Minimum_dt)
       {
         std::ostringstream err;
         err << "Tried to reduce dt to " << new_dt_candidate
             << " which is less than the minimum dt (" << Minimum_dt << ")."
             << std::endl;
         throw OomphLibError(
           err.str(), OOMPH_EXCEPTION_LOCATION, OOMPH_CURRENT_FUNCTION);
       }
       else
       {
         dt_actual = new_dt_candidate;
       }
  
  
       actions_after_implicit_timestep_and_error_estimation();
  
  
       // If we are rejecting this attempt then revert the dofs etc.
       if (reject_timestep)
       {
         // Reset the time
         time_pt()->time() = time_current;
  
         // Reload the dofs
         unsigned ni = dofs_current.size();
         for (unsigned i = 0; i < ni; i++)
         {
           dof(i) = dofs_current[i];
         }
  
 #ifdef OOMPH_HAS_MPI
         // Synchronise the solution on different processors (on each submesh)
         this->synchronise_all_dofs();
 #endif
  
         // Call all "after" actions, e.g. to handle mesh updates
         actions_after_newton_step();
         actions_before_newton_convergence_check();
         actions_after_newton_solve();
         actions_after_implicit_timestep();
         actions_after_implicit_timestep_and_error_estimation();
       }
  
     }
     // Keep this loop going until we accept the timestep
     while (reject_timestep);
  
     // Once the timestep has been accepted, return the time step that should be
     // used next time.
     return dt_actual;
   }

References abs(), actions_after_implicit_timestep(), actions_after_implicit_timestep_and_error_estimation(), actions_after_newton_solve(), actions_after_newton_step(), oomph::TimeStepper::actions_after_timestep(), actions_before_implicit_timestep(), actions_before_newton_convergence_check(), oomph::TimeStepper::actions_before_timestep(), calculate_predictions(), dof(), dof_distribution_pt(), oomph::Time::dt(), DTSF_max_increase, DTSF_min_decrease, e(), oomph::SarahBL::epsilon, calibrate::error, global_temporal_error_norm(), i, Keep_temporal_error_below_tolerance, max, Maximum_dt, Minimum_dt, Minimum_dt_but_still_proceed, newton_solve(), oomph::LinearAlgebraDistribution::nrow_local(), ntime_stepper(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::oomph_info, Eigen::bfloat16_impl::pow(), oomph::TimeStepper::set_error_weights(), oomph::TimeStepper::set_predictor_weights(), oomph::TimeStepper::set_weights(), shift_time_values(), oomph::Global_string_for_annotation::string(), oomph::Time::time(), Time_adaptive_newton_crash_on_solve_fail, time_pt(), time_stepper_pt(), and Timestep_reduction_factor_after_nonconvergence.

◆ add_eigenvector_to_dofs()

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

Add the eigenvector passed to the function scaled by the constat epsilon to the dofs in the problem so that it can be output by the usual routines

Add the eigenvector passed to the function to the dofs with magnitude epsilon

   {
     unsigned long n_dof = ndof();
     // Check that the eigenvector has the correct size
     if (eigenvector.nrow() != n_dof)
     {
       std::ostringstream error_message;
       error_message << "Eigenvector has size " << eigenvector.nrow()
                     << ", not equal to the number of dofs in the problem,"
                     << n_dof << std::endl;
  
       throw OomphLibError(
         error_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
  
     // Loop over the dofs and add the eigenvector
     // Only use local values
     for (unsigned long n = 0; n < eigenvector.nrow_local(); n++)
     {
       dof(n) += epsilon * eigenvector[n];
     }
 // Of course we now need to synchronise
 #ifdef OOMPH_HAS_MPI
     this->synchronise_all_dofs();
 #endif
   }

References dof(), oomph::SarahBL::epsilon, n, ndof(), oomph::DistributableLinearAlgebraObject::nrow(), oomph::DistributableLinearAlgebraObject::nrow_local(), OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

◆ add_global_data()

void oomph::Problem::add_global_data ( Data *const & global_data_pt )

inline

Add Data to the Problem's global data – the Problem will perform equation numbering etc. for such Data

     {
       Global_data_pt.push_back(global_data_pt);
     }

References Global_data_pt, and global_data_pt().

Referenced by CapProblem< ELEMENT >::CapProblem(), ElasticRingProblem< ELEMENT >::ElasticRingProblem(), FreeSurfaceRotationProblem< ELEMENT >::FreeSurfaceRotationProblem(), PseudoSolidCapProblem< ELEMENT >::PseudoSolidCapProblem(), RefineableRotatingCylinderProblem< ELEMENT >::RefineableRotatingCylinderProblem(), and SolidFreeSurfaceRotationProblem< ELEMENT >::SolidFreeSurfaceRotationProblem().

◆ add_sub_mesh()

unsigned oomph::Problem::add_sub_mesh ( Mesh *const & mesh_pt )

inline

Add a submesh to the problem and return its number, i, by which it can be accessed via mesh_pt(i).

     {
       Sub_mesh_pt.push_back(mesh_pt);
       return Sub_mesh_pt.size() - 1;
     }

References mesh_pt(), and Sub_mesh_pt.

◆ add_time_stepper_pt()

void Problem::add_time_stepper_pt ( TimeStepper *const & time_stepper_pt )

Add a timestepper to the problem. The function will automatically create or resize the Time object so that it contains the appropriate number of levels of storage.

   {
     // Add the timestepper to the vector
     Time_stepper_pt.push_back(time_stepper_pt);
  
     // Find the number of timesteps required by the timestepper
     unsigned ndt = time_stepper_pt->ndt();
  
     // If time has not been allocated, create time object with the
     // required number of time steps
     if (Time_pt == 0)
     {
       Time_pt = new Time(ndt);
       oomph_info << "Created Time with " << ndt << " timesteps" << std::endl;
     }
     else
     {
       // If the required number of time steps is greater than currently stored
       // resize the time storage
       if (ndt > Time_pt->ndt())
       {
         Time_pt->resize(ndt);
         oomph_info << "Resized Time to include " << ndt << " timesteps"
                    << std::endl;
       }
       // Otherwise report that we are OK
       else
       {
         oomph_info << "Time object already has storage for " << ndt
                    << " timesteps" << std::endl;
       }
     }
  
     // Pass the pointer to time to the timestepper
     time_stepper_pt->time_pt() = Time_pt;
   }

References oomph::Time::ndt(), oomph::TimeStepper::ndt(), oomph::oomph_info, oomph::Time::resize(), Time_pt, oomph::TimeStepper::time_pt(), Time_stepper_pt, and time_stepper_pt().

Referenced by arc_length_step_solve(), ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::ConvectionProblem(), ElasticInterfaceProblem< ELEMENT, TIMESTEPPER >::ElasticInterfaceProblem(), ElasticRingProblem< ELEMENT >::ElasticRingProblem(), FlowAroundCylinderProblem< ELEMENT >::FlowAroundCylinderProblem(), FSIChannelWithLeafletProblem< ELEMENT >::FSIChannelWithLeafletProblem(), FSIRingProblem::FSIRingProblem(), HomogenisationProblem< ELEMENT >::HomogenisationProblem(), InterfaceProblem< ELEMENT, TIMESTEPPER >::InterfaceProblem(), LinearWaveProblem< ELEMENT, TIMESTEPPER >::LinearWaveProblem(), OscRingNStProblem< ELEMENT >::OscRingNStProblem(), PerturbedStateProblem< BASE_ELEMENT, PERTURBED_ELEMENT >::PerturbedStateProblem(), RayleighProblem< ELEMENT, TIMESTEPPER >::RayleighProblem(), RefineableActivatorInhibitorProblem< ELEMENT >::RefineableActivatorInhibitorProblem(), RefineableRotatingCylinderProblem< ELEMENT >::RefineableRotatingCylinderProblem(), RefineableUnsteadyHeatProblem< ELEMENT >::RefineableUnsteadyHeatProblem(), SurfactantProblem< ELEMENT, INTERFACE_ELEMENT >::SurfactantProblem(), TurekNonFSIProblem< ELEMENT >::TurekNonFSIProblem(), TurekProblem< FLUID_ELEMENT, SOLID_ELEMENT >::TurekProblem(), UnsteadyHeatProblem< ELEMENT >::UnsteadyHeatProblem(), and oomph::WomersleyProblem< ELEMENT, DIM >::WomersleyProblem().

◆ add_to_dofs()

void Problem::add_to_dofs	(	const double &	lambda,
		const DoubleVector &	increment_dofs
	)

virtual

Add lambda x incremenet_dofs[l] to the l-th dof.

Function that adds the values to the dofs.

Reimplemented from oomph::ExplicitTimeSteppableObject.

   {
     const unsigned long n_dof = this->ndof();
     for (unsigned long l = 0; l < n_dof; l++)
     {
       *Dof_pt[l] += lambda * increment_dofs[l];
     }
   }

References Dof_pt, lambda, and ndof().

◆ arc_length_step_solve() [1/2]

double Problem::arc_length_step_solve	(	Data *const &	data_pt,
		const unsigned &	data_index,
		const double &	ds,
		const unsigned &	max_adapt = `0`
	)

Solve a steady problem using arc-length continuation, when the variable corresponding to the arc-length constraint equation is already stored in data used in the problem: data_pt is a pointer to the appropriate data object, data_index is the index of the value that will be traded for the constriant, ds is the desired arc_length and max_adapt is the maximum number of spatial adaptations (default zero, no adaptation). Note that the value must be pinned in order for this formulation to work

This function takes one step of length ds in pseudo-arclength.The argument data_pt is a pointer to the data that holds the parameter (global variable) that is being traded for arc-length. The exact value is located at the location given by data_index. The function returns the next desired arc-length according to criteria based upon the desired number of Newton Iterations per solve.

   {
     // Firstly check that the data is pinned
     if (!data_pt->is_pinned(data_index))
     {
       std::ostringstream error_stream;
       error_stream << "The value at index " << data_index
                    << " in the data object to be used for continuation\n"
                    << "is not pinned, which means that it is already a\n"
                    << "variable in the problem "
                    << "and cannot be used for continuation.\n\n"
                    << "Please correct your formulation by either:\n"
                    << "A. Pinning the value"
                    << "\n or \n"
                    << "B. Using a different parameter for continuation"
                    << std::endl;
       throw OomphLibError(
         error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
  
  
     // If we are using the continuation timestepper
     if (Use_continuation_timestepper)
     {
       // Has the timestepper already been added to the problem
       bool continuation_time_stepper_added = false;
       const unsigned n_time_steppers = this->ntime_stepper();
       for (unsigned i = 0; i < n_time_steppers; i++)
       {
         if (this->time_stepper_pt(i) == &Continuation_time_stepper)
         {
           continuation_time_stepper_added = true;
           break;
         }
       }
  
       // If not add it
       if (!continuation_time_stepper_added)
       {
         oomph_info << "Adding the continuation time stepper\n";
         this->add_time_stepper_pt(&Continuation_time_stepper);
       }
  
       // Need to treat case of eigenproblems and bifurcation detection/tracking
       // here
  
  
       // Backup the current timesteppers for each mesh!
  
  
       // If an arc length step has not been taken then set the timestepper
       if (!Arc_length_step_taken)
       {
         // Set the continuation timestepper for all data in the problem
         oomph_info << this->set_timestepper_for_all_data(
                         &Continuation_time_stepper)
                    << " equation numbers allocated for continuation\n";
       }
  
  
     } // End of continuation time stepper case
  
  
     // Now make a pointer to the (newly allocated) data object
     double* parameter_pt = data_pt->value_pt(data_index);
     // Call the helper function, this will change the parameter_pt if
     // the data storage is changed (if the timestepper has to be changed,
     // which happens if this is the first time that a continuation step is
     // taken)
     // ALH: Don't think this is true because it has happened above....
     return arc_length_step_solve_helper(parameter_pt, ds, max_adapt);
   }

References add_time_stepper_pt(), arc_length_step_solve_helper(), Arc_length_step_taken, Continuation_time_stepper, i, oomph::Data::is_pinned(), ntime_stepper(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::oomph_info, set_timestepper_for_all_data(), time_stepper_pt(), Use_continuation_timestepper, and oomph::Data::value_pt().

◆ arc_length_step_solve() [2/2]

double Problem::arc_length_step_solve	(	double *const &	parameter_pt,
		const double &	ds,
		const unsigned &	max_adapt = `0`
	)

Solve a steady problem using arc-length continuation, when the parameter that becomes a variable corresponding to the arc-length constraint equation is an external double: parameter_pt is a pointer to that double, ds is the desired arc_length and max_adapt is the maximum number of spatial adaptations (default zero, no adaptation).

This function takes one step of length ds in pseudo-arclength.The argument parameter_pt is a pointer to the parameter (global variable) that is being traded for arc-length. The function returns the next desired arc-length according to criteria based upon the desired number of Newton Iterations per solve.

   {
     // First check that we shouldn't use the other interface
     // by checking that the parameter isn't already stored as data
     if (does_pointer_correspond_to_problem_data(parameter_pt))
     {
       std::ostringstream error_message;
       error_message
         << "The parameter addressed by " << parameter_pt << " with the value "
         << *parameter_pt
         << "\n is supposed to be used for arc-length contiunation,\n"
         << " but it is stored in a Data object used by the problem.\n\n"
         << "This is bad for two reasons:\n"
         << "1. If it's a variable in the problem, it must already have an\n"
            "associated equation, so it can't be used for continuation;\n"
         << "2. The problem data will be reorganised in memory during "
            "continuation,\n"
         << "   which means that the pointer will become invalid.\n\n"
         << "If you are sure that this is what you want to do you must:\n"
         << "A. Ensure that the value is pinned (don't worry we'll shout again "
            "if not)\n"
         << "B. Use the alternative interface\n"
         << "   Problem::arc_length_step_solve(Data*,unsigned,...)\n"
         << "   which uses a pointer to the data object and not the raw double "
            "pointer."
         << std::endl;
       throw OomphLibError(
         error_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
  
  
     // If we are using the continuation timestepper
     if (Use_continuation_timestepper)
     {
       // Has the timestepper already been added to the problem
       bool continuation_time_stepper_added = false;
       const unsigned n_time_steppers = this->ntime_stepper();
       for (unsigned i = 0; i < n_time_steppers; i++)
       {
         if (this->time_stepper_pt(i) == &Continuation_time_stepper)
         {
           continuation_time_stepper_added = true;
           break;
         }
       }
  
       // If not add it
       if (!continuation_time_stepper_added)
       {
         oomph_info << "Adding the continuation time stepper\n";
         this->add_time_stepper_pt(&Continuation_time_stepper);
       }
  
       // Need to treat case of eigenproblems and bifurcation detection/tracking
       // here
  
       // Backup the current timesteppers for each mesh!
  
  
       // If an arc length step has not been taken then set the timestepper
       if (!Arc_length_step_taken)
       {
         // Set the continuation timestepper for all data in the problem
         oomph_info << this->set_timestepper_for_all_data(
                         &Continuation_time_stepper)
                    << " equation numbers allocated for continuation\n";
       }
  
     } // End of continuation time stepper case
  
  
     // Just call the helper function (parameter is not from data)
     return arc_length_step_solve_helper(parameter_pt, ds, max_adapt);
   }

References add_time_stepper_pt(), arc_length_step_solve_helper(), Arc_length_step_taken, Continuation_time_stepper, does_pointer_correspond_to_problem_data(), i, ntime_stepper(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::oomph_info, set_timestepper_for_all_data(), time_stepper_pt(), and Use_continuation_timestepper.

Referenced by ContinuationProblem::solve().

◆ arc_length_step_solve_helper()

double Problem::arc_length_step_solve_helper	(	double *const &	parameter_pt,
		const double &	ds,
		const unsigned &	max_adapt
	)

private

Private helper function that actually contains the guts of the arc-length stepping, parameter_pt is a pointer to the parameter that is traded for the arc-length constraint, ds is the desired arc length and max_adapt is the maximum number of spatial adaptations. The pointer to the parameter may be changed if this is called from the Data-based interface

This function takes one step of length ds in pseudo-arclength.The argument parameter_pt is a pointer to the parameter (global variable) that is being traded for arc-length. The function returns the next desired arc-length according to criteria based upon the desired number of Newton Iterations per solve.

end of adaptation loop

   {
     //----------------------MAKE THE PROBLEM STEADY-----------------------
     // Loop over the timesteppers and make them (temporarily) steady.
     // We can only do continuation for steady problems!
     unsigned n_time_steppers = ntime_stepper();
     // Vector of bools to store the is_steady status of the various
     // timesteppers when we came in here
     std::vector<bool> was_steady(n_time_steppers);
  
     // Loop over them all and make them (temporarily) static
     for (unsigned i = 0; i < n_time_steppers; i++)
     {
       was_steady[i] = time_stepper_pt(i)->is_steady();
       time_stepper_pt(i)->make_steady();
     }
  
  
     // Max number of solves
     unsigned max_solve = max_adapt + 1;
     // Storage for newton steps in each adaptation
     unsigned max_count_in_adapt_loop = 0;
  
  
     //----SET UP MEMORY FOR QUANTITIES THAT ARE REQUIRED OUTSIDE THE LOOP----
  
     // Assign memory for solutions of the equations Jz = du/dparameter
     // This is needed here (outside the loop), so that we can save on
     // one linear solve when calculating the derivatives wrt the arc-length
     DoubleVector z;
  
  
     // Store sign of the Jacobian, used for bifurcation detection
     // If this is the first time that we are calling the arc-length solver,
     // this should not be used.
     int previous_sign = Sign_of_jacobian;
  
     // Flag to indicate a sign change
     bool SIGN_CHANGE = false;
  
  
     // Adaptation loop
     for (unsigned isolve = 0; isolve < max_solve; ++isolve)
     {
       // Only adapt after the first solve has been done
       if (isolve > 0)
       {
         unsigned n_refined;
         unsigned n_unrefined;
  
         // Adapt problem
         adapt(n_refined, n_unrefined);
  
 #ifdef OOMPH_HAS_MPI
         // Adaptation only converges if ALL the processes have no
         // refinement or unrefinement to perform
         unsigned total_refined = 0;
         unsigned total_unrefined = 0;
         if (Problem_has_been_distributed)
         {
           MPI_Allreduce(&n_refined,
                         &total_refined,
                         1,
                         MPI_UNSIGNED,
                         MPI_SUM,
                         this->communicator_pt()->mpi_comm());
           n_refined = total_refined;
           MPI_Allreduce(&n_unrefined,
                         &total_unrefined,
                         1,
                         MPI_UNSIGNED,
                         MPI_SUM,
                         this->communicator_pt()->mpi_comm());
           n_unrefined = total_unrefined;
         }
 #endif
  
         oomph_info << "---> " << n_refined << " elements were refined, and "
                    << n_unrefined << " were unrefined"
 #ifdef OOMPH_HAS_MPI
                    << ", in total (over all processors).\n";
 #else
                    << ".\n";
 #endif
  
  
         // Check convergence of adaptation cycle
         if ((n_refined == 0) && (n_unrefined == 0))
         {
           oomph_info << "\n \n Solution is fully converged in "
                      << "Problem::newton_solver(). \n \n ";
           break;
         }
       }
  
       //----------SAVE THE INITIAL VALUES, IN CASE THE STEP FAILS-----------
  
       // Find the number of local dofs
       unsigned ndof_local = Dof_distribution_pt->nrow_local();
  
       // Only need to do this in the first loop
       if (isolve == 0)
       {
         if (!Use_continuation_timestepper)
         {
           // Safety check, set up the array of dof derivatives, if necessary
           // The distribution is the same as the (natural) distribution of the
           // dofs
           if (Dof_derivative.size() != ndof_local)
           {
             Dof_derivative.resize(ndof_local, 0.0);
           }
  
           // Safety check, set up the array of curren values, if necessary
           // Again the distribution reflects the (natural) distribution of the
           // dofs
           if (Dof_current.size() != ndof_local)
           {
             Dof_current.resize(ndof_local);
           }
         }
  
         // Save the current value of the parameter
         Parameter_current = *parameter_pt;
  
         // Save the current values of the degrees of freedom
         for (unsigned long l = 0; l < ndof_local; l++)
         {
           dof_current(l) = *Dof_pt[l];
         }
  
         // Set the value of ds_current
         Ds_current = ds;
       }
  
       // Counter for the number of newton steps
       unsigned count = 0;
  
       // Flag to indicate a successful step
       bool STEP_REJECTED = false;
  
  
       // Set the appropriate initial conditions for the pinned data
       if (Use_continuation_timestepper)
       {
         this->set_consistent_pinned_values_for_continuation();
       }
  
       // Loop around the step in arc-length
       do
       {
         // Check that the step has not fallen below the minimum tolerance
         if (std::fabs(Ds_current) < Minimum_ds)
         {
           std::ostringstream error_message;
           error_message << "DESIRED ARC-LENGTH STEP " << Ds_current
                         << " HAS FALLEN BELOW MINIMUM TOLERANCE, " << Minimum_ds
                         << std::endl;
  
           throw OomphLibError(error_message.str(),
                               OOMPH_CURRENT_FUNCTION,
                               OOMPH_EXCEPTION_LOCATION);
         }
  
         // Assume that we shall accept the step
         STEP_REJECTED = false;
  
         // Set initial value of the parameter
         *parameter_pt = Parameter_current + Parameter_derivative * Ds_current;
  
         // Perform any actions...
         actions_after_parameter_increase(parameter_pt);
  
         Ds_current = (*parameter_pt - Parameter_current) / Parameter_derivative;
  
         // Loop over the (local) variables and set their initial values
         for (unsigned long l = 0; l < ndof_local; l++)
         {
           *Dof_pt[l] = dof_current(l) + dof_derivative(l) * Ds_current;
         }
  
         // Actually do the newton solve stage for the continuation problem
         try
         {
           count = newton_solve_continuation(parameter_pt, z);
         }
         // Catch any exceptions thrown in the Newton solver
         catch (NewtonSolverError& error)
         {
           // Check whether it's the linear solver
           if (error.linear_solver_error)
           {
             std::ostringstream error_stream;
             error_stream << std::endl
                          << "USER-DEFINED ERROR IN NEWTON SOLVER " << std::endl;
             oomph_info << "ERROR IN THE LINEAR SOLVER" << std::endl;
             throw OomphLibError(error_stream.str(),
                                 OOMPH_CURRENT_FUNCTION,
                                 OOMPH_EXCEPTION_LOCATION);
           }
           // Otherwise mark the step as having failed
           else
           {
             oomph_info << "STEP REJECTED --- TRYING AGAIN" << std::endl;
             STEP_REJECTED = true;
             // Let's take a smaller step
             Ds_current *= (2.0 / 3.0);
           }
         }
       } while (STEP_REJECTED); // continue until a step is accepted
  
       // Set the maximum count
       if (count > max_count_in_adapt_loop)
       {
         max_count_in_adapt_loop = count;
       }
     } 
  
     // Only recalculate the derivatives if there has been a Newton solve
     // If not, the previous values should be close enough
     if (max_count_in_adapt_loop > 0)
     {
       //--------------------CHECK FOR POTENTIAL BIFURCATIONS-------------
       if (Bifurcation_detection)
       {
         // If the sign of the jacobian is zero issue a warning
         if (Sign_of_jacobian == 0)
         {
           std::string error_message =
             "The sign of the jacobian is zero after a linear solve\n";
           error_message += "Either the matrix is singular (unlikely),\n";
           error_message += "or the linear solver cannot compute the "
                            "determinant of the matrix;\n";
           error_message += "e.g. an iterative linear solver.\n";
           error_message +=
             "If the latter, bifurcation detection must be via an eigensolver\n";
           OomphLibWarning(error_message,
                           "Problem::arc_length_step_solve",
                           OOMPH_EXCEPTION_LOCATION);
         }
         // If this is the first step, we cannot rely on the previous value
         // of the jacobian so set the previous sign to the present sign
         if (!Arc_length_step_taken)
         {
           previous_sign = Sign_of_jacobian;
         }
         // If we have detected a sign change in the last converged Jacobian,
         // it must be a turning point or bifurcation
         if (Sign_of_jacobian != previous_sign)
         {
           // There has been, at least, one sign change
           First_jacobian_sign_change = true;
  
           // The sign has changed this time
           SIGN_CHANGE = true;
  
           // Calculate the dot product of the approximate null vector
           // of the Jacobian matrix ((badly) approximated by z)
           // and the vectors of derivatives of the residuals wrt the
           // global parameter
           // If this is small it is a bifurcation rather than a turning point.
           // Get the derivative wrt global parameter
           // DoubleVector dparam;
           // get_derivative_wrt_global_parameter(parameter_pt,dparam);
           // Calculate the dot product
           // double dot=0.0;
           // for(unsigned long n=0;n<n_dofs;++n) {dot += dparam[n]*z[n];}
           // z.dot(dparam);
  
           // Write the output message
           std::ostringstream message;
           message
             << "-----------------------------------------------------------";
           message << std::endl
                   << "SIGN CHANGE IN DETERMINANT OF JACOBIAN: " << std::endl;
           message << "BIFURCATION OR TURNING POINT DETECTED BETWEEN "
                   << Parameter_current << " AND " << *parameter_pt << std::endl;
           // message << "APPROXIMATE DOT PRODUCT : " << dot << "," << std::endl;
           // message << "IF CLOSE TO ZERO WE HAVE A BIFURCATION; ";
           // message << "OTHERWISE A TURNING POINT" << std::endl;
           message
             << "-----------------------------------------------------------"
             << std::endl;
  
           // Write the message to standard output
           oomph_info << message.str();
  
           // Open the information file for appending
           std::ofstream bifurcation_info("bifurcation_info",
                                          std::ios_base::app);
           // Write the message to the file
           bifurcation_info << message.str();
           bifurcation_info.close();
         }
       }
  
       // Calculate the derivatives required for the next stage of continuation
       // In this we pass the last value of z (i.e. approximation)
       if (!Use_finite_differences_for_continuation_derivatives)
       {
         calculate_continuation_derivatives(z);
       }
       // Or use finite differences
       else
       {
         calculate_continuation_derivatives_fd(parameter_pt);
       }
  
       // If it's the first step then the value of the next step should
       // be the change in parameter divided by the parameter derivative
       // to obtain approximately the same parameter change
       if (!Arc_length_step_taken)
       {
         Ds_current = (*parameter_pt - Parameter_current) / Parameter_derivative;
       }
  
       // We have taken our first step
       Arc_length_step_taken = true;
     }
     // If there has not been a newton step then we still need to estimate
     // the derivatives in the arc length direction
     else
     {
       // Default is to calculate the continuation derivatives by solving the
       // linear system. We must do this to ensure that the derivatives are in
       // sync It could lead to problems near turning points when we should
       // really be solving an eigenproblem, but seems OK so far!
  
       // Save the current sign of the jacobian
       int temp_sign = Sign_of_jacobian;
  
       // Calculate the continuation derivatives, which includes a solve
       // of the linear system if not using finite differences
       if (!Use_finite_differences_for_continuation_derivatives)
       {
         calculate_continuation_derivatives(parameter_pt);
       }
       // Otherwise use finite differences
       else
       {
         calculate_continuation_derivatives_fd(parameter_pt);
       }
  
       // Reset the sign of the jacobian, just in case the sign has changed when
       // solving the continuation derivatives. The sign change will be picked
       // up on the next continuation step.
       Sign_of_jacobian = temp_sign;
     }
  
     // Reset the is_steady status of all timesteppers that
     // weren't already steady when we came in here and reset their
     // weights
     for (unsigned i = 0; i < n_time_steppers; i++)
     {
       if (!was_steady[i])
       {
         time_stepper_pt(i)->undo_make_steady();
       }
     }
  
     // If we are trying to find a bifurcation and the first sign change
     // has occured, use bisection
     if ((Bifurcation_detection) && (Bisect_to_find_bifurcation) &&
         (First_jacobian_sign_change))
     {
       // If there has been a sign change we need to half the step size
       // and reverse the direction
       if (SIGN_CHANGE)
       {
         Ds_current *= -0.5;
       }
       // Otherwise
       else
       {
         // The size of the bracketed interval is always
         // 2ds - Ds_current (this will work even if the original step failed)
         // We want our new step size to be half this
         Ds_current = ds - 0.5 * Ds_current;
       }
       // Return the desired value of the step
       return Ds_current;
     }
  
     // If fewer than the desired number of Newton Iterations, increase the step
     if (max_count_in_adapt_loop < Desired_newton_iterations_ds)
     {
       return Ds_current * 1.5;
     }
     // If more than the desired number of Newton Iterations, reduce the step
     if (max_count_in_adapt_loop > Desired_newton_iterations_ds)
     {
       return Ds_current * (2.0 / 3.0);
     }
     // Otherwise return the step just taken
     return Ds_current;
   }

References actions_after_parameter_increase(), adapt(), Arc_length_step_taken, Bifurcation_detection, Bisect_to_find_bifurcation, calculate_continuation_derivatives(), calculate_continuation_derivatives_fd(), communicator_pt(), Desired_newton_iterations_ds, Dof_current, dof_current(), Dof_derivative, dof_derivative(), Dof_distribution_pt, Dof_pt, Ds_current, calibrate::error, boost::multiprecision::fabs(), First_jacobian_sign_change, i, oomph::TimeStepper::is_steady(), oomph::TimeStepper::make_steady(), Minimum_ds, newton_solve_continuation(), oomph::LinearAlgebraDistribution::nrow_local(), ntime_stepper(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::oomph_info, Parameter_current, Parameter_derivative, set_consistent_pinned_values_for_continuation(), Sign_of_jacobian, oomph::Global_string_for_annotation::string(), time_stepper_pt(), oomph::TimeStepper::undo_make_steady(), Use_continuation_timestepper, and Use_finite_differences_for_continuation_derivatives.

Referenced by arc_length_step_solve().

◆ are_hessian_products_calculated_analytically()

bool oomph::Problem::are_hessian_products_calculated_analytically ( )

inline

Function to determine whether the hessian products are calculated analytically

     {
       return Calculate_hessian_products_analytic;
     }

References Calculate_hessian_products_analytic.

Referenced by get_hessian_vector_products().

◆ assembly_handler_pt() [1/2]

AssemblyHandler*& oomph::Problem::assembly_handler_pt ( )

inline

Return a pointer to the assembly handler object.

     {
       return Assembly_handler_pt;
     }

References Assembly_handler_pt.

Referenced by activate_pitchfork_tracking(), bifurcation_adapt_helper(), oomph::FpPressureAdvectionDiffusionProblem< ELEMENT >::FpPressureAdvectionDiffusionProblem(), get_hessian_vector_products(), get_inverse_mass_matrix_times_residuals(), get_jacobian(), oomph::NavierStokesSchurComplementPreconditioner::get_pressure_advection_diffusion_matrix(), get_residuals(), print_elemental_jacobian(), oomph::HSL_MA42::reorder_elements(), oomph::AugmentedBlockFoldLinearSolver::resolve(), oomph::BlockPitchForkLinearSolver::resolve(), oomph::AugmentedBlockPitchForkLinearSolver::resolve(), oomph::AugmentedBlockFoldLinearSolver::solve(), oomph::BlockPitchForkLinearSolver::solve(), oomph::AugmentedBlockPitchForkLinearSolver::solve(), oomph::BlockHopfLinearSolver::solve(), oomph::HSL_MA42::solve(), oomph::HSL_MA42::solve_for_one_dof(), oomph::BlockHopfLinearSolver::solve_for_two_rhs(), sparse_assemble_row_or_column_compressed_with_lists(), sparse_assemble_row_or_column_compressed_with_maps(), sparse_assemble_row_or_column_compressed_with_two_arrays(), sparse_assemble_row_or_column_compressed_with_two_vectors(), and sparse_assemble_row_or_column_compressed_with_vectors_of_pairs().

◆ assembly_handler_pt() [2/2]

AssemblyHandler* const& oomph::Problem::assembly_handler_pt ( ) const

inline

Return a pointer to the assembly handler object (const version)

     {
       return Assembly_handler_pt;
     }

References Assembly_handler_pt.

◆ assign_eigenvector_to_dofs()

void Problem::assign_eigenvector_to_dofs ( DoubleVector & eigenvector )

Assign the eigenvector passed to the function to the dofs.

Assign the eigenvector passed to the function to the dofs in the problem so that it can be output by the usual routines.

   {
     unsigned long n_dof = ndof();
     // Check that the eigenvector has the correct size
     if (eigenvector.nrow() != n_dof)
     {
       std::ostringstream error_message;
       error_message << "Eigenvector has size " << eigenvector.nrow()
                     << ", not equal to the number of dofs in the problem,"
                     << n_dof << std::endl;
  
       throw OomphLibError(
         error_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
  
     // Loop over the dofs and assign the eigenvector
     for (unsigned long n = 0; n < eigenvector.nrow_local(); n++)
     {
       dof(n) = eigenvector[n];
     }
 // Of course we now need to synchronise
 #ifdef OOMPH_HAS_MPI
     this->synchronise_all_dofs();
 #endif
   }

References dof(), n, ndof(), oomph::DistributableLinearAlgebraObject::nrow(), oomph::DistributableLinearAlgebraObject::nrow_local(), OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

◆ assign_eqn_numbers()

unsigned long Problem::assign_eqn_numbers ( const bool & assign_local_eqn_numbers = true )

Assign all equation numbers for problem: Deals with global data (= data that isn't attached to any elements) and then does the equation numbering for the elements. Virtual so it can be overloaded in MPI problems. Bool argument can be set to false to ignore assigning local equation numbers (found to be necessary in the parallel implementation of locate_zeta between multiple meshes).

Assign all equation numbers for problem: Deals with global data (= data that isn't attached to any elements) and then does the equation numbering for the elements. Bool argument can be set to false to ignore assigning local equation numbers (necessary in the parallel implementation of locate_zeta between multiple meshes).

   {
     // Check that the global mesh has been build
 #ifdef PARANOID
     if (Mesh_pt == 0)
     {
       std::ostringstream error_stream;
       error_stream << "Global mesh does not exist, so equation numbers cannot "
                       "be assigned.\n";
       // Check for sub meshes
       if (nsub_mesh() == 0)
       {
         error_stream << "There aren't even any sub-meshes in the Problem.\n"
                      << "You can set the global mesh directly by using\n"
                      << "Problem::mesh_pt() = my_mesh_pt;\n"
                      << "OR you can use Problem::add_sub_mesh(mesh_pt); "
                      << "to add a sub mesh.\n";
       }
       else
       {
         error_stream << "There are " << nsub_mesh() << " sub-meshes.\n";
       }
       error_stream << "You need to call Problem::build_global_mesh() to create "
                       "a global mesh\n"
                    << "from the sub-meshes.\n\n";
  
       throw OomphLibError(
         error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
 #endif
  
     // Number of submeshes
     unsigned n_sub_mesh = Sub_mesh_pt.size();
  
 #ifdef OOMPH_HAS_MPI
  
     // Storage for number of processors
     int n_proc = this->communicator_pt()->nproc();
  
  
     if (n_proc > 1)
     {
       // Force re-analysis of time spent on assembly each
       // elemental Jacobian
       Must_recompute_load_balance_for_assembly = true;
       Elemental_assembly_time.clear();
     }
     else
     {
       Must_recompute_load_balance_for_assembly = false;
     }
  
     // Re-distribution of elements over processors during assembly
     // must be recomputed
     if (!Problem_has_been_distributed)
     {
       // Set default first and last elements for parallel assembly
       // of non-distributed problem.
       set_default_first_and_last_element_for_assembly();
     }
  
 #endif
  
  
     double t_start = 0.0;
     if (Global_timings::Doc_comprehensive_timings)
     {
       t_start = TimingHelpers::timer();
     }
  
     // Loop over all elements in the mesh and set up any additional
     // dependencies that they may have (e.g. storing the geometric
     // Data, i.e. Data that affects an element's shape in elements
     // with algebraic node-update functions
     unsigned nel = Mesh_pt->nelement();
     for (unsigned e = 0; e < nel; e++)
     {
       Mesh_pt->element_pt(e)->complete_setup_of_dependencies();
     }
  
 #ifdef OOMPH_HAS_MPI
     // Complete setup of dependencies for external halo elements too
     unsigned n_mesh = this->nsub_mesh();
     for (unsigned i_mesh = 0; i_mesh < n_mesh; i_mesh++)
     {
       for (int iproc = 0; iproc < n_proc; iproc++)
       {
         unsigned n_ext_halo_el = mesh_pt(i_mesh)->nexternal_halo_element(iproc);
         for (unsigned e = 0; e < n_ext_halo_el; e++)
         {
           mesh_pt(i_mesh)
             ->external_halo_element_pt(iproc, e)
             ->complete_setup_of_dependencies();
         }
       }
     }
 #endif
  
  
     double t_end = 0.0;
     if (Global_timings::Doc_comprehensive_timings)
     {
       t_end = TimingHelpers::timer();
       oomph_info
         << "Time for complete setup of dependencies in assign_eqn_numbers: "
         << t_end - t_start << std::endl;
     }
  
  
     // Initialise number of dofs for reserve below
     unsigned n_dof = 0;
  
     // Potentially loop over remainder of routine, possible re-visiting all
     // those parts that must be redone, following the removal of duplicate
     // external halo data.
     for (unsigned loop_count = 0; loop_count < 2; loop_count++)
     {
       //(Re)-set the dof pointer to zero length because entries are
       // pushed back onto it -- if it's not reset here then we get into
       // trouble during mesh refinement when we reassign all dofs
       Dof_pt.resize(0);
  
       // Reserve from previous allocation if we're going around again
       Dof_pt.reserve(n_dof);
  
       // Reset the equation number
       unsigned long equation_number = 0;
  
       // Now set equation numbers for the global Data
       unsigned Nglobal_data = nglobal_data();
       for (unsigned i = 0; i < Nglobal_data; i++)
       {
         Global_data_pt[i]->assign_eqn_numbers(equation_number, Dof_pt);
       }
  
       if (Global_timings::Doc_comprehensive_timings)
       {
         t_start = TimingHelpers::timer();
       }
  
       // Call assign equation numbers on the global mesh
       n_dof = Mesh_pt->assign_global_eqn_numbers(Dof_pt);
  
       // Deal with the spine meshes additional numbering
       // If there is only one mesh
       if (n_sub_mesh == 0)
       {
         if (SpineMesh* const spine_mesh_pt = dynamic_cast<SpineMesh*>(Mesh_pt))
         {
           n_dof = spine_mesh_pt->assign_global_spine_eqn_numbers(Dof_pt);
         }
       }
       // Otherwise loop over the sub meshes
       else
       {
         // Assign global equation numbers first
         for (unsigned i = 0; i < n_sub_mesh; i++)
         {
           if (SpineMesh* const spine_mesh_pt =
                 dynamic_cast<SpineMesh*>(Sub_mesh_pt[i]))
           {
             n_dof = spine_mesh_pt->assign_global_spine_eqn_numbers(Dof_pt);
           }
         }
       }
  
       if (Global_timings::Doc_comprehensive_timings)
       {
         t_end = TimingHelpers::timer();
         oomph_info
           << "Time for assign_global_eqn_numbers in assign_eqn_numbers: "
           << t_end - t_start << std::endl;
         t_start = TimingHelpers::timer();
       }
  
  
 #ifdef OOMPH_HAS_MPI
  
       // reset previous allocation
       Parallel_sparse_assemble_previous_allocation = 0;
  
       // Only synchronise if the problem has actually been
       // distributed.
       if (Problem_has_been_distributed)
       {
         // Synchronise the equation numbers and return the total
         // number of degrees of freedom in the overall problem
         // Do not assign local equation numbers -- we're doing this
         // below.
         n_dof = synchronise_eqn_numbers(false);
       }
       // ..else just setup the Dof_distribution_pt
       // NOTE: this is setup by synchronise_eqn_numbers(...)
       // if Problem_has_been_distributed
       else
 #endif
       {
         Dof_distribution_pt->build(Communicator_pt, n_dof, false);
       }
  
       if (Global_timings::Doc_comprehensive_timings)
       {
         t_end = TimingHelpers::timer();
         oomph_info << "Time for Problem::synchronise_eqn_numbers in "
                    << "Problem::assign_eqn_numbers: " << t_end - t_start
                    << std::endl;
       }
  
  
 #ifdef OOMPH_HAS_MPI
  
  
       // Now remove duplicate data in external halo elements
       if (Problem_has_been_distributed)
       {
         if (Global_timings::Doc_comprehensive_timings)
         {
           t_start = TimingHelpers::timer();
         }
  
         // Monitor if we've actually changed anything
         bool actually_removed_some_data = false;
  
         // Only do it once!
         if (loop_count == 0)
         {
           if (n_sub_mesh == 0)
           {
             remove_duplicate_data(Mesh_pt, actually_removed_some_data);
           }
           else
           {
             for (unsigned i = 0; i < n_sub_mesh; i++)
             {
               bool tmp_actually_removed_some_data = false;
               remove_duplicate_data(Sub_mesh_pt[i],
                                     tmp_actually_removed_some_data);
               if (tmp_actually_removed_some_data)
                 actually_removed_some_data = true;
             }
           }
         }
  
  
         if (Global_timings::Doc_comprehensive_timings)
         {
           t_end = TimingHelpers::timer();
           std::stringstream tmp;
           tmp << "Time for calls to Problem::remove_duplicate_data in "
               << "Problem::assign_eqn_numbers: " << t_end - t_start
               << " ; have ";
           if (!actually_removed_some_data)
           {
             tmp << " not ";
           }
           tmp << " removed some/any data.\n";
           oomph_info << tmp.str();
           t_start = TimingHelpers::timer();
         }
  
         // Break out of the loop if we haven't done anything here.
         unsigned status = 0;
         if (actually_removed_some_data) status = 1;
  
         // Allreduce to check if anyone has removed any data
         unsigned overall_status = 0;
         MPI_Allreduce(&status,
                       &overall_status,
                       1,
                       MPI_UNSIGNED,
                       MPI_MAX,
                       this->communicator_pt()->mpi_comm());
  
  
         if (Global_timings::Doc_comprehensive_timings)
         {
           t_end = TimingHelpers::timer();
           std::stringstream tmp;
           tmp
             << "Time for MPI_Allreduce after Problem::remove_duplicate_data in "
             << "Problem::assign_eqn_numbers: " << t_end - t_start << std::endl;
           oomph_info << tmp.str();
           t_start = TimingHelpers::timer();
         }
  
         // Bail out if we haven't done anything here
         if (overall_status != 1)
         {
           break;
         }
  
         // Big tidy up: Remove null pointers from halo/haloed node storage
         // for all meshes (this involves comms and therefore must be
         // performed outside loop over meshes so the all-to-all is only
         // done once)
         remove_null_pointers_from_external_halo_node_storage();
  
         // Time it...
         if (Global_timings::Doc_comprehensive_timings)
         {
           double t_end = TimingHelpers::timer();
           oomph_info << "Total time for "
                      << "Problem::remove_null_pointers_from_external_halo_node_"
                         "storage(): "
                      << t_end - t_start << std::endl;
         }
       }
       else
       {
         // Problem not distributed; no need for another loop
         break;
       }
  
 #else
  
       // Serial run: Again no need for a second loop
       break;
  
 #endif
  
     } // end of loop over fcts that need to be re-executed if
     // we've removed duplicate external data
  
  
     // Resize the sparse assemble with arrays previous allocation
     Sparse_assemble_with_arrays_previous_allocation.resize(0);
  
  
     if (Global_timings::Doc_comprehensive_timings)
     {
       t_start = TimingHelpers::timer();
     }
  
     // Finally assign local equations
     if (assign_local_eqn_numbers)
     {
       if (n_sub_mesh == 0)
       {
         Mesh_pt->assign_local_eqn_numbers(Store_local_dof_pt_in_elements);
       }
       else
       {
         for (unsigned i = 0; i < n_sub_mesh; i++)
         {
           Sub_mesh_pt[i]->assign_local_eqn_numbers(
             Store_local_dof_pt_in_elements);
         }
       }
     }
  
     if (Global_timings::Doc_comprehensive_timings)
     {
       t_end = TimingHelpers::timer();
       oomph_info << "Total time for all Mesh::assign_local_eqn_numbers in "
                  << "Problem::assign_eqn_numbers: " << t_end - t_start
                  << std::endl;
     }
  
  
     // and return the total number of DOFs
     return n_dof;
   }

References oomph::Mesh::assign_global_eqn_numbers(), oomph::Mesh::assign_local_eqn_numbers(), oomph::LinearAlgebraDistribution::build(), Communicator_pt, communicator_pt(), oomph::GeneralisedElement::complete_setup_of_dependencies(), oomph::Global_timings::Doc_comprehensive_timings, Dof_distribution_pt, Dof_pt, e(), oomph::Mesh::element_pt(), Global_data_pt, i, Mesh_pt, mesh_pt(), oomph::Mesh::nelement(), nglobal_data(), oomph::OomphCommunicator::nproc(), nsub_mesh(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::oomph_info, Sparse_assemble_with_arrays_previous_allocation, Store_local_dof_pt_in_elements, Sub_mesh_pt, oomph::TimingHelpers::timer(), and tmp.

◆ assign_initial_values_impulsive() [1/2]

void Problem::assign_initial_values_impulsive ( )

Initialise data and nodal positions to simulate impulsive start from initial configuration/solution

Initialise the previous values of the variables for time stepping corresponding to an impulsive start. Previous history for all data is generated by the appropriate timesteppers. Previous nodal positions are simply copied backwards.

   {
     // Assign the impulsive values in the "master" mesh
     Mesh_pt->assign_initial_values_impulsive();
  
     // Loop over global data
     unsigned Nglobal = Global_data_pt.size();
     for (unsigned iglobal = 0; iglobal < Nglobal; iglobal++)
     {
       Global_data_pt[iglobal]
         ->time_stepper_pt()
         ->assign_initial_values_impulsive(Global_data_pt[iglobal]);
     }
   }

References oomph::Mesh::assign_initial_values_impulsive(), Global_data_pt, and Mesh_pt.

Referenced by assign_initial_values_impulsive(), oomph::SolidICProblem::set_static_initial_condition(), steady_newton_solve(), and oomph::SegregatableFSIProblem::steady_segregated_solve().

◆ assign_initial_values_impulsive() [2/2]

void Problem::assign_initial_values_impulsive ( const double & dt )

Initialise data and nodal positions to simulate an impulsive start and also set the initial and previous values of dt

Assign the values for an impulsive start and also set the initial values of the previous dts to both be dt

   {
     // First initialise the dts and set the weights
     initialise_dt(dt);
     // Now call assign_initial_values_impulsive
     assign_initial_values_impulsive();
   }

References assign_initial_values_impulsive(), and initialise_dt().

◆ bifurcation_adapt_doc_errors()

void Problem::bifurcation_adapt_doc_errors ( const unsigned & bifurcation_type )

private

A function that is used to document the errors used in the adaptive solution of bifurcation problems.

A function that is used to document the errors when adapting a bifurcation-tracking problem, which requires separate interpolation of the associated eigenfunction. The error measure is chosen to be a suitable combination of the errors in the base flow and the eigenfunction. The bifurcation type is passed as an argument

   {
     // Dummy arguments
     unsigned n_refined, n_unrefined;
     // Just call the bifurcation helper without actually adapting
     bifurcation_adapt_helper(n_refined, n_unrefined, bifurcation_type, false);
   }

References bifurcation_adapt_helper().

Referenced by doc_errors().

◆ bifurcation_adapt_helper()

void Problem::bifurcation_adapt_helper	(	unsigned &	n_refined,
		unsigned &	n_unrefined,
		const unsigned &	bifurcation_type,
		const bool &	actually_adapt = `true`
	)

private

A function that is used to adapt a bifurcation-tracking problem, which requires separate interpolation of the associated eigenfunction. The error measure is chosen to be a suitable combination of the errors in the base flow and the eigenfunction

A function that is used to adapt a bifurcation-tracking problem, which requires separate interpolation of the associated eigenfunction. The error measure is chosen to be a suitable combination of the errors in the base flow and the eigenfunction. The bifurcation type is passed as an argument

   {
     // Storage for eigenfunction from the problem
     Vector<DoubleVector> eigenfunction;
     // Get the eigenfunction from the problem
     this->get_bifurcation_eigenfunction(eigenfunction);
  
     // Get the bifurcation parameter
     double* parameter_pt = this->bifurcation_parameter_pt();
  
     // Get the frequency parameter if tracking a Hopf bifurcation
     double omega = 0.0;
     // If we're tracking a Hopf then also get the frequency
     if (bifurcation_type == 3)
     {
       omega = dynamic_cast<HopfHandler*>(assembly_handler_pt())->omega();
     }
  
     // If we're tracking a Pitchfork get the slack parameter (Hack)
     double sigma = 0.0;
     if (bifurcation_type == 2)
     {
       sigma = this->dof(this->ndof() - 1);
     }
  
     // We can now deactivate the bifurcation tracking in the problem
     // to restore the degrees of freedom to the unaugmented value
     this->deactivate_bifurcation_tracking();
  
     // Next, we create copies of the present problem
     // The number of copies depends on the number of eigenfunctions
     // One copy for each eigenfunction
     const unsigned n_copies = eigenfunction.size();
     Copy_of_problem_pt.resize(n_copies);
  
     // Loop over the number of copies
     for (unsigned c = 0; c < n_copies; c++)
     {
       // If we don't already have a copy
       if (Copy_of_problem_pt[c] == 0)
       {
         // Create the copy
         Copy_of_problem_pt[c] = this->make_copy();
  
         // Refine the copy to the same level as the current problem
  
         // Find number of submeshes
         const unsigned N_mesh = Copy_of_problem_pt[c]->nsub_mesh();
         // If there is only one mesh
         if (N_mesh == 0)
         {
           // Can we refine the mesh
           if (TreeBasedRefineableMeshBase* mmesh_pt =
                 dynamic_cast<TreeBasedRefineableMeshBase*>(
                   Copy_of_problem_pt[c]->mesh_pt(0)))
           {
             // Is the adapt flag set
             if (mmesh_pt->is_adaptation_enabled())
             {
               // Now get the original problem's mesh if it's refineable
               if (TreeBasedRefineableMeshBase* original_mesh_pt =
                     dynamic_cast<TreeBasedRefineableMeshBase*>(
                       this->mesh_pt(0)))
               {
                 mmesh_pt->refine_base_mesh_as_in_reference_mesh(
                   original_mesh_pt);
               }
               else
               {
                 oomph_info
                   << "Info/Warning: Mesh in orginal problem is not refineable."
                   << std::endl;
               }
             }
             else
             {
               oomph_info << "Info/Warning: Mesh adaptation is disabled in copy."
                          << std::endl;
             }
           }
           else
           {
             oomph_info << "Info/Warning: Mesh cannot be adapted in copy."
                        << std::endl;
           }
         } // End of single mesh case
         // Otherwise loop over the submeshes
         else
         {
           for (unsigned m = 0; m < N_mesh; m++)
           {
             // Can we refine the submesh
             if (TreeBasedRefineableMeshBase* mmesh_pt =
                   dynamic_cast<TreeBasedRefineableMeshBase*>(
                     Copy_of_problem_pt[c]->mesh_pt(m)))
             {
               // Is the adapt flag set
               if (mmesh_pt->is_adaptation_enabled())
               {
                 // Now get the original problem's mesh
                 if (TreeBasedRefineableMeshBase* original_mesh_pt =
                       dynamic_cast<TreeBasedRefineableMeshBase*>(
                         this->mesh_pt(m)))
                 {
                   mmesh_pt->refine_base_mesh_as_in_reference_mesh(
                     original_mesh_pt);
                 }
                 else
                 {
                   oomph_info << "Info/Warning: Mesh in orginal problem is not "
                                 "refineable."
                              << std::endl;
                 }
               }
               else
               {
                 oomph_info
                   << "Info/Warning: Mesh adaptation is disabled in copy."
                   << std::endl;
               }
             }
             else
             {
               oomph_info << "Info/Warning: Mesh cannot be adapted in copy."
                          << std::endl;
             }
           }
           // rebuild the global mesh in the copy
           Copy_of_problem_pt[c]->rebuild_global_mesh();
  
         } // End of multiple mesh case
  
         // Must call actions after adapt
         Copy_of_problem_pt[c]->actions_after_adapt();
  
         // Assign the equation numbers to the copy (quietly)
         (void)Copy_of_problem_pt[c]->assign_eqn_numbers();
       }
     } // End of creation of copies
  
  
     // Now check some numbers
     for (unsigned c = 0; c < n_copies; c++)
     {
       // Check that the dofs match for each copy
 #ifdef PARANOID
       // If the problems don't match then complain
       if (Copy_of_problem_pt[c]->ndof() != this->ndof())
       {
         std::ostringstream error_stream;
         error_stream << "Number of unknowns in the problem copy " << c << " "
                      << "not equal to number in the original:\n"
                      << this->ndof() << " (original) "
                      << Copy_of_problem_pt[c]->ndof() << " (copy)\n";
  
         throw OomphLibError(
           error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
       }
 #endif
  
       // Assign the eigenfunction(s) to the copied problems
       Copy_of_problem_pt[c]->assign_eigenvector_to_dofs(eigenfunction[c]);
       // Set all pinned values to zero
       Copy_of_problem_pt[c]->set_pinned_values_to_zero();
     }
  
     // Symmetrise the problem if we are solving a pitchfork
     if (bifurcation_type == 2)
     {
       Copy_of_problem_pt[0]
         ->symmetrise_eigenfunction_for_adaptive_pitchfork_tracking();
     }
  
     // Find error estimates based on current problem and eigenproblem
     // Now we need to get the error estimates for both problems.
     Vector<Vector<double>> base_error, eigenfunction_error;
     this->get_all_error_estimates(base_error);
     // Loop over the copies
     for (unsigned c = 0; c < n_copies; c++)
     {
       // Get the error estimates for the copy
       Copy_of_problem_pt[c]->get_all_error_estimates(eigenfunction_error);
  
       // Find the number of meshes
       unsigned n_mesh = base_error.size();
  
 #ifdef PARANOID
       if (n_mesh != eigenfunction_error.size())
       {
         std::ostringstream error_stream;
         error_stream << "Problems do not have the same number of meshes\n"
                      << "Base : " << n_mesh
                      << " : Eigenproblem : " << eigenfunction_error.size()
                      << "\n";
         throw OomphLibError(
           error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
       }
 #endif
  
       for (unsigned m = 0; m < n_mesh; m++)
       {
         // Check the number of elements is the same
         unsigned n_element = base_error[m].size();
 #ifdef PARANOID
         if (n_element != eigenfunction_error[m].size())
         {
           std::ostringstream error_stream;
           error_stream << "Mesh " << m
                        << " does not have the same number of elements in the "
                           "two problems:\n"
                        << "Base: " << n_element
                        << " :  Eigenproblem: " << eigenfunction_error[m].size()
                        << "\n";
           throw OomphLibError(error_stream.str(),
                               OOMPH_CURRENT_FUNCTION,
                               OOMPH_EXCEPTION_LOCATION);
         }
 #endif
         // Now add all the error esimates together
         for (unsigned e = 0; e < n_element; e++)
         {
           // Add the error estimates (lazy)
           base_error[m][e] += eigenfunction_error[m][e];
         }
       }
     } // End of loop over copies
  
     // Then refine all problems based on the combined measure
     // if we are actually adapting (not just estimating the errors)
     if (actually_adapt)
     {
       this->adapt_based_on_error_estimates(n_refined, n_unrefined, base_error);
       for (unsigned c = 0; c < n_copies; c++)
       {
         Copy_of_problem_pt[c]->adapt_based_on_error_estimates(
           n_refined, n_unrefined, base_error);
       }
       // Symmetrise the problem (again) if we are solving for a pitchfork
       if (bifurcation_type == 2)
       {
         Copy_of_problem_pt[0]
           ->symmetrise_eigenfunction_for_adaptive_pitchfork_tracking();
       }
  
       // Now get the refined guess for the eigenvector
       for (unsigned c = 0; c < n_copies; c++)
       {
         Copy_of_problem_pt[c]->get_dofs(eigenfunction[c]);
       }
     }
  
     // Reactivate the tracking
     switch (bifurcation_type)
     {
         // Fold tracking
       case 1:
         this->activate_fold_tracking(parameter_pt);
         break;
  
         // Pitchfork
       case 2:
         this->activate_pitchfork_tracking(parameter_pt, eigenfunction[0]);
         // reset the slack parameter
         this->dof(this->ndof() - 1) = sigma;
         break;
  
         // Hopf
       case 3:
         this->activate_hopf_tracking(
           parameter_pt, omega, eigenfunction[0], eigenfunction[1]);
         break;
  
       default:
         std::ostringstream error_stream;
         error_stream << "Bifurcation type " << bifurcation_type
                      << " not known\n"
                      << "1: Fold, 2: Pitchfork, 3: Hopf\n";
         throw OomphLibError(
           error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
   }

References activate_fold_tracking(), activate_hopf_tracking(), activate_pitchfork_tracking(), adapt_based_on_error_estimates(), assembly_handler_pt(), assign_eqn_numbers(), bifurcation_parameter_pt(), calibrate::c, Copy_of_problem_pt, deactivate_bifurcation_tracking(), dof(), e(), get_all_error_estimates(), get_bifurcation_eigenfunction(), m, make_copy(), mesh_pt(), ndof(), Eigen::internal::omega(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::oomph_info, calibrate::sigma, and size.

Referenced by adapt(), bifurcation_adapt_doc_errors(), and p_adapt().

◆ bifurcation_parameter_pt()

double * Problem::bifurcation_parameter_pt ( ) const

Return pointer to the parameter that is used in the bifurcation detection. If we are not tracking a bifurcation then an error will be thrown by the AssemblyHandler

   {
     return Assembly_handler_pt->bifurcation_parameter_pt();
   }

References Assembly_handler_pt, and oomph::AssemblyHandler::bifurcation_parameter_pt().

Referenced by bifurcation_adapt_helper().

◆ build_global_mesh()

void Problem::build_global_mesh ( )

Build the global mesh by combining the all the submeshes. Note: The nodes boundary information refers to the boundary numbers within the submesh!

Build a single (global) mesh from a number of submeshes which are passed as a vector of pointers to the submeshes. The ordering is not necessarily optimal.

   {
 #ifdef PARANOID
     // Has a global mesh already been built
     if (Mesh_pt != 0)
     {
       std::string error_message = "Problem::build_global_mesh() called,\n";
       error_message += " but a global mesh has already been built:\n";
       error_message += "Problem::Mesh_pt is not zero!\n";
  
       throw OomphLibError(
         error_message, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
     // Check that there are submeshes
     if (Sub_mesh_pt.size() == 0)
     {
       std::string error_message = "Problem::build_global_mesh() called,\n";
       error_message += " but there are no submeshes:\n";
       error_message += "Problem::Sub_mesh_pt has no entries\n";
  
       throw OomphLibError(
         error_message, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
 #endif
  
     // Create an empty mesh
     Mesh_pt = new Mesh();
  
     // Call the rebuild function to construct the mesh
     rebuild_global_mesh();
   }

References Mesh_pt, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, rebuild_global_mesh(), oomph::Global_string_for_annotation::string(), and Sub_mesh_pt.

Referenced by AxisymFreeSurfaceNozzleAdvDiffRobinProblem< ELEMENT >::AxisymFreeSurfaceNozzleAdvDiffRobinProblem(), oomph::ODEProblem::build(), oomph::BiharmonicProblem< DIM >::build_global_mesh_and_assign_eqn_numbers(), CapProblem< ELEMENT >::CapProblem(), ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::ConvectionProblem(), ElasticInterfaceProblem< ELEMENT, TIMESTEPPER >::ElasticInterfaceProblem(), FluxPoissonMGProblem< ELEMENT, MESH >::FluxPoissonMGProblem(), FreeSurfaceRotationProblem< ELEMENT >::FreeSurfaceRotationProblem(), FSIChannelWithLeafletProblem< ELEMENT >::FSIChannelWithLeafletProblem(), FSIRingProblem::FSIRingProblem(), HomogenisationProblem< ELEMENT >::HomogenisationProblem(), InterfaceProblem< ELEMENT, TIMESTEPPER >::InterfaceProblem(), MeltSpinningProblem< ELEMENT >::MeltSpinningProblem(), oomph::NonLinearElasticitySmoothMesh< ELEMENT >::operator()(), OscRingNStProblem< ELEMENT >::OscRingNStProblem(), PerturbedStateProblem< BASE_ELEMENT, PERTURBED_ELEMENT >::PerturbedStateProblem(), PseudoSolidCapProblem< ELEMENT >::PseudoSolidCapProblem(), RefineableFishPoissonProblem< ELEMENT >::RefineableFishPoissonProblem(), RefineableRotatingCylinderProblem< ELEMENT >::RefineableRotatingCylinderProblem(), RefineableTwoMeshFluxPoissonProblem< ELEMENT >::RefineableTwoMeshFluxPoissonProblem(), RefineableUnsteadyHeatProblem< ELEMENT >::RefineableUnsteadyHeatProblem(), SolidFreeSurfaceRotationProblem< ELEMENT >::SolidFreeSurfaceRotationProblem(), SurfactantProblem< ELEMENT, INTERFACE_ELEMENT >::SurfactantProblem(), TurekProblem< FLUID_ELEMENT, SOLID_ELEMENT >::TurekProblem(), TwoMeshFluxAdvectionDiffusionProblem< ELEMENT >::TwoMeshFluxAdvectionDiffusionProblem(), TwoMeshFluxPoissonProblem< ELEMENT >::TwoMeshFluxPoissonProblem(), UnsteadyHeatProblem< ELEMENT >::UnsteadyHeatProblem(), UnstructuredFvKProblem< ELEMENT >::UnstructuredFvKProblem(), and UnstructuredSolidProblem< ELEMENT, MESH >::UnstructuredSolidProblem().

◆ calculate_continuation_derivatives() [1/2]

void Problem::calculate_continuation_derivatives ( const DoubleVector & z )

protected

A function to calculate the derivatives with respect to the arc-length required for continuation. The arguments is the solution of the linear system, Jz = dR/dparameter, that gives du/dparameter and the direction output from the newton_solve_continuation function. The derivatives are stored in the ContinuationParameters namespace.

   {
     // Calculate the continuation derivatives
     calculate_continuation_derivatives_helper(z);
  
     // Scale the value of theta if the control flag is set
     if (Scale_arc_length)
     {
       // Don't divide by zero!
       if (Parameter_derivative != 1.0)
       {
         Theta_squared *= (Parameter_derivative * Parameter_derivative /
                           Desired_proportion_of_arc_length) *
                          ((1.0 - Desired_proportion_of_arc_length) /
                           (1.0 - Parameter_derivative * Parameter_derivative));
  
         // Recalculate the continuation derivatives with the new scaled values
         calculate_continuation_derivatives_helper(z);
       }
     }
   }

References calculate_continuation_derivatives_helper(), Desired_proportion_of_arc_length, Parameter_derivative, Scale_arc_length, and Theta_squared.

◆ calculate_continuation_derivatives() [2/2]

void Problem::calculate_continuation_derivatives ( double *const & parameter_pt )

protected

A function to calculate the derivatives wrt the arc-length. This version of the function actually does a linear solve so that the derivatives are calculated "exactly" rather than using the values at the Newton step just before convergence. This is necessary in spatially adaptive problems, in which the number of degrees of freedom changes and so the appropriate derivatives must be calculated for the new variables. This function is called if no Newton steps were taken in the continuation routine ... i.e. the initial residuals were sufficiently small.

A function to calculate the derivatives wrt the arc-length. This version of the function actually does a linear solve so that the derivatives are calculated "exactly" rather than using the values at the Newton step just before convergence. This is only necessary in spatially adaptive problems, in which the number of degrees of freedom changes and so the appropriate derivatives must be calculated for the new variables.

   {
     // Find the number of degrees of freedom in the problem
     const unsigned long n_dofs = ndof();
  
     // create a non-distributed z vector
     LinearAlgebraDistribution dist(Communicator_pt, n_dofs, false);
  
     // Assign memory for solutions of the equations
     DoubleVector z(&dist, 0.0);
  
     // If it's the block hopf solver need to solve for both RHS
     // at once, but this would all be alleviated if we have the solve
     // for the non-residuals RHS.
     if (dynamic_cast<BlockHopfLinearSolver*>(Linear_solver_pt))
     {
       // Get the vector dresiduals/dparameter
       get_derivative_wrt_global_parameter(parameter_pt, z);
  
       // Copy rhs vector into local storage so it doesn't get overwritten
       // if the linear solver decides to initialise the solution vector, say,
       // which it's quite entitled to do!
       DoubleVector dummy(&dist, 0.0), input_z(z);
  
       // Solve for the two RHSs
       dynamic_cast<BlockHopfLinearSolver*>(Linear_solver_pt)
         ->solve_for_two_rhs(this, dummy, input_z, z);
     }
     // Otherwise we can use the normal resolve
     else
     {
       // Save the status before entry to this routine
       bool enable_resolve = Linear_solver_pt->is_resolve_enabled();
  
       // We need to do resolves
       Linear_solver_pt->enable_resolve();
  
       // Solve the standard problem, we only want to make sure that
       // we factorise the matrix, if it has not been factorised. We shall
       // ignore the return value of z.
       Linear_solver_pt->solve(this, z);
  
       // Get the vector dresiduals/dparameter
       get_derivative_wrt_global_parameter(parameter_pt, z);
  
  
       // Copy rhs vector into local storage so it doesn't get overwritten
       // if the linear solver decides to initialise the solution vector, say,
       // which it's quite entitled to do!
       DoubleVector input_z(z);
  
       // Now resolve the system with the new RHS and overwrite the solution
       Linear_solver_pt->resolve(input_z, z);
  
       // Restore the storage status of the linear solver
       if (enable_resolve)
       {
         Linear_solver_pt->enable_resolve();
       }
       else
       {
         Linear_solver_pt->disable_resolve();
       }
     }
  
     // Now, we can calculate the derivatives, etc
     calculate_continuation_derivatives(z);
   }

References Communicator_pt, oomph::LinearSolver::disable_resolve(), oomph::LinearSolver::enable_resolve(), get_derivative_wrt_global_parameter(), oomph::LinearSolver::is_resolve_enabled(), Linear_solver_pt, ndof(), oomph::LinearSolver::resolve(), and oomph::LinearSolver::solve().

Referenced by arc_length_step_solve_helper().

◆ calculate_continuation_derivatives_fd()

void Problem::calculate_continuation_derivatives_fd ( double *const & parameter_pt )

protected

A function to calculate the derivatives with respect to the arc-length required for continuation by finite differences, using the previous values of the solution. The derivatives are stored in the ContinuationParameters namespace.

A function to calculate the derivatives with respect to the arc-length required for continuation using finite differences.

   {
     // Calculate the continuation derivatives
     calculate_continuation_derivatives_fd_helper(parameter_pt);
  
     // Scale the value of theta if the control flag is set
     if (Scale_arc_length)
     {
       // Don't divide by zero!
       if (Parameter_derivative != 1.0)
       {
         Theta_squared *= (Parameter_derivative * Parameter_derivative /
                           Desired_proportion_of_arc_length) *
                          ((1.0 - Desired_proportion_of_arc_length) /
                           (1.0 - Parameter_derivative * Parameter_derivative));
  
         // Recalculate the continuation derivatives with the new scaled values
         calculate_continuation_derivatives_fd_helper(parameter_pt);
       }
     }
   }

References calculate_continuation_derivatives_fd_helper(), Desired_proportion_of_arc_length, Parameter_derivative, Scale_arc_length, and Theta_squared.

Referenced by arc_length_step_solve_helper().

◆ calculate_continuation_derivatives_fd_helper()

void Problem::calculate_continuation_derivatives_fd_helper ( double *const & parameter_pt )

private

A function that performs the guts of the continuation derivative calculation in arc-length continuation problems using finite differences

A private helper function to calculate the derivatives with respect to the arc-length required for continuation using finite differences.

   {
     // Find the number of values
     // const unsigned long n_dofs = this->ndof();
     // Find the number of local dofs in the problem
     const unsigned long ndof_local = Dof_distribution_pt->nrow_local();
  
     // Temporary storage for the finite-difference approximation to the helper
     Vector<double> z(ndof_local);
     double length = 0.0;
     // Calculate the change in values and contribution to total length
     for (unsigned long l = 0; l < ndof_local; l++)
     {
       z[l] = (*Dof_pt[l] - Dof_current[l]) / Ds_current;
       length += Theta_squared * z[l] * z[l];
     }
  
     // Reduce if parallel
 #ifdef OOMPH_HAS_MPI
     double length2 = length;
     if ((Dof_distribution_pt->distributed()) &&
         (Dof_distribution_pt->communicator_pt()->nproc() > 1))
     {
       MPI_Allreduce(&length,
                     &length2,
                     1,
                     MPI_DOUBLE,
                     MPI_SUM,
                     Dof_distribution_pt->communicator_pt()->mpi_comm());
     }
     length = length2;
 #endif
  
     // Calculate change in parameter
     double Z = (*parameter_pt - Parameter_current) / Ds_current;
     length += Z * Z;
  
     // Scale the approximations to the derivatives
     length = sqrt(length);
     for (unsigned long l = 0; l < ndof_local; l++)
     {
       dof_derivative(l) = z[l] / length;
     }
     Parameter_derivative = Z / length;
   }

References oomph::LinearAlgebraDistribution::communicator_pt(), oomph::LinearAlgebraDistribution::distributed(), Dof_current, dof_derivative(), Dof_distribution_pt, Dof_pt, Ds_current, oomph::OomphCommunicator::nproc(), oomph::LinearAlgebraDistribution::nrow_local(), Parameter_current, Parameter_derivative, sqrt(), Theta_squared, and Z.

Referenced by calculate_continuation_derivatives_fd().

◆ calculate_continuation_derivatives_helper()

void Problem::calculate_continuation_derivatives_helper ( const DoubleVector & z )

private

A function that performs the guts of the continuation derivative calculation in arc length continuation problems.

A private helper function to calculate the derivatives with respect to the arc-length required for continuation. The arguments is the solution of the linear system, Jz = dR/dparameter, that gives du/dparameter and the direction output from the newton_solve_continuation function. The derivatives are stored in the ContinuationParameters namespace.

   {
     // Find the number of degrees of freedom in the problem
     // unsigned long n_dofs = ndof();
     // Find the number of local dofs in the problem
     const unsigned long ndof_local = Dof_distribution_pt->nrow_local();
  
     // Work out the continuation direction
     // The idea is that (du/ds)_{old} . (du/ds)_{new} >= 0
     // if the direction is to remain the same.
     // du/ds_{new} = [dlambda/ds; du/ds] = [dlambda/ds ; - dlambda/ds z]
     // so (du/ds)_{new} . (du/ds)_{old}
     // = dlambda/ds [1 ; - z] . [ Parameter_derivative ; Dof_derivatives]
     // = dlambda/ds (Parameter_derivative - Dof_derivative . z)
  
     // Create a local copy of z that can be redistributed without breaking
     // the constness of z
     DoubleVector local_z(z);
  
     // Redistribute z so that it has the (natural) dof distribution
     local_z.redistribute(Dof_distribution_pt);
  
     // Calculate the local contribution to the Continuation direction
     Continuation_direction = 0.0;
     // Cache the pointer to z
     double* const local_z_pt = local_z.values_pt();
     for (unsigned long l = 0; l < ndof_local; l++)
     {
       Continuation_direction -= dof_derivative(l) * local_z_pt[l];
     }
  
     // Now reduce if we have been distributed
 #ifdef OOMPH_HAS_MPI
     double cont_dir2 = Continuation_direction;
     if ((Dof_distribution_pt->distributed()) &&
         (Dof_distribution_pt->communicator_pt()->nproc() > 1))
     {
       MPI_Allreduce(&Continuation_direction,
                     &cont_dir2,
                     1,
                     MPI_DOUBLE,
                     MPI_SUM,
                     Dof_distribution_pt->communicator_pt()->mpi_comm());
     }
     Continuation_direction = cont_dir2;
 #endif
  
     // Add parameter derivative
     Continuation_direction += Parameter_derivative;
  
     // Calculate the magnitude of the du/ds Vector
  
     // Note that actually, we are usually approximating by using the value at
     // newton step just before convergence, which saves one additional
     // Newton solve.
  
     // First calculate the magnitude of du/dparameter, chi
     double chi = local_z.dot(local_z);
  
     // Calculate the current derivative of the parameter wrt the arc-length
     Parameter_derivative = 1.0 / sqrt(1.0 + Theta_squared * chi);
  
     // If the dot product of the current derivative wrt the Direction
     // is less than zero, switch the sign of the derivative to ensure
     // smooth continuation
     if (Parameter_derivative * Continuation_direction < 0.0)
     {
       Parameter_derivative *= -1.0;
     }
  
     // Resize the derivatives array, if necessary
     if (!Use_continuation_timestepper)
     {
       if (Dof_derivative.size() != ndof_local)
       {
         Dof_derivative.resize(ndof_local, 0.0);
       }
     }
     // Calculate the new derivatives wrt the arc-length
     for (unsigned long l = 0; l < ndof_local; l++)
     {
       // This comes from the formulation J u_dot + dr/dlambda  lambda_dot = 0
       // on the curve and then it follows that.
       dof_derivative(l) = -Parameter_derivative * local_z_pt[l];
     }
   }

References oomph::LinearAlgebraDistribution::communicator_pt(), Continuation_direction, oomph::LinearAlgebraDistribution::distributed(), Dof_derivative, dof_derivative(), Dof_distribution_pt, oomph::DoubleVector::dot(), oomph::OomphCommunicator::nproc(), oomph::LinearAlgebraDistribution::nrow_local(), Parameter_derivative, oomph::DoubleVector::redistribute(), sqrt(), Theta_squared, Use_continuation_timestepper, and oomph::DoubleVector::values_pt().

Referenced by calculate_continuation_derivatives().

◆ calculate_predictions()

void Problem::calculate_predictions ( )

Calculate predictions.

Calculate the predictions of all variables in problem.

   {
 // Check that if we have multiple time steppers none of them want to
 // predict by calling an explicit timestepper (as opposed to doing
 // something like an explicit step by combining known history values, as
 // done in BDF).
 #ifdef PARANOID
     if (Time_stepper_pt.size() != 1)
     {
       for (unsigned j = 0; j < Time_stepper_pt.size(); j++)
       {
         if (time_stepper_pt()->predict_by_explicit_step())
         {
           std::string err = "Prediction by explicit step only works for "
                             "problems with a simple time";
           err += "stepper. I think implementing anything more general will";
           err += "require a rewrite of explicit time steppers. - David";
           throw OomphLibError(
             err, OOMPH_EXCEPTION_LOCATION, OOMPH_CURRENT_FUNCTION);
         }
       }
     }
 #endif
  
  
     // Predict using an explicit timestepper (don't do it if adaptive = false
     // because pointers probably aren't set up).
     if (time_stepper_pt()->predict_by_explicit_step() &&
         time_stepper_pt()->adaptive_flag())
     {
       // Copy the time stepper's predictor pt into problem's explicit time
       // stepper pt (unless problem already has its own explicit time
       // stepper).
       ExplicitTimeStepper* ets_pt = time_stepper_pt()->explicit_predictor_pt();
 #ifdef PARANOID
       if (ets_pt == 0)
       {
         std::string err = "Requested predictions by explicit step but explicit";
         err += " predictor pt is null.";
         throw OomphLibError(
           err, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
       }
  
       if ((explicit_time_stepper_pt() != ets_pt) &&
           (explicit_time_stepper_pt() != 0))
       {
         throw OomphLibError("Problem has explicit time stepper other than "
                             "predictor, not sure how to handle this yet ??ds",
                             OOMPH_EXCEPTION_LOCATION,
                             OOMPH_CURRENT_FUNCTION);
       }
 #endif
       explicit_time_stepper_pt() = ets_pt;
  
       // Backup dofs and time
       store_current_dof_values();
  
 #ifdef PARANOID
       double backup_time = time();
 #endif
  
       // Move time back so that we are at the start of the timestep (as
       // explicit_timestep functions expect). This is needed because the
       // predictor calculations are done after unsteady newton solve has
       // started, and it has already moved time forwards.
       double dt = time_pt()->dt();
       time() -= dt;
  
       // Explicit step
       this->explicit_timestep(dt, false);
  
       // Copy predicted dofs and time to their storage slots.
       set_dofs(time_stepper_pt()->predictor_storage_index(), Dof_pt);
       time_stepper_pt()->update_predicted_time(time());
  
       // Check we got the times right
 #ifdef PARANOID
       if (std::abs(time() - backup_time) > 1e-12)
       {
         using namespace StringConversion;
         std::string err = "Predictor landed at the wrong time!";
         err += " Expected time " + to_string(backup_time, 14) + " but got ";
         err += to_string(time(), 14);
         throw OomphLibError(
           err, OOMPH_EXCEPTION_LOCATION, OOMPH_CURRENT_FUNCTION);
       }
 #endif
  
       // Restore dofs and time
       restore_dof_values();
     }
  
     // Otherwise we can do predictions in a more object oriented way using
     // whatever timestepper the data provides (this is the normal case).
     else
     {
       // Calculate all predictions in the "master" mesh
       Mesh_pt->calculate_predictions();
  
       // Calculate predictions for global data with their own timesteppers
       unsigned Nglobal = Global_data_pt.size();
       for (unsigned iglobal = 0; iglobal < Nglobal; iglobal++)
       {
         Global_data_pt[iglobal]->time_stepper_pt()->calculate_predicted_values(
           Global_data_pt[iglobal]);
       }
     }
  
     // If requested then copy the predicted value into the current time data
     // slots, ready for the newton solver to use as an initial guess.
     if (use_predictor_values_as_initial_guess())
     {
       // Not sure I know enough about distributed problems to implement
       // this. Probably you just need to loop over ndof_local or something,
       // but I can't really test it...
 #ifdef OOMPH_HAS_MPI
       if (distributed())
       {
         throw OomphLibError("Not yet implemented for distributed problems",
                             OOMPH_EXCEPTION_LOCATION,
                             OOMPH_CURRENT_FUNCTION);
       }
 #endif
  
       // With multiple time steppers this is much more complex becuase you
       // need to check the time stepper for each data to get the
       // predictor_storage_index(). Do-able if you need it though.
       if (Time_stepper_pt.size() != 1)
       {
         std::string err = "Not implemented for multiple time steppers";
         throw OomphLibError(
           err, OOMPH_EXCEPTION_LOCATION, OOMPH_CURRENT_FUNCTION);
       }
  
       // Get predicted values
       DoubleVector predicted_dofs;
       get_dofs(time_stepper_pt()->predictor_storage_index(), predicted_dofs);
  
       // Update dofs at current step
       for (unsigned i = 0; i < ndof(); i++)
       {
         dof(i) = predicted_dofs[i];
       }
     }
   }

References abs(), oomph::Mesh::calculate_predictions(), distributed(), dof(), Dof_pt, oomph::Time::dt(), e(), oomph::TimeStepper::explicit_predictor_pt(), explicit_time_stepper_pt(), explicit_timestep(), get_dofs(), Global_data_pt, i, j, Mesh_pt, ndof(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, restore_dof_values(), set_dofs(), store_current_dof_values(), oomph::Global_string_for_annotation::string(), time(), time_pt(), Time_stepper_pt, time_stepper_pt(), oomph::StringConversion::to_string(), oomph::TimeStepper::update_predicted_time(), and use_predictor_values_as_initial_guess().

Referenced by adaptive_unsteady_newton_solve().

◆ communicator_pt() [1/2]

OomphCommunicator* oomph::Problem::communicator_pt ( )

inline

access function to the oomph-lib communicator

     {
       return Communicator_pt;
     }

References Communicator_pt.

Referenced by oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::adapt_temporal_mesh(), arc_length_step_solve_helper(), assign_eqn_numbers(), oomph::Multi_domain_functions::aux_setup_multi_domain_interaction(), doubly_adaptive_unsteady_newton_solve_helper(), dump(), oomph::FoldHandler::FoldHandler(), oomph::Multi_domain_functions::get_dim_helper(), oomph::FoldHandler::get_eigenfunction(), oomph::HopfHandler::get_eigenfunction(), get_hessian_vector_products(), get_inverse_mass_matrix_times_residuals(), get_jacobian(), get_residuals(), oomph::HopfHandler::HopfHandler(), newton_solve(), parallel_test(), oomph::PitchForkHandler::PitchForkHandler(), read(), oomph::BlockPitchForkLinearSolver::resolve(), oomph::AugmentedBlockPitchForkLinearSolver::resolve(), oomph::SolidICProblem::set_static_initial_condition(), setup_element_count_per_dof(), oomph::AugmentedBlockFoldLinearSolver::solve(), oomph::BlockPitchForkLinearSolver::solve(), oomph::AugmentedBlockPitchForkLinearSolver::solve(), oomph::BlockHopfLinearSolver::solve(), oomph::HSL_MA42::solve(), oomph::GS< MATRIX >::solve(), oomph::GS< CRDoubleMatrix >::solve(), oomph::DampedJacobi< MATRIX >::solve(), oomph::GMRES< MATRIX >::solve(), oomph::AugmentedProblemGMRES::solve(), oomph::SuperLUSolver::solve(), oomph::MumpsSolver::solve(), oomph::HelmholtzGMRESMG< MATRIX >::solve(), oomph::HelmholtzFGMRESMG< MATRIX >::solve(), oomph::FoldHandler::solve_augmented_block_system(), oomph::PitchForkHandler::solve_augmented_block_system(), oomph::FoldHandler::solve_block_system(), oomph::HopfHandler::solve_complex_system(), oomph::ARPACK::solve_eigenproblem(), oomph::LAPACK_QZ::solve_eigenproblem(), oomph::BlockHopfLinearSolver::solve_for_two_rhs(), oomph::FoldHandler::solve_full_system(), oomph::PitchForkHandler::solve_full_system(), oomph::HopfHandler::solve_full_system(), oomph::HopfHandler::solve_standard_system(), oomph::SuperLUSolver::solve_transpose(), unsteady_newton_solve(), oomph::FoldHandler::~FoldHandler(), and oomph::HopfHandler::~HopfHandler().

◆ communicator_pt() [2/2]

const OomphCommunicator* oomph::Problem::communicator_pt ( ) const

inline

access function to the oomph-lib communicator, const version

     {
       return Communicator_pt;
     }

References Communicator_pt.

◆ copy()

void Problem::copy ( Problem * orig_problem_pt )

Copy Data values, nodal positions etc from specified problem. Note: This is not a copy constructor. We assume that the current and the "original" problem have both been created by calling the same problem constructor so that all Data objects, time steppers etc. in the two problems are completely independent. This function copies the nodal, internal and global values, and the time parameters from the original problem into "this" one. This functionality is required, e.g. for multigrid computations.

Copy Data values, nodal positions etc from specified problem. Note: This is not a copy constructor. We assume that the current and the "original" problem have both been created by calling the same problem constructor so that all Data objects, time steppers etc. in the two problems are completely independent. This function copies the nodal, internal and global values and the time parameters from the original problem into "this" one. This functionality is required, e.g. for multigrid computations.

   {
     // Copy time
     //----------
  
     // Flag to indicate that orig problem is unsteady problem
     bool unsteady_flag = (orig_problem_pt->time_pt() != 0);
  
     // Copy current time and previous time increments for proper unsteady run
     if (unsteady_flag)
     {
       oomph_info << "Copying an unsteady problem." << std::endl;
       // Current time
       this->time_pt()->time() = orig_problem_pt->time_pt()->time();
       // Timesteps
       unsigned n_dt = orig_problem_pt->time_pt()->ndt();
       time_pt()->resize(n_dt);
       for (unsigned i = 0; i < n_dt; i++)
       {
         time_pt()->dt(i) = orig_problem_pt->time_pt()->dt(i);
       }
  
       // Find out how many timesteppers there are
       unsigned n_time_steppers = ntime_stepper();
  
       // Loop over them all and set the weights
       for (unsigned i = 0; i < n_time_steppers; i++)
       {
         time_stepper_pt(i)->set_weights();
       }
     }
  
     // Copy nodes
     //-----------
  
     // Loop over submeshes:
     unsigned nmesh = nsub_mesh();
     if (nmesh == 0) nmesh = 1;
     for (unsigned m = 0; m < nmesh; m++)
     {
       // Find number of nodes in present mesh
       unsigned long n_node = mesh_pt(m)->nnode();
  
       // Check # of nodes:
       unsigned long n_node_orig = orig_problem_pt->mesh_pt(m)->nnode();
       if (n_node != n_node_orig)
       {
         std::ostringstream error_message;
         error_message << "Number of nodes in copy " << n_node
                       << " not equal to the number in the original "
                       << n_node_orig << std::endl;
  
         throw OomphLibError(error_message.str(),
                             OOMPH_CURRENT_FUNCTION,
                             OOMPH_EXCEPTION_LOCATION);
       }
  
       // Loop over the nodes
       for (unsigned long i = 0; i < n_node; i++)
       {
         // Try to cast to elastic node
         SolidNode* el_node_pt =
           dynamic_cast<SolidNode*>(mesh_pt(m)->node_pt(i));
         if (el_node_pt != 0)
         {
           SolidNode* el_node_orig_pt =
             dynamic_cast<SolidNode*>(orig_problem_pt->mesh_pt(m)->node_pt(i));
           el_node_pt->copy(el_node_orig_pt);
         }
         else
         {
           mesh_pt(m)->node_pt(i)->copy(orig_problem_pt->mesh_pt(m)->node_pt(i));
         }
       }
     }
  
  
     // Copy global data:
     //------------------
  
     // Number of global data
     unsigned n_global = Global_data_pt.size();
  
     // Check # of nodes in orig problem
     unsigned long n_global_orig = orig_problem_pt->nglobal_data();
     if (n_global != n_global_orig)
     {
       std::ostringstream error_message;
       error_message << "Number of global data in copy " << n_global
                     << " not equal to the number in the original "
                     << n_global_orig << std::endl;
  
       throw OomphLibError(
         error_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
  
     for (unsigned iglobal = 0; iglobal < n_global; iglobal++)
     {
       Global_data_pt[iglobal]->copy(orig_problem_pt->global_data_pt(iglobal));
     }
  
  
     // Copy internal data of elements:
     //--------------------------------
  
     // Loop over submeshes:
     for (unsigned m = 0; m < nmesh; m++)
     {
       // Loop over elements and deal with internal data
       unsigned n_element = mesh_pt(m)->nelement();
       for (unsigned e = 0; e < n_element; e++)
       {
         GeneralisedElement* el_pt = mesh_pt(m)->element_pt(e);
         unsigned n_internal = el_pt->ninternal_data();
         if (n_internal > 0)
         {
           // Check # of internals :
           unsigned long n_internal_orig =
             orig_problem_pt->mesh_pt(m)->element_pt(e)->ninternal_data();
           if (n_internal != n_internal_orig)
           {
             std::ostringstream error_message;
             error_message << "Number of internal data in copy " << n_internal
                           << " not equal to the number in the original "
                           << n_internal_orig << std::endl;
  
             throw OomphLibError(error_message.str(),
                                 OOMPH_CURRENT_FUNCTION,
                                 OOMPH_EXCEPTION_LOCATION);
           }
           for (unsigned i = 0; i < n_internal; i++)
           {
             el_pt->internal_data_pt(i)->copy(
               orig_problem_pt->mesh_pt(m)->element_pt(e)->internal_data_pt(i));
           }
         }
       }
     }
   }

References oomph::Data::copy(), oomph::Node::copy(), oomph::SolidNode::copy(), oomph::Time::dt(), e(), oomph::Mesh::element_pt(), Global_data_pt, global_data_pt(), i, oomph::GeneralisedElement::internal_data_pt(), m, mesh_pt(), oomph::Time::ndt(), oomph::Mesh::nelement(), nglobal_data(), oomph::GeneralisedElement::ninternal_data(), oomph::Mesh::nnode(), oomph::Mesh::node_pt(), nsub_mesh(), ntime_stepper(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::oomph_info, oomph::Time::resize(), oomph::TimeStepper::set_weights(), oomph::Time::time(), time_pt(), and time_stepper_pt().

◆ deactivate_bifurcation_tracking()

void oomph::Problem::deactivate_bifurcation_tracking ( )

inline

Deactivate all bifuraction tracking, by reseting the assembly handler to the default

     {
       reset_assembly_handler_to_default();
     }

References reset_assembly_handler_to_default().

Referenced by bifurcation_adapt_helper().

◆ debug_hook_fct()

virtual void oomph::Problem::debug_hook_fct ( const unsigned & i )

inlinevirtual

Hook for debugging. Can be overloaded in driver code; argument allows identification of where we're coming from

     {
       oomph_info << "Called empty hook fct with i=" << i << std::endl;
     }

References i, and oomph::oomph_info.

◆ delete_all_external_storage()

void Problem::delete_all_external_storage ( )

Wrapper function to delete external storage for each submesh of the problem

Delete any external storage for any submeshes NB this would ordinarily take place within the adaptation procedure for each submesh (See RefineableMesh::adapt_mesh(...)), but there are instances where the actions_before/after_adapt routines are used and no adaptive routines are called in between (e.g. when doc-ing errors at the end of an adaptive newton solver)

   {
     // Number of submeshes
     unsigned n_mesh = nsub_mesh();
  
     // External storage will only exist if there is more than one (sub)mesh
     if (n_mesh > 1)
     {
       for (unsigned i_mesh = 0; i_mesh < n_mesh; i_mesh++)
       {
         mesh_pt(i_mesh)->delete_all_external_storage();
       }
     }
   }

References oomph::Mesh::delete_all_external_storage(), mesh_pt(), and nsub_mesh().

◆ describe_dofs()

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

Function to describe the dofs in terms of the global equation number, i.e. what type of value (nodal value of a Node; value in a Data object; value of internal Data in an element; etc) is the unknown with a certain global equation number. Output stream defaults to oomph_info.

   {
     // Check that the global mesh has been build
 #ifdef PARANOID
     if (Mesh_pt == 0)
     {
       std::ostringstream error_stream;
       error_stream
         << "Global mesh does not exist, so equation numbers cannot be found.\n";
       // Check for sub meshes
       if (nsub_mesh() == 0)
       {
         error_stream << "There aren't even any sub-meshes in the Problem.\n"
                      << "You can set the global mesh directly by using\n"
                      << "Problem::mesh_pt() = my_mesh_pt;\n"
                      << "OR you can use Problem::add_sub_mesh(mesh_pt); "
                      << "to add a sub mesh.\n";
       }
       else
       {
         error_stream << "There are " << nsub_mesh() << " sub-meshes.\n";
       }
       error_stream << "You need to call Problem::build_global_mesh() to create "
                       "a global mesh\n"
                    << "from the sub-meshes.\n\n";
  
       throw OomphLibError(
         error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
 #endif
  
     out
       << "Although this program will describe the degrees of freedom in the \n"
       << "problem, it will do so using the typedef for the elements. This is \n"
       << "not neccesarily human readable, but there is a solution.\n"
       << "Pipe your program's output through c++filt, with the argument -t.\n"
       << "e.g. \"./two_d_multi_poisson | c++filt -t > ReadableOutput.txt\".\n "
       << "(Disregarding the quotes)\n\n\n";
  
     out << "Classifying Global Equation Numbers" << std::endl;
     out << std::string(80, '-') << std::endl;
  
     // Number of submeshes
     unsigned n_sub_mesh = Sub_mesh_pt.size();
  
     // Classify Global dofs
     unsigned Nglobal_data = nglobal_data();
     for (unsigned i = 0; i < Nglobal_data; i++)
     {
       std::stringstream conversion;
       conversion << " in Global Data " << i << ".";
       std::string in(conversion.str());
       Global_data_pt[i]->describe_dofs(out, in);
     }
  
     // Put string in limiting scope.
     {
       // Descend into assignment for mesh.
       std::string in(" in Problem's Only Mesh.");
       Mesh_pt->describe_dofs(out, in);
     }
  
     // Deal with the spine meshes additional numbering:
     // If there is only one mesh:
     if (n_sub_mesh == 0)
     {
       if (SpineMesh* const spine_mesh_pt = dynamic_cast<SpineMesh*>(Mesh_pt))
       {
         std::string in(" in Problem's Only SpineMesh.");
         spine_mesh_pt->describe_spine_dofs(out, in);
       }
     }
     // Otherwise loop over the sub meshes
     else
     {
       // Assign global equation numbers first
       for (unsigned i = 0; i < n_sub_mesh; i++)
       {
         if (SpineMesh* const spine_mesh_pt =
               dynamic_cast<SpineMesh*>(Sub_mesh_pt[i]))
         {
           std::stringstream conversion;
           conversion << " in Sub-SpineMesh " << i << ".";
           std::string in(conversion.str());
           spine_mesh_pt->describe_spine_dofs(out, in);
         } // end if.
       } // end for.
     } // end else.
  
  
     out << std::string(80, '\\') << std::endl;
     out << std::string(80, '\\') << std::endl;
     out << std::string(80, '\\') << std::endl;
     out << "Classifying global eqn numbers in terms of elements." << std::endl;
     out << std::string(80, '-') << std::endl;
     out << "Eqns   | Source" << std::endl;
     out << std::string(80, '-') << std::endl;
  
     if (n_sub_mesh == 0)
     {
       std::string in(" in Problem's Only Mesh.");
       Mesh_pt->describe_local_dofs(out, in);
     }
     else
     {
       for (unsigned i = 0; i < n_sub_mesh; i++)
       {
         std::stringstream conversion;
         conversion << " in Sub-Mesh " << i << ".";
         std::string in(conversion.str());
         Sub_mesh_pt[i]->describe_local_dofs(out, in);
       } // End for
     } // End else
   } // End problem::describe_dofs(...)

References oomph::Mesh::describe_dofs(), oomph::Mesh::describe_local_dofs(), Global_data_pt, i, Mesh_pt, nglobal_data(), nsub_mesh(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, out(), oomph::Global_string_for_annotation::string(), and Sub_mesh_pt.

◆ disable_discontinuous_formulation()

void oomph::Problem::disable_discontinuous_formulation ( )

inline

Disable the use of a discontinuous-element formulation. Note that the methods will all still work even if the elements are discontinuous, we will just be assembling a larger system matrix than necessary.

     {
       Discontinuous_element_formulation = false;
     }

References Discontinuous_element_formulation.

◆ disable_globally_convergent_newton_method()

void oomph::Problem::disable_globally_convergent_newton_method ( )

inline

disable globally convergent Newton method

     {
       Use_globally_convergent_newton_method = false;
     }

References Use_globally_convergent_newton_method.

◆ disable_info_in_newton_solve()

void oomph::Problem::disable_info_in_newton_solve ( )

inline

Disable the output of information when in the newton solver.

     {
       Shut_up_in_newton_solve = true;
     }

References Shut_up_in_newton_solve.

Referenced by PerturbedStateProblem< BASE_ELEMENT, PERTURBED_ELEMENT >::PerturbedStateProblem(), and oomph::ProjectionProblem< PROJECTABLE_ELEMENT >::project().

◆ disable_jacobian_reuse()

void oomph::Problem::disable_jacobian_reuse ( )

inline

Disable recycling of Jacobian in Newton iteration.

     {
       Jacobian_reuse_is_enabled = false;
       Jacobian_has_been_computed = false;
     }

References Jacobian_has_been_computed, and Jacobian_reuse_is_enabled.

◆ disable_mass_matrix_reuse()

void Problem::disable_mass_matrix_reuse ( )

Turn off recyling of the mass matrix in explicit timestepping schemes

Turn off the recyling of the mass matrix in explicit time-stepping schemes

   {
     Mass_matrix_reuse_is_enabled = false;
     Mass_matrix_has_been_computed = false;
  
     // If we have a discontinuous formulation set the element-level
     // function
     if (Discontinuous_element_formulation)
     {
       const unsigned n_element = Problem::mesh_pt()->nelement();
       // Loop over the other elements
       for (unsigned e = 0; e < n_element; e++)
       {
         // Cache the element
         DGElement* const elem_pt =
           dynamic_cast<DGElement*>(Problem::mesh_pt()->element_pt(e));
         elem_pt->disable_mass_matrix_reuse();
       }
     }
   }

References oomph::DGElement::disable_mass_matrix_reuse(), Discontinuous_element_formulation, e(), oomph::Mesh::element_pt(), Mass_matrix_has_been_computed, Mass_matrix_reuse_is_enabled, mesh_pt(), and oomph::Mesh::nelement().

◆ disable_store_local_dof_pt_in_elements()

void oomph::Problem::disable_store_local_dof_pt_in_elements ( )

inline

Insist that local dof pointers are NOT set up in each element when equation numbering takes place (the default)

     {
       Store_local_dof_pt_in_elements = false;
     }

References Store_local_dof_pt_in_elements.

◆ distributed()

bool oomph::Problem::distributed ( ) const

inline

If we have MPI return the "problem has been distributed" flag, otherwise it can't be distributed so return false.

     {
 #ifdef OOMPH_HAS_MPI
       return Problem_has_been_distributed;
 #else
       return false;
 #endif
     }

Referenced by calculate_predictions(), get_dofs(), oomph::NavierStokesSchurComplementPreconditioner::get_pressure_advection_diffusion_matrix(), oomph::PitchForkHandler::PitchForkHandler(), oomph::BlockPitchForkLinearSolver::resolve(), set_dofs(), and oomph::BlockPitchForkLinearSolver::solve().

◆ doc_errors() [1/2]

void oomph::Problem::doc_errors ( )

inline

Get max and min error for all elements in submeshes.

     {
       DocInfo tmp_doc_info;
       tmp_doc_info.disable_doc();
       doc_errors(tmp_doc_info);
     }

References oomph::DocInfo::disable_doc().

◆ doc_errors() [2/2]

void Problem::doc_errors ( DocInfo & doc_info )

Get max and min error for all elements in submeshes.

   {
     // Get the bifurcation type
     int bifurcation_type = this->Assembly_handler_pt->bifurcation_type();
     // If we are tracking a bifurcation then call the bifurcation adapt function
     if (bifurcation_type != 0)
     {
       this->bifurcation_adapt_doc_errors(bifurcation_type);
       // Return immediately
       return;
     }
  
     // Number of submeshes?
     unsigned Nmesh = nsub_mesh();
  
     // Single mesh:
     //------------
     if (Nmesh == 0)
     {
       // Is the single mesh refineable?
       if (RefineableMeshBase* mmesh_pt =
             dynamic_cast<RefineableMeshBase*>(mesh_pt(0)))
       {
         // Get pointer to error estimator
         ErrorEstimator* error_estimator_pt =
           mmesh_pt->spatial_error_estimator_pt();
  
 #ifdef PARANOID
         if (error_estimator_pt == 0)
         {
           throw OomphLibError("Error estimator hasn't been set yet",
                               OOMPH_CURRENT_FUNCTION,
                               OOMPH_EXCEPTION_LOCATION);
         }
 #endif
  
         // Get error for all elements
         Vector<double> elemental_error(mmesh_pt->nelement());
         if (!doc_info.is_doc_enabled())
         {
           error_estimator_pt->get_element_errors(mesh_pt(0), elemental_error);
         }
         else
         {
           error_estimator_pt->get_element_errors(
             mesh_pt(0), elemental_error, doc_info);
         }
  
         // Store max./min actual error
         mmesh_pt->max_error() = std::fabs(*std::max_element(
           elemental_error.begin(), elemental_error.end(), AbsCmp<double>()));
  
         mmesh_pt->min_error() = std::fabs(*std::min_element(
           elemental_error.begin(), elemental_error.end(), AbsCmp<double>()));
  
         oomph_info << "\n Max/min error: " << mmesh_pt->max_error() << " "
                    << mmesh_pt->min_error() << std::endl;
       }
     }
  
     // Multiple submeshes
     //------------------
     else
     {
       // Loop over submeshes
       for (unsigned imesh = 0; imesh < Nmesh; imesh++)
       {
         // Is the single mesh refineable?
         if (RefineableMeshBase* mmesh_pt =
               dynamic_cast<RefineableMeshBase*>(mesh_pt(imesh)))
         {
           // Get pointer to error estimator
           ErrorEstimator* error_estimator_pt =
             mmesh_pt->spatial_error_estimator_pt();
  
 #ifdef PARANOID
           if (error_estimator_pt == 0)
           {
             throw OomphLibError("Error estimator hasn't been set yet",
                                 OOMPH_CURRENT_FUNCTION,
                                 OOMPH_EXCEPTION_LOCATION);
           }
 #endif
  
           // Get error for all elements
           Vector<double> elemental_error(mmesh_pt->nelement());
           if (mmesh_pt->doc_info_pt() == 0)
           {
             error_estimator_pt->get_element_errors(mesh_pt(imesh),
                                                    elemental_error);
           }
           else
           {
             error_estimator_pt->get_element_errors(
               mesh_pt(imesh), elemental_error, *mmesh_pt->doc_info_pt());
           }
  
           // Store max./min error if the mesh has any elements
           if (mesh_pt(imesh)->nelement() > 0)
           {
             mmesh_pt->max_error() =
               std::fabs(*std::max_element(elemental_error.begin(),
                                           elemental_error.end(),
                                           AbsCmp<double>()));
  
             mmesh_pt->min_error() =
               std::fabs(*std::min_element(elemental_error.begin(),
                                           elemental_error.end(),
                                           AbsCmp<double>()));
           }
  
           oomph_info << "\n Max/min error: " << mmesh_pt->max_error() << " "
                      << mmesh_pt->min_error() << std::endl;
         }
  
       } // End of loop over submeshes
     }
   }

References Assembly_handler_pt, bifurcation_adapt_doc_errors(), oomph::AssemblyHandler::bifurcation_type(), MeshRefinement::error_estimator_pt, boost::multiprecision::fabs(), oomph::DocInfo::is_doc_enabled(), mesh_pt(), nsub_mesh(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and oomph::oomph_info.

◆ does_pointer_correspond_to_problem_data()

bool Problem::does_pointer_correspond_to_problem_data ( double *const & parameter_pt )

protected

Return a boolean flag to indicate whether the pointer parameter_pt refers to values stored in a Data object that is contained within the problem

Function that returns a boolean flag to indicate whether the pointer parameter_pt refers to memory that is a value in a Data object used within the problem

   {
     // Firstly check the global data
     const unsigned n_global = Global_data_pt.size();
     for (unsigned i = 0; i < n_global; ++i)
     {
       // If we find it then return true
       if (Global_data_pt[i]->does_pointer_correspond_to_value(parameter_pt))
       {
         return true;
       }
     }
  
     // If we find the pointer in the mesh data return true
     if (Mesh_pt->does_pointer_correspond_to_mesh_data(parameter_pt))
     {
       return true;
     }
  
     // Loop over the submeshes to handle the case of spine data
     const unsigned n_sub_mesh = this->nsub_mesh();
     // If there is only one mesh
     if (n_sub_mesh == 0)
     {
       if (SpineMesh* const spine_mesh_pt = dynamic_cast<SpineMesh*>(Mesh_pt))
       {
         if (spine_mesh_pt->does_pointer_correspond_to_spine_data(parameter_pt))
         {
           return true;
         }
       }
     }
     // Otherwise loop over the sub meshes
     else
     {
       // Assign global equation numbers first
       for (unsigned i = 0; i < n_sub_mesh; i++)
       {
         if (SpineMesh* const spine_mesh_pt =
               dynamic_cast<SpineMesh*>(Sub_mesh_pt[i]))
         {
           if (spine_mesh_pt->does_pointer_correspond_to_spine_data(
                 parameter_pt))
           {
             return true;
           }
         }
       }
     }
  
     // If we have got here then the data is not stored in the problem, so return
     // false
     return false;
   }

References oomph::Mesh::does_pointer_correspond_to_mesh_data(), Global_data_pt, i, Mesh_pt, nsub_mesh(), and Sub_mesh_pt.

Referenced by arc_length_step_solve().

◆ dof() [1/2]

double& oomph::Problem::dof ( const unsigned & i )

inline

i-th dof in the problem

     {
       return *(Dof_pt[i]);
     }

References Dof_pt, and i.

Referenced by oomph::IMRByBDF::actions_before_timestep(), adaptive_unsteady_newton_solve(), add_eigenvector_to_dofs(), assign_eigenvector_to_dofs(), bifurcation_adapt_helper(), calculate_predictions(), oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::get_dofs_for_element(), get_hessian_vector_products(), oomph::AugmentedBlockFoldLinearSolver::resolve(), oomph::AugmentedBlockPitchForkLinearSolver::resolve(), restore_dof_values(), oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::set_dofs_for_element(), oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::set_previous_dofs_to_current_dofs(), oomph::AugmentedBlockFoldLinearSolver::solve(), oomph::AugmentedBlockPitchForkLinearSolver::solve(), oomph::BlockHopfLinearSolver::solve(), oomph::BlockHopfLinearSolver::solve_for_two_rhs(), and store_current_dof_values().

◆ dof() [2/2]

double oomph::Problem::dof ( const unsigned & i ) const

inline

i-th dof in the problem (const version)

     {
       return *(Dof_pt[i]);
     }

References Dof_pt, and i.

◆ dof_current()

double& oomph::Problem::dof_current ( const unsigned & i )

inlineprotected

Access function to the current value of the i-th (local) dof at the start of a continuation step

     {
       if (!Use_continuation_timestepper)
       {
         return Dof_current[i];
       }
       else
       {
         return (*(Dof_pt[i] + Dof_current_offset));
       }
     }

References Dof_current, Dof_current_offset, Dof_pt, i, and Use_continuation_timestepper.

Referenced by adapt(), arc_length_step_solve_helper(), and newton_solve_continuation().

◆ dof_derivative()

double& oomph::Problem::dof_derivative ( const unsigned & i )

inlineprotected

Access function to the derivative of the i-th (local) dof with respect to the arc length, used in continuation

     {
       if (!Use_continuation_timestepper)
       {
         return Dof_derivative[i];
       }
       else
       {
         return (*(Dof_pt[i] + Dof_derivative_offset));
       }
     }

References Dof_derivative, Dof_derivative_offset, Dof_pt, i, and Use_continuation_timestepper.

Referenced by adapt(), arc_length_step_solve_helper(), calculate_continuation_derivatives_fd_helper(), calculate_continuation_derivatives_helper(), and newton_solve_continuation().

◆ dof_distribution_pt()

LinearAlgebraDistribution* const& oomph::Problem::dof_distribution_pt ( ) const

inline

Return the pointer to the dof distribution (read-only)

     {
       return Dof_distribution_pt;
     }

References Dof_distribution_pt.

Referenced by adaptive_unsteady_newton_solve(), oomph::ProblemBasedShiftInvertOperator::ProblemBasedShiftInvertOperator(), and oomph::ANASAZI::solve_eigenproblem().

◆ dof_pt() [1/2]

double*& oomph::Problem::dof_pt ( const unsigned & i )

inline

Pointer to i-th dof in the problem.

     {
       return Dof_pt[i];
     }

References Dof_pt, and i.

Referenced by oomph::AssemblyHandler::local_problem_dof(), and set_dofs().

◆ dof_pt() [2/2]

double* oomph::Problem::dof_pt ( const unsigned & i ) const

inline

Pointer to i-th dof in the problem (const version)

     {
       return Dof_pt[i];
     }

References Dof_pt, and i.

◆ doubly_adaptive_unsteady_newton_solve() [1/2]

double oomph::Problem::doubly_adaptive_unsteady_newton_solve	(	const double &	dt,
		const double &	epsilon,
		const unsigned &	max_adapt,
		const bool &	first,
		const bool &	shift = `true`
	)

inline

Unsteady "doubly" adaptive Newton solve: Does temporal adaptation first, i.e. we try to do a timestep with an increment of dt, and adjusting dt until the solution on the given mesh satisfies the temporal error measure with tolerance epsilon. Following this, we do up to max_adapt spatial adaptions (without re-examining the temporal error). If first==true, the initial conditions are re-assigned after the mesh adaptations. Shifting of time can be suppressed by overwriting the default value of shift (true). [Shifting must be done if first_timestep==true because we're constantly re-assigning the initial conditions; if first_timestep==true and shift==false shifting is performed anyway and a warning is issued.

     {
       // Call helper function with default setting (do re-solve after
       // spatial adaptation)
       unsigned suppress_resolve_after_spatial_adapt_flag = 0;
       return doubly_adaptive_unsteady_newton_solve_helper(
         dt,
         epsilon,
         max_adapt,
         suppress_resolve_after_spatial_adapt_flag,
         first,
         shift);
     }

References doubly_adaptive_unsteady_newton_solve_helper(), and oomph::SarahBL::epsilon.

◆ doubly_adaptive_unsteady_newton_solve() [2/2]

double oomph::Problem::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`
	)

inline

Unsteady "doubly" adaptive Newton solve: Does temporal adaptation first, i.e. we try to do a timestep with an increment of dt, and adjusting dt until the solution on the given mesh satisfies the temporal error measure with tolerance epsilon. Following this, we do up to max_adapt spatial adaptions (without re-examining the temporal error). If first==true, the initial conditions are re-assigned after the mesh adaptations. Shifting of time can be suppressed by overwriting the default value of shift (true). [Shifting must be done if first_timestep==true because we're constantly re-assigning the initial conditions; if first_timestep==true and shift==false shifting is performed anyway and a warning is issued. Pseudo-Boolean flag suppress_resolve_after_spatial_adapt [0: false; 1: true] does what it says.]

     {
       // Call helper function
       return doubly_adaptive_unsteady_newton_solve_helper(
         dt,
         epsilon,
         max_adapt,
         suppress_resolve_after_spatial_adapt_flag,
         first,
         shift);
     }

References doubly_adaptive_unsteady_newton_solve_helper(), and oomph::SarahBL::epsilon.

◆ doubly_adaptive_unsteady_newton_solve_helper()

double Problem::doubly_adaptive_unsteady_newton_solve_helper	(	const double &	dt_desired,
		const double &	epsilon,
		const unsigned &	max_adapt,
		const unsigned &	suppress_resolve_after_spatial_adapt_flag,
		const bool &	first,
		const bool &	shift_values = `true`
	)

private

Private helper function that actually performs the unsteady "doubly" adaptive Newton solve. See actual (non-helper) functions for description of parameters.

Private helper function to perform unsteady "doubly" adaptive Newton solve: Does temporal adaptation first, i.e. we try to do a timestep with an increment of dt, and adjusting dt until the solution on the given mesh satisfies the temporal error measure with tolerance epsilon. Following this, we do up to max_adapt spatial adaptions (without re-examining the temporal error). If first==true, the initial conditions are re-assigned after the mesh adaptations. Shifting of time can be suppressed by overwriting the default value of shift (true). [Shifting must be done if first_timestep==true because we're constantly re-assigning the initial conditions; if first_timestep==true and shift==false shifting is performed anyway and a warning is issued. Pseudo-Boolean flag suppress_resolve_after_spatial_adapt [0: false; 1: true] does what it says.]

   {
     // Store the initial time
     double initial_time = time_pt()->time();
  
     // Take adaptive timestep, adjusting dt until tolerance is satisfied
     double new_dt =
       adaptive_unsteady_newton_solve(dt_desired, epsilon, shift_values);
     double dt_taken = time_pt()->dt();
     oomph_info << "Accepted solution taken with timestep: " << dt_taken
                << std::endl;
  
  
     // Bail out straightaway if no spatial adaptation allowed
     if (max_adapt == 0)
     {
       oomph_info << "No spatial refinement allowed; max_adapt=0\n";
       return new_dt;
     }
  
     // Adapt problem/mesh
     unsigned n_refined = 0;
     unsigned n_unrefined = 0;
     adapt(n_refined, n_unrefined);
  
     // Check if mesh has been adapted on other processors
     Vector<int> total_ref_count(2);
     total_ref_count[0] = n_refined;
     total_ref_count[1] = n_unrefined;
  
  
 #ifdef OOMPH_HAS_MPI
     if (Problem_has_been_distributed)
     {
       // Sum n_refine across all processors
       Vector<int> ref_count(2);
       ref_count[0] = n_refined;
       ref_count[1] = n_unrefined;
       MPI_Allreduce(&ref_count[0],
                     &total_ref_count[0],
                     2,
                     MPI_INT,
                     MPI_SUM,
                     communicator_pt()->mpi_comm());
     }
 #endif
  
  
     // Re-solve the problem if the adaptation has changed anything
     if ((total_ref_count[0] != 0) || (total_ref_count[1] != 0))
     {
       if (suppress_resolve_after_spatial_adapt_flag == 1)
       {
         oomph_info << "Mesh was adapted but re-solve has been suppressed."
                    << std::endl;
       }
       else
       {
         oomph_info
           << "Mesh was adapted --> we'll re-solve for current timestep."
           << std::endl;
  
         // Reset time to what it was when we entered here
         // because it will be incremented again by dt_taken.
         time_pt()->time() = initial_time;
  
         // Shift the timesteps? No! They've been shifted already when we
         // called the solve with pure temporal adaptivity...
         bool shift = false;
  
         // Reset the inital condition on refined meshes
         if (first)
         {
           // Reset default set_initial_condition has been called flag to false
           Default_set_initial_condition_called = false;
  
           // Reset the initial conditions
           oomph_info << "Re-assigning initial condition at time="
                      << time_pt()->time() << std::endl;
           set_initial_condition();
  
           // This is the first timestep so shifting
           // has to be done following the assignment of initial conditions,
           // providing the default set_initial_condition function has not
           // been called.
           // In fact, unsteady_newton_solve(...) does that automatically.
           // We're changing the flag here to avoid warning messages.
           if (!Default_set_initial_condition_called)
           {
             shift = true;
           }
         }
  
         // Now take the step again on the refined mesh, using the same
         // timestep as used before.
         unsteady_newton_solve(dt_taken, max_adapt, first, shift);
       }
     }
     else
     {
       oomph_info << "Mesh wasn't adapted --> we'll accept spatial refinement."
                  << std::endl;
     }
  
     return new_dt;
   }

References adapt(), adaptive_unsteady_newton_solve(), communicator_pt(), Default_set_initial_condition_called, oomph::Time::dt(), oomph::SarahBL::epsilon, oomph::oomph_info, set_initial_condition(), oomph::Time::time(), time_pt(), and unsteady_newton_solve().

Referenced by doubly_adaptive_unsteady_newton_solve().

◆ dump() [1/2]

void oomph::Problem::dump ( const std::string & dump_file_name ) const

inline

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

     {
       std::ofstream dump_stream(dump_file_name.c_str());
 #ifdef PARANOID
       if (!dump_stream.is_open())
       {
         std::string err = "Couldn't open file " + dump_file_name;
         throw OomphLibError(
           err, OOMPH_EXCEPTION_LOCATION, OOMPH_CURRENT_FUNCTION);
       }
 #endif
       dump(dump_stream);
     }

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

◆ dump() [2/2]

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

virtual

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

Reimplemented in oomph::MyProblem, and AirwayReopeningProblem< ELEMENT >.

   {
     // Number of submeshes?
     unsigned n_mesh = nsub_mesh();
  
     dump_file << std::max(unsigned(1), n_mesh) << " # number of (sub)meshes "
               << std::endl;
  
     // Single mesh:
     //------------
     if (n_mesh == 0)
     {
       // Dump level of refinement before pruning
       if (TreeBasedRefineableMeshBase* mmesh_pt =
             dynamic_cast<TreeBasedRefineableMeshBase*>(mesh_pt(0)))
       {
         dump_file << mmesh_pt->uniform_refinement_level_when_pruned()
                   << " # uniform refinement when pruned " << std::endl;
       }
       else
       {
         dump_file << 0 << " # (fake) uniform refinement when pruned "
                   << std::endl;
       }
       dump_file << 9999 << " # test flag for end of sub-meshes " << std::endl;
     }
  
     // Multiple submeshes
     //------------------
     else
     {
       // Loop over submeshes to dump level of refinement before pruning
       for (unsigned imesh = 0; imesh < n_mesh; imesh++)
       {
         if (TreeBasedRefineableMeshBase* mmesh_pt =
               dynamic_cast<TreeBasedRefineableMeshBase*>(mesh_pt(imesh)))
         {
           dump_file << mmesh_pt->uniform_refinement_level_when_pruned()
                     << " # uniform refinement when pruned " << std::endl;
         }
         else
         {
           dump_file << 0 << " # (fake) uniform refinement when pruned "
                     << std::endl;
         }
       }
       dump_file << 9999 << " # test flag for end of sub-meshes " << std::endl;
     }
  
 #ifdef OOMPH_HAS_MPI
  
     const int my_rank = this->communicator_pt()->my_rank();
  
     // Record destination of all base elements
     unsigned n = Base_mesh_element_pt.size();
     Vector<int> local_base_element_processor(n, -1);
     Vector<int> base_element_processor(n, -1);
     for (unsigned e = 0; e < n; e++)
     {
       GeneralisedElement* el_pt = Base_mesh_element_pt[e];
       if (el_pt != 0)
       {
         if (!el_pt->is_halo())
         {
           local_base_element_processor[e] = my_rank;
         }
       }
     }
  
  
     // Get target for all base elements by reduction
     if (Problem_has_been_distributed)
     {
       // Check that the base elements have been associated to a processor
       // (the Base_mesh_elemen_pt is only used for structured meshes,
       // therefore, if there are no ustructured meshes as part of the
       // problem this container will be empty)
       if (n > 0)
       {
         MPI_Allreduce(&local_base_element_processor[0],
                       &base_element_processor[0],
                       n,
                       MPI_INT,
                       MPI_MAX,
                       this->communicator_pt()->mpi_comm());
       }
     }
     else
     {
       // All the same...
       base_element_processor = local_base_element_processor;
     }
  
  
     dump_file << n << " # Number of base elements; partitioning follows.\n";
     for (unsigned e = 0; e < n; e++)
     {
       dump_file << base_element_processor[e] << "\n";
     }
     dump_file << "8888 #test flag for end of base element distribution\n";
  
 #endif
  
     // Single mesh:
     //------------
     if (n_mesh == 0)
     {
       // Dump single mesh refinement pattern (if mesh is refineable)
       if (TreeBasedRefineableMeshBase* mmesh_pt =
             dynamic_cast<TreeBasedRefineableMeshBase*>(mesh_pt(0)))
       {
         mmesh_pt->dump_refinement(dump_file);
       }
 #ifdef OOMPH_HAS_TRIANGLE_LIB
       // Dump triangle mesh TriangulateIO which represents mesh topology
       TriangleMeshBase* mmesh_pt = dynamic_cast<TriangleMeshBase*>(mesh_pt(0));
       if (mmesh_pt != 0 && mmesh_pt->use_triangulateio_restart())
       {
 #ifdef OOMPH_HAS_MPI
         // Check if the mesh is distributed, if that is the case then
         // additional info. needs to be saved
         if (mmesh_pt->is_mesh_distributed())
         {
           // Dump the info. related with the distribution of the mesh
           mmesh_pt->dump_distributed_info_for_restart(dump_file);
         }
 #endif
         mmesh_pt->dump_triangulateio(dump_file);
       }
 #endif
     }
  
     // Multiple submeshes
     //------------------
     else
     {
       // Loop over submeshes
       for (unsigned imesh = 0; imesh < n_mesh; imesh++)
       {
         // Dump single mesh refinement pattern (if mesh is refineable)
         if (TreeBasedRefineableMeshBase* mmesh_pt =
               dynamic_cast<TreeBasedRefineableMeshBase*>(mesh_pt(imesh)))
         {
           mmesh_pt->dump_refinement(dump_file);
         }
 #ifdef OOMPH_HAS_TRIANGLE_LIB
         // Dump triangle mesh TriangulateIO which represents mesh topology
         TriangleMeshBase* mmesh_pt =
           dynamic_cast<TriangleMeshBase*>(mesh_pt(imesh));
         if (mmesh_pt != 0 && mmesh_pt->use_triangulateio_restart())
         {
 #ifdef OOMPH_HAS_MPI
           // Check if the mesh is distributed, if that is the case then
           // additional info. needs to be saved
           if (mmesh_pt->is_mesh_distributed())
           {
             // Dump the info. related with the distribution of the mesh
             mmesh_pt->dump_distributed_info_for_restart(dump_file);
           }
 #endif
           mmesh_pt->dump_triangulateio(dump_file);
         }
 #endif
       } // End of loop over submeshes
     }
  
  
     // Dump time
     // ---------
  
     // Flag to indicate unsteady run
     bool unsteady_flag = (time_pt() != 0);
     dump_file << unsteady_flag << " # bool flag for unsteady" << std::endl;
  
     // Current time and previous time increments for proper unsteady run
     if (unsteady_flag)
     {
       // Current time
       dump_file << time_pt()->time() << " # Time " << std::endl;
       // Timesteps
       unsigned n_dt = time_pt()->ndt();
       dump_file << n_dt << " # Number of timesteps " << std::endl;
       for (unsigned i = 0; i < n_dt; i++)
       {
         dump_file << time_pt()->dt(i) << " # dt " << std::endl;
       }
     }
     // Dummy time and previous time increments for steady run
     else
     {
       // Current time
       dump_file << "0.0 # Dummy time from steady run " << std::endl;
       // Timesteps
       dump_file << "0 # Dummy number of timesteps from steady run" << std::endl;
     }
  
     // Loop over submeshes and dump their data
     unsigned nmesh = nsub_mesh();
     if (nmesh == 0) nmesh = 1;
     for (unsigned m = 0; m < nmesh; m++)
     {
       mesh_pt(m)->dump(dump_file);
     }
  
     // Dump global data
  
     // Loop over global data
     unsigned Nglobal = Global_data_pt.size();
     dump_file << Nglobal << " # number of global Data items " << std::endl;
     for (unsigned iglobal = 0; iglobal < Nglobal; iglobal++)
     {
       Global_data_pt[iglobal]->dump(dump_file);
       dump_file << std::endl;
     }
   }

References communicator_pt(), oomph::Time::dt(), oomph::Mesh::dump(), e(), Global_data_pt, i, oomph::Mesh::is_mesh_distributed(), m, max, mesh_pt(), oomph::OomphCommunicator::my_rank(), n, oomph::Time::ndt(), nsub_mesh(), oomph::Time::time(), and time_pt().

Referenced by dump(), and oomph::MyProblem::dump().

◆ eigen_solver_pt() [1/2]

EigenSolver*& oomph::Problem::eigen_solver_pt ( )

inline

Return a pointer to the eigen solver object.

     {
       return Eigen_solver_pt;
     }

References Eigen_solver_pt.

Referenced by FlowAroundCylinderProblem< ELEMENT >::FlowAroundCylinderProblem(), and OrrSommerfeldProblem< ELEMENT >::OrrSommerfeldProblem().

◆ eigen_solver_pt() [2/2]

EigenSolver* const& oomph::Problem::eigen_solver_pt ( ) const

inline

Return a pointer to the eigen solver object (const version)

     {
       return Eigen_solver_pt;
     }

References Eigen_solver_pt.

◆ enable_discontinuous_formulation()

void oomph::Problem::enable_discontinuous_formulation ( )

inline

Indicate that the problem involves discontinuous elements This allows for a more efficiently assembly and inversion of the mass matrix

     {
       Discontinuous_element_formulation = true;
     }

References Discontinuous_element_formulation.

◆ enable_globally_convergent_newton_method()

void oomph::Problem::enable_globally_convergent_newton_method ( )

inline

enable globally convergent Newton method

     {
       Use_globally_convergent_newton_method = true;
     }

References Use_globally_convergent_newton_method.

◆ enable_info_in_newton_solve()

void oomph::Problem::enable_info_in_newton_solve ( )

inline

Enable the output of information when in the newton solver (Default)

     {
       Shut_up_in_newton_solve = false;
     }

References Shut_up_in_newton_solve.

◆ enable_jacobian_reuse()

void oomph::Problem::enable_jacobian_reuse ( )

inline

Enable recycling of Jacobian in Newton iteration (if the linear solver allows it). Useful for linear problems with constant Jacobians or nonlinear problems where you're willing to risk the trade-off between faster solve times and degraded Newton convergence rate

     {
       Jacobian_reuse_is_enabled = true;
       Jacobian_has_been_computed = false;
     }

References Jacobian_has_been_computed, and Jacobian_reuse_is_enabled.

◆ enable_mass_matrix_reuse()

void Problem::enable_mass_matrix_reuse ( )

Enable recycling of the mass matrix in explicit timestepping schemes. Useful for timestepping on fixed meshes when you want to avoid the linear solve phase.

   {
     Mass_matrix_reuse_is_enabled = true;
     Mass_matrix_has_been_computed = false;
  
     // If we have a discontinuous formulation set the elements to reuse
     // their own mass matrices
     if (Discontinuous_element_formulation)
     {
       const unsigned n_element = Problem::mesh_pt()->nelement();
       // Loop over the other elements
       for (unsigned e = 0; e < n_element; e++)
       {
         // Cache the element
         DGElement* const elem_pt =
           dynamic_cast<DGElement*>(Problem::mesh_pt()->element_pt(e));
         elem_pt->enable_mass_matrix_reuse();
       }
     }
   }

References Discontinuous_element_formulation, e(), oomph::Mesh::element_pt(), oomph::DGElement::enable_mass_matrix_reuse(), Mass_matrix_has_been_computed, Mass_matrix_reuse_is_enabled, mesh_pt(), and oomph::Mesh::nelement().

◆ enable_store_local_dof_pt_in_elements()

void oomph::Problem::enable_store_local_dof_pt_in_elements ( )

inline

Insist that local dof pointers are set up in each element when equation numbering takes place

     {
       Store_local_dof_pt_in_elements = true;
     }

References Store_local_dof_pt_in_elements.

◆ explicit_time_stepper_pt()

ExplicitTimeStepper*& oomph::Problem::explicit_time_stepper_pt ( )

inline

Return a pointer to the explicit timestepper.

     {
       return Explicit_time_stepper_pt;
     }

References Explicit_time_stepper_pt.

Referenced by calculate_predictions(), explicit_timestep(), and set_explicit_time_stepper_pt().

◆ explicit_timestep()

void Problem::explicit_timestep	(	const double &	dt,
		const bool &	shift_values = `true`
	)

Take an explicit timestep of size dt.

Take an explicit timestep of size dt and optionally shift any stored values of the time history

   {
 #ifdef PARANOID
     if (this->explicit_time_stepper_pt() == 0)
     {
       throw OomphLibError("Explicit time stepper pointer is null in problem.",
                           OOMPH_EXCEPTION_LOCATION,
                           OOMPH_CURRENT_FUNCTION);
     }
 #endif
  
     // Firstly we shift the time values
     if (shift_values)
     {
       shift_time_values();
     }
     // Set the current value of dt, if we can
     if (time_pt()->ndt() > 0)
     {
       time_pt()->dt() = dt;
     }
  
     // Take the explicit step
     this->explicit_time_stepper_pt()->timestep(this, dt);
   }

References oomph::Time::dt(), explicit_time_stepper_pt(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, shift_time_values(), time_pt(), and oomph::ExplicitTimeStepper::timestep().

Referenced by calculate_predictions().

◆ flush_global_data()

void oomph::Problem::flush_global_data ( )

inline

Flush the Problem's global data – resizes container to zero. Data objects are not deleted!

     {
       Global_data_pt.resize(0);
     }

References Global_data_pt.

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

◆ flush_sub_meshes()

void oomph::Problem::flush_sub_meshes ( )

inline

Flush the problem's collection of sub-meshes. Must be followed by call to rebuild_global_mesh().

     {
       Sub_mesh_pt.clear();
     }

References Sub_mesh_pt.

Referenced by oomph::NavierStokesSchurComplementPreconditioner::get_pressure_advection_diffusion_matrix(), oomph::SegregatableFSIProblem::rebuild_monolithic_mesh(), oomph::SegregatableFSIProblem::use_only_fluid_elements(), and oomph::SegregatableFSIProblem::use_only_solid_elements().

◆ get_all_error_estimates()

void Problem::get_all_error_estimates ( Vector< Vector< double >> & elemental_error )

Return the error estimates computed by (all) refineable (sub)mesh(es) in the elemental_error structure, which consists of a vector of vectors of elemental errors, one vector for each (sub)mesh.

Return the error estimates computed by (all) refineable (sub)mesh(es) in the elemental_error structure, which consists of a vector of elemental errors for each (sub)mesh.

   {
     // Number of submeshes?
     const unsigned Nmesh = nsub_mesh();
  
     // Single mesh:
     //------------
     if (Nmesh == 0)
     {
       // There is only one mesh
       elemental_error.resize(1);
       // Refine single mesh uniformly if possible
       if (RefineableMeshBase* mmesh_pt =
             dynamic_cast<RefineableMeshBase*>(Problem::mesh_pt(0)))
       {
         // If we can adapt the mesh
         if (mmesh_pt->is_adaptation_enabled())
         {
           // Get pointer to error estimator
           ErrorEstimator* error_estimator_pt =
             mmesh_pt->spatial_error_estimator_pt();
  
 #ifdef PARANOID
           if (error_estimator_pt == 0)
           {
             throw OomphLibError("Error estimator hasn't been set yet",
                                 OOMPH_CURRENT_FUNCTION,
                                 OOMPH_EXCEPTION_LOCATION);
           }
 #endif
  
           // Get error for all elements
           elemental_error[0].resize(mmesh_pt->nelement());
           // Are we documenting the errors or not
           if (mmesh_pt->doc_info_pt() == 0)
           {
             error_estimator_pt->get_element_errors(Problem::mesh_pt(0),
                                                    elemental_error[0]);
           }
           else
           {
             error_estimator_pt->get_element_errors(Problem::mesh_pt(0),
                                                    elemental_error[0],
                                                    *mmesh_pt->doc_info_pt());
           }
  
           // Store max./min actual error
           mmesh_pt->max_error() =
             std::fabs(*std::max_element(elemental_error[0].begin(),
                                         elemental_error[0].end(),
                                         AbsCmp<double>()));
  
           mmesh_pt->min_error() =
             std::fabs(*std::min_element(elemental_error[0].begin(),
                                         elemental_error[0].end(),
                                         AbsCmp<double>()));
  
           oomph_info << "\n Max/min error: " << mmesh_pt->max_error() << " "
                      << mmesh_pt->min_error() << std::endl;
         }
         else
         {
           oomph_info << "Info/Warning: Mesh adaptation is disabled."
                      << std::endl;
         }
       }
       else
       {
         oomph_info << "Info/Warning: Mesh cannot be adapted" << std::endl;
       }
     }
  
     // Multiple submeshes
     //------------------
     else
     {
       // Resize to the number of submeshes
       elemental_error.resize(Nmesh);
  
       // Loop over submeshes
       for (unsigned imesh = 0; imesh < Nmesh; imesh++)
       {
         // Refine single mesh uniformly if possible
         if (RefineableMeshBase* mmesh_pt =
               dynamic_cast<RefineableMeshBase*>(Problem::mesh_pt(imesh)))
         {
           // Get pointer to error estimator
           ErrorEstimator* error_estimator_pt =
             mmesh_pt->spatial_error_estimator_pt();
  
 #ifdef PARANOID
           if (error_estimator_pt == 0)
           {
             throw OomphLibError("Error estimator hasn't been set yet",
                                 OOMPH_CURRENT_FUNCTION,
                                 OOMPH_EXCEPTION_LOCATION);
           }
 #endif
           // If we can adapt the mesh
           if (mmesh_pt->is_adaptation_enabled())
           {
             // Get error for all elements
             elemental_error[imesh].resize(mmesh_pt->nelement());
             if (mmesh_pt->doc_info_pt() == 0)
             {
               error_estimator_pt->get_element_errors(Problem::mesh_pt(imesh),
                                                      elemental_error[imesh]);
             }
             else
             {
               error_estimator_pt->get_element_errors(Problem::mesh_pt(imesh),
                                                      elemental_error[imesh],
                                                      *mmesh_pt->doc_info_pt());
             }
  
             // Store max./min error
             mmesh_pt->max_error() =
               std::fabs(*std::max_element(elemental_error[imesh].begin(),
                                           elemental_error[imesh].end(),
                                           AbsCmp<double>()));
  
             mmesh_pt->min_error() =
               std::fabs(*std::min_element(elemental_error[imesh].begin(),
                                           elemental_error[imesh].end(),
                                           AbsCmp<double>()));
  
             oomph_info << "\n Max/min error: " << mmesh_pt->max_error() << " "
                        << mmesh_pt->min_error() << std::endl;
           }
           else
           {
             oomph_info << "Info/Warning: Mesh adaptation is disabled."
                        << std::endl;
           }
         }
         else
         {
           oomph_info << "Info/Warning: Mesh cannot be adapted." << std::endl;
         }
  
       } // End of loop over submeshes
     }
   }

References Eigen::placeholders::end, MeshRefinement::error_estimator_pt, boost::multiprecision::fabs(), mesh_pt(), nsub_mesh(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and oomph::oomph_info.

Referenced by adapt(), and bifurcation_adapt_helper().

◆ get_bifurcation_eigenfunction()

void Problem::get_bifurcation_eigenfunction ( Vector< DoubleVector > & eigenfunction )

Return the eigenfunction calculated as part of a bifurcation tracking process. If we are not tracking a bifurcation then an error will be thrown by the AssemblyHandler

   {
     // Simply call the appropriate assembly handler function
     Assembly_handler_pt->get_eigenfunction(eigenfunction);
   }

References Assembly_handler_pt, and oomph::AssemblyHandler::get_eigenfunction().

Referenced by bifurcation_adapt_helper().

◆ get_derivative_wrt_global_parameter()

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

Get the derivative of the entire residuals vector wrt a global parameter, used in continuation problems

Get derivative of the residuals vector wrt a global parameter This is required in continuation problems

   {
     // If we are doing the calculation analytically then call the appropriate
     // handler and then calling get_residuals
     if (is_dparameter_calculated_analytically(parameter_pt))
     {
       // Locally cache pointer to assembly handler
       AssemblyHandler* const old_assembly_handler_pt = Assembly_handler_pt;
       // Create a new assembly handler that replaces get_residuals by
       // get_dresiduals_dparameter for each element
       Assembly_handler_pt =
         new ParameterDerivativeHandler(old_assembly_handler_pt, parameter_pt);
       // Get the residuals, which will be dresiduals by dparameter
       this->get_residuals(result);
       // Delete the parameter derivative handler
       delete Assembly_handler_pt;
       // Reset the assembly handler to the original handler
       Assembly_handler_pt = old_assembly_handler_pt;
  
       /*AssemblyHandler* const assembly_handler_pt = Assembly_handler_pt;
       //Loop over all the elements
       unsigned long Element_pt_range = Mesh_pt->nelement();
       for(unsigned long e=0;e<Element_pt_range;e++)
        {
         //Get the pointer to the element
         GeneralisedElement* elem_pt = Mesh_pt->element_pt(e);
         //Find number of dofs in the element
         unsigned n_element_dofs = assembly_handler_pt->ndof(elem_pt);
         //Set up an array
         Vector<double> element_residuals(n_element_dofs);
         //Fill the array
         assembly_handler_pt->get_dresiduals_dparameter(elem_pt,parameter_pt,
                                                        element_residuals);
         //Now loop over the dofs and assign values to global Vector
         for(unsigned l=0;l<n_element_dofs;l++)
          {
           result[assembly_handler_pt->eqn_number(elem_pt,l)]
            += element_residuals[l];
           }
           }*/
  
       // for(unsigned n=0;n<n_dof;n++)
       // {std::cout << "BLA " << n << " " <<  result[n] << "\n";}
     }
     // Otherwise use the finite difference default
     else
     {
       // Get the (global) residuals and store in the result vector
       get_residuals(result);
  
       // Storage for the new residuals
       DoubleVector newres;
  
       // Increase the global parameter
       const double FD_step = 1.0e-8;
  
       // Store the current value of the parameter
       double param_value = *parameter_pt;
  
       // Increase the parameter
       *parameter_pt += FD_step;
  
       // Do any possible updates
       actions_after_change_in_global_parameter(parameter_pt);
  
       // Get the new residuals
       get_residuals(newres);
  
       // Find the number of local rows
       //(I think it's a global vector, so that should be fine)
       const unsigned ndof_local = result.nrow_local();
  
       // Do the finite differencing in the local variables
       for (unsigned n = 0; n < ndof_local; ++n)
       {
         result[n] = (newres[n] - result[n]) / FD_step;
       }
  
       // Reset the value of the parameter
       *parameter_pt = param_value;
  
       // Do any possible updates
       actions_after_change_in_global_parameter(parameter_pt);
     }
   }

References actions_after_change_in_global_parameter(), Assembly_handler_pt, oomph::BlackBoxFDNewtonSolver::FD_step, get_residuals(), is_dparameter_calculated_analytically(), n, and oomph::DistributableLinearAlgebraObject::nrow_local().

Referenced by calculate_continuation_derivatives(), oomph::FoldHandler::FoldHandler(), oomph::HopfHandler::HopfHandler(), newton_solve_continuation(), and oomph::BlockPitchForkLinearSolver::solve().

◆ get_dofs() [1/2]

void Problem::get_dofs	(	const unsigned &	t,
		DoubleVector &	dofs
	)		const

virtual

Return vector of the t'th history value of all dofs.

Get history values of dofs in a double vector.

Reimplemented from oomph::ExplicitTimeSteppableObject.

   {
 #ifdef PARANOID
     if (distributed())
     {
       throw OomphLibError("Not designed for distributed problems",
                           OOMPH_EXCEPTION_LOCATION,
                           OOMPH_CURRENT_FUNCTION);
       // might work, not sure
     }
 #endif
  
     // Resize the vector
     dofs.build(Dof_distribution_pt, 0.0);
  
     // First deal with global data
     unsigned Nglobal_data = nglobal_data();
     for (unsigned i = 0; i < Nglobal_data; i++)
     {
       for (unsigned j = 0, nj = Global_data_pt[i]->nvalue(); j < nj; j++)
       {
         // For each data get the equation number and copy out the value.
         int eqn_number = Global_data_pt[i]->eqn_number(j);
         if (eqn_number >= 0)
         {
           dofs[eqn_number] = Global_data_pt[i]->value(t, j);
         }
       }
     }
  
     // Next element internal data
     for (unsigned i = 0, ni = mesh_pt()->nelement(); i < ni; i++)
     {
       GeneralisedElement* ele_pt = mesh_pt()->element_pt(i);
       for (unsigned j = 0, nj = ele_pt->ninternal_data(); j < nj; j++)
       {
         Data* d_pt = ele_pt->internal_data_pt(j);
         for (unsigned k = 0, nk = d_pt->nvalue(); k < nk; k++)
         {
           int eqn_number = d_pt->eqn_number(k);
           if (eqn_number >= 0)
           {
             dofs[eqn_number] = d_pt->value(t, k);
           }
         }
       }
     }
  
     // Now the nodes
     for (unsigned i = 0, ni = mesh_pt()->nnode(); i < ni; i++)
     {
       Node* node_pt = mesh_pt()->node_pt(i);
       for (unsigned j = 0, nj = node_pt->nvalue(); j < nj; j++)
       {
         // For each node get the equation number and copy out the value.
         int eqn_number = node_pt->eqn_number(j);
         if (eqn_number >= 0)
         {
           dofs[eqn_number] = node_pt->value(t, j);
         }
       }
     }
   }

References oomph::DoubleVector::build(), distributed(), Dof_distribution_pt, oomph::Mesh::element_pt(), oomph::Data::eqn_number(), Global_data_pt, i, oomph::GeneralisedElement::internal_data_pt(), j, k, mesh_pt(), nglobal_data(), oomph::GeneralisedElement::ninternal_data(), oomph::Mesh::node_pt(), oomph::Data::nvalue(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, plotPSD::t, oomph::Data::value(), and oomph::Node::value().

◆ get_dofs() [2/2]

void Problem::get_dofs ( DoubleVector & dofs ) const

virtual

Return the vector of dofs, i.e. a vector containing the current values of all unknowns.

Get the vector of dofs, i.e. a vector containing the current values of all unknowns.

Reimplemented from oomph::ExplicitTimeSteppableObject.

   {
     // Find number of dofs
     const unsigned long n_dof = ndof();
  
     // Resize the vector
     dofs.build(Dof_distribution_pt, 0.0);
  
     // Copy dofs into vector
     for (unsigned long l = 0; l < n_dof; l++)
     {
       dofs[l] = *Dof_pt[l];
     }
   }

References oomph::DoubleVector::build(), Dof_distribution_pt, Dof_pt, and ndof().

Referenced by oomph::IMRByBDF::actions_after_timestep(), oomph::IMRByBDF::actions_before_timestep(), and calculate_predictions().

◆ get_dvaluesdt()

void Problem::get_dvaluesdt ( DoubleVector & f )

virtual

Get the time derivative of all values (using get_inverse_mass_matrix_times_residuals(..) with all time steppers set to steady) e.g. for use in explicit time steps. The approach used is slighty hacky, beware if you have a residual which is non-linear or implicit in the derivative or if you have overloaded get_jacobian(...).

Reimplemented from oomph::ExplicitTimeSteppableObject.

   {
     // Loop over timesteppers: make them (temporarily) steady and store their
     // is_steady status.
     unsigned n_time_steppers = this->ntime_stepper();
     std::vector<bool> was_steady(n_time_steppers);
     for (unsigned i = 0; i < n_time_steppers; i++)
     {
       was_steady[i] = time_stepper_pt(i)->is_steady();
       time_stepper_pt(i)->make_steady();
     }
  
     // Calculate f using the residual/jacobian machinary.
     get_inverse_mass_matrix_times_residuals(f);
  
     // Reset the is_steady status of all timesteppers that weren't already
     // steady when we came in here and reset their weights
     for (unsigned i = 0; i < n_time_steppers; i++)
     {
       if (!was_steady[i])
       {
         time_stepper_pt(i)->undo_make_steady();
       }
     }
   }

References f(), get_inverse_mass_matrix_times_residuals(), i, oomph::TimeStepper::is_steady(), oomph::TimeStepper::make_steady(), ntime_stepper(), time_stepper_pt(), and oomph::TimeStepper::undo_make_steady().

Referenced by oomph::TR::setup_initial_derivative().

◆ get_eigenproblem_matrices()

void Problem::get_eigenproblem_matrices	(	CRDoubleMatrix &	mass_matrix,
		CRDoubleMatrix &	main_matrix,
		const double &	shift = `0.0`
	)

virtual

Get the matrices required by a eigensolver. If the shift parameter is non-zero the second matrix will be shifted

Get the matrices required to solve an eigenproblem WARNING: temporarily this method only works with non-distributed matrices

   {
     // Three different cases again here:
     // 1) Compiled with MPI, but run in serial
     // 2) Compiled with MPI, but MPI not initialised in driver
     // 3) Serial version
  
  
 #ifdef PARANOID
     if (mass_matrix.distribution_built() && main_matrix.distribution_built())
     {
       // Check that the distribution of the mass matrix and jacobian match
       if (!(*mass_matrix.distribution_pt() == *main_matrix.distribution_pt()))
       {
         std::ostringstream error_stream;
         error_stream
           << "The distributions of the jacobian and mass matrix are\n"
           << "not the same and they must be.\n";
         throw OomphLibError(
           error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
       }
  
       if (mass_matrix.nrow() != this->ndof())
       {
         std::ostringstream error_stream;
         error_stream
           << "mass_matrix has a distribution, but the number of rows is not "
           << "equal to the number of degrees of freedom in the problem.";
         throw OomphLibError(
           error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
       }
  
       if (main_matrix.nrow() != this->ndof())
       {
         std::ostringstream error_stream;
         error_stream
           << "main_matrix has a distribution, but the number of rows is not "
           << "equal to the number of degrees of freedom in the problem.";
         throw OomphLibError(
           error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
       }
     }
     // If the distributions are not the same, then complain
     else if (main_matrix.distribution_built() !=
              mass_matrix.distribution_built())
     {
       std::ostringstream error_stream;
       error_stream << "The distribution of the jacobian and mass matrix must "
                    << "both be setup or both not setup";
       throw OomphLibError(
         error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
 #endif
  
     // Store the old assembly handler
     AssemblyHandler* old_assembly_handler_pt = Assembly_handler_pt;
     // Now setup the eigenproblem handler, pass in the value of the shift
     Assembly_handler_pt = new EigenProblemHandler(shift);
  
     // Prepare the storage formats.
     Vector<int*> column_or_row_index(2);
     Vector<int*> row_or_column_start(2);
     Vector<double*> value(2);
     Vector<unsigned> nnz(2);
     // Allocate pointer to residuals, although not used in these problems
     Vector<double*> residuals_vectors(0);
  
     // total number of rows in each matrix
     unsigned nrow = this->ndof();
  
     // determine the distribution for the jacobian (main matrix)
     // IF the jacobian has distribution setup then use that
     // ELSE determine the distribution based on the
     // distributed_matrix_distribution enum
     LinearAlgebraDistribution* dist_pt = 0;
     if (main_matrix.distribution_built())
     {
       dist_pt = new LinearAlgebraDistribution(main_matrix.distribution_pt());
     }
     else
     {
 #ifdef OOMPH_HAS_MPI
       // if problem is only one one processor
       if (Communicator_pt->nproc() == 1)
       {
         dist_pt = new LinearAlgebraDistribution(Communicator_pt, nrow, false);
       }
       // if the problem is not distributed then assemble the matrices with
       // a uniform distributed distribution
       else if (!Problem_has_been_distributed)
       {
         dist_pt = new LinearAlgebraDistribution(Communicator_pt, nrow, true);
       }
       // otherwise the problem is a distributed problem
       else
       {
         switch (Dist_problem_matrix_distribution)
         {
           case Uniform_matrix_distribution:
             dist_pt =
               new LinearAlgebraDistribution(Communicator_pt, nrow, true);
             break;
           case Problem_matrix_distribution:
             dist_pt = new LinearAlgebraDistribution(Dof_distribution_pt);
             break;
           case Default_matrix_distribution:
             LinearAlgebraDistribution* uniform_dist_pt =
               new LinearAlgebraDistribution(Communicator_pt, nrow, true);
             bool use_problem_dist = true;
             unsigned nproc = Communicator_pt->nproc();
             for (unsigned p = 0; p < nproc; p++)
             {
               if ((double)Dof_distribution_pt->nrow_local(p) >
                   ((double)uniform_dist_pt->nrow_local(p)) * 1.1)
               {
                 use_problem_dist = false;
               }
             }
             if (use_problem_dist)
             {
               dist_pt = new LinearAlgebraDistribution(Dof_distribution_pt);
             }
             else
             {
               dist_pt = new LinearAlgebraDistribution(uniform_dist_pt);
             }
             delete uniform_dist_pt;
             break;
         }
       }
 #else
       dist_pt = new LinearAlgebraDistribution(Communicator_pt, nrow, false);
 #endif
     }
  
  
     // The matrix is in compressed row format
     bool compressed_row_flag = true;
  
 #ifdef OOMPH_HAS_MPI
     //
     if (Communicator_pt->nproc() == 1)
     {
 #endif
  
       sparse_assemble_row_or_column_compressed(column_or_row_index,
                                                row_or_column_start,
                                                value,
                                                nnz,
                                                residuals_vectors,
                                                compressed_row_flag);
  
       // The main matrix is the first entry
       main_matrix.build(dist_pt);
       main_matrix.build_without_copy(dist_pt->nrow(),
                                      nnz[0],
                                      value[0],
                                      column_or_row_index[0],
                                      row_or_column_start[0]);
       // The mass matrix is the second entry
       mass_matrix.build(dist_pt);
       mass_matrix.build_without_copy(dist_pt->nrow(),
                                      nnz[1],
                                      value[1],
                                      column_or_row_index[1],
                                      row_or_column_start[1]);
 #ifdef OOMPH_HAS_MPI
     }
     else
     {
       if (dist_pt->distributed())
       {
         parallel_sparse_assemble(dist_pt,
                                  column_or_row_index,
                                  row_or_column_start,
                                  value,
                                  nnz,
                                  residuals_vectors);
         // The main matrix is the first entry
         main_matrix.build(dist_pt);
         main_matrix.build_without_copy(dist_pt->nrow(),
                                        nnz[0],
                                        value[0],
                                        column_or_row_index[0],
                                        row_or_column_start[0]);
         // The mass matrix is the second entry
         mass_matrix.build(dist_pt);
         mass_matrix.build_without_copy(dist_pt->nrow(),
                                        nnz[1],
                                        value[1],
                                        column_or_row_index[1],
                                        row_or_column_start[1]);
       }
       else
       {
         LinearAlgebraDistribution* temp_dist_pt =
           new LinearAlgebraDistribution(Communicator_pt, dist_pt->nrow(), true);
         parallel_sparse_assemble(temp_dist_pt,
                                  column_or_row_index,
                                  row_or_column_start,
                                  value,
                                  nnz,
                                  residuals_vectors);
         // The main matrix is the first entry
         main_matrix.build(temp_dist_pt);
         main_matrix.build_without_copy(dist_pt->nrow(),
                                        nnz[0],
                                        value[0],
                                        column_or_row_index[0],
                                        row_or_column_start[0]);
         main_matrix.redistribute(dist_pt);
         // The mass matrix is the second entry
         mass_matrix.build(temp_dist_pt);
         mass_matrix.build_without_copy(dist_pt->nrow(),
                                        nnz[1],
                                        value[1],
                                        column_or_row_index[1],
                                        row_or_column_start[1]);
         mass_matrix.redistribute(dist_pt);
         delete temp_dist_pt;
       }
     }
 #endif
  
     // clean up dist_pt and residuals_vector pt
     delete dist_pt;
  
     // Delete the eigenproblem handler
     delete Assembly_handler_pt;
     // Reset the assembly handler to the original handler
     Assembly_handler_pt = old_assembly_handler_pt;
   }

References Assembly_handler_pt, oomph::CRDoubleMatrix::build(), oomph::CRDoubleMatrix::build_without_copy(), Communicator_pt, oomph::LinearAlgebraDistribution::distributed(), oomph::DistributableLinearAlgebraObject::distribution_built(), oomph::DistributableLinearAlgebraObject::distribution_pt(), Dof_distribution_pt, ndof(), oomph::OomphCommunicator::nproc(), oomph::LinearAlgebraDistribution::nrow(), oomph::CRDoubleMatrix::nrow(), oomph::LinearAlgebraDistribution::nrow_local(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, p, oomph::CRDoubleMatrix::redistribute(), sparse_assemble_row_or_column_compressed(), and Eigen::value.

Referenced by oomph::ProblemBasedShiftInvertOperator::ProblemBasedShiftInvertOperator(), oomph::ARPACK::solve_eigenproblem(), and oomph::LAPACK_QZ::solve_eigenproblem().

◆ get_fd_jacobian()

void Problem::get_fd_jacobian	(	DoubleVector &	residuals,
		DenseMatrix< double > &	jacobian
	)

Get the full Jacobian by finite differencing.

Return the fully-assembled Jacobian and residuals, generated by finite differences

   {
 #ifdef OOMPH_HAS_MPI
  
     if (Problem_has_been_distributed)
     {
       OomphLibWarning("This is unlikely to work with a distributed problem",
                       " Problem::get_fd_jacobian()",
                       OOMPH_EXCEPTION_LOCATION);
     }
 #endif
  
  
     // Find number of dofs
     const unsigned long n_dof = ndof();
  
     // Advanced residuals
     DoubleVector residuals_pls;
  
     // Get reference residuals
     get_residuals(residuals);
  
     const double FD_step = 1.0e-8;
  
     // Make sure the Jacobian is the right size (since we don't care about
     // speed).
     jacobian.resize(n_dof, n_dof);
  
     // Loop over all dofs
     for (unsigned long jdof = 0; jdof < n_dof; jdof++)
     {
       double backup = *Dof_pt[jdof];
       *Dof_pt[jdof] += FD_step;
  
       // We're checking if the new values for Dof_pt[] actually
       // solve the entire problem --> update as if problem had
       // been solved
       actions_before_newton_solve();
       actions_before_newton_convergence_check();
       actions_after_newton_solve();
  
       // Get advanced residuals
       get_residuals(residuals_pls);
  
       for (unsigned long ieqn = 0; ieqn < n_dof; ieqn++)
       {
         jacobian(ieqn, jdof) =
           (residuals_pls[ieqn] - residuals[ieqn]) / FD_step;
       }
  
       *Dof_pt[jdof] = backup;
     }
  
     // Reset problem to state it was in
     actions_before_newton_solve();
     actions_before_newton_convergence_check();
     actions_after_newton_solve();
   }

References actions_after_newton_solve(), actions_before_newton_convergence_check(), actions_before_newton_solve(), Dof_pt, oomph::BlackBoxFDNewtonSolver::FD_step, get_residuals(), ndof(), OOMPH_EXCEPTION_LOCATION, and oomph::DenseMatrix< T >::resize().

Referenced by oomph::FD_LU::solve().

◆ get_hessian_vector_products()

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

Return the product of the global hessian (derivative of Jacobian matrix with respect to all variables) with an eigenvector, Y, and any number of other specified vectors C (d(J_{ij})/d u_{k}) Y_{j} C_{k}. This function is used in assembling and solving the augmented systems associated with bifurcation tracking. The default implementation is to use finite differences at the global level.

Alice: My bifurcation tracking converges better with this FD_step as 1.0e-5. The default value remains at 1.0e-8.

   {
     // How many vector products must we construct
     const unsigned n_vec = C.size();
  
     // currently only global (non-distributed) distributions are allowed
     // LinearAlgebraDistribution* dist_pt = new
     // LinearAlgebraDistribution(Communicator_pt,n_dof,false);
  
     // Cache the assembly hander
     AssemblyHandler* const assembly_handler_pt = Assembly_handler_pt;
  
     // Rebuild the results vectors and initialise to zero
     // use the same distribution of the vector Y
     for (unsigned i = 0; i < n_vec; i++)
     {
       product[i].build(Y.distribution_pt(), 0.0);
       product[i].initialise(0.0);
     }
  
 // Setup the halo schemes for the result
 #ifdef OOMPH_HAS_MPI
     if (Problem_has_been_distributed)
     {
       for (unsigned i = 0; i < n_vec; i++)
       {
         product[i].build_halo_scheme(this->Halo_scheme_pt);
       }
     }
 #endif
  
     // If we are doing the calculation analytically then call the appropriate
     // handler
     // A better way to do this is probably to hook into the get_residuals
     // framework but with a different member function of the assembly
     // handler
     if (this->are_hessian_products_calculated_analytically())
     {
       // Loop over all the elements
       unsigned long Element_pt_range = Mesh_pt->nelement();
       for (unsigned long e = 0; e < Element_pt_range; e++)
       {
         // Get the pointer to the element
         GeneralisedElement* elem_pt = Mesh_pt->element_pt(e);
 // Do not loop over halo elements
 #ifdef OOMPH_HAS_MPI
         if (!elem_pt->is_halo())
         {
 #endif
           // Find number of dofs in the element
           unsigned n_var = assembly_handler_pt->ndof(elem_pt);
           // Set up a matrix for the input and output
           Vector<double> Y_local(n_var);
           DenseMatrix<double> C_local(n_vec, n_var);
           DenseMatrix<double> product_local(n_vec, n_var);
  
           // Translate the global input vectors into the local storage
           // Probably horribly inefficient, but otherwise things get really
           // messy at the elemental level
           for (unsigned l = 0; l < n_var; l++)
           {
             // Cache the global equation number
             const unsigned long eqn_number =
               assembly_handler_pt->eqn_number(elem_pt, l);
  
             Y_local[l] = Y.global_value(eqn_number);
             for (unsigned i = 0; i < n_vec; i++)
             {
               C_local(i, l) = C[i].global_value(eqn_number);
             }
           }
  
           // Fill the array
           assembly_handler_pt->get_hessian_vector_products(
             elem_pt, Y_local, C_local, product_local);
  
           // Assign the local results to the global vector
           for (unsigned l = 0; l < n_var; l++)
           {
             const unsigned long eqn_number =
               assembly_handler_pt->eqn_number(elem_pt, l);
  
             for (unsigned i = 0; i < n_vec; i++)
             {
               product[i].global_value(eqn_number) += product_local(i, l);
               // std::cout << "BLA " << e << " " << i << " "
               //          << l << " " << product_local(i,l) << "\n";
             }
           }
 #ifdef OOMPH_HAS_MPI
         }
 #endif
       }
     }
     // Otherwise calculate using finite differences by
     // perturbing the jacobian along a particular direction
     else
     {
       // Cache the finite difference step
       const double FD_step = FD_step_used_in_get_hessian_vector_products;
  
       // We can now construct our multipliers
       const unsigned n_dof_local = this->Dof_distribution_pt->nrow_local();
       // Prepare to scale
       double dof_length = 0.0;
       Vector<double> C_length(n_vec, 0.0);
  
       for (unsigned n = 0; n < n_dof_local; n++)
       {
         if (std::fabs(this->dof(n)) > dof_length)
         {
           dof_length = std::fabs(this->dof(n));
         }
       }
  
       // C is assumed to have the same distribution as the dofs
       for (unsigned i = 0; i < n_vec; i++)
       {
         for (unsigned n = 0; n < n_dof_local; n++)
         {
           if (std::fabs(C[i][n]) > C_length[i])
           {
             C_length[i] = std::fabs(C[i][n]);
           }
         }
       }
  
       // Now broadcast the information, if distributed
 #ifdef OOMPH_HAS_MPI
       if (Problem_has_been_distributed)
       {
         const unsigned n_length = n_vec + 1;
         double all_length[n_length];
         all_length[0] = dof_length;
         for (unsigned i = 0; i < n_vec; i++)
         {
           all_length[i + 1] = C_length[i];
         }
  
         // Do the MPI call
         double all_length_reduce[n_length];
         MPI_Allreduce(all_length,
                       all_length_reduce,
                       n_length,
                       MPI_DOUBLE,
                       MPI_MAX,
                       this->communicator_pt()->mpi_comm());
  
         // Read out the information
         dof_length = all_length_reduce[0];
         for (unsigned i = 0; i < n_vec; i++)
         {
           C_length[i] = all_length_reduce[i + 1];
         }
       }
 #endif
  
       // Form the multipliers
       Vector<double> C_mult(n_vec, 0.0);
       for (unsigned i = 0; i < n_vec; i++)
       {
         C_mult[i] = dof_length / C_length[i];
         C_mult[i] += FD_step;
         C_mult[i] *= FD_step;
       }
  
  
       // Dummy vector to stand in the place of the residuals
       Vector<double> dummy_res;
  
       // Calculate the product of the jacobian matrices, etc by looping over the
       // elements
       const unsigned long n_element = this->mesh_pt()->nelement();
       for (unsigned long e = 0; e < n_element; e++)
       {
         GeneralisedElement* elem_pt = this->mesh_pt()->element_pt(e);
         // Ignore halo's of course
 #ifdef OOMPH_HAS_MPI
         if (!elem_pt->is_halo())
         {
 #endif
           // Loop over the ndofs in each element
           unsigned n_var = assembly_handler_pt->ndof(elem_pt);
           // Resize the dummy residuals vector
           dummy_res.resize(n_var);
           // Allocate storage for the unperturbed jacobian matrix
           DenseMatrix<double> jac(n_var);
           // Get unperturbed jacobian
           assembly_handler_pt->get_jacobian(elem_pt, dummy_res, jac);
  
           // Backup the dofs
           Vector<double> dof_bac(n_var);
           for (unsigned n = 0; n < n_var; n++)
           {
             unsigned eqn_number = assembly_handler_pt->eqn_number(elem_pt, n);
             dof_bac[n] = *this->global_dof_pt(eqn_number);
           }
  
           // Now loop over all vectors C
           for (unsigned i = 0; i < n_vec; i++)
           {
             // Perturb the dofs by the appropriate vector
             for (unsigned n = 0; n < n_var; n++)
             {
               unsigned eqn_number = assembly_handler_pt->eqn_number(elem_pt, n);
               // Perturb by vector C[i]
               *this->global_dof_pt(eqn_number) +=
                 C_mult[i] * C[i].global_value(eqn_number);
             }
             actions_before_newton_convergence_check();
  
             // Allocate storage for the perturbed jacobian
             DenseMatrix<double> jac_C(n_var);
  
             // Now get the new jacobian
             assembly_handler_pt->get_jacobian(elem_pt, dummy_res, jac_C);
  
             // Reset the dofs
             for (unsigned n = 0; n < n_var; n++)
             {
               unsigned eqn_number = assembly_handler_pt->eqn_number(elem_pt, n);
               *this->global_dof_pt(eqn_number) = dof_bac[n];
             }
             actions_before_newton_convergence_check();
  
             // Now work out the products
             for (unsigned n = 0; n < n_var; n++)
             {
               unsigned eqn_number = assembly_handler_pt->eqn_number(elem_pt, n);
               double prod_c = 0.0;
               for (unsigned m = 0; m < n_var; m++)
               {
                 unsigned unknown = assembly_handler_pt->eqn_number(elem_pt, m);
                 prod_c += (jac_C(n, m) - jac(n, m)) * Y.global_value(unknown);
               }
               // std::cout << "FD   " << e << " " << i << " "
               //          << n << " " << prod_c/C_mult[i] << "\n";
               product[i].global_value(eqn_number) += prod_c / C_mult[i];
             }
           }
 #ifdef OOMPH_HAS_MPI
         }
 #endif
       } // End of loop over elements
     }
  
     // If we have a distributed problem then gather all
     // values
 #ifdef OOMPH_HAS_MPI
     if (Problem_has_been_distributed)
     {
       // Sum all values if distributed
       for (unsigned i = 0; i < n_vec; i++)
       {
         product[i].sum_all_halo_and_haloed_values();
       }
     }
 #endif
   }

References actions_before_newton_convergence_check(), are_hessian_products_calculated_analytically(), Assembly_handler_pt, assembly_handler_pt(), communicator_pt(), dof(), Dof_distribution_pt, e(), oomph::Mesh::element_pt(), oomph::AssemblyHandler::eqn_number(), boost::multiprecision::fabs(), oomph::BlackBoxFDNewtonSolver::FD_step, FD_step_used_in_get_hessian_vector_products, oomph::AssemblyHandler::get_hessian_vector_products(), oomph::AssemblyHandler::get_jacobian(), global_dof_pt(), i, m, Mesh_pt, mesh_pt(), n, oomph::AssemblyHandler::ndof(), oomph::Mesh::nelement(), oomph::LinearAlgebraDistribution::nrow_local(), product(), and Y.

Referenced by oomph::BlockPitchForkLinearSolver::resolve(), and oomph::BlockPitchForkLinearSolver::solve().

◆ get_inverse_mass_matrix_times_residuals()

void Problem::get_inverse_mass_matrix_times_residuals ( DoubleVector & Mres )

virtual

Return the residual vector multiplied by the inverse mass matrix Virtual so that it can be overloaded for mpi problems

   {
     // This function does not make sense for assembly handlers other than the
     // default, so complain if we try to call it with another handler
  
 #ifdef PARANOID
     // If we are not the default, then complain
     if (this->assembly_handler_pt() != Default_assembly_handler_pt)
     {
       std::ostringstream error_stream;
       error_stream << "The function get_inverse_mass_matrix_times_residuals() "
                       "can only be\n"
                    << "used with the default assembly handler\n\n";
       throw OomphLibError(
         error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
 #endif
  
     // Find the number of degrees of freedom in the problem
     const unsigned n_dof = this->ndof();
  
     // Resize the vector
     LinearAlgebraDistribution dist(this->communicator_pt(), n_dof, false);
     Mres.build(&dist, 0.0);
  
     // If we have discontinuous formulation
     // We can invert the mass matrix element by element
     if (Discontinuous_element_formulation)
     {
       // Loop over the elements and get their residuals
       const unsigned n_element = Problem::mesh_pt()->nelement();
       Vector<double> element_Mres;
       for (unsigned e = 0; e < n_element; e++)
       {
         // Cache the element
         DGElement* const elem_pt =
           dynamic_cast<DGElement*>(Problem::mesh_pt()->element_pt(e));
  
         // Find the elemental inverse mass matrix times residuals
         const unsigned n_el_dofs = elem_pt->ndof();
         elem_pt->get_inverse_mass_matrix_times_residuals(element_Mres);
  
         // Add contribution to global matrix
         for (unsigned i = 0; i < n_el_dofs; i++)
         {
           Mres[elem_pt->eqn_number(i)] = element_Mres[i];
         }
       }
     }
     // Otherwise it's continous and we must invert the full
     // mass matrix via a global linear solve.
     else
     {
       // Now do the linear solve -- recycling Mass matrix if requested
       // If we already have the factorised mass matrix, then resolve
       if (Mass_matrix_reuse_is_enabled && Mass_matrix_has_been_computed)
       {
         if (!Shut_up_in_newton_solve)
         {
           oomph_info << "Not recomputing Mass Matrix " << std::endl;
         }
  
         // Get the residuals
         DoubleVector residuals(&dist, 0.0);
         this->get_residuals(residuals);
  
         // Resolve the linear system
         this->mass_matrix_solver_for_explicit_timestepper_pt()->resolve(
           residuals, Mres);
       }
       // Otherwise solve for the first time
       else
       {
         // If we wish to reuse the mass matrix, then enable resolve
         if (Mass_matrix_reuse_is_enabled)
         {
           if (!Shut_up_in_newton_solve)
           {
             oomph_info << "Enabling resolve in explicit timestep" << std::endl;
           }
           this->mass_matrix_solver_for_explicit_timestepper_pt()
             ->enable_resolve();
         }
  
         // Use a custom assembly handler to assemble and invert the mass matrix
  
         // Store the old assembly handler
         AssemblyHandler* old_assembly_handler_pt = this->assembly_handler_pt();
         // Set the assembly handler to the explicit timestep handler
         this->assembly_handler_pt() = new ExplicitTimeStepHandler;
  
         // Solve the linear system
         this->mass_matrix_solver_for_explicit_timestepper_pt()->solve(this,
                                                                       Mres);
         // The mass matrix has now been computed
         Mass_matrix_has_been_computed = true;
  
         // Delete the Explicit Timestep handler
         delete this->assembly_handler_pt();
         // Reset the assembly handler to the original handler
         this->assembly_handler_pt() = old_assembly_handler_pt;
       }
     }
   }

References assembly_handler_pt(), oomph::DoubleVector::build(), communicator_pt(), Default_assembly_handler_pt, Discontinuous_element_formulation, e(), oomph::Mesh::element_pt(), oomph::LinearSolver::enable_resolve(), oomph::GeneralisedElement::eqn_number(), oomph::DGElement::get_inverse_mass_matrix_times_residuals(), get_residuals(), i, Mass_matrix_has_been_computed, Mass_matrix_reuse_is_enabled, mass_matrix_solver_for_explicit_timestepper_pt(), mesh_pt(), oomph::GeneralisedElement::ndof(), ndof(), oomph::Mesh::nelement(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::oomph_info, oomph::LinearSolver::resolve(), Shut_up_in_newton_solve, and oomph::LinearSolver::solve().

Referenced by get_dvaluesdt().

◆ get_jacobian() [1/4]

void Problem::get_jacobian	(	DoubleVector &	residuals,
		CCDoubleMatrix &	jacobian
	)

virtual

Return the fully-assembled Jacobian and residuals for the problem. Interface for the case when the Jacobian is in column-compressed storage format. This is virtual so, if we feel like it (e.g. for testing iterative solvers with specific test matrices), we can bypass the default assembly procedure for the Jacobian and the residual vector.

Return the fully-assembled Jacobian and residuals for the problem, in the case when the jacobian matrix is in column-compressed storage format.

   {
     // Three different cases; if MPI_Helpers::MPI_has_been_initialised=true
     // this means MPI_Helpers::setup() has been called.  This could happen on a
     // code compiled with MPI but run serially; in this instance the
     // get_residuals function still works on one processor.
     //
     // Secondly, if a code has been compiled with MPI, but MPI_Helpers::setup()
     // has not been called, then MPI_Helpers::MPI_has_been_initialised=false
     // and the code calls...
     //
     // Thirdly, the serial version (compiled by all, but only run when compiled
     // with MPI if MPI_Helpers::MPI_has_been_5Binitialised=false
     //
     // The only case where an MPI code cannot run serially at present
     // is one where the distribute function is used (i.e. METIS is called)
  
     // get the number of degrees of freedom
     unsigned n_dof = ndof();
  
 #ifdef PARANOID
     // PARANOID checks : if the distribution of residuals is setup then it must
     // must not be distributed, have the right number of rows, and the same
     // communicator as the problem
     if (residuals.built())
     {
       if (residuals.distribution_pt()->distributed())
       {
         std::ostringstream error_stream;
         error_stream
           << "If the DoubleVector residuals is setup then it must not "
           << "be distributed.";
         throw OomphLibError(
           error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
       }
       if (residuals.distribution_pt()->nrow() != n_dof)
       {
         std::ostringstream error_stream;
         error_stream
           << "If the DoubleVector residuals is setup then it must have"
           << " the correct number of rows";
         throw OomphLibError(
           error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
       }
       if (!(*Communicator_pt ==
             *residuals.distribution_pt()->communicator_pt()))
       {
         std::ostringstream error_stream;
         error_stream
           << "If the DoubleVector residuals is setup then it must have"
           << " the same communicator as the problem.";
         throw OomphLibError(
           error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
       }
     }
 #endif
  
     // Allocate storage for the matrix entries
     // The generalised Vector<Vector<>> structure is required
     // for the most general interface to sparse_assemble() which allows
     // the assembly of multiple matrices at once.
     Vector<int*> row_index(1);
     Vector<int*> column_start(1);
     Vector<double*> value(1);
  
     // Allocate generalised storage format for passing to sparse_assemble()
     Vector<double*> res(1);
  
     // allocate storage for the number of non-zeros in each matrix
     Vector<unsigned> nnz(1);
  
     // The matrix is in compressed column format
     bool compressed_row_flag = false;
  
     // get the distribution for the residuals
     LinearAlgebraDistribution* dist_pt;
     if (!residuals.built())
     {
       dist_pt =
         new LinearAlgebraDistribution(Communicator_pt, this->ndof(), false);
     }
     else
     {
       dist_pt = new LinearAlgebraDistribution(residuals.distribution_pt());
     }
  
 #ifdef OOMPH_HAS_MPI
     if (communicator_pt()->nproc() == 1)
     {
 #endif
       sparse_assemble_row_or_column_compressed(
         row_index, column_start, value, nnz, res, compressed_row_flag);
       jacobian.build_without_copy(
         value[0], row_index[0], column_start[0], nnz[0], n_dof, n_dof);
       residuals.build(dist_pt, 0.0);
       residuals.set_external_values(res[0], true);
 #ifdef OOMPH_HAS_MPI
     }
     else
     {
       std::ostringstream error_stream;
       error_stream << "Cannot assemble a CCDoubleMatrix Jacobian on more "
                    << "than one processor.";
       throw OomphLibError(
         error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
 #endif
  
     // clean up
     delete dist_pt;
   }

References oomph::DoubleVector::build(), oomph::CCMatrix< T >::build_without_copy(), oomph::DoubleVector::built(), oomph::LinearAlgebraDistribution::communicator_pt(), Communicator_pt, communicator_pt(), oomph::LinearAlgebraDistribution::distributed(), oomph::DistributableLinearAlgebraObject::distribution_pt(), ndof(), oomph::LinearAlgebraDistribution::nrow(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, res, oomph::DoubleVector::set_external_values(), sparse_assemble_row_or_column_compressed(), and Eigen::value.

◆ get_jacobian() [2/4]

void Problem::get_jacobian	(	DoubleVector &	residuals,
		CRDoubleMatrix &	jacobian
	)

virtual

Return the fully-assembled Jacobian and residuals for the problem. Interface for the case when the Jacobian is in row-compressed storage format. This is virtual so, if we feel like it (e.g. for testing iterative solvers with specific test matrices), we can bypass the default assembly procedure for the Jacobian and the residual vector.

Return the fully-assembled Jacobian and residuals for the problem, in the case where the Jacobian matrix is in a distributable row compressed storage format.

If the distribution of the jacobian and residuals is setup then, they will be returned with that distribution. Note. the jacobian and residuals must have the same distribution.
If the distribution of the jacobian and residuals are not setup then their distribution will computed based on: Distributed_problem_matrix_distribution.

   {
     // Three different cases; if MPI_Helpers::MPI_has_been_initialised=true
     // this means MPI_Helpers::setup() has been called.  This could happen on a
     // code compiled with MPI but run serially; in this instance the
     // get_residuals function still works on one processor.
     //
     // Secondly, if a code has been compiled with MPI, but MPI_Helpers::setup()
     // has not been called, then MPI_Helpers::MPI_has_been_initialised=false
     // and the code calls...
     //
     // Thirdly, the serial version (compiled by all, but only run when compiled
     // with MPI if MPI_Helpers::MPI_has_been_initialised=false
     //
     // The only case where an MPI code cannot run serially at present
     // is one where the distribute function is used (i.e. METIS is called)
  
     // Allocate storage for the matrix entries
     // The generalised Vector<Vector<>> structure is required
     // for the most general interface to sparse_assemble() which allows
     // the assembly of multiple matrices at once.
     Vector<int*> column_index(1);
     Vector<int*> row_start(1);
     Vector<double*> value(1);
     Vector<unsigned> nnz(1);
  
 #ifdef PARANOID
     // PARANOID checks that the distribution of the jacobian matches that of the
     // residuals (if they are setup) and that they have the right number of rows
     if (residuals.built() && jacobian.distribution_built())
     {
       if (!(*residuals.distribution_pt() == *jacobian.distribution_pt()))
       {
         std::ostringstream error_stream;
         error_stream << "The distribution of the residuals must "
                      << "be the same as the distribution of the jacobian.";
         throw OomphLibError(
           error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
       }
       if (jacobian.distribution_pt()->nrow() != this->ndof())
       {
         std::ostringstream error_stream;
         error_stream
           << "The distribution of the jacobian and residuals does not"
           << "have the correct number of global rows.";
         throw OomphLibError(
           error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
       }
     }
     else if (residuals.built() != jacobian.distribution_built())
     {
       std::ostringstream error_stream;
       error_stream << "The distribution of the jacobian and residuals must "
                    << "both be setup or both not setup";
       throw OomphLibError(
         error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
 #endif
  
  
     // Allocate generalised storage format for passing to sparse_assemble()
     Vector<double*> res(1);
  
     // number of rows
     unsigned nrow = this->ndof();
  
     // determine the distribution for the jacobian.
     // IF the jacobian has distribution setup then use that
     // ELSE determine the distribution based on the
     // distributed_matrix_distribution enum
     LinearAlgebraDistribution* dist_pt = 0;
     if (jacobian.distribution_built())
     {
       dist_pt = new LinearAlgebraDistribution(jacobian.distribution_pt());
     }
     else
     {
 #ifdef OOMPH_HAS_MPI
       // if problem is only one one processor
       if (Communicator_pt->nproc() == 1)
       {
         dist_pt = new LinearAlgebraDistribution(Communicator_pt, nrow, false);
       }
       // if the problem is not distributed then assemble the jacobian with
       // a uniform distributed distribution
       else if (!Problem_has_been_distributed)
       {
         dist_pt = new LinearAlgebraDistribution(Communicator_pt, nrow, true);
       }
       // otherwise the problem is a distributed problem
       else
       {
         switch (Dist_problem_matrix_distribution)
         {
           case Uniform_matrix_distribution:
             dist_pt =
               new LinearAlgebraDistribution(Communicator_pt, nrow, true);
             break;
           case Problem_matrix_distribution:
             dist_pt = new LinearAlgebraDistribution(Dof_distribution_pt);
             break;
           case Default_matrix_distribution:
             LinearAlgebraDistribution* uniform_dist_pt =
               new LinearAlgebraDistribution(Communicator_pt, nrow, true);
             bool use_problem_dist = true;
             unsigned nproc = Communicator_pt->nproc();
             for (unsigned p = 0; p < nproc; p++)
             {
               if ((double)Dof_distribution_pt->nrow_local(p) >
                   ((double)uniform_dist_pt->nrow_local(p)) * 1.1)
               {
                 use_problem_dist = false;
               }
             }
             if (use_problem_dist)
             {
               dist_pt = new LinearAlgebraDistribution(Dof_distribution_pt);
             }
             else
             {
               dist_pt = new LinearAlgebraDistribution(uniform_dist_pt);
             }
             delete uniform_dist_pt;
             break;
         }
       }
 #else
       dist_pt = new LinearAlgebraDistribution(Communicator_pt, nrow, false);
 #endif
     }
  
  
     // The matrix is in compressed row format
     bool compressed_row_flag = true;
  
 #ifdef OOMPH_HAS_MPI
     //
     if (Communicator_pt->nproc() == 1)
     {
 #endif
       sparse_assemble_row_or_column_compressed(
         column_index, row_start, value, nnz, res, compressed_row_flag);
       jacobian.build(dist_pt);
       jacobian.build_without_copy(
         dist_pt->nrow(), nnz[0], value[0], column_index[0], row_start[0]);
       residuals.build(dist_pt, 0.0);
       residuals.set_external_values(res[0], true);
 #ifdef OOMPH_HAS_MPI
     }
     else
     {
       if (dist_pt->distributed())
       {
         parallel_sparse_assemble(
           dist_pt, column_index, row_start, value, nnz, res);
         jacobian.build(dist_pt);
         jacobian.build_without_copy(
           dist_pt->nrow(), nnz[0], value[0], column_index[0], row_start[0]);
         residuals.build(dist_pt, 0.0);
         residuals.set_external_values(res[0], true);
       }
       else
       {
         LinearAlgebraDistribution* temp_dist_pt =
           new LinearAlgebraDistribution(Communicator_pt, dist_pt->nrow(), true);
         parallel_sparse_assemble(
           temp_dist_pt, column_index, row_start, value, nnz, res);
         jacobian.build(temp_dist_pt);
         jacobian.build_without_copy(
           dist_pt->nrow(), nnz[0], value[0], column_index[0], row_start[0]);
         jacobian.redistribute(dist_pt);
         residuals.build(temp_dist_pt, 0.0);
         residuals.set_external_values(res[0], true);
         residuals.redistribute(dist_pt);
         delete temp_dist_pt;
       }
     }
 #endif
  
     // clean up dist_pt and residuals_vector pt
     delete dist_pt;
   }

References oomph::DoubleVector::build(), oomph::CRDoubleMatrix::build(), oomph::CRDoubleMatrix::build_without_copy(), oomph::DoubleVector::built(), Communicator_pt, oomph::LinearAlgebraDistribution::distributed(), oomph::DistributableLinearAlgebraObject::distribution_built(), oomph::DistributableLinearAlgebraObject::distribution_pt(), Dof_distribution_pt, ndof(), oomph::OomphCommunicator::nproc(), oomph::LinearAlgebraDistribution::nrow(), oomph::LinearAlgebraDistribution::nrow_local(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, p, oomph::DoubleVector::redistribute(), oomph::CRDoubleMatrix::redistribute(), res, oomph::DoubleVector::set_external_values(), sparse_assemble_row_or_column_compressed(), and Eigen::value.

◆ get_jacobian() [3/4]

void Problem::get_jacobian	(	DoubleVector &	residuals,
		DenseDoubleMatrix &	jacobian
	)

virtual

Return the fully-assembled Jacobian and residuals for the problem Interface for the case when the Jacobian matrix is dense. This is virtual so, if we feel like it (e.g. for testing iterative solvers with specific test matrices, we can bypass the default assembly procedure for the Jacobian and the residual vector.

Get the fully assembled residual vector and Jacobian matrix in dense storage. The DoubleVector residuals returned will be non-distributed. If on calling this method the DoubleVector residuals is setup then it must be non-distributed and of the correct length. The matrix type DenseDoubleMatrix is not distributable and therefore the residual vector is also assumed to be non distributable.

   {
     // get the number of degrees of freedom
     unsigned n_dof = ndof();
  
 #ifdef PARANOID
     // PARANOID checks : if the distribution of residuals is setup then it must
     // must not be distributed, have the right number of rows, and the same
     // communicator as the problem
     if (residuals.built())
     {
       if (residuals.distribution_pt()->distributed())
       {
         std::ostringstream error_stream;
         error_stream
           << "If the DoubleVector residuals is setup then it must not "
           << "be distributed.";
         throw OomphLibError(
           error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
       }
       if (residuals.distribution_pt()->nrow() != n_dof)
       {
         std::ostringstream error_stream;
         error_stream
           << "If the DoubleVector residuals is setup then it must have"
           << " the correct number of rows";
         throw OomphLibError(
           error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
       }
       if (!(*Communicator_pt ==
             *residuals.distribution_pt()->communicator_pt()))
       {
         std::ostringstream error_stream;
         error_stream
           << "If the DoubleVector residuals is setup then it must have"
           << " the same communicator as the problem.";
         throw OomphLibError(
           error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
       }
     }
 #endif
  
     // set the residuals distribution if it is not setup
     if (!residuals.built())
     {
       LinearAlgebraDistribution dist(Communicator_pt, n_dof, false);
       residuals.build(&dist, 0.0);
     }
     // else just zero the residuals
     else
     {
       residuals.initialise(0.0);
     }
  
     // Resize the matrices -- this cannot always be done externally
     // because get_jacobian exists in many different versions for
     // different storage formats -- resizing a CC or CR matrix doesn't
     // make sense.
  
     // resize the jacobian
     jacobian.resize(n_dof, n_dof);
     jacobian.initialise(0.0);
  
     // Locally cache pointer to assembly handler
     AssemblyHandler* const assembly_handler_pt = Assembly_handler_pt;
  
     // Loop over all the elements
     unsigned long n_element = Mesh_pt->nelement();
     for (unsigned long e = 0; e < n_element; e++)
     {
       // Get the pointer to the element
       GeneralisedElement* elem_pt = Mesh_pt->element_pt(e);
       // Find number of dofs in the element
       unsigned n_element_dofs = assembly_handler_pt->ndof(elem_pt);
       // Set up an array
       Vector<double> element_residuals(n_element_dofs);
       // Set up a matrix
       DenseMatrix<double> element_jacobian(n_element_dofs);
       // Fill the array
       assembly_handler_pt->get_jacobian(
         elem_pt, element_residuals, element_jacobian);
       // Now loop over the dofs and assign values to global Vector
       for (unsigned l = 0; l < n_element_dofs; l++)
       {
         unsigned long eqn_number = assembly_handler_pt->eqn_number(elem_pt, l);
         residuals[eqn_number] += element_residuals[l];
         for (unsigned l2 = 0; l2 < n_element_dofs; l2++)
         {
           jacobian(eqn_number, assembly_handler_pt->eqn_number(elem_pt, l2)) +=
             element_jacobian(l, l2);
         }
       }
     }
   }

References Assembly_handler_pt, assembly_handler_pt(), oomph::DoubleVector::build(), oomph::DoubleVector::built(), oomph::LinearAlgebraDistribution::communicator_pt(), Communicator_pt, oomph::LinearAlgebraDistribution::distributed(), oomph::DistributableLinearAlgebraObject::distribution_pt(), e(), oomph::Mesh::element_pt(), oomph::AssemblyHandler::eqn_number(), oomph::AssemblyHandler::get_jacobian(), oomph::DoubleVector::initialise(), oomph::DenseMatrix< T >::initialise(), Mesh_pt, ndof(), oomph::AssemblyHandler::ndof(), oomph::Mesh::nelement(), oomph::LinearAlgebraDistribution::nrow(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and oomph::DenseMatrix< T >::resize().

Referenced by oomph::FpPressureAdvectionDiffusionProblem< ELEMENT >::get_pressure_advection_diffusion_jacobian(), oomph::NavierStokesSchurComplementPreconditioner::get_pressure_advection_diffusion_matrix(), main(), oomph::CG< MATRIX >::solve(), oomph::BiCGStab< MATRIX >::solve(), oomph::GS< MATRIX >::solve(), oomph::GS< CRDoubleMatrix >::solve(), oomph::DampedJacobi< MATRIX >::solve(), oomph::GMRES< MATRIX >::solve(), oomph::AugmentedProblemGMRES::solve(), oomph::DenseLU::solve(), oomph::SuperLUSolver::solve(), oomph::MumpsSolver::solve(), oomph::HelmholtzGMRESMG< MATRIX >::solve(), oomph::HelmholtzFGMRESMG< MATRIX >::solve(), oomph::HypreSolver::solve(), oomph::TrilinosAztecOOSolver::solve(), and oomph::SuperLUSolver::solve_transpose().

◆ get_jacobian() [4/4]

virtual void oomph::Problem::get_jacobian	(	DoubleVector &	residuals,
		SumOfMatrices &	jacobian
	)

inlinevirtual

Dummy virtual function that must be overloaded by the problem to specify which matrices should be summed to give the final Jacobian.

     {
       std::ostringstream error_stream;
       error_stream
         << "You must overload this function in your problem class to specify\n"
         << "which matrices should be summed to give the final Jacobian.";
       throw OomphLibError(
         error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }

References OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

◆ get_residuals()

void Problem::get_residuals ( DoubleVector & residuals )

virtual

Get the total residuals Vector for the problem.

Return the fully-assembled residuals Vector for the problem: Virtual so it can be overloaded in for mpi problems

   {
     // Three different cases; if MPI_Helpers::MPI_has_been_initialised=true
     // this means MPI_Helpers::init() has been called.  This could happen on a
     // code compiled with MPI but run serially; in this instance the
     // get_residuals function still works on one processor.
     //
     // Secondly, if a code has been compiled with MPI, but MPI_Helpers::init()
     // has not been called, then MPI_Helpers::MPI_has_been_initialised=false
     // and the code calls...
     //
     // Thirdly, the serial version (compiled by all, but only run when compiled
     // with MPI if MPI_Helpers::MPI_has_been_initialised=false
  
     // Check that the residuals has the correct number of rows if it has been
     // setup
 #ifdef PARANOID
     if (residuals.built())
     {
       if (residuals.distribution_pt()->nrow() != this->ndof())
       {
         std::ostringstream error_stream;
         error_stream << "The distribution of the residuals vector does not "
                         "have the correct\n"
                      << "number of global rows\n";
  
         throw OomphLibError(
           error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
       }
     }
 #endif
  
     // Find the number of rows
     const unsigned nrow = this->ndof();
  
     // Determine the distribution for the residuals vector
     // IF the vector has distribution setup then use that
     // ELSE determine the distribution based on the
     // distributed_matrix_distribution enum
     LinearAlgebraDistribution* dist_pt = 0;
     if (residuals.built())
     {
       dist_pt = new LinearAlgebraDistribution(residuals.distribution_pt());
     }
     else
     {
 #ifdef OOMPH_HAS_MPI
       // if problem is only one one processor assemble non-distributed
       // distribution
       if (Communicator_pt->nproc() == 1)
       {
         dist_pt = new LinearAlgebraDistribution(Communicator_pt, nrow, false);
       }
       // if the problem is not distributed then assemble the jacobian with
       // a uniform distributed distribution
       else if (!Problem_has_been_distributed)
       {
         dist_pt = new LinearAlgebraDistribution(Communicator_pt, nrow, true);
       }
       // otherwise the problem is a distributed problem
       else
       {
         switch (Dist_problem_matrix_distribution)
         {
           case Uniform_matrix_distribution:
             dist_pt =
               new LinearAlgebraDistribution(Communicator_pt, nrow, true);
             break;
           case Problem_matrix_distribution:
             dist_pt = new LinearAlgebraDistribution(Dof_distribution_pt);
             break;
           case Default_matrix_distribution:
             LinearAlgebraDistribution* uniform_dist_pt =
               new LinearAlgebraDistribution(Communicator_pt, nrow, true);
             bool use_problem_dist = true;
             unsigned nproc = Communicator_pt->nproc();
             for (unsigned p = 0; p < nproc; p++)
             {
               if ((double)Dof_distribution_pt->nrow_local(p) >
                   ((double)uniform_dist_pt->nrow_local(p)) * 1.1)
               {
                 use_problem_dist = false;
               }
             }
             if (use_problem_dist)
             {
               dist_pt = new LinearAlgebraDistribution(Dof_distribution_pt);
             }
             else
             {
               dist_pt = new LinearAlgebraDistribution(uniform_dist_pt);
             }
             delete uniform_dist_pt;
             break;
         }
       }
 #else
       dist_pt = new LinearAlgebraDistribution(Communicator_pt, nrow, false);
 #endif
     }
  
     // Locally cache pointer to assembly handler
     AssemblyHandler* const assembly_handler_pt = Assembly_handler_pt;
  
     // Build and zero the residuals
     residuals.build(dist_pt, 0.0);
  
     // Serial (or one processor case)
 #ifdef OOMPH_HAS_MPI
     if (this->communicator_pt()->nproc() == 1)
     {
 #endif // OOMPH_HAS_MPI
       // Loop over all the elements
       unsigned long Element_pt_range = Mesh_pt->nelement();
       for (unsigned long e = 0; e < Element_pt_range; e++)
       {
         // Get the pointer to the element
         GeneralisedElement* elem_pt = Mesh_pt->element_pt(e);
         // Find number of dofs in the element
         unsigned n_element_dofs = assembly_handler_pt->ndof(elem_pt);
         // Set up an array
         Vector<double> element_residuals(n_element_dofs);
         // Fill the array
         assembly_handler_pt->get_residuals(elem_pt, element_residuals);
         // Now loop over the dofs and assign values to global Vector
         for (unsigned l = 0; l < n_element_dofs; l++)
         {
           residuals[assembly_handler_pt->eqn_number(elem_pt, l)] +=
             element_residuals[l];
         }
       }
       // Otherwise parallel case
 #ifdef OOMPH_HAS_MPI
     }
     else
     {
       // Store the current assembly handler
       AssemblyHandler* const old_assembly_handler_pt = Assembly_handler_pt;
       // Create a new assembly handler that only assembles the residuals
       Assembly_handler_pt =
         new ParallelResidualsHandler(old_assembly_handler_pt);
  
       // Setup memory for parallel sparse assemble
       // No matrix so all size zero
       Vector<int*> column_index;
       Vector<int*> row_start;
       Vector<double*> value;
       Vector<unsigned> nnz;
       // One set of residuals of sizer one
       Vector<double*> res(1);
  
       // Call the parallel sparse assemble, that should only assemble residuals
       parallel_sparse_assemble(
         dist_pt, column_index, row_start, value, nnz, res);
       // Fill in the residuals data
       residuals.set_external_values(res[0], true);
  
       // Delete new assembly handler
       delete Assembly_handler_pt;
       // Reset the assembly handler to the original
       Assembly_handler_pt = old_assembly_handler_pt;
     }
 #endif
  
     // Delete the distribution
     delete dist_pt;
   }

References Assembly_handler_pt, assembly_handler_pt(), oomph::DoubleVector::build(), oomph::DoubleVector::built(), Communicator_pt, communicator_pt(), oomph::DistributableLinearAlgebraObject::distribution_pt(), Dof_distribution_pt, e(), oomph::Mesh::element_pt(), oomph::AssemblyHandler::eqn_number(), oomph::AssemblyHandler::get_residuals(), Mesh_pt, ndof(), oomph::AssemblyHandler::ndof(), oomph::Mesh::nelement(), oomph::OomphCommunicator::nproc(), oomph::LinearAlgebraDistribution::nrow(), oomph::LinearAlgebraDistribution::nrow_local(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, p, res, oomph::DoubleVector::set_external_values(), and Eigen::value.

Referenced by get_derivative_wrt_global_parameter(), get_fd_jacobian(), get_inverse_mass_matrix_times_residuals(), globally_convergent_line_search(), newton_solve(), newton_solve_continuation(), oomph::UnsteadyHeatFluxPseudoMeltElement< ELEMENT >::plot_residual_landscape(), oomph::SegregatableFSIProblem::segregated_solve(), oomph::SolidICProblem::set_newmark_initial_condition_consistently(), oomph::BlockHopfLinearSolver::solve(), and oomph::BlockHopfLinearSolver::solve_for_two_rhs().

◆ global_data_pt()

Data*& oomph::Problem::global_data_pt ( const unsigned & i )

inline

Return a pointer to the the i-th global data object.

     {
       return Global_data_pt[i];
     }

References Global_data_pt, and i.

Referenced by oomph::IMRByBDF::actions_after_timestep(), oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::adapt_temporal_mesh(), add_global_data(), CapProblem< ELEMENT >::CapProblem(), and copy().

◆ global_dof_pt()

double* oomph::Problem::global_dof_pt ( const unsigned & i )

inline

Return a pointer to the dof, indexed by global equation number which may be haloed or stored locally. If it is haloed, a local copy must have been requested on this processor in the Halo_scheme_pt.

     {
 #ifdef OOMPH_HAS_MPI
       // If the problem is distributed I have to do something different
       if (Problem_has_been_distributed)
       {
 #ifdef PARANOID
         if (Halo_scheme_pt == 0)
         {
           std::ostringstream error_stream;
           error_stream
             << "Direct access to global dofs in a distributed problem is only\n"
             << "possible if the function setup_dof_halo_scheme() has been "
                "called.\n"
             << "You can access local dofs via Problem::dof(i).\n";
           throw OomphLibError(error_stream.str(),
                               OOMPH_CURRENT_FUNCTION,
                               OOMPH_EXCEPTION_LOCATION);
         }
 #endif
  
         // Work out the local coordinate of the dof
         // based on the original distribution stored in the Halo_scheme
         const unsigned first_row_local =
           Halo_scheme_pt->distribution_pt()->first_row();
         const unsigned n_row_local =
           Halo_scheme_pt->distribution_pt()->nrow_local();
  
         // If we are in range then just call the local value
         if ((i >= first_row_local) && (i < first_row_local + n_row_local))
         {
           return this->Dof_pt[i - first_row_local];
         }
         // Otherwise the entry is not stored in the local processor
         // and we must have haloed it
         else
         {
           return Halo_dof_pt[Halo_scheme_pt->local_index(i)];
         }
       }
       // Otherwise just return the dof
       else
 #endif
       {
         return this->Dof_pt[i];
       }
     }

References oomph::DoubleVectorHaloScheme::distribution_pt(), oomph::LinearAlgebraDistribution::first_row(), i, oomph::DoubleVectorHaloScheme::local_index(), oomph::LinearAlgebraDistribution::nrow_local(), OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

Referenced by get_hessian_vector_products(), oomph::PitchForkHandler::get_jacobian(), and oomph::PitchForkHandler::get_residuals().

◆ global_temporal_error_norm()

virtual double oomph::Problem::global_temporal_error_norm ( )

inlineprotectedvirtual

Function to calculate a global error norm, used in adaptive timestepping to control the change in timestep. Individual errors for each data object can be obtained via the data timestepper's temporal_error_in_value or temporal_error_in_position functions and should be combined to construct a global norm. For example, in fluids problems a suitable norm is usually the weighted sum of the errors in the velocities; for moving mesh problems is it usually better to use the weighted sum of the errors in position.

     {
       std::string error_message =
         "The global_temporal_error_norm function will be problem-specific:\n";
       error_message += "Please write your own in your Problem class";
  
       throw OomphLibError(
         error_message, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
       return 0.0;
     }

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

Referenced by adaptive_unsteady_newton_solve().

◆ globally_convergent_line_search()

void Problem::globally_convergent_line_search	(	const Vector< double > &	x_old,
		const double &	half_residual_squared_old,
		DoubleVector &	gradient,
		DoubleVector &	newton_dir,
		double &	half_residual_squared,
		const double &	stpmax
	)

private

Line search helper for globally convergent Newton method.

Helper function for the globally convergent Newton solver.

   {
     const double min_fct_decrease = 1.0e-4;
     double convergence_tol_on_x = 1.0e-16;
     double f_aux = 0.0;
     double lambda_aux = 0.0;
     double proposed_lambda;
     unsigned long n_dof = ndof();
     double sum = 0.0;
     for (unsigned i = 0; i < n_dof; i++)
     {
       sum += newton_dir[i] * newton_dir[i];
     }
     sum = sqrt(sum);
     if (sum > stpmax)
     {
       for (unsigned i = 0; i < n_dof; i++)
       {
         newton_dir[i] *= stpmax / sum;
       }
     }
     double slope = 0.0;
     for (unsigned i = 0; i < n_dof; i++)
     {
       slope += gradient[i] * newton_dir[i];
     }
     if (slope >= 0.0)
     {
       std::ostringstream warn_message;
       warn_message << "WARNING: Non-negative slope, probably due to a "
                    << " roundoff \nproblem in the linesearch: slope=" << slope
                    << "\n";
       OomphLibWarning(warn_message.str(),
                       "Problem::globally_convergent_line_search()",
                       OOMPH_EXCEPTION_LOCATION);
     }
     double test = 0.0;
     for (unsigned i = 0; i < n_dof; i++)
     {
       double temp =
         std::fabs(newton_dir[i]) / std::max(std::fabs(x_old[i]), 1.0);
       if (temp > test) test = temp;
     }
     double lambda_min = convergence_tol_on_x / test;
     double lambda = 1.0;
     while (true)
     {
       for (unsigned i = 0; i < n_dof; i++)
       {
         *Dof_pt[i] = x_old[i] + lambda * newton_dir[i];
       }
  
       // Evaluate current residuals
       DoubleVector residuals;
       get_residuals(residuals);
       half_residual_squared = 0.0;
       for (unsigned i = 0; i < n_dof; i++)
       {
         half_residual_squared += residuals[i] * residuals[i];
       }
       half_residual_squared *= 0.5;
  
       if (lambda < lambda_min)
       {
         for (unsigned i = 0; i < n_dof; i++) *Dof_pt[i] = x_old[i];
  
         std::ostringstream warn_message;
         warn_message << "WARNING: Line search converged on x only!\n";
         OomphLibWarning(warn_message.str(),
                         "Problem::globally_convergent_line_search()",
                         OOMPH_EXCEPTION_LOCATION);
         return;
       }
       else if (half_residual_squared <=
                half_residual_squared_old + min_fct_decrease * lambda * slope)
       {
         oomph_info << "Returning from linesearch with lambda=" << lambda
                    << std::endl;
         return;
       }
       else
       {
         if (lambda == 1.0)
         {
           proposed_lambda =
             -slope /
             (2.0 * (half_residual_squared - half_residual_squared_old - slope));
         }
         else
         {
           double r1 =
             half_residual_squared - half_residual_squared_old - lambda * slope;
           double r2 = f_aux - half_residual_squared_old - lambda_aux * slope;
           double a_poly =
             (r1 / (lambda * lambda) - r2 / (lambda_aux * lambda_aux)) /
             (lambda - lambda_aux);
           double b_poly = (-lambda_aux * r1 / (lambda * lambda) +
                            lambda * r2 / (lambda_aux * lambda_aux)) /
                           (lambda - lambda_aux);
           if (a_poly == 0.0)
           {
             proposed_lambda = -slope / (2.0 * b_poly);
           }
           else
           {
             double discriminant = b_poly * b_poly - 3.0 * a_poly * slope;
             if (discriminant < 0.0)
             {
               proposed_lambda = 0.5 * lambda;
             }
             else if (b_poly <= 0.0)
             {
               proposed_lambda = (-b_poly + sqrt(discriminant)) / (3.0 * a_poly);
             }
             else
             {
               proposed_lambda = -slope / (b_poly + sqrt(discriminant));
             }
           }
           if (proposed_lambda > 0.5 * lambda)
           {
             proposed_lambda = 0.5 * lambda;
           }
         }
       }
       lambda_aux = lambda;
       f_aux = half_residual_squared;
       lambda = std::max(proposed_lambda, 0.1 * lambda);
     }
   }

References Dof_pt, boost::multiprecision::fabs(), get_residuals(), i, lambda, max, ndof(), OOMPH_EXCEPTION_LOCATION, oomph::oomph_info, sqrt(), and Eigen::test.

Referenced by newton_solve().

◆ initialise_dt() [1/2]

void Problem::initialise_dt ( const double & dt )

Set all timesteps to the same value, dt, and assign weights for all timesteppers in the problem

Set all timesteps to the same value, dt, and assign weights for all timesteppers in the problem.

   {
     // Initialise the timesteps in the Problem's time object
     Time_pt->initialise_dt(dt);
  
     // Find out how many timesteppers there are
     unsigned n_time_steppers = ntime_stepper();
  
     // Loop over them all and set the weights
     for (unsigned i = 0; i < n_time_steppers; i++)
     {
       time_stepper_pt(i)->set_weights();
       if (time_stepper_pt(i)->adaptive_flag())
       {
         time_stepper_pt(i)->set_error_weights();
       }
     }
   }

References i, oomph::Time::initialise_dt(), ntime_stepper(), oomph::TimeStepper::set_error_weights(), oomph::TimeStepper::set_weights(), Time_pt, and time_stepper_pt().

Referenced by assign_initial_values_impulsive(), FSIRingProblem::dynamic_run(), main(), OscRingNStProblem< ELEMENT >::OscRingNStProblem(), and read().

◆ initialise_dt() [2/2]

void Problem::initialise_dt ( const Vector< double > & dt )

Set the value of the timesteps to be equal to the values passed in a vector and assign weights for all timesteppers in the problem

   {
     // Initialise the timesteps in the Problem's time object
     Time_pt->initialise_dt(dt);
  
     // Find out how many timesteppers there are
     unsigned n_time_steppers = ntime_stepper();
  
     // Loop over them all and set the weights
     for (unsigned i = 0; i < n_time_steppers; i++)
     {
       time_stepper_pt(i)->set_weights();
       if (time_stepper_pt(i)->adaptive_flag())
       {
         time_stepper_pt(i)->set_error_weights();
       }
     }
   }

References i, oomph::Time::initialise_dt(), ntime_stepper(), oomph::TimeStepper::set_error_weights(), oomph::TimeStepper::set_weights(), Time_pt, and time_stepper_pt().

◆ is_dparameter_calculated_analytically()

bool oomph::Problem::is_dparameter_calculated_analytically ( double *const & parameter_pt )

inline

Function to determine whether the parameter derivatives are calculated analytically

     {
       // If the entry is found then the iterator returned from the find
       // command will NOT be equal to the end and the expression will
       // return true, otherwise it will return false
       return (Calculate_dparameter_analytic.find(parameter_pt) !=
               Calculate_dparameter_analytic.end());
     }

References Calculate_dparameter_analytic.

Referenced by get_derivative_wrt_global_parameter().

◆ jacobian_reuse_is_enabled()

bool oomph::Problem::jacobian_reuse_is_enabled ( )

inline

Is recycling of Jacobian in Newton iteration enabled?

     {
       return Jacobian_reuse_is_enabled;
     }

References Jacobian_reuse_is_enabled.

◆ linear_solver_pt() [1/2]

LinearSolver*& oomph::Problem::linear_solver_pt ( )

inline

Return a pointer to the linear solver object.

     {
       return Linear_solver_pt;
     }

References Linear_solver_pt.

Referenced by oomph::FoldHandler::FoldHandler(), FSIChannelWithLeafletProblem< ELEMENT >::FSIChannelWithLeafletProblem(), oomph::HopfHandler::HopfHandler(), parallel_test(), PerturbedStateProblem< BASE_ELEMENT, PERTURBED_ELEMENT >::PerturbedStateProblem(), oomph::ProjectionProblem< PROJECTABLE_ELEMENT >::project(), oomph::SolidICProblem::set_newmark_initial_condition_consistently(), oomph::ANASAZI::solve_eigenproblem(), TurekProblem< FLUID_ELEMENT, SOLID_ELEMENT >::TurekProblem(), oomph::FoldHandler::~FoldHandler(), oomph::HopfHandler::~HopfHandler(), and oomph::PitchForkHandler::~PitchForkHandler().

◆ linear_solver_pt() [2/2]

LinearSolver* const& oomph::Problem::linear_solver_pt ( ) const

inline

Return a pointer to the linear solver object (const version)

     {
       return Linear_solver_pt;
     }

References Linear_solver_pt.

◆ make_copy()

Problem * Problem::make_copy ( )

virtual

Make and return a pointer to the copy of the problem. A virtual function that must be filled in by the user is they wish to perform adaptive refinement in bifurcation tracking or in multigrid problems. ALH: WILL NOT BE NECESSARY IN BIFURCATION TRACKING IN LONG RUN...

Reimplemented in ABCProblem< ELEMENT, TIMESTEPPERT >, RefineablePorousChannelProblem< ELEMENT >, and FlowAroundCylinderProblem< ELEMENT >.

   {
     std::ostringstream error_stream;
     error_stream
       << "This function must be overloaded in your specific problem, and must\n"
       << "create an exact copy of your problem. Usually this will be achieved\n"
       << "by a call to the constructor with exactly the same arguments as "
          "used\n";
  
     throw OomphLibError(
       error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
   }

References OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

Referenced by adapt(), and bifurcation_adapt_helper().

◆ mass_matrix_reuse_is_enabled()

bool oomph::Problem::mass_matrix_reuse_is_enabled ( )

inline

Return whether the mass matrix is being reused.

     {
       return Mass_matrix_reuse_is_enabled;
     }

References Mass_matrix_reuse_is_enabled.

◆ mass_matrix_solver_for_explicit_timestepper_pt() [1/2]

LinearSolver*& oomph::Problem::mass_matrix_solver_for_explicit_timestepper_pt ( )

inline

Return a pointer to the linear solver object used for explicit time stepping.

     {
       return Mass_matrix_solver_for_explicit_timestepper_pt;
     }

References Mass_matrix_solver_for_explicit_timestepper_pt.

Referenced by get_inverse_mass_matrix_times_residuals().

◆ mass_matrix_solver_for_explicit_timestepper_pt() [2/2]

LinearSolver* oomph::Problem::mass_matrix_solver_for_explicit_timestepper_pt ( ) const

inline

Return a pointer to the linear solver object used for explicit time stepping (const version).

     {
       return Mass_matrix_solver_for_explicit_timestepper_pt;
     }

References Mass_matrix_solver_for_explicit_timestepper_pt.

◆ max_newton_iterations()

unsigned& oomph::Problem::max_newton_iterations ( )

inline

Access function to max Newton iterations before giving up.

     {
       return Max_newton_iterations;
     }

References Max_newton_iterations.

◆ max_residuals()

double& oomph::Problem::max_residuals ( )

inline

Access function to max residuals in Newton iterations before giving up.

     {
       return Max_residuals;
     }

References Max_residuals.

◆ maximum_dt()

double& oomph::Problem::maximum_dt ( )

inline

Access function to max timestep in adaptive timestepping.

     {
       return Maximum_dt;
     }

References Maximum_dt.

◆ mesh_pt() [1/4]

Mesh*& oomph::Problem::mesh_pt ( )

inline

Return a pointer to the global mesh.

     {
       return Mesh_pt;
     }

References Mesh_pt.

◆ mesh_pt() [2/4]

Mesh* const& oomph::Problem::mesh_pt ( ) const

inline

Return a pointer to the global mesh (const version)

     {
       return Mesh_pt;
     }

References Mesh_pt.

◆ mesh_pt() [3/4]

Mesh*& oomph::Problem::mesh_pt ( const unsigned & imesh )

inline

Return a pointer to the i-th submesh. If there are no submeshes, the 0-th submesh is the global mesh itself.

     {
       // If there are no submeshes then the zero-th submesh is the
       // mesh itself
       if ((Sub_mesh_pt.size() == 0) && (imesh == 0))
       {
         return Mesh_pt;
       }
       else
       {
         return Sub_mesh_pt[imesh];
       }
     }

References Mesh_pt, and Sub_mesh_pt.

◆ mesh_pt() [4/4]

Mesh* const& oomph::Problem::mesh_pt ( const unsigned & imesh ) const

inline

Return a pointer to the i-th submesh (const version)

     {
       // If there are no submeshes then the zero-th submesh is the
       // mesh itself
       if ((Sub_mesh_pt.size() == 0) && (imesh == 0))
       {
         return Mesh_pt;
       }
       else
       {
         return Sub_mesh_pt[imesh];
       }
     }

References Mesh_pt, and Sub_mesh_pt.

◆ minimum_dt()

double& oomph::Problem::minimum_dt ( )

inline

Access function to min timestep in adaptive timestepping.

     {
       return Minimum_dt;
     }

References Minimum_dt.

◆ ndof()

unsigned long oomph::Problem::ndof ( ) const

inline

Return the number of dofs.

     {
       return Dof_distribution_pt->nrow();
     }

References Dof_distribution_pt, and oomph::LinearAlgebraDistribution::nrow().

Referenced by oomph::IMRByBDF::actions_after_timestep(), oomph::IMRByBDF::actions_before_timestep(), adapt(), add_eigenvector_to_dofs(), add_to_dofs(), assign_eigenvector_to_dofs(), bifurcation_adapt_helper(), oomph::ODEProblem::build(), calculate_continuation_derivatives(), calculate_predictions(), oomph::FoldHandler::FoldHandler(), get_dofs(), get_eigenproblem_matrices(), get_fd_jacobian(), get_inverse_mass_matrix_times_residuals(), get_jacobian(), get_residuals(), globally_convergent_line_search(), oomph::HopfHandler::HopfHandler(), newton_solve(), parallel_test(), oomph::PitchForkHandler::PitchForkHandler(), oomph::MGPreconditioner< DIM >::preconditioner_solve(), oomph::HSL_MA42::reorder_elements(), oomph::AugmentedBlockFoldLinearSolver::resolve(), oomph::AugmentedBlockPitchForkLinearSolver::resolve(), restore_dof_values(), set_dofs(), oomph::AugmentedBlockFoldLinearSolver::solve(), oomph::AugmentedBlockPitchForkLinearSolver::solve(), oomph::BlockHopfLinearSolver::solve(), oomph::HSL_MA42::solve(), oomph::GS< MATRIX >::solve(), oomph::GS< CRDoubleMatrix >::solve(), oomph::DampedJacobi< MATRIX >::solve(), oomph::GMRES< MATRIX >::solve(), oomph::AugmentedProblemGMRES::solve(), oomph::DenseLU::solve(), oomph::FD_LU::solve(), oomph::SuperLUSolver::solve(), oomph::MumpsSolver::solve(), oomph::HelmholtzGMRESMG< MATRIX >::solve(), oomph::HelmholtzFGMRESMG< MATRIX >::solve(), oomph::ARPACK::solve_eigenproblem(), oomph::LAPACK_QZ::solve_eigenproblem(), oomph::HSL_MA42::solve_for_one_dof(), oomph::BlockHopfLinearSolver::solve_for_two_rhs(), oomph::SuperLUSolver::solve_transpose(), sparse_assemble_row_or_column_compressed_with_lists(), sparse_assemble_row_or_column_compressed_with_maps(), sparse_assemble_row_or_column_compressed_with_two_arrays(), sparse_assemble_row_or_column_compressed_with_two_vectors(), sparse_assemble_row_or_column_compressed_with_vectors_of_pairs(), and store_current_dof_values().

◆ newton_solve() [1/2]

void Problem::newton_solve ( )

Use Newton method to solve the problem.

General Newton solver. Requires only a convergence tolerance. The linear solver takes a pointer to the problem (which defines the Jacobian J and the residual Vector r) and returns the solution x of the system

\[ {\bf J} {\bf x} = - \bf{r} \]

.

   {
     // Initialise timers
     double total_linear_solver_time = 0.0;
     double t_start = TimingHelpers::timer();
     Max_res.clear();
  
     // Find total number of dofs
     unsigned long n_dofs = ndof();
  
     // Set up the Vector to hold the solution
     DoubleVector dx;
  
     //-----Variables for the globally convergent Newton method------
  
     // Set up the vector to hold the gradient
     DoubleVector gradient;
  
     // Other variables
     double half_residual_squared = 0.0;
     double max_step = 0.0;
  
     //--------------------------------------------------------------
  
     // Set the counter
     unsigned count = 0;
     // Set the loop flag
     unsigned LOOP_FLAG = 1;
  
     if (Use_globally_convergent_newton_method)
     {
 #ifdef OOMPH_HAS_MPI
       // Break if running in parallel
       if (MPI_Helpers::mpi_has_been_initialised())
       {
         std::ostringstream error_stream;
         error_stream << "Globally convergent Newton method has not been "
                      << "implemented in parallel yet!" << std::endl;
         throw OomphLibError(
           error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
       }
 #endif
  
       // Get gradient
       Linear_solver_pt->enable_computation_of_gradient();
       // Reset the gradient (clear it), since the number of dofs and
       // hence the size of the DoubleVector might have changed
       Linear_solver_pt->reset_gradient();
     }
  
     // Update anything that needs updating
     actions_before_newton_solve();
  
     // Reset number of Newton iterations taken
     Nnewton_iter_taken = 0;
  
     // Now do the Newton loop
     do
     {
       count++;
  
       // Do any updates that are required
       actions_before_newton_step();
  
  
       // No degrees of freedom? What are you solving for?
       if (n_dofs == 0)
       {
         oomph_info << std::endl << std::endl << std::endl;
         oomph_info << "This is a bit bizarre: The problem has no dofs."
                    << std::endl;
         oomph_info
           << "I'll just return from the Newton solver without doing anything."
           << std::endl;
  
         // Do any updates that would have been performed
         actions_before_newton_convergence_check();
         actions_after_newton_step();
         actions_before_newton_convergence_check();
         actions_after_newton_solve();
  
         oomph_info << "I hope this is what you intended me to do..."
                    << std::endl;
         oomph_info << std::endl
                    << "Note: All actions_...() functions were called"
                    << std::endl;
         oomph_info << std::endl << "      before returning." << std::endl;
         oomph_info << std::endl << std::endl << std::endl;
         return;
       }
  
       // Calculate initial residuals
       if (count == 1)
       {
         // Is the problem nonlinear? If not ignore the pre-iteration
         // convergence check.
         if (Problem_is_nonlinear)
         {
 #ifdef OOMPH_HAS_MPI
           // Synchronise the solution on different processors (on each submesh)
           this->synchronise_all_dofs();
 #endif
  
           actions_before_newton_convergence_check();
           dx.clear();
           get_residuals(dx);
  
           // Get half of squared residual and find maximum step length
           // for step length control
           if (Use_globally_convergent_newton_method)
           {
             half_residual_squared = 0.0;
             double sum = 0.0;
             for (unsigned i = 0; i < n_dofs; i++)
             {
               sum += (*Dof_pt[i]) * (*Dof_pt[i]);
               half_residual_squared += dx[i] * dx[i];
             }
             half_residual_squared *= 0.5;
             max_step = 100.0 * std::max(sqrt(sum), double(n_dofs));
           }
  
           // Get maximum residuals
           double maxres = dx.max();
           Max_res.push_back(maxres);
  
           if (!Shut_up_in_newton_solve)
           {
             // Let's output the residuals
             // unsigned n_row_local = dx.distribution_pt()->nrow_local();
             // unsigned first_row = dx.distribution_pt()->first_row();
             // for(unsigned n=0;n<n_row_local;n++)
             //{
             // oomph_info << "residual: " << n + first_row << " " << dx[n] <<
             // "\n";
             //}
  
             oomph_info << "\nInitial Maximum residuals " << maxres << std::endl;
           }
  
           if ((maxres < Newton_solver_tolerance) &&
               (!Always_take_one_newton_step))
           {
             LOOP_FLAG = 0;
             continue;
           }
         }
         else
         {
           if (!Shut_up_in_newton_solve)
           {
             oomph_info
               << "Linear problem -- convergence in one iteration assumed."
               << std::endl;
           }
         }
       }
  
  
       // Increment number of Newton iterations taken
       Nnewton_iter_taken++;
  
       // Initialise timer for linear solver
       double t_solver_start = TimingHelpers::timer();
  
       // Now do the linear solve -- recycling Jacobian if requested
       if (Jacobian_reuse_is_enabled && Jacobian_has_been_computed)
       {
         if (!Shut_up_in_newton_solve)
         {
           oomph_info << "Not recomputing Jacobian! " << std::endl;
         }
  
         // If we're doing the first iteration and the problem is nonlinear,
         // the residuals have already been computed above during the
         // initial convergence check. Otherwise compute them here.
         if ((count != 1) || (!Problem_is_nonlinear)) get_residuals(dx);
  
         // Backup residuals
         DoubleVector resid(dx);
  
         // Resolve
         Linear_solver_pt->resolve(resid, dx);
       }
       else
       {
         if (Jacobian_reuse_is_enabled)
         {
           if (!Shut_up_in_newton_solve)
           {
             oomph_info << "Enabling resolve" << std::endl;
           }
           Linear_solver_pt->enable_resolve();
         }
         Linear_solver_pt->solve(this, dx);
         Jacobian_has_been_computed = true;
       }
  
       // End of linear solver
       double t_solver_end = TimingHelpers::timer();
       total_linear_solver_time += t_solver_end - t_solver_start;
  
       if (!Shut_up_in_newton_solve)
       {
         oomph_info << std::endl;
         oomph_info << "Time for linear solver (ndof=" << n_dofs << "): "
                    << TimingHelpers::convert_secs_to_formatted_string(
                         t_solver_end - t_solver_start)
                    << std::endl
                    << std::endl;
       }
  
       // Subtract the new values from the true dofs
       dx.redistribute(Dof_distribution_pt);
       double* dx_pt = dx.values_pt();
       unsigned ndof_local = Dof_distribution_pt->nrow_local();
  
       if (Use_globally_convergent_newton_method)
       {
         // Get the gradient
         Linear_solver_pt->get_gradient(gradient);
  
         for (unsigned i = 0; i < ndof_local; i++)
         {
           dx_pt[i] *= -1.0;
         }
  
         // Update with steplength control
         Vector<double> unknowns_old(ndof_local);
  
         for (unsigned i = 0; i < ndof_local; i++)
         {
           unknowns_old[i] = *Dof_pt[i];
         }
  
         double half_residual_squared_old = half_residual_squared;
         globally_convergent_line_search(unknowns_old,
                                         half_residual_squared_old,
                                         gradient,
                                         dx,
                                         half_residual_squared,
                                         max_step);
       }
       // direct Newton update
       else
       {
         for (unsigned l = 0; l < ndof_local; l++)
         {
           *Dof_pt[l] -= Relaxation_factor * dx_pt[l];
         }
       }
 #ifdef OOMPH_HAS_MPI
       // Synchronise the solution on different processors (on each submesh)
       this->synchronise_all_dofs();
 #endif
  
       // Do any updates that are required
       actions_after_newton_step();
       actions_before_newton_convergence_check();
  
       // Maximum residuals
       double maxres = 0.0;
       // If the user has declared that the Problem is linear
       // we ignore the convergence check
       if (Problem_is_nonlinear)
       {
         // Get the maximum residuals
         // maxres = std::fabs(*std::max_element(dx.begin(),dx.end(),
         //                                    AbsCmp<double>()));
         // oomph_info << "Maxres correction " << maxres << "\n";
  
         // Calculate the new residuals
         dx.clear();
         get_residuals(dx);
  
         // Get the maximum residuals
         maxres = dx.max();
         Max_res.push_back(maxres);
  
         if (!Shut_up_in_newton_solve)
         {
           oomph_info << "Newton Step " << count << ": Maximum residuals "
                      << maxres << std::endl
                      << std::endl;
         }
       }
  
       // If we have converged jump straight to the test at the end of the loop
       if (maxres < Newton_solver_tolerance)
       {
         LOOP_FLAG = 0;
         continue;
       }
  
       // This section will not be reached if we have converged already
       // If the maximum number of residuals is too high or the maximum number
       // of iterations has been reached
       if ((maxres > Max_residuals) || (count == Max_newton_iterations))
       {
         // Print a warning -- regardless of what the throw does
         if (maxres > Max_residuals)
         {
           oomph_info << "Max. residual (" << Max_residuals
                      << ") has been exceeded in Newton solver." << std::endl;
         }
         if (count == Max_newton_iterations)
         {
           oomph_info << "Reached max. number of iterations ("
                      << Max_newton_iterations << ") in Newton solver."
                      << std::endl;
         }
         // Now throw...
         throw NewtonSolverError(count, maxres);
       }
  
     } while (LOOP_FLAG);
  
     // Now update anything that needs updating
     actions_after_newton_solve();
  
     // Finalise/doc timings
     if (!Shut_up_in_newton_solve)
     {
       oomph_info << std::endl;
       oomph_info << "Total time for linear solver (ndof=" << n_dofs << "): "
                  << TimingHelpers::convert_secs_to_formatted_string(
                       total_linear_solver_time)
                  << std::endl;
     }
  
     double t_end = TimingHelpers::timer();
     double total_time = t_end - t_start;
  
     if (!Shut_up_in_newton_solve)
     {
       oomph_info << "Total time for Newton solver (ndof=" << n_dofs << "): "
                  << TimingHelpers::convert_secs_to_formatted_string(total_time)
                  << std::endl;
     }
     if (total_time > 0.0)
     {
       if (!Shut_up_in_newton_solve)
       {
         oomph_info << "Time outside linear solver        : "
                    << (total_time - total_linear_solver_time) / total_time *
                         100.0
                    << " %" << std::endl;
       }
     }
     else
     {
       if (!Shut_up_in_newton_solve)
       {
         oomph_info << "Time outside linear solver        : "
                    << "[too fast]" << std::endl;
       }
     }
     if (!Shut_up_in_newton_solve) oomph_info << std::endl;
   }

References actions_after_newton_solve(), actions_after_newton_step(), actions_before_newton_convergence_check(), actions_before_newton_solve(), actions_before_newton_step(), Always_take_one_newton_step, oomph::DoubleVector::clear(), oomph::TimingHelpers::convert_secs_to_formatted_string(), Dof_distribution_pt, Dof_pt, oomph::LinearSolver::enable_computation_of_gradient(), oomph::LinearSolver::enable_resolve(), oomph::LinearSolver::get_gradient(), get_residuals(), globally_convergent_line_search(), i, Jacobian_has_been_computed, Jacobian_reuse_is_enabled, Linear_solver_pt, oomph::DoubleVector::max(), max, Max_newton_iterations, Max_res, Max_residuals, oomph::MPI_Helpers::mpi_has_been_initialised(), ndof(), Newton_solver_tolerance, Nnewton_iter_taken, oomph::LinearAlgebraDistribution::nrow_local(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::oomph_info, Problem_is_nonlinear, oomph::DoubleVector::redistribute(), Relaxation_factor, oomph::LinearSolver::reset_gradient(), oomph::LinearSolver::resolve(), Shut_up_in_newton_solve, oomph::LinearSolver::solve(), sqrt(), oomph::TimingHelpers::timer(), Use_globally_convergent_newton_method, and oomph::DoubleVector::values_pt().

Referenced by adaptive_unsteady_newton_solve(), main(), newton_solve(), oomph::NonLinearElasticitySmoothMesh< ELEMENT >::operator()(), oomph::LinearElasticitySmoothMesh< LINEAR_ELASTICITY_ELEMENT >::operator()(), oomph::PoissonSmoothMesh< POISSON_ELEMENT >::operator()(), PolarNSProblem< ELEMENT >::output_streamfunction(), parallel_test(), ElasticBeamProblem::parameter_study(), oomph::ProjectionProblem< PROJECTABLE_ELEMENT >::project(), oomph::SegregatableFSIProblem::segregated_solve(), oomph::SolidICProblem::set_newmark_initial_condition_consistently(), oomph::SolidICProblem::set_newmark_initial_condition_directly(), oomph::SolidICProblem::set_static_initial_condition(), steady_newton_solve(), unsteady_newton_solve(), and oomph::FpPressureAdvectionDiffusionProblem< ELEMENT >::validate().

◆ newton_solve() [2/2]

void Problem::newton_solve ( unsigned const & max_adapt )

Adaptive Newton solve: up to max_adapt adaptations of all refineable submeshes are performed to achieve the the error targets specified in the refineable submeshes.

Adaptive Newton solver. The linear solver takes a pointer to the problem (which defines the Jacobian J and the residual Vector r) and returns the solution x of the system

\[ {\bf J} {\bf x} = - \bf{r} \]

. Performs at most max_adapt adaptations on all meshes.

   {
     // Max number of solves
     unsigned max_solve = max_adapt + 1;
  
     // Adaptation loop
     //----------------
     for (unsigned isolve = 0; isolve < max_solve; isolve++)
     {
       // Only adapt after the first solve has been done!
       if (isolve > 0)
       {
         unsigned n_refined;
         unsigned n_unrefined;
  
         // Adapt problem
         adapt(n_refined, n_unrefined);
  
 #ifdef OOMPH_HAS_MPI
         // Adaptation only converges if ALL the processes have no
         // refinement or unrefinement to perform
         unsigned total_refined = 0;
         unsigned total_unrefined = 0;
         if (Problem_has_been_distributed)
         {
           MPI_Allreduce(&n_refined,
                         &total_refined,
                         1,
                         MPI_UNSIGNED,
                         MPI_SUM,
                         this->communicator_pt()->mpi_comm());
           n_refined = total_refined;
           MPI_Allreduce(&n_unrefined,
                         &total_unrefined,
                         1,
                         MPI_UNSIGNED,
                         MPI_SUM,
                         this->communicator_pt()->mpi_comm());
           n_unrefined = total_unrefined;
         }
 #endif
  
         oomph_info << "---> " << n_refined << " elements were refined, and "
                    << n_unrefined << " were unrefined"
 #ifdef OOMPH_HAS_MPI
                    << ", in total (over all processors).\n";
 #else
                    << ".\n";
 #endif
  
  
         // Check convergence of adaptation cycle
         if ((n_refined == 0) && (n_unrefined == 0))
         {
           oomph_info << "\n \n Solution is fully converged in "
                      << "Problem::newton_solver(). \n \n ";
           break;
         }
       }
  
  
       // Do actual solve
       //----------------
       {
         // Now update anything that needs updating
         // NOT NEEDED -- IS CALLED IN newton_solve BELOW! #
         // actions_before_newton_solve();
  
         try
         {
           // Solve the non-linear problem for this timestep with Newton's method
           newton_solve();
         }
         // Catch any exceptions thrown in the Newton solver
         catch (NewtonSolverError& error)
         {
           oomph_info << std::endl
                      << "USER-DEFINED ERROR IN NEWTON SOLVER " << std::endl;
           // Check to see whether we have reached Max_iterations
           if (error.iterations == Max_newton_iterations)
           {
             oomph_info << "MAXIMUM NUMBER OF ITERATIONS (" << error.iterations
                        << ") REACHED WITHOUT CONVERGENCE " << std::endl;
           }
           // If not, it must be that we have exceeded the maximum residuals
           else
           {
             oomph_info << "MAXIMUM RESIDUALS: " << error.maxres
                        << "EXCEEDS PREDEFINED MAXIMUM " << Max_residuals
                        << std::endl;
           }
  
           // Die horribly!!
           std::ostringstream error_stream;
           error_stream << "Error occured in adaptive Newton solver. "
                        << std::endl;
           throw OomphLibError(error_stream.str(),
                               OOMPH_CURRENT_FUNCTION,
                               OOMPH_EXCEPTION_LOCATION);
         }
  
         // Now update anything that needs updating
         // NOT NEEDED -- WAS CALLED IN newton_solve ABOVE
         // !actions_after_newton_solve();
  
       } // End of solve block
  
  
       if (isolve == max_solve - 1)
       {
         oomph_info
           << std::endl
           << "----------------------------------------------------------"
           << std::endl
           << "Reached max. number of adaptations in \n"
           << "Problem::newton_solver().\n"
           << "----------------------------------------------------------"
           << std::endl
           << std::endl;
       }
  
     } // End of adaptation loop
   }

References adapt(), communicator_pt(), calibrate::error, Max_newton_iterations, Max_residuals, newton_solve(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and oomph::oomph_info.

◆ newton_solve_continuation() [1/2]

unsigned Problem::newton_solve_continuation ( double *const & parameter_pt )

protected

Perform a basic arc-length continuation step using Newton's method. Returns number of Newton steps taken.

Perform a basic continuation step using Newton's method. The governing parameter of the problem is passed as a pointer to the routine. The number of Newton steps taken is returned

   {
     // Set up memory for z
     // unsigned long n_dofs = ndof();
     // LinearAlgebraDistribution dist(Communicator_pt,n_dofs,false);
     // DoubleVector z(&dist,0.0);
     DoubleVector z;
     // Call the solver
     return newton_solve_continuation(parameter_pt, z);
   }

Referenced by arc_length_step_solve_helper().

◆ newton_solve_continuation() [2/2]

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

protected

This function performs a basic continuation step using the Newton method. The number of Newton steps taken is returned, to be used in any external step-size control routines. The governing parameter of the problem is passed as a pointer to the routine, as is a vector in which to store the derivatives wrt the parameter, if required.

This function performs a basic continuation step using the Newton method. The number of Newton steps taken is returned, to be used in any external step-size control routines. The governing parameter of the problem is passed as a pointer to the routine, as is the sign of the Jacobian and a Vector in which to store the derivatives wrt the parameter, if required.

   {
     // Find the total number of dofs
     // unsigned long n_dofs = ndof();
  
     // Find the local number of dofs
     unsigned ndof_local = Dof_distribution_pt->nrow_local();
  
     // create the distribution (not distributed)
     // LinearAlgebraDistribution dist(this->communicator_pt(),n_dofs,false);
  
     // Assign memory for solutions of the equations
     // DoubleVector y(&dist,0.0);
     DoubleVector y;
  
     // Assign memory for the dot products of the uderivatives and y and z
     double uderiv_dot_y = 0.0, uderiv_dot_z = 0.0;
     // Set and initialise the counter
     unsigned count = 0;
     // Set the loop flag
     unsigned LOOP_FLAG = 1;
  
     // Update anything that needs updating
     actions_before_newton_solve();
  
     // Check the arc-length constraint
     double arc_length_constraint_residual = 0.0;
  
     // Are we storing the matrix in the linear solve
     bool enable_resolve = Linear_solver_pt->is_resolve_enabled();
  
     // For this problem, we must store the residuals
     Linear_solver_pt->enable_resolve();
  
     // Now do the Newton loop
     do
     {
       count++;
  
       // Do any updates that are required
       actions_before_newton_step();
  
       // Calculate initial residuals
       if (count == 1)
       {
 #ifdef OOMPH_HAS_MPI
         // Synchronise the solution on different processors (on each submesh)
         this->synchronise_all_dofs();
 #endif
  
         actions_before_newton_convergence_check();
         y.clear();
         get_residuals(y);
         // Get maximum residuals, using our own abscmp function
         double maxres = y.max();
  
         // Assemble the residuals for the arc-length step
         arc_length_constraint_residual = 0.0;
         // Add the variables
         for (unsigned long l = 0; l < ndof_local; l++)
         {
           arc_length_constraint_residual +=
             dof_derivative(l) * (*Dof_pt[l] - dof_current(l));
         }
  
         // Now reduce if we have been distributed
 #ifdef OOMPH_HAS_MPI
         double arc_length_cons_res2 = arc_length_constraint_residual;
         if ((Dof_distribution_pt->distributed()) &&
             (Dof_distribution_pt->communicator_pt()->nproc() > 1))
         {
           MPI_Allreduce(&arc_length_constraint_residual,
                         &arc_length_cons_res2,
                         1,
                         MPI_DOUBLE,
                         MPI_SUM,
                         Dof_distribution_pt->communicator_pt()->mpi_comm());
         }
         arc_length_constraint_residual = arc_length_cons_res2;
 #endif
  
         arc_length_constraint_residual *= Theta_squared;
         arc_length_constraint_residual +=
           Parameter_derivative * (*parameter_pt - Parameter_current) -
           Ds_current;
  
         // Is it the max
         if (std::fabs(arc_length_constraint_residual) > maxres)
         {
           maxres = std::fabs(arc_length_constraint_residual);
         }
  
         // Find the max
         if (!Shut_up_in_newton_solve)
         {
           oomph_info << "Initial Maximum residuals " << maxres << std::endl;
         }
  
         // If we are below the Tolerance, then return immediately
         if ((maxres < Newton_solver_tolerance) &&
             (!Always_take_one_newton_step))
         {
           LOOP_FLAG = 0;
           count = 0;
           continue;
         }
       }
  
       // If it's the block hopf solver we need to solve for both rhs's
       // simultaneously. This is because the block decomposition involves
       // solves with two different matrices and storing both at once to
       // allow general resolves would be more expensive than necessary.
       if (dynamic_cast<BlockHopfLinearSolver*>(Linear_solver_pt))
       {
         // Get the vector dresiduals/dparameter
         z.clear();
         get_derivative_wrt_global_parameter(parameter_pt, z);
  
         // Copy rhs vector into local storage so it doesn't get overwritten
         // if the linear solver decides to initialise the solution vector, say,
         // which it's quite entitled to do!
         DoubleVector input_z(z);
  
         // Solve the system for the two right-hand sides.
         dynamic_cast<BlockHopfLinearSolver*>(Linear_solver_pt)
           ->solve_for_two_rhs(this, y, input_z, z);
       }
       // Otherwise
       else
       {
         // Solve the standard problem
         Linear_solver_pt->solve(this, y);
  
         // Get the vector dresiduals/dparameter
         z.clear();
         get_derivative_wrt_global_parameter(parameter_pt, z);
  
         // Copy rhs vector into local storage so it doesn't get overwritten
         // if the linear solver decides to initialise the solution vector, say,
         // which it's quite entitled to do!
         DoubleVector input_z(z);
  
         // Redistribute the RHS to match the linear solver
         // input_z.redistribute(Linear_solver_pt->distribution_pt());
         // Do not clear z because we assume that it has dR/dparam
         z.clear();
         // Now resolve the system with the new RHS
         Linear_solver_pt->resolve(input_z, z);
       }
  
       // Redistribute the results into the natural distribution
       y.redistribute(Dof_distribution_pt);
       z.redistribute(Dof_distribution_pt);
  
       // Now we need to calculate dparam, for which we must calculate the
       // dot product of the derivatives and y and z
       // Reset these values to zero
       uderiv_dot_y = 0.0;
       uderiv_dot_z = 0.0;
       // Now calculate the dot products of the derivative and the solutions
       // of the linear system
       // Cache pointers to the data in the distributed vectors
       double* const y_pt = y.values_pt();
       double* const z_pt = z.values_pt();
       for (unsigned long l = 0; l < ndof_local; l++)
       {
         uderiv_dot_y += dof_derivative(l) * y_pt[l];
         uderiv_dot_z += dof_derivative(l) * z_pt[l];
       }
  
       // Now reduce if we have been distributed
 #ifdef OOMPH_HAS_MPI
       // Create send and receive arrays of size two
       double uderiv_dot[2];
       double uderiv_dot2[2];
       uderiv_dot[0] = uderiv_dot_y;
       uderiv_dot[1] = uderiv_dot_z;
       uderiv_dot2[0] = uderiv_dot_y;
       uderiv_dot2[1] = uderiv_dot_z;
       // Now reduce both together
       if ((Dof_distribution_pt->distributed()) &&
           (Dof_distribution_pt->communicator_pt()->nproc() > 1))
       {
         MPI_Allreduce(uderiv_dot,
                       uderiv_dot2,
                       2,
                       MPI_DOUBLE,
                       MPI_SUM,
                       Dof_distribution_pt->communicator_pt()->mpi_comm());
       }
       uderiv_dot_y = uderiv_dot2[0];
       uderiv_dot_z = uderiv_dot2[1];
 #endif
  
       // Now scale the results
       uderiv_dot_y *= Theta_squared;
       uderiv_dot_z *= Theta_squared;
  
       // The set the change in the parameter, given by the pseudo-arclength
       // equation. Note that here we are assuming that the arc-length
       // equation is always exactly zero,
       // which seems to work OK, and saves on some storage.
       // In fact, it's more subtle than that. If we include this
       // proper residual then we will have to solve the eigenproblem.
       // This will make the solver more robust and *should* be done
       // ... at some point.
       double dparam = (arc_length_constraint_residual - uderiv_dot_y) /
                       (Parameter_derivative - uderiv_dot_z);
  
       // Set the new value of the parameter
       *parameter_pt -= dparam;
  
       // Update the values of the other degrees of freedom
       for (unsigned long l = 0; l < ndof_local; l++)
       {
         *Dof_pt[l] -= y_pt[l] - dparam * z_pt[l];
       }
  
       // Calculate the new residuals
 #ifdef OOMPH_HAS_MPI
       // Synchronise the solution on different processors (on each submesh)
       this->synchronise_all_dofs();
 #endif
  
       // Do any updates that are required
       actions_after_newton_step();
       actions_before_newton_convergence_check();
  
       y.clear();
       get_residuals(y);
  
       // Get the maximum residuals
       double maxres = y.max();
  
       // Assemble the residuals for the arc-length step
       arc_length_constraint_residual = 0.0;
       // Add the variables
       for (unsigned long l = 0; l < ndof_local; l++)
       {
         arc_length_constraint_residual +=
           dof_derivative(l) * (*Dof_pt[l] - dof_current(l));
       }
  
       // Now reduce if we have been distributed
 #ifdef OOMPH_HAS_MPI
       double arc_length_cons_res2 = arc_length_constraint_residual;
       if ((Dof_distribution_pt->distributed()) &&
           (Dof_distribution_pt->communicator_pt()->nproc() > 1))
       {
         MPI_Allreduce(&arc_length_constraint_residual,
                       &arc_length_cons_res2,
                       1,
                       MPI_DOUBLE,
                       MPI_SUM,
                       Dof_distribution_pt->communicator_pt()->mpi_comm());
       }
       arc_length_constraint_residual = arc_length_cons_res2;
 #endif
  
       arc_length_constraint_residual *= Theta_squared;
       arc_length_constraint_residual +=
         Parameter_derivative * (*parameter_pt - Parameter_current) - Ds_current;
  
       // Is it the max
       if (std::fabs(arc_length_constraint_residual) > maxres)
       {
         maxres = std::fabs(arc_length_constraint_residual);
       }
  
       if (!Shut_up_in_newton_solve)
       {
         oomph_info << "Continuation Step " << count << ":  Maximum residuals "
                    << maxres << "\n";
       }
  
       // If we have converged jump straight to the test at the end of the loop
       if (maxres < Newton_solver_tolerance)
       {
         LOOP_FLAG = 0;
         continue;
       }
  
       // This section will not be reached if we have converged already
       // If the maximum number of residuals is too high or the maximum number
       // of iterations has been reached
       if ((maxres > Max_residuals) || (count == Max_newton_iterations))
       {
         throw NewtonSolverError(count, maxres);
       }
  
     } while (LOOP_FLAG);
  
     // Now update anything that needs updating
     actions_after_newton_solve();
  
     // Reset the storage of the matrix on the linear solver to what it was
     // on entry to this routine
     if (enable_resolve)
     {
       Linear_solver_pt->enable_resolve();
     }
     else
     {
       Linear_solver_pt->disable_resolve();
     }
  
     // Return the number of Newton Steps taken
     return count;
   }

References actions_after_newton_solve(), actions_after_newton_step(), actions_before_newton_convergence_check(), actions_before_newton_solve(), actions_before_newton_step(), Always_take_one_newton_step, oomph::DoubleVector::clear(), oomph::LinearAlgebraDistribution::communicator_pt(), oomph::LinearSolver::disable_resolve(), oomph::LinearAlgebraDistribution::distributed(), dof_current(), dof_derivative(), Dof_distribution_pt, Dof_pt, Ds_current, oomph::LinearSolver::enable_resolve(), boost::multiprecision::fabs(), get_derivative_wrt_global_parameter(), get_residuals(), oomph::LinearSolver::is_resolve_enabled(), Linear_solver_pt, Max_newton_iterations, Max_residuals, Newton_solver_tolerance, oomph::OomphCommunicator::nproc(), oomph::LinearAlgebraDistribution::nrow_local(), oomph::oomph_info, Parameter_current, Parameter_derivative, oomph::DoubleVector::redistribute(), oomph::LinearSolver::resolve(), Shut_up_in_newton_solve, oomph::LinearSolver::solve(), Theta_squared, oomph::DoubleVector::values_pt(), and y.

◆ newton_solver_tolerance()

double& oomph::Problem::newton_solver_tolerance ( )

inline

Access function to tolererance of the Newton solver, i.e. the maximum value of the residuals that will be accepted.

     {
       return Newton_solver_tolerance;
     }

References Newton_solver_tolerance.

◆ nglobal_data()

unsigned oomph::Problem::nglobal_data ( ) const

inline

Return the number of global data values.

     {
       return Global_data_pt.size();
     }

References Global_data_pt.

Referenced by oomph::IMRByBDF::actions_after_timestep(), oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::adapt_temporal_mesh(), assign_eqn_numbers(), copy(), describe_dofs(), get_dofs(), set_dofs(), and set_pinned_values_to_zero().

◆ nsub_mesh()

unsigned oomph::Problem::nsub_mesh ( ) const

inline

Return number of submeshes.

     {
       return Sub_mesh_pt.size();
     }

References Sub_mesh_pt.

Referenced by adapt(), adapt_based_on_error_estimates(), oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::adapt_temporal_mesh(), assign_eqn_numbers(), copy(), delete_all_external_storage(), describe_dofs(), doc_errors(), does_pointer_correspond_to_problem_data(), dump(), get_all_error_estimates(), oomph::NavierStokesSchurComplementPreconditioner::get_pressure_advection_diffusion_matrix(), p_adapt(), p_refine_selected_elements(), p_refine_uniformly(), p_refine_uniformly_and_prune(), p_refine_uniformly_aux(), p_unrefine_uniformly(), oomph::METIS::partition_mesh(), read(), refine_selected_elements(), refine_uniformly(), refine_uniformly_and_prune(), refine_uniformly_aux(), self_test(), set_consistent_pinned_values_for_continuation(), set_timestepper_for_all_data(), oomph::SegregatableFSIProblem::setup_segregated_solver(), and unrefine_uniformly().

◆ ntime_stepper()

unsigned oomph::Problem::ntime_stepper ( ) const

inline

Return the number of time steppers.

     {
       return Time_stepper_pt.size();
     }

References Time_stepper_pt.

Referenced by oomph::IMRByBDF::actions_before_timestep(), adaptive_unsteady_newton_solve(), arc_length_step_solve(), arc_length_step_solve_helper(), copy(), get_dvaluesdt(), initialise_dt(), solve_eigenproblem(), steady_newton_solve(), oomph::SegregatableFSIProblem::steady_segregated_solve(), unsteady_newton_solve(), and oomph::SegregatableFSIProblem::unsteady_segregated_solve().

◆ operator=()

void oomph::Problem::operator= ( const Problem & )

delete

Broken assignment operator.

◆ p_adapt() [1/2]

void oomph::Problem::p_adapt ( )

inline

p-adapt problem: Perform mesh adaptation for (all) refineable (sub)mesh(es), based on their own error estimates and the target errors specified in the mesh(es). Following mesh adaptation, update global mesh, and re-assign equation numbers. On return from this function, Problem can immediately be solved again. [Argument-free wrapper]

     {
       unsigned n_refined, n_unrefined;
       p_adapt(n_refined, n_unrefined);
     }

◆ p_adapt() [2/2]

void Problem::p_adapt	(	unsigned &	n_refined,
		unsigned &	n_unrefined
	)

p-adapt problem: Perform mesh adaptation for (all) refineable (sub)mesh(es), based on their own error estimates and the target errors specified in the mesh(es). Following mesh adaptation, update global mesh, and re-assign equation numbers. Return # of refined/unrefined elements. On return from this function, Problem can immediately be solved again.

   {
     double t_start_total = 0.0;
     if (Global_timings::Doc_comprehensive_timings)
     {
       t_start_total = TimingHelpers::timer();
     }
  
     // Get the bifurcation type
     int bifurcation_type = this->Assembly_handler_pt->bifurcation_type();
  
     // If we are tracking a bifurcation then call the bifurcation adapt function
     if (bifurcation_type != 0)
     {
       this->bifurcation_adapt_helper(n_refined, n_unrefined, bifurcation_type);
       // Return immediately
       return;
     }
  
     oomph_info << std::endl << std::endl;
     oomph_info << "p-adapting problem:" << std::endl;
     oomph_info << "===================" << std::endl;
  
     double t_start = 0.0;
     if (Global_timings::Doc_comprehensive_timings)
     {
       t_start = TimingHelpers::timer();
     }
  
     // Call the actions before adaptation
     actions_before_adapt();
  
     double t_end = 0.0;
     if (Global_timings::Doc_comprehensive_timings)
     {
       t_end = TimingHelpers::timer();
       oomph_info << "Time for actions before adapt: " << t_end - t_start
                  << std::endl;
       t_start = TimingHelpers::timer();
     }
  
     // Initialise counters
     n_refined = 0;
     n_unrefined = 0;
  
     // Number of submeshes?
     unsigned Nmesh = nsub_mesh();
  
     // Single mesh:
     //------------
     if (Nmesh == 0)
     {
       // Refine single mesh if possible
       if (RefineableMeshBase* mmesh_pt =
             dynamic_cast<RefineableMeshBase*>(mesh_pt(0)))
       {
         if (mmesh_pt->is_p_adaptation_enabled())
         {
           double t_start = TimingHelpers::timer();
  
           // Get pointer to error estimator
           ErrorEstimator* error_estimator_pt =
             mmesh_pt->spatial_error_estimator_pt();
  
 #ifdef PARANOID
           if (error_estimator_pt == 0)
           {
             throw OomphLibError("Error estimator hasn't been set yet",
                                 OOMPH_CURRENT_FUNCTION,
                                 OOMPH_EXCEPTION_LOCATION);
           }
 #endif
  
           // Get error for all elements
           Vector<double> elemental_error(mmesh_pt->nelement());
  
           if (mmesh_pt->doc_info_pt() == 0)
           {
             error_estimator_pt->get_element_errors(mesh_pt(0), elemental_error);
           }
           else
           {
             error_estimator_pt->get_element_errors(
               mesh_pt(0), elemental_error, *mmesh_pt->doc_info_pt());
           }
  
           // Store max./min actual error
           mmesh_pt->max_error() = std::fabs(*std::max_element(
             elemental_error.begin(), elemental_error.end(), AbsCmp<double>()));
  
           mmesh_pt->min_error() = std::fabs(*std::min_element(
             elemental_error.begin(), elemental_error.end(), AbsCmp<double>()));
  
           oomph_info << "\n Max/min error: " << mmesh_pt->max_error() << " "
                      << mmesh_pt->min_error() << std::endl
                      << std::endl;
  
  
           if (Global_timings::Doc_comprehensive_timings)
           {
             t_end = TimingHelpers::timer();
             oomph_info << "Time for error estimation: " << t_end - t_start
                        << std::endl;
             t_start = TimingHelpers::timer();
           }
  
           // Adapt mesh
           mmesh_pt->p_adapt(elemental_error);
  
           // Add to counters
           n_refined += mmesh_pt->nrefined();
           n_unrefined += mmesh_pt->nunrefined();
  
           if (Global_timings::Doc_comprehensive_timings)
           {
             t_end = TimingHelpers::timer();
             oomph_info << "Time for complete mesh adaptation "
                        << "(but excluding comp of error estimate): "
                        << t_end - t_start << std::endl;
             t_start = TimingHelpers::timer();
           }
         }
         else
         {
           oomph_info << "Info/Warning: Mesh adaptation is disabled."
                      << std::endl;
         }
       }
       else
       {
         oomph_info << "Info/Warning: Mesh cannot be adapted" << std::endl;
       }
     }
     // Multiple submeshes
     //------------------
     else
     {
       // Loop over submeshes
       for (unsigned imesh = 0; imesh < Nmesh; imesh++)
       {
         // Refine single mesh uniformly if possible
         if (RefineableMeshBase* mmesh_pt =
               dynamic_cast<RefineableMeshBase*>(mesh_pt(imesh)))
         {
           double t_start = TimingHelpers::timer();
  
           // Get pointer to error estimator
           ErrorEstimator* error_estimator_pt =
             mmesh_pt->spatial_error_estimator_pt();
  
 #ifdef PARANOID
           if (error_estimator_pt == 0)
           {
             throw OomphLibError("Error estimator hasn't been set yet",
                                 OOMPH_CURRENT_FUNCTION,
                                 OOMPH_EXCEPTION_LOCATION);
           }
 #endif
  
           if (mmesh_pt->is_p_adaptation_enabled())
           {
             // Get error for all elements
             Vector<double> elemental_error(mmesh_pt->nelement());
             if (mmesh_pt->doc_info_pt() == 0)
             {
               error_estimator_pt->get_element_errors(mesh_pt(imesh),
                                                      elemental_error);
             }
             else
             {
               error_estimator_pt->get_element_errors(
                 mesh_pt(imesh), elemental_error, *mmesh_pt->doc_info_pt());
             }
  
             // Store max./min error if the mesh has any elements
             if (mesh_pt(imesh)->nelement() > 0)
             {
               mmesh_pt->max_error() =
                 std::fabs(*std::max_element(elemental_error.begin(),
                                             elemental_error.end(),
                                             AbsCmp<double>()));
  
               mmesh_pt->min_error() =
                 std::fabs(*std::min_element(elemental_error.begin(),
                                             elemental_error.end(),
                                             AbsCmp<double>()));
             }
  
             oomph_info << "\n Max/min error: " << mmesh_pt->max_error() << " "
                        << mmesh_pt->min_error() << std::endl;
  
  
             if (Global_timings::Doc_comprehensive_timings)
             {
               t_end = TimingHelpers::timer();
               oomph_info << "Time for error estimation: " << t_end - t_start
                          << std::endl;
               t_start = TimingHelpers::timer();
             }
  
             // Adapt mesh
             mmesh_pt->p_adapt(elemental_error);
  
             // Add to counters
             n_refined += mmesh_pt->nrefined();
             n_unrefined += mmesh_pt->nunrefined();
  
  
             if (Global_timings::Doc_comprehensive_timings)
             {
               t_end = TimingHelpers::timer();
               oomph_info << "Time for complete mesh adaptation "
                          << "(but excluding comp of error estimate): "
                          << t_end - t_start << std::endl;
               t_start = TimingHelpers::timer();
             }
           }
           else
           {
             oomph_info << "Info/Warning: Mesh adaptation is disabled."
                        << std::endl;
           }
         }
         else
         {
           oomph_info << "Info/Warning: Mesh cannot be adapted." << std::endl;
         }
  
       } // End of loop over submeshes
  
       // Rebuild the global mesh
       rebuild_global_mesh();
     }
  
  
     if (Global_timings::Doc_comprehensive_timings)
     {
       t_end = TimingHelpers::timer();
       oomph_info << "Total time for actual adaptation "
                  << "(all meshes; incl error estimates): " << t_end - t_start
                  << std::endl;
       t_start = TimingHelpers::timer();
     }
  
     // Any actions after adapt
     actions_after_adapt();
  
  
     if (Global_timings::Doc_comprehensive_timings)
     {
       t_end = TimingHelpers::timer();
       oomph_info << "Time for actions after adapt: " << t_end - t_start
                  << std::endl;
       t_start = TimingHelpers::timer();
  
       oomph_info << "About to start re-assigning eqn numbers "
                  << "with Problem::assign_eqn_numbers() at end of "
                  << "Problem::adapt().\n";
     }
  
     // Attach the boundary conditions to the mesh
     oomph_info << "\nNumber of equations: " << assign_eqn_numbers() << std::endl
                << std::endl;
  
  
     if (Global_timings::Doc_comprehensive_timings)
     {
       t_end = TimingHelpers::timer();
       oomph_info << "Time for re-assigning eqn numbers with "
                  << "Problem::assign_eqn_numbers() at end of Problem::adapt(): "
                  << t_end - t_start << std::endl;
       oomph_info << "Total time for adapt: " << t_end - t_start_total
                  << std::endl;
     }
   }

References actions_after_adapt(), actions_before_adapt(), Assembly_handler_pt, assign_eqn_numbers(), bifurcation_adapt_helper(), oomph::AssemblyHandler::bifurcation_type(), oomph::Global_timings::Doc_comprehensive_timings, MeshRefinement::error_estimator_pt, boost::multiprecision::fabs(), mesh_pt(), nsub_mesh(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::oomph_info, rebuild_global_mesh(), and oomph::TimingHelpers::timer().

Referenced by main().

◆ p_refine_selected_elements() [1/6]

void Problem::p_refine_selected_elements	(	const unsigned &	i_mesh,
		const Vector< PRefineableElement * > &	elements_to_be_refined_pt
	)

p-refine specified submesh by refining the elements identified by their pointers, then rebuild the problem.

   {
     OomphLibWarning(
       "p-refinement for multiple submeshes has not yet been tested.",
       "Problem::p_refine_selected_elements()",
       OOMPH_EXCEPTION_LOCATION);
  
     actions_before_adapt();
  
     // Number of submeshes?
     unsigned n_mesh = nsub_mesh();
  
     if (i_mesh >= n_mesh)
     {
       std::ostringstream error_message;
       error_message << "Problem only has " << n_mesh
                     << " submeshes. Cannot p-refine submesh " << i_mesh
                     << std::endl;
       throw OomphLibError(
         error_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
  
     // Refine single mesh if possible
     if (TreeBasedRefineableMeshBase* mmesh_pt =
           dynamic_cast<TreeBasedRefineableMeshBase*>(mesh_pt(i_mesh)))
     {
       mmesh_pt->p_refine_selected_elements(elements_to_be_refined_pt);
     }
     else
     {
       oomph_info << "Info/Warning: Mesh cannot be refined " << std::endl;
     }
  
     if (n_mesh > 1)
     {
       // Rebuild the global mesh
       rebuild_global_mesh();
     }
  
     // Any actions after the adapatation phase
     actions_after_adapt();
  
     // Do equation numbering
     oomph_info << "Number of equations: " << assign_eqn_numbers() << std::endl;
   }

References actions_after_adapt(), actions_before_adapt(), assign_eqn_numbers(), mesh_pt(), nsub_mesh(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::oomph_info, and rebuild_global_mesh().

◆ p_refine_selected_elements() [2/6]

void Problem::p_refine_selected_elements	(	const unsigned &	i_mesh,
		const Vector< unsigned > &	elements_to_be_refined
	)

p-refine specified submesh by refining the elements identified by their numbers relative to the submesh, then rebuild the problem.

p-refine specified submesh by refining the elements identified by their numbers relative to the specified mesh, then rebuild the problem.

   {
     OomphLibWarning(
       "p-refinement for multiple submeshes has not yet been tested.",
       "Problem::p_refine_selected_elements()",
       OOMPH_EXCEPTION_LOCATION);
  
     actions_before_adapt();
  
     // Number of submeshes?
     unsigned n_mesh = nsub_mesh();
  
     if (i_mesh >= n_mesh)
     {
       std::ostringstream error_message;
       error_message << "Problem only has " << n_mesh
                     << " submeshes. Cannot p-refine submesh " << i_mesh
                     << std::endl;
       throw OomphLibError(
         error_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
  
     // Refine single mesh if possible
     if (TreeBasedRefineableMeshBase* mmesh_pt =
           dynamic_cast<TreeBasedRefineableMeshBase*>(mesh_pt(i_mesh)))
     {
       mmesh_pt->p_refine_selected_elements(elements_to_be_refined);
     }
     else
     {
       oomph_info << "Info/Warning: Mesh cannot be refined " << std::endl;
     }
  
     if (n_mesh > 1)
     {
       // Rebuild the global mesh
       rebuild_global_mesh();
     }
  
     // Any actions after the adapatation phase
     actions_after_adapt();
  
     // Do equation numbering
     oomph_info << "Number of equations: " << assign_eqn_numbers() << std::endl;
   }

References actions_after_adapt(), actions_before_adapt(), assign_eqn_numbers(), mesh_pt(), nsub_mesh(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::oomph_info, and rebuild_global_mesh().

◆ p_refine_selected_elements() [3/6]

void Problem::p_refine_selected_elements ( const Vector< PRefineableElement * > & elements_to_be_refined_pt )

p-refine (one and only!) mesh by refining the elements identified by their pointers, then rebuild the problem.

   {
     actions_before_adapt();
  
     // Number of submeshes?
     unsigned Nmesh = nsub_mesh();
  
     // Single mesh:
     if (Nmesh == 0)
     {
       // Refine single mesh if possible
       if (TreeBasedRefineableMeshBase* mmesh_pt =
             dynamic_cast<TreeBasedRefineableMeshBase*>(mesh_pt(0)))
       {
         mmesh_pt->p_refine_selected_elements(elements_to_be_refined_pt);
       }
       else
       {
         oomph_info << "Info/Warning: Mesh cannot be refined " << std::endl;
       }
     }
     // Multiple submeshes
     else
     {
       std::ostringstream error_message;
       error_message
         << "Problem::p_refine_selected_elements(...) only works for\n"
         << "multiple-mesh problems if you specify the mesh\n"
         << "number in the function argument before the Vector,\n"
         << "or a Vector of Vectors for each submesh.\n"
         << std::endl;
       throw OomphLibError(
         error_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
  
     // Any actions after the adapatation phase
     actions_after_adapt();
  
     // Do equation numbering
     oomph_info << "Number of equations: " << assign_eqn_numbers() << std::endl;
   }

References actions_after_adapt(), actions_before_adapt(), assign_eqn_numbers(), mesh_pt(), nsub_mesh(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and oomph::oomph_info.

◆ p_refine_selected_elements() [4/6]

void Problem::p_refine_selected_elements ( const Vector< unsigned > & elements_to_be_refined )

p-refine (one and only!) mesh by refining the elements identified by their numbers relative to the problems' only mesh, then rebuild the problem.

   {
     actions_before_adapt();
  
     // Number of submeshes?
     unsigned Nmesh = nsub_mesh();
  
     // Single mesh:
     if (Nmesh == 0)
     {
       // Refine single mesh if possible
       if (TreeBasedRefineableMeshBase* mmesh_pt =
             dynamic_cast<TreeBasedRefineableMeshBase*>(mesh_pt(0)))
       {
         mmesh_pt->p_refine_selected_elements(elements_to_be_refined);
       }
       else
       {
         oomph_info << "Info/Warning: Mesh cannot be refined " << std::endl;
       }
     }
     // Multiple submeshes
     else
     {
       std::ostringstream error_message;
       error_message
         << "Problem::p_refine_selected_elements(...) only works for\n"
         << "multiple-mesh problems if you specify the mesh\n"
         << "number in the function argument before the Vector,\n"
         << "or a Vector of Vectors for each submesh.\n"
         << std::endl;
       throw OomphLibError(
         error_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
  
     // Any actions after the adapatation phase
     actions_after_adapt();
  
     // Attach the boundary conditions to the mesh
     oomph_info << "Number of equations: " << assign_eqn_numbers() << std::endl;
   }

References actions_after_adapt(), actions_before_adapt(), assign_eqn_numbers(), mesh_pt(), nsub_mesh(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and oomph::oomph_info.

◆ p_refine_selected_elements() [5/6]

void Problem::p_refine_selected_elements ( const Vector< Vector< PRefineableElement * >> & elements_to_be_refined_pt )

p-refine all submeshes by refining the elements identified by their pointers within each submesh in a Vector of Vectors, then rebuild the problem.

   {
     OomphLibWarning(
       "p-refinement for multiple submeshes has not yet been tested.",
       "Problem::p_refine_selected_elements()",
       OOMPH_EXCEPTION_LOCATION);
  
     actions_before_adapt();
  
     // Number of submeshes?
     unsigned n_mesh = nsub_mesh();
  
     // Refine all submeshes if possible
     for (unsigned i_mesh = 0; i_mesh < n_mesh; i_mesh++)
     {
       if (TreeBasedRefineableMeshBase* mmesh_pt =
             dynamic_cast<TreeBasedRefineableMeshBase*>(mesh_pt(i_mesh)))
       {
         mmesh_pt->p_refine_selected_elements(elements_to_be_refined_pt[i_mesh]);
       }
       else
       {
         oomph_info << "Info/Warning: Mesh cannot be refined " << std::endl;
       }
     }
  
     // Rebuild the global mesh
     rebuild_global_mesh();
  
     // Any actions after the adapatation phase
     actions_after_adapt();
  
     // Do equation numbering
     oomph_info << "Number of equations: " << assign_eqn_numbers() << std::endl;
   }

References actions_after_adapt(), actions_before_adapt(), assign_eqn_numbers(), mesh_pt(), nsub_mesh(), OOMPH_EXCEPTION_LOCATION, oomph::oomph_info, and rebuild_global_mesh().

◆ p_refine_selected_elements() [6/6]

void Problem::p_refine_selected_elements ( const Vector< Vector< unsigned >> & elements_to_be_refined )

p-refine all submeshes by refining the elements identified by their numbers relative to each submesh in a Vector of Vectors, then rebuild the problem.

   {
     OomphLibWarning(
       "p-refinement for multiple submeshes has not yet been tested.",
       "Problem::p_refine_selected_elements()",
       OOMPH_EXCEPTION_LOCATION);
  
     actions_before_adapt();
  
     // Number of submeshes?
     unsigned n_mesh = nsub_mesh();
  
     // Refine all submeshes if possible
     for (unsigned i_mesh = 0; i_mesh < n_mesh; i_mesh++)
     {
       if (TreeBasedRefineableMeshBase* mmesh_pt =
             dynamic_cast<TreeBasedRefineableMeshBase*>(mesh_pt(i_mesh)))
       {
         mmesh_pt->p_refine_selected_elements(elements_to_be_refined[i_mesh]);
       }
       else
       {
         oomph_info << "Info/Warning: Mesh cannot be refined " << std::endl;
       }
     }
  
     // Rebuild the global mesh
     rebuild_global_mesh();
  
     // Any actions after the adapatation phase
     actions_after_adapt();
  
     // Do equation numbering
     oomph_info << "Number of equations: " << assign_eqn_numbers() << std::endl;
   }

References actions_after_adapt(), actions_before_adapt(), assign_eqn_numbers(), mesh_pt(), nsub_mesh(), OOMPH_EXCEPTION_LOCATION, oomph::oomph_info, and rebuild_global_mesh().

◆ p_refine_uniformly() [1/6]

void oomph::Problem::p_refine_uniformly ( )

inline

p-refine (all) p-refineable (sub)mesh(es) uniformly and rebuild problem

     {
       DocInfo doc_info;
       doc_info.disable_doc();
       p_refine_uniformly(doc_info);
     }

References oomph::DocInfo::disable_doc().

Referenced by p_refine_uniformly().

◆ p_refine_uniformly() [2/6]

void oomph::Problem::p_refine_uniformly ( const unsigned & i_mesh )

inline

Do uniform p-refinement for submesh i_mesh without documentation.

     {
       DocInfo doc_info;
       doc_info.disable_doc();
       p_refine_uniformly(i_mesh, doc_info);
     }

References oomph::DocInfo::disable_doc(), and p_refine_uniformly().

◆ p_refine_uniformly() [3/6]

void Problem::p_refine_uniformly	(	const unsigned &	i_mesh,
		DocInfo &	doc_info
	)

Do uniform p-refinement for submesh i_mesh with documentation.

p-refine submesh i_mesh uniformly and rebuild problem; doc refinement process.

   {
     actions_before_adapt();
  
 #ifdef PARANOID
     // Number of submeshes?
     if (i_mesh >= nsub_mesh())
     {
       std::ostringstream error_message;
       error_message << "imesh " << i_mesh
                     << " is greater than the number of sub meshes "
                     << nsub_mesh() << std::endl;
  
       throw OomphLibError(
         error_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
 #endif
  
     // Refine single mesh uniformly if possible
     if (RefineableMeshBase* mmesh_pt =
           dynamic_cast<RefineableMeshBase*>(mesh_pt(i_mesh)))
     {
       mmesh_pt->p_refine_uniformly(doc_info);
     }
     else
     {
       oomph_info << "Info/Warning: Mesh cannot be refined uniformly "
                  << std::endl;
     }
  
     // Rebuild the global mesh
     rebuild_global_mesh();
  
     // Any actions after the adaptation phase
     actions_after_adapt();
  
     // Do equation numbering
     oomph_info << "Number of equations: " << assign_eqn_numbers() << std::endl;
   }

References actions_after_adapt(), actions_before_adapt(), assign_eqn_numbers(), mesh_pt(), nsub_mesh(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::oomph_info, and rebuild_global_mesh().

◆ p_refine_uniformly() [4/6]

void oomph::Problem::p_refine_uniformly ( const Vector< unsigned > & nrefine_for_mesh )

inline

p-refine p-refineable sub-meshes, each as many times as specified in the vector and rebuild problem

     {
       DocInfo doc_info;
       doc_info.disable_doc();
       bool prune = false;
       p_refine_uniformly_aux(nrefine_for_mesh, doc_info, prune);
     }

References oomph::DocInfo::disable_doc(), and p_refine_uniformly_aux().

Referenced by main().

◆ p_refine_uniformly() [5/6]

void oomph::Problem::p_refine_uniformly	(	const Vector< unsigned > &	nrefine_for_mesh,
		DocInfo &	doc_info
	)

inline

p-refine p-refineable sub-meshes, each as many times as specified in the vector and rebuild problem; doc refinement process

     {
       bool prune = false;
       p_refine_uniformly_aux(nrefine_for_mesh, doc_info, prune);
     }

References p_refine_uniformly_aux().

◆ p_refine_uniformly() [6/6]

void oomph::Problem::p_refine_uniformly ( DocInfo & doc_info )

inline

p-refine (all) p-refineable (sub)mesh(es) uniformly and rebuild problem; doc refinement process.

     {
       // Number of (sub)meshes
       unsigned nmesh = std::max(unsigned(1), nsub_mesh());
  
       // Refine each mesh once
       Vector<unsigned> nrefine_for_mesh(nmesh, 1);
       p_refine_uniformly(nrefine_for_mesh);
     }

References max, nsub_mesh(), and p_refine_uniformly().

◆ p_refine_uniformly_and_prune() [1/3]

void oomph::Problem::p_refine_uniformly_and_prune ( const Vector< unsigned > & nrefine_for_mesh )

inline

p-refine p-refineable sub-meshes, each as many times as specified in the vector and rebuild problem. Prune after refinements

     {
       // Not tested:
       throw OomphLibWarning("This functionality has not yet been tested.",
                             "Problem::p_refine_uniformly_and_prune()",
                             OOMPH_EXCEPTION_LOCATION);
       DocInfo doc_info;
       doc_info.disable_doc();
       bool prune = true;
       p_refine_uniformly_aux(nrefine_for_mesh, doc_info, prune);
     }

References oomph::DocInfo::disable_doc(), OOMPH_EXCEPTION_LOCATION, and p_refine_uniformly_aux().

Referenced by p_refine_uniformly_and_prune().

◆ p_refine_uniformly_and_prune() [2/3]

void oomph::Problem::p_refine_uniformly_and_prune	(	const Vector< unsigned > &	nrefine_for_mesh,
		DocInfo &	doc_info
	)

inline

p-refine p-refineable sub-meshes, each as many times as specified in the vector and rebuild problem; doc refinement process

     {
       // Not tested:
       throw OomphLibWarning("This functionality has not yet been tested.",
                             "Problem::p_refine_uniformly_and_prune()",
                             OOMPH_EXCEPTION_LOCATION);
       bool prune = true;
       p_refine_uniformly_aux(nrefine_for_mesh, doc_info, prune);
     }

References OOMPH_EXCEPTION_LOCATION, and p_refine_uniformly_aux().

◆ p_refine_uniformly_and_prune() [3/3]

void oomph::Problem::p_refine_uniformly_and_prune ( DocInfo & doc_info )

inline

p-refine (all) p-refineable (sub)mesh(es) uniformly and rebuild problem; doc refinement process.

     {
       // Not tested:
       throw OomphLibWarning("This functionality has not yet been tested.",
                             "Problem::p_refine_uniformly_and_prune()",
                             OOMPH_EXCEPTION_LOCATION);
       // Number of (sub)meshes
       unsigned nmesh = std::max(unsigned(1), nsub_mesh());
  
       // Refine each mesh once
       Vector<unsigned> nrefine_for_mesh(nmesh, 1);
       p_refine_uniformly_and_prune(nrefine_for_mesh);
     }

References max, nsub_mesh(), OOMPH_EXCEPTION_LOCATION, and p_refine_uniformly_and_prune().

◆ p_refine_uniformly_aux()

void Problem::p_refine_uniformly_aux	(	const Vector< unsigned > &	nrefine_for_mesh,
		DocInfo &	doc_info,
		const bool &	prune
	)

private

Helper function to do compund p-refinement of (all) p-refineable (sub)mesh(es) uniformly as many times as specified in vector and rebuild problem; doc refinement process. Set boolean argument to true if you want to prune immediately after refining the meshes individually.

   {
     double t_start = 0.0;
     if (Global_timings::Doc_comprehensive_timings)
     {
       t_start = TimingHelpers::timer();
     }
  
     actions_before_adapt();
  
     double t_end = 0.0;
     if (Global_timings::Doc_comprehensive_timings)
     {
       t_end = TimingHelpers::timer();
       oomph_info << "Time for actions before adapt in "
                     "Problem::p_refine_uniformly_aux(): "
                  << t_end - t_start << std::endl;
       t_start = TimingHelpers::timer();
     }
  
     // Number of submeshes?
     unsigned n_mesh = nsub_mesh();
  
     // Single mesh:
     if (n_mesh == 0)
     {
       // Refine single mesh uniformly if possible
       if (RefineableMeshBase* mmesh_pt =
             dynamic_cast<RefineableMeshBase*>(mesh_pt(0)))
       {
         unsigned nref = nrefine_for_mesh[0];
         for (unsigned i = 0; i < nref; i++)
         {
           mmesh_pt->p_refine_uniformly(doc_info);
         }
       }
       else
       {
         oomph_info << "Info/Warning: Mesh cannot be p-refined uniformly "
                    << std::endl;
       }
     }
     // Multiple submeshes
     else
     {
       OomphLibWarning(
         "p-refinement for multiple submeshes has not yet been tested.",
         "Problem::p_refine_uniformly_aux()",
         OOMPH_EXCEPTION_LOCATION);
  
       // Loop over submeshes
       for (unsigned imesh = 0; imesh < n_mesh; imesh++)
       {
         // Refine i-th submesh uniformly if possible
         if (RefineableMeshBase* mmesh_pt =
               dynamic_cast<RefineableMeshBase*>(mesh_pt(imesh)))
         {
           unsigned nref = nrefine_for_mesh[imesh];
           for (unsigned i = 0; i < nref; i++)
           {
             mmesh_pt->p_refine_uniformly(doc_info);
           }
         }
         else
         {
           oomph_info << "Info/Warning: Cannot p-refine mesh " << imesh
                      << std::endl;
         }
       }
       // Rebuild the global mesh
       rebuild_global_mesh();
     }
  
     if (Global_timings::Doc_comprehensive_timings)
     {
       t_end = TimingHelpers::timer();
       oomph_info << "Time for mesh-level mesh refinement in "
                  << "Problem::p_refine_uniformly_aux(): " << t_end - t_start
                  << std::endl;
       t_start = TimingHelpers::timer();
     }
  
     // Any actions after the adaptation phase
     actions_after_adapt();
  
  
     if (Global_timings::Doc_comprehensive_timings)
     {
       t_end = TimingHelpers::timer();
       oomph_info
         << "Time for actions after adapt  Problem::p_refine_uniformly_aux(): "
         << t_end - t_start << std::endl;
       t_start = TimingHelpers::timer();
     }
  
  
 #ifdef OOMPH_HAS_MPI
  
     // Prune it?
     if (prune)
     {
       // Note: This calls assign eqn numbers already...
       Bypass_increase_in_dof_check_during_pruning = true;
       prune_halo_elements_and_nodes();
       Bypass_increase_in_dof_check_during_pruning = false;
  
       if (Global_timings::Doc_comprehensive_timings)
       {
         t_end = TimingHelpers::timer();
         oomph_info << "Time for Problem::prune_halo_elements_and_nodes() in "
                    << "Problem::p_refine_uniformly_aux(): " << t_end - t_start
                    << std::endl;
       }
     }
     else
 #else
     if (prune)
     {
       std::ostringstream error_message;
       error_message
         << "Requested pruning in serial build. Ignoring the request.\n";
       OomphLibWarning(error_message.str(),
                       "Problem::p_refine_uniformly_aux()",
                       OOMPH_EXCEPTION_LOCATION);
     }
 #endif
     {
       // Do equation numbering
       oomph_info
         << "Number of equations after Problem::p_refine_uniformly_aux(): "
         << assign_eqn_numbers() << std::endl;
  
       if (Global_timings::Doc_comprehensive_timings)
       {
         t_end = TimingHelpers::timer();
         oomph_info << "Time for Problem::assign_eqn_numbers() in "
                    << "Problem::p_refine_uniformly_aux(): " << t_end - t_start
                    << std::endl;
       }
     }
   }

References actions_after_adapt(), actions_before_adapt(), assign_eqn_numbers(), oomph::Global_timings::Doc_comprehensive_timings, i, mesh_pt(), nsub_mesh(), OOMPH_EXCEPTION_LOCATION, oomph::oomph_info, rebuild_global_mesh(), and oomph::TimingHelpers::timer().

Referenced by p_refine_uniformly(), and p_refine_uniformly_and_prune().

◆ p_unrefine_uniformly() [1/2]

void Problem::p_unrefine_uniformly	(	const unsigned &	i_mesh,
		DocInfo &	doc_info
	)

Do uniform p-unrefinement for submesh i_mesh without documentation.

p-unrefine submesh i_mesh uniformly and rebuild problem; doc refinement process.

   {
     actions_before_adapt();
  
 #ifdef PARANOID
     // Number of submeshes?
     if (i_mesh >= nsub_mesh())
     {
       std::ostringstream error_message;
       error_message << "imesh " << i_mesh
                     << " is greater than the number of sub meshes "
                     << nsub_mesh() << std::endl;
  
       throw OomphLibError(
         error_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
 #endif
  
     // Refine single mesh uniformly if possible
     if (RefineableMeshBase* mmesh_pt =
           dynamic_cast<RefineableMeshBase*>(mesh_pt(i_mesh)))
     {
       mmesh_pt->p_unrefine_uniformly(doc_info);
     }
     else
     {
       oomph_info << "Info/Warning: Mesh cannot be p-unrefined uniformly "
                  << std::endl;
     }
  
     // Rebuild the global mesh
     rebuild_global_mesh();
  
     // Any actions after the adaptation phase
     actions_after_adapt();
  
     // Do equation numbering
     oomph_info << "Number of equations: " << assign_eqn_numbers() << std::endl;
   }

References actions_after_adapt(), actions_before_adapt(), assign_eqn_numbers(), mesh_pt(), nsub_mesh(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::oomph_info, and rebuild_global_mesh().

◆ p_unrefine_uniformly() [2/2]

void Problem::p_unrefine_uniformly ( DocInfo & doc_info )

p-unrefine (all) p-refineable (sub)mesh(es) uniformly and rebuild problem.

p-unrefine (all) p-refineable (sub)mesh(es) uniformly and rebuild problem; doc refinement process.

   {
     actions_before_adapt();
  
     // Number of submeshes?
     unsigned n_mesh = nsub_mesh();
  
     // Single mesh:
     if (n_mesh == 0)
     {
       // Unrefine single mesh uniformly if possible
       if (RefineableMeshBase* mmesh_pt =
             dynamic_cast<RefineableMeshBase*>(mesh_pt(0)))
       {
         mmesh_pt->p_unrefine_uniformly(doc_info);
       }
       else
       {
         oomph_info << "Info/Warning: Mesh cannot be p-unrefined uniformly "
                    << std::endl;
       }
     }
     // Multiple submeshes
     else
     {
       // Not tested:
       throw OomphLibError("This functionality has not yet been tested.",
                           OOMPH_CURRENT_FUNCTION,
                           OOMPH_EXCEPTION_LOCATION);
       // Loop over submeshes
       for (unsigned imesh = 0; imesh < n_mesh; imesh++)
       {
         // Unrefine i-th submesh uniformly if possible
         if (RefineableMeshBase* mmesh_pt =
               dynamic_cast<RefineableMeshBase*>(mesh_pt(imesh)))
         {
           mmesh_pt->p_unrefine_uniformly(doc_info);
         }
         else
         {
           oomph_info << "Info/Warning: Cannot p-unrefine mesh " << imesh
                      << std::endl;
         }
       }
       // Rebuild the global mesh
       rebuild_global_mesh();
     }
  
     // Any actions after the adaptation phase
     actions_after_adapt();
  
     // Do equation numbering
     oomph_info << "Number of equations: " << assign_eqn_numbers() << std::endl;
   }

References actions_after_adapt(), actions_before_adapt(), assign_eqn_numbers(), mesh_pt(), nsub_mesh(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::oomph_info, and rebuild_global_mesh().

◆ problem_is_nonlinear()

void oomph::Problem::problem_is_nonlinear ( const bool & prob_lin )

inline

Access function to Problem_is_nonlinear.

     {
       Problem_is_nonlinear = prob_lin;
     }

References Problem_is_nonlinear.

◆ read() [1/2]

virtual void oomph::Problem::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 in oomph::MyProblem, and AirwayReopeningProblem< ELEMENT >.

     {
       bool unsteady_restart;
       read(restart_file, unsteady_restart);
     }

References read().

◆ read() [2/2]

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

virtual

Read refinement pattern of all refineable meshes and refine them accordingly, then read all Data and nodal position info from file for restart. Return flag to indicate if the restart was from steady or unsteady solution

Read refinement pattern of all refineable meshes and refine them accordingly, then read all Data and nodal position info from file for restart. Return flag to indicate if the restart was from steady or unsteady solution.

   {
     // Check if the file is actually open as it won't be if it doesn't
     // exist! In that case we're almost certainly restarting the run on
     // a larger number of processors than the restart data was produced.
     // Say so and return
     bool restart_file_is_open = true;
     if (!restart_file.is_open())
     {
       std::ostringstream warn_message;
       warn_message << "Restart file isn't open -- I'm assuming that this is\n";
       warn_message << "because we're restarting on a larger number of\n";
       warn_message << "processor than were in use when the restart data was \n";
       warn_message << "dumped.\n";
       OomphLibWarning(
         warn_message.str(), "Problem::read()", OOMPH_EXCEPTION_LOCATION);
       restart_file_is_open = false;
     }
  
     // Number of (sub)meshes?
     unsigned n_mesh = std::max(unsigned(1), nsub_mesh());
  
     std::string input_string;
  
     // Read line up to termination sign
     getline(restart_file, input_string, '#');
  
     // Ignore rest of line
     restart_file.ignore(80, '\n');
  
     // Read in number of sub-meshes
     unsigned n_submesh_read;
     n_submesh_read = std::atoi(input_string.c_str());
  
 #ifdef PARANOID
     if (restart_file_is_open)
     {
       if (n_submesh_read != n_mesh)
       {
         std::ostringstream error_message;
         error_message
           << "Number of sub-meshes specified in restart file, "
           << n_submesh_read << " doesn't \n match the my number of sub-meshes,"
           << n_mesh << std::endl
           << "Make sure all sub-meshes have been added to the global mesh\n"
           << "when calling the Problem::dump() function.\n";
         throw OomphLibError(error_message.str(),
                             OOMPH_CURRENT_FUNCTION,
                             OOMPH_EXCEPTION_LOCATION);
       }
     }
 #else
     // Suppress comiler warnings about non-used variable
     n_submesh_read++;
     n_submesh_read--;
 #endif
  
  
     // Read levels of refinement before pruning
 #ifdef OOMPH_HAS_MPI
     bool refine_and_prune_required = false;
 #endif
     Vector<unsigned> nrefinement_for_mesh(n_mesh);
     for (unsigned i = 0; i < n_mesh; i++)
     {
       // Read line up to termination sign
       getline(restart_file, input_string, '#');
  
       // Ignore rest of line
       restart_file.ignore(80, '\n');
  
       // Convert
       nrefinement_for_mesh[i] = std::atoi(input_string.c_str());
  
       // Get pointer to sub-mesh in incarnation as tree-based refineable mesh
       TreeBasedRefineableMeshBase* ref_mesh_pt =
         dynamic_cast<TreeBasedRefineableMeshBase*>(mesh_pt(i));
  
       // If it's not a tree-based refineable mesh, ignore the following
       if (ref_mesh_pt == 0)
       {
         if (nrefinement_for_mesh[i] != 0)
         {
           std::ostringstream error_stream;
           error_stream << "Nonzero uniform-refinement-when-pruned specified\n"
                        << "even though mesh is not tree-based. Odd. May want\n"
                        << "to check this carefully before disabling this \n"
                        << "warning/error -- most likely if/when we start to\n"
                        << "prune unstructured meshes [though I can't see why\n"
                        << "we would want to do this, given that they are \n"
                        << "currently totally re-generated...]\n";
           throw OomphLibError(error_stream.str(),
                               OOMPH_CURRENT_FUNCTION,
                               OOMPH_EXCEPTION_LOCATION);
         }
       }
       else
       {
         // Get min and max refinement level
         unsigned local_min_ref = 0;
         unsigned local_max_ref = 0;
         ref_mesh_pt->get_refinement_levels(local_min_ref, local_max_ref);
  
         // Overall min refinement level over all meshes
         unsigned min_ref = local_min_ref;
  
 #ifdef OOMPH_HAS_MPI
         if (Problem_has_been_distributed)
         {
           // Reconcile between processors: If (e.g. following
           // distribution/pruning) the mesh has no elements on this
           // processor) then ignore its contribution to the poll of
           // max/min refinement levels
           int int_local_min_ref = local_min_ref;
           if (ref_mesh_pt->nelement() == 0)
           {
             int_local_min_ref = INT_MAX;
           }
           int int_min_ref = 0;
           MPI_Allreduce(&int_local_min_ref,
                         &int_min_ref,
                         1,
                         MPI_INT,
                         MPI_MIN,
                         Communicator_pt->mpi_comm());
  
           // Overall min refinement level over all meshes
           min_ref = unsigned(int_min_ref);
         }
 #endif
  
         // Need to refine less
         if (nrefinement_for_mesh[i] >= min_ref)
         {
           nrefinement_for_mesh[i] -= min_ref;
         }
       }
  
 #ifdef OOMPH_HAS_MPI
       if (nrefinement_for_mesh[i] > 0)
       {
         refine_and_prune_required = true;
       }
 #endif
     }
  
  
     // Reconcile overall need to refine and prune (even empty
     // processors have to participate in some communication!)
 #ifdef OOMPH_HAS_MPI
     if (Problem_has_been_distributed)
     {
       unsigned local_req_flag = 0;
       unsigned req_flag = 0;
       if (refine_and_prune_required)
       {
         local_req_flag = 1;
       }
       MPI_Allreduce(&local_req_flag,
                     &req_flag,
                     1,
                     MPI_UNSIGNED,
                     MPI_MAX,
                     Communicator_pt->mpi_comm());
       refine_and_prune_required = false;
       if (req_flag == 1)
       {
         refine_and_prune_required = true;
       }
  
       // If refine and prune is required make number of uniform
       // refinements for each mesh consistent otherwise code
       // hangs on "empty" processors for which no restart file exists
       if (refine_and_prune_required)
       {
         // This is what we have locally
         Vector<unsigned> local_nrefinement_for_mesh(nrefinement_for_mesh);
         // Synchronise over all processors with max operation
         MPI_Allreduce(&local_nrefinement_for_mesh[0],
                       &nrefinement_for_mesh[0],
                       n_mesh,
                       MPI_UNSIGNED,
                       MPI_MAX,
                       Communicator_pt->mpi_comm());
  
 #ifdef PARANOID
         // Check it: Reconciliation should only be required for
         // for processors on which no restart file was opened and
         // for which the meshes are therefore empty
         bool fail = false;
         std::ostringstream error_message;
         error_message << "Number of uniform refinements was not consistent \n"
                       << "for following meshes during restart on processor \n"
                       << "on which restart file could be opened:\n";
         for (unsigned i = 0; i < n_mesh; i++)
         {
           if ((local_nrefinement_for_mesh[i] != nrefinement_for_mesh[i]) &&
               restart_file_is_open)
           {
             fail = true;
             error_message << "Sub-mesh: " << i << "; local nrefinement: "
                           << local_nrefinement_for_mesh[i] << " "
                           << "; global/synced nrefinement: "
                           << nrefinement_for_mesh[i] << "\n";
           }
         }
         if (fail)
         {
           OomphLibWarning(
             error_message.str(), "Problem::read()", OOMPH_EXCEPTION_LOCATION);
         }
 #endif
       }
     }
 #endif
  
     // Read line up to termination sign
     getline(restart_file, input_string, '#');
  
     // Ignore rest of line
     restart_file.ignore(80, '\n');
  
     // Check flag that indicates that we've read the final data
     unsigned tmp;
     tmp = std::atoi(input_string.c_str());
  
 #ifdef PARANOID
     if (restart_file_is_open)
     {
       if (tmp != 9999)
       {
         std::ostringstream error_message;
         error_message
           << "Error in reading restart data: Uniform refinement when pruned \n"
           << "flags should be followed by 9999.\n";
         throw OomphLibError(error_message.str(),
                             OOMPH_CURRENT_FUNCTION,
                             OOMPH_EXCEPTION_LOCATION);
       }
     }
  
 #else
     // Suppress comiler warnings about non-used variable
     tmp++;
     tmp--;
 #endif
  
  
 #ifdef OOMPH_HAS_MPI
  
     // Refine and prune if required
     if (refine_and_prune_required)
     {
       refine_uniformly(nrefinement_for_mesh);
       prune_halo_elements_and_nodes();
     }
  
     // target_domain_for_local_non_halo_element[e] contains the number
     // of the domain [0,1,...,nproc-1] to which non-halo element e on THE
     // CURRENT PROCESSOR ONLY has been assigned. The order of the non-halo
     // elements is the same as in the Problem's mesh, with the halo
     // elements being skipped.
     Vector<unsigned> target_domain_for_local_non_halo_element;
  
     // If a restart file has been generated using code compiled without MPI
     // then it will not have any of the base element data.
     // If we try to read in that file with code that has been compied using
     // MPI, even if running only one processor, then it will fail here.
     // The ideal fix is to edit the restart file so that it contains the two
     // lines
     //
     // 0 # Number of base elements; partitioning follows.
     // 8888 # Test flag for end of base element distribution
     //
     // after the end of the sub-meshes, but before the number of elements
     // However, we can determine that this is the problem if n_base = 0,
     // so there is a little bit of logic below to catch this case
  
     // Store current location in the file (before we are about to read
     // in either the base mesh or number of elements of the first mesh)
     std::streampos position_before_base_element = restart_file.tellg();
     // Boolean flag used to set whether to read in base element info
     bool read_in_base_element_info = true;
  
     // Read line up to termination sign
     getline(restart_file, input_string, '#');
  
     // Ignore rest of line
     restart_file.ignore(80, '\n');
  
     // Get number of base elements as recorded
     unsigned n_base_element_read_in = atoi(input_string.c_str());
     unsigned nbase = Base_mesh_element_pt.size();
     if (restart_file_is_open)
     {
       if (n_base_element_read_in != nbase)
       {
         // If we have zero base elements the problem could be that the
         // restart file was generated without MPI. Issue a warning
         // and continue anyway
         if (nbase == 0)
         {
           std::ostringstream warn_message;
           warn_message
             << "The number of base elements in the mesh is 0,\n"
             << " but the restart file indicates that there are "
             << n_base_element_read_in << ".\n"
             << "This could be because the restart file was \n"
             << "generated by using code without MPI.\n"
             << "\n"
             << "The best fix is to include two additional lines\n"
             << "in the restart file: \n\n"
             << "0 # Number of base elements; partitioning follows.\n"
             << "8888 # Test flag for end of base element distribution\n"
             << "\n"
             << "These lines go after the flag 9999 that indicates\n"
             << "the end of the submesh information.\n"
             << "\n"
             << "The file will now continue to be read assuming that\n"
             << "the base element information is not present.\n"
             << "If you get strange results then please look carefully\n"
             << "at the restart file. The safest thing to do is to \n"
             << "ensure that the restart file was generated by code\n"
             << "compiled and run with the same parallel options.\n";
           OomphLibWarning(warn_message.str(),
                           OOMPH_CURRENT_FUNCTION,
                           OOMPH_EXCEPTION_LOCATION);
           // Set the skip flag to true
           // and rewind the file pointer
           read_in_base_element_info = false;
           restart_file.seekg(position_before_base_element);
         }
         // Otherwise throw a hard error
         else
         {
           std::ostringstream error_message;
           error_message << "About to read " << n_base_element_read_in
                         << " base elements \n"
                         << "though we only have " << nbase
                         << " base elements in mesh.\n";
           throw OomphLibError(error_message.str(),
                               OOMPH_CURRENT_FUNCTION,
                               OOMPH_EXCEPTION_LOCATION);
         }
       }
     }
  
     // Read in the remaning base element information, if necessary
     if (read_in_base_element_info == true)
     {
       // Read in target_domain_for_base_element[e] for all base elements
       Vector<unsigned> target_domain_for_base_element(nbase);
       for (unsigned e = 0; e < nbase; e++)
       {
         // Read line
         getline(restart_file, input_string);
  
         // Get target domain
         target_domain_for_base_element[e] = atoi(input_string.c_str());
       }
  
       // Read line up to termination sign
       getline(restart_file, input_string, '#');
  
       // Ignore rest of line
       restart_file.ignore(80, '\n');
  
       // Check flag that indicates that we've read the final data
       tmp = std::atoi(input_string.c_str());
  
  
 #ifdef PARANOID
       if (restart_file_is_open)
       {
         if (tmp != 8888)
         {
           std::ostringstream error_message;
           error_message
             << "Error in reading restart data: Target proc for base elements \n"
             << "should be followed by 8888.\n";
           throw OomphLibError(error_message.str(),
                               OOMPH_CURRENT_FUNCTION,
                               OOMPH_EXCEPTION_LOCATION);
         }
       }
 #endif
  
       // Loop over all elements (incl. any FaceElements) and assign
       // target domain for all local non-halo elements and check if
       // load balancing is required -- no need to do this if problem is
       // not distributed.
       unsigned load_balance_required_flag = 0;
       if (Problem_has_been_distributed)
       {
         // Working with TreeBasedRefineableMeshBase mesh
         unsigned local_load_balance_required_flag = 0;
         if (dynamic_cast<TreeBasedRefineableMeshBase*>(mesh_pt(0)))
         {
           const int my_rank = this->communicator_pt()->my_rank();
           unsigned nel = mesh_pt()->nelement();
           for (unsigned e = 0; e < nel; e++)
           {
             GeneralisedElement* el_pt = mesh_pt()->element_pt(e);
             if (!el_pt->is_halo())
             {
               // Get element number (plus one) in base element enumeration
               unsigned el_number_in_base_mesh_plus_one =
                 Base_mesh_element_number_plus_one[el_pt];
  
               // If it's zero then we haven't found it, it may be a FaceElement
               // (in which case we move it to the same processor as its bulk
               // element
               if (el_number_in_base_mesh_plus_one == 0)
               {
                 FaceElement* face_el_pt = dynamic_cast<FaceElement*>(el_pt);
                 if (face_el_pt != 0)
                 {
                   // Get corresponding bulk element
                   FiniteElement* bulk_el_pt = face_el_pt->bulk_element_pt();
  
                   // Use its element number (plus one) in base element
                   // enumeration
                   el_number_in_base_mesh_plus_one =
                     Base_mesh_element_number_plus_one[bulk_el_pt];
  
                   // If this is zero too we have a problem
                   if (el_number_in_base_mesh_plus_one == 0)
                   {
                     throw OomphLibError(
                       "el_number_in_base_mesh_plus_one=0 for bulk",
                       "Problem::read()",
                       OOMPH_EXCEPTION_LOCATION);
                   }
                 }
               }
  
               // If we've made it here then we're not dealing with a
               // FaceElement but with an element that doesn't exist locally
               // --> WTF?
               if (el_number_in_base_mesh_plus_one == 0)
               {
                 throw OomphLibError("el_number_in_base_mesh_plus_one=0",
                                     OOMPH_CURRENT_FUNCTION,
                                     OOMPH_EXCEPTION_LOCATION);
               }
  
               // Assign target domain for next local non-halo element in
               // the order in which it's encountered in the global mesh
               target_domain_for_local_non_halo_element.push_back(
                 target_domain_for_base_element[el_number_in_base_mesh_plus_one -
                                                1]);
  
               // Do elements on this processor to be moved elsewhere?
               if (int(target_domain_for_base_element
                         [el_number_in_base_mesh_plus_one - 1]) != my_rank)
               {
                 local_load_balance_required_flag = 1;
               }
             }
           }
  
         } // if (working with TreeBasedRefineableMeshBase mesh)
  
         // Get overall need to load balance by max
         MPI_Allreduce(&local_load_balance_required_flag,
                       &load_balance_required_flag,
                       1,
                       MPI_UNSIGNED,
                       MPI_MAX,
                       this->communicator_pt()->mpi_comm());
       }
  
       // Do we need to load balance?
       if (load_balance_required_flag == 1)
       {
         oomph_info << "Doing load balancing after pruning\n";
         DocInfo doc_info;
         doc_info.disable_doc();
         bool report_stats = false;
         load_balance(
           doc_info, report_stats, target_domain_for_local_non_halo_element);
         oomph_info << "Done load balancing after pruning\n";
       }
       else
       {
         oomph_info << "No need for load balancing after pruning\n";
       }
     } // End of read in base element information
 #endif
  
  
     // Boolean to record if any unstructured bulk meshes have
     // been read in (and therefore completely re-generated, with new
     // elements and nodes) from disk
     bool have_read_unstructured_mesh = false;
  
     // Call the actions before adaptation
     actions_before_adapt();
  
     // If there are unstructured meshes in the problem we need
     // to strip out any face elements that are attached to them
     // because restart of unstructured meshes re-creates their elements
     // and nodes from scratch, leading to dangling pointers from the
     // face elements to the old elements and nodes. This function is
     // virtual and (practically) empty in the Problem base class
     // but toggles a flag to indicate that it has been called. We can then
     // issue a warning below, prompting the user to consider overloading it
     // if the problem is found to contain unstructured bulk meshes.
     // Warning can be ignored if the bulk mesh is not associated with any
     // face elements.
     Empty_actions_before_read_unstructured_meshes_has_been_called = false;
     actions_before_read_unstructured_meshes();
  
     // Update number of submeshes
     n_mesh = nsub_mesh();
  
     // Single mesh:
     //------------
     if (n_mesh == 0)
     {
       // Refine single mesh (if it's refineable)
       if (TreeBasedRefineableMeshBase* mmesh_pt =
             dynamic_cast<TreeBasedRefineableMeshBase*>(mesh_pt(0)))
       {
         // When we get in here the problem has been constructed
         // by the constructor and the mesh is its original unrefined
         // form.
         // RefineableMeshBase::refine(...) reads the refinement pattern from the
         // specified file and performs refinements until the mesh has
         // reached the same level of refinement as the mesh that existed
         // when the problem was dumped to disk.
         mmesh_pt->refine(restart_file);
       }
 #ifdef OOMPH_HAS_TRIANGLE_LIB
       // Regenerate mesh from triangulate IO if it's a triangular mesh
       TriangleMeshBase* mmesh_pt = dynamic_cast<TriangleMeshBase*>(mesh_pt(0));
       if (mmesh_pt != 0 && mmesh_pt->use_triangulateio_restart())
       {
 #ifdef OOMPH_HAS_MPI
         // Check if the mesh is distributed, if that is the case then
         // additional info. needs to be read
         if (mmesh_pt->is_mesh_distributed())
         {
           // Dump the info. related with the distribution of the mesh
           mmesh_pt->read_distributed_info_for_restart(restart_file);
         }
 #endif
         // The function reads the TriangulateIO data structure from the dump
         // file and then completely regenerates the mesh using the
         // data structure
         mmesh_pt->remesh_from_triangulateio(restart_file);
         have_read_unstructured_mesh = true;
 #ifdef OOMPH_HAS_MPI
         // Check if the mesh is distributed, if that is the case then we
         // need to re-establish the halo/haloed scheme (similar as in the
         // RefineableTriangleMesh::adapt() method)
         if (mmesh_pt->is_mesh_distributed())
         {
           mmesh_pt->reestablish_distribution_info_for_restart(
             this->communicator_pt(), restart_file);
         }
 #endif
         // Still left to update the polylines representation, that is performed
         // later since the nodes positions may still change when reading info.
         // for the mesh, see below
       }
 #endif
     }
  
     // Multiple submeshes
     //------------------
     else
     {
       // Loop over submeshes
       for (unsigned imesh = 0; imesh < n_mesh; imesh++)
       {
         // Refine single mesh (if its refineable)
         if (TreeBasedRefineableMeshBase* mmesh_pt =
               dynamic_cast<TreeBasedRefineableMeshBase*>(mesh_pt(imesh)))
         {
           // When we get in here the problem has been constructed
           // by the constructor and the mesh is its original unrefined
           // form.
           // RefineableMeshBase::refine(...) reads the refinement pattern from
           // the specified file and performs refinements until the mesh has
           // reached the same level of refinement as the mesh that existed
           // when the problem was dumped to disk.
           mmesh_pt->refine(restart_file);
         }
 #ifdef OOMPH_HAS_TRIANGLE_LIB
         // Regenerate mesh from triangulate IO if it's a triangular mesh
         TriangleMeshBase* mmesh_pt =
           dynamic_cast<TriangleMeshBase*>(mesh_pt(imesh));
         if (mmesh_pt != 0 && mmesh_pt->use_triangulateio_restart())
         {
 #ifdef OOMPH_HAS_MPI
           // Check if the mesh is distributed, if that is the case then
           // additional info. needs to be read
           if (mmesh_pt->is_mesh_distributed())
           {
             // Dump the info. related with the distribution of the mesh
             mmesh_pt->read_distributed_info_for_restart(restart_file);
           }
 #endif
           // The function reads the TriangulateIO data structure from the dump
           // file and then completely regenerates the mesh using the
           // data structure
           mmesh_pt->remesh_from_triangulateio(restart_file);
           have_read_unstructured_mesh = true;
  
 #ifdef OOMPH_HAS_MPI
           // Check if the mesh is distributed, if that is the case then we
           // need to re-establish the halo/haloed scheme (similar as in the
           // RefineableTriangleMesh::adapt() method)
           if (mmesh_pt->is_mesh_distributed())
           {
             mmesh_pt->reestablish_distribution_info_for_restart(
               this->communicator_pt(), restart_file);
           }
 #endif
           // Still left to update the polylines representation, that is
           // performed later since the nodes positions may still change when
           // reading info. for the mesh, see below
         }
 #endif
       } // End of loop over submeshes
  
  
       // Rebuild the global mesh
       rebuild_global_mesh();
     }
  
     // Any actions after adapt
     actions_after_adapt();
  
     // Re-attach face elements (or whatever else needs to be done
     // following the total re-generation of the unstructured meshes
     Empty_actions_after_read_unstructured_meshes_has_been_called = false;
     actions_after_read_unstructured_meshes();
  
  
     // Issue warning:
     if (!Suppress_warning_about_actions_before_read_unstructured_meshes)
     {
       if (have_read_unstructured_mesh)
       {
         if (Empty_actions_before_read_unstructured_meshes_has_been_called ||
             Empty_actions_after_read_unstructured_meshes_has_been_called)
         {
           std::ostringstream warn_message;
           warn_message
             << "I've just read in some unstructured meshes and have, in\n"
             << "the process, totally re-generated their nodes and elements.\n"
             << "This may create dangling pointers that still point to the\n"
             << "old nodes and elements, e.g. because FaceElements were\n"
             << "attached to these meshes or pointers to nodes and elements\n"
             << "were stored somewhere. FaceElements should therefore be\n"
             << "removed before reading in these meshes, using an overloaded\n"
             << "version of the function\n\n"
             << "   Problem::actions_before_read_unstructured_meshes()\n\n"
             << "and then re-attached using an overloaded version of\n\n"
             << "   Problem::actions_after_read_unstructured_meshes().\n\n"
             << "The required content of these functions is likely to be "
                "similar\n"
             << "to the Problem::actions_before_adapt() and \n"
             << "Problem::actions_after_adapt() that would be required in\n"
             << "a spatially adaptive computation. If these functions already\n"
             << "exist and perform the required actions, the \n"
             << "actions_before/after_read_unstructured_meshes() functions\n"
             << "can remain empty because the former are called automatically.\n"
             << "In this case, this warning my be suppressed by setting the\n"
             << "public boolean\n\n"
             << "   "
                "Problem::Suppress_warning_about_actions_before_read_"
                "unstructured_meshes\n\n"
             << "to true." << std::endl;
           OomphLibWarning(warn_message.str(),
                           OOMPH_CURRENT_FUNCTION,
                           OOMPH_EXCEPTION_LOCATION);
         }
       }
     }
  
     // Setup equation numbering scheme
     oomph_info << "\nNumber of equations in Problem::read(): "
                << assign_eqn_numbers() << std::endl
                << std::endl;
     // Read time info
     //---------------
     unsigned local_unsteady_restart_flag = 0;
     double local_time = -DBL_MAX;
     unsigned local_n_dt = 0;
 #ifdef OOMPH_HAS_MPI
     unsigned local_sync_needed_flag = 0;
 #endif
     Vector<double> local_dt;
  
     if (restart_file.is_open())
     {
       oomph_info << "Restart file exists" << std::endl;
 #ifdef OOMPH_HAS_MPI
       local_sync_needed_flag = 0;
 #endif
       // Read line up to termination sign
       getline(restart_file, input_string, '#');
  
       // Ignore rest of line
       restart_file.ignore(80, '\n');
  
       // Is the restart data from an unsteady run?
       local_unsteady_restart_flag = atoi(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 in initial time and set
       local_time = 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 & set number of timesteps
       local_n_dt = atoi(input_string.c_str());
       local_dt.resize(local_n_dt);
  
       // Read in timesteps:
       for (unsigned i = 0; i < local_n_dt; i++)
       {
         // Read line up to termination sign
         getline(restart_file, input_string, '#');
  
         // Ignore rest of line
         restart_file.ignore(80, '\n');
  
         // Read in initial time and set
         double prev_dt = atof(input_string.c_str());
         local_dt[i] = prev_dt;
       }
     }
     else
     {
       oomph_info << "Restart file does not exist" << std::endl;
 #ifdef OOMPH_HAS_MPI
       local_sync_needed_flag = 1;
 #endif
     }
  
  
     // No prepare global values, possibly via sync
     Vector<double> dt;
  
     // Do we need to sync?
     unsigned sync_needed_flag = 0;
  
 #ifdef OOMPH_HAS_MPI
     if (Problem_has_been_distributed)
     {
       // Get need to sync by max
       MPI_Allreduce(&local_sync_needed_flag,
                     &sync_needed_flag,
                     1,
                     MPI_UNSIGNED,
                     MPI_MAX,
                     this->communicator_pt()->mpi_comm());
     }
 #endif
  
     // Synchronise
     if (sync_needed_flag == 1)
     {
 #ifdef OOMPH_HAS_MPI
  
  
 #ifdef PARANOID
       if (!Problem_has_been_distributed)
       {
         std::ostringstream error_message;
         error_message << "Synchronisation of temporal restart data \n"
                       << "required even though Problem hasn't been distributed "
                          "-- very odd!\n";
         throw OomphLibError(error_message.str(),
                             OOMPH_CURRENT_FUNCTION,
                             OOMPH_EXCEPTION_LOCATION);
       }
 #endif
  
       // Get unsteady restart flag by max-based reduction
       unsigned unsteady_restart_flag = 0;
       MPI_Allreduce(&local_unsteady_restart_flag,
                     &unsteady_restart_flag,
                     1,
                     MPI_UNSIGNED,
                     MPI_MAX,
                     this->communicator_pt()->mpi_comm());
  
       // So, is it an unsteady restart?
       unsteady_restart = false;
       if (unsteady_restart_flag == 1)
       {
         unsteady_restart = true;
  
         // Get time by max
         double time = -DBL_MAX;
         MPI_Allreduce(&local_time,
                       &time,
                       1,
                       MPI_DOUBLE,
                       MPI_MAX,
                       this->communicator_pt()->mpi_comm());
         time_pt()->time() = time;
  
         // Get number of timesteps by max-based reduction
         unsigned n_dt = 0;
         MPI_Allreduce(&local_n_dt,
                       &n_dt,
                       1,
                       MPI_UNSIGNED,
                       MPI_MAX,
                       this->communicator_pt()->mpi_comm());
  
         // Resize whatever needs resizing
         time_pt()->resize(n_dt);
         dt.resize(n_dt);
         if (local_dt.size() == 0)
         {
           local_dt.resize(n_dt, -DBL_MAX);
         }
  
         // Get timesteps increments by max-based reduction
         MPI_Allreduce(&local_dt[0],
                       &dt[0],
                       n_dt,
                       MPI_DOUBLE,
                       MPI_MAX,
                       this->communicator_pt()->mpi_comm());
       }
  
 #else
  
       std::ostringstream error_message;
       error_message
         << "Synchronisation of temporal restart data \n"
         << "required even though we don't have mpi support -- very odd!\n";
       throw OomphLibError(
         error_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
  
 #endif
     }
     // No sync needed -- just copy across
     else
     {
       unsteady_restart = false;
       if (local_unsteady_restart_flag == 1)
       {
         unsteady_restart = true;
         time_pt()->time() = local_time;
         time_pt()->resize(local_n_dt);
         dt.resize(local_n_dt);
         for (unsigned i = 0; i < local_n_dt; i++)
         {
           dt[i] = local_dt[i];
         }
       }
     }
  
     // Initialise timestep -- also sets the weights for all timesteppers
     // in the problem.
     if (unsteady_restart) initialise_dt(dt);
  
     // Loop over submeshes:
     unsigned nmesh = nsub_mesh();
     if (nmesh == 0) nmesh = 1;
     for (unsigned m = 0; m < nmesh; m++)
     {
       //    //---------------------------------------------------------
       //    // Keep this commented out code around to debug restarts
       //    //---------------------------------------------------------
       //    std::ofstream some_file;
       //    char filename[100];
       //    sprintf(filename,"read_mesh%i_on_proc%i.dat",m,
       //            this->communicator_pt()->my_rank());
       //    some_file.open(filename);
       //    mesh_pt(m)->output(some_file);
       //    some_file.close();
  
       //    sprintf(filename,"read_mesh%i_with_haloes_on_proc%i.dat",m,
       //            this->communicator_pt()->my_rank());
       //    mesh_pt(m)->enable_output_of_halo_elements();
       //    some_file.open(filename);
       //    mesh_pt(m)->output(some_file);
       //    mesh_pt(m)->disable_output_of_halo_elements();
       //    some_file.close();
       //    oomph_info << "Doced mesh " << m << " before reading\n";
  
       //    sprintf(filename,"read_nodes_mesh%i_on_proc%i.dat",m,
       //            this->communicator_pt()->my_rank());
       //    some_file.open(filename);
       //    unsigned nnod=mesh_pt(m)->nnode();
       //    for (unsigned j=0;j<nnod;j++)
       //     {
       //      Node* nod_pt=mesh_pt(m)->node_pt(j);
       //      unsigned n=nod_pt->ndim();
       //      for (unsigned i=0;i<n;i++)
       //       {
       //        some_file << nod_pt->x(i) << " ";
       //       }
       //      some_file << nod_pt->is_halo() << " "
       //                << nod_pt->nvalue() << " "
       //                << nod_pt->hang_code() << "\n";
       //     }
       //    some_file.close();
       //    oomph_info << "Doced mesh " << m << " before reading\n";
       //    //---------------------------------------------------------
       //    // End keep this commented out code around to debug restarts
       //    //---------------------------------------------------------
  
       mesh_pt(m)->read(restart_file);
  
 #ifdef OOMPH_HAS_TRIANGLE_LIB
       // Here update the polyline representation if working with
       // triangle base meshes
       if (TriangleMeshBase* mmesh_pt =
             dynamic_cast<TriangleMeshBase*>(mesh_pt(m)))
       {
         // In charge of updating the polylines representation to the
         // current refinement/unrefinement level after restart, it
         // also update the shared boundaries in case of working with a
         // distributed mesh
         mmesh_pt->update_polyline_representation_from_restart();
       }
 #endif // #ifdef OOMPH_HAS_TRIANGLE_LIB
     }
  
     // Read global data:
     //------------------
  
     // Number of global data
     unsigned Nglobal = Global_data_pt.size();
  
     // Read line up to termination sign
     getline(restart_file, input_string, '#');
  
     // Ignore rest of line
     restart_file.ignore(80, '\n');
  
     // Check # of nodes:
     unsigned long check_nglobal = atoi(input_string.c_str());
  
  
     if (restart_file_is_open)
     {
       if (check_nglobal != Nglobal)
       {
         std::ostringstream error_message;
         error_message << "The number of global data " << Nglobal
                       << " is not equal to that specified in the input file "
                       << check_nglobal << std::endl;
  
         throw OomphLibError(error_message.str(),
                             OOMPH_CURRENT_FUNCTION,
                             OOMPH_EXCEPTION_LOCATION);
       }
     }
  
     for (unsigned iglobal = 0; iglobal < Nglobal; iglobal++)
     {
       Global_data_pt[iglobal]->read(restart_file);
     }
   }

References actions_after_adapt(), actions_after_read_unstructured_meshes(), actions_before_adapt(), actions_before_read_unstructured_meshes(), assign_eqn_numbers(), oomph::FaceElement::bulk_element_pt(), Communicator_pt, communicator_pt(), oomph::DocInfo::disable_doc(), e(), oomph::Mesh::element_pt(), Empty_actions_after_read_unstructured_meshes_has_been_called, Empty_actions_before_read_unstructured_meshes_has_been_called, oomph::TreeBasedRefineableMeshBase::get_refinement_levels(), Global_data_pt, i, initialise_dt(), oomph::Mesh::is_mesh_distributed(), m, max, mesh_pt(), oomph::OomphCommunicator::my_rank(), oomph::Mesh::nelement(), nsub_mesh(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::oomph_info, oomph::Mesh::read(), rebuild_global_mesh(), refine_uniformly(), oomph::Time::resize(), oomph::Global_string_for_annotation::string(), Suppress_warning_about_actions_before_read_unstructured_meshes, time(), oomph::Time::time(), time_pt(), and tmp.

Referenced by oomph::MyProblem::read(), and read().

◆ rebuild_global_mesh()

void Problem::rebuild_global_mesh ( )

If one of the submeshes has changed (e.g. by mesh adaptation) we need to update the global mesh. Note: The nodes boundary information refers to the boundary numbers within the submesh!

If one of the submeshes has changed (e.g. by mesh adaptation) we need to update the global mesh. Note: The nodes boundary information refers to the boundary numbers within the submesh! N.B. This is essentially the same function as the Mesh constructor that assembles a single global mesh from submeshes

   {
     // Use the function in mesh to merge the submeshes into this one
     Mesh_pt->merge_meshes(Sub_mesh_pt);
   }

References oomph::Mesh::merge_meshes(), Mesh_pt, and Sub_mesh_pt.

Referenced by ContactProblem< ELEMENT >::actions_after_adapt(), ContactProblem< ELEMENT >::actions_before_adapt(), adapt(), adapt_based_on_error_estimates(), build_global_mesh(), main(), p_adapt(), p_refine_selected_elements(), p_refine_uniformly(), p_refine_uniformly_aux(), p_unrefine_uniformly(), read(), oomph::SegregatableFSIProblem::rebuild_monolithic_mesh(), refine_selected_elements(), refine_uniformly(), refine_uniformly_aux(), unrefine_uniformly(), oomph::SegregatableFSIProblem::use_only_fluid_elements(), and oomph::SegregatableFSIProblem::use_only_solid_elements().

◆ refine_selected_elements() [1/6]

void Problem::refine_selected_elements	(	const unsigned &	i_mesh,
		const Vector< RefineableElement * > &	elements_to_be_refined_pt
	)

Refine specified submesh by splitting the elements identified by their pointers, then rebuild the problem.

   {
     actions_before_adapt();
  
     // Number of submeshes?
     unsigned n_mesh = nsub_mesh();
  
     if (i_mesh >= n_mesh)
     {
       std::ostringstream error_message;
       error_message << "Problem only has " << n_mesh
                     << " submeshes. Cannot refine submesh " << i_mesh
                     << std::endl;
       throw OomphLibError(
         error_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
  
     // Refine single mesh if possible
     if (TreeBasedRefineableMeshBase* mmesh_pt =
           dynamic_cast<TreeBasedRefineableMeshBase*>(mesh_pt(i_mesh)))
     {
       mmesh_pt->refine_selected_elements(elements_to_be_refined_pt);
     }
     else
     {
       oomph_info << "Info/Warning: Mesh cannot be refined " << std::endl;
     }
  
     if (n_mesh > 1)
     {
       // Rebuild the global mesh
       rebuild_global_mesh();
     }
  
     // Any actions after the adapatation phase
     actions_after_adapt();
  
     // Do equation numbering
     oomph_info << "Number of equations: " << assign_eqn_numbers() << std::endl;
   }

References actions_after_adapt(), actions_before_adapt(), assign_eqn_numbers(), mesh_pt(), nsub_mesh(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::oomph_info, and rebuild_global_mesh().

◆ refine_selected_elements() [2/6]

void Problem::refine_selected_elements	(	const unsigned &	i_mesh,
		const Vector< unsigned > &	elements_to_be_refined
	)

Refine specified submesh by splitting the elements identified by their numbers relative to the submesh, then rebuild the problem.

Refine specified submesh by splitting the elements identified by their numbers relative to the specified mesh, then rebuild the problem.

   {
     actions_before_adapt();
  
     // Number of submeshes?
     unsigned n_mesh = nsub_mesh();
  
     if (i_mesh >= n_mesh)
     {
       std::ostringstream error_message;
       error_message << "Problem only has " << n_mesh
                     << " submeshes. Cannot refine submesh " << i_mesh
                     << std::endl;
       throw OomphLibError(
         error_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
  
     // Refine single mesh if possible
     if (TreeBasedRefineableMeshBase* mmesh_pt =
           dynamic_cast<TreeBasedRefineableMeshBase*>(mesh_pt(i_mesh)))
     {
       mmesh_pt->refine_selected_elements(elements_to_be_refined);
     }
     else
     {
       oomph_info << "Info/Warning: Mesh cannot be refined " << std::endl;
     }
  
     if (n_mesh > 1)
     {
       // Rebuild the global mesh
       rebuild_global_mesh();
     }
  
     // Any actions after the adapatation phase
     actions_after_adapt();
  
     // Do equation numbering
     oomph_info << "Number of equations: " << assign_eqn_numbers() << std::endl;
   }

References actions_after_adapt(), actions_before_adapt(), assign_eqn_numbers(), mesh_pt(), nsub_mesh(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::oomph_info, and rebuild_global_mesh().

◆ refine_selected_elements() [3/6]

void Problem::refine_selected_elements ( const Vector< RefineableElement * > & elements_to_be_refined_pt )

Refine (one and only!) mesh by splitting the elements identified by their pointers, then rebuild the problem.

   {
     actions_before_adapt();
  
     // Number of submeshes?
     unsigned Nmesh = nsub_mesh();
  
     // Single mesh:
     if (Nmesh == 0)
     {
       // Refine single mesh if possible
       if (TreeBasedRefineableMeshBase* mmesh_pt =
             dynamic_cast<TreeBasedRefineableMeshBase*>(mesh_pt(0)))
       {
         mmesh_pt->refine_selected_elements(elements_to_be_refined_pt);
       }
       else
       {
         oomph_info << "Info/Warning: Mesh cannot be refined " << std::endl;
       }
     }
     // Multiple submeshes
     else
     {
       std::ostringstream error_message;
       error_message << "Problem::refine_selected_elements(...) only works for\n"
                     << "multiple-mesh problems if you specify the mesh\n"
                     << "number in the function argument before the Vector,\n"
                     << "or a Vector of Vectors for each submesh.\n"
                     << std::endl;
       throw OomphLibError(
         error_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
  
     // Any actions after the adapatation phase
     actions_after_adapt();
  
     // Do equation numbering
     oomph_info << "Number of equations: " << assign_eqn_numbers() << std::endl;
   }

References actions_after_adapt(), actions_before_adapt(), assign_eqn_numbers(), mesh_pt(), nsub_mesh(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and oomph::oomph_info.

◆ refine_selected_elements() [4/6]

void Problem::refine_selected_elements ( const Vector< unsigned > & elements_to_be_refined )

Refine (one and only!) mesh by splitting the elements identified by their numbers relative to the problems' only mesh, then rebuild the problem.

   {
     actions_before_adapt();
  
     // Number of submeshes?
     unsigned Nmesh = nsub_mesh();
  
     // Single mesh:
     if (Nmesh == 0)
     {
       // Refine single mesh if possible
       if (TreeBasedRefineableMeshBase* mmesh_pt =
             dynamic_cast<TreeBasedRefineableMeshBase*>(mesh_pt(0)))
       {
         mmesh_pt->refine_selected_elements(elements_to_be_refined);
       }
       else
       {
         oomph_info << "Info/Warning: Mesh cannot be refined " << std::endl;
       }
     }
     // Multiple submeshes
     else
     {
       std::ostringstream error_message;
       error_message << "Problem::refine_selected_elements(...) only works for\n"
                     << "multiple-mesh problems if you specify the mesh\n"
                     << "number in the function argument before the Vector,\n"
                     << "or a Vector of Vectors for each submesh.\n"
                     << std::endl;
       throw OomphLibError(
         error_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
  
     // Any actions after the adapatation phase
     actions_after_adapt();
  
     // Attach the boundary conditions to the mesh
     oomph_info << "Number of equations: " << assign_eqn_numbers() << std::endl;
   }

References actions_after_adapt(), actions_before_adapt(), assign_eqn_numbers(), mesh_pt(), nsub_mesh(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and oomph::oomph_info.

◆ refine_selected_elements() [5/6]

void Problem::refine_selected_elements ( const Vector< Vector< RefineableElement * >> & elements_to_be_refined_pt )

Refine all submeshes by splitting the elements identified by their pointers within each submesh in a Vector of Vectors, then rebuild the problem.

   {
     actions_before_adapt();
  
     // Number of submeshes?
     unsigned n_mesh = nsub_mesh();
  
     // Refine all submeshes if possible
     for (unsigned i_mesh = 0; i_mesh < n_mesh; i_mesh++)
     {
       if (TreeBasedRefineableMeshBase* mmesh_pt =
             dynamic_cast<TreeBasedRefineableMeshBase*>(mesh_pt(i_mesh)))
       {
         mmesh_pt->refine_selected_elements(elements_to_be_refined_pt[i_mesh]);
       }
       else
       {
         oomph_info << "Info/Warning: Mesh cannot be refined " << std::endl;
       }
     }
  
     // Rebuild the global mesh
     rebuild_global_mesh();
  
     // Any actions after the adapatation phase
     actions_after_adapt();
  
     // Do equation numbering
     oomph_info << "Number of equations: " << assign_eqn_numbers() << std::endl;
   }

References actions_after_adapt(), actions_before_adapt(), assign_eqn_numbers(), mesh_pt(), nsub_mesh(), oomph::oomph_info, and rebuild_global_mesh().

◆ refine_selected_elements() [6/6]

void Problem::refine_selected_elements ( const Vector< Vector< unsigned >> & elements_to_be_refined )

Refine all submeshes by splitting the elements identified by their numbers relative to each submesh in a Vector of Vectors, then rebuild the problem.

   {
     actions_before_adapt();
  
     // Number of submeshes?
     unsigned n_mesh = nsub_mesh();
  
     // Refine all submeshes if possible
     for (unsigned i_mesh = 0; i_mesh < n_mesh; i_mesh++)
     {
       if (TreeBasedRefineableMeshBase* mmesh_pt =
             dynamic_cast<TreeBasedRefineableMeshBase*>(mesh_pt(i_mesh)))
       {
         mmesh_pt->refine_selected_elements(elements_to_be_refined[i_mesh]);
       }
       else
       {
         oomph_info << "Info/Warning: Mesh cannot be refined " << std::endl;
       }
     }
  
     // Rebuild the global mesh
     rebuild_global_mesh();
  
     // Any actions after the adapatation phase
     actions_after_adapt();
  
     // Do equation numbering
     oomph_info << "Number of equations: " << assign_eqn_numbers() << std::endl;
   }

References actions_after_adapt(), actions_before_adapt(), assign_eqn_numbers(), mesh_pt(), nsub_mesh(), oomph::oomph_info, and rebuild_global_mesh().

◆ refine_uniformly() [1/6]

void oomph::Problem::refine_uniformly ( )

inline

Refine (all) refineable (sub)mesh(es) uniformly and rebuild problem

     {
       DocInfo doc_info;
       doc_info.disable_doc();
       refine_uniformly(doc_info);
     }

References oomph::DocInfo::disable_doc().

Referenced by FSIRingProblem::dynamic_run(), QuarterCircleDrivenCavityProblem< ELEMENT >::QuarterCircleDrivenCavityProblem(), QuarterCircleDrivenCavityProblem2< ELEMENT >::QuarterCircleDrivenCavityProblem2(), read(), UnsteadyHeatProblem< ELEMENT >::refine_uniformly(), and refine_uniformly().

◆ refine_uniformly() [2/6]

void oomph::Problem::refine_uniformly ( const unsigned & i_mesh )

inline

Do uniform refinement for submesh i_mesh without documentation.

     {
       DocInfo doc_info;
       doc_info.disable_doc();
       refine_uniformly(i_mesh, doc_info);
     }

References oomph::DocInfo::disable_doc(), and refine_uniformly().

◆ refine_uniformly() [3/6]

void Problem::refine_uniformly	(	const unsigned &	i_mesh,
		DocInfo &	doc_info
	)

Do uniform refinement for submesh i_mesh with documentation.

Refine submesh i_mesh uniformly and rebuild problem; doc refinement process.

   {
     actions_before_adapt();
  
 #ifdef PARANOID
     // Number of submeshes?
     if (i_mesh >= nsub_mesh())
     {
       std::ostringstream error_message;
       error_message << "imesh " << i_mesh
                     << " is greater than the number of sub meshes "
                     << nsub_mesh() << std::endl;
  
       throw OomphLibError(
         error_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
 #endif
  
     // Refine single mesh uniformly if possible
     if (RefineableMeshBase* mmesh_pt =
           dynamic_cast<RefineableMeshBase*>(mesh_pt(i_mesh)))
     {
       mmesh_pt->refine_uniformly(doc_info);
     }
     else
     {
       oomph_info << "Info/Warning: Mesh cannot be refined uniformly "
                  << std::endl;
     }
  
     // Rebuild the global mesh
     rebuild_global_mesh();
  
     // Any actions after the adaptation phase
     actions_after_adapt();
  
     // Do equation numbering
     oomph_info << "Number of equations: " << assign_eqn_numbers() << std::endl;
   }

References actions_after_adapt(), actions_before_adapt(), assign_eqn_numbers(), mesh_pt(), nsub_mesh(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::oomph_info, and rebuild_global_mesh().

◆ refine_uniformly() [4/6]

void oomph::Problem::refine_uniformly ( const Vector< unsigned > & nrefine_for_mesh )

inline

Refine refineable sub-meshes, each as many times as specified in the vector and rebuild problem

     {
       DocInfo doc_info;
       doc_info.disable_doc();
       bool prune = false;
       refine_uniformly_aux(nrefine_for_mesh, doc_info, prune);
     }

References oomph::DocInfo::disable_doc(), and refine_uniformly_aux().

Referenced by main(), and parallel_test().

◆ refine_uniformly() [5/6]

void oomph::Problem::refine_uniformly	(	const Vector< unsigned > &	nrefine_for_mesh,
		DocInfo &	doc_info
	)

inline

Refine refineable sub-meshes, each as many times as specified in the vector and rebuild problem; doc refinement process

     {
       bool prune = false;
       refine_uniformly_aux(nrefine_for_mesh, doc_info, prune);
     }

References refine_uniformly_aux().

◆ refine_uniformly() [6/6]

void oomph::Problem::refine_uniformly ( DocInfo & doc_info )

inline

Refine (all) refineable (sub)mesh(es) uniformly and rebuild problem; doc refinement process.

     {
       // Number of (sub)meshes
       unsigned nmesh = std::max(unsigned(1), nsub_mesh());
  
       // Refine each mesh once
       Vector<unsigned> nrefine_for_mesh(nmesh, 1);
       refine_uniformly(nrefine_for_mesh);
     }

References max, nsub_mesh(), and refine_uniformly().

◆ refine_uniformly_and_prune() [1/3]

void oomph::Problem::refine_uniformly_and_prune ( const Vector< unsigned > & nrefine_for_mesh )

inline

Refine refineable sub-meshes, each as many times as specified in the vector and rebuild problem. Prune after refinements

     {
       DocInfo doc_info;
       doc_info.disable_doc();
       bool prune = true;
       refine_uniformly_aux(nrefine_for_mesh, doc_info, prune);
     }

References oomph::DocInfo::disable_doc(), and refine_uniformly_aux().

Referenced by refine_uniformly_and_prune().

◆ refine_uniformly_and_prune() [2/3]

void oomph::Problem::refine_uniformly_and_prune	(	const Vector< unsigned > &	nrefine_for_mesh,
		DocInfo &	doc_info
	)

inline

Refine refineable sub-meshes, each as many times as specified in the vector and rebuild problem; doc refinement process

     {
       bool prune = true;
       refine_uniformly_aux(nrefine_for_mesh, doc_info, prune);
     }

References refine_uniformly_aux().

◆ refine_uniformly_and_prune() [3/3]

void oomph::Problem::refine_uniformly_and_prune ( DocInfo & doc_info )

inline

Refine (all) refineable (sub)mesh(es) uniformly and rebuild problem; doc refinement process.

     {
       // Number of (sub)meshes
       unsigned nmesh = std::max(unsigned(1), nsub_mesh());
  
       // Refine each mesh once
       Vector<unsigned> nrefine_for_mesh(nmesh, 1);
       refine_uniformly_and_prune(nrefine_for_mesh);
     }

References max, nsub_mesh(), and refine_uniformly_and_prune().

◆ refine_uniformly_aux()

void Problem::refine_uniformly_aux	(	const Vector< unsigned > &	nrefine_for_mesh,
		DocInfo &	doc_info,
		const bool &	prune
	)

private

Helper function to do compund refinement of (all) refineable (sub)mesh(es) uniformly as many times as specified in vector and rebuild problem; doc refinement process. Set boolean argument to true if you want to prune immediately after refining the meshes individually.

   {
     double t_start = 0.0;
     if (Global_timings::Doc_comprehensive_timings)
     {
       t_start = TimingHelpers::timer();
     }
  
     actions_before_adapt();
  
     double t_end = 0.0;
     if (Global_timings::Doc_comprehensive_timings)
     {
       t_end = TimingHelpers::timer();
       oomph_info
         << "Time for actions before adapt in Problem::refine_uniformly_aux(): "
         << t_end - t_start << std::endl;
       t_start = TimingHelpers::timer();
     }
  
     // Number of submeshes?
     unsigned n_mesh = nsub_mesh();
  
     // Single mesh:
     if (n_mesh == 0)
     {
       // Refine single mesh uniformly if possible
       if (RefineableMeshBase* mmesh_pt =
             dynamic_cast<RefineableMeshBase*>(mesh_pt(0)))
       {
         unsigned nref = nrefine_for_mesh[0];
         for (unsigned i = 0; i < nref; i++)
         {
           mmesh_pt->refine_uniformly(doc_info);
         }
       }
       else
       {
         oomph_info << "Info/Warning: Mesh cannot be refined uniformly "
                    << std::endl;
       }
     }
     // Multiple submeshes
     else
     {
       // Loop over submeshes
       for (unsigned imesh = 0; imesh < n_mesh; imesh++)
       {
         // Refine i-th submesh uniformly if possible
         if (RefineableMeshBase* mmesh_pt =
               dynamic_cast<RefineableMeshBase*>(mesh_pt(imesh)))
         {
           unsigned nref = nrefine_for_mesh[imesh];
           for (unsigned i = 0; i < nref; i++)
           {
             mmesh_pt->refine_uniformly(doc_info);
           }
         }
         else
         {
           oomph_info << "Info/Warning: Cannot refine mesh " << imesh
                      << std::endl;
         }
       }
       // Rebuild the global mesh
       rebuild_global_mesh();
     }
  
     if (Global_timings::Doc_comprehensive_timings)
     {
       t_end = TimingHelpers::timer();
       oomph_info << "Time for mesh-level mesh refinement in "
                  << "Problem::refine_uniformly_aux(): " << t_end - t_start
                  << std::endl;
       t_start = TimingHelpers::timer();
     }
  
     // Any actions after the adaptation phase
     actions_after_adapt();
  
  
     if (Global_timings::Doc_comprehensive_timings)
     {
       t_end = TimingHelpers::timer();
       oomph_info
         << "Time for actions after adapt  Problem::refine_uniformly_aux(): "
         << t_end - t_start << std::endl;
       t_start = TimingHelpers::timer();
     }
  
  
 #ifdef OOMPH_HAS_MPI
  
     // Prune it?
     if (prune)
     {
       // Note: This calls assign eqn numbers already...
       Bypass_increase_in_dof_check_during_pruning = true;
       prune_halo_elements_and_nodes();
       Bypass_increase_in_dof_check_during_pruning = false;
  
       if (Global_timings::Doc_comprehensive_timings)
       {
         t_end = TimingHelpers::timer();
         oomph_info << "Time for Problem::prune_halo_elements_and_nodes() in "
                    << "Problem::refine_uniformly_aux(): " << t_end - t_start
                    << std::endl;
       }
     }
     else
 #else
     if (prune)
     {
       std::ostringstream error_message;
       error_message
         << "Requested pruning in serial build. Ignoring the request.\n";
       OomphLibWarning(error_message.str(),
                       "Problem::refine_uniformly_aux()",
                       OOMPH_EXCEPTION_LOCATION);
     }
 #endif
     {
       // Do equation numbering
       oomph_info
         << "Number of equations after Problem::refine_uniformly_aux(): "
         << assign_eqn_numbers() << std::endl;
  
       if (Global_timings::Doc_comprehensive_timings)
       {
         t_end = TimingHelpers::timer();
         oomph_info << "Time for Problem::assign_eqn_numbers() in "
                    << "Problem::refine_uniformly_aux(): " << t_end - t_start
                    << std::endl;
       }
     }
   }

References actions_after_adapt(), actions_before_adapt(), assign_eqn_numbers(), oomph::Global_timings::Doc_comprehensive_timings, i, mesh_pt(), nsub_mesh(), OOMPH_EXCEPTION_LOCATION, oomph::oomph_info, rebuild_global_mesh(), and oomph::TimingHelpers::timer().

Referenced by refine_uniformly(), and refine_uniformly_and_prune().

◆ reset_arc_length_parameters()

void oomph::Problem::reset_arc_length_parameters ( )

inline

Reset the "internal" arc-length continuation parameters, so as to allow continuation in another parameter. N.B. The parameters that are reset are the "minimum" that are required, others should perhaps be reset, depending upon the application.

     {
       Theta_squared = 1.0;
       Sign_of_jacobian = 0;
       Continuation_direction = 1.0;
       Parameter_derivative = 1.0;
       First_jacobian_sign_change = false;
       Arc_length_step_taken = false;
       Dof_derivative.resize(0);
     }

References Arc_length_step_taken, Continuation_direction, Dof_derivative, First_jacobian_sign_change, Parameter_derivative, Sign_of_jacobian, and Theta_squared.

◆ reset_assembly_handler_to_default()

void Problem::reset_assembly_handler_to_default ( )

Reset the system to the standard non-augemented state.

Reset the assembly handler to default.

   {
     // If we have a non-default handler
     if (Assembly_handler_pt != Default_assembly_handler_pt)
     {
       // Delete the current assembly handler
       delete Assembly_handler_pt;
       // Reset the assembly handler
       Assembly_handler_pt = Default_assembly_handler_pt;
     }
   }

References Assembly_handler_pt, and Default_assembly_handler_pt.

Referenced by activate_bifurcation_tracking(), activate_fold_tracking(), activate_hopf_tracking(), activate_pitchfork_tracking(), and deactivate_bifurcation_tracking().

◆ restore_dof_values()

void Problem::restore_dof_values ( )

Restore the stored values of the degrees of freedom.

Restore the saved dofs.

   {
     // Check that we can do this
     if (Saved_dof_pt == 0)
     {
       throw OomphLibError(
         "There are no stored values, use store_current_dof_values()\n",
         OOMPH_CURRENT_FUNCTION,
         OOMPH_EXCEPTION_LOCATION);
     }
  
  
 #ifdef OOMPH_HAS_MPI
     // If the problem is distributed I have to do something different
     if (Problem_has_been_distributed)
     {
       // How many entries do we store locally?
       const unsigned n_row_local = Dof_distribution_pt->nrow_local();
  
       if (Saved_dof_pt->size() != n_row_local)
       {
         throw OomphLibError("The number of stored values is not equal to the "
                             "current number of dofs\n",
                             OOMPH_CURRENT_FUNCTION,
                             OOMPH_EXCEPTION_LOCATION);
       }
  
       // Transfer the values over
       for (unsigned long n = 0; n < n_row_local; n++)
       {
         *(this->Dof_pt[n]) = (*Saved_dof_pt)[n];
       }
     }
     // Otherwise just restore all the dofs
     else
 #endif
     {
       // Find the number of dofs
       unsigned long n_dof = ndof();
  
       if (Saved_dof_pt->size() != n_dof)
       {
         throw OomphLibError("The number of stored values is not equal to the "
                             "current number of dofs\n",
                             OOMPH_CURRENT_FUNCTION,
                             OOMPH_EXCEPTION_LOCATION);
       }
  
       // Transfer the values over
       for (unsigned long n = 0; n < n_dof; n++)
       {
         dof(n) = (*Saved_dof_pt)[n];
       }
     }
  
     // Delete the memory
     delete Saved_dof_pt;
     Saved_dof_pt = 0;
   }

References dof(), Dof_distribution_pt, Dof_pt, n, ndof(), oomph::LinearAlgebraDistribution::nrow_local(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and Saved_dof_pt.

Referenced by calculate_predictions().

◆ self_test()

unsigned Problem::self_test ( )

Self-test: Check meshes and global data. Return 0 for OK.

   {
     // Initialise
     bool passed = true;
  
     // Are there any submeshes?
     unsigned Nmesh = nsub_mesh();
  
     // Just one mesh: Check it
     if (Nmesh == 0)
     {
       if (mesh_pt()->self_test() != 0)
       {
         passed = false;
         oomph_info
           << "\n ERROR: Failed Mesh::self_test() for single mesh in problem"
           << std::endl;
       }
     }
     // Loop over all submeshes and check them
     else
     {
       for (unsigned imesh = 0; imesh < Nmesh; imesh++)
       {
         if (mesh_pt(imesh)->self_test() != 0)
         {
           passed = false;
           oomph_info << "\n ERROR: Failed Mesh::self_test() for mesh imesh"
                      << imesh << std::endl;
         }
       }
     }
  
  
     // Check global data
     unsigned Nglobal = Global_data_pt.size();
     for (unsigned iglobal = 0; iglobal < Nglobal; iglobal++)
     {
       if (Global_data_pt[iglobal]->self_test() != 0)
       {
         passed = false;
         oomph_info
           << "\n ERROR: Failed Data::self_test() for global data iglobal"
           << iglobal << std::endl;
       }
     }
  
  
 #ifdef OOMPH_HAS_MPI
  
     if (Problem_has_been_distributed)
     {
       // Note: This throws an error if it fails so no return is required.
       DocInfo tmp_doc_info;
       tmp_doc_info.disable_doc();
       check_halo_schemes(tmp_doc_info);
     }
  
 #endif
  
     // Return verdict
     if (passed)
     {
       return 0;
     }
     else
     {
       return 1;
     }
   }

References oomph::DocInfo::disable_doc(), Global_data_pt, mesh_pt(), nsub_mesh(), and oomph::oomph_info.

Referenced by oomph::BiharmonicProblem< DIM >::actions_before_newton_solve(), oomph::BiharmonicFluidProblem< DIM >::actions_before_newton_solve(), and main().

◆ set_analytic_dparameter()

void oomph::Problem::set_analytic_dparameter ( double *const & parameter_pt )

inline

Function to turn on analytic calculation of the parameter derivatives in continuation and bifurcation detection problems

     {
       Calculate_dparameter_analytic[parameter_pt] = true;
     }

References Calculate_dparameter_analytic.

◆ set_analytic_hessian_products()

void oomph::Problem::set_analytic_hessian_products ( )

inline

Function to turn on analytic calculation of the parameter derivatives in continuation and bifurcation detection problems

     {
       Calculate_hessian_products_analytic = true;
     }

References Calculate_hessian_products_analytic.

◆ set_consistent_pinned_values_for_continuation()

void Problem::set_consistent_pinned_values_for_continuation ( )

protected

Private helper function that is used to set the appropriate pinned values for continuation.

Private helper function that is used to set the appropriate pinned values for continuation. If the data is pinned, the its current value is always the same as the original value and the derivative is always zero. If these are not set properly then interpolation and projection in spatial adaptivity will not give the best answers.

   {
     // Set the consistent values for the global mesh
     Mesh_pt->set_consistent_pinned_values_for_continuation(
       &Continuation_time_stepper);
  
     // Deal with the spine meshes additional numbering separately
     const unsigned n_sub_mesh = this->nsub_mesh();
     // If there is only one mesh
     if (n_sub_mesh == 0)
     {
       if (SpineMesh* const spine_mesh_pt = dynamic_cast<SpineMesh*>(Mesh_pt))
       {
         spine_mesh_pt->set_consistent_pinned_spine_values_for_continuation(
           &Continuation_time_stepper);
       }
       // If it's a triangle mesh the we need to set the
     }
     // Otherwise loop over the sub meshes
     else
     {
       // Assign global equation numbers first
       for (unsigned i = 0; i < n_sub_mesh; i++)
       {
         if (SpineMesh* const spine_mesh_pt =
               dynamic_cast<SpineMesh*>(Sub_mesh_pt[i]))
         {
           spine_mesh_pt->set_consistent_pinned_spine_values_for_continuation(
             &Continuation_time_stepper);
         }
       }
     }
  
     // Also set time stepper for global data
     const unsigned n_global = Global_data_pt.size();
     for (unsigned i = 0; i < n_global; ++i)
     {
       Continuation_time_stepper.set_consistent_pinned_values(Global_data_pt[i]);
     }
   }

References Continuation_time_stepper, Global_data_pt, i, Mesh_pt, nsub_mesh(), oomph::ContinuationStorageScheme::set_consistent_pinned_values(), oomph::Mesh::set_consistent_pinned_values_for_continuation(), and Sub_mesh_pt.

Referenced by arc_length_step_solve_helper().

◆ set_dofs() [1/3]

void Problem::set_dofs ( const DoubleVector & dofs )

virtual

Set the values of the dofs.

Function that sets the values of the dofs in the object.

Reimplemented from oomph::ExplicitTimeSteppableObject.

   {
     const unsigned long n_dof = this->ndof();
 #ifdef PARANOID
     if (n_dof != dofs.nrow())
     {
       std::ostringstream error_stream;
       error_stream << "Number of degrees of freedom in vector argument "
                    << dofs.nrow() << "\n"
                    << "does not equal number of degrees of freedom in problem "
                    << n_dof;
       throw OomphLibError(
         error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
 #endif
     for (unsigned long l = 0; l < n_dof; l++)
     {
       *Dof_pt[l] = dofs[l];
     }
   }

References Dof_pt, ndof(), oomph::DistributableLinearAlgebraObject::nrow(), OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

Referenced by calculate_predictions(), and oomph::TR::setup_initial_derivative().

◆ set_dofs() [2/3]

void Problem::set_dofs	(	const unsigned &	t,
		DoubleVector &	dofs
	)

Set the history values of the dofs.

Set history values of dofs.

   {
 #ifdef PARANOID
     if (distributed())
     {
       throw OomphLibError("Not designed for distributed problems",
                           OOMPH_EXCEPTION_LOCATION,
                           OOMPH_CURRENT_FUNCTION);
       // might work if the dofs vector is distributed in the right way...
     }
 #endif
  
     // First deal with global data
     unsigned Nglobal_data = nglobal_data();
     for (unsigned i = 0; i < Nglobal_data; i++)
     {
       for (unsigned j = 0, nj = Global_data_pt[i]->nvalue(); j < nj; j++)
       {
         // For each data get the equation number and copy out the value.
         int eqn_number = Global_data_pt[i]->eqn_number(j);
         if (eqn_number >= 0)
         {
           Global_data_pt[i]->set_value(t, j, dofs[eqn_number]);
         }
       }
     }
  
     // Next element internal data
     for (unsigned i = 0, ni = mesh_pt()->nelement(); i < ni; i++)
     {
       GeneralisedElement* ele_pt = mesh_pt()->element_pt(i);
       for (unsigned j = 0, nj = ele_pt->ninternal_data(); j < nj; j++)
       {
         Data* d_pt = ele_pt->internal_data_pt(j);
         for (unsigned k = 0, nk = d_pt->nvalue(); k < nk; k++)
         {
           int eqn_number = d_pt->eqn_number(k);
           if (eqn_number >= 0)
           {
             d_pt->set_value(t, k, dofs[eqn_number]);
           }
         }
       }
     }
  
     // Now the nodes
     for (unsigned i = 0, ni = mesh_pt()->nnode(); i < ni; i++)
     {
       Node* node_pt = mesh_pt()->node_pt(i);
       for (unsigned j = 0, nj = node_pt->nvalue(); j < nj; j++)
       {
         // For each node get the equation number and copy out the value.
         int eqn_number = node_pt->eqn_number(j);
         if (eqn_number >= 0)
         {
           node_pt->set_value(t, j, dofs[eqn_number]);
         }
       }
     }
   }

References distributed(), oomph::Mesh::element_pt(), oomph::Data::eqn_number(), Global_data_pt, i, oomph::GeneralisedElement::internal_data_pt(), j, k, mesh_pt(), nglobal_data(), oomph::GeneralisedElement::ninternal_data(), oomph::Mesh::node_pt(), oomph::Data::nvalue(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::Data::set_value(), and plotPSD::t.

◆ set_dofs() [3/3]

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

Set history values of dofs from the type of vector stored in problem::Dof_pt.

   {
 #ifdef PARANOID
     if (distributed())
     {
       throw OomphLibError("Not implemented for distributed problems!",
                           OOMPH_EXCEPTION_LOCATION,
                           OOMPH_CURRENT_FUNCTION);
     }
 #endif
  
     // If we have any spine meshes I think there might be more degrees
     // of freedom there. I don't use them though so I'll let someone who
     // knows what they are doing handle it. --David Shepherd
  
     // First deal with global data
     unsigned Nglobal_data = nglobal_data();
     for (unsigned i = 0; i < Nglobal_data; i++)
     {
       for (unsigned j = 0, nj = Global_data_pt[i]->nvalue(); j < nj; j++)
       {
         // For each data get the equation number and copy in the value.
         int eqn_number = Global_data_pt[i]->eqn_number(j);
         if (eqn_number >= 0)
         {
           Global_data_pt[i]->set_value(t, j, *(dof_pt[eqn_number]));
         }
       }
     }
  
     // Now the mesh data
     // nodes
     for (unsigned i = 0, ni = mesh_pt()->nnode(); i < ni; i++)
     {
       Node* node_pt = mesh_pt()->node_pt(i);
       for (unsigned j = 0, nj = node_pt->nvalue(); j < nj; j++)
       {
         // For each node get the equation number and copy in the value.
         int eqn_number = node_pt->eqn_number(j);
         if (eqn_number >= 0)
         {
           node_pt->set_value(t, j, *(dof_pt[eqn_number]));
         }
       }
     }
  
     // and non-nodal data inside elements
     for (unsigned i = 0, ni = mesh_pt()->nelement(); i < ni; i++)
     {
       GeneralisedElement* ele_pt = mesh_pt()->element_pt(i);
       for (unsigned j = 0, nj = ele_pt->ninternal_data(); j < nj; j++)
       {
         Data* data_pt = ele_pt->internal_data_pt(j);
         // For each node get the equation number and copy in the value.
         int eqn_number = data_pt->eqn_number(j);
         if (eqn_number >= 0)
         {
           data_pt->set_value(t, j, *(dof_pt[eqn_number]));
         }
       }
     }
   }

References distributed(), dof_pt(), oomph::Mesh::element_pt(), oomph::Data::eqn_number(), Global_data_pt, i, oomph::GeneralisedElement::internal_data_pt(), j, mesh_pt(), nglobal_data(), oomph::GeneralisedElement::ninternal_data(), oomph::Mesh::node_pt(), oomph::Data::nvalue(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::Data::set_value(), and plotPSD::t.

◆ set_explicit_time_stepper_pt()

void Problem::set_explicit_time_stepper_pt ( ExplicitTimeStepper *const & explicit_time_stepper_pt )

Set the explicit timestepper for the problem. The function will automatically create or resize the Time object so that it contains the appropriate number of levels of storage

Set the explicit time stepper for the problem and also ensure that a time object has been created.

   {
     // Set the explicit time stepper
     Explicit_time_stepper_pt = explicit_time_stepper_pt;
  
     // If time has not been allocated, create time object with the
     // required number of time steps
     if (Time_pt == 0)
     {
       Time_pt = new Time(0);
       oomph_info << "Created Time with storage for no previous timestep"
                  << std::endl;
     }
     else
     {
       oomph_info << "Time object already exists " << std::endl;
     }
   }

References Explicit_time_stepper_pt, explicit_time_stepper_pt(), oomph::oomph_info, and Time_pt.

◆ set_initial_condition()

virtual void oomph::Problem::set_initial_condition ( )

inlineprotectedvirtual

Set initial condition (incl previous timesteps). We need to establish this interface because I.C. needs to be reset when problem is adapted during the first timestep.

     {
       std::ostringstream warn_message;
       warn_message
         << "Warning: We're using the default (empty) set_initial_condition().\n"
         << "If the initial conditions isn't re-assigned after a mesh adaption "
            "\n"
         << "the initial conditions will represent the interpolation of the \n"
         << "initial conditions that were assigned on the original coarse "
            "mesh.\n";
       OomphLibWarning(warn_message.str(),
                       "Problem::set_initial_condition()",
                       OOMPH_EXCEPTION_LOCATION);
  
       // Indicate that this function has been called. This flag is set so
       // that the unsteady_newton_solve routine can be instructed whether
       // or not to shift the history values. If set_initial_condition() has
       // been overloaded than this (default) function won't be called, and
       // so this flag will remain false (its default value). If
       // set_initial_condition() has not been overloaded then this function
       // will be called and the flag set to true.
       Default_set_initial_condition_called = true;
     }

References Default_set_initial_condition_called, and OOMPH_EXCEPTION_LOCATION.

Referenced by doubly_adaptive_unsteady_newton_solve_helper(), and unsteady_newton_solve().

◆ set_pinned_values_to_zero()

void Problem::set_pinned_values_to_zero ( )

Set all pinned values to zero. Used to set boundary conditions to be homogeneous in the copy of the problem used in adaptive bifurcation tracking (ALH: TEMPORARY HACK, WILL BE FIXED)

   {
     // NOTE THIS DOES NOT ZERO ANY SPINE DATA, but otherwise everything else
     // should be zeroed
  
     // Zero any pinned global Data
     const unsigned n_global_data = nglobal_data();
     for (unsigned i = 0; i < n_global_data; i++)
     {
       Data* const local_data_pt = Global_data_pt[i];
       const unsigned n_value = local_data_pt->nvalue();
       for (unsigned j = 0; j < n_value; j++)
       {
         // If the data value is pinned set the value to zero
         if (local_data_pt->is_pinned(j))
         {
           local_data_pt->set_value(j, 0.0);
         }
       }
     }
  
     // Loop over the submeshes:
     const unsigned n_sub_mesh = Sub_mesh_pt.size();
     if (n_sub_mesh == 0)
     {
       // Loop over the nodes in the element
       const unsigned n_node = Mesh_pt->nnode();
       for (unsigned n = 0; n < n_node; n++)
       {
         Node* const local_node_pt = Mesh_pt->node_pt(n);
         const unsigned n_value = local_node_pt->nvalue();
         for (unsigned j = 0; j < n_value; j++)
         {
           // If the data value is pinned set the value to zero
           if (local_node_pt->is_pinned(j))
           {
             local_node_pt->set_value(j, 0.0);
           }
         }
  
         // Try to cast to a solid node
         SolidNode* const local_solid_node_pt =
           dynamic_cast<SolidNode*>(local_node_pt);
         // If we are successful
         if (local_solid_node_pt)
         {
           // Find the dimension of the node
           const unsigned n_dim = local_solid_node_pt->ndim();
           // Find number of positions
           const unsigned n_position_type =
             local_solid_node_pt->nposition_type();
  
           for (unsigned k = 0; k < n_position_type; k++)
           {
             for (unsigned i = 0; i < n_dim; i++)
             {
               // If the generalised position is pinned,
               // set the value to zero
               if (local_solid_node_pt->position_is_pinned(k, i))
               {
                 local_solid_node_pt->x_gen(k, i) = 0.0;
               }
             }
           }
         }
       }
  
       // Now loop over the element's and zero the internal data
       const unsigned n_element = Mesh_pt->nelement();
       for (unsigned e = 0; e < n_element; e++)
       {
         GeneralisedElement* const local_element_pt = Mesh_pt->element_pt(e);
         const unsigned n_internal = local_element_pt->ninternal_data();
         for (unsigned i = 0; i < n_internal; i++)
         {
           Data* const local_data_pt = local_element_pt->internal_data_pt(i);
           const unsigned n_value = local_data_pt->nvalue();
           for (unsigned j = 0; j < n_value; j++)
           {
             // If the data value is pinned set the value to zero
             if (local_data_pt->is_pinned(j))
             {
               local_data_pt->set_value(j, 0.0);
             }
           }
         }
       } // End of loop over elements
     }
     else
     {
       // Alternatively loop over all sub meshes
       for (unsigned m = 0; m < n_sub_mesh; m++)
       {
         // Loop over the nodes in the element
         const unsigned n_node = Sub_mesh_pt[m]->nnode();
         for (unsigned n = 0; n < n_node; n++)
         {
           Node* const local_node_pt = Sub_mesh_pt[m]->node_pt(n);
           const unsigned n_value = local_node_pt->nvalue();
           for (unsigned j = 0; j < n_value; j++)
           {
             // If the data value is pinned set the value to zero
             if (local_node_pt->is_pinned(j))
             {
               local_node_pt->set_value(j, 0.0);
             }
           }
  
           // Try to cast to a solid node
           SolidNode* const local_solid_node_pt =
             dynamic_cast<SolidNode*>(local_node_pt);
           // If we are successful
           if (local_solid_node_pt)
           {
             // Find the dimension of the node
             const unsigned n_dim = local_solid_node_pt->ndim();
             // Find number of positions
             const unsigned n_position_type =
               local_solid_node_pt->nposition_type();
  
             for (unsigned k = 0; k < n_position_type; k++)
             {
               for (unsigned i = 0; i < n_dim; i++)
               {
                 // If the generalised position is pinned,
                 // set the value to zero
                 if (local_solid_node_pt->position_is_pinned(k, i))
                 {
                   local_solid_node_pt->x_gen(k, i) = 0.0;
                 }
               }
             }
           }
         }
  
         // Now loop over the element's and zero the internal data
         const unsigned n_element = Sub_mesh_pt[m]->nelement();
         for (unsigned e = 0; e < n_element; e++)
         {
           GeneralisedElement* const local_element_pt =
             Sub_mesh_pt[m]->element_pt(e);
           const unsigned n_internal = local_element_pt->ninternal_data();
           for (unsigned i = 0; i < n_internal; i++)
           {
             Data* const local_data_pt = local_element_pt->internal_data_pt(i);
             const unsigned n_value = local_data_pt->nvalue();
             for (unsigned j = 0; j < n_value; j++)
             {
               // If the data value is pinned set the value to zero
               if (local_data_pt->is_pinned(j))
               {
                 local_data_pt->set_value(j, 0.0);
               }
             }
           }
         } // End of loop over elements
       }
     }
   }

References e(), oomph::Mesh::element_pt(), Global_data_pt, i, oomph::GeneralisedElement::internal_data_pt(), oomph::Data::is_pinned(), j, k, m, Mesh_pt, n, oomph::Node::ndim(), oomph::Mesh::nelement(), nglobal_data(), oomph::GeneralisedElement::ninternal_data(), oomph::Mesh::nnode(), oomph::Mesh::node_pt(), oomph::Node::nposition_type(), oomph::Data::nvalue(), oomph::SolidNode::position_is_pinned(), oomph::Data::set_value(), Sub_mesh_pt, and oomph::Node::x_gen().

◆ set_timestepper_for_all_data()

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

Set all problem data to have the same timestepper (timestepper_pt) Return the new number of dofs in the problem

Set all problem data to have the same timestepper (timestepper_pt). This is mainly used in continuation and bifurcation detection problems in which case the total number of unknowns may change and the changes to the underlying memory layout means that the Dof_pt must be reallocated. Thus, the function calls assign_eqn_numbers() and returns the number of new equation numbers.

   {
     // Set the timestepper for the master mesh's nodal and elemental data
     // to be the
     // continuation time stepper. This will wipe all storage other than
     // the 0th (present time) value at all the data objects
     Mesh_pt->set_nodal_and_elemental_time_stepper(time_stepper_pt,
                                                   preserve_existing_data);
  
     // Deal with the any additional mesh level timestepper data separately
     const unsigned n_sub_mesh = this->nsub_mesh();
     // If there is only one mesh
     if (n_sub_mesh == 0)
     {
       Mesh_pt->set_mesh_level_time_stepper(time_stepper_pt,
                                            preserve_existing_data);
     }
     // Otherwise loop over the sub meshes
     else
     {
       // Assign global equation numbers first
       for (unsigned i = 0; i < n_sub_mesh; i++)
       {
         this->Sub_mesh_pt[i]->set_mesh_level_time_stepper(
           time_stepper_pt, preserve_existing_data);
       }
     }
  
     // Also set time stepper for global data
     const unsigned n_global = Global_data_pt.size();
     for (unsigned i = 0; i < n_global; ++i)
     {
       Global_data_pt[i]->set_time_stepper(time_stepper_pt,
                                           preserve_existing_data);
     }
  
     // We now need to reassign equations numbers because the Dof pointer
     // will be inappropriate  because memory has been reallocated
  
 #ifdef OOMPH_HAS_MPI
     if (Problem_has_been_distributed)
     {
       std::ostringstream warning_stream;
       warning_stream << "This has not been comprehensively tested for "
                         "distributed problems.\n"
                      << "I'm sure that I need to worry about external halo and "
                         "external elements."
                      << std::endl;
       OomphLibWarning(
         warning_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
  
 #endif
  
     return (this->assign_eqn_numbers());
   }

References assign_eqn_numbers(), Global_data_pt, i, Mesh_pt, nsub_mesh(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::Mesh::set_mesh_level_time_stepper(), oomph::Mesh::set_nodal_and_elemental_time_stepper(), Sub_mesh_pt, and time_stepper_pt().

Referenced by arc_length_step_solve().

◆ setup_base_mesh_info_after_pruning()

void oomph::Problem::setup_base_mesh_info_after_pruning ( )

private

Helper function to re-setup the Base_mesh enumeration (used during load balancing) after pruning

◆ setup_element_count_per_dof()

unsigned Problem::setup_element_count_per_dof ( )

protected

Function that populates the Element_counter_per_dof vector with the number of elements that contribute to each dof. For example, with linear elements in 1D each dof contains contributions from two elements apart from those on the boundary. Returns the total number of elements in the problem

Setup the count vector that records how many elements contribute to each degree of freedom. Returns the total number of elements in the problem

   {
     // Now set the element counter to have the current Dof distribution
     Element_count_per_dof.build(this->Dof_distribution_pt);
     // We need to use the halo scheme (assuming it has been setup)
 #ifdef OOMPH_HAS_MPI
     Element_count_per_dof.build_halo_scheme(this->Halo_scheme_pt);
 #endif
  
     // Loop over the elements and count the entries
     // and number of (non-halo) elements
     const unsigned n_element = this->mesh_pt()->nelement();
     unsigned n_non_halo_element_local = 0;
     for (unsigned e = 0; e < n_element; e++)
     {
       GeneralisedElement* elem_pt = this->mesh_pt()->element_pt(e);
 #ifdef OOMPH_HAS_MPI
       // Ignore halo elements
       if (!elem_pt->is_halo())
       {
 #endif
         // Increment the number of non halo elements
         ++n_non_halo_element_local;
         // Now count the number of times the element contributes to a value
         // using the current assembly handler
         unsigned n_var = this->Assembly_handler_pt->ndof(elem_pt);
         for (unsigned n = 0; n < n_var; n++)
         {
           ++Element_count_per_dof.global_value(
             this->Assembly_handler_pt->eqn_number(elem_pt, n));
         }
 #ifdef OOMPH_HAS_MPI
       }
 #endif
     }
  
     // Storage for the total number of elements
     unsigned Nelement = 0;
  
     // Add together all the counts if we are in parallel
 #ifdef OOMPH_HAS_MPI
     Element_count_per_dof.sum_all_halo_and_haloed_values();
  
     // If distributed, find the total number of elements in the problem
     if (this->Problem_has_been_distributed)
     {
       // Need to gather the total number of non halo elements
       MPI_Allreduce(&n_non_halo_element_local,
                     &Nelement,
                     1,
                     MPI_UNSIGNED,
                     MPI_SUM,
                     this->communicator_pt()->mpi_comm());
     }
     // Otherwise the total number is the same on each processor
     else
 #endif
     {
       Nelement = n_non_halo_element_local;
     }
  
     return Nelement;
   }

References Assembly_handler_pt, oomph::DoubleVector::build(), oomph::DoubleVectorWithHaloEntries::build_halo_scheme(), communicator_pt(), Dof_distribution_pt, e(), Element_count_per_dof, oomph::Mesh::element_pt(), oomph::AssemblyHandler::eqn_number(), oomph::DoubleVectorWithHaloEntries::global_value(), mesh_pt(), n, oomph::AssemblyHandler::ndof(), oomph::Mesh::nelement(), and oomph::DoubleVectorWithHaloEntries::sum_all_halo_and_haloed_values().

◆ shift_time_values()

void Problem::shift_time_values ( )

virtual

Shift all values along to prepare for next timestep.

Shift all time-dependent data along for next timestep.

   {
     // Move the values of dt in the Time object
     Time_pt->shift_dt();
  
     // Only shift time values in the "master" mesh, otherwise things will
     // get shifted twice in complex problems
     Mesh_pt->shift_time_values();
  
     // Shift global data with their own timesteppers
     unsigned Nglobal = Global_data_pt.size();
     for (unsigned iglobal = 0; iglobal < Nglobal; iglobal++)
     {
       Global_data_pt[iglobal]->time_stepper_pt()->shift_time_values(
         Global_data_pt[iglobal]);
     }
   }

References Global_data_pt, Mesh_pt, oomph::Time::shift_dt(), oomph::Mesh::shift_time_values(), and Time_pt.

Referenced by adaptive_unsteady_newton_solve(), explicit_timestep(), unsteady_newton_solve(), and oomph::SegregatableFSIProblem::unsteady_segregated_solve().

◆ sign_of_jacobian()

int& oomph::Problem::sign_of_jacobian ( )

inline

Access function for the sign of the global jacobian matrix. This will be set by the linear solver, if possible (direct solver). If not alternative methods must be used to detect bifurcations (solving the associated eigenproblem).

     {
       return Sign_of_jacobian;
     }

References Sign_of_jacobian.

Referenced by oomph::AugmentedBlockFoldLinearSolver::solve(), oomph::BlockPitchForkLinearSolver::solve(), oomph::AugmentedBlockPitchForkLinearSolver::solve(), oomph::BlockHopfLinearSolver::solve(), oomph::HSL_MA42::solve(), oomph::DenseLU::solve(), oomph::FD_LU::solve(), oomph::SuperLUSolver::solve(), oomph::HSL_MA42::solve_for_one_dof(), oomph::BlockHopfLinearSolver::solve_for_two_rhs(), and oomph::SuperLUSolver::solve_transpose().

◆ solve_eigenproblem() [1/2]

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

inline

Solve an eigenproblem as assembled by EigenElements, but only return the eigenvalues, not the eigenvectors. The boolean flag (default true) is used to specify whether the weighted mass-matrix terms from the timestepping scheme should be included in the jacobian.

     {
       // Create temporary storage for the eigenvectors (potentially wasteful)
       Vector<DoubleVector> eigenvector;
       solve_eigenproblem(n_eval, eigenvalue, eigenvector, steady);
     }

References solve_eigenproblem().

◆ solve_eigenproblem() [2/2]

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

Solve the eigenproblem.

Get derivative of an element in the problem wrt a global parameter, used in continuation problems Solve an eigenproblem as assembled by EigenElements calculate n_eval eigenvalues and return the corresponding eigenvectors. The boolean flag (default true) specifies whether the steady jacobian should be assembled. If the flag is false then the weighted mass-matrix terms from the timestepper will be included in the jacobian — this is almost certainly never wanted.

Get derivative of an element in the problem wrt a global parameter, to be used in continuation problems

   {
     // If the boolean flag is steady, then make all the timesteppers steady
     // before solving the eigenproblem. This will "switch off" the
     // time-derivative terms in the jacobian matrix
     if (steady)
     {
       // Find out how many timesteppers there are
       const unsigned n_time_steppers = ntime_stepper();
  
       // Vector of bools to store the is_steady status of the various
       // timesteppers when we came in here
       std::vector<bool> was_steady(n_time_steppers);
  
       // Loop over them all and make them (temporarily) static
       for (unsigned i = 0; i < n_time_steppers; i++)
       {
         was_steady[i] = time_stepper_pt(i)->is_steady();
         time_stepper_pt(i)->make_steady();
       }
  
       // Call the Eigenproblem for the eigensolver
       Eigen_solver_pt->solve_eigenproblem(
         this, n_eval, eigenvalue, eigenvector);
  
       // Reset the is_steady status of all timesteppers that
       // weren't already steady when we came in here and reset their
       // weights
       for (unsigned i = 0; i < n_time_steppers; i++)
       {
         if (!was_steady[i])
         {
           time_stepper_pt(i)->undo_make_steady();
         }
       }
     }
     // Otherwise if we don't want to make the problem steady, just
     // assemble and solve the eigensystem
     else
     {
       // Call the Eigenproblem for the eigensolver
       Eigen_solver_pt->solve_eigenproblem(
         this, n_eval, eigenvalue, eigenvector);
     }
   }

References Eigen_solver_pt, i, oomph::TimeStepper::is_steady(), oomph::TimeStepper::make_steady(), ntime_stepper(), oomph::EigenSolver::solve_eigenproblem(), time_stepper_pt(), and oomph::TimeStepper::undo_make_steady().

Referenced by solve_eigenproblem().

◆ sparse_assemble_row_or_column_compressed()

void Problem::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 * > &	residuals,
		bool	compressed_row_flag
	)

protectedvirtual

Protected helper function that is used to assemble the Jacobian matrix in the case when the storage is row or column compressed. The boolean Flag indicates if we want compressed row format (true) or compressed column.

This is a (private) helper function that is used to assemble system matrices in compressed row or column format and compute residual vectors. The default action is to assemble the jacobian matrix and residuals for the Newton method. The action can be overloaded at an elemental level by changing the default behaviour of the function Element::get_all_vectors_and_matrices(). column_or_row_index: Column [or row] index of given entry row_or_column_start: Index of first entry for given row [or column] value : Vector of nonzero entries residuals : Residual vector compressed_row_flag: Bool flag to indicate if storage format is compressed row [if false interpretation of arguments is as stated in square brackets]. We provide four different assembly methods, each with different memory requirements/execution speeds. The method is set by the public flag Problem::Sparse_assembly_method.

   {
     // Choose the actual method
     switch (Sparse_assembly_method)
     {
       case Perform_assembly_using_vectors_of_pairs:
  
         sparse_assemble_row_or_column_compressed_with_vectors_of_pairs(
           column_or_row_index,
           row_or_column_start,
           value,
           nnz,
           residuals,
           compressed_row_flag);
  
         break;
  
       case Perform_assembly_using_two_vectors:
  
         sparse_assemble_row_or_column_compressed_with_two_vectors(
           column_or_row_index,
           row_or_column_start,
           value,
           nnz,
           residuals,
           compressed_row_flag);
  
         break;
  
       case Perform_assembly_using_maps:
  
         sparse_assemble_row_or_column_compressed_with_maps(column_or_row_index,
                                                            row_or_column_start,
                                                            value,
                                                            nnz,
                                                            residuals,
                                                            compressed_row_flag);
  
         break;
  
       case Perform_assembly_using_lists:
  
         sparse_assemble_row_or_column_compressed_with_lists(
           column_or_row_index,
           row_or_column_start,
           value,
           nnz,
           residuals,
           compressed_row_flag);
  
         break;
  
       case Perform_assembly_using_two_arrays:
  
         sparse_assemble_row_or_column_compressed_with_two_arrays(
           column_or_row_index,
           row_or_column_start,
           value,
           nnz,
           residuals,
           compressed_row_flag);
  
         break;
  
       default:
  
         std::ostringstream error_stream;
         error_stream
           << "Error: Incorrect value for Problem::Sparse_assembly_method"
           << Sparse_assembly_method << std::endl
           << "It should be one of the enumeration Problem::Assembly_method"
           << std::endl;
         throw OomphLibError(
           error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
   }

References OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, Perform_assembly_using_lists, Perform_assembly_using_maps, Perform_assembly_using_two_arrays, Perform_assembly_using_two_vectors, Perform_assembly_using_vectors_of_pairs, sparse_assemble_row_or_column_compressed_with_lists(), sparse_assemble_row_or_column_compressed_with_maps(), sparse_assemble_row_or_column_compressed_with_two_arrays(), sparse_assemble_row_or_column_compressed_with_two_vectors(), sparse_assemble_row_or_column_compressed_with_vectors_of_pairs(), Sparse_assembly_method, and Eigen::value.

Referenced by get_eigenproblem_matrices(), and get_jacobian().

◆ sparse_assemble_row_or_column_compressed_with_lists()

void Problem::sparse_assemble_row_or_column_compressed_with_lists	(	Vector< int * > &	column_or_row_index,
		Vector< int * > &	row_or_column_start,
		Vector< double * > &	value,
		Vector< unsigned > &	nnz,
		Vector< double * > &	residuals,
		bool	compressed_row_flag
	)

privatevirtual

Private helper function that is used to assemble the Jacobian matrix in the case when the storage is row or column compressed. The boolean Flag indicates if we want compressed row format (true) or compressed column. This version uses lists

This is a (private) helper function that is used to assemble system matrices in compressed row or column format and compute residual vectors using lists The default action is to assemble the jacobian matrix and residuals for the Newton method. The action can be overloaded at an elemental level by chaging the default behaviour of the function Element::get_all_vectors_and_matrices(). column_or_row_index: Column [or row] index of given entry row_or_column_start: Index of first entry for given row [or column] value : Vector of nonzero entries residuals : Residual vector compressed_row_flag: Bool flag to indicate if storage format is compressed row [if false interpretation of arguments is as stated in square brackets].

   {
     // Total number of elements
     const unsigned long n_elements = mesh_pt()->nelement();
  
     // Default range of elements for distributed problems
     unsigned long el_lo = 0;
     unsigned long el_hi = n_elements - 1;
  
 #ifdef OOMPH_HAS_MPI
     // Otherwise just loop over a fraction of the elements
     // (This will either have been initialised in
     // Problem::set_default_first_and_last_element_for_assembly() or
     // will have been re-assigned during a previous assembly loop
     // Note that following the re-assignment only the entries
     // for the current processor are relevant.
     if (!Problem_has_been_distributed)
     {
       el_lo = First_el_for_assembly[Communicator_pt->my_rank()];
       el_hi = Last_el_plus_one_for_assembly[Communicator_pt->my_rank()] - 1;
     }
 #endif
  
     // number of dofs
     unsigned ndof = this->ndof();
  
     // Find the number of vectors to be assembled
     const unsigned n_vector = residuals.size();
  
     // Find the number of matrices to be assembled
     const unsigned n_matrix = column_or_row_index.size();
  
     // Locally cache pointer to assembly handler
     AssemblyHandler* const assembly_handler_pt = Assembly_handler_pt;
  
 #ifdef OOMPH_HAS_MPI
     bool doing_residuals = false;
     if (dynamic_cast<ParallelResidualsHandler*>(Assembly_handler_pt) != 0)
     {
       doing_residuals = true;
     }
 #endif
  
 // Error check dimensions
 #ifdef PARANOID
     if (row_or_column_start.size() != n_matrix)
     {
       std::ostringstream error_stream;
       error_stream << "Error: " << std::endl
                    << "row_or_column_start.size() "
                    << row_or_column_start.size() << " does not equal "
                    << "column_or_row_index.size() "
                    << column_or_row_index.size() << std::endl;
       throw OomphLibError(
         error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
  
     if (value.size() != n_matrix)
     {
       std::ostringstream error_stream;
       error_stream
         << "Error in Problem::sparse_assemble_row_or_column_compressed "
         << std::endl
         << "value.size() " << value.size() << " does not equal "
         << "column_or_row_index.size() " << column_or_row_index.size()
         << std::endl
         << std::endl
         << std::endl;
       throw OomphLibError(
         error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
 #endif
  
     // The idea behind this sparse assembly routine is to use a vector of
     // lists for the entries in each row or column of the complete matrix.
     // The lists contain pairs of entries (global row/column number, value).
     // All non-zero contributions from each element are added to the lists.
     // We then sort each list by global row/column number and then combine
     // the entries corresponding to each row/column before adding to the
     // vectors column_or_row_index and value.
  
     // Note the trade off for "fast assembly" is that we will require
     // more memory during the assembly phase. Then again, if we can
     // only just assemble the sparse matrix, we're in real trouble.
  
     // Set up a vector of lists of paired entries of
     //(row/column index, jacobian matrix entry).
     // The entries of the vector correspond to all the rows or columns.
     // The use of the list storage scheme, should give fast insertion
     // and fast sorts later.
     Vector<Vector<std::list<std::pair<unsigned, double>>>> matrix_data_list(
       n_matrix);
     // Loop over the number of matrices and resize
     for (unsigned m = 0; m < n_matrix; m++)
     {
       matrix_data_list[m].resize(ndof);
     }
  
     // Resize the residuals vectors
     for (unsigned v = 0; v < n_vector; v++)
     {
       residuals[v] = new double[ndof];
       for (unsigned i = 0; i < ndof; i++)
       {
         residuals[v][i] = 0;
       }
     }
  
 #ifdef OOMPH_HAS_MPI
  
  
     // Storage for assembly time for elements
     double t_assemble_start = 0.0;
  
     // Storage for assembly times
     if ((!doing_residuals) && Must_recompute_load_balance_for_assembly)
     {
       Elemental_assembly_time.resize(n_elements);
     }
  
 #endif
  
     //------------Assemble and populate the lists-----------------------
     {
       // Allocate local storage for the element's contribution to the
       // residuals vectors and system matrices of the size of the maximum
       // number of dofs in any element.
       // This means that the stored is only allocated (and deleted) once
       Vector<Vector<double>> el_residuals(n_vector);
       Vector<DenseMatrix<double>> el_jacobian(n_matrix);
  
  
       // Pointer to a single list to be used during the assembly
       std::list<std::pair<unsigned, double>>* list_pt;
  
       // Loop over the all elements
       for (unsigned long e = el_lo; e <= el_hi; e++)
       {
 #ifdef OOMPH_HAS_MPI
         // Time it?
         if ((!doing_residuals) && Must_recompute_load_balance_for_assembly)
         {
           t_assemble_start = TimingHelpers::timer();
         }
 #endif
  
         // Get the pointer to the element
         GeneralisedElement* elem_pt = mesh_pt()->element_pt(e);
  
 #ifdef OOMPH_HAS_MPI
         // Ignore halo elements
         if (!elem_pt->is_halo())
         {
 #endif
  
           // Find number of degrees of freedom in the element
           const unsigned nvar = assembly_handler_pt->ndof(elem_pt);
  
           // Resize the storage for the elemental jacobian and residuals
           for (unsigned v = 0; v < n_vector; v++)
           {
             el_residuals[v].resize(nvar);
           }
           for (unsigned m = 0; m < n_matrix; m++)
           {
             el_jacobian[m].resize(nvar);
           }
  
           // Now get the residuals and jacobian for the element
           assembly_handler_pt->get_all_vectors_and_matrices(
             elem_pt, el_residuals, el_jacobian);
  
           //---------------- Insert the values into the lists -----------
  
           // Loop over the first index of local variables
           for (unsigned i = 0; i < nvar; i++)
           {
             // Get the local equation number
             unsigned eqn_number = assembly_handler_pt->eqn_number(elem_pt, i);
  
             // Add the contribution to the residuals
             for (unsigned v = 0; v < n_vector; v++)
             {
               // Fill in the residuals vector
               residuals[v][eqn_number] += el_residuals[v][i];
             }
  
             // Now loop over the other index
             for (unsigned j = 0; j < nvar; j++)
             {
               // Get the number of the unknown
               unsigned unknown = assembly_handler_pt->eqn_number(elem_pt, j);
  
               // Loop over the matrices
               for (unsigned m = 0; m < n_matrix; m++)
               {
                 // Get the value of the matrix at this point
                 double value = el_jacobian[m](i, j);
                 // Only add to theif it's non-zero
                 if (std::fabs(value) > Numerical_zero_for_sparse_assembly)
                 {
                   // If it's compressed row storage, then our vector is indexed
                   // by row (the equation number)
                   if (compressed_row_flag)
                   {
                     // Find the list that corresponds to the desired row
                     list_pt = &matrix_data_list[m][eqn_number];
                     // Insert the data into the list, the first entry
                     // in the pair is the unknown (column index),
                     // the second is the value itself.
                     list_pt->insert(list_pt->end(),
                                     std::make_pair(unknown, value));
                   }
                   // Otherwise it's compressed column storage, and our
                   // vector is indexed by column (the unknown)
                   else
                   {
                     // Find the list that corresponds to the desired column
                     list_pt = &matrix_data_list[m][unknown];
                     // Insert the data into the list, the first entry
                     // in the pair is the equation number (row index),
                     // the second is the value itself.
                     list_pt->insert(list_pt->end(),
                                     std::make_pair(eqn_number, value));
                   }
                 }
               }
             }
           }
  
 #ifdef OOMPH_HAS_MPI
         } // endif halo element
 #endif
  
  
 #ifdef OOMPH_HAS_MPI
         // Time it?
         if ((!doing_residuals) && Must_recompute_load_balance_for_assembly)
         {
           Elemental_assembly_time[e] =
             TimingHelpers::timer() - t_assemble_start;
         }
 #endif
  
       } // End of loop over the elements
  
     } // list_pt goes out of scope
  
  
 #ifdef OOMPH_HAS_MPI
  
     // Postprocess timing information and re-allocate distribution of
     // elements during subsequent assemblies.
     if ((!doing_residuals) && (!Problem_has_been_distributed) &&
         Must_recompute_load_balance_for_assembly)
     {
       recompute_load_balanced_assembly();
     }
  
     // We have determined load balancing for current setup.
     // This can remain the same until assign_eqn_numbers() is called
     // again -- the flag is re-set to true there.
     if ((!doing_residuals) && Must_recompute_load_balance_for_assembly)
     {
       Must_recompute_load_balance_for_assembly = false;
     }
  
 #endif
  
  
     //----Finally we need to convert the beautiful list storage scheme---
     //----------to the containers required by SuperLU--------------------
  
     // Loop over the number of matrices
     for (unsigned m = 0; m < n_matrix; m++)
     {
       // Set the number of rows or columns
       row_or_column_start[m] = new int[ndof + 1];
       // Counter for the total number of entries in the storage scheme
       unsigned long entry_count = 0;
       // The first entry is 0
       row_or_column_start[m][0] = entry_count;
  
       // first we compute the number of non-zeros
       nnz[m] = 0;
       for (unsigned long i_global = 0; i_global < ndof; i_global++)
       {
         nnz[m] += matrix_data_list[m][i_global].size();
       }
  
       // and then resize the storage
       column_or_row_index[m] = new int[nnz[m]];
       value[m] = new double[nnz[m]];
  
       // Now we merely loop over the number of rows or columns
       for (unsigned long i_global = 0; i_global < ndof; i_global++)
       {
         // Start index for the present row is the number of entries so far
         row_or_column_start[m][i_global] = entry_count;
         // If there are no entries in the list then skip the loop
         if (matrix_data_list[m][i_global].empty())
         {
           continue;
         }
  
         // Sort the list corresponding to this row or column by the
         // column or row index (first entry in the pair).
         // This might be inefficient, but we only have to do the sort ONCE
         // for each list. This is faster than using a map storage scheme, where
         // we are sorting for every insertion (although the map structure
         // is cleaner and more memory efficient)
         matrix_data_list[m][i_global].sort();
  
         // Set up an iterator for start of the list
         std::list<std::pair<unsigned, double>>::iterator it =
           matrix_data_list[m][i_global].begin();
  
         // Get the first row or column index in the list...
         unsigned current_index = it->first;
         //...and the corresponding value
         double current_value = it->second;
  
         // Loop over all the entries in the sorted list
         // Increase the iterator so that we start at the second entry
         for (++it; it != matrix_data_list[m][i_global].end(); ++it)
         {
           // If the index has not changed, then we must add the contribution
           // of the present entry to the value.
           // Additionally check that the entry is non-zero
           if ((it->first == current_index) &&
               (std::fabs(it->second) > Numerical_zero_for_sparse_assembly))
           {
             current_value += it->second;
           }
           // Otherwise, we have added all the contributions to the index
           // to current_value, so add it to the SuperLU data structure
           else
           {
             // Add the row or column index to the vector
             column_or_row_index[m][entry_count] = current_index;
             // Add the actual value to the vector
             value[m][entry_count] = current_value;
             // Increase the counter for the number of entries in each vector
             entry_count++;
  
             // Set the index and value to be those of the current entry in the
             // list
             current_index = it->first;
             current_value = it->second;
           }
         } // End of loop over all list entries for this global row or column
  
         // There are TWO special cases to consider.
         // If there is only one equation number in the list, then it
         // will NOT have been added. We test this case by comparing the
         // number of entries with those stored in row_or_column_start[i_global]
         // Otherwise
         // If the final entry in the list has the same index as the penultimate
         // entry, then it will NOT have been added to the SuperLU storage scheme
         // Check this by comparing the current_index with the final index
         // stored in the SuperLU scheme. If they are not the same, then
         // add the current_index and value.
  
         // If single equation number in list
         if ((static_cast<int>(entry_count) == row_or_column_start[m][i_global])
             // If we have a single equation number, this will not be evaluated.
             // If we don't then we do the test to check that the final
             // entry is added
             || (static_cast<int>(current_index) !=
                 column_or_row_index[m][entry_count - 1]))
         {
           // Add the row or column index to the vector
           column_or_row_index[m][entry_count] = current_index;
           // Add the actual value to the vector
           value[m][entry_count] = current_value;
           // Increase the counter for the number of entries in each vector
           entry_count++;
         }
  
       } // End of loop over the rows or columns of the entire matrix
  
       // Final entry in the row/column start vector
       row_or_column_start[m][ndof] = entry_count;
     } // End of loop over matrices
  
     if (Pause_at_end_of_sparse_assembly)
     {
       oomph_info << "Pausing at end of sparse assembly." << std::endl;
       pause("Check memory usage now.");
     }
   }

References Assembly_handler_pt, assembly_handler_pt(), Communicator_pt, e(), oomph::Mesh::element_pt(), oomph::AssemblyHandler::eqn_number(), boost::multiprecision::fabs(), oomph::AssemblyHandler::get_all_vectors_and_matrices(), i, j, m, mesh_pt(), oomph::OomphCommunicator::my_rank(), ndof(), oomph::AssemblyHandler::ndof(), oomph::Mesh::nelement(), Numerical_zero_for_sparse_assembly, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::oomph_info, oomph::pause(), Pause_at_end_of_sparse_assembly, oomph::TimingHelpers::timer(), v, and Eigen::value.

Referenced by sparse_assemble_row_or_column_compressed().

◆ sparse_assemble_row_or_column_compressed_with_maps()

void Problem::sparse_assemble_row_or_column_compressed_with_maps	(	Vector< int * > &	column_or_row_index,
		Vector< int * > &	row_or_column_start,
		Vector< double * > &	value,
		Vector< unsigned > &	nnz,
		Vector< double * > &	residuals,
		bool	compressed_row_flag
	)

privatevirtual

Private helper function that is used to assemble the Jacobian matrix in the case when the storage is row or column compressed. The boolean Flag indicates if we want compressed row format (true) or compressed column. This version uses maps

This is a (private) helper function that is used to assemble system matrices in compressed row or column format and compute residual vectors, using maps The default action is to assemble the jacobian matrix and residuals for the Newton method. The action can be overloaded at an elemental level by chaging the default behaviour of the function Element::get_all_vectors_and_matrices(). column_or_row_index: Column [or row] index of given entry row_or_column_start: Index of first entry for given row [or column] value : Vector of nonzero entries residuals : Residual vector compressed_row_flag: Bool flag to indicate if storage format is compressed row [if false interpretation of arguments is as stated in square brackets].

   {
     // Total number of elements
     const unsigned long n_elements = mesh_pt()->nelement();
  
     // Default range of elements for distributed problems
     unsigned long el_lo = 0;
     unsigned long el_hi = n_elements - 1;
  
 #ifdef OOMPH_HAS_MPI
     // Otherwise just loop over a fraction of the elements
     // (This will either have been initialised in
     // Problem::set_default_first_and_last_element_for_assembly() or
     // will have been re-assigned during a previous assembly loop
     // Note that following the re-assignment only the entries
     // for the current processor are relevant.
     if (!Problem_has_been_distributed)
     {
       el_lo = First_el_for_assembly[Communicator_pt->my_rank()];
       el_hi = Last_el_plus_one_for_assembly[Communicator_pt->my_rank()] - 1;
     }
 #endif
  
     // number of dofs
     unsigned ndof = this->ndof();
  
     // Find the number of vectors to be assembled
     const unsigned n_vector = residuals.size();
  
     // Find the number of matrices to be assembled
     const unsigned n_matrix = column_or_row_index.size();
  
     // Locally cache pointer to assembly handler
     AssemblyHandler* const assembly_handler_pt = Assembly_handler_pt;
  
 #ifdef OOMPH_HAS_MPI
     bool doing_residuals = false;
     if (dynamic_cast<ParallelResidualsHandler*>(Assembly_handler_pt) != 0)
     {
       doing_residuals = true;
     }
 #endif
  
 // Error check dimensions
 #ifdef PARANOID
     if (row_or_column_start.size() != n_matrix)
     {
       std::ostringstream error_stream;
       error_stream << "Error: " << std::endl
                    << "row_or_column_start.size() "
                    << row_or_column_start.size() << " does not equal "
                    << "column_or_row_index.size() "
                    << column_or_row_index.size() << std::endl;
       throw OomphLibError(
         error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
  
     if (value.size() != n_matrix)
     {
       std::ostringstream error_stream;
       error_stream
         << "Error in Problem::sparse_assemble_row_or_column_compressed "
         << std::endl
         << "value.size() " << value.size() << " does not equal "
         << "column_or_row_index.size() " << column_or_row_index.size()
         << std::endl
         << std::endl
         << std::endl;
       throw OomphLibError(
         error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
 #endif
  
  
     // The idea behind this sparse assembly routine is to use a vector of
     // maps for the entries in each row or column of the complete matrix.
     // The key for each map is the global row or column number and
     // the default comparison operator for integers means that each map
     // is ordered by the global row or column number. Thus, we need not
     // sort the maps, that happens at each insertion of a new entry. The
     // price we pay  is that for large maps, inseration is not a
     // cheap operation. Hash maps can be used to increase the speed, but then
     // the ordering is lost and we would have to sort anyway. The solution if
     // speed is required is to use lists, see below.
  
  
     // Set up a vector of vectors of maps of entries of each  matrix,
     // indexed by either the column or row. The entries of the vector for
     // each matrix correspond to all the rows or columns of that matrix.
     // The use of the map storage
     // scheme, with its implicit ordering on the first index, gives
     // a sparse ordered list of the entries in the given row or column.
     Vector<Vector<std::map<unsigned, double>>> matrix_data_map(n_matrix);
     // Loop over the number of matrices being assembled and resize
     // each vector of maps to the number of rows or columns of the matrix
     for (unsigned m = 0; m < n_matrix; m++)
     {
       matrix_data_map[m].resize(ndof);
     }
  
     // Resize the residuals vectors
     for (unsigned v = 0; v < n_vector; v++)
     {
       residuals[v] = new double[ndof];
       for (unsigned i = 0; i < ndof; i++)
       {
         residuals[v][i] = 0;
       }
     }
  
  
 #ifdef OOMPH_HAS_MPI
  
  
     // Storage for assembly time for elements
     double t_assemble_start = 0.0;
  
     // Storage for assembly times
     if ((!doing_residuals) && Must_recompute_load_balance_for_assembly)
     {
       Elemental_assembly_time.resize(n_elements);
     }
  
 #endif
  
     //----------------Assemble and populate the maps-------------------------
     {
       // Allocate local storage for the element's contribution to the
       // residuals vectors and system matrices of the size of the maximum
       // number of dofs in any element.
       // This means that the storage is only allocated (and deleted) once
       Vector<Vector<double>> el_residuals(n_vector);
       Vector<DenseMatrix<double>> el_jacobian(n_matrix);
  
       // Loop over the elements for this processor
       for (unsigned long e = el_lo; e <= el_hi; e++)
       {
 #ifdef OOMPH_HAS_MPI
         // Time it?
         if ((!doing_residuals) && Must_recompute_load_balance_for_assembly)
         {
           t_assemble_start = TimingHelpers::timer();
         }
 #endif
  
         // Get the pointer to the element
         GeneralisedElement* elem_pt = mesh_pt()->element_pt(e);
  
 #ifdef OOMPH_HAS_MPI
         // Ignore halo elements
         if (!elem_pt->is_halo())
         {
 #endif
  
           // Find number of degrees of freedom in the element
           const unsigned nvar = assembly_handler_pt->ndof(elem_pt);
  
           // Resize the storage for elemental jacobian and residuals
           for (unsigned v = 0; v < n_vector; v++)
           {
             el_residuals[v].resize(nvar);
           }
           for (unsigned m = 0; m < n_matrix; m++)
           {
             el_jacobian[m].resize(nvar);
           }
  
           // Now get the residuals and jacobian for the element
           assembly_handler_pt->get_all_vectors_and_matrices(
             elem_pt, el_residuals, el_jacobian);
  
           //---------------Insert the values into the maps--------------
  
           // Loop over the first index of local variables
           for (unsigned i = 0; i < nvar; i++)
           {
             // Get the local equation number
             unsigned eqn_number = assembly_handler_pt->eqn_number(elem_pt, i);
  
             // Add the contribution to the residuals
             for (unsigned v = 0; v < n_vector; v++)
             {
               // Fill in each residuals vector
               residuals[v][eqn_number] += el_residuals[v][i];
             }
  
             // Now loop over the other index
             for (unsigned j = 0; j < nvar; j++)
             {
               // Get the number of the unknown
               unsigned unknown = assembly_handler_pt->eqn_number(elem_pt, j);
  
               // Loop over the matrices
               for (unsigned m = 0; m < n_matrix; m++)
               {
                 // Get the value of the matrix at this point
                 double value = el_jacobian[m](i, j);
                 // Only bother to add to the map if it's non-zero
                 if (std::fabs(value) > Numerical_zero_for_sparse_assembly)
                 {
                   // If it's compressed row storage, then our vector of maps
                   // is indexed by row (equation number)
                   if (compressed_row_flag)
                   {
                     // Add the data into the map using the unknown as the map
                     // key
                     matrix_data_map[m][eqn_number][unknown] += value;
                   }
                   // Otherwise it's compressed column storage and our vector is
                   // indexed by column (the unknown)
                   else
                   {
                     // Add the data into the map using the eqn_numbe as the map
                     // key
                     matrix_data_map[m][unknown][eqn_number] += value;
                   }
                 }
               } // End of loop over matrices
             }
           }
  
 #ifdef OOMPH_HAS_MPI
         } // endif halo element
 #endif
  
  
 #ifdef OOMPH_HAS_MPI
         // Time it?
         if ((!doing_residuals) && Must_recompute_load_balance_for_assembly)
         {
           Elemental_assembly_time[e] =
             TimingHelpers::timer() - t_assemble_start;
         }
 #endif
  
       } // End of loop over the elements
  
     } // End of map assembly
  
  
 #ifdef OOMPH_HAS_MPI
  
     // Postprocess timing information and re-allocate distribution of
     // elements during subsequent assemblies.
     if ((!doing_residuals) && (!Problem_has_been_distributed) &&
         Must_recompute_load_balance_for_assembly)
     {
       recompute_load_balanced_assembly();
     }
  
     // We have determined load balancing for current setup.
     // This can remain the same until assign_eqn_numbers() is called
     // again -- the flag is re-set to true there.
     if ((!doing_residuals) && Must_recompute_load_balance_for_assembly)
     {
       Must_recompute_load_balance_for_assembly = false;
     }
  
 #endif
  
  
     //-----------Finally we need to convert the beautiful map storage scheme
     //------------------------to the containers required by SuperLU
  
     // Loop over the number of matrices
     for (unsigned m = 0; m < n_matrix; m++)
     {
       // Set the number of rows or columns
       row_or_column_start[m] = new int[ndof + 1];
       // Counter for the total number of entries in the storage scheme
       unsigned long entry_count = 0;
       row_or_column_start[m][0] = entry_count;
  
       // first we compute the number of non-zeros
       nnz[m] = 0;
       for (unsigned long i_global = 0; i_global < ndof; i_global++)
       {
         nnz[m] += matrix_data_map[m][i_global].size();
       }
  
       // and then resize the storage
       column_or_row_index[m] = new int[nnz[m]];
       value[m] = new double[nnz[m]];
  
       // Now we merely loop over the number of rows or columns
       for (unsigned long i_global = 0; i_global < ndof; i_global++)
       {
         // Start index for the present row
         row_or_column_start[m][i_global] = entry_count;
         // If there are no entries in the map then skip the rest of the loop
         if (matrix_data_map[m][i_global].empty())
         {
           continue;
         }
  
         // Loop over all the entries in the map corresponding to the given
         // row or column. It will be ordered
  
         for (std::map<unsigned, double>::iterator it =
                matrix_data_map[m][i_global].begin();
              it != matrix_data_map[m][i_global].end();
              ++it)
         {
           // The first value is the column or row index
           column_or_row_index[m][entry_count] = it->first;
           // The second value is the actual data value
           value[m][entry_count] = it->second;
           // Increase the value of the counter
           entry_count++;
         }
       }
  
       // Final entry in the row/column start vector
       row_or_column_start[m][ndof] = entry_count;
     } // End of the loop over the matrices
  
     if (Pause_at_end_of_sparse_assembly)
     {
       oomph_info << "Pausing at end of sparse assembly." << std::endl;
       pause("Check memory usage now.");
     }
   }

References Assembly_handler_pt, assembly_handler_pt(), Communicator_pt, e(), oomph::Mesh::element_pt(), oomph::AssemblyHandler::eqn_number(), boost::multiprecision::fabs(), oomph::AssemblyHandler::get_all_vectors_and_matrices(), i, j, m, mesh_pt(), oomph::OomphCommunicator::my_rank(), ndof(), oomph::AssemblyHandler::ndof(), oomph::Mesh::nelement(), Numerical_zero_for_sparse_assembly, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::oomph_info, oomph::pause(), Pause_at_end_of_sparse_assembly, oomph::TimingHelpers::timer(), v, and Eigen::value.

Referenced by sparse_assemble_row_or_column_compressed().

◆ sparse_assemble_row_or_column_compressed_with_two_arrays()

void Problem::sparse_assemble_row_or_column_compressed_with_two_arrays	(	Vector< int * > &	column_or_row_index,
		Vector< int * > &	row_or_column_start,
		Vector< double * > &	value,
		Vector< unsigned > &	nnz,
		Vector< double * > &	residuals,
		bool	compressed_row_flag
	)

privatevirtual

Private helper function that is used to assemble the Jacobian matrix in the case when the storage is row or column compressed. The boolean Flag indicates if we want compressed row format (true) or compressed column. This version uses lists

This is a (private) helper function that is used to assemble system matrices in compressed row or column format and compute residual vectors using two vectors. The default action is to assemble the jacobian matrix and residuals for the Newton method. The action can be overloaded at an elemental level by chaging the default behaviour of the function Element::get_all_vectors_and_matrices(). column_or_row_index: Column [or row] index of given entry row_or_column_start: Index of first entry for given row [or column] value : Vector of nonzero entries residuals : Residual vector compressed_row_flag: Bool flag to indicate if storage format is compressed row [if false interpretation of arguments is as stated in square brackets].

   {
     // Total number of elements
     const unsigned long n_elements = mesh_pt()->nelement();
  
     // Default range of elements for distributed problems
     unsigned long el_lo = 0;
     unsigned long el_hi = n_elements - 1;
  
  
 #ifdef OOMPH_HAS_MPI
     // Otherwise just loop over a fraction of the elements
     // (This will either have been initialised in
     // Problem::set_default_first_and_last_element_for_assembly() or
     // will have been re-assigned during a previous assembly loop
     // Note that following the re-assignment only the entries
     // for the current processor are relevant.
     if (!Problem_has_been_distributed)
     {
       el_lo = First_el_for_assembly[Communicator_pt->my_rank()];
       el_hi = Last_el_plus_one_for_assembly[Communicator_pt->my_rank()] - 1;
     }
 #endif
  
     // number of local eqns
     unsigned ndof = this->ndof();
  
     // Find the number of vectors to be assembled
     const unsigned n_vector = residuals.size();
  
     // Find the number of matrices to be assembled
     const unsigned n_matrix = column_or_row_index.size();
  
     // Locally cache pointer to assembly handler
     AssemblyHandler* const assembly_handler_pt = Assembly_handler_pt;
  
 #ifdef OOMPH_HAS_MPI
     bool doing_residuals = false;
     if (dynamic_cast<ParallelResidualsHandler*>(Assembly_handler_pt) != 0)
     {
       doing_residuals = true;
     }
 #endif
  
 // Error check dimensions
 #ifdef PARANOID
     if (row_or_column_start.size() != n_matrix)
     {
       std::ostringstream error_stream;
       error_stream << "Error: " << std::endl
                    << "row_or_column_start.size() "
                    << row_or_column_start.size() << " does not equal "
                    << "column_or_row_index.size() "
                    << column_or_row_index.size() << std::endl;
       throw OomphLibError(
         error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
  
     if (value.size() != n_matrix)
     {
       std::ostringstream error_stream;
       error_stream << "Error: " << std::endl
                    << "value.size() " << value.size() << " does not equal "
                    << "column_or_row_index.size() "
                    << column_or_row_index.size() << std::endl
                    << std::endl
                    << std::endl;
       throw OomphLibError(
         error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
 #endif
  
     // The idea behind this sparse assembly routine is to use Vectors of
     // Vectors for the entries in each complete matrix. And a second
     // Vector of Vectors stores the global row (or column) indeces. This
     // will not have the memory overheads associated with the methods using
     // lists or maps, but insertion will be more costly.
  
     // Set up two vector of vectors to store the entries of each  matrix,
     // indexed by either the column or row. The entries of the vector for
     // each matrix correspond to all the rows or columns of that matrix.
     Vector<unsigned**> matrix_row_or_col_indices(n_matrix);
     Vector<double**> matrix_values(n_matrix);
  
     // Loop over the number of matrices being assembled and resize
     // each vector of vectors to the number of rows or columns of the matrix
     for (unsigned m = 0; m < n_matrix; m++)
     {
       matrix_row_or_col_indices[m] = new unsigned*[ndof];
       matrix_values[m] = new double*[ndof];
     }
  
     // Resize the residuals vectors
     for (unsigned v = 0; v < n_vector; v++)
     {
       residuals[v] = new double[ndof];
       for (unsigned i = 0; i < ndof; i++)
       {
         residuals[v][i] = 0;
       }
     }
  
 #ifdef OOMPH_HAS_MPI
  
     // Storage for assembly time for elements
     double t_assemble_start = 0.0;
  
     // Storage for assembly times
     if ((!doing_residuals) && Must_recompute_load_balance_for_assembly)
     {
       Elemental_assembly_time.resize(n_elements);
     }
  
 #endif
  
     // number of coefficients in each row
     Vector<Vector<unsigned>> ncoef(n_matrix);
     for (unsigned m = 0; m < n_matrix; m++)
     {
       ncoef[m].resize(ndof, 0);
     }
  
     if (Sparse_assemble_with_arrays_previous_allocation.size() == 0)
     {
       Sparse_assemble_with_arrays_previous_allocation.resize(n_matrix);
       for (unsigned m = 0; m < n_matrix; m++)
       {
         Sparse_assemble_with_arrays_previous_allocation[m].resize(ndof, 0);
       }
     }
  
     //----------------Assemble and populate the vector storage scheme-------
     {
       // Allocate local storage for the element's contribution to the
       // residuals vectors and system matrices of the size of the maximum
       // number of dofs in any element
       // This means that the storage will only be allocated (and deleted) once
       Vector<Vector<double>> el_residuals(n_vector);
       Vector<DenseMatrix<double>> el_jacobian(n_matrix);
  
       // Loop over the elements
       for (unsigned long e = el_lo; e <= el_hi; e++)
       {
 #ifdef OOMPH_HAS_MPI
         // Time it?
         if ((!doing_residuals) && Must_recompute_load_balance_for_assembly)
         {
           t_assemble_start = TimingHelpers::timer();
         }
 #endif
  
         // Get the pointer to the element
         GeneralisedElement* elem_pt = mesh_pt()->element_pt(e);
  
 #ifdef OOMPH_HAS_MPI
         // Ignore halo elements
         if (!elem_pt->is_halo())
         {
 #endif
  
           // Find number of degrees of freedom in the element
           const unsigned nvar = assembly_handler_pt->ndof(elem_pt);
  
           // Resize the storage for elemental jacobian and residuals
           for (unsigned v = 0; v < n_vector; v++)
           {
             el_residuals[v].resize(nvar);
           }
           for (unsigned m = 0; m < n_matrix; m++)
           {
             el_jacobian[m].resize(nvar);
           }
  
           // Now get the residuals and jacobian for the element
           assembly_handler_pt->get_all_vectors_and_matrices(
             elem_pt, el_residuals, el_jacobian);
  
           //---------------Insert the values into the vectors--------------
  
           // Loop over the first index of local variables
           for (unsigned i = 0; i < nvar; i++)
           {
             // Get the local equation number
             unsigned eqn_number = assembly_handler_pt->eqn_number(elem_pt, i);
  
             // Add the contribution to the residuals
             for (unsigned v = 0; v < n_vector; v++)
             {
               // Fill in each residuals vector
               residuals[v][eqn_number] += el_residuals[v][i];
             }
  
             // Now loop over the other index
             for (unsigned j = 0; j < nvar; j++)
             {
               // Get the number of the unknown
               unsigned unknown = assembly_handler_pt->eqn_number(elem_pt, j);
  
               // Loop over the matrices
               // If it's compressed row storage, then our vector of maps
               // is indexed by row (equation number)
               for (unsigned m = 0; m < n_matrix; m++)
               {
                 // Get the value of the matrix at this point
                 double value = el_jacobian[m](i, j);
                 // Only bother to add to the vector if it's non-zero
                 if (std::fabs(value) > Numerical_zero_for_sparse_assembly)
                 {
                   // number of entrys in this row
                   const unsigned size = ncoef[m][eqn_number];
  
                   // if no data has been allocated for this row then allocate
                   if (size == 0)
                   {
                     // do we have previous allocation data
                     if (Sparse_assemble_with_arrays_previous_allocation
                           [m][eqn_number] != 0)
                     {
                       matrix_row_or_col_indices[m][eqn_number] = new unsigned
                         [Sparse_assemble_with_arrays_previous_allocation
                            [m][eqn_number]];
                       matrix_values[m][eqn_number] = new double
                         [Sparse_assemble_with_arrays_previous_allocation
                            [m][eqn_number]];
                     }
                     else
                     {
                       matrix_row_or_col_indices[m][eqn_number] = new unsigned
                         [Sparse_assemble_with_arrays_initial_allocation];
                       matrix_values[m][eqn_number] = new double
                         [Sparse_assemble_with_arrays_initial_allocation];
                       Sparse_assemble_with_arrays_previous_allocation
                         [m][eqn_number] =
                           Sparse_assemble_with_arrays_initial_allocation;
                     }
                   }
  
                   // If it's compressed row storage, then our vector of maps
                   // is indexed by row (equation number)
                   if (compressed_row_flag)
                   {
                     // next add the data
                     for (unsigned k = 0; k <= size; k++)
                     {
                       if (k == size)
                       {
                         // do we need to allocate more storage
                         if (Sparse_assemble_with_arrays_previous_allocation
                               [m][eqn_number] == ncoef[m][eqn_number])
                         {
                           unsigned new_allocation =
                             ncoef[m][eqn_number] +
                             Sparse_assemble_with_arrays_allocation_increment;
                           double* new_values = new double[new_allocation];
                           unsigned* new_indices = new unsigned[new_allocation];
                           for (unsigned c = 0; c < ncoef[m][eqn_number]; c++)
                           {
                             new_values[c] = matrix_values[m][eqn_number][c];
                             new_indices[c] =
                               matrix_row_or_col_indices[m][eqn_number][c];
                           }
                           delete[] matrix_values[m][eqn_number];
                           delete[] matrix_row_or_col_indices[m][eqn_number];
                           matrix_values[m][eqn_number] = new_values;
                           matrix_row_or_col_indices[m][eqn_number] =
                             new_indices;
                           Sparse_assemble_with_arrays_previous_allocation
                             [m][eqn_number] = new_allocation;
                         }
                         // and now add the data
                         unsigned entry = ncoef[m][eqn_number];
                         ncoef[m][eqn_number]++;
                         matrix_row_or_col_indices[m][eqn_number][entry] =
                           unknown;
                         matrix_values[m][eqn_number][entry] = value;
                         break;
                       }
                       else if (matrix_row_or_col_indices[m][eqn_number][k] ==
                                unknown)
                       {
                         matrix_values[m][eqn_number][k] += value;
                         break;
                       }
                     }
                   }
                   // Otherwise it's compressed column storage and our vector is
                   // indexed by column (the unknown)
                   else
                   {
                     // Add the data into the vectors in the correct position
                     for (unsigned k = 0; k <= size; k++)
                     {
                       if (k == size)
                       {
                         // do we need to allocate more storage
                         if (Sparse_assemble_with_arrays_previous_allocation
                               [m][unknown] == ncoef[m][unknown])
                         {
                           unsigned new_allocation =
                             ncoef[m][unknown] +
                             Sparse_assemble_with_arrays_allocation_increment;
                           double* new_values = new double[new_allocation];
                           unsigned* new_indices = new unsigned[new_allocation];
                           for (unsigned c = 0; c < ncoef[m][unknown]; c++)
                           {
                             new_values[c] = matrix_values[m][unknown][c];
                             new_indices[c] =
                               matrix_row_or_col_indices[m][unknown][c];
                           }
                           delete[] matrix_values[m][unknown];
                           delete[] matrix_row_or_col_indices[m][unknown];
                           Sparse_assemble_with_arrays_previous_allocation
                             [m][unknown] = new_allocation;
                         }
                         // and now add the data
                         unsigned entry = ncoef[m][unknown];
                         ncoef[m][unknown]++;
                         matrix_row_or_col_indices[m][unknown][entry] =
                           eqn_number;
                         matrix_values[m][unknown][entry] = value;
                         break;
                       }
                       else if (matrix_row_or_col_indices[m][unknown][k] ==
                                eqn_number)
                       {
                         matrix_values[m][unknown][k] += value;
                         break;
                       }
                     }
                   }
                 }
               } // End of loop over matrices
             }
           }
  
 #ifdef OOMPH_HAS_MPI
         } // endif halo element
 #endif
  
  
 #ifdef OOMPH_HAS_MPI
         // Time it?
         if ((!doing_residuals) && Must_recompute_load_balance_for_assembly)
         {
           Elemental_assembly_time[e] =
             TimingHelpers::timer() - t_assemble_start;
         }
 #endif
  
       } // End of loop over the elements
  
     } // End of vector assembly
  
  
 #ifdef OOMPH_HAS_MPI
  
     // Postprocess timing information and re-allocate distribution of
     // elements during subsequent assemblies.
     if ((!doing_residuals) && (!Problem_has_been_distributed) &&
         Must_recompute_load_balance_for_assembly)
     {
       recompute_load_balanced_assembly();
     }
  
     // We have determined load balancing for current setup.
     // This can remain the same until assign_eqn_numbers() is called
     // again -- the flag is re-set to true there.
     if ((!doing_residuals) && Must_recompute_load_balance_for_assembly)
     {
       Must_recompute_load_balance_for_assembly = false;
     }
  
 #endif
  
     //-----------Finally we need to convert this lousy vector storage scheme
     //------------------------to the containers required by SuperLU
  
     // Loop over the number of matrices
     for (unsigned m = 0; m < n_matrix; m++)
     {
       // Set the number of rows or columns
       row_or_column_start[m] = new int[ndof + 1];
  
       // fill row_or_column_start and find the number of entries
       row_or_column_start[m][0] = 0;
       for (unsigned long i = 0; i < ndof; i++)
       {
         row_or_column_start[m][i + 1] = row_or_column_start[m][i] + ncoef[m][i];
         Sparse_assemble_with_arrays_previous_allocation[m][i] = ncoef[m][i];
       }
       const unsigned entries = row_or_column_start[m][ndof];
  
       // resize vectors
       column_or_row_index[m] = new int[entries];
       value[m] = new double[entries];
       nnz[m] = entries;
  
       // Now we merely loop over the number of rows or columns
       for (unsigned long i_global = 0; i_global < ndof; i_global++)
       {
         // If there are no entries in the vector then skip the rest of the loop
         if (ncoef[m][i_global] == 0)
         {
           continue;
         }
  
         // Loop over all the entries in the vectors corresponding to the given
         // row or column. It will NOT be ordered
         unsigned p = 0;
         for (int j = row_or_column_start[m][i_global];
              j < row_or_column_start[m][i_global + 1];
              j++)
         {
           column_or_row_index[m][j] = matrix_row_or_col_indices[m][i_global][p];
           value[m][j] = matrix_values[m][i_global][p];
           ++p;
         }
  
         // and delete
         delete[] matrix_row_or_col_indices[m][i_global];
         delete[] matrix_values[m][i_global];
       }
  
       //
       delete[] matrix_row_or_col_indices[m];
       delete[] matrix_values[m];
     } // End of the loop over the matrices
  
     if (Pause_at_end_of_sparse_assembly)
     {
       oomph_info << "Pausing at end of sparse assembly." << std::endl;
       pause("Check memory usage now.");
     }
   }

References Assembly_handler_pt, assembly_handler_pt(), calibrate::c, Communicator_pt, e(), oomph::Mesh::element_pt(), oomph::AssemblyHandler::eqn_number(), boost::multiprecision::fabs(), oomph::AssemblyHandler::get_all_vectors_and_matrices(), i, j, k, m, mesh_pt(), oomph::OomphCommunicator::my_rank(), ndof(), oomph::AssemblyHandler::ndof(), oomph::Mesh::nelement(), Numerical_zero_for_sparse_assembly, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::oomph_info, p, oomph::pause(), Pause_at_end_of_sparse_assembly, size, Sparse_assemble_with_arrays_allocation_increment, Sparse_assemble_with_arrays_initial_allocation, Sparse_assemble_with_arrays_previous_allocation, oomph::TimingHelpers::timer(), v, and Eigen::value.

Referenced by sparse_assemble_row_or_column_compressed().

◆ sparse_assemble_row_or_column_compressed_with_two_vectors()

void Problem::sparse_assemble_row_or_column_compressed_with_two_vectors	(	Vector< int * > &	column_or_row_index,
		Vector< int * > &	row_or_column_start,
		Vector< double * > &	value,
		Vector< unsigned > &	nnz,
		Vector< double * > &	residuals,
		bool	compressed_row_flag
	)

privatevirtual

Private helper function that is used to assemble the Jacobian matrix in the case when the storage is row or column compressed. The boolean Flag indicates if we want compressed row format (true) or compressed column. This version uses two vectors.

This is a (private) helper function that is used to assemble system matrices in compressed row or column format and compute residual vectors using two vectors. The default action is to assemble the jacobian matrix and residuals for the Newton method. The action can be overloaded at an elemental level by chaging the default behaviour of the function Element::get_all_vectors_and_matrices(). column_or_row_index: Column [or row] index of given entry row_or_column_start: Index of first entry for given row [or column] value : Vector of nonzero entries residuals : Residual vector compressed_row_flag: Bool flag to indicate if storage format is compressed row [if false interpretation of arguments is as stated in square brackets].

   {
     // Total number of elements
     const unsigned long n_elements = mesh_pt()->nelement();
  
     // Default range of elements for distributed problems
     unsigned long el_lo = 0;
     unsigned long el_hi = n_elements - 1;
  
  
 #ifdef OOMPH_HAS_MPI
     // Otherwise just loop over a fraction of the elements
     // (This will either have been initialised in
     // Problem::set_default_first_and_last_element_for_assembly() or
     // will have been re-assigned during a previous assembly loop
     // Note that following the re-assignment only the entries
     // for the current processor are relevant.
     if (!Problem_has_been_distributed)
     {
       el_lo = First_el_for_assembly[Communicator_pt->my_rank()];
       el_hi = Last_el_plus_one_for_assembly[Communicator_pt->my_rank()] - 1;
     }
 #endif
  
     // number of local eqns
     unsigned ndof = this->ndof();
  
     // Find the number of vectors to be assembled
     const unsigned n_vector = residuals.size();
  
     // Find the number of matrices to be assembled
     const unsigned n_matrix = column_or_row_index.size();
  
     // Locally cache pointer to assembly handler
     AssemblyHandler* const assembly_handler_pt = Assembly_handler_pt;
  
 #ifdef OOMPH_HAS_MPI
     bool doing_residuals = false;
     if (dynamic_cast<ParallelResidualsHandler*>(Assembly_handler_pt) != 0)
     {
       doing_residuals = true;
     }
 #endif
  
 // Error check dimensions
 #ifdef PARANOID
     if (row_or_column_start.size() != n_matrix)
     {
       std::ostringstream error_stream;
       error_stream << "Error: " << std::endl
                    << "row_or_column_start.size() "
                    << row_or_column_start.size() << " does not equal "
                    << "column_or_row_index.size() "
                    << column_or_row_index.size() << std::endl;
       throw OomphLibError(
         error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
  
     if (value.size() != n_matrix)
     {
       std::ostringstream error_stream;
       error_stream << "Error: " << std::endl
                    << "value.size() " << value.size() << " does not equal "
                    << "column_or_row_index.size() "
                    << column_or_row_index.size() << std::endl
                    << std::endl
                    << std::endl;
       throw OomphLibError(
         error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
 #endif
  
     // The idea behind this sparse assembly routine is to use Vectors of
     // Vectors for the entries in each complete matrix. And a second
     // Vector of Vectors stores the global row (or column) indeces. This
     // will not have the memory overheads associated with the methods using
     // lists or maps, but insertion will be more costly.
  
     // Set up two vector of vectors to store the entries of each  matrix,
     // indexed by either the column or row. The entries of the vector for
     // each matrix correspond to all the rows or columns of that matrix.
     Vector<Vector<Vector<unsigned>>> matrix_row_or_col_indices(n_matrix);
     Vector<Vector<Vector<double>>> matrix_values(n_matrix);
  
     // Loop over the number of matrices being assembled and resize
     // each vector of vectors to the number of rows or columns of the matrix
     for (unsigned m = 0; m < n_matrix; m++)
     {
       matrix_row_or_col_indices[m].resize(ndof);
       matrix_values[m].resize(ndof);
     }
  
     // Resize the residuals vectors
     for (unsigned v = 0; v < n_vector; v++)
     {
       residuals[v] = new double[ndof];
       for (unsigned i = 0; i < ndof; i++)
       {
         residuals[v][i] = 0;
       }
     }
  
 #ifdef OOMPH_HAS_MPI
  
     // Storage for assembly time for elements
     double t_assemble_start = 0.0;
  
     // Storage for assembly times
     if ((!doing_residuals) && Must_recompute_load_balance_for_assembly)
     {
       Elemental_assembly_time.resize(n_elements);
     }
  
 #endif
  
  
     //----------------Assemble and populate the vector storage scheme-------
     {
       // Allocate local storage for the element's contribution to the
       // residuals vectors and system matrices of the size of the maximum
       // number of dofs in any element
       // This means that the storage will only be allocated (and deleted) once
       Vector<Vector<double>> el_residuals(n_vector);
       Vector<DenseMatrix<double>> el_jacobian(n_matrix);
  
       // Loop over the elements
       for (unsigned long e = el_lo; e <= el_hi; e++)
       {
 #ifdef OOMPH_HAS_MPI
         // Time it?
         if ((!doing_residuals) && Must_recompute_load_balance_for_assembly)
         {
           t_assemble_start = TimingHelpers::timer();
         }
 #endif
  
         // Get the pointer to the element
         GeneralisedElement* elem_pt = mesh_pt()->element_pt(e);
  
 #ifdef OOMPH_HAS_MPI
         // Ignore halo elements
         if (!elem_pt->is_halo())
         {
 #endif
  
           // Find number of degrees of freedom in the element
           const unsigned nvar = assembly_handler_pt->ndof(elem_pt);
  
           // Resize the storage for elemental jacobian and residuals
           for (unsigned v = 0; v < n_vector; v++)
           {
             el_residuals[v].resize(nvar);
           }
           for (unsigned m = 0; m < n_matrix; m++)
           {
             el_jacobian[m].resize(nvar);
           }
  
           // Now get the residuals and jacobian for the element
           assembly_handler_pt->get_all_vectors_and_matrices(
             elem_pt, el_residuals, el_jacobian);
  
           //---------------Insert the values into the vectors--------------
  
           // Loop over the first index of local variables
           for (unsigned i = 0; i < nvar; i++)
           {
             // Get the local equation number
             unsigned eqn_number = assembly_handler_pt->eqn_number(elem_pt, i);
  
             // Add the contribution to the residuals
             for (unsigned v = 0; v < n_vector; v++)
             {
               // Fill in each residuals vector
               residuals[v][eqn_number] += el_residuals[v][i];
             }
  
             // Now loop over the other index
             for (unsigned j = 0; j < nvar; j++)
             {
               // Get the number of the unknown
               unsigned unknown = assembly_handler_pt->eqn_number(elem_pt, j);
  
               // Loop over the matrices
               // If it's compressed row storage, then our vector of maps
               // is indexed by row (equation number)
               for (unsigned m = 0; m < n_matrix; m++)
               {
                 // Get the value of the matrix at this point
                 double value = el_jacobian[m](i, j);
                 // Only bother to add to the vector if it's non-zero
                 if (std::fabs(value) > Numerical_zero_for_sparse_assembly)
                 {
                   // If it's compressed row storage, then our vector of maps
                   // is indexed by row (equation number)
                   if (compressed_row_flag)
                   {
                     // Find the correct position and add the data into the
                     // vectors
                     const unsigned size =
                       matrix_row_or_col_indices[m][eqn_number].size();
  
                     for (unsigned k = 0; k <= size; k++)
                     {
                       if (k == size)
                       {
                         matrix_row_or_col_indices[m][eqn_number].push_back(
                           unknown);
                         matrix_values[m][eqn_number].push_back(value);
                         break;
                       }
                       else if (matrix_row_or_col_indices[m][eqn_number][k] ==
                                unknown)
                       {
                         matrix_values[m][eqn_number][k] += value;
                         break;
                       }
                     }
                   }
                   // Otherwise it's compressed column storage and our vector is
                   // indexed by column (the unknown)
                   else
                   {
                     // Add the data into the vectors in the correct position
                     const unsigned size =
                       matrix_row_or_col_indices[m][unknown].size();
                     for (unsigned k = 0; k <= size; k++)
                     {
                       if (k == size)
                       {
                         matrix_row_or_col_indices[m][unknown].push_back(
                           eqn_number);
                         matrix_values[m][unknown].push_back(value);
                         break;
                       }
                       else if (matrix_row_or_col_indices[m][unknown][k] ==
                                eqn_number)
                       {
                         matrix_values[m][unknown][k] += value;
                         break;
                       }
                     }
                   }
                 }
               } // End of loop over matrices
             }
           }
  
 #ifdef OOMPH_HAS_MPI
         } // endif halo element
 #endif
  
  
 #ifdef OOMPH_HAS_MPI
         // Time it?
         if ((!doing_residuals) && Must_recompute_load_balance_for_assembly)
         {
           Elemental_assembly_time[e] =
             TimingHelpers::timer() - t_assemble_start;
         }
 #endif
  
       } // End of loop over the elements
  
     } // End of vector assembly
  
  
 #ifdef OOMPH_HAS_MPI
  
     // Postprocess timing information and re-allocate distribution of
     // elements during subsequent assemblies.
     if ((!doing_residuals) && (!Problem_has_been_distributed) &&
         Must_recompute_load_balance_for_assembly)
     {
       recompute_load_balanced_assembly();
     }
  
     // We have determined load balancing for current setup.
     // This can remain the same until assign_eqn_numbers() is called
     // again -- the flag is re-set to true there.
     if ((!doing_residuals) && Must_recompute_load_balance_for_assembly)
     {
       Must_recompute_load_balance_for_assembly = false;
     }
  
 #endif
  
     //-----------Finally we need to convert this lousy vector storage scheme
     //------------------------to the containers required by SuperLU
  
     // Loop over the number of matrices
     for (unsigned m = 0; m < n_matrix; m++)
     {
       // Set the number of rows or columns
       row_or_column_start[m] = new int[ndof + 1];
  
       // fill row_or_column_start and find the number of entries
       row_or_column_start[m][0] = 0;
       for (unsigned long i = 0; i < ndof; i++)
       {
         row_or_column_start[m][i + 1] =
           row_or_column_start[m][i] + matrix_values[m][i].size();
       }
       const unsigned entries = row_or_column_start[m][ndof];
  
       // resize vectors
       column_or_row_index[m] = new int[entries];
       value[m] = new double[entries];
       nnz[m] = entries;
  
       // Now we merely loop over the number of rows or columns
       for (unsigned long i_global = 0; i_global < ndof; i_global++)
       {
         // If there are no entries in the vector then skip the rest of the loop
         if (matrix_values[m][i_global].empty())
         {
           continue;
         }
  
         // Loop over all the entries in the vectors corresponding to the given
         // row or column. It will NOT be ordered
         unsigned p = 0;
         for (int j = row_or_column_start[m][i_global];
              j < row_or_column_start[m][i_global + 1];
              j++)
         {
           column_or_row_index[m][j] = matrix_row_or_col_indices[m][i_global][p];
           value[m][j] = matrix_values[m][i_global][p];
           ++p;
         }
       }
     } // End of the loop over the matrices
  
     if (Pause_at_end_of_sparse_assembly)
     {
       oomph_info << "Pausing at end of sparse assembly." << std::endl;
       pause("Check memory usage now.");
     }
   }

References Assembly_handler_pt, assembly_handler_pt(), Communicator_pt, e(), oomph::Mesh::element_pt(), oomph::AssemblyHandler::eqn_number(), boost::multiprecision::fabs(), oomph::AssemblyHandler::get_all_vectors_and_matrices(), i, j, k, m, mesh_pt(), oomph::OomphCommunicator::my_rank(), ndof(), oomph::AssemblyHandler::ndof(), oomph::Mesh::nelement(), Numerical_zero_for_sparse_assembly, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::oomph_info, p, oomph::pause(), Pause_at_end_of_sparse_assembly, size, oomph::TimingHelpers::timer(), v, and Eigen::value.

Referenced by sparse_assemble_row_or_column_compressed().

◆ sparse_assemble_row_or_column_compressed_with_vectors_of_pairs()

void Problem::sparse_assemble_row_or_column_compressed_with_vectors_of_pairs	(	Vector< int * > &	column_or_row_index,
		Vector< int * > &	row_or_column_start,
		Vector< double * > &	value,
		Vector< unsigned > &	nnz,
		Vector< double * > &	residuals,
		bool	compressed_row_flag
	)

privatevirtual

Private helper function that is used to assemble the Jacobian matrix in the case when the storage is row or column compressed. The boolean Flag indicates if we want compressed row format (true) or compressed column. This version uses vectors of pairs.

This is a (private) helper function that is used to assemble system matrices in compressed row or column format and compute residual vectors using vectors of pairs The default action is to assemble the jacobian matrix and residuals for the Newton method. The action can be overloaded at an elemental level by chaging the default behaviour of the function Element::get_all_vectors_and_matrices(). column_or_row_index: Column [or row] index of given entry row_or_column_start: Index of first entry for given row [or column] value : Vector of nonzero entries residuals : Residual vector compressed_row_flag: Bool flag to indicate if storage format is compressed row [if false interpretation of arguments is as stated in square brackets].

   {
     // Total number of elements
     const unsigned long n_elements = mesh_pt()->nelement();
  
     // Default range of elements for distributed problems
     unsigned long el_lo = 0;
     unsigned long el_hi = n_elements - 1;
  
 #ifdef OOMPH_HAS_MPI
     // Otherwise just loop over a fraction of the elements
     // (This will either have been initialised in
     // Problem::set_default_first_and_last_element_for_assembly() or
     // will have been re-assigned during a previous assembly loop
     // Note that following the re-assignment only the entries
     // for the current processor are relevant.
     if (!Problem_has_been_distributed)
     {
       el_lo = First_el_for_assembly[Communicator_pt->my_rank()];
       el_hi = Last_el_plus_one_for_assembly[Communicator_pt->my_rank()] - 1;
     }
 #endif
  
     // number of local eqns
     unsigned ndof = this->ndof();
  
     // Find the number of vectors to be assembled
     const unsigned n_vector = residuals.size();
  
     // Find the number of matrices to be assembled
     const unsigned n_matrix = column_or_row_index.size();
  
     // Locally cache pointer to assembly handler
     AssemblyHandler* const assembly_handler_pt = Assembly_handler_pt;
  
 #ifdef OOMPH_HAS_MPI
     bool doing_residuals = false;
     if (dynamic_cast<ParallelResidualsHandler*>(Assembly_handler_pt) != 0)
     {
       doing_residuals = true;
     }
 #endif
  
 // Error check dimensions
 #ifdef PARANOID
     if (row_or_column_start.size() != n_matrix)
     {
       std::ostringstream error_stream;
       error_stream << "Error: " << std::endl
                    << "row_or_column_start.size() "
                    << row_or_column_start.size() << " does not equal "
                    << "column_or_row_index.size() "
                    << column_or_row_index.size() << std::endl;
       throw OomphLibError(
         error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
  
     if (value.size() != n_matrix)
     {
       std::ostringstream error_stream;
       error_stream << "Error: " << std::endl
                    << "value.size() " << value.size() << " does not equal "
                    << "column_or_row_index.size() "
                    << column_or_row_index.size() << std::endl
                    << std::endl
                    << std::endl;
       throw OomphLibError(
         error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
 #endif
  
  
     // The idea behind this sparse assembly routine is to use a Vector of
     // Vectors of pairs for each complete matrix.
     // Each inner Vector stores pairs and holds the row (or column) index
     // and the value of the matrix entry.
  
     // Set up Vector of Vectors to store the entries of each matrix,
     // indexed by either the column or row.
     Vector<Vector<Vector<std::pair<unsigned, double>>>> matrix_data(n_matrix);
  
     // Loop over the number of matrices being assembled and resize
     // each Vector of Vectors to the number of rows or columns of the matrix
     for (unsigned m = 0; m < n_matrix; m++)
     {
       matrix_data[m].resize(ndof);
     }
  
     // Resize the residuals vectors
     for (unsigned v = 0; v < n_vector; v++)
     {
       residuals[v] = new double[ndof];
       for (unsigned i = 0; i < ndof; i++)
       {
         residuals[v][i] = 0;
       }
     }
  
 #ifdef OOMPH_HAS_MPI
  
     // Storage for assembly time for elements
     double t_assemble_start = 0.0;
  
     // Storage for assembly times
     if ((!doing_residuals) && Must_recompute_load_balance_for_assembly)
     {
       Elemental_assembly_time.resize(n_elements);
     }
  
 #endif
  
     //----------------Assemble and populate the vector storage scheme--------
     {
       // Allocate local storage for the element's contribution to the
       // residuals vectors and system matrices of the size of the maximum
       // number of dofs in any element
       // This means that the storage is only allocated (and deleted) once
       Vector<Vector<double>> el_residuals(n_vector);
       Vector<DenseMatrix<double>> el_jacobian(n_matrix);
  
       // Loop over the elements
       for (unsigned long e = el_lo; e <= el_hi; e++)
       {
 #ifdef OOMPH_HAS_MPI
         // Time it?
         if ((!doing_residuals) && Must_recompute_load_balance_for_assembly)
         {
           t_assemble_start = TimingHelpers::timer();
         }
 #endif
  
         // Get the pointer to the element
         GeneralisedElement* elem_pt = mesh_pt()->element_pt(e);
  
 #ifdef OOMPH_HAS_MPI
         // Ignore halo elements
         if (!elem_pt->is_halo())
         {
 #endif
  
           // Find number of degrees of freedom in the element
           const unsigned nvar = assembly_handler_pt->ndof(elem_pt);
  
           // Resize the storage for elemental jacobian and residuals
           for (unsigned v = 0; v < n_vector; v++)
           {
             el_residuals[v].resize(nvar);
           }
           for (unsigned m = 0; m < n_matrix; m++)
           {
             el_jacobian[m].resize(nvar);
           }
  
           // Now get the residuals and jacobian for the element
           assembly_handler_pt->get_all_vectors_and_matrices(
             elem_pt, el_residuals, el_jacobian);
  
           //---------------Insert the values into the vectors--------------
  
           // Loop over the first index of local variables
           for (unsigned i = 0; i < nvar; i++)
           {
             // Get the local equation number
             unsigned eqn_number = assembly_handler_pt->eqn_number(elem_pt, i);
  
             // Add the contribution to the residuals
             for (unsigned v = 0; v < n_vector; v++)
             {
               // Fill in each residuals vector
               residuals[v][eqn_number] += el_residuals[v][i];
             }
  
             // Now loop over the other index
             for (unsigned j = 0; j < nvar; j++)
             {
               // Get the number of the unknown
               unsigned unknown = assembly_handler_pt->eqn_number(elem_pt, j);
  
               // Loop over the matrices
               // If it's compressed row storage, then our vector of maps
               // is indexed by row (equation number)
               for (unsigned m = 0; m < n_matrix; m++)
               {
                 // Get the value of the matrix at this point
                 double value = el_jacobian[m](i, j);
                 // Only bother to add to the vector if it's non-zero
                 if (std::fabs(value) > Numerical_zero_for_sparse_assembly)
                 {
                   // If it's compressed row storage, then our vector of maps
                   // is indexed by row (equation number)
                   if (compressed_row_flag)
                   {
                     // Find the correct position and add the data into the
                     // vectors
                     const unsigned size = matrix_data[m][eqn_number].size();
                     for (unsigned k = 0; k <= size; k++)
                     {
                       if (k == size)
                       {
                         matrix_data[m][eqn_number].push_back(
                           std::make_pair(unknown, value));
                         break;
                       }
                       else if (matrix_data[m][eqn_number][k].first == unknown)
                       {
                         matrix_data[m][eqn_number][k].second += value;
                         break;
                       }
                     }
                   }
                   // Otherwise it's compressed column storage and our vector is
                   // indexed by column (the unknown)
                   else
                   {
                     // Add the data into the vectors in the correct position
                     const unsigned size = matrix_data[m][unknown].size();
                     for (unsigned k = 0; k <= size; k++)
                     {
                       if (k == size)
                       {
                         matrix_data[m][unknown].push_back(
                           std::make_pair(eqn_number, value));
                         break;
                       }
                       else if (matrix_data[m][unknown][k].first == eqn_number)
                       {
                         matrix_data[m][unknown][k].second += value;
                         break;
                       }
                     }
                   }
                 }
               } // End of loop over matrices
             }
           }
  
 #ifdef OOMPH_HAS_MPI
         } // endif halo element
 #endif
  
  
 #ifdef OOMPH_HAS_MPI
         // Time it?
         if ((!doing_residuals) && Must_recompute_load_balance_for_assembly)
         {
           Elemental_assembly_time[e] =
             TimingHelpers::timer() - t_assemble_start;
         }
 #endif
  
       } // End of loop over the elements
  
  
     } // End of vector assembly
  
  
 #ifdef OOMPH_HAS_MPI
  
     // Postprocess timing information and re-allocate distribution of
     // elements during subsequent assemblies.
     if ((!doing_residuals) && (!Problem_has_been_distributed) &&
         Must_recompute_load_balance_for_assembly)
     {
       recompute_load_balanced_assembly();
     }
  
     // We have determined load balancing for current setup.
     // This can remain the same until assign_eqn_numbers() is called
     // again -- the flag is re-set to true there.
     if ((!doing_residuals) && Must_recompute_load_balance_for_assembly)
     {
       Must_recompute_load_balance_for_assembly = false;
     }
  
 #endif
  
  
     //-----------Finally we need to convert this vector storage scheme
     //------------------------to the containers required by SuperLU
  
     // Loop over the number of matrices
     for (unsigned m = 0; m < n_matrix; m++)
     {
       // Set the number of rows or columns
       row_or_column_start[m] = new int[ndof + 1];
  
       // fill row_or_column_start and find the number of entries
       row_or_column_start[m][0] = 0;
       for (unsigned long i = 0; i < ndof; i++)
       {
         row_or_column_start[m][i + 1] =
           row_or_column_start[m][i] + matrix_data[m][i].size();
       }
       const unsigned entries = row_or_column_start[m][ndof];
  
       // resize vectors
       column_or_row_index[m] = new int[entries];
       value[m] = new double[entries];
       nnz[m] = entries;
  
       // Now we merely loop over the number of rows or columns
       for (unsigned long i_global = 0; i_global < ndof; i_global++)
       {
         // If there are no entries in the vector then skip the rest of the loop
         if (matrix_data[m][i_global].empty())
         {
           continue;
         }
  
         // Loop over all the entries in the vectors corresponding to the given
         // row or column. It will NOT be ordered
         unsigned p = 0;
         for (int j = row_or_column_start[m][i_global];
              j < row_or_column_start[m][i_global + 1];
              j++)
         {
           column_or_row_index[m][j] = matrix_data[m][i_global][p].first;
           value[m][j] = matrix_data[m][i_global][p].second;
           ++p;
         }
       }
     } // End of the loop over the matrices
  
     if (Pause_at_end_of_sparse_assembly)
     {
       oomph_info << "Pausing at end of sparse assembly." << std::endl;
       pause("Check memory usage now.");
     }
   }

References Assembly_handler_pt, assembly_handler_pt(), Communicator_pt, e(), oomph::Mesh::element_pt(), oomph::AssemblyHandler::eqn_number(), boost::multiprecision::fabs(), oomph::AssemblyHandler::get_all_vectors_and_matrices(), i, j, k, m, mesh_pt(), oomph::OomphCommunicator::my_rank(), ndof(), oomph::AssemblyHandler::ndof(), oomph::Mesh::nelement(), Numerical_zero_for_sparse_assembly, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::oomph_info, p, oomph::pause(), Pause_at_end_of_sparse_assembly, size, oomph::TimingHelpers::timer(), v, and Eigen::value.

Referenced by sparse_assemble_row_or_column_compressed().

◆ steady_newton_solve()

void Problem::steady_newton_solve ( unsigned const & max_adapt = 0 )

Solve a steady problem using adaptive Newton's method, but in the context of an overall unstady problem, perhaps to determine an initial condition. This is achieved by setting the weights in the timesteppers to be zero which has the effect of rendering them steady timesteppers. The optional argument max_adapt specifies the max. number of adaptations of all refineable submeshes are performed to achieve the the error targets specified in the refineable submeshes.

Solve a steady problem, in the context of an overall unsteady problem. This is achieved by setting the weights in the timesteppers to be zero which has the effect of rendering them steady timesteppers The optional argument max_adapt specifies the max. number of adaptations of all refineable submeshes are performed to achieve the the error targets specified in the refineable submeshes.

   {
     // Find out how many timesteppers there are
     unsigned n_time_steppers = ntime_stepper();
  
     // Vector of bools to store the is_steady status of the various
     // timesteppers when we came in here
     std::vector<bool> was_steady(n_time_steppers);
  
     // Loop over them all and make them (temporarily) static
     for (unsigned i = 0; i < n_time_steppers; i++)
     {
       was_steady[i] = time_stepper_pt(i)->is_steady();
       time_stepper_pt(i)->make_steady();
     }
  
     try
     {
       // Solve the non-linear problem with Newton's method
       if (max_adapt == 0)
       {
         newton_solve();
       }
       else
       {
         newton_solve(max_adapt);
       }
     }
     // Catch any exceptions thrown in the Newton solver
     catch (NewtonSolverError& error)
     {
       oomph_info << std::endl
                  << "USER-DEFINED ERROR IN NEWTON SOLVER " << std::endl;
       // Check whether it's the linear solver
       if (error.linear_solver_error)
       {
         oomph_info << "ERROR IN THE LINEAR SOLVER" << std::endl;
       }
       // Check to see whether we have reached Max_iterations
       else if (error.iterations == Max_newton_iterations)
       {
         oomph_info << "MAXIMUM NUMBER OF ITERATIONS (" << error.iterations
                    << ") REACHED WITHOUT CONVERGENCE " << std::endl;
       }
       // If not, it must be that we have exceeded the maximum residuals
       else
       {
         oomph_info << "MAXIMUM RESIDUALS: " << error.maxres
                    << " EXCEEDS PREDEFINED MAXIMUM " << Max_residuals
                    << std::endl;
       }
  
       // Die horribly!!
       std::ostringstream error_stream;
       error_stream << "Error occured in Newton solver. " << std::endl;
       throw OomphLibError(
         error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
  
  
     // Reset the is_steady status of all timesteppers that
     // weren't already steady when we came in here and reset their
     // weights
     for (unsigned i = 0; i < n_time_steppers; i++)
     {
       if (!was_steady[i])
       {
         time_stepper_pt(i)->undo_make_steady();
       }
     }
  
     // Since we performed a steady solve, the history values
     // now have to be set as if we had performed an impulsive start from
     // the current solution. This ensures that the time-derivatives
     // evaluate to zero even now that the timesteppers have been
     // reactivated.
     assign_initial_values_impulsive();
   }

References assign_initial_values_impulsive(), calibrate::error, i, oomph::TimeStepper::is_steady(), oomph::TimeStepper::make_steady(), Max_newton_iterations, Max_residuals, newton_solve(), ntime_stepper(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::oomph_info, time_stepper_pt(), and oomph::TimeStepper::undo_make_steady().

◆ store_current_dof_values()

void Problem::store_current_dof_values ( )

Store the current values of the degrees of freedom.

Stored the current values of the dofs.

   {
     // If memory has not been allocated, then allocated memory for the saved
     // dofs
     if (Saved_dof_pt == 0)
     {
       Saved_dof_pt = new Vector<double>;
     }
  
 #ifdef OOMPH_HAS_MPI
     // If the problem is distributed I have to do something different
     if (Problem_has_been_distributed)
     {
       // How many entries do we store locally?
       const unsigned n_row_local = Dof_distribution_pt->nrow_local();
  
       // Resize the vector
       Saved_dof_pt->resize(n_row_local);
  
       // Back 'em up
       for (unsigned i = 0; i < n_row_local; i++)
       {
         (*Saved_dof_pt)[i] = *(this->Dof_pt[i]);
       }
     }
     // Otherwise just store all the dofs
     else
 #endif
     {
       // Find the number of dofs
       unsigned long n_dof = ndof();
  
       // Resize the vector
       Saved_dof_pt->resize(n_dof);
  
       // Transfer the values over
       for (unsigned long n = 0; n < n_dof; n++)
       {
         (*Saved_dof_pt)[n] = dof(n);
       }
     }
   }

References dof(), Dof_distribution_pt, Dof_pt, i, n, ndof(), oomph::LinearAlgebraDistribution::nrow_local(), and Saved_dof_pt.

Referenced by calculate_predictions().

◆ symmetrise_eigenfunction_for_adaptive_pitchfork_tracking()

void Problem::symmetrise_eigenfunction_for_adaptive_pitchfork_tracking ( )

virtual

Virtual function that is used to symmetrise the problem so that the current solution exactly satisfies any symmetries within the system. Used when adpativly solving pitchfork detection problems when small asymmetries in the coarse solution can be magnified leading to very inaccurate answers on the fine mesh. This is always problem-specific and must be filled in by the user The default issues a warning

Reimplemented in RefineablePorousChannelProblem< ELEMENT >.

   {
     std::ostringstream warn_message;
     warn_message
       << "Warning: This function is called after spatially adapting the\n"
       << "eigenfunction associated with a pitchfork bifurcation and should\n"
       << "ensure that the exact (anti-)symmetries of problem are enforced\n"
       << "within that eigenfunction. It is problem specific and must be\n"
       << "filled in by the user if required.\n"
       << "A sign of problems is if the slack paramter gets too large and\n"
       << "if the solution at the Pitchfork is not symmetric.\n";
     OomphLibWarning(
       warn_message.str(),
       "Problem::symmetrise_eigenfunction_for_adaptive_pitchfork_tracking()",
       OOMPH_EXCEPTION_LOCATION);
   }

References OOMPH_EXCEPTION_LOCATION.

◆ time() [1/2]

double & Problem::time ( )

virtual

Return the current value of continuous time.

Return the current value of continuous time. If not Time object has been assigned, then throw an error

Reimplemented from oomph::ExplicitTimeSteppableObject.

   {
     if (Time_pt == 0)
     {
       throw OomphLibError("Time object has not been set",
                           OOMPH_CURRENT_FUNCTION,
                           OOMPH_EXCEPTION_LOCATION);
     }
     else
     {
       return Time_pt->time();
     }
   }

References OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::Time::time(), and Time_pt.

Referenced by oomph::WomersleyProblem< ELEMENT, DIM >::actions_before_implicit_timestep(), calculate_predictions(), FSIRingProblem::dynamic_run(), oomph::ODEProblem::exact_solution(), oomph::ODEProblem::get_error_norm(), oomph::ODEProblem::my_set_initial_condition(), read(), oomph::SolidICProblem::set_static_initial_condition(), oomph::SegregatableFSIProblem::t_spent_on_actual_solve(), and oomph::ODEProblem::write_additional_trace_data().

◆ time() [2/2]

double Problem::time ( ) const

Return the current value of continuous time (const version)

Return the current value of continuous time. If not Time object has been assigned, then throw an error. Const version.

   {
     if (Time_pt == 0)
     {
       throw OomphLibError("Time object has not been set",
                           OOMPH_CURRENT_FUNCTION,
                           OOMPH_EXCEPTION_LOCATION);
     }
     else
     {
       return Time_pt->time();
     }
   }

References OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::Time::time(), and Time_pt.

◆ time_adaptive_newton_crash_on_solve_fail()

bool& oomph::Problem::time_adaptive_newton_crash_on_solve_fail ( )

inline

Access function for Time_adaptive_newton_crash_on_solve_fail.

     {
       return Time_adaptive_newton_crash_on_solve_fail;
     }

References Time_adaptive_newton_crash_on_solve_fail.

◆ time_pt() [1/2]

Time*& oomph::Problem::time_pt ( )

inline

Return a pointer to the global time object.

     {
       return Time_pt;
     }

References Time_pt.

Referenced by oomph::IMRByBDF::actions_after_timestep(), oomph::WomersleyProblem< ELEMENT, DIM >::actions_before_implicit_timestep(), oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::adapt_temporal_mesh(), adaptive_unsteady_newton_solve(), calculate_predictions(), copy(), doubly_adaptive_unsteady_newton_solve_helper(), dump(), FSIRingProblem::dynamic_run(), explicit_timestep(), FlowAroundCylinderProblem< ELEMENT >::FlowAroundCylinderProblem(), oomph::ODEProblem::get_error_norm(), oomph::ODEProblem::my_set_initial_condition(), read(), TurekNonFSIProblem< ELEMENT >::TurekNonFSIProblem(), unsteady_newton_solve(), oomph::SegregatableFSIProblem::unsteady_segregated_solve(), and oomph::ODEProblem::write_additional_trace_data().

◆ time_pt() [2/2]

Time* oomph::Problem::time_pt ( ) const

inlinevirtual

Return a pointer to the global time object (const version).

Reimplemented from oomph::ExplicitTimeSteppableObject.

     {
       return Time_pt;
     }

References Time_pt.

◆ time_stepper_pt() [1/3]

TimeStepper*& oomph::Problem::time_stepper_pt ( )

inline

Access function for the pointer to the first (presumably only) timestepper

     {
       if (Time_stepper_pt.size() == 0)
       {
         throw OomphLibError("No timestepper allocated yet\n",
                             OOMPH_CURRENT_FUNCTION,
                             OOMPH_EXCEPTION_LOCATION);
       }
       return Time_stepper_pt[0];
     }

References OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and Time_stepper_pt.

Referenced by adaptive_unsteady_newton_solve(), add_time_stepper_pt(), arc_length_step_solve(), arc_length_step_solve_helper(), calculate_predictions(), ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::ConvectionProblem(), copy(), ElasticInterfaceProblem< ELEMENT, TIMESTEPPER >::ElasticInterfaceProblem(), FlowAroundCylinderProblem< ELEMENT >::FlowAroundCylinderProblem(), get_dvaluesdt(), HomogenisationProblem< ELEMENT >::HomogenisationProblem(), initialise_dt(), InterfaceProblem< ELEMENT, TIMESTEPPER >::InterfaceProblem(), LinearWaveProblem< ELEMENT, TIMESTEPPER >::LinearWaveProblem(), oomph::ODEProblem::my_set_initial_condition(), OscRingNStProblem< ELEMENT >::OscRingNStProblem(), RayleighProblem< ELEMENT, TIMESTEPPER >::RayleighProblem(), RefineableUnsteadyHeatProblem< ELEMENT >::RefineableUnsteadyHeatProblem(), set_timestepper_for_all_data(), solve_eigenproblem(), steady_newton_solve(), oomph::SegregatableFSIProblem::steady_segregated_solve(), SurfactantProblem< ELEMENT, INTERFACE_ELEMENT >::SurfactantProblem(), TurekNonFSIProblem< ELEMENT >::TurekNonFSIProblem(), unsteady_newton_solve(), oomph::SegregatableFSIProblem::unsteady_segregated_solve(), UnsteadyHeatProblem< ELEMENT >::UnsteadyHeatProblem(), and oomph::WomersleyProblem< ELEMENT, DIM >::WomersleyProblem().

◆ time_stepper_pt() [2/3]

const TimeStepper* oomph::Problem::time_stepper_pt ( ) const

inline

Access function for the pointer to the first (presumably only) timestepper

     {
       if (Time_stepper_pt.size() == 0)
       {
         throw OomphLibError("No timestepper allocated yet\n",
                             OOMPH_CURRENT_FUNCTION,
                             OOMPH_EXCEPTION_LOCATION);
       }
       return Time_stepper_pt[0];
     }

References OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and Time_stepper_pt.

◆ time_stepper_pt() [3/3]

TimeStepper*& oomph::Problem::time_stepper_pt ( const unsigned & i )

inline

Return a pointer to the i-th timestepper.

     {
       return Time_stepper_pt[i];
     }

References i, and Time_stepper_pt.

◆ unrefine_uniformly() [1/2]

unsigned Problem::unrefine_uniformly ( )

Refine (all) refineable (sub)mesh(es) uniformly and rebuild problem. Return 0 for success, 1 for failure (if unrefinement has reached the coarsest permitted level)

Unrefine (all) refineable (sub)mesh(es) uniformly and rebuild problem. Return 0 for success, 1 for failure (if unrefinement has reached the coarsest permitted level)

   {
     // Call actions_before_adapt()
     actions_before_adapt();
  
     // Has unrefinement been successful?
     unsigned success_flag = 0;
  
     // Number of submeshes?
     unsigned n_mesh = nsub_mesh();
  
     // Single mesh:
     if (n_mesh == 0)
     {
       // Unrefine single mesh uniformly if possible
       if (RefineableMeshBase* mmesh_pt =
             dynamic_cast<RefineableMeshBase*>(mesh_pt(0)))
       {
         success_flag += mmesh_pt->unrefine_uniformly();
       }
       else
       {
         oomph_info << "Info/Warning: Mesh cannot be unrefined uniformly "
                    << std::endl;
       }
     }
     // Multiple submeshes
     else
     {
       // Loop over submeshes
       for (unsigned imesh = 0; imesh < n_mesh; imesh++)
       {
         // Unrefine i-th submesh uniformly if possible
         if (RefineableMeshBase* mmesh_pt =
               dynamic_cast<RefineableMeshBase*>(mesh_pt(imesh)))
         {
           success_flag += mmesh_pt->unrefine_uniformly();
         }
         else
         {
           oomph_info << "Info/Warning: Cannot unrefine mesh " << imesh
                      << std::endl;
         }
       }
       // Rebuild the global mesh
       rebuild_global_mesh();
     }
  
     // Any actions after the adaptation phase
     actions_after_adapt();
  
     // Do equation numbering
     oomph_info << " Number of equations: " << assign_eqn_numbers() << std::endl;
  
     // Judge success
     if (success_flag > 0)
     {
       return 1;
     }
     else
     {
       return 0;
     }
   }

References actions_after_adapt(), actions_before_adapt(), assign_eqn_numbers(), mesh_pt(), nsub_mesh(), oomph::oomph_info, and rebuild_global_mesh().

Referenced by parallel_test().

◆ unrefine_uniformly() [2/2]

unsigned Problem::unrefine_uniformly ( const unsigned & i_mesh )

Do uniform refinement for submesh i_mesh without documentation. Return 0 for success, 1 for failure (if unrefinement has reached the coarsest permitted level)

Unrefine submesh i_mesh uniformly and rebuild problem. Return 0 for success, 1 for failure (if unrefinement has reached the coarsest permitted level)

   {
     actions_before_adapt();
  
     // Has unrefinement been successful?
     unsigned success_flag = 0;
  
 #ifdef PARANOID
     // Number of submeshes?
     if (i_mesh >= nsub_mesh())
     {
       std::ostringstream error_message;
       error_message << "imesh " << i_mesh
                     << " is greater than the number of sub meshes "
                     << nsub_mesh() << std::endl;
  
       throw OomphLibError(
         error_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
 #endif
  
     // Unrefine single mesh uniformly if possible
     if (RefineableMeshBase* mmesh_pt =
           dynamic_cast<RefineableMeshBase*>(mesh_pt(i_mesh)))
     {
       success_flag += mmesh_pt->unrefine_uniformly();
     }
     else
     {
       oomph_info << "Info/Warning: Mesh cannot be unrefined uniformly "
                  << std::endl;
     }
  
     // Rebuild the global mesh
     rebuild_global_mesh();
  
     // Any actions after the adaptation phase
     actions_after_adapt();
  
     // Do equation numbering
     oomph_info << "Number of equations: " << assign_eqn_numbers() << std::endl;
  
     // Judge success
     if (success_flag > 0)
     {
       return 1;
     }
     else
     {
       return 0;
     }
   }

References actions_after_adapt(), actions_before_adapt(), assign_eqn_numbers(), mesh_pt(), nsub_mesh(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::oomph_info, and rebuild_global_mesh().

◆ unset_analytic_dparameter()

void oomph::Problem::unset_analytic_dparameter ( double *const & parameter_pt )

inline

Function to turn off analytic calculation of the parameter derivatives in continuation and bifurcation detection problems

     {
       // Find the iterator to the parameter
       std::map<double*, bool>::iterator it =
         Calculate_dparameter_analytic.find(parameter_pt);
       // If the parameter has been found, erase it
       if (it != Calculate_dparameter_analytic.end())
       {
         Calculate_dparameter_analytic.erase(it);
       }
     }

References Calculate_dparameter_analytic.

◆ unset_analytic_hessian_products()

void oomph::Problem::unset_analytic_hessian_products ( )

inline

Function to turn off analytic calculation of the parameter derivatives in continuation and bifurcation detection problems

     {
       Calculate_hessian_products_analytic = false;
     }

References Calculate_hessian_products_analytic.

◆ unsteady_newton_solve() [1/3]

void Problem::unsteady_newton_solve ( const double & dt )

Advance time by dt and solve by Newton's method. This version always shifts time values

Do one timestep of size dt using Newton's method with the specified tolerance and linear solver defined as member data of the Problem class. This will be the most commonly used version of unsteady_newton_solve, in which the time values are always shifted This does not include any kind of adaptativity. If the solution fails to converge the program will end.

   {
     // We shift the values, so shift_values is true
     unsteady_newton_solve(dt, true);
   }

Referenced by doubly_adaptive_unsteady_newton_solve_helper(), FSIRingProblem::dynamic_run(), and unsteady_newton_solve().

◆ unsteady_newton_solve() [2/3]

void Problem::unsteady_newton_solve	(	const double &	dt,
		const bool &	shift_values
	)

Advance time by dt and solve the system, using Newton's method. The boolean flag is used to control whether the time values should be shifted. If it is true the current data values will be shifted (copied to the locations where there are stored as previous timesteps) before solution.

Do one timestep forward of size dt using Newton's method with the specified tolerance and linear solver defined via member data of the Problem class. The boolean flag shift_values is used to control whether the time values should be shifted or not.

   {
     // Shift the time values and the dts, according to the control flag
     if (shift_values)
     {
       shift_time_values();
     }
  
     // Advance global time and set current value of dt
     time_pt()->time() += dt;
     time_pt()->dt() = dt;
  
     // Find out how many timesteppers there are
     unsigned n_time_steppers = ntime_stepper();
  
     // Loop over them all and set the weights
     for (unsigned i = 0; i < n_time_steppers; i++)
     {
       time_stepper_pt(i)->set_weights();
     }
  
     // Run the individual timesteppers actions before timestep. These need to
     // be before the problem's actions_before_implicit_timestep so that the
     // boundary conditions are set consistently.
     for (unsigned i = 0; i < n_time_steppers; i++)
     {
       time_stepper_pt(i)->actions_before_timestep(this);
     }
  
     // Now update anything that needs updating before the timestep
     // This could be time-dependent boundary conditions, for example.
     actions_before_implicit_timestep();
  
     try
     {
       // Solve the non-linear problem for this timestep with Newton's method
       newton_solve();
     }
     // Catch any exceptions thrown in the Newton solver
     catch (NewtonSolverError& error)
     {
       oomph_info << std::endl
                  << "USER-DEFINED ERROR IN NEWTON SOLVER " << std::endl;
       // Check whether it's the linear solver
       if (error.linear_solver_error)
       {
         oomph_info << "ERROR IN THE LINEAR SOLVER" << std::endl;
       }
       // Check to see whether we have reached Max_iterations
       else if (error.iterations == Max_newton_iterations)
       {
         oomph_info << "MAXIMUM NUMBER OF ITERATIONS (" << error.iterations
                    << ") REACHED WITHOUT CONVERGENCE " << std::endl;
       }
       // If not, it must be that we have exceeded the maximum residuals
       else
       {
         oomph_info << "MAXIMUM RESIDUALS: " << error.maxres
                    << " EXCEEDS PREDEFINED MAXIMUM " << Max_residuals
                    << std::endl;
       }
       // Die horribly!!
       std::ostringstream error_stream;
       error_stream << "Error occured in unsteady Newton solver. " << std::endl;
       throw OomphLibError(
         error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
  
     // Run the individual timesteppers actions, these need to be before the
     // problem's actions_after_implicit_timestep so that the time step is
     // finished before the problem does any auxiliary calculations (e.g. in
     // semi-implicit micromagnetics the calculation of magnetostatic field).
     for (unsigned i = 0; i < n_time_steppers; i++)
     {
       time_stepper_pt(i)->actions_after_timestep(this);
     }
  
  
     // Now update anything that needs updating after the timestep
     actions_after_implicit_timestep();
     actions_after_implicit_timestep_and_error_estimation();
   }

References actions_after_implicit_timestep(), actions_after_implicit_timestep_and_error_estimation(), oomph::TimeStepper::actions_after_timestep(), actions_before_implicit_timestep(), oomph::TimeStepper::actions_before_timestep(), oomph::Time::dt(), calibrate::error, i, Max_newton_iterations, Max_residuals, newton_solve(), ntime_stepper(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::oomph_info, oomph::TimeStepper::set_weights(), shift_time_values(), oomph::Time::time(), time_pt(), and time_stepper_pt().

◆ unsteady_newton_solve() [3/3]

void Problem::unsteady_newton_solve	(	const double &	dt,
		const unsigned &	max_adapt,
		const bool &	first_timestep,
		const bool &	shift = `true`
	)

Unsteady adaptive Newton solve: up to max_adapt adaptations of all refineable submeshes are performed to achieve the the error targets specified in the refineable submeshes. If first==true, the initial conditions are re-assigned after the mesh adaptations. Shifting of time can be suppressed by overwriting the default value of shift (true). [Shifting must be done if first_timestep==true because we're constantly re-assigning the initial conditions; if first_timestep==true and shift==false shifting is performed anyway and a warning is issued.

Do one timestep, dt, forward using Newton's method with specified tolerance and linear solver specified via member data. Keep adapting on all meshes to criteria specified in these meshes (up to max_adapt adaptations are performed). If first_timestep==true, re-set initial conditions after mesh adaptation. Shifting of time can be suppressed by overwriting the default value of shift (true). [Shifting must be done if first_timestep==true because we're constantly re-assigning the initial conditions; if first_timestep==true and shift==false shifting is performed anyway and a warning is issued.

   {
     // Do shifting or not?
     bool shift_it = shift;
  
     // Warning:
     if (first_timestep && (!shift) && (!Default_set_initial_condition_called))
     {
       shift_it = true;
       oomph_info
         << "\n\n===========================================================\n";
       oomph_info << "                  ********  WARNING *********** \n";
       oomph_info
         << "===========================================================\n";
       oomph_info << "Problem::unsteady_newton_solve() called with "
                  << std::endl;
       oomph_info << "first_timestep: " << first_timestep << std::endl;
       oomph_info << "shift: " << shift << std::endl;
       oomph_info << "This doesn't make sense (shifting does have to be done"
                  << std::endl;
       oomph_info << "since we're constantly re-assigning the initial conditions"
                  << std::endl;
       oomph_info
         << "\n===========================================================\n\n";
     }
  
  
     // Find the initial time
     double initial_time = time_pt()->time();
  
     // Max number of solves
     unsigned max_solve = max_adapt + 1;
  
     // Adaptation loop
     //----------------
     for (unsigned isolve = 0; isolve < max_solve; isolve++)
     {
       // Only adapt after the first solve has been done!
       if (isolve > 0)
       {
         unsigned n_refined;
         unsigned n_unrefined;
  
         // Adapt problem
         adapt(n_refined, n_unrefined);
  
 #ifdef OOMPH_HAS_MPI
         // Adaptation only converges if ALL the processes have no
         // refinement or unrefinement to perform
         unsigned total_refined = 0;
         unsigned total_unrefined = 0;
         if (Problem_has_been_distributed)
         {
           MPI_Allreduce(&n_refined,
                         &total_refined,
                         1,
                         MPI_UNSIGNED,
                         MPI_SUM,
                         this->communicator_pt()->mpi_comm());
           n_refined = total_refined;
           MPI_Allreduce(&n_unrefined,
                         &total_unrefined,
                         1,
                         MPI_UNSIGNED,
                         MPI_SUM,
                         this->communicator_pt()->mpi_comm());
           n_unrefined = total_unrefined;
         }
 #endif
  
         oomph_info << "---> " << n_refined << " elements were refined, and "
                    << n_unrefined << " were unrefined, in total." << std::endl;
  
         // Check convergence of adaptation cycle
         if ((n_refined == 0) && (n_unrefined == 0))
         {
           oomph_info << "\n \n Solution is fully converged in "
                      << "Problem::unsteady_newton_solver() \n \n ";
           break;
         }
  
         // Reset the time
         time_pt()->time() = initial_time;
  
         // Reset the inital condition on refined meshes. Note that because we
         // have reset the global time to the initial time, the initial
         // conditions are reset at time t=0 rather than at time t=dt
         if (first_timestep)
         {
           // Reset default set_initial_condition has been called flag to false
           Default_set_initial_condition_called = false;
  
           oomph_info << "Re-setting initial condition " << std::endl;
           set_initial_condition();
  
           // If the default set_initial_condition function has been called,
           // we must not shift the timevalues on the first timestep, as we
           // will NOT be constantly re-assigning the initial condition
           if (Default_set_initial_condition_called)
           {
             shift_it = false;
           }
         }
       }
  
       // Now do the actual unsteady timestep
       // If it's the first time around the loop, or the first timestep
       // shift the timevalues, otherwise don't
       // Note: we need to shift if it's the first timestep because
       // we're constantly re-assigning the initial condition above!
       // The only exception to this is if the default set_initial_condition
       // function has been called, in which case we must NOT shift!
       if ((isolve == 0) || (first_timestep))
       {
         Problem::unsteady_newton_solve(dt, shift_it);
       }
       // Subsequent solve: Have shifted already -- don't do it again.
       else
       {
         shift_it = false;
         Problem::unsteady_newton_solve(dt, shift_it);
       }
  
       if (isolve == max_solve - 1)
       {
         oomph_info
           << std::endl
           << "----------------------------------------------------------"
           << std::endl
           << "Reached max. number of adaptations in \n"
           << "Problem::unsteady_newton_solver().\n"
           << "----------------------------------------------------------"
           << std::endl
           << std::endl;
       }
  
     } // End of adaptation loop
   }

References adapt(), communicator_pt(), Default_set_initial_condition_called, oomph::oomph_info, set_initial_condition(), oomph::Time::time(), time_pt(), and unsteady_newton_solve().

◆ use_predictor_values_as_initial_guess()

bool& oomph::Problem::use_predictor_values_as_initial_guess ( )

inline

     {
       return Use_predictor_values_as_initial_guess;
     }

References Use_predictor_values_as_initial_guess.

Referenced by oomph::IMRByBDF::actions_before_timestep(), and calculate_predictions().

Friends And Related Function Documentation

◆ AugmentedBlockFoldLinearSolver

friend class AugmentedBlockFoldLinearSolver

friend

Referenced by activate_bifurcation_tracking(), and activate_fold_tracking().

◆ AugmentedBlockPitchForkLinearSolver

friend class AugmentedBlockPitchForkLinearSolver

friend

◆ BlockFoldLinearSolver

friend class BlockFoldLinearSolver

friend

◆ BlockHopfLinearSolver

friend class BlockHopfLinearSolver

friend

Referenced by activate_hopf_tracking().

◆ BlockPitchForkLinearSolver

friend class BlockPitchForkLinearSolver

friend

Referenced by activate_pitchfork_tracking().

◆ FoldHandler

friend class FoldHandler

friend

Referenced by activate_bifurcation_tracking(), and activate_fold_tracking().

◆ HopfHandler

friend class HopfHandler

friend

Referenced by activate_hopf_tracking().

◆ PeriodicOrbitAssemblyHandler

template<unsigned NNODE_1D>

friend class PeriodicOrbitAssemblyHandler

friend

◆ PitchForkHandler

friend class PitchForkHandler

friend

Referenced by activate_pitchfork_tracking().

Member Data Documentation

◆ Always_take_one_newton_step

bool oomph::Problem::Always_take_one_newton_step

protected

Boolean to indicate whether a Newton step should be taken even if the initial residuals are below the required tolerance

Referenced by newton_solve(), and newton_solve_continuation().

◆ Arc_length_step_taken

bool oomph::Problem::Arc_length_step_taken

protected

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

Referenced by arc_length_step_solve(), arc_length_step_solve_helper(), and reset_arc_length_parameters().

◆ Assembly_handler_pt

AssemblyHandler* oomph::Problem::Assembly_handler_pt

private

◆ Bifurcation_detection

bool oomph::Problem::Bifurcation_detection

protected

Boolean to control bifurcation detection via determinant of Jacobian.

Referenced by arc_length_step_solve_helper().

◆ Bisect_to_find_bifurcation

bool oomph::Problem::Bisect_to_find_bifurcation

protected

Boolean to control wheter bisection is used to located bifurcation.

Referenced by arc_length_step_solve_helper().

◆ Calculate_dparameter_analytic

std::map<double*, bool> oomph::Problem::Calculate_dparameter_analytic

protected

Map used to determine whether the derivatives with respect to a parameter should be finite differenced. The default is that finite differences should be used

Referenced by is_dparameter_calculated_analytically(), set_analytic_dparameter(), and unset_analytic_dparameter().

◆ Calculate_hessian_products_analytic

bool oomph::Problem::Calculate_hessian_products_analytic

protected

Map used to determine whether the hessian products should be computed using finite differences. The default is that finite differences will be used

Referenced by are_hessian_products_calculated_analytically(), set_analytic_hessian_products(), and unset_analytic_hessian_products().

◆ Communicator_pt

OomphCommunicator* oomph::Problem::Communicator_pt

protected

The communicator for this problem.

Referenced by assign_eqn_numbers(), calculate_continuation_derivatives(), communicator_pt(), get_eigenproblem_matrices(), get_jacobian(), get_residuals(), Problem(), read(), oomph::SolidICProblem::set_static_initial_condition(), sparse_assemble_row_or_column_compressed_with_lists(), sparse_assemble_row_or_column_compressed_with_maps(), sparse_assemble_row_or_column_compressed_with_two_arrays(), sparse_assemble_row_or_column_compressed_with_two_vectors(), sparse_assemble_row_or_column_compressed_with_vectors_of_pairs(), and ~Problem().

◆ Continuation_direction

double oomph::Problem::Continuation_direction

protected

The direction of the change in parameter that will ensure that a branch is followed in one direction only

Referenced by calculate_continuation_derivatives_helper(), and reset_arc_length_parameters().

◆ Continuation_time_stepper

ContinuationStorageScheme Problem::Continuation_time_stepper

staticprotected

Storage for the single static continuation timestorage object.

The continuation timestepper object.

Referenced by arc_length_step_solve(), and set_consistent_pinned_values_for_continuation().

◆ Copy_of_problem_pt

Vector<Problem*> oomph::Problem::Copy_of_problem_pt

protected

Vector of pointers to copies of the problem used in adaptive bifurcation tracking problems (ALH: TEMPORARY HACK, WILL BE FIXED)

Referenced by adapt(), bifurcation_adapt_helper(), and ~Problem().

◆ Default_assembly_handler_pt

AssemblyHandler* oomph::Problem::Default_assembly_handler_pt

private

Pointer to the default assembly handler.

Referenced by get_inverse_mass_matrix_times_residuals(), Problem(), reset_assembly_handler_to_default(), and ~Problem().

◆ Default_eigen_solver_pt

EigenSolver* oomph::Problem::Default_eigen_solver_pt

private

Pointer to the default eigensolver.

Referenced by Problem(), and ~Problem().

◆ Default_linear_solver_pt

LinearSolver* oomph::Problem::Default_linear_solver_pt

private

Pointer to the default linear solver.

Referenced by Problem(), and ~Problem().

◆ Default_set_initial_condition_called

bool oomph::Problem::Default_set_initial_condition_called

private

Has default set_initial_condition function been called? Default: false

Referenced by doubly_adaptive_unsteady_newton_solve_helper(), set_initial_condition(), and unsteady_newton_solve().

◆ Desired_newton_iterations_ds

unsigned oomph::Problem::Desired_newton_iterations_ds

protected

The desired number of Newton Steps to reach convergence at each step along the arc

Referenced by arc_length_step_solve_helper().

◆ Desired_proportion_of_arc_length

double oomph::Problem::Desired_proportion_of_arc_length

protected

Proportion of the arc-length to taken by the parameter.

Referenced by calculate_continuation_derivatives(), and calculate_continuation_derivatives_fd().

◆ Discontinuous_element_formulation

bool oomph::Problem::Discontinuous_element_formulation

protected

Is the problem a discontinuous one, i.e. can the elemental contributions be treated independently. Default: false

Referenced by disable_discontinuous_formulation(), disable_mass_matrix_reuse(), enable_discontinuous_formulation(), enable_mass_matrix_reuse(), and get_inverse_mass_matrix_times_residuals().

◆ Doc_time_in_distribute

bool oomph::Problem::Doc_time_in_distribute

protected

Protected boolean flag to provide comprehensive timimings during problem distribution. Initialised to false.

◆ Dof_current

Vector<double> oomph::Problem::Dof_current

protected

Storage for the present values of the variables.

Referenced by adapt(), arc_length_step_solve_helper(), calculate_continuation_derivatives_fd_helper(), and dof_current().

◆ Dof_current_offset

unsigned oomph::Problem::Dof_current_offset

protected

Storage for the offset for the current values of dofs from the original dofs (default is 2, but this will be differnet when continuing bifurcations and periodic orbits)

Referenced by dof_current().

◆ Dof_derivative

Vector<double> oomph::Problem::Dof_derivative

protected

Storage for the derivative of the problem variables wrt arc-length.

Referenced by adapt(), arc_length_step_solve_helper(), calculate_continuation_derivatives_helper(), dof_derivative(), and reset_arc_length_parameters().

◆ Dof_derivative_offset

unsigned oomph::Problem::Dof_derivative_offset

protected

Storage for the offset for the continuation derivatives from the original dofs (default is 1, but this will be differnet when continuing bifurcations and periodic orbits)

Referenced by dof_derivative().

◆ Dof_distribution_pt

LinearAlgebraDistribution* oomph::Problem::Dof_distribution_pt

protected

The distribution of the DOFs in this problem. This object is created in the Problem constructor and setup when assign_eqn_numbers(...) is called. If this problem is distributed then this distribution will match the distribution of the equation numbers. If this problem is not distributed then this distribution will be uniform over all processors.

Referenced by adapt(), oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::adapt_temporal_mesh(), arc_length_step_solve_helper(), assign_eqn_numbers(), calculate_continuation_derivatives_fd_helper(), calculate_continuation_derivatives_helper(), dof_distribution_pt(), oomph::FoldHandler::FoldHandler(), get_dofs(), get_eigenproblem_matrices(), get_hessian_vector_products(), get_jacobian(), get_residuals(), oomph::HopfHandler::HopfHandler(), ndof(), newton_solve(), newton_solve_continuation(), oomph::PitchForkHandler::PitchForkHandler(), Problem(), restore_dof_values(), setup_element_count_per_dof(), oomph::FoldHandler::solve_augmented_block_system(), oomph::PitchForkHandler::solve_augmented_block_system(), oomph::FoldHandler::solve_block_system(), oomph::PitchForkHandler::solve_block_system(), oomph::HopfHandler::solve_complex_system(), oomph::FoldHandler::solve_full_system(), oomph::PitchForkHandler::solve_full_system(), oomph::HopfHandler::solve_full_system(), oomph::HopfHandler::solve_standard_system(), store_current_dof_values(), oomph::FoldHandler::~FoldHandler(), oomph::HopfHandler::~HopfHandler(), oomph::PitchForkHandler::~PitchForkHandler(), and ~Problem().

◆ Dof_pt

Vector<double*> oomph::Problem::Dof_pt

protected

Vector of pointers to dofs.

Referenced by oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::adapt_temporal_mesh(), add_to_dofs(), arc_length_step_solve_helper(), assign_eqn_numbers(), calculate_continuation_derivatives_fd_helper(), calculate_predictions(), dof(), dof_current(), dof_derivative(), dof_pt(), oomph::FoldHandler::FoldHandler(), get_dofs(), get_fd_jacobian(), oomph::FoldHandler::get_jacobian(), oomph::HopfHandler::get_jacobian(), globally_convergent_line_search(), oomph::HopfHandler::HopfHandler(), newton_solve(), newton_solve_continuation(), oomph::PitchForkHandler::PitchForkHandler(), restore_dof_values(), set_dofs(), oomph::FoldHandler::solve_augmented_block_system(), oomph::PitchForkHandler::solve_augmented_block_system(), oomph::FoldHandler::solve_block_system(), oomph::PitchForkHandler::solve_block_system(), oomph::HopfHandler::solve_complex_system(), oomph::FoldHandler::solve_full_system(), oomph::PitchForkHandler::solve_full_system(), oomph::HopfHandler::solve_full_system(), oomph::HopfHandler::solve_standard_system(), store_current_dof_values(), oomph::FoldHandler::~FoldHandler(), oomph::HopfHandler::~HopfHandler(), and oomph::PitchForkHandler::~PitchForkHandler().

◆ Ds_current

double oomph::Problem::Ds_current

protected

Storage for the current step value.

Referenced by arc_length_step_solve_helper(), calculate_continuation_derivatives_fd_helper(), and newton_solve_continuation().

◆ DTSF_max_increase

double oomph::Problem::DTSF_max_increase

protected

Maximum possible increase of dt between time-steps in adaptive schemes

Referenced by adaptive_unsteady_newton_solve().

◆ DTSF_min_decrease

double oomph::Problem::DTSF_min_decrease

protected

Minimum allowed decrease of dt between time-steps in adaptive schemes. Lower scaling values will reject the time-step (and retry with a smaller dt).

Referenced by adaptive_unsteady_newton_solve().

◆ Eigen_solver_pt

EigenSolver* oomph::Problem::Eigen_solver_pt

private

Pointer to the eigen solver for the problem.

Referenced by eigen_solver_pt(), Problem(), and solve_eigenproblem().

◆ Element_count_per_dof

DoubleVectorWithHaloEntries oomph::Problem::Element_count_per_dof

protected

Counter that records how many elements contribute to each dof. Used to determine the (discrete) arc-length automatically. It really should be an integer, but is a double so that the distribution information can be used for distributed problems

Referenced by setup_element_count_per_dof().

◆ Empty_actions_after_read_unstructured_meshes_has_been_called

bool oomph::Problem::Empty_actions_after_read_unstructured_meshes_has_been_called

private

Boolean to indicate that empty actions_after_read_unstructured_meshes() function has been called.

Referenced by actions_after_read_unstructured_meshes(), and read().

◆ Empty_actions_before_read_unstructured_meshes_has_been_called

bool oomph::Problem::Empty_actions_before_read_unstructured_meshes_has_been_called

private

Boolean to indicate that empty actions_before_read_unstructured_meshes() function has been called.

Referenced by actions_before_read_unstructured_meshes(), and read().

◆ Explicit_time_stepper_pt

ExplicitTimeStepper* oomph::Problem::Explicit_time_stepper_pt

private

Pointer to a single explicit timestepper.

Referenced by explicit_time_stepper_pt(), and set_explicit_time_stepper_pt().

◆ FD_step_used_in_get_hessian_vector_products

double oomph::Problem::FD_step_used_in_get_hessian_vector_products

protected

Referenced by get_hessian_vector_products().

◆ First_jacobian_sign_change

bool oomph::Problem::First_jacobian_sign_change

protected

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

Referenced by arc_length_step_solve_helper(), and reset_arc_length_parameters().

◆ Global_data_pt

Vector<Data*> oomph::Problem::Global_data_pt

private

Vector of global data: "Nobody" (i.e. none of the elements etc.) is "in charge" of this Data so it would be overlooked when it comes to equation-numbering, timestepping etc. Including (pointers) to such Data in here, puts the Problem itself "in charge" of these tasks.

Referenced by add_global_data(), assign_eqn_numbers(), assign_initial_values_impulsive(), calculate_predictions(), copy(), describe_dofs(), does_pointer_correspond_to_problem_data(), dump(), flush_global_data(), get_dofs(), global_data_pt(), nglobal_data(), read(), self_test(), set_consistent_pinned_values_for_continuation(), set_dofs(), set_pinned_values_to_zero(), set_timestepper_for_all_data(), and shift_time_values().

◆ Jacobian_has_been_computed

bool oomph::Problem::Jacobian_has_been_computed

protected

Has a Jacobian been computed (and can therefore be re-used if required)? Default: false

Referenced by disable_jacobian_reuse(), enable_jacobian_reuse(), and newton_solve().

◆ Jacobian_reuse_is_enabled

bool oomph::Problem::Jacobian_reuse_is_enabled

protected

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

Referenced by disable_jacobian_reuse(), enable_jacobian_reuse(), jacobian_reuse_is_enabled(), and newton_solve().

◆ Keep_temporal_error_below_tolerance

bool oomph::Problem::Keep_temporal_error_below_tolerance

protected

Boolean to decide if a timestep is to be rejected if the error estimate post-solve (computed by global_temporal_error_norm()) exceeds the tolerance required in the call to adaptive_unsteady_newton_solve(...). Defaults to true.

Referenced by adaptive_unsteady_newton_solve(), and SurfactantProblem< ELEMENT, INTERFACE_ELEMENT >::SurfactantProblem().

◆ Linear_solver_pt

LinearSolver* oomph::Problem::Linear_solver_pt

private

Pointer to the linear solver for the problem.

Referenced by activate_bifurcation_tracking(), activate_fold_tracking(), activate_hopf_tracking(), activate_pitchfork_tracking(), calculate_continuation_derivatives(), linear_solver_pt(), newton_solve(), newton_solve_continuation(), and Problem().

◆ Mass_matrix_has_been_computed

bool oomph::Problem::Mass_matrix_has_been_computed

protected

Has the mass matrix been computed (and can therefore be reused) Default: false

Referenced by disable_mass_matrix_reuse(), enable_mass_matrix_reuse(), and get_inverse_mass_matrix_times_residuals().

◆ Mass_matrix_reuse_is_enabled

bool oomph::Problem::Mass_matrix_reuse_is_enabled

protected

Is re-use of the mass matrix in explicit timestepping enabled Default:false

Referenced by disable_mass_matrix_reuse(), enable_mass_matrix_reuse(), get_inverse_mass_matrix_times_residuals(), and mass_matrix_reuse_is_enabled().

◆ Mass_matrix_solver_for_explicit_timestepper_pt

LinearSolver* oomph::Problem::Mass_matrix_solver_for_explicit_timestepper_pt

private

Pointer to the linear solver used for explicit time steps (this is likely to be different to the linear solver for newton solves because explicit time steps only involve inverting a mass matrix. This can be done very efficiently by, e.g. CG with a diagonal predconditioner).

Referenced by mass_matrix_solver_for_explicit_timestepper_pt(), and Problem().

◆ Max_newton_iterations

unsigned oomph::Problem::Max_newton_iterations

protected

Maximum number of Newton iterations.

Referenced by max_newton_iterations(), newton_solve(), newton_solve_continuation(), RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::RefineableConvectionProblem(), RefineableDDConvectionProblem< NST_ELEMENT, AD_ELEMENT >::RefineableDDConvectionProblem(), steady_newton_solve(), RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::switch_to_iterative_linear_solver(), TurekNonFSIProblem< ELEMENT >::TurekNonFSIProblem(), TurekProblem< FLUID_ELEMENT, SOLID_ELEMENT >::TurekProblem(), and unsteady_newton_solve().

◆ Max_res

Vector<double> oomph::Problem::Max_res

protected

Maximum residuals at start and after each newton iteration.

Referenced by newton_solve().

◆ Max_residuals

double oomph::Problem::Max_residuals

protected

Maximum desired residual: if the maximum residual exceeds this value, the program will exit

Referenced by FlowAroundCylinderProblem< ELEMENT >::FlowAroundCylinderProblem(), max_residuals(), MovingBlockProblem< ELEMENT >::MovingBlockProblem(), newton_solve(), newton_solve_continuation(), steady_newton_solve(), SteadyHelicalProblem< ELEMENT >::SteadyHelicalProblem(), TurekNonFSIProblem< ELEMENT >::TurekNonFSIProblem(), TurekProblem< FLUID_ELEMENT, SOLID_ELEMENT >::TurekProblem(), and unsteady_newton_solve().

◆ Maximum_dt

double oomph::Problem::Maximum_dt

protected

Maximum desired dt.

Referenced by adaptive_unsteady_newton_solve(), and maximum_dt().

◆ Mesh_pt

Mesh* oomph::Problem::Mesh_pt

private

The mesh pointer.

Referenced by assign_eqn_numbers(), assign_initial_values_impulsive(), build_global_mesh(), calculate_predictions(), describe_dofs(), does_pointer_correspond_to_problem_data(), get_hessian_vector_products(), get_jacobian(), get_residuals(), mesh_pt(), rebuild_global_mesh(), set_consistent_pinned_values_for_continuation(), set_pinned_values_to_zero(), set_timestepper_for_all_data(), shift_time_values(), and ~Problem().

◆ Minimum_ds

double oomph::Problem::Minimum_ds

protected

Minimum desired value of arc-length.

Referenced by arc_length_step_solve_helper(), and OrrSommerfeldProblem< ELEMENT >::OrrSommerfeldProblem().

◆ Minimum_dt

double oomph::Problem::Minimum_dt

protected

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

Referenced by adaptive_unsteady_newton_solve(), and minimum_dt().

◆ Minimum_dt_but_still_proceed

double oomph::Problem::Minimum_dt_but_still_proceed

protected

If Minimum_dt_but_still_proceed positive, then dt will not be reduced below this value during adaptive timestepping and the computation will continue with this value, accepting the larger errors that this will incur). Note: This option is disabled by default as this value is initialised to -1.0.

Referenced by adaptive_unsteady_newton_solve().

◆ Newton_solver_tolerance

double oomph::Problem::Newton_solver_tolerance

protected

The Tolerance below which the Newton Method is deemed to have converged

Referenced by oomph::SegregatableFSIProblem::assess_convergence_based_on_absolute_solid_change(), oomph::SegregatableFSIProblem::assess_convergence_based_on_max_global_residual(), oomph::SegregatableFSIProblem::assess_convergence_based_on_relative_solid_change(), FreeSurfaceRotationProblem< ELEMENT >::FreeSurfaceRotationProblem(), newton_solve(), newton_solve_continuation(), newton_solver_tolerance(), and oomph::SegregatableFSIProblem::SegregatableFSIProblem().

◆ Nnewton_iter_taken

unsigned oomph::Problem::Nnewton_iter_taken

protected

Actual number of Newton iterations taken during the most recent iteration

Referenced by newton_solve().

◆ Numerical_zero_for_sparse_assembly

double oomph::Problem::Numerical_zero_for_sparse_assembly

protected

A tolerance used to determine whether the entry in a sparse matrix is zero. If it is then storage need not be allocated.

Referenced by sparse_assemble_row_or_column_compressed_with_lists(), sparse_assemble_row_or_column_compressed_with_maps(), sparse_assemble_row_or_column_compressed_with_two_arrays(), sparse_assemble_row_or_column_compressed_with_two_vectors(), and sparse_assemble_row_or_column_compressed_with_vectors_of_pairs().

◆ Parameter_current

double oomph::Problem::Parameter_current

protected

Storage for the present value of the global parameter.

Referenced by arc_length_step_solve_helper(), calculate_continuation_derivatives_fd_helper(), and newton_solve_continuation().

◆ Parameter_derivative

double oomph::Problem::Parameter_derivative

protected

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

Referenced by arc_length_step_solve_helper(), calculate_continuation_derivatives(), calculate_continuation_derivatives_fd(), calculate_continuation_derivatives_fd_helper(), calculate_continuation_derivatives_helper(), newton_solve_continuation(), and reset_arc_length_parameters().

◆ Pause_at_end_of_sparse_assembly

bool oomph::Problem::Pause_at_end_of_sparse_assembly

protected

Protected boolean flag to halt program execution during sparse assemble process to assess peak memory usage. Initialised to false (obviously!)

Referenced by sparse_assemble_row_or_column_compressed_with_lists(), sparse_assemble_row_or_column_compressed_with_maps(), sparse_assemble_row_or_column_compressed_with_two_arrays(), sparse_assemble_row_or_column_compressed_with_two_vectors(), and sparse_assemble_row_or_column_compressed_with_vectors_of_pairs().

◆ Problem_is_nonlinear

bool oomph::Problem::Problem_is_nonlinear

protected

Boolean flag indicating if we're dealing with a linear or nonlinear Problem – if set to false the Newton solver will not check the residual before or after the linear solve. Set to true by default; can be over-written in specific Problem class.

Referenced by AxiPoroProblem< ELEMENT, TIMESTEPPER >::AxiPoroProblem(), BiharmonicTestProblem1::BiharmonicTestProblem1(), BiharmonicTestProblem2::BiharmonicTestProblem2(), newton_solve(), problem_is_nonlinear(), oomph::ProjectionProblem< PROJECTABLE_ELEMENT >::project(), oomph::ProjectionProblem< PROJECTABLE_ELEMENT >::ProjectionProblem(), and oomph::WomersleyProblem< ELEMENT, DIM >::WomersleyProblem().

◆ Relaxation_factor

double oomph::Problem::Relaxation_factor

protected

Relaxation fator for Newton method (only a fractional Newton correction is applied if this is less than 1; default 1).

Referenced by newton_solve().

◆ Saved_dof_pt

Vector<double>* oomph::Problem::Saved_dof_pt

private

Pointer to vector for backup of dofs.

Referenced by restore_dof_values(), and store_current_dof_values().

◆ Scale_arc_length

bool oomph::Problem::Scale_arc_length

protected

Boolean to control whether arc-length should be scaled.

Referenced by calculate_continuation_derivatives(), and calculate_continuation_derivatives_fd().

◆ Shut_up_in_newton_solve

bool oomph::Problem::Shut_up_in_newton_solve

Boolean to indicate if all output is suppressed in Problem::newton_solve(). Defaults to false.

Referenced by disable_info_in_newton_solve(), enable_info_in_newton_solve(), get_inverse_mass_matrix_times_residuals(), newton_solve(), newton_solve_continuation(), and oomph::ProjectionProblem< PROJECTABLE_ELEMENT >::project().

◆ Sign_of_jacobian

int oomph::Problem::Sign_of_jacobian

protected

Storage for the sign of the global Jacobian.

Referenced by arc_length_step_solve_helper(), reset_arc_length_parameters(), and sign_of_jacobian().

◆ Sparse_assemble_with_arrays_allocation_increment

unsigned oomph::Problem::Sparse_assemble_with_arrays_allocation_increment

protected

the number of elements to add to a matrix row when the initial allocation is exceeded within the sparse_assemble_with_two_arrays(...) method.

Referenced by sparse_assemble_row_or_column_compressed_with_two_arrays().

◆ Sparse_assemble_with_arrays_initial_allocation

unsigned oomph::Problem::Sparse_assemble_with_arrays_initial_allocation

protected

the number of elements to initially allocate for a matrix row within the sparse_assembly_with_two_arrays(...) method (if a matrix of this size has not been assembled already). If a matrix of this size has been assembled then the number of elements in each row in that matrix is used as the initial allocation

Referenced by sparse_assemble_row_or_column_compressed_with_two_arrays().

◆ Sparse_assemble_with_arrays_previous_allocation

Vector<Vector<unsigned> > oomph::Problem::Sparse_assemble_with_arrays_previous_allocation

protected

the number of elements in each row of a compressed matrix in the previous matrix assembly.

Referenced by assign_eqn_numbers(), oomph::FoldHandler::FoldHandler(), oomph::HopfHandler::HopfHandler(), oomph::PitchForkHandler::PitchForkHandler(), oomph::FoldHandler::solve_augmented_block_system(), oomph::PitchForkHandler::solve_augmented_block_system(), oomph::FoldHandler::solve_block_system(), oomph::PitchForkHandler::solve_block_system(), oomph::HopfHandler::solve_complex_system(), oomph::FoldHandler::solve_full_system(), oomph::PitchForkHandler::solve_full_system(), oomph::HopfHandler::solve_full_system(), oomph::HopfHandler::solve_standard_system(), sparse_assemble_row_or_column_compressed_with_two_arrays(), oomph::FoldHandler::~FoldHandler(), oomph::HopfHandler::~HopfHandler(), and oomph::PitchForkHandler::~PitchForkHandler().

◆ Sparse_assembly_method

unsigned oomph::Problem::Sparse_assembly_method

protected

Flag to determine which sparse assembly method to use By default we use assembly by vectors of pairs.

Referenced by sparse_assemble_row_or_column_compressed().

◆ Store_local_dof_pt_in_elements

bool oomph::Problem::Store_local_dof_pt_in_elements

private

Boolean to indicate whether local dof pointers should be stored in the elements

Referenced by assign_eqn_numbers(), disable_store_local_dof_pt_in_elements(), and enable_store_local_dof_pt_in_elements().

◆ Sub_mesh_pt

Vector<Mesh*> oomph::Problem::Sub_mesh_pt

private

Vector of pointers to submeshes.

Referenced by add_sub_mesh(), assign_eqn_numbers(), build_global_mesh(), describe_dofs(), does_pointer_correspond_to_problem_data(), flush_sub_meshes(), mesh_pt(), nsub_mesh(), Problem(), rebuild_global_mesh(), set_consistent_pinned_values_for_continuation(), set_pinned_values_to_zero(), set_timestepper_for_all_data(), and ~Problem().

◆ Suppress_warning_about_actions_before_read_unstructured_meshes

bool Problem::Suppress_warning_about_actions_before_read_unstructured_meshes

static

Initial value:

=

false

Flag to allow suppression of warning messages re reading in unstructured meshes during restart.

Instantiation of public flag to allow suppression of warning messages re reading in unstructured meshes during restart.

Referenced by read().

◆ Theta_squared

double oomph::Problem::Theta_squared

protected

Value of the scaling parameter required so that the parameter occupies the desired proportion of the arc length. NOTE: If you wish to change this then make sure to set the value of Scale_arc_length to false to ensure the value of this isn't overwritten during the arc-length process. Instead of changing this variable, it's better to actually update the Desired_proportion_of_arc_length value.

Referenced by calculate_continuation_derivatives(), calculate_continuation_derivatives_fd(), calculate_continuation_derivatives_fd_helper(), calculate_continuation_derivatives_helper(), newton_solve_continuation(), and reset_arc_length_parameters().

◆ Time_adaptive_newton_crash_on_solve_fail

bool oomph::Problem::Time_adaptive_newton_crash_on_solve_fail

protected

Bool to specify what to do if a Newton solve fails within a time adaptive solve. Default (false) is to half the step and try again. If true then crash instead.

Referenced by adaptive_unsteady_newton_solve(), and time_adaptive_newton_crash_on_solve_fail().

◆ Time_pt

Time* oomph::Problem::Time_pt

private

Pointer to global time for the problem.

Referenced by add_time_stepper_pt(), initialise_dt(), set_explicit_time_stepper_pt(), shift_time_values(), time(), time_pt(), and ~Problem().

◆ Time_stepper_pt

Vector<TimeStepper*> oomph::Problem::Time_stepper_pt

private

The Vector of time steppers (there could be many different ones in multiphysics problems)

Referenced by add_time_stepper_pt(), calculate_predictions(), ntime_stepper(), Problem(), and time_stepper_pt().

◆ Timestep_reduction_factor_after_nonconvergence

double oomph::Problem::Timestep_reduction_factor_after_nonconvergence

protected

What it says: If temporally adaptive Newton solver fails to to converge, reduce timestep by this factor and try again; defaults to 1/2; can be over-written by user in derived problem.

Referenced by adaptive_unsteady_newton_solve().

◆ Use_continuation_timestepper

bool oomph::Problem::Use_continuation_timestepper

protected

Boolean to control original or new storage of dof stuff.

Referenced by adapt(), arc_length_step_solve(), arc_length_step_solve_helper(), calculate_continuation_derivatives_helper(), dof_current(), and dof_derivative().

◆ Use_finite_differences_for_continuation_derivatives

bool oomph::Problem::Use_finite_differences_for_continuation_derivatives

protected

Boolean to specify which scheme to use to calculate the continuation derivatievs

Referenced by arc_length_step_solve_helper().

◆ Use_globally_convergent_newton_method

bool oomph::Problem::Use_globally_convergent_newton_method

private

Use the globally convergent newton method.

Referenced by disable_globally_convergent_newton_method(), enable_globally_convergent_newton_method(), and newton_solve().

◆ Use_predictor_values_as_initial_guess

bool oomph::Problem::Use_predictor_values_as_initial_guess

private

Use values from the time stepper predictor as an initial guess.

Referenced by Problem(), and use_predictor_values_as_initial_guess().

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

Public Types

Public Member Functions

Public Attributes

Static Public Attributes

Protected Types

Protected Member Functions

Protected Attributes

Static Protected Attributes

Private Member Functions

Private Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ SpatialErrorEstimatorFctPt

◆ SpatialErrorEstimatorWithDocFctPt

Member Enumeration Documentation

◆ Assembly_method

Constructor & Destructor Documentation

◆ Problem() [1/2]

◆ Problem() [2/2]

◆ ~Problem()

Member Function Documentation

◆ actions_after_adapt()

◆ actions_after_change_in_bifurcation_parameter()

◆ actions_after_change_in_global_parameter()

◆ actions_after_explicit_timestep()

◆ actions_after_implicit_timestep()

◆ actions_after_implicit_timestep_and_error_estimation()

◆ actions_after_newton_solve()

◆ actions_after_newton_step()

◆ actions_after_parameter_increase()

◆ actions_after_read_unstructured_meshes()

◆ actions_before_adapt()

◆ actions_before_explicit_timestep()

◆ actions_before_implicit_timestep()

◆ actions_before_newton_convergence_check()

◆ actions_before_newton_solve()

◆ actions_before_newton_step()

◆ actions_before_read_unstructured_meshes()

◆ activate_bifurcation_tracking() [1/2]

◆ activate_bifurcation_tracking() [2/2]

◆ activate_fold_tracking()

◆ activate_hopf_tracking() [1/2]

◆ activate_hopf_tracking() [2/2]

◆ activate_pitchfork_tracking()

◆ adapt() [1/2]

◆ adapt() [2/2]

◆ adapt_based_on_error_estimates() [1/2]

◆ adapt_based_on_error_estimates() [2/2]

◆ adaptive_unsteady_newton_solve() [1/2]

◆ adaptive_unsteady_newton_solve() [2/2]

◆ add_eigenvector_to_dofs()

◆ add_global_data()

◆ add_sub_mesh()

◆ add_time_stepper_pt()

◆ add_to_dofs()

◆ arc_length_step_solve() [1/2]

◆ arc_length_step_solve() [2/2]

◆ arc_length_step_solve_helper()

◆ are_hessian_products_calculated_analytically()

◆ assembly_handler_pt() [1/2]

◆ assembly_handler_pt() [2/2]

◆ assign_eigenvector_to_dofs()

◆ assign_eqn_numbers()

◆ assign_initial_values_impulsive() [1/2]

◆ assign_initial_values_impulsive() [2/2]

◆ bifurcation_adapt_doc_errors()

◆ bifurcation_adapt_helper()

◆ bifurcation_parameter_pt()

◆ build_global_mesh()

◆ calculate_continuation_derivatives() [1/2]

◆ calculate_continuation_derivatives() [2/2]

◆ calculate_continuation_derivatives_fd()

◆ calculate_continuation_derivatives_fd_helper()

◆ calculate_continuation_derivatives_helper()

◆ calculate_predictions()

◆ communicator_pt() [1/2]

◆ communicator_pt() [2/2]

◆ copy()

◆ deactivate_bifurcation_tracking()