Struct VoxelGrid 

pub struct VoxelGrid { /* private fields */ }

A regular 3D grid of voxels, each filled by one material. See the module docs for the origin, flattening order, face ownership, boundary behaviour and the traversal algorithm.

use lindhard::geometry::{Boundary, Geometry, VoxelGrid};
use lindhard::material::Material;

let si = Material::from_atom_fractions(&[(14, 1.0)], None).unwrap();
let c = Material::from_atom_fractions(&[(6, 1.0)], None).unwrap();
// 2 x 1 x 1 voxels of 10 nm: silicon in front of carbon.
let grid = VoxelGrid::new(
    vec![si, c],
    [2, 1, 1],
    [1e-8; 3],
    vec![0, 1],
    [Boundary::Vacuum, Boundary::Periodic, Boundary::Periodic],
)
.unwrap();
assert_eq!(grid.locate([1.5e-8, 0.5e-8, 0.5e-8]), Some(1));

Implementations

impl VoxelGrid

pub fn new( materials: Vec<Material>, dims: [usize; 3], spacing_m: [f64; 3], cells: Vec<u32>, boundaries: [Boundary; 3], ) -> Result<Self, GeometryError>

Build a grid of dims voxels of edge lengths spacing_m, where voxel i + nx (j + ny k) has material cells[...] (an index into materials), with boundaries per axis [x, y, z].

Every dimension must be nonzero, every spacing finite and positive with a finite extent n h, the voxel count must not overflow, and every material index must exist.

pub fn dims(&self) -> [usize; 3]

Voxels per axis [nx, ny, nz].

pub fn spacing_m(&self) -> [f64; 3]

Voxel edge lengths [hx, hy, hz], m.

pub fn extent_m(&self) -> [f64; 3]

Box size [Lx, Ly, Lz] = n h, m.

pub fn boundary(&self, axis: usize) -> Boundary

Boundary behaviour of axis axis (0 = x, 1 = y, 2 = z).

pub fn flat_index(&self, ijk: [usize; 3]) -> Option<usize>

Flat region index of voxel (i, j, k), or None out of range.

pub fn voxel_of(&self, region: usize) -> [usize; 3]

Voxel (i, j, k) of a flat region index.

pub fn cell_material(&self, ijk: [usize; 3]) -> Option<usize>

Material index of voxel (i, j, k), or None out of range.

Trait Implementations

impl Clone for VoxelGrid

fn clone(&self) -> VoxelGrid

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for VoxelGrid

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

Formats the value using the given formatter.

impl Geometry for VoxelGrid

fn flight( &self, region: usize, pos: [f64; 3], dir: [f64; 3], limit: f64, ) -> Flight

The traversal behind Geometry::exit. Without an event, the region is the voxel the DDA has reached at the limit: same-material faces up to and including the limit have been crossed, so a flight ending exactly on a face is in the voxel beyond it along dir. A periodic wrap is always an event, so a clear flight never wraps.

fn n_materials(&self) -> usize

Number of distinct materials.

fn material(&self, index: usize) -> &Material

Material index (0..n_materials()).

fn n_regions(&self) -> usize

Number of regions.

fn material_index(&self, region: usize) -> usize

Index of the material filling region.

fn locate(&self, pos: [f64; 3]) -> Option<usize>

The region containing pos, or None outside the target (or for a non-finite position). Ownership of shared faces: see the module docs.

fn entry_point(&self) -> [f64; 3]

Where a beam enters by default: the origin for a Stack, the centre of the front face for a VoxelGrid.

fn exit( &self, region: usize, pos: [f64; 3], dir: [f64; 3], limit: f64, ) -> Option<Exit>

The first event along the straight flight from pos (inside region, or on one of its faces) in the unit direction dir, if it happens at a path length of at most limit; otherwise None. The event is a change of material, a periodic wrap, or leaving the target.

fn in_vacuum(&self, pos: [f64; 3]) -> bool

Whether pos lies outside the target in vacuum, used to skip weak- collision partners that would lie beyond a surface. For a Stack this is in front of the front face only (as in the M0 engine).

fn as_stack(&self) -> Option<&Stack>

This geometry as a layered Stack, if it is one. Tallies defined per layer (dose, depth-dose, interface transmission) need it.

impl PartialEq for VoxelGrid

fn eq(&self, other: &VoxelGrid) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for VoxelGrid