Derived Types

Composite derivation class containing a number of calculation rules applied additively. All derivations must return same length array

Basic normalization based on electron quantities and containing most common values

Calculates extrapolated value of a fluid quantity at a boundary cell edge, optionally applying a lower and/or upper bound to the extrapolated value. Accepts scalar variables for lower/upper bounds. Expects 1-3 variables, The first expected variable name is the interpolated variable. The second is the upper bound if no lower bound variable is expected, otherwise it is the lower bound. The third is the upper bound (if expected). Bounds are all expected to have positive values, and this will be ensured by taking their absolute values. If applied to the left boundary, will apply -abs(lowerBound) as upper bound and -abs(upperBound) as lower bound, i.e. the bounds are reflected around 0.

Butcher tableau derived type

Kernel containing calculation node properties

Node class for the abstract calculation left child/right sibling tree. Each node has a reference to its leftmost child, its sibling to the immediate right, and to its parent.

Object used to calculate derived variables using a derivation object and set of required variable names

Derivation object that has a calculation tree component, used to evaluate the derivation result independently of the passed indices. The derivation is constructed using a FlatTree, which needs to be unpacked before the derivation can be used. Note: This derivation should only be used if the passed object is the global VariableContainers variable array.

Calculates the Chang-Cooper-Langdon diffusion coefficient for f0 Coulomb collisions assuming that the passed variables are the single harmonic f0 and the ccl interpolation weight

Calculates the Chang-Cooper-Langdon drag coefficient for f0 Coulomb collisions assuming that the passed variable is the single harmonic f0

Calculates the Chang-Cooper-Langdon interpolation weight for f0 Coulomb collisions assuming that the two passed variables are single harmonic C and D integrals (see 4.5 in Mijin thesis)

JaggedArrayGenerator for calculating fixed central differencing stencil with no face interpolation

Returns equal to the central difference of the first passed (fluid) variable, optionally multiplied by a constant and product of fluid variables raised to corresponding powers

Calculates the Shkarofsky I or J integrals for cold drifting ions (normalized to ion density). The passed variable is assumed to be the ion flow velocity

Contains lists of variables to broadcast in processor rows and variables participating in halo exchange

Composite integrator object allowing for different integration stages

Composite manipulator object allowing for application of multiple manipulators in series based on their priority

Signal wrapper always returning 1

Container for profiles in the x,h, and v directions

Coordinate list format sparsity pattern

Returns values of the coulomb log based on electron density and temperature variables (and optionally ionization). The passed indices are assumed to be in T,n,Z order if ee or ei logarithm, or in n1,n2,T1,T2 order if ii logarithm. Assumes that density is normalized to m^{-3} units, and temperature to eV.

TermGenerator object used to generate electron Boltzmann terms with fixed inelastic mappings based on associated variables in species list and CRM modelbound data. Assumes that all passed transition indices correspond to fixed inlastic mapping transitions. Assumes that the cross-section values in the transitions include any nonlinear normalization dependence (e.g. recombination etc.)

TermGenerator object used to generate particle source terms based on associated variables in species list and CRM modelbound data. Assumes rates are normalized so that the resulting source term is normalized to densNorm/timeNorm.

TermGenerator object used to generate electronj energy source and sink terms based on associated variables in species list and CRM modelbound data. Assumes rates are normalized so that the resulting source term is normalized to densNorm*eVTemperature/timeNorm.

TermGenerator object used to generate secondary electron source/sink terms based on associated variables in species list and CRM modelbound data.

TermGenerator object used to generate electron Boltzmann terms with variable inelastic mappings based on associated variables in species list and CRM modelbound data. Assumes that all passed transition indices correspond to variable inlastic mapping transitions. Assumes that the cross-section values in the transitions include any nonlinear normalization dependence (e.g. recombination etc.)

Builder for custom models with user defined terms and modelbound data

Periodic signal where in params(1) and params(2) are between 0 and 1. Returns half-sine if params(1)<mod(time,period)<params(2). Otherwise returns 0.

Calculates v_o*d(v_i df/dv)/dv, where v_o and v_i are velocity vectors, and f is a distribution. Can return either a distribution or a single harmonic. Assumes that df/dv at v->inf is 0.

Data type used to store global coordinates of any given matrix row

Transition with fixed energy where the cross-section is calculated using SOL-KiT's version of discrete detailed balance

Calculates v_o*d(v_i f)/dv, where v_o and v_i are velocity vectors, and f is a distribution. Can return either a distribution or a single harmonic. Assumes that f at v->inf is 0.

