#include <elements.h>

Inheritance diagram for oomph::SolidFiniteElement:

Public Types
typedef double(*	MultiplierFctPt) (const Vector< double > &xi)

Public Types inherited from oomph::FiniteElement
typedef void(*	SteadyExactSolutionFctPt) (const Vector< double > &, Vector< double > &)

typedef void(*	UnsteadyExactSolutionFctPt) (const double &, const Vector< double > &, Vector< double > &)

Public Member Functions
void	set_lagrangian_dimension (const unsigned &lagrangian_dimension)

virtual bool	has_internal_solid_data ()

	SolidFiniteElement ()
	Constructor: Set defaults. More...

virtual	~SolidFiniteElement ()
	Destructor to clean up any allocated memory. More...

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

unsigned	ngeom_data () const
	Broken assignment operator. More...

Data *	geom_data_pt (const unsigned &j)

void	identify_geometric_data (std::set< Data * > &geometric_data_pt)

double	zeta_nodal (const unsigned &n, const unsigned &k, const unsigned &i) const

virtual void	get_x_and_xi (const Vector< double > &s, Vector< double > &x_fe, Vector< double > &x, Vector< double > &xi_fe, Vector< double > &xi) const

virtual void	set_macro_elem_pt (MacroElement *macro_elem_pt)

virtual void	set_macro_elem_pt (MacroElement macro_elem_pt, MacroElement undeformed_macro_elem_pt)

void	set_undeformed_macro_elem_pt (MacroElement *undeformed_macro_elem_pt)

MacroElement *	undeformed_macro_elem_pt ()
	Access function to pointer to "undeformed" macro element. More...

double	dshape_lagrangian (const Vector< double > &s, Shape &psi, DShape &dpsidxi) const

virtual double	dshape_lagrangian_at_knot (const unsigned &ipt, Shape &psi, DShape &dpsidxi) const

double	d2shape_lagrangian (const Vector< double > &s, Shape &psi, DShape &dpsidxi, DShape &d2psidxi) const

virtual double	d2shape_lagrangian_at_knot (const unsigned &ipt, Shape &psi, DShape &dpsidxi, DShape &d2psidxi) const

unsigned	lagrangian_dimension () const

unsigned	nnodal_lagrangian_type () const

Node *	construct_node (const unsigned &n)
	Construct the local node n and return a pointer to it. More...

Node *	construct_node (const unsigned &n, TimeStepper *const &time_stepper_pt)

Node *	construct_boundary_node (const unsigned &n)

Node *	construct_boundary_node (const unsigned &n, TimeStepper *const &time_stepper_pt)

virtual void	assign_all_generic_local_eqn_numbers (const bool &store_local_dof_pt)

void	describe_local_dofs (std::ostream &out, const std::string &current_string) const

double	raw_lagrangian_position (const unsigned &n, const unsigned &i) const

double	raw_lagrangian_position_gen (const unsigned &n, const unsigned &k, const unsigned &i) const

double	lagrangian_position (const unsigned &n, const unsigned &i) const
	Return i-th Lagrangian coordinate at local node n. More...

double	lagrangian_position_gen (const unsigned &n, const unsigned &k, const unsigned &i) const

virtual double	interpolated_xi (const Vector< double > &s, const unsigned &i) const

virtual void	interpolated_xi (const Vector< double > &s, Vector< double > &xi) const

virtual void	interpolated_dxids (const Vector< double > &s, DenseMatrix< double > &dxids) const

virtual void	J_lagrangian (const Vector< double > &s) const

virtual double	J_lagrangian_at_knot (const unsigned &ipt) const

SolidInitialCondition *&	solid_ic_pt ()
	Pointer to object that describes the initial condition. More...

void	enable_solve_for_consistent_newmark_accel ()

void	disable_solve_for_consistent_newmark_accel ()
	Set to reset the problem being solved to be the standard problem. More...

MultiplierFctPt &	multiplier_fct_pt ()

MultiplierFctPt	multiplier_fct_pt () const

virtual void	get_residuals_for_solid_ic (Vector< double > &residuals)

void	fill_in_residuals_for_solid_ic (Vector< double > &residuals)

void	fill_in_jacobian_for_solid_ic (Vector< double > &residuals, DenseMatrix< double > &jacobian)

void	fill_in_jacobian_for_newmark_accel (DenseMatrix< double > &jacobian)

void	compute_norm (double &el_norm)

int	position_local_eqn (const unsigned &n, const unsigned &k, const unsigned &j) const

Public Member Functions inherited from oomph::FiniteElement
void	set_dimension (const unsigned &dim)

void	set_nodal_dimension (const unsigned &nodal_dim)

void	set_nnodal_position_type (const unsigned &nposition_type)
	Set the number of types required to interpolate the coordinate. More...

void	set_n_node (const unsigned &n)

int	nodal_local_eqn (const unsigned &n, const unsigned &i) const

double	dJ_eulerian_at_knot (const unsigned &ipt, Shape &psi, DenseMatrix< double > &djacobian_dX) const

	FiniteElement ()
	Constructor. More...

virtual	~FiniteElement ()

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

virtual bool	local_coord_is_valid (const Vector< double > &s)
	Broken assignment operator. More...

virtual void	move_local_coord_back_into_element (Vector< double > &s) const

void	get_centre_of_gravity_and_max_radius_in_terms_of_zeta (Vector< double > &cog, double &max_radius) const

virtual void	local_coordinate_of_node (const unsigned &j, Vector< double > &s) const

virtual void	local_fraction_of_node (const unsigned &j, Vector< double > &s_fraction)

virtual double	local_one_d_fraction_of_node (const unsigned &n1d, const unsigned &i)

MacroElement *	macro_elem_pt ()
	Access function to pointer to macro element. More...

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

void	get_x (const unsigned &t, const Vector< double > &s, Vector< double > &x)

virtual void	get_x_from_macro_element (const Vector< double > &s, Vector< double > &x) const

virtual void	get_x_from_macro_element (const unsigned &t, const Vector< double > &s, Vector< double > &x)

virtual void	set_integration_scheme (Integral *const &integral_pt)
	Set the spatial integration scheme. More...

Integral *const &	integral_pt () const
	Return the pointer to the integration scheme (const version) More...

virtual void	shape (const Vector< double > &s, Shape &psi) const =0

virtual void	shape_at_knot (const unsigned &ipt, Shape &psi) const

virtual void	dshape_local (const Vector< double > &s, Shape &psi, DShape &dpsids) const

virtual void	dshape_local_at_knot (const unsigned &ipt, Shape &psi, DShape &dpsids) const

virtual void	d2shape_local (const Vector< double > &s, Shape &psi, DShape &dpsids, DShape &d2psids) const

virtual void	d2shape_local_at_knot (const unsigned &ipt, Shape &psi, DShape &dpsids, DShape &d2psids) const

virtual double	J_eulerian (const Vector< double > &s) const

virtual double	J_eulerian_at_knot (const unsigned &ipt) const

void	check_J_eulerian_at_knots (bool &passed) const

void	check_jacobian (const double &jacobian) const

double	dshape_eulerian (const Vector< double > &s, Shape &psi, DShape &dpsidx) const

virtual double	dshape_eulerian_at_knot (const unsigned &ipt, Shape &psi, DShape &dpsidx) const

virtual double	dshape_eulerian_at_knot (const unsigned &ipt, Shape &psi, DShape &dpsi, DenseMatrix< double > &djacobian_dX, RankFourTensor< double > &d_dpsidx_dX) const

double	d2shape_eulerian (const Vector< double > &s, Shape &psi, DShape &dpsidx, DShape &d2psidx) const

virtual double	d2shape_eulerian_at_knot (const unsigned &ipt, Shape &psi, DShape &dpsidx, DShape &d2psidx) const

virtual void	assign_nodal_local_eqn_numbers (const bool &store_local_dof_pt)

virtual void	describe_nodal_local_dofs (std::ostream &out, const std::string &current_string) const

Node *&	node_pt (const unsigned &n)
	Return a pointer to the local node n. More...

Node *const &	node_pt (const unsigned &n) const
	Return a pointer to the local node n (const version) More...

unsigned	nnode () const
	Return the number of nodes. More...

virtual unsigned	nnode_1d () const

double	raw_nodal_position (const unsigned &n, const unsigned &i) const

double	raw_nodal_position (const unsigned &t, const unsigned &n, const unsigned &i) const

double	raw_dnodal_position_dt (const unsigned &n, const unsigned &i) const

double	raw_dnodal_position_dt (const unsigned &n, const unsigned &j, const unsigned &i) const

double	raw_nodal_position_gen (const unsigned &n, const unsigned &k, const unsigned &i) const

double	raw_nodal_position_gen (const unsigned &t, const unsigned &n, const unsigned &k, const unsigned &i) const

double	raw_dnodal_position_gen_dt (const unsigned &n, const unsigned &k, const unsigned &i) const

double	raw_dnodal_position_gen_dt (const unsigned &j, const unsigned &n, const unsigned &k, const unsigned &i) const

double	nodal_position (const unsigned &n, const unsigned &i) const

double	nodal_position (const unsigned &t, const unsigned &n, const unsigned &i) const

double	dnodal_position_dt (const unsigned &n, const unsigned &i) const
	Return the i-th component of nodal velocity: dx/dt at local node n. More...

double	dnodal_position_dt (const unsigned &n, const unsigned &j, const unsigned &i) const

double	nodal_position_gen (const unsigned &n, const unsigned &k, const unsigned &i) const

double	nodal_position_gen (const unsigned &t, const unsigned &n, const unsigned &k, const unsigned &i) const

double	dnodal_position_gen_dt (const unsigned &n, const unsigned &k, const unsigned &i) const

double	dnodal_position_gen_dt (const unsigned &j, const unsigned &n, const unsigned &k, const unsigned &i) const

virtual void	get_dresidual_dnodal_coordinates (RankThreeTensor< double > &dresidual_dnodal_coordinates)

virtual void	disable_ALE ()

virtual void	enable_ALE ()

virtual unsigned	required_nvalue (const unsigned &n) const

unsigned	nnodal_position_type () const

bool	has_hanging_nodes () const

unsigned	nodal_dimension () const
	Return the required Eulerian dimension of the nodes in this element. More...

virtual unsigned	nvertex_node () const

virtual Node *	vertex_node_pt (const unsigned &j) const

int	get_node_number (Node *const &node_pt) const

virtual Node *	get_node_at_local_coordinate (const Vector< double > &s) const

double	raw_nodal_value (const unsigned &n, const unsigned &i) const

double	raw_nodal_value (const unsigned &t, const unsigned &n, const unsigned &i) const

double	nodal_value (const unsigned &n, const unsigned &i) const

double	nodal_value (const unsigned &t, const unsigned &n, const unsigned &i) const

unsigned	dim () const

virtual ElementGeometry::ElementGeometry	element_geometry () const
	Return the geometry type of the element (either Q or T usually). More...

virtual double	interpolated_x (const Vector< double > &s, const unsigned &i) const
	Return FE interpolated coordinate x[i] at local coordinate s. More...

virtual double	interpolated_x (const unsigned &t, const Vector< double > &s, const unsigned &i) const

virtual void	interpolated_x (const Vector< double > &s, Vector< double > &x) const
	Return FE interpolated position x[] at local coordinate s as Vector. More...

virtual void	interpolated_x (const unsigned &t, const Vector< double > &s, Vector< double > &x) const

virtual double	interpolated_dxdt (const Vector< double > &s, const unsigned &i, const unsigned &t)

virtual void	interpolated_dxdt (const Vector< double > &s, const unsigned &t, Vector< double > &dxdt)

void	position (const Vector< double > &zeta, Vector< double > &r) const

void	position (const unsigned &t, const Vector< double > &zeta, Vector< double > &r) const

void	dposition_dt (const Vector< double > &zeta, const unsigned &t, Vector< double > &drdt)

void	interpolated_zeta (const Vector< double > &s, Vector< double > &zeta) const

void	locate_zeta (const Vector< double > &zeta, GeomObject *&geom_object_pt, Vector< double > &s, const bool &use_coordinate_as_initial_guess=false)

virtual void	node_update ()

virtual void	identify_field_data_for_interactions (std::set< std::pair< Data *, unsigned >> &paired_field_data)

virtual double	s_min () const
	Min value of local coordinate. More...

virtual double	s_max () const
	Max. value of local coordinate. More...

double	size () const

virtual double	compute_physical_size () const

virtual void	point_output_data (const Vector< double > &s, Vector< double > &data)

void	point_output (std::ostream &outfile, const Vector< double > &s)

virtual unsigned	nplot_points_paraview (const unsigned &nplot) const

virtual unsigned	nsub_elements_paraview (const unsigned &nplot) const

void	output_paraview (std::ofstream &file_out, const unsigned &nplot) const

virtual void	write_paraview_output_offset_information (std::ofstream &file_out, const unsigned &nplot, unsigned &counter) const

virtual void	write_paraview_type (std::ofstream &file_out, const unsigned &nplot) const

virtual void	write_paraview_offsets (std::ofstream &file_out, const unsigned &nplot, unsigned &offset_sum) const

virtual unsigned	nscalar_paraview () const

virtual void	scalar_value_paraview (std::ofstream &file_out, const unsigned &i, const unsigned &nplot) const

virtual void	scalar_value_fct_paraview (std::ofstream &file_out, const unsigned &i, const unsigned &nplot, FiniteElement::SteadyExactSolutionFctPt exact_soln_pt) const

virtual void	scalar_value_fct_paraview (std::ofstream &file_out, const unsigned &i, const unsigned &nplot, const double &time, FiniteElement::UnsteadyExactSolutionFctPt exact_soln_pt) const

virtual std::string	scalar_name_paraview (const unsigned &i) const

virtual void	output (std::ostream &outfile)

virtual void	output (std::ostream &outfile, const unsigned &n_plot)

virtual void	output (const unsigned &t, std::ostream &outfile, const unsigned &n_plot) const

virtual void	output (FILE *file_pt)

virtual void	output (FILE *file_pt, const unsigned &n_plot)

virtual void	output_fct (std::ostream &outfile, const unsigned &n_plot, FiniteElement::SteadyExactSolutionFctPt exact_soln_pt)
	Output an exact solution over the element. More...

virtual void	output_fct (std::ostream &outfile, const unsigned &n_plot, const double &time, FiniteElement::UnsteadyExactSolutionFctPt exact_soln_pt)
	Output a time-dependent exact solution over the element. More...

virtual void	output_fct (std::ostream &outfile, const unsigned &n_plot, const double &time, const SolutionFunctorBase &exact_soln) const
	Output a time-dependent exact solution over the element. More...

virtual void	get_s_plot (const unsigned &i, const unsigned &nplot, Vector< double > &s, const bool &shifted_to_interior=false) const

virtual std::string	tecplot_zone_string (const unsigned &nplot) const

virtual void	write_tecplot_zone_footer (std::ostream &outfile, const unsigned &nplot) const

virtual void	write_tecplot_zone_footer (FILE *file_pt, const unsigned &nplot) const

virtual unsigned	nplot_points (const unsigned &nplot) const

virtual void	compute_error (FiniteElement::SteadyExactSolutionFctPt exact_soln_pt, double &error, double &norm)
	Calculate the norm of the error and that of the exact solution. More...

virtual void	compute_error (FiniteElement::UnsteadyExactSolutionFctPt exact_soln_pt, const double &time, double &error, double &norm)
	Calculate the norm of the error and that of the exact solution. More...

virtual void	compute_error (FiniteElement::SteadyExactSolutionFctPt exact_soln_pt, Vector< double > &error, Vector< double > &norm)

virtual void	compute_error (FiniteElement::UnsteadyExactSolutionFctPt exact_soln_pt, const double &time, Vector< double > &error, Vector< double > &norm)

virtual void	compute_error (std::ostream &outfile, FiniteElement::SteadyExactSolutionFctPt exact_soln_pt, double &error, double &norm)

virtual void	compute_error (std::ostream &outfile, FiniteElement::UnsteadyExactSolutionFctPt exact_soln_pt, const double &time, double &error, double &norm)

virtual void	compute_error (std::ostream &outfile, FiniteElement::SteadyExactSolutionFctPt exact_soln_pt, Vector< double > &error, Vector< double > &norm)

virtual void	compute_error (std::ostream &outfile, FiniteElement::UnsteadyExactSolutionFctPt exact_soln_pt, const double &time, Vector< double > &error, Vector< double > &norm)

virtual void	compute_abs_error (std::ostream &outfile, FiniteElement::SteadyExactSolutionFctPt exact_soln_pt, double &error)

void	integrate_fct (FiniteElement::SteadyExactSolutionFctPt integrand_fct_pt, Vector< double > &integral)
	Integrate Vector-valued function over element. More...

void	integrate_fct (FiniteElement::UnsteadyExactSolutionFctPt integrand_fct_pt, const double &time, Vector< double > &integral)
	Integrate Vector-valued time-dep function over element. More...

virtual void	build_face_element (const int &face_index, FaceElement *face_element_pt)

virtual unsigned	self_test ()

virtual unsigned	get_bulk_node_number (const int &face_index, const unsigned &i) const

virtual int	face_outer_unit_normal_sign (const int &face_index) const
	Get the sign of the outer unit normal on the face given by face_index. More...

virtual unsigned	nnode_on_face () const

void	face_node_number_error_check (const unsigned &i) const
	Range check for face node numbers. More...

