Merzbild.jl internal API reference

map_cont_index(particle_indexer, i)

Maps a continuous index in the range [0, n_local-1] to an index in the particle array given a ParticleIndexer instance describing how particle indices are split across 2 groups.

Positional arguments

• particle_indexer: the ParticleIndexer instance
• i: the index to map

map_cont_index(pia, cell, species, i)

Maps a continuous index in the range [0, n_local-1] to an index in the particle array for particles of a specific species in a specific cell.

Positional arguments

• pia: the ParticleIndexerArray instance
• cell: the index of the cell in which the particles are located
• species: the index of the particles' species
• i: the index to map

update_particle_indexer_new_lower_count(pia, cell, species, new_lower_count)

Update a ParticleIndexerArray instance when the particle count of a given species in a given cell is reduced.

Positional arguments

• pia: the ParticleIndexerArray instance
• cell: the index of the cell in which the particles are located
• species: the index of the particles' species
• new_lower_count: the new number of particles of the given species in the given cell

update_particle_indexer_new_particle(pia, cell, species)

Update a ParticleIndexerArray instance when a particle of a given species in a given cell is created. This places the particle index in the 2-nd group of particle indices in the ParticleIndexer instance.

Positional arguments

• pia: the ParticleIndexerArray instance
• cell: the index of the cell in which the particle is created
• species: the index of the species of which the particle is created

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)

update_particle_buffer_new_particle(pv::ParticleVector, position)

Update the buffer in a ParticleVector instance when a new particle is created. This writes the index of the new particle (the last index stored in the active part of the buffer) to the index vector at position position, and reduces the length of the active part of the buffer by 1.

Positional arguments

• pv: ParticleVector instance
• position: the position in the index vector to which to write the index of the new particle

update_particle_buffer_new_particle(pv::ParticleVector, pia, species)

Update the buffer in a ParticleVector instance when a new particle is created at the end of the particle array, and reduces the length of the active part of the buffer by 1. This assumes that the pia structure has already an updated particle count (that accounts for the newly created particle), as the index of the new particle taken from the buffer is written to pv.index.[pia.n_total[species]].

Positional arguments

• pv: ParticleVector instance
• pia: the ParticleIndexerArray instance
• species: the index of the species of which a new particle is created

update_particle_buffer_new_particle(pv::Vector{Particle}, pia, species)

Dummy function in case Vector{Particle} is used and not a ParticleVector, just to make the simplest 0-D examples work.

update_particle_buffer_new_particle(pv::Vector{Particle}, position)

Dummy function in case Vector{Particle} is used and not a ParticleVector, just to make the simplest 0-D examples work.

delete_particle!(pv::ParticleVector, pia, cell, species, i)

Delete particle with index i of species species in cell cell and update the particle indexers and buffers accordingly. This changes the ordering of the non-deleted particles in the cell.

Positional arguments

• pv: ParticleVector instance
• pia: the ParticleIndexerArray instance
• cell: the index of the cell in which the particle is deleted
• species: the index of the species of which the particle is deleted
• i: the index of the particle to delete

delete_particle_end!(pv::ParticleVector, pia, cell, species)

Delete the last particle of species species in cell cell: if particles are present in the 2nd group of the indices stored in the ParticleIndexer instance, it will delete the last particle in that group; otherwise it will delete the last particle in the 1st group of particles pointed to by the ParticleIndexer instance. If no particles are present in the cell, the function does nothing.

Positional arguments

• pv: ParticleVector instance
• pia: the ParticleIndexerArray instance
• cell: the index of the cell in which the particle is deleted
• species: the index of the species of which the particle is deleted

delete_particle_end_group1!(pv::ParticleVector, pia, cell, species)

