#include <refineable_elements.h>

Inheritance diagram for oomph::RefineableElement:

Public Member Functions
	RefineableElement ()

virtual	~RefineableElement ()
	Destructor, delete the allocated storage for the hanging equations. More...

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

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

Tree *	tree_pt ()
	Access function: Pointer to quadtree representation of this element. More...

void	set_tree_pt (Tree *my_tree_pt)
	Set pointer to quadtree representation of this element. More...

virtual unsigned	required_nsons () const

bool	refinement_is_enabled ()
	Flag to indicate suppression of any refinement. More...

void	disable_refinement ()
	Suppress of any refinement for this element. More...

void	enable_refinement ()
	Emnable refinement for this element. More...

template<class ELEMENT >
void	split (Vector< ELEMENT * > &son_pt) const

int	local_hang_eqn (Node *const &node_pt, const unsigned &i)

virtual void	build (Mesh &mesh_pt, Vector< Node > &new_node_pt, bool &was_already_built, std::ofstream &new_nodes_file)=0

void	set_refinement_level (const int &refine_level)
	Set the refinement level. More...

unsigned	refinement_level () const
	Return the Refinement level. More...

void	select_for_refinement ()
	Select the element for refinement. More...

void	deselect_for_refinement ()
	Deselect the element for refinement. More...

void	select_sons_for_unrefinement ()
	Unrefinement will be performed by merging the four sons of this element. More...

void	deselect_sons_for_unrefinement ()

bool	to_be_refined ()
	Has the element been selected for refinement? More...

bool	sons_to_be_unrefined ()
	Has the element been selected for unrefinement? More...

virtual void	rebuild_from_sons (Mesh *&mesh_pt)=0

virtual void	unbuild ()

virtual void	deactivate_element ()

virtual bool	nodes_built ()
	Return true if all the nodes have been built, false if not. More...

long	number () const
	Element number (for debugging/plotting) More...

void	set_number (const long &mynumber)
	Set element number (for debugging/plotting) More...

virtual unsigned	ncont_interpolated_values () const =0

virtual void	get_interpolated_values (const Vector< double > &s, Vector< double > &values)

virtual void	get_interpolated_values (const unsigned &t, const Vector< double > &s, Vector< double > &values)=0

virtual Node *	interpolating_node_pt (const unsigned &n, const int &value_id)

virtual double	local_one_d_fraction_of_interpolating_node (const unsigned &n1d, const unsigned &i, const int &value_id)

virtual Node *	get_interpolating_node_at_local_coordinate (const Vector< double > &s, const int &value_id)

virtual unsigned	ninterpolating_node (const int &value_id)

virtual unsigned	ninterpolating_node_1d (const int &value_id)

virtual void	interpolating_basis (const Vector< double > &s, Shape &psi, const int &value_id) const

virtual void	check_integrity (double &max_error)=0

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

void	assign_nodal_local_eqn_numbers (const bool &store_local_dof_pt)

virtual RefineableElement *	root_element_pt ()

virtual RefineableElement *	father_element_pt () const
	Return a pointer to the father element. More...

void	get_father_at_refinement_level (unsigned &refinement_level, RefineableElement *&father_at_reflevel_pt)

virtual void	initial_setup (Tree *const &adopted_father_pt=0, const unsigned &initial_p_order=0)

virtual void	pre_build (Mesh &mesh_pt, Vector< Node > &new_node_pt)
	Pre-build the element. More...

virtual void	further_build ()
	Further build: e.g. deal with interpolation of internal values. More...

virtual void	setup_hanging_nodes (Vector< std::ofstream * > &output_stream)

virtual void	further_setup_hanging_nodes ()

void	get_dresidual_dnodal_coordinates (RankThreeTensor< double > &dresidual_dnodal_coordinates)

unsigned	nshape_controlling_nodes ()

std::map< Node *, unsigned >	shape_controlling_node_lookup ()

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

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

virtual double	J_eulerian_at_knot (const unsigned &ipt) const

void	check_J_eulerian_at_knots (bool &passed) const

void	check_jacobian (const double &jacobian) const

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

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

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

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

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

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

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

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

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

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

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

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

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)

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

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

Static Public Member Functions
static double &	max_integrity_tolerance ()
	Max. allowed discrepancy in element integrity check. More...

Protected Member Functions
void	assemble_local_to_eulerian_jacobian (const DShape &dpsids, DenseMatrix< double > &jacobian) const

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

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

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

void	assign_hanging_local_eqn_numbers (const bool &store_local_dof_pt)
	Assign the local equation numbers for hanging node variables. More...

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

Protected Member Functions inherited from oomph::FiniteElement
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 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

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)

Static Protected Member Functions
static void	check_value_id (const int &n_continuously_interpolated_values, const int &value_id)

Protected Attributes
Tree *	Tree_pt
	A pointer to a general tree object. More...

unsigned	Refine_level
	Refinement level. More...

bool	To_be_refined
	Flag for refinement. More...

bool	Refinement_is_enabled
	Flag to indicate suppression of any refinement. More...

bool	Sons_to_be_unrefined
	Flag for unrefinement. More...

long	Number
	Global element number – for plotting/validation purposes. More...

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

Static Protected Attributes
static double	Max_integrity_tolerance = 1.0e-8
	Max. allowed discrepancy in element integrity check. More...

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

Private Attributes
std::map< Node , int >	Local_hang_eqn

std::map< Node *, unsigned >	Shape_controlling_node_lookup

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

Detailed Description

RefineableElements are FiniteElements that may be subdivided into children to provide a better local approximation to the solution. After non-uniform refinement adjacent elements need not necessarily have nodes in common. A node that does not have a counterpart in its neighbouring element is known as a hanging node and its position and any data that it stores must be constrained to ensure inter-element continuity.

Generic data and function interfaces associated with refinement are defined in this class.

Additional data includes:

a pointer to a general Tree object that is used to track the refinement history,
a refinement level (not necessarily the same as the level in the tree!),
a flag indicating whether the element should be refined,
a flag indicating whether the element should be de-refined,
a global element number for plotting/validation purposes,
storage for local equation numbers associated with hanging nodes.

Additional functions perform the following generic tasks:

provide access to additional data,
setup local equation numbering for data associated with hanging nodes,
generic finite-difference calculation of contributions to the elemental jacobian from nodal data to include hanging nodes,
split of the element into its sons,
select and deselect the element for refinement,
select and deselect the sons of the element for de-refinement (merging),

In addition, there are a number of interfaces that specify element-specific tasks. These should be overloaded in RefineableElements of particular geometric types and perform the following tasks:

return a pointer to the root and father elements in the tree structure,
define the number of sons into which the element is divided,
build the element: construct nodes, assign their positions, values and any boundary conditions,
recreate the element from its sons if they are merged,
deactivate the element, perform any operations that are required when the element is still in the tree, but no longer active
set the number and provide access to the values interpolated by the nodes,
setup the hanging nodes

In mixed element different sets of nodes are used to interpolate different unknowns. Interfaces are provided for functions that can be used to find the position of the nodes that interpolate the different unknowns. These functions are used to setup hanging node information automatically in particular elements, e.g. Taylor Hood Navier–Stokes. The default implementation assumes that the elements are isoparameteric.

Constructor & Destructor Documentation

◆ RefineableElement() [1/2]

oomph::RefineableElement::RefineableElement ( )

inline

Constructor, calls the FiniteElement constructor and initialises the member data

       : FiniteElement(),
         Tree_pt(0),
         Refine_level(0),
         To_be_refined(false),
         Refinement_is_enabled(true),
         Sons_to_be_unrefined(false),
         Number(-1),
         Local_hang_eqn(0)
     {
     }

◆ ~RefineableElement()

oomph::RefineableElement::~RefineableElement ( )

virtual

Destructor, delete the allocated storage for the hanging equations.

Destructor (needed here because of IBM xlC compiler under AIX) Delete the storage allocated for the local equations.

   {
     delete[] Local_hang_eqn;
   }

References Local_hang_eqn.

◆ RefineableElement() [2/2]

oomph::RefineableElement::RefineableElement ( const RefineableElement & )

delete

Broken copy constructor.

Member Function Documentation

◆ assemble_eulerian_base_vectors()

void oomph::RefineableElement::assemble_eulerian_base_vectors	(	const DShape &	dpsids,
		DenseMatrix< double > &	interpolated_G
	)		const

protectedvirtual

Assemble the covariant Eulerian base vectors, assuming that the derivatives of the shape functions with respect to the local coordinates have already been constructed. Overload the standard version to account for hanging nodes.

Assemble the covariant Eulerian base vectors and return them in the matrix interpolated_G. The derivatives of the shape functions with respect to the local coordinate should already have been calculated before calling this function

