#include <elements.h>

Inheritance diagram for oomph::FaceElement:

Public Member Functions
	FaceElement ()
	Constructor: Initialise all appropriate member data. More...

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

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

const unsigned &	boundary_number_in_bulk_mesh () const
	Broken assignment operator. More...

void	set_boundary_number_in_bulk_mesh (const unsigned &b)
	Set function for the boundary number in bulk mesh. More...

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

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

double	J_eulerian_at_knot (const unsigned &ipt) const

void	check_J_eulerian_at_knots (bool &passed) const

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

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

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

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

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

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

int &	normal_sign ()

int	normal_sign () const

int &	face_index ()

int	face_index () const

const Vector< double > *	tangent_direction_pt () const
	Public access function for the tangent direction pointer. More...

void	set_tangent_direction (Vector< double > *tangent_direction_pt)
	Set the tangent direction vector. More...

void	turn_on_warning_for_discontinuous_tangent ()

void	turn_off_warning_for_discontinuous_tangent ()

void	continuous_tangent_and_outer_unit_normal (const Vector< double > &s, Vector< Vector< double >> &tang_vec, Vector< double > &unit_normal) const

void	continuous_tangent_and_outer_unit_normal (const unsigned &ipt, Vector< Vector< double >> &tang_vec, Vector< double > &unit_normal) const

void	outer_unit_normal (const Vector< double > &s, Vector< double > &unit_normal) const
	Compute outer unit normal at the specified local coordinate. More...

void	outer_unit_normal (const unsigned &ipt, Vector< double > &unit_normal) const
	Compute outer unit normal at ipt-th integration point. More...

FiniteElement *&	bulk_element_pt ()
	Pointer to higher-dimensional "bulk" element. More...

FiniteElement *	bulk_element_pt () const
	Pointer to higher-dimensional "bulk" element (const version) More...

CoordinateMappingFctPt &	face_to_bulk_coordinate_fct_pt ()

CoordinateMappingFctPt	face_to_bulk_coordinate_fct_pt () const

BulkCoordinateDerivativesFctPt &	bulk_coordinate_derivatives_fct_pt ()

BulkCoordinateDerivativesFctPt	bulk_coordinate_derivatives_fct_pt () const

Vector< double >	local_coordinate_in_bulk (const Vector< double > &s) const

void	get_local_coordinate_in_bulk (const Vector< double > &s, Vector< double > &s_bulk) const

void	get_ds_bulk_ds_face (const Vector< double > &s, DenseMatrix< double > &dsbulk_dsface, unsigned &interior_direction) const

unsigned &	bulk_position_type (const unsigned &i)

const unsigned &	bulk_position_type (const unsigned &i) const

void	bulk_node_number_resize (const unsigned &i)
	Resize the storage for the bulk node numbers. More...

unsigned &	bulk_node_number (const unsigned &n)

const unsigned &	bulk_node_number (const unsigned &n) const

void	bulk_position_type_resize (const unsigned &i)
	Resize the storage for bulk_position_type to i entries. More...

unsigned &	nbulk_value (const unsigned &n)

unsigned	nbulk_value (const unsigned &n) const

void	nbulk_value_resize (const unsigned &i)

void	resize_nodes (Vector< unsigned > &nadditional_data_values)

void	output_zeta (std::ostream &outfile, const unsigned &nplot)
	Output boundary coordinate zeta. More...

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)

virtual void	set_macro_elem_pt (MacroElement *macro_elem_pt)

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

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_local_dofs (std::ostream &out, const std::string &current_string) const

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

virtual void	assign_all_generic_local_eqn_numbers (const bool &store_local_dof_pt)

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

virtual Node *	construct_node (const unsigned &n)

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

virtual Node *	construct_boundary_node (const unsigned &n)

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

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

unsigned	ngeom_data () const

Data *	geom_data_pt (const unsigned &j)

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 void	identify_geometric_data (std::set< Data * > &geometric_data_pt)

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 void	compute_norm (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	add_additional_values (const Vector< unsigned > &nadditional_values, const unsigned &id)

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)

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

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
unsigned	Boundary_number_in_bulk_mesh
	The boundary number in the bulk mesh to which this element is attached. More...

FiniteElement *	Bulk_element_pt
	Pointer to the associated higher-dimensional "bulk" element. More...

Vector< unsigned >	Bulk_node_number

Vector< unsigned >	Nbulk_value

Vector< double > *	Tangent_direction_pt

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 Types
typedef void(*	CoordinateMappingFctPt) (const Vector< double > &s, Vector< double > &s_bulk)

typedef void(*	BulkCoordinateDerivativesFctPt) (const Vector< double > &s, DenseMatrix< double > &ds_bulk_dsface, unsigned &interior_direction)

Private Attributes
CoordinateMappingFctPt	Face_to_bulk_coordinate_fct_pt

BulkCoordinateDerivativesFctPt	Bulk_coordinate_derivatives_fct_pt

Vector< unsigned >	Bulk_position_type

int	Normal_sign

int	Face_index
	Index of the face. More...

Static Private Attributes
static bool	Ignore_discontinuous_tangent_warning = false

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

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

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

FaceElements are elements that coincide with the faces of higher-dimensional "bulk" elements. They are used on boundaries where additional non-trivial boundary conditions need to be applied. Examples include free surfaces, and applied traction conditions. In many cases, FaceElements need to evaluate to quantities in the associated bulk elements. For instance, the evaluation of a shear stresses on 2D FaceElement requires the evaluation of velocity derivatives in the associated 3D volume element etc. Therefore we store a pointer to the associated bulk element, and information about the relation between the local coordinates in the face and bulk elements.

Member Typedef Documentation

◆ BulkCoordinateDerivativesFctPt

typedef void(* oomph::FaceElement::BulkCoordinateDerivativesFctPt) (const Vector< double > &s, DenseMatrix< double > &ds_bulk_dsface, unsigned &interior_direction)

private

Typedef for the function that returns the partial derivative of the local coordinates in the bulk element with respect to the coordinates along the face. In addition this function returns an index of one of the bulk local coordinates that varies away from the edge

◆ CoordinateMappingFctPt

typedef void(* oomph::FaceElement::CoordinateMappingFctPt) (const Vector< double > &s, Vector< double > &s_bulk)

private

Typedef for the function that translates the face coordinate to the coordinate in the bulk element

Constructor & Destructor Documentation

◆ FaceElement() [1/2]

oomph::FaceElement::FaceElement ( )

inline

Constructor: Initialise all appropriate member data.

       : Face_to_bulk_coordinate_fct_pt(0),
         Bulk_coordinate_derivatives_fct_pt(0),
         Normal_sign(0),
         Face_index(0),
         Boundary_number_in_bulk_mesh(0),
         Bulk_element_pt(0),
         Tangent_direction_pt(0)
     {
       // Check whether things have been set
 #ifdef PARANOID
       Boundary_number_in_bulk_mesh_has_been_set = false;
 #endif
  
       // Bulk_position_type[0] is always 0 (the position)
       Bulk_position_type.push_back(0);
     }

References Bulk_position_type.

◆ ~FaceElement()

virtual oomph::FaceElement::~FaceElement ( )

inlinevirtual

Empty virtual destructor.

4465 {}

◆ FaceElement() [2/2]

oomph::FaceElement::FaceElement ( const FaceElement & )

delete

Broken copy constructor.

Member Function Documentation

◆ add_additional_values()

void oomph::FaceElement::add_additional_values	(	const Vector< unsigned > &	nadditional_values,
		const unsigned &	id
	)

inlineprotected

Helper function adding additional values for the unknowns associated with the FaceElement. This function also sets the map containing the position of the first entry of this face element's additional values.The inputs are the number of additional values and the face element's ID. Note the same number of additonal values are allocated at ALL nodes.

     {
       // How many nodes?
       const unsigned n_node = nnode();
  
       // loop over the nodes
       for (unsigned n = 0; n < n_node; n++)
       {
         // Assign the required number of additional nodes to the node
         dynamic_cast<BoundaryNodeBase*>(this->node_pt(n))
           ->assign_additional_values_with_face_id(nadditional_values[n], id);
       }
     }

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

Referenced by oomph::FSIImposeDisplacementByLagrangeMultiplierElement< ELEMENT >::FSIImposeDisplacementByLagrangeMultiplierElement(), oomph::ImposeDisplacementByLagrangeMultiplierElement< ELEMENT >::ImposeDisplacementByLagrangeMultiplierElement(), oomph::ImposeImpenetrabilityElement< ELEMENT >::ImposeImpenetrabilityElement(), oomph::ImposeParallelOutflowElement< ELEMENT >::ImposeParallelOutflowElement(), oomph::LinearisedAxisymPoroelasticBJS_FSIElement< FLUID_BULK_ELEMENT, POROELASTICITY_BULK_ELEMENT >::LinearisedAxisymPoroelasticBJS_FSIElement(), oomph::LinearisedFSIAxisymmetricNStNoSlipBCElementElement< FLUID_BULK_ELEMENT, SOLID_BULK_ELEMENT >::LinearisedFSIAxisymmetricNStNoSlipBCElementElement(), oomph::SurfaceContactElementBase< ELEMENT >::SurfaceContactElementBase(), oomph::SurfaceMeltElement< ELEMENT >::SurfaceMeltElement(), and oomph::UnsteadyHeatFluxPseudoMeltElement< ELEMENT >::UnsteadyHeatFluxPseudoMeltElement().

◆ boundary_number_in_bulk_mesh()

const unsigned& oomph::FaceElement::boundary_number_in_bulk_mesh ( ) const

inline

Broken assignment operator.

Access function for the boundary number in bulk mesh

     {
       return Boundary_number_in_bulk_mesh;
     }

References Boundary_number_in_bulk_mesh.

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

◆ bulk_coordinate_derivatives_fct_pt() [1/2]

BulkCoordinateDerivativesFctPt& oomph::FaceElement::bulk_coordinate_derivatives_fct_pt ( )

inline

Return the pointer to the function that returns the derivatives of the bulk coordinates wrt the face coordinates

     {
       return Bulk_coordinate_derivatives_fct_pt;
     }

References Bulk_coordinate_derivatives_fct_pt.

Referenced by oomph::FiniteElement::build_face_element(), oomph::QHermiteElement< DIM >::build_face_element(), oomph::QSpectralElement< 1, NNODE_1D >::build_face_element(), oomph::QSpectralElement< 2, NNODE_1D >::build_face_element(), oomph::QSpectralElement< 3, NNODE_1D >::build_face_element(), oomph::TElement< 1, NNODE_1D >::build_face_element(), and oomph::TElement< 2, NNODE_1D >::build_face_element().

◆ bulk_coordinate_derivatives_fct_pt() [2/2]

BulkCoordinateDerivativesFctPt oomph::FaceElement::bulk_coordinate_derivatives_fct_pt ( ) const

inline

Return the pointer to the function that returns the derivatives of the bulk coordinates wrt the face coordinates (const version)

     {
       return Bulk_coordinate_derivatives_fct_pt;
     }

References Bulk_coordinate_derivatives_fct_pt.

◆ bulk_element_pt() [1/2]

FiniteElement*& oomph::FaceElement::bulk_element_pt ( )

inline

Pointer to higher-dimensional "bulk" element.

     {
       return Bulk_element_pt;
     }

