Merzbild.jl public API reference

Particle

A structure to store information about a single particle.

Fields

• w: the computational weight of the particle
• v: the 3-dimensional velocity vector of the particle
• x: the 3-dimensional position of the particle

ParticleVector

The structure used to store particles, sort and keep track of particle indices, and keep track of unused particles. The lengths of the particles, index, cell, and buffer vectors are all the same (and stay the same during resizing of a ParticleVector instance). Only the first nbuffer elements of the buffer vector store indices of the actually unused particles.

Accessing ParticleVector[i] will return a Particle, with the actual particle returned being ParticleVector.particles[ParticleVector.index[i]].

Fields

• particles: the vector of particles of a single species
• index: the vector of indices of the particles (these are sorted in grid sorting, not the particles themselves)
• cell: the vector storing information in which cell a particle is located (used in grid sorting routines)
• buffer: a last-in-first-out (LIFO) queue keeping track of pre-allocated but unused particles
• nbuffer: the number of elements in the buffer

ParticleVector(np)

Create an empty ParticleVector instance of length np (all vectors will have length np).

Positional arguments

• np: the length of the ParticleVector instance to create

Base.getindex(pv::ParticleVector, i)

Returns the underlying particle in a ParticleVector instance with index i.

Is usually called as ParticleVector[i].

Positional arguments

• pv: ParticleVector instance
• i: the index of the particle to be selected

Base.setindex!(pv::ParticleVector, p::Particle, i::Integer)

Set the underlying particle in a ParticleVector instance with index i to a new particle.

Is usually called as ParticleVector[i] = p.

Positional arguments

• pv: ParticleVector instance
• p: the Particle instance to write
• i: the index of the particle to be written to

Base.length(pv::ParticleVector)

Returns the length of a ParticleVector instance.

Is usually called as length(ParticleVector).

Positional arguments

• pv: ParticleVector instance

Base.resize!(pv::ParticleVector, n::Integer)

Resize a ParticleVector instance.

Is usually called as resize!(ParticleVector, n).

Positional arguments

• pv: ParticleVector instance
• n: the new length of the ParticleVector instance (i.e. the length of all the vector fields of the instance)

ParticleIndexer

The structure used to index particles of a given species in a given cell. It is assumed that the particle indices are contiguous; they may be split across two groups of contiguous indices.

Fields

• n_local: the number of particles in the cell
• start1: the first index in the first group of particle indices
• end1: the last index in the first group of particle indices
• n_group1: the number of particles in the first group (n_group1 = end1 - start1 + 1)
• start2: the first index in the second group of particle indices, if no particles are present in the group, it should be <= 0
• end2: the last index in the second group of particle indices
• n_group2: the number of particles in the second group (n_group2 = end2 - start2 + 1, unless no particles are present in the second group)

ParticleIndexer()

Create an empty ParticleIndexer. end1 and end2 are set to -1, the other fields are set to 0.

ParticleIndexer(n_particles)

Create a ParticleIndexer given a number of particles. All particles are in group 1, with indices starting from 1.

Positional arguments

• n_particles: the number of particles

ParticleIndexerArray

A structure to store an array of ParticleIndexer instances for each species in each cell. It also stores information about the whether the ParticleIndexer instances for each species are "contiguous". A set of ParticleIndexer instances (for a specific species) are "contiguous" if the following conditions are fulfilled (assuming all cells contain particles and in all cells have both n_group1>0 and n_group2>0, for a more detailed explanation, one is referred to the documentation on contiguous indexing):

• pia.indexer[cell,species].end1 + 1 == pia.indexer[cell+1,species].start1, cell = 1,...,n_cells - 1
• pia.indexer[n_cells,species].end1 + 1 == pia.indexer[1,species].start2
• pia.indexer[cell,species].end2 + 1 == pia.indexer[cell+1,species].start2, cell = 1,...,n_cells - 1

Fields

• indexer: the array of size (n_cells, n_species) (number of grid cells * number of species in the simulation) storing the ParticleIndexer instances
• n_total: vector of length n_species storing the total number of particles of each species
• contiguous: vector of length n_species storing a boolean flag whether the ParticleIndexer instances for a species are "contiguous"

ParticleIndexerArray(indexer_arr::Array{ParticleIndexer,2}, n_total)

Creates a ParticleIndexerArray from a 2-D array of ParticleIndexer instances.

Positional arguments

• indexer_arr: the 2-D array of ParticleIndexer instances
• n_total: the vector of the total number of particles of each species

ParticleIndexerArray(n_cells::Integer, n_species::Integer)

Create an empty ParticleIndexerArray given the number of cells and species

Positional arguments

• n_cells: the number of grid cells
• n_species: the number of species

ParticleIndexerArray(n_particles::Integer)

Create a single-species/single-cell ParticleIndexerArray.

Positional arguments

• n_particles: the number of particles (integer number)

ParticleIndexerArray(n_particles::T) where T<:AbstractVector

Create a multi-species/single-cell ParticleIndexerArray.

Positional arguments