Reimplemented from oomph::FiniteElement.

   {
     // Find the number of nodes and position types
     const unsigned n_node = nnode();
     const unsigned n_position_type = nnodal_position_type();
     // Find the dimension of the node and element
     const unsigned n_dim_node = nodal_dimension();
     const unsigned n_dim_element = dim();
  
     // Loop over the dimensions and compute the entries of the
     // base vector matrix
     for (unsigned i = 0; i < n_dim_element; i++)
     {
       for (unsigned j = 0; j < n_dim_node; j++)
       {
         // Initialise the j-th component of the i-th base vector to zero
         interpolated_G(i, j) = 0.0;
         for (unsigned l = 0; l < n_node; l++)
         {
           for (unsigned k = 0; k < n_position_type; k++)
           {
             interpolated_G(i, j) +=
               nodal_position_gen(l, k, j) * dpsids(l, k, i);
           }
         }
       }
     }
   }

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

◆ assemble_local_to_eulerian_jacobian()

void oomph::RefineableElement::assemble_local_to_eulerian_jacobian	(	const DShape &	dpsids,
		DenseMatrix< double > &	jacobian
	)		const

protectedvirtual

Assemble the jacobian matrix for the mapping from local to Eulerian coordinates, given the derivatives of the shape function w.r.t the local coordinates. Overload the standard version to use the hanging information for the Eulerian coordinates.

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