Delete particle with index pia.indexer[cell, species].end1of speciesspeciesin cellcell` and update the particle indexers and buffers accordingly (i.e. delete the last particle in the 1st group of particles of a given species in a given cell). This also sets the weight of the deleted particle to 0. If no particles are present in the 1st group of particles, the function does nothing.

Positional arguments

• pv: ParticleVector instance
• pia: the ParticleIndexerArray instance
• cell: the index of the cell in which the particle is deleted
• species: the index of the species of which the particle is deleted

delete_particle_end_group2!(pv::ParticleVector, pia, cell, species)

Delete particle with index pia.indexer[cell, species].end2of speciesspeciesin cellcell` and update the particle indexers and buffers accordingly (i.e. delete the last particle in the 2nd group of the particles of a given species in a given cell). This also sets the weight of the deleted particle to 0. If no particles are present in the 2nd group of particles, the function does nothing.

Positional arguments

• pv: ParticleVector instance
• pia: the ParticleIndexerArray instance
• cell: the index of the cell in which the particle is deleted
• species: the index of the species of which the particle is deleted

compute_mu_ref(m_r, vhs_o, vhs_Tref, vhs_d)

Compute reference viscosity for the VHS model.

Positional arguments

• m_r: collision-reduced mass
• vhs_o: exponent for the VHS potential
• vhs_Tref: reference temperature for the VHS potential
• vhs_d: diameter for the VHS potential

Returns

• reference viscosity

UnitDVGrid

Stores information about a uniform discrete 3-dimensional velocity grid with extent $[-1.0,1.0]\times[-1.0,1.0]\times[-1.0,1.0]$.

Fields

• nx: number of cells in x direction
• ny: number of cells in y direction
• nz: number of cells in z direction
• dx: grid spacing in x direction
• dy: grid spacing in y direction
• dz: grid spacing in z direction
• vx_grid: Vector of grid nodes in x direction
• vy_grid: Vector of grid nodes in y direction
• vz_grid: Vector of grid nodes in z direction

DVGrid

Stores information about a uniform discrete 3-dimensional velocity grid with extent $[-v_{x,max},v_{x,max}]\times[-v_{y,max},v_{y,max}]\times[-v_{z,max},v_{z,max}]$.

Fields

• base_grid: the underlying unit (non-scaled) UnitDVGrid uniform grid
• vx_max: extent of the grid in the x direction
• vy_max: extent of the grid in the y direction
• vz_max: extent of the grid in the z direction
• dy: grid spacing in x direction
• dy: grid spacing in y direction
• dz: grid spacing in z direction
• vx_grid: Vector of grid nodes in x direction
• vy_grid: Vector of grid nodes in y direction
• vz_grid: Vector of grid nodes in z direction

VDF

Stores the values of a function evaluated on 3-dimensional velocity grid.

Fields

• nx: the number of grid elements in the x direction
• ny: the number of grid elements in the y direction
• nz: the number of grid elements in the z direction
• w: the 3-dimensional array of values

generate a grid with extent [-1.0,1.0]x[-1.0,1.0]x[-1.0,1.0]

generate a grid [-vxmax, vxmax]x[-vymax, vymax]x[-vzmax, vzmax]

create an empty VDF of size nx * ny * nz

sample_bkw!(rng, particles, nparticles, offset, m, T, v0)

Sample particle velocities from the BKW distribution with temperature T for a species with mass m at t=0 and add a velocity offset. Note: This does not update the particle weights, positions, or any indexing structures.

Positional arguments

• rng: the random number generator
• particles: the Vector-like structure holding the particles
• nparticles: the number of particles to sample
• offset: offset the starting position for writing the sampled particles to the particles array
• m: species' mass
• T: temperature
• v0: the 3-dimensional velocity to add to the sampled velocities

sample_bkw!(rng, particles, nparticles, m, T, v0)

Sample particles' velocities from the BKW distribution with temperature T for a species with mass m at t=0 and add a velocity offset. This does not update the particle weights, positions, or any indexing structures. The sampled particles are written to the start of the particles array.

Positional arguments

• rng: the random number generator
• particles: the Vector-like structure holding the particles
• nparticles: the number of particles to sample
• m: species' mass
• T: temperature
• v0: the 3-dimensional velocity to add to the sampled velocities

