Classes | Enumerations | Functions | Variables
GlobalParameters Namespace Reference

Global parameters. More...

Classes

class  TestPMLMapping
 

Enumerations

enum  Cases { Spherical_cap_in_cylinder_pinned , All_pinned , Barrel_shape , T_junction_with_nonzero_contact_angle }
 Enumeration for the possible cases. More...
 

Functions

void get_pressure (const Vector< double > &x, double &pressure)
 Pressure depending on the position (x,y) More...
 
void zero (const Vector< double > &x, Vector< double > &u)
 
void update_parameters ()
 Update parameters. More...
 
void get_source (const double &time, const Vector< double > &x, double &source)
 Source function. More...
 
void get_exact_u (const double &time, const Vector< double > &x, Vector< double > &u)
 Exact solution as a Vector. More...
 
double melt_flux (const double &t)
 
double radius (const double &t)
 Exact radius of inner circle. More...
 
double incoming_sb_inside (const double &t)
 Incoming sb radiation on inside. More...
 
double incoming_sb_outside (const double &t)
 Incoming sb radiation on outside. More...
 
std::complex< double > I (0.0, 1.0)
 Imaginary unit. More...
 
void get_exact_u (const Vector< double > &x, Vector< double > &u)
 Exact solution as a Vector. More...
 
void prescribed_incoming_flux (const Vector< double > &x, complex< double > &flux)
 
double step_position (const double &time)
 Position of step (x-axis intercept) More...
 
void get_exact_u (const double &time, const Vector< double > &x, double &u)
 Exact solution as a scalar. More...
 
void prescribed_flux_on_fixed_y_boundary (const double &time, const Vector< double > &x, double &flux)
 Flux required by the exact solution on a boundary on which y is fixed. More...
 
void get_simple_exact_u (const Vector< double > &x, Vector< double > &u)
 Get the exact solution, u, at the spatial position, x. More...
 
bool is_in_pinned_region (const Vector< double > &x)
 
void get_exact_u (const Vector< double > &x, Vector< double > &u, const double &alpha=0.25 *MathematicalConstants::Pi)
 
void get_exact_u_bessel (const Vector< double > &x, Vector< double > &u)
 
void default_get_exact_u (const Vector< double > &x, Vector< double > &u)
 
double calculate_strouhal_number (const double &re)
 
void update_simulation_parameters ()
 
void doc_navier_stokes_parameters ()
 Document the value of the Reynolds number and Womersley number. More...
 
void doc_maximum_central_box_deformation ()
 Document the maximum deformation inside the central box. More...
 
double round (const double &d)
 ---------------------------------------—DOCUMENTATION HELPERS---— More...
 
void update_physical_parameters ()
 
void update_mesh_parameters ()
 
void set_up_dof_to_block_mapping (Vector< unsigned > &dof_to_block_map)
 
std::string parameter_to_string (const double *const parameter_pt)
 
void find_node_on_centerline (Mesh *mesh_pt, FiniteElement **el_centerline_pt, unsigned &node_index)
 --------------------—Documentation Helpers----------------------— More...
 
void sin_cos_velocity_field (const Vector< double > &x, Vector< double > &u)
 
void sin_cos_vorticity (const Vector< double > &x, Vector< Vector< double > > &vort_and_derivs)
 
void synthetic_velocity_field (const Vector< double > &x, Vector< double > &veloc)
 Synthetic velocity field for validation. More...
 
void synthetic_vorticity (const Vector< double > &x, Vector< Vector< double > > &vort_and_derivs)
 Synthetic vorticity field and derivs for validation. More...
 
void initial_condition (const Vector< double > &x, Vector< double > &u)
 Initial condition for velocity. More...
 
double get_exact_kappa ()
 Exact kappa. More...
 
void spine_base_function (const Vector< double > &x, Vector< double > &spine_B, Vector< Vector< double > > &dspine_B)
 
void spine_function (const Vector< double > &x, Vector< double > &spine, Vector< Vector< double > > &dspine)
 
void setup_dependent_parameters_and_sanity_check ()
 Setup dependent parameters and perform sanity check. More...
 
void spine_base_function (const Vector< double > &x, Vector< double > &spine_B, Vector< Vector< double > > &dspine_B)
 
void spine_function (const Vector< double > &xx, Vector< double > &spine, Vector< Vector< double > > &dspine)
 
double distorted_y (const double &y_normalised)
 Function to distort mesh. More...
 
void get_source (const Vector< double > &x, double &source)
 Source function required to make the solution above an exact solution. More...
 

Variables

double Eta = 2.39e6
 FvK parameter. More...
 
double R_b = 0.1
 The "bubble" radius. More...
 
double Pressure =0.0
 The pressure. More...
 
double Re =100.0
 Reynolds number. More...
 
double L_z =3.0
 Length of the mesh in the z-direction. More...
 
unsigned N_z =5
 Number of elements in the z-direction. More...
 
DocInfo Doc_info
 Helper for documenting. More...
 
OscillatingCylinder * Cylinder_pt =0
 ---------------------------------—TIME-INTEGRATION PARAMETERS---— More...
 
double Radius =0.5
 Radius of the cylinder. More...
 
double Amplitude =0.50
 Amplitude of the cylinder motion. More...
 
double Length_of_box =10.0
 ----------------------—Cylinder Properties----------------------— More...
 
double Length_z =1.0
 The length of the extruded mesh in the z-direction. More...
 
unsigned N_element_z =10
 Number of elements in the z-direction (in the extruded mesh) More...
 
unsigned N_uniform_refinement_before_solve =2
 Number of uniform refinements before any solve. More...
 
double Annular_region_radius =1.0
 The radius of the annular region surrounding the cylinder. More...
 
string Directory ="RESLT"
 Output directory. More...
 
unsigned Nintpt =10
 Number of integration points for new integration scheme (if used) More...
 
double Sigma = 1.0e-2
 Non-dim Stefan Boltzmann constant. More...
 
double Theta_0 =1.0
 Zero degrees Celsius offset in Stefan Boltzmann law. More...
 
double Alpha0 =1.0
 Thermal inertia in inner region. More...
 
double Alpha1 =1.0
 Thermal inertia in outer annular region. More...
 
double Beta0 =0.05
 Thermal conductivity in inner region. More...
 
double Beta1 =1.5
 Thermal conductivity in outer annular region. More...
 
double Target_area =0.05
 Target element size. More...
 
double Radius_innermost =0.5
 Radius of inner circle. More...
 
double Radius_inner =1.0
 Inner radius of annular region. More...
 
double Radius_outer =1.5
 Outer radius of annular region. More...
 
double U0 = 0.8288627710
 Temperature on boundary of inner circle. More...
 
double S0 =0.1
 Strength of source function in inner region. More...
 
double S1 =1.0
 Strength of source function in outer region. More...
 
double Lambda_sq =0.0
 Non-dim density for pseudo-solid. More...
 
double Nu =0.3
 Poisson's ratio for pseudo-solid. More...
 
ConstitutiveLaw * Constitutive_law_pt =0
 Pointer to constitutive law. More...
 
double Melt_temperature =0.8288627710
 Melt-temperature. More...
 
double R_hat =0.1
 Temporal variation in inner radius (for exact solution) More...
 
double V0 =1.0
 Coeff for (time-)constant variation of temperature in inner circle. More...
 
double V0_hat =0.5
 Coeff for time variation inner circle. More...
 
double K_squared =10.0
 Square of the wavenumber. More...
 
bool DtN_BC =false
 
unsigned ABC_order =3
 Flag to choose wich order to use. More...
 
double Outer_radius =1.5
 Radius of outer boundary (must be a circle!) More...
 
unsigned N_fourier =10
 
std::string Restart_file =""
 Name of restart file. More...
 
std::string Partitioning_file =""
 Name of file specifying the partitioning of the problem. More...
 
double Alpha =1.0
 Parameter for steepness of step. More...
 
double Beta =1.0
 Parameter for amplitude of step translation. More...
 
double Gamma = MathematicalConstants::Pi/4.0
 Parameter for timescale of step translation. More...
 
double TanPhi =0.0
 Parameter for angle of step. More...
 
unsigned Nnode_1d =2
 The number of nodes in one direction (default=2) More...
 
unsigned Min_refinement_level =1
 The minimum level of uniform refinement. More...
 
unsigned Add_refinement_level =0
 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
 
std::ostream * Stream_pt
 
double Lx =1.0
 
double Ly =1.0
 
double Lz =1.0
 
unsigned Nx =7
 Number of elements in each direction (used by SimpleCubicMesh) More...
 
unsigned Ny =7
 
unsigned Nz =7
 
double Element_width =Lx/double(Nx)
 The element width. More...
 
double Pml_thickness =Element_width
 Length of cube in each direction. More...
 
double Pi =MathematicalConstants::Pi
 Store the value of Pi. More...
 
double Alpha_shift =0.0
 
double Wavenumber =sqrt(K_squared)
 Wavenumber (also known as k),k=omega/c. More...
 
double Centre =Lx/2.0
 The x and y coordinate of the centre of the cube. More...
 
FiniteElement::SteadyExactSolutionFctPt simple_exact_u_pt =&get_simple_exact_u
 
TestPMLMapping * Test_pml_mapping_pt =new TestPMLMapping
 Set the new PML mapping. More...
 
unsigned Enable_test_pml_mapping_flag =0
 
double Eps =1.0e-12
 The tolerance for a point relative to the bounding inner square. More...
 
unsigned N_pml_element =1
 The number of elements in the PML layer. More...
 
unsigned Disable_pml_flag =0
 
unsigned N_boundary_segment =6
 The number of segments used to define the circular boundary. More...
 
double Period_ratio =1.0
 The ratio T_e/T_s. More...
 
double Re_target =20.0
 Reynolds number for unsteady run. More...
 
double St =1.0
 The default Strouhal number (overloaded with input value if given) More...
 
double ReSt =Re*St
 The Womersley number. More...
 
unsigned N_period_unsteady =1
 ------------------------------------—NAVIER-STOKES PARAMETERS---— More...
 
unsigned N_step_per_period_unsteady =100
 Number of timesteps per period for unsteady run. More...
 
double Height =20.0
 Height of domain. More...
 
double X_left =-10.0
 X-coordinate of upstream end of domain. More...
 
double X_right =40.0
 X-coordinate of downstream end of domain. More...
 
double Length_of_central_box =10.0
 Side-length of the square box in the mesh surrounding the cylinder. More...
 
unsigned N_plot_point =2
 -------------------------------------------—DOMAIN PROPERTIES---— More...
 
double Amplitude_target =0.50
 
unsigned N_amplitude_step =5
 The number of steps used to reach the target amplitude. More...
 
double Period_ratio_target =1.0
 
unsigned N_period_ratio_step =1
 The number of steps used to reach the target Period_ratio value. More...
 
unsigned N_re_step =2
 
double L_t =1.0
 The length of the mesh in the time direction. More...
 
unsigned N_t =25
 The number of elements in the time direction. More...
 
unsigned Preconditioner =0
 ----------------------—Domain Properties------------------------— More...
 
unsigned N_dof_type =0
 
std::ofstream Trace_file
 Trace file to doc. asymmetry norm data in. More...
 
bool Document_solution =true
 Helper variable to indicate whether or not to document the solution. More...
 
double Length =2.0*MathematicalConstants::Pi
 Length of computational domain. More...
 
double Kinematic_viscosity =1.0
 The value of the kinematic viscosity (assumed to be the same everywhere) More...
 
double L_x =1.0
 ------------------—Unsteady Heat Parameters---------------------— More...
 
double L_y =1.0
 Length of the mesh in the y-direction. More...
 
unsigned N_x =10
 Number of elements in the x-direction. More...
 
unsigned N_y =10
 Number of elements in the y-direction. More...
 
unsigned Element_order =1
 The order of the FE interpolation. More...
 
bool Apply_time_periodic_boundary_conditions =true
 Should we apply time-periodic boundary conditions? More...
 
double Controlled_height = 0.0
 Height control value. More...
 
double Alpha_min = MathematicalConstants::Pi/2.0*1.5
 Min. spine angle against horizontal plane. More...
 
double Alpha_max = MathematicalConstants::Pi/2.0*0.5
 Max. spine angle against horizontal plane. More...
 
bool Use_spines = true
 Use spines (true) or not (false) More...
 
bool Use_height_control = true
 Use height control (true) or not (false)? More...
 
int Case = All_pinned
 What case are we considering: Choose one from the enumeration Cases. More...
 
double Cos_gamma =cos(Gamma)
 Cos of contact angle. More...
 
Data * Kappa_pt = 0
 Pointer to Data object that stores the prescribed curvature. More...
 
double Kappa_initial = 0.0
 Initial value for kappa. More...
 
int Step_sign = 1
 Increase or decrease the value of the control parameters? More...
 
unsigned Nsteps = 5
 Number of steps. More...
 
double Kappa_increment = -0.05
 Increment for prescribed curvature. More...
 
double Controlled_height_increment = 0.1
 Increment for height control. More...
 
unsigned Control_element = 0
 
double Beta_min = MathematicalConstants::Pi/2.0
 Min. second spine angle against horizontal plane. More...
 
double Beta_max = MathematicalConstants::Pi/2.0
 Max. second pine angle against horizontal plane. More...
 
bool Rotate_spines_in_both_directions = true
 Should the spines rotate in the x and y directions (true)? More...
 

Detailed Description

Global parameters.

Namespace for exact solution for Poisson equation with "sharp step".

Namespace for "global" problem parameters.

Namespace for global parameters.

Namespace for the Helmholtz problem parameters.

Namespace for the problem parameters.

Global parameters for the problem.

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

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

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

//////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// Namespace for exact solution of unsteady heat equation with sharp step

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

Enumeration Type Documentation

◆ Cases

enum GlobalParameters::Cases

Enumeration for the possible cases.

Enumerator
Spherical_cap_in_cylinder_pinned 
All_pinned 
Barrel_shape 
T_junction_with_nonzero_contact_angle 
46  {Spherical_cap_in_cylinder_pinned,
47  All_pinned,
48  Barrel_shape,
49  T_junction_with_nonzero_contact_angle,
50  };
GlobalParameters::Barrel_shape
@ Barrel_shape
Definition: common_young_laplace_stuff.h:48
GlobalParameters::All_pinned
@ All_pinned
Definition: common_young_laplace_stuff.h:47
GlobalParameters::T_junction_with_nonzero_contact_angle
@ T_junction_with_nonzero_contact_angle
Definition: common_young_laplace_stuff.h:49
GlobalParameters::Spherical_cap_in_cylinder_pinned
@ Spherical_cap_in_cylinder_pinned
Definition: common_young_laplace_stuff.h:46

Function Documentation

◆ calculate_strouhal_number()

double GlobalParameters::calculate_strouhal_number ( const double &  re)

Function to calculate the appropriate Strouhal number for the simulation. Some noteworthy Re-St values: (1) Re=100 --> St=0.1643 (2) Re=200 --> St=0.198 NOTE: The Re-St values for 46<Re<180 can be found in: Williamson, C.H.K, (1988)."Defining a universal and continuous Strouhal–Reynolds number relationship for the laminar vortex shedding of a circular cylinder".

Function to calculate the Strouhal number appropriate for this simulation. The value chosen corresponds to the Strouhal number associated with the vortex-shedding frequency of the flow past a stationary cylinder.

NOTE (1): The Re-St values for 46<Re<180 can be found in: Williamson, C.H.K, (1988)."Defining a universal and continuous Strouhal–Reynolds number relationship for the laminar vortex shedding of a circular cylinder". Noteworthy Re-St value(s): (i) Re=100 --> St=0.1643.

NOTE (2): This should only be used for Reynolds numbers above 46 (where the Hopf bifurcation occurs for the flow past a stationary cylinder) and below (roughly) 180 (where a secondary bifurcation occurs at which point the flow becomes 3D).

NOTE (3): This should only ever be called through the function update_physical_parameter(); to compute the Strouhal number. It should never be used on its own (as it will only be appropriate for a unit Period_ratio value).

238  {
239  // The min. Reynolds number
240  double min_re=46.0;
241 
242  // The max. Reynolds number
243  double max_re=180.0;
244 
245  // The first coefficient of the Re-St polynomial
246  double a=-3.3265;
247 
248  // The second coefficient of the Re-St polynomial
249  double b=0.1816;
250 
251  // The third coefficient of the Re-St polynomial
252  double c=0.00016;
253 
254  // If we're above the maximum Reynolds number
255  if (re>max_re)
256  {
257  // Throw an error
258  throw OomphLibError("Don't know what to do for this Reynolds number!",
259  OOMPH_CURRENT_FUNCTION,
260  OOMPH_EXCEPTION_LOCATION);
261  }
262  // If we're below the minimum Reynolds number
263  else if (re<min_re)
264  {
265  // Just return the Strouhal value at the minimum Reynolds number
266  return a/min_re+b+c*min_re;
267  }
268  // Otherwise, use the relationship in the Williamson paper
269  else
270  {
271  // Return the Strouhal value at this Reynolds number
272  return a/re+b+c*re;
273  }
274  } // End of calculate_strouhal_number
b
Scalar * b
Definition: benchVecAdd.cpp:17
oomph::OomphLibError
Definition: oomph_definitions.h:222
a
const Scalar * a
Definition: level2_cplx_impl.h:32
calibrate.c
int c
Definition: calibrate.py:100
OOMPH_EXCEPTION_LOCATION
#define OOMPH_EXCEPTION_LOCATION
Definition: oomph_definitions.h:61
OOMPH_CURRENT_FUNCTION
#define OOMPH_CURRENT_FUNCTION
Definition: oomph_definitions.h:86

References a, b, calibrate::c, OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

Referenced by update_physical_parameters(), and update_simulation_parameters().

◆ default_get_exact_u()

void GlobalParameters::default_get_exact_u ( const Vector< double > &  x,
Vector< double > &  u 
)

Default value of the solution on the boundary of the obstacle. This represents a Bessel solution

175  {
176  // Set the first entry
177  u[0]=0.1;
178 
179  // Set the second entry
180  u[1]=0.0;
181  } // End of default_get_exact_u

◆ distorted_y()

double GlobalParameters::distorted_y ( const double &  y_normalised)

Function to distort mesh.

93  {
94  return 0.5*y_normalised*(3.0-y_normalised);
95  }

◆ doc_maximum_central_box_deformation()

void GlobalParameters::doc_maximum_central_box_deformation ( )

Document the maximum deformation inside the central box.