Reimplemented from oomph::FiniteElement.

   {
     // Locally cache the elemental dimension
     const unsigned el_dim = dim();
     // The number of shape functions must be equal to the number
     // of nodes (by definition)
     const unsigned n_shape = nnode();
     // The number of shape function types must be equal to the number
     // of nodal position types (by definition)
     const unsigned n_shape_type = nnodal_position_type();
  
 #ifdef PARANOID
     // Check for dimensional compatibility
     if (dim() != nodal_dimension())
     {
       std::ostringstream error_message;
       error_message << "Dimension mismatch" << std::endl;
       error_message << "The elemental dimension: " << dim()
                     << " must equal the nodal dimension: " << nodal_dimension()
                     << " for the jacobian of the mapping to be well-defined"
                     << std::endl;
       throw OomphLibError(
         error_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
 #endif
  
     // Loop over the rows of the jacobian
     for (unsigned i = 0; i < el_dim; i++)
     {
       // Loop over the columns of the jacobian
       for (unsigned j = 0; j < el_dim; j++)
       {
         // Zero the entry
         jacobian(i, j) = 0.0;
         // Loop over the shape functions
         for (unsigned l = 0; l < n_shape; l++)
         {
           for (unsigned k = 0; k < n_shape_type; k++)
           {
             // Jacobian is dx_j/ds_i, which is represented by the sum
             // over the dpsi/ds_i of the nodal points X j
             // Call the Hanging version of positions
             jacobian(i, j) += nodal_position_gen(l, k, j) * dpsids(l, k, i);
           }
         }
       }
     }
   }

References oomph::FiniteElement::dim(), el_dim, i, j, k, oomph::FiniteElement::nnodal_position_type(), oomph::FiniteElement::nnode(), oomph::FiniteElement::nodal_dimension(), oomph::FiniteElement::nodal_position_gen(), OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

◆ assemble_local_to_eulerian_jacobian2()

void oomph::RefineableElement::assemble_local_to_eulerian_jacobian2	(	const DShape &	d2psids,
		DenseMatrix< double > &	jacobian2
	)		const

protectedvirtual

Assemble the the "jacobian" matrix of second derivatives of the mapping from local to Eulerian coordinates, given the second derivatives of the shape functions w.r.t. local coordinates. Overload the standard version to use the hanging information for the Eulerian coordinates.

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

Reimplemented from oomph::FiniteElement.

   {
     // Find the the dimension of the element
     const unsigned el_dim = dim();
     // Find the number of shape functions and shape functions types
     // Must be equal to the number of nodes and their position types
     // by the definition of the shape function.
     const unsigned n_shape = nnode();
     const unsigned n_shape_type = nnodal_position_type();
     // Find the number of second derivatives
     const unsigned n_row = N2deriv[el_dim];
  
     // Assemble the "jacobian" (d^2 x_j/ds_i^2) for second derivatives of
     // shape functions
     // Loop over the rows (number of second derivatives)
     for (unsigned i = 0; i < n_row; i++)
     {
       // Loop over the columns (element dimension
       for (unsigned j = 0; j < el_dim; j++)
       {
         // Zero the entry
         jacobian2(i, j) = 0.0;
         // Loop over the shape functions
         for (unsigned l = 0; l < n_shape; l++)
         {
           // Loop over the shape function types
           for (unsigned k = 0; k < n_shape_type; k++)
           {
             // Add the terms to the jacobian entry
             // Call the Hanging version of positions
             jacobian2(i, j) += nodal_position_gen(l, k, j) * d2psids(l, k, i);
           }
         }
       }
     }
   }

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

◆ assign_hanging_local_eqn_numbers()

void oomph::RefineableElement::assign_hanging_local_eqn_numbers ( const bool & store_local_dof_pt )

protected

Assign the local equation numbers for hanging node variables.

Assign the local hang eqn.

   {
     // Find the number of nodes
     const unsigned n_node = nnode();
  
     // Check there are nodes!
     if (n_node > 0)
     {
       // Find the number of continuously interpolated values
       const unsigned n_cont_values = ncont_interpolated_values();
  
       // Delete the storage associated with the local hanging equation schemes
       delete[] Local_hang_eqn;
       // Allocate new storage
       Local_hang_eqn = new std::map<Node*, int>[n_cont_values];
  
       // Boolean that is set to true if there are hanging equation numbers
       bool hanging_eqn_numbers = false;
  
       // Maps that store whether the node's local equation number for a
       // particular value has already been assigned
       Vector<std::map<Node*, bool>> local_eqn_number_done(n_cont_values);
  
       // Get number of dofs assigned thus far
       unsigned local_eqn_number = ndof();
  
       // A local queue to store the global equation numbers
       std::deque<unsigned long> global_eqn_number_queue;
  
       // Now loop over all the nodes again to find the master nodes
       // external to the element
       for (unsigned n = 0; n < n_node; n++)
       {
         // Loop over the number of continuously-interpolated values at the node
         for (unsigned j = 0; j < n_cont_values; j++)
         {
           // If the node is hanging node in value j
           if (node_pt(n)->is_hanging(j))
           {
             // Get the pointer to the appropriate hanging info object
             HangInfo* hang_info_pt = node_pt(n)->hanging_pt(j);
             // Find the number of master nodes
             unsigned n_master = hang_info_pt->nmaster();
             // Loop over the master nodes
             for (unsigned m = 0; m < n_master; m++)
             {
               // Get the m-th master node
               Node* Master_node_pt = hang_info_pt->master_node_pt(m);
  
               // If the master node's value has not been considered already,
               // give it a local equation number
               if (local_eqn_number_done[j][Master_node_pt] == false)
               {
 #ifdef PARANOID
                 // Check that the value is stored at the master node
                 // If not the master node must have be set up incorrectly
                 if (Master_node_pt->nvalue() < j)
                 {
                   std::ostringstream error_stream;
                   error_stream << "Master node for " << j
                                << "-th value only has "
                                << Master_node_pt->nvalue() << " stored values!"
                                << std::endl;
  
                   throw OomphLibError(error_stream.str(),
                                       OOMPH_CURRENT_FUNCTION,
                                       OOMPH_EXCEPTION_LOCATION);
                 }
 #endif
  
                 // We now need to test whether the master node is actually
                 // a local node, in which case its local equation number
                 // will already have been assigned and will be stored
                 // in nodal_local_eqn
  
                 // Storage for the index of the local node
                 // Initialised to n_node (beyond the possible indices of
                 //"real" nodes)
                 unsigned local_node_index = n_node;
                 // Loop over the local nodes (again)
                 for (unsigned n1 = 0; n1 < n_node; n1++)
                 {
                   // If the master node is a local node
                   // get its index and break out of the loop
                   if (Master_node_pt == node_pt(n1))
                   {
                     local_node_index = n1;
                     break;
                   }
                 }
  
                 // Now we test whether the node was found
                 if (local_node_index < n_node)
                 {
                   // Copy the local equation number to the
                   // pointer-based look-up scheme
                   Local_hang_eqn[j][Master_node_pt] =
                     nodal_local_eqn(local_node_index, j);
                 }
                 // Otherwise it's a new master node
                 else
                 {
                   // Get the equation number
                   long eqn_number = Master_node_pt->eqn_number(j);
                   // If equation_number positive add to array
                   if (eqn_number >= 0)
                   {
                     // Add global equation number to the queue
                     global_eqn_number_queue.push_back(eqn_number);
                     // Add pointer to the dof to the queue if required
                     if (store_local_dof_pt)
                     {
                       GeneralisedElement::Dof_pt_deque.push_back(
                         Master_node_pt->value_pt(j));
                     }
                     // Add to pointer based scheme
                     Local_hang_eqn[j][Master_node_pt] = local_eqn_number;
                     // Increase number of local variables
                     local_eqn_number++;
                   }
                   // Otherwise the value is pinned
                   else
                   {
                     Local_hang_eqn[j][Master_node_pt] = Data::Is_pinned;
                   }
                   // There are now hanging equation numbers
                 }
                 // The value at this node has now been done
                 local_eqn_number_done[j][Master_node_pt] = true;
                 // There are hanging equation numbers
                 hanging_eqn_numbers = true;
               }
             }
           }
         }
       } // End of second loop over nodes
  
       // Now add our global equations numbers to the internal element storage
       add_global_eqn_numbers(global_eqn_number_queue,
                              GeneralisedElement::Dof_pt_deque);
       // Clear the memory used in the deque
       if (store_local_dof_pt)
       {
         std::deque<double*>().swap(GeneralisedElement::Dof_pt_deque);
       }
  
  
       // If there are no hanging_eqn_numbers delete the (empty) stored maps
       if (!hanging_eqn_numbers)
       {
         delete[] Local_hang_eqn;
         Local_hang_eqn = 0;
       }
  
  
       // Setup map that associates a unique number with any of the nodes
       // that actively control the shape of the element (i.e. they are
       // either non-hanging nodes of this element or master nodes
       // of hanging nodes.
       unsigned count = 0;
       std::set<Node*> all_nodes;
       Shape_controlling_node_lookup.clear();
       for (unsigned j = 0; j < n_node; j++)
       {
         // Get node
         Node* nod_pt = node_pt(j);
  
         // If the node is hanging, consider master nodes
         if (nod_pt->is_hanging())
         {
           HangInfo* hang_info_pt = node_pt(j)->hanging_pt();
           unsigned n_master = hang_info_pt->nmaster();
  
           // Loop over the master nodes
           for (unsigned m = 0; m < n_master; m++)
           {
             Node* master_node_pt = hang_info_pt->master_node_pt(m);
             // Do we have this one already?
             unsigned old_size = all_nodes.size();
             all_nodes.insert(master_node_pt);
             if (all_nodes.size() > old_size)
             {
               Shape_controlling_node_lookup[master_node_pt] = count;
               count++;
             }
           }
         }
         // Not hanging: Consider the node itself
         else
         {
           // Do we have this one already?
           unsigned old_size = all_nodes.size();
           all_nodes.insert(nod_pt);
           if (all_nodes.size() > old_size)
           {
             Shape_controlling_node_lookup[nod_pt] = count;
             count++;
           }
         }
       }
  
     } // End of if nodes
   }

References oomph::GeneralisedElement::add_global_eqn_numbers(), oomph::GeneralisedElement::Dof_pt_deque, oomph::Data::eqn_number(), oomph::GeneralisedElement::eqn_number(), oomph::Node::hanging_pt(), oomph::Node::is_hanging(), oomph::Data::Is_pinned, j, oomph::GeneralisedElement::local_eqn_number(), Local_hang_eqn, m, oomph::HangInfo::master_node_pt(), n, ncont_interpolated_values(), oomph::GeneralisedElement::ndof(), oomph::HangInfo::nmaster(), oomph::FiniteElement::nnode(), oomph::FiniteElement::nodal_local_eqn(), oomph::FiniteElement::node_pt(), oomph::Data::nvalue(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, Shape_controlling_node_lookup, and oomph::Data::value_pt().

Referenced by assign_nodal_local_eqn_numbers().

◆ assign_nodal_local_eqn_numbers()

void oomph::RefineableElement::assign_nodal_local_eqn_numbers ( const bool & store_local_dof_pt )

inlinevirtual

Overload the function that assigns local equation numbers for the Data stored at the nodes so that hanging data is taken into account

Reimplemented from oomph::FiniteElement.

     {
       FiniteElement::assign_nodal_local_eqn_numbers(store_local_dof_pt);
       assign_hanging_local_eqn_numbers(store_local_dof_pt);
     }

References assign_hanging_local_eqn_numbers(), and oomph::FiniteElement::assign_nodal_local_eqn_numbers().

◆ build()

virtual void oomph::RefineableElement::build	(	Mesh *&	mesh_pt,
		Vector< Node * > &	new_node_pt,
		bool &	was_already_built,
		std::ofstream &	new_nodes_file
	)

pure virtual

Interface to function that builds the element: i.e. construct the nodes, assign their positions, apply boundary conditions, etc. The required procedures depend on the geometrical type of the element and must be implemented in specific refineable elements. Any new nodes created during the build process are returned in the vector new_node_pt.

Implemented in oomph::RefineableSolidQElement< 2 >, oomph::RefineableQElement< 2 >, oomph::RefineableSolidQElement< 1 >, oomph::RefineableQElement< 1 >, oomph::NonRefineableElementWithHangingNodes, oomph::RefineableSolidQElement< 3 >, and oomph::RefineableQElement< 3 >.

◆ check_integrity()

virtual void oomph::RefineableElement::check_integrity ( double & max_error )

pure virtual

Check the integrity of the element: Continuity of positions values, etc. Essentially, check that the approximation of the functions is consistent when viewed from both sides of the element boundaries Must be overloaded for each different geometric element

Implemented in oomph::RefineableQElement< 2 >, oomph::RefineableQElement< 1 >, oomph::NonRefineableElementWithHangingNodes, oomph::RefineableQElement< 3 >, oomph::PRefineableQElement< 3, INITIAL_NNODE_1D >, oomph::PRefineableQElement< 2, INITIAL_NNODE_1D >, and oomph::PRefineableQElement< 1, INITIAL_NNODE_1D >.

◆ check_value_id()

void oomph::RefineableElement::check_value_id	(	const int &	n_continuously_interpolated_values,
		const int &	value_id
	)

staticprotected

Static helper function that is used to check that the value_id is in range

Helper function that is used to check that the value_id is in the range allowed by the element. The number of continuously interpolated values and the value_id must be passed as arguments.

   {
     // If the value_id is more than the number of continuously interpolated
     // values or less than -1 (for the position), we have a problem
     if ((value_id < -1) || (value_id >= n_continuously_interpolated_values))
     {
       std::ostringstream error_stream;
       error_stream << "Value_id " << value_id << " is out of range."
                    << std::endl
                    << "It can only take the values -1 (position) "
                    << "or an integer in the range 0 to "
                    << n_continuously_interpolated_values << std::endl;
  
       throw OomphLibError(
         error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
   }

References OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

Referenced by oomph::RefineableQPVDElementWithContinuousPressure< DIM >::get_interpolating_node_at_local_coordinate(), oomph::RefineableQPVDElementWithContinuousPressure< DIM >::interpolating_basis(), oomph::RefineableQPVDElementWithContinuousPressure< DIM >::interpolating_node_pt(), oomph::RefineableQPVDElementWithContinuousPressure< DIM >::local_one_d_fraction_of_interpolating_node(), oomph::RefineableQPVDElementWithContinuousPressure< DIM >::ninterpolating_node(), and oomph::RefineableQPVDElementWithContinuousPressure< DIM >::ninterpolating_node_1d().

◆ deactivate_element()

void oomph::RefineableElement::deactivate_element ( )

virtual

Final operations that must be performed when the element is no longer active in the mesh, but still resident in the QuadTree.

Deactivate the element by marking setting all local pointers to obsolete nodes to zero

   {
     // Find the number of nodes
     const unsigned n_node = nnode();
     // Loop over the nodes
     for (unsigned n = 0; n < n_node; n++)
     {
       // If the node pointer has not already been nulled, but is obsolete
       // then null it
       if ((this->node_pt(n) != 0) && (this->node_pt(n)->is_obsolete()))
       {
         this->node_pt(n) = 0;
       }
     }
   }

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

Referenced by oomph::Tree::deactivate_object().

◆ deselect_for_refinement()

void oomph::RefineableElement::deselect_for_refinement ( )

inline

Deselect the element for refinement.

     {
       To_be_refined = false;
     }

References To_be_refined.

Referenced by oomph::TreeBasedRefineableMeshBase::adapt().

◆ deselect_sons_for_unrefinement()

void oomph::RefineableElement::deselect_sons_for_unrefinement ( )

inline

No unrefinement will be performed by merging the four sons of this element

     {
       Sons_to_be_unrefined = false;
     }

References Sons_to_be_unrefined.

Referenced by oomph::TreeBasedRefineableMeshBase::adapt(), and oomph::Tree::merge_sons_if_required().

◆ disable_refinement()

void oomph::RefineableElement::disable_refinement ( )

inline

Suppress of any refinement for this element.

     {
       Refinement_is_enabled = false;
     }

References Refinement_is_enabled.

◆ enable_refinement()

void oomph::RefineableElement::enable_refinement ( )

inline

Emnable refinement for this element.

     {
       Refinement_is_enabled = true;
     }

References Refinement_is_enabled.

◆ father_element_pt()

virtual RefineableElement* oomph::RefineableElement::father_element_pt ( ) const

inlinevirtual

Return a pointer to the father element.

     {
       // If we have no tree, we have no father
       if (Tree_pt == 0)
       {
         return 0;
       }
       else
       {
         // Otherwise get the father of the tree
         Tree* father_pt = Tree_pt->father_pt();
         // If the tree has no father then return null, no father
         if (father_pt == 0)
         {
           return 0;
         }
         else
         {
           return father_pt->object_pt();
         }
       }
     }

References oomph::Tree::father_pt(), oomph::Tree::object_pt(), and Tree_pt.

◆ fill_in_jacobian_from_nodal_by_fd()

void oomph::RefineableElement::fill_in_jacobian_from_nodal_by_fd	(	Vector< double > &	residuals,
		DenseMatrix< double > &	jacobian
	)

protectedvirtual

Calculate the contributions to the jacobian from the nodal degrees of freedom using finite differences. This version is overloaded to take hanging node information into account

This function calculates the entries of Jacobian matrix, used in the Newton method, associated with the nodal degrees of freedom. This is done by finite differences to handle the general case Overload the standard case to include hanging node case

Reimplemented from oomph::FiniteElement.

   {
     // Find the number of nodes
     const unsigned n_node = nnode();
  
     // If there are no nodes, return straight away
     if (n_node == 0)
     {
       return;
     }
  
     // Call the update function to ensure that the element is in
     // a consistent state before finite differencing starts
     update_before_nodal_fd();
  
     //  bool use_first_order_fd=false;
  
     // Find the number of dofs in the element
     const unsigned n_dof = ndof();
  
     // Create newres vector
     Vector<double> newres(n_dof); // , newres_minus(n_dof);
  
     // Used default value defined in GeneralisedElement
     const double fd_step = Default_fd_jacobian_step;
  
     // Integer storage for local unknowns
     int local_unknown = 0;
  
     // Loop over the nodes
     for (unsigned n = 0; n < n_node; n++)
     {
       // Get the number of values stored at the node
       const unsigned n_value = node_pt(n)->nvalue();
  
       // Get a pointer to the local node
       Node* const local_node_pt = node_pt(n);
  
       // Loop over the number of values stored at the node
       for (unsigned i = 0; i < n_value; i++)
       {
         // If the nodal value is not hanging
         if (local_node_pt->is_hanging(i) == false)
         {
           // Get the equation number
           local_unknown = nodal_local_eqn(n, i);
           // If the variable is free
           if (local_unknown >= 0)
           {
             // Get a pointer to the nodal value
             double* const value_pt = local_node_pt->value_pt(i);
  
             // Save the old value of nodal value
             const double old_var = *value_pt;
  
             // Increment the nodal value
             *value_pt += fd_step;
  
             // Now update any dependent variables
             update_in_nodal_fd(i);
  
             // Calculate the new residuals
             get_residuals(newres);
  
             //          if (use_first_order_fd)
             {
               // Do forward finite differences
               for (unsigned m = 0; m < n_dof; m++)
               {
                 // Stick the entry into the Jacobian matrix
                 jacobian(m, local_unknown) =
                   (newres[m] - residuals[m]) / fd_step;
               }
             }
             //           else
             //            {
             //             //Take backwards step
             //             *value_pt = old_var - fd_step;
  
             //             //Calculate the new residuals at backward position
             //             get_residuals(newres_minus);
  
             //             //Do central finite differences
             //             for(unsigned m=0;m<n_dof;m++)
             //              {
             //               //Stick the entry into the Jacobian matrix
             //               jacobian(m,local_unknown) =
             //                (newres[m] - newres_minus[m])/(2.0*fd_step);
             //              }
             //            }
  
             // Reset the nodal value
             *value_pt = old_var;
  
             // Reset any dependent variables
             reset_in_nodal_fd(i);
           }
         }
         // Otherwise the value is hanging node
         else
         {
           // Get the local hanging infor
           HangInfo* hang_info_pt = local_node_pt->hanging_pt(i);
           // Loop over the master nodes
           const unsigned n_master = hang_info_pt->nmaster();
           for (unsigned m = 0; m < n_master; m++)
           {
             // Get the pointer to the master node
             Node* const master_node_pt = hang_info_pt->master_node_pt(m);
  
             // Get the number of the unknown
             local_unknown = local_hang_eqn(master_node_pt, i);
             // If the variable is free
             if (local_unknown >= 0)
             {
               // Get a pointer to the nodal value stored at the master node
               double* const value_pt = master_node_pt->value_pt(i);
  
               // Save the old value of the nodal value stored at the master node
               const double old_var = *value_pt;
  
               // Increment the nodal value stored at the master node
               *value_pt += fd_step;
  
               // Now update any dependent variables
               update_in_nodal_fd(i);
  
               // Calculate the new residuals
               get_residuals(newres);
  
               //            if (use_first_order_fd)
               {
                 // Do forward finite differences
                 for (unsigned m = 0; m < n_dof; m++)
                 {
                   // Stick the entry into the Jacobian matrix
                   jacobian(m, local_unknown) =
                     (newres[m] - residuals[m]) / fd_step;
                 }
               }
               //             else
               //              {
               //               //Take backwards step
               //               *value_pt = old_var - fd_step;
  
               //               //Calculate the new residuals at backward
               //               position get_residuals(newres_minus);
  
               //               //Do central finite differences
               //               for(unsigned m=0;m<n_dof;m++)
               //                {
               //                 //Stick the entry into the Jacobian matrix
               //                 jacobian(m,local_unknown) =
               //                  (newres[m] - newres_minus[m])/(2.0*fd_step);
               //                }
               //              }
  
               // Reset the value at the master node
               *value_pt = old_var;
  
               // Reset any dependent variables
               reset_in_nodal_fd(i);
             }
           } // End of loop over master nodes
         } // End of hanging node case
       } // End of loop over values
     } // End of loop over nodes
  
     // End of finite difference loop
     // Final reset of any dependent data
     reset_after_nodal_fd();
   }

References oomph::GeneralisedElement::Default_fd_jacobian_step, oomph::GeneralisedElement::get_residuals(), oomph::Node::hanging_pt(), i, oomph::Node::is_hanging(), local_hang_eqn(), m, oomph::HangInfo::master_node_pt(), n, oomph::GeneralisedElement::ndof(), oomph::HangInfo::nmaster(), oomph::FiniteElement::nnode(), oomph::FiniteElement::nodal_local_eqn(), oomph::FiniteElement::node_pt(), oomph::Data::nvalue(), oomph::FiniteElement::reset_after_nodal_fd(), oomph::FiniteElement::reset_in_nodal_fd(), oomph::FiniteElement::update_before_nodal_fd(), oomph::FiniteElement::update_in_nodal_fd(), and oomph::Data::value_pt().

◆ further_build()

virtual void oomph::RefineableElement::further_build ( )

inlinevirtual

Further build: e.g. deal with interpolation of internal values.

599 {}

Referenced by oomph::RefineableSolidElement::further_build().

◆ further_setup_hanging_nodes()

virtual void oomph::RefineableElement::further_setup_hanging_nodes ( )

inlinevirtual

Perform additional hanging node procedures for variables that are not interpolated by all nodes (e.g. lower order interpolations for the pressure in Taylor Hood).

609 {}

◆ get_dresidual_dnodal_coordinates()

void oomph::RefineableElement::get_dresidual_dnodal_coordinates ( RankThreeTensor< double > & dresidual_dnodal_coordinates )

virtual

Compute derivatives of elemental residual vector with respect to nodal coordinates. Default implementation by FD can be overwritten for specific elements. dresidual_dnodal_coordinates(l,i,j) = d res(l) / dX_{ij} This version is overloaded from the version in FiniteElement and takes hanging nodes into account – j in the above loop loops over all the nodes that actively control the shape of the element (i.e. they are non-hanging or master nodes of hanging nodes in this element).

Reimplemented from oomph::FiniteElement.

Reimplemented in oomph::RefineableSpaceTimeNavierStokesMixedOrderEquations< DIM >, oomph::RefineableSpaceTimeNavierStokesEquations< DIM >, oomph::RefineableSpaceTimeNavierStokesEquations< DIM >, oomph::RefineableSpaceTimeNavierStokesEquations< DIM >, oomph::RefineablePoissonEquations< DIM >, and oomph::RefineableNavierStokesEquations< DIM >.

   {
     // Number of nodes
     unsigned n_nod = nnode();
  
     // If the element has no nodes (why??!!) return straightaway
     if (n_nod == 0) return;
  
     // Get dimension from first node
     unsigned dim_nod = node_pt(0)->ndim();
  
     // Number of dofs
     unsigned n_dof = ndof();
  
     // Get reference residual
     Vector<double> res(n_dof);
     Vector<double> res_pls(n_dof);
     get_residuals(res);
  
     // FD step
     double eps_fd = GeneralisedElement::Default_fd_jacobian_step;
  
     // Do FD loop over all active nodes
     for (std::map<Node*, unsigned>::iterator it =
            Shape_controlling_node_lookup.begin();
          it != Shape_controlling_node_lookup.end();
          it++)
     {
       // Get node
       Node* nod_pt = it->first;
  
       // Get its number
       unsigned node_number = it->second;
  
       // Loop over coordinate directions
       for (unsigned i = 0; i < dim_nod; i++)
       {
         // Make backup
         double backup = nod_pt->x(i);
  
         // Do FD step. No node update required as we're
         // attacking the coordinate directly...
         nod_pt->x(i) += eps_fd;
  
         // Perform auxiliary node update function
         nod_pt->perform_auxiliary_node_update_fct();
  
         // Get advanced residual
         get_residuals(res_pls);
  
         // Fill in FD entries [Loop order is "wrong" here as l is the
         // slow index but this is in a function that's costly anyway
         // and gives us the fastest loop outside where these tensor
         // is actually used.]
         for (unsigned l = 0; l < n_dof; l++)
         {
           dresidual_dnodal_coordinates(l, i, node_number) =
             (res_pls[l] - res[l]) / eps_fd;
         }
  
         // Reset coordinate. No node update required as we're
         // attacking the coordinate directly...
         nod_pt->x(i) = backup;
  
         // Perform auxiliary node update function
         nod_pt->perform_auxiliary_node_update_fct();
       }
     }
   }

References oomph::GeneralisedElement::Default_fd_jacobian_step, oomph::GeneralisedElement::get_residuals(), i, oomph::Node::ndim(), oomph::GeneralisedElement::ndof(), oomph::FiniteElement::nnode(), oomph::FiniteElement::node_pt(), oomph::Node::perform_auxiliary_node_update_fct(), res, Shape_controlling_node_lookup, and oomph::Node::x().

◆ get_father_at_refinement_level()

void oomph::RefineableElement::get_father_at_refinement_level	(	unsigned &	refinement_level,
		RefineableElement *&	father_at_reflevel_pt
	)

inline

Return a pointer to the "father" element at the specified refinement level

     {
       // Get the father in the tree (it shouldn't try to get a null Tree...)
       Tree* father_pt = Tree_pt->father_pt();
       // Get the refineable element associated with this father
       RefineableElement* father_el_pt =
         dynamic_cast<RefineableElement*>(father_pt->object_pt());
       // Get the refinement level
       unsigned level = father_el_pt->refinement_level();
       // If the level matches the required one then return, if not call again
       if (level == refinement_level)
       {
         father_at_reflevel_pt = father_el_pt;
       }
       else
       {
         // Recursive call
         father_el_pt->get_father_at_refinement_level(refinement_level,
                                                      father_at_reflevel_pt);
       }
     }

References oomph::Tree::father_pt(), get_father_at_refinement_level(), oomph::Tree::object_pt(), refinement_level(), and Tree_pt.

Referenced by get_father_at_refinement_level().

◆ get_interpolated_values() [1/2]

virtual void oomph::RefineableElement::get_interpolated_values	(	const unsigned &	t,
		const Vector< double > &	s,
		Vector< double > &	values
	)

pure virtual

Get all continously interpolated function values at previous timestep in this element as a Vector. (t=0: present; t>0: prev. timestep) Note: Vector sets is own size to ensure that that this function can be used in black-box fashion.

◆ get_interpolated_values() [2/2]

virtual void oomph::RefineableElement::get_interpolated_values	(	const Vector< double > &	s,
		Vector< double > &	values
	)

inlinevirtual

Get all continously interpolated function values in this element as a Vector. Note: Vector sets is own size to ensure that that this function can be used in black-box fashion.

     {
       get_interpolated_values(0, s, values);
     }

References s.

◆ get_interpolating_node_at_local_coordinate()

virtual Node* oomph::RefineableElement::get_interpolating_node_at_local_coordinate	(	const Vector< double > &	s,
		const int &	value_id
	)

inlinevirtual

Return a pointer to the node that interpolates the value-id-th unknown at local coordinate s. If there is not a node at that position, then return 0.

Reimplemented in oomph::RefineableQTaylorHoodMixedOrderSpaceTimeElement< DIM >, oomph::RefineableQTaylorHoodSpaceTimeElement< DIM >, oomph::RefineableQTaylorHoodSpaceTimeElement< DIM >, oomph::RefineableQTaylorHoodSpaceTimeElement< DIM >, oomph::RefineableQPVDElementWithContinuousPressure< DIM >, oomph::RefineablePolarTaylorHoodElement, oomph::RefineableQTaylorHoodElement< DIM >, oomph::RefineableQTaylorHoodElement< 2 >, oomph::RefineableGeneralisedNewtonianQTaylorHoodElement< DIM >, oomph::RefineableQSphericalTaylorHoodElement, oomph::RefineableLinearisedQTaylorHoodElement, oomph::RefineableLinearisedAxisymmetricQTaylorHoodElement, oomph::RefineableGeneralisedNewtonianAxisymmetricQTaylorHoodElement, oomph::RefineableAxisymmetricQTaylorHoodElement, and oomph::RefineableLinearisedAxisymmetricQTaylorHoodElement.

     {
       return get_node_at_local_coordinate(s);
     }

References oomph::FiniteElement::get_node_at_local_coordinate(), and s.

Referenced by oomph::RefineableQElement< 3 >::oc_hang_helper(), and oomph::RefineableQElement< 2 >::quad_hang_helper().

◆ identify_field_data_for_interactions()

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

virtual

The purpose of this function is to identify all possible Data that can affect the fields interpolated by the FiniteElement. This must be overloaded to include data from any hanging nodes correctly

Reimplemented from oomph::FiniteElement.

   {
     // Loop over all internal data
     const unsigned n_internal = this->ninternal_data();
     for (unsigned n = 0; n < n_internal; n++)
     {
       // Cache the data pointer
       Data* const dat_pt = this->internal_data_pt(n);
       // Find the number of data values stored in the data object
       const unsigned n_value = dat_pt->nvalue();
       // Add the index of each data value and the pointer to the set
       // of pairs
       for (unsigned i = 0; i < n_value; i++)
       {
         paired_field_data.insert(std::make_pair(dat_pt, i));
       }
     }
  
     // Loop over all the nodes
     const unsigned n_node = this->nnode();
     for (unsigned n = 0; n < n_node; n++)
     {
       // Cache the node pointer
       Node* const nod_pt = this->node_pt(n);
       // Find the number of values stored at the node
       const unsigned n_value = nod_pt->nvalue();
  
       // Loop over the number of values
       for (unsigned i = 0; i < n_value; i++)
       {
         // If the node is hanging in the variable
         if (nod_pt->is_hanging(i))
         {
           // Cache the pointer to the HangInfo object for this variable
           HangInfo* const hang_pt = nod_pt->hanging_pt(i);
           // Get number of master nodes
           const unsigned nmaster = hang_pt->nmaster();
  
           // Loop over masters
           for (unsigned m = 0; m < nmaster; m++)
           {
             // Cache the pointer to the master node
             Node* const master_nod_pt = hang_pt->master_node_pt(m);
  
             // Under the assumption that the same data value is interpolated
             // by the hanging nodes, which it really must be
             // Add it to the paired field data
             paired_field_data.insert(std::make_pair(master_nod_pt, i));
           }
         }
         // Otherwise the node is not hanging in the variable, treat as normal
         else
         {
           // Add the index of each data value and the pointer to the set
           // of pairs
           paired_field_data.insert(std::make_pair(nod_pt, i));
         }
       }
     }
   }

References oomph::Node::hanging_pt(), i, oomph::GeneralisedElement::internal_data_pt(), oomph::Node::is_hanging(), m, oomph::HangInfo::master_node_pt(), n, oomph::GeneralisedElement::ninternal_data(), oomph::HangInfo::nmaster(), oomph::FiniteElement::nnode(), oomph::FiniteElement::node_pt(), and oomph::Data::nvalue().

◆ initial_setup()

virtual void oomph::RefineableElement::initial_setup	(	Tree *const &	adopted_father_pt = `0`,
		const unsigned &	initial_p_order = `0`
	)

inlinevirtual

Initial setup of the element: e.g. set the appropriate internal p-order. If an adopted father is specified, information from this is used instead of using the father found from the tree.

Reimplemented in oomph::PRefineableQElement< 3, INITIAL_NNODE_1D >, oomph::PRefineableQElement< 2, INITIAL_NNODE_1D >, and oomph::PRefineableQElement< 1, INITIAL_NNODE_1D >.

592 {

593 }

◆ interpolating_basis()

virtual void oomph::RefineableElement::interpolating_basis	(	const Vector< double > &	s,
		Shape &	psi,
		const int &	value_id
	)		const

inlinevirtual

Return the basis functions that are used to interpolate the value_id-th unknown. By default assume isoparameteric interpolation

Reimplemented in oomph::RefineableQTaylorHoodMixedOrderSpaceTimeElement< DIM >, oomph::RefineableQTaylorHoodSpaceTimeElement< DIM >, oomph::RefineableQTaylorHoodSpaceTimeElement< DIM >, oomph::RefineableQTaylorHoodSpaceTimeElement< DIM >, oomph::RefineableQPVDElementWithContinuousPressure< DIM >, oomph::RefineablePolarTaylorHoodElement, oomph::RefineableQTaylorHoodElement< DIM >, oomph::RefineableQTaylorHoodElement< 2 >, oomph::RefineableGeneralisedNewtonianQTaylorHoodElement< DIM >, oomph::RefineableQSphericalTaylorHoodElement, oomph::RefineableLinearisedQTaylorHoodElement, oomph::RefineableLinearisedAxisymmetricQTaylorHoodElement, oomph::RefineableGeneralisedNewtonianAxisymmetricQTaylorHoodElement, oomph::RefineableAxisymmetricQTaylorHoodElement, and oomph::RefineableLinearisedAxisymmetricQTaylorHoodElement.

     {
       shape(s, psi);
     }

References s, and oomph::FiniteElement::shape().

Referenced by oomph::RefineableQElement< 3 >::oc_hang_helper(), oomph::PRefineableQElement< 3, INITIAL_NNODE_1D >::oc_hang_helper(), oomph::PRefineableQElement< 2, INITIAL_NNODE_1D >::quad_hang_helper(), and oomph::RefineableQElement< 2 >::quad_hang_helper().

◆ interpolating_node_pt()

virtual Node* oomph::RefineableElement::interpolating_node_pt	(	const unsigned &	n,
		const int &	value_id
	)

inlinevirtual

In mixed elements, different sets of nodes are used to interpolate different unknowns. This function returns the n-th node that interpolates the value_id-th unknown. Default implementation is that all variables use the positional nodes, i.e. isoparametric elements. Note that any overloaded versions of this function MUST provide a set of nodes for the position, which always has the value_id -1.

Reimplemented in oomph::RefineableQTaylorHoodMixedOrderSpaceTimeElement< DIM >, oomph::RefineableQTaylorHoodSpaceTimeElement< DIM >, oomph::RefineableQTaylorHoodSpaceTimeElement< DIM >, oomph::RefineableQTaylorHoodSpaceTimeElement< DIM >, oomph::RefineableQPVDElementWithContinuousPressure< DIM >, oomph::RefineablePolarTaylorHoodElement, oomph::RefineableQTaylorHoodElement< DIM >, oomph::RefineableQTaylorHoodElement< 2 >, oomph::RefineableGeneralisedNewtonianQTaylorHoodElement< DIM >, oomph::RefineableQSphericalTaylorHoodElement, oomph::RefineableLinearisedQTaylorHoodElement, oomph::RefineableLinearisedAxisymmetricQTaylorHoodElement, oomph::RefineableGeneralisedNewtonianAxisymmetricQTaylorHoodElement, oomph::RefineableAxisymmetricQTaylorHoodElement, and oomph::RefineableLinearisedAxisymmetricQTaylorHoodElement.

     {
       return node_pt(n);
     }

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

Referenced by oomph::RefineableQElement< 3 >::oc_hang_helper(), oomph::PRefineableQElement< 3, INITIAL_NNODE_1D >::oc_hang_helper(), oomph::PRefineableQElement< 2, INITIAL_NNODE_1D >::quad_hang_helper(), and oomph::RefineableQElement< 2 >::quad_hang_helper().

◆ local_hang_eqn()

int oomph::RefineableElement::local_hang_eqn	(	Node *const &	node_pt,
		const unsigned &	i
	)

inline

Access function that returns the local equation number for the hanging node variables (values stored at master nodes). The local equation number corresponds to the i-th unknown stored at the node addressed by node_pt

     {
 #ifdef RANGE_CHECKING
       if (i > ncont_interpolated_values())
       {
         std::ostringstream error_message;
         error_message << "Range Error: Value " << i
                       << " is not in the range (0,"
                       << ncont_interpolated_values() - 1 << ")";
         throw OomphLibError(error_message.str(),
                             OOMPH_CURRENT_FUNCTION,
                             OOMPH_EXCEPTION_LOCATION);
       }
 #endif
  
       return Local_hang_eqn[i][node_pt];
     }

References i, Local_hang_eqn, ncont_interpolated_values(), oomph::FiniteElement::node_pt(), OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

◆ local_one_d_fraction_of_interpolating_node()

virtual double oomph::RefineableElement::local_one_d_fraction_of_interpolating_node	(	const unsigned &	n1d,
		const unsigned &	i,
		const int &	value_id
	)

inlinevirtual

Return the local one dimensional fraction of the n1d-th node in the direction of the local coordinate s[i] that is used to interpolate the value_id-th continuously interpolated unknown. Default assumes isoparametric interpolation for all unknowns

Reimplemented in oomph::RefineableQTaylorHoodMixedOrderSpaceTimeElement< DIM >, oomph::RefineableQTaylorHoodSpaceTimeElement< DIM >, oomph::RefineableQTaylorHoodSpaceTimeElement< DIM >, oomph::RefineableQTaylorHoodSpaceTimeElement< DIM >, oomph::RefineableQPVDElementWithContinuousPressure< DIM >, oomph::RefineablePolarTaylorHoodElement, oomph::RefineableQTaylorHoodElement< DIM >, oomph::RefineableQTaylorHoodElement< 2 >, oomph::RefineableGeneralisedNewtonianQTaylorHoodElement< DIM >, oomph::RefineableQSphericalTaylorHoodElement, oomph::RefineableLinearisedQTaylorHoodElement, oomph::RefineableLinearisedAxisymmetricQTaylorHoodElement, oomph::RefineableGeneralisedNewtonianAxisymmetricQTaylorHoodElement, oomph::RefineableAxisymmetricQTaylorHoodElement, and oomph::RefineableLinearisedAxisymmetricQTaylorHoodElement.

     {
       return local_one_d_fraction_of_node(n1d, i);
     }

References i, and oomph::FiniteElement::local_one_d_fraction_of_node().

◆ local_to_eulerian_mapping_diagonal()

double oomph::RefineableElement::local_to_eulerian_mapping_diagonal	(	const DShape &	dpsids,
		DenseMatrix< double > &	jacobian,
		DenseMatrix< double > &	inverse_jacobian
	)		const

protectedvirtual

Calculate the mapping from local to Eulerian coordinates given the derivatives of the shape functions w.r.t the local coordinates. assuming that the coordinates are aligned in the direction of the local coordinates, i.e. there are no cross terms and the jacobian is diagonal. This funciton returns the determinant of the jacobian, the jacobian and the inverse jacobian. Overload the standard version to take hanging info into account.

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

Reimplemented from oomph::FiniteElement.

   {
     // Find the dimension of the element
     const unsigned el_dim = dim();
     // Find the number of shape functions and shape functions types
     // Equal to the number of nodes and their position types by definition
     const unsigned n_shape = nnode();
     const unsigned n_shape_type = nnodal_position_type();
  
 #ifdef PARANOID
     // Check for dimension compatibility
     if (dim() != nodal_dimension())
     {
       std::ostringstream error_message;
       error_message << "Dimension mismatch" << std::endl;
       error_message << "The elemental dimension: " << dim()
                     << " must equal the nodal dimension: " << nodal_dimension()
                     << " for the jacobian of the mapping to be well-defined"
                     << std::endl;
       throw OomphLibError(
         error_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
 #endif
  
     // In this case we assume that there are no cross terms, that is
     // global coordinate 0 is always in the direction of local coordinate 0
  
     // Loop over the coordinates
     for (unsigned i = 0; i < el_dim; i++)
     {
       // Zero the jacobian and inverse jacobian entries
       for (unsigned j = 0; j < el_dim; j++)
       {
         jacobian(i, j) = 0.0;
         inverse_jacobian(i, j) = 0.0;
       }
  
       // Loop over the shape functions
       for (unsigned l = 0; l < n_shape; l++)
       {
         // Loop over the types of dof
         for (unsigned k = 0; k < n_shape_type; k++)
         {
           // Derivatives are always dx_{i}/ds_{i}
           jacobian(i, i) += nodal_position_gen(l, k, i) * dpsids(l, k, i);
         }
       }
     }
  
     // Now calculate the determinant of the matrix
     double det = 1.0;
     for (unsigned i = 0; i < el_dim; i++)
     {
       det *= jacobian(i, i);
     }
  
 // Report if Matrix is singular, or negative
 #ifdef PARANOID
     check_jacobian(det);
 #endif
  
     // Calculate the inverse mapping (trivial in this case)
     for (unsigned i = 0; i < el_dim; i++)
     {
       inverse_jacobian(i, i) = 1.0 / jacobian(i, i);
     }
  
     // Return the value of the Jacobian
     return (det);
   }

References oomph::FiniteElement::check_jacobian(), oomph::FiniteElement::dim(), el_dim, i, j, k, oomph::FiniteElement::nnodal_position_type(), oomph::FiniteElement::nnode(), oomph::FiniteElement::nodal_dimension(), oomph::FiniteElement::nodal_position_gen(), OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

◆ max_integrity_tolerance()

static double& oomph::RefineableElement::max_integrity_tolerance ( )

inlinestatic

Max. allowed discrepancy in element integrity check.

     {
       return Max_integrity_tolerance;
     }

References Max_integrity_tolerance.

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

◆ ncont_interpolated_values()

virtual unsigned oomph::RefineableElement::ncont_interpolated_values ( ) const

pure virtual

Number of continuously interpolated values. Note: We assume that they are located at the beginning of the value_pt Vector! (Used for interpolation to son elements, for integrity check and post-processing – we can only expect the continously interpolated values to be continous across element boundaries).

Referenced by assign_hanging_local_eqn_numbers(), oomph::PRefineableQElement< 2, INITIAL_NNODE_1D >::check_integrity(), oomph::RefineableQElement< 3 >::check_integrity(), oomph::RefineableQElement< 1 >::check_integrity(), oomph::RefineableQElement< 2 >::check_integrity(), and local_hang_eqn().

◆ ninterpolating_node()

virtual unsigned oomph::RefineableElement::ninterpolating_node ( const int & value_id )

inlinevirtual

Return the number of nodes that are used to interpolate the value_id-th unknown. Default is to assume isoparametric elements.

Reimplemented in oomph::RefineableQTaylorHoodMixedOrderSpaceTimeElement< DIM >, oomph::RefineableQTaylorHoodSpaceTimeElement< DIM >, oomph::RefineableQTaylorHoodSpaceTimeElement< DIM >, oomph::RefineableQTaylorHoodSpaceTimeElement< DIM >, oomph::RefineableQPVDElementWithContinuousPressure< DIM >, oomph::RefineablePolarTaylorHoodElement, oomph::RefineableQTaylorHoodElement< DIM >, oomph::RefineableQTaylorHoodElement< 2 >, oomph::RefineableGeneralisedNewtonianQTaylorHoodElement< DIM >, oomph::RefineableQSphericalTaylorHoodElement, oomph::RefineableLinearisedQTaylorHoodElement, oomph::RefineableLinearisedAxisymmetricQTaylorHoodElement, oomph::RefineableGeneralisedNewtonianAxisymmetricQTaylorHoodElement, oomph::RefineableAxisymmetricQTaylorHoodElement, and oomph::RefineableLinearisedAxisymmetricQTaylorHoodElement.

     {
       return nnode();
     }

References oomph::FiniteElement::nnode().

Referenced by oomph::RefineableQElement< 3 >::oc_hang_helper(), oomph::PRefineableQElement< 3, INITIAL_NNODE_1D >::oc_hang_helper(), oomph::PRefineableQElement< 2, INITIAL_NNODE_1D >::quad_hang_helper(), and oomph::RefineableQElement< 2 >::quad_hang_helper().

◆ ninterpolating_node_1d()

virtual unsigned oomph::RefineableElement::ninterpolating_node_1d ( const int & value_id )

inlinevirtual

Return the number of nodes in a one_d direction that are used to interpolate the value_id-th unknown. Default is to assume an isoparametric mapping.

Reimplemented in oomph::RefineableQTaylorHoodMixedOrderSpaceTimeElement< DIM >, oomph::RefineableQTaylorHoodSpaceTimeElement< DIM >, oomph::RefineableQTaylorHoodSpaceTimeElement< DIM >, oomph::RefineableQTaylorHoodSpaceTimeElement< DIM >, oomph::RefineableQPVDElementWithContinuousPressure< DIM >, oomph::RefineablePolarTaylorHoodElement, oomph::RefineableQTaylorHoodElement< DIM >, oomph::RefineableQTaylorHoodElement< 2 >, oomph::RefineableGeneralisedNewtonianQTaylorHoodElement< DIM >, oomph::RefineableQSphericalTaylorHoodElement, oomph::RefineableLinearisedQTaylorHoodElement, oomph::RefineableLinearisedAxisymmetricQTaylorHoodElement, oomph::RefineableGeneralisedNewtonianAxisymmetricQTaylorHoodElement, oomph::RefineableAxisymmetricQTaylorHoodElement, and oomph::RefineableLinearisedAxisymmetricQTaylorHoodElement.

     {
       return nnode_1d();
     }

References oomph::FiniteElement::nnode_1d().

Referenced by oomph::PRefineableQElement< 3, INITIAL_NNODE_1D >::oc_hang_helper(), and oomph::PRefineableQElement< 2, INITIAL_NNODE_1D >::quad_hang_helper().

◆ nodes_built()

virtual bool oomph::RefineableElement::nodes_built ( )

inlinevirtual

Return true if all the nodes have been built, false if not.

Reimplemented in oomph::RefineableQSpectralElement< 2 >, oomph::RefineableQSpectralElement< 1 >, oomph::PRefineableElement, and oomph::RefineableQSpectralElement< 3 >.

     {
       return node_pt(0) != 0;
     }

References oomph::FiniteElement::node_pt().

Referenced by oomph::PRefineableQElement< 2, INITIAL_NNODE_1D >::check_integrity(), oomph::RefineableQElement< 3 >::check_integrity(), oomph::RefineableQElement< 1 >::check_integrity(), oomph::RefineableQElement< 2 >::check_integrity(), oomph::OcTree::doc_face_neighbours(), oomph::BinaryTree::doc_neighbours(), oomph::QuadTree::doc_neighbours(), oomph::OcTree::doc_true_edge_neighbours(), oomph::RefineableQElement< 3 >::node_created_by_neighbour(), oomph::RefineableQElement< 1 >::node_created_by_neighbour(), and oomph::RefineableQElement< 2 >::node_created_by_neighbour().

◆ nshape_controlling_nodes()

unsigned oomph::RefineableElement::nshape_controlling_nodes ( )

inline

Number of shape-controlling nodes = the number of non-hanging nodes plus the number of master nodes associated with hanging nodes.

     {
       return Shape_controlling_node_lookup.size();
     }

References Shape_controlling_node_lookup.

Referenced by oomph::ElementWithMovingNodes::fill_in_jacobian_from_geometric_data(), oomph::ElementWithMovingNodes::get_dnodal_coordinates_dgeom_dofs(), oomph::RefineableAxisymmetricNavierStokesEquations::get_dresidual_dnodal_coordinates(), and oomph::RefineableGeneralisedNewtonianAxisymmetricNavierStokesEquations::get_dresidual_dnodal_coordinates().

◆ number()

long oomph::RefineableElement::number ( ) const

inline

Element number (for debugging/plotting)

     {
       return Number;
     }

References Number.

Referenced by oomph::OcTree::doc_face_neighbours(), oomph::BinaryTree::doc_neighbours(), oomph::QuadTree::doc_neighbours(), and oomph::OcTree::doc_true_edge_neighbours().

◆ operator=()

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

delete

Broken assignment operator.

◆ pre_build()

virtual void oomph::RefineableElement::pre_build	(	Mesh *&	mesh_pt,
		Vector< Node * > &	new_node_pt
	)

inlinevirtual

Pre-build the element.

Reimplemented in oomph::PRefineableQElement< 3, INITIAL_NNODE_1D >, oomph::PRefineableQElement< 2, INITIAL_NNODE_1D >, and oomph::PRefineableQElement< 1, INITIAL_NNODE_1D >.

596 {}

◆ rebuild_from_sons()

virtual void oomph::RefineableElement::rebuild_from_sons ( Mesh *& mesh_pt )

pure virtual

Rebuild the element, e.g. set internal values in line with those of the sons that have now merged

Referenced by oomph::Tree::merge_sons_if_required().

◆ refinement_is_enabled()

bool oomph::RefineableElement::refinement_is_enabled ( )

inline

Flag to indicate suppression of any refinement.

     {
       return Refinement_is_enabled;
     }

References Refinement_is_enabled.

Referenced by oomph::TreeBasedRefineableMeshBase::adapt().

◆ refinement_level()

unsigned oomph::RefineableElement::refinement_level ( ) const

inline

Return the Refinement level.

     {
       return Refine_level;
     }

References Refine_level.

Referenced by oomph::TreeBasedRefineableMeshBase::adapt(), get_father_at_refinement_level(), oomph::RefineableBrickMesh< ELEMENT >::setup_octree_forest(), and oomph::RefineableQuadMesh< ELEMENT >::setup_quadtree_forest().

◆ required_nsons()

virtual unsigned oomph::RefineableElement::required_nsons ( ) const

inlinevirtual

Set the number of sons that can be constructed by the element The default is none

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

     {
       return 0;
     }

Referenced by split().

◆ root_element_pt()

virtual RefineableElement* oomph::RefineableElement::root_element_pt ( )

inlinevirtual

Pointer to the root element in refinement hierarchy (must be implemented in specific elements that do refinement via tree-like refinement structure. Here we provide a default implementation that is appropriate for cases where tree-like refinement doesn't exist or if the element doesn't have root in that tree (i.e. if it's a root itself): We return "this".

     {
       // If there is no tree -- the element is its own root
       if (Tree_pt == 0)
       {
         return this;
       }
       // Otherwise it's the tree's root object
       else
       {
         return Tree_pt->root_pt()->object_pt();
       }
     }

References oomph::Tree::object_pt(), oomph::Tree::root_pt(), and Tree_pt.

◆ select_for_refinement()

void oomph::RefineableElement::select_for_refinement ( )

inline

Select the element for refinement.

     {
       To_be_refined = true;
     }

References To_be_refined.

Referenced by oomph::TreeBasedRefineableMeshBase::adapt().

◆ select_sons_for_unrefinement()

void oomph::RefineableElement::select_sons_for_unrefinement ( )

inline

Unrefinement will be performed by merging the four sons of this element.

     {
       Sons_to_be_unrefined = true;
     }

References Sons_to_be_unrefined.

Referenced by oomph::TreeBasedRefineableMeshBase::adapt().

◆ set_number()

void oomph::RefineableElement::set_number ( const long & mynumber )

inline

Set element number (for debugging/plotting)

     {
       Number = mynumber;
     }

References Number.

◆ set_refinement_level()

void oomph::RefineableElement::set_refinement_level ( const int & refine_level )

inline

Set the refinement level.

     {
       Refine_level = refine_level;
     }

References Refine_level.

◆ set_tree_pt()

void oomph::RefineableElement::set_tree_pt ( Tree * my_tree_pt )

inline

Set pointer to quadtree representation of this element.

     {
       Tree_pt = my_tree_pt;
     }

References Tree_pt.

Referenced by oomph::Tree::Tree().

◆ setup_hanging_nodes()

virtual void oomph::RefineableElement::setup_hanging_nodes ( Vector< std::ofstream * > & output_stream )

inlinevirtual

Mark up any hanging nodes that arise as a result of non-uniform refinement. Any hanging nodes will be documented in files addressed by the streams in the vector output_stream, if the streams are open.

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

604 {}

◆ shape_controlling_node_lookup()

std::map<Node*, unsigned> oomph::RefineableElement::shape_controlling_node_lookup ( )

inline

Return lookup scheme for unique number associated with any of the nodes that actively control the shape of the element (i.e. they are either non-hanging nodes of this element or master nodes of hanging nodes.

     {
       return Shape_controlling_node_lookup;
     }

References Shape_controlling_node_lookup.

Referenced by oomph::ElementWithMovingNodes::get_dnodal_coordinates_dgeom_dofs(), oomph::RefineableAxisymmetricNavierStokesEquations::get_dresidual_dnodal_coordinates(), and oomph::RefineableGeneralisedNewtonianAxisymmetricNavierStokesEquations::get_dresidual_dnodal_coordinates().

◆ sons_to_be_unrefined()

bool oomph::RefineableElement::sons_to_be_unrefined ( )

inline

Has the element been selected for unrefinement?

     {
       return Sons_to_be_unrefined;
     }

References Sons_to_be_unrefined.

Referenced by oomph::Tree::merge_sons_if_required().

◆ split()

template<class ELEMENT >

void oomph::RefineableElement::split ( Vector< ELEMENT * > & son_pt ) const

inline

Split the element into the number of sons to be constructed and return a vector of pointers to the sons. Elements are allocated, but they are not given any properties. The refinement level of the sons is one higher than that of the father elemern.

     {
       // Increase refinement level
       int son_refine_level = Refine_level + 1;
  
       // How many sons are to be constructed
       unsigned n_sons = required_nsons();
       // Resize the son pointer
       son_pt.resize(n_sons);
  
       // Loop over the sons and construct
       for (unsigned i = 0; i < n_sons; i++)
       {
         son_pt[i] = new ELEMENT;
         // Set the refinement level of the newly constructed son.
         son_pt[i]->set_refinement_level(son_refine_level);
       }
     }

References i, Refine_level, and required_nsons().

Referenced by oomph::Tree::split_if_required().

◆ to_be_refined()

bool oomph::RefineableElement::to_be_refined ( )

inline

Has the element been selected for refinement?

     {
       return To_be_refined;
     }

References To_be_refined.

Referenced by oomph::Tree::split_if_required().

◆ tree_pt()

Tree* oomph::RefineableElement::tree_pt ( )

inline

Access function: Pointer to quadtree representation of this element.

     {
       return Tree_pt;
     }

References Tree_pt.

Referenced by oomph::TreeBasedRefineableMeshBase::adapt(), oomph::RefineablePolarTaylorHoodElement::get_interpolated_values(), and oomph::RefineablePolarCrouzeixRaviartElement::get_interpolated_values().

◆ unbuild()

virtual void oomph::RefineableElement::unbuild ( )

inlinevirtual

Unbuild the element, i.e. mark the nodes that were created during its creation for possible deletion

     {
       // Get pointer to father element
       RefineableElement* father_pt = father_element_pt();
       // If there is no father, nothing to do
       if (father_pt == 0)
       {
         return;
       }
  
       // Loop over all the nodes
       unsigned n_node = this->nnode();
       for (unsigned n = 0; n < n_node; n++)
       {
         // If any node in this element is in the father, it can't be deleted
         if (father_pt->get_node_number(this->node_pt(n)) >= 0)
         {
           node_pt(n)->set_non_obsolete();
         }
       }
     }

References father_element_pt(), oomph::FiniteElement::get_node_number(), n, oomph::FiniteElement::nnode(), oomph::FiniteElement::node_pt(), and oomph::Node::set_non_obsolete().

Referenced by oomph::Tree::merge_sons_if_required().

Member Data Documentation

◆ Local_hang_eqn

std::map<Node*, int>* oomph::RefineableElement::Local_hang_eqn

private

Storage for local equation numbers of hanging node variables (values stored at master nodes). It is essential that these are indexed by a Node pointer because the Node may be internal or external to the element. local equation number = Local_hang_eqn(master_node_pt,ival)

Referenced by assign_hanging_local_eqn_numbers(), local_hang_eqn(), and ~RefineableElement().

◆ Max_integrity_tolerance

double oomph::RefineableElement::Max_integrity_tolerance = 1.0e-8

staticprotected

Max. allowed discrepancy in element integrity check.

Referenced by max_integrity_tolerance().

◆ Number

long oomph::RefineableElement::Number

protected

Global element number – for plotting/validation purposes.

Referenced by number(), and set_number().

◆ Refine_level

unsigned oomph::RefineableElement::Refine_level

protected

Refinement level.

Referenced by refinement_level(), set_refinement_level(), and split().

◆ Refinement_is_enabled

bool oomph::RefineableElement::Refinement_is_enabled

protected

Flag to indicate suppression of any refinement.

Referenced by disable_refinement(), enable_refinement(), and refinement_is_enabled().

◆ Shape_controlling_node_lookup

std::map<Node*, unsigned> oomph::RefineableElement::Shape_controlling_node_lookup

private

Lookup scheme for unique number associated with any of the nodes that actively control the shape of the element (i.e. they are either non-hanging nodes of this element or master nodes of hanging nodes.

Referenced by assign_hanging_local_eqn_numbers(), get_dresidual_dnodal_coordinates(), nshape_controlling_nodes(), and shape_controlling_node_lookup().

◆ Sons_to_be_unrefined

bool oomph::RefineableElement::Sons_to_be_unrefined

protected

Flag for unrefinement.

Referenced by deselect_sons_for_unrefinement(), select_sons_for_unrefinement(), and sons_to_be_unrefined().

◆ To_be_refined

bool oomph::RefineableElement::To_be_refined

protected

Flag for refinement.

Referenced by deselect_for_refinement(), select_for_refinement(), and to_be_refined().

◆ Tree_pt

Tree* oomph::RefineableElement::Tree_pt

protected

A pointer to a general tree object.

Referenced by father_element_pt(), get_father_at_refinement_level(), root_element_pt(), set_tree_pt(), and tree_pt().

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

Public Member Functions

Static Public Member Functions

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Static Protected Attributes

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ RefineableElement() [1/2]

◆ ~RefineableElement()

◆ RefineableElement() [2/2]

Member Function Documentation

◆ assemble_eulerian_base_vectors()

◆ assemble_local_to_eulerian_jacobian()

◆ assemble_local_to_eulerian_jacobian2()

◆ assign_hanging_local_eqn_numbers()

◆ assign_nodal_local_eqn_numbers()

◆ build()

◆ check_integrity()

◆ check_value_id()

◆ deactivate_element()

◆ deselect_for_refinement()

◆ deselect_sons_for_unrefinement()

◆ disable_refinement()

◆ enable_refinement()

◆ father_element_pt()

◆ fill_in_jacobian_from_nodal_by_fd()

◆ further_build()

◆ further_setup_hanging_nodes()

◆ get_dresidual_dnodal_coordinates()

◆ get_father_at_refinement_level()

◆ get_interpolated_values() [1/2]

◆ get_interpolated_values() [2/2]

◆ get_interpolating_node_at_local_coordinate()

◆ identify_field_data_for_interactions()

◆ initial_setup()

◆ interpolating_basis()

◆ interpolating_node_pt()

◆ local_hang_eqn()

◆ local_one_d_fraction_of_interpolating_node()

◆ local_to_eulerian_mapping_diagonal()

◆ max_integrity_tolerance()

◆ ncont_interpolated_values()

◆ ninterpolating_node()

◆ ninterpolating_node_1d()

◆ nodes_built()

◆ nshape_controlling_nodes()

◆ number()

◆ operator=()

◆ pre_build()

◆ rebuild_from_sons()

◆ refinement_is_enabled()

◆ refinement_level()

◆ required_nsons()

◆ root_element_pt()

◆ select_for_refinement()

◆ select_sons_for_unrefinement()

◆ set_number()

◆ set_refinement_level()

◆ set_tree_pt()

◆ setup_hanging_nodes()

◆ shape_controlling_node_lookup()

◆ sons_to_be_unrefined()

◆ split()

◆ to_be_refined()

◆ tree_pt()

◆ unbuild()

Member Data Documentation

◆ Local_hang_eqn

◆ Max_integrity_tolerance

◆ Number

◆ Refine_level

◆ Refinement_is_enabled

◆ Shape_controlling_node_lookup

◆ Sons_to_be_unrefined

◆ To_be_refined

◆ Tree_pt