Nuclide 0.3.0

Database and simple modeling of all known nuclides
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189

use ::Nuclide::{Isotope, ChemElement, Nuclide};
use ::Nuclide::decay::{AlphaEmission, TotalDecay, ElectronEmission};

/*
 Tests to perform 3
   Assignment
   Identity
   Deterministic decay
   Forced decay, each type


   Side tests to perform exhaustively
   decaymode
   from nucleons  Correct
   isotope
   isobar
   isotone
   identity

*/

const ISOTOPE_COUNT: [u8; 118] = [
    7, 9, 11, 12, 16, 16, 16, 18, 19, 20, 23, 23, 23, 24, 24, 24, 25, 26, 29, 29, 29, 29, 29, 30,
    31, 32, 32, 35, 33, 33, 33, 33, 33, 33, 37, 36, 36, 36, 37, 38, 39, 39, 40, 41, 41, 42, 42, 42,
    42, 42, 41, 42, 42, 43, 42, 42, 42, 41, 41, 40, 40, 41, 41, 40, 40, 39, 39, 39, 39, 38, 39, 38,
    40, 41, 41, 43, 43, 44, 43, 47, 43, 43, 41, 42, 39, 39, 37, 35, 33, 32, 31, 29, 34, 32, 30, 22,
    22, 20, 20, 20, 19, 17, 16, 16, 16, 16, 19, 18, 18, 18, 15, 13, 13, 8, 6, 6, 4, 3,
];

const _ISOTONE_COUNT: [u8; 179] = [
    3, 5, 6, 8, 9, 10, 11, 11, 13, 13, 14, 15, 16, 16, 17, 18, 19, 19, 19, 19, 21, 20, 20, 20, 21,
    21, 22, 23, 23, 23, 23, 23, 22, 21, 21, 22, 22, 22, 23, 24, 25, 25, 24, 24, 24, 24, 25, 25, 25,
    25, 25, 25, 25, 26, 27, 26, 26, 26, 25, 25, 24, 25, 25, 25, 26, 27, 28, 27, 27, 28, 28, 27, 28,
    28, 29, 29, 29, 28, 28, 29, 28, 29, 29, 30, 30, 31, 31, 31, 30, 30, 31, 30, 29, 29, 28, 28, 29,
    28, 27, 26, 26, 26, 26, 25, 24, 23, 24, 24, 23, 22, 22, 21, 20, 20, 19, 19, 19, 19, 19, 18, 19,
    19, 18, 19, 18, 17, 18, 19, 19, 18, 18, 17, 16, 16, 16, 17, 18, 17, 16, 16, 17, 18, 17, 18, 17,
    16, 16, 15, 15, 15, 15, 14, 14, 15, 15, 16, 17, 17, 15, 13, 11, 11, 10, 9, 9, 9, 8, 8, 7, 7, 8,
    8, 8, 8, 8, 8, 7, 6, 1,
];

const _ISOBAR_COUNT: [u8; 295] = [
    1, 2, 3, 3, 4, 5, 5, 5, 5, 6, 6, 6, 7, 6, 7, 7, 7, 7, 8, 8, 9, 9, 9, 9, 9, 9, 9, 10, 10, 10,
    11, 10, 11, 11, 11, 11, 12, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 13, 13, 12, 12, 13, 12, 13,
    12, 13, 13, 14, 14, 14, 14, 13, 14, 13, 14, 13, 14, 13, 13, 13, 13, 13, 14, 13, 14, 14, 14, 14,
    14, 14, 15, 15, 15, 15, 15, 15, 14, 15, 14, 15, 14, 15, 14, 15, 15, 15, 15, 15, 16, 16, 16, 16,
    15, 16, 16, 17, 16, 17, 16, 16, 17, 16, 17, 17, 16, 17, 17, 16, 17, 16, 17, 17, 16, 17, 17, 17,
    17, 18, 17, 18, 18, 17, 18, 17, 18, 17, 17, 17, 17, 18, 17, 18, 17, 18, 18, 17, 17, 17, 17, 18,
    17, 17, 17, 17, 17, 17, 18, 17, 18, 17, 18, 17, 18, 17, 18, 17, 17, 18, 17, 18, 17, 17, 16, 16,
    15, 16, 15, 16, 15, 15, 14, 14, 13, 14, 14, 14, 14, 14, 13, 13, 13, 13, 14, 14, 13, 13, 14, 13,
    13, 12, 13, 13, 13, 12, 13, 12, 12, 13, 12, 12, 12, 12, 12, 12, 13, 13, 12, 12, 12, 12, 12, 12,
    13, 13, 12, 12, 12, 11, 11, 10, 11, 10, 11, 10, 10, 9, 10, 9, 10, 9, 10, 9, 9, 9, 9, 9, 9, 10,
    10, 10, 11, 11, 8, 8, 8, 8, 7, 8, 7, 8, 7, 7, 7, 7, 7, 7, 7, 7, 6, 6, 5, 6, 6, 5, 5, 6, 6, 7,
    6, 6, 5, 5, 4, 5, 4, 4, 4, 4, 4, 4, 4, 3, 3, 3, 1,
];

