fmi_sim/sim/fmi2/
mod.rs

1use arrow::array::RecordBatch;
2
3use fmi::fmi2::import::Fmi2Import;
4
5use crate::{
6    Error,
7    options::{CoSimulationOptions, ModelExchangeOptions},
8    sim::{
9        InputState, RecorderState, SimState, SimStateTrait,
10        traits::{ImportSchemaBuilder, SimInitialize},
11    },
12};
13
14use super::{SimStats, params::SimParams, traits::FmiSim};
15
16#[cfg(feature = "cs")]
17mod cs;
18mod io;
19#[cfg(feature = "me")]
20mod me;
21mod schema;
22
23impl FmiSim for Fmi2Import {
24    #[cfg(feature = "me")]
25    fn simulate_me(
26        &self,
27        options: &ModelExchangeOptions,
28        input_data: Option<RecordBatch>,
29    ) -> Result<(RecordBatch, SimStats), Error> {
30        use crate::sim::{solver, traits::SimMe};
31        use fmi::{fmi2::instance::InstanceME, traits::FmiImport};
32
33        let sim_params =
34            SimParams::new_from_options(&options.common, self.model_description(), true, false);
35
36        let start_values = self.parse_start_values(&options.common.initial_values)?;
37        let input_state = InputState::new(self, input_data)?;
38        let output_state = RecorderState::new(self, &sim_params);
39
40        let mut sim_state =
41            SimState::<InstanceME>::new(self, sim_params, input_state, output_state)?;
42        sim_state.initialize(start_values, options.common.initial_fmu_state_file.as_ref())?;
43        let stats = sim_state.main_loop::<solver::Euler>(())?;
44
45        Ok((sim_state.recorder_state.finish(), stats))
46    }
47
48    #[cfg(feature = "cs")]
49    fn simulate_cs(
50        &self,
51        options: &CoSimulationOptions,
52        input_data: Option<RecordBatch>,
53    ) -> Result<(RecordBatch, SimStats), Error> {
54        use fmi::{fmi2::instance::InstanceCS, traits::FmiImport};
55
56        let sim_params = SimParams::new_from_options(
57            &options.common,
58            self.model_description(),
59            options.event_mode_used,
60            options.early_return_allowed,
61        );
62
63        let start_values = self.parse_start_values(&options.common.initial_values)?;
64        let input_state = InputState::new(self, input_data)?;
65        let recorder_state = RecorderState::new(self, &sim_params);
66
67        let mut sim_state =
68            SimState::<InstanceCS>::new(self, sim_params, input_state, recorder_state)?;
69        sim_state.initialize(start_values, options.common.initial_fmu_state_file.as_ref())?;
70        let stats = sim_state.main_loop().map_err(fmi::Error::from)?;
71
72        Ok((sim_state.recorder_state.finish(), stats))
73    }
74}