#include <generalised_newtonian_navier_stokes_elements.h>

Inheritance diagram for oomph::GeneralisedNewtonianNavierStokesEquations< DIM >:

Public Types
typedef void(*	NavierStokesBodyForceFctPt) (const double &time, const Vector< double > &x, Vector< double > &body_force)

typedef double(*	NavierStokesSourceFctPt) (const double &time, const Vector< double > &x)

typedef double(*	NavierStokesPressureAdvDiffSourceFctPt) (const Vector< double > &x)

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

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

Public Member Functions
	GeneralisedNewtonianNavierStokesEquations ()

const double &	re () const
	Reynolds number. More...

const double &	re_st () const
	Product of Reynolds and Strouhal number (=Womersley number) More...

double *&	re_pt ()
	Pointer to Reynolds number. More...

double *&	re_st_pt ()
	Pointer to product of Reynolds and Strouhal number (=Womersley number) More...

const double &	viscosity_ratio () const

double *&	viscosity_ratio_pt ()
	Pointer to Viscosity Ratio. More...

const double &	density_ratio () const

double *&	density_ratio_pt ()
	Pointer to Density ratio. More...

const double &	re_invfr () const
	Global inverse Froude number. More...

double *&	re_invfr_pt ()
	Pointer to global inverse Froude number. More...

const Vector< double > &	g () const
	Vector of gravitational components. More...

Vector< double > *&	g_pt ()
	Pointer to Vector of gravitational components. More...

NavierStokesBodyForceFctPt &	body_force_fct_pt ()
	Access function for the body-force pointer. More...

NavierStokesBodyForceFctPt	body_force_fct_pt () const
	Access function for the body-force pointer. Const version. More...

NavierStokesSourceFctPt &	source_fct_pt ()
	Access function for the source-function pointer. More...

NavierStokesSourceFctPt	source_fct_pt () const
	Access function for the source-function pointer. Const version. More...

GeneralisedNewtonianConstitutiveEquation< DIM > *&	constitutive_eqn_pt ()
	Access function for the constitutive equation pointer. More...

void	use_current_strainrate_to_compute_second_invariant ()
	Switch to fully implict evaluation of non-Newtonian const eqn. More...

void	use_extrapolated_strainrate_to_compute_second_invariant ()
	Use extrapolation for non-Newtonian const eqn. More...

virtual unsigned	npres_nst () const =0
	Function to return number of pressure degrees of freedom. More...

virtual void	pshape_nst (const Vector< double > &s, Shape &psi) const =0
	Compute the pressure shape functions at local coordinate s. More...

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

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

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

virtual unsigned	u_index_nst (const unsigned &i) const

unsigned	n_u_nst () const

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

void	disable_ALE ()

void	enable_ALE ()

virtual double	p_nst (const unsigned &n_p) const =0

virtual double	p_nst (const unsigned &t, const unsigned &n_p) const =0
	Pressure at local pressure "node" n_p at time level t. More...

virtual void	fix_pressure (const unsigned &p_dof, const double &p_value)=0
	Pin p_dof-th pressure dof and set it to value specified by p_value. More...

virtual int	p_nodal_index_nst () const

double	pressure_integral () const
	Integral of pressure over element. More...

void	max_and_min_invariant_and_viscosity (double &min_invariant, double &max_invariant, double &min_viscosity, double &max_viscosity) const

double	dissipation () const
	Return integral of dissipation over element. More...

double	dissipation (const Vector< double > &s) const
	Return dissipation at local coordinate s. More...

void	get_vorticity (const Vector< double > &s, Vector< double > &vorticity) const
	Compute the vorticity vector at local coordinate s. More...

double	kin_energy () const
	Get integral of kinetic energy over element. More...

double	d_kin_energy_dt () const
	Get integral of time derivative of kinetic energy over element. More...

void	strain_rate (const Vector< double > &s, DenseMatrix< double > &strain_rate) const
	Strain-rate tensor: 1/2 (du_i/dx_j + du_j/dx_i) More...

void	strain_rate (const unsigned &t, const Vector< double > &s, DenseMatrix< double > &strain_rate) const

virtual void	extrapolated_strain_rate (const Vector< double > &s, DenseMatrix< double > &strain_rate) const

virtual void	extrapolated_strain_rate (const unsigned &ipt, DenseMatrix< double > &strain_rate) const

void	get_traction (const Vector< double > &s, const Vector< double > &N, Vector< double > &traction)

void	get_traction (const Vector< double > &s, const Vector< double > &N, Vector< double > &traction_p, Vector< double > &traction_visc_n, Vector< double > &traction_visc_t)

void	get_load (const Vector< double > &s, const Vector< double > &N, Vector< double > &load)

void	get_pressure_and_velocity_mass_matrix_diagonal (Vector< double > &press_mass_diag, Vector< double > &veloc_mass_diag, const unsigned &which_one=0)

unsigned	nscalar_paraview () const

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

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

void	output (std::ostream &outfile)

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

void	output (FILE *file_pt)

void	output (FILE *file_pt, const unsigned &nplot)

void	full_output (std::ostream &outfile)

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

void	output_veloc (std::ostream &outfile, const unsigned &nplot, const unsigned &t)

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

void	output_fct (std::ostream &outfile, const unsigned &nplot, FiniteElement::SteadyExactSolutionFctPt exact_soln_pt)

void	output_fct (std::ostream &outfile, const unsigned &nplot, const double &time, FiniteElement::UnsteadyExactSolutionFctPt exact_soln_pt)

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

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

void	fill_in_contribution_to_residuals (Vector< double > &residuals)
	Compute the element's residual Vector. More...

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

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

void	fill_in_contribution_to_dresiduals_dparameter (double *const &parameter_pt, Vector< double > &dres_dparam)
	Compute the element's residual Vector. More...

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

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)

void	pin_all_non_pressure_dofs (std::map< Data *, std::vector< int >> &eqn_number_backup)
	Pin all non-pressure dofs and backup eqn numbers. More...

virtual void	get_dresidual_dnodal_coordinates (RankThreeTensor< double > &dresidual_dnodal_coordinates)

void	interpolated_u_nst (const Vector< double > &s, Vector< double > &veloc) const
	Compute vector of FE interpolated velocity u at local coordinate s. More...

double	interpolated_u_nst (const Vector< double > &s, const unsigned &i) const
	Return FE interpolated velocity u[i] at local coordinate s. More...

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

virtual void	dinterpolated_u_nst_ddata (const Vector< double > &s, const unsigned &i, Vector< double > &du_ddata, Vector< unsigned > &global_eqn_number)

virtual double	interpolated_p_nst (const Vector< double > &s) const
	Return FE interpolated pressure at local coordinate s. More...

double	interpolated_p_nst (const unsigned &t, const Vector< double > &s) const
	Return FE interpolated pressure at local coordinate s at time level t. More...

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

void	get_vorticity (const Vector< double > &s, Vector< double > &vorticity) const

void	get_vorticity (const Vector< double > &s, Vector< double > &vorticity) const
	Compute 3D vorticity vector at local coordinate s. More...

Public Member Functions inherited from oomph::FSIFluidElement
	FSIFluidElement ()
	Constructor. More...

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

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

virtual void	identify_load_data (std::set< std::pair< Data *, unsigned >> &paired_load_data)=0

virtual void	identify_pressure_data (std::set< std::pair< Data *, unsigned >> &paired_pressure_data)=0

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	assign_nodal_local_eqn_numbers (const bool &store_local_dof_pt)

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

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

virtual void	assign_all_generic_local_eqn_numbers (const bool &store_local_dof_pt)

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

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

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

virtual unsigned	nnode_1d () const

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

virtual 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_field_data_for_interactions (std::set< std::pair< Data *, unsigned >> &paired_field_data)

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

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

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

double	size () const

virtual double	compute_physical_size () const

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 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 void	output (const unsigned &t, std::ostream &outfile, const unsigned &n_plot) const

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

Public Member Functions inherited from oomph::GeneralisedNewtonianTemplateFreeNavierStokesEquationsBase
	GeneralisedNewtonianTemplateFreeNavierStokesEquationsBase ()
	Constructor (empty) More...

virtual	~GeneralisedNewtonianTemplateFreeNavierStokesEquationsBase ()
	Virtual destructor (empty) More...

virtual int	p_local_eqn (const unsigned &n) const =0

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

virtual	~NavierStokesElementWithDiagonalMassMatrices ()
	Virtual destructor. More...

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

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

Static Public Attributes
static Vector< double >	Gamma
	Vector to decide whether the stress-divergence form is used or not. More...

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

Protected Member Functions
virtual double	dshape_and_dtest_eulerian_nst (const Vector< double > &s, Shape &psi, DShape &dpsidx, Shape &test, DShape &dtestdx) const =0

virtual double	dshape_and_dtest_eulerian_at_knot_nst (const unsigned &ipt, Shape &psi, DShape &dpsidx, Shape &test, DShape &dtestdx) const =0

virtual double	dshape_and_dtest_eulerian_at_knot_nst (const unsigned &ipt, Shape &psi, DShape &dpsidx, RankFourTensor< double > &d_dpsidx_dX, Shape &test, DShape &dtestdx, RankFourTensor< double > &d_dtestdx_dX, DenseMatrix< double > &djacobian_dX) const =0

virtual double	dpshape_and_dptest_eulerian_nst (const Vector< double > &s, Shape &ppsi, DShape &dppsidx, Shape &ptest, DShape &dptestdx) const =0

virtual void	get_body_force_nst (const double &time, const unsigned &ipt, const Vector< double > &s, const Vector< double > &x, Vector< double > &result)

virtual void	get_body_force_gradient_nst (const double &time, const unsigned &ipt, const Vector< double > &s, const Vector< double > &x, DenseMatrix< double > &d_body_force_dx)

virtual double	get_source_nst (const double &time, const unsigned &ipt, const Vector< double > &x)

virtual void	get_source_gradient_nst (const double &time, const unsigned &ipt, const Vector< double > &x, Vector< double > &gradient)

virtual void	fill_in_generic_residual_contribution_nst (Vector< double > &residuals, DenseMatrix< double > &jacobian, DenseMatrix< double > &mass_matrix, unsigned flag)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void	fill_in_jacobian_from_nodal_by_fd (DenseMatrix< double > &jacobian)

virtual void	update_before_nodal_fd ()

virtual void	reset_after_nodal_fd ()

virtual void	update_in_nodal_fd (const unsigned &i)

virtual void	reset_in_nodal_fd (const unsigned &i)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

bool	internal_data_fd (const unsigned &i) const

void	exclude_internal_data_fd (const unsigned &i)

void	include_internal_data_fd (const unsigned &i)

void	clear_global_eqn_numbers ()

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

virtual void	assign_internal_and_external_local_eqn_numbers (const bool &store_local_dof_pt)

virtual void	assign_additional_local_eqn_numbers ()

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

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

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_inner_products (Vector< std::pair< unsigned, unsigned >> const &history_index, Vector< double > &inner_product)

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

Protected Attributes
double *	Viscosity_Ratio_pt

double *	Density_Ratio_pt

double *	Re_pt
	Pointer to global Reynolds number. More...

double *	ReSt_pt
	Pointer to global Reynolds number x Strouhal number (=Womersley) More...

double *	ReInvFr_pt

Vector< double > *	G_pt
	Pointer to global gravity Vector. More...

NavierStokesBodyForceFctPt	Body_force_fct_pt
	Pointer to body force function. More...

NavierStokesSourceFctPt	Source_fct_pt
	Pointer to volumetric source function. More...

GeneralisedNewtonianConstitutiveEquation< DIM > *	Constitutive_eqn_pt
	Pointer to the generalised Newtonian constitutive equation. More...

bool	Use_extrapolated_strainrate_to_compute_second_invariant

bool	ALE_is_disabled

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 bool	Pre_multiply_by_viscosity_ratio = false

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

Static Private Attributes
static int	Pressure_not_stored_at_node = -100

static double	Default_Physical_Constant_Value = 0.0
	Navier–Stokes equations static data. More...

static double	Default_Physical_Ratio_Value = 1.0
	Navier–Stokes equations static data. More...

static Vector< double >	Default_Gravity_vector
	Static default value for the gravity vector. More...

Detailed Description

template<unsigned DIM>
class oomph::GeneralisedNewtonianNavierStokesEquations< DIM >

//////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// A class for elements that solve the cartesian Navier–Stokes equations, templated by the dimension DIM. This contains the generic maths – any concrete implementation must be derived from this.

We're solving:

\( { Re \left( St \frac{\partial u_i}{\partial t} + (u_j - u_j^{M}) \frac{\partial u_i}{\partial x_j} \right) = - \frac{\partial p}{\partial x_i} - R_\rho B_i(x_j) - \frac{Re}{Fr} G_i + \frac{\partial }{\partial x_j} \left[ R_\mu \left( \frac{\partial u_i}{\partial x_j} + \frac{\partial u_j}{\partial x_i} \right) \right] } \)

and

\( { \frac{\partial u_i}{\partial x_i} = Q } \)

We also provide all functions required to use this element in FSI problems, by deriving it from the FSIFluidElement base class.

Member Typedef Documentation

◆ NavierStokesBodyForceFctPt

template<unsigned DIM>

typedef void(* oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::NavierStokesBodyForceFctPt) (const double &time, const Vector< double > &x, Vector< double > &body_force)

Function pointer to body force function fct(t,x,f(x)) x is a Vector!

◆ NavierStokesPressureAdvDiffSourceFctPt

template<unsigned DIM>

typedef double(* oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::NavierStokesPressureAdvDiffSourceFctPt) (const Vector< double > &x)

Function pointer to source function fct(x) for the pressure advection diffusion equation (only used during validation!). x is a Vector!

◆ NavierStokesSourceFctPt

template<unsigned DIM>

typedef double(* oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::NavierStokesSourceFctPt) (const double &time, const Vector< double > &x)

Function pointer to source function fct(t,x) x is a Vector!

Constructor & Destructor Documentation

◆ GeneralisedNewtonianNavierStokesEquations()

template<unsigned DIM>

oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::GeneralisedNewtonianNavierStokesEquations ( )

inline

Constructor: NULL the body force and source function and make sure the ALE terms are included by default.

       : Body_force_fct_pt(0),
         Source_fct_pt(0),
         // Press_adv_diff_source_fct_pt(0),
         Constitutive_eqn_pt(new NewtonianConstitutiveEquation<DIM>),
         Use_extrapolated_strainrate_to_compute_second_invariant(false),
         ALE_is_disabled(false)
     {
       // Set all the Physical parameter pointers to the default value zero
       Re_pt = &Default_Physical_Constant_Value;
       ReSt_pt = &Default_Physical_Constant_Value;
       ReInvFr_pt = &Default_Physical_Constant_Value;
       G_pt = &Default_Gravity_vector;
       // Set the Physical ratios to the default value of 1
       Viscosity_Ratio_pt = &Default_Physical_Ratio_Value;
       Density_Ratio_pt = &Default_Physical_Ratio_Value;
     }

References oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::Default_Gravity_vector, oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::Default_Physical_Constant_Value, oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::Default_Physical_Ratio_Value, oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::Density_Ratio_pt, oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::G_pt, oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::Re_pt, oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::ReInvFr_pt, oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::ReSt_pt, and oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::Viscosity_Ratio_pt.

Member Function Documentation

◆ body_force_fct_pt() [1/2]

template<unsigned DIM>

NavierStokesBodyForceFctPt& oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::body_force_fct_pt ( )

inline

Access function for the body-force pointer.

     {
       return Body_force_fct_pt;
     }

References oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::Body_force_fct_pt.

◆ body_force_fct_pt() [2/2]

template<unsigned DIM>

NavierStokesBodyForceFctPt oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::body_force_fct_pt ( ) const

inline

Access function for the body-force pointer. Const version.

     {
       return Body_force_fct_pt;
     }

References oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::Body_force_fct_pt.

◆ compute_error() [1/2]

template<unsigned DIM>

void oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::compute_error	(	std::ostream &	outfile,
		FiniteElement::SteadyExactSolutionFctPt	exact_soln_pt,
		double &	error,
		double &	norm
	)

virtual

Validate against exact solution. Solution is provided via function pointer. Plot at a given number of plot points and compute L2 error and L2 norm of velocity solution over element

Validate against exact velocity solution Solution is provided via function pointer. Plot at a given number of plot points and compute L2 error and L2 norm of velocity solution over element.

Reimplemented from oomph::FiniteElement.

   {
     error = 0.0;
     norm = 0.0;
  
     // Vector of local coordinates
     Vector<double> s(DIM);
  
     // Vector for coordintes
     Vector<double> x(DIM);
  
     // Set the value of n_intpt
     unsigned n_intpt = integral_pt()->nweight();
  
  
     outfile << "ZONE" << std::endl;
  
     // Exact solution Vector (u,v,[w],p)
     Vector<double> exact_soln(DIM + 1);
  
     // Loop over the integration points
     for (unsigned ipt = 0; ipt < n_intpt; ipt++)
     {
       // Assign values of s
       for (unsigned i = 0; i < DIM; i++)
       {
         s[i] = integral_pt()->knot(ipt, i);
       }
  
       // Get the integral weight
       double w = integral_pt()->weight(ipt);
  
       // Get jacobian of mapping
       double J = J_eulerian(s);
  
       // Premultiply the weights and the Jacobian
       double W = w * J;
  
       // Get x position as Vector
       interpolated_x(s, x);
  
       // Get exact solution at this point
       (*exact_soln_pt)(x, exact_soln);
  
       // Velocity error
       for (unsigned i = 0; i < DIM; i++)
       {
         norm += exact_soln[i] * exact_soln[i] * W;
         error += (exact_soln[i] - interpolated_u_nst(s, i)) *
                  (exact_soln[i] - interpolated_u_nst(s, i)) * W;
       }
  
       // Output x,y,...,u_exact
       for (unsigned i = 0; i < DIM; i++)
       {
         outfile << x[i] << " ";
       }
  
       // Output x,y,[z],u_error,v_error,[w_error]
       for (unsigned i = 0; i < DIM; i++)
       {
         outfile << exact_soln[i] - interpolated_u_nst(s, i) << " ";
       }
       outfile << std::endl;
     }
   }

References DIM, calibrate::error, ProblemParameters::exact_soln(), i, J, s, w, oomph::QuadTreeNames::W, and plotDoE::x.

◆ compute_error() [2/2]

template<unsigned DIM>

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

virtual

Validate against exact solution at given time Solution is provided via function pointer. Plot at a given number of plot points and compute L2 error and L2 norm of velocity solution over element

Validate against exact velocity solution at given time. Solution is provided via function pointer. Plot at a given number of plot points and compute L2 error and L2 norm of velocity solution over element.

