Input Parameters ====================== The following is a complete list of input parameters available in XGC. This list is generated with the Python script ``utils/document_inputs.py``. Please help us improve the documentation for completeness, consistency and clarity. In the meantime, parameters labeled 'See Fortran description' may have more useful documentation `here `__. adios_param ----------------------------------------- | ``bool`` **adios_stage_3d** = ``false`` | Enable/disable Adios stage mode for xgc.3d | ``bool`` **adios_stage_escaped_ptls** = ``false`` | Enable/disable Adios stage mode for escape particle diagnostic | ``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_grid_param ----------------------------------------- | ``double`` **axis_r** = ``1.5`` | The r coordinate of the axis of the circular analytic magnetic equilibrium | ``int`` **nsurfaces** = ``30`` | Number of surfaces in the analytic circular grid. col_param ----------------------------------------- ``bool`` **col_accel** = ``false`` Artificial collision amplifying. ``double`` **col_accel_factor1** = ``10.0`` Acceleration factor of Range 1 ``double`` **col_accel_factor2** = ``10.0`` Acceleration factor of Range 2 ``int`` **col_accel_n** = ``2`` Number of psi regions to apply artifical accleration to. Maximum is 2. ``double`` **col_accel_pin1** = ``magnetic_field.inpsi`` Inner 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_pout1** = ``magnetic_field.inpsi + 0.1*psi_range`` Outer psi value of acceleration Range 1 ``double`` **col_accel_pout2** = ``magnetic_field.outpsi`` Outer psi value of acceleration Range 2 ``int`` **col_en_col_on** = ``1`` Switch for energy collision ``int`` **col_mode** = ``0`` Collision method. 0: No collisions. 1: uses the monte carlo non-conserving collisions. 4: uses the non-linear Fokker Planck Landau collision operator. 5: 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_m** = ``50`` Resolution of varying background ``int`` **col_vb_mtheta** = ``8`` Resolution in theta direction of varying background ``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 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`` | Description needed | ``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_nphi** = ``64`` | Number of phi bins for mode 2 | ``int`` **diag_heat_npsi** = ``1000`` | Number of psi bins for mode 1 | ``int`` **diag_heat_nr** = ``100`` | Number of radial bins in mode 1 | ``int`` **diag_heat_nsection** = ``1`` | Number of rectangular sections for mode 1 | ``int`` **diag_heat_nz** = ``100`` | Number of vertical bins in mode 1 | ``bool`` **diag_heat_on** = ``false`` | Whether to write heat diagnostic. | ``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_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_spacing** = ``5.0e-3`` | target spacing for wall segments | ``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 | ``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 | ``int`` **diag_neutral_period** = ``See Fortran description.`` | See Fortran description. | ``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 | ``int`` **diag_poin_isp** = ``See Fortran description.`` | See Fortran description. | ``int`` **diag_poin_nrec** = ``See Fortran description.`` | See Fortran description. | ``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_pseudo_inv_on** = ``false`` | switches pseudo-inverse diagnostics on and off, only used if f0_velocity_interp_use_pseudo_inv = .true. | ``int`` **diag_tracer_n** = ``See Fortran description.`` | See Fortran description. | ``int`` **diag_tracer_period** = ``See Fortran description.`` | See Fortran description. | ``int`` **diag_tracer_sp** = ``See Fortran description.`` | See Fortran description. | ``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 | ``double`` **diff_bd_out** = ``magnetic_field.outpsi`` | Outer psi boundary for diffusion | ``double`` **diff_bd_shift_in** = ``See Fortran description.`` | See Fortran description. | ``double`` **diff_bd_shift_out** = ``See Fortran description.`` | See Fortran description. | ``double`` **diff_bd_width_in** = ``See Fortran description.`` | See Fortran description. | ``double`` **diff_bd_width_out** = ``See Fortran description.`` | See Fortran description. | ``double`` **diff_bd_width_priv** = ``See Fortran description.`` | See Fortran description. | ``bool`` **diff_nonlinear** = ``See Fortran description.`` | See Fortran description. | ``bool`` **diff_on** = ``false`` | Switch for anomalous diffusion | ``bool`` **diff_pol_peak** = ``See Fortran description.`` | See Fortran description. | ``double`` **diff_pol_peak_amp** = ``See Fortran description.`` | See Fortran description. | ``double`` **diff_pol_peak_angle** = ``See Fortran description.`` | See Fortran description. | ``double`` **diff_pol_peak_width** = ``See Fortran description.`` | See Fortran description. | ``int`` **diff_start_time** = ``1`` | Start time (in time steps) for anomalous diffusion | ``bool`` **diff_update_on** = ``0`` | 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 | ``std::string`` **eq_dens_diff_file** = ``See Fortran description.`` | See Fortran description. | ``int`` **eq_dens_diff_shape** = ``See Fortran description.`` | See Fortran description. | ``double`` **eq_dens_diff_v1** = ``See Fortran description.`` | See Fortran description. | ``double`` **eq_dens_diff_v2** = ``See Fortran description.`` | See Fortran description. | ``double`` **eq_dens_diff_v3** = ``See Fortran description.`` | See Fortran description. | ``double`` **eq_dens_diff_v4** = ``See Fortran description.`` | See Fortran description. | ``double`` **eq_dens_diff_x1** = ``See Fortran description.`` | See Fortran description. | ``double`` **eq_dens_diff_x2** = ``See Fortran description.`` | See Fortran description. | ``double`` **eq_dens_diff_x3** = ``See Fortran description.`` | See Fortran description. | ``double`` **eq_dens_diff_x4** = ``See Fortran description.`` | See Fortran description. | ``double`` **eq_dens_diff_x5** = ``See Fortran description.`` | See Fortran description. | ``std::string`` **eq_dens_file** = ``"example.dat", ... [per species] ...`` | Filename for equilibrium density profile | ``int`` **eq_dens_shape** = ``0, ... [per species] ...`` | Shape of equilibrium density profile | ``double`` **eq_dens_v1** = ``1.0e20, ... [per species] ...`` | Shape coefficients (m^-3) | ``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 | ``std::string`` **eq_fg_flow_file** = ``See Fortran description.`` | See Fortran description. | ``int`` **eq_fg_flow_shape** = ``See Fortran description.`` | See Fortran description. | ``int`` **eq_fg_flow_type** = ``See Fortran description.`` | See Fortran description. | ``double`` **eq_fg_flow_v1** = ``See Fortran description.`` | See Fortran description. | ``double`` **eq_fg_flow_v2** = ``See Fortran description.`` | See Fortran description. | ``double`` **eq_fg_flow_v3** = ``See Fortran description.`` | See Fortran description. | ``double`` **eq_fg_flow_x1** = ``See Fortran description.`` | See Fortran description. | ``double`` **eq_fg_flow_x2** = ``See Fortran description.`` | See Fortran description. | ``double`` **eq_fg_flow_x3** = ``See Fortran description.`` | See Fortran description. | ``std::string`` **eq_fg_temp_file** = ``See Fortran description.`` | See Fortran description. | ``int`` **eq_fg_temp_shape** = ``See Fortran description.`` | See Fortran description. | ``double`` **eq_fg_temp_v1** = ``See Fortran description.`` | See Fortran description. | ``double`` **eq_fg_temp_v2** = ``See Fortran description.`` | See Fortran description. | ``double`` **eq_fg_temp_v3** = ``See Fortran description.`` | See Fortran description. | ``double`` **eq_fg_temp_x1** = ``See Fortran description.`` | See Fortran description. | ``double`` **eq_fg_temp_x2** = ``See Fortran description.`` | See Fortran description. | ``double`` **eq_fg_temp_x3** = ``See Fortran description.`` | See Fortran description. | ``std::string`` **eq_filename** = ``"example_base.dat"`` | eq_filename is the name of the equilibrium input | ``std::string`` **eq_flow_diff_file** = ``See Fortran description.`` | See Fortran description. | ``int`` **eq_flow_diff_shape** = ``See Fortran description.`` | See Fortran description. | ``double`` **eq_flow_diff_v1** = ``See Fortran description.`` | See Fortran description. | ``double`` **eq_flow_diff_v2** = ``See Fortran description.`` | See Fortran description. | ``double`` **eq_flow_diff_v3** = ``See Fortran description.`` | See Fortran description. | ``double`` **eq_flow_diff_v4** = ``See Fortran description.`` | See Fortran description. | ``double`` **eq_flow_diff_x1** = ``See Fortran description.`` | See Fortran description. | ``double`` **eq_flow_diff_x2** = ``See Fortran description.`` | See Fortran description. | ``double`` **eq_flow_diff_x3** = ``See Fortran description.`` | See Fortran description. | ``double`` **eq_flow_diff_x4** = ``See Fortran description.`` | See Fortran description. | ``double`` **eq_flow_diff_x5** = ``See Fortran description.`` | See Fortran description. | ``std::string`` **eq_flow_file** = ``"example.dat", ... [per species] ...`` | Filename for equilibrium flow profile | ``int`` **eq_flow_shape** = ``0, ... [per species] ...`` | Shape of equilibrium flow profile | ``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 | ``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 | ``std::string`` **eq_g_filename** = ``See Fortran description.`` | See Fortran description. | ``std::string`` **eq_m3dc1_filename** = ``See Fortran description.`` | See Fortran description. | ``std::string`` **eq_mk_flow_file** = ``See Fortran description.`` | See Fortran description. | ``int`` **eq_mk_flow_shape** = ``See Fortran description.`` | See Fortran description. | ``int`` **eq_mk_flow_type** = ``See Fortran description.`` | See Fortran description. | ``double`` **eq_mk_flow_v1** = ``See Fortran description.`` | See Fortran description. | ``double`` **eq_mk_flow_v2** = ``See Fortran description.`` | See Fortran description. | ``double`` **eq_mk_flow_v3** = ``See Fortran description.`` | See Fortran description. | ``double`` **eq_mk_flow_x1** = ``See Fortran description.`` | See Fortran description. | ``double`` **eq_mk_flow_x2** = ``See Fortran description.`` | See Fortran description. | ``double`` **eq_mk_flow_x3** = ``See Fortran description.`` | See Fortran description. | ``std::string`` **eq_mk_temp_file** = ``See Fortran description.`` | See Fortran description. | ``int`` **eq_mk_temp_shape** = ``See Fortran description.`` | See Fortran description. | ``double`` **eq_mk_temp_v1** = ``See Fortran description.`` | See Fortran description. | ``double`` **eq_mk_temp_v2** = ``See Fortran description.`` | See Fortran description. | ``double`` **eq_mk_temp_v3** = ``See Fortran description.`` | See Fortran description. | ``double`` **eq_mk_temp_x1** = ``See Fortran description.`` | See Fortran description. | ``double`` **eq_mk_temp_x2** = ``See Fortran description.`` | See Fortran description. | ``double`` **eq_mk_temp_x3** = ``See Fortran description.`` | See Fortran description. | ``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 | ``std::string`` **eq_pinch_v_file** = ``See Fortran description.`` | See Fortran description. | ``int`` **eq_pinch_v_shape** = ``See Fortran description.`` | See Fortran description. | ``double`` **eq_pinch_v_v1** = ``See Fortran description.`` | See Fortran description. | ``double`` **eq_pinch_v_v2** = ``See Fortran description.`` | See Fortran description. | ``double`` **eq_pinch_v_v3** = ``See Fortran description.`` | See Fortran description. | ``double`` **eq_pinch_v_v4** = ``See Fortran description.`` | See Fortran description. | ``double`` **eq_pinch_v_x1** = ``See Fortran description.`` | See Fortran description. | ``double`` **eq_pinch_v_x2** = ``See Fortran description.`` | See Fortran description. | ``double`` **eq_pinch_v_x3** = ``See Fortran description.`` | See Fortran description. | ``double`` **eq_pinch_v_x4** = ``See Fortran description.`` | See Fortran description. | ``double`` **eq_pinch_v_x5** = ``See Fortran description.`` | See Fortran description. | ``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. | ``std::string`` **eq_t_diff_file** = ``See Fortran description.`` | See Fortran description. | ``int`` **eq_t_diff_shape** = ``See Fortran description.`` | See Fortran description. | ``double`` **eq_t_diff_v1** = ``See Fortran description.`` | See Fortran description. | ``double`` **eq_t_diff_v2** = ``See Fortran description.`` | See Fortran description. | ``double`` **eq_t_diff_v3** = ``See Fortran description.`` | See Fortran description. | ``double`` **eq_t_diff_v4** = ``See Fortran description.`` | See Fortran description. | ``double`` **eq_t_diff_x1** = ``See Fortran description.`` | See Fortran description. | ``double`` **eq_t_diff_x2** = ``See Fortran description.`` | See Fortran description. | ``double`` **eq_t_diff_x3** = ``See Fortran description.`` | See Fortran description. | ``double`` **eq_t_diff_x4** = ``See Fortran description.`` | See Fortran description. | ``double`` **eq_t_diff_x5** = ``See Fortran description.`` | See Fortran description. | ``std::string`` **eq_temp_file** = ``"example.dat", ... [per species] ...`` | Filename for equilibrium temperature profile | ``int`` **eq_temp_shape** = ``0, ... [per species] ...`` | Shape of equilibrium temperature profile | ``double`` **eq_temp_v1** = ``1.0e3, ... [per species] ...`` | Shape coefficients (ev) | ``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 | ``std::string`` **eq_zeff_file** = ``"zeff.dat"`` | Filename for Z-effective profile for radiation source | ``int`` **eq_zeff_shape** = ``0`` | Shape of analytic Z-effective profile | ``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 ----------------------------------------- | ``double`` **f0_coarse_graining_alpha** = ``1.0e-3`` | Description needed | ``bool`` **f0_coarse_graining_on** = ``false`` | Description needed | ``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 | ``bool`` **f0_update_analytic** = ``false`` | Switch on/off the update of the analytic part of the distribution function | ``double`` **f0_update_analytic_alpha** = ``f0_grid_alpha`` | Separate alpha from sml_f0_grid_alpha for Maxwellian contribution | ``bool`` **f0_update_analytic_local** = ``false`` | If .false. --> flux-surface average update, .true. --> local | ``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_upsample** = ``See Fortran description.`` | See Fortran description. | ``int`` **f0_upsample_cell_target** = ``See Fortran description.`` | See Fortran description. | ``int`` **f0_upsample_corner_cell_target** = ``See Fortran description.`` | See Fortran description. | ``int`` **f0_upsample_rate** = ``See Fortran description.`` | See Fortran description. | ``bool`` **f0_upsample_skip_full_bins** = ``See Fortran description.`` | See Fortran description. | ``int`` **f0_upsample_tile_size** = ``See Fortran description.`` | See Fortran description. | ``bool`` **f0_velocity_interp_force_pseudo_inv** = ``See Fortran description.`` | See Fortran description. | ``bool`` **f0_velocity_interp_pseudo_inv_delta_grid** = ``See Fortran description.`` | See Fortran description. | ``int`` **f0_velocity_interp_pseudo_inv_order** = ``2`` | 1 (linear) or 2 (quadratic) pseudo-inverse interpolation, only used if f0_velocity_interp_use_pseudo_inv = .true. | ``bool`` **f0_velocity_interp_pseudo_inv_particles_to_grid_petsc** = ``See Fortran description.`` | See Fortran description. | ``bool`` **f0_velocity_interp_use_pseudo_inv** = ``false`` | Whether to use pseudo-inverse interpolation between particles and velocity grid | ``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. 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 | ``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 | ``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. | ``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 mr_param ----------------------------------------- | ``int`` **mr_factor1** = ``1`` | Unused | ``int`` **mr_factor2** = ``1`` | Unused | ``int`` **mr_factor3** = ``1`` | Unused | ``int`` **mr_factor4** = ``1`` | Unused | ``int`` **mr_factor5** = ``1`` | multirate timestepping for core region ions; mr_ratio (> 1) is the | factor used to accelerate the core region physics. | ``double`` **mr_psi_max5** = ``0.0`` | maximum normalized psi value of each multirate region neu_param ----------------------------------------- | ``bool`` **neu_adjust_n0** = ``See Fortran description.`` | See Fortran description. | ``int`` **neu_background_period** = ``See Fortran description.`` | See Fortran description. | ``double`` **neu_delta_n** = ``See Fortran description.`` | See Fortran description. | ``double`` **neu_delta_theta** = ``See Fortran description.`` | See Fortran description. | ``double`` **neu_dt** = ``See Fortran description.`` | See Fortran description. | ``bool`` **neu_ebin_log** = ``true`` | Description needed | ``double`` **neu_ebin_max** = ``100.0`` | Description needed | ``double`` **neu_ebin_min** = ``0.1`` | Description needed | ``int`` **neu_ebin_num** = ``1`` | Description needed | ``bool`` **neu_exclude_private** = ``See Fortran description.`` | See Fortran description. | ``double`` **neu_inpsi** = ``See Fortran description.`` | See Fortran description. | ``int`` **neu_istep_max** = ``See Fortran description.`` | See Fortran description. | ``double`` **neu_lost_rate_max** = ``See Fortran description.`` | See Fortran description. | ``double`` **neu_n0** = ``See Fortran description.`` | See Fortran description. | ``int`` **neu_num** = ``See Fortran description.`` | See Fortran description. | ``double`` **neu_peak_theta** = ``See Fortran description.`` | See Fortran description. | ``double`` **neu_recycle_rate** = ``See Fortran description.`` | See Fortran description. | ``bool`` **neu_source_match_flux** = ``See Fortran description.`` | See Fortran description. | ``int`` **neu_start_time** = ``2`` | Start time of neutral recycling in ion time steps | ``double`` **neu_temp0** = ``See Fortran description.`` | See Fortran description. | ``double`` **neu_theta_x** = ``See Fortran description.`` | See Fortran description. 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. | "lapack" is always used for CPU-only simulations | "ginkgo" is available for GPU and improves performance | **[Used when col_param:col_mode=4]** | ``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`` | Not ready for use. 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. | "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** = ``See Fortran description.`` | See Fortran description. | ``int`` **ptb_3db_m3dc1_timeslice** = ``See Fortran description.`` | See Fortran description. | ``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** = ``See Fortran description.`` | See Fortran description. | ``int`` **ptb_3db_nr** = ``See Fortran description.`` | See Fortran description. | ``int`` **ptb_3db_ntor_min** = ``See Fortran description.`` | See Fortran description. | ``int`` **ptb_3db_num_mpol** = ``See Fortran description.`` | See Fortran description. | ``int`` **ptb_3db_num_ntor** = ``1`` | Number of toroidal mode numbers (<= sml_nphi_total) | ``int`` **ptb_3db_nz** = ``See Fortran description.`` | See Fortran description. | ``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 | ``double`` **ptb_3db_screening_fac1** = ``See Fortran description.`` | See Fortran description. | ``double`` **ptb_3db_screening_fac2** = ``See Fortran description.`` | See Fortran description. | ``bool`` **ptb_3db_screening_on** = ``See Fortran description.`` | See Fortran description. | ``double`` **ptb_3db_screening_psi1** = ``See Fortran description.`` | See Fortran description. | ``double`` **ptb_3db_screening_width1** = ``See Fortran description.`` | See Fortran description. | ``double`` **ptb_3db_screening_width2** = ``See Fortran description.`` | See Fortran description. | ``bool`` **ptb_3db_single_mode_input** = ``See Fortran description.`` | See Fortran description. | ``int`` **ptb_3db_single_mode_ntor** = ``See Fortran description.`` | See Fortran description. | ``int`` **ptb_3db_start_time** = ``1`` | Time step in which perturbed field is switched on | ``double`` **ptb_3db_update_alpha** = ``See Fortran description.`` | See Fortran description. ptl_param ----------------------------------------- | ``double`` **ptl_charge_eu** = ``-1.0, ... [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] ...`` | f_analytic_shape shape: Maxwellian, SlowingDown or 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_marker_type** = ``"TotalF", ... [per species] ...`` | Marker type: 'ReducedDeltaF', 'TotalF', 'FullF', or 'None' (placeholder for adiabatic species). excluding the neoclassical terms in the gyrokinetic equation | ``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, MAIN_ION`` | 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. | ``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: Direct, PDE, or None. | - 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 | ``double`` **rad_outpsi** = ``magnetic_field.outpsi`` | Outer boundary for impurity radiation | ``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** = ``"weight"`` | option arg for downsampled new particle selection: 'random','weight','weight+replace','volume' | 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 (# of ptl)/(target # of ptl) 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 # of ptl of a bin | ``double`` **resamp_min_ratio** = ``0.5`` | min ratio of (# of ptl)/(target # of ptl) 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`` | timesteps between subsequent resamples, placedholder, in practice ~ sml_f_source_period | ``bool`` **resamp_restart** = ``false`` | Perform resampling before dumping the final restart file | ``bool`` **resamp_restart_read** = ``false`` | Whether to read a restart file written from a simulation with different grid | ``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: 'random','copy','poisson' currently added | random: random velocity coordinates for new particles in bin | copy: add new particles as copies of old particles with largest absolute w0*w1 weight | poision: 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`` **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`` **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) | ``std::string`` **sml_add_pot0_file** = ``See Fortran description.`` | See Fortran description. | ``int`` **sml_add_pot0_mixing_time** = ``See Fortran description.`` | See Fortran description. | ``bool`` **sml_adiabatic_from_poisson** = ``See Fortran description.`` | See Fortran description. | ``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_delta1`` | 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_delta2`` | 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_sign** = ``1.0`` | Option to flip sign of poloidal field | ``double`` **sml_bt_sign** = ``-1.0`` | Option to flip sign of toroidal field | ``double`` **sml_core_ptl_fac** = ``See Fortran description.`` | See Fortran description. | ``double`` **sml_core_ptl_psi** = ``See Fortran description.`` | See Fortran description. | ``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. | Keep analytic grid options simple: number of surfaces, and axis_r | ``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_width** = ``0.02`` | 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 | ``bool`` **sml_drift_on** = ``true`` | Toggle for using drift | ``double`` **sml_dt** = ``0.001`` | Time step (s) | ``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_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"`` | "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_alpha** = ``0.0`` | Fraction of the particle weight that is transferred to the background | distribution function (particle noise control) every | sml_f_source_period time steps. As a rule of thumb, | sml_f0_grid_alpha=sml_dt*sml_f_source_period can be used. | ``int`` **sml_f0_grid_alpha_start** = ``1`` | For delayed onset of total-f particle noise control. (must be >=1) | Values >1 cause a linear ramp-up of sml_f0_grid_alpha from 0 | to its input value from time step 1 to sml_f0_grid_alpha_start | ``double`` **sml_f0_grid_init_ptl_imbal** = ``See Fortran description.`` | See Fortran description. | ``int`` **sml_f0_grid_lbal_period** = ``See Fortran description.`` | See Fortran description. | ``double`` **sml_f0_grid_max_ptl_imbal** = ``See Fortran description.`` | See Fortran description. | ``double`` **sml_f0_grid_min_ptl_imbal** = ``See Fortran description.`` | See Fortran description. | ``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_cutoff1** = ``4.0`` | Normalized (to :math:`v_{th}`) parallel velocity cutoff of flat marker distribution | ``double`` **sml_flat_marker_cutoff2** = ``flat_marker_cutoff1`` | Like sml_flat_marker_cutoff1 but for the perpendicular velocity | ``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_decay_start2** = ``flat_marker_decay_start1`` | Like sml_flat_marker_decay_start1 but for the perpendicular velocity | ``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_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 (should be such that the resolution is >= 0.5 rho_i) | ``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 | ``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 and replace the solution by | the separatrix potential scaled with the initial electron 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 | ``int`` **sml_increase_ptl_factor_int** = ``1`` | the factor to increase when sml_increase_ptl_tor | ``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_phi** = ``1.0e-1`` | random noise to phi (applied to core only) 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_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 | ``bool`` **sml_increase_ptl_tor** = ``false`` | increase # of particle with different toroidal angle when reading restart file | ``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 | ``std::string`` **sml_input_file_dir** = ``"./"`` | Directory containing the grid files | ``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. | ``double`` **sml_iter_solver_atol** = ``See Fortran description.`` | See Fortran description. | ``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_max_it** = ``See Fortran description.`` | See Fortran description. | ``int`` **sml_iter_solver_niter** = ``See Fortran description.`` | See Fortran description. | ``int`` **sml_iter_solver_precond_type** = ``See Fortran description.`` | See Fortran description. | ``double`` **sml_iter_solver_rtol** = ``See Fortran description.`` | See Fortran description. | ``bool`` **sml_limit_marker_den** = ``false`` | Whether to limit marker density | ``double`` **sml_limit_marker_den_fac** = ``See Fortran description.`` | See Fortran description. | ``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 if sml_marker_temp_factor3>1 | 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_marker_temp_factor2** = ``See Fortran description.`` | See Fortran description. | ``double`` **sml_max_imbalance** = ``See Fortran description.`` | See Fortran description. | ``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_mms** = ``See Fortran description.`` | See Fortran description. | ``double`` **sml_mms_alpha** = ``See Fortran description.`` | See Fortran description. | ``double`` **sml_mms_beta** = ``See Fortran description.`` | See Fortran description. | ``double`` **sml_mms_gamma** = ``See Fortran description.`` | See Fortran description. | ``bool`` **sml_mod_adiabatic** = ``See Fortran description.`` | See Fortran description. | ``double`` **sml_mod_adiabatic_psi_in** = ``See Fortran description.`` | See Fortran description. | ``double`` **sml_mod_adiabatic_psi_out** = ``See Fortran description.`` | See Fortran description. | ``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 | ``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** = ``See Fortran description.`` | See Fortran description. | ``double`` **sml_mode_select_damp_width** = ``See Fortran description.`` | See Fortran description. | ``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 | ``bool`` **sml_mode_select_keep_axisym** = ``See Fortran description.`` | See Fortran description. | ``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** = ``See Fortran description.`` | See Fortran description. | ``int`` **sml_mode_select_num_m_damp** = ``See Fortran description.`` | See Fortran description. | ``double`` **sml_mode_select_outpsi** = ``10.0`` | outer boundary for mode selection | ``double`` **sml_mode_select_psitol** = ``See Fortran description.`` | See Fortran description. | ``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}!) | ``int`` **sml_mode_select_use_minm** = ``See Fortran description.`` | See Fortran description. | ``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 | ``bool`` **sml_multirate_timestepping** = ``false`` | Use multirate timestepping | ``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.node"`` | 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** = ``See Fortran description.`` | See Fortran description. | ``int`` **sml_nsurf3_2** = ``See Fortran description.`` | See Fortran description. | ``double`` **sml_outpsi** = ``1.05`` | Outer psi boundary for the simulation | ``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_plane_major** = ``See Fortran description.`` | See Fortran description. | ``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_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 | ``double`` **smooth_fourier_filt_inpsi** = ``-0.1`` | Inner boundary for Fourier filter (outside of boundary will be zero!) | ``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!) | ``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** = ``See Fortran description.`` | See Fortran description. | ``double`` **smooth_sol_filt_width** = ``See Fortran description.`` | See Fortran description. 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** = ``See Fortran description.`` | See Fortran description. | ``double`` **src_decay_width2** = ``See Fortran description.`` | See Fortran description. | ``double`` **src_decay_width3** = ``See Fortran description.`` | See Fortran description. | ``double`` **src_decay_width4** = ``See Fortran description.`` | See Fortran description. | ``double`` **src_heat_power1** = ``See Fortran description.`` | See Fortran description. | ``double`` **src_heat_power2** = ``See Fortran description.`` | See Fortran description. | ``double`` **src_heat_power3** = ``See Fortran description.`` | See Fortran description. | ``double`` **src_heat_power4** = ``See Fortran description.`` | See Fortran description. | ``int`` **src_ishape1** = ``See Fortran description.`` | See Fortran description. | ``int`` **src_ishape2** = ``See Fortran description.`` | See Fortran description. | ``int`` **src_ishape3** = ``See Fortran description.`` | See Fortran description. | ``int`` **src_ishape4** = ``See Fortran description.`` | See Fortran description. | ``double`` **src_loop_voltage** = ``0.0`` | Initial value for loop voltage | ``double`` **src_loop_voltage_psimax** = ``1.0`` | Inductive current drive: outer boundary (in pol. flux) of the loop voltage | ``int`` **src_narea** = ``See Fortran description.`` | See Fortran description. | ``int`` **src_niter** = ``See Fortran description.`` | See Fortran description. | ``int`` **src_nsubsection** = ``See Fortran description.`` | See Fortran description. | ``double`` **src_pellet_cloud_a** = ``0.1`` | Semi-major 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_cloud_b** = ``0.1`` | Semi-minor axis of the neutral gas cloud around the pellet in m | ``double`` **src_pellet_etemp** = ``5.0`` | Electron temperature of the pellet cloud in eV | ``int`` **src_pellet_ion_species** = ``MAIN_ION`` | Index of the ion species in the pellet; default is a main ion pellet | ``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 | ``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_rad** = ``1.0e-3`` | Radius of the pellet in m | ``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_pellet_z** = ``0.0`` | Position of the pellet, Z-coordinate in m | ``int`` **src_period** = ``See Fortran description.`` | See Fortran description. | ``double`` **src_pin1** = ``See Fortran description.`` | See Fortran description. | ``double`` **src_pin2** = ``See Fortran description.`` | See Fortran description. | ``double`` **src_pin3** = ``See Fortran description.`` | See Fortran description. | ``double`` **src_pin4** = ``See Fortran description.`` | See Fortran description. | ``double`` **src_pout1** = ``See Fortran description.`` | See Fortran description. | ``double`` **src_pout2** = ``See Fortran description.`` | See Fortran description. | ``double`` **src_pout3** = ``See Fortran description.`` | See Fortran description. | ``double`` **src_pout4** = ``See Fortran description.`` | See Fortran description. | ``double`` **src_r_begin1** = ``See Fortran description.`` | See Fortran description. | ``double`` **src_r_begin2** = ``See Fortran description.`` | See Fortran description. | ``double`` **src_r_begin3** = ``See Fortran description.`` | See Fortran description. | ``double`` **src_r_begin4** = ``See Fortran description.`` | See Fortran description. | ``double`` **src_radius1** = ``See Fortran description.`` | See Fortran description. | ``double`` **src_radius2** = ``See Fortran description.`` | See Fortran description. | ``double`` **src_radius3** = ``See Fortran description.`` | See Fortran description. | ``double`` **src_radius4** = ``See Fortran description.`` | See Fortran description. | ``int`` **src_special_mode1** = ``See Fortran description.`` | See Fortran description. | ``int`` **src_special_mode2** = ``See Fortran description.`` | See Fortran description. | ``int`` **src_special_mode3** = ``See Fortran description.`` | See Fortran description. | ``int`` **src_special_mode4** = ``See Fortran description.`` | See Fortran description. | ``int`` **src_start_time** = ``1`` | Start time of source in ion time steps | ``double`` **src_torque1** = ``See Fortran description.`` | See Fortran description. | ``double`` **src_torque2** = ``See Fortran description.`` | See Fortran description. | ``double`` **src_torque3** = ``See Fortran description.`` | See Fortran description. | ``double`` **src_torque4** = ``See Fortran description.`` | See Fortran description. | ``double`` **src_z_begin1** = ``See Fortran description.`` | See Fortran description. | ``double`` **src_z_begin2** = ``See Fortran description.`` | See Fortran description. | ``double`` **src_z_begin3** = ``See Fortran description.`` | See Fortran description. | ``double`` **src_z_begin4** = ``See Fortran description.`` | See Fortran description. 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 | ``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)