349  {
350  // Calculate the distance from the edge of the annular ring to the
351  // box boundary. NOTE: We check from the annular ring because the
352  // region between the cylinder and annular ring is made rigid so
353  // no compression occurs there.
354  double compression_region_width=(Length_of_central_box/2.0-
355  Annular_region_radius);
356 
357  // Calculate the current deformation of the inner box
358  double deformation_ratio=((compression_region_width-Amplitude)/
359  compression_region_width);
360 
361  // If the deformation is too large for the mesh
362  if (deformation_ratio<0.0)
363  {
364  // Used to create an error message
365  std::ostringstream error_message_stream;
366 
367  // Create an error message
368  error_message_stream << "The cylinder amplitude exceeds the size of "
369  << "the central box! Make the box larger!"
370  << std::endl;
371 
372  // Throw an error to the user
373  throw OomphLibError(error_message_stream.str(),
374  OOMPH_CURRENT_FUNCTION,
375  OOMPH_EXCEPTION_LOCATION);
376  }
377  // If the deformation is large then warn the user
378  else if (deformation_ratio<0.5)
379  {
380  // Used to create a warning message
381  std::ostringstream warning_message_stream;
382 
383  // Create a warning message
384  warning_message_stream << "Maximal mesh compression results in elements "
385  << "being reduced\nto "
386  << deformation_ratio*100.0
387  << "% of their original width. It is therefore\n"
388  << "recommended that the central box be "
389  << "made larger." << std::endl;
390 
391  // Throw a warning to the user
392  OomphLibWarning(warning_message_stream.str(),
393  OOMPH_CURRENT_FUNCTION,
394  OOMPH_EXCEPTION_LOCATION);
395  }
396  else
397  {
398  // Document the deformation (special ASCII characters used to output
399  // the text in bold red)
400  oomph_info << "\033[1;31m"
401  << "\nMaximum element compression ratio inside central box: "
402  << "\033[0m"
403  << deformation_ratio*100.0 << "%\n" << std::endl;
404  }
405  } // End of doc_maximum_central_box_deformation
oomph::OomphLibWarning
Definition: oomph_definitions.h:267
GlobalParameters::Annular_region_radius
double Annular_region_radius
The radius of the annular region surrounding the cylinder.
Definition: extrude_with_macro_element_representation.cc:271
GlobalParameters::Amplitude
double Amplitude
Amplitude of the cylinder motion.
Definition: extrude_with_macro_element_representation.cc:254
GlobalParameters::Length_of_central_box
double Length_of_central_box
Side-length of the square box in the mesh surrounding the cylinder.
Definition: flow_past_oscillating_cylinder.cc:325
oomph::oomph_info
OomphInfo oomph_info
Definition: oomph_definitions.cc:319

References Amplitude, Annular_region_radius, Length_of_central_box, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and oomph::oomph_info.

Referenced by NavierStokesProblem< ELEMENT >::create_spacetime_mesh().

◆ doc_navier_stokes_parameters()

void GlobalParameters::doc_navier_stokes_parameters ( )

Document the value of the Reynolds number and Womersley number.

292  {
293  // Tell the user
294  oomph_info << ANSIEscapeCode::Red
295  << "Solving for (Re,ReSt): "
296  << ANSIEscapeCode::Reset
297  << "("
298  << GlobalParameters::Re << "," << GlobalParameters::ReSt
299  << ")" << std::endl;
300  } // End of doc_navier_stokes_parameters
GlobalParameters::Re
double Re
Reynolds number.
Definition: extrude_triangle_generated_mesh.cc:48
GlobalParameters::ReSt
double ReSt
The Womersley number.
Definition: flow_past_oscillating_cylinder.cc:226
oomph::ANSIEscapeCode::Red
std::string Red
Definition: oomph_utilities.cc:71
oomph::ANSIEscapeCode::Reset
std::string Reset
Definition: oomph_utilities.cc:77

References oomph::oomph_info, Re, oomph::ANSIEscapeCode::Red, oomph::ANSIEscapeCode::Reset, and ReSt.

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

◆ find_node_on_centerline()

void GlobalParameters::find_node_on_centerline ( Mesh *  mesh_pt,
FiniteElement **  el_centerline_pt,
unsigned &  node_index 
)

--------------------—Documentation Helpers----------------------—

------------------------—Miscellaneous--------------------------— Find a node on the centerline N.B. We are modifying the pointer el_centerline_pt not the actual data. If we just pass a pointer to the element in then (from outside) we are only given a copy of the pointer which is discarded after the function call (but we need it to stay alive!). To edit the pointer itself we have to pass a pointer to the pointer (hence the **).

916  {
917  // Number of elements in the mesh
918  unsigned n_element=mesh_pt->nelement();
919 
920  // Number of nodes in an element
921  unsigned n_el_node=mesh_pt->finite_element_pt(0)->nnode();
922 
923  // Number of spatial dimensions
924  unsigned n_spatial_dim=2;
925 
926  // Eulerian position
927  Vector<double> x(n_spatial_dim+1,0.0);
928 
929  // Loop over the nodes in the mesh
930  for (unsigned i=0; i<n_element; i++)
931  {
932  // Get a pointer to this element
933  FiniteElement* el_pt=mesh_pt->finite_element_pt(i);
934 
935  // Loop over the nodes in the i-th element
936  for (unsigned j=0; j<n_el_node; j++)
937  {
938  // Get a pointer to the j-th node in the i-th element
939  Node* nod_pt=el_pt->node_pt(j);
940 
941  // Might want pressure information later too so make sure it's not pinned
942  if (!(nod_pt->is_pinned(n_spatial_dim)))
943  {
944  // Loop over the coordinates
945  for (unsigned k=0; k<n_spatial_dim+1; k++)
946  {
947  // Get the i-th coordinate
948  x[k]=nod_pt->x(k);
949  }
950 
951  // Check if the node lies on the centerline, outside the central box
952  // and on the initial time-boundary
953  if ((x[0]>(0.5*Length_of_central_box))&&
954  (std::abs(x[1])<1.0e-10)&&
955  (std::abs(x[2])<1.0e-10))
956  {
957  // Store a pointer to the chosen element
958  (*el_centerline_pt)=el_pt;
959 
960  // Store the local nodal number
961  node_index=j;
962 
963  // We're done; we only need one node
964  return;
965  }
966  } // if (!(el_pt->node_pt(i)->is_pinned(n_spatial_dim)))
967  } // for (unsigned j=0;j<n_el_node;j++)
968  } // for (unsigned i=0;i<n_element;i++)
969  } // End of find_node_on_centerline
abs
AnnoyingScalar abs(const AnnoyingScalar &x)
Definition: AnnoyingScalar.h:135
i
int i
Definition: BiCGSTAB_step_by_step.cpp:9
oomph::Data::is_pinned
bool is_pinned(const unsigned &i) const
Test whether the i-th variable is pinned (1: true; 0: false).
Definition: nodes.h:417
oomph::FiniteElement
Definition: elements.h:1313
oomph::FiniteElement::node_pt
Node *& node_pt(const unsigned &n)
Return a pointer to the local node n.
Definition: elements.h:2175
oomph::FiniteElement::nnode
unsigned nnode() const
Return the number of nodes.
Definition: elements.h:2210
oomph::Mesh::finite_element_pt
FiniteElement * finite_element_pt(const unsigned &e) const
Definition: mesh.h:473
oomph::Mesh::nelement
unsigned long nelement() const
Return number of elements in the mesh.
Definition: mesh.h:590
oomph::Node
Definition: nodes.h:906
oomph::Node::x
double & x(const unsigned &i)
Return the i-th nodal coordinate.
Definition: nodes.h:1060
k
char char char int int * k
Definition: level2_impl.h:374
plotDoE.x
list x
Definition: plotDoE.py:28
j
std::ptrdiff_t j
Definition: tut_arithmetic_redux_minmax.cpp:2

References abs(), oomph::Mesh::finite_element_pt(), i, oomph::Data::is_pinned(), j, k, Length_of_central_box, oomph::Mesh::nelement(), oomph::FiniteElement::nnode(), oomph::FiniteElement::node_pt(), plotDoE::x, and oomph::Node::x().

◆ get_exact_kappa()

double GlobalParameters::get_exact_kappa ( )

Exact kappa.

55  {
56 
57  // Mean curvature of barrel-shaped meniscus
58  return 2.0*Controlled_height/
59  (Controlled_height*Controlled_height+1.0/4.0);
60 
61  } //end exact kappa
GlobalParameters::Controlled_height
double Controlled_height
Height control value.
Definition: barrel.cc:51

References Controlled_height.

Referenced by YoungLaplaceProblem< ELEMENT >::doc_solution().

◆ get_exact_u() [1/4]

void GlobalParameters::get_exact_u ( const double &  time,
const Vector< double > &  x,
double &  u 
)

Exact solution as a scalar.

167  {
168  double X=x[0];
169  double Y=x[1];
170  u=tanh(0.1E1-Alpha*(TanPhi*(X-Beta*tanh(Gamma*cos(0.2E1*
171  MathematicalConstants::Pi*time)))-Y));
172  }
cos
AnnoyingScalar cos(const AnnoyingScalar &x)
Definition: AnnoyingScalar.h:136
X
#define X
Definition: icosphere.cpp:20
BiharmonicTestFunctions2::Pi
double Pi
Definition: two_d_biharmonic.cc:235
Eigen::bfloat16_impl::tanh
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 tanh(const bfloat16 &a)
Definition: BFloat16.h:639
GlobalParameters::TanPhi
double TanPhi
Parameter for angle of step.
Definition: two_d_unsteady_heat_2adapt_load_balance.cc:147
GlobalParameters::Beta
double Beta
Parameter for amplitude of step translation.
Definition: two_d_unsteady_heat_2adapt_load_balance.cc:141
GlobalParameters::Gamma
double Gamma
Parameter for timescale of step translation.
Definition: two_d_unsteady_heat_2adapt_load_balance.cc:144
GlobalParameters::Alpha
double Alpha
Parameter for steepness of step.
Definition: two_d_unsteady_heat_2adapt_load_balance.cc:138
Y
const char Y
Definition: test/EulerAngles.cpp:32

References Alpha, Beta, cos(), Gamma, BiharmonicTestFunctions2::Pi, Eigen::bfloat16_impl::tanh(), TanPhi, plotDoE::x, X, and Y.

◆ get_exact_u() [2/4]

void GlobalParameters::get_exact_u ( const double &  time,
const Vector< double > &  x,
Vector< double > &  u 
)

Exact solution as a Vector.

171  {
172  double r=sqrt(x[0]*x[0]+x[1]*x[1]);
173 
174  // Solutions from maple
175  double t0=0.0;
176  if (r<0.5*(Radius_inner+Radius_innermost))
177  {
178  t0 = 0.25*S0/Beta0*(r*r-1.0*Radius_innermost*Radius_innermost)+U0;
179  }
180  else
181  {
182 
183  double MapleGenVar1 = 0.0;
184  double MapleGenVar4 = 0.0;
185  double MapleGenVar6 = 0.0;
186  double MapleGenVar9 = 0.0;
187  double MapleGenVar8 = 0.0;
188  double MapleGenVar7 = 0.0;
189  double MapleGenVar5 = 0.0;
190  double MapleGenVar3 = 0.0;
191  double MapleGenVar11 = 0.0;
192  double MapleGenVar13 = 0.0;
193  double MapleGenVar15 = 0.0;
194  double MapleGenVar16 = 0.0;
195  double MapleGenVar14 = 0.0;
196  double MapleGenVar12 = 0.0;
197  double MapleGenVar10 = 0.0;
198  double MapleGenVar2 = 0.0;
199 
200  MapleGenVar1 = S1/Beta1*r*r/4.0;
201  MapleGenVar4 = 1/Beta1/4.0;
202  MapleGenVar6 = 1/(log(Radius_inner)-log(Radius_outer));
203  MapleGenVar9 = -2.0*log(Radius_inner)*S0*Radius_innermost*
204 Radius_innermost+2.0*log(Radius_outer)*S0*Radius_innermost*Radius_innermost+4.0
205 *log(Radius_inner)*Sigma*Theta_0*Theta_0*Theta_0*Theta_0*Radius_inner-8.0*log(
206 Radius_inner)*Sigma*Theta_0*Theta_0*Theta_0*Theta_0*Radius_innermost+4.0*log(
207 Radius_inner)*Sigma*U0*U0*U0*U0*Radius_inner-8.0*log(Radius_inner)*Sigma*U0*U0*
208 U0*U0*Radius_innermost-4.0*log(Radius_outer)*Sigma*Theta_0*Theta_0*Theta_0*
209 Theta_0*Radius_inner+8.0*log(Radius_outer)*Sigma*Theta_0*Theta_0*Theta_0*
210 Theta_0*Radius_innermost-4.0*log(Radius_outer)*Sigma*U0*U0*U0*U0*Radius_inner+
211 8.0*log(Radius_outer)*Sigma*U0*U0*U0*U0*Radius_innermost+2.0*log(Radius_inner)*
212 S0*Radius_inner*Radius_innermost-2.0*log(Radius_outer)*S0*Radius_inner*
213 Radius_innermost-2.0*S1*Radius_inner*Radius_inner*log(Radius_inner);
214  MapleGenVar8 = MapleGenVar9+2.0*log(Radius_outer)*S1*Radius_inner*
215 Radius_inner+16.0*log(Radius_inner)*Sigma*Theta_0*Theta_0*Theta_0*U0*
216 Radius_inner-32.0*log(Radius_inner)*Sigma*Theta_0*Theta_0*Theta_0*U0*
217 Radius_innermost+24.0*log(Radius_inner)*Sigma*Theta_0*Theta_0*U0*U0*
218 Radius_inner-48.0*log(Radius_inner)*Sigma*Theta_0*Theta_0*U0*U0*
219 Radius_innermost+16.0*log(Radius_inner)*Sigma*Theta_0*U0*U0*U0*Radius_inner
220 -32.0*log(Radius_inner)*Sigma*Theta_0*U0*U0*U0*Radius_innermost-16.0*log(
221 Radius_outer)*Sigma*Theta_0*Theta_0*Theta_0*U0*Radius_inner+32.0*log(
222 Radius_outer)*Sigma*Theta_0*Theta_0*Theta_0*U0*Radius_innermost-24.0*log(
223 Radius_outer)*Sigma*Theta_0*Theta_0*U0*U0*Radius_inner+48.0*log(Radius_outer)*
224 Sigma*Theta_0*Theta_0*U0*U0*Radius_innermost-16.0*log(Radius_outer)*Sigma*
225 Theta_0*U0*U0*U0*Radius_inner+32.0*log(Radius_outer)*Sigma*Theta_0*U0*U0*U0*
226 Radius_innermost;
227  MapleGenVar9 = log(r);
228  MapleGenVar7 = MapleGenVar8*MapleGenVar9;
229  MapleGenVar5 = MapleGenVar6*MapleGenVar7;
230  MapleGenVar3 = MapleGenVar4*MapleGenVar5;
231  MapleGenVar6 = -Beta1*pow(2.0,0.75)*pow((2.0*Sigma*Theta_0*Theta_0*
232 Theta_0*Theta_0+8.0*Sigma*Theta_0*Theta_0*Theta_0*U0+12.0*Sigma*Theta_0*Theta_0
233 *U0*U0+8.0*Sigma*Theta_0*U0*U0*U0+2.0*Sigma*U0*U0*U0*U0+S0*Radius_innermost)/
234 Sigma,0.25)*log(Radius_outer)/2.0-log(Radius_inner)*S1*Radius_outer*
235 Radius_outer/4.0;
236  MapleGenVar7 = MapleGenVar6+log(Radius_outer)*S1*Radius_inner*
237 Radius_inner/4.0;
238  MapleGenVar8 = MapleGenVar7;
239  MapleGenVar11 = 1.0/4.0;
240  MapleGenVar13 = log(Radius_inner);
241  MapleGenVar15 = 2.0*log(Radius_inner)*S0*Radius_innermost*
242 Radius_innermost-2.0*log(Radius_outer)*S0*Radius_innermost*Radius_innermost-4.0
243 *log(Radius_inner)*Sigma*Theta_0*Theta_0*Theta_0*Theta_0*Radius_inner+8.0*log(
244 Radius_inner)*Sigma*Theta_0*Theta_0*Theta_0*Theta_0*Radius_innermost-4.0*log(
245 Radius_inner)*Sigma*U0*U0*U0*U0*Radius_inner+8.0*log(Radius_inner)*Sigma*U0*U0*
246 U0*U0*Radius_innermost+4.0*log(Radius_outer)*Sigma*Theta_0*Theta_0*Theta_0*
247 Theta_0*Radius_inner-8.0*log(Radius_outer)*Sigma*Theta_0*Theta_0*Theta_0*
248 Theta_0*Radius_innermost+4.0*log(Radius_outer)*Sigma*U0*U0*U0*U0*Radius_inner
249 -8.0*log(Radius_outer)*Sigma*U0*U0*U0*U0*Radius_innermost-2.0*log(Radius_inner)
250 *S0*Radius_inner*Radius_innermost+2.0*log(Radius_outer)*S0*Radius_inner*
251 Radius_innermost+2.0*S1*Radius_inner*Radius_inner*log(Radius_inner)-2.0*log(
252 Radius_outer)*S1*Radius_inner*Radius_inner-S1*Radius_inner*Radius_inner;
253  MapleGenVar16 = MapleGenVar15+2.0*pow(2.0,0.75)*pow((2.0*Sigma*Theta_0*
254 Theta_0*Theta_0*Theta_0+8.0*Sigma*Theta_0*Theta_0*Theta_0*U0+12.0*Sigma*Theta_0
255 *Theta_0*U0*U0+8.0*Sigma*Theta_0*U0*U0*U0+2.0*Sigma*U0*U0*U0*U0+S0*
256 Radius_innermost)/Sigma,0.25)*Beta1+S1*Radius_outer*Radius_outer-4.0*Theta_0*
257 Beta1-16.0*log(Radius_inner)*Sigma*Theta_0*Theta_0*Theta_0*U0*Radius_inner+32.0
258 *log(Radius_inner)*Sigma*Theta_0*Theta_0*Theta_0*U0*Radius_innermost-24.0*log(
259 Radius_inner)*Sigma*Theta_0*Theta_0*U0*U0*Radius_inner+48.0*log(Radius_inner)*
260 Sigma*Theta_0*Theta_0*U0*U0*Radius_innermost;
261  MapleGenVar14 = MapleGenVar16-16.0*log(Radius_inner)*Sigma*Theta_0*U0*U0*
262 U0*Radius_inner+32.0*log(Radius_inner)*Sigma*Theta_0*U0*U0*U0*Radius_innermost+
263 16.0*log(Radius_outer)*Sigma*Theta_0*Theta_0*Theta_0*U0*Radius_inner-32.0*log(
264 Radius_outer)*Sigma*Theta_0*Theta_0*Theta_0*U0*Radius_innermost+24.0*log(
265 Radius_outer)*Sigma*Theta_0*Theta_0*U0*U0*Radius_inner-48.0*log(Radius_outer)*
266 Sigma*Theta_0*Theta_0*U0*U0*Radius_innermost+16.0*log(Radius_outer)*Sigma*
267 Theta_0*U0*U0*U0*Radius_inner-32.0*log(Radius_outer)*Sigma*Theta_0*U0*U0*U0*
268 Radius_innermost;
269  MapleGenVar12 = MapleGenVar13*MapleGenVar14;
270  MapleGenVar10 = MapleGenVar11*MapleGenVar12;
271  MapleGenVar11 = Beta1*log(Radius_outer)*Theta_0;
272  MapleGenVar9 = MapleGenVar10+MapleGenVar11;
273  MapleGenVar5 = MapleGenVar8+MapleGenVar9;
274  MapleGenVar6 = 1/Beta1/(log(Radius_inner)-log(Radius_outer));
275  MapleGenVar4 = MapleGenVar5*MapleGenVar6;
276  MapleGenVar2 = MapleGenVar3+MapleGenVar4;
277  t0 = MapleGenVar1+MapleGenVar2;
278  }
279 
280  u[0] = t0;
281 
282  }
sqrt
AnnoyingScalar sqrt(const AnnoyingScalar &x)
Definition: AnnoyingScalar.h:134
Eigen::ArrayBase::pow
EIGEN_DEVICE_FUNC const GlobalUnaryPowReturnType< Derived, ScalarExponent > pow(const Eigen::ArrayBase< Derived > &x, const ScalarExponent &exponent)
Definition: GlobalFunctions.h:137
Eigen::bfloat16_impl::log
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 log(const bfloat16 &a)
Definition: BFloat16.h:618
GlobalParameters::U0
double U0
Temperature on boundary of inner circle.
Definition: stefan_boltzmann.cc:145
GlobalParameters::Theta_0
double Theta_0
Zero degrees Celsius offset in Stefan Boltzmann law.
Definition: stefan_boltzmann.cc:118
GlobalParameters::S0
double S0
Strength of source function in inner region.
Definition: stefan_boltzmann.cc:148
GlobalParameters::Radius_outer
double Radius_outer
Outer radius of annular region.
Definition: stefan_boltzmann.cc:142
GlobalParameters::Beta0
double Beta0
Thermal conductivity in inner region.
Definition: stefan_boltzmann.cc:127
GlobalParameters::Sigma
double Sigma
Non-dim Stefan Boltzmann constant.
Definition: stefan_boltzmann.cc:115
GlobalParameters::Radius_inner
double Radius_inner
Inner radius of annular region.
Definition: stefan_boltzmann.cc:139
GlobalParameters::Beta1
double Beta1
Thermal conductivity in outer annular region.
Definition: stefan_boltzmann.cc:130
GlobalParameters::Radius_innermost
double Radius_innermost
Radius of inner circle.
Definition: stefan_boltzmann.cc:136
GlobalParameters::S1
double S1
Strength of source function in outer region.
Definition: stefan_boltzmann.cc:151
UniformPSDSelfTest.r
r
Definition: UniformPSDSelfTest.py:20

