fmi 0.8.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

use std::{path::PathBuf, str::FromStr};

use super::{binding, instance::Instance};
use crate::{CS, Error, ME, traits::FmiImport};

use fmi_schema::{MajorVersion, fmi2 as schema};

#[derive(Debug)]
pub struct Fmi2Import {
    /// Path to the unzipped FMU on disk
    dir: tempfile::TempDir,
    /// Parsed raw-schema model description
    model_description: schema::Fmi2ModelDescription,
}

fn platform_folder(os: &str, arch: &str) -> Option<&'static str> {
    match (os, arch) {
        ("windows", "x86_64") => Some("win64"),
        ("windows", "x86") => Some("win32"),
        ("linux", "x86_64") => Some("linux64"),
        ("linux", "x86") => Some("linux32"),
        // FMI 2.0 predates Linux/aarch64; FMpy and other common exporters place aarch64
        // binaries under binaries/linux64/ by convention, so map to "linux64" here.
        ("linux", "aarch64") => Some("linux64"),
        ("macos", "x86_64") => Some("darwin64"),
        ("macos", "x86") => Some("darwin32"),
        _ => None,
    }
}

impl FmiImport for Fmi2Import {
    const MAJOR_VERSION: MajorVersion = MajorVersion::FMI2;
    type ModelDescription = schema::Fmi2ModelDescription;
    type Binding = binding::Fmi2Binding;
    type ValueRef = binding::fmi2ValueReference;

    fn new(dir: tempfile::TempDir, schema_xml: &str) -> Result<Self, Error> {
        let schema = schema::Fmi2ModelDescription::from_str(schema_xml)?;
        Ok(Self {
            dir,
            model_description: schema,
        })
    }

    #[inline]
    fn archive_path(&self) -> &std::path::Path {
        self.dir.path()
    }

    /// Get the path to the shared library
    fn shared_lib_path(&self, model_identifier: &str) -> Result<PathBuf, Error> {
        let platform_folder = platform_folder(std::env::consts::OS, std::env::consts::ARCH)
            .ok_or_else(|| Error::UnsupportedPlatform {
                os: std::env::consts::OS.to_string(),
                arch: std::env::consts::ARCH.to_string(),
            })?;
        let fname = format!("{model_identifier}{}", std::env::consts::DLL_SUFFIX);
        Ok(std::path::PathBuf::from("binaries")
            .join(platform_folder)
            .join(fname))
    }

    fn model_description(&self) -> &Self::ModelDescription {
        &self.model_description
    }

    /// Load the plugin shared library and return the raw bindings.
    fn binding(&self, model_identifier: &str) -> Result<Self::Binding, Error> {
        let lib_path = self
            .dir
            .path()
            .join(self.shared_lib_path(model_identifier)?);
        log::trace!("Loading shared library {lib_path:?}");
        unsafe { binding::Fmi2Binding::new(lib_path).map_err(Error::from) }
    }

    /// Get a `String` representation of the resources path for this FMU
    ///
    /// As per the FMI standard, the resource location is a IETF URI to the resources directory.
    fn canonical_resource_path_string(&self) -> String {
        let resource_path =
            std::path::absolute(self.resource_path()).expect("Invalid resource path");
        url::Url::from_file_path(resource_path)
            .map(|url| url.as_str().to_owned())
            .expect("Error converting path to URL")
    }
}

impl Fmi2Import {
    /// Create a new instance of the FMU for Model-Exchange
    pub fn instantiate_me(
        &self,
        instance_name: &str,
        visible: bool,
        logging_on: bool,
    ) -> Result<Instance<ME>, Error> {
        Instance::<ME>::new(self, instance_name, visible, logging_on)
    }

    /// Create a new instance of the FMU for Co-Simulation
    pub fn instantiate_cs(
        &self,
        instance_name: &str,
        visible: bool,
        logging_on: bool,
    ) -> Result<Instance<CS>, Error> {
        Instance::<CS>::new(self, instance_name, visible, logging_on)
    }
}

#[cfg(test)]
mod tests {
    use super::platform_folder;

    #[test]
    fn linux_aarch64_uses_linux64_platform_folder() {
        assert_eq!(platform_folder("linux", "aarch64"), Some("linux64"));
    }
}