🥮 mooncakes.io

moonbit-plasma

A MoonBit plasma numerics toolkit for teaching, research prototypes, and lightweight engineering calculations.

plasma
simulation
pic
vlasov
numerics
moon add mohongquan0630/moonbit-plasma@0.2.0
Download zip
Version
0.2.0
License
Apache-2.0
Repository
Last updated
1 hour ago
Downloads
8
README

#moonbit-plasma

moonbit-plasma is a pure MoonBit toolkit for deterministic one-dimensional electrostatic plasma models. It provides inspectable numerical kernels for teaching laboratories, research prototypes, regression fixtures, and lightweight engineering calculations.

#Project positioning

The library provides a composable path from physical parameters to a reproducible result: construct a grid and species, sample particles or a distribution, deposit charge, solve the electrostatic field, advance the state, and export diagnostics. Its scope is intentionally explicit: this is a 1D electrostatic toolkit, not a claim of a validated MPI/GPU production solver.

#Core capabilities

  • SI plasma relations, thermal scales, damping estimates, beta, and Alfvén-related helpers.
  • Periodic grids, interpolation, profiles, finite-difference derivatives, and periodic or bounded Poisson solvers.
  • PIC with NGP/CIC/TSC shape functions, multiple species, deterministic sampling, and boundary policies.
  • Simplified Vlasov-Poisson advection with density, velocity marginal, entropy, kinetic energy, positivity, and mass diagnostics.
  • Boris and Verlet integration, analytic fields, collision models, fluid fluxes, spectra, phase-space histograms, and invariant checks.
  • Stable CSV snapshots, benchmark records, verification bundles, and generated public API summaries.

#Quick start

moon update
moon check --deny-warn
moon test --deny-warn
moon run cmd/main

///|
test {
  let grid = Grid1D::new(8, 1.0)
  let state = PicState::new(grid, two_stream_particles(16, 1.0, 1.0e5))
  let next = state.run(1.0e-12, 2)
  assert_eq(next.particles.length(), 16)
}

#CLI

moon run cmd/main prints benchmark rows, an aggregate summary, and a deterministic fingerprint. The reported workload is cells × particles × steps; errors are calculated from each run. Custom experiments can use SimulationScenario, PipelineConfig, ExperimentConfig, or PicConfig and export CSV through the library.

#Architecture

AreaRepresentative modules
Physical relations and unitsconstants.mbt, formulas.mbt, physics_relations_ext.mbt, units.mbt
Grid and field numericsgrid*.mbt, interpolation.mbt, field*.mbt, poisson.mbt, solver_tools.mbt
Particle and distribution modelspic*.mbt, multispecies.mbt, sampling.mbt, shapes.mbt, vlasov*.mbt
Boundaries and dynamicsboundary*.mbt, integrators.mbt, magnetic.mbt, collisions.mbt, fluid.mbt
Analysis and exportmoments.mbt, diagnostics*.mbt, spectra.mbt, phase_space.mbt, dataset.mbt, serialization.mbt
Reproducibilityscenarios.mbt, orchestration.mbt, benchmark_report.mbt, reproducibility.mbt, verification_bundle.mbt

Public interfaces are generated with moon info --target all into pkg.generated.mbti.

#Benchmarks

The deterministic tiny, medium, and large PIC scenarios report configured sizes, computed charge error, energy drift, work units, and a checksum. Run:

moon run cmd/main

The checked-in benchmark report records the output observed during verification; rerun it after changing the toolchain or numerical kernels.

#Tests and numerical boundaries

The suite exercises formulas, degenerate grids, periodic wrapping, field reconstruction, charge deposition, Poisson residuals, shape partition of unity, deterministic sampling, species totals, particle boundaries, Vlasov moments, PIC stepping, spectra, phase-space counts, serialization, and benchmark contracts.

moon test acceptance_test.mbt
moon test advanced_test.mbt
moon test benchmark_test.mbt
moon test physics_test.mbt
moon test system_test.mbt

#CI and release

GitHub Actions tests Linux, macOS, and Windows with the current stable MoonBit installer. It runs dependency update, format verification, warning-free checks across stable targets, all tests, generated API verification, and the CLI smoke test. A separate benchmark workflow uploads CLI output, and the release workflow publishes the package to Mooncakes after the same checks.

#License

Apache-2.0. See LICENSE.

#
ApiEntry

source
pub(all) struct ApiEntry {
  name : String
  category : String
  description : String
} derive(ToJson, 
Debug)

#
BenchmarkRecord

source
pub(all) struct BenchmarkRecord {
  name : String
  cells : Int
  particles : Int
  steps : Int
  work_units : Int
  final_particles : Int
  charge_error : Double
  energy_drift : Double
} derive(ToJson, 
Debug)

#
BenchmarkSample

source
pub(all) struct BenchmarkSample {
  name : String
  cells : Int
  particles : Int
  steps : Int
  energy : Double
} derive(ToJson, 
Debug)

#
BenchmarkSuite

source
pub(all) struct BenchmarkSuite {
  records : Array[BenchmarkRecord]
} derive(ToJson, 
Debug)

#
BenchmarkSuite::maximum_charge_error

source
fn BenchmarkSuite::maximum_charge_error(suite : BenchmarkSuite) -> Double

#
BenchmarkSuite::maximum_energy_drift

source
fn BenchmarkSuite::maximum_energy_drift(suite : BenchmarkSuite) -> Double

#
BenchmarkSuite::total_work

source
fn BenchmarkSuite::total_work(suite : BenchmarkSuite) -> Int

#
Boundary1D

source
pub(all) enum Boundary1D {
  Periodic
  Reflecting
  Absorbing
} derive(Eq, ToJson, 
Debug)

#
BoundaryBatchResult

source
pub(all) struct BoundaryBatchResult {
  alive : Array[Particle]
  absorbed : Int
  reflected : Int
  wrapped : Int
} derive(ToJson, 
Debug)

#
BoundaryResult

source
pub(all) struct BoundaryResult {
  x : Double
  v : Double
  alive : Bool
} derive(ToJson, 
Debug)

#
CflReport

source
pub(all) struct CflReport {
  recommended_dt : Double
  max_displacement : Double
  stable : Bool
} derive(ToJson, 
Debug)

#
CollisionKind

source
pub(all) enum CollisionKind {
  Elastic
  Drag
  Langevin
  Thermalize
} derive(Eq, ToJson, 
Debug)

#
CollisionModel

source
pub(all) struct CollisionModel {
  kind : CollisionKind
  rate : Double
  background_velocity : Double
  thermal_speed : Double
} derive(ToJson, 
Debug)

#
ConservationReport

source
pub(all) struct ConservationReport {
  initial_charge : Double
  final_charge : Double
  charge_drift : Double
  initial_energy : Double
  final_energy : Double
  energy_drift : Double
  particle_count_preserved : Bool
} derive(ToJson, 
Debug)

#
ElectricFieldKind

source
pub(all) enum ElectricFieldKind {
  Constant
  Sinusoidal
  Gaussian
  Linear
  Pulse
} derive(Eq, ToJson, 
Debug)

#
ElectricFieldModel

source
pub(all) struct ElectricFieldModel {
  kind : ElectricFieldKind
  amplitude : Double
  offset : Double
  wave_number : Double
  center : Double
  width : Double
  slope : Double
} derive(ToJson, 
Debug)

#
EnsembleMember

source
pub(all) struct EnsembleMember {
  id : Int
  seed : Int
  diagnostics : Array[PicDiagnostics]
} derive(ToJson, 
Debug)

#
EnsembleSummary

source
pub(all) struct EnsembleSummary {
  members : Int
  mean_final_energy : Double
  spread_final_energy : Double
  mean_charge_error : Double
  maximum_particle_loss : Int
} derive(ToJson, 
Debug)

#
ExperimentConfig

source
pub(all) struct ExperimentConfig {
  name : String
  grid : Grid1D
  steps : Int
  dt : Double
} derive(ToJson, 
Debug)

#
ExperimentConfig::new

source
fn ExperimentConfig::new(name : String, grid : Grid1D, steps : Int, dt : Double) -> ExperimentConfig

#
ExperimentReport

source
pub(all) struct ExperimentReport {
  name : String
  samples : Array[ExperimentSample]
  final_state : PicState
} derive(ToJson, 
Debug)

#
ExperimentSample

source
pub(all) struct ExperimentSample {
  step : Int
  time : Double
  particles : Int
  total_charge : Double
  kinetic_energy : Double
  field_energy : Double
  total_energy : Double
  charge_error : Double
} derive(ToJson, 
Debug)

#
Field1D

source
pub(all) struct Field1D {
  grid : Grid1D
  charge_density : Array[Double]
  electric : Array[Double]
  potential : Array[Double]
} derive(ToJson, 
Debug)

#
Field1D::charge_neutrality_error

source
fn Field1D::charge_neutrality_error(field : Field1D) -> Double

#
Field1D::electric_energy

source
fn Field1D::electric_energy(field : Field1D) -> Double

#
Field1D::electric_range

source
fn Field1D::electric_range(field : Field1D) -> (Double, Double)

#
Field1D::new

source
fn Field1D::new(grid : Grid1D) -> Field1D

#
Field1D::potential_range

source
fn Field1D::potential_range(field : Field1D) -> (Double, Double)

#
FluidFlux

source
pub(all) struct FluidFlux {
  mass : Double
  momentum : Double
  energy : Double
} derive(ToJson, 
Debug)

#
FluidState

source
pub(all) struct FluidState {
  density : Double
  velocity : Double
  pressure : Double
  energy : Double
} derive(ToJson, 
Debug)

#
FluidState::new

source
fn FluidState::new(density : Double, velocity : Double, pressure : Double, energy : Double) -> FluidState

#
Grid1D

source
pub(all) struct Grid1D {
  cells : Int
  length : Double
  dx : Double
} derive(ToJson, 
Debug)

#
Grid1D::cell_index

source
fn Grid1D::cell_index(grid : Grid1D, x : Double) -> Int

#
Grid1D::cell_width

source
fn Grid1D::cell_width(grid : Grid1D) -> Double

#
Grid1D::cells_count

source
fn Grid1D::cells_count(grid : Grid1D) -> Int

#
Grid1D::domain_length

source
fn Grid1D::domain_length(grid : Grid1D) -> Double

#
Grid1D::is_valid

source
fn Grid1D::is_valid(grid : Grid1D) -> Bool

#
Grid1D::new

source
fn Grid1D::new(cells : Int, length : Double) -> Grid1D

#
Grid1D::position

source
fn Grid1D::position(grid : Grid1D, index : Int) -> Double

#
Grid1D::wrap

source
fn Grid1D::wrap(grid : Grid1D, x : Double) -> Double

#
GridDescriptor

source
pub(all) struct GridDescriptor {
  grid : Grid1D
  cell_centers : Array[Double]
  cell_edges : Array[Double]
} derive(ToJson, 
Debug)

#
GridReduction

source
pub(all) struct GridReduction {
  source_cells : Int
  target_cells : Int
  source_length : Double
  values : Array[Double]
} derive(ToJson, 
Debug)

#
HealthCheck

source
pub(all) struct HealthCheck {
  name : String
  passed : Bool
  metric : Double
  threshold : Double
  message : String
} derive(ToJson, 
Debug)

#
InterpolationMode

source
pub(all) enum InterpolationMode {
  Nearest
  Linear
  Quadratic
} derive(Eq, ToJson, 
Debug)

#
InterpolationResult

source
pub(all) struct InterpolationResult {
  value : Double
  left : Int
  right : Int
  fraction : Double
} derive(ToJson, 
Debug)

#
InvariantCheck

source
pub(all) struct InvariantCheck {
  name : String
  passed : Bool
  observed : Double
  tolerance : Double
} derive(ToJson, 
Debug)

#
MagneticField3D

source
pub(all) struct MagneticField3D {
  origin : Vector3
  uniform : Vector3
  gradient : Vector3
} derive(ToJson, 
Debug)

#
MagneticField3D::flux_through_area

source
fn MagneticField3D::flux_through_area(field : MagneticField3D, position : Vector3, normal : Vector3, area : Double) -> Double

#
MagneticField3D::magnitude

source
fn MagneticField3D::magnitude(field : MagneticField3D, position : Vector3) -> Double

#
MagneticField3D::sample

source
fn MagneticField3D::sample(field : MagneticField3D, position : Vector3) -> Vector3

#
Matrix2

source
pub(all) struct Matrix2 {
  a11 : Double
  a12 : Double
  a21 : Double
  a22 : Double
} derive(ToJson, 
Debug)

#
Matrix2::add

source
fn Matrix2::add(a : Matrix2, b : Matrix2) -> Matrix2

#
Matrix2::determinant

source
fn Matrix2::determinant(matrix : Matrix2) -> Double

#
Matrix2::identity

source
fn Matrix2::identity() -> Matrix2

#
Matrix2::inverse

source
fn Matrix2::inverse(matrix : Matrix2) -> Matrix2

#
Matrix2::multiply

source
fn Matrix2::multiply(a : Matrix2, b : Matrix2) -> Matrix2

#
Matrix2::multiply_vector

source
fn Matrix2::multiply_vector(matrix : Matrix2, vector : MatrixVector2) -> MatrixVector2

#
Matrix2::new

source
fn Matrix2::new(a11 : Double, a12 : Double, a21 : Double, a22 : Double) -> Matrix2

#
Matrix2::scale

source
fn Matrix2::scale(a : Matrix2, factor : Double) -> Matrix2

#
Matrix2::transpose

source
fn Matrix2::transpose(matrix : Matrix2) -> Matrix2

#
Matrix2::zero

source
fn Matrix2::zero() -> Matrix2

#
MatrixVector2

source
pub(all) struct MatrixVector2 {
  x : Double
  y : Double
} derive(Eq, ToJson, 
Debug)

#
MatrixVector2::add

source

#
MatrixVector2::distance

source
fn MatrixVector2::distance(a : MatrixVector2, b : MatrixVector2) -> Double

#
MatrixVector2::dot

source
fn MatrixVector2::dot(a : MatrixVector2, b : MatrixVector2) -> Double

#
MatrixVector2::new

source
fn MatrixVector2::new(x : Double, y : Double) -> MatrixVector2

#
MatrixVector2::norm

