Write a namelist¶

Before you run Smilei, you need a namelist (an input file). The namelist is written in the python language. It is thus recommended to know the basics of python.

We suggest you copy one existing namelist from the folder benchmarks. All namelists have the extension .py.

General rules¶

Smilei requires a few blocks to be defined, such as:

Main(
    # ...
    timestep = 0.01,         # defines the timestep value
    grid_length = [10., 20.], # defines the 2D box dimensions
    # ...
)

Outside blocks, you can calculate anything you require. Inside a block, you must only define variables for Smilei.

The python syntax requires special indentation of each line. You begin with no indentation, but you have to add four spaces at the beginning of lines inside a group, and so on. For instance:
```
if a == 0:
    timestep = 0.1
    if b == 1:
        timestep = 0.2
else:
    timestep = 0.3
```
You will need to use lists, which are series of things in python, defined between brackets [] and separated by commas. For example, mean_velocity = [0., 1.1, 3.].
You are free to import any installed python package into the namelist. For instance, you may obtain \(\pi\) using from math import pi.
All quantities are normalized to arbitrary values: see Units.

Python workflow¶

Python is started at the beginning of the simulation (one python interpreter for each MPI process). The following steps are executed:

A few variables from Smilei are passed to python so that they are available to the user:
- The rank of the current MPI process as smilei_mpi_rank.
- The total number of MPI processes as smilei_mpi_size.
- The maximum random integer as smilei_rand_max.
The namelist(s) is executed.
Python runs preprocess() if the user has defined it. This is a good place to calculate things that are not needed for post-processing with happi.
The simulation is initialized (including field and particle arrays).
Python runs cleanup() if the user has defined it. This is a good place to delete unused heavy variables.
Python checks whether the python interpreter is needed during the simulation (e.g. the user has defined a temporal profile which requires python to calculate it every timestep). Otherwise, python is stopped.

All these instructions are summarized in a file smilei.py, so that the user can directly run python -i smilei.py for post-processing purposes.

Main variables¶

The block Main is mandatory and has the following syntax:

Main(
    geometry = "1Dcartesian",
    interpolation_order = 2,
    interpolator = "momentum-conserving",
    grid_length  = [16. ],
    cell_length = [0.01],
    simulation_time    = 15.,
    timestep    = 0.005,
    number_of_patches = [64],
    cluster_width = 5,
    maxwell_solver = 'Yee',
    EM_boundary_conditions = [
        ["silver-muller", "silver-muller"],
#        ["silver-muller", "silver-muller"],
#        ["silver-muller", "silver-muller"],
    ],
    time_fields_frozen = 0.,
    reference_angular_frequency_SI = 0.,
    print_every = 100,
    random_seed = 0,
)

geometry¶

The geometry of the simulation:

"1Dcartesian"
"2Dcartesian"
"3Dcartesian"
"AMcylindrical": cylindrical geometry with Azimuthal modes decomposition.

In the following documentation, all references to dimensions or coordinates depend on the geometry. 1D, 2D and 3D stand for 1-dimensional, 2-dimensional and 3-dimensional cartesian geometries, respectively. All coordinates are ordered as \((x)\), \((x,y)\) or \((x,y,z)\). In the "AMcylindrical" case, all grid coordinates are 2-dimensional \((x,r)\), while particle coordinates (in Species) are expressed in the 3-dimensional Cartesian frame \((x,y,z)\).

Warning

The "AMcylindrical" geometry has some restrictions. Boundary conditions must be set to "remove" for particles, "silver-muller" for longitudinal EM boundaries and "buneman" for transverse EM boundaries. You can alternatively use "PML" for any EM boundary. Collisions and order-4 interpolation are not supported yet.

interpolation_order¶

Default: 2

Interpolation order, defines particle shape function:

2 : 3 points stencil, supported in all configurations.
4 : 5 points stencil, not supported in vectorized 2D geometry.

interpolator¶

Default: "momentum-conserving"

"momentum-conserving"
"wt"

The interpolation scheme to be used in the simulation. "wt" is for the timestep dependent field interpolation scheme described in this paper .

grid_length¶

number_of_cells¶

A list of numbers: size of the simulation box for each dimension of the simulation.

Either grid_length, the simulation length in each direction in units of \(L_r\),
or number_of_cells, the number of cells in each direction.

Note

In AMcylindrical geometry, the grid represents 2-dimensional fields. The second dimension is the radius of the cylinder.