evaluate_distribution_on_grid!(vdf, distribution_function, grid, w_total, cutoff_v; normalize=true)

Evaluate 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 can be re-normalized so that the distribution has the prescribed computational weight/density.

Positional arguments

• vdf: The VDF instance where the evaluated values will be stored
• distribution_function: the distribution function to be evaluated which takes the x, y, and z velocities as parameters
• grid: the DVGrid on which the distribution function is evaluated
• w_total: the total weight used in the re-normalization
• cutoff_v: the radius of the sphere used to cut off high velocities: on grid points outside the sphere the VDF will be 0

Keyword arguments

• normalize: if true, the resulting values of the VDF will be renormalized so that their sum is equal to w_total

sample_maxwellian_single!(rng, v, m, T, v0)

Sample a single particle from a Maxwellian distribution with temperature T for a species with mass m and add a velocity offset.

Positional arguments

• rng: The random number generator
• v: the 3-dimensional vector to store the sampled velocity
• m: the molecular mass of the species
• T: the temperature
• v_offset: the offset velocity vector to be added to the sampled velocity

sample_maxwellian!(rng, particles, nparticles, offset, m, T, v0)

Sample nparticles particles from a Maxwellian with temperature T for a species with mass m and add a velocity offset. Note: This does not update the particle weights, positions, or any indexing structures.

Positional arguments

• rng: the random number generator
• particles: the Vector-like structure holding the particles
• nparticles: the number of particles to sample
• offset: offset the starting position for writing the sampled particles to the particles array
• m: species' mass
• T: temperature
• v0: the 3-dimensional velocity to add to the sampled velocities

sample_maxwellian!(rng, particles, nparticles, m, T, v0)

Sample nparticles particles from a Maxwellian with temperature T for a species with mass m and add a velocity offset. Note: This does not update the particle weights, positions, or any indexing structures. The sampled particles are written to the start of the particles array.

Positional arguments

• rng: the random number generator
• particles: the Vector-like structure holding the particles
• nparticles: the number of particles to sample
• m: species' mass
• T: temperature
• v0: the 3-dimensional velocity to add to the sampled velocities

compute_n_coll_single_species(rng, collision_factors, np, Δt, V)

Compute the non-integer number of collisions between particles of same species.

Positional arguments

• rng: the random number generator
• collision_factors: the CollisionFactors holding the estimate of $(\sigma g w)_{max}$ for the species in question in the cell
• np: number of particles in the cell
• Δt: timestep
• V: cell volume

Returns

The non-integer number of collisions.

compute_n_coll_two_species(rng, collision_factors, np1, np2, Δt, V)

Compute number of collisions between particles of different species

Positional arguments

• rng: the random number generator
• collision_factors: the CollisionFactors holding the estimate of $(\sigma g w)_{max}$ for the species in question in the cell
• np1: number of particles of the first species in the cell
• np2: number of particles of the second species in the cell
• Δt: timestep
• V: cell volume

Returns

The non-integer number of collisions.

compute_vhs_factor(vhs_Tref, vhs_d, vhs_o, m_r)

Compute interaction-specific factor $\pi D_{VHS}^2 (2 T_{ref,VHS}/m_r)^{(\omega_{VHS} - 0.5)} \frac{1}{\Gamma(2.5 - \omega_{VHS})}$.

Positional arguments

• vhs_Tref: reference temperature for the VHS potential
• vhs_d: diameter for the VHS potential
• vhs_o: exponent for the VHS potential
• m_r: collision-reduced mass

Returns

• computed VHS cross-section factor

compute_com!(collision_data::CollisionData, interaction::Interaction, p1, p2)

Compute center of mass velocity of two particles.

Positional arguments

• collision_data: the CollisionData instance where the computed velocity will be stored
• interaction: the Interaction instance for the species of the colliding particles
• p1: the first particle
• p2: the second particle