virtual CoordinateMappingFctPt	face_to_bulk_coordinate_fct_pt (const int &face_index) const

virtual BulkCoordinateDerivativesFctPt	bulk_coordinate_derivatives_fct_pt (const int &face_index) const

Public Member Functions inherited from oomph::GeneralisedElement
	GeneralisedElement ()
	Constructor: Initialise all pointers and all values to zero. More...

virtual	~GeneralisedElement ()
	Virtual destructor to clean up any memory allocated by the object. More...

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

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

Data *&	internal_data_pt (const unsigned &i)
	Return a pointer to i-th internal data object. More...

Data *const &	internal_data_pt (const unsigned &i) const
	Return a pointer to i-th internal data object (const version) More...

Data *&	external_data_pt (const unsigned &i)
	Return a pointer to i-th external data object. More...

Data *const &	external_data_pt (const unsigned &i) const
	Return a pointer to i-th external data object (const version) More...

unsigned long	eqn_number (const unsigned &ieqn_local) const

int	local_eqn_number (const unsigned long &ieqn_global) const

unsigned	add_external_data (Data *const &data_pt, const bool &fd=true)

bool	external_data_fd (const unsigned &i) const

void	exclude_external_data_fd (const unsigned &i)

void	include_external_data_fd (const unsigned &i)

void	flush_external_data ()
	Flush all external data. More...

void	flush_external_data (Data *const &data_pt)
	Flush the object addressed by data_pt from the external data array. More...

unsigned	ninternal_data () const
	Return the number of internal data objects. More...

unsigned	nexternal_data () const
	Return the number of external data objects. More...

unsigned	ndof () const
	Return the number of equations/dofs in the element. More...

void	dof_vector (const unsigned &t, Vector< double > &dof)
	Return the vector of dof values at time level t. More...

void	dof_pt_vector (Vector< double * > &dof_pt)
	Return the vector of pointers to dof values. More...

void	set_internal_data_time_stepper (const unsigned &i, TimeStepper *const &time_stepper_pt, const bool &preserve_existing_data)

void	assign_internal_eqn_numbers (unsigned long &global_number, Vector< double * > &Dof_pt)

void	describe_dofs (std::ostream &out, const std::string &current_string) const

void	add_internal_value_pt_to_map (std::map< unsigned, double * > &map_of_value_pt)

virtual void	assign_local_eqn_numbers (const bool &store_local_dof_pt)

virtual void	complete_setup_of_dependencies ()

virtual void	get_residuals (Vector< double > &residuals)

virtual void	get_jacobian (Vector< double > &residuals, DenseMatrix< double > &jacobian)

virtual void	get_mass_matrix (Vector< double > &residuals, DenseMatrix< double > &mass_matrix)

virtual void	get_jacobian_and_mass_matrix (Vector< double > &residuals, DenseMatrix< double > &jacobian, DenseMatrix< double > &mass_matrix)

virtual void	get_dresiduals_dparameter (double *const &parameter_pt, Vector< double > &dres_dparam)

virtual void	get_djacobian_dparameter (double *const &parameter_pt, Vector< double > &dres_dparam, DenseMatrix< double > &djac_dparam)

virtual void	get_djacobian_and_dmass_matrix_dparameter (double *const &parameter_pt, Vector< double > &dres_dparam, DenseMatrix< double > &djac_dparam, DenseMatrix< double > &dmass_matrix_dparam)

virtual void	get_hessian_vector_products (Vector< double > const &Y, DenseMatrix< double > const &C, DenseMatrix< double > &product)

virtual void	get_inner_products (Vector< std::pair< unsigned, unsigned >> const &history_index, Vector< double > &inner_product)

virtual void	get_inner_product_vectors (Vector< unsigned > const &history_index, Vector< Vector< double >> &inner_product_vector)

virtual void	compute_norm (Vector< double > &norm)

virtual unsigned	ndof_types () const

virtual void	get_dof_numbers_for_unknowns (std::list< std::pair< unsigned long, unsigned >> &dof_lookup_list) const

Public Member Functions inherited from oomph::GeomObject
	GeomObject ()
	Default constructor. More...

	GeomObject (const unsigned &ndim)

	GeomObject (const unsigned &nlagrangian, const unsigned &ndim)

	GeomObject (const unsigned &nlagrangian, const unsigned &ndim, TimeStepper *time_stepper_pt)

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

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

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

unsigned	nlagrangian () const
	Access function to # of Lagrangian coordinates. More...

unsigned	ndim () const
	Access function to # of Eulerian coordinates. More...

void	set_nlagrangian_and_ndim (const unsigned &n_lagrangian, const unsigned &n_dim)
	Set # of Lagrangian and Eulerian coordinates. More...

TimeStepper *&	time_stepper_pt ()

TimeStepper *	time_stepper_pt () const

virtual void	position (const double &t, const Vector< double > &zeta, Vector< double > &r) const

virtual void	dposition (const Vector< double > &zeta, DenseMatrix< double > &drdzeta) const

virtual void	d2position (const Vector< double > &zeta, RankThreeTensor< double > &ddrdzeta) const

virtual void	d2position (const Vector< double > &zeta, Vector< double > &r, DenseMatrix< double > &drdzeta, RankThreeTensor< double > &ddrdzeta) const

Protected Member Functions
void	fill_in_generic_jacobian_for_solid_ic (Vector< double > &residuals, DenseMatrix< double > &jacobian, const unsigned &flag)

void	set_nnodal_lagrangian_type (const unsigned &nlagrangian_type)

virtual double	local_to_lagrangian_mapping (const DShape &dpsids, DenseMatrix< double > &jacobian, DenseMatrix< double > &inverse_jacobian) const

double	local_to_lagrangian_mapping (const DShape &dpsids, DenseMatrix< double > &inverse_jacobian) const

virtual double	local_to_lagrangian_mapping_diagonal (const DShape &dpsids, DenseMatrix< double > &jacobian, DenseMatrix< double > &inverse_jacobian) const

virtual void	assign_solid_local_eqn_numbers (const bool &store_local_dof)
	Assign local equation numbers for the solid equations in the element. More...

void	describe_solid_local_dofs (std::ostream &out, const std::string &current_string) const
	Classifies dofs locally for solid specific aspects. More...

void	fill_in_contribution_to_jacobian (Vector< double > &residuals, DenseMatrix< double > &jacobian)

virtual void	fill_in_jacobian_from_solid_position_by_fd (Vector< double > &residuals, DenseMatrix< double > &jacobian)

void	fill_in_jacobian_from_solid_position_by_fd (DenseMatrix< double > &jacobian)

virtual void	update_before_solid_position_fd ()

virtual void	reset_after_solid_position_fd ()

virtual void	update_in_solid_position_fd (const unsigned &i)

virtual void	reset_in_solid_position_fd (const unsigned &i)

Protected Member Functions inherited from oomph::FiniteElement
virtual void	assemble_local_to_eulerian_jacobian (const DShape &dpsids, DenseMatrix< double > &jacobian) const

virtual void	assemble_local_to_eulerian_jacobian2 (const DShape &d2psids, DenseMatrix< double > &jacobian2) const

virtual void	assemble_eulerian_base_vectors (const DShape &dpsids, DenseMatrix< double > &interpolated_G) const

template<unsigned DIM>
double	invert_jacobian (const DenseMatrix< double > &jacobian, DenseMatrix< double > &inverse_jacobian) const

virtual double	invert_jacobian_mapping (const DenseMatrix< double > &jacobian, DenseMatrix< double > &inverse_jacobian) const

virtual double	local_to_eulerian_mapping (const DShape &dpsids, DenseMatrix< double > &jacobian, DenseMatrix< double > &inverse_jacobian) const

double	local_to_eulerian_mapping (const DShape &dpsids, DenseMatrix< double > &inverse_jacobian) const

virtual double	local_to_eulerian_mapping_diagonal (const DShape &dpsids, DenseMatrix< double > &jacobian, DenseMatrix< double > &inverse_jacobian) const

virtual void	dJ_eulerian_dnodal_coordinates (const DenseMatrix< double > &jacobian, const DShape &dpsids, DenseMatrix< double > &djacobian_dX) const

template<unsigned DIM>
void	dJ_eulerian_dnodal_coordinates_templated_helper (const DenseMatrix< double > &jacobian, const DShape &dpsids, DenseMatrix< double > &djacobian_dX) const

virtual void	d_dshape_eulerian_dnodal_coordinates (const double &det_jacobian, const DenseMatrix< double > &jacobian, const DenseMatrix< double > &djacobian_dX, const DenseMatrix< double > &inverse_jacobian, const DShape &dpsids, RankFourTensor< double > &d_dpsidx_dX) const

template<unsigned DIM>
void	d_dshape_eulerian_dnodal_coordinates_templated_helper (const double &det_jacobian, const DenseMatrix< double > &jacobian, const DenseMatrix< double > &djacobian_dX, const DenseMatrix< double > &inverse_jacobian, const DShape &dpsids, RankFourTensor< double > &d_dpsidx_dX) const

virtual void	transform_derivatives (const DenseMatrix< double > &inverse_jacobian, DShape &dbasis) const

void	transform_derivatives_diagonal (const DenseMatrix< double > &inverse_jacobian, DShape &dbasis) const

virtual void	transform_second_derivatives (const DenseMatrix< double > &jacobian, const DenseMatrix< double > &inverse_jacobian, const DenseMatrix< double > &jacobian2, DShape &dbasis, DShape &d2basis) const

template<unsigned DIM>
void	transform_second_derivatives_template (const DenseMatrix< double > &jacobian, const DenseMatrix< double > &inverse_jacobian, const DenseMatrix< double > &jacobian2, DShape &dbasis, DShape &d2basis) const

template<unsigned DIM>
void	transform_second_derivatives_diagonal (const DenseMatrix< double > &jacobian, const DenseMatrix< double > &inverse_jacobian, const DenseMatrix< double > &jacobian2, DShape &dbasis, DShape &d2basis) const

virtual void	fill_in_jacobian_from_nodal_by_fd (Vector< double > &residuals, DenseMatrix< double > &jacobian)

void	fill_in_jacobian_from_nodal_by_fd (DenseMatrix< double > &jacobian)

virtual void	update_before_nodal_fd ()

virtual void	reset_after_nodal_fd ()

virtual void	update_in_nodal_fd (const unsigned &i)

virtual void	reset_in_nodal_fd (const unsigned &i)

template<>
double	invert_jacobian (const DenseMatrix< double > &jacobian, DenseMatrix< double > &inverse_jacobian) const
	Zero-d specialisation of function to calculate inverse of jacobian mapping. More...

template<>
double	invert_jacobian (const DenseMatrix< double > &jacobian, DenseMatrix< double > &inverse_jacobian) const
	One-d specialisation of function to calculate inverse of jacobian mapping. More...

template<>
double	invert_jacobian (const DenseMatrix< double > &jacobian, DenseMatrix< double > &inverse_jacobian) const
	Two-d specialisation of function to calculate inverse of jacobian mapping. More...

template<>
double	invert_jacobian (const DenseMatrix< double > &jacobian, DenseMatrix< double > &inverse_jacobian) const

template<>
void	dJ_eulerian_dnodal_coordinates_templated_helper (const DenseMatrix< double > &jacobian, const DShape &dpsids, DenseMatrix< double > &djacobian_dX) const

template<>
void	dJ_eulerian_dnodal_coordinates_templated_helper (const DenseMatrix< double > &jacobian, const DShape &dpsids, DenseMatrix< double > &djacobian_dX) const

template<>
void	dJ_eulerian_dnodal_coordinates_templated_helper (const DenseMatrix< double > &jacobian, const DShape &dpsids, DenseMatrix< double > &djacobian_dX) const

template<>
void	dJ_eulerian_dnodal_coordinates_templated_helper (const DenseMatrix< double > &jacobian, const DShape &dpsids, DenseMatrix< double > &djacobian_dX) const

template<>
void	d_dshape_eulerian_dnodal_coordinates_templated_helper (const double &det_jacobian, const DenseMatrix< double > &jacobian, const DenseMatrix< double > &djacobian_dX, const DenseMatrix< double > &inverse_jacobian, const DShape &dpsids, RankFourTensor< double > &d_dpsidx_dX) const

template<>
void	d_dshape_eulerian_dnodal_coordinates_templated_helper (const double &det_jacobian, const DenseMatrix< double > &jacobian, const DenseMatrix< double > &djacobian_dX, const DenseMatrix< double > &inverse_jacobian, const DShape &dpsids, RankFourTensor< double > &d_dpsidx_dX) const

template<>
void	d_dshape_eulerian_dnodal_coordinates_templated_helper (const double &det_jacobian, const DenseMatrix< double > &jacobian, const DenseMatrix< double > &djacobian_dX, const DenseMatrix< double > &inverse_jacobian, const DShape &dpsids, RankFourTensor< double > &d_dpsidx_dX) const

template<>
void	d_dshape_eulerian_dnodal_coordinates_templated_helper (const double &det_jacobian, const DenseMatrix< double > &jacobian, const DenseMatrix< double > &djacobian_dX, const DenseMatrix< double > &inverse_jacobian, const DShape &dpsids, RankFourTensor< double > &d_dpsidx_dX) const

template<>
void	transform_second_derivatives_template (const DenseMatrix< double > &jacobian, const DenseMatrix< double > &inverse_jacobian, const DenseMatrix< double > &jacobian2, DShape &dbasis, DShape &d2basis) const

template<>
void	transform_second_derivatives_template (const DenseMatrix< double > &jacobian, const DenseMatrix< double > &inverse_jacobian, const DenseMatrix< double > &jacobian2, DShape &dbasis, DShape &d2basis) const

template<>
void	transform_second_derivatives_diagonal (const DenseMatrix< double > &jacobian, const DenseMatrix< double > &inverse_jacobian, const DenseMatrix< double > &jacobian2, DShape &dbasis, DShape &d2basis) const

template<>
void	transform_second_derivatives_diagonal (const DenseMatrix< double > &jacobian, const DenseMatrix< double > &inverse_jacobian, const DenseMatrix< double > &jacobian2, DShape &dbasis, DShape &d2basis) const

Protected Member Functions inherited from oomph::GeneralisedElement
unsigned	add_internal_data (Data *const &data_pt, const bool &fd=true)

bool	internal_data_fd (const unsigned &i) const

void	exclude_internal_data_fd (const unsigned &i)

void	include_internal_data_fd (const unsigned &i)

void	clear_global_eqn_numbers ()

void	add_global_eqn_numbers (std::deque< unsigned long > const &global_eqn_numbers, std::deque< double * > const &global_dof_pt)

virtual void	assign_internal_and_external_local_eqn_numbers (const bool &store_local_dof_pt)

virtual void	assign_additional_local_eqn_numbers ()

int	internal_local_eqn (const unsigned &i, const unsigned &j) const

int	external_local_eqn (const unsigned &i, const unsigned &j)

virtual void	fill_in_contribution_to_residuals (Vector< double > &residuals)

void	fill_in_jacobian_from_internal_by_fd (Vector< double > &residuals, DenseMatrix< double > &jacobian, const bool &fd_all_data=false)

void	fill_in_jacobian_from_internal_by_fd (DenseMatrix< double > &jacobian, const bool &fd_all_data=false)

void	fill_in_jacobian_from_external_by_fd (Vector< double > &residuals, DenseMatrix< double > &jacobian, const bool &fd_all_data=false)

void	fill_in_jacobian_from_external_by_fd (DenseMatrix< double > &jacobian, const bool &fd_all_data=false)

virtual void	update_before_internal_fd ()

virtual void	reset_after_internal_fd ()

virtual void	update_in_internal_fd (const unsigned &i)

virtual void	reset_in_internal_fd (const unsigned &i)

virtual void	update_before_external_fd ()

virtual void	reset_after_external_fd ()

virtual void	update_in_external_fd (const unsigned &i)

virtual void	reset_in_external_fd (const unsigned &i)

virtual void	fill_in_contribution_to_mass_matrix (Vector< double > &residuals, DenseMatrix< double > &mass_matrix)

virtual void	fill_in_contribution_to_jacobian_and_mass_matrix (Vector< double > &residuals, DenseMatrix< double > &jacobian, DenseMatrix< double > &mass_matrix)

virtual void	fill_in_contribution_to_dresiduals_dparameter (double *const &parameter_pt, Vector< double > &dres_dparam)

virtual void	fill_in_contribution_to_djacobian_dparameter (double *const &parameter_pt, Vector< double > &dres_dparam, DenseMatrix< double > &djac_dparam)

virtual void	fill_in_contribution_to_djacobian_and_dmass_matrix_dparameter (double *const &parameter_pt, Vector< double > &dres_dparam, DenseMatrix< double > &djac_dparam, DenseMatrix< double > &dmass_matrix_dparam)

virtual void	fill_in_contribution_to_hessian_vector_products (Vector< double > const &Y, DenseMatrix< double > const &C, DenseMatrix< double > &product)

virtual void	fill_in_contribution_to_inner_products (Vector< std::pair< unsigned, unsigned >> const &history_index, Vector< double > &inner_product)

virtual void	fill_in_contribution_to_inner_product_vectors (Vector< unsigned > const &history_index, Vector< Vector< double >> &inner_product_vector)

Protected Attributes
MacroElement *	Undeformed_macro_elem_pt
	Pointer to the element's "undeformed" macro element (NULL by default) More...