cell_length¶: A list of floats: sizes of one cell in each direction in units of \(L_r\).

simulation_time¶

number_of_timesteps¶

Duration of the simulation.

Either simulation_time, the simulation duration in units of \(T_r\),
or number_of_timesteps, the total number of timesteps.

timestep¶

timestep_over_CFL¶

Duration of one timestep.

Either timestep, in units of \(T_r\),
or timestep_over_CFL, in units of the Courant–Friedrichs–Lewy (CFL) time.

gpu_computing¶

Default: False

Activates GPU acceleration if set to True

number_of_patches¶: A list of integers: the number of patches in each direction. Each integer must be a power of 2, and the total number of patches must be greater or equal than the number of MPI processes. It is also strongly advised to have more patches than the total number of openMP threads. See Parallelization basics.On the other hand, in case of GPU-acceleration it is recommended to use one patch per MPI-rank (with one MPI-rank per GPU)

patch_arrangement¶

Default: "hilbertian"

Determines the ordering of patches and the way they are separated into the various MPI processes. Options are:

"hilbertian": following the Hilbert curve (see this explanation).
"linearized_XY" in 2D or "linearized_XYZ" in 3D: following the row-major (C-style) ordering.
"linearized_YX" in 2D or "linearized_ZYX" in 3D: following the column-major (fortran-style) ordering. This prevents the usage of Fields diagnostics (see Parallelization basics).

cluster_width¶

Default: set to minimize the memory footprint of the particles pusher, especially interpolation and projection processes

For advanced users. Integer specifying the cluster width along X direction in number of cells. The “cluster” is a sub-patch structure in which particles are sorted for cache improvement. cluster_width must divide the number of cells in one patch (in dimension X). The finest sorting is achieved with cluster_width=1 and no sorting with cluster_width equal to the full size of a patch along dimension X. The cluster size in dimension Y and Z is always the full extent of the patch.

Warning

The size of clusters becomes particularly important when Task Parallelization is used.

maxwell_solver¶

Default: ‘Yee’

The solver for Maxwell’s equations. Only "Yee" and "M4" are available for all geometries at the moment. "Cowan", "Grassi", "Lehe" and "Bouchard" are available for 2DCartesian. "Lehe" and "Bouchard" are available for 3DCartesian. "Lehe" is available for AMcylindrical. The M4 solver is described in this paper. The Lehe solver is described in this paper. The Bouchard solver is described in this thesis p. 109

solve_poisson¶

Default: True

Decides if Poisson correction must be applied or not initially.

poisson_max_iteration¶

Default: 50000

Maximum number of iteration for the Poisson solver.

poisson_max_error¶

Default: 1e-14

Maximum error for the Poisson solver.

solve_relativistic_poisson¶

Default: False

Decides if relativistic Poisson problem must be solved for at least one species. See Field initialization for relativistic species for more details.

relativistic_poisson_max_iteration¶

Default: 50000

Maximum number of iteration for the Poisson solver.

relativistic_poisson_max_error¶

Default: 1e-22

Maximum error for the Poisson solver.

EM_boundary_conditions¶

Type: list of lists of strings
Default: [["periodic"]]

The boundary conditions for the electromagnetic fields. Each boundary may have one of the following conditions: "periodic", "silver-muller", "reflective", "ramp??" or "PML".

Syntax 1: [[bc_all]], identical for all boundaries.
Syntax 2: [[bc_X], [bc_Y], ...], different depending on x, y or z.
Syntax 3: [[bc_Xmin, bc_Xmax], ...],  different on each boundary.

"silver-muller" is an open boundary condition. The incident wave vector \(k_{inc}\) on each face is defined by "EM_boundary_conditions_k". When using "silver-muller" as an injecting boundary, make sure \(k_{inc}\) is aligned with the wave you are injecting. When using "silver-muller" as an absorbing boundary, the optimal wave absorption on a given face will be along \(k_{abs}\) the specular reflection of \(k_{inc}\) on the considered face.
"ramp??" is a basic, open boundary condition designed for the spectral solver in AMcylindrical geometry. The ?? is an integer representing a number of cells (smaller than the number of ghost cells). Over the first half, the fields remain untouched. Over the second half, all fields are progressively reduced down to zero.
"PML" stands for Perfectly Matched Layer. It is an open boundary condition. The number of cells in the layer must be defined by "number_of_pml_cells". It supports laser injection as in "silver-muller". If not all boundary conditions are PML, make sure to set number_of_pml_cells=0 on boundaries not using PML.