JaggedArrayGenerator for calculating d/dv type stencils for single harmonics. Automatically includes spatial dependence. Has options for custom velocity grid interpolation of the distribution function and definition of the velocity cell boundary flux in the form C*f where f is the distribution function and C is a custom value. The interpolation weights and C are assumed to be defined on right velocity cell boundaries. Assumes that the velocity stencil is [-1,0,1]

Abstract derivation object defining the interface for calculating derived variables and data

Term of the form modelbound variable * derivation result, where the modelbound variable is optional

Transition where the rate is calculated using a derivation object and with a fixed transition energy. Optionally, momentum and energy rates can be calculated using derivation objects

JaggedArrayGenerator for calculating a diffusion stencil, optionally using a derivation object to calculate the diffusion coefficient at faces. The default diffusion coefficient is unity.

Returns the sheath heat transmission coefficient for electrons depending on electron and ion temperatures in the boundary cell. Assumes the indices are in Te,Ti order

EnvironmentWrapper object storing publicly accessible grid, variable, and controller data

Explicit Runge-Kutta integrator

Abstract term providing basic interfaces for build terms used in explicit timestepping

Abstract Extrapolation object, responsible for extrapolating fluid quantites onto x grid boundaries

JaggedArrayGenerator for calculating forward or backwards difference stencils. These are two-point stencils of the form [-Jout(i)Jin(i),Jout(i)Jin(i+1)], or [-Jout(i)Jin(i-1),Jout(i)Jin(i)], depending on whether the difference is forward or backwards. Jout and Jin should be defined on the x grid, and should act like the (inverse) Jacobian/Hodge star operator.

JaggedArrayGenerator for calculating velocity component of Boltzmann collision operator emissionabsorption terms with fixed inelastic mappings. Expects fixed vStencil derived from the weights matrix if absorption term, otherwise vStencil = [0]. Generates Wvsigma(v) for absorption term or - v*sigma(v) for emission. If cross-section depends on x, it assumes no halo.

Transition object with a fixed transition energy and cross-section, which takes moments of a distribution function to calculate rates

Flat representation of multidimensional data allowing for multidimensional indexing using vector notation - i.e. dataObj%getValue([1,2,3]) = someData(1,2,3). Allows for dimensionality agnostic implementations of various algorithms.

Flattened calculation tree for pointer-safe copying

JaggedArrayGenerator for extending the fixed stencil capabilities of StencilGenerator1D to allow for an additional multiplicative dependence on fluid variables in the passed variable container or modelbound data. Allows associating different variables to each column.

Extrapolates a distribution function to the boundary or last cell centre as a (numH,numV) matrix. Assumes that there are no m>0 harmonics for staggered grids. Expects 1-4 variables. The first is the extrapolated distribution, the second the density vector. The third is the staggered density if the variables are staggered. The value of the density at the boundary (scalar) is either the third or the fourth variable, and should be present only if extrapolating to the boundary.

Wraps single integer parameter and single real array function, passing first index variable as input, optionally multiplying it with a constant before passing

General matrix term with the capability to take in various stencils, time and spaticoordinate profiles, and evaluate other term groups in the host model. Required row and column variables passed through the VarData object are raised to corresponding powers.

Derivation taking in multiple variables and calculating multConst*fun(sum coef_i prod vars^powers) where prod vars^powers is shorthand for a product of multiple variables raised to corresponding powers. Basically behaves like a multiplicative derivation where the inner derivation is a massive sum of simple derivation outputs with integer powers. Implemented to allow AMJUEL rate fit derivations efficiently

Geometry object storing spatial cell widths, cell face and cell centre jacobians, as well as linear interpolation coefficients

Grid object storing cell positions of x and v grid, as well as Legendre harmonic data of the grid

Manipulator that evaluates a specific model term group and writes the result into variable with given index

Periodic signal where in params(1) and params(2) are between 0 and 1. Returns 1 if params(1)<mod(time,period)<params(2). Otherwise returns 0.

Controller object responsible for HDF5 IO

Extracts target harmonic from distribution variable

Calculates the Shkarofsky I or J integrals for each passed harmonic.

Indexing object containing local and global indexing rules

Object responsible for storing inelastic mapping matrices, determining active emitter cels, and interpolating variable energy mapping matrices

Array of integer values

Abstract Integrator object

Object containing data pertaining to single integration step

Container allowing for heterogeneous Integrator arrays

Linear interpolation object housing information necessary for linearly interpolating 1D data. Will fail assertsion if interpolation points are outside of the grid.