source
fn MatrixVector2::norm(a : MatrixVector2) -> Double

#
MatrixVector2::scale

source
fn MatrixVector2::scale(a : MatrixVector2, factor : Double) -> MatrixVector2

#
Moments1D

source
pub(all) struct Moments1D {
  density : Array[Double]
  momentum : Array[Double]
  temperature_like : Array[Double]
} derive(ToJson, 
Debug)

#
MultiSpeciesState

source
pub(all) struct MultiSpeciesState {
  grid : Grid1D
  populations : Array[SpeciesPopulation]
  charge_density : Array[Double]
  field : Field1D
  time : Double
} derive(ToJson, 
Debug)

#
MultiSpeciesState::current_density

source
fn MultiSpeciesState::current_density(state : MultiSpeciesState) -> Array[Double]

#
MultiSpeciesState::flatten

source

#
MultiSpeciesState::kinetic_energy

source
fn MultiSpeciesState::kinetic_energy(state : MultiSpeciesState) -> Double

#
MultiSpeciesState::new

source

#
MultiSpeciesState::number_density

source
fn MultiSpeciesState::number_density(state : MultiSpeciesState) -> Array[Double]

#
MultiSpeciesState::particle_count

source
fn MultiSpeciesState::particle_count(state : MultiSpeciesState) -> Int

#
MultiSpeciesState::population

source
fn MultiSpeciesState::population(state : MultiSpeciesState, index : Int) -> SpeciesPopulation?

#
MultiSpeciesState::run

source
fn MultiSpeciesState::run(state : MultiSpeciesState, dt : Double, steps : Int) -> MultiSpeciesState

#
MultiSpeciesState::species_count

source
fn MultiSpeciesState::species_count(state : MultiSpeciesState) -> Int

#
MultiSpeciesState::step

source
fn MultiSpeciesState::step(state : MultiSpeciesState, dt : Double) -> MultiSpeciesState

#
MultiSpeciesState::total_charge

source
fn MultiSpeciesState::total_charge(state : MultiSpeciesState) -> Double

#
MultiSpeciesState::total_energy

source
fn MultiSpeciesState::total_energy(state : MultiSpeciesState) -> Double

#
MultiSpeciesState::total_mass

source
fn MultiSpeciesState::total_mass(state : MultiSpeciesState) -> Double

#
NumericTable

source
pub(all) struct NumericTable {
  columns : Array[String]
  rows : Array[Array[Double]]
} derive(ToJson, 
Debug)

#
NumericTable::add_row

source
fn NumericTable::add_row(table : NumericTable, row : Array[Double]) -> Unit

#
NumericTable::column

source
fn NumericTable::column(table : NumericTable, index : Int) -> String?

#
NumericTable::column_count

source
fn NumericTable::column_count(table : NumericTable) -> Int

#
NumericTable::new

source
fn NumericTable::new(columns : Array[String]) -> NumericTable

#
NumericTable::row

source
fn NumericTable::row(table : NumericTable, index : Int) -> Array[Double]?

#
NumericTable::row_count

source
fn NumericTable::row_count(table : NumericTable) -> Int

#
NumericTable::to_csv

source
fn NumericTable::to_csv(table : NumericTable) -> String

#
NumericTable::transpose

source
fn NumericTable::transpose(table : NumericTable) -> NumericTable

#
Observable

source
pub(all) struct Observable {
  name : String
  unit : String
  values : Array[Double]
} derive(ToJson, 
Debug)

#
Observable::count

source
fn Observable::count(observable : Observable) -> Int

#
Observable::maximum

source
fn Observable::maximum(observable : Observable) -> Double

#
Observable::mean

source
fn Observable::mean(observable : Observable) -> Double

#
Observable::minimum

source
fn Observable::minimum(observable : Observable) -> Double

#
Observable::new

source
fn Observable::new(name : String, unit : String, values : Array[Double]) -> Observable

#
Observable::normalize

source
fn Observable::normalize(observable : Observable) -> Observable

#
Observable::range

source
fn Observable::range(observable : Observable) -> Double

#
Observable::scale

source
fn Observable::scale(observable : Observable, factor : Double) -> Observable

#
Observable::shift

source
fn Observable::shift(observable : Observable, amount : Double) -> Observable

#
Observable::summary

source
fn Observable::summary(observable : Observable) -> SeriesSummary

#
Observable::to_csv

source
fn Observable::to_csv(observable : Observable) -> String

#
Particle

source
pub(all) struct Particle {
  x : Double
  v : Double
  weight : Double
  charge : Double
  mass : Double
} derive(ToJson, 
Debug)

#
Particle::new

source
fn Particle::new(x~ : Double, v~ : Double, weight? : Double, charge? : Double, mass? : Double) -> Particle

#
PhaseSpaceGrid

source
pub(all) struct PhaseSpaceGrid {
  x_bins : Int
  v_bins : Int
  x_min : Double
  x_max : Double
  v_min : Double
  v_max : Double
  counts : Array[Int]
} derive(ToJson, 
Debug)

#
PhaseSpaceGrid::index

source
fn PhaseSpaceGrid::index(grid : PhaseSpaceGrid, x_index : Int, v_index : Int) -> Int

#
PhaseSpaceGrid::new

source
fn PhaseSpaceGrid::new(x_bins : Int, v_bins : Int, x_min : Double, x_max : Double, v_min : Double, v_max : Double) -> PhaseSpaceGrid

#
PhaseSpaceGrid::total_count

source
fn PhaseSpaceGrid::total_count(grid : PhaseSpaceGrid) -> Int

#
PhaseSpaceGrid::v_index

source
fn PhaseSpaceGrid::v_index(grid : PhaseSpaceGrid, v : Double) -> Int

#
PhaseSpaceGrid::v_width

source
fn PhaseSpaceGrid::v_width(grid : PhaseSpaceGrid) -> Double

#
PhaseSpaceGrid::x_index

source
fn PhaseSpaceGrid::x_index(grid : PhaseSpaceGrid, x : Double) -> Int

#
PhaseSpaceGrid::x_width

source
fn PhaseSpaceGrid::x_width(grid : PhaseSpaceGrid) -> Double

#
PicConfig

source
pub(all) struct PicConfig {
  grid : Grid1D
  dt : Double
  steps : Int
  shape : ShapeKind
  boundary : Boundary1D
} derive(ToJson, 
Debug)

#
PicConfig::new

source
fn PicConfig::new(grid : Grid1D, dt : Double, steps : Int) -> PicConfig

#
PicConfig::validate

source
fn PicConfig::validate(config : PicConfig) -> ValidationReport

#
PicConfig::with_boundary

source
fn PicConfig::with_boundary(config : PicConfig, boundary : Boundary1D) -> PicConfig

#
PicConfig::with_shape

source
fn PicConfig::with_shape(config : PicConfig, shape : ShapeKind) -> PicConfig

#
PicDiagnostics

source
pub(all) struct PicDiagnostics {
  time : Double
  particles : Int
  total_charge : Double
  kinetic_energy : Double
  field_energy : Double
  center_of_mass : Double
  mean_velocity : Double
  velocity_variance : Double
} derive(ToJson, 
Debug)

#
PicDiagnostics::from_state

source
fn PicDiagnostics::from_state(state : PicState) -> PicDiagnostics

#
PicDiagnostics::total_energy

source
fn PicDiagnostics::total_energy(d : PicDiagnostics) -> Double

#
PicQuality

source
pub(all) struct PicQuality {
  finite : Bool
  nonnegative_density : Bool
  energy_drift : Double
  charge_error : Double
} derive(ToJson, 
Debug)

#
PicSeriesSummary

source
pub(all) struct PicSeriesSummary {
  samples : Int
  particles_initial : Int
  particles_final : Int
  charge_drift : Double
  energy_drift : Double
  maximum_field : Double
} derive(ToJson, 
Debug)

#
PicState

source
pub(all) struct PicState {
  grid : Grid1D
  particles : Array[Particle]
  field : Field1D
  time : Double
} derive(ToJson, 
Debug)

#
PicState::new

source
fn PicState::new(grid : Grid1D, particles : Array[Particle]) -> PicState

#
PicState::run

source
fn PicState::run(state : PicState, dt : Double, steps : Int) -> PicState

#
PicState::step

source
fn PicState::step(state : PicState, dt : Double) -> PicState

#
PipelineConfig

source
pub(all) struct PipelineConfig {
  name : String
  grid : Grid1D
  particles : Int
  steps : Int
  dt : Double
  shape : ShapeKind
  boundary : Boundary1D
} derive(ToJson, 
Debug)

#
PipelineConfig::new

source
fn PipelineConfig::new(name : String, grid : Grid1D, particles : Int, steps : Int, dt : Double) -> PipelineConfig

#
PipelineConfig::with_boundary

source
fn PipelineConfig::with_boundary(config : PipelineConfig, boundary : Boundary1D) -> PipelineConfig

#
PipelineConfig::with_shape

source
fn PipelineConfig::with_shape(config : PipelineConfig, shape : ShapeKind) -> PipelineConfig

#
PipelineFrame

source
pub(all) struct PipelineFrame {
  step : Int
  state : PicState
  diagnostics : PicDiagnostics
} derive(ToJson, 
Debug)

#
PipelineResult

source
pub(all) struct PipelineResult {
  config : PipelineConfig
  frames : Array[PipelineFrame]
} derive(ToJson, 
Debug)

#
PipelineResult::charge_errors

source
fn PipelineResult::charge_errors(result : PipelineResult) -> Array[Double]

#
PipelineResult::energies

source
fn PipelineResult::energies(result : PipelineResult) -> Array[Double]

#
PipelineResult::final_frame

source
fn PipelineResult::final_frame(result : PipelineResult) -> PipelineFrame?

#
PipelineResult::times

source
fn PipelineResult::times(result : PipelineResult) -> Array[Double]

#
PlasmaBenchmarkCase

source
pub(all) struct PlasmaBenchmarkCase {
  name : String
  cells : Int
  particles : Int
  steps : Int
  initial_energy : Double
  final_energy : Double
  charge_error : Double
} derive(ToJson, 
Debug)

#
PlasmaBenchmarkReport

source
pub(all) struct PlasmaBenchmarkReport {
  cases : Array[PlasmaBenchmarkCase]
  total_steps : Int
} derive(ToJson, 
Debug)

#
PoissonResult

source
pub(all) struct PoissonResult {
  potential : Array[Double]
  residual : Double
  iterations : Int
  converged : Bool
} derive(ToJson, 
Debug)

#
Profile1D

source
pub(all) struct Profile1D {
  kind : ProfileKind
  base : Double
  amplitude : Double
  center : Double
  width : Double
  wave_number : Double
  floor : Double
} derive(ToJson, 
Debug)

#
ProfileKind

source
pub(all) enum ProfileKind {
  Constant
  Gaussian
  Sinusoid
  Ramp
  DoubleHump
  TopHat
} derive(Eq, ToJson, 
Debug)

#
QualityMetric

source
pub(all) struct QualityMetric {
  name : String
  value : Double
  tolerance : Double
  passed : Bool
} derive(ToJson, 
Debug)

#
RandomStream

source
pub(all) struct RandomStream {
  state : Int
} derive(ToJson, 
Debug)

#
RandomStream::new

source
fn RandomStream::new(seed : Int) -> RandomStream

#
RandomStream::next_int

source
fn RandomStream::next_int(stream : RandomStream) -> Int

#
RandomStream::next_signed

source
fn RandomStream::next_signed(stream : RandomStream) -> Double

#
RandomStream::next_unit

source
fn RandomStream::next_unit(stream : RandomStream) -> Double

#
RelaxationResult

source
pub(all) struct RelaxationResult {
  values : Array[Double]
  residuals : Array[Double]
  iterations : Int
  converged : Bool
} derive(ToJson, 
Debug)

#
ReproducibilityManifest

source
pub(all) struct ReproducibilityManifest {
  name : String
  seed : Int
  cells : Int
  particles : Int
  steps : Int
  dt : Double
  shape : String
  boundary : String
  toolchain : String
} derive(ToJson, 
Debug)

#
ResultFingerprint

source
pub(all) struct ResultFingerprint {
  sample_count : Int
  work_units : Int
  charge_error : Double
  energy_drift : Double
  checksum : Int
} derive(ToJson, 
Debug)

#
SamplingConfig

source
pub(all) struct SamplingConfig {
  count : Int
  seed : Int
  drift : Double
  spread : Double
  profile : Profile1D
} derive(ToJson, 
Debug)

#
SamplingConfig::new

source
fn SamplingConfig::new(count : Int, seed : Int, drift : Double, spread : Double) -> SamplingConfig

#
SamplingConfig::sample

source
fn SamplingConfig::sample(config : SamplingConfig, grid : Grid1D) -> Array[Particle]

#
SamplingConfig::validate

source

#
SeriesSummary

source
pub(all) struct SeriesSummary {
  name : String
  count : Int
  minimum : Double
  maximum : Double
  mean : Double
  rms : Double
  span : Double
} derive(ToJson, 
Debug)

#
ShapeContribution

source
pub(all) struct ShapeContribution {
  index : Int
  weight : Double
} derive(ToJson, 
Debug)

#
ShapeKind

source
pub(all) enum ShapeKind {
  NGP
  CIC
  TSC
} derive(Eq, ToJson, 
Debug)

#
ShapeWeights

source
pub(all) struct ShapeWeights {
  contributions : Array[ShapeContribution]
  total : Double
  count : Int
} derive(ToJson, 
Debug)

#
SimulationScenario

source
pub(all) struct SimulationScenario {
  name : String
  grid : Grid1D
  particles : Int
  steps : Int
  dt : Double
  boundary : Boundary1D
  shape : ShapeKind
  seed : Int
} derive(ToJson, 
Debug)

#
Species

source
pub(all) struct Species {
  name : String
  charge : Double
  mass : Double
} derive(ToJson, 
Debug)

#
Species::electron

source
fn Species::electron() -> Species

#
Species::gyro_frequency

source
fn Species::gyro_frequency(species : Species, magnetic_field_t : Double) -> Double

#
Species::ion

source
fn Species::ion(name : String, charge_state : Int, mass_kg : Double) -> Species

#
Species::plasma_frequency