References Beta0, Beta1, Eigen::bfloat16_impl::log(), Eigen::bfloat16_impl::pow(), UniformPSDSelfTest::r, Radius_inner, Radius_innermost, Radius_outer, S0, S1, Sigma, sqrt(), Theta_0, U0, and plotDoE::x.

Referenced by StefanBoltzmannProblem< ELEMENT >::actions_before_implicit_timestep(), RefineableUnsteadyHeatProblem< ELEMENT >::actions_before_implicit_timestep(), RefineableUnsteadyHeatProblem< ELEMENT >::doc_solution(), StefanBoltzmannProblem< ELEMENT >::doc_solution(), ScatteringProblem< ELEMENT >::doc_solution(), RefineableUnsteadyHeatProblem< ELEMENT >::set_initial_condition(), and StefanBoltzmannProblem< ELEMENT >::StefanBoltzmannProblem().

◆ get_exact_u() [3/4]

void GlobalParameters::get_exact_u ( const Vector< double > &  x,
Vector< double > &  u 
)

Exact solution as a Vector.

Exact solution for scattered field (vector returns real and impaginary parts).

87  {
88  // Switch to polar coordinates
89  double r;
90  r=sqrt(x[0]*x[0]+x[1]*x[1]);
91  double theta;
92  theta=atan2(x[1],x[0]);
93 
94  // Argument for Bessel/Hankel functions
95  double rr=sqrt(K_squared)*r;
96 
97  // Evaluate Bessel/Hankel functions
98  complex <double > u_ex(0.0,0.0);
99  Vector<double> jn(N_fourier+1), yn(N_fourier+1),
100  jnp(N_fourier+1), ynp(N_fourier+1);
101  Vector<double> jn_a(N_fourier+1),yn_a(N_fourier+1),
102  jnp_a(N_fourier+1), ynp_a(N_fourier+1);
103  Vector<complex<double> > h(N_fourier+1),h_a(N_fourier+1),
104  hp(N_fourier+1), hp_a(N_fourier+1);
105 
106  // We want to compute N_fourier terms but the function
107  // may return fewer than that.
108  int n_actual=0;
109  CRBond_Bessel::bessjyna(N_fourier,sqrt(K_squared),n_actual,
110  &jn_a[0],&yn_a[0],
111  &jnp_a[0],&ynp_a[0]);
112 
113  // Shout if things went wrong
114 #ifdef PARANOID
115  if (n_actual!=int(N_fourier))
116  {
117  std::ostringstream error_stream;
118  error_stream << "CRBond_Bessel::bessjyna() only computed "
119  << n_actual << " rather than " << N_fourier
120  << " Bessel functions.\n";
121  throw OomphLibError(error_stream.str(),
122  OOMPH_CURRENT_FUNCTION,
123  OOMPH_EXCEPTION_LOCATION);
124  }
125 #endif
126 
127  // Evaluate Hankel at actual radius
128  Hankel_functions_for_helmholtz_problem::Hankel_first(N_fourier,rr,h,hp);
129 
130  // Evaluate Hankel at inner (unit) radius
131  Hankel_functions_for_helmholtz_problem::Hankel_first(N_fourier
132  ,sqrt(K_squared),
133  h_a,hp_a);
134 
135  // Compute the sum: Separate the computation of the negative
136  // and positive terms
137  for (unsigned i=0;i<N_fourier;i++)
138  {
139  u_ex-=pow(I,i)*h[i]*((jnp_a[i])/hp_a[i])*pow(exp(I*theta),i);
140  }
141  for (unsigned i=1;i<N_fourier;i++)
142  {
143  u_ex-=pow(I,i)*h[i]*((jnp_a[i])/hp_a[i])*pow(exp(-I*theta),i);
144  }
145 
146  // Get the real & imaginary part of the result
147  u[0]=real(u_ex);
148  u[1]=imag(u_ex);
149 
150  }// end of get_exact_u
atan2
AnnoyingScalar atan2(const AnnoyingScalar &y, const AnnoyingScalar &x)
Definition: AnnoyingScalar.h:139
imag
AnnoyingScalar imag(const AnnoyingScalar &)
Definition: AnnoyingScalar.h:132
real
float real
Definition: datatypes.h:10
I
#define I
Definition: main.h:127
BiharmonicTestFunctions2::theta
double theta
Definition: two_d_biharmonic.cc:236
CRBond_Bessel::bessjyna
int bessjyna(int n, double x, int &nm, double *jn, double *yn, double *jnp, double *ynp)
Definition: crbond_bessel.cc:852
Eigen::bfloat16_impl::exp
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 exp(const bfloat16 &a)
Definition: BFloat16.h:615
GlobalParameters::N_fourier
unsigned N_fourier
Definition: scattering.cc:68
Global_Parameters::Hankel_first
void Hankel_first(const unsigned &n, const double &x, Vector< std::complex< double > > &h, Vector< std::complex< double > > &hp)
Definition: time_harmonic_elasticity_driver.cc:122
ProblemParameters::K_squared
double K_squared
Square of the wavenumber.
Definition: sphere_scattering.cc:225

References atan2(), CRBond_Bessel::bessjyna(), Eigen::bfloat16_impl::exp(), oomph::Hankel_functions_for_helmholtz_problem::Hankel_first(), i, I, imag(), ProblemParameters::K_squared, N_fourier, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, Eigen::bfloat16_impl::pow(), UniformPSDSelfTest::r, sqrt(), BiharmonicTestFunctions2::theta, and plotDoE::x.

◆ get_exact_u() [4/4]

void GlobalParameters::get_exact_u ( const Vector< double > &  x,
Vector< double > &  u,
const double &  alpha = 0.25*MathematicalConstants::Pi 
)

Value of the solution on the boundary of the obstacle (here we assume the solution is a plane wave incident at angle alpha)

109  {
110  // Set the first entry
111  u[0]=-cos(Wavenumber*(x[0]*cos(alpha)+x[1]*sin(alpha)));
112 
113  // Set the second entry
114  u[1]=-sin(Wavenumber*(x[0]*cos(alpha)+x[1]*sin(alpha)));
115  } // End of get_exact_u
sin
AnnoyingScalar sin(const AnnoyingScalar &x)
Definition: AnnoyingScalar.h:137
alpha
RealScalar alpha
Definition: level1_cplx_impl.h:151
GlobalParameters::Wavenumber
double Wavenumber
Wavenumber (also known as k),k=omega/c.
Definition: structured_cubic_point_source.cc:135

References alpha, cos(), sin(), Wavenumber, and plotDoE::x.

◆ get_exact_u_bessel()

void GlobalParameters::get_exact_u_bessel ( const Vector< double > &  x,
Vector< double > &  u 
)
125  {
126  // The radius in polar coordinates
127  double r;
128 
129  // Switch to polar coordinates
130  r=sqrt((x[0]-Centre)*(x[0]-Centre)+(x[1]-Centre)*(x[1]-Centre));
131 
132  // Tolerance for the point being in the centre
133  double tol=1.0e-06;
134 
135  // Check if the point lies practically in the centre
136  if (r<tol)
137  {
138  // Set the real and imaginary parts of the solution. The real
139  // part is set arbitrarily since the Bessel function of the
140  // second kind is unbounded at the centre of the mesh. The
141  // real part of the solution is (1/4)*Y_0(0) and the imaginary
142  // part is -(i/4)*J_0(0). We know Y_0(0)=-inf and J_0(0)=1
143  // so the imaginary part of the solution is precisely -0.25i
144  // but the real part we can set arbitrarily. Note, setting it
145  // to -DBL_MAX might cause some problems so we choose some
146  // finite value
147  u[0]=-0.5;
148  u[1]=-0.25;
149  }
150  else
151  {
152  // Scale r by the wavenumber
153  double rr=Wavenumber*r;
154 
155  // Number of first-order Hankel function terms (starts from n=0
156  // in H^(1)_n(...))
157  unsigned n_terms=1;
158 
159  // Hankel function and the its derivative
160  Vector<std::complex<double> > h(1);
161  Vector<std::complex<double> > hp(1);
162 
163  // Calculate the solution (i/4)*H^(1)_0(kr) at kr
164  Hankel_functions_for_helmholtz_problem::Hankel_first(n_terms,rr,h,hp);
165 
166  // Calculate the real and imaginary parts of the solution
167  u[0]=0.25*imag(h[0]);
168  u[1]=-0.25*real(h[0]);
169  }
170  } // End of get_exact_u_bessel
ProblemParameters::Centre
Vector< double > Centre
Position of centre of penetrator.
Definition: circular_boulder_melt.cc:85

References ProblemParameters::Centre, oomph::Hankel_functions_for_helmholtz_problem::Hankel_first(), imag(), UniformPSDSelfTest::r, sqrt(), Wavenumber, and plotDoE::x.

◆ get_pressure()

void GlobalParameters::get_pressure ( const Vector< double > &  x,
double &  pressure 
)

Pressure depending on the position (x,y)

61  {
62  pressure=Pressure;
63  }
GlobalParameters::Pressure
double Pressure
The pressure.
Definition: all_foeppl_von_karman/circular_disk.cc:57

References Pressure.

Referenced by UnstructuredFvKProblem< ELEMENT >::complete_problem_setup(), oomph::AxisymmetricPoroelasticityTractionElement< ELEMENT >::fill_in_contribution_to_residuals_axisym_poroelasticity_face(), oomph::DarcyFaceElement< ELEMENT >::fill_in_contribution_to_residuals_darcy_face(), oomph::PoroelasticityFaceElement< ELEMENT >::fill_in_contribution_to_residuals_darcy_face(), oomph::AxisymmetricPoroelasticityTractionElement< ELEMENT >::pressure(), oomph::DarcyFaceElement< ELEMENT >::pressure(), and oomph::PoroelasticityFaceElement< ELEMENT >::pressure().

◆ get_simple_exact_u()

void GlobalParameters::get_simple_exact_u ( const Vector< double > &  x,
Vector< double > &  u 
)

Get the exact solution, u, at the spatial position, x.

149  {
150  // Initialise a variable to store the radial distance
151  double r=std::sqrt((x[0]-Centre)*(x[0]-Centre)
152  +(x[1]-Centre)*(x[1]-Centre)
153  +(x[2]-Centre)*(x[2]-Centre));
154 
155  // Scale the radial distance by the wavenumber
156  double kr=Wavenumber*r;
157 
158  // The solution is singular at the centre so set it to zero
159  if (r==0.0)
160  {
161  // Set the real part of the solution value
162  u[0]=0.0;
163 
164  // Set the imaginary part of the solution value
165  u[1]=0.0;
166  }
167  // Otherwise set the correct solution value
168  else
169  {
170  // Set the real part of the solution value
171  u[0]=cos(kr)/kr;
172 
173  // Set the imaginary part of the solution value
174  u[1]=sin(kr)/kr;
175  }
176  } // End of get_simple_exact_u
GlobalParameters::Centre
double Centre
The x and y coordinate of the centre of the cube.
Definition: structured_cubic_point_source.cc:145

References Centre, cos(), UniformPSDSelfTest::r, sin(), sqrt(), Wavenumber, and plotDoE::x.

Referenced by PMLStructuredCubicHelmholtz< ELEMENT >::apply_boundary_conditions(), and PMLStructuredCubicHelmholtz< ELEMENT >::doc_solution().

◆ get_source() [1/2]

void GlobalParameters::get_source ( const double &  time,
const Vector< double > &  x,
double &  source 
)

Source function.

Source function to make it an exact solution.

155  {
156  double r=sqrt(x[0]*x[0]+x[1]*x[1]);
157  if (r>0.5*(Radius_inner+Radius_innermost))
158  {
159  source = S1;
160  }
161  else
162  {
163  source = S0;
164  }
165 
166  }
TestProblem::source
void source(const Vector< double > &x, Vector< double > &f)
Source function.
Definition: unstructured_two_d_circle.cc:46

References UniformPSDSelfTest::r, Radius_inner, Radius_innermost, S0, S1, TestProblem::source(), sqrt(), and plotDoE::x.

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

◆ get_source() [2/2]

void GlobalParameters::get_source ( const Vector< double > &  x,
double &  source 
)

Source function required to make the solution above an exact solution.

111  {
112  source = 2.0*tanh(-1.0+Alpha*(TanPhi*x[0]-x[1]))*
113  (1.0-pow(tanh(-1.0+Alpha*(TanPhi*x[0]-x[1])),2.0))*
114  Alpha*Alpha*TanPhi*TanPhi+2.0*tanh(-1.0+Alpha*(TanPhi*x[0]-x[1]))*
115  (1.0-pow(tanh(-1.0+Alpha*(TanPhi*x[0]-x[1])),2.0))*Alpha*Alpha;
116  }
TanhSolnForAdvectionDiffusion::TanPhi
double TanPhi
Parameter for angle of step.
Definition: two_d_adv_diff_adapt.cc:56
TanhSolnForAdvectionDiffusion::Alpha
double Alpha
Parameter for steepness of step.
Definition: two_d_adv_diff_adapt.cc:53

References TanhSolnForAdvectionDiffusion::Alpha, Eigen::bfloat16_impl::pow(), TestProblem::source(), Eigen::bfloat16_impl::tanh(), TanhSolnForAdvectionDiffusion::TanPhi, and plotDoE::x.

◆ I()

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

Imaginary unit.

◆ incoming_sb_inside()

double GlobalParameters::incoming_sb_inside ( const double &  t)

Incoming sb radiation on inside.

678  {
679  double t0=0.0;
680 
681 // #--------------------------------------------------------------------
682 // # Incoming sb radiation inside
683 // #--------------------------------------------------------------------
684 // > C(eval(Sigma*((Theta_0+U1)^4)));
685 
686  t0 = Sigma*((Beta0*(Radius_innermost-R_hat*(t-sin(2.0*
687 0.3141592653589793E1*t)/0.3141592653589793E1/2.0))*(V0+V0_hat*(1.0+cos(2.0*
688 0.3141592653589793E1*t))/2.0)+R_hat*(1.0-cos(2.0*0.3141592653589793E1*t)))/
689 Sigma+pow(Theta_0+U0,4.0));
690 
691 
692 
693  return t0;
694  }
ExactSolution::U0
double U0
Constant/initial temperature.
Definition: circular_boulder_melt.cc:99
GlobalParameters::V0_hat
double V0_hat
Coeff for time variation inner circle.
Definition: stefan_boltzmann_melt.cc:230
GlobalParameters::V0
double V0
Coeff for (time-)constant variation of temperature in inner circle.
Definition: stefan_boltzmann_melt.cc:227
GlobalParameters::R_hat
double R_hat
Temporal variation in inner radius (for exact solution)
Definition: stefan_boltzmann_melt.cc:215
plotPSD.t
t
Definition: plotPSD.py:36

References Beta0, cos(), Eigen::bfloat16_impl::pow(), R_hat, Radius_innermost, Sigma, sin(), plotPSD::t, Theta_0, ExactSolution::U0, V0, and V0_hat.

Referenced by StefanBoltzmannProblem< ELEMENT >::doc_solution().

◆ incoming_sb_outside()

double GlobalParameters::incoming_sb_outside ( const double &  t)

Incoming sb radiation on outside.

700  {
701  double t0=0.0;
702 
703 // #--------------------------------------------------------------------
704 // # Incoming sb radiation outside
705 // #--------------------------------------------------------------------
706 // > C(eval((Theta_0+U0)^4*r0(t)/Radius_inner+
707 // > (Theta_0+U1)^4*(1-(r0(t)/Radius_inner))));
708 
709  t0 = Sigma*(pow(Theta_0+U0,4.0)*(Radius_innermost-R_hat*(t-sin(2.0*
710 0.3141592653589793E1*t)/0.3141592653589793E1/2.0))/Radius_inner+((Beta0*(
711 Radius_innermost-R_hat*(t-sin(2.0*0.3141592653589793E1*t)/0.3141592653589793E1/
712 2.0))*(V0+V0_hat*(1.0+cos(2.0*0.3141592653589793E1*t))/2.0)+R_hat*(1.0-cos(2.0*
713 0.3141592653589793E1*t)))/Sigma+pow(Theta_0+U0,4.0))*(1.0-(Radius_innermost-
714 R_hat*(t-sin(2.0*0.3141592653589793E1*t)/0.3141592653589793E1/2.0))/
715 Radius_inner));
716 
717  return t0;
718  }

References Beta0, cos(), Eigen::bfloat16_impl::pow(), R_hat, Radius_inner, Radius_innermost, Sigma, sin(), plotPSD::t, Theta_0, ExactSolution::U0, V0, and V0_hat.

Referenced by StefanBoltzmannProblem< ELEMENT >::doc_solution().

◆ initial_condition()

void GlobalParameters::initial_condition ( const Vector< double > &  x,
Vector< double > &  u 
)

Initial condition for velocity.

