Struct Nuclide 

pub struct Nuclide { /* private fields */ }

Efficient representation of nuclide

Implementations

impl Nuclide

pub fn new(input: &str) -> Option<Nuclide>

Initializes a new Nuclide from a string representation. Currently the input must be of the form {Symbol}-{Nucleon count}

        use ::Nuclide::Nuclide;
          
        let u235 = Nuclide::new("U-235").unwrap();
        assert_eq!(u235.to_string(),"U-235");

Examples found in repository

examples/standard_atomic_mass.rs (line 21)

fn main(){
let hydro = vec![Nuclide::new("H-1").unwrap(), Nuclide::new("H-2").unwrap(), Nuclide::new("H-3").unwrap()];
let distr = vec![0.9998,0.000156,1E-18];
 println!("The standard atomic mass of hydrogen is {:?} ", standard_atomic_mass(&hydro[..], &distr[..]));

let error_values = vec!["B-17","N-23","Ne-17","Ne-31","Mg-21","Mg-34","Mg-37",
"Al-26","K-31","Cr-43","Mn-46","Co-58","Se-63","Kr-67","Rb-92","Ba-114",
"Ac-225","Th-226","Th-228","Th-230","Th-232","Pa-230","Pa-231","Pa-236","Pa-238",
"U-228","U-230","U-232","U-233","U-234","U-235","U-236","U-238","Np-229",
"Np-236","Np-237","Pu-229","Pu-235","Pu-236","Pu-237","Pu-238","Pu-240"];

for i in error_values{
   println!("{}", Nuclide::new(i).unwrap().decay_string());
}

}

examples/molecule.rs (line 30)

fn main(){
  
  let protium = Nuclide::new("H-1").unwrap();
  let deuterium = Nuclide::new("H-2").unwrap();
  let tritium = Nuclide::new("H-3").unwrap();
  let oxy = Nuclide::new("O-16").unwrap();
  let h_oxy = Nuclide::new("O-18").unwrap(); 
  
  let potable = Water::new(oxy, protium, protium);
  let hdo = Water::new(oxy, deuterium, protium);
  let heavy_water = Water::new(oxy, deuterium, deuterium);
  let tritiated_water = Water::new(oxy, tritium, tritium);
  let super_heavy_water = Water::new(h_oxy, deuterium, deuterium);

  println!("Some masses of different types of \"water\" \n ");
  println!("Regular water H2O : {} daltons", potable.mass());
  println!("Semi-heavy water HDO : {} daltons", hdo.mass());
  println!("heavy water D2O : {} daltons", heavy_water.mass());
  println!("Tritiated water T2O : {} daltons", tritiated_water.mass());
  println!("Super heavy water D2O-18 : {} daltons", super_heavy_water.mass());

}

pub fn from_nucleons_unchecked(protons: usize, neutrons: usize) -> Self

In : proton, neutron Out: Nuclide

pub fn from_nucleons(protons: usize, neutrons: usize) -> Option<Self>

In: proton, neutron Returns None if the Nuclide doesn’t exist

pub fn assign(idx: usize) -> Self

Construct a nuclide from the unique index. Avoid direct use as no checks are performed to ensure that it is valid

pub fn change(&mut self, idx: usize)

Transforms a nuclide from the unique index.

pub fn create(z: usize, n: usize) -> (f64, f64)

Returns the approximate mass and binding energy of a nuclide, theorectical or real, using the DZ-10 mass model.

pub fn nuclide_index(&self) -> usize

Returns the underlying unique value. Can be used in conjunction with “assign” and “change” to rapidly create or convert nuclides without decay

pub fn isotope(&self) -> (usize, usize)

Returns the atomic number and the nucleon count

pub fn element_name(&self) -> String

Returns the element name.

pub fn proton_neutron(&self) -> (usize, usize)

Returns the proton and neutron count

pub fn neutron_separation(&self) -> f64

Approximate neutron separation energy

pub fn proton_separation(&self) -> f64

Approximate proton separation energy

pub fn isotope_list(&self) -> Vec<Self>

returns a vector of all isotopes of the element

pub fn mirror(&self) -> Option<Self>

Returns the nuclide (if it exists) that has swapped proton-neutron count

pub fn list() -> Vec<Self>