References Bulk_element_pt.

◆ bulk_element_pt() [2/2]

FiniteElement* oomph::FaceElement::bulk_element_pt ( ) const

inline

Pointer to higher-dimensional "bulk" element (const version)

     {
       return Bulk_element_pt;
     }

References Bulk_element_pt.

◆ bulk_node_number() [1/2]

unsigned& oomph::FaceElement::bulk_node_number ( const unsigned & n )

inline

Return the bulk node number that corresponds to the n-th local node number

     {
       return Bulk_node_number[n];
     }

References Bulk_node_number, and n.

Referenced by oomph::DGFaceElement::add_flux_contributions(), oomph::FiniteElement::build_face_element(), oomph::QHermiteElement< DIM >::build_face_element(), oomph::QSpectralElement< 1, NNODE_1D >::build_face_element(), oomph::QSpectralElement< 2, NNODE_1D >::build_face_element(), oomph::TBubbleEnrichedElement< DIM, NNODE_1D >::build_face_element(), oomph::TElement< 1, NNODE_1D >::build_face_element(), oomph::TElement< 2, NNODE_1D >::build_face_element(), oomph::TElement< 3, NNODE_1D >::build_face_element(), and oomph::PerturbedSpineLinearisedAxisymmetricFluidInterfaceElement< ELEMENT >::hijack_kinematic_conditions().

◆ bulk_node_number() [2/2]

const unsigned& oomph::FaceElement::bulk_node_number ( const unsigned & n ) const

inline

Return the bulk node number that corresponds to the n-th local node number (const version)

     {
       return Bulk_node_number[n];
     }

References Bulk_node_number, and n.

◆ bulk_node_number_resize()

void oomph::FaceElement::bulk_node_number_resize ( const unsigned & i )

inline

Resize the storage for the bulk node numbers.

     {
       Bulk_node_number.resize(i);
     }

References Bulk_node_number, and i.

Referenced by oomph::FiniteElement::build_face_element(), oomph::QHermiteElement< DIM >::build_face_element(), oomph::QSpectralElement< 1, NNODE_1D >::build_face_element(), oomph::QSpectralElement< 2, NNODE_1D >::build_face_element(), oomph::TBubbleEnrichedElement< DIM, NNODE_1D >::build_face_element(), oomph::TElement< 1, NNODE_1D >::build_face_element(), oomph::TElement< 2, NNODE_1D >::build_face_element(), and oomph::TElement< 3, NNODE_1D >::build_face_element().

◆ bulk_position_type() [1/2]

unsigned& oomph::FaceElement::bulk_position_type ( const unsigned & i )

inline

Return the position type in the "bulk" element that corresponds to position type i on the FaceElement.

     {
       return Bulk_position_type[i];
     }

References Bulk_position_type, and i.

Referenced by oomph::QHermiteElement< DIM >::build_face_element(), check_J_eulerian_at_knots(), oomph::ClampedHermiteShellBoundaryConditionElement::ClampedHermiteShellBoundaryConditionElement(), continuous_tangent_and_outer_unit_normal(), J_eulerian(), J_eulerian_at_knot(), and outer_unit_normal().

◆ bulk_position_type() [2/2]

const unsigned& oomph::FaceElement::bulk_position_type ( const unsigned & i ) const

inline

Return the position type in the "bulk" element that corresponds to the position type i on the FaceElement. Const version

     {
       return Bulk_position_type[i];
     }

References Bulk_position_type, and i.

◆ bulk_position_type_resize()

void oomph::FaceElement::bulk_position_type_resize ( const unsigned & i )

inline

Resize the storage for bulk_position_type to i entries.

     {
       Bulk_position_type.resize(i);
     }

References Bulk_position_type, and i.

Referenced by oomph::QHermiteElement< DIM >::build_face_element(), and oomph::ClampedHermiteShellBoundaryConditionElement::ClampedHermiteShellBoundaryConditionElement().

◆ check_J_eulerian_at_knots()

void oomph::FaceElement::check_J_eulerian_at_knots ( bool & passed ) const

Check that Jacobian of mapping between local and Eulerian coordinates at all integration points is positive.

   {
     // Let's be optimistic...
     passed = true;
  
     // Find the number of nodes
     const unsigned n_node = nnode();
  
     // Find the number of position types
     const unsigned n_position_type = nnodal_position_type();
  
     // Find the dimension of the node and element
     const unsigned n_dim = nodal_dimension();
     const unsigned n_dim_el = dim();
  
     // Set up dummy memory for the shape functions
     Shape psi(n_node, n_position_type);
     DShape dpsids(n_node, n_position_type, n_dim_el);
  
  
     unsigned nintpt = integral_pt()->nweight();
     for (unsigned ipt = 0; ipt < nintpt; ipt++)
     {
       // Get the shape functions and local derivatives at the knot
       // This call may use the stored versions, which is why this entire
       // function doesn't just call J_eulerian(s), after reading out s from
       // the knots.
       dshape_local_at_knot(ipt, psi, dpsids);
  
       // Also calculate the surface Vectors (derivatives wrt local coordinates)
       DenseMatrix<double> interpolated_A(n_dim_el, n_dim, 0.0);
  
       // Calculate positions and derivatives
       for (unsigned l = 0; l < n_node; l++)
       {
         // Loop over positional dofs
         for (unsigned k = 0; k < n_position_type; k++)
         {
           // Loop over coordinates
           for (unsigned i = 0; i < n_dim; i++)
           {
             // Loop over LOCAL derivative directions, to calculate the
             // tangent(s)
             for (unsigned j = 0; j < n_dim_el; j++)
             {
               interpolated_A(j, i) +=
                 nodal_position_gen(l, bulk_position_type(k), i) *
                 dpsids(l, k, j);
             }
           }
         }
       }
  
       // Now find the local deformed metric tensor from the tangent Vectors
       DenseMatrix<double> A(n_dim_el, n_dim_el, 0.0);
       for (unsigned i = 0; i < n_dim_el; i++)
       {
         for (unsigned j = 0; j < n_dim_el; j++)
         {
           // Take the dot product
           for (unsigned k = 0; k < n_dim; k++)
           {
             A(i, j) += interpolated_A(i, k) * interpolated_A(j, k);
           }
         }
       }
  
       // Find the determinant of the metric tensor
       double Adet = 0.0;
       switch (n_dim_el)
       {
         case 1:
           Adet = A(0, 0);
           break;
         case 2:
           Adet = A(0, 0) * A(1, 1) - A(0, 1) * A(1, 0);
           break;
         default:
           throw OomphLibError("Wrong dimension in FaceElement",
                               "FaceElement::J_eulerian_at_knot()",
                               OOMPH_EXCEPTION_LOCATION);
       }
  
  
       // Are we dead yet?
       if (Adet <= 0.0)
       {
         passed = false;
         return;
       }
     }
   }

References bulk_position_type(), oomph::FiniteElement::dim(), oomph::FiniteElement::dshape_local_at_knot(), i, oomph::FiniteElement::integral_pt(), j, k, oomph::FiniteElement::nnodal_position_type(), oomph::FiniteElement::nnode(), oomph::FiniteElement::nodal_dimension(), oomph::FiniteElement::nodal_position_gen(), oomph::Integral::nweight(), and OOMPH_EXCEPTION_LOCATION.

◆ continuous_tangent_and_outer_unit_normal() [1/2]

void oomph::FaceElement::continuous_tangent_and_outer_unit_normal	(	const unsigned &	ipt,
		Vector< Vector< double >> &	tang_vec,
		Vector< double > &	unit_normal
	)		const

Compute the tangent vector(s) and the outer unit normal vector at the ipt-th integration point. This is a wrapper around continuous_tangent_and_outer_unit_normal(...) with the integration points converted into local coordinates.

   {
     // Find the dimension of the element
     const unsigned element_dim = dim();
     // Find the local coordinates of the ipt-th integration point
     Vector<double> s(element_dim);
     for (unsigned i = 0; i < element_dim; i++)
     {
       s[i] = integral_pt()->knot(ipt, i);
     }
     // Call the outer unit normal function
     continuous_tangent_and_outer_unit_normal(s, tang_vec, unit_normal);
   }

References continuous_tangent_and_outer_unit_normal(), oomph::FiniteElement::dim(), i, oomph::FiniteElement::integral_pt(), oomph::Integral::knot(), and s.

◆ continuous_tangent_and_outer_unit_normal() [2/2]

void oomph::FaceElement::continuous_tangent_and_outer_unit_normal	(	const Vector< double > &	s,
		Vector< Vector< double >> &	tang_vec,
		Vector< double > &	unit_normal
	)		const

