phase 0.0.0

Physics toolkit and simulations.
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

use arctk::util::ProgressBar;
use rand::thread_rng;
use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
use std::sync::{Arc, Mutex};

use crate::{data::Data, engine::Engine, model::Model};

// pub fn run(num_neutrons: u64, model: &Model) -> i32 {
//     let pb = Arc::new(Mutex::new(ProgressBar::new(
//         "Simulating physics",
//         (num_neutrons as u64).try_into().unwrap(),
//     )));
//     (0..4).par_iter().for_each(|_thread_id| {
//         let data = sample(model);
//         pb.lock().expect("Could not lock progress bar.").tick();
//     });
//     pb.lock()
//         .expect("Could not lock progress bar.")
//         .finish_with_message("Simulation complete");

//     return 123;
// }

// fn sample(model: &Model) -> () {}

/// Run a multi-threaded simulation.
/// # Errors
/// if the progress bar can not be locked.
#[allow(clippy::expect_used)]
#[inline]
pub fn multi_thread<'a>(
    num_neutrons: usize,
    block_size: usize,
    model: &'a Model,
    engine: Engine,
) -> Data {
    let pb = ProgressBar::new("Simulating", num_neutrons);
    let pb = Arc::new(Mutex::new(pb));

    let num_threads = num_cpus::get();
    let threads: Vec<_> = (0..num_threads).collect();
    let mut out: Vec<_> = threads
        .par_iter()
        .map(|_id| {
            worker(
                block_size,
                model,
                Data::new(model.grid.num_voxels),
                &pb,
                engine,
            )
        })
        .collect();
    pb.lock()
        .expect("Failed to lock progress bar.")
        .finish_with_message("Simulation complete.");

    let mut data = out.pop().expect("No data received.");
    while let Some(o) = out.pop() {
        data += &o;
    }

    data
}

/// Run a single-threaded simulation.
/// # Errors
/// if the progress bar can not be locked.
#[allow(clippy::expect_used)]
#[inline]
fn worker<'a>(
    block_size: usize,
    model: &'a Model,
    mut data: Data,
    pb: &Arc<Mutex<ProgressBar>>,
    engine: Engine,
) -> Data {
    let mut rng = thread_rng();

    while let Some((start, end)) = {
        let mut pb = pb.lock().expect("Could not lock progress bar.");
        let b = pb.block(block_size);
        std::mem::drop(pb);
        b
    } {
        for n in start..end {
            engine(n, &mut rng, &model, &mut data);
        }
    }

    data
}