#include <SolidProblem.h>

Inheritance diagram for SolidProblem< ELEMENT_TYPE >:

Public Types
enum	Boundary : unsigned { Z_MIN = 0 , Y_MIN = 1 , X_MAX = 2 , Y_MAX = 3 , X_MIN = 4 , Z_MAX = 5 }

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

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

Public Member Functions
	SolidProblem ()
	Constructor: set default constitutive law and time stepper. More...

void	setName (const std::string &name)
	set function for name_ More...

std::string	getName () const
	get function for name_ More...

void	setElasticModulus (double elasticModulus)
	set function for elasticModulus_ More...

double	getElasticModulus () const
	get function for elasticModulus_ More...

void	addDissipation (double dissipation)

void	setupRefinementParameters (const double &min_error_target, const double &max_error_target, Z2ErrorEstimator *&error_estimator_pt)

void	addAnisotropy (double Ex, double Ey, double Ez)

void	setOomphGravity (double gravity)
	set function for elasticModulus_ More...

double	getOomphGravity () const
	get function for gravity_ More...

void	setPoissonRatio (double poissonRatio)
	set function for poissonRatio_ More...

double	getPoissonRatio () const
	get function for poissonRatio_ More...

void	setDensity (double density)
	set function for density_ More...

double	getDensity () const
	get function for density_ More...

void	setBodyForceAsGravity (double gravity=9.8)
	set function for body_force_pt More...

void	setIsPinned (std::function< bool(SolidNode *, unsigned)> isPinned)
	set function for isPinned_ More...

void	pinBoundary (unsigned b)

void	pinBoundaries (std::vector< unsigned > b)

std::enable_if< std::is_base_of< RefineableQDPVDElement< 3, 2 >, ELEMENT >::value, void >	setDissipation (double dissipation)
	Sets the dissipation coefficient for all elements. More...

void	setNewtonSolverTolerance (double Newton_solver_tolerance)
	set function for Newton_solver_tolerance More...

void	setMaxNewtonIterations (unsigned Max_newton_iterations)
	set function for Max_newton_iterations More...

void	setOomphTimeStep (double dt)
	set function for time step More...

double	getOomphTimeStep () const
	get function for time step More...

double	getOomphTime () const
	get function for current time More...

SolidMesh *&	solid_mesh_pt ()
	Get function for the solid mesh pointer. More...

SolidMesh *&	traction_mesh_pt ()
	Get function for the traction mesh pointer. More...

SolidMesh *const &	solid_mesh_pt () const
	Get function for the solid mesh pointer. More...

SolidMesh *const &	traction_mesh_pt () const
	Get function for the traction mesh pointer. More...

void	getDomainSize (std::array< double, 3 > &min, std::array< double, 3 > &max) const
	Computes the domain size (min/max of the nodal positions in x/y/z) More...

void	prepareForSolve ()

void	countPinned ()
	returns statistics about pinned nodes to the console More...

void	solveSteady (const unsigned &max_adapt=0)

virtual void	actionsBeforeSolve ()

virtual void	actionsAfterSolve ()

virtual void	actionsBeforeOomphTimeStep ()

void	solveUnsteady (double timeMax, double dt, unsigned saveCount=10, const unsigned &max_adapt=0)

void	solveUnsteadyForgiving (double timeMax, double timeMaxMin, double dt, unsigned saveCount=10)

void	removeOldFiles () const

void	get_x (const Vector< double > &xi, Vector< double > &x) const

double	getDeflection (Vector< double > xi, unsigned d) const

void	setSolidCubicMesh (const unsigned &nx, const unsigned &ny, const unsigned &nz, const double &xMin, const double &xMax, const double &yMin, const double &yMax, const double &zMin, const double &zMax)

void	saveSolidMesh ()

void	loadSolidMesh (std::string infileName, bool cubic=true)

void	writeToVTK ()

void	getMassMomentumEnergy (double &mass, Vector< double > &com, Vector< double > &linearMomentum, Vector< double > &angularMomentum, double &elasticEnergy, double &kineticEnergy) const
	See PVDEquationsBase<DIM>::get_energy. More...

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

void	set_analytic_dparameter (double *const &parameter_pt)

void	unset_analytic_dparameter (double *const &parameter_pt)

bool	is_dparameter_calculated_analytically (double *const &parameter_pt)

void	set_analytic_hessian_products ()

void	unset_analytic_hessian_products ()

bool	are_hessian_products_calculated_analytically ()

void	set_pinned_values_to_zero ()

bool	distributed () const

virtual void	actions_before_adapt ()

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

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

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

	Problem ()

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

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

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

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

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

Mesh *&	mesh_pt (const unsigned &imesh)

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

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

unsigned	add_sub_mesh (Mesh *const &mesh_pt)

void	flush_sub_meshes ()

void	build_global_mesh ()

void	rebuild_global_mesh ()

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

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

LinearSolver *&	mass_matrix_solver_for_explicit_timestepper_pt ()

LinearSolver *	mass_matrix_solver_for_explicit_timestepper_pt () const

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

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

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

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

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

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

TimeStepper *&	time_stepper_pt ()

const TimeStepper *	time_stepper_pt () const

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

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

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

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

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

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

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

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

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

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

double &	max_residuals ()

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

double &	newton_solver_tolerance ()

void	add_time_stepper_pt (TimeStepper *const &time_stepper_pt)

void	set_explicit_time_stepper_pt (ExplicitTimeStepper *const &explicit_time_stepper_pt)

void	initialise_dt (const double &dt)

void	initialise_dt (const Vector< double > &dt)

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

void	add_global_data (Data *const &global_data_pt)

void	flush_global_data ()

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

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

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

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

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

void	enable_store_local_dof_pt_in_elements ()

void	disable_store_local_dof_pt_in_elements ()

unsigned long	assign_eqn_numbers (const bool &assign_local_eqn_numbers=true)

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

void	enable_discontinuous_formulation ()

void	disable_discontinuous_formulation ()

void	get_dofs (DoubleVector &dofs) const

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

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

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

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

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

double *	global_dof_pt (const unsigned &i)

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

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

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

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

virtual void	get_inverse_mass_matrix_times_residuals (DoubleVector &Mres)

virtual void	get_dvaluesdt (DoubleVector &f)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void	enable_jacobian_reuse ()

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

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

bool &	use_predictor_values_as_initial_guess ()

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

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

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

void	newton_solve (unsigned const &max_adapt)

void	steady_newton_solve (unsigned const &max_adapt=0)

void	copy (Problem *orig_problem_pt)

virtual Problem *	make_copy ()

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

virtual void	read (std::ifstream &restart_file)

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

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

void	delete_all_external_storage ()

virtual void	symmetrise_eigenfunction_for_adaptive_pitchfork_tracking ()

double *	bifurcation_parameter_pt () const

void	get_bifurcation_eigenfunction (Vector< DoubleVector > &eigenfunction)

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

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

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

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

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

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

void	deactivate_bifurcation_tracking ()

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

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

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

void	reset_arc_length_parameters ()

int &	sign_of_jacobian ()

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

void	unsteady_newton_solve (const double &dt)

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

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

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

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

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

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

void	assign_initial_values_impulsive ()

void	assign_initial_values_impulsive (const double &dt)

void	calculate_predictions ()
	Calculate predictions. More...

void	enable_mass_matrix_reuse ()

void	disable_mass_matrix_reuse ()

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

void	refine_uniformly (const Vector< unsigned > &nrefine_for_mesh)

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

void	refine_uniformly_and_prune (const Vector< unsigned > &nrefine_for_mesh)

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

void	refine_uniformly (DocInfo &doc_info)

void	refine_uniformly_and_prune (DocInfo &doc_info)

void	refine_uniformly ()

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

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