source
fn Species::plasma_frequency(species : Species, density_m3 : Double) -> Double

#
Species::proton

source
fn Species::proton() -> Species

#
Species::thermal_velocity

source
fn Species::thermal_velocity(species : Species, temperature_k : Double) -> Double

#
SpeciesPopulation

source
pub(all) struct SpeciesPopulation {
  species : Species
  particles : Array[Particle]
} derive(ToJson, 
Debug)

#
SpeciesPopulation::charge

source
fn SpeciesPopulation::charge(population : SpeciesPopulation) -> Double

#
SpeciesPopulation::count

source
fn SpeciesPopulation::count(population : SpeciesPopulation) -> Int

#
SpeciesPopulation::mass

source
fn SpeciesPopulation::mass(population : SpeciesPopulation) -> Double

#
SpeciesPopulation::new

source
fn SpeciesPopulation::new(species : Species, particles : Array[Particle]) -> SpeciesPopulation

#
SpectrumBin

source
pub(all) struct SpectrumBin {
  mode : Int
  frequency : Double
  real : Double
  imaginary : Double
  power : Double
} derive(ToJson, 
Debug)

#
TimeSeries

source
pub(all) struct TimeSeries {
  name : String
  times : Array[Double]
  values : Array[Double]
} derive(ToJson, 
Debug)

#
TimeSeries::derivative

source
fn TimeSeries::derivative(series : TimeSeries) -> Array[Double]

#
TimeSeries::difference

source
fn TimeSeries::difference(first : TimeSeries, second : TimeSeries) -> TimeSeries

#
TimeSeries::integral

source
fn TimeSeries::integral(series : TimeSeries) -> Double

#
TimeSeries::is_monotonic_time

source
fn TimeSeries::is_monotonic_time(series : TimeSeries) -> Bool

#
TimeSeries::last_time

source
fn TimeSeries::last_time(series : TimeSeries) -> Double

#
TimeSeries::last_value

source
fn TimeSeries::last_value(series : TimeSeries) -> Double

#
TimeSeries::length

source
fn TimeSeries::length(series : TimeSeries) -> Int

#
TimeSeries::maximum

source
fn TimeSeries::maximum(series : TimeSeries) -> Double

#
TimeSeries::mean

source
fn TimeSeries::mean(series : TimeSeries) -> Double

#
TimeSeries::minimum

source
fn TimeSeries::minimum(series : TimeSeries) -> Double

#
TimeSeries::moving_average

source
fn TimeSeries::moving_average(series : TimeSeries, width : Int) -> Array[Double]

#
TimeSeries::new

source
fn TimeSeries::new(name : String) -> TimeSeries

#
TimeSeries::push

source
fn TimeSeries::push(series : TimeSeries, time : Double, value : Double) -> Unit

#
TimeSeries::resample

source
fn TimeSeries::resample(series : TimeSeries, count : Int) -> TimeSeries

#
TimeSeries::scale

source
fn TimeSeries::scale(series : TimeSeries, factor : Double) -> TimeSeries

#
TimeSeries::shift

source
fn TimeSeries::shift(series : TimeSeries, amount : Double) -> TimeSeries

#
TimeSeries::summary

source
fn TimeSeries::summary(series : TimeSeries) -> SeriesSummary

#
TimeSeries::time_span

source
fn TimeSeries::time_span(series : TimeSeries) -> Double

#
TimeSeries::to_csv

source
fn TimeSeries::to_csv(series : TimeSeries) -> String

#
UnitScales

source
pub(all) struct UnitScales {
  length : Double
  density : Double
  time : Double
  mass : Double
  charge : Double
  temperature : Double
  magnetic : Double
} derive(ToJson, 
Debug)

#
UnitScales::si

source
fn UnitScales::si(length : Double, density : Double, time : Double) -> UnitScales

#
ValidationIssue

source
pub(all) struct ValidationIssue {
  code : String
  message : String
  value : Double
} derive(ToJson, 
Debug)

#
ValidationReport

source
pub(all) struct ValidationReport {
  valid : Bool
  issues : Array[ValidationIssue]
} derive(ToJson, 
Debug)

#
Vector3

source
pub(all) struct Vector3 {
  x : Double
  y : Double
  z : Double
} derive(Eq, ToJson, 
Debug)

#
Vector3::add

source
fn Vector3::add(a : Vector3, b : Vector3) -> Vector3

#
Vector3::component_max

source
fn Vector3::component_max(a : Vector3, b : Vector3) -> Vector3

#
Vector3::component_min

source
fn Vector3::component_min(a : Vector3, b : Vector3) -> Vector3

#
Vector3::cross

source
fn Vector3::cross(a : Vector3, b : Vector3) -> Vector3

#
Vector3::distance

source
fn Vector3::distance(a : Vector3, b : Vector3) -> Double

#
Vector3::dot

source
fn Vector3::dot(a : Vector3, b : Vector3) -> Double

#
Vector3::new

source
fn Vector3::new(x : Double, y : Double, z : Double) -> Vector3

#
Vector3::norm

source
fn Vector3::norm(a : Vector3) -> Double

#
Vector3::normalized

source
fn Vector3::normalized(a : Vector3) -> Vector3

#
Vector3::scale

source
fn Vector3::scale(a : Vector3, factor : Double) -> Vector3

#
Vector3::sub

source
fn Vector3::sub(a : Vector3, b : Vector3) -> Vector3

#
Vector3::zero

source
fn Vector3::zero() -> Vector3

#
VerificationBundle

source
pub(all) struct VerificationBundle {
  scenario : SimulationScenario
  manifest : ReproducibilityManifest
  fingerprint : ResultFingerprint
  metrics : Array[QualityMetric]
  invariants : Array[InvariantCheck]
} derive(ToJson, 
Debug)

#
VerificationBundle::invariant_report

source
fn VerificationBundle::invariant_report(bundle : VerificationBundle) -> String

#
VerificationBundle::metric_report

source
fn VerificationBundle::metric_report(bundle : VerificationBundle) -> String

#
VerificationBundle::passed

source
fn VerificationBundle::passed(bundle : VerificationBundle) -> Bool

#
VerificationBundle::reproducibility_report

source
fn VerificationBundle::reproducibility_report(bundle : VerificationBundle) -> String

#
VerificationBundle::summary

source
fn VerificationBundle::summary(bundle : VerificationBundle) -> String

#
VerificationBundle::to_csv

source
fn VerificationBundle::to_csv(bundle : VerificationBundle) -> String

#
VerificationBundle::work_units

source
fn VerificationBundle::work_units(bundle : VerificationBundle) -> Int

#
VerletState

source
pub(all) struct VerletState {
  position : Double
  velocity : Double
  acceleration : Double
} derive(ToJson, 
Debug)

#
VerletState::new

source
fn VerletState::new(position : Double, velocity : Double, acceleration : Double) -> VerletState

#
VlasovConfig

source
pub(all) struct VlasovConfig {
  grid : Grid1D
  velocity_min : Double
  velocity_max : Double
  velocity_bins : Int
  dt : Double
} derive(ToJson, 
Debug)

#
VlasovConfig::dv

source
fn VlasovConfig::dv(config : VlasovConfig) -> Double

#
VlasovConfig::new

source
fn VlasovConfig::new(grid : Grid1D, velocity_min~ : Double, velocity_max~ : Double, velocity_bins~ : Int, dt~ : Double) -> VlasovConfig

#
VlasovConfig::velocity

source
fn VlasovConfig::velocity(config : VlasovConfig, bin : Int) -> Double

#
VlasovState

source
pub(all) struct VlasovState {
  config : VlasovConfig
  distribution : Array[Double]
  charge_density : Array[Double]
  time : Double
} derive(ToJson, 
Debug)

#
VlasovState::step

source
fn VlasovState::step(state : VlasovState) -> VlasovState

#
VlasovStepReport

source
pub(all) struct VlasovStepReport {
  before_mass : Double
  after_mass : Double
  mass_error : Double
  minimum : Double
  maximum : Double
  time : Double
} derive(ToJson, 
Debug)

#
VlasovSummary

source
pub(all) struct VlasovSummary {
  density_mean : Double
  density_minimum : Double
  density_maximum : Double
  momentum_mean : Double
  kinetic_energy : Double
  entropy : Double
} derive(ToJson, 
Debug)

#
accelerate_particles

source
fn accelerate_particles(particles : ArrayView[Particle], acceleration : Double, dt : Double) -> Array[Particle]

#
acceleration_from_field

source
fn acceleration_from_field(particle : Particle, electric : Double) -> Double

#
acceptance_benchmark_csv

source
fn acceptance_benchmark_csv() -> String

#
acceptance_benchmark_summary

source
fn acceptance_benchmark_summary() -> String

#
acceptance_fingerprint_csv

source
fn acceptance_fingerprint_csv() -> String

#
acoustic_mach

source
fn acoustic_mach(velocity : Double, sound : Double) -> Double

#
add_profile

source
fn add_profile(a : ArrayView[Double], b : ArrayView[Double]) -> Array[Double]

#
advance_leapfrog

source
fn advance_leapfrog(position : Double, velocity : Double, acceleration : Double, dt : Double) -> (Double, Double)

#
advance_particles

source
fn advance_particles(grid : Grid1D, particles : ArrayView[Particle], electric : ArrayView[Double], dt : Double) -> Array[Particle]

#
advance_verlet

source
fn advance_verlet(state : VerletState, dt : Double, next_acceleration : Double) -> VerletState

#
alfven_speed

source
fn alfven_speed(magnetic_field : Double, density : Double, mass : Double) -> Double

#
all_close

source
fn all_close(a : ArrayView[Double], b : ArrayView[Double], absolute : Double, relative : Double) -> Bool

#
all_metrics_pass

source
fn all_metrics_pass(metrics : ArrayView[QualityMetric]) -> Bool

#
analysis_summary

source
fn analysis_summary(values : ArrayView[Double]) -> String

#
angular_frequency

source
fn angular_frequency(charge : Double, magnetic : Vector3, mass : Double) -> Double

#
angular_frequency_from_frequency

source
fn angular_frequency_from_frequency(frequency : Double) -> Double

#
api_catalog

source
fn api_catalog() -> Array[ApiEntry]

#
api_catalog_categories

source
fn api_catalog_categories() -> Array[String]

#
api_catalog_contains

source
fn api_catalog_contains(name : String) -> Bool

#
api_catalog_to_csv

source
fn api_catalog_to_csv() -> String

#
apply_boundary

source
fn apply_boundary(grid : Grid1D, boundary : Boundary1D, x : Double, v : Double) -> BoundaryResult

#
apply_boundary_to_particle

source
fn apply_boundary_to_particle(grid : Grid1D, boundary : Boundary1D, particle : Particle) -> Particle?

#
apply_collision

source
fn apply_collision(particle : Particle, model : CollisionModel, dt : Double, noise : Double) -> Particle

#
apply_collisions

source
fn apply_collisions(particles : ArrayView[Particle], model : CollisionModel, dt : Double, noise : ArrayView[Double]) -> Array[Particle]

#
apply_drag

source
fn apply_drag(particle : Particle, rate : Double, dt : Double, background_velocity : Double) -> Particle

#
apply_particle_boundary_batch

source
fn apply_particle_boundary_batch(grid : Grid1D, boundary : Boundary1D, particles : ArrayView[Particle]) -> BoundaryBatchResult

#
apply_reflecting_position

source
fn apply_reflecting_position(grid : Grid1D, x : Double, v : Double) -> (Double, Double)

#
approximate_log

source
fn approximate_log(value : Double) -> Double

#
assess_pic_cfl

source
fn assess_pic_cfl(grid : Grid1D, maximum_speed~ : Double, dt~ : Double, safety_factor~ : Double) -> CflReport

#
assess_pic_quality

source
fn assess_pic_quality(state : PicState) -> PicQuality

#
assess_vlasov_cfl

source
fn assess_vlasov_cfl(config : VlasovConfig) -> CflReport

#
autocorrelation

source
fn autocorrelation(signal : ArrayView[Double], lag : Int) -> Double

#
autocorrelation_series

source
fn autocorrelation_series(signal : ArrayView[Double]) -> Array[Double]

#
average_reductions

source
fn average_reductions(reductions : ArrayView[GridReduction]) -> Array[Double]

#
backward_difference

source
fn backward_difference(grid : Grid1D, values : ArrayView[Double], index : Int) -> Double

#
benchmark_fingerprint_suite

source
fn benchmark_fingerprint_suite(suite : BenchmarkSuite) -> Array[ResultFingerprint]

#
benchmark_health

source
fn benchmark_health(record : BenchmarkRecord) -> Array[HealthCheck]

#
benchmark_record_to_json_like

source
fn benchmark_record_to_json_like(record : BenchmarkRecord) -> String

#
benchmark_report_csv

source
fn benchmark_report_csv(report : PlasmaBenchmarkReport) -> String

#
benchmark_scenario

source
fn benchmark_scenario(scenario : SimulationScenario) -> BenchmarkRecord

#
benchmark_suite

source
fn benchmark_suite() -> BenchmarkSuite

#
benchmark_suite_summary

source
fn benchmark_suite_summary(suite : BenchmarkSuite) -> String

#
benchmark_suite_to_csv

source
fn benchmark_suite_to_csv(suite : BenchmarkSuite) -> String

#
benchmark_to_csv

source
fn benchmark_to_csv(sample : BenchmarkSample) -> String

#
boltzmann_constant

source
let boltzmann_constant : Double

#
boris_position

source
fn boris_position(position : Vector3, velocity : Vector3, dt : Double) -> Vector3

#
boris_push

source
fn boris_push(velocity : Vector3, electric : Vector3, magnetic : Vector3, dt : Double, charge : Double, mass : Double) -> Vector3

#
boundary_loss_fraction

source
fn boundary_loss_fraction(result : BoundaryBatchResult, original_count : Int) -> Double

#
boundary_name

source
fn boundary_name(boundary : Boundary1D) -> String

#
boundary_positions

source
fn boundary_positions(grid : Grid1D, particles : ArrayView[Particle]) -> Array[Double]

#
boundary_reflection_fraction

source
fn boundary_reflection_fraction(result : BoundaryBatchResult, original_count : Int) -> Double

#
boundary_valid