Derivation that interpolates a variable from the original to the dual grid, or vise versa. Distributions are interpolated by assuming that even l harmonics live on the original grid and odd harmonics on the dual grid.

Linear interpolation object housing information necessary for linearly interpolating N-dimensional data using weighted averages. If interpolation points are outside of the grid will return 0 for interpolated value. NOTE: Does not support changing the number of interpolation points after the first interpolation call.

JaggedArrayGenerator for calculating implicit interpolation stencil between regular and staggered grids. Expects that the xStencil is [0,1] for regular to staggered grid interpolation, and [-1,0] for staggered to regular. If non-periodic and going from staggered to regular the values are implicitly extrapolated to the first and last cell centres from the edges leading up to the boundary. In this case the generator expects that the left boundary stencil is overriden with [0,1] and the right stencil with [-2,-1]

JaggedArrayGenerator object for calculating jagged real arrays based on variable data

Object responsible for reading and writing to JSON files

Linear extrapolation object

Extracts target location value from a fluid variable as a scalar variable. Expects a single input.

Linear extrapolation object

Array of logical values

Abstract Manipulator object used to manipulate data through Modeller callback

Abstract derivation object defining the interface for calculating dense matrix quantities

Abstract matrix term containing general matrix construction routines and interface with PETSc. The values of a matrix are by default constructed by evaluating row and column functions for each element, and multiplying with the corresponding multiplicative and normalization constants

Indexing data used by the matrix term

Container allowing for heterogeneous matrix term arrays

Calculates Maxwellian distribution. Expects temperature and density indices (in that order), and assumes velocity is normalized to electron thermal speed.

Object storing, evaluating, and manipulating various term objects, with terms categorized as either implicit (MatrixTerm objects) or general (Term objects).

Object responsible for storing and providing centralized access to transition objects and, optionally, inelastic grid data

Abstract general modelbound data object used to build classes that contain data for updating terms

Manipulator that extracts a (rank 1!) modelbound data variable from a model into a variable

Modelbound data object containing variable-like data updated using a variable container

Modelbound data object containing data used to construct kinetic logical boundary condition. Assumes no m>0 harmonics. Assumes standard normalization. Data accessible through standard data copy routine: "gamma" - sheath heat transmission coefficient "potential" - potential drop at sheath normalized to boundary temperature "coVel" - cut-off velocity "shTemp" - sheath temperature obtained using the cut-off distribution

Abstract ModelBuilder object, housing basic functionality for the construction of Model objects and passing those objects to their final Modeller destination

Container for Model objects allowing heterogeneous arrays

Central object responsible for storing variables and models, as well as doing integration and data manipulation

Moment derivation object. First step in derivation is taking the mOrder-th moment of the h-th harmonic of the first passed variable (assumes that it is a distribution), optionally multiplied by constant velocity space vector g. The results is then optionally multiplied by a constant and a product of fluid variables raised to powers (as in SimpleDerivation).

Provides a centralized interface with MPI and various support routines compatible with ReMKiT1D needs

Composite derivation class containing two calculation rules applied additively. Both derivations must return same length array. Optionally applies one of several intrinsic functions to "inner" derivation result before multiplication.

Provides capability of building stencil value objects based on tensor products of individual stencil value array

Generates stencil values based on independent data for x,h,v dimensions

Container with named arrays of integers, reals, logicals, and strings

Named integer value

Named integer array

Named logical value

Named logical value array

Named real value

Named real value array

Container with arrays on named integers, reals, logicals, and strings

Named string

Named array of strings

Interpolates n-dimensional data linearly based on n-input variables (must all be the same length)

Abstract normalization object providing access routines

Base object class used to determine whether complex objects have been properly initialized

Abstract operator class for use in explicit terms to transform real arrays

Object responsible for storing the x-h domain decomposition

Object responsible for interfacing with PETSc

Object used to properly preallocate PETSc matrices

Implicit Backwards Euler integrator with Picard iterations for handling non-linearities

Derivation taking in a single variable v and returning c0 + sum(c_ivp_i), where p are powers and c polynomial coefficents, Can optionally take as many conforming variables as there are coefficients and return c0 + sum(c_iv_i**p_i)

Composite derivation class containing a single calculation rule, which is overriden with zeros wherever any one in a set of control variables is outside their defined range. If derivIndices isn't passed will pass all indices to the derivation.

Array of real values

Real array of depth 2