void	p_refine_uniformly (const Vector< unsigned > &nrefine_for_mesh)

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

void	p_refine_uniformly_and_prune (const Vector< unsigned > &nrefine_for_mesh)

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

void	p_refine_uniformly (DocInfo &doc_info)

void	p_refine_uniformly_and_prune (DocInfo &doc_info)

void	p_refine_uniformly ()

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

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

void	refine_selected_elements (const Vector< unsigned > &elements_to_be_refined)

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

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

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

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

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

void	p_refine_selected_elements (const Vector< unsigned > &elements_to_be_refined)

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

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

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

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

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

unsigned	unrefine_uniformly ()

unsigned	unrefine_uniformly (const unsigned &i_mesh)

void	p_unrefine_uniformly (DocInfo &doc_info)

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

void	adapt (unsigned &n_refined, unsigned &n_unrefined)

void	adapt ()

void	p_adapt (unsigned &n_refined, unsigned &n_unrefined)

void	p_adapt ()

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

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

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

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

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

void	enable_info_in_newton_solve ()

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

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

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

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

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

virtual void	actions_before_explicit_stage ()

virtual void	actions_after_explicit_stage ()

Protected Types
typedef ELEMENT_TYPE	ELEMENT

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

Protected Attributes
std::string	name_

double	elasticModulus_ = 0
	Elastic modulus (set via setSolid) More...

double	poissonRatio_ = 0
	Poisson's ratio (set via setSolid) More...

double	density_ = 0
	Density. More...

double	gravity_ = 0
	Density. More...

void(*	body_force_fct )(const double &time, const Vector< double > &xi, Vector< double > &b) = nullptr
	Pointer to the body force function. More...

ConstitutiveLaw *	constitutive_law_pt = nullptr
	Pointer to constitutive law (should be set in constructor) More...

SolidMesh *	Solid_mesh_pt = nullptr
	Pointer to solid mesh. More...

SolidMesh *	Traction_mesh_pt = nullptr
	Pointer to mesh of traction elements. More...

std::function< bool(SolidNode *, unsigned)>	isPinned_
	Function to determine which nodal positions are pinned. More...

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

std::map< double *, bool >	Calculate_dparameter_analytic

bool	Calculate_hessian_products_analytic

LinearAlgebraDistribution *	Dof_distribution_pt

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

DoubleVectorWithHaloEntries	Element_count_per_dof

double	Relaxation_factor

double	Newton_solver_tolerance

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

unsigned	Nnewton_iter_taken

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

double	Max_residuals

bool	Time_adaptive_newton_crash_on_solve_fail

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

bool	Jacobian_has_been_computed

bool	Problem_is_nonlinear

bool	Pause_at_end_of_sparse_assembly

bool	Doc_time_in_distribute

unsigned	Sparse_assembly_method

unsigned	Sparse_assemble_with_arrays_initial_allocation

unsigned	Sparse_assemble_with_arrays_allocation_increment

Vector< Vector< unsigned > >	Sparse_assemble_with_arrays_previous_allocation

double	Numerical_zero_for_sparse_assembly

double	FD_step_used_in_get_hessian_vector_products

bool	Mass_matrix_reuse_is_enabled

bool	Mass_matrix_has_been_computed

bool	Discontinuous_element_formulation

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

double	Maximum_dt
	Maximum desired dt. More...

double	DTSF_max_increase

double	DTSF_min_decrease

double	Minimum_dt_but_still_proceed

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

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

double	Theta_squared

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

double	Continuation_direction

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

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

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

unsigned	Dof_derivative_offset

unsigned	Dof_current_offset

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

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

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

unsigned	Desired_newton_iterations_ds

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

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

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

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

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

bool	Use_finite_differences_for_continuation_derivatives

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

bool	Always_take_one_newton_step

double	Timestep_reduction_factor_after_nonconvergence

bool	Keep_temporal_error_below_tolerance

Additional Inherited Members
Public Attributes inherited from oomph::Problem
bool	Shut_up_in_newton_solve

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

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

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

virtual void	actions_before_newton_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 ()

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

Detailed Description

template<class ELEMENT_TYPE>
class SolidProblem< ELEMENT_TYPE >

Base class for (surface-coupled) problems with a solid body.

Assumptions:

The element type is derived from QPVDElement, i.e. a solid.
The mesh type is derived from SolidMesh.
The constitutive law is derived from Hookean, with parameters elasticModulus, poissonRatio, density.

The solid properties (elasticModulus, poissonRatio, density, constitutive_law_pt, body_force_fct, etc.) are stored in member variables, not in globals as typical in oomph-lib, and accessed by setters and getters.

Additional functionality:

setIsPinned allows one to define the pinned nodes using a function.

Member Typedef Documentation

◆ ELEMENT

template<class ELEMENT_TYPE >

typedef ELEMENT_TYPE SolidProblem< ELEMENT_TYPE >::ELEMENT

protected

Member Enumeration Documentation

◆ Boundary

template<class ELEMENT_TYPE >

enum SolidProblem::Boundary : unsigned

Enumerator
Z_MIN
Y_MIN
X_MAX
Y_MAX
X_MIN
Z_MAX

     {
         Z_MIN = 0, Y_MIN = 1, X_MAX = 2, Y_MAX = 3, X_MIN = 4, Z_MAX = 5
     };

Constructor & Destructor Documentation

◆ SolidProblem()

template<class ELEMENT_TYPE >

SolidProblem< ELEMENT_TYPE >::SolidProblem ( )

inline

Constructor: set default constitutive law and time stepper.

     {
         logger(INFO, "Set default constitutive law (AnisotropicHookean) and time stepper (Newmark<2>)");
  
         // Set Newton solver tolerance and maximum number of Newton iterations
         Max_newton_iterations = 20;
         Newton_solver_tolerance = 1e-10;
         Max_residuals = constants::inf;
  
         // Set constitutive law
         constitutive_law_pt = new AnisotropicHookean(&poissonRatio_, &elasticModulus_);
  
         // Allocate the timestepper
         add_time_stepper_pt(new Newmark<2>);
  
         //build_mesh();
  
         // setup boundary conditions
         //pin_and_assign_eqn_numbers();
     };

References e(), constants::inf, INFO, logger, and oomph::Locate_zeta_helpers::Max_newton_iterations.

Member Function Documentation

◆ actionsAfterSolve()

template<class ELEMENT_TYPE >

virtual void SolidProblem< ELEMENT_TYPE >::actionsAfterSolve ( )

inlinevirtual

Reimplemented in Beam.

435 {}

◆ actionsBeforeOomphTimeStep()

template<class ELEMENT_TYPE >

virtual void SolidProblem< ELEMENT_TYPE >::actionsBeforeOomphTimeStep ( )

inlinevirtual

Reimplemented in Beam, SolidBag, and Beam.

437 {}

◆ actionsBeforeSolve()

template<class ELEMENT_TYPE >

virtual void SolidProblem< ELEMENT_TYPE >::actionsBeforeSolve ( )

inlinevirtual

Reimplemented in Beam, and Beam.

433 {}

◆ addAnisotropy()

template<class ELEMENT_TYPE >

void SolidProblem< ELEMENT_TYPE >::addAnisotropy	(	double	Ex,
		double	Ey,
		double	Ez
	)

inline

     {
         logger(INFO,"Adding anisotropy E = [% % %]",Ex, Ey, Ez);
         // make constitutive law anisotropic in x-direction
         elasticModulus_ = Ex;
         auto hooke_law_pt = dynamic_cast<AnisotropicHookean*>(constitutive_law_pt);
         hooke_law_pt->setAnisotropy({1.0, Ey/Ex, Ez/Ex});
     }

References INFO, logger, and oomph::AnisotropicHookean::setAnisotropy().

◆ addDissipation()

template<class ELEMENT_TYPE >

