scotty.beam_me_up module#

Plan#

Output everything to a file, and then do the analysis on that file.

  1. Check that gradK_xi and such are done correctly, check that K_mag is calculated correctly when K_zeta is nonzero

  2. Check that the calculation of Psi makes sense (and the rotation angle)

  3. Check that K initial’s calculation makes sense

Notes

  • The loading of the input files was taken from integral_5 and modified.

  • I should launch the beam inside the last closed flux surface

  • K**2 = K_R**2 + K_z**2 + (K_zeta/r_R)**2, and K_zeta is constant (mode number). See 14 Sep 2018 notes.

Coordinates#

  • X, Y, Z - Lab Cartesian coordinates

  • R, zeta, Z - Lab cylindrical coordinates

  • x, y, g - Beam coordinates

  • u1, u2, u_parallel - Field-aligned coordinates

Abbreviations#

  • bs - backscattered

  • loc - localisation

  • cum_loc - cumulative_localisation

  • ne - equilibrium electron density

Angles#

  • theta - angle between g and u1, small when mismatch is small

  • theta_m - mismatch angle, angle between u1 and K

Units#

  • SI units

  • Distance in m

  • Angles in rad

  • Temperature in KeV

  • electron cyclotron frequency positive

  • K normalised such that K = 1 in vacuum. (Not implemented yet)

  • Distance not normalised yet, should give it thought

  • Start in vacuum, otherwise Psi_3D_beam_initial_cartersian does not get done properly

scotty.beam_me_up.beam_me_up(poloidal_launch_angle_Torbeam, toroidal_launch_angle_Torbeam, launch_freq_GHz, mode_flag, launch_beam_width, launch_beam_curvature, launch_position, vacuumLaunch_flag=True, relativistic_flag=False, find_B_method='torbeam', density_fit_parameters=None, temperature_fit_parameters=None, shot=None, equil_time=None, vacuum_propagation_flag=False, Psi_BC_flag=None, poloidal_flux_enter=1.0, poloidal_flux_zero_density=1.0, poloidal_flux_zero_temperature=1.0, delta_R=- 0.0001, delta_Z=0.0001, delta_K_R=0.1, delta_K_zeta=0.1, delta_K_Z=0.1, interp_order=5, len_tau=102, rtol=0.001, atol=1e-06, interp_smoothing=0, ne_data_path=PosixPath('.'), magnetic_data_path=PosixPath('.'), Te_data_path=PosixPath('.'), output_path=PosixPath('.'), input_filename_suffix='', output_filename_suffix='', figure_flag=True, detailed_analysis_flag=True, verbose_output_flag=True, quick_run=False, plasmaLaunch_K=array([0., 0., 0.]), plasmaLaunch_Psi_3D_lab_Cartesian=array([[0., 0., 0.], [0., 0., 0.], [0., 0., 0.]]), density_fit_method=None, temperature_fit_method=None, B_T_axis=None, B_p_a=None, R_axis=None, minor_radius_a=None, auto_delta_sign_Z=1, auto_delta_sign_R=1)#

Run the beam tracer

  1. Initialise density fit parameters. One of:

    • spline with data from file

    • Stefanikova

    • O(3) polynomial

    • tanh

    • quadratic

    See profile_fit for more details

  2. If relativistic_flag enabled, initialise temperature fit parameters. Not yet fully implemented. One of:

    • spline with data from file

    • linear

    See ‘profile_fit’ for more details

  3. Initialise magnetic field method. One of:

    • TORBEAM

    • OMFIT

    • analytical

    • EFIT++

    • UDA

    • curvy slab

    • test/test_notime

    See geometry for more details

  4. Initialise beam launch parameters (vacuum/plasma). See launch for more details.

  5. Propagate single ray with IVP solver to find point where beam leaves plasma. See ray_solver for more details

  6. Propagate beam with IVP solver

  7. Dump raw output

  8. Analysis