compute_g!(collision_data::CollisionData, p1, p2)

Compute relative velocity (vector and its magnitude) of two particles.

Positional arguments

• collision_data: the CollisionData instance where the computed velocity will be stored
• p1: the first particle
• p2: the second particle

compute_g_new_ionization!(collision_data, interaction, E_i, energy_splitting)

Compute post-ionization magnitudes of the relative velocities of the impacting and newly created electrons.

Positional arguments

• collision_data: the CollisionData instance where the computed velocity will be stored
• interaction: the Interaction instance for the electron-neutral interaction which produced the ion
• E_i: ionization energy of the neutral species in electron-volt
• energy_splitting: how the energy is divided among the electrons: if ElectronEnergySplitEqual, the energy is split equally, if ElectronEnergySplitZeroE, one electron takes all of the energy

scatter_vhs!(rng, collision_data, interaction, p1, p2)

Scatter two particles using VHS (isotropic) scattering.

Positional arguments

• rng: the random number generator
• collision_data: the CollisionData instance to which stores the center-of-mass velocity, the magnitude of the pre-collisional relative velocity of the particles and to which the new post-collisional velocity will be written
• interaction: the Interaction instance for the colliding particles
• p1: the first colliding particle
• p2: the second colliding particle

scatter_vhs!(rng, collision_data, interaction, p1, p2)

Scatter an electron off of a neutral particle using VHS (isotropic) scattering and re-scale its relative velocity to g_new.

Positional arguments

• rng: the random number generator
• collision_data: the CollisionData instance to which stores the center-of-mass velocity and the magnitude of the pre-collisional relative velocity of the electron and the neutral
• particles_electron: the electron particle to scatter off of the neutral particle
• g_new: the magnitude of the post-collisional relative velocity

scatter_ionization_electrons!(rng, collision_data, particles_electron, i1, i2)

Scatter two electrons off of a neutral using VHS (isotropic) scattering.

Positional arguments

• rng: the random number generator
• collision_data: the CollisionData instance to which stores the center-of-mass velocity the magnitude of the pre-collisional relative velocity of the electron and the neutral, and the post-collisional magnitudes of the velocities of the electrons
• particles_electron: the vector of electron particles to scatter off of the neutral particle
• i1: the index of the first electron particle to scatter off of the neutral
• i2: the index of the second electron particle to scatter off of the neutral

sigma_vhs(interaction, g)

Computes the VHS cross-section.

Positional arguments

• interaction: the Interaction instance
• g: the relative velocity of the collision

Returns

The value of the computed cross-section.

compute_tabulated_cs_constant_continuation(tabulated_cs_data, E_coll)

Compute an energy-dependent cross-section from tabulated data using linear interpolation. If the energy is smaller than the minimum energy used for the tabulation, return first element of the table; if energy is larger than the maximum energy used for the tabulation, return last element of the table.

Positional arguments

• tabulated_cs_data: a TabulatedCSData instance with the tabulated energies and cross-section values
• E_coll: the collision energy for which to compute the cross-section

Returns

The value of the cross-section.

compute_tabulated_cs_zero_continuation(tabulated_cs_data, E_coll)

Compute an energy-dependent cross-section from tabulated data using linear interpolation. If the energy is outside of the range of energies used for the tabulation, returns 0.0.

Positional arguments

• tabulated_cs_data: a TabulatedCSData instance with the tabulated energies and cross-section values
• E_coll: the collision energy for which to compute the cross-section

Returns

The value of the cross-section.

compute_cross_sections_only!(computed_cs, interaction, g, electron_neutral_interactions, neutral_species_index)

Compute electron-impact ionization and excitation cross-sections, and electron-neutral elastic scattering crosss-sections, and return collision energy in eV. Here neutral_species_index is the index of the neutral species being considered in the overall array of the Species instances that includes all species in the simulation and was used to construct the ElectronNeutralInteractions instance.

Positional arguments

