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

use anyhow::Context;
use fmi::{
    fmi3::{CoSimulation, Fmi3Model, import::Fmi3Import, instance::InstanceCS},
    traits::FmiInstance,
};

use crate::{
    Error,
    sim::{
        InputState, RecorderState, SimState, SimStateTrait, SimStats,
        interpolation::Linear,
        params::SimParams,
        traits::{InstRecordValues, SimHandleEvents},
    },
};

impl<'a> SimStateTrait<'a, InstanceCS<'a>, Fmi3Import> for SimState<InstanceCS<'a>> {
    fn new(
        import: &'a Fmi3Import,
        sim_params: SimParams,
        input_state: InputState<InstanceCS<'a>>,
        output_state: RecorderState<InstanceCS<'a>>,
    ) -> Result<Self, Error> {
        let inst = import.instantiate_cs(
            "inst1",
            true,
            true,
            sim_params.event_mode_used,
            sim_params.early_return_allowed,
            &[],
        )?;
        Ok(Self {
            sim_params,
            input_state,
            recorder_state: output_state,
            inst,
            next_event_time: None,
        })
    }
}

impl<'a> SimState<InstanceCS<'a>> {
    /// Main loop of the co-simulation
    pub fn main_loop(&mut self) -> Result<SimStats, Error> {
        let mut stats = SimStats::default();

        if self.sim_params.event_mode_used {
            self.inst.enter_step_mode().map_err(fmi::Error::from)?;
        }

        let mut time = self.sim_params.start_time;

        loop {
            self.inst.record_outputs(time, &mut self.recorder_state)?;

            if time >= self.sim_params.stop_time {
                break;
            }

            // calculate next time point
            let next_regular_point = self.sim_params.start_time
                + (stats.num_steps + 1) as f64 * self.sim_params.output_interval;
            let next_input_event_time = self.input_state.next_input_event(time);
            // use `next_input_event` if it is earlier than `next_regular_point`
            let next_communication_point = next_input_event_time.min(next_regular_point);
            let input_event = next_regular_point > next_input_event_time;

            let step_size = next_communication_point - time;

            let mut event_encountered = false;
            let mut terminate_simulation = false;
            let mut early_return = false;
            let mut last_successful_time = 0.0;

            if self.sim_params.event_mode_used {
                self.input_state
                    .apply_input::<Linear>(time, &mut self.inst, false, true, false)?;
            } else {
                self.input_state
                    .apply_input::<Linear>(time, &mut self.inst, true, true, true)?;
            }

            self.inst
                .do_step(
                    time,
                    step_size,
                    true,
                    &mut event_encountered,
                    &mut terminate_simulation,
                    &mut early_return,
                    &mut last_successful_time,
                )
                .ok()
                .context("do_step")?;

            if early_return && !self.sim_params.early_return_allowed {
                panic!("Early return is not allowed.");
            }

            if terminate_simulation {
                break;
            }

            if early_return && last_successful_time < next_communication_point {
                time = last_successful_time;
            } else {
                time = next_communication_point;
            }

            if time == next_regular_point {
                stats.num_steps += 1;
            }

            if self.sim_params.event_mode_used && (input_event || event_encountered) {
                log::trace!("Event encountered at t = {time}");
                self.handle_events(time, input_event, &mut terminate_simulation)?;

                self.inst
                    .enter_step_mode()
                    .ok()
                    .context("enter_step_mode")?;
            }
        }

        self.inst.terminate().ok().context("terminate")?;

        stats.end_time = time;
        Ok(stats)
    }
}