EM_boundary_conditions_k¶

Type: list of lists of floats
Default: [[1.,0.],[-1.,0.],[0.,1.],[0.,-1.]] in 2D
Default: [[1.,0.,0.],[-1.,0.,0.],[0.,1.,0.],[0.,-1.,0.],[0.,0.,1.],[0.,0.,-1.]] in 3D

For silver-muller absorbing boundaries, the x,y,z coordinates of the unit wave vector k incident on each face (sequentially Xmin, Xmax, Ymin, Ymax, Zmin, Zmax). The number of coordinates is equal to the dimension of the simulation. The number of given vectors must be equal to 1 or to the number of faces which is twice the dimension of the simulation. In cylindrical geometry, k coordinates are given in the xr frame and only the Rmax face is affected.

Syntax 1: [[1,0,0]], identical for all boundaries.

Syntax 2: [[1,0,0],[-1,0,0], ...], different on each boundary.

number_of_pml_cells¶

Type: List of lists of integers
Default: [[10,10],[10,10],[10,10]]

Defines the number of cells in the "PML" layers using the same alternative syntaxes as "EM_boundary_conditions".

pml_sigma¶

Type: List of profiles
Default: [lambda x : 20 * x**2]

Defines the sigma profiles across the transverse dimension of the PML for each dimension of the simulation. It must be expressed as a list of profiles (1 per dimension).

If a single profile is given, it will be used for all dimensions.

For a given dimension, the same profile is applied to both sides of the domain.

The profile is given as a single variable function defined on the interval [0,1] where 0 is the inner bound of the PML and 1 is the outer bound of the PML. Please refer to Perfectly Matched Layers if needed in AM geometry.

pml_kappa¶

Type: List of profiles
Default: [lambda x : 1 + 79 * x**4]

Defines the kappa profiles across the transverse dimension of the PML for each dimension of the simulation. It must be expressed as a list of profiles (1 per dimension).

If a single profile is given, it will be used for all dimensions.

For a given dimension, the same profile is applied to both sides of the domain.

time_fields_frozen¶

Default

Time, at the beginning of the simulation, during which fields are frozen.

reference_angular_frequency_SI¶: The value of the reference angular frequency \(\omega_r\) in SI units, only needed when collisions, ionization, radiation losses or multiphoton Breit-Wheeler pair creation are requested. This frequency is related to the normalization length according to \(L_r\omega_r = c\) (see Units).

print_every¶: Number of timesteps between each info output on screen. By default, 10 outputs per simulation.

print_expected_disk_usage¶

Default: True

If False, the calculation of the expected disk usage, that is usually printed in the standard output, is skipped. This might be useful in rare cases where this calculation is costly.

random_seed¶

Default: 0

The value of the random seed. Each patch has its own random number generator, with a seed equal to random_seed + the index of the patch.

number_of_AM¶

Type: integer
Default: 2

The number of azimuthal modes used for the Fourier decomposition in "AMcylindrical" geometry. The modes range from mode 0 to mode "number_of_AM-1".

number_of_AM_classical_Poisson_solver¶

Default: 1

The number of azimuthal modes used for the field initialization with non relativistic Poisson solver in "AMcylindrical" geometry. Note that this number must be lower or equal to the number of modes of the simulation.

number_of_AM_relativistic_field_initialization¶

Default: 1

The number of azimuthal modes used for the relativistic field initialization in "AMcylindrical" geometry. Note that this number must be lower or equal to the number of modes of the simulation.

use_BTIS3_interpolation¶

Default: False

If True, the B-translated interpolation scheme 3 (or B-TIS3) described in PIC algorithms is used.

custom_oversize¶

Type: integer
Default: 2

The number of ghost-cell for each patches. The default value is set accordingly with the interpolation_order value.

Load Balancing¶

Load balancing (explained here) consists in exchanging patches (domains of the simulation box) between MPI processes to reduce the computational load imbalance. The block LoadBalancing is optional. If you do not define it, load balancing will occur every 150 iterations.

LoadBalancing(
    initial_balance = True,
    every = 150,
    cell_load = 1.,
    frozen_particle_load = 0.1
)

initial_balance¶

Default: True

Decides if the load must be balanced at initialization. If not, the same amount of patches will be attributed to each MPI rank.

every¶

Default: 150

Number of timesteps between each load balancing or a time selection. The value 0 suppresses all load balancing.