Reimplemented from oomph::FiniteElement.

   {
     error = 0.0;
     norm = 0.0;
  
     // Vector of local coordinates
     Vector<double> s(DIM);
  
     // Vector for coordintes
     Vector<double> x(DIM);
  
     // Set the value of n_intpt
     unsigned n_intpt = integral_pt()->nweight();
  
     outfile << "ZONE" << std::endl;
  
     // Exact solution Vector (u,v,[w],p)
     Vector<double> exact_soln(DIM + 1);
  
     // Loop over the integration points
     for (unsigned ipt = 0; ipt < n_intpt; ipt++)
     {
       // Assign values of s
       for (unsigned i = 0; i < DIM; i++)
       {
         s[i] = integral_pt()->knot(ipt, i);
       }
  
       // Get the integral weight
       double w = integral_pt()->weight(ipt);
  
       // Get jacobian of mapping
       double J = J_eulerian(s);
  
       // Premultiply the weights and the Jacobian
       double W = w * J;
  
       // Get x position as Vector
       interpolated_x(s, x);
  
       // Get exact solution at this point
       (*exact_soln_pt)(time, x, exact_soln);
  
       // Velocity error
       for (unsigned i = 0; i < DIM; i++)
       {
         norm += exact_soln[i] * exact_soln[i] * W;
         error += (exact_soln[i] - interpolated_u_nst(s, i)) *
                  (exact_soln[i] - interpolated_u_nst(s, i)) * W;
       }
  
       // Output x,y,...,u_exact
       for (unsigned i = 0; i < DIM; i++)
       {
         outfile << x[i] << " ";
       }
  
       // Output x,y,[z],u_error,v_error,[w_error]
       for (unsigned i = 0; i < DIM; i++)
       {
         outfile << exact_soln[i] - interpolated_u_nst(s, i) << " ";
       }
  
       outfile << std::endl;
     }
   }

References DIM, calibrate::error, ProblemParameters::exact_soln(), i, J, s, w, oomph::QuadTreeNames::W, and plotDoE::x.

◆ constitutive_eqn_pt()

template<unsigned DIM>

GeneralisedNewtonianConstitutiveEquation<DIM>*& oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::constitutive_eqn_pt ( )

inline

Access function for the constitutive equation pointer.

     {
       return Constitutive_eqn_pt;
     }

References oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::Constitutive_eqn_pt.

◆ d_kin_energy_dt()

template<unsigned DIM>

double oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::d_kin_energy_dt

Get integral of time derivative of kinetic energy over element.

Get integral of time derivative of kinetic energy over element:

   {
     // Initialise
     double d_kin_en_dt = 0.0;
  
     // Set the value of n_intpt
     const unsigned n_intpt = integral_pt()->nweight();
  
     // Set the Vector to hold local coordinates
     Vector<double> s(DIM);
  
     // Get the number of nodes
     const unsigned n_node = this->nnode();
  
     // Storage for the shape function
     Shape psi(n_node);
     DShape dpsidx(n_node, DIM);
  
     // Get the value at which the velocities are stored
     unsigned u_index[DIM];
     for (unsigned i = 0; i < DIM; i++)
     {
       u_index[i] = this->u_index_nst(i);
     }
  
     // Loop over the integration points
     for (unsigned ipt = 0; ipt < n_intpt; ipt++)
     {
       // Get the jacobian of the mapping
       double J = dshape_eulerian_at_knot(ipt, psi, dpsidx);
  
       // Get the integral weight
       double w = integral_pt()->weight(ipt);
  
       // Now work out the velocity and the time derivative
       Vector<double> interpolated_u(DIM, 0.0), interpolated_dudt(DIM, 0.0);
  
       // Loop over the shape functions
       for (unsigned l = 0; l < n_node; l++)
       {
         // Loop over the dimensions
         for (unsigned i = 0; i < DIM; i++)
         {
           interpolated_u[i] += nodal_value(l, u_index[i]) * psi(l);
           interpolated_dudt[i] += du_dt_nst(l, u_index[i]) * psi(l);
         }
       }
  
       // Get mesh velocity bit
       if (!ALE_is_disabled)
       {
         Vector<double> mesh_velocity(DIM, 0.0);
         DenseMatrix<double> interpolated_dudx(DIM, DIM, 0.0);
  
         // Loop over nodes again
         for (unsigned l = 0; l < n_node; l++)
         {
           for (unsigned i = 0; i < DIM; i++)
           {
             mesh_velocity[i] += this->dnodal_position_dt(l, i) * psi(l);
  
             for (unsigned j = 0; j < DIM; j++)
             {
               interpolated_dudx(i, j) +=
                 this->nodal_value(l, u_index[i]) * dpsidx(l, j);
             }
           }
         }
  
         // Subtract mesh velocity from du_dt
         for (unsigned i = 0; i < DIM; i++)
         {
           for (unsigned k = 0; k < DIM; k++)
           {
             interpolated_dudt[i] -= mesh_velocity[k] * interpolated_dudx(i, k);
           }
         }
       }
  
  
       // Loop over directions and add up u du/dt  terms
       double sum = 0.0;
       for (unsigned i = 0; i < DIM; i++)
       {
         sum += interpolated_u[i] * interpolated_dudt[i];
       }
  
       d_kin_en_dt += sum * w * J;
     }
  
     return d_kin_en_dt;
   }

References oomph::ALE_is_disabled, DIM, i, J, j, k, s, and w.

◆ density_ratio()

template<unsigned DIM>

const double& oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::density_ratio ( ) const

inline

Density ratio for element: Element's density relative to the viscosity used in the definition of the Reynolds number

     {
       return *Density_Ratio_pt;
     }

References oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::Density_Ratio_pt.

◆ density_ratio_pt()

template<unsigned DIM>

double*& oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::density_ratio_pt ( )

inline

Pointer to Density ratio.

     {
       return Density_Ratio_pt;
     }

References oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::Density_Ratio_pt.

◆ dinterpolated_u_nst_ddata()

template<unsigned DIM>

virtual void oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::dinterpolated_u_nst_ddata	(	const Vector< double > &	s,
		const unsigned &	i,
		Vector< double > &	du_ddata,
		Vector< unsigned > &	global_eqn_number
	)

inlinevirtual

Compute the derivatives of the i-th component of velocity at point s with respect to all data that can affect its value. In addition, return the global equation numbers corresponding to the data. The function is virtual so that it can be overloaded in the refineable version

Reimplemented in oomph::RefineableGeneralisedNewtonianNavierStokesEquations< DIM >.

     {
       // Find number of nodes
       unsigned n_node = nnode();
       // Local shape function
       Shape psi(n_node);
       // Find values of shape function
       shape(s, psi);
  
       // Find the index at which the velocity component is stored
       const unsigned u_nodal_index = u_index_nst(i);
  
       // Find the number of dofs associated with interpolated u
       unsigned n_u_dof = 0;
       for (unsigned l = 0; l < n_node; l++)
       {
         int global_eqn = this->node_pt(l)->eqn_number(u_nodal_index);
         // If it's positive add to the count
         if (global_eqn >= 0)
         {
           ++n_u_dof;
         }
       }
  
       // Now resize the storage schemes
       du_ddata.resize(n_u_dof, 0.0);
       global_eqn_number.resize(n_u_dof, 0);
  
       // Loop over th nodes again and set the derivatives
       unsigned count = 0;
       // Loop over the local nodes and sum
       for (unsigned l = 0; l < n_node; l++)
       {
         // Get the global equation number
         int global_eqn = this->node_pt(l)->eqn_number(u_nodal_index);
         if (global_eqn >= 0)
         {
           // Set the global equation number
           global_eqn_number[count] = global_eqn;
           // Set the derivative with respect to the unknown
           du_ddata[count] = psi[l];
           // Increase the counter
           ++count;
         }
       }
     }

References oomph::Data::eqn_number(), i, oomph::FiniteElement::nnode(), oomph::FiniteElement::node_pt(), s, oomph::FiniteElement::shape(), and oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::u_index_nst().

◆ disable_ALE()

template<unsigned DIM>

void oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::disable_ALE ( )

inlinevirtual

Disable ALE, i.e. assert the mesh is not moving – you do this at your own risk!

Reimplemented from oomph::FiniteElement.

     {
       ALE_is_disabled = true;
     }

References oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::ALE_is_disabled.

◆ dissipation() [1/2]

template<unsigned DIM>

double oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::dissipation

Return integral of dissipation over element.

   {
     throw OomphLibError(
       "Check the dissipation calculation for GeneralisedNewtonian NSt",
       OOMPH_CURRENT_FUNCTION,
       OOMPH_EXCEPTION_LOCATION);
  
     // Initialise
     double diss = 0.0;
  
     // Set the value of n_intpt
     unsigned n_intpt = integral_pt()->nweight();
  
     // Set the Vector to hold local coordinates
     Vector<double> s(DIM);
  
     // Loop over the integration points
     for (unsigned ipt = 0; ipt < n_intpt; ipt++)
     {
       // Assign values of s
       for (unsigned i = 0; i < DIM; i++)
       {
         s[i] = integral_pt()->knot(ipt, i);
       }
  
       // Get the integral weight
       double w = integral_pt()->weight(ipt);
  
       // Get Jacobian of mapping
       double J = J_eulerian(s);
  
       // Get strain rate matrix
       DenseMatrix<double> strainrate(DIM, DIM);
       strain_rate(s, strainrate);
  
       // Initialise
       double local_diss = 0.0;
       for (unsigned i = 0; i < DIM; i++)
       {
         for (unsigned j = 0; j < DIM; j++)
         {
           local_diss += 2.0 * strainrate(i, j) * strainrate(i, j);
         }
       }
  
       diss += local_diss * w * J;
     }
  
     return diss;
   }

References DIM, i, J, j, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, s, and w.

◆ dissipation() [2/2]

template<unsigned DIM>

double oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::dissipation ( const Vector< double > & s ) const

Return dissipation at local coordinate s.

   {
     throw OomphLibError(
       "Check the dissipation calculation for GeneralisedNewtonian NSt",
       OOMPH_CURRENT_FUNCTION,
       OOMPH_EXCEPTION_LOCATION);
  
     // Get strain rate matrix
     DenseMatrix<double> strainrate(DIM, DIM);
     strain_rate(s, strainrate);
  
     // Initialise
     double local_diss = 0.0;
     for (unsigned i = 0; i < DIM; i++)
     {
       for (unsigned j = 0; j < DIM; j++)
       {
         local_diss += 2.0 * strainrate(i, j) * strainrate(i, j);
       }
     }
  
     return local_diss;
   }

References DIM, i, j, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and s.

◆ dpshape_and_dptest_eulerian_nst()

template<unsigned DIM>

virtual double oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::dpshape_and_dptest_eulerian_nst	(	const Vector< double > &	s,
		Shape &	ppsi,
		DShape &	dppsidx,
		Shape &	ptest,
		DShape &	dptestdx
	)		const

protectedpure virtual

Compute the pressure shape and test functions and derivatives w.r.t. global coords at local coordinate s. Return Jacobian of mapping between local and global coordinates.

◆ dshape_and_dtest_eulerian_at_knot_nst() [1/2]

template<unsigned DIM>

virtual double oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::dshape_and_dtest_eulerian_at_knot_nst	(	const unsigned &	ipt,
		Shape &	psi,
		DShape &	dpsidx,
		RankFourTensor< double > &	d_dpsidx_dX,
		Shape &	test,
		DShape &	dtestdx,
		RankFourTensor< double > &	d_dtestdx_dX,
		DenseMatrix< double > &	djacobian_dX
	)		const

protectedpure virtual

Shape/test functions and derivs w.r.t. to global coords at integration point ipt; return Jacobian of mapping (J). Also compute derivatives of dpsidx, dtestdx and J w.r.t. nodal coordinates.

◆ dshape_and_dtest_eulerian_at_knot_nst() [2/2]

template<unsigned DIM>

virtual double oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::dshape_and_dtest_eulerian_at_knot_nst	(	const unsigned &	ipt,
		Shape &	psi,
		DShape &	dpsidx,
		Shape &	test,
		DShape &	dtestdx
	)		const

protectedpure virtual

Compute the shape functions and derivatives w.r.t. global coords at ipt-th integration point Return Jacobian of mapping between local and global coordinates.

Implemented in oomph::GeneralisedNewtonianTTaylorHoodElement< DIM >, oomph::GeneralisedNewtonianTCrouzeixRaviartElement< DIM >, oomph::PRefineableGeneralisedNewtonianQCrouzeixRaviartElement< DIM >, oomph::PRefineableGeneralisedNewtonianQCrouzeixRaviartElement< DIM >, oomph::PRefineableGeneralisedNewtonianQCrouzeixRaviartElement< DIM >, oomph::GeneralisedNewtonianQTaylorHoodElement< DIM >, and oomph::GeneralisedNewtonianQCrouzeixRaviartElement< DIM >.

◆ dshape_and_dtest_eulerian_nst()

template<unsigned DIM>

virtual double oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::dshape_and_dtest_eulerian_nst	(	const Vector< double > &	s,
		Shape &	psi,
		DShape &	dpsidx,
		Shape &	test,
		DShape &	dtestdx
	)		const

protectedpure virtual

Compute the shape functions and derivatives w.r.t. global coords at local coordinate s. Return Jacobian of mapping between local and global coordinates.

Implemented in oomph::GeneralisedNewtonianTTaylorHoodElement< DIM >, oomph::GeneralisedNewtonianTCrouzeixRaviartElement< DIM >, oomph::PRefineableGeneralisedNewtonianQCrouzeixRaviartElement< DIM >, oomph::PRefineableGeneralisedNewtonianQCrouzeixRaviartElement< DIM >, oomph::PRefineableGeneralisedNewtonianQCrouzeixRaviartElement< DIM >, oomph::GeneralisedNewtonianQTaylorHoodElement< DIM >, and oomph::GeneralisedNewtonianQCrouzeixRaviartElement< DIM >.

◆ du_dt_nst()

template<unsigned DIM>

double oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::du_dt_nst	(	const unsigned &	n,
		const unsigned &	i
	)		const

inline

i-th component of du/dt at local node n. Uses suitably interpolated value for hanging nodes.

     {
       // Get the data's timestepper
       TimeStepper* time_stepper_pt = this->node_pt(n)->time_stepper_pt();
  
       // Initialise dudt
       double dudt = 0.0;
  
       // Loop over the timesteps, if there is a non Steady timestepper
       if (!time_stepper_pt->is_steady())
       {
         // Find the index at which the dof is stored
         const unsigned u_nodal_index = this->u_index_nst(i);
  
         // Number of timsteps (past & present)
         const unsigned n_time = time_stepper_pt->ntstorage();
         // Loop over the timesteps
         for (unsigned t = 0; t < n_time; t++)
         {
           dudt +=
             time_stepper_pt->weight(1, t) * nodal_value(t, n, u_nodal_index);
         }
       }
  
       return dudt;
     }

References oomph::TimeStepper::is_steady(), n, oomph::FiniteElement::nodal_value(), oomph::FiniteElement::node_pt(), oomph::TimeStepper::ntstorage(), plotPSD::t, oomph::GeomObject::time_stepper_pt(), oomph::Data::time_stepper_pt(), oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::u_index_nst(), and oomph::TimeStepper::weight().

◆ enable_ALE()

template<unsigned DIM>

void oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::enable_ALE ( )

inlinevirtual

(Re-)enable ALE, i.e. take possible mesh motion into account when evaluating the time-derivative. Note: By default, ALE is enabled, at the expense of possibly creating unnecessary work in problems where the mesh is, in fact, stationary.

Reimplemented from oomph::FiniteElement.

     {
       ALE_is_disabled = false;
     }

References oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::ALE_is_disabled.

◆ extrapolated_strain_rate() [1/2]

template<unsigned DIM>

virtual void oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::extrapolated_strain_rate	(	const unsigned &	ipt,
		DenseMatrix< double > &	strain_rate
	)		const

inlinevirtual

Extrapolated strain-rate tensor: 1/2 (du_i/dx_j + du_j/dx_i) based on the previous time steps evaluated at ipt-th integration point

     {
       // Set the Vector to hold local coordinates
       Vector<double> s(DIM);
       for (unsigned i = 0; i < DIM; i++) s[i] = integral_pt()->knot(ipt, i);
       extrapolated_strain_rate(s, strain_rate);
     }

References DIM, oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::extrapolated_strain_rate(), i, oomph::FiniteElement::integral_pt(), oomph::Integral::knot(), s, and oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::strain_rate().

◆ extrapolated_strain_rate() [2/2]

template<unsigned DIM>

void oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::extrapolated_strain_rate	(	const Vector< double > &	s,
		DenseMatrix< double > &	strainrate
	)		const

virtual

Extrapolated strain-rate tensor: 1/2 (du_i/dx_j + du_j/dx_i) based on the previous time steps evaluated at local coordinate s

