Namespace for global parameters. More...

Enumerations
enum	{ Parallel_flow_lagrange_multiplier_id , FSI_interface_displacement_lagrange_multiplier_id }

enum	{ Parallel_flow_lagrange_multiplier_id , FSI_interface_displacement_lagrange_multiplier_id }

Functions
void	boundary_traction (const double &time, const Vector< double > &x, const Vector< double > &n, Vector< double > &result)
	The traction function at r=Rmin: (t_r, t_z, t_theta) More...

void	body_force (const double &time, const Vector< double > &x, Vector< double > &result)

void	exact_solution_th (const Vector< double > &x, Vector< double > &u)

double	u_r (const double &time, const Vector< double > &x)
	Calculate the time dependent form of the r-component of displacement. More...

double	u_z (const double &time, const Vector< double > &x)
	Calculate the time dependent form of the z-component of displacement. More...

double	u_theta (const double &time, const Vector< double > &x)
	Calculate the time dependent form of the theta-component of displacement. More...

double	d_u_r_dt (const double &time, const Vector< double > &x)
	Calculate the time dependent form of the r-component of velocity. More...

double	d_u_z_dt (const double &time, const Vector< double > &x)
	Calculate the time dependent form of the z-component of velocity. More...

double	d_u_theta_dt (const double &time, const Vector< double > &x)
	Calculate the time dependent form of the theta-component of velocity. More...

double	d2_u_r_dt2 (const double &time, const Vector< double > &x)
	Calculate the time dependent form of the r-component of acceleration. More...

double	d2_u_z_dt2 (const double &time, const Vector< double > &x)
	Calculate the time dependent form of the z-component of acceleration. More...

double	d2_u_theta_dt2 (const double &time, const Vector< double > &x)
	Calculate the time dependent form of the theta-component of acceleration. More...

void	exact_solution (const double &time, const Vector< double > &x, Vector< double > &u)

std::complex< double >	Eigenfunction_normalisation (1.0, 0.0)

TimeHarmonicIsotropicElasticityTensor	E (Nu)
	The elasticity tensor for the solid. More...

void	update_parameter_values ()
	Function to update dependent parameter values. More...

void	solid_boundary_displacement (const Vector< double > &x, Vector< std::complex< double > > &u)
	Displacement field on inner boundary of solid. More...

std::complex< double >	HankelH1 (const double &k, const double &x)
	Interface to Hankel function in maple style. More...

std::complex< double >	axisym_coefficient ()

void	exact_axisym_potential (const Vector< double > &x, Vector< double > &soln)
	Exact solution for Helmholtz potential for axisymmetric solution. More...

double	exact_axisym_radiated_power ()
	Exact radiated power for axisymmetric solution. More...

Vector< double >	Omega_sq (2, 0.0)
	Square of non-dim frequency for the two regions – dependent variable! More...

Vector< double >	Density_ratio (2, 0.1)
	Density ratio for the two regions: solid to fluid. More...

void	pressure_load (const Vector< double > &x, const Vector< double > &n, Vector< std::complex< double > > &traction)
	Pressure load (real and imag part) More...

std::complex< double >	Nu (std::complex< double >(0.3, 0.0))
	Poisson's ratio Nu. More...

std::complex< double >	Omega_sq (std::complex< double >(100.0, 0.0))
	Non-dim square of frequency for solid – dependent variable! More...

Vector< std::complex< double > >	E (2, std::complex< double >(1.0, 0.0))
	Define the non-dimensional Young's modulus. More...

Vector< std::complex< double > >	Omega_sq (2, std::complex< double >(100.0, 0.0))
	Non-dim square of frequency for solid – dependent variable! More...

Vector< double >	Density_ratio (2, 1.0)
	Density ratio: solid to fluid. More...

void	press_load (const Vector< double > &xi, const Vector< double > &x, const Vector< double > &N, Vector< double > &load)
	Load function for wall. More...

double	flux (const double &t)
	Flux: Pulsatile flow. More...

void	gravity (const double &time, const Vector< double > &xi, Vector< double > &b)
	Non-dimensional gravity as body force. More...

void	set_parameters (const string &case_id)
	Set parameters for the various test cases. More...

bool	is_on_fsi_boundary (Node *nod_pt)
	Boolean to identify if node is on fsi boundary. More...

void	prescribed_inflow_traction (const double &t, const Vector< double > &x, const Vector< double > &n, Vector< double > &traction)
	Applied traction on fluid at the inflow boundary. More...

void	prescribed_outflow_traction (const double &t, const Vector< double > &x, const Vector< double > &n, Vector< double > &traction)
	Applied traction on fluid at the inflow boundary. More...

void	exact_solution (const Vector< double > &x, Vector< double > &u)
	The exact solution for infinite depth case. More...

void	periodic_traction (const double &time, const Vector< double > &x, const Vector< double > &n, Vector< double > &result)
	The traction function. More...

double	blend (const Vector< double > &x, const Vector< double > &x_c)
	Blend function, centred at x_c. More...

Vector< double >	grad_blend (const Vector< double > &x, const Vector< double > &x_c)
	Gradient of blend function, centred at x_c. More...

Vector< double >	velocity_couette (const Vector< double > &x)
	Couette flow. More...

double	pressure_couette (const Vector< double > &x)
	Couette Pressure. More...

void	exact_couette (const Vector< double > &x, Vector< double > &soln)
	Combined exact solution (u,v,p) More...

Vector< double >	velocity_pseudo_singularity_for_couette (const Vector< double > &x)
	Pseudo_singularity for computation of Couette flow. More...

Vector< Vector< double > >	grad_velocity_pseudo_singularity_for_couette (const Vector< double > &x)
	Pseudo_singularity for computation of Couette flow: grad[i][j] = du_i/dx_j. More...

double	pressure_pseudo_singularity_for_couette (const Vector< double > &x)
	Pseudo_singularity for computation of Couette flow. More...

Vector< double >	blended_velocity_pseudo_singularity_for_couette (const Vector< double > &x)
	Blended Pseudo_singularity for computation of Couette flow. More...

Vector< Vector< double > >	blended_grad_velocity_pseudo_singularity_for_couette (const Vector< double > &x)

double	blended_pressure_pseudo_singularity_for_couette (const Vector< double > &x)
	Blended Pseudo_singularity for computation of Couette flow. More...

Vector< double >	velocity_singularity1 (const Vector< double > &x)
	Function that computes the fitting velocity solution near the corner (0,0) More...

Vector< double >	velocity_singularity2 (const Vector< double > &x)
	Function that computes the fitting velocity solution near the corner (1,0) More...

Vector< Vector< double > >	grad_velocity_singularity1 (const Vector< double > &coord)

Vector< Vector< double > >	grad_velocity_singularity2 (const Vector< double > &coord)

double	pressure_singularity1 (const Vector< double > &x)
	Function that computes the fitting pressure solution near the corner (0,0) More...

double	pressure_singularity2 (const Vector< double > &x)
	Function that computes the fitting pressure solution near the corner (1,0) More...

Vector< double >	grad_pressure_singularity1 (const Vector< double > &coord)

void	analytic_solution1 (const Vector< double > &x, Vector< double > &solution)
	Function that computes the fitting solutions near the corner (0,0) More...

void	analytic_solution2 (const Vector< double > &x, Vector< double > &solution)
	Function that computes the fitting solutions near the corner (1,0) More...

Vector< double >	G (3)
	Gravity. More...

void	compute_dependent_parameters ()
	Function to compute dependent parameters. More...

void	Hankel_first (const unsigned &n, const double &x, Vector< std::complex< double > > &h, Vector< std::complex< double > > &hp)

void	exact_u (const Vector< double > &x, Vector< double > &u)
	Exact solution as a Vector: {u_x_real, u_y_real, u_x_imag, u_y_imag}. More...

void	body_force (const Vector< double > &x, Vector< std::complex< double > > &b)
	Body force. More...

void	constant_pressure (const Vector< double > &xi, const Vector< double > &x, const Vector< double > &n, Vector< double > &traction)

std::complex< double >	Nu (0.3, 0.05)
	Define Poisson's ratio Nu. More...

std::complex< double >	E (1.0, 0.01)
	Define the non-dimensional Young's modulus. More...

std::complex< double >	Omega_sq (10.0, 5.0)

const std::complex< double >	I (0.0, 1.0)
	Define the imaginary unit. More...

void	boundary_traction (const Vector< double > &x, const Vector< double > &n, Vector< std::complex< double > > &result)
	The traction function at r=rmin: (t_r, t_z, t_theta) More...

std::complex< double >	Omega_sq (10.0, 0.0)

void	solid_boundary_displacement (const Vector< double > &x, Vector< double > &u)
	Real-valued, radial displacement field on inner boundary. More...

void	constant_pressure (const Vector< double > &x, const Vector< double > &n, Vector< std::complex< double > > &traction)
	Constant pressure load (real and imag part) More...

double	BesselY (const double &n, const double &x)
	Helper function to evaluate Y_n(x) from bloody maple output. More...

double	BesselJ (const double &n, const double &x)
	Helper function to evaluate J_n(x) from bloody maple output. More...

Variables
double	Nu = 0.3
	Define Poisson's ratio Nu. More...

double	E = 1.0
	Define the non-dimensional Young's modulus. More...

double	Lambda = ENu/(1.0+Nu)/(1.0-2.0Nu)
	Lame parameters. More...

double	Mu = E/2.0/(1.0+Nu)

double	Omega_sq = 0.5
	Square of the frequency of the time dependence. More...

unsigned	Nr = 5
	Number of elements in r-direction. More...

unsigned	Nz = 10
	Number of elements in z-direction. More...

double	Lr = 1.0
	Length of domain in r direction. More...

double	Lz = 2.0
	Length of domain in z-direction. More...

double	Rmin = 0.1
	Set up min r coordinate. More...

double	Zmin = 0.3
	Set up min z coordinate. More...

double	Rmax = Rmin+Lr
	Set up max r coordinate. More...

double	Zmax = Zmin+Lz
	Set up max z coordinate. More...

double	Re =75.0
	reynolds number More...

double	B =0.7

double	Alpha =0.0
	Peakiness parameter for pressure load. More...

bool	Read_in_eigenfunction_from_disk = true

double	K_squared =10.0
	Square of wavenumber for the Helmholtz equation. More...

double	Outer_radius =4.0
	Radius of outer boundary of Helmholtz domain. More...

double	Q =0.0
	FSI parameter. More...

double	H_coating =0.3
	Non-dim thickness of elastic coating. More...

double	Density_ratio =0.0
	Density ratio: solid to fluid. More...

unsigned	N =0

string	Directory ="RESLT"
	Output directory. More...

unsigned	El_multiplier =1
	Multiplier for number of elements. More...

unsigned	ABC_order =3
	Order of absorbing/appproximate boundary condition. More...

Vector< TimeHarmonicIsotropicElasticityTensor * >	E_pt
	The elasticity tensors for the two regions. More...

double	P = 0.1
	Uniform pressure. More...

int	Fourier_wavenumber =0
	Define azimuthal Fourier wavenumber. More...

unsigned	M =4

double	L =12.0
	tube length More...

double	Lup =1.5
	upstream length More...

double	Ldown =3.0
	downstream length More...

double	H =0.15
	wall thickness More...

unsigned	N_slice =4
	number of axial slices in fluid mesh More...

ConstitutiveLaw *	Constitutive_law_wall_pt =0
	Pointer to constitutive law for the wall. More...

ConstitutiveLaw *	Constitutive_law_pseudo_elastic_pt =0
	Pointer to constitutive law for the pseudo elastic node update elements. More...

double	Nu_wall =0.3

double	Nu_pseudo_elastic =0.1

double	Pcos = 2.0e-4
	Perturbation pressure. More...

double	Lambda_sq =0.0
	Timescale ratio (non-dim density) for solid. More...

double	T =1.0
	Period of periodic variation in inflow pressure. More...

double	Dt =0.01
	Timestep. More...

unsigned	Nstep_per_period =40
	Number of steps per period. More...

unsigned	Nperiod =5
	Number of periods. More...

double	Leaflet_x0 = 1.0
	x-position of root of leaflet More...

double	Leaflet_height =0.5
	height of leaflet More...

double	Fluid_length_left =1.0
	length of fluid mesh to left of leaflet More...

double	Fluid_length_right =3.0
	length of fluid mesh to right of leaflet More...

double	Fluid_height =1.0
	height of fluid mesh More...

unsigned	Mesh_nleft =4
	Num elements to left of leaflet in coarse mesh. More...

unsigned	Mesh_nright =12
	Num elements to right of leaflet in coarse mesh. More...

unsigned	Mesh_ny1 =2
	Num elements in fluid mesh in y dirn adjacent to leaflet. More...

unsigned	Mesh_ny2 =2
	Num elements in fluid mesh in y dirn above leaflet. More...

double	ReSt =50.0
	Womersley number: Product of Reynolds and Strouhal numbers. More...

double	U_base =1.0
	Min. flux. More...

double	U_perturbation =0.5
	Max. flux. More...

double	Lambda_sq_beam =0.0
	Beam mass density. More...

string	Case_ID ="FSI1"
	Default case ID. More...

double	St =0.5
	Strouhal number (default assignment for FSI1 test case) More...

double	Centre_x =2.0
	x position of centre of cylinder More...

double	Centre_y =2.0
	y position of centre of cylinder More...

double	Radius =0.5
	Radius of cylinder. More...

ConstitutiveLaw *	Constitutive_law_pt =0
	Pointer to constitutive law. More...

bool	Ignore_fluid_loading =false
	Ignore fluid (default assignment for FSI1 test case) More...

double	Gravity =0.0
	Non-dim gravity (default assignment for FSI1 test case) More...

double	Ramp_period =2.0
	Period for ramping up in flux. More...

double	Min_flux =0.0
	Min. flux. More...

double	Max_flux =1.0
	Max. flux. More...

bool	Prescribe_pressure =false
	Boolean to choose if inflow pressure (true) or volume flux are prescribed. More...

double	P_in_max =0.0025
	Max. inflow pressure (during periodic variation) More...

double	Period =0.1
	Period of periodic variation in inflow pressure. More...

double	P_in =0.0
	Fluid pressure on inflow boundary. More...

double	P_out =-0.25
	Fluid pressure on outflow boundary. More...

double	Peak_prescribed_flow_rate =-1.0
	Peak prescribed flow rate. More...

double	Prescribed_flow_rate =Peak_prescribed_flow_rate
	Prescribed flow rate. More...

Data *	P_in_data_pt =0

double	Amplitude = 1.0
	Amplitude of traction applied. More...

bool	Finite =false

double	Lx = 1.0
	Length of domain in x direction. More...

double	Ly = 2.0
	Length of domain in y direction. More...

double	Box_half_width = 1.5
	(Half-)width of the box More...

double	Box_half_length = 1.0
	(Half)height of the box More...

std::string	Gmsh_command_line_invocation ="/home/mheil/gmesh/bin/bin/gmsh"
	Specify how to call gmsh from the command line. More...

double	Initial_element_volume =1.0

double	Pr = 0.73
	Prandtl number. More...

double	Pe = Re*Pr
	Peclet number. More...

double	Ra = 0.0
	Rayleigh number. More...

Vector< double >	G
	Gravity. More...

double	Sphere_centre_z = 0.0
	Location of the centre of the sphere on the axis. More...

unsigned	Nnode_1d =2
	The number of nodes in one direction (default=2) More...

unsigned	Min_refinement_level =2
	The minimum level of uniform refinement. More...

unsigned	Add_refinement_level =1
	The additional levels of uniform refinement. More...

unsigned	N_adaptations =1
	The number of adaptations allowed by the Newton solver. More...

unsigned	Use_adaptation_flag =0

unsigned	Pre_smoother_flag =0

unsigned	Post_smoother_flag =0

unsigned	Linear_solver_flag =1

unsigned	Output_management_flag =0

unsigned	Doc_convergence_flag =0

DocInfo	Doc_info
	DocInfo object used for documentation of the solution. More...

unsigned	Element_multiplier = 1

unsigned	N_x =10

unsigned	N_y =10

double	L_x =1.0

double	L_y =1.0

unsigned	Direction = 1

double	R_blend_inner =0.2
	Inner blending radius. More...

double	R_blend_outer =0.8
	Outer blending radius. More...

double	A_couette =1.0
	Amplitude of linearly varying part. More...

double	B_couette =1.0
	Amplitude of singular part. More...

Vector< double >	X_c_couette (2, 0.0)
	Random center for blended couette pseudo singularity. More...

unsigned	Long_run_flag =1
	Flag for long/short run: Default = perform long run. More...

unsigned	Impulsive_start_flag =0

double	Visc_Ratio = 2.0

double	Box_width = 3.0

double	Box_length = 10.0

double	Ca = 1.0
	Set the Capillary number. More...

double	Volume = -16.0atan(1.0)RadiusRadiusRadius/3.0

double	ReInvFr = 0.0
	The Reynolds INverse Froude number. More...

double	Element_area = 0.01
	helper to set target mesh element size More...

double	T_start = 0.0
	helpers to time the code More...

double	T_end = 0.0

unsigned	N_pml_multiplier = 1
	PML width in elements for the right layer. More...

double	L_pml_multiplier = 1.0

unsigned	N_x_right_pml = 8
	PML width in elements for the right layer. More...

unsigned	N_y_top_pml = 8
	PML width in elements for the top layer. More...

unsigned	N_x_left_pml = 8
	PML width in elements for the left layer. More...

unsigned	N_y_bottom_pml = 8
	PML width in elements for the left layer. More...

double	Width_x_right_pml = 2.0

double	Width_y_top_pml = 2.0

double	Width_x_left_pml = 2.0

double	Width_y_bottom_pml = 2.0

double	H_annulus =0.5
	Thickness of annulus. More...

std::complex< double >	lambda = ENu/(1.0+Nu)/(1.0-2.0Nu)

std::complex< double >	mu = E/2.0/(1.0+Nu)

double	rmin = 0.1

double	zmin = 0.3

double	rmax = rmin+Lr

double	zmax = zmin+Lz

double	Displacement_amplitude =0.1
	Displacement amplitude on inner radius. More...

unsigned	Ntheta =20
	Number of elements in azimuthal direction. More...

Vector< double >	Omega_sq_region (2, Omega_sq)
	Square of non-dim frequency for the two regions. More...

Detailed Description

Namespace for global parameters.

Namepspace for global parameters.

Namespace for problem parameters.

Namespace for physical parameters.

Global variables.

Global parameters.

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

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

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

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

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

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

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

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

Enumeration Type Documentation

◆ anonymous enum

anonymous enum

IDs for the two types of Lagrange multipliers used in this problem

Enumerator
Parallel_flow_lagrange_multiplier_id
FSI_interface_displacement_lagrange_multiplier_id

93 {Parallel_flow_lagrange_multiplier_id,

94 FSI_interface_displacement_lagrange_multiplier_id};

Global_Parameters::Parallel_flow_lagrange_multiplier_id

@ Parallel_flow_lagrange_multiplier_id

Definition: unsteady_vmtk_fsi.cc:93

Global_Parameters::FSI_interface_displacement_lagrange_multiplier_id

@ FSI_interface_displacement_lagrange_multiplier_id

Definition: unsteady_vmtk_fsi.cc:94

◆ anonymous enum

