Struct Dose 

pub struct Dose {
    pub absorbed_dose: f64,
}

A simple absorbed dose wrapper in gray.

Fields

absorbed_dose: f64

Absorbed dose in gray.

Implementations

impl Dose

pub fn new(absorbed_dose: f64) -> Option<Self>

Creates a dose from a non-negative finite absorbed dose.

Examples found in repository

examples/basic_usage.rs (line 8)

fn main() -> Result<(), &'static str> {
    let beam = RadiationBeam::new(10.0, 2.0).ok_or("expected valid beam")?;
    let shield = Shield::new(core::f64::consts::LN_2, 1.0).ok_or("expected valid shield")?;
    let dose = Dose::new(2.0).ok_or("expected valid dose")?;
    let weighting = default_radiation_weighting_factor(RadiationKind::Gamma)
        .ok_or("expected gamma weighting")?;

    assert_eq!(beam.intensity(), Some(5.0));
    assert_eq!(beam.photon_flux(2.0), Some(5.0));
    assert!(
        (shield
            .transmitted_fraction()
            .ok_or("expected transmitted fraction")?
            - 0.5)
            .abs()
            < 1.0e-12
    );
    assert_eq!(dose.equivalent(weighting), Some(2.0));

    Ok(())
}

pub fn equivalent(self, radiation_weighting_factor: f64) -> Option<f64>

Computes equivalent dose from this absorbed dose.

Examples

use use_radiation::Dose;

let dose = Dose::new(2.0).ok_or("expected dose")?;

assert_eq!(dose.equivalent(20.0), Some(40.0));

Examples found in repository

examples/basic_usage.rs (line 22)

fn main() -> Result<(), &'static str> {
    let beam = RadiationBeam::new(10.0, 2.0).ok_or("expected valid beam")?;
    let shield = Shield::new(core::f64::consts::LN_2, 1.0).ok_or("expected valid shield")?;
    let dose = Dose::new(2.0).ok_or("expected valid dose")?;
    let weighting = default_radiation_weighting_factor(RadiationKind::Gamma)
        .ok_or("expected gamma weighting")?;

    assert_eq!(beam.intensity(), Some(5.0));
    assert_eq!(beam.photon_flux(2.0), Some(5.0));
    assert!(
        (shield
            .transmitted_fraction()
            .ok_or("expected transmitted fraction")?
            - 0.5)
            .abs()
            < 1.0e-12
    );
    assert_eq!(dose.equivalent(weighting), Some(2.0));

    Ok(())
}

pub fn rate_over(self, time: f64) -> Option<f64>

Computes dose rate over the given time.

Trait Implementations

impl Clone for Dose

fn clone(&self) -> Dose

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Dose

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

Formats the value using the given formatter.

impl PartialEq for Dose

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for Dose

impl StructuralPartialEq for Dose