• n_particles: the number of particles of each species (vector-like)

ParticleIndexerArray(grid, species_data::Array{Species}) where T<:AbstractVector

Create an empty multi-species/multi-cell ParticleIndexerArray.

Positional arguments

• grid: the simulation grid
• species_data: array of Species data for all of the species in the simulation

Species

A structure to store information about a chemical species.

Fields

• name: the name of the species
• mass: the molecular mass of the species
• charge: the charge of the species in terms of elementary charge (i.e. 1, -1, etc.)
• charge_div_mass: the charge of the species divided by its mass, C/kg

Interaction

Structure to store interaction parameters for a 2-species interaction. The VHS model uses the following power law: $\sigma_{VHS} = C g^(1 - 2 \omega_{VHS})$, where $omega$ is the exponent of the VHS potential, and $C$ is the pre-computed factor: $C = \pi D_{VHS}^2 (2 T_{ref,VHS}/m_r)^{(\omega_{VHS} - 0.5)} \frac{1}{\Gamma(2.5 - \omega_{VHS})}$.

Fields

• m_r: collision-reduced mass
• μ1: relative mass of the first species
• μ2: relative mass of the second species
• vhs_d: diameter for the VHS potential
• vhs_o: exponent for the VHS potential
• vhs_Tref: reference temperature for the VHS potential
• vhs_muref: reference viscosity for the VHS potential
• vhs_factor: pre-computed factor for calculation of the VHS cross-section

load_species_data(species_filename, species_names)

Load a vector of species data (mass, charge, etc.) from a TOML file.

Positional arguments

• species_filename: the path to the TOML file containing the data
• species_names: a list of the names of the species for which to load the data

load_species_data(species_filename, species_name::String)

Load a vector of species data (mass, charge, etc.) from a TOML file for a single species.

Positional arguments

• species_filename: the path to the TOML file containing the data
• species_name: the name of the species for which to load the data

load_interaction_data(interactions_filename, species_data)

Load interaction data from a TOML file given a list of species' data (list of Species instances). It will load interaction data for all possible pair-wise interactions of the species in the list.

The resulting 2-D array has the interaction data for Species[i] with Species[k] in position [i,k]. It is not symmetric, as the relative collision masses μ1 and μ2 are swapped when comparing the Interaction instances in positions [i,k] and [k,i]. If no data is found, the function throws an error.

Positional arguments

• interactions_filename: the path to the TOML file containing the data
• species_data: list of Species instances for which to search for the interaction data

Returns

• 2-dimensional array of Interaction instances of size (n_species, n_species)

load_interaction_data(interactions_filename, species_data)

Load interaction data from a TOML file given a list of species' data (list of Species instances), filling in dummy VHS data in case no entry is found in the TOML file. Useful for interactions where the VHS model doesn't make sense, for example electron-neutral interactions.

It will load interaction data for all possible pair-wise interactions of the species in the list. The resulting 2-D array has the interaction data for Species[i] with Species[k] in position [i,k]. It is not symmetric, as the relative collision masses μ1 and μ2 are swapped when comparing the Interaction instances in positions [i,k] and [k,i].

Positional arguments

• interactions_filename: the path to the TOML file containing the data
• species_data: list of Species instances for which to search for the interaction data
• dummy_vhs_d: value to use for the VHS diameter if no interaction data found in the file
• dummy_vhs_o: value to use for the VHS exponent if no interaction data found in the file
• dummy_vhs_Tref: value to use for the VHS reference temperature if no interaction data found in the file

Returns

• 2-dimensional array of Interaction instances of size (n_species, n_species)

load_interaction_data_with_dummy(interactions_filename, species_data)

Load interaction data from a TOML file given a list of species' data (list of Species instances), filling in dummy VHS data in case no entry is found in the TOML file. Useful for interactions where the VHS model doesn't make sense, for example electron-neutral interactions. Uses a value of 1e-10 for the dummy VHS diameter, 1.0 for the dummy VHS exponent, and 273.0 for the dummy VHS reference temperature.

It will load interaction data for all possible pair-wise interactions of the species in the list. The resulting 2-D array has the interaction data for Species[i] with Species[k] in position [i,k]. It is not symmetric, as the relative collision masses μ1 and μ2 are swapped when comparing the Interaction instances in positions [i,k] and [k,i].

Positional arguments

• interactions_filename: the path to the TOML file containing the data
• species_data: list of Species instances for which to search for the interaction data

Returns

• 2-dimensional array of Interaction instances of size (n_species, n_species)

load_species_and_interaction_data(species_filename, interactions_filename, species_names; fill_dummy=true)

Given a list of species' names, load the species and interaction data (filling with dummy data if needed).

Positional arguments

• species_filename: the path to the TOML file containing the species' data
• interactions_filename: the path to the TOML file containing the interaction data
• species_name: the name of the species for which to load the data

Keyword arguments

• fill_dummy: if true, fill interaction data with computed dummy values if no entry found for a species pair in the interaction file

Returns

