fmi-schema 0.7.0

XML schema support for FMI 2.0 and 3.0
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

//! Test FMI 3.0 schema by parsing the FMI3.xml file.

#[test]
#[cfg(feature = "fmi3")]
fn test_fmi3() {
    use fmi_schema::{
        fmi3::{
            BaseUnit, Causality, DependenciesKind, Float64Type, Fmi3ModelDescription, FmiFloat64,
            Initial, TypeDefinition, Variability, Variable,
        },
        traits::FmiInterfaceType,
        utils::AttrList,
    };

    let test_file = std::env::current_dir()
        .map(|path| path.join("tests/FMI3.xml"))
        .unwrap();
    let xml_content = std::fs::read_to_string(test_file).unwrap();
    let model: Fmi3ModelDescription = fmi_schema::deserialize(&xml_content).unwrap();

    let model_exchange = model.model_exchange.unwrap();
    assert_eq!(model_exchange.model_identifier(), "BouncingBall");
    assert_eq!(model_exchange.can_get_and_set_fmu_state(), Some(true));
    assert_eq!(model_exchange.can_serialize_fmu_state(), Some(true));

    let cosim = model.co_simulation.unwrap();
    assert_eq!(cosim.model_identifier(), "BouncingBall");
    assert_eq!(cosim.can_get_and_set_fmu_state(), Some(true));
    assert_eq!(cosim.can_serialize_fmu_state(), Some(true));
    assert_eq!(
        cosim.can_handle_variable_communication_step_size,
        Some(true)
    );
    assert_eq!(cosim.provides_intermediate_update, Some(true));
    assert_eq!(cosim.can_return_early_after_intermediate_update, Some(true));
    assert_eq!(cosim.fixed_internal_step_size, Some(1e-3));

    let unit_defs = model.unit_definitions.unwrap();
    assert_eq!(unit_defs.units.len(), 3);
    assert_eq!(unit_defs.units[0].name, "m");
    assert_eq!(
        unit_defs.units[1].base_unit,
        Some(BaseUnit {
            m: Some(1),
            s: Some(-1),
            ..Default::default()
        })
    );

    let type_defs = model.type_definitions.unwrap();
    assert_eq!(
        type_defs.type_definitions,
        vec![
            TypeDefinition::Float64(Float64Type {
                name: "Position".to_string(),
                quantity: Some("Position".to_string()),
                unit: Some("m".to_string()),
                ..Default::default()
            }),
            TypeDefinition::Float64(Float64Type {
                name: "Velocity".to_string(),
                quantity: Some("Velocity".to_string()),
                unit: Some("m/s".to_string()),
                ..Default::default()
            }),
            TypeDefinition::Float64(Float64Type {
                name: "Acceleration".to_string(),
                quantity: Some("Acceleration".to_string()),
                unit: Some("m/s2".to_string()),
                ..Default::default()
            }),
        ]
    );

    let log_cats = model.log_categories.unwrap();
    assert_eq!(log_cats.categories.len(), 2);
    assert_eq!(&log_cats.categories[0].name, "logEvents");
    assert_eq!(
        log_cats.categories[0].description.as_deref(),
        Some("Log events")
    );

    let default_exp = model.default_experiment.unwrap();
    assert_eq!(default_exp.start_time, Some(0.0));
    assert_eq!(default_exp.stop_time, Some(3.0));
    assert_eq!(default_exp.step_size, Some(1e-3));

    let model_vars = &model.model_variables;
    assert_eq!(model_vars.variables.len(), 7);
    assert_eq!(
        model_vars.variables[4],
        Variable::Float64(FmiFloat64 {
            name: "der(v)".to_owned(),
            description: Some("Derivative of v".to_owned()),
            causality: Some(Causality::Local),
            value_reference: 4,
            variability: Some(Variability::Continuous),
            declared_type: Some("Acceleration".to_owned()),
            initial: Some(Initial::Calculated),
            derivative: Some(3),
            ..Default::default()
        })
    );
    assert_eq!(
        model_vars.variables[6],
        Variable::Float64(FmiFloat64 {
            name: "e".to_owned(),
            value_reference: 6,
            causality: Some(Causality::Parameter),
            variability: Some(Variability::Tunable),
            initial: Some(Initial::Exact),
            description: Some("Coefficient of restitution".to_owned()),
            start: Some(AttrList(vec![0.7])),
            min: Some(0.5),
            max: Some(1.0),
            ..Default::default()
        })
    );

    let model_structure = &model.model_structure;
    let outputs = model_structure.outputs().collect::<Vec<_>>();
    assert_eq!(outputs.len(), 2);
    assert_eq!(outputs[0].value_reference, 1);
    assert_eq!(outputs[1].value_reference, 3);

    let ders = model_structure
        .continuous_state_derivatives()
        .collect::<Vec<_>>();
    assert_eq!(ders.len(), 2);
    let initials = model_structure.initial_unknowns().collect::<Vec<_>>();
    assert_eq!(initials.len(), 2);
    assert_eq!(initials[0].value_reference, 2);
    assert_eq!(initials[0].dependencies, Some(AttrList(vec![3])));
    assert_eq!(
        initials[0].dependencies_kind,
        Some(AttrList(vec![DependenciesKind::Constant]))
    );
    let event_indicators = model_structure.event_indicators().collect::<Vec<_>>();
    assert_eq!(event_indicators.len(), 1);
}