fmi-sim 0.5.0

A pure Rust FMI simulator
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
153
154
155
156
157
158

//! FMI2-specific input and output implementation

use arrow::{
    array::{
        ArrayRef, AsArray, BooleanBuilder, Float64Array, Float64Builder, Int32Builder,
        StringBuilder, downcast_array,
    },
    datatypes::{DataType, Float64Type, Int32Type},
};
use fmi::{fmi2::instance::Common, traits::FmiInstance};
use itertools::Itertools;

use crate::sim::{
    RecorderState,
    interpolation::{Interpolate, PreLookup},
    io::Recorder,
    traits::{InstRecordValues, InstSetValues},
};

macro_rules! impl_recorder {
    ($getter:ident, $builder_type:ident, $inst:expr, $vr:ident, $builder:ident) => {{
        let mut value = [std::default::Default::default()];
        $inst.$getter(&[*$vr], &mut value)?;
        $builder
            .as_any_mut()
            .downcast_mut::<$builder_type>()
            .expect(concat!("column is not ", stringify!($builder_type)))
            .append_value(value[0]);
    }};
}

macro_rules! impl_record_values {
    ($inst:ty) => {
        impl InstRecordValues for $inst {
            fn record_outputs(
                &mut self,
                time: f64,
                recorder: &mut RecorderState<Self>,
            ) -> anyhow::Result<()> {
                log::trace!("Recording variables at time {}", time);

                recorder.time.append_value(time);
                for Recorder {
                    field,
                    value_reference: vr,
                    builder,
                } in &mut recorder.recorders
                {
                    match field.data_type() {
                        DataType::Boolean => {
                            let mut value = [std::default::Default::default()];
                            self.get_boolean(&[*vr], &mut value)?;
                            builder
                                .as_any_mut()
                                .downcast_mut::<BooleanBuilder>()
                                .expect(concat!("column is not ", stringify!($builder_type)))
                                .append_value(value[0] > 0);
                        }
                        DataType::Int32 => {
                            impl_recorder!(get_integer, Int32Builder, self, vr, builder)
                        }
                        DataType::Float64 => {
                            impl_recorder!(get_real, Float64Builder, self, vr, builder)
                        }
                        DataType::Utf8 => {
                            let mut values = vec![std::ffi::CString::new("").unwrap()];
                            if self.get_string(&[*vr], &mut values).is_ok() {
                                let string_value = values[0].to_str().unwrap_or("");
                                builder
                                    .as_any_mut()
                                    .downcast_mut::<StringBuilder>()
                                    .expect("column is not StringBuilder")
                                    .append_value(string_value);
                            } else {
                                // Handle error case by appending empty string
                                builder
                                    .as_any_mut()
                                    .downcast_mut::<StringBuilder>()
                                    .expect("column is not StringBuilder")
                                    .append_value("");
                            }
                        }
                        _ => unimplemented!("Unsupported data type: {:?}", field.data_type()),
                    }
                }
                Ok(())
            }
        }
    };
}

macro_rules! impl_set_values {
    ($t:ty) => {
        impl InstSetValues for $t {
            fn set_array(&mut self, vrs: &[Self::ValueRef], values: &ArrayRef) {
                match values.data_type() {
                    DataType::Boolean => {
                        let values = values
                            .as_boolean()
                            .iter()
                            .map(|x| x.unwrap() as i32)
                            .collect_vec();
                        let _ = self.set_boolean(vrs, &values);
                    }
                    DataType::Int32 => {
                        let _ = self.set_integer(vrs, values.as_primitive::<Int32Type>().values());
                    }
                    DataType::Float64 => {
                        let _ = self.set_real(vrs, values.as_primitive::<Float64Type>().values());
                    }
                    DataType::Utf8 => {
                        let cstrings: Vec<std::ffi::CString> = values
                            .as_string::<i32>()
                            .iter()
                            .flatten()
                            .map(|s| std::ffi::CString::new(s).unwrap())
                            .collect();
                        let _ = self.set_string(vrs, &cstrings);
                    }
                    _ => unimplemented!("Unsupported data type"),
                }
            }

            fn set_interpolated<I: Interpolate>(
                &mut self,
                vr: <Self as FmiInstance>::ValueRef,
                pl: &PreLookup,
                array: &ArrayRef,
            ) -> anyhow::Result<()> {
                match array.data_type() {
                    DataType::Boolean => todo!(),
                    DataType::Int32 => {
                        let array = array.as_primitive::<Int32Type>();
                        let value = I::interpolate(pl, &array);
                        self.set_integer(&[vr], &[value])?;
                    }
                    DataType::Float64 => {
                        let array: Float64Array = downcast_array(&array);
                        let value = I::interpolate(pl, &array);
                        self.set_real(&[vr], &[value])?;
                    }
                    _ => unimplemented!("Unsupported data type: {:?}", array.data_type()),
                }
                Ok(())
            }
        }
    };
}

#[cfg(feature = "cs")]
impl_set_values!(fmi::fmi2::instance::InstanceCS<'_>);
#[cfg(feature = "cs")]
impl_record_values!(fmi::fmi2::instance::InstanceCS<'_>);

#[cfg(feature = "me")]
impl_set_values!(fmi::fmi2::instance::InstanceME<'_>);
#[cfg(feature = "me")]
impl_record_values!(fmi::fmi2::instance::InstanceME<'_>);