195  {
196  // Call a helper function to calculate the initial conditions
197  synthetic_velocity_field(x,u);
198  } // End of initial_condition
GlobalParameters::synthetic_velocity_field
void synthetic_velocity_field(const Vector< double > &x, Vector< double > &veloc)
Synthetic velocity field for validation.
Definition: vorticity_smoother_validation.cc:175

References synthetic_velocity_field(), and plotDoE::x.

◆ is_in_pinned_region()

bool GlobalParameters::is_in_pinned_region ( const Vector< double > &  x)

Function to determine whether or not a point lies in the centre of the mesh (in the pinned region)

223  {
224  // Check if the element lies in the central cube region
225  return (abs(x[0]-GlobalParameters::Centre)<
226  (0.5*GlobalParameters::Element_width+Eps)&&
227  abs(x[1]-GlobalParameters::Centre)<
228  (0.5*GlobalParameters::Element_width+Eps)&&
229  abs(x[2]-GlobalParameters::Centre)<
230  (0.5*GlobalParameters::Element_width+Eps));
231  } // End of is_in_pinned_region
GlobalParameters::Element_width
double Element_width
The element width.
Definition: structured_cubic_point_source.cc:119
GlobalParameters::Eps
double Eps
The tolerance for a point relative to the bounding inner square.
Definition: structured_cubic_point_source.cc:218

References abs(), Centre, Element_width, Eps, and plotDoE::x.

Referenced by PMLStructuredCubicHelmholtz< ELEMENT >::apply_boundary_conditions(), and PMLStructuredCubicHelmholtz< ELEMENT >::doc_solution().

◆ melt_flux()

double GlobalParameters::melt_flux ( const double &  t)

Melt flux for exact solution (to test melting without feedback with S.B.)

644  {
645  double t0=0;
646 
647 //#--------------------------------------------------------------------
648 //# Melt flux
649 //#--------------------------------------------------------------------
650 //> C(eval(melt_flux));
651 
652  t0 = R_hat*(1.0-cos(2.0*0.3141592653589793E1*t));
653 
654  return t0;
655  }

References cos(), R_hat, and plotPSD::t.

Referenced by StefanBoltzmannProblem< ELEMENT >::doc_solution(), oomph::UnsteadyHeatFluxPseudoMeltElement< ELEMENT >::fill_in_generic_residual_contribution_ust_heat_flux(), oomph::SurfaceMeltElement< ELEMENT >::interpolated_melt_rate(), oomph::UnsteadyHeatFluxPseudoMeltElement< ELEMENT >::output(), and ExactSolution::prescribed_flux_for_unsteady_heat_validation().

◆ parameter_to_string()

std::string GlobalParameters::parameter_to_string ( const double *const  parameter_pt)

Helper function that takes a pointer to one of the problem parameters and returns a string to denote it. Used in the (generic) parameter continuation functions to tell the user which parameter we're changing and what value it has at each iteration

867  {
868  // Are we dealing with the Reynolds number?
869  if (parameter_pt==&Re)
870  {
871  // Return a string to denote the Reynolds number
872  return "Re";
873  }
874  else if (parameter_pt==&Amplitude)
875  {
876  // Return a string to denote the amplitude
877  return "A";
878  }
879  else if (parameter_pt==&Period_ratio)
880  {
881  // Return a string to denote the period ratio
882  return "T_e/T_s";
883  }
884  else
885  {
886  // Create an output stream
887  std::ostringstream warning_message_stream;
888 
889  // Create an error message
890  warning_message_stream << "Don't know what to denote this parameter with "
891  << "so I'm just going to return an empty string..."
892  << std::endl;
893 
894  // Provide a warning
895  OomphLibWarning(warning_message_stream.str(),
896  OOMPH_CURRENT_FUNCTION,
897  OOMPH_EXCEPTION_LOCATION);
898 
899  // Return an empty string (this way is faster than simply returning "")
900  return std::string();
901  } // if (parameter_pt==&Re)
902  } // End of parameter_to_string
GlobalParameters::Period_ratio
double Period_ratio
The ratio T_e/T_s.
Definition: flow_past_oscillating_cylinder.cc:212
GlobalPhysicalVariables::Re
double Re
Reynolds number.
Definition: axisym_navier_stokes/counter_rotating_disks/counter_rotating_disks.cc:61
oomph::Global_string_for_annotation::string
std::string string(const unsigned &i)
Definition: oomph_definitions.cc:286

References Amplitude, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, Period_ratio, GlobalPhysicalVariables::Re, and oomph::Global_string_for_annotation::string().

Referenced by NavierStokesProblem< ELEMENT >::run_natural_continuation().

◆ prescribed_flux_on_fixed_y_boundary()

void GlobalParameters::prescribed_flux_on_fixed_y_boundary ( const double &  time,
const Vector< double > &  x,
double &  flux 
)

Flux required by the exact solution on a boundary on which y is fixed.

195  {
196  double X=x[0];
197  double Y=x[1];
198 
199  //The outer unit normal to the boundary is (0,-1)
200  double NX = 0.0;
201  double NY = -1.0;
202 
203  //The flux in terms of the normal is
204  flux = -(1.0-pow(tanh(0.1E1-Alpha*(TanPhi*(X-Beta*tanh(Gamma*cos(0.2E1*
205 MathematicalConstants::Pi*time)))-Y)),2.0))*Alpha*TanPhi*NX+(1.0-pow(tanh(
206 0.1E1-Alpha*(TanPhi*(X-Beta*tanh(Gamma*cos(0.2E1*MathematicalConstants::Pi*
207 time)))-Y)),2.0))*Alpha*NY;
208  }
ProblemParameters::flux
void flux(const double &time, const Vector< double > &x, double &flux)
Get flux applied along boundary x=0.
Definition: pretend_melt.cc:59

References Alpha, Beta, cos(), ProblemParameters::flux(), Gamma, BiharmonicTestFunctions2::Pi, Eigen::bfloat16_impl::pow(), Eigen::bfloat16_impl::tanh(), TanPhi, plotDoE::x, X, and Y.

Referenced by RefineableUnsteadyHeatProblem< ELEMENT >::build_mesh(), and RefineableUnsteadyHeatProblem< ELEMENT >::generic_actions_after().

◆ prescribed_incoming_flux()

void GlobalParameters::prescribed_incoming_flux ( const Vector< double > &  x,
complex< double > &  flux 
)

Flux (normal derivative) on the unit disk for a planar incoming wave

158  {
159  // Switch to polar coordinates
160  double r;
161  r=sqrt(x[0]*x[0]+x[1]*x[1]);
162  double theta;
163  theta=atan2(x[1],x[0]);
164 
165  // Argument of the Bessel/Hankel fcts
166  double rr=sqrt(K_squared)*r;
167 
168  // Compute Bessel/Hankel functions
169  Vector<double> jn(N_fourier+1), yn(N_fourier+1),
170  jnp(N_fourier+1), ynp(N_fourier+1);
171 
172  // We want to compute N_fourier terms but the function
173  // may return fewer than that.
174  int n_actual=0;
175  CRBond_Bessel::bessjyna(N_fourier,rr,n_actual,&jn[0],&yn[0],
176  &jnp[0],&ynp[0]);
177 
178  // Shout if things went wrong...
179 #ifdef PARANOID
180  if (n_actual!=int(N_fourier))
181  {
182  std::ostringstream error_stream;
183  error_stream << "CRBond_Bessel::bessjyna() only computed "
184  << n_actual << " rather than " << N_fourier
185  << " Bessel functions.\n";
186  throw OomphLibError(error_stream.str(),
187  OOMPH_CURRENT_FUNCTION,
188  OOMPH_EXCEPTION_LOCATION);
189  }
190 #endif
191 
192  // Compute the sum: Separate the computation of the negative and
193  // positive terms
194  flux=std::complex<double>(0.0,0.0);
195  for (unsigned i=0;i<N_fourier;i++)
196  {
197  flux+=pow(I,i)*(sqrt(K_squared))*pow(exp(I*theta),i)*jnp[i];
198  }
199  for (unsigned i=1;i<N_fourier;i++)
200  {
201  flux+=pow(I,i)*(sqrt(K_squared))*pow(exp(-I*theta),i)*jnp[i];
202  }
203 
204 
205  }// end of prescribed_incoming_flux

References atan2(), CRBond_Bessel::bessjyna(), Eigen::bfloat16_impl::exp(), ProblemParameters::flux(), i, I, ProblemParameters::K_squared, N_fourier, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, Eigen::bfloat16_impl::pow(), UniformPSDSelfTest::r, sqrt(), BiharmonicTestFunctions2::theta, and plotDoE::x.

Referenced by PMLProblem< ELEMENT >::create_flux_elements(), and ScatteringProblem< ELEMENT >::set_prescribed_incoming_flux_pt().

◆ radius()

double GlobalParameters::radius ( const double &  t)

Exact radius of inner circle.

660  {
661  double t0=0.0;
662 
663 //#--------------------------------------------------------------------
664 //# Radius
665 //#--------------------------------------------------------------------
666 //> C(eval(r0(t)));
667 
668  t0 = Radius_innermost-R_hat*(t-sin(2.0*0.3141592653589793E1*t)/
669 0.3141592653589793E1/2.0);
670 
671 
672  return t0;
673  }

References R_hat, Radius_innermost, sin(), and plotPSD::t.

Referenced by StefanBoltzmannProblem< ELEMENT >::doc_solution().

◆ round()

double GlobalParameters::round ( const double &  d)

---------------------------------------—DOCUMENTATION HELPERS---—

--------------------—Documentation Helpers----------------------—

Function to round a double to the nearest integral value.

-----------------------------------------------—MISCELLANEOUS---— Function to round a double to the nearest integral value

------------------------—Miscellaneous--------------------------— Function to round a double to the nearest integral value

411  {
412  // Round it
413  return std::floor(d+0.5);
414  } // End of round
Eigen::bfloat16_impl::floor
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 floor(const bfloat16 &a)
Definition: BFloat16.h:643

References Eigen::bfloat16_impl::floor().

Referenced by NavierStokesProblem< ELEMENT >::assign_time_slice_id(), and FlowAroundCylinderProblem< ELEMENT >::unsteady_simulation().

◆ set_up_dof_to_block_mapping()

void GlobalParameters::set_up_dof_to_block_mapping ( Vector< unsigned > &  dof_to_block_map)

Helper function which sets up the mapping between DOF types and which block they should be assigned to. This relies on the concept of "time slices" in the space-time formulation. All dofs in a given time slice will be aggregrated together

Helper function which sets up the mapping between DOF types and which block they should be assigned to. This relies on the concept of "time slabs" in the space-time formulation. All dofs in a given time slab will be aggregrated together

736  {
737  // Resize the vector
738  dof_to_block_map.resize(N_dof_type);
739 
740  // Loop over the dofs
741  for (unsigned i=0; i<N_dof_type; i++)
742  {
743  // How many unique dof types are there per element? i.e. The velocities
744  // and pressure in the first time slice constitute the first 3 then the
745  // velocities in the middle time slice (in the element noting that the
746  // NS elements use quadratic interpolation in time). The velocities and
747  // pressure in the final time slice of the element are not included
748  // because they are stored as the first 3 dof types in the next element
749  // (in the time direction).
750  unsigned n_unique_dof_per_element=3;
751 
752  // How many unique dof types are there per element after we've aggregated
753  // the velocity components together? i.e. the velocities and pressure in
754  // the first time slice in the element constitute one (aggregated) dof
755  unsigned n_unique_aggregated_dof_per_element=1;
756 
757  // What (local) elemental dof does this (global) dof correspond to?
758  unsigned i_local_dof=i%n_unique_dof_per_element;
759 
760  // Which elemental time slice does this dof correspond to?
761  unsigned i_temporal=(i-i_local_dof)/n_unique_dof_per_element;
762 
763  // The first time slice in the element (u,v and p)
764  if ((i_local_dof==0)||(i_local_dof==1)||(i_local_dof==2))
765  {
766  // Calculate the i-th entry
767  dof_to_block_map[i]=i_temporal*n_unique_aggregated_dof_per_element;
768  }
769  else
770  {
771  // Create an output stream
772  std::ostringstream error_message_stream;
773 
774  // Create an error message
775  error_message_stream << "There should only be 3 unique dofs per element. "
776  << "Instead, you have " << n_unique_dof_per_element
777  << " unique dofs per element." << std::endl;
778 
779  // Throw the error message
780  throw OomphLibError(error_message_stream.str(),
781  OOMPH_CURRENT_FUNCTION,
782  OOMPH_EXCEPTION_LOCATION);
783  }
784  } // for (unsigned i=0;i<n_dof_types;i++)
785  } // End of set_up_dof_to_block_mapping
GlobalParameters::N_dof_type
unsigned N_dof_type
Definition: space_time_oscillating_cylinder.cc:729

References i, N_dof_type, OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

Referenced by NavierStokesProblem< ELEMENT >::set_up_spacetime_solver(), and UnsteadyHeatProblem< ELEMENT >::set_up_spacetime_solver().

◆ setup_dependent_parameters_and_sanity_check()

void GlobalParameters::setup_dependent_parameters_and_sanity_check ( )

Setup dependent parameters and perform sanity check.

127  {
128 
129  // Reset initial value for kappa
130  Kappa_initial=0.0;
131 
132  // Check that we've got an even number of elements for control element
133  if ((N_x%2!=0)||(N_y%2!=0))
134  {
135  cout << "n_x n_y should even" << endl;
136  abort();
137  }
138 
139  // Find control element
140  Control_element=N_y*N_x/2+N_x/2;
141 
142  // Set up mesh and spines parameters
143  if (Case==Spherical_cap_in_cylinder_pinned)
144  {
145  // Reset parameters (not realLy used for mesh in this
146  // case but for normalisation of spine rotation)
147  L_x=1.0;
148  L_y=1.0;
149 
150  // Rotate outwards
151  Alpha_min=MathematicalConstants::Pi/2.0;
152  Alpha_max=MathematicalConstants::Pi/2.0*0.5;
153  Rotate_spines_in_both_directions=true;
154  }
155  else if (Case==All_pinned)
156  {
157  // Spines angles for all pinned boundary conditions
158  Alpha_min=MathematicalConstants::Pi/2.0*1.5;
159  Alpha_max=MathematicalConstants::Pi/2.0*0.5;
160  Rotate_spines_in_both_directions=true;
161  }
162  else if (Case==Barrel_shape)
163  {
164  // Spines angles for barrel shaped validation
165  Alpha_min=MathematicalConstants::Pi/2.0*1.5;
166  Alpha_max=MathematicalConstants::Pi/2.0*0.5;
167  Rotate_spines_in_both_directions=false;
168  }
169  else if (Case==T_junction_with_nonzero_contact_angle)
170  {
171  // Spines angles for T-junction with non nil contact angle
172  Alpha_min=MathematicalConstants::Pi/2.0*1.5;
173  Alpha_max=MathematicalConstants::Pi/2.0*0.5;
174  Rotate_spines_in_both_directions=false;
175  }
176  else
177  {
178  std::cout << "Never get here: Case = " << Case << std::endl;
179  assert(false);
180  }
181 
182  // Convert angle to cos
183  Cos_gamma = cos(Gamma);
184 
185  } // end of set up
assert
#define assert(e,...)
Definition: Logger.h:744
GlobalParameters::Alpha_max
double Alpha_max
Max. spine angle against horizontal plane.
Definition: barrel.cc:99
GlobalParameters::Control_element
unsigned Control_element
Definition: common_young_laplace_stuff.h:90
GlobalParameters::Rotate_spines_in_both_directions
bool Rotate_spines_in_both_directions
Should the spines rotate in the x and y directions (true)?
Definition: common_young_laplace_stuff.h:119
GlobalParameters::Kappa_initial
double Kappa_initial
Initial value for kappa.
Definition: common_young_laplace_stuff.h:67
GlobalParameters::Alpha_min
double Alpha_min
Min. spine angle against horizontal plane.
Definition: barrel.cc:96
GlobalParameters::Cos_gamma
double Cos_gamma
Cos of contact angle.
Definition: common_young_laplace_stuff.h:61
GlobalParameters::Case
int Case
What case are we considering: Choose one from the enumeration Cases.
Definition: common_young_laplace_stuff.h:53
GlobalPhysicalVariables::Gamma
double Gamma
Aspect ratio (cylinder height / cylinder radius)
Definition: axisym_navier_stokes/counter_rotating_disks/counter_rotating_disks.cc:70
Global_Parameters::L_y
double L_y
Definition: navier_stokes/navier_stokes_with_singularity/driven_cavity.cc:192
Global_Parameters::L_x
double L_x
Definition: navier_stokes/navier_stokes_with_singularity/driven_cavity.cc:189
TanhSolnForPoisson::N_y
double N_y
Orientation of non-normalised y-component of vector in plane direction.
Definition: extrude_with_macro_element_representation.cc:191
TanhSolnForPoisson::N_x
double N_x
Orientation of non-normalised x-component of vector in plane direction.
Definition: extrude_with_macro_element_representation.cc:188

References All_pinned, Alpha_max, Alpha_min, assert, Barrel_shape, Case, Control_element, cos(), Cos_gamma, Gamma, Kappa_initial, L_x, L_y, N_x, N_y, BiharmonicTestFunctions2::Pi, Rotate_spines_in_both_directions, Spherical_cap_in_cylinder_pinned, and T_junction_with_nonzero_contact_angle.

◆ sin_cos_velocity_field()

void GlobalParameters::sin_cos_velocity_field ( const Vector< double > &  x,
Vector< double > &  u 
)

Returns the velocity field associated with the Taylor-Green vortex solution (for validation of vorticity projection)

62  {
63  // Time remains fixed so set to zero
64  double t=0.0;
65 
66  // Calculate the temporal component
67  double temporal_component=exp(-2.0*Kinematic_viscosity*t);
68 
69  // Frequency in the x-direction
70  double omega_x=2.0*MathematicalConstants::Pi/Length;
71 
72  // Frequency in the y-direction
73  double omega_y=2.0*MathematicalConstants::Pi/Height;
74 
75  // The phase shift
76  double phi=MathematicalConstants::Pi/2.0;
77 
78  // First velocity component
79  u[0]=cos(omega_x*x[0]+phi)*sin(omega_y*x[1]+phi)*temporal_component;
80 
81  // Second velocity component
82  u[1]=-sin(omega_x*x[0]+phi)*cos(omega_y*x[1]+phi)*temporal_component;
83  } // End of sin_cos_velocity_field
GlobalParameters::Height
double Height
Height of domain.
Definition: flow_past_oscillating_cylinder.cc:316
GlobalParameters::Kinematic_viscosity
double Kinematic_viscosity
The value of the kinematic viscosity (assumed to be the same everywhere)
Definition: vorticity_smoother_validation.cc:56
GlobalParameters::Length
double Length
Length of computational domain.
Definition: vorticity_smoother_validation.cc:47

References cos(), Eigen::bfloat16_impl::exp(), Height, Kinematic_viscosity, Length, BiharmonicTestFunctions2::Pi, sin(), plotPSD::t, and plotDoE::x.

Referenced by synthetic_velocity_field().

◆ sin_cos_vorticity()

void GlobalParameters::sin_cos_vorticity ( const Vector< double > &  x,
Vector< Vector< double > > &  vort_and_derivs 
)