• Vector of Species instances
• 2-dimensional array of Interaction instances of size (n_species, n_species)

load_electron_neutral_interactions(species_data, filename, databases, scattering_laws, energy_splits)

Load electron-neutral interaction data from an LXCAT format XML file for a set of given neutral species.

Positional arguments

• species_data: vector of Species data for the neutral species
• filename: path to XML file
• databases: dictionary of (species.name => database) pairs, specifying the name

of the cross-section database in the XML file to use for the species

• scattering_laws: vector of ScatteringLaw instances to use for each species
• energy_splits: vector of ElectronEnergySplit instances to use for each species

Returns

ElectronNeutralInteractions structure containing the electron-neutral interaction data.

Throws

DataMissingException if data not found or not all required data present.

maxwellian(vx, vy, vz, m, T)

Evaluate the Maxwell distribution with temperature T for a species with mass m at a velocity (vx, vy, vz)

Positional arguments

• vx: x velocity
• vy: y velocity
• vz: z velocity
• m: species' mass
• T: temperature

bkw(vx, vy, vz, m, T, scaled_time)

Evaluate the Bobylev-Krook-Wu (BKW) distribution with temperature T for a species with mass m at a velocity (vx, vy, vz) and scaled time scaled_time

Positional arguments

• vx: x velocity
• vy: y velocity
• vz: z velocity
• m: species' mass
• T: temperature
• scaled_time: the scaled_time

sample_on_grid!(rng, vdf_func, particles, nv, m, T, n_total,
                xlo, xhi, ylo, yhi, zlo, zhi; v_mult=3.5, cutoff_mult=3.5, noise=0.0,
                v_offset=[0.0, 0.0, 0.0])

Sample particles by evaluating a distribution on a discrete velocity grid, considering only points inside a sphere of a given radius (the value of the VDF at points outside of the sphere will be 0.0). The values of the VDF at the grid points will then be the computational weights of the particles, and the particles velocities are taken to be the velocities of the corresponding grid nodes (with additional uniformly distributed noise). Note: this can produce a large amount of particles for fine grids (as the number of grid nodes scales as nv^3.) The grid is assumed to have the same number of nodes nv in each direction, and the extent is computed as v_mult * v_thermal, where v_thermal is the thermal velocity $\sqrt(2kT/m)$, and v_mult is a user-defined parameter. The positions of the particles are assumed to be randomly distributed in a cuboid.

Positional arguments

• rng: The random number generator
• vdf_func: the distribution function to be evaluated which takes the x, y, and z velocities as parameters
• particles: the Vector-like structure holding the particles
• nv: the number of grid nodes in each direction
• m: the molecular mass of the species
• T: the temperature used to compute the thermal velocity
• n_total: the total computational weight (number of physical particles) to be sampled
• xlo: the lower bound of the x coordinates of the particles
• xhi: the upper bound of the x coordinates of the particles
• ylo: the lower bound of the y coordinates of the particles
• yhi: the upper bound of the y coordinates of the particles
• zlo: the lower bound of the z coordinates of the particles
• zhi: the upper bound of the z coordinates of the particles

Keyword arguments

• v_mult: the value by which the thermal velocity is multiplied to compute the extent of the velocity grid
• cutoff_mult: the value by which the thermal velocity is multiplied to compute the radius for the sphere used to cut-off the higher velocities
• noise: controls the amount of noise added to the particle velocities (the noise is uniformly distributed on the interval [-noise*dv, noise*dv], where dv is the grid spacing)
• v_offset: the streaming velocity vector to be added to the particle velocities

Returns

• The number of particles created

sample_maxwellian_on_grid!(rng, particles, nv, m, T, n_total,
                           xlo, xhi, ylo, yhi, zlo, zhi; v_mult=3.5, cutoff_mult=3.5, noise=0.0,
                           v_offset=[0.0, 0.0, 0.0])

Sample particles by evaluating a Maxwellian on a discrete velocity grid, considering only points inside a sphere of a given radius (the value of the VDF at points outside of the sphere will be 0.0). The values of the VDF at the grid points will then be the computational weights of the particles, and the particles velocities are taken to be the velocities of the corresponding grid nodes (with additional uniformly distributed noise). Note: this can produce a large amount of particles for fine grids (as the number of grid nodes scales as nv^3.) The grid is assumed to have the same number of nodes nv in each direction, and the extent is computed as v_mult * v_thermal, where v_thermal is the thermal velocity $\sqrt(2kT/m)$, and v_mult is a user-defined parameter. The positions of the particles are assumed to be randomly distributed in a cuboid.

Positional arguments

• rng: The random number generator
• particles: the Vector-like structure holding the particles
• nv: the number of grid nodes in each direction
• m: the molecular mass of the species
• T: the temperature used to compute the thermal velocity
• n_total: the total computational weight (number of physical particles) to be sampled
• xlo: the lower bound of the x coordinates of the particles
• xhi: the upper bound of the x coordinates of the particles
• ylo: the lower bound of the y coordinates of the particles
• yhi: the upper bound of the y coordinates of the particles
• zlo: the lower bound of the z coordinates of the particles
• zhi: the upper bound of the z coordinates of the particles

