cres 0.9.1

Cell resampling for collider events
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

use crate::{
    ParticleID,
    event::{Event, EventBuilder}
};

use std::marker::PhantomData;
use std::os::raw::c_double;

/// View into an event
///
/// Changing any of the members does not change the original event.
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct EventView<'a> {
    /// Event id
    pub id: usize,
    /// Event weights
    pub weights: *const c_double,
    /// Sets of particles of a given type
    pub type_sets: *const TypeSetView<'a>,
    /// Number of event weights
    pub n_weights: usize,
    /// Number of particle sets
    pub n_type_sets: usize,
}

/// View into a particle set
///
/// Changing any member does not change the original particle set
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct TypeSetView<'a> {
    /// Particle id
    ///
    /// This is usually the id according to the
    /// [PDG Monte Carlo Particle Numbering Scheme](https://pdg.lbl.gov/2021/mcdata/mc_particle_id_contents.html)
    pub pid: i32,
    /// Four-momenta of the particles
    pub momenta: *const FourMomentum,
    /// Number of particles
    pub n_momenta: usize,
    phantom: PhantomData<&'a ()>,
}

/// A set of particles with the same type
#[derive(Clone, Debug)]
pub struct TypeSet {
    /// Particle id
    ///
    /// This is usually the id according to the
    /// [PDG Monte Carlo Particle Numbering Scheme](https://pdg.lbl.gov/2021/mcdata/mc_particle_id_contents.html)
    pub pid: i32,
    /// Four-momenta of the particles
    pub momenta: Vec<FourMomentum>,
}

impl TypeSet {
    pub fn view(&self) -> TypeSetView<'_> {
        TypeSetView {
            pid: self.pid,
            momenta: self.momenta.as_ptr(),
            n_momenta: self.momenta.len(),
            phantom: PhantomData,
        }
    }
}

/// Four-momentum [E, px, py, pz]
pub type FourMomentum = [c_double; 4];

/// Convert from [EventView] to [Event]
///
/// # Safety
///
/// The input has to be valid, i.e. `weights` should point to a slice
/// with at least `n_weights` elements and `type_sets` to a slice with
/// at least `n_type_set` elements.
///
impl<'a> From<EventView<'a>> for Event {
    fn from(view: EventView<'a>) -> Self {
        use crate::n64;
        let EventView {
            id,
            weights,
            type_sets,
            n_weights,
            n_type_sets,
        } = view;
        let n_particles =
            (0..n_type_sets)
            .map(|n| unsafe { (*type_sets.add(n)).n_momenta })
            .sum();
        let mut event = EventBuilder::with_capacity(n_particles);
        for n_weight in 0..n_weights {
            let weight = unsafe { *weights.add(n_weight) };
            event.add_weight(n64(weight));
        }
        for n_set in 0..n_type_sets {
            let TypeSetView {
                pid,
                momenta,
                n_momenta,
                ..
            } = unsafe { *type_sets.add(n_set) };
            for n_p in 0..n_momenta {
                let p = unsafe { *momenta.add(n_p) };
                event.add_outgoing(ParticleID::new(pid), p.map(n64).into());
            }
        }
        let mut event = event.build();
        event.id = id;
        event
    }
}