source
fn boundary_valid(grid : Grid1D, particles : ArrayView[Particle]) -> Bool

#
boundary_velocity_flux

source
fn boundary_velocity_flux(grid : Grid1D, particles : ArrayView[Particle]) -> Double

#
boundary_wrap_fraction

source
fn boundary_wrap_fraction(result : BoundaryBatchResult, original_count : Int) -> Double

#
build_verification_bundle

source
fn build_verification_bundle(scenario : SimulationScenario, toolchain : String) -> VerificationBundle

#
center_of_mass

source
fn center_of_mass(grid : Grid1D, particles : ArrayView[Particle]) -> Double

#
central_difference

source
fn central_difference(grid : Grid1D, values : ArrayView[Double], index : Int) -> Double

#
central_interpolate

source
fn central_interpolate(first : Double, second : Double, fraction : Double) -> Double

#
cfl_ratio

source
fn cfl_ratio(report : CflReport) -> Double

#
charge_conservation_error

source
fn charge_conservation_error(grid : Grid1D, densities : ArrayView[Array[Double]], expected : Double) -> Double

#
charge_neutralize

source
fn charge_neutralize(_grid : Grid1D, density : ArrayView[Double]) -> Array[Double]

#
charge_series

source
fn charge_series(grid : Grid1D, densities : ArrayView[Array[Double]]) -> Array[Double]

#
clamp

source
fn clamp(value : Double, low : Double, high : Double) -> Double

#
clamp_index

source
fn clamp_index(index : Int, length : Int) -> Int

#
clamp_int

source
fn clamp_int(value : Int, low : Int, high : Int) -> Int

#
clamp_time_step

source
fn clamp_time_step(value : Double, minimum : Double, maximum : Double) -> Double

#
cli_help

source
fn cli_help() -> String

#
collision_energy_loss

source
fn collision_energy_loss(particle : Particle, after : Particle) -> Double

#
collision_frequency

source
fn collision_frequency(density : Double, charge : Double, mass : Double, temperature : Double, log_lambda : Double) -> Double

#
collision_model

source
fn collision_model(kind : CollisionKind, rate : Double, background_velocity : Double, thermal_speed : Double) -> CollisionModel

#
collision_probability

source
fn collision_probability(rate : Double, dt : Double) -> Double

#
collision_rate_for_species

source
fn collision_rate_for_species(species : Species, density : Double, temperature : Double, log_lambda : Double) -> Double

#
collision_summary

source
fn collision_summary(particles : ArrayView[Particle], model : CollisionModel, dt : Double) -> (Double, Double)

#
collision_temperature

source
fn collision_temperature(particles : ArrayView[Particle], mass : Double) -> Double

#
combine_electric_models

source
fn combine_electric_models(first : ElectricFieldModel, second : ElectricFieldModel) -> ElectricFieldModel

#
compare_metric_sets

source
fn compare_metric_sets(first : ArrayView[QualityMetric], second : ArrayView[QualityMetric]) -> Double

#
compare_scenarios

source
fn compare_scenarios(first : SimulationScenario, second : SimulationScenario) -> Bool

#
config_to_csv

source
fn config_to_csv(config : PicConfig) -> String

#
conservation_report

source
fn conservation_report(charges : ArrayView[Double], energies : ArrayView[Double]) -> ConservationReport

#
constant_electric_field

source
fn constant_electric_field(value : Double) -> ElectricFieldModel

#
convergence_order

source
fn convergence_order(errors : ArrayView[Double], step_ratio : Double) -> Double

#
copy_values

source
fn copy_values(values : ArrayView[Double]) -> Array[Double]

#
correlation

source
fn correlation(first : ArrayView[Double], second : ArrayView[Double]) -> Double

#
coulomb_logarithm

source
fn coulomb_logarithm(debye_length_m : Double, impact_parameter_m : Double) -> Double

#
covariance

source
fn covariance(first : ArrayView[Double], second : ArrayView[Double]) -> Double

#
csv_escape

source
fn csv_escape(value : String) -> String

#
csv_header

source
fn csv_header(columns : ArrayView[String]) -> String

#
csv_row

source
fn csv_row(values : ArrayView[Double]) -> String

#
cumulative_series

source
fn cumulative_series(values : ArrayView[Double], spacing : Double) -> Array[Double]

#
curl_1d

source
fn curl_1d(grid : Grid1D, values : ArrayView[Double]) -> Array[Double]

#
cyclotron_period

source
fn cyclotron_period(charge : Double, magnetic : Vector3, mass : Double) -> Double

#
debye_length

source
fn debye_length(electron_temperature_k : Double, electron_density_m3 : Double) -> Double

#
denormalize_charge

source
fn denormalize_charge(scales : UnitScales, value : Double) -> Double

#
denormalize_density

source
fn denormalize_density(scales : UnitScales, value : Double) -> Double

#
denormalize_electric_field

source
fn denormalize_electric_field(scales : UnitScales, value : Double) -> Double

#
denormalize_length

source
fn denormalize_length(scales : UnitScales, value : Double) -> Double

#
denormalize_mass

source
fn denormalize_mass(scales : UnitScales, value : Double) -> Double

#
denormalize_temperature

source
fn denormalize_temperature(scales : UnitScales, value : Double) -> Double

#
denormalize_time

source
fn denormalize_time(scales : UnitScales, value : Double) -> Double

#
denormalize_velocity

source
fn denormalize_velocity(scales : UnitScales, value : Double) -> Double

#
deposit_charge

source
fn deposit_charge(grid : Grid1D, particles : ArrayView[Particle]) -> Array[Double]

#
deposit_charge_with_shape

source
fn deposit_charge_with_shape(grid : Grid1D, particles : ArrayView[Particle], kind : ShapeKind) -> Array[Double]

#
deposit_number_with_shape

source
fn deposit_number_with_shape(grid : Grid1D, particles : ArrayView[Particle], kind : ShapeKind) -> Array[Double]

#
deposit_with_shape

source
fn deposit_with_shape(grid : Grid1D, positions : ArrayView[Double], values : ArrayView[Double], kind : ShapeKind) -> Array[Double]

#
describe_grid

source
fn describe_grid(grid : Grid1D) -> GridDescriptor

#
deterministic_seed

source
fn deterministic_seed(name : String, salt : Int) -> Int

#
diagnostics_to_csv

source
fn diagnostics_to_csv(samples : ArrayView[PicDiagnostics]) -> String

#
diagonal_solve

source
fn diagonal_solve(diagonal : ArrayView[Double], right_hand_side : ArrayView[Double]) -> Array[Double]

#
dimensionless_length

source
fn dimensionless_length(length : Double, scale : Double) -> Double

#
dimensionless_time

source
fn dimensionless_time(time : Double, frequency : Double) -> Double

#
dipole_magnetic_field

source
fn dipole_magnetic_field(moment : Vector3, position : Vector3, coefficient : Double) -> Vector3

#
discrete_spectrum

source
fn discrete_spectrum(signal : ArrayView[Double]) -> Array[SpectrumBin]

#
distribution_entropy

source
fn distribution_entropy(state : VlasovState) -> Double

#
distribution_integral

source
fn distribution_integral(state : VlasovState) -> Double

#
distribution_is_nonnegative

source
fn distribution_is_nonnegative(distribution : ArrayView[Double]) -> Bool

#
distribution_kinetic_energy

source
fn distribution_kinetic_energy(state : VlasovState, mass : Double) -> Double

#
distribution_mass_error

source
fn distribution_mass_error(config : VlasovConfig, left : ArrayView[Double], right : ArrayView[Double]) -> Double

#
distribution_maximum

source
fn distribution_maximum(state : VlasovState) -> Double

#
distribution_mean_velocity

source
fn distribution_mean_velocity(config : VlasovConfig, distribution : ArrayView[Double]) -> Double

#
distribution_minimum

source
fn distribution_minimum(state : VlasovState) -> Double

#
distribution_negative_mass

source
fn distribution_negative_mass(state : VlasovState) -> Double

#
distribution_positive_part

source
fn distribution_positive_part(state : VlasovState) -> Array[Double]

#
distribution_sum

source
fn distribution_sum(config : VlasovConfig, distribution : ArrayView[Double]) -> Double

#
distribution_temperature_like

source
fn distribution_temperature_like(config : VlasovConfig, distribution : ArrayView[Double]) -> Double

#
divergence_periodic

source
fn divergence_periodic(grid : Grid1D, values : ArrayView[Double]) -> Array[Double]

#
dominant_frequency

source
fn dominant_frequency(spectrum : ArrayView[SpectrumBin]) -> Int

#
downsample_mean

source
fn downsample_mean(values : ArrayView[Double], factor : Int) -> Array[Double]

#
drag_factor

source
fn drag_factor(rate : Double, dt : Double) -> Double

#
drift_series

source
fn drift_series(values : ArrayView[Double]) -> Array[Double]

#
electric_field_value

source
fn electric_field_value(model : ElectricFieldModel, x : Double) -> Double

#
electric_field_values

source
fn electric_field_values(grid : Grid1D, model : ElectricFieldModel) -> Array[Double]

#
electric_force

source
fn electric_force(charge : Double, electric : Vector3) -> Vector3

#
electric_from_potential

source
fn electric_from_potential(grid : Grid1D, potential : ArrayView[Double]) -> Array[Double]

#
electric_potential_value

source
fn electric_potential_value(model : ElectricFieldModel, x : Double) -> Double

#
electron_mass

source
let electron_mass : Double

#
electron_plasma_frequency

source
fn electron_plasma_frequency(electron_density_m3 : Double) -> Double

#
electron_thermal_velocity

source
fn electron_thermal_velocity(temperature_k : Double) -> Double

#
electrostatic_energy

source
fn electrostatic_energy(grid : Grid1D, electric : ArrayView[Double]) -> Double

#
electrostatic_energy_density

source
fn electrostatic_energy_density(electric : ArrayView[Double]) -> Array[Double]

#
elementary_charge

source
let elementary_charge : Double

#
energy_series

source
fn energy_series(particles : ArrayView[Array[Particle]], fields : ArrayView[Field1D]) -> Array[Double]

#
ensemble_charge_errors

source
fn ensemble_charge_errors(members : ArrayView[EnsembleMember]) -> Array[Double]

#
ensemble_diagnostics_to_csv

source
fn ensemble_diagnostics_to_csv(members : ArrayView[EnsembleMember]) -> String

#
ensemble_final_energies

source
fn ensemble_final_energies(members : ArrayView[EnsembleMember]) -> Array[Double]

#
ensemble_particle_losses

source
fn ensemble_particle_losses(members : ArrayView[EnsembleMember]) -> Array[Int]

#
ensemble_passes

source
fn ensemble_passes(summary : EnsembleSummary, charge_tolerance : Double, energy_spread_tolerance : Double) -> Bool

#
ensemble_summary_to_csv

source
fn ensemble_summary_to_csv(summary : EnsembleSummary) -> String

#
estimate_landau_rate

source
fn estimate_landau_rate(wave_number : Double, temperature : Double, density : Double) -> Double

#
euler_flux

source
fn euler_flux(state : FluidState, _gamma : Double) -> FluidFlux

#
expected_output_schema

source
fn expected_output_schema() -> String

#
expected_sample_count

source
fn expected_sample_count(scenario : SimulationScenario) -> Int

#
expected_work_units

source
fn expected_work_units(scenario : SimulationScenario) -> Int

#
experiment_charge_error

source
fn experiment_charge_error(report : ExperimentReport) -> Double

#
experiment_energy_drift

source
fn experiment_energy_drift(report : ExperimentReport) -> Double

#
experiment_energy_series

source
fn experiment_energy_series(report : ExperimentReport) -> Array[Double]

#
experiment_particle_counts

source
fn experiment_particle_counts(report : ExperimentReport) -> Array[Int]

#
experiment_passes_charge_tolerance

source
fn experiment_passes_charge_tolerance(report : ExperimentReport, tolerance : Double) -> Bool

#
experiment_passes_energy_tolerance

source
fn experiment_passes_energy_tolerance(report : ExperimentReport, tolerance : Double) -> Bool

#
experiment_summary

source
fn experiment_summary(report : ExperimentReport) -> String

#
experiment_times

source
fn experiment_times(report : ExperimentReport) -> Array[Double]

#
experiment_to_csv

source
fn experiment_to_csv(report : ExperimentReport) -> String

#
field_add

source
fn field_add(first : ArrayView[Double], second : ArrayView[Double]) -> Array[Double]

#
field_difference

source
fn field_difference(first : ArrayView[Double], second : ArrayView[Double]) -> Array[Double]

#
field_energy

source
fn field_energy(field : Field1D) -> Double

#
field_invariants

source
fn field_invariants(field : Field1D) -> Array[InvariantCheck]

#
field_l2_error

source
fn field_l2_error(first : ArrayView[Double], second : ArrayView[Double]) -> Double

#
field_line_step

source
fn field_line_step(position : Vector3, field : MagneticField3D, step : Double) -> Vector3

#
field_maximum

source
fn field_maximum(values : ArrayView[Double]) -> Double

#
field_mean_abs

source
fn field_mean_abs(values : ArrayView[Double]) -> Double

#
field_model_energy

source
fn field_model_energy(grid : Grid1D, model : ElectricFieldModel) -> Double

#
field_model_force

source
fn field_model_force(model : ElectricFieldModel, charge : Double, x : Double) -> Double

#
field_model_mean

source
fn field_model_mean(grid : Grid1D, model : ElectricFieldModel) -> Double

#
field_model_name

source
fn field_model_name(model : ElectricFieldModel) -> String

#
field_model_work

source
fn field_model_work(model : ElectricFieldModel, charge : Double, start : Double, stop : Double, samples : Int) -> Double

#
field_quality_metrics

source
fn field_quality_metrics(grid : Grid1D, field : Field1D) -> Array[QualityMetric]

#
field_residual

source
fn field_residual(grid : Grid1D, electric : ArrayView[Double], charge_density : ArrayView[Double]) -> Array[Double]

#
field_residual_norm

source
fn field_residual_norm(grid : Grid1D, electric : ArrayView[Double], charge_density : ArrayView[Double]) -> Double

#
field_scale

source
fn field_scale(values : ArrayView[Double], factor : Double) -> Array[Double]

#
field_to_csv