SolidInitialCondition *	Solid_ic_pt
	Pointer to object that specifies the initial condition. More...

bool	Solve_for_consistent_newmark_accel_flag

Protected Attributes inherited from oomph::FiniteElement
MacroElement *	Macro_elem_pt
	Pointer to the element's macro element (NULL by default) More...

Protected Attributes inherited from oomph::GeomObject
unsigned	NLagrangian
	Number of Lagrangian (intrinsic) coordinates. More...

unsigned	Ndim
	Number of Eulerian coordinates. More...

TimeStepper *	Geom_object_time_stepper_pt

Private Member Functions
virtual void	assemble_local_to_lagrangian_jacobian (const DShape &dpsids, DenseMatrix< double > &jacobian) const

virtual void	assemble_local_to_lagrangian_jacobian2 (const DShape &d2psids, DenseMatrix< double > &jacobian2) const

double	multiplier (const Vector< double > &xi)

Private Attributes
MultiplierFctPt	Multiplier_fct_pt

int *	Position_local_eqn

unsigned	Lagrangian_dimension

unsigned	Nnodal_lagrangian_type

Additional Inherited Members
Static Public Attributes inherited from oomph::FiniteElement
static double	Tolerance_for_singular_jacobian = 1.0e-16
	Tolerance below which the jacobian is considered singular. More...

static bool	Accept_negative_jacobian = false

static bool	Suppress_output_while_checking_for_inverted_elements

Static Public Attributes inherited from oomph::GeneralisedElement
static bool	Suppress_warning_about_repeated_internal_data

static bool	Suppress_warning_about_repeated_external_data = true

static double	Default_fd_jacobian_step = 1.0e-8

Static Protected Attributes inherited from oomph::FiniteElement
static const unsigned	Default_Initial_Nvalue = 0
	Default value for the number of values at a node. More...

static const double	Node_location_tolerance = 1.0e-14

static const unsigned	N2deriv [] = {0, 1, 3, 6}

Static Protected Attributes inherited from oomph::GeneralisedElement
static DenseMatrix< double >	Dummy_matrix

static std::deque< double * >	Dof_pt_deque

Detailed Description

////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// SolidFiniteElement class.

Solid elements are elements whose nodal positions are unknowns in the problem – their nodes are SolidNodes. In such elements, the nodes not only have a variable (Eulerian) but also a fixed (Lagrangian) position. The positional variables have their own local equation numbering scheme which is set up with

assign_solid_local_eqn_numbers ()

oomph::SolidFiniteElement::assign_solid_local_eqn_numbers

virtual void assign_solid_local_eqn_numbers(const bool &store_local_dof)

Assign local equation numbers for the solid equations in the element.

Definition: elements.cc:6898

The derivatives of the ‘solid equations’ (i.e. the equations that determine the nodal positions) with respect to the nodal positions, required in the Jacobian matrix, are determined by finite differencing.

In the present form, the SolidFiniteElement represents a fully functional base class for ‘proper’ solid mechanics elements, but it can also be combined (via inheritance) with elements that solve additional equations. This is particularly useful in cases where the solid equations are merely used to update the nodal positions in a moving mesh problem, although this can prove costly in practice.

Member Typedef Documentation

◆ MultiplierFctPt

typedef double(* oomph::SolidFiniteElement::MultiplierFctPt) (const Vector< double > &xi)

Pointer to function that computes the "multiplier" for the inertia terms in the consistent determination of the initial conditions for Newmark timestepping.

Constructor & Destructor Documentation

◆ SolidFiniteElement() [1/2]

oomph::SolidFiniteElement::SolidFiniteElement ( )

inline

Constructor: Set defaults.

       : FiniteElement(),
         Undeformed_macro_elem_pt(0),
         Solid_ic_pt(0),
         Multiplier_fct_pt(0),
         Position_local_eqn(0),
         Lagrangian_dimension(0),
         Nnodal_lagrangian_type(1),
         Solve_for_consistent_newmark_accel_flag(false)
     {
     }

◆ ~SolidFiniteElement()

oomph::SolidFiniteElement::~SolidFiniteElement ( )

virtual

Destructor to clean up any allocated memory.

Destructor for SolidFiniteElement:

   {
     // Delete the storage allocated for the positional local equations
     delete[] Position_local_eqn;
   }

References Position_local_eqn.

◆ SolidFiniteElement() [2/2]

oomph::SolidFiniteElement::SolidFiniteElement ( const SolidFiniteElement & )

delete

Broken copy constructor.

Member Function Documentation

◆ assemble_local_to_lagrangian_jacobian()

void oomph::SolidFiniteElement::assemble_local_to_lagrangian_jacobian	(	const DShape &	dpsids,
		DenseMatrix< double > &	jacobian
	)		const

privatevirtual

Assemble the jacobian matrix for the mapping from local to lagrangian coordinates, given the derivatives of the shape function

Internal function that is used to assemble the jacobian of the mapping from local coordinates (s) to the lagrangian coordinates (xi), given the derivatives of the shape functions.