Keyword arguments

• v_mult: the value by which the thermal velocity is multiplied to compute the extent of the velocity grid
• cutoff_mult: the value by which the thermal velocity is multiplied to compute the radius for the sphere used to cut-off the higher velocities
• noise: controls the amount of noise added to the particle velocities (the noise is uniformly distributed on the interval [-noise*dv, noise*dv], where dv is the grid spacing)
• v_offset: the streaming velocity vector to be added to the particle velocities

Returns

The function returns the number of particles created

sample_particles_equal_weight!(rng, particles, pia, cell, species,
                                    nparticles, m, T, Fnum, xlo, xhi, ylo, yhi, zlo, zhi;
                                    distribution=:Maxwellian, vx0=0.0, vy0=0.0, vz0=0.0)

Sample equal-weight particles of a specific species in a specific cell from a distribution. The positions of the particles are assumed to be randomly distributed in a cuboid. Note: this does not work if applied twice in a row to the same cell

Positional arguments

• rng: the random number generator
• particles: the Vector-like structure holding the particles
• pia: the ParticleIndexerArray
• cell: the cell index
• species: the species index
• nparticles: the number of particles to sample
• m: species' mass
• T: temperature
• Fnum: the computational weight of the particles
• xlo: the lower bound of the x coordinates of the particles
• xhi: the upper bound of the x coordinates of the particles
• ylo: the lower bound of the y coordinates of the particles
• yhi: the upper bound of the y coordinates of the particles
• zlo: the lower bound of the z coordinates of the particles
• zhi: the upper bound of the z coordinates of the particles

Keyword arguments

• distribution: the distribution to sample from (either :Maxwellian or :BKW)
• vx0: the x-velocity offset to add to the particle velocities
• vy0: the y-velocity offset to add to the particle velocities
• vz0: the z-velocity offset to add to the particle velocities

sample_particles_equal_weight!(rng, grid1duniform, particles, pia, species, species_data, ppc::Integer, T, Fnum)

Sample particles from a Maxwellian distribution in each cell of 1-D uniform grid given the number of particles per cell

Positional arguments

• rng: the random number generator
• grid1duniform: the 1-D uniform grid
• particles: the ParticleVector of particles
• pia: the ParticleIndexerArray
• species: the index of the species to be sampled for
• species_data: Vector of Species data
• ppc: number of particles per cell to be sampled
• T: the temperature
• Fnum: the computational weight of the particles

sample_particles_equal_weight!(rng, grid1duniform, particles, pia, species, species_data, ndens::Float64, T, Fnum)

Sample particles from a Maxwellian distribution in each cell of 1-D uniform grid given the target number density. If the computed number of particles is not an integer value, the fractional remainder is used to probabilistically sample an extra particle, so that on average, the expected number density is achieved.

Positional arguments

• rng: the random number generator
• grid1duniform: the 1-D uniform grid
• particles: the ParticleVector of particles
• pia: the ParticleIndexerArray
• species: the index of the species to be sampled for
• species_data: Vector of Species data
• ndens: target number density
• T: the temperature
• Fnum: the computational weight of the particles

PhysProps

Structure to store computed physical properties in a physical cell.

Fields

• ndens_not_Np: whether the n field stores number density and not the number of physical particles in a cell
• n_cells: number of physical cells
• n_species: number of species
• n_moments: number of total moments computed
• lpa: length of the particle array (vector of length n_species)
• np: number of particles (array of shape (n_cells, n_species))
• n: number density or number of physical particles in a cell (array of shape (n_cells, n_species))
• v: per-species flow velocity in a cell (array of shape (3, n_cells, n_species))
• T: per-species temperature in a cell (array of shape (n_cells, n_species))
• moment_powers: powers of the total moments computed (vector of length n_moments)
• moments: values of the total moments computed (array of shape (n_moments, n_cells, n_species))
• Tref: reference temperature used to scale moments

PhysProps(n_cells, n_species, moments_list; Tref=300.0)

Construct physical properties given the number of cells and species, as well as the list of the orders of total moments to compute. The total moment of order $M$ is defined as $\int \sqrt{v_x^2+v_y^2+v_z^2}^M f(v_x,v_y,v_z)dv_x dv_y dv_z$.

Positional arguments

• n_cells: number of cells
• n_species: number of species

Keyword arguments

• Tref: reference temperature used to compute the total moments of a Maxwellian distribution which are used to scale the total moments

PhysProps(pia, moments_list; Tref=300.0)

Construct physical properties given a ParticleIndexerArray instance, as well as the list of the orders of total moments to compute. The total moment of order $M$ is defined as $\int \sqrt{v_x^2+v_y^2+v_z^2}^M f(v_x,v_y,v_z)dv_x dv_y dv_z$.

Positional arguments

• pia: the ParticleIndexerArray instance
• n_species: number of species

Keyword arguments