Get strain-rate tensor: 1/2 (du_i/dx_j + du_j/dx_i) Extrapolated from history values.

   {
 #ifdef PARANOID
     if ((strainrate.ncol() != DIM) || (strainrate.nrow() != DIM))
     {
       std::ostringstream error_message;
       error_message << "The strain rate has incorrect dimensions "
                     << strainrate.ncol() << " x " << strainrate.nrow()
                     << " Not " << DIM << std::endl;
  
       throw OomphLibError(
         error_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
 #endif
  
     // Get strain rates at two previous times
     DenseMatrix<double> strain_rate_minus_two(DIM, DIM);
     strain_rate(2, s, strain_rate_minus_two);
  
     DenseMatrix<double> strain_rate_minus_one(DIM, DIM);
     strain_rate(1, s, strain_rate_minus_one);
  
     // Get timestepper from first node
     TimeStepper* time_stepper_pt = node_pt(0)->time_stepper_pt();
  
     // Current and previous timesteps
     double dt_current = time_stepper_pt->time_pt()->dt(0);
     double dt_prev = time_stepper_pt->time_pt()->dt(1);
  
     // Extrapolate
     for (unsigned i = 0; i < DIM; i++)
     {
       for (unsigned j = 0; j < DIM; j++)
       {
         // Rate of changed based on previous two solutions
         double slope =
           (strain_rate_minus_one(i, j) - strain_rate_minus_two(i, j)) / dt_prev;
  
         // Extrapolated value from previous computed one to current one
         strainrate(i, j) = strain_rate_minus_one(i, j) + slope * dt_current;
       }
     }
   }

References DIM, oomph::Time::dt(), i, j, oomph::DenseMatrix< T >::ncol(), oomph::DenseMatrix< T >::nrow(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, s, and oomph::TimeStepper::time_pt().

Referenced by oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::extrapolated_strain_rate().

◆ fill_in_contribution_to_djacobian_and_dmass_matrix_dparameter()

template<unsigned DIM>

void oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::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
	)

inlinevirtual

Add the element's contribution to its residuals vector, jacobian matrix and mass matrix

Reimplemented from oomph::GeneralisedElement.

     {
       // Call the generic routine with the flag set to 2
       fill_in_generic_dresidual_contribution_nst(
         parameter_pt, dres_dparam, djac_dparam, dmass_matrix_dparam, 2);
     }

References oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::fill_in_generic_dresidual_contribution_nst().

◆ fill_in_contribution_to_djacobian_dparameter()

template<unsigned DIM>

void oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::fill_in_contribution_to_djacobian_dparameter	(	double *const &	parameter_pt,
		Vector< double > &	dres_dparam,
		DenseMatrix< double > &	djac_dparam
	)

inlinevirtual

Compute the element's residual Vector and the jacobian matrix Virtual function can be overloaded by hanging-node version

Reimplemented from oomph::GeneralisedElement.

     {
       // Call the generic routine with the flag set to 1
       fill_in_generic_dresidual_contribution_nst(
         parameter_pt,
         dres_dparam,
         djac_dparam,
         GeneralisedElement::Dummy_matrix,
         1);
     }

References oomph::GeneralisedElement::Dummy_matrix, and oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::fill_in_generic_dresidual_contribution_nst().

◆ fill_in_contribution_to_dresiduals_dparameter()

template<unsigned DIM>

void oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::fill_in_contribution_to_dresiduals_dparameter	(	double *const &	parameter_pt,
		Vector< double > &	dres_dparam
	)

inlinevirtual

Compute the element's residual Vector.

Reimplemented from oomph::GeneralisedElement.

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

References oomph::GeneralisedElement::Dummy_matrix, and oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::fill_in_generic_dresidual_contribution_nst().

◆ fill_in_contribution_to_hessian_vector_products()

template<unsigned DIM>

void oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::fill_in_contribution_to_hessian_vector_products	(	Vector< double > const &	Y,
		DenseMatrix< double > const &	C,
		DenseMatrix< double > &	product
	)

protectedvirtual

Compute the hessian tensor vector products required to perform continuation of bifurcations analytically

Reimplemented from oomph::GeneralisedElement.

   {
     throw OomphLibError("Not yet implemented\n",
                         OOMPH_CURRENT_FUNCTION,
                         OOMPH_EXCEPTION_LOCATION);
   }

References OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

◆ fill_in_contribution_to_jacobian()

template<unsigned DIM>

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

inlinevirtual

Compute the element's residual Vector and the jacobian matrix Virtual function can be overloaded by hanging-node version

Reimplemented from oomph::GeneralisedElement.

Reimplemented in oomph::PseudoSolidNodeUpdateElement< GeneralisedNewtonianTTaylorHoodElement< 2 >, TPVDElement< 2, 3 > >.

     {
       // Call the generic routine with the flag set to 1
       fill_in_generic_residual_contribution_nst(
         residuals, jacobian, GeneralisedElement::Dummy_matrix, 1);
       // obacht FD version
       // FiniteElement::fill_in_contribution_to_jacobian(residuals,jacobian);
     }

References oomph::GeneralisedElement::Dummy_matrix, and oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::fill_in_generic_residual_contribution_nst().

◆ fill_in_contribution_to_jacobian_and_mass_matrix()

template<unsigned DIM>

void oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::fill_in_contribution_to_jacobian_and_mass_matrix	(	Vector< double > &	residuals,
		DenseMatrix< double > &	jacobian,
		DenseMatrix< double > &	mass_matrix
	)

inlinevirtual

Add the element's contribution to its residuals vector, jacobian matrix and mass matrix

Reimplemented from oomph::GeneralisedElement.

Reimplemented in oomph::PseudoSolidNodeUpdateElement< GeneralisedNewtonianTTaylorHoodElement< 2 >, TPVDElement< 2, 3 > >.

     {
       // Call the generic routine with the flag set to 2
       fill_in_generic_residual_contribution_nst(
         residuals, jacobian, mass_matrix, 2);
     }

References oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::fill_in_generic_residual_contribution_nst().

◆ fill_in_contribution_to_residuals()

template<unsigned DIM>

void oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::fill_in_contribution_to_residuals ( Vector< double > & residuals )

inlinevirtual

Compute the element's residual Vector.

Reimplemented from oomph::GeneralisedElement.

Reimplemented in oomph::PseudoSolidNodeUpdateElement< GeneralisedNewtonianTTaylorHoodElement< 2 >, TPVDElement< 2, 3 > >.

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

References oomph::GeneralisedElement::Dummy_matrix, and oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::fill_in_generic_residual_contribution_nst().

◆ fill_in_generic_dresidual_contribution_nst()

template<unsigned DIM>

void oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::fill_in_generic_dresidual_contribution_nst	(	double *const &	parameter_pt,
		Vector< double > &	dres_dparam,
		DenseMatrix< double > &	djac_dparam,
		DenseMatrix< double > &	dmass_matrix_dparam,
		unsigned	flag
	)

protectedvirtual

Compute the derivatives of the residuals for the Navier–Stokes equations with respect to a parameter Flag=1 (or 0): do (or don't) compute the Jacobian as well. Flag=2: Fill in mass matrix too.

Compute the derivatives of the residuals for the Navier–Stokes equations with respect to a parameter; flag=2 or 1 or 0: do (or don't) compute the Jacobian and mass matrix as well

   {
     throw OomphLibError("Not yet implemented\n",
                         OOMPH_CURRENT_FUNCTION,
                         OOMPH_EXCEPTION_LOCATION);
   }

References OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

Referenced by oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::fill_in_contribution_to_djacobian_and_dmass_matrix_dparameter(), oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::fill_in_contribution_to_djacobian_dparameter(), and oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::fill_in_contribution_to_dresiduals_dparameter().

◆ fill_in_generic_residual_contribution_nst()

template<unsigned DIM>

void oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::fill_in_generic_residual_contribution_nst	(	Vector< double > &	residuals,
		DenseMatrix< double > &	jacobian,
		DenseMatrix< double > &	mass_matrix,
		unsigned	flag
	)

protectedvirtual

Compute the residuals for the Navier–Stokes equations. Flag=1 (or 0): do (or don't) compute the Jacobian as well. Flag=2: Fill in mass matrix too.

Compute the residuals for the Navier–Stokes equations; flag=1(or 0): do (or don't) compute the Jacobian as well.

Reimplemented in oomph::RefineableGeneralisedNewtonianNavierStokesEquations< DIM >.

   {
     // Return immediately if there are no dofs
     if (ndof() == 0) return;
  
     // Find out how many nodes there are
     unsigned n_node = nnode();
  
     // Get continuous time from timestepper of first node
     double time = node_pt(0)->time_stepper_pt()->time_pt()->time();
  
     // Find out how many pressure dofs there are
     unsigned n_pres = npres_nst();
  
     // Find the indices at which the local velocities are stored
     unsigned u_nodal_index[DIM];
     for (unsigned i = 0; i < DIM; i++)
     {
       u_nodal_index[i] = u_index_nst(i);
     }
  
     // Set up memory for the shape and test functions
     Shape psif(n_node), testf(n_node);
     DShape dpsifdx(n_node, DIM), dtestfdx(n_node, DIM);
  
     // Set up memory for pressure shape and test functions
     Shape psip(n_pres), testp(n_pres);
  
     // Number of integration points
     unsigned n_intpt = integral_pt()->nweight();
  
     // Set the Vector to hold local coordinates
     Vector<double> s(DIM);
  
     // Get Physical Variables from Element
     // Reynolds number must be multiplied by the density ratio
     double scaled_re = re() * density_ratio();
     double scaled_re_st = re_st() * density_ratio();
     double scaled_re_inv_fr = re_invfr() * density_ratio();
     double visc_ratio = viscosity_ratio();
     Vector<double> G = g();
  
     // Integers to store the local equations and unknowns
     int local_eqn = 0, local_unknown = 0;
  
     // Loop over the integration points
     for (unsigned ipt = 0; ipt < n_intpt; ipt++)
     {
       // Assign values of s
       for (unsigned i = 0; i < DIM; i++) s[i] = integral_pt()->knot(ipt, i);
       // Get the integral weight
       double w = integral_pt()->weight(ipt);
  
       // Call the derivatives of the shape and test functions
       double J = dshape_and_dtest_eulerian_at_knot_nst(
         ipt, psif, dpsifdx, testf, dtestfdx);
  
       // Call the pressure shape and test functions
       pshape_nst(s, psip, testp);
  
       // Premultiply the weights and the Jacobian
       double W = w * J;
  
       // Calculate local values of the pressure and velocity components
       // Allocate
       double interpolated_p = 0.0;
       Vector<double> interpolated_u(DIM, 0.0);
       Vector<double> interpolated_x(DIM, 0.0);
       Vector<double> mesh_velocity(DIM, 0.0);
       Vector<double> dudt(DIM, 0.0);
       DenseMatrix<double> interpolated_dudx(DIM, DIM, 0.0);
  
       // Calculate pressure
       for (unsigned l = 0; l < n_pres; l++)
         interpolated_p += p_nst(l) * psip[l];
  
       // Calculate velocities and derivatives:
  
       // Loop over nodes
       for (unsigned l = 0; l < n_node; l++)
       {
         // Loop over directions
         for (unsigned i = 0; i < DIM; i++)
         {
           // Get the nodal value
           double u_value = raw_nodal_value(l, u_nodal_index[i]);
           interpolated_u[i] += u_value * psif[l];
           interpolated_x[i] += raw_nodal_position(l, i) * psif[l];
           dudt[i] += du_dt_nst(l, i) * psif[l];
  
           // Loop over derivative directions
           for (unsigned j = 0; j < DIM; j++)
           {
             interpolated_dudx(i, j) += u_value * dpsifdx(l, j);
           }
         }
       }
  
       if (!ALE_is_disabled)
       {
         // Loop over nodes
         for (unsigned l = 0; l < n_node; l++)
         {
           // Loop over directions
           for (unsigned i = 0; i < DIM; i++)
           {
             mesh_velocity[i] += this->raw_dnodal_position_dt(l, i) * psif[l];
           }
         }
       }
  
       // The strainrate used to compute the second invariant
       DenseMatrix<double> strainrate_to_compute_second_invariant(DIM, DIM, 0.0);
  
       // the strainrate used to calculate the second invariant
       // can be either the current one or the one extrapolated from
       // previous velocity values
       if (!Use_extrapolated_strainrate_to_compute_second_invariant)
       {
         strain_rate(s, strainrate_to_compute_second_invariant);
       }
       else
       {
         extrapolated_strain_rate(ipt, strainrate_to_compute_second_invariant);
       }
  
       // Calculate the second invariant
       double second_invariant = SecondInvariantHelper::second_invariant(
         strainrate_to_compute_second_invariant);
  
       // Get the viscosity according to the constitutive equation
       double viscosity = Constitutive_eqn_pt->viscosity(second_invariant);
  
       // Get the user-defined body force terms
       Vector<double> body_force(DIM);
       get_body_force_nst(time, ipt, s, interpolated_x, body_force);
  
       // Get the user-defined source function
       double source = get_source_nst(time, ipt, interpolated_x);
  
       // The generalised Newtonian viscosity differentiated w.r.t.
       // the unknown velocities
       DenseMatrix<double> dviscosity_dunknown(DIM, n_node, 0.0);
  
       if (!Use_extrapolated_strainrate_to_compute_second_invariant)
       {
         // Calculate the derivate of the viscosity w.r.t. the second invariant
         double dviscosity_dsecond_invariant =
           Constitutive_eqn_pt->dviscosity_dinvariant(second_invariant);
  
         // calculate the strainrate
         DenseMatrix<double> strainrate(DIM, DIM, 0.0);
         strain_rate(s, strainrate);
  
         // pre-compute the derivative of the second invariant w.r.t. the
         // entries in the rate of strain tensor
         DenseMatrix<double> dinvariant_dstrainrate(DIM, DIM, 0.0);
  
         // setting up a Kronecker Delta matrix, which has ones at the diagonal
         // and zeros off-diagonally
         DenseMatrix<double> kroneckerdelta(DIM, DIM, 0.0);
  
         for (unsigned i = 0; i < DIM; i++)
         {
           for (unsigned j = 0; j < DIM; j++)
           {
             if (i == j)
             {
               // Set the diagonal entries of the Kronecker delta
               kroneckerdelta(i, i) = 1.0;
  
               double tmp = 0.0;
               for (unsigned k = 0; k < DIM; k++)
               {
                 if (k != i)
                 {
                   tmp += strainrate(k, k);
                 }
               }
               dinvariant_dstrainrate(i, i) = tmp;
             }
             else
             {
               dinvariant_dstrainrate(i, j) = -strainrate(j, i);
             }
           }
         }
  
         // a rank four tensor storing the derivative of the strainrate
         // w.r.t. the unknowns
         RankFourTensor<double> dstrainrate_dunknown(DIM, DIM, DIM, n_node);
  
         // loop over the nodes
         for (unsigned l = 0; l < n_node; l++)
         {
           // loop over the velocity components
           for (unsigned k = 0; k < DIM; k++)
           {
             // loop over the entries of the rate of strain tensor
             for (unsigned i = 0; i < DIM; i++)
             {
               for (unsigned j = 0; j < DIM; j++)
               {
                 // initialise the entry to zero
                 dstrainrate_dunknown(i, j, k, l) = 0.0;
  
                 // loop over velocities and directions
                 for (unsigned m = 0; m < DIM; m++)
                 {
                   for (unsigned n = 0; n < DIM; n++)
                   {
                     dstrainrate_dunknown(i, j, k, l) +=
                       0.5 *
                       (kroneckerdelta(i, m) * kroneckerdelta(j, n) +
                        kroneckerdelta(i, n) * kroneckerdelta(j, m)) *
                       kroneckerdelta(m, k) * dpsifdx(l, n);
                   }
                 }
               }
             }
           }
         }
  
         // Now calculate the derivative of the viscosity w.r.t. the unknowns
         // loop over the nodes
         for (unsigned l = 0; l < n_node; l++)
         {
           // loop over the velocities
           for (unsigned k = 0; k < DIM; k++)
           {
             // loop over the entries in the rate of strain tensor
             for (unsigned i = 0; i < DIM; i++)
             {
               for (unsigned j = 0; j < DIM; j++)
               {
                 dviscosity_dunknown(k, l) += dviscosity_dsecond_invariant *
                                              dinvariant_dstrainrate(i, j) *
                                              dstrainrate_dunknown(i, j, k, l);
               }
             }
           }
         }
       }
  
  
       // MOMENTUM EQUATIONS
       //------------------
  
       // Loop over the test functions
       for (unsigned l = 0; l < n_node; l++)
       {
         // Loop over the velocity components
         for (unsigned i = 0; i < DIM; i++)
         {
           /*IF it's not a boundary condition*/
           local_eqn = nodal_local_eqn(l, u_nodal_index[i]);
           if (local_eqn >= 0)
           {
             // Add the user-defined body force terms
             residuals[local_eqn] += body_force[i] * testf[l] * W;
  
             // Add the gravitational body force term
             residuals[local_eqn] += scaled_re_inv_fr * testf[l] * G[i] * W;
  
             // Add the pressure gradient term
             // Potentially pre-multiply by viscosity ratio
             if (Pre_multiply_by_viscosity_ratio)
             {
               residuals[local_eqn] +=
                 visc_ratio * viscosity * interpolated_p * dtestfdx(l, i) * W;
             }
             else
             {
               residuals[local_eqn] += interpolated_p * dtestfdx(l, i) * W;
             }
  
             // Add in the stress tensor terms
             // The viscosity ratio needs to go in here to ensure
             // continuity of normal stress is satisfied even in flows
             // with zero pressure gradient!
             for (unsigned k = 0; k < DIM; k++)
             {
               residuals[local_eqn] -=
                 visc_ratio * viscosity *
                 (interpolated_dudx(i, k) + Gamma[i] * interpolated_dudx(k, i)) *
                 dtestfdx(l, k) * W;
             }
  
             // Add in the inertial terms
             // du/dt term
             residuals[local_eqn] -= scaled_re_st * dudt[i] * testf[l] * W;
  
  
             // Convective terms, including mesh velocity
             for (unsigned k = 0; k < DIM; k++)
             {
               double tmp = scaled_re * interpolated_u[k];
               if (!ALE_is_disabled) tmp -= scaled_re_st * mesh_velocity[k];
               residuals[local_eqn] -=
                 tmp * interpolated_dudx(i, k) * testf[l] * W;
             }
  
             // CALCULATE THE JACOBIAN
             if (flag)
             {
               // Loop over the velocity shape functions again
               for (unsigned l2 = 0; l2 < n_node; l2++)
               {
                 // Loop over the velocity components again
                 for (unsigned i2 = 0; i2 < DIM; i2++)
                 {
                   // If at a non-zero degree of freedom add in the entry
                   local_unknown = nodal_local_eqn(l2, u_nodal_index[i2]);
                   if (local_unknown >= 0)
                   {
                     // Add contribution to Elemental Matrix
                     jacobian(local_eqn, local_unknown) -=
                       visc_ratio * viscosity * Gamma[i] * dpsifdx(l2, i) *
                       dtestfdx(l, i2) * W;
  
                     // Extra component if i2 = i
                     if (i2 == i)
                     {
                       /*Loop over velocity components*/
                       for (unsigned k = 0; k < DIM; k++)
                       {
                         jacobian(local_eqn, local_unknown) -=
                           visc_ratio * viscosity * dpsifdx(l2, k) *
                           dtestfdx(l, k) * W;
                       }
                     }
  
                     if (
                       !Use_extrapolated_strainrate_to_compute_second_invariant)
                     {
                       for (unsigned k = 0; k < DIM; k++)
                       {
                         jacobian(local_eqn, local_unknown) -=
                           visc_ratio * dviscosity_dunknown(i2, l2) *
                           (interpolated_dudx(i, k) +
                            Gamma[i] * interpolated_dudx(k, i)) *
                           dtestfdx(l, k) * W;
                       }
                     }
  
                     // Now add in the inertial terms
                     jacobian(local_eqn, local_unknown) -=
                       scaled_re * psif[l2] * interpolated_dudx(i, i2) *
                       testf[l] * W;
  
                     // Extra component if i2=i
                     if (i2 == i)
                     {
                       // Add the mass matrix term (only diagonal entries)
                       // Note that this is positive because the mass matrix
                       // is taken to the other side of the equation when
                       // formulating the generalised eigenproblem.
                       if (flag == 2)
                       {
                         mass_matrix(local_eqn, local_unknown) +=
                           scaled_re_st * psif[l2] * testf[l] * W;
                       }
  
                       // du/dt term
                       jacobian(local_eqn, local_unknown) -=
                         scaled_re_st *
                         node_pt(l2)->time_stepper_pt()->weight(1, 0) *
                         psif[l2] * testf[l] * W;
  
                       // Loop over the velocity components
                       for (unsigned k = 0; k < DIM; k++)
                       {
                         double tmp = scaled_re * interpolated_u[k];
                         if (!ALE_is_disabled)
                           tmp -= scaled_re_st * mesh_velocity[k];
                         jacobian(local_eqn, local_unknown) -=
                           tmp * dpsifdx(l2, k) * testf[l] * W;
                       }
                     }
                   }
                 }
               }
  
               /*Now loop over pressure shape functions*/
               /*This is the contribution from pressure gradient*/
               for (unsigned l2 = 0; l2 < n_pres; l2++)
               {
                 /*If we are at a non-zero degree of freedom in the entry*/
                 local_unknown = p_local_eqn(l2);
                 if (local_unknown >= 0)
                 {
                   if (Pre_multiply_by_viscosity_ratio)
                   {
                     jacobian(local_eqn, local_unknown) +=
                       visc_ratio * viscosity * psip[l2] * dtestfdx(l, i) * W;
                   }
                   else
                   {
                     jacobian(local_eqn, local_unknown) +=
                       psip[l2] * dtestfdx(l, i) * W;
                   }
                 }
               }
             } /*End of Jacobian calculation*/
  
           } // End of if not boundary condition statement
  
         } // End of loop over dimension
       } // End of loop over shape functions
  
  
       // CONTINUITY EQUATION
       //-------------------
  
       // Loop over the shape functions
       for (unsigned l = 0; l < n_pres; l++)
       {
         local_eqn = p_local_eqn(l);
         // If not a boundary conditions
         if (local_eqn >= 0)
         {
           // Source term
           // residuals[local_eqn] -=source*testp[l]*W;
           double aux = -source;
  
           // Loop over velocity components
           for (unsigned k = 0; k < DIM; k++)
           {
             // residuals[local_eqn] += interpolated_dudx(k,k)*testp[l]*W;
             aux += interpolated_dudx(k, k);
           }
  
           // Potentially pre-multiply by viscosity ratio
           if (Pre_multiply_by_viscosity_ratio)
           {
             residuals[local_eqn] += visc_ratio * viscosity * aux * testp[l] * W;
           }
           else
           {
             residuals[local_eqn] += aux * testp[l] * W;
           }
  
           /*CALCULATE THE JACOBIAN*/
           if (flag)
           {
             /*Loop over the velocity shape functions*/
             for (unsigned l2 = 0; l2 < n_node; l2++)
             {
               /*Loop over velocity components*/
               for (unsigned i2 = 0; i2 < DIM; i2++)
               {
                 /*If we're at a non-zero degree of freedom add it in*/
                 local_unknown = nodal_local_eqn(l2, u_nodal_index[i2]);
                 if (local_unknown >= 0)
                 {
                   if (Pre_multiply_by_viscosity_ratio)
                   {
                     jacobian(local_eqn, local_unknown) +=
                       visc_ratio * viscosity * dpsifdx(l2, i2) * testp[l] * W;
                   }
                   else
                   {
                     jacobian(local_eqn, local_unknown) +=
                       dpsifdx(l2, i2) * testp[l] * W;
                   }
                 }
               } /*End of loop over i2*/
             } /*End of loop over l2*/
           } /*End of Jacobian calculation*/
  
         } // End of if not boundary condition
       } // End of loop over l
     }
   }

References oomph::ALE_is_disabled, Global_Parameters::body_force(), DIM, extrapolated_strain_rate(), G, GlobalPhysicalVariables::Gamma, i, J, j, k, m, n, s, oomph::SecondInvariantHelper::second_invariant(), TestProblem::source(), tmp, w, and oomph::QuadTreeNames::W.

Referenced by oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::fill_in_contribution_to_jacobian(), oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::fill_in_contribution_to_jacobian_and_mass_matrix(), and oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::fill_in_contribution_to_residuals().

◆ fix_pressure()

template<unsigned DIM>

virtual void oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::fix_pressure	(	const unsigned &	p_dof,
		const double &	p_value
	)

pure virtual

Pin p_dof-th pressure dof and set it to value specified by p_value.

Implemented in oomph::GeneralisedNewtonianTTaylorHoodElement< DIM >, oomph::GeneralisedNewtonianTCrouzeixRaviartElement< DIM >, oomph::PRefineableGeneralisedNewtonianQCrouzeixRaviartElement< DIM >, oomph::GeneralisedNewtonianQTaylorHoodElement< DIM >, and oomph::GeneralisedNewtonianQCrouzeixRaviartElement< DIM >.

◆ full_output() [1/2]

template<unsigned DIM>

void oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::full_output ( std::ostream & outfile )

inline

Full output function: x,y,[z],u,v,[w],p,du/dt,dv/dt,[dw/dt],dissipation in tecplot format. Default number of plot points

     {
       unsigned nplot = 5;
       full_output(outfile, nplot);
     }

Referenced by oomph::GeneralisedNewtonianQCrouzeixRaviartElement< DIM >::full_output(), and oomph::GeneralisedNewtonianTCrouzeixRaviartElement< DIM >::full_output().

◆ full_output() [2/2]

template<unsigned DIM>

void oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::full_output	(	std::ostream &	outfile,
		const unsigned &	nplot
	)

Full output function: x,y,[z],u,v,[w],p,du/dt,dv/dt,[dw/dt],dissipation in tecplot format. nplot points in each coordinate direction

Full output function: x,y,[z],u,v,[w],p,du/dt,dv/dt,[dw/dt],dissipation in tecplot format. Specified number of plot points in each coordinate direction

   {
     // Vector of local coordinates
     Vector<double> s(DIM);
  
     // Acceleration
     Vector<double> dudt(DIM);
  
     // Mesh elocity
     Vector<double> mesh_veloc(DIM, 0.0);
  
     // Tecplot header info
     outfile << tecplot_zone_string(nplot);
  
     // Find out how many nodes there are
     unsigned n_node = nnode();
  
     // Set up memory for the shape functions
     Shape psif(n_node);
     DShape dpsifdx(n_node, DIM);
  
     // Loop over plot points
     unsigned num_plot_points = nplot_points(nplot);
     for (unsigned iplot = 0; iplot < num_plot_points; iplot++)
     {
       // Get local coordinates of plot point
       get_s_plot(iplot, nplot, s);
  
       // Call the derivatives of the shape and test functions
       dshape_eulerian(s, psif, dpsifdx);
  
       // Allocate storage
       Vector<double> mesh_veloc(DIM);
       Vector<double> dudt(DIM);
       Vector<double> dudt_ALE(DIM);
       DenseMatrix<double> interpolated_dudx(DIM, DIM);
  
       // Initialise everything to zero
       for (unsigned i = 0; i < DIM; i++)
       {
         mesh_veloc[i] = 0.0;
         dudt[i] = 0.0;
         dudt_ALE[i] = 0.0;
         for (unsigned j = 0; j < DIM; j++)
         {
           interpolated_dudx(i, j) = 0.0;
         }
       }
  
       // Calculate velocities and derivatives
  
  
       // Loop over directions
       for (unsigned i = 0; i < DIM; i++)
       {
         // Get the index at which velocity i is stored
         unsigned u_nodal_index = u_index_nst(i);
         // Loop over nodes
         for (unsigned l = 0; l < n_node; l++)
         {
           dudt[i] += du_dt_nst(l, u_nodal_index) * psif[l];
           mesh_veloc[i] += dnodal_position_dt(l, i) * psif[l];
  
           // Loop over derivative directions for velocity gradients
           for (unsigned j = 0; j < DIM; j++)
           {
             interpolated_dudx(i, j) +=
               nodal_value(l, u_nodal_index) * dpsifdx(l, j);
           }
         }
       }
  
  
       // Get dudt in ALE form (incl mesh veloc)
       for (unsigned i = 0; i < DIM; i++)
       {
         dudt_ALE[i] = dudt[i];
         for (unsigned k = 0; k < DIM; k++)
         {
           dudt_ALE[i] -= mesh_veloc[k] * interpolated_dudx(i, k);
         }
       }
  
  
       // Coordinates
       for (unsigned i = 0; i < DIM; i++)
       {
         outfile << interpolated_x(s, i) << " ";
       }
  
       // Velocities
       for (unsigned i = 0; i < DIM; i++)
       {
         outfile << interpolated_u_nst(s, i) << " ";
       }
  
       // Pressure
       outfile << interpolated_p_nst(s) << " ";
  
       // Accelerations
       for (unsigned i = 0; i < DIM; i++)
       {
         outfile << dudt_ALE[i] << " ";
       }
  
       //    // Mesh velocity
       //    for(unsigned i=0;i<DIM;i++)
       //     {
       //      outfile << mesh_veloc[i] << " ";
       //     }
  
       // Dissipation
       outfile << dissipation(s) << " ";
  
  
       outfile << std::endl;
     }
  
     // Write tecplot footer (e.g. FE connectivity lists)
     write_tecplot_zone_footer(outfile, nplot);
   }

References DIM, i, j, k, and s.

◆ g()

template<unsigned DIM>

const Vector<double>& oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::g ( ) const

inline

Vector of gravitational components.

     {
       return *G_pt;
     }

References oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::G_pt.

◆ g_pt()

template<unsigned DIM>

Vector<double>*& oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::g_pt ( )

inline

Pointer to Vector of gravitational components.

     {
       return G_pt;
     }

References oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::G_pt.

◆ get_body_force_gradient_nst()

template<unsigned DIM>

virtual void oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::get_body_force_gradient_nst	(	const double &	time,
		const unsigned &	ipt,
		const Vector< double > &	s,
		const Vector< double > &	x,
		DenseMatrix< double > &	d_body_force_dx
	)

inlineprotectedvirtual

Get gradient of body force term at (Eulerian) position x. This function is virtual to allow overloading in multi-physics problems where the strength of the source function might be determined by another system of equations. Computed via function pointer (if set) or by finite differencing (default)

     {
       // hierher: Implement function pointer version
       /*    //If no gradient function has been set, FD it */
       /*    if(Body_force_fct_gradient_pt==0) */
       {
         // Reference value
         Vector<double> body_force(DIM, 0.0);
         get_body_force_nst(time, ipt, s, x, body_force);
  
         // FD it
         double eps_fd = GeneralisedElement::Default_fd_jacobian_step;
         Vector<double> body_force_pls(DIM, 0.0);
         Vector<double> x_pls(x);
         for (unsigned i = 0; i < DIM; i++)
         {
           x_pls[i] += eps_fd;
           get_body_force_nst(time, ipt, s, x_pls, body_force_pls);
           for (unsigned j = 0; j < DIM; j++)
           {
             d_body_force_dx(j, i) =
               (body_force_pls[j] - body_force[j]) / eps_fd;
           }
           x_pls[i] = x[i];
         }
       }
       /*    else */
       /*     { */
       /*      // Get gradient */
       /*      (*Source_fct_gradient_pt)(time,x,gradient); */
       /*     } */
     }

References Global_Parameters::body_force(), oomph::GeneralisedElement::Default_fd_jacobian_step, DIM, oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::get_body_force_nst(), i, j, s, and plotDoE::x.

◆ get_body_force_nst()

template<unsigned DIM>

virtual void oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::get_body_force_nst	(	const double &	time,
		const unsigned &	ipt,
		const Vector< double > &	s,
		const Vector< double > &	x,
		Vector< double > &	result
	)

inlineprotectedvirtual

Calculate the body force at a given time and local and/or Eulerian position. This function is virtual so that it can be overloaded in multi-physics elements where the body force might depend on another variable.

     {
       // If the function pointer is zero return zero
       if (Body_force_fct_pt == 0)
       {
         // Loop over dimensions and set body forces to zero
         for (unsigned i = 0; i < DIM; i++)
         {
           result[i] = 0.0;
         }
       }
       // Otherwise call the function
       else
       {
         (*Body_force_fct_pt)(time, x, result);
       }
     }

References oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::Body_force_fct_pt, DIM, i, and plotDoE::x.

Referenced by oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::get_body_force_gradient_nst().

◆ get_dresidual_dnodal_coordinates()

template<unsigned DIM>

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

virtual

Compute derivatives of elemental residual vector with respect to nodal coordinates. Overwrites default implementation in FiniteElement base class. dresidual_dnodal_coordinates(l,i,j) = d res(l) / dX_{ij}

Compute derivatives of elemental residual vector with respect to nodal coordinates. dresidual_dnodal_coordinates(l,i,j) = d res(l) / dX_{ij} Overloads the FD-based version in the FE base class.

Reimplemented from oomph::FiniteElement.

Reimplemented in oomph::RefineableGeneralisedNewtonianNavierStokesEquations< DIM >.

   {
     // Return immediately if there are no dofs
     if (ndof() == 0)
     {
       return;
     }
  
     // Determine number of nodes in element
     const unsigned n_node = nnode();
  
     // Get continuous time from timestepper of first node
     double time = node_pt(0)->time_stepper_pt()->time_pt()->time();
  
     // Determine number of pressure dofs in element
     const unsigned n_pres = npres_nst();
  
     // Find the indices at which the local velocities are stored
     unsigned u_nodal_index[DIM];
     for (unsigned i = 0; i < DIM; i++)
     {
       u_nodal_index[i] = u_index_nst(i);
     }
  
     // Set up memory for the shape and test functions
     Shape psif(n_node), testf(n_node);
     DShape dpsifdx(n_node, DIM), dtestfdx(n_node, DIM);
  
     // Set up memory for pressure shape and test functions
     Shape psip(n_pres), testp(n_pres);
  
     // Deriatives of shape fct derivatives w.r.t. nodal coords
     RankFourTensor<double> d_dpsifdx_dX(DIM, n_node, n_node, DIM);
     RankFourTensor<double> d_dtestfdx_dX(DIM, n_node, n_node, DIM);
  
     // Derivative of Jacobian of mapping w.r.t. to nodal coords
     DenseMatrix<double> dJ_dX(DIM, n_node);
  
     // Derivatives of derivative of u w.r.t. nodal coords
     RankFourTensor<double> d_dudx_dX(DIM, n_node, DIM, DIM);
  
     // Derivatives of nodal velocities w.r.t. nodal coords:
     // Assumption: Interaction only local via no-slip so
     // X_ij only affects U_ij.
     DenseMatrix<double> d_U_dX(DIM, n_node, 0.0);
  
     // Determine the number of integration points
     const unsigned n_intpt = integral_pt()->nweight();
  
     // Vector to hold local coordinates
     Vector<double> s(DIM);
  
     // Get physical variables from element
     // (Reynolds number must be multiplied by the density ratio)
     double scaled_re = re() * density_ratio();
     double scaled_re_st = re_st() * density_ratio();
     double scaled_re_inv_fr = re_invfr() * density_ratio();
     double visc_ratio = viscosity_ratio();
     Vector<double> G = g();
  
     // FD step
     double eps_fd = GeneralisedElement::Default_fd_jacobian_step;
  
     // Pre-compute derivatives of nodal velocities w.r.t. nodal coords:
     // Assumption: Interaction only local via no-slip so
     // X_ij only affects U_ij.
     bool element_has_node_with_aux_node_update_fct = false;
     for (unsigned q = 0; q < n_node; q++)
     {
       Node* nod_pt = node_pt(q);
  
       // Only compute if there's a node-update fct involved
       if (nod_pt->has_auxiliary_node_update_fct_pt())
       {
         element_has_node_with_aux_node_update_fct = true;
  
         // Current nodal velocity
         Vector<double> u_ref(DIM);
         for (unsigned i = 0; i < DIM; i++)
         {
           u_ref[i] = *(nod_pt->value_pt(u_nodal_index[i]));
         }
  
         // FD
         for (unsigned p = 0; p < DIM; p++)
         {
           // Make backup
           double backup = nod_pt->x(p);
  
           // Do FD step. No node update required as we're
           // attacking the coordinate directly...
           nod_pt->x(p) += eps_fd;
  
           // Do auxiliary node update (to apply no slip)
           nod_pt->perform_auxiliary_node_update_fct();
  
           // Evaluate
           d_U_dX(p, q) =
             (*(nod_pt->value_pt(u_nodal_index[p])) - u_ref[p]) / eps_fd;
  
           // Reset
           nod_pt->x(p) = backup;
  
           // Do auxiliary node update (to apply no slip)
           nod_pt->perform_auxiliary_node_update_fct();
         }
       }
     }
  
     // Integer to store the local equation number
     int local_eqn = 0;
  
     // Loop over the integration points
     for (unsigned ipt = 0; ipt < n_intpt; ipt++)
     {
       // Assign values of s
       for (unsigned i = 0; i < DIM; i++)
       {
         s[i] = integral_pt()->knot(ipt, i);
       }
  
       // Get the integral weight
       const double w = integral_pt()->weight(ipt);
  
       // Call the derivatives of the shape and test functions
       const double J = dshape_and_dtest_eulerian_at_knot_nst(ipt,
                                                              psif,
                                                              dpsifdx,
                                                              d_dpsifdx_dX,
                                                              testf,
                                                              dtestfdx,
                                                              d_dtestfdx_dX,
                                                              dJ_dX);
  
       // Call the pressure shape and test functions
       pshape_nst(s, psip, testp);
  
       // Calculate local values of the pressure and velocity components
       // Allocate
       double interpolated_p = 0.0;
       Vector<double> interpolated_u(DIM, 0.0);
       Vector<double> interpolated_x(DIM, 0.0);
       Vector<double> mesh_velocity(DIM, 0.0);
       Vector<double> dudt(DIM, 0.0);
       DenseMatrix<double> interpolated_dudx(DIM, DIM, 0.0);
  
       // Calculate pressure
       for (unsigned l = 0; l < n_pres; l++)
       {
         interpolated_p += p_nst(l) * psip[l];
       }
  
       // Calculate velocities and derivatives:
  
       // Loop over nodes
       for (unsigned l = 0; l < n_node; l++)
       {
         // Loop over directions
         for (unsigned i = 0; i < DIM; i++)
         {
           // Get the nodal value
           double u_value = raw_nodal_value(l, u_nodal_index[i]);
           interpolated_u[i] += u_value * psif[l];
           interpolated_x[i] += raw_nodal_position(l, i) * psif[l];
           dudt[i] += du_dt_nst(l, i) * psif[l];
  
           // Loop over derivative directions
           for (unsigned j = 0; j < DIM; j++)
           {
             interpolated_dudx(i, j) += u_value * dpsifdx(l, j);
           }
         }
       }
  
       if (!ALE_is_disabled)
       {
         // Loop over nodes
         for (unsigned l = 0; l < n_node; l++)
         {
           // Loop over directions
           for (unsigned i = 0; i < DIM; i++)
           {
             mesh_velocity[i] += this->raw_dnodal_position_dt(l, i) * psif[l];
           }
         }
       }
  
       // Calculate derivative of du_i/dx_k w.r.t. nodal positions X_{pq}
       for (unsigned q = 0; q < n_node; q++)
       {
         // Loop over coordinate directions
         for (unsigned p = 0; p < DIM; p++)
         {
           for (unsigned i = 0; i < DIM; i++)
           {
             for (unsigned k = 0; k < DIM; k++)
             {
               double aux = 0.0;
               for (unsigned j = 0; j < n_node; j++)
               {
                 aux += raw_nodal_value(j, u_nodal_index[i]) *
                        d_dpsifdx_dX(p, q, j, k);
               }
               d_dudx_dX(p, q, i, k) = aux;
             }
           }
         }
       }
  
       // Get weight of actual nodal position/value in computation of mesh
       // velocity from positional/value time stepper
       const double pos_time_weight =
         node_pt(0)->position_time_stepper_pt()->weight(1, 0);
       const double val_time_weight =
         node_pt(0)->time_stepper_pt()->weight(1, 0);
  
       // Get the user-defined body force terms
       Vector<double> body_force(DIM);
       get_body_force_nst(time, ipt, s, interpolated_x, body_force);
  
       // Get the user-defined source function
       const double source = get_source_nst(time, ipt, interpolated_x);
  
       // Note: Can use raw values and avoid bypassing hanging information
       // because this is the non-refineable version!
  
       // Get gradient of body force function
       DenseMatrix<double> d_body_force_dx(DIM, DIM, 0.0);
       get_body_force_gradient_nst(
         time, ipt, s, interpolated_x, d_body_force_dx);
  
       // Get gradient of source function
       Vector<double> source_gradient(DIM, 0.0);
       get_source_gradient_nst(time, ipt, interpolated_x, source_gradient);
  
  
       // Assemble shape derivatives
       // --------------------------
  
       // MOMENTUM EQUATIONS
       // ------------------
  
       // Loop over the test functions
       for (unsigned l = 0; l < n_node; l++)
       {
         // Loop over coordinate directions
         for (unsigned i = 0; i < DIM; i++)
         {
           // Get the local equation
           local_eqn = nodal_local_eqn(l, u_nodal_index[i]);
           ;
  
           // IF it's not a boundary condition
           if (local_eqn >= 0)
           {
             // Loop over coordinate directions
             for (unsigned p = 0; p < DIM; p++)
             {
               // Loop over nodes
               for (unsigned q = 0; q < n_node; q++)
               {
                 // Residual x deriv of Jacobian
                 //-----------------------------
  
                 // Add the user-defined body force terms
                 double sum = body_force[i] * testf[l];
  
                 // Add the gravitational body force term
                 sum += scaled_re_inv_fr * testf[l] * G[i];
  
                 // Add the pressure gradient term
                 sum += interpolated_p * dtestfdx(l, i);
  
                 // Add in the stress tensor terms
                 // The viscosity ratio needs to go in here to ensure
                 // continuity of normal stress is satisfied even in flows
                 // with zero pressure gradient!
                 for (unsigned k = 0; k < DIM; k++)
                 {
                   sum -= visc_ratio *
                          (interpolated_dudx(i, k) +
                           Gamma[i] * interpolated_dudx(k, i)) *
                          dtestfdx(l, k);
                 }
  
                 // Add in the inertial terms
  
                 // du/dt term
                 sum -= scaled_re_st * dudt[i] * testf[l];
  
                 // Convective terms, including mesh velocity
                 for (unsigned k = 0; k < DIM; k++)
                 {
                   double tmp = scaled_re * interpolated_u[k];
                   if (!ALE_is_disabled)
                   {
                     tmp -= scaled_re_st * mesh_velocity[k];
                   }
                   sum -= tmp * interpolated_dudx(i, k) * testf[l];
                 }
  
                 // Multiply through by deriv of Jacobian and integration weight
                 dresidual_dnodal_coordinates(local_eqn, p, q) +=
                   sum * dJ_dX(p, q) * w;
  
                 // Derivative of residual x Jacobian
                 //----------------------------------
  
                 // Body force
                 sum = d_body_force_dx(i, p) * psif(q) * testf(l);
  
                 // Pressure gradient term
                 sum += interpolated_p * d_dtestfdx_dX(p, q, l, i);
  
                 // Viscous term
                 for (unsigned k = 0; k < DIM; k++)
                 {
                   sum -= visc_ratio * ((interpolated_dudx(i, k) +
                                         Gamma[i] * interpolated_dudx(k, i)) *
                                          d_dtestfdx_dX(p, q, l, k) +
                                        (d_dudx_dX(p, q, i, k) +
                                         Gamma[i] * d_dudx_dX(p, q, k, i)) *
                                          dtestfdx(l, k));
                 }
  
                 // Convective terms, including mesh velocity
                 for (unsigned k = 0; k < DIM; k++)
                 {
                   double tmp = scaled_re * interpolated_u[k];
                   if (!ALE_is_disabled)
                   {
                     tmp -= scaled_re_st * mesh_velocity[k];
                   }
                   sum -= tmp * d_dudx_dX(p, q, i, k) * testf(l);
                 }
                 if (!ALE_is_disabled)
                 {
                   sum += scaled_re_st * pos_time_weight * psif(q) *
                          interpolated_dudx(i, p) * testf(l);
                 }
  
                 // Multiply through by Jacobian and integration weight
                 dresidual_dnodal_coordinates(local_eqn, p, q) += sum * J * w;
  
                 // Derivs w.r.t. to nodal velocities
                 // ---------------------------------
                 if (element_has_node_with_aux_node_update_fct)
                 {
                   sum =
                     -visc_ratio * Gamma[i] * dpsifdx(q, i) * dtestfdx(l, p) -
                     scaled_re * psif(q) * interpolated_dudx(i, p) * testf(l);
                   if (i == p)
                   {
                     sum -= scaled_re_st * val_time_weight * psif(q) * testf(l);
                     for (unsigned k = 0; k < DIM; k++)
                     {
                       sum -= visc_ratio * dpsifdx(q, k) * dtestfdx(l, k);
                       double tmp = scaled_re * interpolated_u[k];
                       if (!ALE_is_disabled)
                         tmp -= scaled_re_st * mesh_velocity[k];
                       sum -= tmp * dpsifdx(q, k) * testf(l);
                     }
                   }
                   dresidual_dnodal_coordinates(local_eqn, p, q) +=
                     sum * d_U_dX(p, q) * J * w;
                 }
               }
             }
           }
         }
       } // End of loop over test functions
  
  
       // CONTINUITY EQUATION
       // -------------------
  
       // Loop over the shape functions
       for (unsigned l = 0; l < n_pres; l++)
       {
         local_eqn = p_local_eqn(l);
  
         // If not a boundary conditions
         if (local_eqn >= 0)
         {
           // Loop over coordinate directions
           for (unsigned p = 0; p < DIM; p++)
           {
             // Loop over nodes
             for (unsigned q = 0; q < n_node; q++)
             {
               // Residual x deriv of Jacobian
               //-----------------------------
  
               // Source term
               double aux = -source;
  
               // Loop over velocity components
               for (unsigned k = 0; k < DIM; k++)
               {
                 aux += interpolated_dudx(k, k);
               }
  
               // Multiply through by deriv of Jacobian and integration weight
               dresidual_dnodal_coordinates(local_eqn, p, q) +=
                 aux * dJ_dX(p, q) * testp[l] * w;
  
               // Derivative of residual x Jacobian
               //----------------------------------
  
               // Loop over velocity components
               aux = -source_gradient[p] * psif(q);
               for (unsigned k = 0; k < DIM; k++)
               {
                 aux += d_dudx_dX(p, q, k, k);
               }
               // Multiply through by Jacobian and integration weight
               dresidual_dnodal_coordinates(local_eqn, p, q) +=
                 aux * testp[l] * J * w;
  
               // Derivs w.r.t. to nodal velocities
               //---------------------------------
               if (element_has_node_with_aux_node_update_fct)
               {
                 aux = dpsifdx(q, p) * testp(l);
                 dresidual_dnodal_coordinates(local_eqn, p, q) +=
                   aux * d_U_dX(p, q) * J * w;
               }
             }
           }
         }
       }
     } // End of loop over integration points
   }

References oomph::ALE_is_disabled, Global_Parameters::body_force(), oomph::GeneralisedElement::Default_fd_jacobian_step, DIM, G, GlobalPhysicalVariables::Gamma, oomph::Node::has_auxiliary_node_update_fct_pt(), i, J, j, k, p, oomph::Node::perform_auxiliary_node_update_fct(), Eigen::numext::q, s, TestProblem::source(), tmp, oomph::Data::value_pt(), w, and oomph::Node::x().

◆ get_load()

template<unsigned DIM>

void oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::get_load	(	const Vector< double > &	s,
		const Vector< double > &	N,
		Vector< double > &	load
	)

inlinevirtual

This implements a pure virtual function defined in the FSIFluidElement class. The function computes the traction (on the viscous scale), at the element's local coordinate s, that the fluid element exerts onto an adjacent solid element. The number of arguments is imposed by the interface defined in the FSIFluidElement – only the unit normal N (pointing into the fluid!) is actually used in the computation.

Implements oomph::FSIFluidElement.

     {
       // Note: get_traction() computes the traction onto the fluid
       // if N is the outer unit normal onto the fluid; here we're
       // exepcting N to point into the fluid so we're getting the
       // traction onto the adjacent wall instead!
       get_traction(s, N, load);
     }

References oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::get_traction(), load(), N, and s.

◆ get_pressure_and_velocity_mass_matrix_diagonal()

template<unsigned DIM>

void oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::get_pressure_and_velocity_mass_matrix_diagonal	(	Vector< double > &	press_mass_diag,
		Vector< double > &	veloc_mass_diag,
		const unsigned &	which_one = `0`
	)

virtual

Compute the diagonal of the velocity/pressure mass matrices. If which one=0, both are computed, otherwise only the pressure (which_one=1) or the velocity mass matrix (which_one=2 – the LSC version of the preconditioner only needs that one)

Implements oomph::GeneralisedNewtonianTemplateFreeNavierStokesEquationsBase.

Reimplemented in oomph::RefineableGeneralisedNewtonianNavierStokesEquations< DIM >.

   {
     // Resize and initialise
     unsigned n_dof = ndof();
  
     if ((which_one == 0) || (which_one == 1))
       press_mass_diag.assign(n_dof, 0.0);
     if ((which_one == 0) || (which_one == 2))
       veloc_mass_diag.assign(n_dof, 0.0);
  
     // find out how many nodes there are
     unsigned n_node = nnode();
  
     // find number of spatial dimensions
     unsigned n_dim = this->dim();
  
     // Local coordinates
     Vector<double> s(n_dim);
  
     // find the indices at which the local velocities are stored
     Vector<unsigned> u_nodal_index(n_dim);
     for (unsigned i = 0; i < n_dim; i++)
     {
       u_nodal_index[i] = this->u_index_nst(i);
     }
  
     // Set up memory for veloc shape functions
     Shape psi(n_node);
  
     // Find number of pressure dofs
     unsigned n_pres = npres_nst();
  
     // Pressure shape function
     Shape psi_p(n_pres);
  
     // Number of integration points
     unsigned n_intpt = integral_pt()->nweight();
  
     // Integer to store the local equations no
     int local_eqn = 0;
  
     // Loop over the integration points
     for (unsigned ipt = 0; ipt < n_intpt; ipt++)
     {
       // Get the integral weight
       double w = integral_pt()->weight(ipt);
  
       // Get determinant of Jacobian of the mapping
       double J = J_eulerian_at_knot(ipt);
  
       // Assign values of s
       for (unsigned i = 0; i < n_dim; i++)
       {
         s[i] = integral_pt()->knot(ipt, i);
       }
  
       // Premultiply weights and Jacobian
       double W = w * J;
  
  
       // Do we want the velocity one?
       if ((which_one == 0) || (which_one == 2))
       {
         // Get the velocity shape functions
         shape_at_knot(ipt, psi);
  
         // Loop over the veclocity shape functions
         for (unsigned l = 0; l < n_node; l++)
         {
           // Loop over the velocity components
           for (unsigned i = 0; i < n_dim; i++)
           {
             local_eqn = nodal_local_eqn(l, u_nodal_index[i]);
  
             // If not a boundary condition
             if (local_eqn >= 0)
             {
               // Add the contribution
               veloc_mass_diag[local_eqn] += pow(psi[l], 2) * W;
             }
           }
         }
       }
  
       // Do we want the pressure one?
       if ((which_one == 0) || (which_one == 1))
       {
         // Get the pressure shape functions
         pshape_nst(s, psi_p);
  
         // Loop over the veclocity shape functions
         for (unsigned l = 0; l < n_pres; l++)
         {
           // Get equation number
           local_eqn = p_local_eqn(l);
  
           // If not a boundary condition
           if (local_eqn >= 0)
           {
             // Add the contribution
             press_mass_diag[local_eqn] += pow(psi_p[l], 2) * W;
           }
         }
       }
     }
   }

References i, J, Eigen::bfloat16_impl::pow(), s, w, and oomph::QuadTreeNames::W.

◆ get_source_gradient_nst()

template<unsigned DIM>

virtual void oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::get_source_gradient_nst	(	const double &	time,
		const unsigned &	ipt,
		const Vector< double > &	x,
		Vector< double > &	gradient
	)

inlineprotectedvirtual

Get gradient of source term at (Eulerian) position x. This function is virtual to allow overloading in multi-physics problems where the strength of the source function might be determined by another system of equations. Computed via function pointer (if set) or by finite differencing (default)

     {
       // hierher: Implement function pointer version
       /*    //If no gradient function has been set, FD it */
       /*    if(Source_fct_gradient_pt==0) */
       {
         // Reference value
         double source = get_source_nst(time, ipt, x);
  
         // FD it
         double eps_fd = GeneralisedElement::Default_fd_jacobian_step;
         double source_pls = 0.0;
         Vector<double> x_pls(x);
         for (unsigned i = 0; i < DIM; i++)
         {
           x_pls[i] += eps_fd;
           source_pls = get_source_nst(time, ipt, x_pls);
           gradient[i] = (source_pls - source) / eps_fd;
           x_pls[i] = x[i];
         }
       }
       /*    else */
       /*     { */
       /*      // Get gradient */
       /*      (*Source_fct_gradient_pt)(time,x,gradient); */
       /*     } */
     }

References oomph::GeneralisedElement::Default_fd_jacobian_step, DIM, oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::get_source_nst(), i, TestProblem::source(), and plotDoE::x.

◆ get_source_nst()

template<unsigned DIM>

virtual double oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::get_source_nst	(	const double &	time,
		const unsigned &	ipt,
		const Vector< double > &	x
	)

inlineprotectedvirtual

Calculate the source fct at given time and Eulerian position

     {
       // If the function pointer is zero return zero
       if (Source_fct_pt == 0)
       {
         return 0;
       }
       // Otherwise call the function
       else
       {
         return (*Source_fct_pt)(time, x);
       }
     }

References oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::Source_fct_pt, and plotDoE::x.

Referenced by oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::get_source_gradient_nst().

◆ get_traction() [1/2]

template<unsigned DIM>

void oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::get_traction	(	const Vector< double > &	s,
		const Vector< double > &	N,
		Vector< double > &	traction
	)

Compute traction (on the viscous scale) exerted onto the fluid at local coordinate s. N has to be outer unit normal to the fluid.

   {
     // Get velocity gradients
     DenseMatrix<double> strainrate(DIM, DIM, 0.0);
  
     // Do we use the current or extrapolated strainrate to compute
     // the second invariant?
     if (!Use_extrapolated_strainrate_to_compute_second_invariant)
     {
       strain_rate(s, strainrate);
     }
     else
     {
       extrapolated_strain_rate(s, strainrate);
     }
  
     // Get the second invariant of the rate of strain tensor
     double second_invariant =
       SecondInvariantHelper::second_invariant(strainrate);
  
     double visc = Constitutive_eqn_pt->viscosity(second_invariant);
  
     // Get pressure
     double press = interpolated_p_nst(s);
  
     // Loop over traction components
     for (unsigned i = 0; i < DIM; i++)
     {
       traction[i] = -press * N[i];
       for (unsigned j = 0; j < DIM; j++)
       {
         traction[i] += visc * 2.0 * strainrate(i, j) * N[j];
       }
     }
   }

References DIM, extrapolated_strain_rate(), i, j, N, s, and oomph::SecondInvariantHelper::second_invariant().

Referenced by oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::get_load().

◆ get_traction() [2/2]

template<unsigned DIM>

void oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::get_traction	(	const Vector< double > &	s,
		const Vector< double > &	N,
		Vector< double > &	traction_p,
		Vector< double > &	traction_visc_n,
		Vector< double > &	traction_visc_t
	)

Compute traction (on the viscous scale) exerted onto the fluid at local coordinate s, decomposed into pressure and normal and tangential viscous components. N has to be outer unit normal to the fluid.

   {
     Vector<double> traction_visc(DIM);
  
     // Get velocity gradients
     DenseMatrix<double> strainrate(DIM, DIM, 0.0);
  
     // Do we use the current or extrapolated strainrate to compute
     // the second invariant?
     if (!Use_extrapolated_strainrate_to_compute_second_invariant)
     {
       strain_rate(s, strainrate);
     }
     else
     {
       extrapolated_strain_rate(s, strainrate);
     }
  
     // Get the second invariant of the rate of strain tensor
     double second_invariant =
       SecondInvariantHelper::second_invariant(strainrate);
  
     double visc = Constitutive_eqn_pt->viscosity(second_invariant);
  
     // Get pressure
     double press = interpolated_p_nst(s);
  
     // Loop over traction components
     for (unsigned i = 0; i < DIM; i++)
     {
       // pressure
       traction_p[i] = -press * N[i];
       for (unsigned j = 0; j < DIM; j++)
       {
         // viscous stress
         traction_visc[i] += visc * 2.0 * strainrate(i, j) * N[j];
       }
       // Decompose viscous stress into normal and tangential components
       traction_visc_n[i] = traction_visc[i] * N[i];
       traction_visc_t[i] = traction_visc[i] - traction_visc_n[i];
     }
   }

References DIM, extrapolated_strain_rate(), i, j, N, s, and oomph::SecondInvariantHelper::second_invariant().

◆ get_vorticity() [1/3]

void oomph::GeneralisedNewtonianNavierStokesEquations< 2 >::get_vorticity	(	const Vector< double > &	s,
		Vector< double > &	vorticity
	)		const

Compute 2D vorticity vector at local coordinate s (return in one and only component of vorticity vector

   {
 #ifdef PARANOID
     if (vorticity.size() != 1)
     {
       std::ostringstream error_message;
       error_message << "Computation of vorticity in 2D requires a 1D vector\n"
                     << "which contains the only non-zero component of the\n"
                     << "vorticity vector. You've passed a vector of size "
                     << vorticity.size() << std::endl;
  
       throw OomphLibError(
         error_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
 #endif
  
     // Specify spatial dimension
     unsigned DIM = 2;
  
     // Velocity gradient matrix
     DenseMatrix<double> dudx(DIM);
  
     // Find out how many nodes there are in the element
     unsigned n_node = nnode();
  
     // Set up memory for the shape and test functions
     Shape psi(n_node);
     DShape dpsidx(n_node, DIM);
  
     // Call the derivatives of the shape functions
     dshape_eulerian(s, psi, dpsidx);
  
     // Initialise to zero
     for (unsigned i = 0; i < DIM; i++)
     {
       for (unsigned j = 0; j < DIM; j++)
       {
         dudx(i, j) = 0.0;
       }
     }
  
     // Loop over veclocity components
     for (unsigned i = 0; i < DIM; i++)
     {
       // Get the index at which the i-th velocity is stored
       unsigned u_nodal_index = u_index_nst(i);
       // Loop over derivative directions
       for (unsigned j = 0; j < DIM; j++)
       {
         // Loop over nodes
         for (unsigned l = 0; l < n_node; l++)
         {
           dudx(i, j) += nodal_value(l, u_nodal_index) * dpsidx(l, j);
         }
       }
     }
  
     // Z-component of vorticity
     vorticity[0] = dudx(1, 0) - dudx(0, 1);
   }

References DIM, i, j, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and s.

◆ get_vorticity() [2/3]

void oomph::GeneralisedNewtonianNavierStokesEquations< 3 >::get_vorticity	(	const Vector< double > &	s,
		Vector< double > &	vorticity
	)		const

Compute 3D vorticity vector at local coordinate s.

   {
 #ifdef PARANOID
     if (vorticity.size() != 3)
     {
       std::ostringstream error_message;
       error_message << "Computation of vorticity in 3D requires a 3D vector\n"
                     << "which contains the only non-zero component of the\n"
                     << "vorticity vector. You've passed a vector of size "
                     << vorticity.size() << std::endl;
  
       throw OomphLibError(
         error_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
 #endif
  
     // Specify spatial dimension
     unsigned DIM = 3;
  
     // Velocity gradient matrix
     DenseMatrix<double> dudx(DIM);
  
     // Find out how many nodes there are in the element
     unsigned n_node = nnode();
  
     // Set up memory for the shape and test functions
     Shape psi(n_node);
     DShape dpsidx(n_node, DIM);
  
     // Call the derivatives of the shape functions
     dshape_eulerian(s, psi, dpsidx);
  
     // Initialise to zero
     for (unsigned i = 0; i < DIM; i++)
     {
       for (unsigned j = 0; j < DIM; j++)
       {
         dudx(i, j) = 0.0;
       }
     }
  
     // Loop over veclocity components
     for (unsigned i = 0; i < DIM; i++)
     {
       // Get the index at which the i-th velocity component is stored
       unsigned u_nodal_index = u_index_nst(i);
       // Loop over derivative directions
       for (unsigned j = 0; j < DIM; j++)
       {
         // Loop over nodes
         for (unsigned l = 0; l < n_node; l++)
         {
           dudx(i, j) += nodal_value(l, u_nodal_index) * dpsidx(l, j);
         }
       }
     }
  
     vorticity[0] = dudx(2, 1) - dudx(1, 2);
     vorticity[1] = dudx(0, 2) - dudx(2, 0);
     vorticity[2] = dudx(1, 0) - dudx(0, 1);
   }

References DIM, i, j, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and s.

◆ get_vorticity() [3/3]

template<unsigned DIM>

void oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::get_vorticity	(	const Vector< double > &	s,
		Vector< double > &	vorticity
	)		const

Compute the vorticity vector at local coordinate s.

◆ interpolated_p_nst() [1/2]

template<unsigned DIM>

double oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::interpolated_p_nst	(	const unsigned &	t,
		const Vector< double > &	s
	)		const

inline

Return FE interpolated pressure at local coordinate s at time level t.

     {
       // Find number of nodes
       unsigned n_pres = npres_nst();
       // Local shape function
       Shape psi(n_pres);
       // Find values of shape function
       pshape_nst(s, psi);
  
       // Initialise value of p
       double interpolated_p = 0.0;
       // Loop over the local nodes and sum
       for (unsigned l = 0; l < n_pres; l++)
       {
         interpolated_p += p_nst(t, l) * psi[l];
       }
  
       return (interpolated_p);
     }

References oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::npres_nst(), oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::p_nst(), oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::pshape_nst(), s, and plotPSD::t.

◆ interpolated_p_nst() [2/2]

template<unsigned DIM>

virtual double oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::interpolated_p_nst ( const Vector< double > & s ) const

inlinevirtual

Return FE interpolated pressure at local coordinate s.

     {
       // Find number of nodes
       unsigned n_pres = npres_nst();
       // Local shape function
       Shape psi(n_pres);
       // Find values of shape function
       pshape_nst(s, psi);
  
       // Initialise value of p
       double interpolated_p = 0.0;
       // Loop over the local nodes and sum
       for (unsigned l = 0; l < n_pres; l++)
       {
         interpolated_p += p_nst(l) * psi[l];
       }
  
       return (interpolated_p);
     }

References oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::npres_nst(), oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::p_nst(), oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::pshape_nst(), and s.

Referenced by oomph::PRefineableGeneralisedNewtonianQCrouzeixRaviartElement< DIM >::further_build(), oomph::RefineableGeneralisedNewtonianQCrouzeixRaviartElement< DIM >::further_build(), oomph::RefineableGeneralisedNewtonianQTaylorHoodElement< DIM >::get_interpolated_values(), oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::point_output_data(), and oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::scalar_value_paraview().

◆ interpolated_u_nst() [1/3]

template<unsigned DIM>

double oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::interpolated_u_nst	(	const unsigned &	t,
		const Vector< double > &	s,
		const unsigned &	i
	)		const

inline

Return FE interpolated velocity u[i] at local coordinate s at time level t (t=0: present; t>0: history)

     {
       // Find number of nodes
       unsigned n_node = nnode();
  
       // Local shape function
       Shape psi(n_node);
  
       // Find values of shape function
       shape(s, psi);
  
       // Get nodal index at which i-th velocity is stored
       unsigned u_nodal_index = u_index_nst(i);
  
       // Initialise value of u
       double interpolated_u = 0.0;
       // Loop over the local nodes and sum
       for (unsigned l = 0; l < n_node; l++)
       {
         interpolated_u += nodal_value(t, l, u_nodal_index) * psi[l];
       }
  
       return (interpolated_u);
     }

References i, oomph::FiniteElement::nnode(), oomph::FiniteElement::nodal_value(), s, oomph::FiniteElement::shape(), plotPSD::t, and oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::u_index_nst().

◆ interpolated_u_nst() [2/3]

template<unsigned DIM>

double oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::interpolated_u_nst	(	const Vector< double > &	s,
		const unsigned &	i
	)		const

inline

Return FE interpolated velocity u[i] at local coordinate s.

     {
       // Find number of nodes
       unsigned n_node = nnode();
       // Local shape function
       Shape psi(n_node);
       // Find values of shape function
       shape(s, psi);
  
       // Get nodal index at which i-th velocity is stored
       unsigned u_nodal_index = u_index_nst(i);
  
       // Initialise value of u
       double interpolated_u = 0.0;
       // Loop over the local nodes and sum
       for (unsigned l = 0; l < n_node; l++)
       {
         interpolated_u += nodal_value(l, u_nodal_index) * psi[l];
       }
  
       return (interpolated_u);
     }

References i, oomph::FiniteElement::nnode(), oomph::FiniteElement::nodal_value(), s, oomph::FiniteElement::shape(), and oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::u_index_nst().

◆ interpolated_u_nst() [3/3]

template<unsigned DIM>

void oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::interpolated_u_nst	(	const Vector< double > &	s,
		Vector< double > &	veloc
	)		const

inline

Compute vector of FE interpolated velocity u at local coordinate s.

     {
       // Find number of nodes
       unsigned n_node = nnode();
       // Local shape function
       Shape psi(n_node);
       // Find values of shape function
       shape(s, psi);
  
       for (unsigned i = 0; i < DIM; i++)
       {
         // Index at which the nodal value is stored
         unsigned u_nodal_index = u_index_nst(i);
         // Initialise value of u
         veloc[i] = 0.0;
         // Loop over the local nodes and sum
         for (unsigned l = 0; l < n_node; l++)
         {
           veloc[i] += nodal_value(l, u_nodal_index) * psi[l];
         }
       }
     }

References DIM, i, oomph::FiniteElement::nnode(), oomph::FiniteElement::nodal_value(), s, oomph::FiniteElement::shape(), and oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::u_index_nst().

Referenced by oomph::RefineableGeneralisedNewtonianQTaylorHoodElement< DIM >::get_interpolated_values(), oomph::RefineableGeneralisedNewtonianQCrouzeixRaviartElement< DIM >::get_interpolated_values(), oomph::PRefineableGeneralisedNewtonianQCrouzeixRaviartElement< DIM >::get_interpolated_values(), oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::point_output_data(), and oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::scalar_value_paraview().

◆ kin_energy()

template<unsigned DIM>

double oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::kin_energy

Get integral of kinetic energy over element.

Get integral of kinetic energy over element: Note that this is the "raw" kinetic energy in the sense that the density ratio has not been included. In problems with two or more fluids the user will have to remember to premultiply certain elements by the appropriate density ratio.

   {
     throw OomphLibError(
       "Check the kinetic energy calculation for GeneralisedNewtonian NSt",
       OOMPH_CURRENT_FUNCTION,
       OOMPH_EXCEPTION_LOCATION);
  
     // Initialise
     double kin_en = 0.0;
  
     // Set the value of n_intpt
     unsigned n_intpt = integral_pt()->nweight();
  
     // Set the Vector to hold local coordinates
     Vector<double> s(DIM);
  
     // Loop over the integration points
     for (unsigned ipt = 0; ipt < n_intpt; ipt++)
     {
       // Assign values of s
       for (unsigned i = 0; i < DIM; i++)
       {
         s[i] = integral_pt()->knot(ipt, i);
       }
  
       // Get the integral weight
       double w = integral_pt()->weight(ipt);
  
       // Get Jacobian of mapping
       double J = J_eulerian(s);
  
       // Loop over directions
       double veloc_squared = 0.0;
       for (unsigned i = 0; i < DIM; i++)
       {
         veloc_squared += interpolated_u_nst(s, i) * interpolated_u_nst(s, i);
       }
  
       kin_en += 0.5 * veloc_squared * w * J;
     }
  
     return kin_en;
   }

References DIM, i, J, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, s, and w.

◆ max_and_min_invariant_and_viscosity()

template<unsigned DIM>

void oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::max_and_min_invariant_and_viscosity	(	double &	min_invariant,
		double &	max_invariant,
		double &	min_viscosity,
		double &	max_viscosity
	)		const

Get max. and min. strain rate invariant and visocosity over all integration points in element

   {
     // Initialise
     min_invariant = DBL_MAX;
     max_invariant = -DBL_MAX;
     min_viscosity = DBL_MAX;
     max_viscosity = -DBL_MAX;
  
     // Number of integration points
     unsigned Nintpt = integral_pt()->nweight();
  
     // Set the Vector to hold local coordinates
     Vector<double> s(DIM);
  
     // Loop over the integration points
     for (unsigned ipt = 0; ipt < Nintpt; ipt++)
     {
       // Assign values of s
       for (unsigned i = 0; i < DIM; i++) s[i] = integral_pt()->knot(ipt, i);
  
       // The strainrate
       DenseMatrix<double> strainrate(DIM, DIM, 0.0);
       strain_rate(s, strainrate);
  
       // Calculate the second invariant
       double second_invariant =
         SecondInvariantHelper::second_invariant(strainrate);
  
       // Get the viscosity according to the constitutive equation
       double viscosity = Constitutive_eqn_pt->viscosity(second_invariant);
  
       min_invariant = std::min(min_invariant, second_invariant);
       max_invariant = std::max(max_invariant, second_invariant);
       min_viscosity = std::min(min_viscosity, viscosity);
       max_viscosity = std::max(max_viscosity, viscosity);
     }
   }

References DIM, i, max, min, GlobalParameters::Nintpt, s, and oomph::SecondInvariantHelper::second_invariant().

◆ n_u_nst()

template<unsigned DIM>

unsigned oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::n_u_nst ( ) const

inline

Return the number of velocity components Used in FluidInterfaceElements

     {
       return DIM;
     }

References DIM.

◆ npres_nst()

template<unsigned DIM>

virtual unsigned oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::npres_nst ( ) const

pure virtual

Function to return number of pressure degrees of freedom.

Implemented in oomph::GeneralisedNewtonianTTaylorHoodElement< DIM >, oomph::GeneralisedNewtonianTTaylorHoodElement< DIM >, oomph::GeneralisedNewtonianTTaylorHoodElement< DIM >, oomph::GeneralisedNewtonianTCrouzeixRaviartElement< DIM >, oomph::PRefineableGeneralisedNewtonianQCrouzeixRaviartElement< DIM >, oomph::GeneralisedNewtonianQTaylorHoodElement< DIM >, and oomph::GeneralisedNewtonianQCrouzeixRaviartElement< DIM >.

Referenced by oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::interpolated_p_nst().

◆ nscalar_paraview()

template<unsigned DIM>

unsigned oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::nscalar_paraview ( ) const

inlinevirtual

Number of scalars/fields output by this element. Reimplements broken virtual function in base class.

Reimplemented from oomph::FiniteElement.

     {
       return DIM + 1;
     }

References DIM.

◆ output() [1/4]

template<unsigned DIM>

void oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::output ( FILE * file_pt )

inlinevirtual

C-style output function: x,y,[z],u,v,[w],p in tecplot format. Default number of plot points

Reimplemented from oomph::FiniteElement.

Reimplemented in oomph::PseudoSolidNodeUpdateElement< GeneralisedNewtonianTTaylorHoodElement< 2 >, TPVDElement< 2, 3 > >, oomph::GeneralisedNewtonianTTaylorHoodElement< DIM >, oomph::GeneralisedNewtonianTCrouzeixRaviartElement< DIM >, oomph::GeneralisedNewtonianQTaylorHoodElement< DIM >, and oomph::GeneralisedNewtonianQCrouzeixRaviartElement< DIM >.

     {
       unsigned nplot = 5;
       output(file_pt, nplot);
     }

References oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::output().

◆ output() [2/4]

template<unsigned DIM>

void oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::output	(	FILE *	file_pt,
		const unsigned &	nplot
	)

virtual

C-style output function: x,y,[z],u,v,[w],p in tecplot format. nplot points in each coordinate direction

C-style output function: x,y,[z],u,v,[w],p in tecplot format. Specified number of plot points in each coordinate direction.

Reimplemented from oomph::FiniteElement.

Reimplemented in oomph::GeneralisedNewtonianQTaylorHoodElement< DIM >, oomph::GeneralisedNewtonianQCrouzeixRaviartElement< DIM >, oomph::GeneralisedNewtonianTTaylorHoodElement< DIM >, oomph::GeneralisedNewtonianTCrouzeixRaviartElement< DIM >, and oomph::PseudoSolidNodeUpdateElement< GeneralisedNewtonianTTaylorHoodElement< 2 >, TPVDElement< 2, 3 > >.

   {
     // Vector of local coordinates
     Vector<double> s(DIM);
  
     // Tecplot header info
     fprintf(file_pt, "%s", tecplot_zone_string(nplot).c_str());
  
     // Loop over plot points
     unsigned num_plot_points = nplot_points(nplot);
     for (unsigned iplot = 0; iplot < num_plot_points; iplot++)
     {
       // Get local coordinates of plot point
       get_s_plot(iplot, nplot, s);
  
       // Coordinates
       for (unsigned i = 0; i < DIM; i++)
       {
         fprintf(file_pt, "%g ", interpolated_x(s, i));
       }
  
       // Velocities
       for (unsigned i = 0; i < DIM; i++)
       {
         fprintf(file_pt, "%g ", interpolated_u_nst(s, i));
       }
  
       // Pressure
       fprintf(file_pt, "%g \n", interpolated_p_nst(s));
     }
     fprintf(file_pt, "\n");
  
     // Write tecplot footer (e.g. FE connectivity lists)
     write_tecplot_zone_footer(file_pt, nplot);
   }

References DIM, i, and s.

◆ output() [3/4]

template<unsigned DIM>

void oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::output ( std::ostream & outfile )

inlinevirtual

Output function: x,y,[z],u,v,[w],p in tecplot format. Default number of plot points

Reimplemented from oomph::FiniteElement.

Reimplemented in oomph::PseudoSolidNodeUpdateElement< GeneralisedNewtonianTTaylorHoodElement< 2 >, TPVDElement< 2, 3 > >, oomph::GeneralisedNewtonianTTaylorHoodElement< DIM >, oomph::GeneralisedNewtonianTCrouzeixRaviartElement< DIM >, oomph::GeneralisedNewtonianQTaylorHoodElement< DIM >, and oomph::GeneralisedNewtonianQCrouzeixRaviartElement< DIM >.

     {
       unsigned nplot = 5;
       output(outfile, nplot);
     }

Referenced by oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::output(), oomph::GeneralisedNewtonianQCrouzeixRaviartElement< DIM >::output(), oomph::GeneralisedNewtonianQTaylorHoodElement< DIM >::output(), oomph::GeneralisedNewtonianTCrouzeixRaviartElement< DIM >::output(), and oomph::GeneralisedNewtonianTTaylorHoodElement< DIM >::output().

◆ output() [4/4]

template<unsigned DIM>

void oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::output	(	std::ostream &	outfile,
		const unsigned &	nplot
	)

virtual

Output function: x,y,[z],u,v,[w],p in tecplot format. nplot points in each coordinate direction

Output function: x,y,[z],u,v,[w],p in tecplot format. Specified number of plot points in each coordinate direction.

Reimplemented from oomph::FiniteElement.

Reimplemented in oomph::GeneralisedNewtonianTTaylorHoodElement< DIM >, oomph::GeneralisedNewtonianTCrouzeixRaviartElement< DIM >, oomph::GeneralisedNewtonianQTaylorHoodElement< DIM >, oomph::GeneralisedNewtonianQCrouzeixRaviartElement< DIM >, and oomph::PseudoSolidNodeUpdateElement< GeneralisedNewtonianTTaylorHoodElement< 2 >, TPVDElement< 2, 3 > >.

   {
     // Vector of local coordinates
     Vector<double> s(DIM);
  
     // Tecplot header info
     outfile << tecplot_zone_string(nplot);
  
     // Loop over plot points
     unsigned num_plot_points = nplot_points(nplot);
     for (unsigned iplot = 0; iplot < num_plot_points; iplot++)
     {
       // Get local coordinates of plot point
       get_s_plot(iplot, nplot, s);
  
       // Coordinates
       for (unsigned i = 0; i < DIM; i++)
       {
         outfile << interpolated_x(s, i) << " ";
       }
  
       // Velocities
       for (unsigned i = 0; i < DIM; i++)
       {
         outfile << interpolated_u_nst(s, i) << " ";
       }
  
       // Pressure
       outfile << interpolated_p_nst(s) << " ";
  
       outfile << std::endl;
     }
     outfile << std::endl;
  
     // Write tecplot footer (e.g. FE connectivity lists)
     write_tecplot_zone_footer(outfile, nplot);
   }

References DIM, i, and s.

◆ output_fct() [1/2]

template<unsigned DIM>

void oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::output_fct	(	std::ostream &	outfile,
		const unsigned &	nplot,
		const double &	time,
		FiniteElement::UnsteadyExactSolutionFctPt	exact_soln_pt
	)

virtual

Output exact solution specified via function pointer at a given time and at a given number of plot points. Function prints as many components as are returned in solution Vector.

Output "exact" solution at a given time Solution is provided via function pointer. Plot at a given number of plot points. Function prints as many components as are returned in solution Vector.

Reimplemented from oomph::FiniteElement.

   {
     // Vector of local coordinates
     Vector<double> s(DIM);
  
     // Vector for coordintes
     Vector<double> x(DIM);
  
     // Tecplot header info
     outfile << tecplot_zone_string(nplot);
  
     // Exact solution Vector
     Vector<double> exact_soln;
  
     // Loop over plot points
     unsigned num_plot_points = nplot_points(nplot);
     for (unsigned iplot = 0; iplot < num_plot_points; iplot++)
     {
       // Get local coordinates of plot point
       get_s_plot(iplot, nplot, s);
  
       // Get x position as Vector
       interpolated_x(s, x);
  
       // Get exact solution at this point
       (*exact_soln_pt)(time, x, exact_soln);
  
       // Output x,y,...
       for (unsigned i = 0; i < DIM; i++)
       {
         outfile << x[i] << " ";
       }
  
       // Output "exact solution"
       for (unsigned i = 0; i < exact_soln.size(); i++)
       {
         outfile << exact_soln[i] << " ";
       }
  
       outfile << std::endl;
     }
  
     // Write tecplot footer (e.g. FE connectivity lists)
     write_tecplot_zone_footer(outfile, nplot);
   }

References DIM, ProblemParameters::exact_soln(), i, s, and plotDoE::x.

◆ output_fct() [2/2]

template<unsigned DIM>

void oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::output_fct	(	std::ostream &	outfile,
		const unsigned &	nplot,
		FiniteElement::SteadyExactSolutionFctPt	exact_soln_pt
	)

virtual

Output exact solution specified via function pointer at a given number of plot points. Function prints as many components as are returned in solution Vector

Output "exact" solution Solution is provided via function pointer. Plot at a given number of plot points. Function prints as many components as are returned in solution Vector.

Reimplemented from oomph::FiniteElement.

   {
     // Vector of local coordinates
     Vector<double> s(DIM);
  
     // Vector for coordintes
     Vector<double> x(DIM);
  
     // Tecplot header info
     outfile << tecplot_zone_string(nplot);
  
     // Exact solution Vector
     Vector<double> exact_soln;
  
     // Loop over plot points
     unsigned num_plot_points = nplot_points(nplot);
     for (unsigned iplot = 0; iplot < num_plot_points; iplot++)
     {
       // Get local coordinates of plot point
       get_s_plot(iplot, nplot, s);
  
       // Get x position as Vector
       interpolated_x(s, x);
  
       // Get exact solution at this point
       (*exact_soln_pt)(x, exact_soln);
  
       // Output x,y,...
       for (unsigned i = 0; i < DIM; i++)
       {
         outfile << x[i] << " ";
       }
  
       // Output "exact solution"
       for (unsigned i = 0; i < exact_soln.size(); i++)
       {
         outfile << exact_soln[i] << " ";
       }
  
       outfile << std::endl;
     }
  
     // Write tecplot footer (e.g. FE connectivity lists)
     write_tecplot_zone_footer(outfile, nplot);
   }

References DIM, ProblemParameters::exact_soln(), i, s, and plotDoE::x.

◆ output_veloc()

template<unsigned DIM>

void oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::output_veloc	(	std::ostream &	outfile,
		const unsigned &	nplot,
		const unsigned &	t
	)

Output function: x,y,[z],u,v,[w] in tecplot format. nplot points in each coordinate direction at timestep t (t=0: present; t>0: previous timestep)

Output function: Velocities only x,y,[z],u,v,[w] in tecplot format at specified previous timestep (t=0: present; t>0: previous timestep). Specified number of plot points in each coordinate direction.

   {
     // Find number of nodes
     unsigned n_node = nnode();
  
     // Local shape function
     Shape psi(n_node);
  
     // Vectors of local coordinates and coords and velocities
     Vector<double> s(DIM);
     Vector<double> interpolated_x(DIM);
     Vector<double> interpolated_u(DIM);
  
     // Tecplot header info
     outfile << tecplot_zone_string(nplot);
  
     // Loop over plot points
     unsigned num_plot_points = nplot_points(nplot);
     for (unsigned iplot = 0; iplot < num_plot_points; iplot++)
     {
       // Get local coordinates of plot point
       get_s_plot(iplot, nplot, s);
  
       // Get shape functions
       shape(s, psi);
  
       // Loop over directions
       for (unsigned i = 0; i < DIM; i++)
       {
         interpolated_x[i] = 0.0;
         interpolated_u[i] = 0.0;
         // Get the index at which velocity i is stored
         unsigned u_nodal_index = u_index_nst(i);
         // Loop over the local nodes and sum
         for (unsigned l = 0; l < n_node; l++)
         {
           interpolated_u[i] += nodal_value(t, l, u_nodal_index) * psi[l];
           interpolated_x[i] += nodal_position(t, l, i) * psi[l];
         }
       }
  
       // Coordinates
       for (unsigned i = 0; i < DIM; i++)
       {
         outfile << interpolated_x[i] << " ";
       }
  
       // Velocities
       for (unsigned i = 0; i < DIM; i++)
       {
         outfile << interpolated_u[i] << " ";
       }
  
       outfile << std::endl;
     }
  
     // Write tecplot footer (e.g. FE connectivity lists)
     write_tecplot_zone_footer(outfile, nplot);
   }

References DIM, i, s, oomph::OneDimLagrange::shape(), and plotPSD::t.

◆ output_vorticity()

template<unsigned DIM>

void oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::output_vorticity	(	std::ostream &	outfile,
		const unsigned &	nplot
	)

Output function: x,y,[z], [omega_x,omega_y,[and/or omega_z]] in tecplot format. nplot points in each coordinate direction

Output function for vorticity. x,y,[z],[omega_x,omega_y,[and/or omega_z]] in tecplot format. Specified number of plot points in each coordinate direction.

   {
     // Vector of local coordinates
     Vector<double> s(DIM);
  
     // Create vorticity vector of the required size
     Vector<double> vorticity;
     if (DIM == 2)
     {
       vorticity.resize(1);
     }
     else if (DIM == 3)
     {
       vorticity.resize(3);
     }
     else
     {
       std::string error_message =
         "Can't output vorticity in 1D - in fact, what do you mean\n";
       error_message += "by the 1D Navier-Stokes equations?\n";
  
       throw OomphLibError(
         error_message, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
  
     // Tecplot header info
     outfile << tecplot_zone_string(nplot);
  
     // Loop over plot points
     unsigned num_plot_points = nplot_points(nplot);
     for (unsigned iplot = 0; iplot < num_plot_points; iplot++)
     {
       // Get local coordinates of plot point
       get_s_plot(iplot, nplot, s);
  
       // Coordinates
       for (unsigned i = 0; i < DIM; i++)
       {
         outfile << interpolated_x(s, i) << " ";
       }
  
       // Get vorticity
       get_vorticity(s, vorticity);
  
       if (DIM == 2)
       {
         outfile << vorticity[0];
       }
       else
       {
         outfile << vorticity[0] << " " << vorticity[1] << " " << vorticity[2]
                 << " ";
       }
  
       outfile << std::endl;
     }
     outfile << std::endl;
  
     // Write tecplot footer (e.g. FE connectivity lists)
     write_tecplot_zone_footer(outfile, nplot);
   }

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

◆ p_nodal_index_nst()

template<unsigned DIM>

virtual int oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::p_nodal_index_nst ( ) const

inlinevirtual

Return the index at which the pressure is stored if it is stored at the nodes. If not stored at the nodes this will return a negative number.

Implements oomph::GeneralisedNewtonianTemplateFreeNavierStokesEquationsBase.

Reimplemented in oomph::GeneralisedNewtonianTTaylorHoodElement< DIM >, and oomph::GeneralisedNewtonianQTaylorHoodElement< DIM >.

     {
       return Pressure_not_stored_at_node;
     }

References oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::Pressure_not_stored_at_node.

Referenced by oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::pin_all_non_pressure_dofs().

◆ p_nst() [1/2]

template<unsigned DIM>

virtual double oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::p_nst ( const unsigned & n_p ) const

pure virtual

Pressure at local pressure "node" n_p Uses suitably interpolated value for hanging nodes.

Implemented in oomph::GeneralisedNewtonianTTaylorHoodElement< DIM >, oomph::GeneralisedNewtonianQTaylorHoodElement< DIM >, oomph::GeneralisedNewtonianTCrouzeixRaviartElement< DIM >, oomph::PRefineableGeneralisedNewtonianQCrouzeixRaviartElement< DIM >, and oomph::GeneralisedNewtonianQCrouzeixRaviartElement< DIM >.

Referenced by oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::interpolated_p_nst().

◆ p_nst() [2/2]

template<unsigned DIM>

virtual double oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::p_nst	(	const unsigned &	t,
		const unsigned &	n_p
	)		const

pure virtual

Pressure at local pressure "node" n_p at time level t.

Implemented in oomph::GeneralisedNewtonianTTaylorHoodElement< DIM >, oomph::GeneralisedNewtonianQTaylorHoodElement< DIM >, oomph::GeneralisedNewtonianTCrouzeixRaviartElement< DIM >, oomph::PRefineableGeneralisedNewtonianQCrouzeixRaviartElement< DIM >, and oomph::GeneralisedNewtonianQCrouzeixRaviartElement< DIM >.

◆ pin_all_non_pressure_dofs()

template<unsigned DIM>

void oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::pin_all_non_pressure_dofs ( std::map< Data *, std::vector< int >> & eqn_number_backup )

inlinevirtual

Pin all non-pressure dofs and backup eqn numbers.

Implements oomph::GeneralisedNewtonianTemplateFreeNavierStokesEquationsBase.

     {
       // Loop over internal data and pin the values (having established that
       // pressure dofs aren't amongst those)
       unsigned nint = this->ninternal_data();
       for (unsigned j = 0; j < nint; j++)
       {
         Data* data_pt = this->internal_data_pt(j);
         if (eqn_number_backup[data_pt].size() == 0)
         {
           unsigned nvalue = data_pt->nvalue();
           eqn_number_backup[data_pt].resize(nvalue);
           for (unsigned i = 0; i < nvalue; i++)
           {
             // Backup
             eqn_number_backup[data_pt][i] = data_pt->eqn_number(i);
  
             // Pin everything
             data_pt->pin(i);
           }
         }
       }
  
       // Now deal with nodal values
       unsigned nnod = this->nnode();
       for (unsigned j = 0; j < nnod; j++)
       {
         Node* nod_pt = this->node_pt(j);
         if (eqn_number_backup[nod_pt].size() == 0)
         {
           unsigned nvalue = nod_pt->nvalue();
           eqn_number_backup[nod_pt].resize(nvalue);
           for (unsigned i = 0; i < nvalue; i++)
           {
             // Pin everything apart from the nodal pressure
             // value
             if (int(i) != this->p_nodal_index_nst())
             {
               // Backup
               eqn_number_backup[nod_pt][i] = nod_pt->eqn_number(i);
  
               // Pin
               nod_pt->pin(i);
             }
             // Else it's a pressure value
             else
             {
               // Exclude non-nodal pressure based elements
               if (this->p_nodal_index_nst() >= 0)
               {
                 // Backup
                 eqn_number_backup[nod_pt][i] = nod_pt->eqn_number(i);
               }
             }
           }
  
  
           // If it's a solid node deal with its positional data too
           SolidNode* solid_nod_pt = dynamic_cast<SolidNode*>(nod_pt);
           if (solid_nod_pt != 0)
           {
             Data* solid_posn_data_pt = solid_nod_pt->variable_position_pt();
             if (eqn_number_backup[solid_posn_data_pt].size() == 0)
             {
               unsigned nvalue = solid_posn_data_pt->nvalue();
               eqn_number_backup[solid_posn_data_pt].resize(nvalue);
               for (unsigned i = 0; i < nvalue; i++)
               {
                 // Backup
                 eqn_number_backup[solid_posn_data_pt][i] =
                   solid_posn_data_pt->eqn_number(i);
  
                 // Pin
                 solid_posn_data_pt->pin(i);
               }
             }
           }
         }
       }
     }

References oomph::Data::eqn_number(), i, oomph::GeneralisedElement::internal_data_pt(), j, oomph::GeneralisedElement::ninternal_data(), oomph::FiniteElement::nnode(), oomph::FiniteElement::node_pt(), oomph::Data::nvalue(), oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::p_nodal_index_nst(), oomph::Data::pin(), oomph::FiniteElement::size(), and oomph::SolidNode::variable_position_pt().

◆ point_output_data()

template<unsigned DIM>

void oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::point_output_data	(	const Vector< double > &	s,
		Vector< double > &	data
	)

inlinevirtual

Output solution in data vector at local cordinates s: x,y [,z], u,v,[w], p

Reimplemented from oomph::FiniteElement.

     {
       // Dimension
       unsigned dim = s.size();
  
       // Resize data for values
       data.resize(2 * dim + 1);
  
       // Write values in the vector
       for (unsigned i = 0; i < dim; i++)
       {
         data[i] = interpolated_x(s, i);
         data[i + dim] = this->interpolated_u_nst(s, i);
       }
       data[2 * dim] = this->interpolated_p_nst(s);
     }

References data, oomph::FiniteElement::dim(), i, oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::interpolated_p_nst(), oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::interpolated_u_nst(), oomph::FiniteElement::interpolated_x(), and s.

◆ pressure_integral()

template<unsigned DIM>

double oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::pressure_integral

Integral of pressure over element.

Return pressure integrated over the element.

   {
     // Initialise
     double press_int = 0;
  
     // Set the value of n_intpt
     unsigned n_intpt = integral_pt()->nweight();
  
     // Set the Vector to hold local coordinates
     Vector<double> s(DIM);
  
     // Loop over the integration points
     for (unsigned ipt = 0; ipt < n_intpt; ipt++)
     {
       // Assign values of s
       for (unsigned i = 0; i < DIM; i++)
       {
         s[i] = integral_pt()->knot(ipt, i);
       }
  
       // Get the integral weight
       double w = integral_pt()->weight(ipt);
  
       // Get Jacobian of mapping
       double J = J_eulerian(s);
  
       // Premultiply the weights and the Jacobian
       double W = w * J;
  
       // Get pressure
       double press = interpolated_p_nst(s);
  
       // Add
       press_int += press * W;
     }
  
     return press_int;
   }

References DIM, i, J, s, w, and oomph::QuadTreeNames::W.

◆ pshape_nst() [1/2]

template<unsigned DIM>

virtual void oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::pshape_nst	(	const Vector< double > &	s,
		Shape &	psi
	)		const

pure virtual

Compute the pressure shape functions at local coordinate s.

Referenced by oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::interpolated_p_nst().

◆ pshape_nst() [2/2]

template<unsigned DIM>

virtual void oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::pshape_nst	(	const Vector< double > &	s,
		Shape &	psi,
		Shape &	test
	)		const

pure virtual

Compute the pressure shape and test functions at local coordinate s

Implemented in oomph::GeneralisedNewtonianTTaylorHoodElement< DIM >, oomph::GeneralisedNewtonianTCrouzeixRaviartElement< DIM >, oomph::GeneralisedNewtonianTCrouzeixRaviartElement< DIM >, oomph::GeneralisedNewtonianTCrouzeixRaviartElement< DIM >, oomph::PRefineableGeneralisedNewtonianQCrouzeixRaviartElement< DIM >, oomph::PRefineableGeneralisedNewtonianQCrouzeixRaviartElement< DIM >, oomph::PRefineableGeneralisedNewtonianQCrouzeixRaviartElement< DIM >, oomph::GeneralisedNewtonianQTaylorHoodElement< DIM >, and oomph::GeneralisedNewtonianQCrouzeixRaviartElement< DIM >.

◆ re()

template<unsigned DIM>

const double& oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::re ( ) const

inline

Reynolds number.

     {
       return *Re_pt;
     }

References oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::Re_pt.

◆ re_invfr()

template<unsigned DIM>

const double& oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::re_invfr ( ) const

inline

Global inverse Froude number.

     {
       return *ReInvFr_pt;
     }

References oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::ReInvFr_pt.

◆ re_invfr_pt()

template<unsigned DIM>

double*& oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::re_invfr_pt ( )

inline

Pointer to global inverse Froude number.

     {
       return ReInvFr_pt;
     }

References oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::ReInvFr_pt.

◆ re_pt()

template<unsigned DIM>

double*& oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::re_pt ( )

inline

Pointer to Reynolds number.

     {
       return Re_pt;
     }

References oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::Re_pt.

◆ re_st()

template<unsigned DIM>

const double& oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::re_st ( ) const

inline

Product of Reynolds and Strouhal number (=Womersley number)

     {
       return *ReSt_pt;
     }

References oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::ReSt_pt.

◆ re_st_pt()

template<unsigned DIM>

double*& oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::re_st_pt ( )

inline

Pointer to product of Reynolds and Strouhal number (=Womersley number)

     {
       return ReSt_pt;
     }

References oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::ReSt_pt.

◆ scalar_name_paraview()

template<unsigned DIM>

std::string oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::scalar_name_paraview ( const unsigned & i ) const

inlinevirtual

Name of the i-th scalar field. Default implementation returns V1 for the first one, V2 for the second etc. Can (should!) be overloaded with more meaningful names in specific elements.

Reimplemented from oomph::FiniteElement.

     {
       // Velocities
       if (i < DIM)
       {
         return "Velocity " + StringConversion::to_string(i);
       }
       // Preussre
       else if (i == DIM)
       {
         return "Pressure";
       }
       // Never get here
       else
       {
         std::stringstream error_stream;
         error_stream << "These Navier Stokes elements only store " << DIM + 1
                      << "  fields,\n"
                      << "but i is currently  " << i << std::endl;
         throw OomphLibError(
           error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
         // Dummy return
         return " ";
       }
     }

References DIM, i, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and oomph::StringConversion::to_string().

◆ scalar_value_paraview()

template<unsigned DIM>

void oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::scalar_value_paraview	(	std::ofstream &	file_out,
		const unsigned &	i,
		const unsigned &	nplot
	)		const

inlinevirtual

Write values of the i-th scalar field at the plot points. Needs to be implemented for each new specific element type.

Reimplemented from oomph::FiniteElement.

     {
       // Vector of local coordinates
       Vector<double> s(DIM);
  
  
       // Loop over plot points
       unsigned num_plot_points = nplot_points_paraview(nplot);
       for (unsigned iplot = 0; iplot < num_plot_points; iplot++)
       {
         // Get local coordinates of plot point
         get_s_plot(iplot, nplot, s);
  
         // Velocities
         if (i < DIM)
         {
           file_out << interpolated_u_nst(s, i) << std::endl;
         }
  
         // Pressure
         else if (i == DIM)
         {
           file_out << interpolated_p_nst(s) << std::endl;
         }
  
         // Never get here
         else
         {
 #ifdef PARANOID
           std::stringstream error_stream;
           error_stream << "These Navier Stokes elements only store " << DIM + 1
                        << " fields, "
                        << "but i is currently  " << i << std::endl;
           throw OomphLibError(error_stream.str(),
                               OOMPH_CURRENT_FUNCTION,
                               OOMPH_EXCEPTION_LOCATION);
 #endif
         }
       }
     }

References DIM, oomph::FiniteElement::get_s_plot(), i, oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::interpolated_p_nst(), oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::interpolated_u_nst(), oomph::FiniteElement::nplot_points_paraview(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and s.

◆ source_fct_pt() [1/2]

template<unsigned DIM>

NavierStokesSourceFctPt& oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::source_fct_pt ( )

inline

Access function for the source-function pointer.

     {
       return Source_fct_pt;
     }

References oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::Source_fct_pt.

◆ source_fct_pt() [2/2]

template<unsigned DIM>

NavierStokesSourceFctPt oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::source_fct_pt ( ) const

inline

Access function for the source-function pointer. Const version.

     {
       return Source_fct_pt;
     }

References oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::Source_fct_pt.

◆ strain_rate() [1/2]

template<unsigned DIM>

void oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::strain_rate	(	const unsigned &	t,
		const Vector< double > &	s,
		DenseMatrix< double > &	strainrate
	)		const

Strain-rate tensor: 1/2 (du_i/dx_j + du_j/dx_i) at a specific time history value

Get strain-rate tensor: 1/2 (du_i/dx_j + du_j/dx_i) at a specific time

   {
 #ifdef PARANOID
     if ((strainrate.ncol() != DIM) || (strainrate.nrow() != DIM))
     {
       std::ostringstream error_message;
       error_message << "The strain rate has incorrect dimensions "
                     << strainrate.ncol() << " x " << strainrate.nrow()
                     << " Not " << DIM << std::endl;
  
       throw OomphLibError(
         error_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
 #endif
  
     // Velocity gradient matrix
     DenseMatrix<double> dudx(DIM);
  
     // Find out how many nodes there are in the element
     unsigned n_node = nnode();
  
     // Set up memory for the shape and test functions
     Shape psi(n_node);
     DShape dpsidx(n_node, DIM);
  
     // Loop over all nodes to back up current positions and over-write them
     // with the appropriate history values
     DenseMatrix<double> backed_up_nodal_position(n_node, DIM);
     for (unsigned j = 0; j < n_node; j++)
     {
       for (unsigned k = 0; k < DIM; k++)
       {
         backed_up_nodal_position(j, k) = node_pt(j)->x(k);
         node_pt(j)->x(k) = node_pt(j)->x(t, k);
       }
     }
  
     // Call the derivatives of the shape functions
     dshape_eulerian(s, psi, dpsidx);
  
     // Initialise to zero
     for (unsigned i = 0; i < DIM; i++)
     {
       for (unsigned j = 0; j < DIM; j++)
       {
         dudx(i, j) = 0.0;
       }
     }
  
     // Loop over veclocity components
     for (unsigned i = 0; i < DIM; i++)
     {
       // Get the index at which the i-th velocity is stored
       unsigned u_nodal_index = u_index_nst(i);
       // Loop over derivative directions
       for (unsigned j = 0; j < DIM; j++)
       {
         // Loop over nodes
         for (unsigned l = 0; l < n_node; l++)
         {
           dudx(i, j) += nodal_value(t, l, u_nodal_index) * dpsidx(l, j);
         }
       }
     }
  
     // Loop over veclocity components
     for (unsigned i = 0; i < DIM; i++)
     {
       // Loop over derivative directions
       for (unsigned j = 0; j < DIM; j++)
       {
         strainrate(i, j) = 0.5 * (dudx(i, j) + dudx(j, i));
       }
     }
  
     // Reset current nodal positions
     for (unsigned j = 0; j < n_node; j++)
     {
       for (unsigned k = 0; k < DIM; k++)
       {
         node_pt(j)->x(k) = backed_up_nodal_position(j, k);
       }
     }
   }

References DIM, i, j, k, oomph::DenseMatrix< T >::ncol(), oomph::DenseMatrix< T >::nrow(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, s, and plotPSD::t.

◆ strain_rate() [2/2]

template<unsigned DIM>

void oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::strain_rate	(	const Vector< double > &	s,
		DenseMatrix< double > &	strain_rate
	)		const

Strain-rate tensor: 1/2 (du_i/dx_j + du_j/dx_i)

Get strain-rate tensor: 1/2 (du_i/dx_j + du_j/dx_i)

   {
 #ifdef PARANOID
     if ((strainrate.ncol() != DIM) || (strainrate.nrow() != DIM))
     {
       std::ostringstream error_message;
       error_message << "The strain rate has incorrect dimensions "
                     << strainrate.ncol() << " x " << strainrate.nrow()
                     << " Not " << DIM << std::endl;
  
       throw OomphLibError(
         error_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
 #endif
  
     // Velocity gradient matrix
     DenseMatrix<double> dudx(DIM);
  
     // Find out how many nodes there are in the element
     unsigned n_node = nnode();
  
     // Set up memory for the shape and test functions
     Shape psi(n_node);
     DShape dpsidx(n_node, DIM);
  
     // Call the derivatives of the shape functions
     dshape_eulerian(s, psi, dpsidx);
  
     // Initialise to zero
     for (unsigned i = 0; i < DIM; i++)
     {
       for (unsigned j = 0; j < DIM; j++)
       {
         dudx(i, j) = 0.0;
       }
     }
  
     // Loop over veclocity components
     for (unsigned i = 0; i < DIM; i++)
     {
       // Get the index at which the i-th velocity is stored
       unsigned u_nodal_index = u_index_nst(i);
       // Loop over derivative directions
       for (unsigned j = 0; j < DIM; j++)
       {
         // Loop over nodes
         for (unsigned l = 0; l < n_node; l++)
         {
           dudx(i, j) += nodal_value(l, u_nodal_index) * dpsidx(l, j);
         }
       }
     }
  
     // Loop over veclocity components
     for (unsigned i = 0; i < DIM; i++)
     {
       // Loop over derivative directions
       for (unsigned j = 0; j < DIM; j++)
       {
         strainrate(i, j) = 0.5 * (dudx(i, j) + dudx(j, i));
       }
     }
   }

References DIM, i, j, oomph::DenseMatrix< T >::ncol(), oomph::DenseMatrix< T >::nrow(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and s.

Referenced by oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::extrapolated_strain_rate(), oomph::RefineableGeneralisedNewtonianNavierStokesEquations< DIM >::get_Z2_flux(), oomph::GeneralisedNewtonianTCrouzeixRaviartElement< DIM >::get_Z2_flux(), and oomph::GeneralisedNewtonianTTaylorHoodElement< DIM >::get_Z2_flux().

◆ u_index_nst()

template<unsigned DIM>

virtual unsigned oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::u_index_nst ( const unsigned & i ) const

inlinevirtual

Return the index at which the i-th unknown velocity component is stored. The default value, i, is appropriate for single-physics problems. In derived multi-physics elements, this function should be overloaded to reflect the chosen storage scheme. Note that these equations require that the unknowns are always stored at the same indices at each node.

     {
       return i;
     }

References i.

Referenced by oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::dinterpolated_u_nst_ddata(), oomph::RefineableGeneralisedNewtonianNavierStokesEquations< DIM >::dinterpolated_u_nst_ddata(), oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::du_dt_nst(), oomph::RefineableGeneralisedNewtonianQTaylorHoodElement< DIM >::get_interpolated_values(), oomph::RefineableGeneralisedNewtonianQCrouzeixRaviartElement< DIM >::get_interpolated_values(), oomph::PRefineableGeneralisedNewtonianQCrouzeixRaviartElement< DIM >::get_interpolated_values(), oomph::RefineableGeneralisedNewtonianQTaylorHoodElement< DIM >::identify_load_data(), oomph::RefineableGeneralisedNewtonianQCrouzeixRaviartElement< DIM >::identify_load_data(), oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::interpolated_u_nst(), and oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::u_nst().

◆ u_nst() [1/2]

template<unsigned DIM>

double oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::u_nst	(	const unsigned &	n,
		const unsigned &	i
	)		const

inline

Velocity i at local node n. Uses suitably interpolated value for hanging nodes. The use of u_index_nst() permits the use of this element as the basis for multi-physics elements. The default is to assume that the i-th velocity component is stored at the i-th location of the node

     {
       return nodal_value(n, u_index_nst(i));
     }

References i, n, oomph::FiniteElement::nodal_value(), and oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::u_index_nst().

◆ u_nst() [2/2]

template<unsigned DIM>

double oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::u_nst	(	const unsigned &	t,
		const unsigned &	n,
		const unsigned &	i
	)		const

inline

Velocity i at local node n at timestep t (t=0: present; t>0: previous). Uses suitably interpolated value for hanging nodes.

     {
       return nodal_value(t, n, u_index_nst(i));
     }

References i, n, oomph::FiniteElement::nodal_value(), plotPSD::t, and oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::u_index_nst().

◆ use_current_strainrate_to_compute_second_invariant()

template<unsigned DIM>

void oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::use_current_strainrate_to_compute_second_invariant ( )

inline

Switch to fully implict evaluation of non-Newtonian const eqn.

     {
       Use_extrapolated_strainrate_to_compute_second_invariant = false;
     }

References oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::Use_extrapolated_strainrate_to_compute_second_invariant.

◆ use_extrapolated_strainrate_to_compute_second_invariant()

template<unsigned DIM>

void oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::use_extrapolated_strainrate_to_compute_second_invariant ( )

inline

Use extrapolation for non-Newtonian const eqn.

     {
       Use_extrapolated_strainrate_to_compute_second_invariant = true;
     }

References oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::Use_extrapolated_strainrate_to_compute_second_invariant.

◆ viscosity_ratio()

template<unsigned DIM>

const double& oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::viscosity_ratio ( ) const

inline

Viscosity ratio for element: Element's viscosity relative to the viscosity used in the definition of the Reynolds number

     {
       return *Viscosity_Ratio_pt;
     }

References oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::Viscosity_Ratio_pt.

◆ viscosity_ratio_pt()

template<unsigned DIM>

double*& oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::viscosity_ratio_pt ( )

inline

Pointer to Viscosity Ratio.

     {
       return Viscosity_Ratio_pt;
     }

References oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::Viscosity_Ratio_pt.

Member Data Documentation

◆ ALE_is_disabled

template<unsigned DIM>

bool oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::ALE_is_disabled

protected

Boolean flag to indicate if ALE formulation is disabled when time-derivatives are computed. Only set to true if you're sure that the mesh is stationary.

Referenced by oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::disable_ALE(), oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::enable_ALE(), and oomph::RefineableGeneralisedNewtonianNavierStokesEquations< DIM >::further_build().

◆ Body_force_fct_pt

template<unsigned DIM>

NavierStokesBodyForceFctPt oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::Body_force_fct_pt

protected

Pointer to body force function.

Referenced by oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::body_force_fct_pt(), oomph::RefineableGeneralisedNewtonianNavierStokesEquations< DIM >::further_build(), and oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::get_body_force_nst().

◆ Constitutive_eqn_pt

template<unsigned DIM>

GeneralisedNewtonianConstitutiveEquation<DIM>* oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::Constitutive_eqn_pt

protected

Pointer to the generalised Newtonian constitutive equation.

Referenced by oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::constitutive_eqn_pt().

◆ Default_Gravity_vector

template<unsigned DIM>

Vector< double > oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::Default_Gravity_vector

staticprivate

Static default value for the gravity vector.

Navier-Stokes equations default gravity vector.

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

◆ Default_Physical_Constant_Value

template<unsigned DIM>

double oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::Default_Physical_Constant_Value = 0.0

staticprivate

Navier–Stokes equations static data.

Static default value for the physical constants (all initialised to zero)

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

◆ Default_Physical_Ratio_Value

template<unsigned DIM>

double oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::Default_Physical_Ratio_Value = 1.0

staticprivate

Navier–Stokes equations static data.

Static default value for the physical ratios (all are initialised to one)

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

◆ Density_Ratio_pt

template<unsigned DIM>

double* oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::Density_Ratio_pt

protected

Pointer to the density ratio (relative to the density used in the definition of the Reynolds number)

Referenced by oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::density_ratio(), oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::density_ratio_pt(), oomph::RefineableGeneralisedNewtonianNavierStokesEquations< DIM >::further_build(), and oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::GeneralisedNewtonianNavierStokesEquations().

◆ G_pt

template<unsigned DIM>

Vector<double>* oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::G_pt

protected

Pointer to global gravity Vector.

Referenced by oomph::RefineableGeneralisedNewtonianNavierStokesEquations< DIM >::further_build(), oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::g(), oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::g_pt(), and oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::GeneralisedNewtonianNavierStokesEquations().

◆ Gamma

template<unsigned DIM>

Vector< double > oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::Gamma

static

Vector to decide whether the stress-divergence form is used or not.

Navier–Stokes equations static data.

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

◆ Pre_multiply_by_viscosity_ratio

template<unsigned DIM>

bool oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::Pre_multiply_by_viscosity_ratio = false

staticprotected

Static boolean telling us whether we pre-multiply the pressure and continuity by the viscosity ratio

By default disable the pre-multiplication of the pressure and continuity equation by the viscosity ratio

◆ Pressure_not_stored_at_node

template<unsigned DIM>

int oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::Pressure_not_stored_at_node = -100

staticprivate

Static "magic" number that indicates that the pressure is not stored at a node

"Magic" negative number that indicates that the pressure is not stored at a node. This cannot be -1 because that represents the positional hanging scheme in the hanging_pt object of nodes

Referenced by oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::p_nodal_index_nst().

◆ Re_pt

template<unsigned DIM>

double* oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::Re_pt

protected

Pointer to global Reynolds number.

Referenced by oomph::RefineableGeneralisedNewtonianNavierStokesEquations< DIM >::further_build(), oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::GeneralisedNewtonianNavierStokesEquations(), oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::re(), and oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::re_pt().

◆ ReInvFr_pt

template<unsigned DIM>

double* oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::ReInvFr_pt

protected

Pointer to global Reynolds number x inverse Froude number (= Bond number / Capillary number)

Referenced by oomph::RefineableGeneralisedNewtonianNavierStokesEquations< DIM >::further_build(), oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::GeneralisedNewtonianNavierStokesEquations(), oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::re_invfr(), and oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::re_invfr_pt().

◆ ReSt_pt

template<unsigned DIM>

double* oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::ReSt_pt

protected

Pointer to global Reynolds number x Strouhal number (=Womersley)

Referenced by oomph::RefineableGeneralisedNewtonianNavierStokesEquations< DIM >::further_build(), oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::GeneralisedNewtonianNavierStokesEquations(), oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::re_st(), and oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::re_st_pt().

◆ Source_fct_pt

template<unsigned DIM>

NavierStokesSourceFctPt oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::Source_fct_pt

protected

Pointer to volumetric source function.

Referenced by oomph::RefineableGeneralisedNewtonianNavierStokesEquations< DIM >::further_build(), oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::get_source_nst(), and oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::source_fct_pt().

◆ Use_extrapolated_strainrate_to_compute_second_invariant

template<unsigned DIM>

bool oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::Use_extrapolated_strainrate_to_compute_second_invariant

protected

Referenced by oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::use_current_strainrate_to_compute_second_invariant(), and oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::use_extrapolated_strainrate_to_compute_second_invariant().

◆ Viscosity_Ratio_pt

template<unsigned DIM>

double* oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::Viscosity_Ratio_pt

protected

Pointer to the viscosity ratio (relative to the viscosity used in the definition of the Reynolds number)

Referenced by oomph::RefineableGeneralisedNewtonianNavierStokesEquations< DIM >::further_build(), oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::GeneralisedNewtonianNavierStokesEquations(), oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::viscosity_ratio(), and oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::viscosity_ratio_pt().

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

Public Types

Public Member Functions

Static Public Attributes

Protected Member Functions

Protected Attributes

Static Protected Attributes

Static Private Attributes

Detailed Description

template<unsigned DIM> class oomph::GeneralisedNewtonianNavierStokesEquations< DIM >

Member Typedef Documentation

◆ NavierStokesBodyForceFctPt

◆ NavierStokesPressureAdvDiffSourceFctPt

◆ NavierStokesSourceFctPt

Constructor & Destructor Documentation

◆ GeneralisedNewtonianNavierStokesEquations()

Member Function Documentation

◆ body_force_fct_pt() [1/2]

◆ body_force_fct_pt() [2/2]

◆ compute_error() [1/2]

◆ compute_error() [2/2]

◆ constitutive_eqn_pt()

◆ d_kin_energy_dt()

◆ density_ratio()

◆ density_ratio_pt()

◆ dinterpolated_u_nst_ddata()

◆ disable_ALE()

◆ dissipation() [1/2]

◆ dissipation() [2/2]

◆ dpshape_and_dptest_eulerian_nst()

◆ dshape_and_dtest_eulerian_at_knot_nst() [1/2]

◆ dshape_and_dtest_eulerian_at_knot_nst() [2/2]

◆ dshape_and_dtest_eulerian_nst()

◆ du_dt_nst()

◆ enable_ALE()

◆ extrapolated_strain_rate() [1/2]

◆ extrapolated_strain_rate() [2/2]

◆ fill_in_contribution_to_djacobian_and_dmass_matrix_dparameter()

◆ fill_in_contribution_to_djacobian_dparameter()

◆ fill_in_contribution_to_dresiduals_dparameter()

◆ fill_in_contribution_to_hessian_vector_products()

◆ fill_in_contribution_to_jacobian()

◆ fill_in_contribution_to_jacobian_and_mass_matrix()

◆ fill_in_contribution_to_residuals()

◆ fill_in_generic_dresidual_contribution_nst()

◆ fill_in_generic_residual_contribution_nst()

◆ fix_pressure()

◆ full_output() [1/2]

◆ full_output() [2/2]

◆ g()

◆ g_pt()

◆ get_body_force_gradient_nst()

◆ get_body_force_nst()

◆ get_dresidual_dnodal_coordinates()

◆ get_load()

◆ get_pressure_and_velocity_mass_matrix_diagonal()

◆ get_source_gradient_nst()

◆ get_source_nst()

◆ get_traction() [1/2]

◆ get_traction() [2/2]

◆ get_vorticity() [1/3]

◆ get_vorticity() [2/3]

◆ get_vorticity() [3/3]

◆ interpolated_p_nst() [1/2]

◆ interpolated_p_nst() [2/2]

◆ interpolated_u_nst() [1/3]

◆ interpolated_u_nst() [2/3]

◆ interpolated_u_nst() [3/3]

◆ kin_energy()

◆ max_and_min_invariant_and_viscosity()

◆ n_u_nst()

◆ npres_nst()

◆ nscalar_paraview()

◆ output() [1/4]

◆ output() [2/4]

◆ output() [3/4]

◆ output() [4/4]

◆ output_fct() [1/2]

◆ output_fct() [2/2]

◆ output_veloc()

◆ output_vorticity()

template<unsigned DIM>
class oomph::GeneralisedNewtonianNavierStokesEquations< DIM >