anonymous enum

IDs for the two types of Lagrange multipliers used in this problem

Enumerator
Parallel_flow_lagrange_multiplier_id
FSI_interface_displacement_lagrange_multiplier_id

180 {Parallel_flow_lagrange_multiplier_id,

181 FSI_interface_displacement_lagrange_multiplier_id};

Function Documentation

◆ analytic_solution1()

void Global_Parameters::analytic_solution1	(	const Vector< double > &	x,
		Vector< double > &	solution
	)

Function that computes the fitting solutions near the corner (0,0)

Polar coordinates centered at the point (0,0)

Value of the U component at the angle theta

Value of the V component at the angle theta

Value of P at the angle theta

  {
   using namespace MathematicalConstants;
  
   double r = sqrt(x[0]*x[0] + x[1]*x[1]);
   double theta = atan2(x[1],x[0]);
  
   solution[0] = -(0.5*Pi*theta*sin(theta) + theta*cos(theta) - 0.25*Pi*Pi*sin(theta))*sin(theta)/(-1.0 + 0.25*Pi*Pi) - 1.0*(-theta*sin(theta) + 0.5*Pi*theta*cos(theta) + 0.5*Pi*sin(theta) - 0.25*Pi*Pi*cos(theta) + cos(theta))*cos(theta)/(-1.0 + 0.25*Pi*Pi);
  
   solution[1] = (0.5*Pi*theta*sin(theta) + theta*cos(theta) - 0.25*Pi*Pi*sin(theta))*cos(theta)/(-1.0 + 0.25*Pi*Pi) - 1.0*(-theta*sin(theta) + 0.5*Pi*theta*cos(theta) + 0.5*Pi*sin(theta) - 0.25*Pi*Pi*cos(theta) + cos(theta))*sin(theta)/(-1.0 + 0.25*Pi*Pi);
  
   if (x[0]==0.0 && x[1]==0.0)
    {
     solution[2] = -200.0;
    }
   else
    {
     solution[2] = -(-0.25*Pi*Pi*Pi*sin(theta) + 1.0*Pi*sin(theta) - 0.5*Pi*Pi*cos(theta) + 2.0*cos(theta))/(r*(-0.0625*Pi*Pi*Pi*Pi - 1.0 + 0.5*Pi*Pi));
    }
  }

References atan2(), cos(), BiharmonicTestFunctions2::Pi, UniformPSDSelfTest::r, sin(), BiharmonicTestFunctions1::solution(), sqrt(), BiharmonicTestFunctions2::theta, and plotDoE::x.

◆ analytic_solution2()

void Global_Parameters::analytic_solution2	(	const Vector< double > &	x,
		Vector< double > &	solution
	)

Function that computes the fitting solutions near the corner (1,0)

Polar coordinates centered at the point (1,0)

Value of the U component at the angle theta

Value of the V component at the angle theta

Value of P at the angle theta

  {
   using namespace MathematicalConstants;
  
   // Variable change
   Vector<double> x1(2);
   x1[0] = 1.0-x[0];
   x1[1] = x[1];
  
   double r = sqrt(x1[0]*x1[0] + x1[1]*x1[1]);
   double theta = atan2(x1[1],x1[0]);
  
   solution[0] = (0.5*Pi*theta*sin(theta) + theta*cos(theta) - 0.25*Pi*Pi*sin(theta))*sin(theta)/(-1.0 + 0.25*Pi*Pi) + 1.0*(-theta*sin(theta) + 0.5*Pi*theta*cos(theta) + 0.5*Pi*sin(theta) - 0.25*Pi*Pi*cos(theta) + cos(theta))*cos(theta)/(-1.0 + 0.25*Pi*Pi);
   solution[0] = - solution[0];
  
   solution[1] = -(0.5*Pi*theta*sin(theta) + theta*cos(theta) - 0.25*Pi*Pi*sin(theta))*cos(theta)/(-1.0 + 0.25*Pi*Pi) + 1.0*(-theta*sin(theta) + 0.5*Pi*theta*cos(theta) + 0.5*Pi*sin(theta) - 0.25*Pi*Pi*cos(theta) + cos(theta))*sin(theta)/(-1.0 + 0.25*Pi*Pi);
  
   if (x1[0]==0.0 && x1[1]==0.0)
    {
     solution[2] = 200.0;
    }
   else
    {
     solution[2] = -(-1.0*Pi*sin(theta) + 0.25*Pi*Pi*Pi*sin(theta) - 2.0*cos(theta) + 0.5*Pi*Pi*cos(theta))/(r*(-0.0625*Pi*Pi*Pi*Pi - 1.0 + 0.5*Pi*Pi));
    }
  }

References atan2(), cos(), BiharmonicTestFunctions2::Pi, UniformPSDSelfTest::r, sin(), BiharmonicTestFunctions1::solution(), sqrt(), BiharmonicTestFunctions2::theta, plotDoE::x, and Global_parameters::x1().

◆ axisym_coefficient()

std::complex<double> Global_Parameters::axisym_coefficient ( )

Coefficient in front of Hankel function for axisymmetric solution of Helmholtz potential

  {
   std::complex<double> MapleGenVar1;
   std::complex<double> MapleGenVar2;
   std::complex<double> MapleGenVar3;
   std::complex<double> MapleGenVar4;
   std::complex<double> MapleGenVar5;
   std::complex<double> MapleGenVar6;
   std::complex<double> MapleGenVar7;
   std::complex<double> MapleGenVar8;
   std::complex<double> t0;
   
  
       MapleGenVar3 = (-2.0/(2.0+2.0*Nu)*1.0+2.0/(2.0+2.0*Nu)*1.0*
 H_coating)/(Nu/(1.0+Nu)/(1.0-2.0*Nu)+2.0/(2.0+2.0*Nu)-2.0/(2.0+2.0*Nu)*
 H_coating+1/(2.0+2.0*Nu)*H_coating*H_coating)/2.0;
       MapleGenVar5 = -1/(Nu/(1.0+Nu)/(1.0-2.0*Nu)+2.0/(2.0+2.0*Nu)-2.0/(2.0+2.0
 *Nu)*H_coating+1/(2.0+2.0*Nu)*H_coating*H_coating)*Q/2.0;
       MapleGenVar6 = HankelH1(0.0,sqrt(K_squared))*(-(-2.0/(2.0+2.0*Nu)*1.0
 +2.0/(2.0+2.0*Nu)*1.0*H_coating)/(Nu/(1.0+Nu)/(1.0-2.0*Nu)+2.0/(2.0+2.0*Nu)
 -2.0/(2.0+2.0*Nu)*H_coating+1/(2.0+2.0*Nu)*H_coating*H_coating)/2.0+(2.0/(2.0+
 2.0*Nu)*1.0-2.0/(2.0+2.0*Nu)*1.0*H_coating+2.0*1.0*Nu/(1.0+Nu)/(1.0
 -2.0*Nu)-2.0*1.0*H_coating*Nu/(1.0+Nu)/(1.0-2.0*Nu))/(Nu/(1.0+Nu)/(1.0-2.0*
 Nu)+2.0/(2.0+2.0*Nu)-2.0/(2.0+2.0*Nu)*H_coating+1/(2.0+2.0*Nu)*H_coating*
 H_coating)/2.0)/(HankelH1(1.0,sqrt(K_squared))*sqrt(K_squared)-Q*HankelH1(0.0,
 sqrt(K_squared))/(Nu/(1.0+Nu)/(1.0-2.0*Nu)+2.0/(2.0+2.0*Nu)-2.0/(2.0+2.0*Nu)*
 H_coating+1/(2.0+2.0*Nu)*H_coating*H_coating)/2.0+Q*HankelH1(0.0,sqrt(K_squared
 ))*(1.0-2.0*H_coating+H_coating*H_coating)/(Nu/(1.0+Nu)/(1.0-2.0*Nu)+2.0/(2.0+
 2.0*Nu)-2.0/(2.0+2.0*Nu)*H_coating+1/(2.0+2.0*Nu)*H_coating*H_coating)/2.0);
       MapleGenVar4 = MapleGenVar5*MapleGenVar6;
       MapleGenVar2 = MapleGenVar3+MapleGenVar4;
       MapleGenVar3 = MapleGenVar2;
       MapleGenVar5 = -(2.0/(2.0+2.0*Nu)*1.0-2.0/(2.0+2.0*Nu)*1.0*
 H_coating+2.0*1.0*Nu/(1.0+Nu)/(1.0-2.0*Nu)-2.0*1.0*H_coating*Nu/(1.0+Nu
 )/(1.0-2.0*Nu))/(Nu/(1.0+Nu)/(1.0-2.0*Nu)+2.0/(2.0+2.0*Nu)-2.0/(2.0+2.0*Nu)*
 H_coating+1/(2.0+2.0*Nu)*H_coating*H_coating)/2.0;
       MapleGenVar7 = (1.0-2.0*H_coating+H_coating*H_coating)/(Nu/(1.0+Nu)/(1.0
 -2.0*Nu)+2.0/(2.0+2.0*Nu)-2.0/(2.0+2.0*Nu)*H_coating+1/(2.0+2.0*Nu)*H_coating*
 H_coating)/2.0;
       MapleGenVar8 = Q*HankelH1(0.0,sqrt(K_squared))*(-(-2.0/(2.0+2.0*Nu)*
 1.0+2.0/(2.0+2.0*Nu)*1.0*H_coating)/(Nu/(1.0+Nu)/(1.0-2.0*Nu)+2.0/(2.0+
 2.0*Nu)-2.0/(2.0+2.0*Nu)*H_coating+1/(2.0+2.0*Nu)*H_coating*H_coating)/2.0+(2.0
 /(2.0+2.0*Nu)*1.0-2.0/(2.0+2.0*Nu)*1.0*H_coating+2.0*1.0*Nu/(1.0+Nu
 )/(1.0-2.0*Nu)-2.0*1.0*H_coating*Nu/(1.0+Nu)/(1.0-2.0*Nu))/(Nu/(1.0+Nu)/(
 1.0-2.0*Nu)+2.0/(2.0+2.0*Nu)-2.0/(2.0+2.0*Nu)*H_coating+1/(2.0+2.0*Nu)*
 H_coating*H_coating)/2.0)/(HankelH1(1.0,sqrt(K_squared))*sqrt(K_squared)-Q*
 HankelH1(0.0,sqrt(K_squared))/(Nu/(1.0+Nu)/(1.0-2.0*Nu)+2.0/(2.0+2.0*Nu)-2.0/(
 2.0+2.0*Nu)*H_coating+1/(2.0+2.0*Nu)*H_coating*H_coating)/2.0+Q*HankelH1(0.0,
 sqrt(K_squared))*(1.0-2.0*H_coating+H_coating*H_coating)/(Nu/(1.0+Nu)/(1.0-2.0*
 Nu)+2.0/(2.0+2.0*Nu)-2.0/(2.0+2.0*Nu)*H_coating+1/(2.0+2.0*Nu)*H_coating*
 H_coating)/2.0);
       MapleGenVar6 = MapleGenVar7*MapleGenVar8;
       MapleGenVar4 = MapleGenVar5+MapleGenVar6;
       MapleGenVar1 = MapleGenVar3+MapleGenVar4;
       MapleGenVar2 = 1.0/HankelH1(1.0,sqrt(K_squared))/sqrt(K_squared);
       t0 = MapleGenVar1*MapleGenVar2;
  
       return t0;
  }

References H_coating, HankelH1(), K_squared, Constitutive_Parameters::Nu, Q, and sqrt().

Referenced by exact_axisym_potential(), and exact_axisym_radiated_power().

◆ BesselJ()

double Global_Parameters::BesselJ	(	const double &	n,
		const double &	x
	)

Helper function to evaluate J_n(x) from bloody maple output.

  {
   
   // Bessel fcts J_0(x), J_1(x), Y_0(x), Y_1(x) and their derivatives
   double j0,j1,y0,y1,j0p,j1p,y0p,y1p;
   CRBond_Bessel::bessjy01a(x,j0,j1,y0,y1,j0p,j1p,y0p,y1p);
   
   if (n==0.0)
    {
     return j0;
    }
   else if (n==1.0)
    {
     return j1;
    }
   else
    {
     cout << "Never get here...";
     abort();
    }
  }

References CRBond_Bessel::bessjy01a(), n, and plotDoE::x.

◆ BesselY()

double Global_Parameters::BesselY	(	const double &	n,
		const double &	x
	)

Helper function to evaluate Y_n(x) from bloody maple output.

  {
   // Bessel fcts J_0(x), J_1(x), Y_0(x), Y_1(x) and their derivatives
   double j0,j1,y0,y1,j0p,j1p,y0p,y1p;
   CRBond_Bessel::bessjy01a(x,j0,j1,y0,y1,j0p,j1p,y0p,y1p);
   
   if (n==0.0)
    {
     return y0;
    }
   else if (n==1.0)
    {
     return y1;
    }
   else
    {
     cout << "Never get here...";
     abort();
    }
    
  }

References CRBond_Bessel::bessjy01a(), n, and plotDoE::x.

◆ blend()

double Global_Parameters::blend	(	const Vector< double > &	x,
		const Vector< double > &	x_c
	)

Blend function, centred at x_c.

  {
   // shifted origin
   double dx=x[0]-x_c[0];
   double dy=x[1]-x_c[1];
   double r=sqrt(dx*dx+dy*dy);
   double result=0.0;
   if (r<=R_blend_inner)
    {
     result=1.0;
    }
   else if (r<=R_blend_outer)
    {
     result=0.5*(1.0+cos(MathematicalConstants::Pi*
                         (r-R_blend_inner)/(R_blend_outer-R_blend_inner)));
    }
   return result;
  }

References cos(), BiharmonicTestFunctions2::Pi, UniformPSDSelfTest::r, R_blend_inner, R_blend_outer, sqrt(), and plotDoE::x.

Referenced by blended_grad_velocity_pseudo_singularity_for_couette(), blended_pressure_pseudo_singularity_for_couette(), blended_velocity_pseudo_singularity_for_couette(), and packetmath().

◆ blended_grad_velocity_pseudo_singularity_for_couette()

Vector<Vector<double> > Global_Parameters::blended_grad_velocity_pseudo_singularity_for_couette ( const Vector< double > & x )

Blended Pseudo_singularity for computation of Couette flow: grad[i][j] = du_i/dx_j

  {
   // unblended velocity
   Vector<double> u=velocity_pseudo_singularity_for_couette(x);
   Vector<Vector<double> > grad_u=
    grad_velocity_pseudo_singularity_for_couette(x);
  
   Vector<Vector<double> > blended_grad_u(2);
   for (unsigned d=0;d<2;d++)
    {
     blended_grad_u[d].resize(2);
    }
  
   // Now blend
   double b=blend(x,X_c_couette);
   Vector<double> grad_b=grad_blend(x,X_c_couette);
   for (unsigned i=0;i<2;i++)
    {
      for (unsigned j=0;j<2;j++)
       {
        blended_grad_u[i][j]=grad_u[i][j]*b+u[i]*grad_b[j];
       }
    }
  
   return blended_grad_u;
  }

References b, blend(), grad_blend(), grad_velocity_pseudo_singularity_for_couette(), i, j, velocity_pseudo_singularity_for_couette(), plotDoE::x, and X_c_couette.

Referenced by main().

◆ blended_pressure_pseudo_singularity_for_couette()

double Global_Parameters::blended_pressure_pseudo_singularity_for_couette ( const Vector< double > & x )

Blended Pseudo_singularity for computation of Couette flow.

  {
   double p=pressure_pseudo_singularity_for_couette(x);
  
   // Now blend
   double b=blend(x,X_c_couette);
  
   return b*p;
  }

References b, blend(), p, pressure_pseudo_singularity_for_couette(), plotDoE::x, and X_c_couette.

◆ blended_velocity_pseudo_singularity_for_couette()

Vector<double> Global_Parameters::blended_velocity_pseudo_singularity_for_couette ( const Vector< double > & x )

Blended Pseudo_singularity for computation of Couette flow.

  {
   // Initialise velocity vector to return
   Vector<double> u=velocity_pseudo_singularity_for_couette(x);
  
   // Now blend
   double b=blend(x,X_c_couette);
   for (unsigned i=0;i<2;i++)
    {
     u[i]*=b;
    }
   return u;
  }

References b, blend(), i, velocity_pseudo_singularity_for_couette(), plotDoE::x, and X_c_couette.

Referenced by main().

◆ body_force() [1/2]

void Global_Parameters::body_force	(	const double &	time,
		const Vector< double > &	x,
		Vector< double > &	result
	)

The body force function; returns vector of doubles in the order (b_r, b_z, b_theta)

  {
   result[0] = cos(time)*(
    x[0]*(-cos(x[1])*
          (Lambda*(8.0+3.0*x[0])-
           Mu*(-16.0+x[0]*(x[0]-3.0))+pow(x[0],2)*Omega_sq)));
   result[1] = cos(time)*(
    x[0]*sin(x[1])*(Mu*(-9.0)+
                    4.0*x[0]*(Lambda+Mu)+pow(x[0],2)*
                    (Lambda+2.0*Mu-Omega_sq)));
   result[2] = cos(time)*(
    -x[0]*(8.0*Mu*pow(x[1],3)+pow(x[0],2)*(pow(x[1],3)*Omega_sq+6.0*Mu*x[1])));
  } // end of body force

References cos(), Lambda, Mu, Omega_sq, Eigen::bfloat16_impl::pow(), sin(), and plotDoE::x.

◆ body_force() [2/2]

void Global_Parameters::body_force	(	const Vector< double > &	x,
		Vector< std::complex< double > > &	result
	)

Body force.

The body force function; returns vector of complex doubles in the order (b_r, b_z, b_theta)

Define the magnitude of the forcing

Define the decay rate

The forcing used is of damped exponential type to generate axisymmetric results after post-processing

Assign the source in each dimension

  {
   double magnitude=1.0;
  
   double alpha=1.0;
  
   double source_fct=magnitude*exp(-alpha*sqrt(x[0]*x[0]+x[1]*x[1]));
  
   b[0]=source_fct*x[0]/sqrt(x[0]*x[0]+x[1]*x[1]);
   b[1]=source_fct*x[1]/sqrt(x[0]*x[0]+x[1]*x[1]);
  }

References alpha, b, Eigen::bfloat16_impl::exp(), oomph::VectorHelpers::magnitude(), sqrt(), and plotDoE::x.

◆ boundary_traction() [1/2]

void Global_Parameters::boundary_traction	(	const double &	time,
		const Vector< double > &	x,
		const Vector< double > &	n,
		Vector< double > &	result
	)

The traction function at r=Rmin: (t_r, t_z, t_theta)

  {
   result[0] = cos(time)*(-6.0*pow(x[0],2)*Mu*cos(x[1])-
    Lambda*(4.0*pow(x[0],2)+pow(x[0],3))*cos(x[1]));
   result[1] = cos(time)*(-Mu*(3.0*pow(x[0],2)-pow(x[0],3))*sin(x[1]));
   result[2] = cos(time)*(-Mu*pow(x[0],2)*(2*pow(x[1],3)));
  }

References cos(), Lambda, Mu, Eigen::bfloat16_impl::pow(), sin(), and plotDoE::x.