• Tref: reference temperature used to compute the total moments of a Maxwellian distribution which are used to scale the total moments

PhysProps(pia)

Construct physical properties given a ParticleIndexerArray instance, with no computation of the total moments.

Positional arguments

• pia: the ParticleIndexerArray instance

compute_props!(particles, pia, species_data, phys_props)

Compute the physical properties of all species in all cells and store the result in a PhysProps instance. This function does not compute the total moments, even if phys_props.n_moments > 0.

Positional arguments

• particles: the Vector of ParticleVectors containing all the particles in a simulation
• pia: the ParticleIndexerArray instance
• species_data: the Vector of SpeciesData
• phys_props: the PhysProps instance in which the computed physical properties are stored

compute_props_with_total_moments!(particles, pia, species_data, phys_props)

Compute the physical properties of all species in all cells and store the result in a PhysProps instance. This function computes the total moments.

Positional arguments

• particles: the Vector of ParticleVectors containing all the particles in a simulation
• pia: the ParticleIndexerArray instance
• species_data: the Vector of SpeciesData
• phys_props: the PhysProps instance in which the computed physical properties are stored

compute_props!(particles, pia, species_data, phys_props)

Compute the physical properties of all species in all cells and store the result in a PhysProps instance, assuming the particles are sorted. This function does not compute the total moments, even if phys_props.n_moments > 0.

Positional arguments

• particles: the Vector of ParticleVectors containing all the particles in a simulation
• pia: the ParticleIndexerArray instance
• species_data: the Vector of SpeciesData
• phys_props: the PhysProps instance in which the computed physical properties are stored

avg_props!(phys_props_avg, phys_props, n_avg_timesteps)

Used to time-average computed physical properties, not including the total moments. For each instantaneous value of a property computed and stored in phys_props, it is divided by n_avg_timesteps and added to phys_props_avg.

Positional arguments

• phys_props_avg: the PhysProps instance used to store the time-averaged properties
• phys_props: the PhysProps instance holding the current values of the properties to be used for the averaging at the current timestep
• n_avg_timesteps: the number of timesteps over which the averaging is performed

clear_props!(phys_props)

Clear all data from PhysProps, for use when physical properties are averaged over timesteps and averaging over a new set of timesteps needs to be started.

Positional arguments

• phys_props: the PhysProps instance to be cleared

CollisionData

Structure to store temporary collision data for a specific collision (relative velocity, collision energy, post-collision velocities, etc.)

Fields

• v_com: vector of center-of-mass velocity
• g: magnitude of relative velocity
• E_coll: relative translational energy of the colliding particles
• E_coll_eV: relative translational energy of the colliding particles in electron-volt
• E_coll_electron_eV: collisional energy of the an electron in electron-volt for electron-neutral collisions
• g_vec: vector of pre-collisional relative velocity
• g_vec_new: vector of post-collisional relative velocity
• g_new_1: magnitude of post-collisional relative velocity of the first particle in the collision pair
• g_new_2: magnitude of post-collisional relative velocity of the second particle in the collision pair

CollisionData()

Create an empty CollisionData instance.

CollisionFactors

Structure to store NTC-related collision factors for collisions between particles of two species in a given cell.

Fields

• n1: the number of particles of the first species in the cell
• n2: the number of particles of the second species in the cell
• sigma_g_w_max: estimate of the $(\sigma g w)_{max}$ ($\sigma$ is the total collision cross-section, $g$ is the relative collision velocity, $w$ is the computational weight of the particles)
• n_coll: number of collisions to be tested
• n_coll_performed: number of collisions actually performed
• n_eq_w_coll_performed: number of collisions between particles with equal weights actually performed

CollisionFactors()

Create an empty CollisionFactors instance (all values set to 0).

CollisionData

Structure to store temporary collision data for the particle Fokker-Planck approach.

Fields

• vel_ave: average velocity of the particles in the cell
• mean: mean value of the sampled velocities
• stddev: standard deviation of the sampled velocities

CollisionDataFP()

Create an empty CollisionDataFP instance.

create_collision_factors_array(n_species)

Create a 3-dimensional array of collision factors for all interaction pairs for a 0-D case (1 spatial cell), with shape (n_species,n_species,1).

Positional arguments

• n_species: number of species in the flow

Returns

3-dimensional array of CollisionFactors instances with shape (n_species,n_species,1).

create_collision_factors_array(n_species, n_cells)

Create a 3-dimensional array of collision factors for all interaction pairs for all cells in the simulation, with shape (n_species,n_species,n_cells).

Positional arguments

• n_species: number of species in the flow
• n_cells: number of cells in the simulation

Returns

3-dimensional array of CollisionFactors instances with shape (n_species,n_species,n_cells).

create_computed_crosssections(electron_neutral_interactions)

Create a vector of ComputedCrossSection instances for the electron-neutral interactions.

Positional arguments

• electron_neutral_interactions: the ElectronNeutralInteractions instance for which the cross-sections will be computed

Returns

Vector of ComputedCrossSection of length electron_neutral_interactions.n_neutrals.