Returns the vorticity field associated with the Taylor-Green vortex solution (for validation of vorticity projection)

90  {
91  // Time remains fixed so set to zero
92  double t=0.0;
93 
94  // Calculate the temporal component
95  double temporal_component=exp(-2.0*Kinematic_viscosity*t);
96 
97  // Frequency in the x-direction
98  double omega_x=2.0*MathematicalConstants::Pi/Length;
99 
100  // Frequency in the y-direction
101  double omega_y=2.0*MathematicalConstants::Pi/Height;
102 
103  // The phase shift
104  double phi=MathematicalConstants::Pi/2.0;
105 
106  // The vorticity itself: w
107  vort_and_derivs[0][0]=(-1.0*(omega_x+omega_y)*
108  cos(omega_x*x[0]+phi)*cos(omega_y*x[1]+phi)*
109  temporal_component);
110 
111  // The first derivative of the vorticity: dw/dx
112  vort_and_derivs[1][0]=(omega_x*(omega_x+omega_y)*
113  sin(omega_x*x[0]+phi)*cos(omega_y*x[1]+phi)*
114  temporal_component);
115 
116  // The first derivative of the vorticity: dw/dy
117  vort_and_derivs[1][1]=(omega_y*(omega_x+omega_y)*
118  cos(omega_x*x[0]+phi)*sin(omega_y*x[1]+phi)*
119  temporal_component);
120 
121  // The second derivative of the vorticity: dw^2/dx^2
122  vort_and_derivs[2][0]=(omega_x*omega_x*(omega_x+omega_y)*
123  cos(omega_x*x[0]+phi)*cos(omega_y*x[1]+phi)*
124  temporal_component);
125 
126  // The second derivative of the vorticity: dw^2/dxdy
127  vort_and_derivs[2][1]=(-1.0*omega_x*omega_y*(omega_x+omega_y)*
128  sin(omega_x*x[0]+phi)*sin(omega_y*x[1]+phi)*
129  temporal_component);
130 
131  // The second derivative of the vorticity: dw^2/dy^2
132  vort_and_derivs[2][2]=(omega_y*omega_y*(omega_x+omega_y)*
133  cos(omega_x*x[0]+phi)*cos(omega_y*x[1]+phi)*
134  temporal_component);
135 
136  // The third derivative of the vorticity: dw^3/dx^3
137  vort_and_derivs[3][0]=(-1.0*omega_x*omega_x*omega_x*(omega_x+omega_y)*
138  sin(omega_x*x[0]+phi)*cos(omega_y*x[1]+phi)*
139  temporal_component);
140 
141  // The third derivative of the vorticity: dw^3/dx^2dy
142  vort_and_derivs[3][1]=(-1.0*omega_x*omega_x*omega_y*(omega_x+omega_y)*
143  cos(omega_x*x[0]+phi)*sin(omega_y*x[1]+phi)*
144  temporal_component);
145 
146  // The third derivative of the vorticity: dw^3/dxdy^2
147  vort_and_derivs[3][2]=(-1.0*omega_x*omega_y*omega_y*(omega_x+omega_y)*
148  sin(omega_x*x[0]+phi)*cos(omega_y*x[1]+phi)*
149  temporal_component);
150 
151  // The third derivative of the vorticity: dw^3/dy^3
152  vort_and_derivs[3][3]=(-1.0*omega_y*omega_y*omega_y*(omega_x+omega_y)*
153  cos(omega_x*x[0]+phi)*sin(omega_y*x[1]+phi)*
154  temporal_component);
155 
156  // The derivatives of the velocity: du/dx
157  vort_and_derivs[4][0]=(-1.0*omega_x*sin(omega_x*x[0]+phi)*
158  sin(omega_y*x[1]+phi)*temporal_component);
159 
160  // The derivatives of the velocity: du/dy
161  vort_and_derivs[4][1]=(omega_y*cos(omega_x*x[0]+phi)*
162  cos(omega_y*x[1]+phi)*temporal_component);
163 
164  // The derivatives of the velocity: dv/dx
165  vort_and_derivs[4][2]=(-1.0*omega_x*cos(omega_x*x[0]+phi)*
166  cos(omega_y*x[1]+phi)*temporal_component);
167 
168  // The derivatives of the velocity: dv/dy
169  vort_and_derivs[4][3]=(omega_y*sin(omega_x*x[0]+phi)*
170  sin(omega_y*x[1]+phi)*temporal_component);
171  } // End of sin_cos_vorticity

References cos(), Eigen::bfloat16_impl::exp(), Height, Kinematic_viscosity, Length, BiharmonicTestFunctions2::Pi, sin(), plotPSD::t, and plotDoE::x.

Referenced by synthetic_vorticity().

◆ spine_base_function() [1/2]

void GlobalParameters::spine_base_function ( const Vector< double > &  x,
Vector< double > &  spine_B,
Vector< Vector< double > > &  dspine_B 
)

Spine basis: The position vector to the basis of the spine as a function of the two coordinates x_1 and x_2, and its derivatives w.r.t. to these coordinates. dspine_B[i][j] = d spine_B[j] / dx_i Spines start in the (x_1,x_2) plane at (x_1,x_2).

75  {
76 
77  // Bspines and derivatives
78  spine_B[0] = x[0];
79  spine_B[1] = x[1];
80  spine_B[2] = 0.0 ;
81  dspine_B[0][0] = 1.0 ;
82  dspine_B[1][0] = 0.0 ;
83  dspine_B[0][1] = 0.0 ;
84  dspine_B[1][1] = 1.0 ;
85  dspine_B[0][2] = 0.0 ;
86  dspine_B[1][2] = 0.0 ;
87 
88  } // End of bspine functions

References plotDoE::x.

Referenced by RefineableYoungLaplaceProblem< ELEMENT >::RefineableYoungLaplaceProblem(), and YoungLaplaceProblem< ELEMENT >::YoungLaplaceProblem().

◆ spine_base_function() [2/2]

void GlobalParameters::spine_base_function ( const Vector< double > &  x,
Vector< double > &  spine_B,
Vector< Vector< double > > &  dspine_B 
)

Spine basis: The position vector to the basis of the spine as a function of the two coordinates x_1 and x_2, and its derivatives w.r.t. to these coordinates. dspine_B[i][j] = d spine_B[j] / dx_i Spines start in the (x_1,x_2) plane at (x_1,x_2).

198  {
199 
200  // Bspines and derivatives
201  spine_B[0] = x[0];
202  spine_B[1] = x[1];
203  spine_B[2] = 0.0 ;
204  dspine_B[0][0] = 1.0 ;
205  dspine_B[1][0] = 0.0 ;
206  dspine_B[0][1] = 0.0 ;
207  dspine_B[1][1] = 1.0 ;
208  dspine_B[0][2] = 0.0 ;
209  dspine_B[1][2] = 0.0 ;
210 
211  } // End of bspine functions

References plotDoE::x.

◆ spine_function() [1/2]

void GlobalParameters::spine_function ( const Vector< double > &  x,
Vector< double > &  spine,
Vector< Vector< double > > &  dspine 
)

Spine: The spine vector field as a function of the two coordinates x_1 and x_2, and its derivatives w.r.t. to these coordinates: dspine[i][j] = d spine[j] / dx_i

Spines (and derivatives) are independent of x[0] and rotate in the x[1]-direction

Spines (and derivatives) are independent of x[0] and rotate in the x[1]-direction

Spines (and derivatives) are independent of x[0] and rotate in the x[1]-direction

107  {
108 
111  spine[0]=0.0;
112  dspine[0][0]=0.0;
113  dspine[1][0]=0.0;
114 
115  spine[1]=cos(Alpha_min+(Alpha_max-Alpha_min)*x[1]);
116  dspine[0][1]=0.0;
117  dspine[1][1]=-sin(Alpha_min+(Alpha_max-Alpha_min)*x[1])
118  *(Alpha_max-Alpha_min);
119 
120  spine[2]=sin(Alpha_min+(Alpha_max-Alpha_min)*x[1]);
121  dspine[0][2]=0.0;
122  dspine[1][2]=cos(Alpha_min+(Alpha_max-Alpha_min)*x[1])
123  *(Alpha_max-Alpha_min);
124 
125  } // End spine function

References Alpha_max, Alpha_min, cos(), sin(), and plotDoE::x.

Referenced by RefineableYoungLaplaceProblem< ELEMENT >::RefineableYoungLaplaceProblem(), and YoungLaplaceProblem< ELEMENT >::YoungLaplaceProblem().

◆ spine_function() [2/2]

void GlobalParameters::spine_function ( const Vector< double > &  xx,
Vector< double > &  spine,
Vector< Vector< double > > &  dspine 
)

Spine: The spine vector field as a function of the two coordinates x_1 and x_2, and its derivatives w.r.t. to these coordinates: dspine[i][j] = d spine[j] / dx_i

Spines (and derivatives) are independent of x[0] and rotate in the x[1]-direction

Spines are dependent of x[0] AND x[1] and rotate in both directions

220  {
221 
222  // Scale lengths
223  Vector<double> x(2,0.0);
224  x[0]=xx[0]/L_x;
225  x[1]=xx[1]/L_y;
226 
227  // Which spine orientation do we have?
228  if (!Rotate_spines_in_both_directions)
229  {
232  spine[0]=0.0; // Sx
233  dspine[0][0]=0.0; // dSx/dx[0]
234  dspine[1][0]=0.0; // dSx/dx[1]
235 
236  spine[1]=cos(Alpha_min+(Alpha_max-Alpha_min)*x[1]); // Sy
237  dspine[0][1]=0.0; // dSy/dx[0]
238  dspine[1][1]=-sin(Alpha_min+(Alpha_max-Alpha_min)*x[1])
239  *(Alpha_max-Alpha_min)/L_y; // dSy/dx[1]
240 
241  spine[2]=sin(Alpha_min+(Alpha_max-Alpha_min)*x[1]); // Sz
242  dspine[0][2]=0.0; // dSz/dx[0]
243  dspine[1][2]=cos(Alpha_min+(Alpha_max-Alpha_min)*x[1])
244  *(Alpha_max-Alpha_min)/L_y; // dSz/dx[1]
245  }
246  else
247  {
249  spine[0]=cos(Alpha_min+(Alpha_max-Alpha_min)*x[0]); // Sx
250  dspine[0][0]=-sin(Alpha_min+(Alpha_max-Alpha_min)*x[0])*
251  (Alpha_max-Alpha_min)/L_x; // dSx/dx[0]
252  dspine[1][0]=0.0; // dSx/dx[1]
253 
254  spine[1]=cos(Alpha_min+(Alpha_max-Alpha_min)*x[1]); // Sy
255  dspine[0][1]=0.0; // dSy/dx[0]
256  dspine[1][1]=-sin(Alpha_min+(Alpha_max-Alpha_min)*x[1])*
257  (Alpha_max-Alpha_min)/L_y; // dSy/dx[1]
258 
259  spine[2]=1.0; // Sz
260  dspine[0][2]=0.0; // dSz/dx[0]
261  dspine[1][2]=0.0; // dSz/dx[1]
262  }
263 
264 
265  } // End spine function

References Alpha_max, Alpha_min, cos(), L_x, L_y, Rotate_spines_in_both_directions, sin(), and plotDoE::x.

◆ step_position()

double GlobalParameters::step_position ( const double &  time)

Position of step (x-axis intercept)

151  {
152  return Beta*tanh(Gamma*cos(0.2E1*MathematicalConstants::Pi*time));
153  }

References Beta, cos(), Gamma, BiharmonicTestFunctions2::Pi, and Eigen::bfloat16_impl::tanh().

Referenced by RefineableUnsteadyHeatProblem< ELEMENT >::doc_solution().

◆ synthetic_velocity_field()

void GlobalParameters::synthetic_velocity_field ( const Vector< double > &  x,
Vector< double > &  veloc 
)

Synthetic velocity field for validation.

177  {
178  // Get the sin/cos velocity field
179  sin_cos_velocity_field(x,veloc);
180  } // End of synthetic_velocity_field
GlobalParameters::sin_cos_velocity_field
void sin_cos_velocity_field(const Vector< double > &x, Vector< double > &u)
Definition: vorticity_smoother_validation.cc:60

References sin_cos_velocity_field(), and plotDoE::x.

Referenced by VorticityRecoveryProblem< ELEMENT >::apply_boundary_conditions(), VorticityRecoveryProblem< ELEMENT >::assign_synthetic_veloc_field(), and initial_condition().

◆ synthetic_vorticity()

void GlobalParameters::synthetic_vorticity ( const Vector< double > &  x,
Vector< Vector< double > > &  vort_and_derivs 
)

Synthetic vorticity field and derivs for validation.

186  {
187  // Get the sin/cos vorticity field
188  sin_cos_vorticity(x,vort_and_derivs);
189  } // End of synthetic_vorticity
GlobalParameters::sin_cos_vorticity
void sin_cos_vorticity(const Vector< double > &x, Vector< Vector< double > > &vort_and_derivs)
Definition: vorticity_smoother_validation.cc:88

References sin_cos_vorticity(), and plotDoE::x.

Referenced by VorticityRecoveryProblem< ELEMENT >::complete_problem_setup().

◆ update_mesh_parameters()

void GlobalParameters::update_mesh_parameters ( )

Update mesh parameters. This is (and only needs to be) once per simulation, during the setup of the mesh. This decides how thick the "fine resolution" layer of elements around the cylinder is. This layer is used to accurately resolve the boundary layer close to the cylinder.

702  {
703  // Sanity check: N_t has to be odd!
704  if ((N_t%2)==0)
705  {
706  // Throw an error
707  OomphLibWarning("Method requires an odd number of time slices!\n",
708  OOMPH_CURRENT_FUNCTION,
709  OOMPH_EXCEPTION_LOCATION);
710  }
711 
712  // Update the radius of the annular region from the updated parameter
713  // values. NOTE: The annular rings are used to resolve the boundary
714  // layers so they should not be made too large (hence the use of std::min)
715  Annular_region_radius=
716  Radius+std::min(2.0*Radius,0.5*((0.5*Length_of_central_box)-Radius));
717  } // End of update_mesh_parameters
min
#define min(a, b)
Definition: datatypes.h:22
GlobalParameters::N_t
unsigned N_t
The number of elements in the time direction.
Definition: space_time_oscillating_cylinder.cc:694
Global_Physical_Variables::Radius
double Radius
Radius of the pipe.
Definition: pipe.cc:55

References Annular_region_radius, Length_of_central_box, min, N_t, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and Global_Physical_Variables::Radius.

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

◆ update_parameters()

void GlobalParameters::update_parameters ( )

Update parameters.

Update the parameters passed in at the command line.

Wavenumber (also known as k), k=omega/c

Wavenumber (also known as k), k=omega/c

Wavenumber (also known as k), k=omega/c

Wavenumber (also known as k), k=omega/c

275  {
276  // Update the radius of the annular mesh region surrounding the cylinder
277  Annular_region_radius=
278  Radius+std::min(2.0*Radius,0.5*((0.5*Length_of_box)-Radius));
279  } // End of update_parameters
GlobalParameters::Length_of_box
double Length_of_box
----------------------—Cylinder Properties----------------------—
Definition: extrude_with_macro_element_representation.cc:259
GlobalParameters::Radius
double Radius
Radius of the cylinder.
Definition: extrude_with_macro_element_representation.cc:251

References Annular_region_radius, Length_of_box, min, and Radius.

Referenced by main().

◆ update_physical_parameters()

void GlobalParameters::update_physical_parameters ( )

Update physical parameters. This updates: (1) The Reynolds number, and; (2) The Strouhal number, and should ALWAYS be called after either the Reynolds number or Period_ratio value changes.

656  {
657  // Update the Strouhal number
658  St=calculate_strouhal_number(Re)/Period_ratio;
659 
660  // Update the Womersley number
661  ReSt=Re*St;
662  } // End of update_physical_parameters
GlobalParameters::calculate_strouhal_number
double calculate_strouhal_number(const double &re)
Definition: flow_past_oscillating_cylinder.cc:237
GlobalPhysicalVariables::ReSt
double ReSt
Product of Reynolds and Strouhal numbers.
Definition: axisym_navier_stokes/counter_rotating_disks/counter_rotating_disks.cc:64
Global_Physical_Variables::St
double St
Strouhal number.
Definition: elastic_two_layer_interface_axisym.cc:66

References calculate_strouhal_number(), Period_ratio, GlobalPhysicalVariables::Re, GlobalPhysicalVariables::ReSt, and Global_Physical_Variables::St.

Referenced by NavierStokesProblem< ELEMENT >::actions_after_parameter_increase(), and NavierStokesProblem< ELEMENT >::NavierStokesProblem().

◆ update_simulation_parameters()

void GlobalParameters::update_simulation_parameters ( )

Update physical parameters. This updates: (1) The Reynolds number, and; (2) The Strouhal number, and should ALWAYS be called after either the Reynolds number or Period_ratio value changes.

282  {
283  // Update the Strouhal number ourselves to ensure "lock-in"
284  St=calculate_strouhal_number(Re)/Period_ratio;
285 
286  // Calculate the Womersley number
287  ReSt=Re*St;
288  } // End of update_simulation_parameters
GlobalParameters::St
double St
The default Strouhal number (overloaded with input value if given)
Definition: flow_past_oscillating_cylinder.cc:223

References calculate_strouhal_number(), Period_ratio, GlobalPhysicalVariables::Re, ReSt, and St.

Referenced by main().

◆ zero()

void GlobalParameters::zero ( const Vector< double > &  x,
Vector< double > &  u 
)

Function to compute norm of solution itself (we treat this as the "exact" solution)

68  {
69  u[0]=0.0;
70  }

Referenced by UnstructuredFvKProblem< ELEMENT >::doc_solution().

Variable Documentation

◆ ABC_order

unsigned GlobalParameters::ABC_order =3

Flag to choose wich order to use.

Referenced by main(), HelmholtzPointSourceProblem< ELEMENT >::setup_outer_boundary(), and ScatteringProblem< ELEMENT >::setup_outer_boundary().

◆ Add_refinement_level

unsigned GlobalParameters::Add_refinement_level =0

The additional levels of uniform refinement.

Referenced by main().

◆ Alpha

double GlobalParameters::Alpha =1.0

Parameter for steepness of step.

Parameter for steepness of "step".

------------------—Unsteady Heat Parameters---------------------— Alpha value (thermal inertia)

Referenced by get_exact_u(), SinSolution::get_source(), main(), prescribed_flux_on_fixed_y_boundary(), and RefineableUnsteadyHeatProblem< ELEMENT >::RefineableUnsteadyHeatProblem().

◆ Alpha0

double GlobalParameters::Alpha0 =1.0

Thermal inertia in inner region.

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

◆ Alpha1

double GlobalParameters::Alpha1 =1.0

Thermal inertia in outer annular region.

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

◆ Alpha_max

double GlobalParameters::Alpha_max = MathematicalConstants::Pi/2.0*0.5

Max. spine angle against horizontal plane.

Max. first spine angle against horizontal plane.

Referenced by setup_dependent_parameters_and_sanity_check(), and spine_function().

◆ Alpha_min