Referenced by AxisymmetricLinearElasticityProblem< ELEMENT, TIMESTEPPER >::AxisymmetricLinearElasticityProblem(), FourierDecomposedTimeHarmonicLinearElasticityProblem< ELEMENT >::complete_problem_setup(), and FourierDecomposedTimeHarmonicLinearElasticityProblem< ELEMENT >::FourierDecomposedTimeHarmonicLinearElasticityProblem().

◆ boundary_traction() [2/2]

void Global_Parameters::boundary_traction	(	const Vector< double > &	x,
		const Vector< double > &	n,
		Vector< std::complex< double > > &	result
	)

The traction function at r=rmin: (t_r, t_z, t_theta)

  {
   result[0] = -6.0*pow(x[0],2)*mu*cos(x[1])-
    lambda*(I*double(Fourier_wavenumber)*pow(x[0],2)*pow(x[1],3)+
            (4.0*pow(x[0],2)+pow(x[0],3))*cos(x[1]));
   result[1] = -mu*(3.0*pow(x[0],2)-pow(x[0],3))*sin(x[1]);
   result[2] = -mu*pow(x[0],2)*(2*pow(x[1],3)+I*double(Fourier_wavenumber)*
                                cos(x[1]));
  }

References cos(), Fourier_wavenumber, I, lambda, mu, Eigen::bfloat16_impl::pow(), sin(), and plotDoE::x.

◆ compute_dependent_parameters()

void Global_Parameters::compute_dependent_parameters ( )

Function to compute dependent parameters.

Adjust number of PML elements, set to be equal for all layers

Adjust physical size of PML layers, set to be equal for all layers

Adjust number of PML elements, set to be equal for all layers

Adjust physical size of PML layers, set to be equal for all layers

Adjust number of PML elements, set to be equal for all layers

Adjust physical size of PML layers, set to be equal for all layers

  {
   N_x_right_pml  = N_x_right_pml  * N_pml_multiplier;
   N_x_left_pml   = N_x_left_pml   * N_pml_multiplier;
   N_y_top_pml    = N_y_top_pml    * N_pml_multiplier;
   N_y_bottom_pml = N_y_bottom_pml * N_pml_multiplier;
  
   Width_x_right_pml  = Width_x_right_pml  * L_pml_multiplier;
   Width_x_left_pml   = Width_x_left_pml   * L_pml_multiplier;
   Width_y_top_pml    = Width_y_top_pml    * L_pml_multiplier;
   Width_y_bottom_pml = Width_y_bottom_pml * L_pml_multiplier;
  }

References L_pml_multiplier, N_pml_multiplier, N_x_left_pml, N_x_right_pml, N_y_bottom_pml, N_y_top_pml, Width_x_left_pml, Width_x_right_pml, Width_y_bottom_pml, and Width_y_top_pml.

Referenced by main().

◆ constant_pressure() [1/2]

void Global_Parameters::constant_pressure	(	const Vector< double > &	x,
		const Vector< double > &	n,
		Vector< std::complex< double > > &	traction
	)

Constant pressure load (real and imag part)

  {
   unsigned dim = traction.size();
   for(unsigned i=0;i<dim;i++)
    {
     traction[i] = complex<double>(-P*n[i],P*n[i]);
    }
  } // end_of_pressure_load

References i, n, and Global_Physical_Variables::P.

◆ constant_pressure() [2/2]

void Global_Parameters::constant_pressure	(	const Vector< double > &	xi,
		const Vector< double > &	x,
		const Vector< double > &	n,
		Vector< double > &	traction
	)

Constant pressure load. The arguments to this function are imposed on us by the SolidTractionElements which allow the traction to depend on the Lagrangian and Eulerian coordinates x and xi, and on the outer unit normal to the surface. Here we only need the outer unit normal.

  {
   unsigned dim = traction.size();
   for(unsigned i=0;i<dim;i++)
    {
     traction[i] = -P*n[i];
    }
  } // end traction

References i, n, and Global_Physical_Variables::P.

Referenced by UnstructuredSolidProblem< ELEMENT, MESH >::create_traction_elements(), and AnnularDiskProblem< ELASTICITY_ELEMENT >::create_traction_elements().

◆ d2_u_r_dt2()

double Global_Parameters::d2_u_r_dt2	(	const double &	time,
		const Vector< double > &	x
	)

Calculate the time dependent form of the r-component of acceleration.

   {
    Vector<double> displ(3);
    exact_solution_th(x,displ);
    return -cos(time)*displ[0];
   }

References cos(), exact_solution_th(), and plotDoE::x.

Referenced by exact_solution(), AxisymmetricLinearElasticityProblem< ELEMENT, TIMESTEPPER >::set_boundary_conditions(), and AxisymmetricLinearElasticityProblem< ELEMENT, TIMESTEPPER >::set_initial_conditions().

◆ d2_u_theta_dt2()

double Global_Parameters::d2_u_theta_dt2	(	const double &	time,
		const Vector< double > &	x
	)

Calculate the time dependent form of the theta-component of acceleration.

   {
    Vector<double> displ(3);
    exact_solution_th(x,displ);
    return -cos(time)*displ[2];
   }

References cos(), exact_solution_th(), and plotDoE::x.

Referenced by exact_solution(), AxisymmetricLinearElasticityProblem< ELEMENT, TIMESTEPPER >::set_boundary_conditions(), and AxisymmetricLinearElasticityProblem< ELEMENT, TIMESTEPPER >::set_initial_conditions().

◆ d2_u_z_dt2()

double Global_Parameters::d2_u_z_dt2	(	const double &	time,
		const Vector< double > &	x
	)

Calculate the time dependent form of the z-component of acceleration.

   {
    Vector<double> displ(3);
    exact_solution_th(x,displ);
    return -cos(time)*displ[1];
   }

References cos(), exact_solution_th(), and plotDoE::x.

Referenced by exact_solution(), AxisymmetricLinearElasticityProblem< ELEMENT, TIMESTEPPER >::set_boundary_conditions(), and AxisymmetricLinearElasticityProblem< ELEMENT, TIMESTEPPER >::set_initial_conditions().

◆ d_u_r_dt()

double Global_Parameters::d_u_r_dt	(	const double &	time,
		const Vector< double > &	x
	)

Calculate the time dependent form of the r-component of velocity.

   {
    Vector<double> displ(3);
    exact_solution_th(x,displ);
    return -sin(time)*displ[0];
   }

References exact_solution_th(), sin(), and plotDoE::x.

Referenced by exact_solution(), AxisymmetricLinearElasticityProblem< ELEMENT, TIMESTEPPER >::set_boundary_conditions(), and AxisymmetricLinearElasticityProblem< ELEMENT, TIMESTEPPER >::set_initial_conditions().

◆ d_u_theta_dt()

double Global_Parameters::d_u_theta_dt	(	const double &	time,
		const Vector< double > &	x
	)

Calculate the time dependent form of the theta-component of velocity.

   {
    Vector<double> displ(3);
    exact_solution_th(x,displ);
    return -sin(time)*displ[2];
   }

References exact_solution_th(), sin(), and plotDoE::x.

Referenced by exact_solution(), AxisymmetricLinearElasticityProblem< ELEMENT, TIMESTEPPER >::set_boundary_conditions(), and AxisymmetricLinearElasticityProblem< ELEMENT, TIMESTEPPER >::set_initial_conditions().

◆ d_u_z_dt()

double Global_Parameters::d_u_z_dt	(	const double &	time,
		const Vector< double > &	x
	)

Calculate the time dependent form of the z-component of velocity.

   {
    Vector<double> displ(3);
    exact_solution_th(x,displ);
    return -sin(time)*displ[1];
   }

References exact_solution_th(), sin(), and plotDoE::x.

Referenced by exact_solution(), AxisymmetricLinearElasticityProblem< ELEMENT, TIMESTEPPER >::set_boundary_conditions(), and AxisymmetricLinearElasticityProblem< ELEMENT, TIMESTEPPER >::set_initial_conditions().

◆ Density_ratio() [1/2]

Vector<double> Global_Parameters::Density_ratio	(	2	,
		0.	1
	)

Density ratio for the two regions: solid to fluid.

◆ Density_ratio() [2/2]

Vector<double> Global_Parameters::Density_ratio	(	2	,
		1.	0
	)

Density ratio: solid to fluid.

◆ E() [1/3]

std::complex<double> Global_Parameters::E	(	1.	0,
		0.	01
	)

Define the non-dimensional Young's modulus.

◆ E() [2/3]

Vector<std::complex<double> > Global_Parameters::E	(	2	,
		std::complex< double >	1.0, 0.0
	)

Define the non-dimensional Young's modulus.

◆ E() [3/3]

TimeHarmonicIsotropicElasticityTensor Global_Parameters::E ( Nu )

The elasticity tensor for the solid.

The elasticity tensor.

◆ Eigenfunction_normalisation()

std::complex<double> Global_Parameters::Eigenfunction_normalisation	(	1.	0,
		0.	0
	)

Referenced by FlowAroundCylinderProblem< ELEMENT >::add_eigenproblem().

◆ exact_axisym_potential()

void Global_Parameters::exact_axisym_potential	(	const Vector< double > &	x,
		Vector< double > &	soln
	)

Exact solution for Helmholtz potential for axisymmetric solution.

  {
   std::complex<double> C=axisym_coefficient();
   double r=sqrt(x[0]*x[0]+x[1]*x[1]);
   soln[0]=real(HankelH1(0,sqrt(K_squared)*r)*C);
   soln[1]=imag(HankelH1(0,sqrt(K_squared)*r)*C);
  }

References axisym_coefficient(), HankelH1(), imag(), K_squared, UniformPSDSelfTest::r, sqrt(), and plotDoE::x.

Referenced by CoatedDiskProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::doc_solution().

◆ exact_axisym_radiated_power()

double Global_Parameters::exact_axisym_radiated_power ( )

Exact radiated power for axisymmetric solution.

  {
   // Solution is independent of where it's evaluated (have checked!)
   double r=1.0;
  
   // Get the coefficient for the axisymmetric potential
   std::complex<double> C=axisym_coefficient();
   
   // Argument for Bessel/Hankel functions
   double rr=sqrt(K_squared)*r;  
   
   // Evaluate Hankel functions -- only need zero-th term
   Vector<std::complex<double> > h(2),hp(2);
   Hankel_functions_for_helmholtz_problem::Hankel_first(1,rr,h,hp);
   
   // Compute time-average radiated power
   double power=sqrt(K_squared)*0.5*r*2.0*MathematicalConstants::Pi*
    (imag(C*hp[0])*real(C*h[0])-real(C*hp[0])*imag(C*h[0]));       
  
   return power;
  }

References axisym_coefficient(), Hankel_first(), imag(), K_squared, BiharmonicTestFunctions2::Pi, UniformPSDSelfTest::r, and sqrt().

Referenced by CoatedDiskProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::doc_solution().

◆ exact_couette()

void Global_Parameters::exact_couette	(	const Vector< double > &	x,
		Vector< double > &	soln
	)

Combined exact solution (u,v,p)

  {
   soln=velocity_couette(x);
   soln.resize(3);
   soln[2]=pressure_couette(x);            
  }

References pressure_couette(), velocity_couette(), and plotDoE::x.

◆ exact_solution() [1/2]

void Global_Parameters::exact_solution	(	const double &	time,
		const Vector< double > &	x,
		Vector< double > &	u
	)

The exact solution in a vector: 0: u_r, 1: u_z, 2: u_theta and their 1st and 2nd derivs

  {
   u[0]=u_r(time,x);
   u[1]=u_z(time,x);
   u[2]=u_theta(time,x);
  
   u[3]=d_u_r_dt(time,x);
   u[4]=d_u_z_dt(time,x);
   u[5]=d_u_theta_dt(time,x);
  
   u[6]=d2_u_r_dt2(time,x);
   u[7]=d2_u_z_dt2(time,x);
   u[8]=d2_u_theta_dt2(time,x);
  } // end_of_exact_solution

References d2_u_r_dt2(), d2_u_theta_dt2(), d2_u_z_dt2(), d_u_r_dt(), d_u_theta_dt(), d_u_z_dt(), u_r(), u_theta(), u_z(), and plotDoE::x.

Referenced by cod(), cod_fixedsize(), AxisymmetricLinearElasticityProblem< ELEMENT, TIMESTEPPER >::doc_solution(), PeriodicLoadProblem< ELEMENT >::doc_solution(), RefineablePeriodicLoadProblem< ELEMENT >::doc_solution(), FourierDecomposedTimeHarmonicLinearElasticityProblem< ELEMENT >::doc_solution(), FourierDecomposedTimeHarmonicLinearElasticityProblem< ELEMENT >::FourierDecomposedTimeHarmonicLinearElasticityProblem(), oomph::MyProblem::get_error_norm(), PeriodicLoadProblem< ELEMENT >::PeriodicLoadProblem(), RefineablePeriodicLoadProblem< ELEMENT >::RefineablePeriodicLoadProblem(), and AxisymmetricLinearElasticityProblem< ELEMENT, TIMESTEPPER >::set_boundary_conditions().

◆ exact_solution() [2/2]

void Global_Parameters::exact_solution	(	const Vector< double > &	x,
		Vector< double > &	u
	)

The exact solution for infinite depth case.

The exact solution in a flat-packed vector:

  {
   u[0] = -Amplitude*cos(2.0*MathematicalConstants::Pi*x[0]/Lx)*
     exp(2.0*MathematicalConstants::Pi*(x[1]-Ly))/
         (2.0/(1.0+Nu)*MathematicalConstants::Pi);
   u[1] = -Amplitude*sin(2.0*MathematicalConstants::Pi*x[0]/Lx)*
     exp(2.0*MathematicalConstants::Pi*(x[1]-Ly))/
         (2.0/(1.0+Nu)*MathematicalConstants::Pi);
  }

References Amplitude, cos(), Eigen::bfloat16_impl::exp(), Lx, Ly, Constitutive_Parameters::Nu, BiharmonicTestFunctions2::Pi, sin(), and plotDoE::x.

◆ exact_solution_th()

void Global_Parameters::exact_solution_th	(	const Vector< double > &	x,
		Vector< double > &	u
	)

Helper function - spatial components of the exact solution in a vector. This is necessary because we need to multiply this by different things to obtain the velocity and acceleration 0: u_r, 1: u_z, 2: u_theta

  {
   u[0] = pow(x[0],3)*cos(x[1]);
   u[1] = pow(x[0],3)*sin(x[1]);
   u[2] = pow(x[0],3)*pow(x[1],3);
  }

References cos(), Eigen::bfloat16_impl::pow(), sin(), and plotDoE::x.

Referenced by d2_u_r_dt2(), d2_u_theta_dt2(), d2_u_z_dt2(), d_u_r_dt(), d_u_theta_dt(), d_u_z_dt(), u_r(), u_theta(), and u_z().

◆ exact_u()

void Global_Parameters::exact_u	(	const Vector< double > &	x,
		Vector< double > &	u
	)

Exact solution as a Vector: {u_x_real, u_y_real, u_x_imag, u_y_imag}.

Exact solution as a Vector.

  {
   double r=sqrt(x[0]*x[0]+x[1]*x[1]);
  
   // Non-dim Lame parameters
   double lambda=Nu/((1.0+Nu)*(1-2.0*Nu));
   double mu=1.0/(2.0*(1.0+Nu));
   
   // Initialize solutions
   double u_r_real = 0.0;
   double u_r_imag = 0.0;
   double u_phi_real = 0.0;
   double u_phi_imag = 0.0;
  
   // Solution 1: Pressure wave in radial direction
   {
    // Effective wavenumber for pressure waves
    double k=sqrt(Omega_sq/(lambda+2.0*mu));
  
    // Argument for hankel function
    double kr=k*r;
  
    // Fourier wavenumber
    unsigned n_fourier=0;
  
    // Storage for Hankel functions
    Vector<std::complex<double> > h(n_fourier+2);
  
    // Storage for derivs of Hankel fcts
    Vector<std::complex<double> > hp(n_fourier+2);
  
    // Get Hankel fcts
    Hankel_first(n_fourier+2,kr,h,hp);
  
    // Radial displacement
    u_r_real=h[1].real();
    u_r_imag=h[1].imag();
  }
  
   // Solution 2: shear wave in azimuthal direction
   {
    // Effective wavenumber for pressure waves
    double k=sqrt(Omega_sq/mu);
  
    // Argument for hankel function
    double kr=k*r;
  
    // Fourier wavenumber
    unsigned n_fourier=0;
  
    // Storage for Hankel functions
    Vector<std::complex<double> > h(n_fourier+2);
  
    // Storage for derivs of Hankel fcts
    Vector<std::complex<double> > hp(n_fourier+2);
  
    // Get Hankel fcts
    Hankel_first(n_fourier+2,kr,h,hp);
  
    // Radial displacement
    u_phi_real=h[1].real();
    u_phi_imag=h[1].imag();
  }
   
   // switch of type 1 solutions
   double sol1_switch = 1.0;
  
   // switch of type 2 solutions
   double sol2_switch = 1.0;
  
   // Real part of x displacement
   u[0]=sol1_switch*u_r_real*x[0]/r-sol2_switch*u_phi_real*x[1]/r;
  
   // Real part of y displacement
   u[1]=sol1_switch*u_r_real*x[1]/r+sol2_switch*u_phi_real*x[0]/r;
  
   // Imag part of x displacement
   u[2]=sol1_switch*u_r_imag*x[0]/r-sol2_switch*u_phi_imag*x[1]/r;
  
   // Imag part of y displacement
   u[3]=sol1_switch*u_r_imag*x[1]/r+sol2_switch*u_phi_imag*x[0]/r; 
  
  }

References Hankel_first(), k, lambda, mu, Constitutive_Parameters::Nu, Omega_sq, UniformPSDSelfTest::r, sqrt(), and plotDoE::x.

Referenced by ElasticAnnulusProblem< ELASTICITY_ELEMENT >::complete_problem_setup(), AnnularDiskProblem< ELASTICITY_ELEMENT >::doc_solution(), and ElasticAnnulusProblem< ELASTICITY_ELEMENT >::doc_solution().

◆ flux()

double Global_Parameters::flux ( const double & t )

Flux: Pulsatile flow.

Flux increases between Min_flux and Max_flux over period Ramp_period

  {  
   return U_base+U_perturbation*cos(2.0*MathematicalConstants::Pi*t/T);
  }

References cos(), BiharmonicTestFunctions2::Pi, plotPSD::t, U_base, and U_perturbation.

Referenced by FSIChannelWithLeafletProblem< ELEMENT >::actions_before_implicit_timestep(), TurekProblem< FLUID_ELEMENT, SOLID_ELEMENT >::actions_before_implicit_timestep(), TurekProblem< FLUID_ELEMENT, SOLID_ELEMENT >::build_mesh(), TurekProblem< FLUID_ELEMENT, SOLID_ELEMENT >::doc_solution(), and TurekProblem< FLUID_ELEMENT, SOLID_ELEMENT >::TurekProblem().

◆ G()

Vector<double> Global_Parameters::G ( 3 )

Gravity.

◆ grad_blend()

Vector<double> Global_Parameters::grad_blend	(	const Vector< double > &	x,
		const Vector< double > &	x_c
	)

