Struct MapMeasurement 

pub struct MapMeasurement<'a> {

    pub time_edges_us: Vec<f64>,
    pub charge_ratio: f64,
    pub normalization: Value,
    pub time_background: [Value; 3],
    pub room_background: Option<RoomBackground>,
    pub open_counts: ArrayView3<'a, f64>,
    pub sample_counts: ArrayView3<'a, f64>,
    pub open_live: Option<Vec<f64>>,
    pub sample_live: Option<Vec<f64>>,
    pub excluded: ArrayView2<'a, bool>,
    pub sample: ArrayView2<'a, bool>,
    pub empty: ArrayView2<'a, bool>,
    pub binning: usize,
    pub material: Material,
    pub background: [Value; 5],
    pub gamma_transmission: Value,
    pub capture_gammas: Value,
    pub in_scatter: Value,
    pub empty_background: [Value; 5],
}

The counts of every pixel of an open-beam run and a sample run recorded in the same time bins, which pixels to fit, and the material behind the sample.

Fields

time_edges_us: Vec<f64>

Time-bin edges in µs.

charge_ratio: f64

c_q, the sample run’s proton charge over the open-beam run’s.

normalization: Value

a, the normalization of the sample run, the same in every pixel.

time_background: [Value; 3]

[C, A, τ] of the time background per pixel, as Measurement::time_background, the same in every pixel; NO_TIME_BACKGROUND gives none.

room_background: Option<RoomBackground>

Counts that follow each run’s duration, as Measurement::room_background, the same in every pixel.

open_counts: ArrayView3<'a, f64>

Raw counts of the open-beam run, in (time bin, row, column).

sample_counts: ArrayView3<'a, f64>

Raw counts of the sample run, in (time bin, row, column).

open_live: Option<Vec<f64>>

The fraction of the open-beam run’s neutrons arriving in each bin that every pixel records, in (0, 1]; None records every one.

sample_live: Option<Vec<f64>>

The fraction of the sample run’s neutrons arriving in each bin that every pixel records, in (0, 1]; None records every one.

excluded: ArrayView2<'a, bool>

Pixels left out of both runs, in (row, column).

sample: ArrayView2<'a, bool>

Pixels behind the sample, in (row, column).

empty: ArrayView2<'a, bool>

Pixels the beam reaches through nothing and the sample scatters no neutrons into, in (row, column).

binning: usize

The side of a square patch, in pixels.

material: Material

The material behind the sample: its isotopes’ densities and its temperature, known, fitted or within bounds, in every patch.

background: [Value; 5]

[b0, b1, b2, d, f] of the background of every patch behind the sample, as Region::background, known, fitted or within bounds.

gamma_transmission: Value

The fraction of the time background that reaches the pixels behind the sample in the sample run, as Region::gamma_transmission, known, fitted or within bounds in every patch; the empty pixels take 1.

capture_gammas: Value

The capture gammas’ ε of every patch behind the sample, as Region::capture_gammas, known, fitted or within bounds; the empty pixels hold no sample and record none.

in_scatter: Value

The in-scatter’s Ω of every patch behind the sample, as Region::in_scatter, known, fitted or within bounds; the empty pixels hold no sample and record none.

empty_background: [Value; 5]

[b0, b1, b2, d, f] of the background of the empty pixels.

Implementations

impl MapMeasurement<'_>

pub fn patches(&self) -> Result<Array2<Patch>, PipelineError>

Each patch’s kind, in (patch row, patch column); patch (i, j) holds the pixels from (i·binning, j·binning) up to the next patch or the image’s edge.

Errors

PipelineError::ShapeMismatch unless both runs’ counts have one time bin per pair of edges and the same rows and columns as the three masks; PipelineError::InvalidParameter if binning is 0.

Trait Implementations

impl<'a> Clone for MapMeasurement<'a>

fn clone(&self) -> MapMeasurement<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for MapMeasurement<'a>

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

Formats the value using the given formatter.