JaggedArrayGenerator for calculating logical boundary condition for electron distribution function. Contains x,h,v dependencies. Expects xStencil = [0] or [-1], depending on whether the boundary is left or right, and whether variables are staggered. The hStencil should cover all harmonics and assumes no m>0 harmonics. Expects vStencil = [0,1]. Calculates v*f_{cl}, without taking the x width or boundary sign into account.

Object storing named signals

Container object for signal types

Simple derivation object assuming all variables are confroming. Just multiplies the input array entries and raises them to set powers. Optionally multiplies the result with a constant.

Timestep controller that calculates the timestep using the min (max) value of a product of variables raised to corresponding powers. Variables are assumed fluid-like.

Simple transition object with a fixed rate and energy, and single ingoing and outgoing state. The default energy rate is set to rate*energy, and the momentum rate is 0

Contains data used by the PETSc ksp solver to set various options (refer to PETSc manual)

Sparse row matrix representation

Base species class containing particle properties and associated variable names

Species list object providing centralized access and initialization of species objects

Stencil object for construction of matrix patterns by mapping row coordinates to sets of column coordinates

1D stencil component for global stencil construction

JaggedArrayGenerator for calculating a fixed stencil based on fixed column-wise value vectors and a Stencil1D object. Each column value vector is associated with its entry in the Stencil1D object.

Array of character arrays (a string)

General abstract term object

Container allowing for heterogeneous general term arrays

Manipulator that evaluates a specific model,term pairs and writes the total result into variable with given index Optionally accumulates the values in the variable instead of overriding them. Optionally performs its own update calls on the models/terms

Abstract TermGenerator object, responsible for automatic generation of terms

Container object for term generators

JaggedArrayGenerator for calculating moment terms based on taking velocity moments of other kinetic terms. The term whose moment is taken is expected to be evolving a single harmonic of a distribution variable and have a diagonal spatial stencil. If the implcit variable is a distribution, the spatial stencil must be strictly diagonal (no interpolation allowed).

Object storing named derivations

Object responsible for the main integration loop

Abstract signal class wrapping explicit time dependence. NOTE: Not meant to be initializable, hence not an object

Container for time signal data used tu inject explicit time dependence

Abstract timestep controller object

Represents a process in which an ingoing set of particles(states) is transformed into an outgoing set and to which quantities representing particle/momentum/energy exchange rates can be meaningfully assigned. Optionally, a Transition can have a cross-section object of rank 2 to accommodate anisotropic differential cross-sections.

Container allowing for heterogeneous Transition object arrays

JaggedArrayGenerator for calculating a flux-like boundary condition stencil. Can take 2 variable indices, one for a flux jacobian variable and the other for a lower jacobian bound variable. If the flux jacobian is present it is extrapolated to the boundary and the stencil multiplied by it. If the lower jacobian bound variable is present it is extrapolated to the boundary and substituted for the flux jacobian if the jacobian's projection to the boundary surface normal is smaller than the lower bound variable. If setting extrapolate to true the stencils will extrapolate the implicit/column variables as well. The stencil is assumed to either be [0,-1] for right boundary or [0,1] for left boundary. Will return size(0) stencil if the current processor does not contain the corresponding boundary.

JaggedArrayGenerator for calculating an upwinding or central difference stencil based on interpolation to cell faces. Optionally interpolates a variable with given index in variable container. Interpolation variable required in upwinding mode.

Container for common data used to initialize general matrix terms

JaggedArrayGenerator for calculating velocity component of Boltzmann collision operator emission/absorption terms with variable inelastic mappings. Expects upper/lower triangular vStencil (depending on energy sign), otherwise vStencil = [0]. Generates Wvsigma(v) for absorption term or - v*sigma(v) for emission. Assumes no halo in cross-section.

Container for variable data, allows for handling conversion between local data storage and flattened vectors used for PETSc NOTE: Does not support single harmonic variables

Transition where the transition energy and cross-section are derived

Contains a list of variable names and records whether they are distribution functions

JaggedArrayGenerator for calculating d(Ad/dv)/dv type stencils. Formally a d/dv term where the flux is A*df/dv where df/dv at cell edge n+1/2 is (f_{n+1}-f_{n})/(v_{n+1}-v_{n}). A is assumed to be defined on right velocity cell boundaries. Assumes that the velocity stencil is [-1,0,1]

Derivation that calculates the contraction of velocity vector g with h'th harmonic of single passed distribution variable

Derivation that calculates the flattened tensor product of vector v with a fluid variable, optionally shifting v by a second fluid variable and raising the shifted values to a power

Object responsible for taking velocity moments of distributions and other velocity grid manipulation