Gradient of blend function, centred at x_c.

  {
   // shifted origin
   double dx=x[0]-x_c[0];
   double dy=x[1]-x_c[1];
   double r=sqrt(dx*dx+dy*dy);
   Vector<double> result(2,0.0);
   if ((r>R_blend_inner)&&(r<R_blend_outer))
    {
     result[0] = -sin(MathematicalConstants::Pi*
                      (sqrt(dx*dx+dy*dy)-R_blend_inner)/(
                       R_blend_outer-R_blend_inner))*
      MathematicalConstants::Pi/sqrt(dx*dx+dy*dy)*dx/(
       R_blend_outer-R_blend_inner)/2.0;
  
     result[1] = -sin(MathematicalConstants::Pi*
                       (sqrt(dx*dx+dy*dy)-R_blend_inner)/(
                        R_blend_outer-R_blend_inner))*
      MathematicalConstants::Pi/sqrt(dx*dx+dy*dy)*dy/(
       R_blend_outer-R_blend_inner)/2.0;
    }
   return result;
  }

References BiharmonicTestFunctions2::Pi, UniformPSDSelfTest::r, R_blend_inner, R_blend_outer, sin(), sqrt(), and plotDoE::x.

Referenced by blended_grad_velocity_pseudo_singularity_for_couette().

◆ grad_pressure_singularity1()

Vector<double> Global_Parameters::grad_pressure_singularity1 ( const Vector< double > & coord )

Function that computes the gradient of the fitting pressure solution near the corner (0,0)

  {
   using namespace MathematicalConstants;
  
   // Cartesian coordinates
   double x = coord[0];
   double y = coord[1];
   
   // Initialise the gradient vector
   Vector<double> grad_p(2,0.0);
  
   // Value of \frac{\partial p}{\partial x}
   grad_p[0] = -x*(-0.5*Pi*Pi*x/sqrt(x*x + y*y) + 2.0*x/sqrt(x*x + y*y)
                   - 0.25*Pi*Pi*Pi*y/sqrt(x*x + y*y) + 1.0*Pi*y/sqrt(x*x + y*y))
    /((x*x + y*y)*sqrt(x*x + y*y)*(-0.0625*Pi*Pi*Pi*Pi - 1.0 + 0.5*Pi*Pi))
    + (-2.0*x*x/(x*x + y*y)*sqrt(x*x + y*y) + 0.5*Pi*Pi*x*x/(x*x + y*y)
       *sqrt(x*x + y*y) - 1.0*Pi*x*y/(x*x + y*y)*sqrt(x*x + y*y) + 0.25*Pi
       *Pi*Pi*x*y/(x*x + y*y)*sqrt(x*x + y*y) - 0.5*Pi*Pi/sqrt(x*x + y*y)
       + 2.0/sqrt(x*x + y*y))
    /(sqrt(x*x + y*y)*(-0.0625*Pi*Pi*Pi*Pi - 1.0 + 0.5*Pi*Pi));
  
   // Value of \frac{\partial p}{\partial y}
   grad_p[1] = -y*(-0.5*Pi*Pi*x/sqrt(x*x + y*y) + 2.0*x/sqrt(x*x + y*y)
                   - 0.25*Pi*Pi*Pi*y/sqrt(x*x + y*y) + 1.0*Pi*y/sqrt(x*x + y*y))
    /((x*x + y*y)*sqrt(x*x + y*y)*(-0.0625*Pi*Pi*Pi*Pi - 1.0 + 0.5*Pi*Pi))
    + (-2.0*x*y/(x*x + y*y)*sqrt(x*x + y*y) + 0.5*Pi*Pi*x*y/(x*x + y*y)
       *sqrt(x*x + y*y) - 1.0*Pi*y*y/(x*x + y*y)*sqrt(x*x + y*y) + 0.25*Pi
       *Pi*Pi*y*y/(x*x + y*y)*sqrt(x*x + y*y) - 0.25*Pi*Pi*Pi
       /sqrt(x*x + y*y) + 1.0*Pi/sqrt(x*x + y*y))
    /(sqrt(x*x + y*y)*(-0.0625*Pi*Pi*Pi*Pi - 1.0 + 0.5*Pi*Pi));
  
   return grad_p;
   
  } // End of function

References BiharmonicTestFunctions2::Pi, sqrt(), plotDoE::x, and y.

◆ grad_velocity_pseudo_singularity_for_couette()

Vector<Vector<double> > Global_Parameters::grad_velocity_pseudo_singularity_for_couette ( const Vector< double > & x )

Pseudo_singularity for computation of Couette flow: grad[i][j] = du_i/dx_j.

  {
   // Initialise grad matrix
   Vector<Vector<double> > grad_u(2);
   for (unsigned d=0;d<2;d++)
    {
     grad_u[d].resize(2);
     for (unsigned k=0;k<2;k++)
      {
       grad_u[d][k] = 0.0;
      }
    }
  
   // Compute \frac{\partial u}{\partial x} 
   grad_u[0][0] = 0.0;
  
   // Compute \frac{\partial u}{\partial y}
   grad_u[0][1] = 0.0; // 1.0-2.0*x[1];
  
   // Compute \frac{\partial v}{\partial x}
   grad_u[1][0] = 1.0-2.0*x[0]; // 0.0;
  
   // Compute \frac{\partial v}{\partial y}
   grad_u[1][1] = 0.0;
  
   return grad_u;
  }

References k, and plotDoE::x.

Referenced by blended_grad_velocity_pseudo_singularity_for_couette().

◆ grad_velocity_singularity1()

Vector<Vector<double> > Global_Parameters::grad_velocity_singularity1 ( const Vector< double > & coord )

Function that computes the gradient of the fitting velocity solution near the corner (0,0): grad[i][j] = du_i/dx_j

  {  
   using namespace MathematicalConstants;
  
   // Initialise the gradient matrix to return
   Vector<Vector<double> > grad_u(2);
   for (unsigned d=0;d<2;d++)
    {
     grad_u[d].resize(2);
     for (unsigned k=0;k<2;k++)
      {
       grad_u[d][k] = 0.0;
      }
    }
  
   // Cartesian coordinates
   double x = coord[0];
   double y = coord[1];
  
   // Value of \frac{\partial u}{\partial x}
   grad_u[0][0] = pow(x, 2)*(0.5*Pi*x*atan2(y, x)/sqrt(pow(x, 2) + pow(y, 2)) - 0.25*pow(Pi, 2)*x/sqrt(pow(x, 2) + pow(y, 2)) + 1.0*x/sqrt(pow(x, 2) + pow(y, 2)) - 1.0*y*atan2(y, x)/sqrt(pow(x, 2) + pow(y, 2)) + 0.5*Pi*y/sqrt(pow(x, 2) + pow(y, 2)))/((-1 + 0.25*pow(Pi, 2))*pow(pow(x, 2) + pow(y, 2), 3.0L/2.0L)) - x*y*(-x*atan2(y, x)/sqrt(pow(x, 2) + pow(y, 2)) - 0.5*Pi*y*atan2(y, x)/sqrt(pow(x, 2) + pow(y, 2)) + 0.25*pow(Pi, 2)*y/sqrt(pow(x, 2) + pow(y, 2)))/((-1 + 0.25*pow(Pi, 2))*pow(pow(x, 2) + pow(y, 2), 3.0L/2.0L)) - x*(-0.5*Pi*pow(x, 2)*atan2(y, x)/pow(pow(x, 2) + pow(y, 2), 3.0L/2.0L) - 1.0*pow(x, 2)/pow(pow(x, 2) + pow(y, 2), 3.0L/2.0L) + 0.25*pow(Pi, 2)*pow(x, 2)/pow(pow(x, 2) + pow(y, 2), 3.0L/2.0L) + 1.0*x*y*atan2(y, x)/pow(pow(x, 2) + pow(y, 2), 3.0L/2.0L) - 1.0*Pi*x*y/pow(pow(x, 2) + pow(y, 2), 3.0L/2.0L) + 1.0*pow(y, 2)/pow(pow(x, 2) + pow(y, 2), 3.0L/2.0L) + 0.5*Pi*atan2(y, x)/sqrt(pow(x, 2) + pow(y, 2)) - 0.25*pow(Pi, 2)/sqrt(pow(x, 2) + pow(y, 2)) + 1.0/sqrt(pow(x, 2) + pow(y, 2)))/((-1 + 0.25*pow(Pi, 2))*sqrt(pow(x, 2) + pow(y, 2))) + y*(pow(x, 2)*atan2(y, x)/pow(pow(x, 2) + pow(y, 2), 3.0L/2.0L) + 0.5*Pi*x*y*atan2(y, x)/pow(pow(x, 2) + pow(y, 2), 3.0L/2.0L) - 0.25*pow(Pi, 2)*x*y/pow(pow(x, 2) + pow(y, 2), 3.0L/2.0L) + x*y/pow(pow(x, 2) + pow(y, 2), 3.0L/2.0L) + 0.5*Pi*pow(y, 2)/pow(pow(x, 2) + pow(y, 2), 3.0L/2.0L) - atan2(y, x)/sqrt(pow(x, 2) + pow(y, 2)))/((-1 + 0.25*pow(Pi, 2))*sqrt(pow(x, 2) + pow(y, 2))) - (0.5*Pi*x*atan2(y, x)/sqrt(pow(x, 2) + pow(y, 2)) - 0.25*pow(Pi, 2)*x/sqrt(pow(x, 2) + pow(y, 2)) + 1.0*x/sqrt(pow(x, 2) + pow(y, 2)) - 1.0*y*atan2(y, x)/sqrt(pow(x, 2) + pow(y, 2)) + 0.5*Pi*y/sqrt(pow(x, 2) + pow(y, 2)))/((-1 + 0.25*pow(Pi, 2))*sqrt(pow(x, 2) + pow(y, 2)));
  
   // Value of \frac{\partial u}{\partial y}
   grad_u[0][1] = x*y*(0.5*Pi  *x*atan2(y, x)/sqrt(pow(x, 2) + pow(y, 2)) - 0.25*pow(Pi  , 2)*x/sqrt(pow(x, 2) + pow(y, 2)) + 1.0*x/sqrt(pow(x, 2) + pow(y, 2)) - 1.0*y*atan2(y, x)/sqrt(pow(x, 2) + pow(y, 2)) + 0.5*Pi  *y/sqrt(pow(x, 2) + pow(y, 2)))/((-1 + 0.25*pow(Pi  , 2))*pow(pow(x, 2) + pow(y, 2), 3.0L/2.0L)) - x*(0.5*Pi  *pow(x, 2)/pow(pow(x, 2) + pow(y, 2), 3.0L/2.0L) - 0.5*Pi  *x*y*atan2(y, x)/pow(pow(x, 2) + pow(y, 2), 3.0L/2.0L) - 2.0*x*y/pow(pow(x, 2) + pow(y, 2), 3.0L/2.0L) + 0.25*pow(Pi  , 2)*x*y/pow(pow(x, 2) + pow(y, 2), 3.0L/2.0L) + 1.0*pow(y, 2)*atan2(y, x)/pow(pow(x, 2) + pow(y, 2), 3.0L/2.0L) - 0.5*Pi  *pow(y, 2)/pow(pow(x, 2) + pow(y, 2), 3.0L/2.0L) - 1.0*atan2(y, x)/sqrt(pow(x, 2) + pow(y, 2)) + 0.5*Pi  /sqrt(pow(x, 2) + pow(y, 2)))/((-1 + 0.25*pow(Pi  , 2))*sqrt(pow(x, 2) + pow(y, 2))) - pow(y, 2)*(-x*atan2(y, x)/sqrt(pow(x, 2) + pow(y, 2)) - 0.5*Pi  *y*atan2(y, x)/sqrt(pow(x, 2) + pow(y, 2)) + 0.25*pow(Pi  , 2)*y/sqrt(pow(x, 2) + pow(y, 2)))/((-1 + 0.25*pow(Pi  , 2))*pow(pow(x, 2) + pow(y, 2), 3.0L/2.0L)) + y*(-pow(x, 2)/pow(pow(x, 2) + pow(y, 2), 3.0L/2.0L) + x*y*atan2(y, x)/pow(pow(x, 2) + pow(y, 2), 3.0L/2.0L) - 0.5*Pi  *x*y/pow(pow(x, 2) + pow(y, 2), 3.0L/2.0L) + 0.5*Pi  *pow(y, 2)*atan2(y, x)/pow(pow(x, 2) + pow(y, 2), 3.0L/2.0L) - 0.25*pow(Pi  , 2)*pow(y, 2)/pow(pow(x, 2) + pow(y, 2), 3.0L/2.0L) - 0.5*Pi  *atan2(y, x)/sqrt(pow(x, 2) + pow(y, 2)) + 0.25*pow(Pi  , 2)/sqrt(pow(x, 2) + pow(y, 2)))/((-1 + 0.25*pow(Pi  , 2))*sqrt(pow(x, 2) + pow(y, 2))) + (-x*atan2(y, x)/sqrt(pow(x, 2) + pow(y, 2)) - 0.5*Pi  *y*atan2(y, x)/sqrt(pow(x, 2) + pow(y, 2)) + 0.25*pow(Pi  , 2)*y/sqrt(pow(x, 2) + pow(y, 2)))/((-1 + 0.25*pow(Pi  , 2))*sqrt(pow(x, 2) + pow(y, 2)));
  
   // Value of \frac{\partial v}{\partial x}
   grad_u[1][0] = -pow(x, 2)*(x*atan2(y, x)/sqrt(pow(x, 2) + pow(y, 2)) + 0.5*Pi  *y*atan2(y, x)/sqrt(pow(x, 2) + pow(y, 2)) - 0.25*pow(Pi  , 2)*y/sqrt(pow(x, 2) + pow(y, 2)))/((-1 + 0.25*pow(Pi  , 2))*pow(pow(x, 2) + pow(y, 2), 3.0L/2.0L)) + x*y*(0.5*Pi  *x*atan2(y, x)/sqrt(pow(x, 2) + pow(y, 2)) - 0.25*pow(Pi  , 2)*x/sqrt(pow(x, 2) + pow(y, 2)) + 1.0*x/sqrt(pow(x, 2) + pow(y, 2)) - 1.0*y*atan2(y, x)/sqrt(pow(x, 2) + pow(y, 2)) + 0.5*Pi  *y/sqrt(pow(x, 2) + pow(y, 2)))/((-1 + 0.25*pow(Pi  , 2))*pow(pow(x, 2) + pow(y, 2), 3.0L/2.0L)) + x*(-pow(x, 2)*atan2(y, x)/pow(pow(x, 2) + pow(y, 2), 3.0L/2.0L) - 0.5*Pi  *x*y*atan2(y, x)/pow(pow(x, 2) + pow(y, 2), 3.0L/2.0L) - x*y/pow(pow(x, 2) + pow(y, 2), 3.0L/2.0L) + 0.25*pow(Pi  , 2)*x*y/pow(pow(x, 2) + pow(y, 2), 3.0L/2.0L) - 0.5*Pi  *pow(y, 2)/pow(pow(x, 2) + pow(y, 2), 3.0L/2.0L) + atan2(y, x)/sqrt(pow(x, 2) + pow(y, 2)))/((-1 + 0.25*pow(Pi  , 2))*sqrt(pow(x, 2) + pow(y, 2))) - y*(-0.5*Pi  *pow(x, 2)*atan2(y, x)/pow(pow(x, 2) + pow(y, 2), 3.0L/2.0L) - 1.0*pow(x, 2)/pow(pow(x, 2) + pow(y, 2), 3.0L/2.0L) + 0.25*pow(Pi  , 2)*pow(x, 2)/pow(pow(x, 2) + pow(y, 2), 3.0L/2.0L) + 1.0*x*y*atan2(y, x)/pow(pow(x, 2) + pow(y, 2), 3.0L/2.0L) - 1.0*Pi  *x*y/pow(pow(x, 2) + pow(y, 2), 3.0L/2.0L) + 1.0*pow(y, 2)/pow(pow(x, 2) + pow(y, 2), 3.0L/2.0L) + 0.5*Pi  *atan2(y, x)/sqrt(pow(x, 2) + pow(y, 2)) - 0.25*pow(Pi  , 2)/sqrt(pow(x, 2) + pow(y, 2)) + 1.0/sqrt(pow(x, 2) + pow(y, 2)))/((-1 + 0.25*pow(Pi  , 2))*sqrt(pow(x, 2) + pow(y, 2))) + (x*atan2(y, x)/sqrt(pow(x, 2) + pow(y, 2)) + 0.5*Pi  *y*atan2(y, x)/sqrt(pow(x, 2) + pow(y, 2)) - 0.25*pow(Pi  , 2)*y/sqrt(pow(x, 2) + pow(y, 2)))/((-1 + 0.25*pow(Pi  , 2))*sqrt(pow(x, 2) + pow(y, 2)));
  
   // Value of \frac{\partial v}{\partial y}
   grad_u[1][1] = -x*y*(x*atan2(y, x)/sqrt(pow(x, 2) + pow(y, 2)) + 0.5*Pi  *y*atan2(y, x)/sqrt(pow(x, 2) + pow(y, 2)) - 0.25*pow(Pi  , 2)*y/sqrt(pow(x, 2) + pow(y, 2)))/((-1 + 0.25*pow(Pi  , 2))*pow(pow(x, 2) + pow(y, 2), 3.0L/2.0L)) + x*(pow(x, 2)/pow(pow(x, 2) + pow(y, 2), 3.0L/2.0L) - x*y*atan2(y, x)/pow(pow(x, 2) + pow(y, 2), 3.0L/2.0L) + 0.5*Pi  *x*y/pow(pow(x, 2) + pow(y, 2), 3.0L/2.0L) - 0.5*Pi  *pow(y, 2)*atan2(y, x)/pow(pow(x, 2) + pow(y, 2), 3.0L/2.0L) + 0.25*pow(Pi  , 2)*pow(y, 2)/pow(pow(x, 2) + pow(y, 2), 3.0L/2.0L) + 0.5*Pi  *atan2(y, x)/sqrt(pow(x, 2) + pow(y, 2)) - 0.25*pow(Pi  , 2)/sqrt(pow(x, 2) + pow(y, 2)))/((-1 + 0.25*pow(Pi  , 2))*sqrt(pow(x, 2) + pow(y, 2))) + pow(y, 2)*(0.5*Pi  *x*atan2(y, x)/sqrt(pow(x, 2) + pow(y, 2)) - 0.25*pow(Pi  , 2)*x/sqrt(pow(x, 2) + pow(y, 2)) + 1.0*x/sqrt(pow(x, 2) + pow(y, 2)) - 1.0*y*atan2(y, x)/sqrt(pow(x, 2) + pow(y, 2)) + 0.5*Pi  *y/sqrt(pow(x, 2) + pow(y, 2)))/((-1 + 0.25*pow(Pi  , 2))*pow(pow(x, 2) + pow(y, 2), 3.0L/2.0L)) - y*(0.5*Pi  *pow(x, 2)/pow(pow(x, 2) + pow(y, 2), 3.0L/2.0L) - 0.5*Pi  *x*y*atan2(y, x)/pow(pow(x, 2) + pow(y, 2), 3.0L/2.0L) - 2.0*x*y/pow(pow(x, 2) + pow(y, 2), 3.0L/2.0L) + 0.25*pow(Pi  , 2)*x*y/pow(pow(x, 2) + pow(y, 2), 3.0L/2.0L) + 1.0*pow(y, 2)*atan2(y, x)/pow(pow(x, 2) + pow(y, 2), 3.0L/2.0L) - 0.5*Pi  *pow(y, 2)/pow(pow(x, 2) + pow(y, 2), 3.0L/2.0L) - 1.0*atan2(y, x)/sqrt(pow(x, 2) + pow(y, 2)) + 0.5*Pi  /sqrt(pow(x, 2) + pow(y, 2)))/((-1 + 0.25*pow(Pi  , 2))*sqrt(pow(x, 2) + pow(y, 2))) - (0.5*Pi  *x*atan2(y, x)/sqrt(pow(x, 2) + pow(y, 2)) - 0.25*pow(Pi  , 2)*x/sqrt(pow(x, 2) + pow(y, 2)) + 1.0*x/sqrt(pow(x, 2) + pow(y, 2)) - 1.0*y*atan2(y, x)/sqrt(pow(x, 2) + pow(y, 2)) + 0.5*Pi  *y/sqrt(pow(x, 2) + pow(y, 2)))/((-1 + 0.25*pow(Pi  , 2))*sqrt(pow(x, 2) + pow(y, 2)));
  
   return grad_u;
  
  } // End of function

