Feature/212 provide overview of modified variables

include/cse.h

@@ -363,6 +363,9 @@ int cse_slave_get_num_variables(cse_execution* execution, cse_slave_index slave)
  */
 int cse_slave_get_variables(cse_execution* execution, cse_slave_index slave, cse_variable_description variables[], size_t numVariables);
 
+/// Returns the number of variables in the execution that currently has an active modifier (all slaves).
+int cse_get_num_modified_variables(cse_execution* execution);
+
 /// A struct containing information about a slave which has been added to an execution.
 typedef struct
 {
@@ -374,6 +377,17 @@ typedef struct
     cse_slave_index index;
 } cse_slave_info;
 
+/// A struct containing variable information.
+typedef struct
+{
+    /// The index of the slave containing the variable.
+    cse_slave_index slave_index;
+    /// The type of the variable.
+    cse_variable_type type;
+    /// The index of the variable.
+    cse_variable_index variable_index;
+} cse_variable_id;
+
 
 /// Returns the number of slaves which have been added to an execution.
 size_t cse_execution_get_num_slaves(cse_execution* execution);
@@ -912,6 +926,19 @@ int cse_scenario_is_running(cse_manipulator* manipulator);
 /// Aborts the execution of a running scenario
 int cse_scenario_abort(cse_manipulator* manipulator);
 
+/*
+ * Retrieves a list of the currently modified variables in the simulation.
+ *
+ *  \param [in] execution
+ *      The execution.
+ *  \param [in] ids
+ *      A list of cse_variable_id structs to contain the variable information.
+ *
+ *  \returns
+ *      0 on success and -1 on error.
+ */
+int cse_get_modified_variables(cse_execution* execution, cse_variable_id ids[], size_t numVariables);
+
 #ifdef __cplusplus
 } // extern(C)
 #endif

include/cse/algorithm.hpp

@@ -175,22 +175,59 @@ class simulator : public observable
      *      solver doesn't use error estimation, it will just ignore this
      *      parameter.
      */
+
     virtual boost::fibers::future<void> setup(
         time_point startTime,
         std::optional<time_point> stopTime,
         std::optional<double> relativeTolerance) = 0;
 
+    /**
+     *
+     * Returns all variable_indexes of real type with an active modifier.
+     *
+     * @return modifiedRealIndexes
+     * Unordered set of all variable_indexes that currently have an active modifier.
+     */
+    virtual const std::unordered_set<variable_index> get_modified_real_indexes() const = 0;
+
+    /**
+     *
+     * Returns all variable_indexes of integer type with an active modifier.
+     *
+     * @return modifiedIntegerIndexes
+     * Unordered set of all variable_indexes that currently have an active modifier.
+     */
+    virtual const std::unordered_set<variable_index> get_modified_integer_indexes() const = 0;
+
+    /**
+     *
+     * Returns all variable_indexes of boolean type with an active modifier.
+     *
+     * @return modifiedBooleanIndexes
+     * Unordered set of all variable_indexes that currently have an active modifier.
+     */
+    virtual const std::unordered_set<variable_index> get_modified_boolean_indexes() const = 0;
 
     /**
-     *  Updates the simulator with new input values and makes it calculate
-     *  new output values, without advancing logical time.
-     *
-     *  This function can be used in the initialisation phase, after `setup()`
-     *  has been called and before the first `do_step()` call.  It enables
-     *  iterative initialisation of the system.  The purpose could be to
-     *  propagate initial values between simulators and/or bring the system
-     *  to a steady state.
+     *
+     * Returns all variable_indexes of string type with an active modifier.
+     *
+     * @return modifiedStringIndexes
+     * Unordered set of all variable_indexes that currently have an active modifier.
      */