void SolidProblem< ELEMENT_TYPE >::addDissipation ( double dissipation )

inline

     {
         logger(INFO,"Adding dissipation %",dissipation);
         for (int i = 0; i < solid_mesh_pt()->nelement(); ++i)
         {
             dynamic_cast<ELEMENT*>(solid_mesh_pt()->element_pt(i))->dissipation_ = dissipation;
         }
     }

References i, INFO, and logger.

◆ countPinned()

template<class ELEMENT_TYPE >

void SolidProblem< ELEMENT_TYPE >::countPinned ( )

inline

returns statistics about pinned nodes to the console

     {
         // count pinned
         std::array<unsigned,3> countPinned {0,0,0};
         unsigned countAll = 0;
         for (unsigned n = 0; n < solid_mesh_pt()->nnode(); n++)
         {
             for (unsigned i = 0; i < 3; i++)
             {
                 countPinned[i] += solid_mesh_pt()->node_pt(n)->position_is_pinned(i);
                 countAll++;
             }
         }
         unsigned countPinnedAll = countPinned[0] + countPinned[1] +countPinned[2];
         logger(INFO, "Pinned % of % positions (% free): % in x, % in y, % in z", countPinnedAll, countAll, countAll - countPinnedAll, countPinned[0], countPinned[1], countPinned[2]);
     }

References i, INFO, logger, and n.

◆ get_x()

template<class ELEMENT_TYPE >

void SolidProblem< ELEMENT_TYPE >::get_x	(	const Vector< double > &	xi,
		Vector< double > &	x
	)		const

inline

Returns the x value at a certain xi value

     {
         if (OOMPH_MPI_PROCESSOR_NUM>1) {
             logger(INFO, "get_x does not work with MPI");
             for (int i = 0; i < 3; ++i) {
                 x[i] = xi[i];
             }
         } else {
             Vector<double> s(3);
             GeomObject *geom_obj_pt = nullptr;
             const unsigned long nelement = solid_mesh_pt()->nelement();
             for (unsigned long i = 0; i < nelement; i++) {
                 auto el_pt = dynamic_cast<ELEMENT *>(solid_mesh_pt()->element_pt(i));
                 el_pt->locate_zeta(xi, geom_obj_pt, s);
                 if (geom_obj_pt) {
                     //logger(INFO,"Point % % % is in element % at % % %",
                     //       xi[0],xi[1],xi[2],i,s[0], s[1], s[2]);
                     el_pt->interpolated_x(s, x); //deformed coordinate
                     return;
                 }
             }
             logger(ERROR, "x(xi) could not be found");
         }
     }

References ERROR, i, INFO, oomph::GeomObject::locate_zeta(), logger, OOMPH_MPI_PROCESSOR_NUM, s, and plotDoE::x.

◆ getDeflection()

template<class ELEMENT_TYPE >

double SolidProblem< ELEMENT_TYPE >::getDeflection	(	Vector< double >	xi,
		unsigned	d
	)		const

inline

Returns the difference between the x and xi value in dimension d at a certain xi value

     {
         Vector<double> x(3);
         get_x(xi, x);
         return x[d] - xi[d];
     }

References plotDoE::x.

◆ getDensity()

template<class ELEMENT_TYPE >

double SolidProblem< ELEMENT_TYPE >::getDensity ( ) const

inline

get function for density_

     {
         return density_;
     }

◆ getDomainSize()

template<class ELEMENT_TYPE >

void SolidProblem< ELEMENT_TYPE >::getDomainSize	(	std::array< double, 3 > &	min,
		std::array< double, 3 > &	max
	)		const

inline

Computes the domain size (min/max of the nodal positions in x/y/z)

     {
         min[0] = min[1] = min[2] = constants::inf;
         max[0] = max[1] = max[2] = -constants::inf;
         logger.assert_always(solid_mesh_pt(),"mesh not found");
         for (unsigned i = 0; i < solid_mesh_pt()->nnode(); i++)
         {
             const auto n = solid_mesh_pt()->node_pt(i);
             for (int j = 0; j < 3; ++j)
             {
                 min[j] = std::min(min[j], n->xi(j));
                 max[j] = std::max(max[j], n->xi(j));
             }
         }
     }

References i, constants::inf, j, logger, max, min, and n.

◆ getElasticModulus()

template<class ELEMENT_TYPE >

double SolidProblem< ELEMENT_TYPE >::getElasticModulus ( ) const

inline

get function for elasticModulus_

     {
         return elasticModulus_;
     }

◆ getMassMomentumEnergy()

template<class ELEMENT_TYPE >

void SolidProblem< ELEMENT_TYPE >::getMassMomentumEnergy	(	double &	mass,
		Vector< double > &	com,
		Vector< double > &	linearMomentum,
		Vector< double > &	angularMomentum,
		double &	elasticEnergy,
		double &	kineticEnergy
	)		const

inline

See PVDEquationsBase<DIM>::get_energy.

                                                             {
         // Initialise mass
         mass = 0;
         // Initialise center of mass
         com.initialise(0);
         // Initialise momentum
         linearMomentum.initialise(0);
         angularMomentum.initialise(0);
         // Initialise energy
         elasticEnergy = 0;
         kineticEnergy = 0;
  
         // For each element
         const unsigned long nelement = this->solid_mesh_pt()->nelement();
         for (unsigned long e = 0; e < nelement; e++) {
  
             // Get the pointer to the element
             ELEMENT* e_pt = dynamic_cast<ELEMENT*>(Solid_mesh_pt->element_pt(e));
  
             const unsigned DIM = e_pt->dim();
  
             //Find out how many integration points there are
             unsigned n_intpt = e_pt->integral_pt()->nweight();
  
             //Set the Vector to hold local coordinates
             Vector<double> s(DIM);
  
             //Find out how many nodes there are
             const unsigned n_node = e_pt->nnode();
  
             //Find out how many positional dofs there are
             const unsigned n_position_type = e_pt->nnodal_position_type();
  
             //Set up memory for the shape functions
             Shape psi(n_node, n_position_type);
             DShape dpsidxi(n_node, n_position_type, DIM);
  
             // Timescale ratio (non-dim density)
             double lambda_sq = e_pt->lambda_sq();
  
             //Loop over the integration points
             for (unsigned ipt = 0; ipt < n_intpt; ipt++) {
                 //Assign local coordinate s
                 for (unsigned i = 0; i < DIM; i++) { s[i] = e_pt->integral_pt()->knot(ipt, i); }
  
                 //Get the integral weight
                 double w = e_pt->integral_pt()->weight(ipt);
  
                 //Evaluate the shape function and its derivatives, and get Jacobian
                 double J = e_pt->dshape_lagrangian_at_knot(ipt, psi, dpsidxi);
  
                 //Get mass and the coupling weight at the integration point
                 double coupling_w = 0;
                 //for (unsigned l = 0; l < n_node; l++)
                 //{
                 //    double nodal_coupling_w = dynamic_cast<SolidNode*>(e_pt->node_pt(l))->get_coupling_weight();
                 //    double psi_ = psi(l);
                 //    coupling_w += psi_ * nodal_coupling_w;
                 //}
  
                 //Get the coordinates of the integration point
                 Vector<double> x(DIM, 0.0);
                 e_pt->interpolated_x(s,x);
  
                 //Storage for Lagrangian coordinates and velocity (initialised to zero)
                 Vector<double> interpolated_xi(DIM, 0.0);
                 Vector<double> veloc(DIM, 0.0);
  
                 //Calculate lagrangian coordinates
                 for (unsigned l = 0; l < n_node; l++) {
                     //Loop over positional dofs
                     for (unsigned k = 0; k < n_position_type; k++) {
                         //Loop over displacement components (deformed position)
                         for (unsigned i = 0; i < DIM; i++) {
                             //Calculate the Lagrangian coordinates
                             interpolated_xi[i] += e_pt->lagrangian_position_gen(l, k, i) * psi(l, k);
  
                             //Calculate the velocity components (if unsteady solve)
                             if (e_pt->is_inertia_enabled()) {
                                 veloc[i] += e_pt->dnodal_position_gen_dt(l, k, i) * psi(l, k);
                             }
                         }
                     }
                 }
  
                 //Get isotropic growth factor
                 double gamma = 1.0;
                 e_pt->get_isotropic_growth(ipt, s, interpolated_xi, gamma);
  
                 //Premultiply the undeformed volume ratio (from the isotropic
                 // growth), the integral weights, the coupling weights, and the Jacobian
                 double W = gamma * w * (1.0 - coupling_w) * J;
  
                 DenseMatrix<double> sigma(DIM, DIM);
                 DenseMatrix<double> strain(DIM, DIM);
  
                 //Now calculate the stress tensor from the constitutive law
                 e_pt->get_stress(s, sigma);
  
                 // Add pre-stress
                 for (unsigned i = 0; i < DIM; i++) {
                     for (unsigned j = 0; j < DIM; j++) {
                         sigma(i, j) += e_pt->prestress(i, j, interpolated_xi);
                     }
                 }
  
                 //get the strain
                 e_pt->get_strain(s, strain);
  
                 // Initialise
                 double localElasticEnergy = 0;
                 double velocitySquared = 0;
  
                 // Compute integrals
                 for (unsigned i = 0; i < DIM; i++) {
                     for (unsigned j = 0; j < DIM; j++) {
                         localElasticEnergy += sigma(i, j) * strain(i, j);
                     }
                     velocitySquared += veloc[i] * veloc[i];
                 }
  
                 // Mass
                 mass += lambda_sq * W;
                 // Linear momentum and angular momentum
                 Vector<double> cross_product(DIM, 0);
                 VectorHelpers::cross(interpolated_xi, veloc, cross_product);
                 for (unsigned i = 0; i < DIM; i++) {
                     com[i] += lambda_sq * W * x[i];
                     linearMomentum[i] += lambda_sq * veloc[i] * W;
                     angularMomentum[i] += lambda_sq * cross_product[i] * W;
                 }
                 // Potential energy
                 elasticEnergy += 0.5 * localElasticEnergy * W;
                 // Kinetic energy
                 kineticEnergy += lambda_sq * 0.5 * velocitySquared * W;
             }
         }
         for (unsigned i = 0; i < com.size(); i++) {
             com[i] /= mass;
         }
     }