References atan2(), k, BiharmonicTestFunctions2::Pi, Eigen::bfloat16_impl::pow(), sqrt(), plotDoE::x, and y.

◆ grad_velocity_singularity2()

Vector<Vector<double> > Global_Parameters::grad_velocity_singularity2 ( const Vector< double > & coord )

Function that computes the gradient of the fitting velocity solution near the corner (1,0): grad[i][j] = du_i/dx_j

  { 
   using namespace MathematicalConstants;
  
   // Cartesian coordinates
   double x = coord[0];
   double y = coord[1];
   
   // Initialise the gradient matrix to return
   Vector<Vector<double> > grad_u(2);
   for (unsigned d=0;d<2;d++)
    {
     grad_u[d].resize(2);
     for (unsigned k=0;k<2;k++)
      {
       grad_u[d][k] = 0.0;
      }
    }
  
   // Value of \frac{\partial u}{\partial x}
   grad_u[0][0] = -y*(-x + 1)*(-0.5*Pi*y*atan2(y, -x + 1)/sqrt(pow(y, 2) + pow(-x + 1, 2)) + 0.25*pow(Pi, 2)*y/sqrt(pow(y, 2) + pow(-x + 1, 2)) - (-x + 1)*atan2(y, -x + 1)/sqrt(pow(y, 2) + pow(-x + 1, 2)))/((-1 + 0.25*pow(Pi, 2))*pow(pow(y, 2) + pow(-x + 1, 2), 3.0L/2.0L)) - y*(-0.5*Pi*pow(y, 2)/pow(pow(y, 2) + pow(-x + 1, 2), 3.0L/2.0L) - 0.5*Pi*y*(-x + 1)*atan2(y, -x + 1)/pow(pow(y, 2) + pow(-x + 1, 2), 3.0L/2.0L) - y*(-x + 1)/pow(pow(y, 2) + pow(-x + 1, 2), 3.0L/2.0L) + 0.25*pow(Pi, 2)*y*(-x + 1)/pow(pow(y, 2) + pow(-x + 1, 2), 3.0L/2.0L) - pow(-x + 1, 2)*atan2(y, -x + 1)/pow(pow(y, 2) + pow(-x + 1, 2), 3.0L/2.0L) + atan2(y, -x + 1)/sqrt(pow(y, 2) + pow(-x + 1, 2)))/((-1 + 0.25*pow(Pi, 2))*sqrt(pow(y, 2) + pow(-x + 1, 2))) + pow(-x + 1, 2)*(-1.0*y*atan2(y, -x + 1)/sqrt(pow(y, 2) + pow(-x + 1, 2)) + 0.5*Pi*y/sqrt(pow(y, 2) + pow(-x + 1, 2)) + 0.5*Pi*(-x + 1)*atan2(y, -x + 1)/sqrt(pow(y, 2) + pow(-x + 1, 2)) - 0.25*pow(Pi, 2)*(-x + 1)/sqrt(pow(y, 2) + pow(-x + 1, 2)) + 1.0*(-x + 1)/sqrt(pow(y, 2) + pow(-x + 1, 2)))/((-1 + 0.25*pow(Pi, 2))*pow(pow(y, 2) + pow(-x + 1, 2), 3.0L/2.0L)) + (-x + 1)*(-1.0*pow(y, 2)/pow(pow(y, 2) + pow(-x + 1, 2), 3.0L/2.0L) - 1.0*y*(-x + 1)*atan2(y, -x + 1)/pow(pow(y, 2) + pow(-x + 1, 2), 3.0L/2.0L) + 1.0*Pi*y*(-x + 1)/pow(pow(y, 2) + pow(-x + 1, 2), 3.0L/2.0L) + 0.5*Pi*pow(-x + 1, 2)*atan2(y, -x + 1)/pow(pow(y, 2) + pow(-x + 1, 2), 3.0L/2.0L) - 0.25*pow(Pi, 2)*pow(-x + 1, 2)/pow(pow(y, 2) + pow(-x + 1, 2), 3.0L/2.0L) + 1.0*pow(-x + 1, 2)/pow(pow(y, 2) + pow(-x + 1, 2), 3.0L/2.0L) - 0.5*Pi*atan2(y, -x + 1)/sqrt(pow(y, 2) + pow(-x + 1, 2)) - 1.0/sqrt(pow(y, 2) + pow(-x + 1, 2)) + 0.25*pow(Pi, 2)/sqrt(pow(y, 2) + pow(-x + 1, 2)))/((-1 + 0.25*pow(Pi, 2))*sqrt(pow(y, 2) + pow(-x + 1, 2))) - (-1.0*y*atan2(y, -x + 1)/sqrt(pow(y, 2) + pow(-x + 1, 2)) + 0.5*Pi*y/sqrt(pow(y, 2) + pow(-x + 1, 2)) + 0.5*Pi*(-x + 1)*atan2(y, -x + 1)/sqrt(pow(y, 2) + pow(-x + 1, 2)) - 0.25*pow(Pi, 2)*(-x + 1)/sqrt(pow(y, 2) + pow(-x + 1, 2)) + 1.0*(-x + 1)/sqrt(pow(y, 2) + pow(-x + 1, 2)))/((-1 + 0.25*pow(Pi, 2))*sqrt(pow(y, 2) + pow(-x + 1, 2)));
  
   // Value of \frac{\partial u}{\partial y}
   grad_u[0][1] = pow(y, 2)*(-0.5*Pi*y*atan2(y, -x + 1)/sqrt(pow(y, 2) + pow(-x + 1, 2)) + 0.25*pow(Pi, 2)*y/sqrt(pow(y, 2) + pow(-x + 1, 2)) - (-x + 1)*atan2(y, -x + 1)/sqrt(pow(y, 2) + pow(-x + 1, 2)))/((-1 + 0.25*pow(Pi, 2))*pow(pow(y, 2) + pow(-x + 1, 2), 3.0L/2.0L)) - y*(-x + 1)*(-1.0*y*atan2(y, -x + 1)/sqrt(pow(y, 2) + pow(-x + 1, 2)) + 0.5*Pi*y/sqrt(pow(y, 2) + pow(-x + 1, 2)) + 0.5*Pi*(-x + 1)*atan2(y, -x + 1)/sqrt(pow(y, 2) + pow(-x + 1, 2)) - 0.25*pow(Pi, 2)*(-x + 1)/sqrt(pow(y, 2) + pow(-x + 1, 2)) + 1.0*(-x + 1)/sqrt(pow(y, 2) + pow(-x + 1, 2)))/((-1 + 0.25*pow(Pi, 2))*pow(pow(y, 2) + pow(-x + 1, 2), 3.0L/2.0L)) - y*(0.5*Pi*pow(y, 2)*atan2(y, -x + 1)/pow(pow(y, 2) + pow(-x + 1, 2), 3.0L/2.0L) - 0.25*pow(Pi, 2)*pow(y, 2)/pow(pow(y, 2) + pow(-x + 1, 2), 3.0L/2.0L) + y*(-x + 1)*atan2(y, -x + 1)/pow(pow(y, 2) + pow(-x + 1, 2), 3.0L/2.0L) - 0.5*Pi*y*(-x + 1)/pow(pow(y, 2) + pow(-x + 1, 2), 3.0L/2.0L) - pow(-x + 1, 2)/pow(pow(y, 2) + pow(-x + 1, 2), 3.0L/2.0L) - 0.5*Pi*atan2(y, -x + 1)/sqrt(pow(y, 2) + pow(-x + 1, 2)) + 0.25*pow(Pi, 2)/sqrt(pow(y, 2) + pow(-x + 1, 2)))/((-1 + 0.25*pow(Pi, 2))*sqrt(pow(y, 2) + pow(-x + 1, 2))) + (-x + 1)*(1.0*pow(y, 2)*atan2(y, -x + 1)/pow(pow(y, 2) + pow(-x + 1, 2), 3.0L/2.0L) - 0.5*Pi*pow(y, 2)/pow(pow(y, 2) + pow(-x + 1, 2), 3.0L/2.0L) - 0.5*Pi*y*(-x + 1)*atan2(y, -x + 1)/pow(pow(y, 2) + pow(-x + 1, 2), 3.0L/2.0L) - 2.0*y*(-x + 1)/pow(pow(y, 2) + pow(-x + 1, 2), 3.0L/2.0L) + 0.25*pow(Pi, 2)*y*(-x + 1)/pow(pow(y, 2) + pow(-x + 1, 2), 3.0L/2.0L) + 0.5*Pi*pow(-x + 1, 2)/pow(pow(y, 2) + pow(-x + 1, 2), 3.0L/2.0L) - 1.0*atan2(y, -x + 1)/sqrt(pow(y, 2) + pow(-x + 1, 2)) + 0.5*Pi/sqrt(pow(y, 2) + pow(-x + 1, 2)))/((-1 + 0.25*pow(Pi, 2))*sqrt(pow(y, 2) + pow(-x + 1, 2))) - (-0.5*Pi*y*atan2(y, -x + 1)/sqrt(pow(y, 2) + pow(-x + 1, 2)) + 0.25*pow(Pi, 2)*y/sqrt(pow(y, 2) + pow(-x + 1, 2)) - (-x + 1)*atan2(y, -x + 1)/sqrt(pow(y, 2) + pow(-x + 1, 2)))/((-1 + 0.25*pow(Pi, 2))*sqrt(pow(y, 2) + pow(-x + 1, 2)));
  
   // Value of \frac{\partial v}{\partial x}
   grad_u[1][0] = -y*(-x + 1)*(-1.0*y*atan2(y, -x + 1)/sqrt(pow(y, 2) + pow(-x + 1, 2)) + 0.5*Pi*y/sqrt(pow(y, 2) + pow(-x + 1, 2)) + 0.5*Pi*(-x + 1)*atan2(y, -x + 1)/sqrt(pow(y, 2) + pow(-x + 1, 2)) - 0.25*pow(Pi, 2)*(-x + 1)/sqrt(pow(y, 2) + pow(-x + 1, 2)) + 1.0*(-x + 1)/sqrt(pow(y, 2) + pow(-x + 1, 2)))/((-1 + 0.25*pow(Pi, 2))*pow(pow(y, 2) + pow(-x + 1, 2), 3.0L/2.0L)) - y*(-1.0*pow(y, 2)/pow(pow(y, 2) + pow(-x + 1, 2), 3.0L/2.0L) - 1.0*y*(-x + 1)*atan2(y, -x + 1)/pow(pow(y, 2) + pow(-x + 1, 2), 3.0L/2.0L) + 1.0*Pi*y*(-x + 1)/pow(pow(y, 2) + pow(-x + 1, 2), 3.0L/2.0L) + 0.5*Pi*pow(-x + 1, 2)*atan2(y, -x + 1)/pow(pow(y, 2) + pow(-x + 1, 2), 3.0L/2.0L) - 0.25*pow(Pi, 2)*pow(-x + 1, 2)/pow(pow(y, 2) + pow(-x + 1, 2), 3.0L/2.0L) + 1.0*pow(-x + 1, 2)/pow(pow(y, 2) + pow(-x + 1, 2), 3.0L/2.0L) - 0.5*Pi*atan2(y, -x + 1)/sqrt(pow(y, 2) + pow(-x + 1, 2)) - 1.0/sqrt(pow(y, 2) + pow(-x + 1, 2)) + 0.25*pow(Pi, 2)/sqrt(pow(y, 2) + pow(-x + 1, 2)))/((-1 + 0.25*pow(Pi, 2))*sqrt(pow(y, 2) + pow(-x + 1, 2))) + pow(-x + 1, 2)*(0.5*Pi*y*atan2(y, -x + 1)/sqrt(pow(y, 2) + pow(-x + 1, 2)) - 0.25*pow(Pi, 2)*y/sqrt(pow(y, 2) + pow(-x + 1, 2)) + (-x + 1)*atan2(y, -x + 1)/sqrt(pow(y, 2) + pow(-x + 1, 2)))/((-1 + 0.25*pow(Pi, 2))*pow(pow(y, 2) + pow(-x + 1, 2), 3.0L/2.0L)) + (-x + 1)*(0.5*Pi*pow(y, 2)/pow(pow(y, 2) + pow(-x + 1, 2), 3.0L/2.0L) + 0.5*Pi*y*(-x + 1)*atan2(y, -x + 1)/pow(pow(y, 2) + pow(-x + 1, 2), 3.0L/2.0L) - 0.25*pow(Pi, 2)*y*(-x + 1)/pow(pow(y, 2) + pow(-x + 1, 2), 3.0L/2.0L) + y*(-x + 1)/pow(pow(y, 2) + pow(-x + 1, 2), 3.0L/2.0L) + pow(-x + 1, 2)*atan2(y, -x + 1)/pow(pow(y, 2) + pow(-x + 1, 2), 3.0L/2.0L) - atan2(y, -x + 1)/sqrt(pow(y, 2) + pow(-x + 1, 2)))/((-1 + 0.25*pow(Pi, 2))*sqrt(pow(y, 2) + pow(-x + 1, 2))) - (0.5*Pi*y*atan2(y, -x + 1)/sqrt(pow(y, 2) + pow(-x + 1, 2)) - 0.25*pow(Pi, 2)*y/sqrt(pow(y, 2) + pow(-x + 1, 2)) + (-x + 1)*atan2(y, -x + 1)/sqrt(pow(y, 2) + pow(-x + 1, 2)))/((-1 + 0.25*pow(Pi, 2))*sqrt(pow(y, 2) + pow(-x + 1, 2)));
  
   // Value of \frac{\partial v}{\partial y}
   grad_u[1][1] = pow(y, 2)*(-1.0*y*atan2(y, -x + 1)/sqrt(pow(y, 2) + pow(-x + 1, 2)) + 0.5*Pi*y/sqrt(pow(y, 2) + pow(-x + 1, 2)) + 0.5*Pi*(-x + 1)*atan2(y, -x + 1)/sqrt(pow(y, 2) + pow(-x + 1, 2)) - 0.25*pow(Pi, 2)*(-x + 1)/sqrt(pow(y, 2) + pow(-x + 1, 2)) + 1.0*(-x + 1)/sqrt(pow(y, 2) + pow(-x + 1, 2)))/((-1 + 0.25*pow(Pi, 2))*pow(pow(y, 2) + pow(-x + 1, 2), 3.0L/2.0L)) - y*(-x + 1)*(0.5*Pi*y*atan2(y, -x + 1)/sqrt(pow(y, 2) + pow(-x + 1, 2)) - 0.25*pow(Pi, 2)*y/sqrt(pow(y, 2) + pow(-x + 1, 2)) + (-x + 1)*atan2(y, -x + 1)/sqrt(pow(y, 2) + pow(-x + 1, 2)))/((-1 + 0.25*pow(Pi, 2))*pow(pow(y, 2) + pow(-x + 1, 2), 3.0L/2.0L)) - y*(1.0*pow(y, 2)*atan2(y, -x + 1)/pow(pow(y, 2) + pow(-x + 1, 2), 3.0L/2.0L) - 0.5*Pi*pow(y, 2)/pow(pow(y, 2) + pow(-x + 1, 2), 3.0L/2.0L) - 0.5*Pi*y*(-x + 1)*atan2(y, -x + 1)/pow(pow(y, 2) + pow(-x + 1, 2), 3.0L/2.0L) - 2.0*y*(-x + 1)/pow(pow(y, 2) + pow(-x + 1, 2), 3.0L/2.0L) + 0.25*pow(Pi, 2)*y*(-x + 1)/pow(pow(y, 2) + pow(-x + 1, 2), 3.0L/2.0L) + 0.5*Pi*pow(-x + 1, 2)/pow(pow(y, 2) + pow(-x + 1, 2), 3.0L/2.0L) - 1.0*atan2(y, -x + 1)/sqrt(pow(y, 2) + pow(-x + 1, 2)) + 0.5*Pi/sqrt(pow(y, 2) + pow(-x + 1, 2)))/((-1 + 0.25*pow(Pi, 2))*sqrt(pow(y, 2) + pow(-x + 1, 2))) + (-x + 1)*(-0.5*Pi*pow(y, 2)*atan2(y, -x + 1)/pow(pow(y, 2) + pow(-x + 1, 2), 3.0L/2.0L) + 0.25*pow(Pi, 2)*pow(y, 2)/pow(pow(y, 2) + pow(-x + 1, 2), 3.0L/2.0L) - y*(-x + 1)*atan2(y, -x + 1)/pow(pow(y, 2) + pow(-x + 1, 2), 3.0L/2.0L) + 0.5*Pi*y*(-x + 1)/pow(pow(y, 2) + pow(-x + 1, 2), 3.0L/2.0L) + pow(-x + 1, 2)/pow(pow(y, 2) + pow(-x + 1, 2), 3.0L/2.0L) + 0.5*Pi*atan2(y, -x + 1)/sqrt(pow(y, 2) + pow(-x + 1, 2)) - 0.25*pow(Pi, 2)/sqrt(pow(y, 2) + pow(-x + 1, 2)))/((-1 + 0.25*pow(Pi, 2))*sqrt(pow(y, 2) + pow(-x + 1, 2))) - (-1.0*y*atan2(y, -x + 1)/sqrt(pow(y, 2) + pow(-x + 1, 2)) + 0.5*Pi*y/sqrt(pow(y, 2) + pow(-x + 1, 2)) + 0.5*Pi*(-x + 1)*atan2(y, -x + 1)/sqrt(pow(y, 2) + pow(-x + 1, 2)) - 0.25*pow(Pi, 2)*(-x + 1)/sqrt(pow(y, 2) + pow(-x + 1, 2)) + 1.0*(-x + 1)/sqrt(pow(y, 2) + pow(-x + 1, 2)))/((-1 + 0.25*pow(Pi, 2))*sqrt(pow(y, 2) + pow(-x + 1, 2)));
  
  
   grad_u[0][0]*=-1.0;
   grad_u[0][1]*=-1.0;
   grad_u[1][0]*=-1.0;
   grad_u[1][1]*=-1.0;
  
   return grad_u;
  }

References atan2(), k, BiharmonicTestFunctions2::Pi, Eigen::bfloat16_impl::pow(), sqrt(), plotDoE::x, and y.