+    virtual const std::unordered_set<variable_index> get_modified_string_indexes() const = 0;
+
+    /**
+  *  Updates the simulator with new input values and makes it calculate
+  *  new output values, without advancing logical time.
+  *
+  *  This function can be used in the initialisation phase, after `setup()`
+  *  has been called and before the first `do_step()` call.  It enables
+  *  iterative initialisation of the system.  The purpose could be to
+  *  propagate initial values between simulators and/or bring the system
+  *  to a steady state.
+  */
+
     virtual boost::fibers::future<void> do_iteration() = 0;
 
     /**

include/cse/execution.hpp

@@ -177,6 +177,8 @@ class execution
     /// Returns the current real time factor target
     double get_real_time_factor_target();
 
+    /// Returns a map of currently modified variables
+    std::vector<variable_id> get_modified_variables();
     /// Set initial value for a variable of type real. Must be called before simulation is started.
     void set_real_initial_value(simulator_index sim, variable_index var, double value);
 

src/c/cse.cpp

@@ -231,6 +231,11 @@ int cse_slave_get_num_variables(cse_execution* execution, cse_slave_index slave)
     return -1;
 }
 
+int cse_get_num_modified_variables(cse_execution* execution)
+{
+    return static_cast<int>(execution->cpp_execution->get_modified_variables().size());
+}
+
 cse_variable_variability to_variable_variability(const cse::variable_variability& vv)
 {
     switch (vv) {
@@ -316,7 +321,6 @@ int cse_slave_get_variables(cse_execution* execution, cse_slave_index slave, cse
     }
 }
 
-
 struct cse_slave_s
 {
     std::string address;
@@ -825,6 +829,7 @@ int cse_observer_start_observing(cse_observer* observer, cse_slave_index slave,
         return failure;
     }
 }
+
 int cse_observer_stop_observing(cse_observer* observer, cse_slave_index slave, cse_variable_type type, cse_variable_index index)
 {
     try {
@@ -1056,3 +1061,28 @@ int cse_scenario_abort(cse_manipulator* manipulator)
         return failure;
     }
 }
+
+int cse_get_modified_variables(cse_execution* execution, cse_variable_id ids[], size_t numVariables)
+{
+    try {
+        auto modified_vars = execution->cpp_execution->get_modified_variables();
+        size_t counter = 0;
+
+        if (!modified_vars.empty()) {
+            for (; counter < std::min(numVariables, modified_vars.size()); counter++) {
+                ids[counter].slave_index = modified_vars[counter].simulator;
+                ids[counter].type = to_c_variable_type(modified_vars[counter].type);
+                ids[counter].variable_index = modified_vars[counter].index;
+
+                ++counter;
+            }
+        }
+
+        return static_cast<int>(counter);
+    } catch (...) {
+        execution->state = CSE_EXECUTION_ERROR;
+        execution->error_code = CSE_ERRC_UNSPECIFIED;
+        handle_current_exception();
+        return failure;
+    }
+}

src/cpp/cse/slave_simulator.hpp

@@ -71,6 +71,11 @@ class slave_simulator : public simulator
         variable_index index,
         std::function<std::string(std::string_view)> modifier) override;
 
+    std::unordered_set<variable_index> get_modified_real_indexes() override;
+    std::unordered_set<variable_index> get_modified_integer_indexes() override;
+    std::unordered_set<variable_index> get_modified_boolean_indexes() override;
+    std::unordered_set<variable_index> get_modified_string_indexes() override;
+
     boost::fibers::future<void> setup(
         time_point startTime,
         std::optional<time_point> stopTime,

src/cpp/execution.cpp

@@ -3,10 +3,10 @@
 #include "cse/algorithm.hpp"
 #include "cse/slave_simulator.hpp"
 #include "cse/timer.hpp"
-#include <cse/exception.hpp>
 
 #include <boost/functional/hash.hpp>
 
+#include <cse/exception.hpp>
 #include <sstream>
 #include <unordered_map>
 #include <utility>
@@ -195,6 +195,44 @@ class execution::impl
         return timer_.get_real_time_factor_target();
     }
 
+    std::vector<variable_id> get_modified_variables()
+    {
+        std::vector<variable_id> modifiedVariables;
+
+        auto index = 0;
+        for (const auto& sim : simulators_) {
+
+            const auto& realIndexes = sim->get_modified_real_indexes();
+            const auto& intIndexes = sim->get_modified_integer_indexes();
+            const auto& boolIndexes = sim->get_modified_boolean_indexes();
+            const auto& stringIndexes = sim->get_modified_string_indexes();
+
+            for (const auto& varIndex : realIndexes) {
+                variable_id var = {index, variable_type::real, varIndex};
+                modifiedVariables.push_back(var);
+            }
+
+            for (const auto& varIndex : intIndexes) {
+                variable_id var = {index, variable_type::integer, varIndex};
+                modifiedVariables.push_back(var);
+            }
+
+            for (const auto& varIndex : boolIndexes) {
+                variable_id var = {index, variable_type::boolean, varIndex};
+                modifiedVariables.push_back(var);
+            }
+
+            for (const auto& varIndex : stringIndexes) {
+                variable_id var = {index, variable_type::string, varIndex};
+                modifiedVariables.push_back(var);
+            }
+
+            index++;
+        }
+
+        return modifiedVariables;
+    }
+
     void set_real_initial_value(simulator_index sim, variable_index var, double value)
     {
         if (initialized_) {
@@ -359,6 +397,11 @@ double execution::get_real_time_factor_target() {
     return pimpl_->get_real_time_factor_target();
 }
 
+std::vector<variable_id> execution::get_modified_variables()
+{
+    return pimpl_->get_modified_variables();
+}
+
 void execution::set_real_initial_value(simulator_index sim, variable_index var, double value)
 {
     pimpl_->set_real_initial_value(sim, var, value);