References oomph::VectorHelpers::cross(), DIM, e(), oomph::Mesh::element_pt(), mathsFunc::gamma(), i, oomph::Vector< _Tp >::initialise(), J, j, k, s, calibrate::sigma, w, oomph::QuadTreeNames::W, and plotDoE::x.

◆ getName()

template<class ELEMENT_TYPE >

std::string SolidProblem< ELEMENT_TYPE >::getName ( ) const

inline

get function for name_

     {
         return name_;
     }

◆ getOomphGravity()

template<class ELEMENT_TYPE >

double SolidProblem< ELEMENT_TYPE >::getOomphGravity ( ) const

inline

get function for gravity_

     {
         return gravity_;
     }

◆ getOomphTime()

template<class ELEMENT_TYPE >

double SolidProblem< ELEMENT_TYPE >::getOomphTime ( ) const

inline

get function for current time

                                  {
         return time_pt()->time();
     }

◆ getOomphTimeStep()

template<class ELEMENT_TYPE >

double SolidProblem< ELEMENT_TYPE >::getOomphTimeStep ( ) const

inline

get function for time step

                                      {
         return time_pt()->dt();
     }

◆ getPoissonRatio()

template<class ELEMENT_TYPE >

double SolidProblem< ELEMENT_TYPE >::getPoissonRatio ( ) const

inline

get function for poissonRatio_

     {
         return poissonRatio_;
     }

◆ loadSolidMesh()

template<class ELEMENT_TYPE >

void SolidProblem< ELEMENT_TYPE >::loadSolidMesh	(	std::string	infileName,
		bool	cubic = `true`
	)

inline

     {
         logger(INFO, "Loading % (cubic=%)",infileName, cubic);
         //if (useTetgen()) logger(ERROR, "Not implemented for Tetgen meshes");
  
         std::ifstream mesh(infileName);
         logger.assert_always(mesh.good(),"Mesh file % could not be opened",infileName);
  
         if (cubic) {
             unsigned nx, ny, nz;
             mesh >> nx >> ny >> nz;
             logger(INFO, "Loaded %x%x% cubic mesh from %", nx, ny, nz, infileName);
             logger.assert_debug(nx > 1 and ny > 1 and nz > 1, "Mesh size invalid");
             Solid_mesh_pt = new RefineableSolidCubicMesh<ELEMENT_TYPE>(nx, ny, nz, 0, 1, 0, 1, 0, 1, time_stepper_pt());
             // Assign physical properties to the elements before any refinement
             for (unsigned i = 0; i < solid_mesh_pt()->nelement(); i++)
             {
                 //Cast to a solid element
                 ELEMENT* el_pt = dynamic_cast<ELEMENT*>(solid_mesh_pt()->element_pt(i));
                 // Set the constitutive law
                 el_pt->constitutive_law_pt() = constitutive_law_pt;
             }
         }
  
         double xi, x;
         bool pin;
         logger(INFO, "Loading % nodes", solid_mesh_pt()->nnode());
         for (int i = 0; i < solid_mesh_pt()->nnode(); ++i)
         {
             SolidNode* n = solid_mesh_pt()->node_pt(i);
             for (int j = 0; j < 3; ++j)
             {
                 mesh >> xi >> x >> pin;
                 n->xi(j) = xi;
                 n->x(j) = x;
                 if (pin) n->pin_position(j);
             }
         }
     }

References mathsFunc::cubic(), i, INFO, j, logger, n, Mesh_Parameters::nx, Mesh_Parameters::ny, Mesh_Parameters::nz, and plotDoE::x.

◆ pinBoundaries()

template<class ELEMENT_TYPE >

void SolidProblem< ELEMENT_TYPE >::pinBoundaries ( std::vector< unsigned > b )

inline

                                               {
         for (const auto a: b) {
             logger(INFO, "Pinning nodes on boundary %", a);
         }
         isPinned_ = [b](SolidNode *n, unsigned d) {
             for (const auto a : b) {
                 if (n->is_on_boundary(a)) return true;
             }
             return false;
         };
     }

References a, b, INFO, logger, and n.

◆ pinBoundary()

template<class ELEMENT_TYPE >

void SolidProblem< ELEMENT_TYPE >::pinBoundary ( unsigned b )

inline

                                  {
         logger(INFO, "Pinning nodes on boundary %", b);
         isPinned_ = [b](SolidNode *n, unsigned d) {
             return n->is_on_boundary(b);
         };
     }

References b, INFO, logger, and n.

◆ prepareForSolve()

template<class ELEMENT_TYPE >

void SolidProblem< ELEMENT_TYPE >::prepareForSolve ( )

inline

Asserts all parameters are set
Assign pointers for all elements
Builds global mesh
Pins nodes
Pins solid pressure
Assigns equation numbers

This function should be called before solve(), after creating the mesh, defining body force and constitutive law.