double GlobalParameters::Alpha_min = MathematicalConstants::Pi/2.0*1.5

Min. spine angle against horizontal plane.

Min. first spine angle against horizontal plane.

Referenced by setup_dependent_parameters_and_sanity_check(), and spine_function().

◆ Alpha_shift

double GlobalParameters::Alpha_shift =0.0

Choose the value of the shift to create the complex-shifted Laplacian preconditioner (CSLP)

Referenced by main(), PMLStructuredCubicHelmholtz< ELEMENT >::set_gmres_multigrid_solver(), PMLHelmholtzMGProblem< ELEMENT >::set_gmres_multigrid_solver(), and oomph::HelmholtzMGPreconditioner< DIM >::setup_mg_structures().

◆ Amplitude

double GlobalParameters::Amplitude =0.50

Amplitude of the cylinder motion.

---------------------------------------------—CYLINDER MOTION---— Amplitude of the cylinder motion used by Williamson & Roshko (1988). Probably best to fix the wavelength and vary this to get different wake modes. Also the easiest way to get different wake patterns to shown in Leontini et al. (2006). SIDE NOTE: as D=1 in our mesh this is also the dimensionless amplitude.

-----------------------—Cylinder Motion-------------------------— Amplitude of the cylinder motion used by Williamson & Roshko (1988). As a side note, since the (simulation) cylinder has unit diameter (i.e. D=1) this is actually the dimensionless amplitude.

Referenced by NavierStokesProblem< ELEMENT >::actions_after_parameter_increase(), CollapsibleChannelProblem< ELEMENT >::CollapsibleChannelProblem(), ExtrudedMovingCylinderProblem< TWO_D_ELEMENT, THREE_D_ELEMENT >::create_extruded_mesh(), NavierStokesProblem< ELEMENT >::create_spacetime_mesh(), doc_maximum_central_box_deformation(), FlowAroundCylinderProblem< ELEMENT >::FlowAroundCylinderProblem(), main(), and parameter_to_string().

◆ Amplitude_target

double GlobalParameters::Amplitude_target =0.50

The target amplitude; used if we're going to do a parameter sweep through the amplitude-wavelength plane. This is generally the second parameter for which parameter continuation is used (if, of course, the value of Amplitude is different to Amplitude_target).

Referenced by main().

◆ Annular_region_radius

double GlobalParameters::Annular_region_radius =1.0

The radius of the annular region surrounding the cylinder.

The radius of the annular region surrounding the cylinder NOTE: The annular rings are used to resolve the boundary layers so they should not be made too large (hence the use of std::min).

Referenced by ExtrudedMovingCylinderProblem< TWO_D_ELEMENT, THREE_D_ELEMENT >::create_extruded_mesh(), NavierStokesProblem< ELEMENT >::create_spacetime_mesh(), doc_maximum_central_box_deformation(), FlowAroundCylinderProblem< ELEMENT >::FlowAroundCylinderProblem(), update_mesh_parameters(), and update_parameters().

◆ Apply_time_periodic_boundary_conditions

bool GlobalParameters::Apply_time_periodic_boundary_conditions =true

Should we apply time-periodic boundary conditions?

Referenced by UnsteadyHeatProblem< ELEMENT >::apply_boundary_conditions(), UnsteadyHeatProblem< ELEMENT >::doc_solution(), and main().

◆ Beta

double GlobalParameters::Beta =1.0

Parameter for amplitude of step translation.

Beta value (thermal conductivity)

Referenced by get_exact_u(), SinSolution::get_source(), prescribed_flux_on_fixed_y_boundary(), RefineableUnsteadyHeatProblem< ELEMENT >::RefineableUnsteadyHeatProblem(), and step_position().

◆ Beta0

double GlobalParameters::Beta0 =0.05

Thermal conductivity in inner region.

Referenced by get_exact_u(), incoming_sb_inside(), incoming_sb_outside(), and StefanBoltzmannProblem< ELEMENT >::StefanBoltzmannProblem().

◆ Beta1

double GlobalParameters::Beta1 =1.5

Thermal conductivity in outer annular region.

Referenced by get_exact_u(), oomph::Newmark< NSTEPS >::Newmark(), oomph::NewmarkBDF< NSTEPS >::set_newmark_veloc_weights(), oomph::Newmark< NSTEPS >::set_weights(), and StefanBoltzmannProblem< ELEMENT >::StefanBoltzmannProblem().

◆ Beta_max

double GlobalParameters::Beta_max = MathematicalConstants::Pi/2.0

Max. second pine angle against horizontal plane.

◆ Beta_min

double GlobalParameters::Beta_min = MathematicalConstants::Pi/2.0

Min. second spine angle against horizontal plane.

◆ Case

int GlobalParameters::Case = All_pinned

What case are we considering: Choose one from the enumeration Cases.

Referenced by RefineableYoungLaplaceProblem< ELEMENT >::actions_after_adapt(), main(), and setup_dependent_parameters_and_sanity_check().

◆ Centre

double GlobalParameters::Centre =Lx/2.0

The x and y coordinate of the centre of the cube.

The x and y coordinate of the centre of the square.

Referenced by get_simple_exact_u(), is_in_pinned_region(), and PMLHelmholtzMGProblem< ELEMENT >::PMLHelmholtzMGProblem().

◆ Constitutive_law_pt

ConstitutiveLaw* GlobalParameters::Constitutive_law_pt =0

Pointer to constitutive law.

Referenced by main().

◆ Control_element

unsigned GlobalParameters::Control_element = 0

Number of element in bulk mesh at which height control is applied. Initialise to 0 – will be overwritte in setup_dependent_parameters_and_sanity_check()

Referenced by setup_dependent_parameters_and_sanity_check().

◆ Controlled_height

double GlobalParameters::Controlled_height = 0.0

Height control value.

Height control value for displacement control.

Referenced by get_exact_kappa(), RefineableYoungLaplaceProblem< ELEMENT >::increment_parameters(), main(), RefineableYoungLaplaceProblem< ELEMENT >::RefineableYoungLaplaceProblem(), and YoungLaplaceProblem< ELEMENT >::YoungLaplaceProblem().

◆ Controlled_height_increment

double GlobalParameters::Controlled_height_increment = 0.1

Increment for height control.

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

◆ Cos_gamma

double GlobalParameters::Cos_gamma =cos(Gamma)

Cos of contact angle.

Referenced by RefineableYoungLaplaceProblem< ELEMENT >::actions_after_adapt(), RefineableYoungLaplaceProblem< ELEMENT >::RefineableYoungLaplaceProblem(), and setup_dependent_parameters_and_sanity_check().

◆ Cylinder_pt

OscillatingCylinder * GlobalParameters::Cylinder_pt =0

---------------------------------—TIME-INTEGRATION PARAMETERS---—

Pointer to the cylinder.

----------------------—Cylinder Properties----------------------— Pointer to the cylinder

-------------------------------------------—DOMAIN PROPERTIES---— Pointer to the cylinder

Referenced by NavierStokesProblem< ELEMENT >::apply_boundary_conditions(), TurekProblem< FLUID_ELEMENT, SOLID_ELEMENT >::build_mesh(), ExtrudedMovingCylinderProblem< TWO_D_ELEMENT, THREE_D_ELEMENT >::create_extruded_mesh(), NavierStokesProblem< ELEMENT >::create_spacetime_mesh(), RectangleWithHoleDomain::cylinder_pt(), CylinderAndInterfaceDomain::CylinderAndInterfaceDomain(), FlowAroundCylinderProblem< ELEMENT >::FlowAroundCylinderProblem(), RectangleWithHoleDomain::macro_element_boundary(), oomph::HalfRectangleWithHoleDomain::macro_element_boundary(), CylinderAndInterfaceDomain::macro_element_boundary(), FlowAroundCylinderProblem< ELEMENT >::make_copy(), oomph::AlgebraicCylinderWithFlagMesh< ELEMENT >::node_update_IX(), and oomph::AlgebraicCylinderWithFlagMesh< ELEMENT >::node_update_VIII().

◆ Directory

string GlobalParameters::Directory ="RESLT"

Output directory.

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

◆ Disable_pml_flag

unsigned GlobalParameters::Disable_pml_flag =0

The choice of whether or not to disable PMLs (the default is to enable them) 0 = Enable PMLs 1 = Disable PMLs

Referenced by PMLHelmholtzMGProblem< ELEMENT >::actions_after_adapt(), GlobalParameters::TestPMLMapping::gamma(), main(), and PMLHelmholtzMGProblem< ELEMENT >::PMLHelmholtzMGProblem().

◆ Doc_convergence_flag

unsigned GlobalParameters::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(), PMLStructuredCubicHelmholtz< ELEMENT >::set_gmres_multigrid_solver(), and PMLHelmholtzMGProblem< ELEMENT >::set_gmres_multigrid_solver().

◆ Doc_info

DocInfo GlobalParameters::Doc_info

Helper for documenting.

-----------------------—Mesh Properties-------------------------—

-------------------------—Solver Info---------------------------—

Doc info object.

DocInfo object used for documentation of the solution.

----------------------—Domain Properties----------------------—

--------------------—Documentation Helpers--------------------— Doc info object

--------------------—Documentation Helpers----------------------—

Referenced by NavierStokesProblem< ELEMENT >::actions_after_newton_solve(), EntryFlowProblem< ELEMENT >::actions_after_newton_solve(), FreeSurfaceRotationProblem< ELEMENT >::actions_after_newton_solve(), RefineableAdvectionDiffusionProblem< ELEMENT >::actions_before_adapt(), RefineableAdvectionDiffusionPipeProblem< ELEMENT >::actions_before_adapt(), PreconditionedFSICollapsibleChannelProblem< ELEMENT >::actions_before_newton_convergence_check(), oomph::MyProblem::actions_before_newton_step(), AnnularDiskProblem< ELASTICITY_ELEMENT >::AnnularDiskProblem(), CantileverProblem< ELEMENT >::CantileverProblem(), CoatedDiskProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::CoatedDiskProblem(), ContactProblem< ELEMENT >::ContactProblem(), ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::ConvectionProblem(), DDConvectionProblem< NST_ELEMENT, AD_ELEMENT >::DDConvectionProblem(), DiskShockWaveProblem< ELEMENT, TIMESTEPPER >::doc_displ_and_veloc(), RefineableFishPoissonProblem< ELEMENT >::doc_info(), GeomObjectAsGeneralisedElementProblem::doc_info(), RefineableUnsteadyHeatProblem< ELEMENT >::doc_info(), RefineableAdvectionDiffusionProblem< ELEMENT >::doc_solution(), SUPGAdvectionDiffusionProblem< ELEMENT >::doc_solution(), AxisymFvKProblem< ELEMENT >::doc_solution(), UnstructuredFvKProblem< ELEMENT >::doc_solution(), RefineableAdvectionDiffusionPipeProblem< ELEMENT >::doc_solution(), MovingBlockProblem< ELEMENT >::doc_solution(), ExtrudedMovingCylinderProblem< TWO_D_ELEMENT, THREE_D_ELEMENT >::doc_solution(), MeltContactProblem< ELEMENT >::doc_solution(), SolarRadiationProblem< ELEMENT >::doc_solution(), ContactProblem< ELEMENT >::doc_solution(), UnsteadyHeatMeltProblem< ELEMENT >::doc_solution(), StefanBoltzmannProblem< ELEMENT >::doc_solution(), CoatedDiskProblem< ELASTICITY_ELEMENT, HELMHOLTZ_ELEMENT >::doc_solution(), RefineableFishPoissonProblem< ELEMENT >::doc_solution(), GeomObjectAsGeneralisedElementProblem::doc_solution(), NavierStokesProblem< ELEMENT >::doc_solution(), UnstructuredSolidProblem< ELEMENT, MESH >::doc_solution(), CantileverProblem< ELEMENT >::doc_solution(), PrescribedBoundaryDisplacementProblem< ELEMENT >::doc_solution(), EntryFlowProblem< ELEMENT >::doc_solution(), ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::doc_solution(), RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::doc_solution(), DDConvectionProblem< NST_ELEMENT, AD_ELEMENT >::doc_solution(), RefineableDDConvectionProblem< NST_ELEMENT, AD_ELEMENT >::doc_solution(), ThermalProblem< ELEMENT >::doc_solution(), PMLStructuredCubicHelmholtz< ELEMENT >::doc_solution(), PMLHelmholtzMGProblem< ELEMENT >::doc_solution(), SteadyCurvedTubeProblem< ELEMENT >::doc_solution(), SteadyHelicalProblem< ELEMENT >::doc_solution(), SteadyTubeProblem< ELEMENT >::doc_solution(), SolidFreeSurfaceRotationProblem< ELEMENT >::doc_solution(), DiskShockWaveProblem< ELEMENT, TIMESTEPPER >::doc_solution(), AnnularDiskProblem< ELASTICITY_ELEMENT >::doc_solution(), RingWithTRibProblem< ELASTICITY_ELEMENT >::doc_solution(), UnsteadyHeatProblem< ELEMENT >::doc_solution(), FlowAroundCylinderProblem< ELEMENT >::doc_solution(), CompressedSquareProblem< ELEMENT >::doc_solution(), UnstructuredImmersedEllipseProblem< ELEMENT >::doc_solution(), UnstructuredPoissonProblem< ELEMENT >::doc_solution(), RefineableUnsteadyHeatProblem< ELEMENT >::doc_solution(), RefineableDrivenCavityProblem< ELEMENT >::doc_solution(), oomph::MyProblem::doc_solution(), ElasticAnnulusProblem< ELASTICITY_ELEMENT >::doc_solution(), SurfactantProblem< ELEMENT, INTERFACE_ELEMENT >::doc_solution(), FSICollapsibleChannelProblem< ELEMENT >::doc_solution_steady(), FSICollapsibleChannelProblem< ELEMENT >::doc_solution_unsteady(), oomph::MyProblem::dump(), RefineableUnsteadyHeatProblem< ELEMENT >::dump_it(), ElasticAnnulusProblem< ELASTICITY_ELEMENT >::ElasticAnnulusProblem(), oomph::MyProblem::final_doc(), GeomObjectAsGeneralisedElementProblem::GeomObjectAsGeneralisedElementProblem(), oomph::MyProblem::initial_doc(), main(), MeltContactProblem< ELEMENT >::MeltContactProblem(), oomph::MyProblem::MyProblem(), PrescribedBoundaryDisplacementProblem< ELEMENT >::PrescribedBoundaryDisplacementProblem(), oomph::MyProblem::read(), RefineableAdvectionDiffusionPipeProblem< ELEMENT >::RefineableAdvectionDiffusionPipeProblem(), RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::RefineableConvectionProblem(), RefineableDDConvectionProblem< NST_ELEMENT, AD_ELEMENT >::RefineableDDConvectionProblem(), RefineableUnsteadyHeatProblem< ELEMENT >::restart(), RingWithTRibProblem< ELASTICITY_ELEMENT >::RingWithTRibProblem(), DiskShockWaveProblem< ELEMENT, TIMESTEPPER >::run(), CompressedSquareProblem< ELEMENT >::run_it(), CantileverProblem< ELEMENT >::run_it(), CantileverProblem< ELEMENT >::run_tests(), StefanBoltzmannProblem< ELEMENT >::setup_sb_radiation(), SolarRadiationProblem< ELEMENT >::SolarRadiationProblem(), FSICollapsibleChannelProblem< ELEMENT >::steady_run(), ThermalProblem< ELEMENT >::ThermalProblem(), FSICollapsibleChannelProblem< ELEMENT >::unsteady_run(), FlowAroundCylinderProblem< ELEMENT >::unsteady_simulation(), UnsteadyHeatMeltProblem< ELEMENT >::UnsteadyHeatMeltProblem(), UnstructuredImmersedEllipseProblem< ELEMENT >::UnstructuredImmersedEllipseProblem(), oomph::MyProblem::write_trace(), and RefineableUnsteadyHeatProblem< ELEMENT >::write_trace_file_header().

◆ Document_solution

bool GlobalParameters::Document_solution =true

Helper variable to indicate whether or not to document the solution.

◆ DtN_BC

bool GlobalParameters::DtN_BC =false

Flag to choose the Dirichlet to Neumann BC or ABC BC

Referenced by HelmholtzPointSourceProblem< ELEMENT >::actions_before_newton_convergence_check(), ScatteringProblem< ELEMENT >::actions_before_newton_convergence_check(), HelmholtzPointSourceProblem< ELEMENT >::create_outer_bc_elements(), ScatteringProblem< ELEMENT >::create_outer_bc_elements(), main(), HelmholtzPointSourceProblem< ELEMENT >::setup_outer_boundary(), and ScatteringProblem< ELEMENT >::setup_outer_boundary().

◆ Element_order

unsigned GlobalParameters::Element_order =1

The order of the FE interpolation.

◆ Element_width

double GlobalParameters::Element_width =Lx/double(Nx)

The element width.

Referenced by is_in_pinned_region().

◆ Enable_test_pml_mapping_flag

unsigned GlobalParameters::Enable_test_pml_mapping_flag =0

The choice of whether or not to enable the new test mapping 1 = Enable test mapping 0 = Disable test mapping

Referenced by PMLHelmholtzMGProblem< ELEMENT >::actions_after_adapt(), PMLStructuredCubicHelmholtz< ELEMENT >::enable_pmls(), main(), PMLHelmholtzMGProblem< ELEMENT >::PMLHelmholtzMGProblem(), and PMLStructuredCubicHelmholtz< ELEMENT >::PMLStructuredCubicHelmholtz().

◆ Eps

double GlobalParameters::Eps =1.0e-12

The tolerance for a point relative to the bounding inner square.

Referenced by is_in_pinned_region().

◆ Eta

double GlobalParameters::Eta = 2.39e6

FvK parameter.

Referenced by UnstructuredFvKProblem< ELEMENT >::complete_problem_setup().

◆ Gamma

double GlobalParameters::Gamma = MathematicalConstants::Pi/4.0

Parameter for timescale of step translation.

Contact angle and its cos (dependent parameter – is reassigned)

Referenced by get_exact_u(), main(), prescribed_flux_on_fixed_y_boundary(), RefineableUnsteadyHeatProblem< ELEMENT >::RefineableUnsteadyHeatProblem(), setup_dependent_parameters_and_sanity_check(), and step_position().

◆ Height

double GlobalParameters::Height =20.0

Height of domain.

Height of computational domain.

