fmi 0.7.0

A Rust interface to FMUs (Functional Mockup Units) that follow the FMI Standard. See http://www.fmi-standard.org/
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

//! FMI 3.0 instance interface

use crate::{
    CS, InterfaceType, ME, SE,
    fmi3::{
        Fmi3Error, Fmi3Res,
        traits::{Common, GetSet},
    },
    traits::{FmiImport, FmiInstance, InstanceTag},
};

use super::{Fmi3Status, binding, import::Fmi3Import, schema};

mod co_simulation;
mod common;
mod model_exchange;
mod scheduled_execution;

pub type InstanceME = Instance<ME>;
pub type InstanceCS = Instance<CS>;
pub type InstanceSE = Instance<SE>;

/// An imported FMI 3.0 instance
pub struct Instance<Tag> {
    /// Raw FMI 3.0 bindings
    binding: binding::Fmi3Binding,
    /// Pointer to the raw FMI 3.0 instance
    ptr: binding::fmi3Instance,
    /// Instance name
    name: String,
    _tag: std::marker::PhantomData<Tag>,
}

impl<Tag> Drop for Instance<Tag> {
    fn drop(&mut self) {
        unsafe {
            log::trace!("Freeing instance {:?}", self.ptr);
            self.binding.fmi3FreeInstance(self.ptr);
        }
    }
}

impl<Tag> Instance<Tag>
where
    Self: Common,
{
    /// Get the sum of the product of the dimensions of the variables with the given value references.
    ///
    /// # Arguments
    /// * `model_description` - The model description to look up variable information
    /// * `var_refs` - Value references of the variables to get dimensions for
    pub fn get_variable_dimensions(
        &mut self,
        model_description: &schema::Fmi3ModelDescription,
        var_refs: &[u32],
    ) -> usize {
        let var_dims = var_refs.iter().map(|vr| {
            model_description
                .model_variables
                .iter_floating()
                .find(|fv| fv.value_reference() == *vr)
                .map(|fv| fv.dimensions().iter())
                .expect("Variable not found")
        });

        var_dims
            .map(|dims| {
                dims.map(|dim| match dim {
                    schema::Dimension::Fixed(start) => *start as usize,
                    schema::Dimension::Variable(vr) => {
                        let mut dim_val = [0];
                        self.get_uint64(&[*vr], &mut dim_val)
                            .expect("Error getting dimension");
                        dim_val[0] as usize
                    }
                })
                .product::<usize>()
            })
            .sum()
    }
}

impl<Tag: InstanceTag> FmiInstance for Instance<Tag> {
    type ModelDescription = schema::Fmi3ModelDescription;
    type ValueRef = <Fmi3Import as FmiImport>::ValueRef;
    type Status = Fmi3Status;

    fn name(&self) -> &str {
        &self.name
    }

    fn get_version(&self) -> &str {
        Common::get_version(self)
    }

    fn interface_type(&self) -> InterfaceType {
        Tag::TYPE
    }

    fn set_debug_logging(
        &mut self,
        logging_on: bool,
        categories: &[&str],
    ) -> Result<Fmi3Res, Fmi3Error> {
        Common::set_debug_logging(self, logging_on, categories)
    }

    fn enter_initialization_mode(
        &mut self,
        tolerance: Option<f64>,
        start_time: f64,
        stop_time: Option<f64>,
    ) -> Result<Fmi3Res, Fmi3Error> {
        Common::enter_initialization_mode(self, tolerance, start_time, stop_time)
    }

    fn exit_initialization_mode(&mut self) -> Result<Fmi3Res, Fmi3Error> {
        Common::exit_initialization_mode(self)
    }

    fn terminate(&mut self) -> Result<Fmi3Res, Fmi3Error> {
        Common::terminate(self)
    }

    fn reset(&mut self) -> Result<Fmi3Res, Fmi3Error> {
        Common::reset(self)
    }
}

pub struct Fmu3State<Tag> {
    instance: Instance<Tag>,
    /// Pointer to the raw FMI 3.0 state
    state: binding::fmi3FMUState,
}

impl<Tag> Drop for Fmu3State<Tag> {
    fn drop(&mut self) {
        unsafe {
            log::trace!("Freeing state {:?}", self.state);
            self.instance
                .binding
                .fmi3FreeFMUState(self.instance.ptr, &mut self.state);
        }
    }
}