Produces an iterator of all nuclides sorted by atomic number, e.g all hydrogen isotopes, all helium isotopes, …

pub fn isobar_list(&self) -> Vec<Self>

Produces a list of all nuclides that share the same atomic number as the selected nuclide

pub fn isotone_list(&self) -> Vec<Self>

Produces a list of nuclides that share the same number of neutrons

pub fn spin_parity(&self) -> (i8, i8)

Returns the isospin and parity in the form of a i8 pair, one of which is negatively signed for - parity

Trait Implementations

impl ChemElement for Nuclide

fn am(&self) -> f64

Returns the atomic mass in daltons

fn mullikan_en(&self) -> f64

Returns the Mullikan, or absolute, electronegativity in kj/mol

fn allen_en(&self) -> f64

Allen Electronegativity

fn pauling_en(&self) -> f64

Pauling Electronegativity. A poor fit for experimental values, however it is here for completeness

fn covalent_radii(&self, bond: usize) -> Option<f64>

Radius in Single-double-and-triple covalent bonds

fn atomic_num(&self) -> u64

Atomic number

fn electron_affinity(&self) -> f64

Electron affinity in kj/mol

fn ionization_energies(&self, level: usize) -> Option<f64>

Returns the ionization energies for all known levels. Values are in kj/mol

fn electronegativity(&self) -> f64

Returns Oganov-Tantardini values, the current best evaluation

fn ionic_radii(&self) -> f64

Ionic radii

fn vdr_crystal(&self) -> f64

Van der Waal radius in crystalline structure

fn vdr_isolated(&self) -> f64

Van der Waal radius in isolated atoms

impl Clone for Nuclide

fn clone(&self) -> Nuclide

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Nuclide

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

Formats the value using the given formatter.

impl Display for Nuclide

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

Formats the value using the given formatter.

impl FromStr for Nuclide

type Err = &'static str

The associated error which can be returned from parsing.

fn from_str(input: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for Nuclide

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Isotope for Nuclide

fn decay_constant<T: DecayMode>(&self) -> f64

Approximation of decay constant

fn decay_probability<T: DecayMode>(&self, time: f64) -> f64

Returns probability of decay

fn decay_time<T: DecayMode>(&self, time: f64) -> bool

Returns true if the nuclide would have decayed in the time given. The nuclide remains unchanged

fn decay_string(&self) -> String

Returns the probable decay modes as a string

fn decay_q<T: DecayMode>(&self) -> f64

Q-value (total energy) of a nuclear decay, regardless of whether it is observed

NAN

Returns NAN if this decay mode results in a nonexistent nuclide

fn decay<T: DecayMode>(&mut self, time: f64) -> (f64, Vec<Particle>)

Returns the name and isotope number of the nuclide

use ::Nuclide::{Nuclide, Isotope,::decay::TotalDecay};
let mut uranium = "U-238".parse::<Nuclide>().unwrap();

// total particle energy of the nuclide and vector of decay particles
let (particle_energy,particle_vector) = uranium.decay::<TotalDecay>(5E+20);

 // final nuclide in the U-238 decay series
 assert_eq!(uranium.to_string(), "Pb-206");

fn mass_deficit(&self) -> f64

Mass defect or the difference between the empirical mass and the mass of the constituents, in Daltons

fn binding_energy(&self) -> f64

Binding energy in MeV

fn branching_ratio<T: DecayMode>(&self) -> f64

Probability of the provided Decay mode being taken

fn half_life<T: DecayMode>(&self) -> f64

Half-life of nuclide/isomer in seconds. TotalDecay mode returns the half-life, all other modes return the partial half-life

fn mean_lifetime<T: DecayMode>(&self) -> f64

The mean lifetime of nuclide in seconds

fn daughter_theoretical<T: DecayMode>(&self) -> Option<Self>

Returns the daughter nuclide,regardless of whether it has been observed

fn daughter_energetic<T: DecayMode>(&mut self) -> (f64, Vec<Particle>)

Returns the daughter with decay energy

fn daughter<T: DecayMode>(&self) -> Option<Self>

Returns the daughter nuclide

impl PartialEq for Nuclide

fn eq(&self, other: &Nuclide) -> 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 Nuclide

impl Eq for Nuclide

impl StructuralPartialEq for Nuclide