altrios-core 1.0.0

ALTRIOS Core model for train simulation
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

pub mod kind;
pub mod method;

use crate::imports::*;
use crate::track::LinkPoint;
use crate::track::PathTpc;
use crate::train::TrainState;

pub trait ResMethod {
    fn update_res(
        &mut self,
        state: &mut TrainState,
        path_tpc: &PathTpc,
        dir: &Dir,
    ) -> anyhow::Result<()>;
    fn fix_cache(&mut self, link_point_del: &LinkPoint);
}

#[serde_api]
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
#[cfg_attr(feature = "pyo3", pyclass(module = "altrios", subclass, eq))]
/// Wrapper for `TrainRes` to enable exposing contents of enum variants in python
pub struct TrainResWrapper(pub TrainRes);

#[pyo3_api]
impl TrainResWrapper {
    #[getter("point")]
    fn get_point_py(&self) -> Option<method::Point> {
        self.get_point()
    }

    #[getter("strap")]
    fn get_strap_py(&self) -> Option<method::Strap> {
        self.get_strap()
    }
}

impl Init for TrainResWrapper {}
impl SerdeAPI for TrainResWrapper {}

#[cfg(feature = "pyo3")]
impl TrainResWrapper {
    fn get_point(&self) -> Option<method::Point> {
        match &self.0 {
            TrainRes::Point(p) => Some(p.clone()),
            _ => None,
        }
    }

    fn get_strap(&self) -> Option<method::Strap> {
        match &self.0 {
            TrainRes::Strap(s) => Some(s.clone()),
            _ => None,
        }
    }
}

/// Train resistance calculator that calculates resistive powers due to rolling, curvature, flange,
/// grade, and bearing resistances.
// TODO: May also include inertial -- figure this out and modify doc string above
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub enum TrainRes {
    Point(method::Point),
    Strap(method::Strap),
}

impl Init for TrainRes {}
impl SerdeAPI for TrainRes {}

impl ResMethod for TrainRes {
    fn update_res(
        &mut self,
        state: &mut TrainState,
        path_tpc: &PathTpc,
        dir: &Dir,
    ) -> anyhow::Result<()> {
        match self {
            TrainRes::Point(p) => p.update_res(state, path_tpc, dir),
            TrainRes::Strap(s) => s.update_res(state, path_tpc, dir),
        }
    }
    fn fix_cache(&mut self, link_point_del: &LinkPoint) {
        match self {
            TrainRes::Point(p) => p.fix_cache(link_point_del),
            TrainRes::Strap(s) => s.fix_cache(link_point_del),
        }
    }
}

impl Default for TrainRes {
    fn default() -> Self {
        Self::Strap(method::Strap::default())
    }
}

impl Valid for TrainRes {
    fn valid() -> Self {
        Self::Strap(method::Strap::valid())
    }
}

// #[cfg(test)]
// mod test_train_res {
//     use super::*;

//     #[test]
//     fn check_output() {
//         let file = File::create("train_res_test.yaml").unwrap();
//         serde_yaml::to_writer(file, &TrainRes::valid()).unwrap();
//     }
// }