estimate_sigma_g_w_max(interaction, species1, species2, T1, T2, Fnum; mult_factor=1.0)

Estimate $(\sigma g w)_{max}$ for a two-species interaction, assuming a constant particle computational weight Fnum and a VHS cross-section. The relative velocity $g$ is estimated as $g = 0.5 (\sqrt{2T_1 k_B / m_1} + \sqrt{2T_2 k_B / m_2})$, where $T_1$ and $m_1$ are the temperature and mass of the first species (species1), and $T_2$ and $m_2$ are the temperature and mass of the second species (species2). This relative velocity estimate is then plugged into the VHS cross-section model to compute $\sigma$. The result is then multiplied by Fnum and an (optional) factor mult_factor.

Positional arguments

• interaction: the Interaction instance for the interacting species
• species1: the Species instance of the first interacting species
• species2: the Species instance of the second interacting species
• T1: the temperature of the first interacting species
• T2: the temperature of the second interacting species
• Fnum: the constant computational weight of the particles

Keyword arguments

• mult_factor: a factor by which to multiply the result (default value is 1.0)

Returns

• the estimate of $(\sigma g w)_{max}$

estimate_sigma_g_w_max(interaction, species, T, Fnum; mult_factor=1.0)

Estimate $(\sigma g w)_{max}$ for a single-species interaction, assuming a constant particle computational weight Fnum and a VHS cross-section. Uses the same methodology as the estimate for a two-species interaction.

Positional arguments

• interaction: the Interaction instance for the interacting species
• species: the Species instance of the interacting species
• T: the temperature of the interacting species
• Fnum: the constant computational weight of the particles

Keyword arguments

• mult_factor: a factor by which to multiply the result (default value is 1.0)

Returns

• the estimate of $(\sigma g w)_{max}$

estimate_sigma_g_w_max!(collision_factors, interactions, species_data, T_list, Fnum; mult_factor=1.0)

Estimate $(\sigma g w)_{max}$ for all species in all cells, assuming a constant particle computational weight Fnum, a VHS cross-section, and that each species' temperature is constant across all cells. Uses the same methodology as the estimate for a two-species interaction.

Positional arguments

• collision_factors: 3-dimensional array of CollisionFactors of shape (n_species, n_species, n_cells)
• interactions: the 2-dimensional array of Interaction instances (of shape (n_species, n_species)) of all the pair-wise interactions
• species_data: the vectors Species instances of the species in the flow
• T_list: the list of temperatures of the species
• Fnum: the constant computational weight of the particles

Keyword arguments

• mult_factor: a factor by which to multiply the result (default value is 1.0)

Estimate $(\sigma g w)_{max}$ for an electron-neutral interaction by stochastically choosing particle pairs

ntc!(rng, collision_factors, collision_data, interaction, particles, pia,
     cell, species, Δt, V)

Perform elastic collisions between particles of same species using the NTC algorithm and the VHS cross-section model.

Positional arguments

• rng: the random number generator
• collision_factors: the CollisionFactors for the species in question in the cell
• collision_data: CollisionData instance used for storing collisional quantities
• interaction: 2-dimensional array of Interaction instances for all possible species pairs
• particles: ParticleVector of the particles being collided
• pia: the ParticleIndexerArray
• cell: the index of the cell in which collisions are performed
• species: the index of the species for which collisions are performed
• Δt: timestep
• V: cell volume

ntc!(rng, collision_factors, collision_data, interaction,
     particles_1, particles_2, pia,
     cell, species1, species2, Δt, V)

Perform elastic collisions between particles of different species using the NTC algorithm and the VHS cross-section model.

Positional arguments

• rng: the random number generator
• collision_factors: the CollisionFactors for the species in question in the cell
• collision_data: CollisionData instance used for storing collisional quantities
• interaction: 2-dimensional array of Interaction instances for all possible species pairs
• particles_1: ParticleVector of the particles of the first species being collided
• particles_2: ParticleVector of the particles of the second species being collided
• pia: the ParticleIndexerArray
• cell: the index of the cell in which collisions are performed
• species1: the index of the first species for which collisions are performed
• species1: the index of the second species for which collisions are performed
• Δt: timestep
• V: cell volume

Perform elastic scattering and ionizing collisions for electron-neutral interactions

Perform elastic scattering and ionizing collisions for electron-neutral interactions using the event splitting approach of Oblapenko et al. (2022)

Model single-species elastic collisions using a linear Fokker-Planck approximation

ElectronNeutralInteractions

Structure to hold data on electron-neutral interactions. The neutral_indexer field is used to obtain the index of the species inside the structure, given an index of the neutral species in the full list of species in the simulation. For example, if we have a following list of species in the simulation: [e-, He, Ar+, He+, Ar], n_neutrals=2, the ElectronNeutralInteractions instance stores data for interactions of electrons with [He, Ar], and neutral_indexer[2] = 1, neutral_indexer[5] = 2.

Fields