Compute the tangent vector(s) and the outer unit normal vector at the specified local coordinate. In two spatial dimensions, a "tangent direction" is not required. In three spatial dimensions, a tangent direction is required (set via set_tangent_direction(...)), and we project the tanent direction on to the surface. The second tangent vector is taken to be the cross product of the projection and the unit normal.

   {
     // Find the spatial dimension of the FaceElement
     const unsigned element_dim = dim();
  
     // Find the overall dimension of the problem
     //(assume that it's the same for all nodes)
     const unsigned spatial_dim = nodal_dimension();
  
 #ifdef PARANOID
     // Check the number of local coordinates passed
     if (s.size() != element_dim)
     {
       std::ostringstream error_stream;
       error_stream
         << "Local coordinate s passed to outer_unit_normal() has dimension "
         << s.size() << std::endl
         << "but element dimension is " << element_dim << std::endl;
  
       throw OomphLibError(
         error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
  
     // Check that if the Tangent_direction_pt is set, then
     // it is the same length as the spatial dimension.
     if (Tangent_direction_pt != 0 &&
         Tangent_direction_pt->size() != spatial_dim)
     {
       std::ostringstream error_stream;
       error_stream << "Tangent direction vector has dimension "
                    << Tangent_direction_pt->size() << std::endl
                    << "but spatial dimension is " << spatial_dim << std::endl;
  
       throw OomphLibError(
         error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
  
     // Check the dimension of the normal vector
     if (unit_normal.size() != spatial_dim)
     {
       std::ostringstream error_stream;
       error_stream << "Unit normal passed to outer_unit_normal() has dimension "
                    << unit_normal.size() << std::endl
                    << "but spatial dimension is " << spatial_dim << std::endl;
  
       throw OomphLibError(
         error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
  
  
     // The number of tangent vectors.
     unsigned ntangent_vec = tang_vec.size();
  
     // For the tangent vector,
     // if element_dim = 2, tang_vec is a 2D Vector of length 3.
     // if element_dim = 1, tang_vec is a 1D Vector of length 2.
     // if element_dim = 0, tang_vec is a 1D Vector of length 1.
     switch (element_dim)
     {
         // Point element, derived from a 1D element.
       case 0:
       {
         // Check that tang_vec is a 1D vector.
         if (ntangent_vec != 1)
         {
           std::ostringstream error_stream;
           error_stream
             << "This is a 0D FaceElement, we need one tangent vector.\n"
             << "You have given me " << tang_vec.size() << " vector(s).\n";
           throw OomphLibError(error_stream.str(),
                               OOMPH_CURRENT_FUNCTION,
                               OOMPH_EXCEPTION_LOCATION);
         }
       }
       break;
  
       // Line element, derived from a 2D element.
       case 1:
       {
         // Check that tang_vec is a 1D vector.
         if (ntangent_vec != 1)
         {
           std::ostringstream error_stream;
           error_stream
             << "This is a 1D FaceElement, we need one tangent vector.\n"
             << "You have given me " << tang_vec.size() << " vector(s).\n";
           throw OomphLibError(error_stream.str(),
                               OOMPH_CURRENT_FUNCTION,
                               OOMPH_EXCEPTION_LOCATION);
         }
       }
       break;
  
       // Plane element, derived from 3D element.
       case 2:
       {
         // Check that tang_vec is a 2D vector.
         if (ntangent_vec != 2)
         {
           std::ostringstream error_stream;
           error_stream
             << "This is a 2D FaceElement, we need two tangent vectors.\n"
             << "You have given me " << tang_vec.size() << " vector(s).\n";
           throw OomphLibError(error_stream.str(),
                               OOMPH_CURRENT_FUNCTION,
                               OOMPH_EXCEPTION_LOCATION);
         }
       }
       break;
       // There are no other elements!
       default:
  
         throw OomphLibError(
           "Cannot have a FaceElement with dimension higher than 2",
           OOMPH_CURRENT_FUNCTION,
           OOMPH_EXCEPTION_LOCATION);
         break;
     }
  
     // Check the lengths of each sub vectors.
     for (unsigned vec_i = 0; vec_i < ntangent_vec; vec_i++)
     {
       if (tang_vec[vec_i].size() != spatial_dim)
       {
         std::ostringstream error_stream;
         error_stream << "This problem has " << spatial_dim
                      << " spatial dimensions.\n"
                      << "But the " << vec_i << " tangent vector has size "
                      << tang_vec[vec_i].size() << std::endl;
         throw OomphLibError(
           error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
       }
     }
  
 #endif
  
  
     // Now let's consider the different element dimensions
     switch (element_dim)
     {
         // Point element, derived from a 1D element.
       case 0:
       {
         std::ostringstream error_stream;
         error_stream
           << "It is unclear how to calculate a tangent and normal vectors for "
           << "a point element.\n";
         throw OomphLibError(
           error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
       }
       break;
  
       // Line element, derived from a 2D element, in this case
       // the normal is a mess of cross products
       // We need an interior direction, so we must find the local
       // derivatives in the BULK element
       case 1:
       {
         // Find the number of nodes in the bulk element
         const unsigned n_node_bulk = Bulk_element_pt->nnode();
         // Find the number of position types in the bulk element
         const unsigned n_position_type_bulk =
           Bulk_element_pt->nnodal_position_type();
  
         // Construct the local coordinate in the bulk element
         Vector<double> s_bulk(2);
         // Get the local coordinates in the bulk element
         get_local_coordinate_in_bulk(s, s_bulk);
  
         // Allocate storage for the shape functions and their derivatives wrt
         // local coordinates
         Shape psi(n_node_bulk, n_position_type_bulk);
         DShape dpsids(n_node_bulk, n_position_type_bulk, 2);
         // Get the value of the shape functions at the given local coordinate
         Bulk_element_pt->dshape_local(s_bulk, psi, dpsids);
  
         // Calculate all derivatives of the spatial coordinates
         // wrt local coordinates
         DenseMatrix<double> interpolated_dxds(2, spatial_dim, 0.0);
  
         // Loop over all parent nodes
         for (unsigned l = 0; l < n_node_bulk; l++)
         {
           // Loop over all position types in the bulk
           for (unsigned k = 0; k < n_position_type_bulk; k++)
           {
             // Loop over derivative direction
             for (unsigned j = 0; j < 2; j++)
             {
               // Loop over coordinate directions
               for (unsigned i = 0; i < spatial_dim; i++)
               {
                 // Compute the spatial derivative
                 interpolated_dxds(j, i) +=
                   Bulk_element_pt->nodal_position_gen(l, k, i) *
                   dpsids(l, k, j);
               }
             }
           }
         }
  
         // Initialise the tangent, interior tangent and normal vectors to zero
         // The idea is that even if the element is in a two-dimensional space,
         // the normal cannot be calculated without embedding the element in
         // three dimensions, in which case, the tangent and interior tangent
         // will have zero z-components.
         Vector<double> tangent(3, 0.0), interior_tangent(3, 0.0),
           normal(3, 0.0);
  
         // We must get the relationship between the coordinate along the face
         // and the local coordinates in the bulk element
         // We must also find an interior direction
         DenseMatrix<double> dsbulk_dsface(2, 1, 0.0);
         unsigned interior_direction = 0;
         get_ds_bulk_ds_face(s, dsbulk_dsface, interior_direction);
         // Load in the values for the tangents
         for (unsigned i = 0; i < spatial_dim; i++)
         {
           // Tangent to the face is the derivative wrt to the face coordinate
           // which is calculated using dsbulk_dsface and the chain rule
           tangent[i] = interpolated_dxds(0, i) * dsbulk_dsface(0, 0) +
                        interpolated_dxds(1, i) * dsbulk_dsface(1, 0);
           // Interior tangent to the face is the derivative in the interior
           // direction
           interior_tangent[i] = interpolated_dxds(interior_direction, i);
         }
  
         // Now the (3D) normal to the element is the interior tangent
         // crossed with the tangent
         VectorHelpers::cross(interior_tangent, tangent, normal);
  
         // We find the line normal by crossing the element normal with the
         // tangent
         Vector<double> full_normal(3);
         VectorHelpers::cross(normal, tangent, full_normal);
  
         // Copy the appropriate entries into the unit normal
         // Two or Three depending upon the spatial dimension of the system
         for (unsigned i = 0; i < spatial_dim; i++)
         {
           unit_normal[i] = full_normal[i];
         }
  
         // Finally normalise unit normal and multiply by the Normal_sign
         double length = VectorHelpers::magnitude(unit_normal);
         for (unsigned i = 0; i < spatial_dim; i++)
         {
           unit_normal[i] *= Normal_sign / length;
         }
  
         // Create the tangent vector
         tang_vec[0][0] = -unit_normal[1];
         tang_vec[0][1] = unit_normal[0];
       }
       break;
  
       // Plane element, derived from 3D element, in this case the normal
       // is just the cross product of the two surface tangents
       // We assume, therefore, that we have three spatial coordinates
       // and two surface coordinates
       // Then we need only to get the derivatives wrt the local coordinates
       // in this face element
       case 2:
       {
 #ifdef PARANOID
         // Check that we actually have three spatial dimensions
         if (spatial_dim != 3)
         {
           std::ostringstream error_stream;
           error_stream << "There are only " << spatial_dim
                        << "coordinates at the nodes of this 2D FaceElement,\n"
                        << "which must have come from a 3D Bulk element\n";
           throw OomphLibError(error_stream.str(),
                               OOMPH_CURRENT_FUNCTION,
                               OOMPH_EXCEPTION_LOCATION);
         }
 #endif
  
         // Find the number of nodes in the element
         const unsigned n_node = this->nnode();
         // Find the number of position types
         const unsigned n_position_type = this->nnodal_position_type();
  
         // Allocate storage for the shape functions and their derivatives wrt
         // local coordinates
         Shape psi(n_node, n_position_type);
         DShape dpsids(n_node, n_position_type, 2);
         // Get the value of the shape functions at the given local coordinate
         this->dshape_local(s, psi, dpsids);
  
         // Calculate all derivatives of the spatial coordinates
         // wrt local coordinates
         Vector<Vector<double>> interpolated_dxds(2, Vector<double>(3, 0));
  
         // Loop over all nodes
         for (unsigned l = 0; l < n_node; l++)
         {
           // Loop over all position types
           for (unsigned k = 0; k < n_position_type; k++)
           {
             // Loop over derivative directions
             for (unsigned j = 0; j < 2; j++)
             {
               // Loop over coordinate directions
               for (unsigned i = 0; i < 3; i++)
               {
                 // Compute the spatial derivative
                 // Remember that we need to translate the position type
                 // to its location in the bulk node
                 interpolated_dxds[j][i] +=
                   this->nodal_position_gen(l, bulk_position_type(k), i) *
                   dpsids(l, k, j);
               }
             }
           }
         }
  
         // We now take the cross product of the two normal vectors
         VectorHelpers::cross(
           interpolated_dxds[0], interpolated_dxds[1], unit_normal);
  
         // Finally normalise unit normal
         double normal_length = VectorHelpers::magnitude(unit_normal);
  
         for (unsigned i = 0; i < spatial_dim; i++)
         {
           unit_normal[i] *= Normal_sign / normal_length;
         }
  
         // Next we create the continuous tangent vectors!
         if (Tangent_direction_pt != 0)
         // There is a general direction that the first tangent vector should
         // follow.
         {
           // Project the Tangent direction vector onto the surface.
           // Project Tangent_direction_pt D onto the plane P defined by
           // T1 and T2:
           // proj_P(D) = proj_T1(D) + proj_T2(D), where D is
           // Tangent_direction_pt, recall that proj_u(v) = (u.v)/(u.u) * u
  
           // Get the direction vector. The vector is NOT copied! :)
           Vector<double>& direction_vector = *Tangent_direction_pt;
  
 #ifdef PARANOID
           // Check that the angle between the direction vector and the normal
           // is not less than 10 degrees
           if (VectorHelpers::angle(direction_vector, unit_normal) <
               (10.0 * MathematicalConstants::Pi / 180.0))
           {
             std::ostringstream err_stream;
             err_stream << "The angle between the unit normal and the \n"
                        << "direction vector is less than 10 degrees.";
             throw OomphLibError(err_stream.str(),
                                 OOMPH_CURRENT_FUNCTION,
                                 OOMPH_EXCEPTION_LOCATION);
           }
 #endif
  
           // Calculate the two scalings, (u.v) / (u.u)
           double t1_scaling =
             VectorHelpers::dot(interpolated_dxds[0], direction_vector) /
             VectorHelpers::dot(interpolated_dxds[0], interpolated_dxds[0]);
  
           double t2_scaling =
             VectorHelpers::dot(interpolated_dxds[1], direction_vector) /
             VectorHelpers::dot(interpolated_dxds[1], interpolated_dxds[1]);
  
           // Finish off the projection.
           tang_vec[0][0] = t1_scaling * interpolated_dxds[0][0] +
                            t2_scaling * interpolated_dxds[1][0];
           tang_vec[0][1] = t1_scaling * interpolated_dxds[0][1] +
                            t2_scaling * interpolated_dxds[1][1];
           tang_vec[0][2] = t1_scaling * interpolated_dxds[0][2] +
                            t2_scaling * interpolated_dxds[1][2];
  
           // The second tangent vector is the cross product of
           // tang_vec[0] and the normal vector N.
           VectorHelpers::cross(tang_vec[0], unit_normal, tang_vec[1]);
  
           // Normalise the tangent vectors
           for (unsigned vec_i = 0; vec_i < 2; vec_i++)
           {
             // Get the length...
             double tang_length = VectorHelpers::magnitude(tang_vec[vec_i]);
  
             for (unsigned dim_i = 0; dim_i < spatial_dim; dim_i++)
             {
               tang_vec[vec_i][dim_i] /= tang_length;
             }
           }
         }
         else
         // A direction for the first tangent vector is not supplied, we do our
         // best to keep it continuous. But if the normal vector is aligned with
         // the z axis, then the tangent vector may "flip", even within elements.
         // This is because we check this by comparing doubles.
         // The code is copied from impose_parallel_outflow_element.h,
         // NO modification is done except for a few variable name changes.
         {
           double a, b, c;
           a = unit_normal[0];
           b = unit_normal[1];
           c = unit_normal[2];
  
           if (a != 0.0 || b != 0.0)
           {
             double a_sq = a * a;
             double b_sq = b * b;
             double c_sq = c * c;
  
             tang_vec[0][0] = -b / sqrt(a_sq + b_sq);
             tang_vec[0][1] = a / sqrt(a_sq + b_sq);
             tang_vec[0][2] = 0;
  
             double z = (a_sq + b_sq) / sqrt(a_sq * c_sq + b_sq * c_sq +
                                             (a_sq + b_sq) * (a_sq + b_sq));
  
             tang_vec[1][0] = -(a * c * z) / (a_sq + b_sq);
             tang_vec[1][1] = -(b * c * z) / (a_sq + b_sq);
             tang_vec[1][2] = z;
             // NB : we didn't use the fact that N is normalized,
             // that's why we have these unsimplified formulas
           }
           else if (c != 0.0)
           {
             if (!FaceElement::Ignore_discontinuous_tangent_warning)
             {
               std::ostringstream warn_stream;
               warn_stream
                 << "I have detected that your normal vector is [0,0,1].\n"
                 << "Since this function compares against 0.0, you may\n"
                 << "get discontinuous tangent vectors.";
               OomphLibWarning(warn_stream.str(),
                               OOMPH_CURRENT_FUNCTION,
                               OOMPH_EXCEPTION_LOCATION);
             }
  
             tang_vec[0][0] = 1.0;
             tang_vec[0][1] = 0.0;
             tang_vec[0][2] = 0.0;
  
             tang_vec[1][0] = 0.0;
             tang_vec[1][1] = 1.0;
             tang_vec[1][2] = 0.0;
           }
           else
           {
             throw OomphLibError("You have a zero normal vector!! ",
                                 OOMPH_CURRENT_FUNCTION,
                                 OOMPH_EXCEPTION_LOCATION);
           }
         }
       }
       break;
  
       default:
  
         throw OomphLibError(
           "Cannot have a FaceElement with dimension higher than 2",
           OOMPH_CURRENT_FUNCTION,
           OOMPH_EXCEPTION_LOCATION);
         break;
     }
   }

References a, oomph::VectorHelpers::angle(), b, Bulk_element_pt, bulk_position_type(), calibrate::c, oomph::VectorHelpers::cross(), oomph::FiniteElement::dim(), oomph::VectorHelpers::dot(), oomph::FiniteElement::dshape_local(), get_ds_bulk_ds_face(), get_local_coordinate_in_bulk(), i, Ignore_discontinuous_tangent_warning, j, k, oomph::VectorHelpers::magnitude(), oomph::FiniteElement::nnodal_position_type(), oomph::FiniteElement::nnode(), oomph::FiniteElement::nodal_dimension(), oomph::FiniteElement::nodal_position_gen(), WallFunction::normal(), Normal_sign, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::MathematicalConstants::Pi, s, oomph::FiniteElement::size(), sqrt(), and Tangent_direction_pt.

Referenced by continuous_tangent_and_outer_unit_normal(), and oomph::ImposeParallelOutflowElement< ELEMENT >::fill_in_generic_contribution_to_residuals_parall_lagr_multiplier().

◆ face_index() [1/2]

int& oomph::FaceElement::face_index ( )

inline

Index of the face (a number that uniquely identifies the face in the element)

     {
       return Face_index;
     }

References Face_index.

◆ face_index() [2/2]

int oomph::FaceElement::face_index ( ) const

inline

Index of the face (a number that uniquely identifies the face in the element) (const version)

     {
       return Face_index;
     }

References Face_index.

◆ face_to_bulk_coordinate_fct_pt() [1/2]

CoordinateMappingFctPt& oomph::FaceElement::face_to_bulk_coordinate_fct_pt ( )

inline

Return the pointer to the function that maps the face coordinate to the bulk coordinate

     {
       return Face_to_bulk_coordinate_fct_pt;
     }

References Face_to_bulk_coordinate_fct_pt.

Referenced by oomph::FiniteElement::build_face_element(), oomph::QHermiteElement< DIM >::build_face_element(), oomph::QSpectralElement< 1, NNODE_1D >::build_face_element(), oomph::QSpectralElement< 2, NNODE_1D >::build_face_element(), oomph::QSpectralElement< 3, NNODE_1D >::build_face_element(), oomph::TElement< 1, NNODE_1D >::build_face_element(), oomph::TElement< 2, NNODE_1D >::build_face_element(), and oomph::TElement< 3, NNODE_1D >::build_face_element().

◆ face_to_bulk_coordinate_fct_pt() [2/2]

CoordinateMappingFctPt oomph::FaceElement::face_to_bulk_coordinate_fct_pt ( ) const

inline

Return the pointer to the function that maps the face coordinate to the bulk coordinate (const version)

     {
       return Face_to_bulk_coordinate_fct_pt;
     }

References Face_to_bulk_coordinate_fct_pt.

◆ get_ds_bulk_ds_face()

void oomph::FaceElement::get_ds_bulk_ds_face	(	const Vector< double > &	s,
		DenseMatrix< double > &	dsbulk_dsface,
		unsigned &	interior_direction
	)		const

Calculate the derivatives of the local coordinates in the bulk element with respect to the local coordinates in this FaceElement. In addition return the index of a bulk local coordinate that varies away from the face.

   {
     // Use the function pointer if it is set
     if (Bulk_coordinate_derivatives_fct_pt)
     {
       // Call the translation function
       (*Bulk_coordinate_derivatives_fct_pt)(
         s, dsbulk_dsface, interior_direction);
     }
     // Otherwise throw an error
     else
     {
       throw OomphLibError(
         "No function for derivatives of bulk coords wrt face coords set",
         OOMPH_CURRENT_FUNCTION,
         OOMPH_EXCEPTION_LOCATION);
     }
   }

References Bulk_coordinate_derivatives_fct_pt, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and s.

Referenced by continuous_tangent_and_outer_unit_normal(), and outer_unit_normal().

◆ get_local_coordinate_in_bulk()

void oomph::FaceElement::get_local_coordinate_in_bulk	(	const Vector< double > &	s,
		Vector< double > &	s_bulk
	)		const

Calculate the vector of local coordinate in the bulk element given the local coordinates in this FaceElement

Calculate the vector of local coordinates in bulk element, given the local coordinates in this FaceElement

   {
     // Use the function pointer if it is set
     if (Face_to_bulk_coordinate_fct_pt)
     {
       // Call the translation function
       (*Face_to_bulk_coordinate_fct_pt)(s, s_bulk);
     }
     // Otherwise use the existing (not general) interface
     else
     {
       throw OomphLibError("Face_to_bulk_coordinate mapping not set",
                           OOMPH_CURRENT_FUNCTION,
                           OOMPH_EXCEPTION_LOCATION);
     }
   }

References Face_to_bulk_coordinate_fct_pt, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and s.

Referenced by continuous_tangent_and_outer_unit_normal(), oomph::NavierStokesSurfacePowerElement< ELEMENT >::drag_force(), oomph::ClampedSlidingHermiteBeamBoundaryConditionElement::fill_in_contribution_to_residuals(), oomph::PointFluidInterfaceBoundingElement::fill_in_generic_residual_contribution_interface_boundary(), oomph::LineFluidInterfaceBoundingElement::fill_in_generic_residual_contribution_interface_boundary(), oomph::NavierStokesSurfaceDragTorqueElement< ELEMENT >::get_drag_and_torque(), oomph::NavierStokesSurfacePowerElement< ELEMENT >::get_kinetic_energy_flux(), oomph::NavierStokesSurfacePowerElement< ELEMENT >::get_rate_of_traction_work(), oomph::NavierStokesSurfacePowerElement< ELEMENT >::get_rate_of_traction_work_components(), oomph::NavierStokesImpedanceTractionElement< BULK_NAVIER_STOKES_ELEMENT, WOMERSLEY_ELEMENT, DIM >::get_volume_flux(), oomph::NavierStokesSurfacePowerElement< ELEMENT >::get_volume_flux(), SCoupling< M, O >::getSCoupledElements(), TwoDDGProblem< ELEMENT >::limit(), oomph::Multi_domain_functions::locate_zeta_for_local_coordinates(), outer_unit_normal(), oomph::NavierStokesSurfaceDragTorqueElement< ELEMENT >::output(), oomph::DGFaceElement::setup_neighbour_info(), and TFaceTestProblem< ELEMENT >::TFaceTestProblem().

◆ interpolated_dxdt() [1/2]

double oomph::FaceElement::interpolated_dxdt	(	const Vector< double > &	s,
		const unsigned &	i,
		const unsigned &	t
	)

inlinevirtual

Return t-th time-derivative of the i-th FE-interpolated Eulerian coordinate at local coordinate s. Overloaded to get information from bulk.

Reimplemented from oomph::FiniteElement.

     {
       // Local coordinates in bulk element
       Vector<double> s_bulk(dim() + 1);
       s_bulk = local_coordinate_in_bulk(s);
  
       // Return Eulerian coordinate as computed by bulk
       return bulk_element_pt()->interpolated_dxdt(s_bulk, i, t);
     }

References bulk_element_pt(), oomph::FiniteElement::dim(), i, oomph::FiniteElement::interpolated_dxdt(), local_coordinate_in_bulk(), s, and plotPSD::t.

◆ interpolated_dxdt() [2/2]

void oomph::FaceElement::interpolated_dxdt	(	const Vector< double > &	s,
		const unsigned &	t,
		Vector< double > &	dxdt
	)

inlinevirtual

Compte t-th time-derivative of the FE-interpolated Eulerian coordinate vector at local coordinate s. Overloaded to get information from bulk.

Reimplemented from oomph::FiniteElement.

     {
       // Local coordinates in bulk element
       Vector<double> s_bulk(dim() + 1);
       s_bulk = local_coordinate_in_bulk(s);
  
       // Get Eulerian position vector
       bulk_element_pt()->interpolated_dxdt(s_bulk, t, dxdt);
     }

References bulk_element_pt(), oomph::FiniteElement::dim(), oomph::FiniteElement::interpolated_dxdt(), local_coordinate_in_bulk(), s, and plotPSD::t.

◆ interpolated_x() [1/4]

double oomph::FaceElement::interpolated_x	(	const unsigned &	t,
		const Vector< double > &	s,
		const unsigned &	i
	)		const

inlinevirtual

Return FE interpolated coordinate x[i] at local coordinate s at previous timestep t (t=0: present; t>0: previous timestep). Overloaded to get information from bulk.

Reimplemented from oomph::FiniteElement.

     {
       // Local coordinates in bulk element
       Vector<double> s_bulk(dim() + 1);
       s_bulk = local_coordinate_in_bulk(s);
  
       // Return Eulerian coordinate as computed by bulk
       return bulk_element_pt()->interpolated_x(t, s_bulk, i);
     }

References bulk_element_pt(), oomph::FiniteElement::dim(), i, oomph::FiniteElement::interpolated_x(), local_coordinate_in_bulk(), s, and plotPSD::t.

◆ interpolated_x() [2/4]

void oomph::FaceElement::interpolated_x	(	const unsigned &	t,
		const Vector< double > &	s,
		Vector< double > &	x
	)		const

inlinevirtual

Return FE interpolated position x[] at local coordinate s at previous timestep t as Vector (t=0: present; t>0: previous timestep). Overloaded to get information from bulk.

Reimplemented from oomph::FiniteElement.

     {
       // Local coordinates in bulk element
       Vector<double> s_bulk(dim() + 1);
       s_bulk = local_coordinate_in_bulk(s);
  
       // Get Eulerian position vector
       bulk_element_pt()->interpolated_x(t, s_bulk, x);
     }

References bulk_element_pt(), oomph::FiniteElement::dim(), oomph::FiniteElement::interpolated_x(), local_coordinate_in_bulk(), s, plotPSD::t, and plotDoE::x.

◆ interpolated_x() [3/4]

double oomph::FaceElement::interpolated_x	(	const Vector< double > &	s,
		const unsigned &	i
	)		const

inlinevirtual

Return FE interpolated coordinate x[i] at local coordinate s. Overloaded to get information from bulk.

Reimplemented from oomph::FiniteElement.

     {
       // Local coordinates in bulk element
       Vector<double> s_bulk(dim() + 1);
       s_bulk = local_coordinate_in_bulk(s);
  
       // Return Eulerian coordinate as computed by bulk
       return bulk_element_pt()->interpolated_x(s_bulk, i);
     }

References bulk_element_pt(), oomph::FiniteElement::dim(), i, oomph::FiniteElement::interpolated_x(), local_coordinate_in_bulk(), and s.

◆ interpolated_x() [4/4]

void oomph::FaceElement::interpolated_x	(	const Vector< double > &	s,
		Vector< double > &	x
	)		const

inlinevirtual

Return FE interpolated position x[] at local coordinate s as Vector Overloaded to get information from bulk.

Reimplemented from oomph::FiniteElement.

     {
       // Local coordinates in bulk element
       Vector<double> s_bulk(dim() + 1);
       s_bulk = local_coordinate_in_bulk(s);
  
       // Get Eulerian position vector
       bulk_element_pt()->interpolated_x(s_bulk, x);
     }

References bulk_element_pt(), oomph::FiniteElement::dim(), oomph::FiniteElement::interpolated_x(), local_coordinate_in_bulk(), s, and plotDoE::x.

◆ J_eulerian()

double oomph::FaceElement::J_eulerian ( const Vector< double > & s ) const

virtual

Return the Jacobian of mapping from local to global coordinates at local position s. Overloaded from FiniteElement.

Calculate the determinant of the Jacobian of the mapping between local and global coordinates at the position s. Overloaded from FiniteElement.

Reimplemented from oomph::FiniteElement.

Reimplemented in oomph::BiharmonicFluxElement< DIM >.

   {
     // Find out the sptial dimension of the element
     unsigned n_dim_el = this->dim();
  
     // Bail out if we're in a point element -- not sure what
     // J_eulerian actually is, but this is harmless
     if (n_dim_el == 0) return 1.0;
  
     // Find out how many nodes there are
     unsigned n_node = nnode();
  
     // Find out how many positional dofs there are
     unsigned n_position_type = this->nnodal_position_type();
  
     // Find out the dimension of the node
     unsigned n_dim = this->nodal_dimension();
  
     // Set up memory for the shape functions
     Shape psi(n_node, n_position_type);
     DShape dpsids(n_node, n_position_type, n_dim_el);
  
     // Only need to call the local derivatives
     dshape_local(s, psi, dpsids);
  
     // Also calculate the surface Vectors (derivatives wrt local coordinates)
     DenseMatrix<double> interpolated_A(n_dim_el, n_dim, 0.0);
  
     // Calculate positions and derivatives
     for (unsigned l = 0; l < n_node; l++)
     {
       // Loop over positional dofs
       for (unsigned k = 0; k < n_position_type; k++)
       {
         // Loop over coordinates
         for (unsigned i = 0; i < n_dim; i++)
         {
           // Loop over LOCAL derivative directions, to calculate the tangent(s)
           for (unsigned j = 0; j < n_dim_el; j++)
           {
             interpolated_A(j, i) +=
               nodal_position_gen(l, bulk_position_type(k), i) * dpsids(l, k, j);
           }
         }
       }
     }
     // Now find the local deformed metric tensor from the tangent Vectors
     DenseMatrix<double> A(n_dim_el, n_dim_el, 0.0);
     for (unsigned i = 0; i < n_dim_el; i++)
     {
       for (unsigned j = 0; j < n_dim_el; j++)
       {
         // Take the dot product
         for (unsigned k = 0; k < n_dim; k++)
         {
           A(i, j) += interpolated_A(i, k) * interpolated_A(j, k);
         }
       }
     }
  
     // Find the determinant of the metric tensor
     double Adet = 0.0;
     switch (n_dim_el)
     {
       case 1:
         Adet = A(0, 0);
         break;
       case 2:
         Adet = A(0, 0) * A(1, 1) - A(0, 1) * A(1, 0);
         break;
       default:
         throw OomphLibError("Wrong dimension in FaceElement",
                             "FaceElement::J_eulerian()",
                             OOMPH_EXCEPTION_LOCATION);
     }
  
     // Return
     return sqrt(Adet);
   }

References bulk_position_type(), oomph::FiniteElement::dim(), oomph::FiniteElement::dshape_local(), i, j, k, oomph::FiniteElement::nnodal_position_type(), oomph::FiniteElement::nnode(), oomph::FiniteElement::nodal_dimension(), oomph::FiniteElement::nodal_position_gen(), OOMPH_EXCEPTION_LOCATION, s, and sqrt().

◆ J_eulerian_at_knot()

double oomph::FaceElement::J_eulerian_at_knot ( const unsigned & ipt ) const

virtual

Return the Jacobian of the mapping from local to global coordinates at the ipt-th integration point Overloaded from FiniteElement.

Compute the Jacobian of the mapping between the local and global coordinates at the ipt-th integration point. Overloaded from FiniteElement.

Reimplemented from oomph::FiniteElement.

   {
     // Find the number of nodes
     const unsigned n_node = nnode();
  
     // Find the number of position types
     const unsigned n_position_type = nnodal_position_type();
  
     // Find the dimension of the node and element
     const unsigned n_dim = nodal_dimension();
     const unsigned n_dim_el = dim();
  
     // Set up dummy memory for the shape functions
     Shape psi(n_node, n_position_type);
     DShape dpsids(n_node, n_position_type, n_dim_el);
  
     // Get the shape functions and local derivatives at the knot
     // This call may use the stored versions, which is why this entire
     // function doesn't just call J_eulerian(s), after reading out s from
     // the knots.
     dshape_local_at_knot(ipt, psi, dpsids);
  
     // Also calculate the surface Vectors (derivatives wrt local coordinates)
     DenseMatrix<double> interpolated_A(n_dim_el, n_dim, 0.0);
  
     // Calculate positions and derivatives
     for (unsigned l = 0; l < n_node; l++)
     {
       // Loop over positional dofs
       for (unsigned k = 0; k < n_position_type; k++)
       {
         // Loop over coordinates
         for (unsigned i = 0; i < n_dim; i++)
         {
           // Loop over LOCAL derivative directions, to calculate the tangent(s)
           for (unsigned j = 0; j < n_dim_el; j++)
           {
             interpolated_A(j, i) +=
               nodal_position_gen(l, bulk_position_type(k), i) * dpsids(l, k, j);
           }
         }
       }
     }
  
     // Now find the local deformed metric tensor from the tangent Vectors
     DenseMatrix<double> A(n_dim_el, n_dim_el, 0.0);
     for (unsigned i = 0; i < n_dim_el; i++)
     {
       for (unsigned j = 0; j < n_dim_el; j++)
       {
         // Take the dot product
         for (unsigned k = 0; k < n_dim; k++)
         {
           A(i, j) += interpolated_A(i, k) * interpolated_A(j, k);
         }
       }
     }
  
     // Find the determinant of the metric tensor
     double Adet = 0.0;
     switch (n_dim_el)
     {
       case 1:
         Adet = A(0, 0);
         break;
       case 2:
         Adet = A(0, 0) * A(1, 1) - A(0, 1) * A(1, 0);
         break;
       default:
         throw OomphLibError("Wrong dimension in FaceElement",
                             "FaceElement::J_eulerian_at_knot()",
                             OOMPH_EXCEPTION_LOCATION);
     }
  
     // Return
     return sqrt(Adet);
   }

References bulk_position_type(), oomph::FiniteElement::dim(), oomph::FiniteElement::dshape_local_at_knot(), i, j, k, oomph::FiniteElement::nnodal_position_type(), oomph::FiniteElement::nnode(), oomph::FiniteElement::nodal_dimension(), oomph::FiniteElement::nodal_position_gen(), OOMPH_EXCEPTION_LOCATION, and sqrt().

◆ local_coordinate_in_bulk()

Vector< double > oomph::FaceElement::local_coordinate_in_bulk ( const Vector< double > & s ) const

Return vector of local coordinates in bulk element, given the local coordinates in this FaceElement

   {
     // Find the dimension of the bulk element
     unsigned dim_bulk = Bulk_element_pt->dim();
  
     // Vector of local coordinates in bulk element
     Vector<double> s_bulk(dim_bulk);
  
     // Use the function pointer if it is set
     if (Face_to_bulk_coordinate_fct_pt)
     {
       // Call the translation function
       (*Face_to_bulk_coordinate_fct_pt)(s, s_bulk);
     }
     else
     {
       throw OomphLibError("Face_to_bulk_coordinate mapping not set",
                           OOMPH_CURRENT_FUNCTION,
                           OOMPH_EXCEPTION_LOCATION);
     }
  
     // Return it
     return s_bulk;
   }

References Bulk_element_pt, oomph::FiniteElement::dim(), Face_to_bulk_coordinate_fct_pt, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and s.

Referenced by oomph::AxisymmetricPoroelasticityTractionElement< ELEMENT >::contribution_to_total_porous_flux(), oomph::LinearisedAxisymPoroelasticBJS_FSIElement< FLUID_BULK_ELEMENT, POROELASTICITY_BULK_ELEMENT >::contribution_to_total_porous_flux(), RefineableYoungLaplaceProblem< ELEMENT >::doc_solution(), oomph::ClampedHermiteShellBoundaryConditionElement::fill_in_contribution_to_residuals(), oomph::PMLHelmholtzPowerElement< ELEMENT >::global_flux_contribution(), oomph::TimeHarmonicLinElastLoadedByPMLHelmholtzPressureBCElement< ELASTICITY_BULK_ELEMENT, HELMHOLTZ_BULK_ELEMENT >::global_flux_contribution_from_helmholtz(), oomph::TimeHarmonicLinElastLoadedByPMLHelmholtzPressureBCElement< ELASTICITY_BULK_ELEMENT, HELMHOLTZ_BULK_ELEMENT >::global_flux_contribution_from_solid(), oomph::FourierDecomposedHelmholtzBCElementBase< ELEMENT >::global_power_contribution(), oomph::HelmholtzBCElementBase< ELEMENT >::global_power_contribution(), oomph::PMLFourierDecomposedHelmholtzPowerMonitorElement< ELEMENT >::global_power_contribution(), oomph::PMLHelmholtzPowerElement< ELEMENT >::global_power_contribution(), interpolated_dxdt(), interpolated_x(), oomph::SolidFaceElement::interpolated_xi(), oomph::AxisymmetricPoroelasticityTractionElement< ELEMENT >::lagrangian_eulerian_translation_factor(), oomph::LinearisedAxisymPoroelasticBJS_FSIElement< FLUID_BULK_ELEMENT, POROELASTICITY_BULK_ELEMENT >::output(), oomph::AxisymmetricPoroelasticityTractionElement< ELEMENT >::output(), oomph::FSILinearisedAxisymPoroelasticTractionElement< POROELASTICITY_BULK_ELEMENT, NAVIER_STOKES_BULK_ELEMENT >::output(), and oomph::ClampedHermiteShellBoundaryConditionElement::output().

◆ nbulk_value() [1/2]

unsigned& oomph::FaceElement::nbulk_value ( const unsigned & n )

inline

Return the number of values originally stored at local node n (before the FaceElement added additional values to it (if it did))

     {
       return Nbulk_value[n];
     }

References n, and Nbulk_value.

◆ nbulk_value() [2/2]

unsigned oomph::FaceElement::nbulk_value ( const unsigned & n ) const

inline

Return the number of values originally stored at local node n (before the FaceElement added additional values to it (if it did)) (const version)

     {
       return Nbulk_value[n];
     }

References n, and Nbulk_value.

◆ nbulk_value_resize()

void oomph::FaceElement::nbulk_value_resize ( const unsigned & i )

inline

Resize the storage for the number of values originally stored at the local nodes to i entries.

     {
       Nbulk_value.resize(i);
     }

References i, and Nbulk_value.

◆ normal_sign() [1/2]

int& oomph::FaceElement::normal_sign ( )

inline

Sign of outer unit normal (relative to cross-products of tangent vectors in the corresponding "bulk" element.

     {
       return Normal_sign;
     }

References Normal_sign.

Referenced by oomph::FiniteElement::build_face_element(), oomph::QHermiteElement< DIM >::build_face_element(), oomph::QSpectralElement< 1, NNODE_1D >::build_face_element(), oomph::QSpectralElement< 2, NNODE_1D >::build_face_element(), oomph::QSpectralElement< 3, NNODE_1D >::build_face_element(), oomph::TElement< 1, NNODE_1D >::build_face_element(), oomph::TElement< 2, NNODE_1D >::build_face_element(), oomph::TElement< 3, NNODE_1D >::build_face_element(), oomph::BrickFromTetMesh< ELEMENT >::build_mesh(), oomph::SurfaceVolumeConstraintBoundingElement::fill_in_generic_residual_contribution_volume_constraint(), and oomph::ThinLayerBrickOnTetMesh< ELEMENT >::ThinLayerBrickOnTetMesh().

◆ normal_sign() [2/2]

int oomph::FaceElement::normal_sign ( ) const

inline

Return sign of outer unit normal (relative to cross-products of tangent vectors in the corresponding "bulk" element. (const version)

     {
       return Normal_sign;
     }

References Normal_sign.

◆ outer_unit_normal() [1/2]

void oomph::FaceElement::outer_unit_normal	(	const unsigned &	ipt,
		Vector< double > &	unit_normal
	)		const

Compute outer unit normal at ipt-th integration point.

Compute the outer unit normal at the ipt-th integration point.

   {
     // Find the dimension of the element
     const unsigned element_dim = dim();
     // Find the local coordiantes of the ipt-th integration point
     Vector<double> s(element_dim);
     for (unsigned i = 0; i < element_dim; i++)
     {
       s[i] = integral_pt()->knot(ipt, i);
     }
     // Call the outer unit normal function
     outer_unit_normal(s, unit_normal);
   }

References oomph::FiniteElement::dim(), i, oomph::FiniteElement::integral_pt(), oomph::Integral::knot(), outer_unit_normal(), and s.

◆ outer_unit_normal() [2/2]

void oomph::FaceElement::outer_unit_normal	(	const Vector< double > &	s,
		Vector< double > &	unit_normal
	)		const

Compute outer unit normal at the specified local coordinate.

Compute the outer unit normal at the specified local coordinate.

   {
     // Find the spatial dimension of the FaceElement
     const unsigned element_dim = dim();
  
     // Find the overall dimension of the problem
     //(assume that it's the same for all nodes)
     const unsigned spatial_dim = nodal_dimension();
  
 #ifdef PARANOID
     // Check the number of local coordinates passed
     if (s.size() != element_dim)
     {
       std::ostringstream error_stream;
       error_stream
         << "Local coordinate s passed to outer_unit_normal() has dimension "
         << s.size() << std::endl
         << "but element dimension is " << element_dim << std::endl;
  
       throw OomphLibError(
         error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
  
     // Check the dimension of the normal vector
     if (unit_normal.size() != spatial_dim)
     {
       std::ostringstream error_stream;
       error_stream << "Unit normal passed to outer_unit_normal() has dimension "
                    << unit_normal.size() << std::endl
                    << "but spatial dimension is " << spatial_dim << std::endl;
  
       throw OomphLibError(
         error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
 #endif
  
     /*  //The spatial dimension of the bulk element will be element_dim+1
       const unsigned bulk_dim = element_dim + 1;
  
       //Find the number of nodes in the bulk element
       const unsigned n_node_bulk = Bulk_element_pt->nnode();
       //Find the number of position types in the bulk element
       const unsigned n_position_type_bulk =
        Bulk_element_pt->nnodal_position_type();
  
       //Construct the local coordinate in the bulk element
       Vector<double> s_bulk(bulk_dim);
       //Set the value of the bulk coordinate that is fixed on the face
       //s_bulk[s_fixed_index()] = s_fixed_value();
  
       //Set the other bulk coordinates
       //for(unsigned i=0;i<element_dim;i++) {s_bulk[bulk_s_index(i)] = s[i];}
  
       get_local_coordinate_in_bulk(s,s_bulk);
  
       //Allocate storage for the shape functions and their derivatives wrt
       //local coordinates
       Shape psi(n_node_bulk,n_position_type_bulk);
       DShape dpsids(n_node_bulk,n_position_type_bulk,bulk_dim);
       //Get the value of the shape functions at the given local coordinate
       Bulk_element_pt->dshape_local(s_bulk,psi,dpsids);
  
       //Calculate all derivatives of the spatial coordinates wrt local
       coordinates DenseMatrix<double> interpolated_dxds(bulk_dim,spatial_dim);
       //Initialise to zero
       for(unsigned j=0;j<bulk_dim;j++)
        {for(unsigned i=0;i<spatial_dim;i++) {interpolated_dxds(j,i) = 0.0;}}
  
       //Loop over all parent nodes
       for(unsigned l=0;l<n_node_bulk;l++)
        {
         //Loop over all position types in the bulk
         for(unsigned k=0;k<n_position_type_bulk;k++)
          {
           //Loop over derivative direction
           for(unsigned j=0;j<bulk_dim;j++)
            {
             //Loop over coordinate directions
             for(unsigned i=0;i<spatial_dim;i++)
              {
               //Compute the spatial derivative
               interpolated_dxds(j,i) +=
                Bulk_element_pt->nodal_position_gen(l,k,i)*dpsids(l,k,j);
              }
            }
          }
          }*/
  
     // Now let's consider the different element dimensions
     switch (element_dim)
     {
         // Point element, derived from a 1D element, in this case
         // the normal is merely the tangent to the bulk element
         // and there is only one free coordinate in the bulk element
         // Hence we will need to calculate the derivatives wrt the
         // local coordinates in the BULK element.
       case 0:
       {
         // Find the number of nodes in the bulk element
         const unsigned n_node_bulk = Bulk_element_pt->nnode();
         // Find the number of position types in the bulk element
         const unsigned n_position_type_bulk =
           Bulk_element_pt->nnodal_position_type();
  
         // Construct the local coordinate in the bulk element
         Vector<double> s_bulk(1);
  
         // Get the local coordinates in the bulk element
         get_local_coordinate_in_bulk(s, s_bulk);
  
         // Allocate storage for the shape functions and their derivatives wrt
         // local coordinates
         Shape psi(n_node_bulk, n_position_type_bulk);
         DShape dpsids(n_node_bulk, n_position_type_bulk, 1);
         // Get the value of the shape functions at the given local coordinate
         Bulk_element_pt->dshape_local(s_bulk, psi, dpsids);
  
         // Calculate all derivatives of the spatial coordinates wrt
         // local coordinates
         DenseMatrix<double> interpolated_dxds(1, spatial_dim, 0.0);
  
         // Loop over all parent nodes
         for (unsigned l = 0; l < n_node_bulk; l++)
         {
           // Loop over all position types in the bulk
           for (unsigned k = 0; k < n_position_type_bulk; k++)
           {
             // Loop over coordinate directions
             for (unsigned i = 0; i < spatial_dim; i++)
             {
               // Compute the spatial derivative
               interpolated_dxds(0, i) +=
                 Bulk_element_pt->nodal_position_gen(l, k, i) * dpsids(l, k, 0);
             }
           }
         }
  
         // Now the unit normal is just the derivative of the position vector
         // with respect to the single coordinate
         for (unsigned i = 0; i < spatial_dim; i++)
         {
           unit_normal[i] = interpolated_dxds(0, i);
         }
       }
       break;
  
         // Line element, derived from a 2D element, in this case
         // the normal is a mess of cross products
         // We need an interior direction, so we must find the local
         // derivatives in the BULK element
       case 1:
       {
         // Find the number of nodes in the bulk element
         const unsigned n_node_bulk = Bulk_element_pt->nnode();
         // Find the number of position types in the bulk element
         const unsigned n_position_type_bulk =
           Bulk_element_pt->nnodal_position_type();
  
         // Construct the local coordinate in the bulk element
         Vector<double> s_bulk(2);
         // Get the local coordinates in the bulk element
         get_local_coordinate_in_bulk(s, s_bulk);
  
         // Allocate storage for the shape functions and their derivatives wrt
         // local coordinates
         Shape psi(n_node_bulk, n_position_type_bulk);
         DShape dpsids(n_node_bulk, n_position_type_bulk, 2);
         // Get the value of the shape functions at the given local coordinate
         Bulk_element_pt->dshape_local(s_bulk, psi, dpsids);
  
         // Calculate all derivatives of the spatial coordinates
         // wrt local coordinates
         DenseMatrix<double> interpolated_dxds(2, spatial_dim, 0.0);
  
         // Loop over all parent nodes
         for (unsigned l = 0; l < n_node_bulk; l++)
         {
           // Loop over all position types in the bulk
           for (unsigned k = 0; k < n_position_type_bulk; k++)
           {
             // Loop over derivative direction
             for (unsigned j = 0; j < 2; j++)
             {
               // Loop over coordinate directions
               for (unsigned i = 0; i < spatial_dim; i++)
               {
                 // Compute the spatial derivative
                 interpolated_dxds(j, i) +=
                   Bulk_element_pt->nodal_position_gen(l, k, i) *
                   dpsids(l, k, j);
               }
             }
           }
         }
  
         // Initialise the tangent, interior tangent and normal vectors to zero
         // The idea is that even if the element is in a two-dimensional space,
         // the normal cannot be calculated without embedding the element in
         // three dimensions, in which case, the tangent and interior tangent
         // will have zero z-components.
         Vector<double> tangent(3, 0.0), interior_tangent(3, 0.0),
           normal(3, 0.0);
  
         // We must get the relationship between the coordinate along the face
         // and the local coordinates in the bulk element
         // We must also find an interior direction
         DenseMatrix<double> dsbulk_dsface(2, 1, 0.0);
         unsigned interior_direction = 0;
         get_ds_bulk_ds_face(s, dsbulk_dsface, interior_direction);
         // Load in the values for the tangents
         for (unsigned i = 0; i < spatial_dim; i++)
         {
           // Tangent to the face is the derivative wrt to the face coordinate
           // which is calculated using dsbulk_dsface and the chain rule
           tangent[i] = interpolated_dxds(0, i) * dsbulk_dsface(0, 0) +
                        interpolated_dxds(1, i) * dsbulk_dsface(1, 0);
           // Interior tangent to the face is the derivative in the interior
           // direction
           interior_tangent[i] = interpolated_dxds(interior_direction, i);
         }
  
         // Now the (3D) normal to the element is the interior tangent
         // crossed with the tangent
         VectorHelpers::cross(interior_tangent, tangent, normal);
  
         // We find the line normal by crossing the element normal with the
         // tangent
         Vector<double> full_normal(3);
         VectorHelpers::cross(normal, tangent, full_normal);
  
         // Copy the appropriate entries into the unit normal
         // Two or Three depending upon the spatial dimension of the system
         for (unsigned i = 0; i < spatial_dim; i++)
         {
           unit_normal[i] = full_normal[i];
         }
       }
       break;
  
       // Plane element, derived from 3D element, in this case the normal
       // is just the cross product of the two surface tangents
       // We assume, therefore, that we have three spatial coordinates
       // and two surface coordinates
       // Then we need only to get the derivatives wrt the local coordinates
       // in this face element
       case 2:
       {
 #ifdef PARANOID
         // Check that we actually have three spatial dimensions
         if (spatial_dim != 3)
         {
           std::ostringstream error_stream;
           error_stream << "There are only " << spatial_dim
                        << "coordinates at the nodes of this 2D FaceElement,\n"
                        << "which must have come from a 3D Bulk element\n";
           throw OomphLibError(error_stream.str(),
                               OOMPH_CURRENT_FUNCTION,
                               OOMPH_EXCEPTION_LOCATION);
         }
 #endif
  
         // Find the number of nodes in the element
         const unsigned n_node = this->nnode();
         // Find the number of position types
         const unsigned n_position_type = this->nnodal_position_type();
  
         // Allocate storage for the shape functions and their derivatives wrt
         // local coordinates
         Shape psi(n_node, n_position_type);
         DShape dpsids(n_node, n_position_type, 2);
         // Get the value of the shape functions at the given local coordinate
         this->dshape_local(s, psi, dpsids);
  
         // Calculate all derivatives of the spatial coordinates
         // wrt local coordinates
         Vector<Vector<double>> interpolated_dxds(2, Vector<double>(3, 0));
  
         // Loop over all nodes
         for (unsigned l = 0; l < n_node; l++)
         {
           // Loop over all position types
           for (unsigned k = 0; k < n_position_type; k++)
           {
             // Loop over derivative directions
             for (unsigned j = 0; j < 2; j++)
             {
               // Loop over coordinate directions
               for (unsigned i = 0; i < 3; i++)
               {
                 // Compute the spatial derivative
                 // Remember that we need to translate the position type
                 // to its location in the bulk node
                 interpolated_dxds[j][i] +=
                   this->nodal_position_gen(l, bulk_position_type(k), i) *
                   dpsids(l, k, j);
               }
             }
           }
         }
  
         // We now take the cross product of the two normal vectors
         VectorHelpers::cross(
           interpolated_dxds[0], interpolated_dxds[1], unit_normal);
       }
       break;
  
       default:
  
         throw OomphLibError(
           "Cannot have a FaceElement with dimension higher than 2",
           OOMPH_CURRENT_FUNCTION,
           OOMPH_EXCEPTION_LOCATION);
         break;
     }
  
     // Finally normalise unit normal
     double length = VectorHelpers::magnitude(unit_normal);
     for (unsigned i = 0; i < spatial_dim; i++)
     {
       unit_normal[i] *= Normal_sign / length;
     }
   }

References Bulk_element_pt, bulk_position_type(), oomph::VectorHelpers::cross(), oomph::FiniteElement::dim(), oomph::FiniteElement::dshape_local(), get_ds_bulk_ds_face(), get_local_coordinate_in_bulk(), i, j, k, oomph::VectorHelpers::magnitude(), oomph::FiniteElement::nnodal_position_type(), oomph::FiniteElement::nnode(), oomph::FiniteElement::nodal_dimension(), oomph::FiniteElement::nodal_position_gen(), WallFunction::normal(), Normal_sign, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and s.

◆ output_zeta()

void oomph::FaceElement::output_zeta	(	std::ostream &	outfile,
		const unsigned &	nplot
	)

Output boundary coordinate zeta.

   {
     // Vector of local coordinates
     unsigned n_dim = dim();
     Vector<double> s(n_dim);
  
     // Tecplot header info
     outfile << tecplot_zone_string(nplot);
  
     // Loop over plot points
     unsigned num_plot_points = nplot_points(nplot);
     for (unsigned iplot = 0; iplot < num_plot_points; iplot++)
     {
       // Get local coordinates of plot point
       get_s_plot(iplot, nplot, s);
  
       // Spatial coordinates are one higher
       for (unsigned i = 0; i < n_dim + 1; i++)
       {
         outfile << interpolated_x(s, i) << " ";
       }
  
       // Boundary coordinate
       Vector<double> zeta(n_dim);
       interpolated_zeta(s, zeta);
       for (unsigned i = 0; i < n_dim; i++)
       {
         outfile << zeta[i] << " ";
       }
       outfile << std::endl;
     }
  
     // Write tecplot footer (e.g. FE connectivity lists)
     write_tecplot_zone_footer(outfile, nplot);
   }

References oomph::FiniteElement::dim(), oomph::FiniteElement::get_s_plot(), i, interpolated_x(), oomph::FiniteElement::interpolated_zeta(), oomph::FiniteElement::nplot_points(), s, oomph::FiniteElement::tecplot_zone_string(), oomph::FiniteElement::write_tecplot_zone_footer(), and Eigen::zeta().

◆ resize_nodes()

void oomph::FaceElement::resize_nodes ( Vector< unsigned > & nadditional_data_values )

inline

Provide additional storage for a specified number of values at the nodes of the FaceElement. (This is needed, for instance, in free-surface elements, if the non-penetration condition is imposed by Lagrange multipliers whose values are only stored at the surface nodes but not in the interior of the bulk element). nadditional_data_values[n] specifies the number of additional values required at node n of the FaceElement. Note: Since this function is executed separately for each FaceElement, nodes that are common to multiple elements might be resized repeatedly. To avoid this, we only allow a single resize operation by comparing the number of values stored at each node to the number of values the node had when it was simply a member of the associated "bulk" element. There are cases where this will break! – e.g. if a node is common to two FaceElements which require additional storage for distinct quantities. Such cases need to be handled by "hand-crafted" face elements.

     {
       // Locally cache the number of node
       unsigned n_node = nnode();
       // Resize the storage for values at the nodes:
       for (unsigned l = 0; l < n_node; l++)
       {
         // Find number of values stored at the node
         unsigned Initial_Nvalue = node_pt(l)->nvalue();
         // Read out the number of additional values
         unsigned Nadditional = nadditional_data_values[l];
         // If the node has not already been resized, resize it
         if ((Initial_Nvalue == Nbulk_value[l]) && (Nadditional > 0))
         {
           // Resize the node according to the number of additional values
           node_pt(l)->resize(Nbulk_value[l] + Nadditional);
         }
       } // End of loop over nodes
     }

References Nbulk_value, oomph::FiniteElement::nnode(), oomph::FiniteElement::node_pt(), oomph::Data::nvalue(), and oomph::Node::resize().

Referenced by oomph::ClampedHermiteShellBoundaryConditionElement::ClampedHermiteShellBoundaryConditionElement(), and oomph::ClampedSlidingHermiteBeamBoundaryConditionElement::ClampedSlidingHermiteBeamBoundaryConditionElement().

◆ set_boundary_number_in_bulk_mesh()

void oomph::FaceElement::set_boundary_number_in_bulk_mesh ( const unsigned & b )

inline

Set function for the boundary number in bulk mesh.

     {
       Boundary_number_in_bulk_mesh = b;
 #ifdef PARANOID
       Boundary_number_in_bulk_mesh_has_been_set = true;
 #endif
     }

References b, and Boundary_number_in_bulk_mesh.

Referenced by TurekProblem< FLUID_ELEMENT, SOLID_ELEMENT >::actions_after_distribute(), TurekProblem< FLUID_ELEMENT, SOLID_ELEMENT >::build_mesh(), oomph::BrickFromTetMesh< ELEMENT >::build_mesh(), PressureWaveFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::create_fluid_traction_elements(), PseudoSolidCapProblem< ELEMENT >::create_free_surface_elements(), AxisymmetricVibratingShellProblem< ELEMENT >::create_free_surface_elements(), VibratingShellProblem< ELEMENT >::create_free_surface_elements(), TwoLayerInterfaceProblem< ELEMENT >::create_free_surface_elements(), RisingBubbleProblem< ELEMENT >::create_free_surface_elements(), BubbleInChannelProblem< ELEMENT >::create_free_surface_elements(), DropInChannelProblem< ELEMENT >::create_free_surface_elements(), CoatedDiskProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::create_fsi_traction_elements(), CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::create_fsi_traction_elements(), PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::create_fsi_traction_elements(), UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::create_fsi_traction_elements(), CoatedDiskProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::create_helmholtz_fsi_flux_elements(), CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::create_helmholtz_fsi_flux_elements(), CoatedDiskProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::create_solid_traction_elements(), CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::create_solid_traction_elements(), PressureWaveFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::create_solid_traction_elements(), AnnularDiskProblem< ELASTICITY_ELEMENT >::create_traction_elements(), RingWithTRibProblem< ELASTICITY_ELEMENT >::create_traction_elements(), oomph::Mesh::doc_boundary_coordinates(), TurekProblem< FLUID_ELEMENT, SOLID_ELEMENT >::generic_actions_after(), oomph::NonLinearElasticitySmoothMesh< ELEMENT >::operator()(), oomph::Multi_domain_functions::setup_bulk_elements_adjacent_to_face_mesh(), oomph::RefineableTetgenMesh< ELEMENT >::snap_nodes_onto_boundary(), oomph::ThinLayerBrickOnTetMesh< ELEMENT >::ThinLayerBrickOnTetMesh(), TurekProblem< FLUID_ELEMENT, SOLID_ELEMENT >::TurekProblem(), and oomph::RefineableTetgenMesh< ELEMENT >::update_faceted_surface_using_face_mesh().

◆ set_tangent_direction()

void oomph::FaceElement::set_tangent_direction ( Vector< double > * tangent_direction_pt )

inline

Set the tangent direction vector.

     {
 #ifdef PARANOID
       // Check that tangent_direction_pt is not null.
       if (tangent_direction_pt == 0)
       {
         std::ostringstream error_message;
         error_message << "The pointer tangent_direction_pt is null.\n";
         throw OomphLibError(error_message.str(),
                             OOMPH_CURRENT_FUNCTION,
                             OOMPH_EXCEPTION_LOCATION);
       }
  
       // Check that the vector is the correct size.
       // The size of the tangent vector.
       unsigned tang_dir_size = tangent_direction_pt->size();
       unsigned spatial_dimension = this->nodal_dimension();
       if (tang_dir_size != spatial_dimension)
       {
         std::ostringstream error_message;
         error_message << "The tangent direction vector has size "
                       << tang_dir_size << "\n"
                       << "but this element has spatial dimension "
                       << spatial_dimension << ".\n";
         throw OomphLibError(error_message.str(),
                             OOMPH_CURRENT_FUNCTION,
                             OOMPH_EXCEPTION_LOCATION);
       }
  
       if (tang_dir_size == 2)
       {
         std::ostringstream warning_message;
         warning_message
           << "The spatial dimension is " << spatial_dimension << ".\n"
           << "I do not need a tangent direction vector to create \n"
           << "continuous tangent vectors in two spatial dimensions.";
         OomphLibWarning(warning_message.str(),
                         OOMPH_CURRENT_FUNCTION,
                         OOMPH_EXCEPTION_LOCATION);
       }
 #endif
  
       // Set the direction vector for the tangent.
       Tangent_direction_pt = tangent_direction_pt;
     }

References oomph::FiniteElement::nodal_dimension(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, Tangent_direction_pt, and tangent_direction_pt().

◆ tangent_direction_pt()

const Vector<double>* oomph::FaceElement::tangent_direction_pt ( ) const

inline

Public access function for the tangent direction pointer.

     {
       return Tangent_direction_pt;
     }

References Tangent_direction_pt.

Referenced by set_tangent_direction().

◆ turn_off_warning_for_discontinuous_tangent()

void oomph::FaceElement::turn_off_warning_for_discontinuous_tangent ( )

inline

Turn off warning for when there may be discontinuous tangent vectors from continuous_tangent_and_outer_unit_normal(...)

     {
       FaceElement::Ignore_discontinuous_tangent_warning = false;
     }

References Ignore_discontinuous_tangent_warning.

◆ turn_on_warning_for_discontinuous_tangent()

void oomph::FaceElement::turn_on_warning_for_discontinuous_tangent ( )

inline

Turn on warning for when there may be discontinuous tangent vectors from continuous_tangent_and_outer_unit_normal(...)

     {
       FaceElement::Ignore_discontinuous_tangent_warning = true;
     }

References Ignore_discontinuous_tangent_warning.

◆ zeta_nodal()

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

inlinevirtual

In a FaceElement, the "global" intrinsic coordinate of the element along the boundary, when viewed as part of a compound geometric object is specified using the boundary coordinate defined by the mesh. Note: Boundary coordinates will have been set up when creating the underlying mesh, and their values will have been stored at the nodes.

Reimplemented from oomph::FiniteElement.

     {
       // Vector in which to hold the intrinsic coordinate
       Vector<double> zeta(this->dim());
  
       // Get the k-th generalised boundary coordinate at node n
       this->node_pt(n)->get_coordinates_on_boundary(
         Boundary_number_in_bulk_mesh, k, zeta);
  
       // Return the individual coordinate
       return zeta[i];
     }

References Boundary_number_in_bulk_mesh, oomph::FiniteElement::dim(), oomph::Node::get_coordinates_on_boundary(), i, k, oomph::FiniteElement::node_pt(), and Eigen::zeta().

Member Data Documentation

◆ Boundary_number_in_bulk_mesh

unsigned oomph::FaceElement::Boundary_number_in_bulk_mesh

protected

The boundary number in the bulk mesh to which this element is attached.

Referenced by boundary_number_in_bulk_mesh(), set_boundary_number_in_bulk_mesh(), oomph::ImposeDisplacementByLagrangeMultiplierElement< ELEMENT >::set_boundary_shape_geom_object_pt(), and zeta_nodal().

◆ Bulk_coordinate_derivatives_fct_pt

BulkCoordinateDerivativesFctPt oomph::FaceElement::Bulk_coordinate_derivatives_fct_pt

private

Pointer to a function that returns the derivatives of the local "bulk" coordinates with respect to the local face coordinates.

Referenced by bulk_coordinate_derivatives_fct_pt(), and get_ds_bulk_ds_face().

◆ Bulk_element_pt

FiniteElement* oomph::FaceElement::Bulk_element_pt

protected

Pointer to the associated higher-dimensional "bulk" element.

Referenced by bulk_element_pt(), continuous_tangent_and_outer_unit_normal(), oomph::ImposeImpenetrabilityElement< ELEMENT >::get_dof_numbers_for_unknowns(), oomph::ImposeParallelOutflowElement< ELEMENT >::get_dof_numbers_for_unknowns(), local_coordinate_in_bulk(), and outer_unit_normal().

◆ Bulk_node_number

Vector<unsigned> oomph::FaceElement::Bulk_node_number

protected

List of indices of the local node numbers in the "bulk" element that correspond to the local node numbers in the FaceElement

Referenced by bulk_node_number(), bulk_node_number_resize(), oomph::ImposeImpenetrabilityElement< ELEMENT >::get_dof_numbers_for_unknowns(), oomph::ImposeParallelOutflowElement< ELEMENT >::get_dof_numbers_for_unknowns(), and oomph::FluidInterfaceBoundingElement::set_contact_angle().

◆ Bulk_position_type

Vector<unsigned> oomph::FaceElement::Bulk_position_type

private

Vector holding integers to translate additional position types to those of the "bulk" element; e.g. Bulk_position_type(1) is the position type of the "bulk" element that corresponds to face position type 1. This is required in QHermiteElements, where the slope in the direction of the 1D element is face position type 1, but may be position type 1 or 2 in the "bulk" element, depending upon which face, we are located.

Referenced by bulk_position_type(), bulk_position_type_resize(), and FaceElement().

◆ Face_index

int oomph::FaceElement::Face_index

private

Index of the face.

Referenced by face_index().

◆ Face_to_bulk_coordinate_fct_pt

CoordinateMappingFctPt oomph::FaceElement::Face_to_bulk_coordinate_fct_pt

private

Pointer to a function that translates the face coordinate to the coordinate in the bulk element

Referenced by face_to_bulk_coordinate_fct_pt(), get_local_coordinate_in_bulk(), and local_coordinate_in_bulk().

◆ Ignore_discontinuous_tangent_warning

bool oomph::FaceElement::Ignore_discontinuous_tangent_warning = false

staticprivate

Ignores the warning when the tangent vectors from continuous_tangent_and_outer_unit_normal may not be continuous as a result of the unit normal being aligned with the z axis. This can be avoided by supplying a general direction vector for the tangent vector via set_tangent_direction(...).

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

Referenced by continuous_tangent_and_outer_unit_normal(), turn_off_warning_for_discontinuous_tangent(), and turn_on_warning_for_discontinuous_tangent().

◆ Nbulk_value

Vector<unsigned> oomph::FaceElement::Nbulk_value

protected

A vector that will hold the number of data values at the nodes that are associated with the "bulk" element. i.e. not including any additional degrees of freedom that might be required for extra equations that are being solved by the FaceElement.

Referenced by oomph::ClampedSlidingHermiteBeamBoundaryConditionElement::fill_in_contribution_to_residuals(), oomph::ClampedHermiteShellBoundaryConditionElement::fill_in_contribution_to_residuals(), nbulk_value(), nbulk_value_resize(), oomph::ClampedHermiteShellBoundaryConditionElement::output(), and resize_nodes().

◆ Normal_sign

int oomph::FaceElement::Normal_sign

private

Sign of outer unit normal (relative to cross-products of tangent vectors in the corresponding "bulk" element.

Referenced by continuous_tangent_and_outer_unit_normal(), normal_sign(), and outer_unit_normal().

◆ Tangent_direction_pt

Vector<double>* oomph::FaceElement::Tangent_direction_pt

protected

A general direction pointer for the tangent vectors. This is used in the function continuous_tangent_and_outer_unit_normal() for creating continuous tangent vectors in spatial dimensions. The general direction is projected on to the surface. This technique is not required in two spatial dimensions.

Referenced by continuous_tangent_and_outer_unit_normal(), set_tangent_direction(), and tangent_direction_pt().

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

Public Member Functions

Protected Member Functions

Protected Attributes

Private Types

Private Attributes

Static Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ BulkCoordinateDerivativesFctPt

◆ CoordinateMappingFctPt

Constructor & Destructor Documentation

◆ FaceElement() [1/2]

◆ ~FaceElement()

◆ FaceElement() [2/2]

Member Function Documentation

◆ add_additional_values()

◆ boundary_number_in_bulk_mesh()

◆ bulk_coordinate_derivatives_fct_pt() [1/2]

◆ bulk_coordinate_derivatives_fct_pt() [2/2]

◆ bulk_element_pt() [1/2]

◆ bulk_element_pt() [2/2]

◆ bulk_node_number() [1/2]

◆ bulk_node_number() [2/2]

◆ bulk_node_number_resize()

◆ bulk_position_type() [1/2]

◆ bulk_position_type() [2/2]

◆ bulk_position_type_resize()

◆ check_J_eulerian_at_knots()

◆ continuous_tangent_and_outer_unit_normal() [1/2]

◆ continuous_tangent_and_outer_unit_normal() [2/2]

◆ face_index() [1/2]

◆ face_index() [2/2]

◆ face_to_bulk_coordinate_fct_pt() [1/2]

◆ face_to_bulk_coordinate_fct_pt() [2/2]

◆ get_ds_bulk_ds_face()

◆ get_local_coordinate_in_bulk()

◆ interpolated_dxdt() [1/2]

◆ interpolated_dxdt() [2/2]

◆ interpolated_x() [1/4]

◆ interpolated_x() [2/4]

◆ interpolated_x() [3/4]

◆ interpolated_x() [4/4]

◆ J_eulerian()

◆ J_eulerian_at_knot()

◆ local_coordinate_in_bulk()

◆ nbulk_value() [1/2]

◆ nbulk_value() [2/2]

◆ nbulk_value_resize()

◆ normal_sign() [1/2]

◆ normal_sign() [2/2]

◆ outer_unit_normal() [1/2]

◆ outer_unit_normal() [2/2]

◆ output_zeta()

◆ resize_nodes()

◆ set_boundary_number_in_bulk_mesh()

◆ set_tangent_direction()

◆ tangent_direction_pt()

◆ turn_off_warning_for_discontinuous_tangent()

◆ turn_on_warning_for_discontinuous_tangent()

◆ zeta_nodal()

Member Data Documentation

◆ Boundary_number_in_bulk_mesh

◆ Bulk_coordinate_derivatives_fct_pt

◆ Bulk_element_pt

◆ Bulk_node_number

◆ Bulk_position_type

◆ Face_index

◆ Face_to_bulk_coordinate_fct_pt

◆ Ignore_discontinuous_tangent_warning

◆ Nbulk_value

◆ Normal_sign

◆ Tangent_direction_pt