Feature / columnar data optional id field support in update data

power_grid_model_c/power_grid_model/include/power_grid_model/common/common.hpp

@@ -66,6 +66,7 @@ constexpr double numerical_tolerance = 1e-8;
 constexpr double nan = std::numeric_limits<double>::quiet_NaN();
 constexpr IntS na_IntS = std::numeric_limits<IntS>::min();
 constexpr ID na_IntID = std::numeric_limits<ID>::min();
+constexpr Idx na_Idx = std::numeric_limits<Idx>::min();
 
 // power grid constant
 constexpr double base_power_3p = 1e6;

power_grid_model_c/power_grid_model/include/power_grid_model/component/load_gen.hpp

@@ -102,7 +102,6 @@ class LoadGen final : public std::conditional_t<is_generator_v<appliance_type_>,
 
     // update for load_gen
     UpdateChange update(LoadGenUpdate<loadgen_symmetry> const& update_data) {
-        assert(update_data.id == this->id());
         this->set_status(update_data.status);
         set_power(update_data.p_specified, update_data.q_specified);
         // change load connection and/or value will not change topology or parameters
@@ -112,8 +111,6 @@ class LoadGen final : public std::conditional_t<is_generator_v<appliance_type_>,
     LoadGenUpdate<loadgen_symmetry> inverse(LoadGenUpdate<loadgen_symmetry> update_data) const {
         double const scalar = direction_ * base_power<loadgen_symmetry>;
 
-        assert(update_data.id == this->id());
-
         set_if_not_nan(update_data.status, static_cast<IntS>(this->status()));
         set_if_not_nan(update_data.p_specified, real(s_specified_) * scalar);
         set_if_not_nan(update_data.q_specified, imag(s_specified_) * scalar);

power_grid_model_c/power_grid_model/include/power_grid_model/component/power_sensor.hpp

@@ -99,8 +99,6 @@ template <symmetry_tag power_sensor_symmetry_> class PowerSensor : public Generi
     }
 
     PowerSensorUpdate<power_sensor_symmetry> inverse(PowerSensorUpdate<power_sensor_symmetry> update_data) const {
-        assert(update_data.id == this->id());
-
         auto const scalar = convert_direction() * base_power<power_sensor_symmetry>;
 
         set_if_not_nan(update_data.p_measured, real(s_measured_) * scalar);

power_grid_model_c/power_grid_model/include/power_grid_model/component/voltage_sensor.hpp

@@ -80,8 +80,6 @@ template <symmetry_tag sym> class VoltageSensor : public GenericVoltageSensor {
           u_angle_measured_{voltage_sensor_input.u_angle_measured} {};
 
     UpdateChange update(VoltageSensorUpdate<sym> const& update_data) {
-        assert(update_data.id == this->id());
-
         double const scalar = 1 / (u_rated_ * u_scale<sym>);
 
         update_real_value<sym>(update_data.u_measured, u_measured_, scalar);
@@ -95,8 +93,6 @@ template <symmetry_tag sym> class VoltageSensor : public GenericVoltageSensor {
     }
 
     VoltageSensorUpdate<sym> inverse(VoltageSensorUpdate<sym> update_data) const {
-        assert(update_data.id == this->id());
-
         double const scalar = u_rated_ * u_scale<sym>;
 
         set_if_not_nan(update_data.u_measured, u_measured_ * scalar);

power_grid_model_c/power_grid_model/include/power_grid_model/container.hpp

@@ -125,6 +125,10 @@ class Container<RetrievableTypes<GettableTypes...>, StorageableTypes...> {
         }
         return result;
     }
+    template <supported_type_c<StorageableTypes...> Storageable> Idx get_group_idx() const {
+        return static_cast<Idx>(get_cls_pos_v<Storageable, StorageableTypes...>);
+    }
+
     // get item based on ID
     template <supported_type_c<GettableTypes...> Gettable> Gettable& get_item(ID id) {
         Idx2D const idx = get_idx_by_id<Gettable>(id);

power_grid_model_c/power_grid_model/include/power_grid_model/main_core/state_queries.hpp

@@ -33,6 +33,12 @@ inline Idx2D get_component_idx_by_id(MainModelState<ComponentContainer> const& s
     return state.components.template get_idx_by_id<ComponentType>(id);
 }
 
+template <typename ComponentType, class ComponentContainer>
+    requires model_component_state_c<MainModelState, ComponentContainer, ComponentType>
+inline Idx get_component_group_idx(MainModelState<ComponentContainer> const& state) {
+    return state.components.template get_group_idx<ComponentType>();
+}
+
 template <typename ComponentType, class ComponentContainer>
     requires model_component_state_c<MainModelState, ComponentContainer, ComponentType>
 inline Idx get_component_sequence(MainModelState<ComponentContainer> const& state, auto const& id_or_index) {

power_grid_model_c/power_grid_model/include/power_grid_model/main_core/update.hpp

@@ -33,21 +33,30 @@ template <component_c Component, class ComponentContainer,
           std::output_iterator<Idx2D> OutputIterator>
     requires model_component_state_c<MainModelState, ComponentContainer, Component>
 inline void get_component_sequence(MainModelState<ComponentContainer> const& state, ForwardIterator begin,
-                                   ForwardIterator end, OutputIterator destination) {
+                                   ForwardIterator end, OutputIterator destination, Idx n_comp_elements) {
     using UpdateType = typename Component::UpdateType;
 
+    auto idx_getter_func = [&state, n_comp_elements](UpdateType const& update, auto index) {
+        if (n_comp_elements == na_Idx) {
+            return get_component_idx_by_id<Component>(state, update.id);
+        } else {
+            Idx group = get_component_group_idx<Component>(state);
+            return Idx2D{group, index % n_comp_elements};
+        }
+    };
+
     std::transform(begin, end, destination,
-                   [&state](UpdateType const& update) { return get_component_idx_by_id<Component>(state, update.id); });
+                   [&, index = 0](UpdateType const& update) mutable { return idx_getter_func(update, index++); });
 }
 
 template <component_c Component, class ComponentContainer,
           forward_iterator_like<typename Component::UpdateType> ForwardIterator>
     requires model_component_state_c<MainModelState, ComponentContainer, Component>
 inline std::vector<Idx2D> get_component_sequence(MainModelState<ComponentContainer> const& state, ForwardIterator begin,
-                                                 ForwardIterator end) {
+                                                 ForwardIterator end, Idx n_comp_elements = na_Idx) {
     std::vector<Idx2D> result;
     result.reserve(std::distance(begin, end));
-    get_component_sequence<Component>(state, begin, end, std::back_inserter(result));
+    get_component_sequence<Component>(state, begin, end, std::back_inserter(result), n_comp_elements);
     return result;
 }