source
fn field_to_csv(field : Field1D) -> String

#
fill_like

source
fn fill_like(values : ArrayView[Double], value : Double) -> Array[Double]

#
fingerprint_diagnostics

source
fn fingerprint_diagnostics(values : ArrayView[PicDiagnostics]) -> Int

#
fingerprint_from_scenario

source
fn fingerprint_from_scenario(scenario : SimulationScenario) -> ResultFingerprint

#
fingerprint_integer

source
fn fingerprint_integer(value : Double) -> Int

#
fingerprint_suite_to_csv

source
fn fingerprint_suite_to_csv(suite : BenchmarkSuite) -> String

#
fingerprint_to_csv

source
fn fingerprint_to_csv(fingerprint : ResultFingerprint) -> String

#
fingerprint_values

source
fn fingerprint_values(values : ArrayView[Double]) -> Int

#
fingerprints_equal

source
fn fingerprints_equal(first : ResultFingerprint, second : ResultFingerprint) -> Bool

#
finite_difference_first

source
fn finite_difference_first(values : ArrayView[Double], spacing : Double) -> Array[Double]

#
finite_difference_second

source
fn finite_difference_second(values : ArrayView[Double], spacing : Double) -> Array[Double]

#
finite_difference_series

source
fn finite_difference_series(values : ArrayView[Double], spacing : Double) -> Array[Double]

#
fluid_cfl_dt

source
fn fluid_cfl_dt(states : ArrayView[FluidState], gamma : Double, cell_width : Double, cfl : Double) -> Double

#
fluid_clamp_physical

source
fn fluid_clamp_physical(state : FluidState) -> FluidState

#
fluid_compressibility

source
fn fluid_compressibility(state : FluidState, gamma : Double) -> Double

#
fluid_energy

source
fn fluid_energy(density : Double, velocity : Double, pressure : Double, gamma : Double) -> Double

#
fluid_enthalpy

source
fn fluid_enthalpy(state : FluidState) -> Double

#
fluid_mach_number

source
fn fluid_mach_number(state : FluidState, gamma : Double) -> Double

#
fluid_mean_density

source
fn fluid_mean_density(states : ArrayView[FluidState]) -> Double

#
fluid_mean_pressure

source
fn fluid_mean_pressure(states : ArrayView[FluidState]) -> Double

#
fluid_mean_velocity

source
fn fluid_mean_velocity(states : ArrayView[FluidState]) -> Double

#
fluid_pressure

source
fn fluid_pressure(density : Double, temperature : Double, gas_constant : Double) -> Double

#
fluid_state_from_primitive

source
fn fluid_state_from_primitive(density : Double, velocity : Double, pressure : Double, gamma : Double) -> FluidState

#
fluid_state_is_physical

source
fn fluid_state_is_physical(state : FluidState) -> Bool

#
fluid_temperature

source
fn fluid_temperature(state : FluidState, gas_constant : Double) -> Double

#
fluid_update

source
fn fluid_update(state : FluidState, flux_difference : FluidFlux, dt : Double, cell_width : Double) -> FluidState

#
fluid_wave_speed

source
fn fluid_wave_speed(state : FluidState, gamma : Double) -> Double

#
forward_difference

source
fn forward_difference(grid : Grid1D, values : ArrayView[Double], index : Int) -> Double

#
frequency_from_angular_frequency

source
fn frequency_from_angular_frequency(angular : Double) -> Double

#
gather_with_shape

source
fn gather_with_shape(grid : Grid1D, values : ArrayView[Double], positions : ArrayView[Double], kind : ShapeKind) -> Array[Double]

#
gaussian_electric_field

source
fn gaussian_electric_field(amplitude : Double, center : Double, width : Double, offset : Double) -> ElectricFieldModel

#
geometric_schedule

source
fn geometric_schedule(start : Double, factor : Double, count : Int) -> Array[Double]

#
gradient_periodic

source
fn gradient_periodic(grid : Grid1D, values : ArrayView[Double]) -> Array[Double]

#
grid_cell_edges

source
fn grid_cell_edges(grid : Grid1D) -> Array[Double]

#
grid_cell_volume

source
fn grid_cell_volume(grid : Grid1D) -> Double

#
grid_center_of_mass

source
fn grid_center_of_mass(grid : Grid1D, density : ArrayView[Double]) -> Double

#
grid_clip

source
fn grid_clip(grid : Grid1D, values : ArrayView[Double], low : Double, high : Double) -> Array[Double]

#
grid_coordinates

source
fn grid_coordinates(grid : Grid1D) -> Array[Double]

#
grid_distance

source
fn grid_distance(grid : Grid1D, first : Double, second : Double) -> Double

#
grid_index_at

source
fn grid_index_at(grid : Grid1D, x : Double) -> Int

#
grid_integral

source
fn grid_integral(grid : Grid1D, values : ArrayView[Double]) -> Double

#
grid_interpolate_coordinates

source
fn grid_interpolate_coordinates(grid : Grid1D, count : Int) -> Array[Double]

#
grid_l2_difference

source
fn grid_l2_difference(grid : Grid1D, first : ArrayView[Double], second : ArrayView[Double]) -> Double

#
grid_neighbor_indices

source
fn grid_neighbor_indices(grid : Grid1D, index : Int) -> (Int, Int)

#
grid_periodic_copy

source
fn grid_periodic_copy(grid : Grid1D, values : ArrayView[Double], shift : Int) -> Array[Double]

#
grid_periodic_mean

source
fn grid_periodic_mean(_grid : Grid1D, values : ArrayView[Double]) -> Double

#
grid_regrid

source
fn grid_regrid(source : Grid1D, values : ArrayView[Double], target : Grid1D) -> Array[Double]

#
grid_roll

source
fn grid_roll(grid : Grid1D, values : ArrayView[Double], shift : Int) -> Array[Double]

#
grid_smooth

source
fn grid_smooth(grid : Grid1D, values : ArrayView[Double], passes : Int) -> Array[Double]

#
grid_variance

source
fn grid_variance(grid : Grid1D, values : ArrayView[Double]) -> Double

#
grid_weighted_integral

source
fn grid_weighted_integral(grid : Grid1D, values : ArrayView[Double], weight : ArrayView[Double]) -> Double

#
gyro_frequency

source
fn gyro_frequency(charge_c : Double, magnetic_field_t : Double, mass_kg : Double) -> Double

#
gyroradius

source
fn gyroradius(mass : Double, speed : Double, charge : Double, magnetic : Double) -> Double

#
hann_window

source
fn hann_window(signal : ArrayView[Double]) -> Array[Double]

#
health_charge

source
fn health_charge(grid : Grid1D, density : ArrayView[Double], expected : Double, tolerance : Double) -> HealthCheck

#
health_check

source
fn health_check(name : String, metric : Double, threshold : Double, message : String) -> HealthCheck

#
health_energy

source
fn health_energy(initial : Double, final_value : Double, tolerance : Double) -> HealthCheck

#
health_particles

source
fn health_particles(expected : Int, actual : Int) -> HealthCheck

#
health_report

source
fn health_report(checks : ArrayView[HealthCheck]) -> Bool

#
health_report_to_csv

source
fn health_report_to_csv(checks : ArrayView[HealthCheck]) -> String

#
health_residual

source
fn health_residual(residual : Double, tolerance : Double) -> HealthCheck

#
histogram_edges

source
fn histogram_edges(low : Double, high : Double, bins : Int) -> Array[Double]

#
histogram_particles

source
fn histogram_particles(grid : PhaseSpaceGrid, particles : ArrayView[Particle]) -> PhaseSpaceGrid

#
integrate_position

source
fn integrate_position(position : Double, velocity : Double, acceleration : Double, dt : Double) -> Double

#
integrate_trapezoid

source
fn integrate_trapezoid(grid : Grid1D, values : ArrayView[Double]) -> Double

#
integrate_velocity

source
fn integrate_velocity(velocity : Double, acceleration : Double, dt : Double) -> Double

#
interpolate_pair

source
fn interpolate_pair(left : Double, right : Double, fraction : Double, mode : InterpolationMode) -> Double

#
interpolate_periodic

source
fn interpolate_periodic(grid : Grid1D, values : ArrayView[Double], x : Double) -> Double

#
interpolate_series

source
fn interpolate_series(values : ArrayView[Double], count : Int) -> Array[Double]

#
interpolation_error

source
fn interpolation_error(grid : Grid1D, values : ArrayView[Double], points : ArrayView[Double], expected : ArrayView[Double]) -> Double

#
interquartile_range

source
fn interquartile_range(values : ArrayView[Double]) -> Double

#
invariant

source
fn invariant(name : String, observed : Double, tolerance : Double) -> InvariantCheck

#
invariant_all

source
fn invariant_all(checks : ArrayView[InvariantCheck]) -> Bool

#
invariant_bounds

source
fn invariant_bounds(name : String, values : ArrayView[Double], low : Double, high : Double) -> InvariantCheck

#
invariant_charge

source
fn invariant_charge(grid : Grid1D, density : ArrayView[Double], expected : Double, tolerance : Double) -> InvariantCheck

#
invariant_close

source
fn invariant_close(name : String, actual : Double, expected : Double, tolerance : Double) -> InvariantCheck

#
invariant_max_error

source
fn invariant_max_error(checks : ArrayView[InvariantCheck]) -> Double

#
invariant_positive

source
fn invariant_positive(name : String, values : ArrayView[Double]) -> InvariantCheck

#
invariant_report

source
fn invariant_report(checks : ArrayView[InvariantCheck]) -> String

#
invariant_shape

source
fn invariant_shape(name : String, actual : Int, expected : Int) -> InvariantCheck

#
invariant_to_csv

source
fn invariant_to_csv(checks : ArrayView[InvariantCheck]) -> String

#
invariant_zero_mean

source
fn invariant_zero_mean(name : String, values : ArrayView[Double], tolerance : Double) -> InvariantCheck

#
inverse_lerp

source
fn inverse_lerp(a : Double, b : Double, value : Double) -> Double

#
kinetic_energy

source
fn kinetic_energy(particles : ArrayView[Particle]) -> Double

#
kinetic_energy_vector

source
fn kinetic_energy_vector(mass : Double, velocity : Vector3) -> Double

#
kinetic_temperature

source
fn kinetic_temperature(particles : ArrayView[Particle]) -> Double

#
kinetic_to_thermal_ratio

source
fn kinetic_to_thermal_ratio(velocity : Double, temperature : Double, mass : Double) -> Double

#
l2_distance

source
fn l2_distance(left : ArrayView[Double], right : ArrayView[Double]) -> Double

#
l2_norm

source
fn l2_norm(values : ArrayView[Double]) -> Double

#
landau_damping_rate

source
fn landau_damping_rate(wave_number_m : Double, electron_temperature_k : Double, electron_density_m3 : Double) -> Double

#
laplacian_periodic

source
fn laplacian_periodic(grid : Grid1D, values : ArrayView[Double]) -> Array[Double]

#
lax_friedrichs_flux

source
fn lax_friedrichs_flux(left : FluidState, right : FluidState, gamma : Double, wave_speed : Double) -> FluidFlux

#
lerp

source
fn lerp(a : Double, b : Double, t : Double) -> Double

#
linear_electric_field

source
fn linear_electric_field(offset : Double, slope : Double, center : Double) -> ElectricFieldModel

#
linear_magnetic_field

source
fn linear_magnetic_field(origin : Vector3, uniform : Vector3, gradient : Vector3) -> MagneticField3D

#
linear_schedule

source
fn linear_schedule(start : Double, stop : Double, count : Int) -> Array[Double]

#
linspace

source
fn linspace(start : Double, stop : Double, count : Int) -> Array[Double]

#
locate_periodic

source
fn locate_periodic(grid : Grid1D, x : Double) -> InterpolationResult

#
lorentz_force

source
fn lorentz_force(charge : Double, velocity : Vector3, electric : Vector3, magnetic : Vector3) -> Vector3

#
magnetic_energy_density

source
fn magnetic_energy_density(field : Vector3) -> Double

#
magnetic_force

source
fn magnetic_force(charge : Double, velocity : Vector3, magnetic : Vector3) -> Vector3

#
magnetic_pressure

source
fn magnetic_pressure(field : Vector3) -> Double

#
magnetic_pressure_si

source
fn magnetic_pressure_si(magnetic_field : Double) -> Double

#
make_landau_initial

source
fn make_landau_initial(config : VlasovConfig, density0~ : Double, thermal_speed~ : Double, perturbation? : Double, mode? : Int) -> VlasovState

#
manifest_fingerprint

source
fn manifest_fingerprint(scenario : SimulationScenario, toolchain : String) -> String

#
manifest_from_scenario

source
fn manifest_from_scenario(scenario : SimulationScenario, toolchain : String) -> ReproducibilityManifest

#
manifest_seed

source
fn manifest_seed(manifest : ReproducibilityManifest) -> Int

#
manifest_to_csv

source
fn manifest_to_csv(manifest : ReproducibilityManifest) -> String

#
manifest_work_units

source
fn manifest_work_units(manifest : ReproducibilityManifest) -> Int

#
map_field

source
fn map_field(field : Field1D, transform : (Double) -> Double) -> Field1D

#
map_particles

source
fn map_particles(particles : ArrayView[Particle], transform : (Particle) -> Particle) -> Array[Particle]

#
mass_series

source
fn mass_series(particles : ArrayView[Array[Particle]]) -> Array[Double]

#
matrix_frobenius_norm

source
fn matrix_frobenius_norm(matrix : Matrix2) -> Double

#
matrix_trace

source
fn matrix_trace(matrix : Matrix2) -> Double

#
max_abs_value

source
fn max_abs_value(values : ArrayView[Double]) -> Double

#
max_value

source
fn max_value(values : ArrayView[Double], fallback : Double) -> Double

#
maximum_metric

source
fn maximum_metric(metrics : ArrayView[QualityMetric]) -> Double

#
maxwellian

source
fn maxwellian(v : Double, thermal_speed : Double) -> Double

#
mean

source
fn mean(values : ArrayView[Double]) -> Double

#
mean_absolute_error

source
fn mean_absolute_error(actual : ArrayView[Double], predicted : ArrayView[Double]) -> Double

#
mean_subtract