Referenced by MeltSpinningProblem< ELEMENT >::actions_before_newton_solve(), AxisymFreeSurfaceNozzleAdvDiffRobinProblem< ELEMENT >::actions_before_newton_solve(), CombCanSpineMesh< ELEMENT, INTERFACE_ELEMENT >::build_single_layer_mesh(), CombTipSpineMesh< ELEMENT, INTERFACE_ELEMENT >::build_single_layer_mesh(), STSpineMesh< ELEMENT, INTERFACE_ELEMENT >::build_single_layer_mesh(), AngleOfRepose::create_inflow_particle(), NavierStokesProblem< ELEMENT >::create_spacetime_mesh(), CylinderAndInterfaceDomain::CylinderAndInterfaceDomain(), MeltSpinningProblem< ELEMENT >::deform_free_surface(), AxisymFreeSurfaceNozzleAdvDiffRobinProblem< ELEMENT >::deform_free_surface(), InterfaceProblem< ELEMENT, TIMESTEPPER >::deform_free_surface(), FlowAroundCylinderProblem< ELEMENT >::FlowAroundCylinderProblem(), RectangleWithHoleMesh< ELEMENT >::height(), main(), oomph::AlgebraicCylinderWithFlagMesh< ELEMENT >::node_update_I(), oomph::AlgebraicCylinderWithFlagMesh< ELEMENT >::node_update_II(), oomph::AlgebraicCylinderWithFlagMesh< ELEMENT >::node_update_III(), oomph::AlgebraicCylinderWithFlagMesh< ELEMENT >::node_update_IV(), oomph::AlgebraicCylinderWithFlagMesh< ELEMENT >::node_update_IX(), oomph::AlgebraicCylinderWithFlagMesh< ELEMENT >::node_update_V(), oomph::AlgebraicCylinderWithFlagMesh< ELEMENT >::node_update_VI(), oomph::AlgebraicCylinderWithFlagMesh< ELEMENT >::node_update_VII(), oomph::AlgebraicCylinderWithFlagMesh< ELEMENT >::node_update_VIII(), RectangleWithHoleMesh< ELEMENT >::RectangleWithHoleMesh(), sin_cos_velocity_field(), sin_cos_vorticity(), and VorticityRecoveryProblem< ELEMENT >::VorticityRecoveryProblem().

◆ K_squared

double GlobalParameters::K_squared =10.0

Square of the wavenumber.

Square of the wavenumber (also known as k^2)

Problem specific parameters:

Square of the wavenumber (also known as k^2)

Referenced by HelmholtzPointSourceProblem< ELEMENT >::actions_after_adapt(), PMLStructuredCubicHelmholtz< ELEMENT >::actions_after_adapt(), PMLHelmholtzMGProblem< ELEMENT >::actions_after_adapt(), HelmholtzPointSourceProblem< ELEMENT >::HelmholtzPointSourceProblem(), main(), PMLHelmholtzMGProblem< ELEMENT >::PMLHelmholtzMGProblem(), PMLProblem< ELEMENT >::PMLProblem(), PMLStructuredCubicHelmholtz< ELEMENT >::PMLStructuredCubicHelmholtz(), and ScatteringProblem< ELEMENT >::ScatteringProblem().

◆ Kappa_increment

double GlobalParameters::Kappa_increment = -0.05

Increment for prescribed curvature.

Referenced by RefineableYoungLaplaceProblem< ELEMENT >::increment_parameters().

◆ Kappa_initial

double GlobalParameters::Kappa_initial = 0.0

Initial value for kappa.

Referenced by setup_dependent_parameters_and_sanity_check().

◆ Kappa_pt

Data* GlobalParameters::Kappa_pt = 0

Pointer to Data object that stores the prescribed curvature.

Referenced by YoungLaplaceProblem< ELEMENT >::actions_before_newton_solve(), YoungLaplaceProblem< ELEMENT >::doc_solution(), RefineableYoungLaplaceProblem< ELEMENT >::doc_solution(), RefineableYoungLaplaceProblem< ELEMENT >::increment_parameters(), RefineableYoungLaplaceProblem< ELEMENT >::RefineableYoungLaplaceProblem(), and YoungLaplaceProblem< ELEMENT >::YoungLaplaceProblem().

◆ Kinematic_viscosity

double GlobalParameters::Kinematic_viscosity =1.0

The value of the kinematic viscosity (assumed to be the same everywhere)

Referenced by VorticityRecoveryProblem< ELEMENT >::complete_problem_setup(), sin_cos_velocity_field(), and sin_cos_vorticity().

◆ L_t

double GlobalParameters::L_t =1.0

The length of the mesh in the time direction.

Length of the mesh in the t-direction.

Referenced by UnsteadyHeatProblem< ELEMENT >::assign_time_slab_id(), NavierStokesProblem< ELEMENT >::assign_time_slice_id(), NavierStokesProblem< ELEMENT >::create_spacetime_mesh(), and UnsteadyHeatProblem< ELEMENT >::create_spacetime_mesh().

◆ L_x

double GlobalParameters::L_x =1.0

------------------—Unsteady Heat Parameters---------------------—

Length of domain.

Length and width of the domain.

-----------------------—Mesh Properties-------------------------— Length of the mesh in the x-direction

Referenced by UnsteadyHeatProblem< ELEMENT >::create_spacetime_mesh(), main(), RefineableYoungLaplaceProblem< ELEMENT >::RefineableYoungLaplaceProblem(), setup_dependent_parameters_and_sanity_check(), and spine_function().

◆ L_y

double GlobalParameters::L_y =1.0

Length of the mesh in the y-direction.

Width of domain.

Referenced by UnsteadyHeatProblem< ELEMENT >::create_spacetime_mesh(), main(), RefineableYoungLaplaceProblem< ELEMENT >::RefineableYoungLaplaceProblem(), setup_dependent_parameters_and_sanity_check(), and spine_function().

◆ L_z

double GlobalParameters::L_z =3.0

Length of the mesh in the z-direction.

Referenced by MovingBlockProblem< ELEMENT >::create_extruded_mesh().

◆ Lambda_sq

double GlobalParameters::Lambda_sq =0.0

Non-dim density for pseudo-solid.

◆ Length

double GlobalParameters::Length =2.0*MathematicalConstants::Pi

Length of computational domain.

Referenced by sin_cos_velocity_field(), sin_cos_vorticity(), and VorticityRecoveryProblem< ELEMENT >::VorticityRecoveryProblem().

◆ Length_of_box

double GlobalParameters::Length_of_box =10.0

----------------------—Cylinder Properties----------------------—

----------------------—Domain Properties------------------------— Length of square central box domain

Referenced by ExtrudedMovingCylinderProblem< TWO_D_ELEMENT, THREE_D_ELEMENT >::create_extruded_mesh(), and update_parameters().

◆ Length_of_central_box

double GlobalParameters::Length_of_central_box =10.0

Side-length of the square box in the mesh surrounding the cylinder.

Length of square central box domain.

Referenced by NavierStokesProblem< ELEMENT >::create_spacetime_mesh(), doc_maximum_central_box_deformation(), find_node_on_centerline(), FlowAroundCylinderProblem< ELEMENT >::FlowAroundCylinderProblem(), and update_mesh_parameters().

◆ Length_z

double GlobalParameters::Length_z =1.0

The length of the extruded mesh in the z-direction.

Referenced by ExtrudedMovingCylinderProblem< TWO_D_ELEMENT, THREE_D_ELEMENT >::create_extruded_mesh().

◆ Linear_solver_flag

unsigned GlobalParameters::Linear_solver_flag =1

The choice of linear solver 0 = SuperLU 1 = Multigrid

Referenced by main(), PMLHelmholtzMGProblem< ELEMENT >::PMLHelmholtzMGProblem(), PMLStructuredCubicHelmholtz< ELEMENT >::PMLStructuredCubicHelmholtz(), PMLHelmholtzMGProblem< ELEMENT >::~PMLHelmholtzMGProblem(), and PMLStructuredCubicHelmholtz< ELEMENT >::~PMLStructuredCubicHelmholtz().

◆ Lx

double GlobalParameters::Lx =1.0

Problem specific parameters:

Length of the cube in each direction

Mesh specific parameters:

Length of the square in each direction

Referenced by PMLStructuredCubicHelmholtz< ELEMENT >::doc_solution(), PMLStructuredCubicHelmholtz< ELEMENT >::enable_pmls(), PMLHelmholtzMGProblem< ELEMENT >::PMLHelmholtzMGProblem(), and PMLStructuredCubicHelmholtz< ELEMENT >::PMLStructuredCubicHelmholtz().

◆ Ly

double GlobalParameters::Ly =1.0

Referenced by PMLStructuredCubicHelmholtz< ELEMENT >::enable_pmls(), PMLHelmholtzMGProblem< ELEMENT >::PMLHelmholtzMGProblem(), and PMLStructuredCubicHelmholtz< ELEMENT >::PMLStructuredCubicHelmholtz().

◆ Lz

double GlobalParameters::Lz =1.0

Referenced by PMLStructuredCubicHelmholtz< ELEMENT >::enable_pmls(), and PMLStructuredCubicHelmholtz< ELEMENT >::PMLStructuredCubicHelmholtz().

◆ Melt_temperature

double GlobalParameters::Melt_temperature =0.8288627710

Melt-temperature.

Referenced by StefanBoltzmannProblem< ELEMENT >::create_melt_elements().

◆ Min_refinement_level

unsigned GlobalParameters::Min_refinement_level =1

The minimum level of uniform refinement.

Referenced by main().

◆ N_adaptations

unsigned GlobalParameters::N_adaptations =1

The number of adaptations allowed by the Newton solver.

Referenced by main().

◆ N_amplitude_step

unsigned GlobalParameters::N_amplitude_step =5

The number of steps used to reach the target amplitude.

Referenced by main().

◆ N_boundary_segment

unsigned GlobalParameters::N_boundary_segment =6

The number of segments used to define the circular boundary.

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

◆ N_dof_type

unsigned GlobalParameters::N_dof_type =0

Storage for the number of dof types in the mesh. Will be assigned in the function assign_time_slice_id()

Referenced by UnsteadyHeatProblem< ELEMENT >::assign_time_slab_id(), NavierStokesProblem< ELEMENT >::assign_time_slice_id(), and set_up_dof_to_block_mapping().

◆ N_element_z

unsigned GlobalParameters::N_element_z =10

Number of elements in the z-direction (in the extruded mesh)

Referenced by ExtrudedMovingCylinderProblem< TWO_D_ELEMENT, THREE_D_ELEMENT >::create_extruded_mesh().

◆ N_fourier

unsigned GlobalParameters::N_fourier =10

Number of terms used in the computation of the exact solution

Referenced by get_exact_u(), prescribed_incoming_flux(), and ScatteringProblem< ELEMENT >::ScatteringProblem().

◆ N_period_ratio_step

unsigned GlobalParameters::N_period_ratio_step =1

The number of steps used to reach the target Period_ratio value.

◆ N_period_unsteady

unsigned GlobalParameters::N_period_unsteady =1

------------------------------------—NAVIER-STOKES PARAMETERS---—

---------------------------------—TIME-INTEGRATION PARAMETERS---— Number of periods for unsteady run

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

◆ N_plot_point

unsigned GlobalParameters::N_plot_point =2

-------------------------------------------—DOMAIN PROPERTIES---—

Number of plot points (in each direction)

---------------------------------------—DOCUMENTATION HELPERS---— The number of plot points in each direction

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

◆ N_pml_element

unsigned GlobalParameters::N_pml_element =1

The number of elements in the PML layer.

Referenced by PMLHelmholtzMGProblem< ELEMENT >::actions_after_adapt(), PMLHelmholtzMGProblem< ELEMENT >::actions_before_adapt(), PMLHelmholtzMGProblem< ELEMENT >::apply_boundary_conditions(), PMLHelmholtzMGProblem< ELEMENT >::create_pml_meshes(), PMLHelmholtzMGProblem< ELEMENT >::doc_solution(), main(), and PMLHelmholtzMGProblem< ELEMENT >::PMLHelmholtzMGProblem().

◆ N_re_step

unsigned GlobalParameters::N_re_step =2

The number of steps used to reach the target Reynolds number. In general the target Reynolds number will be reached using natural parameter continuation as pseudo-arc-length continuation doesn't seem to be a reliable method for it (or at least that's what was observed in coarse-grid simulations).

Referenced by main().

◆ N_step_per_period_unsteady

unsigned GlobalParameters::N_step_per_period_unsteady =100

Number of timesteps per period for unsteady run.

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

◆ N_t

unsigned GlobalParameters::N_t =25

The number of elements in the time direction.

Number of elements in the t-direction.

Referenced by NavierStokesProblem< ELEMENT >::assign_time_slice_id(), NavierStokesProblem< ELEMENT >::create_spacetime_mesh(), UnsteadyHeatProblem< ELEMENT >::create_spacetime_mesh(), and update_mesh_parameters().

◆ N_uniform_refinement_before_solve

unsigned GlobalParameters::N_uniform_refinement_before_solve =2

Number of uniform refinements before any solve.

Number of uniform refinements before the mesh extrusion.

Referenced by ExtrudedMovingCylinderProblem< TWO_D_ELEMENT, THREE_D_ELEMENT >::create_extruded_mesh(), NavierStokesProblem< ELEMENT >::create_spacetime_mesh(), and main().

◆ N_x

unsigned GlobalParameters::N_x =10

Number of elements in the x-direction.

Number of elements in the mesh.

Referenced by UnsteadyHeatProblem< ELEMENT >::create_spacetime_mesh(), and setup_dependent_parameters_and_sanity_check().

◆ N_y

unsigned GlobalParameters::N_y =10

Number of elements in the y-direction.

Referenced by UnsteadyHeatProblem< ELEMENT >::create_spacetime_mesh(), and setup_dependent_parameters_and_sanity_check().

◆ N_z

unsigned GlobalParameters::N_z =5

Number of elements in the z-direction.

Referenced by MovingBlockProblem< ELEMENT >::create_extruded_mesh().

◆ Nintpt

unsigned GlobalParameters::Nintpt =10

Number of integration points for new integration scheme (if used)

Referenced by oomph::AxisymmetricNavierStokesEquations::compute_error(), oomph::GeneralisedNewtonianAxisymmetricNavierStokesEquations::compute_error(), StefanBoltzmannProblem< ELEMENT >::create_melt_elements(), StefanBoltzmannProblem< ELEMENT >::create_sb_elements(), oomph::AxisymmetricNavierStokesEquations::dissipation(), oomph::GeneralisedNewtonianAxisymmetricNavierStokesEquations::dissipation(), oomph::AxisymmetricNavierStokesEquations::fill_in_contribution_to_hessian_vector_products(), oomph::GeneralisedNewtonianAxisymmetricNavierStokesEquations::fill_in_contribution_to_hessian_vector_products(), oomph::AxisymmetricNavierStokesEquations::fill_in_generic_dresidual_contribution_axi_nst(), oomph::GeneralisedNewtonianAxisymmetricNavierStokesEquations::fill_in_generic_dresidual_contribution_axi_nst(), oomph::AxisymmetricNavierStokesEquations::fill_in_generic_residual_contribution_axi_nst(), oomph::RefineableAxisymmetricNavierStokesEquations::fill_in_generic_residual_contribution_axi_nst(), oomph::GeneralisedNewtonianAxisymmetricNavierStokesEquations::fill_in_generic_residual_contribution_axi_nst(), oomph::RefineableGeneralisedNewtonianAxisymmetricNavierStokesEquations::fill_in_generic_residual_contribution_axi_nst(), oomph::Z2ErrorEstimator::get_recovered_flux_in_patch(), oomph::AxisymmetricNavierStokesEquations::kin_energy(), oomph::GeneralisedNewtonianAxisymmetricNavierStokesEquations::kin_energy(), main(), oomph::GeneralisedNewtonianAxisymmetricNavierStokesEquations::max_and_min_invariant_and_viscosity(), oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::max_and_min_invariant_and_viscosity(), oomph::AxisymmetricNavierStokesEquations::pressure_integral(), oomph::GeneralisedNewtonianAxisymmetricNavierStokesEquations::pressure_integral(), and StefanBoltzmannProblem< ELEMENT >::StefanBoltzmannProblem().

◆ Nnode_1d

unsigned GlobalParameters::Nnode_1d =2

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

Solver specific parameters:

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

Referenced by oomph::PRefineableQElement< 2, INITIAL_NNODE_1D >::get_node_at_local_coordinate(), oomph::PRefineableQElement< 3, INITIAL_NNODE_1D >::get_node_at_local_coordinate(), oomph::PRefineableQElement< 2, INITIAL_NNODE_1D >::local_coordinate_of_node(), oomph::PRefineableQElement< 3, INITIAL_NNODE_1D >::local_coordinate_of_node(), and main().

◆ Nsteps

unsigned GlobalParameters::Nsteps = 5

Number of steps.

Referenced by main(), and run_it().

◆ Nu

double GlobalParameters::Nu =0.3

Poisson's ratio for pseudo-solid.

Referenced by main().

◆ Nx

unsigned GlobalParameters::Nx =7

Number of elements in each direction (used by SimpleCubicMesh)

Referenced by NautaMixer::addParticlesAtWall(), CylinderMesh< ELEMENT >::assign_centreline_nodes(), ShellMesh< ELEMENT >::assign_undeformed_positions(), FlatPlateMesh< ELEMENT >::assign_undeformed_positions(), BratuProblem< ELEMENT >::BratuProblem(), oomph::ChannelSpineMesh< ELEMENT >::build_channel_spine_mesh(), oomph::HorizontalSingleLayerSpineMesh< ELEMENT >::build_horizontal_single_layer_mesh(), oomph::CircularCylindricalShellMesh< ELEMENT >::build_mesh(), oomph::RectangularQuadMesh< 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(), oomph::SingleLayerSpineMesh< ELEMENT >::build_single_layer_mesh(), oomph::TwoLayerPerturbedSpineMesh< ELEMENT >::build_two_layer_mesh(), oomph::TwoLayerSpineMesh< BASE_ELEMENT >::build_two_layer_mesh(), CapProblem< ELEMENT >::CapProblem(), ChannelSpineFlowProblem< ELEMENT >::ChannelSpineFlowProblem(), oomph::TwoLayerPerturbedSpineMesh< ELEMENT >::element_reorder(), oomph::ChannelSpineMesh< ELEMENT >::element_reorder(), oomph::RectangularQuadMesh< ELEMENT >::element_reorder(), ExactSolution::flux_into_bulk(), FSIDrivenCavityProblem< ELEMENT >::FSIDrivenCavityProblem(), oomph::BrethertonSpineMesh< ELEMENT, INTERFACE_ELEMENT >::initial_element_reorder(), LinearWaveProblem< ELEMENT, TIMESTEPPER >::LinearWaveProblem(), Mesh1D< ELEMENT >::Mesh1D(), PMLStructuredCubicHelmholtz< ELEMENT >::PMLStructuredCubicHelmholtz(), PolarNSProblem< ELEMENT >::PolarNSProblem(), PseudoSolidCapProblem< ELEMENT >::PseudoSolidCapProblem(), CoilSelfTest::setupInitialConditions(), oomph::SimpleRectangularQuadMesh< ELEMENT >::SimpleRectangularQuadMesh(), SimpleRefineableRectangularQuadMesh< ELEMENT >::SimpleRefineableRectangularQuadMesh(), TwoDDGMesh< ELEMENT >::TwoDDGMesh(), TwoDDGProblem< ELEMENT >::TwoDDGProblem(), oomph::TwoLayerPerturbedSpineMesh< ELEMENT >::x_spacing_function(), and oomph::TwoLayerSpineMesh< ELEMENT >::x_spacing_function().

◆ Ny

unsigned GlobalParameters::Ny =7