Todo:: UMBU Note, prepareForSolve did not set lambda correctly before

     {
         // check certain values are set
         logger.assert_always(!name_.empty(), "Set name via setName(..)");
         logger.assert_always(elasticModulus_>0, "Set elastic modulus via setElasticModulus(..)");
         logger.assert_always(density_>0, "Set density via setDensity(..)");
         logger.assert_always(solid_mesh_pt(), "Set solid mesh via e.g. setSolidCubicMesh(..)");
  
         // Assign constitutive_law_pt and body_force_fct_pt of each element
         logger(INFO, "Assign constitutive_law, body_force, density to all elements");
         for (unsigned i = 0; i < solid_mesh_pt()->nelement(); i++)
         {
             //Cast to a solid element
             ELEMENT* el_pt = dynamic_cast<ELEMENT*>(solid_mesh_pt()->element_pt(i));
             // Set the constitutive law
             el_pt->constitutive_law_pt() = constitutive_law_pt;
             // Set body force
             el_pt->body_force_fct_pt() = body_force_fct;
             // Set density
             el_pt->lambda_sq_pt() = &density_;
         }
  
         // Construct the traction element mesh
         // Traction_mesh_pt = new SolidMesh;
         // create_traction_elements();
  
         //Build combined "global" mesh
         add_sub_mesh(solid_mesh_pt());
         if (traction_mesh_pt()) {
             add_sub_mesh(traction_mesh_pt());
             logger(INFO, "Built global mesh from solid mesh and traction mesh");
         } else {
             logger(INFO, "Built global mesh from solid mesh");
         }
         build_global_mesh();
  
         //Pin nodes
         if (isPinned_)
         {
             for ( unsigned n = 0; n < solid_mesh_pt()->nnode(); n++ )
             {
                 SolidNode* n_pt = solid_mesh_pt()->node_pt( n );
                 //Pin all nodes
                 for ( unsigned i = 0; i < 3; i++ )
                 {
                     if ( isPinned_( n_pt, i ) )
                     {
                         n_pt->pin_position( i );
                     }
                     else
                     {
                         n_pt->unpin_position( i );
                     }
                 }
             }
         }
         countPinned();
  
         // Pin the redundant solid pressures (if any)
         PVDEquationsBase<3>::pin_redundant_nodal_solid_pressures(
             solid_mesh_pt()->element_pt());
         logger(INFO, "Pinned redundant nodal solid pressures");
  
         // Attach the boundary conditions to the mesh
         unsigned n_eq = assign_eqn_numbers();
         logger(INFO, "Assigned % equation numbers", n_eq);
     }

References i, INFO, logger, n, oomph::SolidNode::pin_position(), oomph::PVDEquationsBase< DIM >::pin_redundant_nodal_solid_pressures(), and oomph::SolidNode::unpin_position().

◆ removeOldFiles()

template<class ELEMENT_TYPE >

void SolidProblem< ELEMENT_TYPE >::removeOldFiles ( ) const

inline

Removes old output files (vtu) with the same name as this problem.

     {
         for (int i = 0; true; ++i)
         {
             std::string fileName = name_ + "FEM_" + std::to_string(i) + ".vtu";
             if (remove(fileName.c_str())) break;
             std::cout << "Deleted " << fileName << '\n';
         }
     }

References UniformPSDSelfTest::fileName, i, oomph::Global_string_for_annotation::string(), and oomph::StringConversion::to_string().

◆ saveSolidMesh()

template<class ELEMENT_TYPE >

void SolidProblem< ELEMENT_TYPE >::saveSolidMesh ( )

inline

     {
         std::string filename = name_;
 #ifdef OOMPH_HAS_MPI
         // When the problem hasn't been distributed, the whole mesh is stored on every processor.
         // Prevent writing the same file multiple times, so only write for the first processor.
         if (!Problem_has_been_distributed && OOMPH_MPI_PROCESSOR_ID != 0)
             return;
  
         // When the problem has been distributed, add the processor id to the filename.
         if (Problem_has_been_distributed)
             filename += "_" + std::to_string(OOMPH_MPI_PROCESSOR_ID);
 #endif
         filename += ".mesh";
  
         //if (useTetgen()) logger(ERROR, "Not implemented for Tetgen meshes");
  
         std::ofstream mesh(filename);
         auto solid_cubic_mesh_pt = dynamic_cast<RefineableSolidCubicMesh<ELEMENT_TYPE>*>(solid_mesh_pt());
         if (solid_cubic_mesh_pt) {
             //logger.assert_always(solid_cubic_mesh_pt, "Mesh is not cubic");
             mesh << solid_cubic_mesh_pt->nx() << ' ';
             mesh << solid_cubic_mesh_pt->ny() << ' ';
             mesh << solid_cubic_mesh_pt->nz() << '\n';
         }
         for (int i = 0; i < solid_mesh_pt()->nnode(); ++i)
         {
             SolidNode* n = solid_mesh_pt()->node_pt(i);
             for (int j = 0; j < 3; ++j)
             {
                 mesh << n->xi(j) << ' ' << n->x(j) << ' ' << n->position_is_pinned(j) << ' ';
             }
             mesh << '\n';
         }
         if (solid_cubic_mesh_pt) {
             logger(INFO, "Saved %x%x% mesh to %",
                    solid_cubic_mesh_pt->nx(), solid_cubic_mesh_pt->ny(), solid_cubic_mesh_pt->nz(), filename);
         } else {
             logger(INFO, "Saved mesh to % (% nodes)", filename, solid_mesh_pt()->nnode());
         }
     }

References MergeRestartFiles::filename, i, INFO, j, logger, n, oomph::SimpleCubicMesh< ELEMENT >::nx(), OOMPH_MPI_PROCESSOR_ID, oomph::Global_string_for_annotation::string(), and oomph::StringConversion::to_string().

◆ setBodyForceAsGravity()

template<class ELEMENT_TYPE >

void SolidProblem< ELEMENT_TYPE >::setBodyForceAsGravity ( double gravity = 9.8 )

inline

set function for body_force_pt

     {
         logger(INFO, "Setting oomph-gravity in z-direction");
         gravity_ = gravity;
         // define a static body force
         static double& Density = density_;
         static double& Gravity = gravity_;
         body_force_fct = [](const double& time, const Vector<double>& xi, Vector<double>& b) {
             b[0] = 0.0;
             b[1] = 0.0;
             b[2] = -Gravity * Density;
         };
     }

References b, Gravity::gravity(), INFO, and logger.

◆ setDensity()

template<class ELEMENT_TYPE >

void SolidProblem< ELEMENT_TYPE >::setDensity ( double density )

inline

set function for density_

     {
         density_ = density;
         logger(INFO, "Density: %", density_);
     }

References UniformPSDSelfTest::density, INFO, and logger.

◆ setDissipation()

template<class ELEMENT_TYPE >

std::enable_if<std::is_base_of<RefineableQDPVDElement<3,2>, ELEMENT>::value, void> SolidProblem< ELEMENT_TYPE >::setDissipation ( double dissipation )

inline

Sets the dissipation coefficient for all elements.

     {
         for (int i = 0; i < solid_mesh_pt()->nelement(); ++i)
         {
             dynamic_cast<RefineableQDPVDElement<3,2>*>(solid_mesh_pt()->element_pt(i))->setDissipation(dissipation);
         }
     }

References i.

◆ setElasticModulus()

template<class ELEMENT_TYPE >

void SolidProblem< ELEMENT_TYPE >::setElasticModulus ( double elasticModulus )

inline

set function for elasticModulus_

     {
         elasticModulus_ = elasticModulus;
         logger(INFO, "Elastic Modulus: %", elasticModulus_);
     }

References INFO, and logger.

◆ setIsPinned()

template<class ELEMENT_TYPE >

void SolidProblem< ELEMENT_TYPE >::setIsPinned ( std::function< bool(SolidNode *, unsigned)> isPinned )

inline

set function for isPinned_

     {
         isPinned_ = std::move(isPinned);
         logger(INFO, "Setting which positions on which nodes are pinned");
     }

References INFO, and logger.

◆ setMaxNewtonIterations()