source
fn mean_subtract(signal : ArrayView[Double]) -> Array[Double]

#
median

source
fn median(values : ArrayView[Double]) -> Double

#
merge_observables

source
fn merge_observables(first : Observable, second : Observable) -> Observable

#
merge_populations

source
fn merge_populations(first : SpeciesPopulation, second : SpeciesPopulation) -> SpeciesPopulation

#
metric

source
fn metric(name : String, value : Double, tolerance : Double) -> QualityMetric

#
metric_count

source
fn metric_count(name : String, actual : Int, expected : Int) -> QualityMetric

#
metric_l2

source
fn metric_l2(name : String, actual : ArrayView[Double], expected : ArrayView[Double], tolerance : Double) -> QualityMetric

#
metric_max_abs

source
fn metric_max_abs(name : String, values : ArrayView[Double], tolerance : Double) -> QualityMetric

#
metric_names

source
fn metric_names(metrics : ArrayView[QualityMetric]) -> Array[String]

#
metric_relative

source
fn metric_relative(name : String, actual : Double, expected : Double, tolerance : Double) -> QualityMetric

#
metrics_to_csv

source
fn metrics_to_csv(metrics : ArrayView[QualityMetric]) -> String

#
min_value

source
fn min_value(values : ArrayView[Double], fallback : Double) -> Double

#
mix_fields

source
fn mix_fields(first : Field1D, second : Field1D, fraction : Double) -> Field1D

#
modulo_index

source
fn modulo_index(index : Int, count : Int) -> Int

#
momentum_series

source
fn momentum_series(particles : ArrayView[Array[Particle]]) -> Array[Double]

#
momentum_vector

source
fn momentum_vector(mass : Double, velocity : Vector3) -> Vector3

#
monotonic_time

source
fn monotonic_time(values : ArrayView[Double]) -> Bool

#
moving_average

source
fn moving_average(values : ArrayView[Double], width : Int) -> Array[Double]

#
multiply_profile

source
fn multiply_profile(a : ArrayView[Double], b : ArrayView[Double]) -> Array[Double]

#
nearest_index

source
fn nearest_index(grid : Grid1D, x : Double) -> Int

#
normalize_charge

source
fn normalize_charge(scales : UnitScales, value : Double) -> Double

#
normalize_density

source
fn normalize_density(scales : UnitScales, value : Double) -> Double

#
normalize_electric_field

source
fn normalize_electric_field(scales : UnitScales, value : Double) -> Double

#
normalize_field

source
fn normalize_field(field : Field1D) -> Field1D

#
normalize_length

source
fn normalize_length(scales : UnitScales, value : Double) -> Double

#
normalize_mass

source
fn normalize_mass(scales : UnitScales, value : Double) -> Double

#
normalize_profile

source
fn normalize_profile(grid : Grid1D, values : ArrayView[Double], target_integral : Double) -> Array[Double]

#
normalize_series

source
fn normalize_series(values : ArrayView[Double]) -> Array[Double]

#
normalize_shape_weights

source
fn normalize_shape_weights(weights : ArrayView[ShapeContribution]) -> Array[ShapeContribution]

#
normalize_sum

source
fn normalize_sum(values : ArrayView[Double]) -> Array[Double]

#
normalize_temperature

source
fn normalize_temperature(scales : UnitScales, value : Double) -> Double

#
normalize_time

source
fn normalize_time(scales : UnitScales, value : Double) -> Double

#
normalize_velocity

source
fn normalize_velocity(scales : UnitScales, value : Double) -> Double

#
normalize_wave_number

source
fn normalize_wave_number(wave_number : Double, debye : Double) -> Double

#
numerical_epsilon

source
fn numerical_epsilon(scale : Double) -> Double

#
observable_correlation

source
fn observable_correlation(first : Observable, second : Observable) -> Double

#
observable_difference

source
fn observable_difference(first : Observable, second : Observable) -> Observable

#
observable_summary_csv

source
fn observable_summary_csv(values : ArrayView[Observable]) -> String

#
observables_from_diagnostics

source
fn observables_from_diagnostics(values : ArrayView[PicDiagnostics]) -> Array[Observable]

#
outer_product

source
fn outer_product(first : MatrixVector2, second : MatrixVector2) -> Matrix2

#
package_description

source
fn package_description() -> String

#
package_keywords

source
fn package_keywords() -> Array[String]

#
package_license

source
fn package_license() -> String

#
package_metadata_csv

source
fn package_metadata_csv() -> String

#
package_name

source
fn package_name() -> String

#
package_ready

source
fn package_ready() -> Bool

#
package_repository

source
fn package_repository() -> String

#
package_version

source
fn package_version() -> String

#
particle_charge_series

source
fn particle_charge_series(states : ArrayView[Array[Particle]]) -> Array[Double]

#
particle_current_density

source
fn particle_current_density(grid : Grid1D, particles : ArrayView[Particle]) -> Array[Double]

#
particle_energy_series

source
fn particle_energy_series(states : ArrayView[Array[Particle]]) -> Array[Double]

#
particle_for_species

source
fn particle_for_species(species : Species, x~ : Double, v~ : Double, weight? : Double) -> Particle

#
particle_mean_shift

source
fn particle_mean_shift(particles : ArrayView[Particle]) -> Array[Particle]

#
particle_merge

source
fn particle_merge(first : ArrayView[Particle], second : ArrayView[Particle]) -> Array[Particle]

#
particle_momentum_series

source
fn particle_momentum_series(states : ArrayView[Array[Particle]]) -> Array[Double]

#
particle_number_density

source
fn particle_number_density(grid : Grid1D, particles : ArrayView[Particle]) -> Array[Double]

#
particle_position_bounds

source
fn particle_position_bounds(particles : ArrayView[Particle]) -> (Double, Double)

#
particle_quality_metrics

source
fn particle_quality_metrics(grid : Grid1D, particles : ArrayView[Particle]) -> Array[QualityMetric]

#
particle_speed

source
fn particle_speed(particle : Particle) -> Double

#
particle_speed_range

source
fn particle_speed_range(particles : ArrayView[Particle]) -> (Double, Double)

#
particle_speeds

source
fn particle_speeds(particles : ArrayView[Particle]) -> Array[Double]

#
particle_thermalize

source
fn particle_thermalize(particles : ArrayView[Particle], temperature : Double) -> Array[Particle]

#
particle_total_momentum

source
fn particle_total_momentum(particles : ArrayView[Particle]) -> Double

#
particle_velocity_bounds

source
fn particle_velocity_bounds(particles : ArrayView[Particle]) -> (Double, Double)

#
particle_velocity_center

source
fn particle_velocity_center(particles : ArrayView[Particle]) -> Array[Particle]

#
particles_in_cell

source
fn particles_in_cell(grid : Grid1D, particles : ArrayView[Particle], cell : Int) -> Array[Particle]

#
particles_to_csv

source
fn particles_to_csv(particles : ArrayView[Particle]) -> String

#
particles_with_position_range

source
fn particles_with_position_range(particles : ArrayView[Particle], low : Double, high : Double) -> Array[Particle]

#
particles_with_speed_limit

source
fn particles_with_speed_limit(particles : ArrayView[Particle], limit : Double) -> Array[Particle]

#
percentile

source
fn percentile(values : ArrayView[Double], fraction : Double) -> Double

#
periodic_average

source
fn periodic_average(grid : Grid1D, values : ArrayView[Double], radius : Int) -> Array[Double]

#
periodic_cumulative

source
fn periodic_cumulative(grid : Grid1D, values : ArrayView[Double]) -> Array[Double]

#
periodic_gradient

source
fn periodic_gradient(grid : Grid1D, values : ArrayView[Double]) -> Array[Double]

#
periodic_index

source
fn periodic_index(index : Int, length : Int) -> Int

#
periodic_laplacian

source
fn periodic_laplacian(grid : Grid1D, values : ArrayView[Double]) -> Array[Double]

#
phase_space_density

source
fn phase_space_density(grid : PhaseSpaceGrid, particles : ArrayView[Particle]) -> Array[Double]

#
phase_space_energy

source
fn phase_space_energy(grid : PhaseSpaceGrid, histogram : ArrayView[Double], mass : Double) -> Double

#
phase_space_entropy

source
fn phase_space_entropy(histogram : ArrayView[Double]) -> Double

#
phase_space_marginal_v

source
fn phase_space_marginal_v(grid : PhaseSpaceGrid, histogram : ArrayView[Double]) -> Array[Double]

#
phase_space_marginal_x

source
fn phase_space_marginal_x(grid : PhaseSpaceGrid, histogram : ArrayView[Double]) -> Array[Double]

#
phase_space_mean_velocity

source
fn phase_space_mean_velocity(grid : PhaseSpaceGrid, histogram : ArrayView[Double]) -> Double

#
phase_space_peak

source
fn phase_space_peak(grid : PhaseSpaceGrid, histogram : ArrayView[Double]) -> (Int, Int)

#
phase_space_to_csv

source
fn phase_space_to_csv(grid : PhaseSpaceGrid, histogram : ArrayView[Double]) -> String

let pi : Double

#
pic_charge_drift

source
fn pic_charge_drift(values : ArrayView[PicDiagnostics]) -> Double

#
pic_config_summary

source
fn pic_config_summary(config : PicConfig) -> String

#
pic_diagnostics_charges

source
fn pic_diagnostics_charges(values : ArrayView[PicDiagnostics]) -> Array[Double]

#
pic_diagnostics_energies

source
fn pic_diagnostics_energies(values : ArrayView[PicDiagnostics]) -> Array[Double]

#
pic_diagnostics_pass

source
fn pic_diagnostics_pass(values : ArrayView[PicDiagnostics], charge_tolerance : Double, energy_tolerance : Double) -> Bool

#
pic_diagnostics_times

source
fn pic_diagnostics_times(values : ArrayView[PicDiagnostics]) -> Array[Double]

#
pic_diagnostics_to_table

source
fn pic_diagnostics_to_table(values : ArrayView[PicDiagnostics]) -> NumericTable

#
pic_energy_drift

source
fn pic_energy_drift(values : ArrayView[PicDiagnostics]) -> Double

#
pic_invariants

source
fn pic_invariants(state : PicState, expected_charge : Double) -> Array[InvariantCheck]

#
pic_series_summary_to_csv

source
fn pic_series_summary_to_csv(summary : PicSeriesSummary) -> String

#
pic_state_charge_error

source
fn pic_state_charge_error(state : PicState) -> Double

#
pic_state_energy

source
fn pic_state_energy(state : PicState) -> Double

#
pic_state_is_finite

source
fn pic_state_is_finite(state : PicState) -> Bool

#
pic_state_to_snapshot

source
fn pic_state_to_snapshot(state : PicState) -> String

#
pipeline_frame

source
fn pipeline_frame(_config : PipelineConfig, step : Int, state : PicState) -> PipelineFrame

#
pipeline_initial_state

source
fn pipeline_initial_state(config : PipelineConfig) -> PicState

#
pipeline_step

source
fn pipeline_step(config : PipelineConfig, state : PicState) -> PicState

#
pipeline_summary

source
fn pipeline_summary(result : PipelineResult) -> String

#
pipeline_to_csv

source
fn pipeline_to_csv(result : PipelineResult) -> String

#
plasma_beta

source
fn plasma_beta(temperature : Double, density : Double, magnetic_field : Double) -> Double

#
plasma_frequency

source
fn plasma_frequency(density_m3 : Double, charge_c? : Double, mass_kg? : Double) -> Double

#
plasma_parameter

source
fn plasma_parameter(electron_density_m3 : Double, debye_length_m : Double) -> Double

#
plasma_parameter_from_state

source
fn plasma_parameter_from_state(temperature : Double, density : Double) -> Double

#
plasma_time_unit

source
fn plasma_time_unit(scales : UnitScales, density : Double, mass : Double, charge : Double) -> Double

#
poisson_converges

source
fn poisson_converges(grid : Grid1D, source : ArrayView[Double], tolerance : Double, max_iterations : Int) -> Bool

#
poisson_electric_field

source
fn poisson_electric_field(grid : Grid1D, potential : ArrayView[Double]) -> Array[Double]

#
poisson_energy

source
fn poisson_energy(grid : Grid1D, potential : ArrayView[Double]) -> Double

#
poisson_iteration_history

source
fn poisson_iteration_history(grid : Grid1D, source : ArrayView[Double], steps : Int) -> Array[Double]

#
poisson_mean_free

source
fn poisson_mean_free(potential : ArrayView[Double]) -> Array[Double]

#
poisson_residual

source
fn poisson_residual(grid : Grid1D, potential : ArrayView[Double], source : ArrayView[Double]) -> Double

#
poisson_residual_series

source
fn poisson_residual_series(grid : Grid1D, potentials : ArrayView[Array[Double]], source : ArrayView[Double]) -> Array[Double]

#
poisson_solution_range

source
fn poisson_solution_range(result : PoissonResult) -> Double

#
poisson_source

source
fn poisson_source(charge_density : ArrayView[Double]) -> Array[Double]

#
polynomial_basis

source
fn polynomial_basis(x : Double, order : Int) -> Array[Double]

#
polynomial_derivative

source
fn polynomial_derivative(coefficients : ArrayView[Double]) -> Array[Double]

#
polynomial_evaluate

source
fn polynomial_evaluate(coefficients : ArrayView[Double], x : Double) -> Double

#
polynomial_fit_constant

source
fn polynomial_fit_constant(values : ArrayView[Double]) -> Array[Double]

#
population_charge_density

source
fn population_charge_density(grid : Grid1D, populations : ArrayView[SpeciesPopulation], kind : ShapeKind) -> Array[Double]

#
population_charge_summary

source
fn population_charge_summary(state : MultiSpeciesState) -> Array[Double]

#
population_mass_summary

source
fn population_mass_summary(state : MultiSpeciesState) -> Array[Double]

#
population_names

source
fn population_names(state : MultiSpeciesState) -> Array[String]

#
position_marginal

source
fn position_marginal(state : VlasovState) -> Array[Double]

#
potential_from_electric

source
fn potential_from_electric(grid : Grid1D, electric : ArrayView[Double]) -> Array[Double]

#
power_spectrum

source
fn power_spectrum(signal : ArrayView[Double]) -> Array[Double]

