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
pub mod cell;
pub mod elements;
use nalgebra::Vector3;
use serde::{Deserialize, Serialize};
use crate::system::cell::Cell;
use crate::system::elements::Element;
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct System {
size: usize,
cell: Cell,
pub elements: Vec<Element>,
pub positions: Vec<Vector3<f32>>,
pub velocities: Vec<Vector3<f32>>,
}
impl System {
pub fn size(&self) -> usize {
self.size
}
pub fn cell(&self) -> &Cell {
&self.cell
}
}
pub struct SystemBuilder {
size: usize,
cell: Option<Cell>,
elements: Option<Vec<Element>>,
positions: Option<Vec<Vector3<f32>>>,
velocities: Option<Vec<Vector3<f32>>>,
}
impl SystemBuilder {
pub fn new(size: usize) -> SystemBuilder {
SystemBuilder {
size,
cell: None,
elements: None,
positions: None,
velocities: None,
}
}
pub fn with_cell(mut self, cell: Cell) -> SystemBuilder {
self.cell = Some(cell);
self
}
pub fn with_elements(mut self, elements: Vec<Element>) -> SystemBuilder {
assert!(elements.len() == self.size);
self.elements = Some(elements);
self
}
pub fn with_positions(mut self, positions: Vec<Vector3<f32>>) -> SystemBuilder {
assert!(positions.len() == self.size);
self.positions = Some(positions);
self
}
pub fn with_velocities(mut self, velocities: Vec<Vector3<f32>>) -> SystemBuilder {
assert!(velocities.len() == self.size);
self.velocities = Some(velocities);
self
}
pub fn build(self) -> System {
let cell = match self.cell {
Some(c) => c,
None => panic!("System requires `cell` attribute"),
};
let elements = match self.elements {
Some(e) => e,
None => panic!("System requires `elements` attribute"),
};
let positions = match self.positions {
Some(p) => p,
None => panic!("System requires `positions` attribute"),
};
let velocities = match self.velocities {
Some(v) => v,
None => vec![Vector3::new(0.0, 0.0, 0.0); self.size],
};
System {
size: self.size,
cell,
elements,
positions,
velocities,
}
}
}