• computed_cs: the vector of ComputedCrossSection instances in which the computed values will be stored
• interaction: the Interaction instance describing the electron-neutral interaction being considered
• g: the magnitude of the relative collision velocity
• electron_neutral_interactions: the ElectronNeutralInteractions instance storing the tabulated cross-section data
• neutral_species_index: the index of the neutral species being considered

Returns

The electron-neutral collision energy in eV.

compute_cross_sections!(computed_cs, interaction, g, electron_neutral_interactions, neutral_species_index)

Compute electron-impact ionization and excitation cross-sections, electron-neutral elastic scattering cross-sections, total collision cross-section, probabilities of the different processes, and return collision energy in eV. Here neutral_species_index is the index of the neutral species being considered in the overall array of the Species instances that includes all species in the simulation and was used to construct the ElectronNeutralInteractions instance.

Positional arguments

• computed_cs: the vector of ComputedCrossSection instances in which the computed values will be stored
• interaction: the Interaction instance describing the electron-neutral interaction being considered
• g: the magnitude of the relative collision velocity
• electron_neutral_interactions: the ElectronNeutralInteractions instance storing the tabulated cross-section data
• neutral_species_index: the index of the neutral species being considered

Returns

The electron-neutral collision energy in eV.

get_cs_total(electron_neutral_interactions, computed_cs, neutral_species_index)

Get the value of a computed total collision cross-section for electron-neutral interactions. Here neutral_species_index is the index of the neutral species being considered in the overall array of the Species instances that includes all species in the simulation and was used to construct the ElectronNeutralInteractions instance.

Positional arguments

• electron_neutral_interactions: the ElectronNeutralInteractions instance storing the tabulated cross-section data
• computed_cs: the vector of ComputedCrossSection instances holding the computed cross-section values
• neutral_species_index: the index of the neutral species being considered

Returns

The value of the total collision cross-section.

get_cs_elastic(electron_neutral_interactions, computed_cs, neutral_species_index)

Get the value of a computed electron-neutral elastic scattering cross-section. Here neutral_species_index is the index of the neutral species being considered in the overall array of the Species instances that includes all species in the simulation and was used to construct the ElectronNeutralInteractions instance.

Positional arguments

• electron_neutral_interactions: the ElectronNeutralInteractions instance storing the tabulated cross-section data
• computed_cs: the vector of ComputedCrossSection instances holding the computed cross-section values
• neutral_species_index: the index of the neutral species being considered

Returns

The value of the elastic scattering cross-section.

get_cs_ionization(electron_neutral_interactions, computed_cs, neutral_species_index)

Get the value of a computed electron-impact ionization cross-section. Here neutral_species_index is the index of the neutral species being considered in the overall array of the Species instances that includes all species in the simulation and was used to construct the ElectronNeutralInteractions instance.

Positional arguments

• electron_neutral_interactions: the ElectronNeutralInteractions instance storing the tabulated cross-section data
• computed_cs: the vector of ComputedCrossSection instances holding the computed cross-section values
• neutral_species_index: the index of the neutral species being considered

Returns

The value of the electron-impact ionization scattering cross-section.

get_ionization_threshold(electron_neutral_interactions, neutral_species_index)

Get the ionization threshold energy. Here neutral_species_index is the index of the neutral species being considered in the overall array of the Species instances that includes all species in the simulation and was used to construct the ElectronNeutralInteractions instance.

Positional arguments

• electron_neutral_interactions the ElectronNeutralInteractions instance storing the tabulated cross-section data
• neutral_species_index: the index of the neutral species being considered

Returns

The ionization threshold energy of a specific neutral species.

get_electron_energy_split(electron_neutral_interactions, neutral_species_index)

Get the way electron energy is split during ionization for a specific electron-neutral interaction. Here neutral_species_index is the index of the neutral species being considered in the overall array of the Species instances that includes all species in the simulation and was used to construct the ElectronNeutralInteractions instance.

Positional arguments