Referenced by Vreman::add_particles(), NautaMixer::addParticlesAtWall(), ShellMesh< ELEMENT >::assign_undeformed_positions(), FlatPlateMesh< ELEMENT >::assign_undeformed_positions(), oomph::CircularCylindricalShellMesh< ELEMENT >::assign_undeformed_positions(), oomph::ChannelSpineMesh< ELEMENT >::build_channel_spine_mesh(), oomph::HorizontalSingleLayerSpineMesh< ELEMENT >::build_horizontal_single_layer_mesh(), oomph::CircularCylindricalShellMesh< ELEMENT >::build_mesh(), oomph::RectangularQuadMesh< 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(), oomph::SingleLayerSpineMesh< ELEMENT >::build_single_layer_mesh(), ChannelSpineFlowProblem< ELEMENT >::ChannelSpineFlowProblem(), CollapsibleChannelProblem< ELEMENT >::CollapsibleChannelProblem(), doc_sparse_node_update(), oomph::ChannelSpineMesh< ELEMENT >::element_reorder(), oomph::RectangularQuadMesh< ELEMENT >::element_reorder(), ExactSolution::flux_into_bulk(), FSICollapsibleChannelProblem< ELEMENT >::FSICollapsibleChannelProblem(), FSIDrivenCavityProblem< ELEMENT >::FSIDrivenCavityProblem(), oomph::BrethertonSpineMesh< ELEMENT, INTERFACE_ELEMENT >::initial_element_reorder(), LinearWaveProblem< ELEMENT, TIMESTEPPER >::LinearWaveProblem(), PMLStructuredCubicHelmholtz< ELEMENT >::PMLStructuredCubicHelmholtz(), PolarNSProblem< ELEMENT >::PolarNSProblem(), CoilSelfTest::setupInitialConditions(), oomph::SimpleRectangularQuadMesh< ELEMENT >::SimpleRectangularQuadMesh(), SpikedChannelSpineFlowProblem< ELEMENT >::SpikedChannelSpineFlowProblem(), TwoDDGMesh< ELEMENT >::TwoDDGMesh(), and TwoDDGProblem< ELEMENT >::TwoDDGProblem().

◆ Nz

unsigned GlobalParameters::Nz =7

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

◆ Outer_radius

double GlobalParameters::Outer_radius =1.5

Radius of outer boundary (must be a circle!)

Referenced by HelmholtzPointSourceProblem< ELEMENT >::HelmholtzPointSourceProblem(), ScatteringProblem< ELEMENT >::ScatteringProblem(), oomph::FourierDecomposedHelmholtzDtNMesh< ELEMENT >::setup_gamma(), oomph::HelmholtzDtNMesh< ELEMENT >::setup_gamma(), HelmholtzPointSourceProblem< ELEMENT >::setup_outer_boundary(), and ScatteringProblem< ELEMENT >::setup_outer_boundary().

◆ Output_management_flag

unsigned GlobalParameters::Output_management_flag =0

The MG solver allows for five different levels of output: 0 = Outputs everything 1 = Outputs everything except the smoother timings 2 = Outputs setup information but no V-cycle timings 3 = Suppresses all output

Referenced by PMLStructuredCubicHelmholtz< ELEMENT >::apply_boundary_conditions(), main(), PMLStructuredCubicHelmholtz< ELEMENT >::set_gmres_multigrid_solver(), and PMLHelmholtzMGProblem< ELEMENT >::set_gmres_multigrid_solver().

◆ Partitioning_file

std::string GlobalParameters::Partitioning_file =""

Name of file specifying the partitioning of the problem.

Referenced by main().

◆ Period_ratio

double GlobalParameters::Period_ratio =1.0

The ratio T_e/T_s.

The ratio between the cylinder excitation period, T_e, and the stationary cylinder vortex-shedding period, T_s. Explicitly, we have, Period_ratio=T_e/T_s. If the value of this parameter ever changes then the function update_physical_parameter(), (defined in this namespace) MUST be called immediately after.

NOTE: We use the ratio T_e/T_s (instead of T_s/T_e; used by Leontini et al. 2006) to match the x-axis in the experimental phase diagram of Williamson & Roshko (1988) (with the y-axis given by the non-dimensionalised amplitude parameter).

Referenced by NavierStokesProblem< ELEMENT >::actions_after_parameter_increase(), main(), parameter_to_string(), update_physical_parameters(), and update_simulation_parameters().

◆ Period_ratio_target

double GlobalParameters::Period_ratio_target =1.0

The target Period_ratio value; used if we're going to do a parameter sweep through the amplitude-wavelength plane. This will normally be the last parameter for which parameter continuation is used (again, if the value of Period_ratio is different to Period_ratio_target).

◆ Pi

double GlobalParameters::Pi =MathematicalConstants::Pi

Store the value of Pi.

◆ Pml_thickness

double GlobalParameters::Pml_thickness =Element_width

Length of cube in each direction.

The thickness of the PML layer defaults to 0.2, so 10% of the size of the physical domain

Referenced by PMLHelmholtzMGProblem< ELEMENT >::create_pml_meshes(), PMLStructuredCubicHelmholtz< ELEMENT >::doc_solution(), PMLStructuredCubicHelmholtz< ELEMENT >::enable_pmls(), and main().

◆ Post_smoother_flag

unsigned GlobalParameters::Post_smoother_flag =0

The choice of post-smoother: 0 = Automatic (GMRES as a smoother on levels where kh>0.5) 1 = Damped Jacobi on all levels with a constant omega value

Referenced by main(), PMLStructuredCubicHelmholtz< ELEMENT >::set_gmres_multigrid_solver(), and PMLHelmholtzMGProblem< ELEMENT >::set_gmres_multigrid_solver().

◆ Pre_smoother_flag

unsigned GlobalParameters::Pre_smoother_flag =0

The choice of pre-smoother: 0 = Automatic (GMRES as a smoother on levels where kh>0.5) 1 = Damped Jacobi on all levels with a constant omega value

Referenced by main(), PMLStructuredCubicHelmholtz< ELEMENT >::set_gmres_multigrid_solver(), and PMLHelmholtzMGProblem< ELEMENT >::set_gmres_multigrid_solver().

◆ Preconditioner

unsigned GlobalParameters::Preconditioner =0

----------------------—Domain Properties------------------------—

-----------------------—Mesh Properties-------------------------—

-------------------------—Solver Info---------------------------— Variable to choose which preconditioner to use. The actual preconditioner we choose to use is defined by the enumeration class implemented in the problem

Referenced by NavierStokesProblem< ELEMENT >::NavierStokesProblem(), NavierStokesProblem< ELEMENT >::set_up_spacetime_solver(), and UnsteadyHeatProblem< ELEMENT >::set_up_spacetime_solver().

◆ Pressure

double GlobalParameters::Pressure =0.0

The pressure.

Referenced by UnstructuredFvKProblem< ELEMENT >::doc_solution(), get_pressure(), and main().

◆ R_b

double GlobalParameters::R_b = 0.1

The "bubble" radius.

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

◆ R_hat

double GlobalParameters::R_hat =0.1

Temporal variation in inner radius (for exact solution)

Referenced by incoming_sb_inside(), incoming_sb_outside(), melt_flux(), and radius().

◆ Radius

double GlobalParameters::Radius =0.5

Radius of the cylinder.

------------------—Navier-Stokes Parameters---------------------—

----------------------—Domain Properties------------------------— Radius of the cylinder

Referenced by ExtrudedMovingCylinderProblem< TWO_D_ELEMENT, THREE_D_ELEMENT >::create_extruded_mesh(), NavierStokesProblem< ELEMENT >::create_spacetime_mesh(), FlowAroundCylinderProblem< ELEMENT >::FlowAroundCylinderProblem(), and update_parameters().

◆ Radius_inner

double GlobalParameters::Radius_inner =1.0

Inner radius of annular region.

Referenced by get_exact_u(), get_source(), incoming_sb_outside(), and StefanBoltzmannProblem< ELEMENT >::StefanBoltzmannProblem().

◆ Radius_innermost

double GlobalParameters::Radius_innermost =0.5

Radius of inner circle.

Initial radius of inner circle.

Referenced by get_exact_u(), get_source(), incoming_sb_inside(), incoming_sb_outside(), radius(), and StefanBoltzmannProblem< ELEMENT >::StefanBoltzmannProblem().

◆ Radius_outer

double GlobalParameters::Radius_outer =1.5

Outer radius of annular region.

Referenced by get_exact_u(), and StefanBoltzmannProblem< ELEMENT >::StefanBoltzmannProblem().

◆ Re

double GlobalParameters::Re =100.0

Reynolds number.

-----------------------—Cylinder Motion-------------------------—

---------------------------------------------—CYLINDER MOTION---—

------------------------------------—NAVIER-STOKES PARAMETERS---— The current Reynolds number

------------------—Navier-Stokes Parameters---------------------— Set the (current) Reynolds number. A pointer to this variable is provided to elements to make them fully functional. As this is used to calculate the Womersley number (=Re*St), the function update_physical_parameter(), (defined in this namespace) MUST be called immediately after editing the value of this variable.

Referenced by NavierStokesProblem< ELEMENT >::actions_after_parameter_increase(), MovingBlockProblem< ELEMENT >::complete_element_build(), NavierStokesProblem< ELEMENT >::complete_problem_setup(), VorticityRecoveryProblem< ELEMENT >::complete_problem_setup(), doc_navier_stokes_parameters(), FlowAroundCylinderProblem< ELEMENT >::FlowAroundCylinderProblem(), main(), and FlowAroundCylinderProblem< ELEMENT >::unsteady_simulation().

◆ Re_target

double GlobalParameters::Re_target =20.0

Reynolds number for unsteady run.

The target Reynolds number used in simulations. If this is different to the current Reynolds number then the first part of this simulation will (or at least, should) work to reach the target Reynolds number. Also, the value this number takes dictates the choice of Strouhal number (=St).

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

◆ ReSt

double GlobalParameters::ReSt =Re*St

The Womersley number.

The Womersley number (=Re*St), otherwise denoted as ReSt, is dependent on the value of the Reynolds number and the Strouhal number. If either value is changed then the function update_physical_parameter(), will be called which, in turn, updates the Womersley number value.

Referenced by NavierStokesProblem< ELEMENT >::complete_problem_setup(), doc_navier_stokes_parameters(), FlowAroundCylinderProblem< ELEMENT >::FlowAroundCylinderProblem(), main(), and update_simulation_parameters().

◆ Restart_file

std::string GlobalParameters::Restart_file =""

Name of restart file.

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

◆ Rotate_spines_in_both_directions

bool GlobalParameters::Rotate_spines_in_both_directions = true

Should the spines rotate in the x and y directions (true)?

Referenced by setup_dependent_parameters_and_sanity_check(), and spine_function().

◆ S0

double GlobalParameters::S0 =0.1

Strength of source function in inner region.

Referenced by get_exact_u(), get_source(), oomph::BrethertonSpineMesh< ELEMENT, SpineLineFluidInterfaceElement< ELEMENT > >::initial_element_reorder(), Eigen::internal::ptranspose(), oomph::BrethertonSpineMesh< ELEMENT, INTERFACE_ELEMENT >::reposition_spines(), SegregationPeriodic::setSpeciesProperties(), SegregationPeriodic::setupInitialConditions(), oomph::BrethertonSpineMesh< ELEMENT, INTERFACE_ELEMENT >::spine_node_update_vertical_transition_lower(), and oomph::BrethertonSpineMesh< ELEMENT, INTERFACE_ELEMENT >::spine_node_update_vertical_transition_upper().

◆ S1

double GlobalParameters::S1 =1.0

Strength of source function in outer region.

Referenced by get_exact_u(), get_source(), Eigen::internal::ptranspose(), SegregationPeriodic::setSpeciesProperties(), and SegregationPeriodic::setupInitialConditions().

◆ Sigma

double GlobalParameters::Sigma = 1.0e-2

Non-dim Stefan Boltzmann constant.

Referenced by StefanBoltzmannProblem< ELEMENT >::create_melt_elements(), StefanBoltzmannProblem< ELEMENT >::create_sb_elements(), oomph::PerturbedSpineLinearisedAxisymmetricFluidInterfaceElement< ELEMENT >::fill_in_generic_residual_contribution_interface(), oomph::FluidInterfaceElement::fill_in_generic_residual_contribution_interface(), get_exact_u(), incoming_sb_inside(), incoming_sb_outside(), and StefanBoltzmannProblem< ELEMENT >::StefanBoltzmannProblem().

◆ simple_exact_u_pt

FiniteElement::SteadyExactSolutionFctPt GlobalParameters::simple_exact_u_pt =&get_simple_exact_u

Referenced by PMLHelmholtzMGProblem< ELEMENT >::apply_boundary_conditions(), PMLStructuredCubicHelmholtz< ELEMENT >::doc_solution(), and PMLHelmholtzMGProblem< ELEMENT >::doc_solution().

◆ St

double GlobalParameters::St =1.0

The default Strouhal number (overloaded with input value if given)

The Strouhal number, St, is normally defined as St=L/UT, where L, U and T are the defining length-scale, flow speed and defining time scale. Physically, this parameter represents the ratio of convection time-scale to that of our artificial time- scale. The natural length-scale to use here is the cylinder diameter and U is defined to be the speed of the flow at the inlet. To capture time-periodic solutions (which have the same period as a single cylinder oscillation) we non-dimensionalise time on the cylinder oscillation time-scale, i.e. T_{e}. This allows us to use a mesh with fixed (unit) length in the time- direction; avoiding any re-meshing. Thus, we define St=St_{oomph}=D/UT_{e}. However, this is not the only time-scale of the flow. There is also the time-scale of the vortex-shedding past a stationary cylinder. The Strouhal number associated with this (which is dependent on the choice of Reynolds number) is St(Re)=St_{vort}(Re)=D/UT_{s}, where T_{s} is the period of vortex-shedding. This is also the Strouhal number computed by: calculate_strouhal_number(Re), which is defined further below. It then follows: St_{oomph}=(D/UT_{e}) =(D/UT_{s})*(T_{s}/T_{e}) =St_{vort}/Period_ratio. In general, we always choose St_{vort} to be that associated with the value of Re_target (which will remain the same throughout a simulation). As such, the only time the value of St=St_{oomph}=St_{vort}/Period_ratio, may change is when the value of Period_ratio changes.

NOTE: This value is also used to scale the cylinder velocity since, in dimensional units, nodes on the cylinder boundary satisfy: u_{node}^{*}=dr^{*}_{cyl}/dt^{*}, where the asterisk indicates the quantity is in dimensional units. After non-dimensionalising and rearranging we find u_{node}=(D/UT_{e})*dr_{cyl}/dt =St_{oomph}*dr_{cyl}/dt =(St_{vort}/Period_ratio)*dr_{cyl}/dt.

Referenced by NavierStokesProblem< ELEMENT >::apply_boundary_conditions(), FlowAroundCylinderProblem< ELEMENT >::unsteady_simulation(), and update_simulation_parameters().

◆ Step_sign

int GlobalParameters::Step_sign = 1

Increase or decrease the value of the control parameters?

◆ Stream_pt

std::ostream * GlobalParameters::Stream_pt

Referenced by PMLStructuredCubicHelmholtz< ELEMENT >::apply_boundary_conditions(), main(), oomph::OomphInfo::operator<<(), oomph::OomphLibError::set_stream_pt(), oomph::OomphLibWarning::set_stream_pt(), oomph::BlockDiagonalPreconditioner< MATRIX >::setup(), oomph::BlockTriangularPreconditioner< MATRIX >::setup(), oomph::ExactDGPBlockPreconditioner< MATRIX >::setup(), oomph::BandedBlockTriangularPreconditioner< MATRIX >::setup(), and oomph::OomphInfo::stream_pt().

◆ TanPhi

double GlobalParameters::TanPhi =0.0

Parameter for angle of step.

Parameter for angle Phi of "step".

Referenced by get_exact_u(), main(), prescribed_flux_on_fixed_y_boundary(), and RefineableUnsteadyHeatProblem< ELEMENT >::RefineableUnsteadyHeatProblem().

◆ Target_area

double GlobalParameters::Target_area =0.05

Target element size.

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

◆ Test_pml_mapping_pt

TestPMLMapping * GlobalParameters::Test_pml_mapping_pt =new TestPMLMapping

Set the new PML mapping.

Referenced by PMLHelmholtzMGProblem< ELEMENT >::actions_after_adapt(), PMLStructuredCubicHelmholtz< ELEMENT >::enable_pmls(), PMLHelmholtzMGProblem< ELEMENT >::PMLHelmholtzMGProblem(), and PMLStructuredCubicHelmholtz< ELEMENT >::PMLStructuredCubicHelmholtz().

◆ Theta_0

double GlobalParameters::Theta_0 =1.0

Zero degrees Celsius offset in Stefan Boltzmann law.

Referenced by StefanBoltzmannProblem< ELEMENT >::create_melt_elements(), StefanBoltzmannProblem< ELEMENT >::create_sb_elements(), get_exact_u(), incoming_sb_inside(), incoming_sb_outside(), and StefanBoltzmannProblem< ELEMENT >::StefanBoltzmannProblem().

◆ Trace_file

std::ofstream GlobalParameters::Trace_file

Trace file to doc. asymmetry norm data in.

◆ U0

double GlobalParameters::U0 = 0.8288627710

Temperature on boundary of inner circle.

Referenced by get_exact_u().

◆ Use_adaptation_flag

unsigned GlobalParameters::Use_adaptation_flag =0

The choice of whether or not to use adaptation 0 = Uniform refinement 1 = Adaptive refinement

Referenced by main().

◆ Use_height_control

bool GlobalParameters::Use_height_control = true

Use height control (true) or not (false)?

Referenced by RefineableYoungLaplaceProblem< ELEMENT >::increment_parameters().

◆ Use_spines

bool GlobalParameters::Use_spines = true

Use spines (true) or not (false)

Referenced by main().

◆ V0

double GlobalParameters::V0 =1.0

Coeff for (time-)constant variation of temperature in inner circle.

Referenced by incoming_sb_inside(), and incoming_sb_outside().

◆ V0_hat

double GlobalParameters::V0_hat =0.5

Coeff for time variation inner circle.

Referenced by incoming_sb_inside(), and incoming_sb_outside().

◆ Wavenumber

double GlobalParameters::Wavenumber =sqrt(K_squared)

Wavenumber (also known as k),k=omega/c.

Wavenumber (also known as k), k=omega/c.

Referenced by get_exact_u(), get_exact_u_bessel(), get_simple_exact_u(), oomph::HelmholtzMGPreconditioner< DIM >::setup_mg_structures(), and oomph::HelmholtzMGPreconditioner< DIM >::setup_smoothers().

◆ X_left

double GlobalParameters::X_left =-10.0

X-coordinate of upstream end of domain.

Referenced by NavierStokesProblem< ELEMENT >::create_spacetime_mesh(), FlowAroundCylinderProblem< ELEMENT >::FlowAroundCylinderProblem(), and OscillatingWall::position().

◆ X_right

double GlobalParameters::X_right =40.0

X-coordinate of downstream end of domain.

Referenced by NavierStokesProblem< ELEMENT >::create_spacetime_mesh(), and FlowAroundCylinderProblem< ELEMENT >::FlowAroundCylinderProblem().