#
profile_ceiling

source
fn profile_ceiling(values : ArrayView[Double], ceiling : Double) -> Array[Double]

#
profile_constant

source
fn profile_constant(value : Double) -> Profile1D

#
profile_double_hump

source
fn profile_double_hump(base : Double, amplitude : Double, center : Double, width : Double) -> Profile1D

#
profile_floor

source
fn profile_floor(values : ArrayView[Double], floor : Double) -> Array[Double]

#
profile_gaussian

source
fn profile_gaussian(base : Double, amplitude : Double, center : Double, width : Double) -> Profile1D

#
profile_integral

source
fn profile_integral(grid : Grid1D, profile : Profile1D) -> Double

#
profile_maximum

source
fn profile_maximum(values : ArrayView[Double]) -> Double

#
profile_mean

source
fn profile_mean(grid : Grid1D, profile : Profile1D) -> Double

#
profile_minimum

source
fn profile_minimum(values : ArrayView[Double]) -> Double

#
profile_ramp

source
fn profile_ramp(start : Double, end : Double, center : Double, width : Double) -> Profile1D

#
profile_range

source
fn profile_range(values : ArrayView[Double]) -> Double

#
profile_sinusoid

source
fn profile_sinusoid(base : Double, amplitude : Double, wave_number : Double, phase : Double) -> Profile1D

#
profile_top_hat

source
fn profile_top_hat(low : Double, high : Double, center : Double, width : Double) -> Profile1D

#
profile_value

source
fn profile_value(profile : Profile1D, x : Double) -> Double

#
profile_values

source
fn profile_values(grid : Grid1D, profile : Profile1D) -> Array[Double]

#
project_field

source
fn project_field(field : Field1D) -> Field1D

#
project_zero_mean

source
fn project_zero_mean(values : ArrayView[Double]) -> Array[Double]

#
prolongate_linear

source
fn prolongate_linear(source : Grid1D, values : ArrayView[Double], target : Grid1D) -> Array[Double]

#
proton_mass

source
let proton_mass : Double

#
public_api_summary

source
fn public_api_summary() -> String

#
pulse_electric_field

source
fn pulse_electric_field(amplitude : Double, center : Double, width : Double, offset : Double) -> ElectricFieldModel

#
push_particle

source
fn push_particle(grid : Grid1D, particle : Particle, electric~ : Double, dt~ : Double) -> Particle

#
push_particle_unbounded

source
fn push_particle_unbounded(particle : Particle, electric : Double, dt : Double) -> Particle

#
push_particles

source
fn push_particles(particles : ArrayView[Particle], electric : ArrayView[Double], dt : Double) -> Array[Particle]

#
quality_report

source
fn quality_report(metrics : ArrayView[QualityMetric]) -> String

#
reduce_average

source
fn reduce_average(source : Grid1D, values : ArrayView[Double], target_cells : Int) -> GridReduction

#
reduction_converges

source
fn reduction_converges(errors : ArrayView[Double], tolerance : Double) -> Bool

#
reduction_error

source
fn reduction_error(source : Grid1D, values : ArrayView[Double], reduction : GridReduction) -> Double

#
reduction_errors

source
fn reduction_errors(source : Grid1D, values : ArrayView[Double], reductions : ArrayView[GridReduction]) -> Array[Double]

#
reduction_integral

source
fn reduction_integral(_grid : Grid1D, reduction : GridReduction) -> Double

#
reduction_maximum

source
fn reduction_maximum(reduction : GridReduction) -> Double

#
reduction_minimum

source
fn reduction_minimum(reduction : GridReduction) -> Double

#
reduction_series

source
fn reduction_series(source : Grid1D, values : ArrayView[Double], resolutions : ArrayView[Int]) -> Array[GridReduction]

#
reduction_summary

source
fn reduction_summary(reduction : GridReduction) -> String

#
reduction_to_csv

source
fn reduction_to_csv(reduction : GridReduction) -> String

#
reflect_position

source
fn reflect_position(grid : Grid1D, x : Double) -> Double

#
relative_change

source
fn relative_change(initial : Double, final_value : Double) -> Double

#
relative_energy_drift

source
fn relative_energy_drift(initial : Double, ending : Double) -> Double

#
relative_error

source
fn relative_error(actual : Double, predicted : Double) -> Double

#
relative_l2_error

source
fn relative_l2_error(reference : ArrayView[Double], actual : ArrayView[Double]) -> Double

#
relative_residual

source
fn relative_residual(values : ArrayView[Double], target : ArrayView[Double]) -> Double

#
relax_to_target

source
fn relax_to_target(initial : Array[Double], target : Array[Double], factor : Double, max_iterations : Int) -> RelaxationResult

#
relaxation_time

source
fn relaxation_time(rate : Double) -> Double

#
reproducibility_report

source
fn reproducibility_report(scenario : SimulationScenario, toolchain : String) -> String

#
reproducible_run

source
fn reproducible_run(scenario : SimulationScenario) -> Bool

#
resample_periodic

source
fn resample_periodic(source_grid : Grid1D, source : ArrayView[Double], target_grid : Grid1D, mode : InterpolationMode) -> Array[Double]

#
rescale_particle_weights

source
fn rescale_particle_weights(particles : ArrayView[Particle], factor : Double) -> Array[Particle]

#
residual_norm

source
fn residual_norm(residual : ArrayView[Double]) -> Double

#
residual_sum_of_squares

source
fn residual_sum_of_squares(actual : ArrayView[Double], predicted : ArrayView[Double]) -> Double

#
result_is_well_formed

source
fn result_is_well_formed(scenario : SimulationScenario, fingerprint : ResultFingerprint) -> Bool

#
rms

source
fn rms(values : ArrayView[Double]) -> Double

#
run_ensemble

source
fn run_ensemble(scenario : SimulationScenario, members : Int) -> Array[EnsembleMember]

#
run_experiment

source
fn run_experiment(config : ExperimentConfig) -> ExperimentReport

#
run_pic_benchmark

source
fn run_pic_benchmark(cells? : Int, particles? : Int, steps? : Int) -> BenchmarkSample

#
run_pipeline

source
fn run_pipeline(config : PipelineConfig) -> PipelineResult

#
run_plasma_benchmark_catalog

source
fn run_plasma_benchmark_catalog() -> PlasmaBenchmarkReport

#
running_maximum

source
fn running_maximum(values : ArrayView[Double]) -> Array[Double]

#
running_minimum

source
fn running_minimum(values : ArrayView[Double]) -> Array[Double]

#
safe_grid

source
fn safe_grid(cells : Int, length : Double) -> Grid1D?

#
safe_ratio

source
fn safe_ratio(numerator : Double, denominator : Double, fallback : Double) -> Double

#
sample_beam

source
fn sample_beam(count : Int, seed : Int, drift : Double, spread : Double) -> Array[Double]

#
sample_clone

source
fn sample_clone(particles : ArrayView[Particle]) -> Array[Particle]

#
sample_histogram

source
fn sample_histogram(values : ArrayView[Double], low : Double, high : Double, bins : Int) -> Array[Int]

#
sample_lattice

source
fn sample_lattice(grid : Grid1D, velocity : Double, count : Int) -> Array[Particle]

#
sample_linear

source
fn sample_linear(grid : Grid1D, values : ArrayView[Double], x : Double) -> Double

#
sample_mean

source
fn sample_mean(values : ArrayView[Double]) -> Double

#
sample_normal

source
fn sample_normal(count : Int, seed : Int, mean_value : Double, standard_deviation : Double) -> Array[Double]

#
sample_particles

source
fn sample_particles(grid : Grid1D, count : Int, seed : Int, drift : Double, spread : Double) -> Array[Particle]

#
sample_periodic

source
fn sample_periodic(grid : Grid1D, values : ArrayView[Double], x : Double, mode : InterpolationMode) -> Double

#
sample_periodic_linear

source
fn sample_periodic_linear(grid : Grid1D, values : ArrayView[Double], x : Double) -> Double

#
sample_positions

source
fn sample_positions(count : Int, length : Double, phase : Double) -> Array[Double]

#
sample_profile

source
fn sample_profile(grid : Grid1D, profile : Profile1D, count : Int, seed : Int) -> Array[Double]

#
sample_quantiles

source
fn sample_quantiles(values : ArrayView[Double], count : Int) -> Array[Double]

#
sample_rejection

source
fn sample_rejection(grid : Grid1D, profile : Profile1D, count : Int, seed : Int, upper : Double) -> Array[Double]

#
sample_span

source
fn sample_span(values : ArrayView[Double]) -> Double

#
sample_two_beam

source
fn sample_two_beam(count : Int, seed : Int, drift : Double, spread : Double) -> Array[Double]

#
sample_uniform

source
fn sample_uniform(count : Int, seed : Int, low : Double, high : Double) -> Array[Double]

#
sample_uniform_grid

source
fn sample_uniform_grid(grid : Grid1D, count : Int, seed : Int) -> Array[Double]

#
sample_variance

source
fn sample_variance(values : ArrayView[Double]) -> Double

#
sample_weighted_particles

source
fn sample_weighted_particles(grid : Grid1D, count : Int, seed : Int, profile : Profile1D) -> Array[Particle]

#
sampled_beam

source
fn sampled_beam(config : VlasovConfig, density~ : Double, center_velocity~ : Double, thermal_speed~ : Double) -> Array[Double]

#
sampled_maxwellian

source
fn sampled_maxwellian(config : VlasovConfig, density~ : Double, thermal_speed~ : Double) -> Array[Double]

#
sampling_config_summary

source
fn sampling_config_summary(config : SamplingConfig) -> String

#
scale_field

source
fn scale_field(field : Field1D, factor : Double) -> Field1D

#
scales_summary

source
fn scales_summary(scales : UnitScales) -> String

#
scenario_charge_error

source
fn scenario_charge_error(scenario : SimulationScenario) -> Double

#
scenario_description

source
fn scenario_description(scenario : SimulationScenario) -> String

#
scenario_diagnostics_csv

source
fn scenario_diagnostics_csv(scenario : SimulationScenario) -> String

#
scenario_health

source
fn scenario_health(scenario : SimulationScenario) -> Array[HealthCheck]

#
scenario_initial_state

source
fn scenario_initial_state(scenario : SimulationScenario) -> PicState

#
scenario_manifest_summary

source
fn scenario_manifest_summary(scenario : SimulationScenario) -> String

#
scenario_particle_count

source
fn scenario_particle_count(scenario : SimulationScenario) -> Int

#
scenario_quality_metrics

source
fn scenario_quality_metrics(scenario : SimulationScenario) -> Array[QualityMetric]

#
scenario_run

source
fn scenario_run(scenario : SimulationScenario) -> PicState

#
scenario_step

source
fn scenario_step(state : PicState, scenario : SimulationScenario) -> PicState

#
scenario_trace

source
fn scenario_trace(scenario : SimulationScenario) -> Array[PicDiagnostics]

#
scenario_with_boundary

source
fn scenario_with_boundary(scenario : SimulationScenario, boundary : Boundary1D) -> SimulationScenario

#
scenario_with_dt

source
fn scenario_with_dt(scenario : SimulationScenario, dt : Double) -> SimulationScenario

#
scenario_with_shape

source
fn scenario_with_shape(scenario : SimulationScenario, shape : ShapeKind) -> SimulationScenario

#
scenario_work_units

source
fn scenario_work_units(scenario : SimulationScenario) -> Int

#
serialize_benchmark

source
fn serialize_benchmark(suite : BenchmarkSuite) -> String

#
serialize_config

source
fn serialize_config(config : ExperimentConfig) -> String

#
serialize_field_snapshot

source
fn serialize_field_snapshot(field : Field1D) -> String

#
serialize_grid_values

source
fn serialize_grid_values(grid : Grid1D, name : String, values : ArrayView[Double]) -> String

#
serialize_named_values

source
fn serialize_named_values(names : ArrayView[String], values : ArrayView[Double]) -> String

#
serialize_particles_snapshot

source
fn serialize_particles_snapshot(particles : ArrayView[Particle]) -> String

#
serialize_pipeline

source
fn serialize_pipeline(result : PipelineResult) -> String

#
serialize_scalar_series

source
fn serialize_scalar_series(name : String, values : ArrayView[Double]) -> String

#
serialize_shape_weights

source
fn serialize_shape_weights(weights : ShapeWeights) -> String

#
serialize_summary

source
fn serialize_summary(name : String, values : ArrayView[Double]) -> String

#
serialize_validation

source
fn serialize_validation(report : ValidationReport) -> String

#
serialize_vector_series

source
fn serialize_vector_series(name : String, values : ArrayView[Vector3]) -> String

#
serialize_vlasov

source
fn serialize_vlasov(state : VlasovState) -> String

#
series_from_pairs

source
fn series_from_pairs(name : String, pairs : Array[(Double, Double)]) -> TimeSeries

#
series_mean

source
fn series_mean(values : ArrayView[Double]) -> Double

#
series_range

source
fn series_range(values : ArrayView[Double]) -> Double

#
series_rms

source
fn series_rms(values : ArrayView[Double]) -> Double

#
shape_blend

source
fn shape_blend(grid : Grid1D, x : Double, first : ShapeKind, second : ShapeKind, fraction : Double) -> Array[Double]

#
shape_charge_error

source
fn shape_charge_error(grid : Grid1D, particles : ArrayView[Particle], kind : ShapeKind) -> Double

#
shape_kind_from_index

source
fn shape_kind_from_index(index : Int) -> ShapeKind

#
shape_moment

source
fn shape_moment(grid : Grid1D, positions : ArrayView[Double], values : ArrayView[Double], kind : ShapeKind, order : Int) -> Double

#
shape_name

source
fn shape_name(kind : ShapeKind) -> String

#
shape_partition_error

source
fn shape_partition_error(grid : Grid1D, x : Double, kind : ShapeKind) -> Double

#
shape_reconstruct

source
fn shape_reconstruct(grid : Grid1D, deposited : ArrayView[Double], positions : ArrayView[Double], kind : ShapeKind) -> Array[Double]

#
shape_support

source
fn shape_support(kind : ShapeKind) -> Int

#
shape_weight

source
fn shape_weight(grid : Grid1D, x : Double, index : Int, kind : ShapeKind) -> Double