• electron_neutral_interactions the ElectronNeutralInteractions instance storing the tabulated cross-section data
• neutral_species_index: the index of the neutral species being considered

Returns

The ElectronEnergySplit value for the specific electron-neutral interaction.

TabulatedCSData

Structure for storing tabulated cross-section data as a function of relative collision energy

Fields

• n_vals: number of values stored
• E: array of relative collision energies
• sigma: array of cross-section values at these energies
• ΔE: how much energy is lost (gained) in the collision in case it is inelastic

ElasticScattering

Structure to hold data on an elastic scattering cross-section.

Fields

• data: a TabulatedCSData instance holding the cross-section values
• scattering: the ScatteringLaw model for the scattering of the particles

Ionization

Structure to hold data on electron-impact electronic excitation cross-sections for a specific species.

Fields

• n_reactions: number of electron-impact electronic excitation reactions
• data: an array of TabulatedCSData instances (of length n_reactions) holding the cross-section values for each reaction
• scattering: the ScatteringLaw model for the scattering of the particles

Ionization

Structure to hold data on an electron-impact ionization cross-section.

Fields

• data: a TabulatedCSData instance holding the cross-section values
• scattering: the ScatteringLaw model for the scattering of the electrons
• split: the ElectronEnergySplit model for energy splitting across the primary and secondary electrons

Find a chemical species in an LXCat-format XML; returns the first instance of the species found and the id of the "Groups" element in which the species was found. The following conditions need to be satisfied for a tuple (i,j) for it to be returned: tag(xml_data[i]) == "Groups" and attributes(xml_data[i][j])["id"] == species_name.

Positional arguments

• xml_data: the LXCat-format XML data to be searched
• species_name: the name of the species to search for

Returns

Tuple (i,j) denoting the index of the group and group element in which the species is located

load_elastic_data(xml_data)

Load electron-neutral elastic scattering data from the part of an LXCat-format XML file for a specific species. The following should hold for the data to be loaded: tag(xml_data[i]) == "Processes", attributes(xml_data[i][j])["type"] == "Ionization". This will load the first set of data found for the ionization process.

Positional arguments

• xml_data: the LXCat-format XML data to be searched

Returns

TabulatedCSData structure containing the electron-neutral elastic scattering cross-section data.

Throws

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

load_ionization_data(xml_data)

Load electron-impact ionization data from the part of an LXCat-format XML file for a specific species. The following should hold for the data to be loaded: tag(xml_data[i]) == "Processes", attributes(xml_data[i][j])["type"] == "Ionization". This will load the first set of data found for the ionization process.

Positional arguments

• xml_data: the LXCat-format XML data to be searched

Returns

TabulatedCSData structure containing the electron-impact ionization cross-section data.

Throws

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

Struct for keeping track of merging-related quantities in a velocity grid cell

Compute extent of velocity grid based on temperature in the cell

Compute index of particle on the merging grid

Reset merging grid

Compute properties for all cells on the merging grid

Compute new particles based on the grid cell properties without checking particle locations

Compute post-merge particles

Return sign of velocity vx of an octant in velocity space

Return sign of velocity vy of an octant in velocity space

Return sign of velocity vz of an octant in velocity space

Check speed bound

Check speed bound with multiplier

Base multi indices corresponding to conservation of mass momentum and energy components

Compute total computational weight of particles and mean velocity, as well as velocity bounds

Compute unweighted centered moment

Compute unweighted centered moment

Compute LHS matrix and RHS vector for NNLS merging

Compute LHS matrix and RHS vector for NNLS merging, rate-preserving version

Compute additional LHS columns for additional particles

Compute additional LHS columns for additional particles, rate preserving

Scale LHS and RHS

Scale LHS and RHS, rate-preserving version

Compute post-merge particles

Struct holding data needed for refinement of an octree bin

Octree bin properties required to merge the particles in a bin

Fill the octree bins struct with zero data

Fill the octree full bins struct with zero data

Reset octree

Resize octree buffers

