fmi-rs 0.1.0

Functional Mock-up Interface (FMI) for Rust
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

use crate::{
    model_description::fmi2::ModelDescription,
    sim::{
        SimulationError,
        fmi2::{Trajectories, parse_variable_value},
    },
};
use std::{io::Read, path::Path, sync::Arc};

pub fn write_csv<P: AsRef<Path>>(
    trajectories: &Trajectories,
    output_file: P,
) -> std::io::Result<()> {
    let mut writer = csv::Writer::from_path(output_file)?;

    let mut header = vec!["time".to_string()];

    for variable in trajectories.variables() {
        header.push(variable.name.clone());
    }

    writer.write_record(&header)?;

    for (time, row) in trajectories.time.iter().zip(trajectories.rows.iter()) {
        let values = row.iter().map(|value| value.to_literal());
        let record: Vec<String> = std::iter::once(time.to_string()).chain(values).collect();
        writer.write_record(&record)?;
    }

    writer.flush()?;

    Ok(())
}

pub fn read_csv<R: Read>(
    reader: R,
    model_description: Arc<ModelDescription>,
) -> Result<Trajectories, SimulationError> {
    let mut reader = csv::Reader::from_reader(reader);

    let headers = match reader.headers() {
        Ok(record) => record,
        Err(e) => {
            return Err(SimulationError::Parse(format!(
                "Failed to read headers. {e}"
            )));
        }
    };

    let mut variable_indices = vec![];
    let mut variable_types = vec![];

    for name in headers.iter().skip(1) {
        variable_indices.push(model_description.variable_index_by_name(name)?);
        variable_types.push(&model_description.variable_by_name(name)?.variableType);
    }

    let mut time = vec![];
    let mut rows = vec![];

    for (i, result) in reader.records().enumerate() {
        match result {
            Ok(record) => {
                let mut row = vec![];
                let mut it = record.iter();

                let next_time: f64 = it
                    .next()
                    .ok_or_else(|| {
                        SimulationError::Parse(format!(
                            "Missing time value in row {}.",
                            i.saturating_add(2)
                        ))
                    })?
                    .parse()
                    .map_err(|e| {
                        SimulationError::Parse(format!(
                            "Failed to parse time value '{}' in row {}: {}",
                            record.get(0).unwrap_or(""),
                            i.saturating_add(2),
                            e
                        ))
                    })?;

                time.push(next_time);

                for (j, (literal, variable_type)) in it.zip(variable_types.iter()).enumerate() {
                    row.push(parse_variable_value(variable_type, literal).map_err(|e| {
                        SimulationError::Parse(format!(
                            "Failed to parse '{literal:?}' (row {}, column {}): {e}",
                            i.saturating_add(2),
                            j.saturating_add(2)
                        ))
                    })?);
                }

                rows.push(row);
            }
            Err(e) => {
                return Err(SimulationError::Parse(format!("Error reading input. {e}")));
            }
        }
    }

    let trajectories = Trajectories {
        model_description,
        variable_indices,
        time,
        rows,
    };

    trajectories.validate().map_err(SimulationError::Parse)?;

    Ok(trajectories)
}