bambam 0.3.1

The Behavior and Advanced Mobility Big Access Model
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

//! builds labels that include enumerations for leg modes.
//!
use std::num::NonZeroU64;

use itertools::Itertools;
use routee_compass_core::model::{
    label::{label_model_error::LabelModelError, Label, LabelModel},
    network::VertexId,
    state::{StateModel, StateVariable},
};

use bambam_core::model::state::{
    multimodal_state_ops as ops, LegIdx, MultimodalMapping, MultimodalStateMapping,
};

/// builds trip leg mode sequences into the tree labels.
/// does not impose a pareto domination scheme over the space of valid trips.
pub struct MultimodalLabelModel {
    mode_to_state: MultimodalStateMapping,
    max_trip_legs: NonZeroU64,
}

impl MultimodalLabelModel {
    pub fn new(
        mode_to_state: MultimodalStateMapping,
        max_trip_legs: NonZeroU64,
    ) -> MultimodalLabelModel {
        MultimodalLabelModel {
            mode_to_state,
            max_trip_legs,
        }
    }

    pub const ERR_EMPTY: &str = "cannot build a multimodal search Label for a trip with no legs";
}

impl LabelModel for MultimodalLabelModel {
    fn label_from_state(
        &self,
        vertex_id: VertexId,
        state: &[StateVariable],
        state_model: &StateModel,
    ) -> Result<Label, LabelModelError> {
        let mode_labels: Vec<u8> =
            ops::get_mode_label_sequence(state, state_model, self.max_trip_legs)?
                .into_iter()
                .map(|mode_label| {
                    mode_label.try_into().map_err(|e| {
                        LabelModelError::LabelModelError(format!(
                            "mode label {mode_label} cannot be expressed as u8: {e}"
                        ))
                    })
                })
                .collect::<Result<Vec<_>, _>>()?;

        let label = Label::new_u8_state(vertex_id, &mode_labels)?;

        log::debug!(
            "multimodal label model at vertex {} produced label [{}] for state at time: {:.2} minutes",
            vertex_id,
            mode_labels.iter().map(|l| self.mode_to_state.get_categorical(*l as i64).unwrap_or_default().cloned().unwrap_or_default()).join("->"),
            state_model
                .get_time(state, "trip_time")
                .unwrap_or_default()
                .get::<uom::si::time::minute>()
        );

        Ok(label)
    }
}

#[cfg(test)]
mod test {
    use std::num::NonZeroU64;

    use routee_compass_core::model::state::StateVariable;
    use routee_compass_core::model::traversal::TraversalModel;
    use routee_compass_core::model::{label::LabelModel, network::VertexId, state::StateModel};

    use crate::model::label::multimodal::{
        multimodal_label_ops as label_ops, MultimodalLabelModel,
    };
    use crate::model::traversal::multimodal::MultimodalTraversalModel;
    use bambam_core::model::state::MultimodalMapping;
    use bambam_core::model::state::{multimodal_state_ops as state_ops, MultimodalStateMapping};
    #[test]
    fn test_empty() {
        let max_trip_legs = NonZeroU64::new(1).unwrap();
        let mtm = MultimodalTraversalModel::new_local("walk", max_trip_legs, &["walk"])
            .expect("test invariant failed");
        let state_model = StateModel::new(mtm.output_features());
        let state = state_model
            .initial_state(None)
            .expect("test invariant failed");
        let vertex_id = VertexId(0);
        let model = MultimodalLabelModel::new(MultimodalMapping::empty(), max_trip_legs);

        let label = model
            .label_from_state(vertex_id, &state, &state_model)
            .expect("test failed");
        let result =
            label_ops::get_mode_sequence(&label, &mtm.mode_enumeration).expect("test failed");
        assert!(result.is_empty());
    }

    #[test]
    fn test_store_leg_sequence_in_label() {
        // SETUP: assign a state with sequence ["drive", "transit", "walk"]
        let max_trip_legs = NonZeroU64::new(3).unwrap();
        let am = MultimodalTraversalModel::new_local(
            "drive",
            max_trip_legs,
            &["walk", "bike", "drive", "tnc", "transit"],
        )
        .expect("test invariant failed");
        let sm = StateModel::new(am.output_features());
        let mut state = sm.initial_state(None).expect("test invariant failed");
        inject_trip_legs(
            &["drive", "transit", "walk"],
            &mut state,
            &sm,
            &am.mode_enumeration,
            max_trip_legs,
        );

        let vertex_id = VertexId(0);
        let model = MultimodalLabelModel::new(MultimodalMapping::empty(), max_trip_legs);

        // TEST
        let label = model
            .label_from_state(vertex_id, &state, &sm)
            .expect("test failed");
        let result =
            label_ops::get_mode_sequence(&label, &am.mode_enumeration).expect("test failed");
        assert_eq!(result, &["drive", "transit", "walk"]);
    }

    fn inject_trip_legs(
        legs: &[&str],
        state: &mut [StateVariable],
        state_model: &StateModel,
        mode_to_state: &MultimodalStateMapping,
        max_trip_legs: NonZeroU64,
    ) {
        for (leg_idx, mode) in legs.iter().enumerate() {
            state_ops::set_leg_mode(state, leg_idx as u64, mode, state_model, mode_to_state)
                .expect("test invariant failed");
            state_ops::increment_active_leg_idx(state, state_model, max_trip_legs)
                .expect("test invariant failed");
        }
    }
}