template<class ELEMENT_TYPE >

void SolidProblem< ELEMENT_TYPE >::setMaxNewtonIterations ( unsigned Max_newton_iterations )

inline

set function for Max_newton_iterations

     {
         this->Max_newton_iterations = Max_newton_iterations;
     }

References oomph::Locate_zeta_helpers::Max_newton_iterations.

◆ setName()

template<class ELEMENT_TYPE >

void SolidProblem< ELEMENT_TYPE >::setName ( const std::string & name )

inline

set function for name_

     {
         name_ = name;
         logger(INFO, "Name: %", name_);
     }

References INFO, logger, and plotDoE::name.

◆ setNewtonSolverTolerance()

template<class ELEMENT_TYPE >

void SolidProblem< ELEMENT_TYPE >::setNewtonSolverTolerance ( double Newton_solver_tolerance )

inline

set function for Newton_solver_tolerance

     {
         this->Newton_solver_tolerance = Newton_solver_tolerance;
     }

◆ setOomphGravity()

template<class ELEMENT_TYPE >

void SolidProblem< ELEMENT_TYPE >::setOomphGravity ( double gravity )

inline

set function for elasticModulus_

     {
         gravity_ = gravity;
         logger(INFO, "Elastic Modulus: %", gravity_);
     }

References Gravity::gravity(), INFO, and logger.

◆ setOomphTimeStep()

template<class ELEMENT_TYPE >

void SolidProblem< ELEMENT_TYPE >::setOomphTimeStep ( double dt )

inline

set function for time step

                                      {
         time_pt()->initialise_dt(dt);
     }

◆ setPoissonRatio()

template<class ELEMENT_TYPE >

void SolidProblem< ELEMENT_TYPE >::setPoissonRatio ( double poissonRatio )

inline

set function for poissonRatio_

     {
         poissonRatio_ = poissonRatio;
         logger(INFO, "Poisson Ratio: %", poissonRatio_);
     }

References INFO, and logger.

◆ setSolidCubicMesh()

template<class ELEMENT_TYPE >

void SolidProblem< ELEMENT_TYPE >::setSolidCubicMesh	(	const unsigned &	nx,
		const unsigned &	ny,
		const unsigned &	nz,
		const double &	xMin,
		const double &	xMax,
		const double &	yMin,
		const double &	yMax,
		const double &	zMin,
		const double &	zMax
	)

inline

     {
         // Create mesh
         solid_mesh_pt() = new RefineableSolidCubicMesh<ELEMENT_TYPE>(nx, ny, nz, xMin, xMax, yMin, yMax, zMin, zMax, time_stepper_pt());
  
         logger(INFO, "Created %x%x% cubic mesh on domain [%,%]x[%,%]x[%,%]",
                nx, ny, nz, xMin, xMax, yMin, yMax, zMin, zMax);
     }

References INFO, logger, Mesh_Parameters::nx, Mesh_Parameters::ny, and Mesh_Parameters::nz.

◆ setupRefinementParameters()

template<class ELEMENT_TYPE >

void SolidProblem< ELEMENT_TYPE >::setupRefinementParameters	(	const double &	min_error_target,
		const double &	max_error_target,
		Z2ErrorEstimator *&	error_estimator_pt
	)

inline

     {
         RefineableSolidCubicMesh<ELEMENT_TYPE>* refineable_mesh_pt = dynamic_cast<RefineableSolidCubicMesh<ELEMENT_TYPE>*>(solid_mesh_pt());
         // Set error estimator 
         refineable_mesh_pt->spatial_error_estimator_pt()=error_estimator_pt;
         // Error targets for adaptive refinement
         refineable_mesh_pt->max_permitted_error()=max_error_target; 
         refineable_mesh_pt->min_permitted_error()=min_error_target; 
     }

References MeshRefinement::error_estimator_pt, oomph::RefineableMeshBase::max_permitted_error(), oomph::RefineableMeshBase::min_permitted_error(), and oomph::RefineableMeshBase::spatial_error_estimator_pt().

◆ solid_mesh_pt() [1/2]

template<class ELEMENT_TYPE >

SolidMesh*& SolidProblem< ELEMENT_TYPE >::solid_mesh_pt ( )

inline

Get function for the solid mesh pointer.

293 { return Solid_mesh_pt; }

◆ solid_mesh_pt() [2/2]

template<class ELEMENT_TYPE >

SolidMesh* const& SolidProblem< ELEMENT_TYPE >::solid_mesh_pt ( ) const

inline

Get function for the solid mesh pointer.

299 { return Solid_mesh_pt; }

◆ solveSteady()

template<class ELEMENT_TYPE >

void SolidProblem< ELEMENT_TYPE >::solveSteady ( const unsigned & max_adapt = 0 )

inline

Solves a steady problem.

     {
         logger.assert_always(mesh_pt(), "Mesh pointer not set; did you call prepareForSolve?");
         logger(INFO, "Solve steady-state problem");
         actionsBeforeSolve();
         if(max_adapt==0) newton_solve();
         else newton_solve(max_adapt);
         actionsAfterSolve();
         writeToVTK();
         saveSolidMesh();
     }

References INFO, and logger.

◆ solveUnsteady()

template<class ELEMENT_TYPE >

void SolidProblem< ELEMENT_TYPE >::solveUnsteady	(	double	timeMax,
		double	dt,
		unsigned	saveCount = `10`,
		const unsigned &	max_adapt = `0`
	)

inline

Solves an unsteady problem.

Todo:: UMBU changed from

Todo:: UMBU Changed counting back to the old way, otherwise we did not plot the same time step

     {
         logger.assert_always(mesh_pt(), "Mesh pointer not set; did you call prepareForSolve?");
  
         std::cout << "Solving oomph with dt=" << dt << " until timeMax=" << timeMax << std::endl;
  
         // Setup initial conditions. Default is a non-impulsive start
         this->time_pt()->initialise_dt(dt);
         assign_initial_values_impulsive(dt);
         actionsBeforeSolve();
  
         // This is the main loop over advancing time
         double& time = time_stepper_pt()->time();
         unsigned count = 0;
         const unsigned countMax = std::ceil(timeMax/dt);
         while (time < timeMax)
         {
             logger(INFO, "Time %s of %s (% of %)", time, timeMax, count, countMax);
             actionsBeforeOomphTimeStep();
             // solve the oomphProb for one time step (this also increments time)
             //adaptive_unsteady_newton_solve(dt,2e-7);
             if(max_adapt == 0)
             {
              unsteady_newton_solve(dt, true);   
             }
             else
             {
              unsteady_newton_solve(dt, max_adapt, false, true);
             }
             // increase count
             //count++;
             // write outputs of the oomphProb
             if (count++ % saveCount == 0 or time + dt > timeMax) {
                 writeToVTK();
                 // save in case code breaks
                 // saveSolidMesh();
             }
             // abort if problem
             if (Max_res.back()==0) {
                 saveSolidMesh();
                 logger(ERROR, "Maximum residual is 0; exiting the code");
             }
         }
         saveSolidMesh();
         actionsAfterSolve();
     }

References Eigen::bfloat16_impl::ceil(), ERROR, INFO, and logger.

◆ solveUnsteadyForgiving()

template<class ELEMENT_TYPE >

void SolidProblem< ELEMENT_TYPE >::solveUnsteadyForgiving	(	double	timeMax,
		double	timeMaxMin,
		double	dt,
		unsigned	saveCount = `10`
	)

inline

