Input Parameters ====================== The following is a complete list of input parameters available in XGC. This list is generated with the Python script ``utils/python/document_inputs.py``. Please help us improve the documentation for completeness, consistency and clarity. adios_param ----------------------------------------- ``bool`` **adios_stage_3d** = ``false`` Enable/disable Adios stage mode for xgc.3d ``bool`` **adios_stage_escaped_ptls** = ``false`` Whether to use ADIOS staging for the escaped particles diagnostic. If false, a standalone file will be written per step with the naming convention "xgc.escaped\_ptls.%gstep%.bp". ``bool`` **adios_stage_f0** = ``false`` Enable/disable Adios stage mode for xgc.f0 ``bool`` **adios_stage_f0_df** = ``false`` Enable/disable Adios stage mode for xgc.fsourcediag ``bool`` **adios_stage_particle** = ``false`` Enable/disable Adios stage mode for xgc.particle ``bool`` **adios_stage_restart** = ``false`` Enable/disable Adios stage mode for checkpoint file ``bool`` **adios_stage_restartf0** = ``false`` Enable/disable Adios stage mode for f0 checkpoint file analytic_eq_files_param ----------------------------------------- ``double`` **axis_r** = ``axis_r_default`` Radial location of magnetic axis for analytic equilibrium. Should be within the bounds defined below. The default value is near the center of the default radial bounds. ``double`` **axis_z** = ``axis_z_default`` Vertical location of magnetic axis for analytic equilibrium. Should be within the bounds defined below. The default value is near the center of the default vertical bounds. ``std::string`` **i_option** = ``"Constant"`` Option for analytic toroidal-field profile. Should match test-facing names for compatibility with regression helper. Available options: - ``0`` (InverseShiftedPsi) - ``1`` (Constant) ``std::string`` **psi_option** = ``"Circular"`` Option for analytic psi grid. Should match test-facing names for compatibility with regression helper. Available options: - ``0`` (NoXPoints) - ``1`` (OneXPoint) - ``2`` (TwoXPoints) - ``3`` (Circular) ``double`` **safety_factor_coeff** = ``10000.0`` Coefficient used in the analytic toroidal-field profile. The default value creates a nearly constant safety factor profile, which is desirable for testing purposes since it avoids complications related to q=1 surfaces. analytic_grid_param ----------------------------------------- ``double`` **axis_r** = ``1.5`` r coordinate of analytic circular grid axis ``double`` **axis_z** = ``0.0`` z coordinate of analytic circular grid axis ``int`` **nsurfaces** = ``30`` Number of surfaces in the analytic circular grid. col_param ----------------------------------------- ``bool`` **col_accel** = ``false`` Artificial collision amplifying. ``int`` **col_accel_n** = ``2`` Number of psi regions to apply artifical accleration to. Maximum is 2. ``double`` **col_accel_factor1** = ``10.0`` Acceleration factor of Range 1 ``double`` **col_accel_factor2** = ``10.0`` Acceleration factor of Range 2 ``double`` **col_accel_pin1** = ``magnetic_field.inpsi`` Inner psi value of acceleration Range 1 ``double`` **col_accel_pout1** = ``magnetic_field.inpsi + 0.1*psi_range`` Outer psi value of acceleration Range 1 ``double`` **col_accel_pin2** = ``magnetic_field.outpsi - 0.1*psi_range`` Inner psi value of acceleration Range 2 ``double`` **col_accel_pout2** = ``magnetic_field.outpsi`` Outer psi value of acceleration Range 2 ``int`` **col_en_col_on** = ``1`` Switch for energy collision ``bool`` **col_exclude_private** = ``false`` Exclude private flux region(s) from the collision operation. Override exclude\_private\_region if exclude\_private\_region\_in is true ``int`` **col_mode** = ``0`` Collision method. Available options: - ``0`` (None): No collisions - ``1`` (MonteCarlo): uses the monte carlo non-conserving collisions - ``4`` (Nonlinear): uses the non-linear Fokker Planck Landau collision operator - ``5`` (PETSc): uses PETSc Landau AMR collisions ``double`` **col_pin** = ``magnetic_field.inpsi`` Minimum of psi range where collisions are performed. ``double`` **col_pout** = ``magnetic_field.outpsi`` Maximum of psi range where collisions are performed. ``int`` **col_max_n_subcycles** = ``1`` Enables collision subcycling. Collision time step of an unconverged vertex will be reduced, increasing the number of cycles of that vertex up to a maximum of col\_max\_n\_subcycles. If it still does not converge, the vertex will not be attempted again. ``int`` **col_f_start** = ``1`` The time step at which collisions begin ``bool`` **col_moving_frame** = ``true`` Switch for moving frame for collisions ``int`` **col_period** = ``3`` Frequency of collisions ``int`` **col_varying_bg** = ``0`` Switch for background plasma update ``int`` **col_vb_period** = ``1`` Frequency of background update for collisions ``double`` **col_vb_pin** = ``magnetic_field.inpsi`` Inner psi boundary for varying background ``double`` **col_vb_pout** = ``std::min(magnetic_field.outpsi, 1.03`` Outer psi boundary for varying background ``int`` **col_vb_m** = ``50`` Resolution of varying background ``int`` **col_vb_mtheta** = ``8`` Resolution in theta direction of varying background diag_param ----------------------------------------- ``bool`` **diag_1d_on** = ``true`` Whether to write 1D diagnostics ``int`` **diag_1d_period** = ``10`` Number of time steps between diag\_1d diagnostic write ``bool`` **diag_3d_more** = ``false`` Write some additional moments in the diag\_3d diagnostic ``bool`` **diag_3d_on** = ``true`` Whether to write 3D diagnostics ``int`` **diag_3d_period** = ``default_period`` Number of time steps between 3D diagnostic write ``bool`` **diag_col_convergence_stat_on** = ``false`` Switches file-output of convergence status of the collision operator on/off **[Used when col_param:col_mode=4]** ``bool`` **diag_current_drive_on** = ``false`` Switches the loop voltage diagnostic on if dynamic current drive is on ``int`` **diag_current_drive_period** = ``1`` Output frequency of loop\_voltage\_diagnostic ``bool`` **diag_diff_profiles_on** = ``false`` Whether to turn on the diffusion profiles diagnostic. This should be consistent with diff\_update\_on in diff\_param namelist. **[Used when diff_param:diff_update_on=True]** ``int`` **diag_diff_profiles_period** = ``1`` Rate (multiples of sml\_f\_source\_period) at which the profile data is sampled. (Must be compatible with diff\_update\_period!) ``bool`` **diag_f0_df_on** = ``is_on_default`` Switch for f0\_df (grid-conservation) diagnostic ``int`` **diag_f0_df_period** = ``period_default`` Output interval for f0\_df diagnostic ``bool`` **diag_f0_g** = ``false`` Whether to additionally write f0\_g in the f0 diagnostic ``bool`` **diag_f0_n** = ``false`` Whether to additionally write f0\_n in the f0 diagnostic ``bool`` **diag_f0_on** = ``true`` Whether to write f0 diagnostic ``int`` **diag_f0_period** = ``default_period`` Number of time steps between f0 diagnostic write Make sure period is divisible by f\_source\_period ``int`` **diag_f3d_period** = ``default_period`` Number of time steps between f3d diagnostic write ``int`` **diag_heat_mode** = ``2`` Heat diagnostic mode - 1 for old mode (rectangle based), 2 for new mode (wall segment based) ``int`` **diag_heat_nr** = ``100`` Number of radial bins in mode 1 ``int`` **diag_heat_nz** = ``100`` Number of vertical bins in mode 1 ``int`` **diag_heat_nsection** = ``1`` Number of rectangular sections for mode 1 ``int`` **diag_heat_npsi** = ``1000`` Number of psi bins for mode 1 ``double`` **diag_heat_rmin1** = ``magnetic_field.bounds.min_r`` Minimum r for the first section ``double`` **diag_heat_rmin2** = ``magnetic_field.bounds.min_r`` Minimum r for the second section ``double`` **diag_heat_rmin3** = ``magnetic_field.bounds.min_r`` Minimum r for the third section ``double`` **diag_heat_rmax1** = ``magnetic_field.bounds.max_r`` Maximum r for the first section ``double`` **diag_heat_rmax2** = ``magnetic_field.bounds.max_r`` Maximum r for the second section ``double`` **diag_heat_rmax3** = ``magnetic_field.bounds.max_r`` Maximum r for the third section ``double`` **diag_heat_zmin1** = ``magnetic_field.bounds.min_z`` Minimum z for the first section ``double`` **diag_heat_zmin2** = ``magnetic_field.bounds.min_z`` Minimum z for the second section ``double`` **diag_heat_zmin3** = ``magnetic_field.bounds.min_z`` Minimum z for the third section ``double`` **diag_heat_zmax1** = ``magnetic_field.bounds.max_z`` Maximum z for the first section ``double`` **diag_heat_zmax2** = ``magnetic_field.bounds.max_z`` Maximum z for the second section ``double`` **diag_heat_zmax3** = ``magnetic_field.bounds.max_z`` Maximum z for the third section ``int`` **diag_heat_nphi** = ``64`` Number of phi bins for mode 2 ``double`` **diag_heat_spacing** = ``5.0e-3`` target spacing for wall segments ``bool`` **diag_heat_on** = ``false`` Whether to write heat diagnostic. ``int`` **diag_neutral_period** = ``100`` The number of discrete timesteps between writing the neutral output files. Should generally be equal to neu\_background\_period. ``int`` **diag_particle_mod** = ``1`` Writes every Nth particle (based on GID) ``bool`` **diag_particle_on** = ``false`` Whether to write diag particles ``int`` **diag_particle_period** = ``1`` Number of time steps between particle diagnostic write ``double`` **diag_ps_pin** = ``0.80`` Psi range of selected particles ``double`` **diag_ps_pout** = ``0.81`` Psi range of selected particles ``int`` **diag_ps_reset_period** = ``10`` Number of time steps between particle stream diagnostic recording ``bool`` **diag_weight_stats** = ``false`` Write some particle weight statistics in the diag\_3d diagnostic diff_param ----------------------------------------- ``double`` **diff_bd_in** = ``magnetic_field.inpsi`` Inner psi boundary for diffusion ``int`` **diff_bd_option** = ``0`` Boundary damping option: (0) Damp the diffusivities, (1) damp the entire RHS ``double`` **diff_bd_out** = ``magnetic_field.outpsi`` Outer psi boundary for diffusion ``double`` **diff_bd_shift_in** = ``0.05`` Shift relative to sml\_diffusion\_bd\_in where diff. coeff starts to decay ``double`` **diff_bd_shift_out** = ``0.05`` Shift relative to sml\_diffusion\_bd\_out where diff. coeff starts to decay ``double`` **diff_bd_width_in** = ``0.02`` Decay length of diffusion coefficients in rgn 1 and 2 (inner bd) ``double`` **diff_bd_width_out** = ``0.02`` Decay length of diffusion coefficients in rgn 1 and 2 (outer bd) ``double`` **diff_bd_width_priv** = ``0.02`` Decay length of diffusion coefficients in private region ``bool`` **diff_hyp_vis_rad_on** = ``false`` Switch for the radial hyperviscosity used in the diffusion model ``std::string`` **diff_lifting_operator_type** = ``"Polynomial"`` Switch for choosing a lifting operator in the anomalous transport module Available options: - ``Polynomial``: Uses a set of orthonormal polynomials to scale the distribution function to change moments in the desired way. - ``BiMaxwellian``: Uses the difference between two bi-Maxwellians to get a delta-f that changes the fluid moments of the distribution function in the desired way. ``bool`` **diff_negative_f_correction** = ``false`` Whether to apply negative-f correction after diffusion. ``bool`` **diff_nonlinear** = ``false`` Switch for including nonlinear terms ``bool`` **diff_on** = ``false`` Switch for anomalous diffusion ``bool`` **diff_pol_peak** = ``false`` Whether the diffusion coefficient is constant or varies on a flux-surface (with Gaussian) ``double`` **diff_pol_peak_amp** = ``0.2`` Minimum of the poloidal scaling function of the diffusion operator ``double`` **diff_pol_peak_angle** = ``0.0`` Geometric poloidal angle at which the diffusion coefficient is peaked (rad/pi) ``double`` **diff_pol_peak_width** = ``0.5`` Width of the peak of the diffusion coefficients (rad/pi) ``int`` **diff_start_time** = ``1`` Start time (in time steps) for anomalous diffusion ``bool`` **diff_update_on** = ``false`` Switch for periodic updates of the diffusion coefficients ``int`` **diff_update_period** = ``500`` Period in time steps between subsequent updates of the diffusion coefficients ``bool`` **diff_use_smoothing** = ``0`` Whether apply poloidal smoothing to the fluid moments before solving the diffusion equations. eq_param ----------------------------------------- ``int`` **eq_den_rsp_index** = ``0`` Due to quasineutrality, the density of one species should be obtained from that of the others: specify its index here. ``int`` **eq_den_rsp_sample_num** = ``1024`` density for the reduced spcies (rsp) is constructed from this number of samples ``double`` **eq_den_rsp_xmax** = ``1.3`` normalized value of psi for domain setting psi\_norm = [0, xmax], psi = psi\_norm * eq\_x\_psi ``int`` **eq_dens_diff_shape** = ``None, ... [per species] ...`` Analytic shape selector for particle diffusivity profiles. Use -1 for file input. Available options: - ``-1`` (Custom): Read from specified file (eq\_*\_file) - ``0`` (Constant) - ``1`` (TanH) - ``2`` (Linear) - ``5`` (Shape5) ``std::string`` **eq_dens_diff_file** = ``None, ... [per species] ...`` File name for particle diffusivity profile input. ``double`` **eq_dens_diff_v1** = ``None, ... [per species] ...`` Shape-function value parameter for particle diffusivity. ``double`` **eq_dens_diff_v2** = ``None, ... [per species] ...`` Shape-function value parameter for particle diffusivity. ``double`` **eq_dens_diff_v3** = ``None, ... [per species] ...`` Shape-function value parameter for particle diffusivity. ``double`` **eq_dens_diff_v4** = ``None, ... [per species] ...`` Shape-function value parameter for particle diffusivity. ``double`` **eq_dens_diff_x1** = ``None, ... [per species] ...`` Shape-function coordinate parameter for particle diffusivity. ``double`` **eq_dens_diff_x2** = ``None, ... [per species] ...`` Shape-function coordinate parameter for particle diffusivity. ``double`` **eq_dens_diff_x3** = ``None, ... [per species] ...`` Shape-function coordinate parameter for particle diffusivity. ``double`` **eq_dens_diff_x4** = ``None, ... [per species] ...`` Shape-function coordinate parameter for particle diffusivity. ``double`` **eq_dens_diff_x5** = ``None, ... [per species] ...`` Shape-function coordinate parameter for particle diffusivity. ``int`` **eq_dens_shape** = ``0, ... [per species] ...`` Shape of equilibrium density profile Available options: - ``-1`` (Custom): Read from specified file (eq\_*\_file) - ``0`` (Constant) - ``1`` (TanH) - ``2`` (Linear) - ``5`` (Shape5) ``double`` **eq_dens_v1** = ``1.0e20, ... [per species] ...`` Shape coefficients (m^-3) ``std::string`` **eq_dens_file** = ``"example.dat", ... [per species] ...`` Filename for equilibrium density profile ``double`` **eq_dens_v2** = ``0.0, ... [per species] ...`` Shape coefficients (m^-3) ``double`` **eq_dens_v3** = ``0.0, ... [per species] ...`` Shape coefficients (m^-3) ``double`` **eq_dens_x1** = ``0.0, ... [per species] ...`` Shape coefficients ``double`` **eq_dens_x2** = ``0.0, ... [per species] ...`` Shape coefficients ``double`` **eq_dens_x3** = ``0.0, ... [per species] ...`` Shape coefficients ``int`` **eq_fg_flow_shape** = ``shape_int, ... [per species] ...`` fg flow shape Available options: - ``-1`` (Custom): Read from specified file (eq\_*\_file) - ``0`` (Constant) - ``1`` (TanH) - ``2`` (Linear) - ``5`` (Shape5) ``std::string`` **eq_fg_flow_file** = ``"", ... [per species] ...`` fg flow file ``double`` **eq_fg_flow_x1** = ``inx[0]/psi_normalization, ... [per species] ...`` x\_psi unit -> code unit ``double`` **eq_fg_flow_x2** = ``inx[1]/psi_normalization, ... [per species] ...`` x\_psi unit -> code unit ``double`` **eq_fg_flow_x3** = ``inx[2]/psi_normalization, ... [per species] ...`` x\_psi unit -> code unit ``double`` **eq_fg_flow_v1** = ``iny[0], ... [per species] ...`` m^-3 or ev ``double`` **eq_fg_flow_v2** = ``iny[1], ... [per species] ...`` m^-3 or ev ``double`` **eq_fg_flow_v3** = ``iny[2], ... [per species] ...`` m^-3 or ev ``int`` **eq_fg_flow_type** = ``species.eq_flow_type, ... [per species] ...`` fg flow type ``int`` **eq_fg_temp_shape** = ``shape_int, ... [per species] ...`` fg temp shape Available options: - ``-1`` (Custom): Read from specified file (eq\_*\_file) - ``0`` (Constant) - ``1`` (TanH) - ``2`` (Linear) - ``5`` (Shape5) ``std::string`` **eq_fg_temp_file** = ``"", ... [per species] ...`` fg temp file ``double`` **eq_fg_temp_x1** = ``inx[0]/psi_normalization, ... [per species] ...`` x\_psi unit -> code unit ``double`` **eq_fg_temp_x2** = ``inx[1]/psi_normalization, ... [per species] ...`` x\_psi unit -> code unit ``double`` **eq_fg_temp_x3** = ``inx[2]/psi_normalization, ... [per species] ...`` x\_psi unit -> code unit ``double`` **eq_fg_temp_v1** = ``iny[0], ... [per species] ...`` m^-3 or ev ``double`` **eq_fg_temp_v2** = ``iny[1], ... [per species] ...`` m^-3 or ev ``double`` **eq_fg_temp_v3** = ``iny[2], ... [per species] ...`` m^-3 or ev ``std::string`` **eq_filename** = ``"example_base.dat"`` eq\_filename is the name of the equilibrium input ``int`` **eq_flow_diff_shape** = ``None, ... [per species] ...`` Analytic shape selector for momentum diffusivity profiles. Use -1 for file input. Available options: - ``-1`` (Custom): Read from specified file (eq\_*\_file) - ``0`` (Constant) - ``1`` (TanH) - ``2`` (Linear) - ``5`` (Shape5) ``std::string`` **eq_flow_diff_file** = ``None, ... [per species] ...`` File name for momentum diffusivity profile input. ``double`` **eq_flow_diff_v1** = ``None, ... [per species] ...`` Shape-function value parameter for momentum diffusivity. ``double`` **eq_flow_diff_v2** = ``None, ... [per species] ...`` Shape-function value parameter for momentum diffusivity. ``double`` **eq_flow_diff_v3** = ``None, ... [per species] ...`` Shape-function value parameter for momentum diffusivity. ``double`` **eq_flow_diff_v4** = ``None, ... [per species] ...`` Shape-function value parameter for momentum diffusivity. ``double`` **eq_flow_diff_x1** = ``None, ... [per species] ...`` Shape-function coordinate parameter for momentum diffusivity. ``double`` **eq_flow_diff_x2** = ``None, ... [per species] ...`` Shape-function coordinate parameter for momentum diffusivity. ``double`` **eq_flow_diff_x3** = ``None, ... [per species] ...`` Shape-function coordinate parameter for momentum diffusivity. ``double`` **eq_flow_diff_x4** = ``None, ... [per species] ...`` Shape-function coordinate parameter for momentum diffusivity. ``double`` **eq_flow_diff_x5** = ``None, ... [per species] ...`` Shape-function coordinate parameter for momentum diffusivity. ``int`` **eq_flow_shape** = ``0, ... [per species] ...`` Shape of equilibrium flow profile Available options: - ``-1`` (Custom): Read from specified file (eq\_*\_file) - ``0`` (Constant) - ``1`` (TanH) - ``2`` (Linear) - ``5`` (Shape5) ``std::string`` **eq_flow_file** = ``"example.dat", ... [per species] ...`` Filename for equilibrium flow profile ``double`` **eq_flow_v1** = ``0.0, ... [per species] ...`` Shape coefficients ``double`` **eq_flow_v2** = ``0.0, ... [per species] ...`` Shape coefficients ``double`` **eq_flow_v3** = ``0.0, ... [per species] ...`` Shape coefficients ``double`` **eq_flow_x1** = ``0.0, ... [per species] ...`` Shape coefficients ``double`` **eq_flow_x2** = ``0.0, ... [per species] ...`` Shape coefficients ``double`` **eq_flow_x3** = ``0.0, ... [per species] ...`` Shape coefficients ``int`` **eq_flow_type** = ``2, ... [per species] ...`` How the flow term is calculated from the equilibrium flow profile. 0: flow = value; 1: flow = value*R; 2: flow = value*R*Bphi/B ``std::string`` **eq_g_filename** = ``"null.eqd"`` gqdsk file generated from M3D-C1 data (needed for wall shape and consistency) ``std::string`` **eq_m3dc1_filename** = ``"C1.h5"`` Name of the M3D-C1 data file ``int`` **eq_mk_flow_shape** = ``shape_int, ... [per species] ...`` mk flow shape Available options: - ``-1`` (Custom): Read from specified file (eq\_*\_file) - ``0`` (Constant) - ``1`` (TanH) - ``2`` (Linear) - ``5`` (Shape5) ``std::string`` **eq_mk_flow_file** = ``"", ... [per species] ...`` mk flow file ``double`` **eq_mk_flow_x1** = ``inx[0]/psi_normalization, ... [per species] ...`` x\_psi unit -> code unit ``double`` **eq_mk_flow_x2** = ``inx[1]/psi_normalization, ... [per species] ...`` x\_psi unit -> code unit ``double`` **eq_mk_flow_x3** = ``inx[2]/psi_normalization, ... [per species] ...`` x\_psi unit -> code unit ``double`` **eq_mk_flow_v1** = ``iny[0], ... [per species] ...`` m^-3 or ev ``double`` **eq_mk_flow_v2** = ``iny[1], ... [per species] ...`` m^-3 or ev ``double`` **eq_mk_flow_v3** = ``iny[2], ... [per species] ...`` m^-3 or ev ``int`` **eq_mk_flow_type** = ``species.eq_flow_type, ... [per species] ...`` mk flow type ``int`` **eq_mk_temp_shape** = ``shape_int, ... [per species] ...`` mk temp shape Available options: - ``-1`` (Custom): Read from specified file (eq\_*\_file) - ``0`` (Constant) - ``1`` (TanH) - ``2`` (Linear) - ``5`` (Shape5) ``std::string`` **eq_mk_temp_file** = ``"", ... [per species] ...`` mk temp file ``double`` **eq_mk_temp_x1** = ``inx[0]/psi_normalization, ... [per species] ...`` x\_psi unit -> code unit ``double`` **eq_mk_temp_x2** = ``inx[1]/psi_normalization, ... [per species] ...`` x\_psi unit -> code unit ``double`` **eq_mk_temp_x3** = ``inx[2]/psi_normalization, ... [per species] ...`` x\_psi unit -> code unit ``double`` **eq_mk_temp_v1** = ``iny[0], ... [per species] ...`` m^-3 or ev ``double`` **eq_mk_temp_v2** = ``iny[1], ... [per species] ...`` m^-3 or ev ``double`` **eq_mk_temp_v3** = ``iny[2], ... [per species] ...`` m^-3 or ev ``double`` **eq_out_decay_factor** = ``0.1`` Profiles decay exponentially to f(sml\_outpsi)/decay\_factor for psi>sml\_outpsi ``double`` **eq_out_decay_width** = ``0.03`` Width for exponential decay for psi>sml\_outpsi ``int`` **eq_pinch_v_shape** = ``None, ... [per species] ...`` Analytic shape selector for particle pinch velocity profiles. Use -1 for file input. Available options: - ``-1`` (Custom): Read from specified file (eq\_*\_file) - ``0`` (Constant) - ``1`` (TanH) - ``2`` (Linear) - ``5`` (Shape5) ``std::string`` **eq_pinch_v_file** = ``None, ... [per species] ...`` File name for particle pinch velocity profile input. ``double`` **eq_pinch_v_v1** = ``None, ... [per species] ...`` Shape-function value parameter for particle pinch velocity. ``double`` **eq_pinch_v_v2** = ``None, ... [per species] ...`` Shape-function value parameter for particle pinch velocity. ``double`` **eq_pinch_v_v3** = ``None, ... [per species] ...`` Shape-function value parameter for particle pinch velocity. ``double`` **eq_pinch_v_v4** = ``None, ... [per species] ...`` Shape-function value parameter for particle pinch velocity. ``double`` **eq_pinch_v_x1** = ``None, ... [per species] ...`` Shape-function coordinate parameter for particle pinch velocity. ``double`` **eq_pinch_v_x2** = ``None, ... [per species] ...`` Shape-function coordinate parameter for particle pinch velocity. ``double`` **eq_pinch_v_x3** = ``None, ... [per species] ...`` Shape-function coordinate parameter for particle pinch velocity. ``double`` **eq_pinch_v_x4** = ``None, ... [per species] ...`` Shape-function coordinate parameter for particle pinch velocity. ``double`` **eq_pinch_v_x5** = ``None, ... [per species] ...`` Shape-function coordinate parameter for particle pinch velocity. ``double`` **eq_priv_flux_decay_factor** = ``0.05`` Profiles decay exponentially to f(sml\_outpsi)/decay\_factor in priv. flux region ``double`` **eq_priv_flux_decay_width** = ``0.015`` Width for exponential decay in private flux region ``bool`` **eq_set_x2** = ``false`` Determine if there is second (upper) X-point to consider. It does not have to be set unless using the old flx.aif format. ``int`` **eq_t_diff_shape** = ``None, ... [per species] ...`` Analytic shape selector for heat conductivity profiles. Use -1 for file input. Available options: - ``-1`` (Custom): Read from specified file (eq\_*\_file) - ``0`` (Constant) - ``1`` (TanH) - ``2`` (Linear) - ``5`` (Shape5) ``std::string`` **eq_t_diff_file** = ``None, ... [per species] ...`` File name for heat conductivity profile input. ``double`` **eq_t_diff_v1** = ``None, ... [per species] ...`` Shape-function value parameter for heat conductivity. ``double`` **eq_t_diff_v2** = ``None, ... [per species] ...`` Shape-function value parameter for heat conductivity. ``double`` **eq_t_diff_v3** = ``None, ... [per species] ...`` Shape-function value parameter for heat conductivity. ``double`` **eq_t_diff_v4** = ``None, ... [per species] ...`` Shape-function value parameter for heat conductivity. ``double`` **eq_t_diff_x1** = ``None, ... [per species] ...`` Shape-function coordinate parameter for heat conductivity. ``double`` **eq_t_diff_x2** = ``None, ... [per species] ...`` Shape-function coordinate parameter for heat conductivity. ``double`` **eq_t_diff_x3** = ``None, ... [per species] ...`` Shape-function coordinate parameter for heat conductivity. ``double`` **eq_t_diff_x4** = ``None, ... [per species] ...`` Shape-function coordinate parameter for heat conductivity. ``double`` **eq_t_diff_x5** = ``None, ... [per species] ...`` Shape-function coordinate parameter for heat conductivity. ``int`` **eq_temp_shape** = ``0, ... [per species] ...`` Shape of equilibrium temperature profile Available options: - ``-1`` (Custom): Read from specified file (eq\_*\_file) - ``0`` (Constant) - ``1`` (TanH) - ``2`` (Linear) - ``5`` (Shape5) ``double`` **eq_temp_v1** = ``1.0e3, ... [per species] ...`` Shape coefficients (ev) ``std::string`` **eq_temp_file** = ``"example.dat", ... [per species] ...`` Filename for equilibrium temperature profile ``double`` **eq_temp_v2** = ``0.0, ... [per species] ...`` Shape coefficients (ev) ``double`` **eq_temp_v3** = ``0.0, ... [per species] ...`` Shape coefficients (ev) ``double`` **eq_temp_x1** = ``0.0, ... [per species] ...`` Shape coefficients ``double`` **eq_temp_x2** = ``0.0, ... [per species] ...`` Shape coefficients ``double`` **eq_temp_x3** = ``0.0, ... [per species] ...`` Shape coefficients ``double`` **eq_x2_r** = ``1.7`` R value of second (upper) X-point ``double`` **eq_x2_z** = ``10.0`` Z value of second (upper) X-point ``int`` **eq_zeff_shape** = ``0`` Shape of analytic Z-effective profile Available options: - ``-1`` (Custom): Read from specified file (eq\_*\_file) - ``0`` (Constant) - ``1`` (TanH) - ``2`` (Linear) - ``5`` (Shape5) ``std::string`` **eq_zeff_file** = ``"zeff.dat"`` Filename for Z-effective profile for radiation source ``double`` **eq_zeff_v1** = ``1.0`` Shape coefficients for analytic Z-effective profile ``double`` **eq_zeff_v2** = ``1.0`` Shape coefficients for analytic Z-effective profile ``double`` **eq_zeff_v3** = ``1.0`` Shape coefficients for analytic Z-effective profile ``double`` **eq_zeff_x1** = ``1.0`` Shape coefficients for analytic Z-effective profile ``double`` **eq_zeff_x2** = ``0.1`` Shape coefficients for analytic Z-effective profile ``double`` **eq_zeff_x3** = ``0.0`` Shape coefficients for analytic Z-effective profile f0_param ----------------------------------------- ``bool`` **f0_coarse_graining_on** = ``false`` Whether to enable the f0 coarse-graining source. If active, this source will be called every f\_source step and will move a fraction of the mesh background distribution f0g back into the marker particles. ``double`` **f0_coarse_graining_alpha** = ``1.0e-3`` Fraction of f0g to move back into the marker particles every time this source is called. This should be a small number (e.g. 1.0e-3) to avoid large perturbations to the distribution function, but can be increased if desired to accelerate the coarse-graining process. ``int`` **f0_df0g_retention_calls** = ``0`` This parameter sets the retention period (number of calls to f\_source) after which source information that cannot be interpolated to particles is discarded. ``std::string`` **f0_df0g_transfer_algorithm** = ``"LegacyAddToF0gH"`` This option controls how data from source routines (collisions, neutrals, diffusion, etc.) that cannot be interpolated to particles due to insufficient phase space coverage is treated. Available options: - ``LegacyAddToF0gH``: Adds this to the background distribution function on the 5D phase space mesh, which implies that particles will still see that data in the weight evolution equation. So this method technically conserves density, momentum and energy in the mesh-to-particle interpolation. But if there's too much accumulation of this noisy data in the background distribution, the simulation can become unstable. - ``PersistentRetainedDf0g``: Saves the data from the source routines that cannot be interpolated to particles to a separate memory instead of adding it to the background distribution function. The method will try repeatedly to interpolate this data to the particles until the retention period ("f0\_df0g\_retention\_calls") expires. Then the data is deleted. ``int`` **f0_mesh_order** = ``0`` Order of scatter/gather operations to/from f0 grid (0: nearest node, 1: triangle vertices) ``int`` **f0_nmu** = ``31`` Resolution of velocity space in perpendicular direction. Total perpendicular grid points is f0\_nmu+1 ``int`` **f0_nvp** = ``15`` Resolution of velocity space in parallel direcion. Total parallel grid points is 2*f0\_nvp+1 ``double`` **f0_smu_max** = ``3.0`` Maximum perpendicular velocity of velocity space grid, normalized to thermal velocity ``double`` **f0_update_alpha** = ``2.0e-3`` Single transfer-rate parameter for analytic and f0g updates ``bool`` **f0_update_analytic** = ``false`` Switch on/off the update of the analytic part of the distribution function ``bool`` **f0_update_analytic_local** = ``false`` If .false. --> flux-surface average update, .true. --> local ``bool`` **f0_update_analytic_hyp_vis_rad_on** = ``false`` Apply radial hyperviscosity to analytic-background moment adjustments ``double`` **f0_update_analytic_damp_width** = ``0.5`` For width of :math:`\exp^{-(x/w)^2}` damping factor for updating density/temperature of the analytical f0 ``bool`` **f0_update_f0g** = ``false`` Switch on/off f0g update ``double`` **f0_vp_max** = ``3.0`` Maximum parallel velocity of velocity space grid, normalized to thermal velocity field_decomp_param ----------------------------------------- ``int`` **n_ghost_planes** = ``1`` Number of ghost planes on each side of a subdomain. Toroidal overlap is not required, but may be useful for performance since it reduces the need to shift particles between ranks. ``int`` **n_ghost_vertices** = ``3000`` Number of ghost vertices on each side of the subdomain within the poloidal plane. It must be large enough to ensure that all neighboring vertices of the subdomain are present. However, this depends entirely on the grid since there is no guarantee on the order of vertices in an XGC grid. ``int`` **n_phi_domains** = ``n_ranks`` Number of subdomains in the toroidal direction. By default, there is no poloidal decomposition. ``int`` **n_ranks** = ``6`` Number of ranks across which the fields are decomposed. The larger this number, the less memory is used per rank. However, for best performance, this number should be as small as possible. ``bool`` **use_near_field** = ``false`` For better load balancing, have each rank retain the field near its global domain decomposition in addition to its secondary domain init_cond ----------------------------------------- ``bool`` **ic_add_zonal** = ``false`` Include a n=0 component ``double`` **ic_amp** = ``1.0e-4`` Amplitude of the n!=0 initial perturbation ``double`` **ic_amp_0** = ``0.0`` Amplitude of the n=0 initial perturbation ``int`` **ic_delta_n** = ``wedge_n`` Spacing between toroidal modes ``int`` **ic_n_modes** = ``(int`` Number of toroidal modes ``double`` **ic_phi_sign** = ``magnetic_field.bp_sign*magnetic_field.bt_sign`` Invert the sign of toridal direction in the eikonal ``bool`` **ic_poloidal_gaussian** = ``false`` Apply a gaussian modulation to the poloidal profile ``double`` **ic_psi_0** = ``0.0`` Center of radial gaussian modulation, in normalized poloidal flux (units of eq\_x\_psi) ``double`` **ic_q_sign** = ``magnetic_field.bp_sign`` Invert the sign of q in the eikonal ``bool`` **ic_radial_gaussian** = ``false`` Apply a gaussian modulation to the radial profile ``bool`` **ic_resonant_modes** = ``true`` use field aligned resonant modes ``int`` **ic_resonant_nmax_real** = ``1`` Maximal (real, not wedge) toroidal mode number in initial density when using sml\_field\_aligned\_initial=.true. and ic\_resonant\_modes=.true. ``int`` **ic_resonant_nmin_real** = ``1`` Minimal (real, not wedge) toroidal mode number in initial density when using sml\_field\_aligned\_initial=.true. and ic\_resonant\_modes=.true. ``double`` **ic_sigma_psi** = ``0.5`` Width of radial gaussian modulation, in normalized poloidal flux (units of eq\_x\_psi) ``double`` **ic_sigma_theta** = ``0.784`` Width of poloidal gaussian ``double`` **ic_theta_0** = ``0.0`` Center of poloidal gaussian load_balance_param ----------------------------------------- ``double`` **max_mem_redist_gb** = ``10.0`` Sets the maximum amount of memory per rank that can be allocated to particles, in gigabytes. ``bool`` **shift_before_push** = ``false`` Calls a particle shift to evenly distribute particles on plane right before the particle push ``double`` **threshold_to_rebalance** = ``0.02`` How much better the projected timing of a proposed load redistribution must be than the current distribution in order to adopt the new one. e.g. 0.02 sets a threshold of 2% better. ``std::string`` **update_method** = ``"NoHistory"`` Methods for updating internal model of load distribution. "NoHistory" uses only the most recent time step, while "ExpHistory" averages the existing model with the new step's timing information. Does not apply when weighting\_algorithm is "Fortran". ``bool`` **verbose** = ``false`` Verbose output of the internal load distribution model and load balancing decisions. ``std::string`` **weighting_algorithm** = ``"Fortran"`` Load balancing method. "Fortran" is the default since the newer methods are experimental. "ParticleBalance" does not incorporate timing data, but only tries to equally distribute particles. "SingleRegionBalance" currently tries to balance the push. mon_param ----------------------------------------- ``int`` **mon_flush_count** = ``12`` Number of timing files to write. Set to 0 to use mon\_flush\_freq ``int`` **mon_flush_freq** = ``0`` Frequency of timing files, if mon\_flush\_count is set to 0 neu_param ----------------------------------------- ``int`` **neu_background_period** = ``500`` Period between subsequent updates of the background neutral distribution function in ion time steps. In any case, the density renormalization and source rates are recalculated every timestep for a fixed normalized neutral profile ``bool`` **neu_degas2** = ``false`` Use DEGAS2 for the neutral Monte Carlo calculation. ``int`` **neu_ebin_num** = ``10`` Number of energy bins to use for neutral source. ``bool`` **neu_ebin_log** = ``false`` Whether to use logarithmic energy bins for the wall loss energy binning when neu\_ebin\_num is greater than 1. If false, linear bins will be used. ``double`` **neu_ebin_min** = ``3.0`` Minimum energy for the wall loss energy binning when neu\_ebin\_num is greater than 1. ``double`` **neu_ebin_max** = ``13.0`` Maximum energy for the wall loss energy binning when neu\_ebin\_num is greater than 1. ``int`` **neu_d2_ran_k** = ``100`` The ran\_k parameter from DEGAS2's random.hweb. Unlikely to change. ``double`` **neu_gas_puff_source** = ``-1.0`` Source of additional neutrals in particles/s. Puffed neutrals enter at the lowest energy bin. ``int`` **neu_gas_puff_segment** = ``-1`` One-based wall segment from which neu\_gas\_puff\_source is produced. ``bool`` **neu_exclude_private** = ``false`` Exclude the private region from neutral recycling ``double`` **neu_inpsi** = ``0.7`` Inner boundary for neutral fueling calculation (normalized pol. flux) ``int`` **neu_istep_max** = ``20000`` Maximum number of neutral push time steps ``double`` **neu_lost_rate_max** = ``5.0e23`` upper cutoff on the particle loss rate (particles/sec) ``double`` **neu_n0** = ``5.0e17`` m^-3 -> normalized unit, Realistic initial value for neu\_base\_den (=base neutral density). ``int`` **neu_num** = ``10000`` Number of neutral particles per thread per wall segment. If neu\_degas2=.true., this is the number of neutral particles per thread ``double`` **neu_recycle_rate** = ``0.9`` Fraction of lost ions that are recycled as neutrals. The ions lost to the wall as calculated in the sheath module are used to determine the global particle sink. Neutrals are produced at a rate of neu\_recycle\_rate*neu\_sum\_weight\_lost (in particles per second). ``int`` **neu_start_time** = ``2`` The time (in global time steps) after which the neutral source is turned on, in units of the main loop time step. Should be >= 1 since the neutral source calculation relies on the particle loss tally from the previous time step. ``double`` **neu_temp0** = ``3.0`` Neutral temperature boundary condition performance_param ----------------------------------------- ``bool`` **backup_particles_on_device** = ``false`` Whether to store backup of electrons in device memory. Saves on host-device communication, but uses significantly more device memory. ``bool`` **calculate_phi_ff_on_device** = ``false`` With this option, potential is communicated and the electric field is calculated on every MPI process. This means additional computation, but less communication. This tradeoff is probably beneficial on all current flagship platforms, but this has not been verified. ``bool`` **col_async_reassign** = ``false`` Asynchronously transfer collision workload between MPI ranks **[Used when col_param:col_mode=4]** ``std::string`` **collisions_solver** = ``"lapack"`` Which collisions solver to use. **[Used when col_param:col_mode=4]** Available options: - ``lapack``: is always used for CPU-only simulations - ``ginkgo``: is available for GPU and improves performance ``double`` **ginkgo_residual_reduction** = ``1.0e-16`` For the Ginkgo solver, the residual reduction ``int`` **ginkgo_max_iterations** = ``300`` For the Ginkgo solver, the maximum number of iterations ``bool`` **decompose_fields** = ``false`` Experimental. This option splits field quantities used for the electron push kernel so that not every MPI process contains the field information of the entire simulation domain. ``std::string`` **gyro_comm_method** = ``"PlaneComm"`` Different methods for storing gyroaverage matrices. Available options: - ``PlaneComm``: assigns each gyromatrix to a separate MPI process on each plane - ``PackedPlaneComm``: assigns each gyromatrix to multiple MPI process on each plane and communicates the results locally. This is not currently supported - ``SelfComm``: stores every gyromatrix on each MPI process, reducing communication but increasing storage requirements and computation. ``double`` **initial_ptl_res_margin** = ``1.1`` The particles are allocated with this initial buffer factor to delay or avoid having to reallocate these large arrays later in the simulation ``int`` **mesh_batch_size** = ``default_batch_size`` Collisions are batched (multiple vertices run in parallel) for better performance. The best value may vary by platform. Typically higher is better (for GPU simulations) but memory usage is linearly proportional to this value. **[Used when col_param:col_mode=4]** ``bool`` **particles_resident_on_device** = ``default_residence_option(`` Sets particle information to reside in device memory. This improves performance by reducing host-device communication. Particles are still sent back to host memory for some operations. This option can and should be used on platforms with sufficient device memory, which includes all flagship platforms as of 2024. ``bool`` **stream_particles** = ``default_streaming_option(`` Streams particles in chunks to hide time spent on host-device communication while not increasing device memory usage. This probably isn't currently very helpful for performance, and is not actively supported. ``bool`` **use_unfused_electron_push_kernel** = ``false`` Use unfused electron push kernel. This algorithm may be faster than the default push algorithm ptb_3db_param ----------------------------------------- ``int`` **ptb_3db_dasdt_opt** = ``1`` Selector for how to compute dAs/dt for RMP penetration ``double`` **ptb_3db_em_bd_width** = ``0.05`` Blending width between A\_s and full A representation ``bool`` **ptb_3db_em_full_spec** = ``false`` If false, only modes \|m/q-n\|<=sml\_mode\_select\_mres\_q are retained, if true, the remaining modes are retained in toroidal Fourier representation but without RMP response (Always true for ES). ``double`` **ptb_3db_em_inpsi** = ``-1.0`` Inner boundary of RMP representation in A\_s ``double`` **ptb_3db_em_outpsi** = ``1.1`` Outer boundary of RMP representation in A\_s ``int`` **ptb_3db_es_to_em_dt_ratio** = ``1`` Ratio of ES to EM time step size in RMP penetration calculation with ptb\_3db\_mode==2 (also: the number of time steps over which the perturbed current is averaged) ``int`` **ptb_3db_file_format** = ``1`` Format of input file with perturbed field data: (0) toroidal Fourier coefficients in R,Z, (1) read from M3D-C1 file using fusion-io (2) Generic test data (no file) ``std::string`` **ptb_3db_filename** = ``"xgc.ptb_3db.bp"`` Filename for perturbed field data if file\_format=0. Ignored otherwise. ``int`` **ptb_3db_m3dc1_timeslice** = ``1`` Time slice that is to be read from M3D-C1 file ``int`` **ptb_3db_mode** = ``0`` Mode of operation: (0) static RMP field (ES), or fully self-consistent RMP field (EM version) (2) self-consistent RMP field with time-averaged field-equations (EM version) ``int`` **ptb_3db_mstep_em** = ``mstep`` Number of EM time steps in RMP penetration calculation with ptb\_3db\_mode==2 ``int`` **ptb_3db_mstep_es** = ``0`` Number of ES time steps in RMP penetration calculation with ptb\_3db\_mode==2 ``double`` **ptb_3db_mult_factor** = ``1.0`` Factor for scaling the perturbed field ``int`` **ptb_3db_nr** = ``1000`` (R,Z) grid size in R-direction ``int`` **ptb_3db_ntor_min** = ``3`` smallest toroidal mode number ``int`` **ptb_3db_num_mpol** = ``30`` Number of poloidal mode numbers ``int`` **ptb_3db_num_ntor** = ``1`` Number of toroidal mode numbers (<= sml\_nphi\_total) ``int`` **ptb_3db_nz** = ``1000`` (R,Z) grid size in Z-direction ``int`` **ptb_3db_rampup_time** = ``1000`` Number of time steps over which the perturbed field is ramped up ``bool`` **ptb_3db_rampup_vac** = ``true`` (.true.) Ramp up perturbed field slowly, (.false.) turn on perturbed field abruptly ``bool`` **ptb_3db_screening_on** = ``false`` Artificial screening for static RMP field: (.false.) no screening, (.true.) exponential damping towards the axis ``double`` **ptb_3db_screening_width1** = ``0.02`` Decay length of the exponential damping function in units of normalized poloidal flux ``double`` **ptb_3db_screening_width2** = ``0.02`` Width of tanh for damping in the core in units of normalized poloidal flux ``double`` **ptb_3db_screening_psi1** = ``0.975`` Center of the tanh function for screening in the core (<1) ``double`` **ptb_3db_screening_fac1** = ``0.9`` Reduction of deltaB at the separatrix (<=1) ``double`` **ptb_3db_screening_fac2** = ``0.8`` Fraction of vacuum RMP in the core (<=1) ``bool`` **ptb_3db_single_mode_input** = ``true`` For M3D-C1 input; If .true., M3D-C1 file contains only one toroidal mode number. ``int`` **ptb_3db_single_mode_ntor** = ``3`` The mode number in the M3D-C1 file in case of single mode input ``int`` **ptb_3db_start_time** = ``1`` Time step in which perturbed field is switched on ``double`` **ptb_3db_update_alpha** = ``1.0`` Damping factor for update of the perturbed field ptl_param ----------------------------------------- ``double`` **ptl_charge_eu** = ``default_charge_eu, ... [per species] ...`` Particle charge in EU ``int`` **ptl_collision_grid_index** = ``nonadiabatic_idx, ... [per species] ...`` Which collision grid to use. This option can be used to assign species to share a collision grid, improving performance of the collision operator. By default, each species has its own collision grid. ptl\_collision\_grid\_index = 0, 1, 2, 2 would mean the third and fourth species share a collision grid. ``bool`` **ptl_dynamic_f0** = ``default_dynamic_f0, ... [per species] ...`` Whether f0 can evolve in time ``std::string`` **ptl_f_analytic_shape** = ``default_f_analytic_shape, ... [per species] ...`` Shape of analytic f Available options: - ``Maxwellian`` - ``SlowingDown`` - ``None`` ``std::string`` **ptl_f_init_file** = ``"i_initial_f.bp", ... [per species] ...`` Input file name for initial distribution ``std::string`` **ptl_input_file_dir** = ``"./"`` Directory of input file for loading initial distribution ``bool`` **ptl_is_gyrokinetic** = ``!species_is_electron, ... [per species] ...`` Whether particles of this species are gyrokinetic or drift kinetic ``std::string`` **ptl_label** = ``default_label(idx, ... [per species] ...`` Human-readable species label (15 characters or fewer) ``std::string`` **ptl_marker_type** = ``"TotalF", ... [per species] ...`` Marker type: Available options: - ``ReducedDeltaF`` - ``TotalF`` - ``FullF`` - ``None``: Placeholder for adiabatic species. @array:per\_species ``double`` **ptl_mass_au** = ``2.0e-2, ... [per species] ...`` Particle mass in AU ``bool`` **ptl_maxwellian_init** = ``true, ... [per species] ...`` whether initial distribution is maxwellian ``int`` **ptl_nsp** = ``1`` Number of ion species in the simulation ``int`` **ptl_num** = ``0`` Initial number of particles per species per OpenMP thread per MPI rank. This method is an alternative to ptl\_num\_per\_vertex. All species have the same value. ``int`` **ptl_num_per_vertex** = ``10000, ... [per species] ...`` Initial number of particles of each species per vertex per plane. e.g. Doubling the number of planes will double the number of particles in the simulation. The value refers to the average number of particles per vertex. It does not imply that each vertex has this number of associated particles initialized; the spatial distribution is controlled by other parameters. ``std::string`` **ptl_short_label** = ``default_short_label(idx, ... [per species] ...`` Short species label used in IO names (3 characters or fewer) ``double`` **ptl_special_en_ev** = ``7205.0`` Initial energy of particle if using sml\_load\_single\_ptl ``double`` **ptl_special_phi** = ``0.0`` Initial phi coordinate of particle if using sml\_load\_single\_ptl ``double`` **ptl_special_pitch** = ``0.276`` Initial pitch angle of particle if using sml\_load\_single\_ptl ``double`` **ptl_special_r** = ``magnetic_field.equil.axis.r`` Initial r coordinate of particle if using sml\_load\_single\_ptl ``double`` **ptl_special_z** = ``magnetic_field.equil.axis.z`` Initial z coordinate of particle if using sml\_load\_single\_ptl ``std::string`` **ptl_weight_evo_eq** = ``default_weight_evo_eq, ... [per species] ...`` Specifies the weight evolution equation method: Available options: - ``Direct``: Direct integration: Is used in the Total-F method, where the source term and particle contributions are evaluated separately. Refer to Section II C of Hager et al., Phys. Plasmas 29, 112308 (2022) for more details. - ``PDE``: The PDE (Partial Differential Equation) method, where the source term and particle contributions are evaluated together (delta-f). - ``None``: No weight evolution is applied. rad_param ----------------------------------------- ``std::string`` **rad_filename** = ``"mist_adas_xgc1.dat"`` Filename containing radiation information ``double`` **rad_impurity_fraction** = ``0.1`` simplest model : n\_imp / n\_e is constant ``double`` **rad_inpsi** = ``magnetic_field.inpsi`` Inner boundary for impurity radiation, in normalized poloidal flux (units of eq\_x\_psi) ``double`` **rad_outpsi** = ``magnetic_field.outpsi`` Outer boundary for impurity radiation, in normalized poloidal flux (units of eq\_x\_psi) ``int`` **rad_species** = ``-1`` Which species to use for density if not using a Z-effective profile ``int`` **rad_start_time** = ``1`` Start time for impurity radiation in time steps ``bool`` **rad_use_fix_charge** = ``true`` Use fixed Z for impurity ``bool`` **rad_use_zeff_profile** = ``false`` Use a psi-dependent Z-effective for radiation. ``double`` **rad_z** = ``6.0`` ! fixed Z for impurity - Z\_Carbon --> 6, Z^2 --> 36 resamp_param ----------------------------------------- ``bool`` **resamp_discard_var_bins** = ``false`` Discard resampled bins that increase the variance by factor of resamp\_var\_limit ``bool`` **resamp_distribute_evenly_subbins** = ``false`` Whether to fill/remove evenly in 1x1 velocity cells in the bin when resamp\_tile\_size > 1 and upsampling/downsampling ``std::string`` **resamp_down_choice** = ``"random"`` Option arg for downsampled new particle selection. Available options: - ``random``: Randomly chosen parameters - ``weight``: Keep particles with largest w0*w1 absolute weight, deterministic - ``weight_replace``: Keep particles with largest w0*w1 absolute weight, allow multiple copies of same particle if split weight is still larger than next unsplit particle - ``volume``: : Keep particles with largest phase space volume, deterministic ``bool`` **resamp_fill_empty** = ``false`` Whether to fill empty bins ``bool`` **resamp_fullf_on** = ``false`` Whether to resample the full-f weights in addition to delta-f weights ``bool`` **resamp_grid_ineq_on** = ``false`` Switch for using inequality constraints for the grid charge for resampling ``double`` **resamp_highv_max** = ``10.0`` energy cutoff of the high velocity bins v\_para>f0\_vp\_max and v\_perp>f0\_smu\_max ``double`` **resamp_highv_max_ratio** = ``4.0`` Downsampling threshold for high-velocity bins ``double`` **resamp_ineq_tol** = ``1.0e-4`` Threshold for relative error in the inequality constraints in the QP optimization ``double`` **resamp_ineq_tol_max** = ``1.0e-3`` Maximal threshold for relative error in inequality constraints for retried bins ``bool`` **resamp_keep_downsamples** = ``false`` Retain downsampling results with high variance, mainly for preventing buildup. Only relevant if resamp\_discard\_var\_bins is .true. ``bool`` **resamp_keep_upsamples** = ``false`` Retain upsampling results with high variance, for filling for pseudoinverse. Only relevant if resamp\_discard\_var\_bins is .true. ``double`` **resamp_max_ratio** = ``1.5`` Max ratio of (number of particles)/(target number of particles) in bin for auto-downsample ``double`` **resamp_max_shift** = ``0.1`` maximum shift in local coordinates for 'copy', 'weight\_replace' ``int`` **resamp_max_target** = ``4`` Overrides the number of constraints in determining the target number of particles of a bin ``double`` **resamp_min_ratio** = ``0.5`` Min ratio of (number of particles)/(target number of particles) in bin for auto-upsample ``std::string`` **resamp_node_file** = ``"resample.node"`` File containing the vertex positions of the mesh for which to resample ``int`` **resamp_nphi_new** = ``1`` Number of poloidal planes in simulation with new mesh ``bool`` **resamp_output_problem_bins** = ``false`` Switch to output failed or high-variance bins as to .bp files ``int`` **resamp_rate** = ``2*f_source_period`` timesteps between subsequent resamples ``bool`` **resamp_retry** = ``false`` Retry QP optimization for failed bins with relaxed inequality constraints ``int`` **resamp_tile_size** = ``2`` Bin size on the velocity space grid in cells (not vertices) (input parameter) ``std::string`` **resamp_up_choice** = ``"random"`` Option arg for upsampled new particle selection. Available options: - ``random``: Random velocity coordinates for new particles in bin - ``copy``: Add new particles as copies of old particles with largest absolute w0*w1 weight - ``poisson``: !DISABLED! Add new particles as poisson disc samples generated from the old particle set. ``double`` **resamp_var** = ``1.0e4`` threshold for relative standard deviation in bin for auto-resample ``double`` **resamp_var_limit** = ``3.0`` Increase in relative bin variance for flagging for possible rejection sml_param ----------------------------------------- ``bool`` **sml_00_efield** = ``true`` Flux-surface averaged potential not used for calculating the electric field if .false. ``int`` **sml_00_npsi** = ``150`` Size of the uniform 1D psi-grid ``bool`` **sml_0m_efield** = ``true`` The axisymmetric potential variation :math:`\langle \phi-\langle\phi\rangle\rangle_T` is set to zero if .false. ``bool`` **sml_3db_on** = ``false`` Toggle for ptb\_3db ``int`` **sml_add_pot0** = ``0`` Additional electrostatic potential: (0) for off, (1) for reading data from file (2) for simple neoclassical axisymmetric field (not operational) ``bool`` **sml_replace_pot0** = ``false`` If .true., replace Poisson solution with external data, if .false., add external potential to Poisson solution. ``int`` **sml_add_pot0_mixing_time** = ``1`` With sml\_replace\_pot0=.true. this option allows mixing the consistent solution with the imposed potential. At t=0 only the imposed field is used, over sml\_add\_pot0\_mixing\_time times steps the mixing factor is ramped down linearly to zero (only consistent field is used) ``std::string`` **sml_add_pot0_file** = ``"pot0.dat"`` Name of the file containing the potential data. Two formats are supported: Text file: The first line is the number of points, which must equal grid.nnode. Each subsequent line is the value at a point. ADIOS2 file (.bp): The array should be called "pot" and be size grid.nnode. ``bool`` **sml_ampere_natural_boundary** = ``false`` Ampere counterpart of sml\_poisson\_natural\_boundary. When using this option .true., should we force sml\_poisson\_natural\_boundary to .true.? ``double`` **sml_bd_ext_delta1** = ``0.01`` Outward shift of the inner boundary of the axisymmetric Poisson solver relative to sml\_inpsi (in norm. pol. flux) ``double`` **sml_bd_ext_delta1h** = ``bd_ext_delta1`` Outward shift of the inner boundary of the non-axisymmetric Poisson solver relative to sml\_inpsi (in norm. pol. flux) ``double`` **sml_bd_ext_delta2** = ``0.02`` Outward shift of the inner boundary of the RHS of the axisymmetric Poisson solver relative to sml\_inpsi (in norm. pol. flux) ``double`` **sml_bd_ext_delta2h** = ``bd_ext_delta2`` Outward shift of the inner boundary of the RHS of the non-axisymmetric Poisson solver relative to sml\_inpsi (in norm. pol. flux) ``double`` **sml_bd_ext_delta3** = ``bd_ext_inner`` Inward shift of the outer boundary of the axisymmetric Poisson solver relative to sml\_outpsi (in norm. pol. flux) ``double`` **sml_bd_ext_delta3h** = ``bd_ext_delta3`` Inward shift of the outer boundary of the non-axisymmetric Poisson solver relative to sml\_outpsi (in norm. pol. flux) ``double`` **sml_bd_ext_delta4** = ``bd_ext_rhs_inner`` Inward shift of the outer boundary of the RHS of the axisymmetric Poisson solver relative to sml\_outpsi (in norm. pol. flux) ``double`` **sml_bd_ext_delta4h** = ``bd_ext_delta4`` Inward shift of the outer boundary of the RHS of the non-axisymmetric Poisson solver relative to sml\_outpsi (in norm. pol. flux) ``double`` **sml_bd_ext_delta_ai** = ``0.0`` Shift of inner boundary of n!=0 Ampere solver (LHS) outwards relative to sml\_inpsi ``double`` **sml_bd_ext_delta_ao** = ``0.0`` Shift of outer boundary of n!=0 Ampere solver (LHS) inwards relative to sml\_outpsi ``bool`` **sml_bd_ext_delta_in_simple00** = ``false`` If .true., the outer boundary of the simple 1D Poisson solver that provides the initial guess of the flux-surface averaged potential is determined as the minimum of [sml\_outpsi-sml\_bd\_ext\_delta3,psi\_xpt-sml\_bd\_ext\_delta4] instead of [sml\_outpsi-sml\_bd\_ext\_delta3,psi\_xpt]. ``double`` **sml_bd_ext_delta_ji** = ``0.0`` Shift of inner boundary of n!=0 Ampere solver (RHS=current density) outwards relative to sml\_inpsi ``double`` **sml_bd_ext_delta_jo** = ``0.0`` Shift of outer boundary of n!=0 Ampere solver (RHS) inwards relative to sml\_outpsi ``double`` **sml_bd_ext_near_wall** = ``0.0`` To move the outer boundary of the Poisson solver away from the inner wall (in m) ``double`` **sml_bd_max_r** = ``1.0e3`` Minimum R of simulation ``double`` **sml_bd_max_z** = ``1.0e3`` Maximum Z of simulation ``double`` **sml_bd_min_r** = ``1.0e-4`` Minimum R of simulation ``double`` **sml_bd_min_z** = ``-1.0e3`` Maximum Z of simulation ``int`` **sml_bounce** = ``is_core_simulation ? 2 : 1`` Bounce routine switch 0 for off, 1 for inner boundary, 2 for both boundaries ``double`` **sml_bounce_buffer** = ``0.0`` Buffer width between sml\_outpsi and where the particle actually bounces (must be >=0) ``int`` **sml_bounce_zero_weight** = ``0`` If ==1 and bounce>0, set particle weights to zero after bouncing from the outer boundary ``double`` **sml_bp_mult** = ``1.0`` Artificial multiplication of poloidal B-field ``double`` **sml_bp_sign** = ``1.0`` Option to flip sign of poloidal field ``double`` **sml_bt_mult** = ``1.0`` Artificial multiplication of toroidal B-field ``double`` **sml_bt_sign** = ``-1.0`` Option to flip sign of toroidal field ``bool`` **sml_create_analytic_equil** = ``false`` Creates a simple analytic magnetic field instead of reading from a file ``bool`` **sml_create_analytic_grid** = ``false`` Option to use a generated grid instead of reading a grid from file. The grid is composed of concentric circles of vertices. analytic\_grid\_param can be used to control basic grid properties. ``bool`` **sml_current_drive_on** = ``false`` Whether to use dynamic current drive via adjustments of the loop voltage The controller output is implemented as :math:`V_{loop} = 2\pi R \eta_\parallel P \left[\Delta j_\parallel + I \int_0^t \Delta j_\parallel \mathrm{d}\tau + D \frac{\partial \Delta j_\parallel}{\partial t} \right] ` Time integral and derivative are with respect to the ion time step instead of time, so :math:`1/I` is the integration time scale, and :math:`D` is the derivative time scale ``bool`` **sml_dpot_bd_apply** = ``false`` Damp (n=0,m>0) potential towards the magnetic axis ``double`` **sml_dpot_bd_psi_c** = ``0.4`` Center (normalized flux) for (n=0,m>0) potential blending ``double`` **sml_dpot_bd_width** = ``0.05`` Decay length (normalized flux) for (n=0,m>0) potential towards the magnetic axis ``double`` **sml_dpot_te_limit** = ``64.0`` Max absolute value of dpot/temp in getf0 ``double`` **sml_dpot_te_limit_n0** = ``64.0`` Limits the magnitude of the normalized axisymmetric potential e*dphi\_0/T\_e ``double`` **sml_dpot_turb_psi_edge** = ``0.0`` Center of turbulent-potential core taper in normalized poloidal flux ``double`` **sml_dpot_turb_w_edge** = ``0.0`` Width of turbulent-potential core taper in normalized poloidal flux ``bool`` **sml_drift_on** = ``true`` Toggle for using drift ``double`` **sml_dt** = ``0.001`` Time step, in units of the main ion toroidal transit time ``bool`` **sml_dwdt_exb_only** = ``false`` excluding grad-b drift in dwdt ``bool`` **sml_dwdt_fix_bg** = ``false`` 1-w factor in dwdt ``std::string`` **sml_ele_file** = ``"example_file.ele"`` The element file ``bool`` **sml_electromagnetic** = ``false`` Simulate electromagnetic turbulence using the mixed-variable/pullback method to mitigate the Ampere cancellation problem ``bool`` **sml_electron_on** = ``false`` Use kinetic electrons ``bool`` **sml_em_b_para_eff** = ``false`` Effective dB\_\|\| via a modified grad-B drift (Joiner et al., PoP, 2010) ``bool`` **sml_em_control_variate** = ``false`` Switch for use of control variate method ``int`` **sml_em_control_variate_niter** = ``1`` Number of iterations for Ampere solve with control-variate method ``bool`` **sml_em_dasdt_filter_on** = ``false`` Switch for applying Fourier filters on RHS of dAs/dt equation (pullback mode 4) ``bool`` **sml_em_dasdt_hypvis** = ``false`` Use radial hyperviscosity in dA\_s/dt (push\_As) ``bool`` **sml_em_exclude_private** = ``true`` Makes the private flux region electrostatic if .true. ``bool`` **sml_em_mixed_variable** = ``true`` Switch for use of mixed-variable formulation ``bool`` **sml_em_n0** = ``false`` Include n=0 electromagnetic mode ``double`` **sml_em_pullback_dampfac** = ``1.0`` Damping term gamma on -b.grad(phi) in pullback mode 4 ``std::string`` **sml_em_pullback_method** = ``"Electrostatic"`` Available options: - ``Electrostatic``: Mixed-variable pullback with dA\_s/dt=0, - ``IdealMHD``: Pullback using Ohm's law dA\_s/dt + b.grad(phi) = 0 ``int`` **sml_em_pullback_mode** = ``3`` (3) mixed-variable pullback with dA\_s/dt=0, (4) pullback using Ohm's law dA\_s/dt + b.grad(phi) = 0 ``bool`` **sml_em_use_dpot_te_limit** = ``false`` In EM simulation: whether to force usage of the min-max limiter on the turbulent potential fluctuation ``double`` **sml_en_order_kev** = ``0.2`` Characteristic ion energy (keV) --> controls reference time (toroidal ion transit time) ``bool`` **sml_exclude_private** = ``false`` This is already in Simulation class; should consolidate ``bool`` **sml_exclude_private_turb** = ``true`` If .true. the private-flux region has no turbulence ``double`` **sml_f0_grid_init_ptl_imbal** = ``-1.0`` Initial particle load imbalance. ``int`` **sml_f0_grid_lbal_period** = ``0`` Force periodic update of the domain decomposition every sml\_f0\_grid\_lbal\_period time steps. When set to zero, the domain decomposition is adjusted only when the load imbalance exceeds its thresholds. ``double`` **sml_f0_grid_max_ptl_imbal** = ``2.0`` Upper threshold for the particle load imbalance (typically ~1.3). ``double`` **sml_f0_grid_min_ptl_imbal** = ``1.0`` Lower threshold for the particle load imbalance. ``int`` **sml_f0_nmu_decomp** = ``1`` (Not operational!) Parameter to control the decomposition of the velocity space grid in the :math:`v_\perp` direction. 1 means no decomposition. ``int`` **sml_f_source_period** = ``1`` Period (in time steps) of when f\_source is called ``bool`` **sml_ff_boundary_zero_p** = ``false`` zero out p for non-exist field following position. ``int`` **sml_ff_order** = ``4`` Order of RK scheme used for field following. Can be 1, 2, or 4. ``int`` **sml_ff_step** = ``2`` Number of steps taken when projecting the particle location onto the midplane ``bool`` **sml_field_aligned_initial** = ``false`` Use field aligned initial condition ``bool`` **sml_field_solver** = ``true`` Whether to solve for fields. Scatter and solve are skipped if set to false ``bool`` **sml_flat_electron_density** = ``false`` In case of adiabatic electrons, whether to use a uniform electron background density ``bool`` **sml_flat_marker** = ``true`` Use flat marker distribution function when set to .true. Marker distribution g is constant up to v<= sml\_flat\_marker\_decay\_start[1/2] and decays exponentially from there up to v<= sml\_flat\_marker\_cutoff. The decay length is sml\_flat\_marker\_width. Does not applied to FullF ``double`` **sml_flat_marker_decay_start1** = ``3.5`` Normalized (to :math:`v_{th}`) velocity at which the marker distribution decays exponentially ``double`` **sml_flat_marker_cutoff1** = ``4.0`` Normalized (to :math:`v_{th}`) parallel velocity cutoff of flat marker distribution ``double`` **sml_flat_marker_width1** = ``0.5`` Decay length of flat marker distribution in the normalized (to :math:`v_{th}`) parallel velocity ``double`` **sml_flat_marker_decay_start2** = ``flat_marker_decay_start1`` Like sml\_flat\_marker\_decay\_start1 but for the perpendicular velocity ``double`` **sml_flat_marker_cutoff2** = ``flat_marker_cutoff1`` Like sml\_flat\_marker\_cutoff1 but for the perpendicular velocity ``double`` **sml_flat_marker_width2** = ``flat_marker_width1`` Like sml\_flat\_marker\_width1 but for the perpendicular velocity ``bool`` **sml_grad_psitheta** = ``false`` This is already in Simulation class; should consolidate ``double`` **sml_gradpsi_limit** = ``1.0e-3`` If :math:`|\nabla\psi|` is smaller than this threshold, :math:`\nabla\psi` is computed ``int`` **sml_grid_nrho** = ``6`` Size of the gyroradius grid. ``int`` **sml_guess_table_size** = ``500`` Size of the hash table used to narrow down the number of triangles in which to search a particle ``std::string`` **sml_gyraze_surrogate_file** = ``"gyraze_surrogate_mpe.bp"`` Gyraze surrogate coefficient file name ``std::string`` **sml_gyro_radius_method** = ``"ThermalMuProjectedBOverT"`` Selects how NEWGYROMATRIX computes the marker rho-grid coordinate. Available options: - ``FixedRho``: thermal-normalized grid using Ti(psi=0) instead of local Ti - ``ThermalRho``: adaptive thermal grid with marker rho estimated at the marker plane - ``ThermalMuExact``: exact marker-side-plane field following, NEWGYROMAT\_V1 reference - ``ThermalMuProjectedB``: interpolate precomputed side-plane projected B and use local marker Ti - ``ThermalMuProjectedBOverT``: interpolate precomputed side-plane sqrt(2B/(Ti e)) scale (default) ``double`` **sml_gyro_rho_norm_max** = ``3.5`` Upper cutoff in normalized sqrt(mu), rho/rho\_th. ``bool`` **sml_helmholtz_spectral** = ``false`` Whether to solve Helmholtz-type equations with toroidally spectral solver ``bool`` **sml_heuristic_priv_pot** = ``false`` Override the Poisson solver in the private region using the method selected by sml\_heuristic\_priv\_pot\_method. ``std::string`` **sml_heuristic_priv_pot_method** = ``"ElecTempScaling"`` Switch for choosing the method with which to set the private region potential. Available options: - ``Constant``: Sets the potential uniformly to the flux-surface averaged potential on the separatrix. - ``ElecTempScaling``: Sets the values to the flux-surface average separatrix potential times the ratio of the local electron temperature (FSA) to the separatrix temperature. ``bool`` **sml_ignore_f0g** = ``false`` Ignore f0g in f0 calculation. When true, it skips the update of den\_f0\_h, instead using the initialized value (which is zero). This is helpful to density conservation of heating when f0g is noisy due to insufficient number of particles ``bool`` **sml_increase_ptl_tor** = ``false`` Increase number of particles with different toroidal angle when reading restart file ``int`` **sml_increase_ptl_factor_int** = ``1`` the factor to increase when sml\_increase\_ptl\_tor ``double`` **sml_increase_ptl_rand_w0** = ``1.0e-4`` random noise to w0 - to avoid identical marker of sml\_increase\_ptl\_factor\_int ``double`` **sml_increase_ptl_rand_w1** = ``1.0e-4`` random noise to w1 - to avoid identical marker of sml\_increase\_ptl\_factor\_int ``double`` **sml_increase_ptl_rand_mu** = ``1.0e-4`` random noise to rho\_parallel (v\_parallel) - to avoid identical marker of sml\_increase\_ptl\_factor\_int ``double`` **sml_increase_ptl_rand_vp** = ``1.0e-4`` random noise to mu - to avoid identical marker of sml\_increase\_ptl\_factor\_int ``double`` **sml_increase_ptl_rand_phi** = ``1.0e-1`` random noise to phi (applied to core only) to avoid identical marker of sml\_increase\_ptl\_factor\_int ``double`` **sml_initial_deltaf_noise** = ``1.0e-3`` Delta-f particle weights are initialized with this level of noise ``double`` **sml_inpsi** = ``0.0`` Inner psi boundary for the simulation, in normalized poloidal flux (units of eq\_x\_psi) ``std::string`` **sml_input_file_dir** = ``"./"`` Directory containing the grid files ``std::string`` **sml_input_file_format** = ``"text"`` Input-file format for equilibrium and mesh data. Options: "text" reads the traditional eqd/node/ele/flx.aif files; "adios" reads sml\_input\_package\_file. ``std::string`` **sml_input_package_file** = ``"xgc.input.bp"`` ADIOS2 input package containing required equilibrium, mesh, and flux-surface data when sml\_input\_file\_format="adios". ``bool`` **sml_iter_solver** = ``true`` Split Poisson equation into axisymmetric and non-axisymmetric parts. The axisymmetric part has the flux-surface averaged potential on the RHS. Solve iteratively by lagging the RHS potential by one iteration. Stop after sml\_iter\_solver\_niter iterations. If .false., split Poisson equation into flux-surface averaged part and rest (assuming that the polarization term commutes with the flux-surface average) and the rest; solve in two steps. ``bool`` **sml_iter_solver_converge** = ``false`` If .true., keep taking iterations in PETSc until termination criteria is met, i.e. until a residual tolerance is reached or it is determined that the iterations have diverged or exceeded sml\_iter\_solver\_max\_it. If .false., take a fixed number of iterations set from sml\_iter\_solver\_niter. ``int`` **sml_iter_solver_niter** = ``10`` Number of iterations for the iterative axisymmetric Poisson solver when sml\_iter\_solver\_converge=.false. ``int`` **sml_iter_solver_precond_type** = ``0`` Set the preconditioner type for the iterative axisymmetric poisson solver (0) poisson operator without the flux surface average term (i.e. Amat). This is used to reproduce the old iterative method. (1) Amat in addition to an approximate 1D solve for the flux surface averaged part. This option should be used when sml\_iter\_solver\_converge is set to .true. as it is a much more effective preconditioner. ``double`` **sml_iter_solver_rtol** = ``1.0e-5`` Relative tolerance for residual. Used to determine convergence when sml\_iter\_solver\_converge=.true. ``double`` **sml_iter_solver_atol** = ``1.0e-50`` Absolute tolerance for residual. Used to determine convergence when sml\_iter\_solver\_converge=.true. ``int`` **sml_iter_solver_max_it** = ``10`` Maximum number of iterations allowed when sml\_iter\_solver\_converge=.true. ``bool`` **sml_limit_marker_den** = ``false`` Whether to limit marker density ``double`` **sml_limit_marker_den_fac** = ``5.0`` Threshold for removing excess particles in multiples of the target number of particles per vertex ``bool`` **sml_load_single_ptl** = ``false`` Option to run simulation with a single particle. The particle's initial phase is determined by the inputs ptl\_special\_r etc. This option overrides ptl\_num and ptl\_num\_per\_vertex ``bool`` **sml_loop_voltage_fsa** = ``true`` Make loop voltage and current drive flux-functions if true (default: true) ``bool`` **sml_loop_voltage_on** = ``false`` Inductive current drive: loop voltage (from Faraday's law curl(E)=-dB/dt) ``double`` **sml_low_mu_fill_population** = ``0.0`` Used for filling the low-mu range of velocity space 0.0 --> all markers in low-mu range, 1.0 --> no low-mu filling (only if sml\_flat\_marker=.false.) ``double`` **sml_marker_min_temp** = ``10.0`` minimum temperature of markers (only if sml\_flat\_marker=.false.) ``double`` **sml_marker_temp_factor** = ``1.0`` Initial loading with Maxwellian marker distribution with virtual temperature :math:`T_{marker} = \alpha*T_{plasma}` (only if sml\_flat\_marker=.false.) ``double`` **sml_max_imbalance** = ``1.1`` Threshold of the combined particle-mesh load imbalance that triggers an update of the domain decomposition ``double`` **sml_max_loading_factor** = ``10.0`` Upper limit for loading factor (default is conservative, might need higher value) ``double`` **sml_min_loading_factor** = ``0.1`` Lower limit for loading factor (default is conservative, might need lower value; lower values increase time for loading) ``bool`` **sml_mod_adiabatic** = ``false`` If .true., a psi-dependent weight is assigned to the FSA term in the adiabatic response. The weights are assigned according to a piecewise blending function in region 1: w = 1 if psi < psi\_in w = (psi\_out - psi)/(psi\_out - psi\_in) if psi\_in < psi < psi\_out w = 0 if psi > psi\_out Outside of region 1, w = 0. The parameter sml\_mod\_adiabatic\_psi\_in sets psi\_in and sml\_mod\_adiabatic\_psi\_out sets psi\_out. ``double`` **sml_mod_adiabatic_psi_in** = ``0.99`` Inner boundary for psi-dependent weighting function when sml\_mod\_adiabatic=.true. ``double`` **sml_mod_adiabatic_psi_out** = ``1.00`` Outer boundary for psi-dependent weighting function when sml\_mod\_adiabatic=.true. ``bool`` **sml_adiabatic_from_poisson** = ``false`` If .true., the adiabatic density used in the weight update comes directly from the corresponding term in the gyrokinetic Poisson equation. ``bool`` **sml_mode_select_bands_on** = ``false`` Determine the number of side bands to include by using grid%m\_max\_surf(i) ``double`` **sml_mode_select_bd_width** = ``0.01`` width of boundary envelope, in normalized poloidal flux (units of eq\_x\_psi) ``int`` **sml_mode_select_cutoff** = ``2`` Factor for cutoff in Fourier space, determines grid%m\_max\_surf(i) The default is the Nyquist limit sml\_mode\_select\_cutoff=2 ``int`` **sml_mode_select_cutoff_mode** = ``1`` (1) Default: calculate max. pol. mode number using :math:`\max(\Delta\theta^\ast)`; (2) use :math:`\Delta\theta^\ast` at :math:`B=B_{max}` on the flux-surface. ``double`` **sml_mode_select_damp_width** = ``2.0`` Width (in terms of poloidal mode numbers of the smooth exponential cutoff in the poloidal part of the field-aligned Fourier filter (see sml\_mode\_select\_num\_m\_damp). ``bool`` **sml_mode_select_div_mix** = ``true`` Whether to blend filtered and unfiltered data near the divertor plates (set .false. for increasing stability in EM simulations) ``double`` **sml_mode_select_inpsi** = ``-0.1`` inner boundary for mode selection, in normalized poloidal flux (units of eq\_x\_psi) ``bool`` **sml_mode_select_keep_axisym** = ``false`` Whether to retain -sml\_mode\_select\_mres\_q*1 < m < sml\_mode\_select\_mres\_q*q (i.e. the axisymmetric mode) (used if FFT\_NTOR\_NUM\_ZERO=On) ``double`` **sml_mode_select_max_kth_rho** = ``1.0`` Max. k\_theta*rhoi retained in poloidal Fourier filter ``int`` **sml_mode_select_mmax** = ``25`` Highest pol. mode number for Fourier filter ``int`` **sml_mode_select_mmin** = ``0`` Lowest pol. mode number for Fourier filter ``int`` **sml_mode_select_mode** = ``0`` Fourier filter mode: 0) No filter, 1) single-n, 4) m\_range (mmin..mmax) 2 or 5) n range + resonant m 3 or 6) n range + m range ``int`` **sml_mode_select_mres_q** = ``3`` number of pol. mode numbers around the resonant mode divided by q; --> \|m/q - n\| <= mres\_q or \|m -n*q\| <= mres\_q*q ``int`` **sml_mode_select_n** = ``1`` Toroidal mode number for Fourier filter ``int`` **sml_mode_select_nmax** = ``1`` Highest numerical tor. mode number for Fourier filter (0,1,...,sml\_nphi\_total-1) ``int`` **sml_mode_select_nmax_real** = ``999`` Highest real toroidal mode number for FFT filter (n\_real = (n\_num+(i-1)*sml\_nphi\_total)*sml\_wedge\_n), max. i depending on mesh resolution ``int`` **sml_mode_select_nmin** = ``1`` Lowest numerical tor. mode number for Fourier filter (0,1,...,sml\_nphi\_total-1) ``int`` **sml_mode_select_nmin_real** = ``0`` Lowest real toroidal mode number for FFT filter (n\_real = (n\_num+(i-1)*sml\_nphi\_total)*sml\_wedge\_n), max. i depending on mesh resolution ``bool`` **sml_mode_select_no_m0** = ``true`` filter out m=0 mode while field-following FFT filtering. (fourier\_filter\_n\_m\_range\_parallel) ``int`` **sml_mode_select_num_m_damp** = ``0`` Pad the rectangular mode filter with \|m/q-n\|<=N with sml\_mode\_select\_num\_m\_damp modes left and right and damp those modes exponentially. The damping factor is given by exp(-(x/w)^2) where x=max(0,\|m-n*q\|-sml\_mode\_select\_mres\_q) and w=sml\_mode\_select\_damp\_width. The default is sml\_mode\_select\_num\_m\_damp=0, i.e., a sharp cutoff in the filter ``double`` **sml_mode_select_outpsi** = ``10.0`` outer boundary for mode selection, in normalized poloidal flux (units of eq\_x\_psi) ``int`` **sml_mode_select_sol_mode** = ``0`` 0: Retain sine and cosine modes in SOL but use a window function 1: Retain only sine modes in SOL and don't use a window function 2: Retain sine and cosine modes and DO NOT use a window function (Applies only to filter modes sml\_mode\_select\_mode={5,6}!) ``bool`` **sml_mode_select_use_minm** = ``false`` Restrict poloidal mode number m to m>1 in field aligned filter (sml\_mode\_select\_mode=5) ``long long int`` **sml_monte_num** = ``monte_num_minimum`` Number of Monte Carlo points to use in calculating various simulation volumes. The actual number of points used may depend on number of MPI ranks, OpenMP threads, and particles. ``int`` **sml_mstep** = ``3000`` Number of time steps to run ``int`` **sml_ncycle_half** = ``30`` Number of subcycles in electron push RK step 1. Total number of subcycles is twice this value. ``bool`` **sml_neutral** = ``false`` Switch for using the neutrals ``bool`` **sml_no_fp_in_f** = ``false`` If .true. the distribution function used for the source routines will not include particle information (only for testing) ``bool`` **sml_no_turb** = ``false`` Set all non-axisymmetric field perturbations to zero (electromagnetic version only) ``std::string`` **sml_node_file** = ``"example_file"`` The grid file ``int`` **sml_node_file_spacing** = ``1`` Option to take every nth grid file, starting from 0001 ``bool`` **sml_node_vol_monte** = ``node_vol_monte_default`` Calculate node volume using Monte-Carlo method (true), or analytic method (false) ``int`` **sml_nphi_total** = ``16`` Number of planes in the simulation ``int`` **sml_nsurf3** = ``0`` Number of flux-surfaces in the private flux region (from sml\_surf\_file if compiled with -DNEW\_FLX\_AIF=ON) ``int`` **sml_nsurf3_2** = ``0`` Number of flux-surfaces in the second private flux region (from sml\_surf\_file if compiled with -DNEW\_FLX\_AIF=ON) ``double`` **sml_outpsi** = ``1.05`` Outer psi boundary for the simulation, in normalized poloidal flux (units of eq\_x\_psi) ``double`` **sml_outpsi_priv1** = ``0.97`` Outer boundary (for Poisson solver), normalized poloidal flux ``double`` **sml_outpsi_priv2** = ``2.0`` Outer boundary (for Poisson solver, 2nd private region), normalized poloidal flux ``bool`` **sml_particle_source** = ``false`` On/off switch for the particle source module (df = f*dn\_dt\_source*dt), configured in src\_param. ``bool`` **sml_plane_major** = ``false`` MPI task ordering to use when mapping to 2D virtual processor grid. .true. for consecutive within plane; .false. for consecutive between planes. ``bool`` **sml_poisson_0m_full_geo** = ``false`` Whether to use full toroidal geometry in the axisymmetric Poisson solver (w/o approximation B\_R<` if .false. psn%dpot will still contain all (n=0,\|m\|>0) and (\|n\|>0,m) modes ``bool`` **sml_update_ampere_solver** = ``false`` If .true. density and temperature in the Ampere's law solver operators will be updated every sml\_update\_ampere\_solver\_nstep time steps ``int`` **sml_update_ampere_solver_nstep** = ``1`` Number of time steps between subsequent updates of the Ampere's law solver operators ``double`` **sml_update_g_alpha** = ``0.0`` Fraction of the numerical marker particle density that is transferred to the g2 ``bool`` **sml_update_poisson_solver** = ``false`` Whether poisson solver is updated ``int`` **sml_update_poisson_solver_nstep** = ``1`` Number of time steps between subsequent updates of the Poisson solver operators ``bool`` **sml_update_poisson_turb** = ``false`` Update the n != 0 Poisson solver, too (energy conservation?) ``bool`` **sml_use_loading_factor** = ``false`` Marker particle distribution taking into account the local (configuration space) node volume, i.e. aim for uniform number of ptl/mesh vertex. Set .true. when using a mesh with very non-uniform resolution ``bool`` **sml_use_pade** = ``false`` Use Pade approximation for short wavelengths ``int`` **sml_wedge_n** = ``1`` Simulate a wedge of 2pi/sml\_wedge\_n of the full torus ``bool`` **sml_write_wts_part_output** = ``true`` Whether to write weight partition output in set\_weights subroutine ``bool`` **sml_zero_inner_bd** = ``false`` If .true., use Dirichlet boundary condition :math:`\phi=0` ``bool`` **sml_zero_inner_bd_turb** = ``true`` If .true., use Dirichlet boundary condition :math:`\delta\phi=0`, !! if .false., set the magnetic axis to the flux-surface average of the !! first flux-surface (provides continuity of the m=0 mode). !! (requires the inner boundaries be set to <0) smooth_param ----------------------------------------- ``double`` **smooth_fourier_filt_bd_width** = ``0.02`` Boundary width (tanh) for Fourier filter, in normalized poloidal flux (units of eq\_x\_psi) ``double`` **smooth_fourier_filt_inpsi** = ``-0.1`` Inner boundary for Fourier filter (outside of boundary will be zero!), in normalized poloidal flux (units of eq\_x\_psi) ``int`` **smooth_fourier_filt_maxm** = ``30`` Maximal poloidal mode number for SOL Fourier filter ``int`` **smooth_fourier_filt_minm** = ``0`` Minimal poloidal mode number for SOL Fourier filter ``bool`` **smooth_fourier_filt_on** = ``false`` Switch for additional SOL Fourier filter ``double`` **smooth_fourier_filt_outpsi** = ``10.0`` Outer boundary for Fourier filter (outside of boundary will be zero!), in normalized poloidal flux (units of eq\_x\_psi) ``bool`` **smooth_hyp_vis_parallel_on** = ``false`` Switch for 2nd order accurate 4th derivative field-aligned hyperviscosity ``double`` **smooth_hyp_vis_parallel** = ``1.0`` Strength of the parallel hyperviscosity; sml\_dt/smooth\_hyp\_vis\_parallel corresponds to the decay time of a mode with k\_x=pi/dx, where dx is the local mesh size ``bool`` **smooth_hyp_vis_rad_on** = ``false`` Switch for 2nd order accurate 4th derivative radial (grad(psi)) hyperviscosity ``double`` **smooth_hyp_vis_rad** = ``0.1`` Strength of the radial hyperviscosity; sml\_dt/smooth\_hyp\_vis\_rad corresponds to the decay time of a mode with k\_x=pi/dx, where dx is the local mesh size **[Also used when sml_param:sml_em_dasdt_hypvis=true]** ``double`` **smooth_hyp_vis_rad_priv** = ``1.0`` Strength of the radial hyperviscosity in the private region; sml\_dt/smooth\_hyp\_vis\_rad corresponds to the decay time of a mode with k\_x=pi/dx, where dx is the local mesh size **[Also used when sml_param:sml_em_dasdt_hypvis=true]** ``double`` **smooth_pol_d0** = ``0.1`` Smoothing length for poloidal smoothing ``bool`` **smooth_pol_efield** = ``false`` Smoothing of poloidal potential before computing the poloidal field ``int`` **smooth_pol_width** = ``3`` Width for poloidal smoothing ``double`` **smooth_sol_filt_lp0** = ``0.20`` Poloidal Fourier filter for SOL: Window function --> distance from divertor plate in m ``double`` **smooth_sol_filt_width** = ``0.05`` Poloidal Fourier filter for SOL: Window function --> decay length in m src_param ----------------------------------------- ``double`` **src_current_drive_d** = ``1.0`` Current drive PID controller: factor for derivative controller (:math:`D`) ``double`` **src_current_drive_i** = ``0.01`` Current drive PID controller: factor for integral controller (:math:`I`) ``double`` **src_current_drive_p** = ``0.4`` Current drive PID controller: factor for proportional controller (:math:`P`) ``int`` **src_current_drive_start_time** = ``1`` Time step at which current drive turns on ``double`` **src_decay_width1** = ``0.01, ... [per species] ...`` Decay width (in normalized psi) for source region 1. ``double`` **src_decay_width2** = ``0.01, ... [per species] ...`` Decay width (in normalized psi) for source region 2. ``double`` **src_decay_width3** = ``0.01, ... [per species] ...`` Decay width (in normalized psi) for source region 3. ``double`` **src_decay_width4** = ``0.01, ... [per species] ...`` Decay width (in normalized psi) for source region 4. ``double`` **src_heat_power1** = ``0.0, ... [per species] ...`` Heat power in Watts for source region 1 (whole torus value). ``double`` **src_heat_power2** = ``0.0, ... [per species] ...`` Heat power in Watts for source region 2 (whole torus value). ``double`` **src_heat_power3** = ``0.0, ... [per species] ...`` Heat power in Watts for source region 3 (whole torus value). ``double`` **src_heat_power4** = ``0.0, ... [per species] ...`` Heat power in Watts for source region 4 (whole torus value). ``std::string`` **src_heat_torque_method** = ``"org"`` Selects heat/torque algorithm. Available options: - ``org``: Velocity-shift - ``polynomial``: Polynomial lifting ``int`` **src_ishape1** = ``1, ... [per species] ...`` Radial profile shape for source region 1: 1 trapezoid, 2 Gaussian. ``int`` **src_ishape2** = ``1, ... [per species] ...`` Radial profile shape for source region 2: 1 trapezoid, 2 Gaussian. ``int`` **src_ishape3** = ``1, ... [per species] ...`` Radial profile shape for source region 3: 1 trapezoid, 2 Gaussian. ``int`` **src_ishape4** = ``1, ... [per species] ...`` Radial profile shape for source region 4: 1 trapezoid, 2 Gaussian. ``double`` **src_loop_voltage** = ``0.0`` Initial value for loop voltage Positive loop voltage corresponds to an electron torque opposite to the toroidal direction (clockwise looking down on the torus, i.e. in negative Z-direction) ``double`` **src_loop_voltage_psimax** = ``1.0`` Inductive current drive: outer boundary (in pol. flux) of the loop voltage ``int`` **src_narea** = ``default_narea, ... [per species] ...`` Number of source regions for this species. Default is 1 for main ions and 0 otherwise. Max is 4. ``int`` **src_particle_source_shape** = ``0, ... [per species] ...`` Per-species shape selector for particle-source rate profile; interpreted as :math:`\\partial n_s / \\partial t` with units :math:`\\mathrm{m}^{-3}\\,\\mathrm{s}^{-1}`. Available options: - ``-1`` (Custom): Read from specified file (eq\_*\_file) - ``0`` (Constant) - ``1`` (TanH) - ``2`` (Linear) - ``5`` (Shape5) ``std::string`` **src_particle_source_file** = ``"example.dat", ... [per species] ...`` Per-species profile data file for file-based particle-source shapes. ``double`` **src_particle_source_v1** = ``0.0, ... [per species] ...`` Per-species shape coefficient v1 for particle-source rate profile. ``double`` **src_particle_source_v2** = ``0.0, ... [per species] ...`` Per-species shape coefficient v2 for particle-source rate profile. ``double`` **src_particle_source_v3** = ``0.0, ... [per species] ...`` Per-species shape coefficient v3 for particle-source rate profile. Guarded for future profile-size changes; currently Profile::N\_Y==4 so this path is taken. ``double`` **src_particle_source_v4** = ``0.0, ... [per species] ...`` Optional per-species shape coefficient v4 for particle-source rate profile. ``double`` **src_particle_source_x1** = ``0.0, ... [per species] ...`` Per-species shape coordinate x1 (psi-like) for particle-source rate profile. ``double`` **src_particle_source_x2** = ``0.0, ... [per species] ...`` Per-species shape coordinate x2 (psi-like) for particle-source rate profile. ``double`` **src_particle_source_x3** = ``0.0, ... [per species] ...`` Per-species shape coordinate x3 (psi-like) for particle-source rate profile. ``double`` **src_particle_source_x4** = ``0.0, ... [per species] ...`` Optional per-species shape coordinate x4 (psi-like) for particle-source rate profile. ``double`` **src_particle_source_x5** = ``0.0, ... [per species] ...`` Optional per-species shape coordinate x5 (psi-like) for particle-source rate profile. ``int`` **src_particle_source_start_time** = ``1`` First time step where the particle source is applied. ``bool`` **src_pellet_on** = ``false`` On/off switch for pellet ablation ``double`` **src_pellet_r** = ``1.0`` Position of the pellet, R-coordinate in m ``double`` **src_pellet_z** = ``0.0`` Position of the pellet, Z-coordinate in m ``double`` **src_pellet_cloud_a** = ``0.1`` Semi-major axis of the neutral gas cloud around the pellet in m ``double`` **src_pellet_cloud_b** = ``0.1`` Semi-minor axis of the neutral gas cloud around the pellet in m ``double`` **src_pellet_cloud_angle** = ``0.0`` Angle of the semi-major axis wrt the horizontal plane ``double`` **src_pellet_rad** = ``1.0e-3`` Radius of the pellet in m ``double`` **src_pellet_etemp** = ``5.0`` Electron temperature of the pellet cloud in eV ``double`` **src_pellet_itemp** = ``5.0`` Ion temperature of the pellet cloud in eV ``double`` **src_pellet_n_atoms** = ``1.0e21`` Total number of atoms in the pellet; ablation stops after the pellet is spent ``int`` **src_pellet_ion_species** = ``MAIN_ION`` Index of the ion species in the pellet; default is a main ion pellet ``int`` **src_pellet_start_time** = ``1`` Start time step of the pellet ablation ``int`` **src_pellet_stop_time** = ``-1`` End time step of the pellet ablation; if <0, no stop time ``double`` **src_pin1** = ``0.0, ... [per species] ...`` Inner flat-top boundary in normalized psi for source region 1. ``double`` **src_pin2** = ``1.04, ... [per species] ...`` Inner flat-top boundary in normalized psi for source region 2. ``double`` **src_pin3** = ``0.0, ... [per species] ...`` Inner flat-top boundary in normalized psi for source region 3. ``double`` **src_pin4** = ``0.0, ... [per species] ...`` Inner flat-top boundary in normalized psi for source region 4. ``double`` **src_pout1** = ``0.01, ... [per species] ...`` Outer flat-top boundary in normalized psi for source region 1. ``double`` **src_pout2** = ``1.05, ... [per species] ...`` Outer flat-top boundary in normalized psi for source region 2. ``double`` **src_pout3** = ``-1.0, ... [per species] ...`` Outer flat-top boundary in normalized psi for source region 3. ``double`` **src_pout4** = ``-1.0, ... [per species] ...`` Outer flat-top boundary in normalized psi for source region 4. ``double`` **src_r_begin1** = ``0.0, ... [per species] ...`` R reference for special modes in source region 1. ``double`` **src_r_begin2** = ``0.0, ... [per species] ...`` R reference for special modes in source region 2. ``double`` **src_r_begin3** = ``0.0, ... [per species] ...`` R reference for special modes in source region 3. ``double`` **src_r_begin4** = ``0.0, ... [per species] ...`` R reference for special modes in source region 4. ``double`` **src_radius1** = ``0.1, ... [per species] ...`` Radius in meters for circular source region 1 (special\_mode=2). ``double`` **src_radius2** = ``0.1, ... [per species] ...`` Radius in meters for circular source region 2 (special\_mode=2). ``double`` **src_radius3** = ``0.1, ... [per species] ...`` Radius in meters for circular source region 3 (special\_mode=2). ``double`` **src_radius4** = ``0.1, ... [per species] ...`` Radius in meters for circular source region 4 (special\_mode=2). ``int`` **src_special_mode1** = ``0, ... [per species] ...`` Region mode for source region 1: 0 normal, 1 divertor/SOL z-weighted, 2 circular region. ``int`` **src_special_mode2** = ``0, ... [per species] ...`` Region mode for source region 2: 0 normal, 1 divertor/SOL z-weighted, 2 circular region. ``int`` **src_special_mode3** = ``0, ... [per species] ...`` Region mode for source region 3: 0 normal, 1 divertor/SOL z-weighted, 2 circular region. ``int`` **src_special_mode4** = ``0, ... [per species] ...`` Region mode for source region 4: 0 normal, 1 divertor/SOL z-weighted, 2 circular region. ``int`` **src_start_time** = ``1`` Start time of source in ion time steps ``double`` **src_torque1** = ``0.0, ... [per species] ...`` Torque in N m for source region 1 (whole torus value). ``double`` **src_torque2** = ``0.0, ... [per species] ...`` Torque in N m for source region 2 (whole torus value). ``double`` **src_torque3** = ``0.0, ... [per species] ...`` Torque in N m for source region 3 (whole torus value). ``double`` **src_torque4** = ``0.0, ... [per species] ...`` Torque in N m for source region 4 (whole torus value). ``double`` **src_z_begin1** = ``0.0, ... [per species] ...`` Z reference for special modes in source region 1. ``double`` **src_z_begin2** = ``0.0, ... [per species] ...`` Z reference for special modes in source region 2. ``double`` **src_z_begin3** = ``0.0, ... [per species] ...`` Z reference for special modes in source region 3. ``double`` **src_z_begin4** = ``0.0, ... [per species] ...`` Z reference for special modes in source region 4. thermal_bath_param ----------------------------------------- ``double`` **gamma** = ``5000.0`` gamma\_k ``double`` **gamma_coarse_graining** = ``5000.0`` Coarse-graining gamma\_cg ``double`` **inpsi** = ``1.05`` Overlap region inner boundary ``double`` **inpsi_priv1** = ``0.97`` Boundary for weight sink in the primary private region ``double`` **inpsi_priv2** = ``1.02`` Boundary for weight sink in the secondary private region Convert boundaries from normalized flux to SI units ``int`` **n_diag_bins** = ``1`` Number of bins for diagnostic ``int`` **n_energy_bins** = ``1`` Number of energy bins ``double`` **outpsi** = ``1.05`` Overlap region outer boundary ``double`` **vmax** = ``5.0`` Maximum velocity for energy bins (normalized to thermal velocity)