Merge branch 'fmi2-directional-derivatives' into libcosim/fmi3-types-metadata

# Conflicts:
#	.github/workflows/ci-cmake.yml
#	include/cosim/fmi/v2/fmu.hpp
#	src/cosim/fmi/v2/fmu.cpp
#	tests/CMakeLists.txt
#	tests/fmi_v2_fmu_unittest.cpp

Author: davidhjp01

.github/workflows/ci-cmake.yml

@@ -38,7 +38,6 @@ jobs:
             zipcmp \
             zipmerge \
             ziptool
-          rm -rf /var/lib/apt/lists/*
       - uses: actions/checkout@v4
       - name: Install FMI Library and libcbor
         shell: bash

cmake/AddTestExecutable.cmake

@@ -7,13 +7,21 @@
 #       SOURCES <sources...>
 #       DEPENDENCIES <targets...>
 #       DATA_DIR <directory>
+#       REFERENCE_FMU_V2_DIR <directory>
+#       GEN_TEST_DATA_DIR <directory>
 #   )
 #
 # "target folder" is just a human-readable name for the IDE folder that the
 # target will be grouped under. If omitted, it will be a top-level target.
 function(add_test_executable name)
     # Parse argument list
-    set(params "FOLDER" "SOURCES" "DEPENDENCIES" "DATA_DIR")
+    set(params
+        "FOLDER"
+        "SOURCES"
+        "DEPENDENCIES"
+        "DATA_DIR"
+        "REFERENCE_FMU_V2_DIR"
+        "GEN_TEST_DATA_DIR")
     foreach(p IN LISTS params)
         set(arg_${p})
     endforeach()
@@ -37,7 +45,18 @@ function(add_test_executable name)
 
     # Add test
     add_test(NAME "${name}" COMMAND "${name}")
+    set(environment)
     if(arg_DATA_DIR)
-        set_property(TEST "${name}" PROPERTY ENVIRONMENT "TEST_DATA_DIR=${arg_DATA_DIR}")
+        list(APPEND environment "TEST_DATA_DIR=${arg_DATA_DIR}")
+    endif()
+    if(arg_REFERENCE_FMU_V2_DIR)
+        list(APPEND environment
+            "REFERENCE_FMU_V2_DIR=${arg_REFERENCE_FMU_V2_DIR}")
+    endif()
+    if(arg_GEN_TEST_DATA_DIR)
+        list(APPEND environment "GEN_TEST_DATA_DIR=${arg_GEN_TEST_DATA_DIR}")
+    endif()
+    if(environment)
+        set_property(TEST "${name}" PROPERTY ENVIRONMENT ${environment})
     endif()
 endfunction()

include/cosim/exception.hpp

@@ -51,7 +51,10 @@ enum class errc
     invalid_system_structure,
 
     /// ZIP file error
-    zip_error
+    zip_error,
+
+    /// Invalid operation (e.g. calling a function at the invalid time in the simulation lifecycle)
+    invalid_operation
 };
 
 

include/cosim/fmi/v2/fmu.hpp

@@ -211,8 +211,6 @@ class slave_instance : public fmi::slave_instance
     struct saved_state
     {
         fmi2_FMU_state_t fmuState = nullptr;
-        bool setupComplete = false;
-        bool simStarted = false;
         lifecycle_state lifecycleState = lifecycle_state::instantiated;
     };
     void copy_current_state(saved_state& state);
@@ -222,8 +220,6 @@ class slave_instance : public fmi::slave_instance
     std::shared_ptr<v2::fmu> fmu_;
     fmi2_import_t* handle_;
 
-    bool setupComplete_ = false;
-    bool simStarted_ = false;
     lifecycle_state lifecycleState_ = lifecycle_state::instantiated;
     bool providesDirectionalDerivatives_ = false;
     std::vector<value_reference> outputReferences_;

src/cosim/exception.cpp

@@ -44,6 +44,8 @@ class my_error_category : public std::error_category
                 return "Invalid system structure";
             case errc::zip_error:
                 return "ZIP file error";
+            case errc::invalid_operation:
+                return "Invalid operation";
             default:
                 COSIM_PANIC();
         }

src/cosim/fmi/v2/fmu.cpp

@@ -329,7 +329,7 @@ slave_instance::slave_instance(
 
 slave_instance::~slave_instance() noexcept
 {
-    if (simStarted_) {
+    if (lifecycleState_ == lifecycle_state::step) {
         fmi2_import_terminate(handle_);
     }
     fmi2_import_free_instance(handle_);
@@ -343,7 +343,7 @@ void slave_instance::setup(
     std::optional<time_point> stopTime,
     std::optional<double> relativeTolerance)
 {
-    assert(!setupComplete_);
+    assert(lifecycleState_ == lifecycle_state::instantiated);
     const auto rcs = fmi2_import_setup_experiment(
         handle_,
         relativeTolerance ? fmi2_true : fmi2_false,
@@ -364,31 +364,27 @@ void slave_instance::setup(
             last_log_record(instanceName_).message);
     }
 
-    setupComplete_ = true;
     lifecycleState_ = lifecycle_state::initialization;
 }
 
 
 void slave_instance::start_simulation()
 {
-    assert(setupComplete_);
-    assert(!simStarted_);
+    assert(lifecycleState_ == lifecycle_state::initialization);
     const auto rc = fmi2_import_exit_initialization_mode(handle_);
     if (rc != fmi2_status_ok && rc != fmi2_status_warning) {
         throw error(
             make_error_code(errc::model_error),
             last_log_record(instanceName_).message);
     }
-    simStarted_ = true;
     lifecycleState_ = lifecycle_state::step;
 }
 
 
 void slave_instance::end_simulation()
 {
-    assert(simStarted_);
+    assert(lifecycleState_ == lifecycle_state::step);
     const auto rc = fmi2_import_terminate(handle_);
-    simStarted_ = false;
     if (rc != fmi2_status_ok && rc != fmi2_status_warning) {
         throw error(
             make_error_code(errc::model_error),
@@ -400,7 +396,7 @@ void slave_instance::end_simulation()
 
 step_result slave_instance::do_step(time_point currentT, duration deltaT)
 {
-    assert(simStarted_);
+    assert(lifecycleState_ == lifecycle_state::step);
     const auto rc = fmi2_import_do_step(
         handle_,
         to_double_time_point(currentT),
@@ -607,8 +603,6 @@ void slave_instance::restore_state(state_index stateIndex)
             make_error_code(errc::model_error),
             last_log_record(instanceName_).message);
     }
-    setupComplete_ = state.setupComplete;
-    simStarted_ = state.simStarted;
     lifecycleState_ = state.lifecycleState;
 }
 
@@ -672,8 +666,6 @@ serialization::node slave_instance::export_state(state_index stateIndex) const
     exportedState.put("scheme_version", export_scheme_version);
     exportedState.put("fmu_uuid", fmu_->model_description()->uuid);
     exportedState.put("serialized_fmu_state", serializedFMUState);
-    exportedState.put("setup_complete", savedState.setupComplete);
-    exportedState.put("simulation_started", savedState.simStarted);
     exportedState.put(
         "lifecycle_state",
         static_cast<std::int32_t>(savedState.lifecycleState));
@@ -715,56 +707,26 @@ slave::state_index slave_instance::import_state(
         }
 
         // Validate wrapper state before asking the FMU to allocate a state.
-        savedState.setupComplete = exportedState.get<bool>("setup_complete");
-        savedState.simStarted = exportedState.get<bool>("simulation_started");
-        if (schemeVersion == 0) {
-            if (savedState.setupComplete && !savedState.simStarted) {
+        const auto serializedLifecycleState =
+            exportedState.get<std::int32_t>("lifecycle_state");
+        switch (serializedLifecycleState) {
+            case static_cast<std::int32_t>(lifecycle_state::instantiated):
+                savedState.lifecycleState = lifecycle_state::instantiated;
+                break;
+            case static_cast<std::int32_t>(lifecycle_state::initialization):
+                savedState.lifecycleState = lifecycle_state::initialization;
+                break;
+            case static_cast<std::int32_t>(lifecycle_state::step):
+                savedState.lifecycleState = lifecycle_state::step;
+                break;
+            case static_cast<std::int32_t>(lifecycle_state::terminated):
+                savedState.lifecycleState = lifecycle_state::terminated;
+                break;
+            default:
                 throw error(
                     make_error_code(errc::bad_file),
                     "The serialized state of subsimulator '" + instanceName_
-                        + "' uses scheme 0 lifecycle data that is ambiguous "
-                          "between Initialization Mode and Terminated");
-            }
-            savedState.lifecycleState = savedState.simStarted
-                ? lifecycle_state::step
-                : lifecycle_state::instantiated;
-        } else {
-            const auto serializedLifecycleState =
-                exportedState.get<std::int32_t>("lifecycle_state");
-            switch (serializedLifecycleState) {
-                case static_cast<std::int32_t>(lifecycle_state::instantiated):
-                    savedState.lifecycleState = lifecycle_state::instantiated;
-                    break;
-                case static_cast<std::int32_t>(lifecycle_state::initialization):
-                    savedState.lifecycleState = lifecycle_state::initialization;
-                    break;
-                case static_cast<std::int32_t>(lifecycle_state::step):
-                    savedState.lifecycleState = lifecycle_state::step;
-                    break;
-                case static_cast<std::int32_t>(lifecycle_state::terminated):
-                    savedState.lifecycleState = lifecycle_state::terminated;
-                    break;
-                default:
-                    throw error(
-                        make_error_code(errc::bad_file),
-                        "The serialized state of subsimulator '" + instanceName_
-                            + "' contains an invalid lifecycle state");
-            }
-            const bool lifecycleStateConsistent =
-                (savedState.lifecycleState == lifecycle_state::instantiated &&
-                    !savedState.setupComplete && !savedState.simStarted) ||
-                (savedState.lifecycleState == lifecycle_state::initialization &&
-                    savedState.setupComplete && !savedState.simStarted) ||
-                (savedState.lifecycleState == lifecycle_state::step &&
-                    savedState.setupComplete && savedState.simStarted) ||
-                (savedState.lifecycleState == lifecycle_state::terminated &&
-                    savedState.setupComplete && !savedState.simStarted);
-            if (!lifecycleStateConsistent) {
-                throw error(
-                    make_error_code(errc::bad_file),
-                    "The serialized state of subsimulator '" + instanceName_
-                        + "' contains inconsistent lifecycle data");
-            }
+                        + "' contains an invalid lifecycle state");
         }
 
         const auto& serializedFMUState = std::get<std::vector<std::byte>>(
@@ -829,9 +791,12 @@ void slave_instance::get_directional_derivative(
         lifecycleState_ != lifecycle_state::step &&
         lifecycleState_ != lifecycle_state::terminated) {
         throw error(
-            make_error_code(errc::model_error),
+            make_error_code(errc::invalid_operation),
             instanceName_ +
-                ": invalid lifecycle operation: GetDirectionalDerivative");
+                ": GetDirectionalDerivative can only be called in lifecycle states "
+                "initialization (1), step (2), or terminated (3); current lifecycle "
+                "state: " +
+                std::to_string(static_cast<std::int32_t>(lifecycleState_)));
     }
     COSIM_INPUT_CHECK(!unknowns.empty());
     COSIM_INPUT_CHECK(!knowns.empty());
@@ -844,9 +809,6 @@ void slave_instance::get_directional_derivative(
                    references.end(),
                    reference) != references.end();
     };
-    const bool initializing =
-        lifecycleState_ == lifecycle_state::initialization;
-
     for (const auto reference : unknowns) {
         const auto variable = fmi2_import_get_variable_by_vr(
             handle_, fmi2_base_type_real, reference);
@@ -857,7 +819,8 @@ void slave_instance::get_directional_derivative(
             contains(outputReferences_, reference) &&
             (variability == fmi2_variability_enu_continuous ||
                 variability == fmi2_variability_enu_discrete);
-        const bool validUnknown = initializing
+        const bool validUnknown =
+            lifecycleState_ == lifecycle_state::initialization
             ? contains(initialUnknownReferences_, reference)
             : eligibleOutput ||
                 contains(derivativeReferences_, reference);
@@ -879,7 +842,7 @@ void slave_instance::get_directional_derivative(
             validKnown =
                 causality == fmi2_causality_enu_input ||
                 causality == fmi2_causality_enu_independent;
-            if (initializing) {
+            if (lifecycleState_ == lifecycle_state::initialization) {
                 validKnown =
                     validKnown ||
                     fmi2_import_get_initial(variable) ==
@@ -940,8 +903,6 @@ void slave_instance::copy_current_state(saved_state& state)
             make_error_code(errc::model_error),
             last_log_record(instanceName_).message);
     }
-    state.setupComplete = setupComplete_;
-    state.simStarted = simStarted_;
     state.lifecycleState = lifecycleState_;
 }
 

src/cosim/observer/file_observer.cpp

@@ -568,8 +568,16 @@ file_observer_config file_observer_config::parse(const filesystem::path& configP
     boost::property_tree::read_xml(configPath.string(), ptree,
         boost::property_tree::xml_parser::no_comments | boost::property_tree::xml_parser::trim_whitespace);
 
+    const auto& simulators = ptree.get_child("simulators");
+
     file_observer_config config;
-    for (const auto& simulator : ptree.get_child("simulators")) {
+    if (const auto timestamps = get_optional_attribute<bool>(simulators, "timestampedFilenames")) {
+        config.set_timestamped_filenames(*timestamps);
+    }
+    if (const auto precision = get_optional_attribute<int>(simulators, "floatingPointPrecision")) {
+        config.fixed_precision(*precision);
+    }
+    for (const auto& simulator : simulators) {
         if (simulator.first == "simulator") {
             const auto modelName = get_attribute<std::string>(simulator.second, "name");
             const auto decimationFactor = get_optional_attribute<size_t>(simulator.second, "decimationFactor");
@@ -583,15 +591,6 @@ file_observer_config file_observer_config::parse(const filesystem::path& configP
             config.log_simulator_variables(modelName, variableNames, decimationFactor);
         }
     }
-    if (const auto configuration = ptree.get_child_optional("configuration")) {
-        if (const auto timestamps = get_optional_attribute<bool>(*configuration, "timestampedFilenames")) {
-            config.set_timestamped_filenames(*timestamps);
-        }
-        if (const auto precision = get_optional_attribute<int>(*configuration, "floatingPointPrecision")) {
-            config.fixed_precision(*precision);
-        }
-    }
-
     return config;
 }
 

tests/CMakeLists.txt

@@ -49,6 +49,15 @@ ExternalProject_Add(
     INSTALL_COMMAND ""
     TEST_COMMAND "")
 
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
+
+if(NOT DEFINED GEN_TEST_DATA_DIR)
+    set(GEN_TEST_DATA_DIR
+        "${CMAKE_CURRENT_BINARY_DIR}/generated-test-data")
+endif()
+include(PrepareDahlquistTestData)
+prepare_dahlquist_test_data()
+
 if(WIN32 AND CMAKE_SIZEOF_VOID_P EQUAL 8)
     set(FMI2_TEST_PLATFORM "win64")
 elseif(CMAKE_SYSTEM_NAME STREQUAL "Linux" AND
@@ -109,7 +118,7 @@ add_custom_target(
     fmi2_derivative_fixture
     DEPENDS "${FMI2_DERIVATIVE_FIXTURE}")
 
-set(tests        
+set(tests
     "ecco_algorithm_from_system_structure_test"
     "ecco_algorithm_multi_bond_test"    
     "ecco_algorithm_test"
@@ -167,6 +176,8 @@ foreach(test IN LISTS tests)
         SOURCES "${test}.cpp"
         DEPENDENCIES "cosim"
         DATA_DIR "${CMAKE_CURRENT_SOURCE_DIR}/data"
+        REFERENCE_FMU_V2_DIR "${REFERENCE_FMUS_V2_BINARY_DIR}/fmus"
+        GEN_TEST_DATA_DIR "${GEN_TEST_DATA_DIR}"
     )
 endforeach()
 
@@ -183,15 +194,23 @@ foreach(test IN LISTS unittests)
         SOURCES "${test}.cpp"
         DEPENDENCIES ${dependencies}
         DATA_DIR "${CMAKE_CURRENT_SOURCE_DIR}/data"
+        REFERENCE_FMU_V2_DIR "${REFERENCE_FMUS_V2_BINARY_DIR}/fmus"
+        GEN_TEST_DATA_DIR "${GEN_TEST_DATA_DIR}"
     )
     target_include_directories("cpp_${test}" PRIVATE "$<TARGET_PROPERTY:cosim,SOURCE_DIR>")
 endforeach()
 
 add_dependencies(
     cpp_fmi_v2_fmu_unittest
     fmi2_derivative_fixture)
-set_property(
-    TEST cpp_fmi_v2_fmu_unittest
-    APPEND
-    PROPERTY ENVIRONMENT
-        "REFERENCE_FMU_V2_DIR=${REFERENCE_FMUS_V2_BINARY_DIR}/fmus")
+
+set(reference_fmu_test_targets
+    cpp_save_state_test
+    cpp_slave_simulator_unittest)
+if(LIBCOSIM_WITH_PROXYFMU)
+    list(APPEND reference_fmu_test_targets cpp_proxyfmu_save_state_test)
+endif()
+
+foreach(reference_fmu_test IN LISTS reference_fmu_test_targets)
+    add_dependencies("${reference_fmu_test}" reference_fmus_v2_build)
+endforeach()