Struct DynamicRun2d 

pub struct DynamicRun2d<'a> { /* private fields */ }

A fluence-stepped 2-D run. See the module documentation.

Implementations

impl<'a> DynamicRun2d<'a>

pub fn new( columns: Vec<CompositionGrid>, column_width_m: f64, beam: Beam, config: BcaConfig, stopping: &'a (dyn ElectronicStopping + Sync), table: &'a ScatteringTable, cfg: Dynamic2dConfig, ) -> Result<Self, DynamicRunError>

Set up a run on columns (front to back identical bookkeeping to the 1-D module; all columns must share the lateral width column_width_m). beam.count is the number of primaries per illuminated column.

pub fn with_profiles( self, grid: VoxelTallyGrid, snapshot_fluences_m2: &[f64], ) -> Result<Self, DynamicRunError>

Tally the implanted beam species and the displacement damage on grid (sample frame, see the profiles module docs) and take a snapshot when the peak fluence reaches each of snapshot_fluences_m2 (each in (0, fluence_m2], rounded to a whole number of primaries per column). Steps are shortened to end on a snapshot, so the step sequence (and the random numbers drawn, which are indexed by primary) depends on the snapshot list; with the same list a run is bit-identical at any thread count. Without this call no profile is tallied and results are unchanged.

pub fn snapshots(&self) -> &[ProfileSnapshot]

Snapshots taken so far at the requested fluences, in order.

pub fn profile_snapshot(&self) -> Option<ProfileSnapshot>

The profiles at the current fluence (None unless with_profiles was called).

pub fn run_until_cut_through( &mut self, on_step: impl FnMut(&Step2d, &[CompositionGrid]), ) -> Result<CutThrough, DynamicRunError>

Run until the hole first reaches the substrate (an illuminated column with no slab left) or the primaries are used up, calling on_step after each accepted step.

The columns must have a substrate (the layer beneath the film). The fluence is resolved to one step: see CutThrough. With a fixed or small adaptive step the bracket is narrow; the damage left in the substrate at the stop is in the profiles of the result.

pub fn columns(&self) -> &[CompositionGrid]

The current columns.

pub fn surface_m(&self) -> &[f64]

Surface position per column: cumulative recession, m.

pub fn profile_weights(&self) -> &[f64]

Relative fluence per column (0 where not illuminated).

pub fn ions_total_per_column(&self) -> u64

Primaries per column of the whole run.

pub fn ions_done(&self) -> u64

Primaries per column used so far.

pub fn fluence_done_m2(&self) -> f64

Peak fluence delivered so far, ions/m².

pub fn steps_done(&self) -> u64

Accepted steps so far.

pub fn cumulative(&self) -> &Yields

Event counts summed over the accepted steps and columns.

pub fn redeposited_fraction(&self) -> f64

Redeposited over sputtered atoms, over the whole run so far.

pub fn incidence_rad(&self) -> Vec<f64>

Beam incidence angle from the local surface normal per column, radians (the local-angle rule of the module docs) for the current surface.

pub fn step(&mut self) -> Result<Option<Step2d>, DynamicRunError>

Run the next step. Ok(None) when all primaries are used. On error the run state is unchanged.

pub fn run_all( &mut self, on_step: impl FnMut(&Step2d, &[CompositionGrid]), ) -> Result<(), DynamicRunError>

Run all remaining steps, calling on_step after each accepted step.

Trait Implementations

impl Debug for DynamicRun2d<'_>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.