#[test]
fn decay_test() {
    let uranium = Nuclide::new("U-235").unwrap();
    let thorium = uranium.daughter::<AlphaEmission<1>>().expect("Alpha decay of U-235 valid");
    let expected = Nuclide::new("Th-231").unwrap();
    assert_eq!(thorium, expected, "{thorium} != {expected}");

    let pa = thorium.daughter::<ElectronEmission<1>>().expect("Electron emission of Th-231 valid");
    let expected = Nuclide::new("Pa-231").unwrap();
    assert_eq!(pa, expected, "{pa} != {expected}");
}

#[test] // Verifies that proton-neutron and from_nucleons are correct inverses
fn initialization_test() {
    for i in 0..3585 {
        let nuclide = Nuclide::assign(i);
        let (z, n) = nuclide.proton_neutron();
        let testnuclide = Nuclide::from_nucleons(z, n).unwrap();
        assert_eq!(nuclide.nuclide_index(), testnuclide.nuclide_index());
        // Verifies that new and identity are inverses
        assert_eq!(
            nuclide.nuclide_index(),
            Nuclide::new(&nuclide.to_string()).unwrap().nuclide_index()
        )
    }

    let mut count = 0u32; //Bruteforce check of from_nucleons. Ensures that only unique values are counted
    for z in 0..300 {
        // generously exceeds the limit of 118 protons
        for n in 0..300 {
            // Exceeds the limit of 178 neutrons as well
            if let Some(nuclide) = Nuclide::from_nucleons(z, n) {
                count += 1;
                assert_eq!(nuclide.proton_neutron(), (z, n));
            }
        }
    }

    assert_eq!(3585, count); // Total of 3585 nuclides means that this is correct
}

#[test] // verifies that isotope lists are accurate
fn isotope_test() {
    for i in 1..119 {
        let p = Nuclide::from_nucleons(i, (i as f64 * 1.5).round() as usize).unwrap();
        let isocount = p.isotope_list().len();
        assert_eq!(isocount as u8, ISOTOPE_COUNT[i - 1])
    }
    /*
    for i in 1..178{

      let p = Nuclide::from_nucleons((i as f64/1.5).ceil() as usize,i).unwrap();
     // println!("{}",p.identity());
      let isocount = p.isotone_list().len();
      assert_eq!(isocount as u8,ISOTONE_COUNT[i-1])
    }
    */
}

//#[ignore]
#[test]
fn mirror() {
    // Construct all mirrorable nuclides and show that the function correctly swaps the nucleons.
    // This does not test that the mirror function selects all mirrorable nuclides however

    let nuclides = Nuclide::list();
    let mut mirrors = vec![];
    let mut mirrorable = vec![];
    for atom in nuclides {
        if let Some(mir) = atom.mirror() {
            mirrors.push(mir);
            mirrorable.push(atom);
        }
    }

    for (og, mir) in mirrorable.iter().zip(mirrors.iter()) {
        assert_eq!(*og, mir.mirror().unwrap());
        assert_eq!(
            og.proton_neutron(),
            (mir.proton_neutron().1, mir.proton_neutron().0)
        )
    }

    assert_eq!(mirrors.len(), 514); // Currently believed by the author to be 514 mirror nuclide pairs
}

/* Checks that the mass model meets the error bounds, binding energy is currently computed using the mass model
so mass_defect as EV is used instead. Note that this means that the binding energy error is not a comparison against
empirical values. The mass error however is, and one can see that the current model has -+ 0.2968 amu maximum error.

*/
// #[test]
// fn mass_model() {
//     const MASS_ERROR: f64 = 0.29677;
//     const BE_ERROR: f64 = 235.01;
// 
//     let nuclides = Nuclide::list(); // List of all nuclides
// 
//     for atom in nuclides.iter() {
//         let (proton, neutron) = atom.proton_neutron();
//         let (mass, be) = Nuclide::create(proton, neutron);
// 
//         let masshi = atom.am() + MASS_ERROR;
//         let masslo = atom.am() - MASS_ERROR;
// 
//         let be_hi = atom.mass_deficit_ev() + BE_ERROR;
//         let be_lo = atom.mass_deficit_ev() - BE_ERROR;
// 
//         assert!(mass < masshi && mass > masslo);
//         assert!(be < be_hi && be > be_lo);
//     }
// }

/*
   Checks that all potential daughter nuclides are documented and exist within the nuclide dataset

   This will panic if there are decays that include undocumented nuclides. This will also detect any decay looping
   errors where an isotope has a mode set to decay back into it's mother resulting in an infinite loop
*/

#[test]
fn no_ghost_nuclide() {
    let nuclides = Nuclide::list();

    for atom in nuclides.iter() {
        if atom.half_life::<TotalDecay>() == f64::INFINITY {
            // Skips nuclide if it is stable
            continue;
        }

        let mut radio_isotope = *atom;
        radio_isotope.decay::<TotalDecay>(f64::MAX); // sufficient to decay any nuclide to a stable state
    }
}