◆ gravity()

void Global_Parameters::gravity	(	const double &	time,
		const Vector< double > &	xi,
		Vector< double > &	b
	)

Non-dimensional gravity as body force.

  {
   b[0]=0.0;
   b[1]=-Gravity;
  }

References b, and Gravity.

Referenced by TurekProblem< FLUID_ELEMENT, SOLID_ELEMENT >::build_mesh(), and TurekProblem< FLUID_ELEMENT, SOLID_ELEMENT >::TurekProblem().

◆ Hankel_first()

void Global_Parameters::Hankel_first	(	const unsigned &	n,
		const double &	x,
		Vector< std::complex< double > > &	h,
		Vector< std::complex< double > > &	hp
	)

Compute Hankel function of the first kind of orders 0...n and its derivates at coordinate x. The function returns the vector then its derivative.

  {
   int  n_actual = 0;
   Vector<double> jn(n+1),yn(n+1),jnp(n+1), ynp(n+1);
   CRBond_Bessel::bessjyna(int(n),x,n_actual,&jn[0],&yn[0],
                           &jnp[0],&ynp[0]);
 #ifdef PARANOID
   if (n_actual!=int(n))
    {
     std::ostringstream error_stream; 
     error_stream << "CRBond_Bessel::bessjyna() only computed "
                  << n_actual << " rather than " << n
                  << " Bessel functions.\n";    
     throw OomphLibError(error_stream.str(),
                         OOMPH_CURRENT_FUNCTION,
                         OOMPH_EXCEPTION_LOCATION);
    }
 #endif
   for (unsigned i=0;i<n;i++)
    {
     h[i] =std::complex<double>(jn[i], yn[i]);
     hp[i]=std::complex<double>(jnp[i],ynp[i]);
    }
  }

References CRBond_Bessel::bessjyna(), i, n, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and plotDoE::x.

Referenced by exact_axisym_radiated_power(), exact_u(), and HankelH1().

◆ HankelH1()

std::complex<double> Global_Parameters::HankelH1	(	const double &	k,
		const double &	x
	)

Interface to Hankel function in maple style.

  {
   Vector<std::complex<double> > h(2);
   Vector<std::complex<double> > hp(2);
   Hankel_functions_for_helmholtz_problem::Hankel_first(2,x,h,hp);
   
   if (k==0.0)
    {
     return h[0];
    }
   else if (k==1.0)
    {
     return h[1];
    }
   else
    {
     cout << "Never get here. k=" << k << std::endl;
     assert(false);
     // Dummy return
     return std::complex<double>(1.0,1.0); 
    }
  }

References assert, Hankel_first(), k, and plotDoE::x.

Referenced by axisym_coefficient(), and exact_axisym_potential().

◆ I()

const std::complex< double > Global_Parameters::I	(	0.	0,
		1.	0
	)

Define the imaginary unit.

◆ is_on_fsi_boundary()

bool Global_Parameters::is_on_fsi_boundary ( Node * nod_pt )

Boolean to identify if node is on fsi boundary.

  {
   if (
    (
     // Is it a boundary node?
     dynamic_cast<BoundaryNodeBase*>(nod_pt)!=0)&&
    (
     // Horizontal extent of main immersed obstacle
     (  (nod_pt->x(0)>1.6)&&(nod_pt->x(0)<4.75)&&
        // Vertical extent of main immersed obstacle
        (nod_pt->x(1)>0.1125)&&(nod_pt->x(1)<2.8) ) ||
     // Two nodes on the bottom wall are below y=0.3
     (  (nod_pt->x(1)<0.3)&&
        // ...and bracketed in these two x-ranges
        (  ( (nod_pt->x(0)>3.0)&&(nod_pt->x(0)<3.1) ) ||
           ( (nod_pt->x(0)<4.6)&&(nod_pt->x(0)>4.5) )   ) 
      )
     )
    )
    {
     return true;
    }
   else
    {
     return false;
    }
  }

References oomph::Node::x().

Referenced by FluidTriangleMesh< ELEMENT >::FluidTriangleMesh(), MySolidTriangleMesh< ELEMENT >::MySolidTriangleMesh(), and oomph::ThinLayerBrickOnTetMesh< ELEMENT >::ThinLayerBrickOnTetMesh().

◆ Nu() [1/2]

std::complex<double> Global_Parameters::Nu	(	0.	3,
		0.	05
	)

Define Poisson's ratio Nu.

◆ Nu() [2/2]

std::complex<double> Global_Parameters::Nu ( std::complex< double > 0.3, 0.0 )

Poisson's ratio Nu.

◆ Omega_sq() [1/5]

std::complex<double> Global_Parameters::Omega_sq	(	10.	0,
		0.	0
	)

Define the non-dimensional square angular frequency of time-harmonic motion

◆ Omega_sq() [2/5]

std::complex<double> Global_Parameters::Omega_sq	(	10.	0,
		5.	0
	)

Define the non-dimensional square angular frequency of time-harmonic motion

◆ Omega_sq() [3/5]

Vector<double> Global_Parameters::Omega_sq	(	2	,
		0.	0
	)

Square of non-dim frequency for the two regions – dependent variable!

◆ Omega_sq() [4/5]

Vector<std::complex<double> > Global_Parameters::Omega_sq	(	2	,
		std::complex< double >	100.0, 0.0
	)

Non-dim square of frequency for solid – dependent variable!

◆ Omega_sq() [5/5]

std::complex<double> Global_Parameters::Omega_sq ( std::complex< double > 100.0, 0.0 )

Non-dim square of frequency for solid – dependent variable!

◆ periodic_traction()

void Global_Parameters::periodic_traction	(	const double &	time,
		const Vector< double > &	x,
		const Vector< double > &	n,
		Vector< double > &	result
	)

The traction function.

  {
   result[0] = -Amplitude*cos(2.0*MathematicalConstants::Pi*x[0]/Lx);
   result[1] = -Amplitude*sin(2.0*MathematicalConstants::Pi*x[0]/Lx);
  }

References Amplitude, cos(), Lx, BiharmonicTestFunctions2::Pi, sin(), and plotDoE::x.

Referenced by RefineablePeriodicLoadProblem< ELEMENT >::assign_traction_elements(), and PeriodicLoadProblem< ELEMENT >::PeriodicLoadProblem().

◆ prescribed_inflow_traction()

void Global_Parameters::prescribed_inflow_traction	(	const double &	t,
		const Vector< double > &	x,
		const Vector< double > &	n,
		Vector< double > &	traction
	)

Applied traction on fluid at the inflow boundary.

  {
   traction[0]=0.0;
   traction[1]=0.0;
   traction[2]=P_in;
  } 

References P_in.

Referenced by UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::create_fluid_traction_elements(), and UnstructuredFluidProblem< ELEMENT >::create_fluid_traction_elements().

◆ prescribed_outflow_traction()

void Global_Parameters::prescribed_outflow_traction	(	const double &	t,
		const Vector< double > &	x,
		const Vector< double > &	n,
		Vector< double > &	traction
	)

Applied traction on fluid at the inflow boundary.

  {
   traction[0]=0.0;
   traction[1]=0.0;
   traction[2]=-P_out;
  } 

References P_out.

Referenced by UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::create_fluid_traction_elements(), and UnstructuredFluidProblem< ELEMENT >::create_fluid_traction_elements().

◆ press_load()

void Global_Parameters::press_load	(	const Vector< double > &	xi,
		const Vector< double > &	x,
		const Vector< double > &	N,
		Vector< double > &	load
	)

Load function for wall.

  {  
   // Get polar angle
   double phi=atan2(xi[1],xi[0]);
  
 //  if (xi[0]==0.0) assert(false);
  
   // Pressure with pcos perturbation
   for(unsigned i=0;i<3;i++)
    {
     load[i] = (-P - Pcos*cos(2.0*phi))*N[i];
    }
  } 

References atan2(), cos(), i, load(), N, Global_Physical_Variables::P, and Pcos.

Referenced by PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::create_solid_traction_elements().

◆ pressure_couette()

double Global_Parameters::pressure_couette ( const Vector< double > & x )

Couette Pressure.

  {
   // Shifted origin
   double x_shifted=1.0+x[0];
   double y_shifted=1.0+x[1];
  
   // Polar coordinates
   double r=sqrt(x_shifted*x_shifted+y_shifted*y_shifted);
  
   // Pressure
   double press=Global_Physical_Variables::Re*
    (A_couette*A_couette*r*r/2.0+
     2.0*A_couette*B_couette*log(r)-
     B_couette*B_couette/(2.0*r*r));
  
   return press;
  }

References A_couette, B_couette, Eigen::bfloat16_impl::log(), UniformPSDSelfTest::r, Global_Physical_Variables::Re, sqrt(), and plotDoE::x.

Referenced by exact_couette().

◆ pressure_load()

void Global_Parameters::pressure_load	(	const Vector< double > &	x,
		const Vector< double > &	n,
		Vector< std::complex< double > > &	traction
	)

Pressure load (real and imag part)

Constant pressure load (real and imag part)

  {
   double phi=atan2(x[1],x[0]);
   double magnitude=exp(-Alpha*pow(phi-0.25*MathematicalConstants::Pi,2));
  
   unsigned dim = traction.size();
   for(unsigned i=0;i<dim;i++)
    {
     traction[i] = complex<double>(-magnitude*P*n[i],magnitude*P*n[i]);
    }
  } // end_of_pressure_load

References TanhSolnForAdvectionDiffusion::Alpha, atan2(), Eigen::bfloat16_impl::exp(), i, oomph::VectorHelpers::magnitude(), n, P, BiharmonicTestFunctions2::Pi, Eigen::bfloat16_impl::pow(), and plotDoE::x.

Referenced by CoatedDiskProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::create_solid_traction_elements(), CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::create_solid_traction_elements(), and RingWithTRibProblem< ELASTICITY_ELEMENT >::create_traction_elements().

◆ pressure_pseudo_singularity_for_couette()

double Global_Parameters::pressure_pseudo_singularity_for_couette ( const Vector< double > & x )

Pseudo_singularity for computation of Couette flow.

  {
   return -2.0*x[1]; //-2.0*x[0];
  }

References plotDoE::x.

Referenced by blended_pressure_pseudo_singularity_for_couette().

◆ pressure_singularity1()

double Global_Parameters::pressure_singularity1 ( const Vector< double > & x )

Function that computes the fitting pressure solution near the corner (0,0)

  {  
   using namespace MathematicalConstants;
  
   // Polar coordinates centered at the point (0,0)
   double r = sqrt(x[0]*x[0]+x[1]*x[1]);
   double theta = atan2(x[1],x[0]);
   
   double p = -(-0.25*Pi*Pi*Pi*sin(theta) + 1.0*Pi*sin(theta) - 0.5*Pi*Pi*cos(theta) + 2.0*cos(theta))/(r*(-0.0625*Pi*Pi*Pi*Pi - 1.0 + 0.5*Pi*Pi));
   
   //hierher
   if (std::isinf(p))
    {
     p=200.0;
    }
   
   return p;
  }

References atan2(), cos(), isinf, p, BiharmonicTestFunctions2::Pi, UniformPSDSelfTest::r, sin(), sqrt(), BiharmonicTestFunctions2::theta, and plotDoE::x.

◆ pressure_singularity2()

double Global_Parameters::pressure_singularity2 ( const Vector< double > & x )

Function that computes the fitting pressure solution near the corner (1,0)

Polar coordinates centered at the point (1,0)

  {
   using namespace MathematicalConstants;
  
   // Variable change
   Vector<double> x1(2);
   x1[0] = 1.0-x[0];
   x1[1] = x[1];
  
   double r = sqrt(x1[0]*x1[0] + x1[1]*x1[1]);
   double theta = atan2(x1[1],x1[0]);
   
   double p = -(-1.0*Pi*sin(theta) + 0.25*Pi*Pi*Pi*sin(theta) - 2.0*cos(theta) + 0.5*Pi*Pi*cos(theta))/(r*(-0.0625*Pi*Pi*Pi*Pi - 1.0 + 0.5*Pi*Pi));
  
   // hierher 
   if (std::isinf(p))
    {
     p=200.0;
    }
  
   return p;
  }

References atan2(), cos(), isinf, p, BiharmonicTestFunctions2::Pi, UniformPSDSelfTest::r, sin(), sqrt(), BiharmonicTestFunctions2::theta, plotDoE::x, and Global_parameters::x1().

◆ set_parameters()

void Global_Parameters::set_parameters ( const string & case_id )

Set parameters for the various test cases.

  {
  
   // Remember which case we're dealing with
   Case_ID=case_id;
  
   // Setup independent parameters depending on test case
   if (case_id=="FSI1")
    {
     // Reynolds number based on diameter of cylinder
     Re=20.0;
  
     // Strouhal number based on timescale of one second
     St=0.5;
  
     // Womersley number
     ReSt=Re*St;
  
     // FSI parameter
     Q=1.429e-6;
     
     // Timestep -- aiming for about 40 steps per period
     Dt=0.1;
  
     // Density ratio
     Density_ratio=1.0;
  
     // Gravity
     Gravity=0.0;
     
     // Max. flux
     Max_flux=1.0;
  
     // Ignore fluid
     Ignore_fluid_loading=false;
  
     // Compute dependent parameters
     
     // Timescale ratio for solid 
     Lambda_sq=Re*Q*Density_ratio*St*St;
   }
   else if (case_id=="FSI2")
    {
     // Reynolds number based on diameter of cylinder
     Re=100.0;
  
     // Strouhal number based on timescale of one second
     St=0.1;
  
     // Womersley number
     ReSt=Re*St;
  
     // FSI parameter
     Q=7.143e-6;
     
     // Timestep -- aiming for about 40 steps per period
     Dt=0.01;
  
     // Density ratio
     Density_ratio=10.0;
  
     // Gravity
     Gravity=0.0;
     
     // Max. flux
     Max_flux=1.0;
  
     // Ignore fluid
     Ignore_fluid_loading=false;
  
     // Compute dependent parameters
     
     // Timescale ratio for solid 
     Lambda_sq=Re*Q*Density_ratio*St*St;
    }
   else if (case_id=="FSI3")
    {
     // Reynolds number based on diameter of cylinder
     Re=200.0;
  
     // Strouhal number based on timescale of one second
     St=0.05;
  
     // Womersley number
     ReSt=Re*St;
  
     // FSI parameter
     Q=3.571e-6;
  
     // Timestep -- aiming for about 40 steps per period
     Dt=0.005;
  
     // Density ratio
     Density_ratio=1.0;
  
     // Gravity
     Gravity=0.0;
     
     // Max. flux
     Max_flux=1.0;
  
     // Ignore fluid
     Ignore_fluid_loading=false;
  
     // Compute dependent parameters
     
     // Timescale ratio for solid 
     Lambda_sq=Re*Q*Density_ratio*St*St;
    } 
   else if (case_id=="CSM1")
    {
     // Reynolds number based on diameter of cylinder
     Re=0.0;
  
     // Strouhal number based on timescale of one second
     // (irrelevant here)
     St=0.0;
  
     // Womersley number
     ReSt=Re*St;
  
     // FSI parameter
     Q=0.0;
  
     // Timestep -- irrelevant here
     Dt=0.005;
  
     // Density ratio (switch off wall inertia)
     Density_ratio=0.0;
  
     // Gravity
     Gravity=1.429e-4;
  
     // Max. flux
     Max_flux=0.0;
     
     // Ignore fluid
     Ignore_fluid_loading=true;
  
     // Compute dependent parameters
     
     // Timescale ratio for solid 
     Lambda_sq=0.0;
    }
   else if (case_id=="CSM3")
    {
     // Reynolds number based on diameter of cylinder
     Re=0.0;
  
     // Strouhal number based on timescale of one second
     // (irrelevant here)
     St=0.0;
  
     // Womersley number
     ReSt=Re*St;
  
     // Timestep -- aiming for about 40 steps per period
     Dt=0.025;
  
     // FSI parameter
     Q=0.0;
  
     // Density ratio (not used here)
     Density_ratio=0.0;
  
     // Gravity
     Gravity=1.429e-4;
  
     // Max. flux
     Max_flux=0.0;
     
     // Ignore fluid
     Ignore_fluid_loading=true;
  
     // Compute dependent parameters
     
     // Set timescale ratio for solid based on the
     // observed period of oscillation of about 1 sec)
     Lambda_sq=7.143e-6;
    }
   else
    {
     std::cout << "Wrong case_id: " << case_id << std::endl;
     exit(0);
    }
  
   
   // Ramp period (20 timesteps)
   Ramp_period=Dt*20.0;
  
   // "Big G" Linear constitutive equations:
   Constitutive_law_pt = new GeneralisedHookean(&Nu,&E);
   
   // Doc
   oomph_info << std::endl;
   oomph_info << "-------------------------------------------" 
              << std::endl;
   oomph_info << "Case: " << case_id << std::endl;
   oomph_info << "Re            = " << Re << std::endl;
   oomph_info << "St            = " << St << std::endl;
   oomph_info << "ReSt          = " << ReSt << std::endl;
   oomph_info << "Q             = " << Q << std::endl;
   oomph_info << "Dt            = " << Dt << std::endl;
   oomph_info << "Ramp_period   = " << Ramp_period << std::endl;
   oomph_info << "Max_flux      = " << Max_flux << std::endl;
   oomph_info << "Density_ratio = " << Density_ratio << std::endl;
   oomph_info << "Lambda_sq     = " << Lambda_sq << std::endl;
   oomph_info << "Gravity       = " << Gravity << std::endl;
   oomph_info << "Ignore fluid  = " << Ignore_fluid_loading<< std::endl;
   oomph_info << "-------------------------------------------"
              << std::endl << std::endl;
  }

References Case_ID, Constitutive_law_pt, ProblemParameters::Density_ratio, ProblemParameters::Dt, Global_Physical_Variables::E, Ignore_fluid_loading, Global_Physical_Variables::Lambda_sq, Max_flux, Constitutive_Parameters::Nu, oomph::oomph_info, Q, Ramp_period, GlobalPhysicalVariables::Re, GlobalPhysicalVariables::ReSt, and St.

Referenced by main().

◆ solid_boundary_displacement() [1/2]

void Global_Parameters::solid_boundary_displacement	(	const Vector< double > &	x,
		Vector< double > &	u
	)

Real-valued, radial displacement field on inner boundary.

  {
   Vector<double> normal(2);
   double norm=sqrt(x[0]*x[0]+x[1]*x[1]);
   normal[0]=x[0]/norm;
   normal[1]=x[1]/norm;
  
   u[0]=Displacement_amplitude*normal[0];
   u[1]=Displacement_amplitude*normal[1];
  }

References Displacement_amplitude, WallFunction::normal(), sqrt(), and plotDoE::x.

◆ solid_boundary_displacement() [2/2]

void Global_Parameters::solid_boundary_displacement	(	const Vector< double > &	x,
		Vector< std::complex< double > > &	u
	)

Displacement field on inner boundary of solid.

  {
   Vector<double> normal(2);
   double norm=sqrt(x[0]*x[0]+x[1]*x[1]);
   double phi=atan2(x[1],x[0]);
   normal[0]=x[0]/norm;
   normal[1]=x[1]/norm;
  
   u[0]=complex<double>(normal[0]*cos(double(N)*phi),0.0);
   u[1]=complex<double>(normal[1]*cos(double(N)*phi),0.0);
  }