• n_neutrals: number of neutral species for which the data has been loaded
• neutral_indexer: array that maps indices of neutral species in the full list of species to local indices in the ElectronNeutralInteractions structure
• elastic: an array of ElasticScattering instances (of length n_neutrals) holding the cross-section data on elastic scattering for each neutral species
• ionization: an array of Ionization instances (of length n_neutrals) holding the cross-section data on electron-impact ionization for each neutral species
• excitation_sink: an array of ExcitationSink instances (of length n_neutrals) holding the cross-section data on electron-impact electronic excitation for each neutral species

ComputedCrossSections

Structure to hold data on computed cross-sections of electron-neutral interactions for a specific neutral species.

Fields

• n_excitations: number of electron-impact excitation reactions
• cs_total: the computed total cross-section (sum of cross-sections of all processes)
• cs_elastic: the computed elastic scattering cross-section
• cs_ionization: the computed electron-impact ionization cross-section
• cs_excitation: the computed electron-impact electronic excitation cross-section
• prob_vec: a vector of probabilities of the processes (of length 2+n_excitations). prob_vec[1] is the probability of elastic scattering, prob_vec[2] is the probability of electron-impact ionization, prob_vec[3:2+n_excitations] are the probabilities of th
• cdf_prob_vec: a vector of cumulative probabilities of the processes (of length 3+n_excitations), used for sampling a specific process: cfd_prob_vec[1] = 0.0, cfd_prob_vec[n] = cfd_prob_vec[n-1] + prob_vec[n-1], n>1

ElectronEnergySplit ElectronEnergySplitEqual=1 ElectronEnergySplitZeroE=2

Enum for various splittings of electron energy in electron-impact ionization reactions. ElectronEnergySplitEqual corresponds to energy being shared equally amongst the electrons, ElectronEnergySplitZeroE corresponds to the one-takes-all sharing model.

ScatteringLaw ScatteringIsotropic=1 ScatteringOkhrimovskyy=2

Enum for various scattering laws in electron-neutral interactions. ScatteringIsotropic corresponds to isotropic scattering, ScatteringOkhrimovskyy to the scattering model of A. Okhrimovskyy et al., 2002.

Struct for merging on a velocity grid

Fields

• Nx: number of cells

GridN2Merge(Nx::Int, Ny::Int, Nz::Int, extent_multiplier::T) where T <: AbstractArray

Create velocity grid-based merging

Positional arguments

• Nx: number of cells in vx direction
• Ny: number of cells in vy direction

GridN2Merge(N::Int, extent_multiplier::T) where T <: AbstractArray

Create velocity grid-based merging with equal number of cells in each direction

GridN2Merge(Nx::Int, Ny::Int, Nz::Int, extent_multiplier::Float64)

Create velocity grid-based merging with single multiplier

GridN2Merge(Nx::Int, Ny::Int, Nz::Int,
            extent_multiplier_x::Float64,
            extent_multiplier_y::Float64,
            extent_multiplier_z::Float64)

Create velocity grid-based merging

GridN2Merge(N::Int, extent_multiplier::Float64)

Create velocity grid-based merging with equal number of cells in each direction, single multiplier

Merge particles using a velocity grid-based merging approach

Struct for keeping track of merging-related quantities for NNLS merging

NNLSMerge(multi_index_moments, init_np; rate_preserving=false)

Create NNLS-based merging

Positional arguments

• multi_index_moments: vector of mixed moments to preserve, [(i1, j1, k1), (i2, j2, k2), ...] Mass/momentum/directionalenergy are always conserved! (Added automatically if not in list)
• init_np: initial number of particles to pre-allocated memory for

Keyword arguments:

• rate_preserving: used for rate-preserving merging of electrons, preserves approximate elastic collision and ionization rates

Compute all mixed moments of total order up to n

Perform NNLS-based merging

Perform NNLS-based merging, rate-preserving version

OctreeBinSplit OctreeBinMidSplit=1 OctreeBinMeanSplit=2 OctreeBinMedianSplit=3

Enum for octree bin splitting types

OctreeInitBin OctreeInitBinMinMaxVel=1 OctreeInitBinMinMaxVelSym=2 OctreeInitBinC=3

Enum for initial bin bounds

OctreeBinBounds OctreeBinBoundsInherit=1 OctreeBinBoundsRecompute=2

Computation of bounds of split bin

Struct for N:2 Octree merging

OctreeN2Merge(split::OctreeBinSplit; init_bin_bounds=OctreeInitBinMinMaxVel, bin_bounds_compute=OctreeBinBoundsInherit,
          max_Nbins=4096, max_depth=10)

Create Octree N:2 merging

Grid1DUniform

1-D Uniform grid for a domain $[0,L]$

Fields

• L: length of the domain
• nx: number of cells
• Δx: cell size
• inv_Δx: inverse of cell size
• cells: Vector of Cell1D elements
• min_x: minimum allowed x coordinate for particles (slightly larger than $0$)
• max_x: maximum allowed x coordinate for particles (slightly smaller than $L$)