Reimplemented in oomph::RefineableSolidElement.

   {
     // Find the the dimension of the element
     const unsigned el_dim = dim();
     // Find the number of shape functions and shape functions types
     // We shall ASSUME (ENFORCE) that Lagrangian coordinates must
     // be interpolated through the nodes
     const unsigned n_shape = nnode();
     const unsigned n_shape_type = nnodal_lagrangian_type();
  
 #ifdef PARANOID
     // Check for dimensional compatibility
     if (el_dim != Lagrangian_dimension)
     {
       std::ostringstream error_message;
       error_message << "Dimension mismatch" << std::endl;
       error_message << "The elemental dimension: " << el_dim
                     << " must equal the nodal Lagrangian dimension: "
                     << Lagrangian_dimension
                     << " for the jacobian of the mapping to be well-defined"
                     << std::endl;
       throw OomphLibError(
         error_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
 #endif
  
     // Loop over the rows of the jacobian
     for (unsigned i = 0; i < el_dim; i++)
     {
       // Loop over the columns of the jacobian
       for (unsigned j = 0; j < el_dim; j++)
       {
         // Zero the entry
         jacobian(i, j) = 0.0;
         // Loop over the shape functions
         for (unsigned l = 0; l < n_shape; l++)
         {
           for (unsigned k = 0; k < n_shape_type; k++)
           {
             // Jacobian is dx_j/ds_i, which is represented by the sum
             // over the dpsi/ds_i of the nodal points X j
             // Call the Non-hanging version of positions
             // This is overloaded in refineable elements
             jacobian(i, j) +=
               raw_lagrangian_position_gen(l, k, j) * dpsids(l, k, i);
           }
         }
       }
     }
   }

References oomph::FiniteElement::dim(), el_dim, i, j, k, Lagrangian_dimension, nnodal_lagrangian_type(), oomph::FiniteElement::nnode(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and raw_lagrangian_position_gen().

Referenced by local_to_lagrangian_mapping().

◆ assemble_local_to_lagrangian_jacobian2()

void oomph::SolidFiniteElement::assemble_local_to_lagrangian_jacobian2	(	const DShape &	d2psids,
		DenseMatrix< double > &	jacobian2
	)		const

privatevirtual

Assemble the the "jacobian" matrix of second derivatives, given the second derivatives of the shape functions w.r.t. local coordinates

Internal function that is used to assemble the jacobian of second derivatives of the the mapping from local coordinates (s) to the lagrangian coordinates (xi), given the second derivatives of the shape functions.

Reimplemented in oomph::RefineableSolidElement.

   {
     // Find the the dimension of the element
     const unsigned el_dim = dim();
     // Find the number of shape functions and shape functions types
     // We ENFORCE that Lagrangian coordinates must be interpolated through
     // the nodes
     const unsigned n_shape = nnode();
     const unsigned n_shape_type = nnodal_lagrangian_type();
     // Find the number of second derivatives
     const unsigned n_row = N2deriv[el_dim];
  
     // Assemble the "jacobian" (d^2 x_j/ds_i^2) for second derivatives of
     // shape functions
     // Loop over the rows (number of second derivatives)
     for (unsigned i = 0; i < n_row; i++)
     {
       // Loop over the columns (element dimension
       for (unsigned j = 0; j < el_dim; j++)
       {
         // Zero the entry
         jacobian2(i, j) = 0.0;
         // Loop over the shape functions
         for (unsigned l = 0; l < n_shape; l++)
         {
           // Loop over the shape function types
           for (unsigned k = 0; k < n_shape_type; k++)
           {
             // Add the terms to the jacobian entry
             // Call the Non-hanging version of positions
             // This is overloaded in refineable elements
             jacobian2(i, j) +=
               raw_lagrangian_position_gen(l, k, j) * d2psids(l, k, i);
           }
         }
       }
     }
   }

References oomph::FiniteElement::dim(), el_dim, i, j, k, oomph::FiniteElement::N2deriv, nnodal_lagrangian_type(), oomph::FiniteElement::nnode(), and raw_lagrangian_position_gen().

Referenced by d2shape_lagrangian(), and d2shape_lagrangian_at_knot().

◆ assign_all_generic_local_eqn_numbers()

virtual void oomph::SolidFiniteElement::assign_all_generic_local_eqn_numbers ( const bool & store_local_dof_pt )

inlinevirtual

Overload assign_all_generic_local_equation numbers to include the data associated with solid dofs. It remains virtual so that it can be overloaded by RefineableSolidElements. If the boolean argument is true then the degrees of freedom are stored in Dof_pt

Reimplemented from oomph::FiniteElement.

     {
       // Call the standard finite element equation numbering
       //(internal, external and nodal data).
       FiniteElement::assign_all_generic_local_eqn_numbers(store_local_dof_pt);
       // Assign the numbering for the solid dofs
       assign_solid_local_eqn_numbers(store_local_dof_pt);
     }

References oomph::FiniteElement::assign_all_generic_local_eqn_numbers(), and assign_solid_local_eqn_numbers().

◆ assign_solid_local_eqn_numbers()

void oomph::SolidFiniteElement::assign_solid_local_eqn_numbers ( const bool & store_local_dof_pt )

protectedvirtual

Assign local equation numbers for the solid equations in the element.

Assigns local equation numbers for the generic solid local equation numbering schemes. If the boolean flag is true the the degrees of freedom are stored in Dof_pt

If the boolean argument is true then pointers to the dofs will be stored in Dof_pt.

Reimplemented in oomph::RefineableSolidElement.

   {
     // Find the number of nodes
     const unsigned n_node = nnode();
  
     // Check there are nodes!
     if (n_node > 0)
     {
       // Find the number of position types and dimensions of the nodes
       // Local caching
       const unsigned n_position_type = nnodal_position_type();
       const unsigned nodal_dim = nodal_dimension();
  
       // Delete the existing storage
       delete[] Position_local_eqn;
       // Resize the storage for the positional equation numbers
       Position_local_eqn = new int[n_node * n_position_type * nodal_dim];
  
       // A local queue to store the global equation numbers
       std::deque<unsigned long> global_eqn_number_queue;
  
       // Get the number of dofs so far, this must be outside both loops
       // so that both can use it
       unsigned local_eqn_number = ndof();
  
       // Loop over the nodes
       for (unsigned n = 0; n < n_node; n++)
       {
         // Cast to a solid node
         SolidNode* cast_node_pt = static_cast<SolidNode*>(node_pt(n));
  
         // Loop over the number of position dofs
         for (unsigned j = 0; j < n_position_type; j++)
         {
           // Loop over the dimension of each node
           for (unsigned k = 0; k < nodal_dim; k++)
           {
             // Get equation number
             // Note eqn_number is long !
             long eqn_number = cast_node_pt->position_eqn_number(j, k);
             // If equation_number positive add to array
             if (eqn_number >= 0)
             {
               // Add to global array
               global_eqn_number_queue.push_back(eqn_number);
               // Add pointer to the dof to the queue if required
               if (store_local_dof_pt)
               {
                 GeneralisedElement::Dof_pt_deque.push_back(
                   &(cast_node_pt->x_gen(j, k)));
               }
  
               // Add to look-up scheme
               Position_local_eqn[(n * n_position_type + j) * nodal_dim + k] =
                 local_eqn_number;
               // Increment the local equation number
               local_eqn_number++;
             }
             else
             {
               Position_local_eqn[(n * n_position_type + j) * nodal_dim + k] =
                 Data::Is_pinned;
             }
           }
         }
       } // End of loop over nodes
  
       // Now add our global equations numbers to the internal element storage
       add_global_eqn_numbers(global_eqn_number_queue,
                              GeneralisedElement::Dof_pt_deque);
       // Clear the memory used in the deque
       if (store_local_dof_pt)
       {
         std::deque<double*>().swap(GeneralisedElement::Dof_pt_deque);
       }
  
     } // End of the case when there are nodes
   }

References oomph::GeneralisedElement::add_global_eqn_numbers(), oomph::GeneralisedElement::Dof_pt_deque, oomph::GeneralisedElement::eqn_number(), oomph::Data::Is_pinned, j, k, oomph::GeneralisedElement::local_eqn_number(), n, oomph::GeneralisedElement::ndof(), oomph::FiniteElement::nnodal_position_type(), oomph::FiniteElement::nnode(), oomph::FiniteElement::nodal_dimension(), oomph::FiniteElement::node_pt(), oomph::SolidNode::position_eqn_number(), Position_local_eqn, and oomph::Node::x_gen().

Referenced by assign_all_generic_local_eqn_numbers(), and oomph::RefineableSolidElement::assign_solid_local_eqn_numbers().

◆ compute_norm()

void oomph::SolidFiniteElement::compute_norm ( double & el_norm )

virtual

Calculate the L2 norm of the displacement u=R-r to overload the compute_norm function in the GeneralisedElement base class

//////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// Calculate the L2 norm of the displacement u=R-r to overload the compute_norm function in the GeneralisedElement base class

Reimplemented from oomph::GeneralisedElement.

Reimplemented in oomph::PseudoSolidNodeUpdateElement< TCrouzeixRaviartElement< 2 >, TPVDBubbleEnrichedElement< 2, 3 > >, oomph::PseudoSolidNodeUpdateElement< TTaylorHoodElement< 2 >, TPVDElement< 2, 3 > >, oomph::PseudoSolidNodeUpdateElement< GeneralisedNewtonianAxisymmetricTTaylorHoodElement, TPVDElement< 2, 3 > >, oomph::PseudoSolidNodeUpdateElement< AxisymmetricTTaylorHoodElement, TPVDElement< 2, 3 > >, and oomph::PseudoSolidNodeUpdateElement< GeneralisedNewtonianTTaylorHoodElement< 2 >, TPVDElement< 2, 3 > >.

   {
     // Initialise el_norm to 0.0
     el_norm = 0.0;
  
     unsigned n_dim = dim();
  
     // Vector of local coordinates
     Vector<double> s(n_dim);
  
     // Displacement vector, Lagrangian coordinate vector and Eulerian
     // coordinate vector respectively
     Vector<double> disp(n_dim, 0.0);
     Vector<double> xi(n_dim, 0.0);
     Vector<double> x(n_dim, 0.0);
  
     // Find out how many nodes there are in the element
     unsigned n_node = this->nnode();
  
     // Construct a shape function
     Shape psi(n_node);
  
     // Get the number of integration points
     unsigned n_intpt = this->integral_pt()->nweight();
  
     // Loop over the integration points
     for (unsigned ipt = 0; ipt < n_intpt; ipt++)
     {
       // Assign values of s
       for (unsigned i = 0; i < n_dim; i++)
       {
         s[i] = this->integral_pt()->knot(ipt, i);
       }
  
       // Get the integral weight
       double w = this->integral_pt()->weight(ipt);
  
       // Get jacobian of mapping
       double J = this->J_eulerian(s);
  
       // Premultiply the weights and the Jacobian
       double W = w * J;
  
       // Get the Lagrangian and Eulerian coordinate at this point, respectively
       this->interpolated_xi(s, xi);
       this->interpolated_x(s, x);
  
       // Calculate the displacement vector, u=R-r=x-xi
       for (unsigned idim = 0; idim < n_dim; idim++)
       {
         disp[idim] = x[idim] - xi[idim];
       }
  
       // Add to norm
       for (unsigned ii = 0; ii < n_dim; ii++)
       {
         el_norm += (disp[ii] * disp[ii]) * W;
       }
     }
   } // End of compute_norm(...)

References oomph::FiniteElement::dim(), i, oomph::FiniteElement::integral_pt(), oomph::FiniteElement::interpolated_x(), interpolated_xi(), J, oomph::FiniteElement::J_eulerian(), oomph::Integral::knot(), oomph::FiniteElement::nnode(), oomph::Integral::nweight(), s, w, oomph::QuadTreeNames::W, oomph::Integral::weight(), and plotDoE::x.

◆ construct_boundary_node() [1/2]

Node* oomph::SolidFiniteElement::construct_boundary_node ( const unsigned & n )

inlinevirtual

Construct the local node n and return a pointer to it. in the case when it is a boundary node; that is it MAY be located on a Mesh boundary

Reimplemented from oomph::FiniteElement.

     {
       // Construct a solid node and assign it to the local node pointer vector.
       // The dimension and number of values are taken from internal element data
       // The number of solid pressure dofs are also taken from internal data
       // The number of timesteps to be stored comes from the problem!
       node_pt(n) = new BoundaryNode<SolidNode>(lagrangian_dimension(),
                                                nnodal_lagrangian_type(),
                                                nodal_dimension(),
                                                nnodal_position_type(),
                                                required_nvalue(n));
       // Now return a pointer to the node, so that the mesh can find it
       return node_pt(n);
     }

References lagrangian_dimension(), n, nnodal_lagrangian_type(), oomph::FiniteElement::nnodal_position_type(), oomph::FiniteElement::nodal_dimension(), oomph::FiniteElement::node_pt(), and oomph::FiniteElement::required_nvalue().

◆ construct_boundary_node() [2/2]

Node* oomph::SolidFiniteElement::construct_boundary_node	(	const unsigned &	n,
		TimeStepper *const &	time_stepper_pt
	)

inlinevirtual

Construct the local node n and return a pointer to it, in the case when the node MAY be located on a boundary. Additionally, create storage for ‘history’ values as required by timestepper

Reimplemented from oomph::FiniteElement.

     {
       // Construct a solid node and assign it to the local node pointer vector
       // The dimension and number of values are taken from internal element data
       // The number of solid pressure dofs are also taken from internal data
       node_pt(n) = new BoundaryNode<SolidNode>(time_stepper_pt,
                                                lagrangian_dimension(),
                                                nnodal_lagrangian_type(),
                                                nodal_dimension(),
                                                nnodal_position_type(),
                                                required_nvalue(n));
       // Now return a pointer to the node, so that the mesh can find it
       return node_pt(n);
     }

References lagrangian_dimension(), n, nnodal_lagrangian_type(), oomph::FiniteElement::nnodal_position_type(), oomph::FiniteElement::nodal_dimension(), oomph::FiniteElement::node_pt(), oomph::FiniteElement::required_nvalue(), and oomph::GeomObject::time_stepper_pt().

◆ construct_node() [1/2]

Node* oomph::SolidFiniteElement::construct_node ( const unsigned & n )

inlinevirtual

Construct the local node n and return a pointer to it.

Reimplemented from oomph::FiniteElement.

     {
       // Construct a solid node and assign it to the local node pointer vector.
       // The dimension and number of values are taken from internal element data
       // The number of solid pressure dofs are also taken from internal data
       // The number of timesteps to be stored comes from the problem!
       node_pt(n) = new SolidNode(lagrangian_dimension(),
                                  nnodal_lagrangian_type(),
                                  nodal_dimension(),
                                  nnodal_position_type(),
                                  required_nvalue(n));
       // Now return a pointer to the node, so that the mesh can find it
       return node_pt(n);
     }

References lagrangian_dimension(), n, nnodal_lagrangian_type(), oomph::FiniteElement::nnodal_position_type(), oomph::FiniteElement::nodal_dimension(), oomph::FiniteElement::node_pt(), and oomph::FiniteElement::required_nvalue().

◆ construct_node() [2/2]

Node* oomph::SolidFiniteElement::construct_node	(	const unsigned &	n,
		TimeStepper *const &	time_stepper_pt
	)

inlinevirtual

Construct the local node n and return a pointer to it. Additionally, create storage for ‘history’ values as required by timestepper

Reimplemented from oomph::FiniteElement.

     {
       // Construct a solid node and assign it to the local node pointer vector
       // The dimension and number of values are taken from internal element data
       // The number of solid pressure dofs are also taken from internal data
       node_pt(n) = new SolidNode(time_stepper_pt,
                                  lagrangian_dimension(),
                                  nnodal_lagrangian_type(),
                                  nodal_dimension(),
                                  nnodal_position_type(),
                                  required_nvalue(n));
       // Now return a pointer to the node, so that the mesh can find it
       return node_pt(n);
     }

References lagrangian_dimension(), n, nnodal_lagrangian_type(), oomph::FiniteElement::nnodal_position_type(), oomph::FiniteElement::nodal_dimension(), oomph::FiniteElement::node_pt(), oomph::FiniteElement::required_nvalue(), and oomph::GeomObject::time_stepper_pt().

◆ d2shape_lagrangian()

double oomph::SolidFiniteElement::d2shape_lagrangian	(	const Vector< double > &	s,
		Shape &	psi,
		DShape &	dpsi,
		DShape &	d2psi
	)		const

Compute the geometric shape functions and also first and second derivatives w.r.t. Lagrangian coordinates at local coordinate s; Returns Jacobian of mapping from Lagrangian to local coordinates. Numbering: 1D: d2pidxi(i,0) = $ d^2 \psi_j / d \xi^2 $ 2D: d2psidxi(i,0) = $ \partial^2 \psi_j / \partial \xi_0^2 $ d2psidxi(i,1) = $ \partial^2 \psi_j / \partial \xi_1^2 $ d2psidxi(i,2) = $ \partial^2 \psi_j / \partial \xi_0 \partial \xi_1 $ 3D: d2psidxi(i,0) = $ \partial^2 \psi_j / \partial \xi_0^2 $ d2psidxi(i,1) = $ \partial^2 \psi_j / \partial \xi_1^2 $ d2psidxi(i,2) = $ \partial^2 \psi_j / \partial \xi_2^2 $ d2psidxi(i,3) = $ \partial^2 \psi_j/\partial \xi_0 \partial \xi_1 $ d2psidxi(i,4) = $ \partial^2 \psi_j/\partial \xi_0 \partial \xi_2 $ d2psidxi(i,5) = $ \partial^2 \psi_j/\partial \xi_1 \partial \xi_2 $

   {
     // Find the element dimension
     const unsigned el_dim = dim();
     // Find the number of second derivatives required
     const unsigned n_deriv = N2deriv[el_dim];
  
     // Get the values of the shape function and local derivatives
     d2shape_local(s, psi, dpsi, d2psi);
  
     // Allocate memory for the jacobian and inverse jacobian
     DenseMatrix<double> jacobian(el_dim), inverse_jacobian(el_dim);
     // Calculate the jacobian and inverse jacobian
     const double det =
       local_to_lagrangian_mapping(dpsi, jacobian, inverse_jacobian);
  
     // Allocate memory for the jacobian of second derivatives
     DenseMatrix<double> jacobian2(n_deriv, el_dim);
     // Assemble the jacobian of second derivatives
     assemble_local_to_lagrangian_jacobian2(d2psi, jacobian2);
  
     // Now set the value of the derivatives
     transform_second_derivatives(
       jacobian, inverse_jacobian, jacobian2, dpsi, d2psi);
     // Return the determinant of the mapping
     return det;
   }

References assemble_local_to_lagrangian_jacobian2(), oomph::FiniteElement::d2shape_local(), oomph::FiniteElement::dim(), el_dim, local_to_lagrangian_mapping(), oomph::FiniteElement::N2deriv, s, and oomph::FiniteElement::transform_second_derivatives().

Referenced by oomph::KirchhoffLoveShellEquations::get_strain_and_bend().

◆ d2shape_lagrangian_at_knot()

double oomph::SolidFiniteElement::d2shape_lagrangian_at_knot	(	const unsigned &	ipt,
		Shape &	psi,
		DShape &	dpsi,
		DShape &	d2psi
	)		const

virtual

Return the geometric shape functions and also first and second derivatives w.r.t. Lagrangian coordinates at the ipt-th integration point. Returns Jacobian of mapping from Lagrangian to local coordinates. Numbering: 1D: d2pidxi(i,0) = $ d^2 \psi_j / d^2 \xi^2 $ 2D: d2psidxi(i,0) = $ \partial^2 \psi_j/\partial^2 \xi_0^2 $ d2psidxi(i,1) = $ \partial^2 \psi_j/\partial^2 \xi_1^2 $ d2psidxi(i,2) = $ \partial^2 \psi_j/\partial \xi_0 \partial \xi_1 $ 3D: d2psidxi(i,0) = $ \partial^2 \psi_j / \partial^2 \xi_0^2 $ d2psidxi(i,1) = $ \partial^2 \psi_j / \partial^2 \xi_1^2 $ d2psidxi(i,2) = $ \partial^2 \psi_j / \partial^2 \xi_2^2 $ d2psidxi(i,3) = $ \partial^2 \psi_j / \partial \xi_0 \partial \xi_1 $ d2psidxi(i,4) = $ \partial^2 \psi_j / \partial \xi_0 \partial \xi_2 $ d2psidxi(i,5) = $ \partial^2 \psi_j / \partial \xi_1 \partial \xi_2 $

Compute the geometric shape functions and also first and second derivatives w.r.t. Lagrangian coordinates at the ipt-th integration point Returns Jacobian of mapping from Lagrangian to local coordinates. Numbering: 1D: d2pidxi(i,0) = $ d^2 \psi_j / d \xi^2 $ 2D: d2psidxi(i,0) = $ \partial^2 \psi_j / \partial \xi_0^2 $ d2psidxi(i,1) = $ \partial^2 \psi_j / \partial \xi_1^2 $ d2psidxi(i,2) = $ \partial^2 \psi_j/\partial \xi_0 \partial \xi_1 $ 3D: d2psidxi(i,0) = $ \partial^2 \psi_j / \partial \xi_0^2 $ d2psidxi(i,1) = $ \partial^2 \psi_j / \partial \xi_1^2 $ d2psidxi(i,2) = $ \partial^2 \psi_j / \partial \xi_2^2 $ d2psidxi(i,3) = $ \partial^2 \psi_j/\partial \xi_0 \partial \xi_1 $ d2psidxi(i,4) = $ \partial^2 \psi_j/\partial \xi_0 \partial \xi_2 $ d2psidxi(i,5) = $ \partial^2 \psi_j/\partial \xi_1 \partial \xi_2 $

Reimplemented in oomph::StorableShapeSolidElementBase.

   {
     // Find the values of the indices of the shape functions
     // Find the element dimension
     const unsigned el_dim = dim();
     // Find the number of second derivatives required
     const unsigned n_deriv = N2deriv[el_dim];
  
     // Get the values of the shape function and local derivatives
     d2shape_local_at_knot(ipt, psi, dpsi, d2psi);
  
     // Allocate memory for the jacobian and inverse jacobian
     DenseMatrix<double> jacobian(el_dim), inverse_jacobian(el_dim);
     // Calculate the jacobian and inverse jacobian
     const double det =
       local_to_lagrangian_mapping(dpsi, jacobian, inverse_jacobian);
  
     // Allocate memory for the jacobian of second derivatives
     DenseMatrix<double> jacobian2(n_deriv, el_dim);
     // Assemble the jacobian of second derivatives
     assemble_local_to_lagrangian_jacobian2(d2psi, jacobian2);
  
     // Now set the value of the derivatives
     transform_second_derivatives(
       jacobian, inverse_jacobian, jacobian2, dpsi, d2psi);
     // Return the determinant of the mapping
     return det;
   }

References assemble_local_to_lagrangian_jacobian2(), oomph::FiniteElement::d2shape_local_at_knot(), oomph::FiniteElement::dim(), el_dim, local_to_lagrangian_mapping(), oomph::FiniteElement::N2deriv, and oomph::FiniteElement::transform_second_derivatives().

Referenced by oomph::StorableShapeSolidElementBase::d2shape_lagrangian_at_knot(), oomph::KirchhoffLoveBeamEquations::fill_in_contribution_to_residuals_beam(), oomph::KirchhoffLoveShellEquations::fill_in_contribution_to_residuals_shell(), oomph::KirchhoffLoveShellEquations::get_energy(), oomph::KirchhoffLoveBeamEquations::get_energy(), and oomph::StorableShapeSolidElementBase::pre_compute_d2shape_lagrangian_at_knots().

◆ describe_local_dofs()

void oomph::SolidFiniteElement::describe_local_dofs	(	std::ostream &	out,
		const std::string &	current_string
	)		const

virtual

Function to describe the local dofs of the element. The ostream specifies the output stream to which the description is written; the string stores the currently assembled output that is ultimately written to the output stream by Data::describe_dofs(...); it is typically built up incrementally as we descend through the call hierarchy of this function when called from Problem::describe_dofs(...)

Reimplemented from oomph::FiniteElement.

Reimplemented in oomph::FSIImposeDisplacementByLagrangeMultiplierElement< ELEMENT >, oomph::PseudoSolidNodeUpdateElement< TCrouzeixRaviartElement< 2 >, TPVDBubbleEnrichedElement< 2, 3 > >, oomph::PseudoSolidNodeUpdateElement< TTaylorHoodElement< 2 >, TPVDElement< 2, 3 > >, oomph::PseudoSolidNodeUpdateElement< GeneralisedNewtonianAxisymmetricTTaylorHoodElement, TPVDElement< 2, 3 > >, oomph::PseudoSolidNodeUpdateElement< AxisymmetricTTaylorHoodElement, TPVDElement< 2, 3 > >, oomph::PseudoSolidNodeUpdateElement< GeneralisedNewtonianTTaylorHoodElement< 2 >, TPVDElement< 2, 3 > >, and oomph::FSIWallElement.

   {
     // Call the standard finite element description.
     FiniteElement::describe_local_dofs(out, current_string);
     describe_solid_local_dofs(out, current_string);
   }

References oomph::FiniteElement::describe_local_dofs(), describe_solid_local_dofs(), and out().

◆ describe_solid_local_dofs()

void oomph::SolidFiniteElement::describe_solid_local_dofs	(	std::ostream &	out,
		const std::string &	current_string
	)		const

protected

Classifies dofs locally for solid specific aspects.

Function to describe the local dofs of the element. The ostream specifies the output stream to which the description is written; the string stores the currently assembled output that is ultimately written to the output stream by Data::describe_dofs(...); it is typically built up incrementally as we descend through the call hierarchy of this function when called from Problem::describe_dofs(...)

   {
     // Find the number of nodes
     const unsigned n_node = nnode();
     // Loop over the nodes
     for (unsigned n = 0; n < n_node; n++)
     {
       // Cast to a solid node
       SolidNode* cast_node_pt = static_cast<SolidNode*>(node_pt(n));
       std::stringstream conversion;
       conversion << " of Solid Node " << n << current_string;
       std::string in(conversion.str());
       cast_node_pt->describe_dofs(out, in);
     }
   }

References oomph::SolidNode::describe_dofs(), n, oomph::FiniteElement::nnode(), oomph::FiniteElement::node_pt(), out(), and oomph::Global_string_for_annotation::string().

Referenced by describe_local_dofs(), and oomph::FSIWallElement::describe_local_dofs().

◆ disable_solve_for_consistent_newmark_accel()

void oomph::SolidFiniteElement::disable_solve_for_consistent_newmark_accel ( )

inline

Set to reset the problem being solved to be the standard problem.

     {
       Solve_for_consistent_newmark_accel_flag = false;
     }

References Solve_for_consistent_newmark_accel_flag.

◆ dshape_lagrangian()

double oomph::SolidFiniteElement::dshape_lagrangian	(	const Vector< double > &	s,
		Shape &	psi,
		DShape &	dpsi
	)		const

Calculate shape functions and derivatives w.r.t. Lagrangian coordinates at local coordinate s. Returns the Jacobian of the mapping from Lagrangian to local coordinates.

Calculate shape functions and derivatives w.r.t. Lagrangian coordinates at local coordinate s. Returns the Jacobian of the mapping from Lagrangian to local coordinates. General case, may be overloaded

   {
     // Find the element dimension
     const unsigned el_dim = dim();
  
     // Get the values of the shape function and local derivatives
     // Temporarily stored in dpsi
     dshape_local(s, psi, dpsi);
  
     // Allocate memory for the inverse jacobian
     DenseMatrix<double> inverse_jacobian(el_dim);
     // Now calculate the inverse jacobian
     const double det = local_to_lagrangian_mapping(dpsi, inverse_jacobian);
  
     // Now set the values of the derivatives to be dpsidxi
     transform_derivatives(inverse_jacobian, dpsi);
     // Return the determinant of the jacobian
     return det;
   }

References oomph::FiniteElement::dim(), oomph::FiniteElement::dshape_local(), el_dim, local_to_lagrangian_mapping(), s, and oomph::FiniteElement::transform_derivatives().

Referenced by oomph::FSIHermiteBeamElement::dposition_dlagrangian_at_local_coordinate(), oomph::FSIDiagHermiteShellElement::dposition_dlagrangian_at_local_coordinate(), fill_in_jacobian_for_newmark_accel(), oomph::KirchhoffLoveShellEquations::get_normal(), oomph::KirchhoffLoveBeamEquations::get_normal(), and oomph::KirchhoffLoveShellEquations::load_rate_of_work().

◆ dshape_lagrangian_at_knot()

double oomph::SolidFiniteElement::dshape_lagrangian_at_knot	(	const unsigned &	ipt,
		Shape &	psi,
		DShape &	dpsi
	)		const

virtual

Return the geometric shape functions and also first derivatives w.r.t. Lagrangian coordinates at ipt-th integration point.

Compute the geometric shape functions and also first derivatives w.r.t. Lagrangian coordinates at integration point ipt. Most general form of function, but may be over-loaded if desired

Reimplemented in oomph::StorableShapeSolidElementBase.

   {
     // Find the element dimension
     const unsigned el_dim = dim();
  
     // Shape function for the local derivatives
     // Again we ASSUME (insist) that the lagrangian coordinates
     // are interpolated through the nodes
     // Get the values of the shape function and local derivatives
     dshape_local_at_knot(ipt, psi, dpsi);
  
     // Allocate memory for the inverse jacobian
     DenseMatrix<double> inverse_jacobian(el_dim);
     // Now calculate the inverse jacobian
     const double det = local_to_lagrangian_mapping(dpsi, inverse_jacobian);
  
     // Now set the values of the derivatives
     transform_derivatives(inverse_jacobian, dpsi);
     // Return the determinant of the jacobian
     return det;
   }

References oomph::FiniteElement::dim(), oomph::FiniteElement::dshape_local_at_knot(), el_dim, local_to_lagrangian_mapping(), and oomph::FiniteElement::transform_derivatives().

Referenced by oomph::AxisymmetricPVDEquations::compute_physical_size(), oomph::AxisymmetricPVDEquationsWithPressure::compute_physical_size(), oomph::StorableShapeSolidElementBase::dshape_lagrangian_at_knot(), oomph::AxisymmetricPVDEquations::fill_in_contribution_to_residuals_axisym_pvd(), oomph::RefineableQDPVDElement< DIM, NNODE_1D >::fill_in_generic_contribution_to_residuals_pvd(), oomph::AxisymmetricPVDEquationsWithPressure::fill_in_generic_residual_contribution_axisym_pvd_with_pressure(), and oomph::StorableShapeSolidElementBase::pre_compute_dshape_lagrangian_at_knots().

◆ enable_solve_for_consistent_newmark_accel()

void oomph::SolidFiniteElement::enable_solve_for_consistent_newmark_accel ( )

inline

Set to alter the problem being solved when assigning the initial conditions for time-dependent problems: solve for the history value that corresponds to the acceleration in the Newmark scheme by demanding that the PDE is satisifed at the initial time. In this case the Jacobian is replaced by the mass matrix.

     {
       Solve_for_consistent_newmark_accel_flag = true;
     }

References Solve_for_consistent_newmark_accel_flag.

Referenced by oomph::SolidICProblem::set_newmark_initial_condition_consistently().

◆ fill_in_contribution_to_jacobian()

void oomph::SolidFiniteElement::fill_in_contribution_to_jacobian	(	Vector< double > &	residuals,
		DenseMatrix< double > &	jacobian
	)

inlineprotectedvirtual

Overload the fill_in_contribution_to_jacobian() function to use finite differences to calculate the solid residuals by default

Reimplemented from oomph::FiniteElement.

Reimplemented in oomph::RefineableFSIImposeDisplacementByLagrangeMultiplierElement< ELEMENT >, oomph::FSIImposeDisplacementByLagrangeMultiplierElement< ELEMENT >, oomph::RefineableImposeDisplacementByLagrangeMultiplierElement< ELEMENT >, oomph::ImposeDisplacementByLagrangeMultiplierElement< ELEMENT >, oomph::RefineableFSISolidTractionElement< ELEMENT, DIM >, oomph::FSISolidTractionElement< ELEMENT, DIM >, oomph::RefineableSolidTractionElement< ELEMENT >, oomph::SolidTractionElement< ELEMENT >, oomph::PVDEquationsWithPressure< DIM >, oomph::PVDEquations< DIM >, oomph::FSIDiagHermiteShellElement, oomph::KirchhoffLoveShellEquations, oomph::PseudoSolidNodeUpdateElement< TCrouzeixRaviartElement< 2 >, TPVDBubbleEnrichedElement< 2, 3 > >, oomph::PseudoSolidNodeUpdateElement< TTaylorHoodElement< 2 >, TPVDElement< 2, 3 > >, oomph::PseudoSolidNodeUpdateElement< GeneralisedNewtonianAxisymmetricTTaylorHoodElement, TPVDElement< 2, 3 > >, oomph::PseudoSolidNodeUpdateElement< AxisymmetricTTaylorHoodElement, TPVDElement< 2, 3 > >, oomph::PseudoSolidNodeUpdateElement< GeneralisedNewtonianTTaylorHoodElement< 2 >, TPVDElement< 2, 3 > >, and oomph::FSIWallElement.

     {
       // Add the contribution to the residuals
       fill_in_contribution_to_residuals(residuals);
  
       // Solve for the consistent acceleration in Newmark scheme?
       if (Solve_for_consistent_newmark_accel_flag)
       {
         fill_in_jacobian_for_newmark_accel(jacobian);
         return;
       }
  
       // Allocate storage for the full residuals (residuals of entire element)
       unsigned n_dof = ndof();
       Vector<double> full_residuals(n_dof);
       // Get the residuals for the entire element
       get_residuals(full_residuals);
       // Get the solid entries in the jacobian using finite differences
       fill_in_jacobian_from_solid_position_by_fd(full_residuals, jacobian);
       // There could be internal data
       //(finite-difference the lot by default)
       fill_in_jacobian_from_internal_by_fd(full_residuals, jacobian, true);
       // There could also be external data
       //(finite-difference the lot by default)
       fill_in_jacobian_from_external_by_fd(full_residuals, jacobian, true);
       // There could also be nodal data
       fill_in_jacobian_from_nodal_by_fd(full_residuals, jacobian);
     }

References oomph::GeneralisedElement::fill_in_contribution_to_residuals(), fill_in_jacobian_for_newmark_accel(), oomph::GeneralisedElement::fill_in_jacobian_from_external_by_fd(), oomph::GeneralisedElement::fill_in_jacobian_from_internal_by_fd(), oomph::FiniteElement::fill_in_jacobian_from_nodal_by_fd(), fill_in_jacobian_from_solid_position_by_fd(), oomph::GeneralisedElement::get_residuals(), oomph::GeneralisedElement::ndof(), and Solve_for_consistent_newmark_accel_flag.

Referenced by QThermalPVDElement< DIM >::fill_in_contribution_to_jacobian().

◆ fill_in_generic_jacobian_for_solid_ic()

void oomph::SolidFiniteElement::fill_in_generic_jacobian_for_solid_ic	(	Vector< double > &	residuals,
		DenseMatrix< double > &	jacobian,
		const unsigned &	flag
	)

protected

Helper function to fill in the residuals and (if flag==1) the Jacobian for the setup of an initial condition. The global equations are:

\[ 0 = \int \left( \sum_{j=1}^N \sum_{k=1}^K X_{ijk} \psi_{jk}(\xi_n) - \frac{\partial^D R^{(IC)}_i(\xi_n)}{\partial t^D} \right) \psi_{lm}(\xi_n) \ dv \mbox{ \ \ \ \ for \ \ \ $l=1,...,N, \ \ m=1,...,K$} \]

where $ N $ is the number of nodes in the mesh and $ K $ the number of generalised nodal coordinates. The initial shape of the solid body, $ {\bf R}^{(IC)},$ and its time-derivatives are specified via the GeomObject that is stored in the SolidFiniteElement::SolidInitialCondition object. The latter also stores the order of the time-derivative $ D $ to be assigned.

   {
     // Find the number of nodes and position types
     const unsigned n_node = nnode();
     const unsigned n_position_type = nnodal_position_type();
  
     // Set the dimension of the global coordinates
     const unsigned nodal_dim = nodal_dimension();
  
     // Find the number of lagragian types from the first node
     const unsigned n_lagrangian_type = nnodal_lagrangian_type();
  
     // Set the number of lagrangian coordinates
     const unsigned n_lagrangian = dim();
  
     // Integer storage for local equation number
     int local_eqn = 0;
     int local_unknown = 0;
  
     // # of nodes, # of positional dofs
     Shape psi(n_node, n_position_type);
  
     // # of nodes, # of positional dofs, # of lagrangian coords (for deriv)
     // not needed but they come for free when we compute the Jacobian
     // DShape dpsidxi(n_node,n_position_type,n_lagrangian);
  
     // Set # of integration points
     const unsigned n_intpt = integral_pt()->nweight();
  
     // Set the Vector to hold local coordinates
     Vector<double> s(n_lagrangian);
  
     // Loop over the integration points
     for (unsigned ipt = 0; ipt < n_intpt; ipt++)
     {
       // Assign values of s
       for (unsigned i = 0; i < n_lagrangian; i++)
       {
         s[i] = integral_pt()->knot(ipt, i);
       }
  
       // Get the integral weight
       double w = integral_pt()->weight(ipt);
  
       // Shape fcts
       shape(s, psi);
  
       // Get Lagrangian coordinate
       Vector<double> xi(n_lagrangian, 0.0);
  
       // Loop over the number of lagrangian coordinates
       for (unsigned i = 0; i < n_lagrangian; i++)
       {
         // Loop over the local nodes
         for (unsigned l = 0; l < n_node; l++)
         {
           // Loop over the number of dofs
           for (unsigned k = 0; k < n_lagrangian_type; k++)
           {
             xi[i] += lagrangian_position_gen(l, k, i) * psi(l, k);
           }
         }
       }
  
       // Get initial condition
       Vector<double> drdt_ic(nodal_dim);
       Solid_ic_pt->geom_object_pt()->dposition_dt(
         xi, Solid_ic_pt->ic_time_deriv(), drdt_ic);
  
       // Weak form of assignment of initial guess
  
       // Loop over the number of node
       for (unsigned l = 0; l < n_node; l++)
       {
         // Loop over the type of degree of freedom
         for (unsigned k = 0; k < n_position_type; k++)
         {
           // Loop over the coordinate directions
           for (unsigned i = 0; i < nodal_dim; i++)
           {
             local_eqn = position_local_eqn(l, k, i);
  
             // If it's not a boundary condition
             if (local_eqn >= 0)
             {
               // Note we're ignoring the mapping between local and
               // global Lagrangian coords -- doesn't matter here;
               // we're just enforcing a slightly different
               // weak form.
               residuals[local_eqn] +=
                 (interpolated_x(s, i) - drdt_ic[i]) * psi(l, k) * w;
  
  
               // Do Jacobian too?
               if (flag == 1)
               {
                 // Loop over the number of node
                 for (unsigned ll = 0; ll < n_node; ll++)
                 {
                   // Loop over the type of degree of freedom
                   for (unsigned kk = 0; kk < n_position_type; kk++)
                   {
                     // Only diagonal term
                     unsigned ii = i;
  
                     local_unknown = position_local_eqn(ll, kk, ii);
  
                     // If it's not a boundary condition
                     if (local_unknown >= 0)
                     {
                       // Note we're ignoring the mapping between local and
                       // global Lagrangian coords -- doesn't matter here;
                       // we're just enforcing a slightly different
                       // weak form.
                       jacobian(local_eqn, local_unknown) +=
                         psi(ll, kk) * psi(l, k) * w;
                     }
                     else
                     {
                       oomph_info
                         << "WARNING: You should really free all Data"
                         << std::endl
                         << "         before setup of initial guess" << std::endl
                         << "ll, kk, ii " << ll << " " << kk << " " << ii
                         << std::endl;
                     }
                   }
                 }
               }
             }
             else
             {
               oomph_info << "WARNING: You should really free all Data"
                          << std::endl
                          << "         before setup of initial guess"
                          << std::endl
                          << "l, k, i " << l << " " << k << " " << i
                          << std::endl;
             }
           }
         }
       }
  
     } // End of loop over the integration points
   }

References oomph::FiniteElement::dim(), oomph::GeomObject::dposition_dt(), oomph::SolidInitialCondition::geom_object_pt(), i, oomph::SolidInitialCondition::ic_time_deriv(), oomph::FiniteElement::integral_pt(), oomph::FiniteElement::interpolated_x(), k, oomph::Integral::knot(), lagrangian_position_gen(), nnodal_lagrangian_type(), oomph::FiniteElement::nnodal_position_type(), oomph::FiniteElement::nnode(), oomph::FiniteElement::nodal_dimension(), oomph::Integral::nweight(), oomph::oomph_info, position_local_eqn(), s, oomph::FiniteElement::shape(), Solid_ic_pt, w, and oomph::Integral::weight().

Referenced by fill_in_jacobian_for_solid_ic(), and fill_in_residuals_for_solid_ic().

◆ fill_in_jacobian_for_newmark_accel()

void oomph::SolidFiniteElement::fill_in_jacobian_for_newmark_accel ( DenseMatrix< double > & jacobian )

Fill in the contributions of the Jacobian matrix for the consistent assignment of the initial "accelerations" in Newmark scheme. In this case the Jacobian is the mass matrix.

Add jacobian and residuals for consistent assignment of initial "accelerations" in Newmark scheme. Jacobian is the mass matrix.

   {
 #ifdef PARANOID
     // Check that we're computing the real residuals, not the
     // ones corresponding to the assignement of a prescribed displacement
     if ((Solid_ic_pt != 0) || (!Solve_for_consistent_newmark_accel_flag))
     {
       std::ostringstream error_stream;
       error_stream << "Can only call fill_in_jacobian_for_newmark_accel()\n"
                    << "With Solve_for_consistent_newmark_accel_flag:"
                    << Solve_for_consistent_newmark_accel_flag << std::endl;
       error_stream << "Solid_ic_pt: " << Solid_ic_pt << std::endl;
  
       throw OomphLibError(
         error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
 #endif
  
     // Find the number of nodes
     const unsigned n_node = nnode();
     const unsigned n_position_type = nnodal_position_type();
     const unsigned nodal_dim = nodal_dimension();
  
     // Set the number of Lagrangian coordinates
     const unsigned n_lagrangian = dim();
  
     // Integer storage for local equation and unknown
     int local_eqn = 0, local_unknown = 0;
  
     // Set up memory for the shape functions:
     // # of nodes, # of positional dofs
     Shape psi(n_node, n_position_type);
  
     // # of nodes, # of positional dofs, # of lagrangian coords (for deriv)
     // Not needed but they come for free when compute the Jacobian.
     DShape dpsidxi(n_node, n_position_type, n_lagrangian);
  
     // Set # of integration points
     const unsigned n_intpt = integral_pt()->nweight();
  
     // Set the Vector to hold local coordinates
     Vector<double> s(n_lagrangian);
  
     // Get positional timestepper from first nodal point
     TimeStepper* timestepper_pt = node_pt(0)->position_time_stepper_pt();
  
 #ifdef PARANOID
     // Of course all this only works if we're actually using a
     // Newmark timestepper!
     if (timestepper_pt->type() != "Newmark")
     {
       std::ostringstream error_stream;
       error_stream
         << "Assignment of Newmark accelerations obviously only works\n"
         << "for Newmark timesteppers. You've called me with "
         << timestepper_pt->type() << std::endl;
  
       throw OomphLibError(
         error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
 #endif
  
     // "Acceleration" is the last history value:
     const unsigned ntstorage = timestepper_pt->ntstorage();
     const double accel_weight = timestepper_pt->weight(2, ntstorage - 1);
  
     // Loop over the integration points
     for (unsigned ipt = 0; ipt < n_intpt; ipt++)
     {
       // Assign values of s
       for (unsigned i = 0; i < n_lagrangian; i++)
       {
         s[i] = integral_pt()->knot(ipt, i);
       }
  
       // Get the integral weight
       double w = integral_pt()->weight(ipt);
  
       // Jacobian of mapping between local and Lagrangian coords and shape
       // functions
       double J = dshape_lagrangian(s, psi, dpsidxi);
  
       // Get Lagrangian coordinate
       Vector<double> xi(n_lagrangian);
       interpolated_xi(s, xi);
  
       // Get multiplier for inertia terms
       double factor = multiplier(xi);
  
       // Premultiply the weights and the Jacobian
       double W = w * J;
  
       // Loop over the nodes
       for (unsigned l0 = 0; l0 < n_node; l0++)
       {
         // Loop over the positional dofs: 'Type': 0: displacement; 1: deriv
         for (unsigned k0 = 0; k0 < n_position_type; k0++)
         {
           // Loop over Eulerian directions
           for (unsigned i0 = 0; i0 < nodal_dim; i0++)
           {
             local_eqn = position_local_eqn(l0, k0, i0);
             // If it's a degree of freedom, add contribution
             if (local_eqn >= 0)
             {
               // Loop over the nodes
               for (unsigned l1 = 0; l1 < n_node; l1++)
               {
                 // Loop over the positional dofs: 'Type': 0: displacement;
                 // 1: deriv
                 for (unsigned k1 = 0; k1 < n_position_type; k1++)
                 {
                   // Loop over Eulerian directions
                   unsigned i1 = i0;
                   {
                     local_unknown = position_local_eqn(l1, k1, i1);
                     // If it's a degree of freedom, add contribution
                     if (local_unknown >= 0)
                     {
                       // Add contribution: Mass matrix, multiplied by
                       // weight for "acceleration" in Newmark scheme
                       // and general multiplier
                       jacobian(local_eqn, local_unknown) +=
                         factor * accel_weight * psi(l0, k0) * psi(l1, k1) * W;
                     }
                   }
                 }
               }
             }
           }
         }
       }
  
     } // End of loop over the integration points
   }

References oomph::FiniteElement::dim(), dshape_lagrangian(), i, oomph::FiniteElement::integral_pt(), interpolated_xi(), J, oomph::Integral::knot(), multiplier(), oomph::FiniteElement::nnodal_position_type(), oomph::FiniteElement::nnode(), oomph::FiniteElement::nodal_dimension(), oomph::FiniteElement::node_pt(), oomph::TimeStepper::ntstorage(), oomph::Integral::nweight(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, position_local_eqn(), oomph::Node::position_time_stepper_pt(), s, Solid_ic_pt, Solve_for_consistent_newmark_accel_flag, oomph::TimeStepper::type(), w, oomph::QuadTreeNames::W, oomph::Integral::weight(), and oomph::TimeStepper::weight().

Referenced by oomph::AxisymmetricPVDEquations::fill_in_contribution_to_jacobian(), oomph::KirchhoffLoveBeamEquations::fill_in_contribution_to_jacobian(), fill_in_contribution_to_jacobian(), oomph::FSIWallElement::fill_in_contribution_to_jacobian(), oomph::KirchhoffLoveShellEquations::fill_in_contribution_to_jacobian(), and oomph::PVDEquations< DIM >::fill_in_contribution_to_jacobian().

◆ fill_in_jacobian_for_solid_ic()

void oomph::SolidFiniteElement::fill_in_jacobian_for_solid_ic	(	Vector< double > &	residuals,
		DenseMatrix< double > &	jacobian
	)

inline

Fill in the residuals and Jacobian for the setup of an initial condition. The global equations are:

\[ 0 = \int \left( \sum_{j=1}^N \sum_{k=1}^K X_{ijk} \psi_{jk}(\xi_n) - \frac{\partial^D R^{(IC)}_i(\xi_n)}{\partial t^D} \right) \psi_{lm}(\xi_n) \ dv \mbox{ \ \ \ \ for \ \ \ $l=1,...,N, \ \ m=1,...,K$} \]

where $ N $ is the number of nodes in the mesh and $ K $ the number of generalised nodal coordinates. The initial shape of the solid body, $ {\bf R}^{(IC)},$ and its time-derivatives are specified via the GeomObject that is stored in the SolidFiniteElement::SolidInitialCondition object. The latter also stores the order of the time-derivative $ D $ to be assigned.

     {
       // Call the generic routine with the flag set to 1
       fill_in_generic_jacobian_for_solid_ic(residuals, jacobian, 1);
     }

References fill_in_generic_jacobian_for_solid_ic().

Referenced by oomph::PVDEquations< DIM >::fill_in_contribution_to_jacobian().

◆ fill_in_jacobian_from_solid_position_by_fd() [1/2]

void oomph::SolidFiniteElement::fill_in_jacobian_from_solid_position_by_fd ( DenseMatrix< double > & jacobian )

inlineprotected

Use finite differences to calculate the Jacobian entries corresponding to the solid positions.

     {
       // Allocate storage for a residuals vector and initialise to zero
       unsigned n_dof = ndof();
       Vector<double> residuals(n_dof, 0.0);
       // Get the residuals for the entire element
       get_residuals(residuals);
       // Call the jacobian calculation
       fill_in_jacobian_from_solid_position_by_fd(residuals, jacobian);
     }

References fill_in_jacobian_from_solid_position_by_fd(), oomph::GeneralisedElement::get_residuals(), and oomph::GeneralisedElement::ndof().

◆ fill_in_jacobian_from_solid_position_by_fd() [2/2]

void oomph::SolidFiniteElement::fill_in_jacobian_from_solid_position_by_fd	(	Vector< double > &	residuals,
		DenseMatrix< double > &	jacobian
	)

protectedvirtual

Use finite differences to calculate the Jacobian entries corresponding to the solid positions. This version assumes that the residuals vector has already been computed

This function calculates the entries of Jacobian matrix, used in the Newton method, associated with the elastic problem in which the nodal position is a variable. It does this using finite differences, rather than an analytical formulation, so can be done in total generality.

Reimplemented in oomph::RefineableSolidElement.

   {
     // Flag to indicate if we use first or second order FD
     // bool use_first_order_fd=false;
  
     // Find the number of nodes
     const unsigned n_node = nnode();
  
     // If there aren't any nodes, then return straight away
     if (n_node == 0)
     {
       return;
     }
  
     // Call the update function to ensure that the element is in
     // a consistent state before finite differencing starts
     update_before_solid_position_fd();
  
     // Get the number of position dofs and dimensions at the node
     const unsigned n_position_type = nnodal_position_type();
     const unsigned nodal_dim = nodal_dimension();
  
     // Find the number of dofs in the element
     const unsigned n_dof = this->ndof();
  
     // Create newres vectors
     Vector<double> newres(n_dof);
     // Vector<double> newres_minus(n_dof);
  
     // Integer storage for local unknown
     int local_unknown = 0;
  
     // Should probably give this a more global scope
     const double fd_step = Default_fd_jacobian_step;
  
     // Loop over the nodes
     for (unsigned n = 0; n < n_node; n++)
     {
       // Loop over position dofs
       for (unsigned k = 0; k < n_position_type; k++)
       {
         // Loop over dimension
         for (unsigned i = 0; i < nodal_dim; i++)
         {
           // If the variable is free
           local_unknown = position_local_eqn(n, k, i);
           if (local_unknown >= 0)
           {
             // Store a pointer to the (generalised) Eulerian nodal position
             double* const value_pt = &(node_pt(n)->x_gen(k, i));
  
             // Save the old value of the (generalised) Eulerian nodal position
             const double old_var = *value_pt;
  
             // Increment the (generalised) Eulerian nodal position
             *value_pt += fd_step;
  
             // Perform any auxialiary node updates
             node_pt(n)->perform_auxiliary_node_update_fct();
  
             // Update any other dependent variables
             update_in_solid_position_fd(n);
  
             // Calculate the new residuals
             get_residuals(newres);
  
             //          if (use_first_order_fd)
             {
               // Do forward finite differences
               for (unsigned m = 0; m < n_dof; m++)
               {
                 // Stick the entry into the Jacobian matrix
                 jacobian(m, local_unknown) =
                   (newres[m] - residuals[m]) / fd_step;
               }
             }
             //           else
             //            {
             //             //Take backwards step for the  (generalised) Eulerian
             //             nodal
             //             // position
             //             node_pt(n)->x_gen(k,i) = old_var-fd_step;
  
             //             //Calculate the new residuals at backward position
             //             get_residuals(newres_minus);
  
             //             //Do central finite differences
             //             for(unsigned m=0;m<n_dof;m++)
             //              {
             //               //Stick the entry into the Jacobian matrix
             //               jacobian(m,local_unknown) =
             //                (newres[m] - newres_minus[m])/(2.0*fd_step);
             //              }
             //            }
  
             // Reset the (generalised) Eulerian nodal position
             *value_pt = old_var;
  
  
             // Perform any auxialiary node updates
             node_pt(n)->perform_auxiliary_node_update_fct();
  
             // Reset any other dependent variables
             reset_in_solid_position_fd(n);
           }
         }
       }
     }
  
     // End of finite difference loop
     // Final reset of any dependent data
     reset_after_solid_position_fd();
   }

References oomph::GeneralisedElement::Default_fd_jacobian_step, oomph::GeneralisedElement::get_residuals(), i, k, m, n, oomph::GeneralisedElement::ndof(), oomph::FiniteElement::nnodal_position_type(), oomph::FiniteElement::nnode(), oomph::FiniteElement::nodal_dimension(), oomph::FiniteElement::node_pt(), oomph::Node::perform_auxiliary_node_update_fct(), position_local_eqn(), reset_after_solid_position_fd(), reset_in_solid_position_fd(), update_before_solid_position_fd(), update_in_solid_position_fd(), and oomph::Node::x_gen().

◆ fill_in_residuals_for_solid_ic()

void oomph::SolidFiniteElement::fill_in_residuals_for_solid_ic ( Vector< double > & residuals )

inline

Fill in the residuals for the setup of an initial condition. The global equations are:

\[ 0 = \int \left( \sum_{j=1}^N \sum_{k=1}^K X_{ijk} \psi_{jk}(\xi_n) - \frac{\partial^D R^{(IC)}_i(\xi_n)}{\partial t^D} \right) \psi_{lm}(\xi_n) \ dv \mbox{ \ \ \ \ for \ \ \ $l=1,...,N, \ \ m=1,...,K$} \]

where $ N $ is the number of nodes in the mesh and $ K $ the number of generalised nodal coordinates. The initial shape of the solid body, $ {\bf R}^{(IC)},$ and its time-derivatives are specified via the GeomObject that is stored in the SolidFiniteElement::SolidInitialCondition object. The latter also stores the order of the time-derivative $ D $ to be assigned.

     {
       // Call the generic residuals function with flag set to 0
       // using a dummy matrix argument
       fill_in_generic_jacobian_for_solid_ic(
         residuals, GeneralisedElement::Dummy_matrix, 0);
     }

References oomph::GeneralisedElement::Dummy_matrix, and fill_in_generic_jacobian_for_solid_ic().

Referenced by oomph::KirchhoffLoveBeamEquations::fill_in_contribution_to_residuals_beam(), and get_residuals_for_solid_ic().

◆ geom_data_pt()

Data* oomph::SolidFiniteElement::geom_data_pt ( const unsigned & j )

inlinevirtual

Return pointer to the j-th Data item that the object's shape depends on. (Redirects to the nodes' positional Data).

Reimplemented from oomph::FiniteElement.

Reimplemented in oomph::RefineableSolidElement.

     {
       return static_cast<SolidNode*>(node_pt(j))->variable_position_pt();
     }

References j, and oomph::FiniteElement::node_pt().

Referenced by oomph::ImposeDisplacementByLagrangeMultiplierElement< ELEMENT >::set_boundary_shape_geom_object_pt().

◆ get_residuals_for_solid_ic()

virtual void oomph::SolidFiniteElement::get_residuals_for_solid_ic ( Vector< double > & residuals )

inlinevirtual

Compute the residuals for the setup of an initial condition. The global equations are:

\[ 0 = \int \left( \sum_{j=1}^N \sum_{k=1}^K X_{ijk} \psi_{jk}(\xi_n) - \frac{\partial^D R^{(IC)}_i(\xi_n)}{\partial t^D} \right) \psi_{lm}(\xi_n) \ dv \mbox{ \ \ \ \ for \ \ \ $l=1,...,N, \ \ m=1,...,K$} \]

where $ N $ is the number of nodes in the mesh and $ K $ the number of generalised nodal coordinates. The initial shape of the solid body, $ {\bf R}^{(IC)},$ and its time-derivatives are specified via the GeomObject that is stored in the SolidFiniteElement::SolidInitialCondition object. The latter also stores the order of the time-derivative $ D $ to be assigned.

     {
       residuals.initialise(0.0);
       fill_in_residuals_for_solid_ic(residuals);
     }

References fill_in_residuals_for_solid_ic(), and oomph::Vector< _Tp >::initialise().

Referenced by oomph::RefineableQDPVDElement< DIM, NNODE_1D >::fill_in_generic_contribution_to_residuals_pvd().

◆ get_x_and_xi()

virtual void oomph::SolidFiniteElement::get_x_and_xi	(	const Vector< double > &	s,
		Vector< double > &	x_fe,
		Vector< double > &	x,
		Vector< double > &	xi_fe,
		Vector< double > &	xi
	)		const

inlinevirtual

Eulerian and Lagrangian coordinates as function of the local coordinates: The Eulerian position is returned in FE-interpolated form (x_fe) and then in the form obtained from the "current" MacroElement representation (if it exists – if not, x is the same as x_fe). This allows the Domain/MacroElement- based representation to be used to apply displacement boundary conditions exactly. Ditto for the Lagrangian coordinates returned in xi_fe and xi. (Broken virtual – overload in specific geometric element class if you want to use this functionality.)

Reimplemented in oomph::QSolidElementBase.

     {
       throw OomphLibError(
         "get_x_and_xi(...) is not implemented for this element\n",
         OOMPH_CURRENT_FUNCTION,
         OOMPH_EXCEPTION_LOCATION);
     }

References OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

Referenced by oomph::TreeBasedRefineableMeshBase::adapt_mesh(), and oomph::TreeBasedRefineableMeshBase::p_adapt_mesh().

◆ has_internal_solid_data()

virtual bool oomph::SolidFiniteElement::has_internal_solid_data ( )

inlinevirtual

Return whether there is internal solid data (e.g. discontinuous solid pressure). At present, this is used to report an error in setting initial conditions for ElasticProblems which can't handle such cases. The default is false.

Reimplemented in oomph::QPVDElementWithPressure< DIM >, and oomph::AxisymQPVDElementWithPressure.

     {
       return false;
     }

Referenced by oomph::SolidICProblem::backup_original_state(), oomph::SolidICProblem::reset_original_state(), and oomph::SolidICProblem::setup_problem().

◆ identify_geometric_data()

void oomph::SolidFiniteElement::identify_geometric_data ( std::set< Data * > & geometric_data_pt )

inlinevirtual

Specify Data that affects the geometry of the element by adding the position Data to the set that's passed in. (This functionality is required in FSI problems; set is used to avoid double counting).

Reimplemented from oomph::FiniteElement.

Reimplemented in oomph::RefineableSolidElement, oomph::PseudoSolidNodeUpdateElement< TCrouzeixRaviartElement< 2 >, TPVDBubbleEnrichedElement< 2, 3 > >, oomph::PseudoSolidNodeUpdateElement< TTaylorHoodElement< 2 >, TPVDElement< 2, 3 > >, oomph::PseudoSolidNodeUpdateElement< GeneralisedNewtonianAxisymmetricTTaylorHoodElement, TPVDElement< 2, 3 > >, oomph::PseudoSolidNodeUpdateElement< AxisymmetricTTaylorHoodElement, TPVDElement< 2, 3 > >, and oomph::PseudoSolidNodeUpdateElement< GeneralisedNewtonianTTaylorHoodElement< 2 >, TPVDElement< 2, 3 > >.

     {
       // Loop over the node update data and add to the set
       const unsigned n_node = this->nnode();
       for (unsigned n = 0; n < n_node; n++)
       {
         geometric_data_pt.insert(
           dynamic_cast<SolidNode*>(this->node_pt(n))->variable_position_pt());
       }
     }

References n, oomph::FiniteElement::nnode(), and oomph::FiniteElement::node_pt().

◆ interpolated_dxids()

void oomph::SolidFiniteElement::interpolated_dxids	(	const Vector< double > &	s,
		DenseMatrix< double > &	dxids
	)		const

virtual

Compute derivatives of FE-interpolated Lagrangian coordinates xi with respect to local coordinates: dxids[i][j]=dxi_i/ds_j.

Compute derivatives of FE-interpolated Lagrangian coordinates xi with respect to local coordinates: dxids[i][j]=dxi_i/ds_j

   {
     // Find the number of nodes
     const unsigned n_node = nnode();
  
     // Find the number of lagrangian types from the first node
     const unsigned n_lagrangian_type = nnodal_lagrangian_type();
  
     // Dimension of the element =  number of local coordinates
     unsigned el_dim = dim();
  
     // Assign storage for the local shape function
     Shape psi(n_node, n_lagrangian_type);
     DShape dpsi(n_node, n_lagrangian_type, el_dim);
  
     // Find the values of shape function and its derivs w.r.t. to local coords
     dshape_local(s, psi, dpsi);
  
     // Read out the number of lagrangian coordinates from the node
     const unsigned n_lagrangian = lagrangian_dimension();
  
     // Loop over the number of lagrangian and local coordinates
     for (unsigned i = 0; i < n_lagrangian; i++)
     {
       for (unsigned j = 0; j < el_dim; j++)
       {
         // Initialise component to zero
         dxids(i, j) = 0.0;
  
         // Loop over the local nodes
         for (unsigned l = 0; l < n_node; l++)
         {
           // Loop over the number of dofs
           for (unsigned k = 0; k < n_lagrangian_type; k++)
           {
             dxids(i, j) += lagrangian_position_gen(l, k, i) * dpsi(l, k, j);
           }
         }
       }
     }
   }

References oomph::FiniteElement::dim(), oomph::FiniteElement::dshape_local(), el_dim, i, j, k, lagrangian_dimension(), lagrangian_position_gen(), nnodal_lagrangian_type(), oomph::FiniteElement::nnode(), and s.

◆ interpolated_xi() [1/2]

double oomph::SolidFiniteElement::interpolated_xi	(	const Vector< double > &	s,
		const unsigned &	i
	)		const

virtual

Return i-th FE-interpolated Lagrangian coordinate xi[i] at local coordinate s.

Return i-th FE-interpolated Lagrangian coordinate at local coordinate s.

Reimplemented in oomph::SolidFaceElement.

   {
     // Find the number of nodes
     const unsigned n_node = nnode();
  
     // Find the number of lagrangian types from the first node
     const unsigned n_lagrangian_type = nnodal_lagrangian_type();
  
     // Assign storage for the local shape function
     Shape psi(n_node, n_lagrangian_type);
  
     // Find the values of shape function
     shape(s, psi);
  
     // Initialise value of xi
     double interpolated_xi = 0.0;
  
     // Loop over the local nodes
     for (unsigned l = 0; l < n_node; l++)
     {
       // Loop over the number of dofs
       for (unsigned k = 0; k < n_lagrangian_type; k++)
       {
         interpolated_xi += lagrangian_position_gen(l, k, i) * psi(l, k);
       }
     }
  
     return (interpolated_xi);
   }

References i, k, lagrangian_position_gen(), nnodal_lagrangian_type(), oomph::FiniteElement::nnode(), s, and oomph::FiniteElement::shape().

Referenced by compute_norm(), oomph::AxisymmetricPVDEquations::compute_physical_size(), oomph::AxisymmetricPVDEquationsWithPressure::compute_physical_size(), AirwayReopeningProblem< ELEMENT >::connect_walls(), DiskShockWaveProblem< ELEMENT, TIMESTEPPER >::doc_solution(), CantileverProblem< ELEMENT >::doc_solution(), DiskOscillationProblem< ELEMENT >::doc_solution(), FSIChannelWithLeafletProblem< ELEMENT >::doc_solution(), oomph::AxisymmetricPVDEquations::fill_in_contribution_to_residuals_axisym_pvd(), oomph::KirchhoffLoveBeamEquations::fill_in_contribution_to_residuals_beam(), oomph::KirchhoffLoveShellEquations::fill_in_contribution_to_residuals_shell(), oomph::RefineableQDPVDElement< DIM, NNODE_1D >::fill_in_generic_contribution_to_residuals_pvd(), oomph::AxisymmetricPVDEquationsWithPressure::fill_in_generic_residual_contribution_axisym_pvd_with_pressure(), fill_in_jacobian_for_newmark_accel(), FSICollapsibleChannelProblem< ELEMENT >::FSICollapsibleChannelProblem(), oomph::KirchhoffLoveShellEquations::get_energy(), oomph::KirchhoffLoveBeamEquations::get_energy(), oomph::KirchhoffLoveShellEquations::get_strain_and_bend(), oomph::QSolidElementBase::get_x_and_xi(), oomph::AxisymmetricPVDEquations::output(), oomph::AxisymDiagHermitePVDElement::output(), oomph::AxisymmetricPVDEquationsWithPressure::output(), oomph::HermiteBeamElement::output(), oomph::HermiteShellElement::output(), oomph::ClampedHermiteShellBoundaryConditionElement::output(), PlateProblem< ELEMENT >::PlateProblem(), and ShellProblem< ELEMENT >::ShellProblem().

◆ interpolated_xi() [2/2]

void oomph::SolidFiniteElement::interpolated_xi	(	const Vector< double > &	s,
		Vector< double > &	xi
	)		const

virtual

Compute FE interpolated Lagrangian coordinate vector xi[] at local coordinate s as Vector

Compute FE-interpolated Lagrangian coordinate vector xi[] at local coordinate s.

Reimplemented in oomph::SolidFaceElement.

   {
     // Find the number of nodes
     const unsigned n_node = nnode();
  
     // Find the number of lagrangian types from the first node
     const unsigned n_lagrangian_type = nnodal_lagrangian_type();
  
     // Assign storage for the local shape function
     Shape psi(n_node, n_lagrangian_type);
  
     // Find the values of shape function
     shape(s, psi);
  
     // Read out the number of lagrangian coordinates from the node
     const unsigned n_lagrangian = lagrangian_dimension();
  
     // Loop over the number of lagrangian coordinates
     for (unsigned i = 0; i < n_lagrangian; i++)
     {
       // Initialise component to zero
       xi[i] = 0.0;
  
       // Loop over the local nodes
       for (unsigned l = 0; l < n_node; l++)
       {
         // Loop over the number of dofs
         for (unsigned k = 0; k < n_lagrangian_type; k++)
         {
           xi[i] += lagrangian_position_gen(l, k, i) * psi(l, k);
         }
       }
     }
   }

References i, k, lagrangian_dimension(), lagrangian_position_gen(), nnodal_lagrangian_type(), oomph::FiniteElement::nnode(), s, and oomph::FiniteElement::shape().

◆ J_lagrangian()

virtual void oomph::SolidFiniteElement::J_lagrangian ( const Vector< double > & s ) const

inlinevirtual

Return the Jacobian of mapping from local to Lagrangian coordinates at local position s. NOT YET IMPLEMENTED

     {
       // Must be implemented and overloaded in FaceElements
       throw OomphLibError("Function not implemented yet",
                           OOMPH_CURRENT_FUNCTION,
                           OOMPH_EXCEPTION_LOCATION);
     }

References OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

◆ J_lagrangian_at_knot()

virtual double oomph::SolidFiniteElement::J_lagrangian_at_knot ( const unsigned & ipt ) const

inlinevirtual

Return the Jacobian of the mapping from local to Lagrangian coordinates at the ipt-th integration point. NOT YET IMPLEMENTED

     {
       // Must be implemented and overloaded in FaceElements
       throw OomphLibError("Function not implemented yet",
                           OOMPH_CURRENT_FUNCTION,
                           OOMPH_EXCEPTION_LOCATION);
     }

References OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

◆ lagrangian_dimension()

unsigned oomph::SolidFiniteElement::lagrangian_dimension ( ) const

inline

Return the number of Lagrangian coordinates that the element requires at all nodes. This is by default the elemental dimension. If we ever need any other case, it can be implemented.

     {
       return Lagrangian_dimension;
     }

References Lagrangian_dimension.

Referenced by construct_boundary_node(), construct_node(), interpolated_dxids(), interpolated_xi(), and set_lagrangian_dimension().

◆ lagrangian_position()

double oomph::SolidFiniteElement::lagrangian_position	(	const unsigned &	n,
		const unsigned &	i
	)		const

inline

Return i-th Lagrangian coordinate at local node n.

     {
       return static_cast<SolidNode*>(node_pt(n))->lagrangian_position(i);
     }

References i, n, and oomph::FiniteElement::node_pt().

Referenced by oomph::ImposeDisplacementByLagrangeMultiplierElement< ELEMENT >::fill_in_generic_contribution_to_residuals_displ_lagr_multiplier(), oomph::FSIImposeDisplacementByLagrangeMultiplierElement< ELEMENT >::fill_in_generic_contribution_to_residuals_fsi_displ_lagr_multiplier(), oomph::RefineableImposeDisplacementByLagrangeMultiplierElement< ELEMENT >::refineable_fill_in_generic_contribution_to_residuals_displ_lagr_multiplier(), oomph::RefineableFSIImposeDisplacementByLagrangeMultiplierElement< ELEMENT >::refineable_fill_in_generic_contribution_to_residuals_fsi_displ_lagr_multiplier(), and oomph::ImposeDisplacementByLagrangeMultiplierElement< ELEMENT >::square_of_l2_norm_of_error().

◆ lagrangian_position_gen()

double oomph::SolidFiniteElement::lagrangian_position_gen	(	const unsigned &	n,
		const unsigned &	k,
		const unsigned &	i
	)		const

inline

Return Generalised Lagrangian coordinate at local node n. ‘Direction’ i, ‘Type’ k.

     {
       return static_cast<SolidNode*>(node_pt(n))->lagrangian_position_gen(k, i);
     }

References i, k, n, and oomph::FiniteElement::node_pt().

Referenced by oomph::RefineableSolidElement::assemble_local_to_lagrangian_jacobian(), oomph::RefineableSolidElement::assemble_local_to_lagrangian_jacobian2(), oomph::AxisymmetricPVDEquations::compute_physical_size(), oomph::AxisymmetricPVDEquationsWithPressure::compute_physical_size(), oomph::AxisymmetricPVDEquations::fill_in_contribution_to_residuals_axisym_pvd(), oomph::RefineableQDPVDElement< DIM, NNODE_1D >::fill_in_generic_contribution_to_residuals_pvd(), fill_in_generic_jacobian_for_solid_ic(), oomph::AxisymmetricPVDEquationsWithPressure::fill_in_generic_residual_contribution_axisym_pvd_with_pressure(), oomph::KirchhoffLoveShellEquations::get_energy(), interpolated_dxids(), interpolated_xi(), oomph::KirchhoffLoveShellEquations::load_rate_of_work(), oomph::RefineableSolidElement::local_to_lagrangian_mapping_diagonal(), and zeta_nodal().

◆ local_to_lagrangian_mapping() [1/2]

double oomph::SolidFiniteElement::local_to_lagrangian_mapping	(	const DShape &	dpsids,
		DenseMatrix< double > &	inverse_jacobian
	)		const

inlineprotected

Calculate the mapping from local to lagrangian coordinates, given the derivatives of the shape functions w.r.t. local coordinates, Return only the determinant of the jacobian and the inverse of the mapping (ds/dx)

     {
       // Find the dimension of the element
       unsigned el_dim = dim();
       // Assign memory for the jacobian
       DenseMatrix<double> jacobian(el_dim);
       // Calculate the jacobian and inverse
       return local_to_lagrangian_mapping(dpsids, jacobian, inverse_jacobian);
     }

References oomph::FiniteElement::dim(), el_dim, and local_to_lagrangian_mapping().

◆ local_to_lagrangian_mapping() [2/2]

virtual double oomph::SolidFiniteElement::local_to_lagrangian_mapping	(	const DShape &	dpsids,
		DenseMatrix< double > &	jacobian,
		DenseMatrix< double > &	inverse_jacobian
	)		const

inlineprotectedvirtual

Calculate the mapping from local to lagrangian coordinates, given the derivatives of the shape functions w.r.t. local coorindates. Return the determinant of the jacobian, the jacobian and inverse jacobian

Reimplemented in oomph::SolidDiagQHermiteElement< DIM >, oomph::SolidDiagQHermiteElement< 1 >, and oomph::SolidDiagQHermiteElement< 2 >.

     {
       // Assemble the jacobian
       assemble_local_to_lagrangian_jacobian(dpsids, jacobian);
       // Invert the jacobian
       return invert_jacobian_mapping(jacobian, inverse_jacobian);
     }

References assemble_local_to_lagrangian_jacobian(), and oomph::FiniteElement::invert_jacobian_mapping().

Referenced by d2shape_lagrangian(), d2shape_lagrangian_at_knot(), dshape_lagrangian(), dshape_lagrangian_at_knot(), and local_to_lagrangian_mapping().

◆ local_to_lagrangian_mapping_diagonal()

double oomph::SolidFiniteElement::local_to_lagrangian_mapping_diagonal	(	const DShape &	dpsids,
		DenseMatrix< double > &	jacobian,
		DenseMatrix< double > &	inverse_jacobian
	)		const

protectedvirtual

Calculate the mapping from local to Lagrangian coordinates given the derivatives of the shape functions w.r.t the local coorindates. assuming that the coordinates are aligned in the direction of the local coordinates, i.e. there are no cross terms and the jacobian is diagonal. This function returns the determinant of the jacobian, the jacobian and the inverse jacobian.

Calculate the mapping from local to lagrangian coordinates assuming that the coordinates are aligned in the direction of the local coordinates, i.e. there are no cross terms and the jacobian is diagonal. The local derivatives are passed as dpsids and the jacobian and inverse jacobian are returned.

Reimplemented in oomph::RefineableSolidElement.

   {
     // Find the dimension of the element
     const unsigned el_dim = dim();
     // Find the number of shape functions and shape functions types
     // We shall ASSUME (ENFORCE) that Lagrangian coordinates must
     // be interpolated through the nodes
     const unsigned n_shape = nnode();
     const unsigned n_shape_type = nnodal_lagrangian_type();
  
     // In this case we assume that there are no cross terms, that is
     // global coordinate 0 is always in the direction of local coordinate 0
  
     // Loop over the coordinates
     for (unsigned i = 0; i < el_dim; i++)
     {
       // Zero the jacobian and inverse jacobian entries
       for (unsigned j = 0; j < el_dim; j++)
       {
         jacobian(i, j) = 0.0;
         inverse_jacobian(i, j) = 0.0;
       }
  
       // Loop over the shape functions
       for (unsigned l = 0; l < n_shape; l++)
       {
         // Loop over the types of dof
         for (unsigned k = 0; k < n_shape_type; k++)
         {
           // Derivatives are always dx_{i}/ds_{i}
           jacobian(i, i) +=
             raw_lagrangian_position_gen(l, k, i) * dpsids(l, k, i);
         }
       }
     }
  
     // Now calculate the determinant of the matrix
     double det = 1.0;
     for (unsigned i = 0; i < el_dim; i++)
     {
       det *= jacobian(i, i);
     }
  
 // Report if Matrix is singular, or negative
 #ifdef PARANOID
     check_jacobian(det);
 #endif
  
     // Calculate the inverse mapping (trivial in this case)
     for (unsigned i = 0; i < el_dim; i++)
     {
       inverse_jacobian(i, i) = 1.0 / jacobian(i, i);
     }
  
     // Return the value of the Jacobian
     return (det);
   }

References oomph::FiniteElement::check_jacobian(), oomph::FiniteElement::dim(), el_dim, i, j, k, nnodal_lagrangian_type(), oomph::FiniteElement::nnode(), and raw_lagrangian_position_gen().

Referenced by oomph::SolidDiagQHermiteElement< DIM >::local_to_lagrangian_mapping().

◆ multiplier()

double oomph::SolidFiniteElement::multiplier ( const Vector< double > & xi )

inlineprivate

Access to the "multiplier" for the inertia terms in the consistent determination of the initial conditions for Newmark timestepping.

     {
       // If no function has been set, return 1
       if (Multiplier_fct_pt == 0)
       {
         return 1.0;
       }
       else
       {
         // Evaluate function pointer
         return (*Multiplier_fct_pt)(xi);
       }
     }

References Multiplier_fct_pt.

Referenced by fill_in_jacobian_for_newmark_accel().

◆ multiplier_fct_pt() [1/2]

MultiplierFctPt& oomph::SolidFiniteElement::multiplier_fct_pt ( )

inline

Access function: Pointer to multiplicator function for assignment of consistent assignement of initial conditions for Newmark scheme

     {
       return Multiplier_fct_pt;
     }

References Multiplier_fct_pt.

Referenced by oomph::SolidICProblem::set_newmark_initial_condition_consistently().

◆ multiplier_fct_pt() [2/2]

MultiplierFctPt oomph::SolidFiniteElement::multiplier_fct_pt ( ) const

inline

Access function: Pointer to multiplicator function for assignment of consistent assignement of initial conditions for Newmark scheme (const version)

     {
       return Multiplier_fct_pt;
     }

References Multiplier_fct_pt.

◆ ngeom_data()

unsigned oomph::SolidFiniteElement::ngeom_data ( ) const

inlinevirtual

Broken assignment operator.

The number of geometric data affecting a SolidFiniteElemnet is the same as the number of nodes (one variable position data per node)

Reimplemented from oomph::FiniteElement.

Reimplemented in oomph::RefineableSolidElement.

     {
       return nnode();
     }

References oomph::FiniteElement::nnode().

◆ nnodal_lagrangian_type()

unsigned oomph::SolidFiniteElement::nnodal_lagrangian_type ( ) const

inline

Return the number of types of (generalised) nodal Lagrangian coordinates required to interpolate the Lagrangian coordinates in the element. (E.g. 1 for Lagrange-type elements; 2 for Hermite beam elements; 4 for Hermite shell elements). Default value is 1. Needs to be overloaded for any other element.

     {
       return Nnodal_lagrangian_type;
     }

References Nnodal_lagrangian_type.

Referenced by assemble_local_to_lagrangian_jacobian(), oomph::RefineableSolidElement::assemble_local_to_lagrangian_jacobian(), assemble_local_to_lagrangian_jacobian2(), oomph::RefineableSolidElement::assemble_local_to_lagrangian_jacobian2(), construct_boundary_node(), construct_node(), fill_in_generic_jacobian_for_solid_ic(), interpolated_dxids(), interpolated_xi(), local_to_lagrangian_mapping_diagonal(), and oomph::RefineableSolidElement::local_to_lagrangian_mapping_diagonal().

◆ position_local_eqn()

int oomph::SolidFiniteElement::position_local_eqn	(	const unsigned &	n,
		const unsigned &	k,
		const unsigned &	j
	)		const

inline

Access function that returns the local equation number that corresponds to the j-th coordinate of the k-th position-type at the n-th local node.

     {
 #ifdef RANGE_CHECKING
       std::ostringstream error_message;
       bool error = false;
       if (n >= nnode())
       {
         error = true;
         error_message << "Range Error: Nodal number " << n
                       << " is not in the range (0," << nnode() << ")";
       }
  
       if (k >= nnodal_position_type())
       {
         error = true;
         error_message << "Range Error: Position type " << k
                       << " is not in the range (0," << nnodal_position_type()
                       << ")";
       }
  
       if (j >= nodal_dimension())
       {
         error = true;
         error_message << "Range Error: Nodal coordinate " << j
                       << " is not in the range (0," << nodal_dimension() << ")";
       }
  
       if (error)
       {
         // Throw the error
         throw OomphLibError(error_message.str(),
                             OOMPH_CURRENT_FUNCTION,
                             OOMPH_EXCEPTION_LOCATION);
       }
 #endif
  
       // Return the value
       return Position_local_eqn[(n * nnodal_position_type() + k) *
                                   nodal_dimension() +
                                 j];
     }

References calibrate::error, j, k, n, oomph::FiniteElement::nnodal_position_type(), oomph::FiniteElement::nnode(), oomph::FiniteElement::nodal_dimension(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and Position_local_eqn.

Referenced by oomph::RefineableSolidElement::assign_solid_hanging_local_eqn_numbers(), oomph::ClampedSlidingHermiteBeamBoundaryConditionElement::fill_in_contribution_to_residuals(), oomph::ClampedHermiteShellBoundaryConditionElement::fill_in_contribution_to_residuals(), oomph::AxisymmetricPVDEquations::fill_in_contribution_to_residuals_axisym_pvd(), oomph::KirchhoffLoveBeamEquations::fill_in_contribution_to_residuals_beam(), oomph::KirchhoffLoveShellEquations::fill_in_contribution_to_residuals_shell(), oomph::ImposeDisplacementByLagrangeMultiplierElement< ELEMENT >::fill_in_generic_contribution_to_residuals_displ_lagr_multiplier(), oomph::FSIImposeDisplacementByLagrangeMultiplierElement< ELEMENT >::fill_in_generic_contribution_to_residuals_fsi_displ_lagr_multiplier(), oomph::RefineableQDPVDElement< DIM, NNODE_1D >::fill_in_generic_contribution_to_residuals_pvd(), fill_in_generic_jacobian_for_solid_ic(), oomph::AxisymmetricPVDEquationsWithPressure::fill_in_generic_residual_contribution_axisym_pvd_with_pressure(), fill_in_jacobian_for_newmark_accel(), fill_in_jacobian_from_solid_position_by_fd(), oomph::RefineableSolidElement::fill_in_jacobian_from_solid_position_by_fd(), oomph::FSIHermiteBeamElement::get_dof_numbers_for_unknowns(), oomph::FSIDiagHermiteShellElement::get_dof_numbers_for_unknowns(), oomph::ClampedHermiteShellBoundaryConditionElement::get_dof_numbers_for_unknowns(), oomph::PVDEquationsBase< DIM >::get_dof_numbers_for_unknowns(), oomph::PVDEquationsWithPressure< DIM >::get_dof_numbers_for_unknowns(), oomph::RefineableImposeDisplacementByLagrangeMultiplierElement< ELEMENT >::refineable_fill_in_generic_contribution_to_residuals_displ_lagr_multiplier(), oomph::RefineableFSIImposeDisplacementByLagrangeMultiplierElement< ELEMENT >::refineable_fill_in_generic_contribution_to_residuals_fsi_displ_lagr_multiplier(), oomph::ProjectableAxisymmetricPoroelasticityElement< AXISYMMETRIC_POROELASTICITY_ELEMENT >::residual_for_projection(), oomph::ProjectableDarcyElement< DARCY_ELEMENT >::residual_for_projection(), and oomph::ProjectableElement< ELEMENT >::residual_for_projection().

◆ raw_lagrangian_position()

double oomph::SolidFiniteElement::raw_lagrangian_position	(	const unsigned &	n,
		const unsigned &	i
	)		const

inline

Return i-th Lagrangian coordinate at local node n without using the hanging representation

     {
       return static_cast<SolidNode*>(node_pt(n))->xi(i);
     }

References i, n, and oomph::FiniteElement::node_pt().

Referenced by oomph::FSIHermiteBeamElement::locate_zeta().

◆ raw_lagrangian_position_gen()

double oomph::SolidFiniteElement::raw_lagrangian_position_gen	(	const unsigned &	n,
		const unsigned &	k,
		const unsigned &	i
	)		const

inline

Return Generalised Lagrangian coordinate at local node n. ‘Direction’ i, ‘Type’ k. Does not use the hanging node representation

     {
       return static_cast<SolidNode*>(node_pt(n))->xi_gen(k, i);
     }

References i, k, n, and oomph::FiniteElement::node_pt().

Referenced by assemble_local_to_lagrangian_jacobian(), assemble_local_to_lagrangian_jacobian2(), oomph::KirchhoffLoveBeamEquations::fill_in_contribution_to_residuals_beam(), oomph::KirchhoffLoveShellEquations::fill_in_contribution_to_residuals_shell(), oomph::KirchhoffLoveBeamEquations::get_energy(), oomph::KirchhoffLoveShellEquations::get_strain_and_bend(), local_to_lagrangian_mapping_diagonal(), and oomph::HermiteBeamElement::output().

◆ reset_after_solid_position_fd()

virtual void oomph::SolidFiniteElement::reset_after_solid_position_fd ( )

inlineprotectedvirtual

Function that is call after the finite differencing of the solid position data. This may be overloaded to reset any dependent variables that may have changed during the finite differencing.

Reimplemented in oomph::FSIWallElement.

4245 {}

Referenced by fill_in_jacobian_from_solid_position_by_fd(), and oomph::RefineableSolidElement::fill_in_jacobian_from_solid_position_by_fd().

◆ reset_in_solid_position_fd()

virtual void oomph::SolidFiniteElement::reset_in_solid_position_fd ( const unsigned & i )

inlineprotectedvirtual

Function called within the finite difference loop for solid position data after the values in the i-th node are reset. The default behaviour is to call the update function.

Reimplemented in oomph::FSIWallElement.

     {
       update_in_solid_position_fd(i);
     }

References i, and update_in_solid_position_fd().

Referenced by fill_in_jacobian_from_solid_position_by_fd(), and oomph::RefineableSolidElement::fill_in_jacobian_from_solid_position_by_fd().

◆ set_lagrangian_dimension()

void oomph::SolidFiniteElement::set_lagrangian_dimension ( const unsigned & lagrangian_dimension )

inline

Set the lagrangian dimension of the element — the number of lagrangian coordinates stored at the nodes in the element.

     {
       Lagrangian_dimension = lagrangian_dimension;
     }

References lagrangian_dimension(), and Lagrangian_dimension.

Referenced by oomph::SolidQHermiteElement< DIM >::SolidQHermiteElement().

◆ set_macro_elem_pt() [1/2]

virtual void oomph::SolidFiniteElement::set_macro_elem_pt ( MacroElement * macro_elem_pt )

inlinevirtual

Set pointer to MacroElement – overloads generic version and uses the MacroElement also as the default for the "undeformed" configuration. This assignment must be overwritten with set_undeformed_macro_elem_pt(...) if the deformation of the solid body is driven by a deformation of the "current" Domain/MacroElement representation of it's boundary. Can be overloaded in derived classes to perform additional tasks

Reimplemented from oomph::FiniteElement.

Reimplemented in oomph::RefineableSolidQElement< 2 >, oomph::RefineableSolidQElement< 1 >, oomph::RefineableSolidQElement< 3 >, and oomph::QSolidElementBase.

     {
       Macro_elem_pt = macro_elem_pt;
       Undeformed_macro_elem_pt = macro_elem_pt;
     }

References oomph::FiniteElement::Macro_elem_pt, oomph::FiniteElement::macro_elem_pt(), and Undeformed_macro_elem_pt.

◆ set_macro_elem_pt() [2/2]

virtual void oomph::SolidFiniteElement::set_macro_elem_pt	(	MacroElement *	macro_elem_pt,
		MacroElement *	undeformed_macro_elem_pt
	)

inlinevirtual

Set pointers to "current" and "undeformed" MacroElements. Can be overloaded in derived classes to perform additional tasks

Reimplemented in oomph::RefineableSolidQElement< 2 >, oomph::RefineableSolidQElement< 1 >, oomph::RefineableSolidQElement< 3 >, and oomph::QSolidElementBase.

     {
       Macro_elem_pt = macro_elem_pt;
       Undeformed_macro_elem_pt = undeformed_macro_elem_pt;
     }

References oomph::FiniteElement::Macro_elem_pt, oomph::FiniteElement::macro_elem_pt(), undeformed_macro_elem_pt(), and Undeformed_macro_elem_pt.

◆ set_nnodal_lagrangian_type()

void oomph::SolidFiniteElement::set_nnodal_lagrangian_type ( const unsigned & nlagrangian_type )

inlineprotected

Set the number of types required to interpolate the Lagrangian coordinates

     {
       Nnodal_lagrangian_type = nlagrangian_type;
     }

References Nnodal_lagrangian_type.

Referenced by oomph::SolidQHermiteElement< DIM >::SolidQHermiteElement().

◆ set_undeformed_macro_elem_pt()

void oomph::SolidFiniteElement::set_undeformed_macro_elem_pt ( MacroElement * undeformed_macro_elem_pt )

inline

Set pointer to "undeformed" macro element. Can be overloaded in derived classes to perform additional tasks.

     {
       Undeformed_macro_elem_pt = undeformed_macro_elem_pt;
     }

References undeformed_macro_elem_pt(), and Undeformed_macro_elem_pt.

Referenced by oomph::QSolidElementBase::set_macro_elem_pt().

◆ solid_ic_pt()

SolidInitialCondition*& oomph::SolidFiniteElement::solid_ic_pt ( )

inline

Pointer to object that describes the initial condition.

     {
       return Solid_ic_pt;
     }

References Solid_ic_pt.

Referenced by oomph::SolidICProblem::set_newmark_initial_condition_consistently(), and oomph::SolidICProblem::setup_problem().

◆ undeformed_macro_elem_pt()

MacroElement* oomph::SolidFiniteElement::undeformed_macro_elem_pt ( )

inline

Access function to pointer to "undeformed" macro element.

     {
       return Undeformed_macro_elem_pt;
     }

References Undeformed_macro_elem_pt.

Referenced by oomph::TreeBasedRefineableMeshBase::adapt_mesh(), oomph::TreeBasedRefineableMeshBase::p_adapt_mesh(), set_macro_elem_pt(), oomph::QSolidElementBase::set_macro_elem_pt(), and set_undeformed_macro_elem_pt().

◆ update_before_solid_position_fd()

virtual void oomph::SolidFiniteElement::update_before_solid_position_fd ( )

inlineprotectedvirtual

Function that is called before the finite differencing of any solid position data. This may be overloaded to update any dependent data before finite differencing takes place.

4240 {}

Referenced by fill_in_jacobian_from_solid_position_by_fd(), and oomph::RefineableSolidElement::fill_in_jacobian_from_solid_position_by_fd().

◆ update_in_solid_position_fd()

virtual void oomph::SolidFiniteElement::update_in_solid_position_fd ( const unsigned & i )

inlineprotectedvirtual

Function called within the finite difference loop for the solid position dat after a change in any values in the n-th node.

Reimplemented in oomph::FSIWallElement.

4250 {}

Referenced by fill_in_jacobian_from_solid_position_by_fd(), oomph::RefineableSolidElement::fill_in_jacobian_from_solid_position_by_fd(), and reset_in_solid_position_fd().

◆ zeta_nodal()

double oomph::SolidFiniteElement::zeta_nodal	(	const unsigned &	n,
		const unsigned &	k,
		const unsigned &	i
	)		const

inlinevirtual

In a SolidFiniteElement, the "global" intrinsic coordinate of the element when viewed as part of a compound geometric object (a Mesh) is, by default, the Lagrangian coordinate Note the assumption here is that we are always using isoparameteric elements in which the lagrangian coordinate is interpolated by the same shape functions as the eulerian coordinate.

Reimplemented from oomph::FiniteElement.

Reimplemented in oomph::SolidFaceElement.

     {
       return lagrangian_position_gen(n, k, i);
     }

References i, k, lagrangian_position_gen(), and n.

Member Data Documentation

◆ Lagrangian_dimension

unsigned oomph::SolidFiniteElement::Lagrangian_dimension

private

The Lagrangian dimension of the nodes stored in the element, / i.e. the number of Lagrangian coordinates

Referenced by assemble_local_to_lagrangian_jacobian(), lagrangian_dimension(), and set_lagrangian_dimension().

◆ Multiplier_fct_pt

MultiplierFctPt oomph::SolidFiniteElement::Multiplier_fct_pt

private

Pointer to function that computes the "multiplier" for the inertia terms in the consistent determination of the initial conditions for Newmark timestepping.

Referenced by multiplier(), and multiplier_fct_pt().

◆ Nnodal_lagrangian_type

unsigned oomph::SolidFiniteElement::Nnodal_lagrangian_type

private

The number of coordinate types requried to intepolate the Lagrangian coordinates in the element. For Lagrange elements it is 1 (the default). It must be over-ridden by using the set_nlagrangian_type() function in the constructors of elements that use generalised coordinate, e.g. for 1D Hermite elements Nnodal_position_types =2.

Referenced by nnodal_lagrangian_type(), and set_nnodal_lagrangian_type().

◆ Position_local_eqn

int* oomph::SolidFiniteElement::Position_local_eqn

private

Array to hold the local equation number information for the solid equations, whatever they may be.

Referenced by assign_solid_local_eqn_numbers(), position_local_eqn(), and ~SolidFiniteElement().

◆ Solid_ic_pt

SolidInitialCondition* oomph::SolidFiniteElement::Solid_ic_pt

protected

Pointer to object that specifies the initial condition.

Referenced by oomph::PVDEquations< DIM >::fill_in_contribution_to_jacobian(), oomph::PVDEquationsWithPressure< DIM >::fill_in_contribution_to_jacobian(), oomph::PVDEquationsWithPressure< DIM >::fill_in_contribution_to_jacobian_and_mass_matrix(), oomph::KirchhoffLoveBeamEquations::fill_in_contribution_to_residuals_beam(), oomph::RefineableQDPVDElement< DIM, NNODE_1D >::fill_in_generic_contribution_to_residuals_pvd(), fill_in_generic_jacobian_for_solid_ic(), fill_in_jacobian_for_newmark_accel(), and solid_ic_pt().

◆ Solve_for_consistent_newmark_accel_flag

bool oomph::SolidFiniteElement::Solve_for_consistent_newmark_accel_flag

protected

Flag to indicate which system of equations to solve when assigning initial conditions for time-dependent problems. If true, solve for the history value that corresponds to the acceleration in the Newmark scheme by demanding that the PDE is satisifed at the initial time. In this case the Jacobian is replaced by the mass matrix.

Referenced by disable_solve_for_consistent_newmark_accel(), enable_solve_for_consistent_newmark_accel(), oomph::AxisymmetricPVDEquations::fill_in_contribution_to_jacobian(), oomph::KirchhoffLoveBeamEquations::fill_in_contribution_to_jacobian(), fill_in_contribution_to_jacobian(), oomph::FSIWallElement::fill_in_contribution_to_jacobian(), oomph::KirchhoffLoveShellEquations::fill_in_contribution_to_jacobian(), oomph::PVDEquations< DIM >::fill_in_contribution_to_jacobian(), oomph::PVDEquationsWithPressure< DIM >::fill_in_contribution_to_jacobian(), oomph::PVDEquationsWithPressure< DIM >::fill_in_contribution_to_jacobian_and_mass_matrix(), and fill_in_jacobian_for_newmark_accel().

◆ Undeformed_macro_elem_pt

MacroElement* oomph::SolidFiniteElement::Undeformed_macro_elem_pt

protected

Pointer to the element's "undeformed" macro element (NULL by default)

Referenced by oomph::RefineableSolidQElement< 3 >::build(), oomph::RefineableSolidQElement< 2 >::build(), oomph::QSolidElementBase::get_x_and_xi(), set_macro_elem_pt(), set_undeformed_macro_elem_pt(), and undeformed_macro_elem_pt().

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

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ MultiplierFctPt

Constructor & Destructor Documentation

◆ SolidFiniteElement() [1/2]

◆ ~SolidFiniteElement()

◆ SolidFiniteElement() [2/2]

Member Function Documentation

◆ assemble_local_to_lagrangian_jacobian()

◆ assemble_local_to_lagrangian_jacobian2()

◆ assign_all_generic_local_eqn_numbers()

◆ assign_solid_local_eqn_numbers()

◆ compute_norm()

◆ construct_boundary_node() [1/2]

◆ construct_boundary_node() [2/2]

◆ construct_node() [1/2]

◆ construct_node() [2/2]

◆ d2shape_lagrangian()

◆ d2shape_lagrangian_at_knot()

◆ describe_local_dofs()

◆ describe_solid_local_dofs()

◆ disable_solve_for_consistent_newmark_accel()

◆ dshape_lagrangian()

◆ dshape_lagrangian_at_knot()

◆ enable_solve_for_consistent_newmark_accel()

◆ fill_in_contribution_to_jacobian()

◆ fill_in_generic_jacobian_for_solid_ic()

◆ fill_in_jacobian_for_newmark_accel()

◆ fill_in_jacobian_for_solid_ic()

◆ fill_in_jacobian_from_solid_position_by_fd() [1/2]

◆ fill_in_jacobian_from_solid_position_by_fd() [2/2]

◆ fill_in_residuals_for_solid_ic()

◆ geom_data_pt()

◆ get_residuals_for_solid_ic()

◆ get_x_and_xi()

◆ has_internal_solid_data()

◆ identify_geometric_data()

◆ interpolated_dxids()

◆ interpolated_xi() [1/2]

◆ interpolated_xi() [2/2]

◆ J_lagrangian()

◆ J_lagrangian_at_knot()

◆ lagrangian_dimension()

◆ lagrangian_position()

◆ lagrangian_position_gen()

◆ local_to_lagrangian_mapping() [1/2]

◆ local_to_lagrangian_mapping() [2/2]

◆ local_to_lagrangian_mapping_diagonal()

◆ multiplier()

◆ multiplier_fct_pt() [1/2]

◆ multiplier_fct_pt() [2/2]

◆ ngeom_data()

◆ nnodal_lagrangian_type()

◆ position_local_eqn()

◆ raw_lagrangian_position()

◆ raw_lagrangian_position_gen()

◆ reset_after_solid_position_fd()

◆ reset_in_solid_position_fd()

◆ set_lagrangian_dimension()

◆ set_macro_elem_pt() [1/2]

◆ set_macro_elem_pt() [2/2]

◆ set_nnodal_lagrangian_type()

◆ set_undeformed_macro_elem_pt()

◆ solid_ic_pt()

◆ undeformed_macro_elem_pt()

◆ update_before_solid_position_fd()

◆ update_in_solid_position_fd()

◆ zeta_nodal()

Member Data Documentation

◆ Lagrangian_dimension

◆ Multiplier_fct_pt

◆ Nnodal_lagrangian_type

◆ Position_local_eqn