References atan2(), cos(), N, WallFunction::normal(), sqrt(), and plotDoE::x.

Referenced by AnnularDiskProblem< ELASTICITY_ELEMENT >::AnnularDiskProblem(), CoatedDiskProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::CoatedDiskProblem(), and CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::CoatedSphereProblem().

◆ u_r()

double Global_Parameters::u_r	(	const double &	time,
		const Vector< double > &	x
	)

Calculate the time dependent form of the r-component of displacement.

   {
    Vector<double> displ(3);
    exact_solution_th(x,displ);
    return cos(time)*displ[0];
   } // end_of_u_r

References cos(), exact_solution_th(), and plotDoE::x.

Referenced by exact_solution(), oomph::AxisymmetricPoroelasticityEquations::fill_in_generic_residual_contribution(), oomph::RefineableSphericalNavierStokesEquations::fill_in_generic_residual_contribution_spherical_nst(), oomph::SphericalNavierStokesEquations::fill_in_generic_residual_contribution_spherical_nst(), oomph::MinModLimiter::limit(), oomph::SphericalNavierStokesEquations::output(), AxisymmetricLinearElasticityProblem< ELEMENT, TIMESTEPPER >::set_boundary_conditions(), and AxisymmetricLinearElasticityProblem< ELEMENT, TIMESTEPPER >::set_initial_conditions().

◆ u_theta()

double Global_Parameters::u_theta	(	const double &	time,
		const Vector< double > &	x
	)

Calculate the time dependent form of the theta-component of displacement.

   {
    Vector<double> displ(3);
    exact_solution_th(x,displ);
    return cos(time)*displ[2];
   }

References cos(), exact_solution_th(), and plotDoE::x.

Referenced by Global::exact_solution(), exact_solution(), oomph::RefineableSphericalNavierStokesEquations::fill_in_generic_residual_contribution_spherical_nst(), oomph::SphericalNavierStokesEquations::fill_in_generic_residual_contribution_spherical_nst(), oomph::SphericalNavierStokesEquations::output(), AxisymmetricLinearElasticityProblem< ELEMENT, TIMESTEPPER >::set_boundary_conditions(), and AxisymmetricLinearElasticityProblem< ELEMENT, TIMESTEPPER >::set_initial_conditions().

◆ u_z()

double Global_Parameters::u_z	(	const double &	time,
		const Vector< double > &	x
	)

Calculate the time dependent form of the z-component of displacement.

   {
    Vector<double> displ(3);
    exact_solution_th(x,displ);
    return cos(time)*displ[1];
   }

References cos(), exact_solution_th(), and plotDoE::x.

Referenced by exact_solution(), AxisymmetricLinearElasticityProblem< ELEMENT, TIMESTEPPER >::set_boundary_conditions(), and AxisymmetricLinearElasticityProblem< ELEMENT, TIMESTEPPER >::set_initial_conditions().

◆ update_parameter_values()

void Global_Parameters::update_parameter_values ( )

Function to update dependent parameter values.

  {
   Omega_sq=Density_ratio*Q;
  }

References Density_ratio, Omega_sq, and Q.

Referenced by main().

◆ velocity_couette()

Vector<double> Global_Parameters::velocity_couette ( const Vector< double > & x )

Couette flow.

  {
   // Initialise velocity vector to return
   Vector<double> u(2,0.0);
  
   // Shifted origin
   double x_shifted=1.0+x[0];
   double y_shifted=1.0+x[1];
  
  
   // Polar coordinates
   double theta = atan2(y_shifted,x_shifted);
   double r=sqrt(x_shifted*x_shifted+y_shifted*y_shifted);
  
   double magnitude=A_couette*r+B_couette/r;
   u[0]=-magnitude*sin(theta);
   u[1]= magnitude*cos(theta);
  
   return u;
  }

References A_couette, atan2(), B_couette, cos(), oomph::VectorHelpers::magnitude(), UniformPSDSelfTest::r, sin(), sqrt(), BiharmonicTestFunctions2::theta, and plotDoE::x.

Referenced by exact_couette().

◆ velocity_pseudo_singularity_for_couette()

Vector<double> Global_Parameters::velocity_pseudo_singularity_for_couette ( const Vector< double > & x )

Pseudo_singularity for computation of Couette flow.

  {
   // Initialise velocity vector to return
   Vector<double> u(2,0.0);
  
   // Poiseuille flow
   u[0]=0.0;
   u[1]=x[0]*(1.0-x[0]);
  
  
   return u;
  }

References plotDoE::x.

Referenced by blended_grad_velocity_pseudo_singularity_for_couette(), and blended_velocity_pseudo_singularity_for_couette().

◆ velocity_singularity1()

Vector<double> Global_Parameters::velocity_singularity1 ( const Vector< double > & x )

Function that computes the fitting velocity solution near the corner (0,0)

  {
   using namespace MathematicalConstants;
  
   // Initialise velocity vector to return
   Vector<double> u(2,0.0);
   
   // Find angle of polar coordinates centered at the point (0,0)
   double theta = atan2(x[1],x[0]);
   
   u[0] = -(0.5*Pi*theta*sin(theta) + theta*cos(theta) - 0.25*Pi*Pi*sin(theta))*sin(theta)/(-1.0 + 0.25*Pi*Pi) - 1.0*(-theta*sin(theta) + 0.5*Pi*theta*cos(theta) + 0.5*Pi*sin(theta) - 0.25*Pi*Pi*cos(theta) + cos(theta))*cos(theta)/(-1.0 + 0.25*Pi*Pi);
  
   u[1] = (0.5*Pi*theta*sin(theta) + theta*cos(theta) - 0.25*Pi*Pi*sin(theta))*cos(theta)/(-1.0 + 0.25*Pi*Pi) - 1.0*(-theta*sin(theta) + 0.5*Pi*theta*cos(theta) + 0.5*Pi*sin(theta) - 0.25*Pi*Pi*cos(theta) + cos(theta))*sin(theta)/(-1.0 + 0.25*Pi*Pi);
  
   // return the velocity vector
   return u;
  }

References atan2(), cos(), BiharmonicTestFunctions2::Pi, sin(), BiharmonicTestFunctions2::theta, and plotDoE::x.

◆ velocity_singularity2()

Vector<double> Global_Parameters::velocity_singularity2 ( const Vector< double > & x )

Function that computes the fitting velocity solution near the corner (1,0)

Polar coordinates centered at the point (1,0)

Value of the U component at the angle theta

Value of the V component at the angle theta

  {
   using namespace MathematicalConstants;
  
   // Variable change
   Vector<double> x1(2);
   x1[0] = 1.0-x[0];
   x1[1] = x[1];
  
   //double r = sqrt(x1[0]*x1[0] + x1[1]*x1[1]);
   double theta = atan2(x1[1],x1[0]);
  
   // Initialise the velocity vector
   Vector<double> u(2,0.0);
  
   u[0] = (0.5*Pi*theta*sin(theta) + theta*cos(theta) - 0.25*Pi*Pi*sin(theta))*sin(theta)/(-1.0 + 0.25*Pi*Pi) + 1.0*(-theta*sin(theta) + 0.5*Pi*theta*cos(theta) + 0.5*Pi*sin(theta) - 0.25*Pi*Pi*cos(theta) + cos(theta))*cos(theta)/(-1.0 + 0.25*Pi*Pi);
   u[0] = - u[0];
  
   u[1] = -(0.5*Pi*theta*sin(theta) + theta*cos(theta) - 0.25*Pi*Pi*sin(theta))*cos(theta)/(-1.0 + 0.25*Pi*Pi) + 1.0*(-theta*sin(theta) + 0.5*Pi*theta*cos(theta) + 0.5*Pi*sin(theta) - 0.25*Pi*Pi*cos(theta) + cos(theta))*sin(theta)/(-1.0 + 0.25*Pi*Pi);
  
   return u;
  }

References atan2(), cos(), BiharmonicTestFunctions2::Pi, sin(), BiharmonicTestFunctions2::theta, plotDoE::x, and Global_parameters::x1().

Variable Documentation

◆ A_couette

double Global_Parameters::A_couette =1.0

Amplitude of linearly varying part.

Referenced by pressure_couette(), and velocity_couette().

◆ ABC_order

unsigned Global_Parameters::ABC_order =3

Order of absorbing/appproximate boundary condition.

Referenced by CoatedDiskProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::create_helmholtz_ABC_elements().

◆ Add_refinement_level

unsigned Global_Parameters::Add_refinement_level =1

The additional levels of uniform refinement.

Referenced by main().

◆ Alpha

double Global_Parameters::Alpha =0.0

Peakiness parameter for pressure load.

Referenced by main(), and FlowAroundCylinderProblem< ELEMENT >::set_boundary_conditions().

◆ Amplitude

double Global_Parameters::Amplitude = 1.0

Amplitude of traction applied.

Referenced by exact_solution(), and periodic_traction().

◆ B

double Global_Parameters::B =0.7

Referenced by GeneralEllipse::b(), and main().

◆ B_couette

double Global_Parameters::B_couette =1.0

Amplitude of singular part.

Referenced by pressure_couette(), and velocity_couette().

◆ Box_half_length

double Global_Parameters::Box_half_length = 1.0

(Half)height of the box

Referenced by TetmeshPoissonProblem< ELEMENT >::TetmeshPoissonProblem().

◆ Box_half_width

double Global_Parameters::Box_half_width = 1.5

(Half-)width of the box

Referenced by TetmeshPoissonProblem< ELEMENT >::TetmeshPoissonProblem().

◆ Box_length

double Global_Parameters::Box_length = 10.0

Referenced by CubicTetMeshFacetedSurface::CubicTetMeshFacetedSurface(), and RisingBubbleProblem< ELEMENT >::RisingBubbleProblem().

◆ Box_width

double Global_Parameters::Box_width = 3.0

Referenced by FallingBlockProblem< ELEMENT >::actions_before_newton_solve(), CubicTetMeshFacetedSurface::CubicTetMeshFacetedSurface(), and RisingBubbleProblem< ELEMENT >::RisingBubbleProblem().

◆ Ca

double Global_Parameters::Ca = 1.0

Set the Capillary number.

Referenced by RisingBubbleProblem< ELEMENT >::create_free_surface_elements(), and RisingBubbleProblem< ELEMENT >::RisingBubbleProblem().

◆ Case_ID

string Global_Parameters::Case_ID ="FSI1"

Default case ID.

Referenced by main(), and set_parameters().

◆ Centre_x

double Global_Parameters::Centre_x =2.0

x position of centre of cylinder

Referenced by TurekProblem< FLUID_ELEMENT, SOLID_ELEMENT >::build_mesh(), GeneralEllipse::centre_x(), RectangleWithHoleDomain::centre_x(), oomph::AlgebraicCylinderWithFlagMesh< ELEMENT >::node_update_IV(), oomph::AlgebraicCylinderWithFlagMesh< ELEMENT >::node_update_V(), FilledCircle::position(), GeneralCircle::position(), GeneralEllipse::position(), RectangleWithHoleDomain::RectangleWithHoleDomain(), and TurekProblem< FLUID_ELEMENT, SOLID_ELEMENT >::TurekProblem().

◆ Centre_y

double Global_Parameters::Centre_y =2.0

y position of centre of cylinder

Referenced by TurekProblem< FLUID_ELEMENT, SOLID_ELEMENT >::build_mesh(), GeneralEllipse::centre_y(), RectangleWithHoleDomain::centre_y(), oomph::AlgebraicCylinderWithFlagMesh< ELEMENT >::node_update_IV(), oomph::AlgebraicCylinderWithFlagMesh< ELEMENT >::node_update_V(), FilledCircle::position(), GeneralCircle::position(), GeneralEllipse::position(), RectangleWithHoleDomain::RectangleWithHoleDomain(), and TurekProblem< FLUID_ELEMENT, SOLID_ELEMENT >::TurekProblem().

◆ Constitutive_law_pseudo_elastic_pt

ConstitutiveLaw * Global_Parameters::Constitutive_law_pseudo_elastic_pt =0

Pointer to constitutive law for the pseudo elastic node update elements.

Referenced by main(), and PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::PseudoElasticCollapsibleChannelProblem().

◆ Constitutive_law_pt

ConstitutiveLaw * Global_Parameters::Constitutive_law_pt =0

Pointer to constitutive law.

Create constitutive law.

Constitutive law used to determine the mesh deformation.

Constitutive law for the solid (and pseudo-solid) mechanics.

Referenced by RisingBubbleProblem< ELEMENT >::actions_after_adapt(), TurekProblem< FLUID_ELEMENT, SOLID_ELEMENT >::build_mesh(), main(), RisingBubbleProblem< ELEMENT >::RisingBubbleProblem(), set_parameters(), TurekProblem< FLUID_ELEMENT, SOLID_ELEMENT >::TurekProblem(), UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::UnstructuredFSIProblem(), and TurekProblem< FLUID_ELEMENT, SOLID_ELEMENT >::~TurekProblem().

◆ Constitutive_law_wall_pt

ConstitutiveLaw * Global_Parameters::Constitutive_law_wall_pt =0

Pointer to constitutive law for the wall.

Referenced by main(), and PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::PseudoElasticCollapsibleChannelProblem().

◆ Density_ratio

double Global_Parameters::Density_ratio =0.0

Density ratio: solid to fluid.

Density ratio for the two regions: solid to fluid.

Density ratio (solid to fluid; default assignment for FSI1 test case)

Referenced by CoatedDiskProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::doc_solution(), CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::doc_solution(), main(), and update_parameter_values().

◆ Direction

unsigned Global_Parameters::Direction = 1

◆ Directory

string Global_Parameters::Directory ="RESLT"

Output directory.

Referenced by AnnularDiskProblem< ELASTICITY_ELEMENT >::AnnularDiskProblem(), CoatedDiskProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::CoatedDiskProblem(), CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::CoatedSphereProblem(), ElasticAnnulusProblem< ELASTICITY_ELEMENT >::ElasticAnnulusProblem(), main(), and RingWithTRibProblem< ELASTICITY_ELEMENT >::RingWithTRibProblem().

◆ Displacement_amplitude

double Global_Parameters::Displacement_amplitude =0.1

Displacement amplitude on inner radius.

Referenced by solid_boundary_displacement().

◆ Doc_convergence_flag

unsigned Global_Parameters::Doc_convergence_flag =0

Variable used to decide whether or not convergence information is displayed: 0 = Don't display convergence information 1 = Display convergence information

Referenced by main().

◆ Doc_info

DocInfo Global_Parameters::Doc_info

DocInfo object used for documentation of the solution.

Referenced by FluxPoissonMGProblem< ELEMENT, MESH >::doc_solution(), UnitCubePoissonMGProblem< ELEMENT, MESH >::doc_solution(), and main().

◆ Dt

double Global_Parameters::Dt =0.01

Timestep.

Timestep for simulation: 40 steps per period.

Referenced by main(), and PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::unsteady_run().

◆ E

TimeHarmonicIsotropicElasticityTensor Global_Parameters::E = 1.0

Define the non-dimensional Young's modulus.

The elasticity tensor.

Elastic modulus.

The elasticity tensor for the solid.

Referenced by AnnularDiskProblem< ELASTICITY_ELEMENT >::AnnularDiskProblem(), AxisymmetricLinearElasticityProblem< ELEMENT, TIMESTEPPER >::AxisymmetricLinearElasticityProblem(), CoatedDiskProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::CoatedDiskProblem(), CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::complete_problem_setup(), FourierDecomposedTimeHarmonicLinearElasticityProblem< ELEMENT >::complete_problem_setup(), FourierDecomposedTimeHarmonicLinearElasticityProblem< ELEMENT >::FourierDecomposedTimeHarmonicLinearElasticityProblem(), main(), PeriodicLoadProblem< ELEMENT >::PeriodicLoadProblem(), and RefineablePeriodicLoadProblem< ELEMENT >::RefineablePeriodicLoadProblem().

◆ E_pt

Vector< TimeHarmonicIsotropicElasticityTensor * > Global_Parameters::E_pt

The elasticity tensors for the two regions.

The elasticity tensor.

Referenced by Problem_Parameter::bulk_elasticity_tensor_pt(), oomph::HomogenisedLinearElasticityEquations< DIM >::calculate_effective_modulus(), CoatedDiskProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::complete_problem_setup(), ElasticAnnulusProblem< ELASTICITY_ELEMENT >::complete_problem_setup(), RingWithTRibProblem< ELASTICITY_ELEMENT >::complete_problem_setup(), Problem_Parameter::fibre_elasticity_tensor_pt(), oomph::HomogenisedLinearElasticityEquations< DIM >::fill_in_generic_contribution_to_residuals_linear_elasticity(), oomph::HomogenisedLinearElasticityEquationsBase::get_E_pt(), main(), and RingWithTRibProblem< ELASTICITY_ELEMENT >::RingWithTRibProblem().

◆ El_multiplier

unsigned Global_Parameters::El_multiplier =1

Multiplier for number of elements.

Referenced by CoatedDiskProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::CoatedDiskProblem(), CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::CoatedSphereProblem(), and main().

◆ Element_area

double Global_Parameters::Element_area = 0.01

helper to set target mesh element size

Referenced by ElasticAnnulusProblem< ELASTICITY_ELEMENT >::ElasticAnnulusProblem(), and main().

◆ Element_multiplier

unsigned Global_Parameters::Element_multiplier = 1

Referenced by main().

◆ Finite

bool Global_Parameters::Finite =false

Specify problem to be solved (boundary conditons for finite or infinite domain).

Referenced by PeriodicLoadProblem< ELEMENT >::PeriodicLoadProblem(), and RefineablePeriodicLoadProblem< ELEMENT >::RefineablePeriodicLoadProblem().

◆ Fluid_height

double Global_Parameters::Fluid_height =1.0

height of fluid mesh

Referenced by FSIChannelWithLeafletProblem< ELEMENT >::actions_before_implicit_timestep(), and FSIChannelWithLeafletProblem< ELEMENT >::FSIChannelWithLeafletProblem().

◆ Fluid_length_left

double Global_Parameters::Fluid_length_left =1.0

length of fluid mesh to left of leaflet

Referenced by FSIChannelWithLeafletProblem< ELEMENT >::FSIChannelWithLeafletProblem().

◆ Fluid_length_right

double Global_Parameters::Fluid_length_right =3.0

length of fluid mesh to right of leaflet

Referenced by FSIChannelWithLeafletProblem< ELEMENT >::FSIChannelWithLeafletProblem().

◆ Fourier_wavenumber

int Global_Parameters::Fourier_wavenumber =0

Define azimuthal Fourier wavenumber.

Define Fourier wavenumber.

Referenced by boundary_traction(), CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::CoatedSphereProblem(), CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::complete_problem_setup(), FourierDecomposedTimeHarmonicLinearElasticityProblem< ELEMENT >::complete_problem_setup(), CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::doc_solution(), and FourierDecomposedTimeHarmonicLinearElasticityProblem< ELEMENT >::FourierDecomposedTimeHarmonicLinearElasticityProblem().

◆ G

Vector< double > Global_Parameters::G

Gravity.