cell_load¶

Default

Computational load of a single grid cell considered by the dynamic load balancing algorithm. This load is normalized to the load of a single particle.

frozen_particle_load¶

Default: 0.1

Computational load of a single frozen particle considered by the dynamic load balancing algorithm. This load is normalized to the load of a single particle.

Multiple decomposition of the domain¶

The block MultipleDecomposition is necessary for spectral solvers and optional in all other cases. When present, it activates the Single-domain multiple decompositions (SDMD) technique which separates the decomposition of the field grids from that of the particles. Fields are set on large sub-domain called regions (1 region per MPI process) while particles are kept as small patches as in the standard decomposition (many patches per MPI process). Benefits of this option are illustrated in this paper.

MultipleDecomposition(
    region_ghost_cells = 2
)

region_ghost_cells¶

Type: integer
Default: 2

The number of ghost cells for each region. The default value is set accordingly with the interpolation_order. The same number of ghost cells is used in all dimensions except for spectral solver in AM geometry for which the number of radial ghost cells is always automatically set to be the same as patches.

Vectorization¶

The block Vectorization is optional. It controls the SIMD operations that can enhance the performance of some computations. The technique is detailed in Ref. [Beck2019] and summarized in this doc. It requires additional compilation options to be actived.

Vectorization(
    mode = "adaptive",
    reconfigure_every = 20,
    initial_mode = "on"
)

mode¶

Default: "off"

"off": non-vectorized operators are used. Recommended when the number of particles per cell stays below 10.
"on": vectorized operators are used. Recommended when the number of particles per cell stays above 10. Particles are sorted per cell.
"adaptive": the best operators (scalar or vectorized) are determined and configured dynamically and locally (per patch and per species). For the moment this mode is only supported in 3Dcartesian geometry. Particles are sorted per cell.

In the "adaptive" mode, cluster_width is set to the maximum.

reconfigure_every¶

Default: 20

The number of timesteps between each dynamic reconfiguration of the vectorized operators, when using the "adaptive" vectorization mode. It may be set to a time selection as well.

initial_mode¶

Default: off

Default state when the "adaptive" mode is activated and no particle is present in the patch.

Moving window¶

The simulated domain can move relatively to its the initial position. The “moving window” is (almost) periodically shifted in the x_max direction. Each “shift” consists in removing a column of patches from the x_min border and adding a new one after the x_max border, thus changing the physical domain that the simulation represents but keeping the same box size. This is particularly useful to follow waves or plasma moving at high speed. The frequency of the shifts is adjusted so that the average displacement velocity over many shifts matches the velocity given by the user. The user may ask for a given number of additional shifts at a given time. These additional shifts are not taken into account for the evaluation of the average velocity of the moving window.

The block MovingWindow is optional. The window does not move it you do not define it.

Warning

When the window starts moving, all laser injections via Silver-Muller boundary conditions are immediately stopped for physical correctness.

MovingWindow(
    time_start = 0.,
    velocity_x = 1.,
    number_of_additional_shifts = 0.,
    additional_shifts_time = 0.,
)

time_start¶

Type

Float.

Default

The time at which the window starts moving.

velocity_x¶

Type

Float.

Default

The average velocity of the moving window in the x_max direction. It muste be between 0 and 1.

number_of_additional_shifts¶

Type

Integer.

Default

The number of additional shifts of the moving window.

additional_shifts_time¶

Type

Float.

Default

The time at which the additional shifts are done.

Note

The particle binning diagnostics accept an “axis” called moving_x corresponding to the x coordinate corrected by the moving window’s current movement.

Current filtering¶

The present version of Smilei provides a multi-pass binomial filter on the current densities, which parameters are controlled in the following block:

CurrentFilter(
    model = "binomial",
    passes = [0],
    kernelFIR = [0.25,0.5,0.25]
)

model¶

Default: "binomial"

The model for current filtering.

"binomial" for a binomial filter.
"customFIR" for a custom FIR kernel.

passes¶

Type: A python list of integers.
Default: [0]

The number of passes (at each timestep) given for each dimension. If the list is of length 1, the same number of passes is assumed for all dimensions.

kernelFIR¶

Default: "[0.25,0.5,0.25]"

The FIR kernel for the "customFIR" model. The number of coefficients must be less than twice the number of ghost cells (adjusted using custom_oversize).

Field filtering¶