Grid1DUniform(L, nx; wall_offset=1e-12)

Create 1-D uniform grid for a domain $[0, L]$ with nx cells

Positional arguments

• L: length of the domain
• nx: number of cells

Keyword arguments

• wall_offset: specifies a small relative offset from the walls so that particles never end up with a coordinate of exactly $0$ or $L$, otherwise some sorting routines may produce cell indices outside of the 1:nx range. The offset is computed as Δx * wall_offset, where Δx is the cell size.

GridSortInPlace

Struct for in-place sorting of particles.

Fields

• cell_counts: vector to store the number of particles in each cell + number of particles in all previous cells
• sorted_indices: vector to store sorted particle indices
• non_contiguous_indices: vector to store non-contiguous indices of the particles used in sorting in a contiguous array, in case the indices pointed to by a ParticleIndexerArray are not contiguous

GridSortInPlace(grid, n_particles::Integer)

Create a GridSortInPlace instance given a grid and number of particles.

Positional arguments

• grid: the grid on which to sort the particles
• n_particles: the (expected) number of particles in the simulation (to pre-allocate the sorted_indices vector) - it is recommended to set this to the maximum expected number of particles in the simulation to avoid resizing of arrays during a simulation

sort_particles!(gridsort::GridSortInPlace, grid, particles, pia, species)

Sort particles on a grid using an in-place sorting algorithm. The pia instance is allowed to have non-contiguous indices (arising for example from merging).

Positional arguments

• gridsort: the GridSortInPlace structure
• grid: the grid (should have an n_cells field, and a get_cell function has to be defined for the grid type)
• particles: the ParticleVector of particles to be sorted
• pia: the ParticleIndexerArray instance
• species: the index of the species being sorted

convect_particles!(rng, grid::Grid1DUniform, boundaries::MaxwellWalls1D, particles, pia, species, species_data, Δt)

Convect particles on a 1-D uniform grid.

Positional arguments

• rng: the random number generator
• grid: the grid on which the convection is performed
• boundaries: the MaxwellWalls1D struct describing the boundaries (it is assumed that the wall with index 1 is the left wall and the wall with index 2 is the right wall)
• particles: the ParticleVector of particles to be convected
• pia: the ParticleIndexerArray instance
• species: the index of the species being convected
• species_data: the vector of Species data
• Δt: the convection timestep

MaxwellWallBC

A struct to hold information about a diffuse reflecting wall.

Fields

• T: temperature
• v: wall velocity vector
• accommodation: accommodation coefficient (a value of 0 corresponds to specular reflection, a value of 1 corresponds to purely diffuse reflection)

MaxwellWalls1D

A struct to hold information about all diffuse reflecting walls in the simulation.

Fields

• boundaries: a vector of MaxwellWallBC walls
• reflection_velocities_sq: array of pre-computed squared thermal reflection velocities (nwalls x nspecies)

MaxwellWalls1D(species_data, T_l::Float64, T_r::Float64, vy_l::Float64, vy_r::Float64, accomodation_l::Float64, accomodation_r::Float64)

Create a MaxwellWalls1D struct for a 1-D simulation with 2 walls ("left" and "right") with a velocity in the y-direction only.

Positional arguments

• species_data: vector of Species data
• T_l: temperature of left wall
• T_r: temperature of right wall
• vy_l: y-velocity of left wall
• vy_r: y-velocity of right wall
• accomodation_l: accommodation coefficient of left wall
• accomodation_r: accommodation coefficient of right wall

write_grid(nc_filename, grid::Grid1DUniform; global_attributes=Dict{Any,Any}())

Write grid info to a NetCDF file

Positional arguments

• nc_filename: path to the NetCDF file
• grid: the grid to be written out to a file

Keyword arguments

• global_attributes: dictionary of additional global attributes to be written to the netCDF file

Struct that holds track of which variables are not to be written to NetCDF file

IOSkipList(list_of_variables_to_skip)

Construct an IOSkipList from a list of variable names

IOSkipList()

Construct an empty IOSkipList

Struct that holds NetCDF-output related data

NCDataHolder(nc_filename, names_skip_list, species_data, phys_props; global_attributes=Dict{Any,Any}())

Construct a NCDataHolder instance

NCDataHolder(nc_filename, species_data, phys_props; global_attributes=Dict{Any,Any}())

Construct a NCDataHolder instance with an empty list of variable to skip

Close NetCDF file

Write PhysProps to NetCDF file

accelerate_constant_field_x!(particles, pia, cell, species, species_data, E, Δt)

Accelerate particles with a constant electric field in the X direction

Positional arguments

• particles: vector-like structure of particles to be accelerated
• pia: ParticleIndexerArray instance
• cell: index of the cell in which particles are being accelerated
• species: index of the species of the particles being accelerated
• species_data: a Vector{Species} instance with the species' data
• E: value of the electric field in V/m
• Δt: timestep for which the acceleration is performed

Boltzmann constant, J/K

DataMissingException

Exception for the case of missing tabulated cross-section data

Fields

• msg: error message