Compute octant of particle velocity relative to a v_middle`

Compute new bin bounds of sub-bin inheriting bounds of parent bin

Recompute bin bounds based on particle velocities

Compute mean velocity of bin

Compute median velocity of bin

Get index of a newly created bin

Sort particles into sub-bins, split bin, keeping track of which sub-bins particles end up in

Compute properties in a bin required for merging

Get number of post-merge particles in a bin

Initialize the top bin in an octree

Perform N:2 merging

Cell1D

Cell element of a 1-D grid

Fields

• xlo: coordinate of the left end of the element
• xhi: coordinate of the right end of the element
• V: cell volume

get_cell(grid1duniform::Grid1DUniform, x_pos)

Find in which cell of 1-D uniform grid the coordinate is located

Positional arguments

• grid1duniform: the 1-D uniform grid
• x_pos: the 3-D coordinate vector for the which the cell index is to be determined (only the first component is used)

convect_single_particle!(rng, grid::Grid1DUniform, boundaries::MaxwellWalls1D, particle, species, Δt)

Convect a singe particle 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 particle to be convected
• species: the index of the species being convected
• Δt: the convection timestep

specular_reflection_x!(particle)

Perform specular reflection of a particle in the x direction.

Positional arguments

• particle: the Particle instance for which the velocity is reflected

specular_reflection_x!(particle)

Perform diffuse reflection of a particle, assuming the wall is orthogonal to the x axis.

Positional arguments

• rng: the random number generator
• particle: the Particle instance for which the velocity is reflected
• wall_reflection_v_sq: the squared thermal velocity of the species reflected at the wall temperature
• wall_normal_sign: sign of the wall normal
• wall_v: wall velocity vector

reflect_particle_x!(rng, particle, wall_reflection_v_sq, wall_normal_sign, wall_v, wall_accommodation)

Reflect particle from a Maxwell wall orthogonal to the x axis.

Positional arguments

• rng: the random number generator
• particle: the Particle instance for which the velocity is reflected
• wall_reflection_v_sq: the squared thermal velocity of the species reflected at the wall temperature
• wall_normal_sign: sign of the wall normal
• wall_v: wall velocity vector
• wall_accommodation: wall accommodation coefficient

Speed of light, m/s

Electron-Volt, K

Electron-Volt, J

1.0/eV[J], 1/J (or equivalent to how much 1 J is equal to expressed in eV)

$2 \pi$

Electron mass divided by 1 eV, kg/J

Positive and negative direction signs

Elementary charge, C

compute_thermal_velocity(m, T)

Compute the thermal velocity $\sqrt(2kT/m)$.

Positional arguments

• m: the molecular mass of the species
• T: the temperature

Returns

The thermal velocity

binary_search(x, val)

Binary search for value val in a sorted array x. Finds the position mid such that x[mid] < val < x[mid+1].

Positional arguments

• x: the sorted array to be searched
• val: the value to search for

Returns

• -1 if val < x[1]
• 0 if val > x[end]
• Otherwise, returns the index mid satisfying x[mid] < val < x[mid+1]

linear_interpolation(x, y, val, pos, lower_limit, upper_limit)

Perform linear interpolation of a tabulated function y(x), given a parameter value val, a sorted array of values of x and corresponding values of y, as well as the index of the closest values of x to val. In case val is outside of the limits of x, return placeholder values. That is, given that x[pos] < val < x[pos+1], we want to interpolate y(val) given that y[x[pos]] = y[pos], y[x[pos+1]] = y[pos+1].

Positional arguments

• x: the vector of values of the parameter of the function to be interpolated
• y: the vector of the corresponding function values
• val: the value of the parameter at which the function is to be interpolated
• pos: the index of the element in x such that x[pos] < val < x[pos+1], or -1 if val < x[1], 0 if val > x[end]
• lower_limit: the value to return if val < x[1]
• upper_limit: the value to return if val > x[end]

Returns

• The linearly interpolated value of y(val) if x[1] <= val <= x[end]
• lower_limit, if val < x[1]
• upper_limit, if val > x[end]

compute_mixed_moment(particles, pia, cell, species, powers; sum_scaler=1.0, res_scaler=1.0)

Compute mixed velocity moment of particles in a cell: $\sum_i w_i v_{x,i}^{p_x} v_{y,i}^{p_y} v_{z,i}^{p_z}$

Positional arguments

• particles: the Vector of ParticleVectors containing all the particles in a simulation
• pia: the ParticleIndexerArray instance
• cell: the cell in which the moment is being computed
• species: the species for which the mixed moment is being computed
• powers: a Vector of the powers to which the x-, y-, and z-components of the velocity are to be raised

Keyword arguments

• sum_scaler: during the summation over the particles, scale each summand by this factor potentially reduce round-off issues
• res_scaler: scaling factor by which to multiply the result at the end

Algorithm NNLS: NONNEGATIVE LEAST SQUARES

The original version of this code was developed by Charles L. Lawson and Richard J. Hanson at Jet Propulsion Laboratory 1973 JUN 15, and published in the book "SOLVING LEAST SQUARES PROBLEMS", Prentice-HalL, 1974. Revised FEB 1995 to accompany reprinting of the book by SIAM.

GIVEN AN M BY N MATRIX, A, AND AN M-VECTOR, B, COMPUTE AN N-VECTOR, X, THAT SOLVES THE LEAST SQUARES PROBLEM A * X = B SUBJECT TO X .GE. 0

CONSTRUCTION AND/OR APPLICATION OF A SINGLE HOUSEHOLDER TRANSFORMATION.. Q = I + U*(U**T)/B

The original version of this code was developed by Charles L. Lawson and Richard J. Hanson at Jet Propulsion Laboratory 1973 JUN 12, and published in the book "SOLVING LEAST SQUARES PROBLEMS", Prentice-HalL, 1974. Revised FEB 1995 to accompany reprinting of the book by SIAM.

UnsafeVectorView only works for isbitstype types. For other types, we're already allocating lots of memory elsewhere, so creating a new View is fine.

This function looks type-unstable, but the isbitstype(T) test can be evaluated by the compiler, so the result is actually type-stable.

Fallback for non-contiguous arrays, for which UnsafeVectorView does not make sense.

The original version of this code was developed by Charles L. Lawson and Richard J. Hanson at Jet Propulsion Laboratory 1973 JUN 15, and published in the book "SOLVING LEAST SQUARES PROBLEMS", Prentice-HalL, 1974. Revised FEB 1995 to accompany reprinting of the book by SIAM.

Views in Julia still allocate some memory (since they need to keep a reference to the original array). This type allocates no memory and does no bounds checking. Use it with caution.

COMPUTE ORTHOGONAL ROTATION MATRIX.. The original version of this code was developed by Charles L. Lawson and Richard J. Hanson at Jet Propulsion Laboratory 1973 JUN 12, and published in the book "SOLVING LEAST SQUARES PROBLEMS", Prentice-HalL, 1974. Revised FEB 1995 to accompany reprinting of the book by SIAM.

COMPUTE.. MATRIX (C, S) SO THAT (C, S)(A) = (SQRT(A2+B2)) (-S,C) (-S,C)(B) ( 0 ) COMPUTE SIG = SQRT(A2+B2) SIG IS COMPUTED LAST TO ALLOW FOR THE POSSIBILITY THAT SIG MAY BE IN THE SAME LOCATION AS A OR B .

CONSTRUCTION AND/OR APPLICATION OF A SINGLE HOUSEHOLDER TRANSFORMATION.. Q = I + U*(U**T)/B

The original version of this code was developed by Charles L. Lawson and Richard J. Hanson at Jet Propulsion Laboratory 1973 JUN 12, and published in the book "SOLVING LEAST SQUARES PROBLEMS", Prentice-HalL, 1974. Revised FEB 1995 to accompany reprinting of the book by SIAM.