Parameters

  • poloidal_launch_angle_Torbeam (float) – Poloidal angle of antenna in TORBEAM convention

  • toroidal_launch_angle_Torbeam (float) – Toroidal angle of antenna in TORBEAM convention

  • launch_freq_GHz (float) – Frequency of the launched beam in GHz

  • mode_flag (int) – Either +/-1, used to determine which mode branch to use

  • launch_beam_width (float) – Width of the beam at launch

  • launch_beam_curvature (float) – Curvatuve of the beam at launch

  • launch_position (FloatArray) – Position of the antenna in cylindrical coordinates

  • vacuumLaunch_flag (bool) – If True, launch beam from vacuum, otherwise beam launch position is inside the plasma already

  • vacuum_propagation_flag (bool) – If True, run solver from the launch position, and don’t use analytical vacuum propagation

  • relativistic_flag (bool) – If True, generates a temperature profile from given data or parameters and applies relativistic corrections to electron mass.

  • Psi_BC_flag (String) – If None, do no special treatment at plasma-vacuum boundary If continuous, apply BCs for continuous ne but discontinuous gradient of ne If discontinuous, apply BCs for discontinuous ne Using True or False is now deprecated

  • poloidal_flux_enter (float) – Normalised poloidal flux label of plasma boundary. If vacuum_propagation_flag, then this is where the solver begins. If Psi_BC_flag, then this is where the plasma-vacuum BCs are applied

  • poloidal_flux_zero_density (float) – At and above this normalised poloidal flux label, Scotty sets the electron density to zero

  • poloidal_flux_zero_temperature (float) – At and above this normalised poloidal flux label, Scotty sets the electron temperature to zero. This effectively negates any relativistic mass corrections.

  • plasmaLaunch_Psi_3D_lab_Cartesian (FloatArray) – \(\Psi\) of beam in lab Cartesian coordinates. Required if vacuumLaunch_flag is False

  • plasmaLaunch_K (FloatArray) – Wavevector of beam at launch. Required if vacuumLaunch_flag is False

  • delta_R (float) – Finite difference spacing to use for R

  • delta_Z (float) – Finite difference spacing to use for Z

  • delta_K_R (float) – Finite difference spacing to use for K_R

  • delta_K_zeta (float) – Finite difference spacing to use for K_zeta

  • delta_K_Z (float) – Finite difference spacing to use for K_Z

  • find_B_method (Union[str, scotty.geometry.MagneticField]) –

    See create_magnetic_geometry for more information.

    Common options:

    • "efitpp" uses magnetic field data from efitpp files directly

    • "torbeam" uses magnetic field data from TORBEAM input files

    • "omfit" is similar to "torbeam" but reads the data from JSON files

    • "UDA_saved" reads EFIT data from numpy’s .npz files

    • "analytical" uses a constant current density circular equilibrium

    Or pass a MagneticField instance directly.

  • density_fit_parameters (Optional[Sequence]) –

    A list of parameters to be passed to the density_fit_method constructor. See the docs for the individual methods for the meaning of their parameters

    Note

    These parameters should not include poloidal_flux_zero_density

  • density_fit_method (Optional[Union[str, Callable[[Union[float, numpy.ndarray[Any, numpy.dtype[numpy.float64]]]], Union[float, numpy.ndarray[Any, numpy.dtype[numpy.float64]]]]]]) –

    Parameterisation of the density profile. Either a callable (see ProfileFit), or one of the following options:

    • "smoothing-spline": 1D smoothing spline (SmoothingSplineFit)

    • "smoothing-spline-file": 1D smoothing spline constructed from file (SmoothingSplineFit.from_dat_file)

    • "stefanikova": combination of modified hyperbolic \(\tan\) and a Gaussian (StefanikovaFit)

    • "poly3" or "polynomial": \(n\)-th order polynomial (PolynomialFit)

    • "tanh": hyperbolic \(\tan\) (TanhFit)

    • "quadratic": constrained quadratic (QuadraticFit)

    If density_fit_method is a string, then the corresponding DensityFit object is constructed using poloidal_flux_zero_density and density_fit_parameters.

    "smoothing-spline-file" looks for a file called ne<input_filename_suffix>.dat in ne_data_path. It also uses interp_order and interp_smoothing instead of density_fit_parameters.

    Deprecated since version 2.4.0: If None (the default) is passed, the method will be guessed from the length of density_fit_parameters. In this case, quadratic and tanh parameters _should_ include poloidal_flux_zero_density as the last value.

  • temperature_fit_method (Optional[Union[str, Callable[[Union[float, numpy.ndarray[Any, numpy.dtype[numpy.float64]]]], Union[float, numpy.ndarray[Any, numpy.dtype[numpy.float64]]]]]]) – Parameterisation of the temperature profile. Leverages the same ProfileFit class used for density. See density_fit_method for details.

  • len_tau (int) – Number of output tau points

  • rtol (float) – Relative tolerance for ODE solver

  • atol (float) – Absolute tolerance for ODE solver

  • quick_run (bool) – If true, then run only the ray tracer and get an analytic estimate of the \(K\) cut-off location

  • auto_delta_sign_Z – A sign variable that takes on +1/-1. Ensures that forward differebce is always in negative poloidal flux gradient direction (into the plasma). Current implementation is flawed because the MagneticField has to be constructed in order to determine the intersection point and corresponding sign. Sign flip is thus subsequently applied throughout the code except for the already constructed field.

  • auto_delta_sign_R – Similar to auto_delta_sign_Z but for the R coordinate

  • temperature_fit_parameters (Optional[Sequence]) –

scotty.beam_me_up.create_magnetic_geometry(find_B_method, magnetic_data_path=None, input_filename_suffix='', interp_order=5, interp_smoothing=0, B_T_axis=None, R_axis=None, minor_radius_a=None, B_p_a=None, shot=None, equil_time=None, delta_R=None, delta_Z=None, **kwargs)#

Create an object representing the magnetic field geometry

Parameters
Return type

scotty.geometry.MagneticField

scotty.beam_me_up.make_density_fit(method, poloidal_flux_zero_density, parameters, filename)#

Either construct a ProfileFit instance, or return method if it’s already suitable. Suitable methods are callables that take an array of poloidal fluxes and return an array of densities.

Parameters
Return type

Callable[[Union[float, numpy.ndarray[Any, numpy.dtype[numpy.float64]]]], Union[float, numpy.ndarray[Any, numpy.dtype[numpy.float64]]]]

scotty.beam_me_up.make_temperature_fit(method, poloidal_flux_zero_temperature, parameters, filename)#

Either construct a DensityFit instance, or return method if it’s already suitable. Suitable methods are callables that take an array of poloidal fluxes and return an array of temperatures.

Parameters
Return type

Callable[[Union[float, numpy.ndarray[Any, numpy.dtype[numpy.float64]]]], Union[float, numpy.ndarray[Any, numpy.dtype[numpy.float64]]]]