Solves an unsteady problem, returns successful if timeMaxMin has been reached

                                                                                                        {
         // solve
         try {
             solveUnsteady(timeMax, dt, saveCount);
         } catch(OomphLibError& error)  {
             //Store output if newton solver fails
             saveSolidMesh();
             if (time_stepper_pt()->time()-dt >= timeMaxMin) {
                 // take it as successful if a fraction of the time evolution has finished
                 logger(INFO,"Newton solver failed at t=% (tMax=%), but code will continue.",
                        time_stepper_pt()->time()-dt, timeMax);
                 exit(0);
             } else {
                 logger(ERROR,"Newton solver failed at t=% (tMax=%).",
                        time_stepper_pt()->time()-dt, timeMax);
             }
         }
     }

References calibrate::error, ERROR, INFO, and logger.

◆ traction_mesh_pt() [1/2]

template<class ELEMENT_TYPE >

SolidMesh*& SolidProblem< ELEMENT_TYPE >::traction_mesh_pt ( )

inline

Get function for the traction mesh pointer.

296 { return Traction_mesh_pt; }

SolidProblem::Traction_mesh_pt

SolidMesh * Traction_mesh_pt

Pointer to mesh of traction elements.

Definition: SolidProblem.h:90

◆ traction_mesh_pt() [2/2]

template<class ELEMENT_TYPE >

SolidMesh* const& SolidProblem< ELEMENT_TYPE >::traction_mesh_pt ( ) const

inline

Get function for the traction mesh pointer.

302 { return Traction_mesh_pt; }

◆ writeToVTK()

template<class ELEMENT_TYPE >

void SolidProblem< ELEMENT_TYPE >::writeToVTK ( )

inline

     {
 #ifdef OOMPH_HAS_MPI
         // When the problem hasn't been distributed, the whole mesh is stored on every processor.
         // Prevent writing the same file multiple times, so only write for the first processor.
         if (!Problem_has_been_distributed && OOMPH_MPI_PROCESSOR_ID != 0)
             return;
 #endif
  
         //set local coordinates list
         std::vector<std::vector<double>> sList0;
         // order of nodes
         std::vector<unsigned> nList;
         // vtkFormat for given shape
         // https://kitware.github.io/vtk-examples/site/VTKFileFormats/
         unsigned vtkFormat;
  
         // define differently for tetrahedral and hexahedral (quad) elements
         if (std::is_base_of<SolidTElement<3, 2>, ELEMENT>::value)
         {
             vtkFormat = 10; // TETRA
  
             sList0 = {
                 {1, 0, 0},
                 {0, 1, 0},
                 {0, 0, 1},
                 {0, 0, 0}
             };
  
             nList = {0, 1, 2, 3};
         }
         else if (std::is_base_of<SolidQElement<3, 2>, ELEMENT>::value)
         {
             vtkFormat = 12; // HEXAHEDRON
  
             sList0 = {
                 {-1, -1, -1},
                 {-1, -1, +1},
                 {-1, +1, +1},
                 {-1, +1, -1},
                 {+1, -1, -1},
                 {+1, -1, +1},
                 {+1, +1, +1},
                 {+1, +1, -1}
             };
             // order of nodes
             nList = {0, 4, 6, 2, 1, 5, 7, 3};
         } else {
             logger(ERROR,"Element type unknown");
         }
  
         // convert to Vector
         std::vector<Vector<double>> sList;
         for (auto s0 : sList0)
         {
             Vector<double> s(3);
             s[0] = s0[0];
             s[1] = s0[1];
             s[2] = s0[2];
             sList.push_back(s);
         }
  
         // number of cells
         unsigned nel = solid_mesh_pt()->nelement();
  
         // set up vtu Points
         struct Point
         {
             Vector<double> coordinate;
             struct Data
             {
                 std::string name;
                 std::vector<double> value;
             };
             std::vector<Data> data;
         };
         std::vector<Point> points;
         points.reserve(nel * sList.size());
  
         // set up vtu Cells
         struct Cell
         {
             std::vector<unsigned long> connectivity;
             unsigned long offset;
             unsigned type;
         };
         std::vector<Cell> cells;
         points.reserve(nel);
  
         //for all elements
         for (unsigned e = 0; e < nel; e++)
         {
             // Get pointer to element
             auto el_pt = dynamic_cast<ELEMENT*>(
                 solid_mesh_pt()->element_pt(e));
  
             std::vector<unsigned long> connectivity;
             unsigned ix = 0; // node index
             for (const auto& s : sList)
             {
                 // pointer to node info
                 auto n = nList[ix];
                 auto n_pt = dynamic_cast<SolidNode*>(el_pt->node_pt(n));
                 // Get Eulerian coordinates
                 Vector<double> x(3);
                 el_pt->interpolated_x(s, x);
                 // get velocity
                 Vector<double> dxdt(3);
                 el_pt->interpolated_dxdt(s, 1, dxdt);
                 // get displacement
                 Vector<double> xi(3);
                 el_pt->interpolated_xi(s, xi);
                 // getBodyForce
                 Vector<double> body_force(3);
                 auto bodyForceFct = el_pt->body_force_fct_pt();
                 if (bodyForceFct) bodyForceFct(time(), xi, body_force);
                 // get coupling residual (fails)
                 //std::vector<double> couplingResidual
                 //    {el_pt->get_nodal_coupling_residual(n, 0),
                 //     el_pt->get_nodal_coupling_residual(n, 1),
                 //     el_pt->get_nodal_coupling_residual(n, 2)};
                 // get stress/pressure
                 DenseMatrix<double> sigma(3,3);
                 el_pt->get_stress(s, sigma);
                 // first invariant
                 double pressure = (sigma(0,0)+sigma(1,1)+sigma(2,2))/3;
                 //https://en.wikipedia.org/wiki/Von_Mises_yield_criterion
                 double J2 = 0;
                 for (int i = 0; i < 3; ++i) {
                     for (int j = 0; j < 3; ++j) {
                         J2 += 0.5*sigma(i,j)*sigma(i,j);
                     }
                 }
                 //std::cout << " " << J2;
                 // get strain
                 DenseMatrix<double> strain(3,3);
                 el_pt->get_strain(s, strain);
                 // get velocity (fails)
                 std::vector<double> dudt
                     {el_pt->dnodal_position_dt(n, 0),
                      el_pt->dnodal_position_dt(n, 1),
                      el_pt->dnodal_position_dt(n, 2)};
                 // get boundary (works)
                 std::set<unsigned>* boundaries_pt;
                 n_pt->get_boundaries_pt(boundaries_pt);
                 double b = boundaries_pt ? *boundaries_pt->begin()+1 : 0;
                 std::vector<double> pin {(double) n_pt->position_is_pinned(0),
                                          (double) n_pt->position_is_pinned(1),
                                          (double) n_pt->position_is_pinned(2)};
                 points.push_back(
                     {x, {
                         {"Velocity", {dxdt[0], dxdt[1], dxdt[2]}},
                         {"Displacement", {x[0] - xi[0], x[1] - xi[1], x[2] - xi[2]}},
                         {"BodyForce", {body_force[0], body_force[1], body_force[2]}},
                         {"Pin", pin},
                         //{"CouplingResidual", couplingResidual},
                         {"Velocity2", dudt},
                         {"Pressure", {pressure}},
                         {"J2", {J2}},
                         {"Stress", {sigma(0,0), sigma(0,1), sigma(0,2),
                                     sigma(1,0), sigma(1,1), sigma(1,2),
                                     sigma(2,0), sigma(2,1), sigma(2,2)}},
 //                             {"Strain", {strain(0,0), strain(0,1), strain(0,2),
 //                                           strain(1,0), strain(1,1), strain(1,2),
 //                                           strain(2,0), strain(2,1), strain(2,2)}},
                         //\todo undo this comment, but it causes a problem in the output
                         {"Boundary", {b}}
                     }});
  
                 // add to connectivity
                 connectivity.push_back(points.size() - 1);
                 ix++;
             }
             cells.push_back({connectivity, points.size(), vtkFormat});
         }
  
         //open vtk file
         static unsigned count = 0;
 #ifdef OOMPH_HAS_MPI
         std::string vtkFileName = name_ + "FEM_" + std::to_string(OOMPH_MPI_PROCESSOR_ID) + "_" + std::to_string(count++) + ".vtu";
 #else
         std::string vtkFileName = name_ + "FEM_" + std::to_string(count++) + ".vtu";
 #endif
  
         std::ofstream vtk(vtkFileName);
  
         //write vtk file
         vtk << "<?xml version=\"1.0\"?>\n"
                "<!-- time 10.548-->\n"
                "<VTKFile type=\"UnstructuredGrid\" version=\"0.1\" byte_order=\"LittleEndian\">\n"
                "<UnstructuredGrid>\n"
                "<Piece NumberOfPoints=\""
             << points.size()
             << "\" NumberOfCells=\""
             << cells.size()
             << "\">\n"
                "\n"
                "<Points>\n"
                "<DataArray type=\"Float32\" Name=\"Position\" NumberOfComponents=\"3\" format=\"ascii\">\n";
         for (auto point : points)
         {
             vtk << point.coordinate[0] << " " << point.coordinate[1] << " " << point.coordinate[2] << "\n";
         }
         vtk << "</DataArray>\n"
                "</Points>\n\n";
         if (not points.empty())
         {
             vtk << "<PointData  Vectors=\"vector\">\n";
             for (int i = 0; i < points.front().data.size(); ++i)
             {
                 auto data = points.front().data[i];
                 vtk << R"(<DataArray type="Float32" Name=")"
                     << points.front().data[i].name
                     << R"(" NumberOfComponents=")"
                     << points.front().data[i].value.size()
                     << R"(" format="ascii">)" << "\n";
                 for (const Point& point : points)
                 {
                     for (const auto& value : point.data[i].value)
                     {
                         //ensure values are not too small (VTK issue)
                         vtk << ((!isfinite(value) or fabs(value)<1e-33 or fabs(value)>1e33)?0.0:value) << " ";
                     }
                 }
                 vtk << "\n"
                        "</DataArray>\n";
             }
             vtk << "</PointData>\n"
                    "\n";
         }
         vtk << "<Cells>\n"
                "<DataArray type=\"Int32\" Name=\"connectivity\" format=\"ascii\">\n";
         for (const Cell& cell : cells)
         {
             for (auto point : cell.connectivity)
             {
                 vtk << point << " ";
             }
         }
         vtk << "</DataArray>\n"
                "<DataArray type=\"Int32\" Name=\"offsets\" format=\"ascii\">\n";
         for (const Cell& cell : cells)
         {
             vtk << cell.offset << " ";
         }
         vtk << "</DataArray>\n"
                "<DataArray type=\"UInt8\"  Name=\"types\" format=\"ascii\">\n";
         for (const Cell& cell : cells)
         {
             vtk << cell.type << " ";
         }
         vtk << "\n"
                "</DataArray>\n"
                "</Cells>\n"
                "\n"
                "</Piece>\n"
                "</UnstructuredGrid>\n"
                "</VTKFile>\n";
         vtk.close();
         logger(INFO, "Written %", vtkFileName);
     }