Referenced by RisingBubbleProblem< ELEMENT >::actions_after_adapt(), FlowAroundHalfCylinderProblem< ELEMENT >::FlowAroundHalfCylinderProblem(), main(), and RisingBubbleProblem< ELEMENT >::RisingBubbleProblem().

◆ Gmsh_command_line_invocation

std::string Global_Parameters::Gmsh_command_line_invocation ="/home/mheil/gmesh/bin/bin/gmsh"

Specify how to call gmsh from the command line.

Referenced by main(), and TetmeshPoissonProblem< ELEMENT >::TetmeshPoissonProblem().

◆ Gravity

double Global_Parameters::Gravity =0.0

Non-dim gravity (default assignment for FSI1 test case)

Non-dim gravity.

Referenced by Global_Physical_Variables::body_force(), gravity(), and main().

◆ H

double Global_Parameters::H =0.15

wall thickness

Height of flag.

Non-dimensional wall thickness.

Referenced by TurekProblem< FLUID_ELEMENT, SOLID_ELEMENT >::build_mesh(), FSIChannelWithLeafletProblem< ELEMENT >::FSIChannelWithLeafletProblem(), PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::PseudoElasticCollapsibleChannelProblem(), and TurekProblem< FLUID_ELEMENT, SOLID_ELEMENT >::TurekProblem().

◆ H_annulus

double Global_Parameters::H_annulus =0.5

Thickness of annulus.

Referenced by AnnularDiskProblem< ELASTICITY_ELEMENT >::AnnularDiskProblem(), and RingWithTRibProblem< ELASTICITY_ELEMENT >::RingWithTRibProblem().

◆ H_coating

double Global_Parameters::H_coating =0.3

Non-dim thickness of elastic coating.

Referenced by axisym_coefficient(), CoatedDiskProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::CoatedDiskProblem(), and CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::CoatedSphereProblem().

◆ Ignore_fluid_loading

bool Global_Parameters::Ignore_fluid_loading =false

Ignore fluid (default assignment for FSI1 test case)

Referenced by TurekProblem< FLUID_ELEMENT, SOLID_ELEMENT >::actions_after_adapt(), TurekProblem< FLUID_ELEMENT, SOLID_ELEMENT >::actions_after_distribute(), TurekProblem< FLUID_ELEMENT, SOLID_ELEMENT >::generic_actions_after(), set_parameters(), and TurekProblem< FLUID_ELEMENT, SOLID_ELEMENT >::TurekProblem().

◆ Impulsive_start_flag

unsigned Global_Parameters::Impulsive_start_flag =0

Flag for impulsive start: Default = start from exact time-periodic solution.

Referenced by main(), RayleighProblem< ELEMENT, TIMESTEPPER >::unsteady_run(), and RayleighTractionProblem< ELEMENT, TIMESTEPPER >::unsteady_run().

◆ Initial_element_volume

double Global_Parameters::Initial_element_volume =1.0

◆ K_squared

double Global_Parameters::K_squared =10.0

Square of wavenumber for the Helmholtz equation.

Referenced by axisym_coefficient(), CoatedDiskProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::CoatedDiskProblem(), CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::CoatedSphereProblem(), CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::complete_problem_setup(), CoatedDiskProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::doc_solution(), CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::doc_solution(), exact_axisym_potential(), exact_axisym_radiated_power(), and main().

◆ L

double Global_Parameters::L =12.0

tube length

Referenced by PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::actions_after_adapt(), main(), and PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::PseudoElasticCollapsibleChannelProblem().

◆ L_pml_multiplier

double Global_Parameters::L_pml_multiplier = 1.0

Referenced by compute_dependent_parameters(), and main().

◆ L_x

double Global_Parameters::L_x =1.0

Referenced by main().

◆ L_y

double Global_Parameters::L_y =1.0

Referenced by main().

◆ Lambda

double Global_Parameters::Lambda = E*Nu/(1.0+Nu)/(1.0-2.0*Nu)

Lame parameters.

Referenced by body_force(), boundary_traction(), QCrouzeixRaviartElementWithTwoExternalElement< DIM >::Default_Physical_Constant_Value(), oomph::deriv_functions::SimpleStiffTest::derivative(), oomph::deriv_functions::OrderReductionTest::derivative(), oomph::deriv_functions::SimpleStiffTest::operator()(), oomph::deriv_functions::OrderReductionTest::OrderReductionTest(), and oomph::deriv_functions::SimpleStiffTest::SimpleStiffTest().

◆ lambda

std::complex< double > Global_Parameters::lambda = E*Nu/(1.0+Nu)/(1.0-2.0*Nu)

Referenced by boundary_traction().

◆ Lambda_sq

double Global_Parameters::Lambda_sq =0.0

Timescale ratio (non-dim density) for solid.

Pseudo-solid mass density.

Timescale ratio for solid (dependent parameter assigned in set_parameters())

Referenced by TurekProblem< FLUID_ELEMENT, SOLID_ELEMENT >::build_mesh(), FSIChannelWithLeafletProblem< ELEMENT >::FSIChannelWithLeafletProblem(), PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::PseudoElasticCollapsibleChannelProblem(), TurekProblem< FLUID_ELEMENT, SOLID_ELEMENT >::TurekProblem(), and UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::UnstructuredFSIProblem().

◆ Lambda_sq_beam

double Global_Parameters::Lambda_sq_beam =0.0

Beam mass density.

Referenced by FSIChannelWithLeafletProblem< ELEMENT >::doc_parameters(), and FSIChannelWithLeafletProblem< ELEMENT >::FSIChannelWithLeafletProblem().

◆ Ldown

double Global_Parameters::Ldown =3.0

downstream length

Referenced by PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::actions_after_adapt(), CollapsibleChannelProblem< ELEMENT >::CollapsibleChannelProblem(), FSICollapsibleChannelProblem< ELEMENT >::FSICollapsibleChannelProblem(), PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::PseudoElasticCollapsibleChannelProblem(), and CollapsibleChannelProblem< ELEMENT >::unsteady_run().

◆ Leaflet_height

double Global_Parameters::Leaflet_height =0.5

height of leaflet

Referenced by FSIChannelWithLeafletProblem< ELEMENT >::FSIChannelWithLeafletProblem().

◆ Leaflet_x0

double Global_Parameters::Leaflet_x0 = 1.0

x-position of root of leaflet

Referenced by FSIChannelWithLeafletProblem< ELEMENT >::FSIChannelWithLeafletProblem().

◆ Linear_solver_flag

unsigned Global_Parameters::Linear_solver_flag =1

The choice of linear solver 0 = SuperLU 1 = Multigrid

Referenced by main(), and UnitCubePoissonMGProblem< ELEMENT, MESH >::~UnitCubePoissonMGProblem().

◆ Long_run_flag

unsigned Global_Parameters::Long_run_flag =1

Flag for long/short run: Default = perform long run.

Referenced by main(), RayleighProblem< ELEMENT, TIMESTEPPER >::unsteady_run(), and RayleighTractionProblem< ELEMENT, TIMESTEPPER >::unsteady_run().

◆ Lr

double Global_Parameters::Lr = 1.0

Length of domain in r direction.

Referenced by InterfaceProblem< ELEMENT, TIMESTEPPER >::deform_free_surface(), InterfaceProblem< ELEMENT, TIMESTEPPER >::InterfaceProblem(), and main().

◆ Lup

double Global_Parameters::Lup =1.5

upstream length

Referenced by PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::actions_after_adapt(), CollapsibleChannelProblem< ELEMENT >::CollapsibleChannelProblem(), FSICollapsibleChannelProblem< ELEMENT >::FSICollapsibleChannelProblem(), PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::PseudoElasticCollapsibleChannelProblem(), and CollapsibleChannelProblem< ELEMENT >::unsteady_run().

◆ Lx

double Global_Parameters::Lx = 1.0

Length of domain in x direction.

Referenced by ChannelSpineFlowProblem< ELEMENT >::ChannelSpineFlowProblem(), InterfaceProblem< ELEMENT, TIMESTEPPER >::deform_free_surface(), exact_solution(), Eigen::SimplicialCholeskyBase< Derived >::factorize_preordered(), FSIDrivenCavityProblem< ELEMENT >::FSIDrivenCavityProblem(), LinearWaveProblem< ELEMENT, TIMESTEPPER >::LinearWaveProblem(), main(), periodic_traction(), oomph::SimpleRectangularQuadMesh< ELEMENT >::SimpleRectangularQuadMesh(), TwoDDGMesh< ELEMENT >::TwoDDGMesh(), Eigen::umfpack_get_numeric(), and ElasticInterfaceProblem< ELEMENT, TIMESTEPPER >::unsteady_run().

◆ Ly

double Global_Parameters::Ly = 2.0

Length of domain in y direction.

Referenced by SpikedChannelSpineFlowProblem< ELEMENT >::actions_before_newton_solve(), ChannelSpineFlowProblem< ELEMENT >::ChannelSpineFlowProblem(), CollapsibleChannelProblem< ELEMENT >::CollapsibleChannelProblem(), doc_sparse_node_update(), exact_solution(), FSICollapsibleChannelProblem< ELEMENT >::FSICollapsibleChannelProblem(), FSIDrivenCavityProblem< ELEMENT >::FSIDrivenCavityProblem(), LinearWaveProblem< ELEMENT, TIMESTEPPER >::LinearWaveProblem(), main(), FSICollapsibleChannelProblem< ELEMENT >::set_initial_condition(), CollapsibleChannelProblem< ELEMENT >::set_initial_condition(), CollapsibleChannelProblem< ELEMENT >::set_poiseuille_outflow(), oomph::SimpleRectangularQuadMesh< ELEMENT >::SimpleRectangularQuadMesh(), SpikedChannelSpineFlowProblem< ELEMENT >::SpikedChannelSpineFlowProblem(), TwoDDGMesh< ELEMENT >::TwoDDGMesh(), and ElasticInterfaceProblem< ELEMENT, TIMESTEPPER >::unsteady_run().

◆ Lz

double Global_Parameters::Lz = 2.0

Length of domain in z-direction.

Referenced by SinusoidalWall::d2position(), SinusoidalWall::dposition(), main(), and SinusoidalWall::position().

◆ M

unsigned Global_Parameters::M =4

Wavenumber "zenith"-variation of imposed displacement of coating on inner boundary

Referenced by main().

◆ Max_flux

double Global_Parameters::Max_flux =1.0

Max. flux.

Referenced by set_parameters().

◆ Mesh_nleft

unsigned Global_Parameters::Mesh_nleft =4

Num elements to left of leaflet in coarse mesh.

Referenced by FSIChannelWithLeafletProblem< ELEMENT >::FSIChannelWithLeafletProblem().

◆ Mesh_nright

unsigned Global_Parameters::Mesh_nright =12

Num elements to right of leaflet in coarse mesh.

Referenced by FSIChannelWithLeafletProblem< ELEMENT >::FSIChannelWithLeafletProblem().

◆ Mesh_ny1

unsigned Global_Parameters::Mesh_ny1 =2

Num elements in fluid mesh in y dirn adjacent to leaflet.

Referenced by FSIChannelWithLeafletProblem< ELEMENT >::FSIChannelWithLeafletProblem().

◆ Mesh_ny2

unsigned Global_Parameters::Mesh_ny2 =2

Num elements in fluid mesh in y dirn above leaflet.

Referenced by FSIChannelWithLeafletProblem< ELEMENT >::FSIChannelWithLeafletProblem().

◆ Min_flux

double Global_Parameters::Min_flux =0.0

Min. flux.

◆ Min_refinement_level

unsigned Global_Parameters::Min_refinement_level =2

The minimum level of uniform refinement.

Referenced by main().

◆ Mu

double Global_Parameters::Mu = E/2.0/(1.0+Nu)

Referenced by body_force(), boundary_traction(), and SilbertPeriodic::set_study().

◆ mu

std::complex< double > Global_Parameters::mu = E/2.0/(1.0+Nu)

◆ N

unsigned Global_Parameters::N =0

Azimuthal wavenumber for imposed displacement of coating on inner boundary

Referenced by main().

◆ N_adaptations

unsigned Global_Parameters::N_adaptations =1

The number of adaptations allowed by the Newton solver.

Referenced by main().

◆ N_pml_multiplier

unsigned Global_Parameters::N_pml_multiplier = 1

PML width in elements for the right layer.

Referenced by compute_dependent_parameters(), and main().

◆ N_slice

unsigned Global_Parameters::N_slice =4

number of axial slices in fluid mesh

Referenced by PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::PseudoElasticCollapsibleChannelProblem().

◆ N_x

unsigned Global_Parameters::N_x =10

◆ N_x_left_pml

unsigned Global_Parameters::N_x_left_pml = 8

PML width in elements for the left layer.

Referenced by compute_dependent_parameters(), ElasticAnnulusProblem< ELASTICITY_ELEMENT >::create_pml_meshes(), and main().

◆ N_x_right_pml

unsigned Global_Parameters::N_x_right_pml = 8

PML width in elements for the right layer.

Referenced by compute_dependent_parameters(), ElasticAnnulusProblem< ELASTICITY_ELEMENT >::create_pml_meshes(), and main().

◆ N_y

unsigned Global_Parameters::N_y =10

◆ N_y_bottom_pml

unsigned Global_Parameters::N_y_bottom_pml = 8

PML width in elements for the left layer.

Referenced by compute_dependent_parameters(), ElasticAnnulusProblem< ELASTICITY_ELEMENT >::create_pml_meshes(), and main().

◆ N_y_top_pml

unsigned Global_Parameters::N_y_top_pml = 8

PML width in elements for the top layer.

Referenced by compute_dependent_parameters(), ElasticAnnulusProblem< ELASTICITY_ELEMENT >::create_pml_meshes(), and main().

◆ Nnode_1d

unsigned Global_Parameters::Nnode_1d =2

The number of nodes in one direction (default=2)

Referenced by main().

◆ Nperiod

unsigned Global_Parameters::Nperiod =5

Number of periods.

Referenced by PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::unsteady_run().

◆ Nr

unsigned Global_Parameters::Nr = 5

Number of elements in r-direction.

Number of elements in radial direction.

Referenced by AnnularDiskProblem< ELASTICITY_ELEMENT >::AnnularDiskProblem(), AxisymmetricLinearElasticityProblem< ELEMENT, TIMESTEPPER >::AxisymmetricLinearElasticityProblem(), CapProblem< ELEMENT >::CapProblem(), main(), and SphericalSteadyRotationProblem< ELEMENT >::parameter_study().

◆ Nstep_per_period

unsigned Global_Parameters::Nstep_per_period =40

Number of steps per period.

Referenced by main(), and PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::unsteady_run().

◆ Ntheta

unsigned Global_Parameters::Ntheta =20

Number of elements in azimuthal direction.

Referenced by AnnularDiskProblem< ELASTICITY_ELEMENT >::AnnularDiskProblem(), main(), and SphericalSteadyRotationProblem< ELEMENT >::parameter_study().

◆ Nu

double Global_Parameters::Nu = 0.3

Define Poisson's ratio Nu.

Poisson's ratio Nu.

Define Poisson coefficient Nu.

Poisson's ratio for generalised Hookean constitutive equation.

Pseudo-solid Poisson ratio.

Poisson's ratio.

Referenced by AxisymmetricLinearElasticityProblem< ELEMENT, TIMESTEPPER >::AxisymmetricLinearElasticityProblem(), CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::CoatedSphereProblem(), CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::complete_problem_setup(), FourierDecomposedTimeHarmonicLinearElasticityProblem< ELEMENT >::complete_problem_setup(), FourierDecomposedTimeHarmonicLinearElasticityProblem< ELEMENT >::FourierDecomposedTimeHarmonicLinearElasticityProblem(), FSIChannelWithLeafletProblem< ELEMENT >::FSIChannelWithLeafletProblem(), main(), and RingWithTRibProblem< ELASTICITY_ELEMENT >::RingWithTRibProblem().

◆ Nu_pseudo_elastic

double Global_Parameters::Nu_pseudo_elastic =0.1

Poisson's ratio for generalised Hookean constitutive equation for the pseudo elastic bulk

Referenced by main().

◆ Nu_wall

double Global_Parameters::Nu_wall =0.3

Poisson's ratio for generalised Hookean constitutive equation for the wall

Referenced by main().

◆ Nz

unsigned Global_Parameters::Nz = 10

Number of elements in z-direction.

Referenced by Vreman::add_particles(), NautaMixer::addParticlesAtWall(), AxisymmetricLinearElasticityProblem< ELEMENT, TIMESTEPPER >::AxisymmetricLinearElasticityProblem(), oomph::ExtrudedCubeMeshFromQuadMesh< ELEMENT >::build_mesh(), oomph::SimpleCubicMesh< ELEMENT >::build_mesh(), MyCanyonMesh< ELEMENT, INTERFACE_ELEMENT >::build_single_layer_mesh(), MyTipMesh< ELEMENT, INTERFACE_ELEMENT >::build_single_layer_mesh(), oomph::SingleLayerCubicSpineMesh< ELEMENT >::build_single_layer_mesh(), and CoilSelfTest::setupInitialConditions().

◆ Omega_sq

double Global_Parameters::Omega_sq = 0.5

Square of the frequency of the time dependence.

Square of non-dim frequency.

Square of non-dim frequency for the two regions – dependent variable!

Non-dim square of frequency for solid – dependent variable!

Define the non-dimensional square angular frequency of time-harmonic motion

Referenced by AnnularDiskProblem< ELASTICITY_ELEMENT >::AnnularDiskProblem(), AxisymmetricLinearElasticityProblem< ELEMENT, TIMESTEPPER >::AxisymmetricLinearElasticityProblem(), body_force(), CoatedDiskProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::CoatedDiskProblem(), CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::CoatedSphereProblem(), CoatedDiskProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::complete_problem_setup(), CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::complete_problem_setup(), ElasticAnnulusProblem< ELASTICITY_ELEMENT >::complete_problem_setup(), FourierDecomposedTimeHarmonicLinearElasticityProblem< ELEMENT >::complete_problem_setup(), CoatedDiskProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::doc_solution(), CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::doc_solution(), exact_u(), FourierDecomposedTimeHarmonicLinearElasticityProblem< ELEMENT >::FourierDecomposedTimeHarmonicLinearElasticityProblem(), main(), and update_parameter_values().

◆ Omega_sq_region

Vector<double> Global_Parameters::Omega_sq_region(2, Omega_sq)	(	2	,
		Omega_sq
	)

Square of non-dim frequency for the two regions.

Referenced by RingWithTRibProblem< ELASTICITY_ELEMENT >::complete_problem_setup(), and main().

◆ Outer_radius

double Global_Parameters::Outer_radius =4.0

Radius of outer boundary of Helmholtz domain.

Referenced by CoatedDiskProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::CoatedDiskProblem(), CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::CoatedSphereProblem(), CoatedDiskProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::create_helmholtz_ABC_elements(), CoatedSphereProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::doc_solution(), and main().

◆ Output_management_flag

unsigned Global_Parameters::Output_management_flag =0

The MG solver allows for five different levels of output: 0 = Outputs everything 1 = Outputs everything and plots refinement and unrefinement patterns 2 = Outputs everything except the smoother timings 3 = Outputs setup information but no V-cycle timings 4 = Suppresses all output Note: choosing '1' will also keep the coarser problems alive

Referenced by main().