The present version of Smilei provides a method for field filtering (at the moment, only the Friedman electric field time-filter is available) which parameters are controlled in the following block:

FieldFilter(
    model = "Friedman",
    theta = 0.,
)

model¶

Default: "Friedman"

The model for field filtering. Presently, only "Friedman" field filtering is available.

theta¶

Default: 0.

The \(\theta\) parameter (between 0 and 1) of Friedman’s method.

Species¶

Each species has to be defined in a Species block:

Species(
    name      = "electrons1",
    position_initialization = "random",
    momentum_initialization = "maxwell-juettner",
    regular_number = [],
    particles_per_cell = 100,
    mass = 1.,
    atomic_number = None,
    #maximum_charge_state = None,
    number_density = 10.,
    # charge_density = None,
    charge = -1.,
    mean_velocity = [0.],
    #mean_velocity_AM = [0.],
    temperature = [1e-10],
    boundary_conditions = [
        ["reflective", "reflective"],
    #    ["periodic", "periodic"],
    #    ["periodic", "periodic"],
    ],
    # thermal_boundary_temperature = None,
    # thermal_boundary_velocity = None,
    time_frozen = 0.0,
    # ionization_model = "none",
    # ionization_electrons = None,
    # ionization_rate = None,
    is_test = False,
    pusher = "boris",

    # Radiation reaction, for particles only:
    radiation_model = "none",
    radiation_photon_species = "photon",
    radiation_photon_sampling = 1,
    radiation_photon_gamma_threshold = 2,
    radiation_max_emissions = 10,

    # Relativistic field initialization:
    relativistic_field_initialization = "False",

    # For photon species only:
    multiphoton_Breit_Wheeler = ["electron","positron"],
    multiphoton_Breit_Wheeler_sampling = [1,1]

    # Merging
    merging_method = "vranic_spherical",
    merge_every = 5,
    merge_min_particles_per_cell = 16,
    merge_max_packet_size = 4,
    merge_min_packet_size = 4,
    merge_momentum_cell_size = [16,16,16],
)

name¶: The name you want to give to this species. It should be more than one character and can not start with "m_".

position_initialization¶

The method for initialization of particle positions. Options are:

"regular" for regularly spaced. See regular_number.
"random" for randomly distributed.
"centered" for centered in each cell (not supported in AMcylindrical geometry.
The name of another species from which the positions are copied. The source species must have positions initialized using one of the three other options above, and must be defined before this species.
A numpy array or an HDF5 file defining all the positions of the particles. In this case you must also provide the weight of each particle (see Macro-particle weights). See Initialize particles from an array or a file.

regular_number¶

Type: A list of as many integers as the simulation dimension

When position_initialization = "regular", this sets the number of evenly-spaced particles per cell in each direction: [Nx, Ny, Nz] in cartesian geometries and [Nx, Nr, Ntheta] in AMcylindrical in which case we recommend Ntheta \(\geq 4\times (\) number_of_AM \(-1)\). If unset, particles_per_cell must be a power of the simulation dimension, for instance, a power of 2 in 2Dcartesian.

momentum_initialization¶

The method for initialization of particle momenta. Options are:

"maxwell-juettner" for a relativistic maxwellian (see how it is done)
"rectangular" for a rectangular distribution
"cold" for zero temperature
A numpy array or an HDF5 file defining all the momenta of the particles. See Initialize particles from an array or a file.

The first 2 distributions depend on the parameter temperature explained below.

particles_per_cell¶

Type: float or profile

The number of particles per cell.

mass¶: The mass of particles, in units of the electron mass \(m_e\).

atomic_number¶

Default: 0

The atomic number of the particles, required only for ionization. It must be lower than 101.

maximum_charge_state¶

Default: 0

The maximum charge state of a species for which the ionization model is "from_rate".

number_density¶

charge_density¶

Type: float or profile

The absolute value of the charge density or number density (choose one only) of the particle distribution, in units of the reference density \(N_r\) (see Units).

charge¶

Type: float or profile

The particle charge, in units of the elementary charge \(e\).

mean_velocity¶

Type: a list of 3 floats or profiles

The initial drift velocity of the particles, in units of the speed of light \(c\), in the x, y and z directions.

WARNING: For massless particles, this is actually the momentum in units of \(m_e c\).

mean_velocity_AM¶

Type: a list of 3 floats or profiles

The initial drift velocity of the particles, in units of the speed of light \(c\), in the longitudinal, radial and azimuthal directions. This entry is available only in AMcylindrical velocity and cannot be used if also mean_velocity is used in the same Species: only one of the two can be chosen.

WARNING: For massless particles, this is actually the momentum in units of \(m_e c\).

WARNING: The initial cylindrical drift velocity is applied to each particle, thus it can be computationally demanding.

temperature¶

Type: a list of 3 floats or profiles
Default: 1e-10

The initial temperature of the particles, in units of \(m_ec^2\).

boundary_conditions¶

Type: a list of lists of strings
Default: [["periodic"]]

The boundary conditions for the particles of this species. Each boundary may have one of the following conditions: "periodic", "reflective", "remove" (particles are deleted), "stop" (particle momenta are set to 0), and "thermalize". For photon species (mass=0), the last two options are not available.

Syntax 1: [[bc_all]], identical for all boundaries.
Syntax 2: [[bc_X], [bc_Y], ...], different depending on x, y or z.
Syntax 3: [[bc_Xmin, bc_Xmax], ...],  different on each boundary.

thermal_boundary_temperature¶

Default: None

A list of floats representing the temperature of the thermal boundaries (those set to "thermalize" in boundary_conditions) for each spatial coordinate. Currently, only the first coordinate (x) is taken into account.

thermal_boundary_velocity¶

Default: []

A list of floats representing the components of the particles’ drift velocity after encountering the thermal boundaries (those set to "thermalize" in boundary_conditions).

time_frozen¶

Default

The time during which the particles are “frozen”, in units of \(T_r\). Frozen particles do not move and therefore do not deposit any current density either. Nonetheless, they deposit a charge density. They are computationally much cheaper than non-frozen particles and oblivious to any EM-fields in the simulation. Note that frozen particles can be ionized (this is computationally much cheaper if ion motion is not relevant).

ionization_model¶

Default: "none"

The model for ionization:

"tunnel" for field ionization (requires species with an atomic_number)
"tunnel_envelope_averaged" for field ionization with a laser envelope
"from_rate", relying on a user-defined ionization rate (requires species with a maximum_charge_state).

ionization_rate¶

A python function giving the user-defined ionisation rate as a function of various particle attributes. To use this option, the numpy package must be available in your python installation. The function must have one argument, that you may call, for instance, particles. This object has several attributes x, y, z, px, py, pz, charge, weight and id. Each of these attributes are provided as numpy arrays where each cell corresponds to one particle.

The following example defines, for a species with maximum charge state of 2, an ionization rate that depends on the initial particle charge and linear in the x coordinate:

from numpy import exp, zeros_like

def my_rate(particles):
    rate = zeros_like(particles.x)
    charge_0 = (particles.charge==0)
    charge_1 = (particles.charge==1)
    rate[charge_0] = r0 * particles.x[charge_0]
    rate[charge_1] = r1 * particles.x[charge_1]
    return rate

Species( ..., ionization_rate = my_rate )

ionization_electrons¶: The name of the electron species that ionization_model uses when creating new electrons.

is_test¶

Default: False

Flag for test particles. If True, this species will contain only test particles which do not participate in the charge and currents.

pusher¶

Default: "boris"

Type of pusher to be used for this species. Options are:

"boris": The relativistic Boris pusher
"borisnr": The non-relativistic Boris pusher
"vay": The relativistic pusher of J. L. Vay
"higueracary": The relativistic pusher of A. V. Higuera and J. R. Cary
"norm": For photon species only (rectilinear propagation)
"ponderomotive_boris": modified relativistic Boris pusher for species interacting with the laser envelope model. Valid only if the species has non-zero mass
"borisBTIS3": as "boris", but using B fields interpolated with the B-TIS3 scheme.
"ponderomotive_borisBTIS3": as "ponderomotive_boris", but using B fields interpolated with the B-TIS3 scheme.

WARNING: "borisBTIS3" and "ponderomotive_borisBTIS3" can be used only when use_BTIS3_interpolation=True in the Main block.

radiation_model¶

Default: "none"

The radiation reaction model used for this species (see High-energy photon emission & radiation reaction).

"none": no radiation
"Landau-Lifshitz" (or ll): Landau-Lifshitz model approximated for high energies
"corrected-Landau-Lifshitz" (or cll): with quantum correction
"Niel": a stochastic radiation model based on the work of Niel et al..
"Monte-Carlo" (or mc): Monte-Carlo radiation model. This model can be configured to generate macro-photons with radiation_photon_species.