References b, Global_Parameters::body_force(), data, e(), ERROR, boost::multiprecision::fabs(), i, INFO, isfinite, j, logger, n, plotDoE::name, OOMPH_MPI_PROCESSOR_ID, s, calibrate::sigma, oomph::Global_string_for_annotation::string(), oomph::StringConversion::to_string(), compute_granudrum_aor::type, Eigen::value, and plotDoE::x.

Member Data Documentation

◆ body_force_fct

template<class ELEMENT_TYPE >

void(* SolidProblem< ELEMENT_TYPE >::body_force_fct) (const double &time, const Vector< double > &xi, Vector< double > &b) = nullptr

protected

Pointer to the body force function.

◆ constitutive_law_pt

template<class ELEMENT_TYPE >

ConstitutiveLaw* SolidProblem< ELEMENT_TYPE >::constitutive_law_pt = nullptr

protected

Pointer to constitutive law (should be set in constructor)

◆ density_

template<class ELEMENT_TYPE >

double SolidProblem< ELEMENT_TYPE >::density_ = 0

protected

Density.

◆ elasticModulus_

template<class ELEMENT_TYPE >

double SolidProblem< ELEMENT_TYPE >::elasticModulus_ = 0

protected

Elastic modulus (set via setSolid)

◆ gravity_

template<class ELEMENT_TYPE >

double SolidProblem< ELEMENT_TYPE >::gravity_ = 0

protected

Density.

◆ isPinned_

template<class ELEMENT_TYPE >

std::function<bool(SolidNode*, unsigned)> SolidProblem< ELEMENT_TYPE >::isPinned_

protected

Function to determine which nodal positions are pinned.

◆ name_

template<class ELEMENT_TYPE >

std::string SolidProblem< ELEMENT_TYPE >::name_

protected

◆ poissonRatio_

template<class ELEMENT_TYPE >

double SolidProblem< ELEMENT_TYPE >::poissonRatio_ = 0

protected

Poisson's ratio (set via setSolid)

◆ Solid_mesh_pt

template<class ELEMENT_TYPE >

SolidMesh* SolidProblem< ELEMENT_TYPE >::Solid_mesh_pt = nullptr

protected

Pointer to solid mesh.

◆ Traction_mesh_pt

template<class ELEMENT_TYPE >

SolidMesh* SolidProblem< ELEMENT_TYPE >::Traction_mesh_pt = nullptr

protected

Pointer to mesh of traction elements.

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

SolidProblem.h

Public Types

Public Member Functions

Protected Types

Protected Attributes

Additional Inherited Members

Detailed Description

template<class ELEMENT_TYPE> class SolidProblem< ELEMENT_TYPE >

Member Typedef Documentation

◆ ELEMENT

Member Enumeration Documentation

◆ Boundary

Constructor & Destructor Documentation

◆ SolidProblem()

Member Function Documentation

◆ actionsAfterSolve()

◆ actionsBeforeOomphTimeStep()

◆ actionsBeforeSolve()

◆ addAnisotropy()

◆ addDissipation()

◆ countPinned()

◆ get_x()

◆ getDeflection()

◆ getDensity()

◆ getDomainSize()

◆ getElasticModulus()

◆ getMassMomentumEnergy()

◆ getName()

◆ getOomphGravity()

◆ getOomphTime()

◆ getOomphTimeStep()

◆ getPoissonRatio()

◆ loadSolidMesh()

◆ pinBoundaries()

◆ pinBoundary()

◆ prepareForSolve()

◆ removeOldFiles()

◆ saveSolidMesh()

◆ setBodyForceAsGravity()

◆ setDensity()

◆ setDissipation()

◆ setElasticModulus()

◆ setIsPinned()

◆ setMaxNewtonIterations()

◆ setName()

◆ setNewtonSolverTolerance()

◆ setOomphGravity()

◆ setOomphTimeStep()

◆ setPoissonRatio()

◆ setSolidCubicMesh()

◆ setupRefinementParameters()

◆ solid_mesh_pt() [1/2]

◆ solid_mesh_pt() [2/2]

◆ solveSteady()

◆ solveUnsteady()

◆ solveUnsteadyForgiving()

◆ traction_mesh_pt() [1/2]

◆ traction_mesh_pt() [2/2]

◆ writeToVTK()

Member Data Documentation

◆ body_force_fct

◆ constitutive_law_pt

◆ density_

◆ elasticModulus_

◆ gravity_

◆ isPinned_

◆ name_

◆ poissonRatio_

◆ Solid_mesh_pt

◆ Traction_mesh_pt

template<class ELEMENT_TYPE>
class SolidProblem< ELEMENT_TYPE >