#
shape_weights

source
fn shape_weights(grid : Grid1D, x : Double, kind : ShapeKind) -> ShapeWeights

#
shift_field

source
fn shift_field(grid : Grid1D, field : Field1D, shift : Double) -> Field1D

#
shift_profile

source
fn shift_profile(grid : Grid1D, values : ArrayView[Double], shift : Double) -> Array[Double]

#
simpson_integral

source
fn simpson_integral(values : ArrayView[Double], spacing : Double) -> Double

#
sinusoidal_electric_field

source
fn sinusoidal_electric_field(amplitude : Double, offset : Double, wave_number : Double, phase : Double) -> ElectricFieldModel

#
sliding_windows

source
fn sliding_windows(values : ArrayView[Double], width : Int, stride : Int) -> Array[Array[Double]]

#
solve_2x2

source
fn solve_2x2(matrix : Matrix2, rhs : MatrixVector2) -> MatrixVector2

#
solve_periodic_field

source
fn solve_periodic_field(grid : Grid1D, charge_density : ArrayView[Double]) -> Field1D

#
solve_periodic_poisson

source
fn solve_periodic_poisson(grid : Grid1D, source : ArrayView[Double], max_iterations? : Int, tolerance? : Double) -> PoissonResult

Compatibility wrapper with a source-density API.

#
solve_periodic_potential_field

source
fn solve_periodic_potential_field(grid : Grid1D, source : ArrayView[Double], max_iterations? : Int, tolerance? : Double) -> Field1D

#
solve_poisson_dirichlet

source
fn solve_poisson_dirichlet(grid : Grid1D, source : ArrayView[Double], left_value : Double, right_value : Double) -> Array[Double]

#
solve_poisson_jacobi

source
fn solve_poisson_jacobi(grid : Grid1D, charge_density : ArrayView[Double], max_iterations : Int, tolerance : Double) -> PoissonResult

#
solve_poisson_periodic

source
fn solve_poisson_periodic(grid : Grid1D, charge_density : ArrayView[Double], max_iterations : Int, tolerance : Double) -> PoissonResult

#
solver_convergence_rate

source
fn solver_convergence_rate(residuals : ArrayView[Double]) -> Double

#
solver_is_decreasing

source
fn solver_is_decreasing(residuals : ArrayView[Double]) -> Bool

#
solver_residual_csv

source
fn solver_residual_csv(residuals : ArrayView[Double]) -> String

#
sound_speed

source
fn sound_speed(state : FluidState, gamma : Double) -> Double

#
sound_speed_ideal

source
fn sound_speed_ideal(temperature : Double, mass : Double, gamma : Double) -> Double

#
species_gyro_frequency

source
fn species_gyro_frequency(species : Species, field : Double) -> Double

#
species_gyroradius

source
fn species_gyroradius(species : Species, temperature : Double, field : Double) -> Double

#
species_particles

source
fn species_particles(species : Species, count : Int, spacing : Double, drift : Double) -> Array[Particle]

#
species_plasma_frequency

source
fn species_plasma_frequency(species : Species, density : Double) -> Double

#
specific_internal_energy

source
fn specific_internal_energy(state : FluidState) -> Double

#
spectral_centroid

source
fn spectral_centroid(spectrum : ArrayView[SpectrumBin]) -> Double

#
spectrum_band_power

source
fn spectrum_band_power(spectrum : ArrayView[SpectrumBin], low : Double, high : Double) -> Double

#
spectrum_to_csv

source
fn spectrum_to_csv(spectrum : ArrayView[SpectrumBin]) -> String

#
stable_pic_dt

source
fn stable_pic_dt(grid : Grid1D, maximum_speed : Double, safety_factor : Double) -> Double

#
stable_time_step

source
fn stable_time_step(cell_width : Double, speed : Double, cfl : Double) -> Double

#
standard_scenario

source
fn standard_scenario(name : String, cells : Int, particles : Int, steps : Int) -> SimulationScenario

#
sum_values

source
fn sum_values(values : ArrayView[Double]) -> Double

#
summarize_ensemble

source
fn summarize_ensemble(members : ArrayView[EnsembleMember]) -> EnsembleSummary

#
summarize_pic_series

source
fn summarize_pic_series(values : ArrayView[PicDiagnostics]) -> PicSeriesSummary

#
summarize_series

source
fn summarize_series(name : String, values : ArrayView[Double]) -> SeriesSummary

#
summarize_vlasov

source
fn summarize_vlasov(state : VlasovState, mass : Double) -> VlasovSummary

#
summary_array

source
fn summary_array(values : ArrayView[Array[Double]]) -> Array[SeriesSummary]

#
summary_to_csv

source
fn summary_to_csv(summary : SeriesSummary) -> String

#
table_append_column

source
fn table_append_column(table : NumericTable, name : String, values : ArrayView[Double]) -> NumericTable

#
table_column_sums

source
fn table_column_sums(table : NumericTable) -> Array[Double]

#
table_column_values

source
fn table_column_values(table : NumericTable, index : Int) -> Array[Double]

#
table_filter_rows

source
fn table_filter_rows(table : NumericTable, column : Int, low : Double, high : Double) -> NumericTable

#
table_from_series

source
fn table_from_series(names : Array[String], series : Array[Array[Double]]) -> NumericTable

#
table_maximum

source
fn table_maximum(table : NumericTable, index : Int) -> Double

#
table_mean

source
fn table_mean(table : NumericTable, index : Int) -> Double

#
table_minimum

source
fn table_minimum(table : NumericTable, index : Int) -> Double

#
table_row_sums

source
fn table_row_sums(table : NumericTable) -> Array[Double]

#
table_summary

source
fn table_summary(table : NumericTable) -> String

#
thermal_debye_length

source
fn thermal_debye_length(temperature : Double, density : Double, charge : Double) -> Double

#
thermal_energy

source
fn thermal_energy(temperature : Double) -> Double

#
thermal_speed

source
fn thermal_speed(temperature : Double, mass : Double) -> Double

#
thermal_speed_from_temperature

source
fn thermal_speed_from_temperature(temperature : Double, mass : Double) -> Double

#
thermal_unit

source
fn thermal_unit(scales : UnitScales) -> Double

#
thermal_velocity

source
fn thermal_velocity(temperature_k : Double, mass_kg~ : Double) -> Double

#
total_charge

source
fn total_charge(grid : Grid1D, charge_density : ArrayView[Double]) -> Double

#
total_particle_charge

source
fn total_particle_charge(particles : ArrayView[Particle]) -> Double

#
trace_field_line

source
fn trace_field_line(position : Vector3, field : MagneticField3D, step : Double, count : Int) -> Array[Vector3]

#
trace_pic

source
fn trace_pic(state : PicState, dt : Double, steps : Int, every? : Int) -> Array[PicDiagnostics]

#
trace_pic_diagnostics

source
fn trace_pic_diagnostics(state : PicState, dt : Double, steps : Int) -> Array[PicDiagnostics]

#
translate_particles

source
fn translate_particles(particles : ArrayView[Particle], shift : Double) -> Array[Particle]

#
trapezoid_integral

source
fn trapezoid_integral(grid : Grid1D, values : ArrayView[Double]) -> Double

#
trapezoid_integral_uniform

source
fn trapezoid_integral_uniform(values : ArrayView[Double], spacing : Double) -> Double

#
tridiagonal_jacobi

source
fn tridiagonal_jacobi(diagonal : ArrayView[Double], lower : ArrayView[Double], upper : ArrayView[Double], rhs : ArrayView[Double], iterations : Int) -> RelaxationResult

#
tridiagonal_residual

source
fn tridiagonal_residual(diagonal : ArrayView[Double], lower : ArrayView[Double], upper : ArrayView[Double], solution : ArrayView[Double], rhs : ArrayView[Double]) -> Array[Double]

#
two_stream_particles

source
fn two_stream_particles(count : Int, length : Double, speed : Double) -> Array[Particle]

#
uniform_magnetic_field

source
fn uniform_magnetic_field(field : Vector3) -> MagneticField3D

#
vacuum_permittivity

source
let vacuum_permittivity : Double

#
validate_count

source
fn validate_count(value : Int, name : String) -> ValidationReport

#
validate_grid

source
fn validate_grid(cells : Int, length : Double) -> ValidationReport

#
validate_non_negative

source
fn validate_non_negative(value : Double, name : String) -> ValidationReport

#
validate_positive

source
fn validate_positive(value : Double, name : String) -> ValidationReport

#
validate_range

source
fn validate_range(value : Double, low : Double, high : Double, name : String) -> ValidationReport

#
validate_simulation_inputs

source
fn validate_simulation_inputs(grid : Grid1D, dt : Double, particles : Int, steps : Int) -> ValidationReport

#
validation_health

source
fn validation_health(report : ValidationReport) -> HealthCheck

#
validation_message

source
fn validation_message(report : ValidationReport) -> String

#
vector_distance

source
fn vector_distance(a : ArrayView[Double], b : ArrayView[Double]) -> Double

#
velocity_marginal

source
fn velocity_marginal(state : VlasovState) -> Array[Double]

#
velocity_mean

source
fn velocity_mean(particles : ArrayView[Particle]) -> Double

#
velocity_variance

source
fn velocity_variance(particles : ArrayView[Particle]) -> Double

#
verification_bundle_check_count

source
fn verification_bundle_check_count(bundle : VerificationBundle) -> Int

#
verification_bundle_checksum

source
fn verification_bundle_checksum(bundle : VerificationBundle) -> Int

#
verification_bundle_expected_work

source
fn verification_bundle_expected_work(bundle : VerificationBundle) -> Int

#
verification_bundle_is_deterministic

source
fn verification_bundle_is_deterministic(scenario : SimulationScenario, toolchain : String) -> Bool

#
verification_bundle_matches_work

source
fn verification_bundle_matches_work(bundle : VerificationBundle) -> Bool

#
verification_bundle_passes_thresholds

source
fn verification_bundle_passes_thresholds(bundle : VerificationBundle, charge : Double, energy : Double) -> Bool

#
verification_bundle_records

source
fn verification_bundle_records(bundle : VerificationBundle) -> Array[QualityMetric]

#
verification_bundle_schema

source
fn verification_bundle_schema() -> String

#
verification_bundle_status

source
fn verification_bundle_status(bundle : VerificationBundle) -> String

#
verification_bundle_to_text

source
fn verification_bundle_to_text(bundle : VerificationBundle) -> String

#
vlasov_advect_x

source
fn vlasov_advect_x(state : VlasovState, velocity : Double) -> VlasovState

#
vlasov_cfl

source
fn vlasov_cfl(config : VlasovConfig) -> Double

#
vlasov_charge_from_density

source
fn vlasov_charge_from_density(_state : VlasovState, density : ArrayView[Double]) -> Array[Double]

#
vlasov_clip_negative

source
fn vlasov_clip_negative(state : VlasovState) -> VlasovState

#
vlasov_conservative_mass_correction

source
fn vlasov_conservative_mass_correction(state : VlasovState, reference_mass : Double) -> VlasovState

#
vlasov_density

source
fn vlasov_density(config : VlasovConfig, distribution : ArrayView[Double]) -> Array[Double]

#
vlasov_density_error

source
fn vlasov_density_error(state : VlasovState, expected : Double) -> Double

#
vlasov_distribution_difference

source
fn vlasov_distribution_difference(first : VlasovState, second : VlasovState) -> Array[Double]

#
vlasov_invariants

source
fn vlasov_invariants(state : VlasovState, expected_mass : Double) -> Array[InvariantCheck]

#
vlasov_is_normalized

source
fn vlasov_is_normalized(state : VlasovState, expected : Double, tolerance : Double) -> Bool

#
vlasov_is_positive

source
fn vlasov_is_positive(state : VlasovState) -> Bool

#
vlasov_l2_difference

source
fn vlasov_l2_difference(first : VlasovState, second : VlasovState) -> Double

#
vlasov_mass_error

source
fn vlasov_mass_error(first : VlasovState, second : VlasovState) -> Double

#
vlasov_moments

source
fn vlasov_moments(state : VlasovState) -> Moments1D

#
vlasov_report_to_csv

source
fn vlasov_report_to_csv(reports : ArrayView[VlasovStepReport]) -> String

#
vlasov_rescale_mass

source
fn vlasov_rescale_mass(state : VlasovState, target : Double) -> VlasovState

#
vlasov_run_reports

source
fn vlasov_run_reports(state : VlasovState, steps : Int) -> Array[VlasovStepReport]

#
vlasov_shift_distribution

source
fn vlasov_shift_distribution(state : VlasovState, shift : Double) -> VlasovState

#
vlasov_snapshot_to_csv

source
fn vlasov_snapshot_to_csv(state : VlasovState) -> String

#
vlasov_step_report

source
fn vlasov_step_report(state : VlasovState) -> VlasovStepReport

#
vlasov_summary_to_csv

source
fn vlasov_summary_to_csv(values : ArrayView[VlasovSummary]) -> String

#
vlasov_time_series

source
fn vlasov_time_series(state : VlasovState, steps : Int) -> Array[VlasovSummary]

#
wave_group_speed

source
fn wave_group_speed(omega_first : Double, omega_second : Double, wave_first : Double, wave_second : Double) -> Double

#
wave_phase_speed

source
fn wave_phase_speed(omega : Double, wave_number : Double) -> Double

#
wavelength_from_wavenumber

source
fn wavelength_from_wavenumber(wave_number : Double) -> Double

#
wavenumber_from_wavelength

source
fn wavenumber_from_wavelength(wavelength : Double) -> Double

#
weighted_histogram_particles

source
fn weighted_histogram_particles(grid : PhaseSpaceGrid, particles : ArrayView[Particle]) -> Array[Double]

#
weighted_mean

source
fn weighted_mean(values : ArrayView[Double], weights : ArrayView[Double]) -> Double

#
weighted_sum

source
fn weighted_sum(values : ArrayView[Double], weights : ArrayView[Double]) -> Double

#
window_means

source
fn window_means(values : ArrayView[Double], width : Int, stride : Int) -> Array[Double]

#
z_scores

source
fn z_scores(values : ArrayView[Double]) -> Array[Double]

#
zeros

source
fn zeros(n : Int) -> Array[Double]

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io