Merge branch 'main' into feature/links-part-3

Author: figueroa1395

code_generation/data/attribute_classes/update.json

@@ -87,6 +87,11 @@
           "data_type": "double",
           "names": ["u_ref", "u_ref_angle"],
           "description": "reference voltage"
+        },
+        {
+          "data_type": "double",
+          "names": ["sk", "rx_ratio", "z01_ratio"],
+          "description": "short circuit capacity"
         }
       ]
     },

docs/user_manual/components.md

@@ -614,9 +614,9 @@ The impedance is specified by convention as short circuit power.
 |---------------|-----------|------------------|----------------------------------------------------|:----------------------------:|:--------:|:------------:|
 | `u_ref`       | `double`  | -                | reference voltage in per-unit                      | ✨ only for power flow | ✔ |    `> 0`     |
 | `u_ref_angle` | `double`  | rad              | reference voltage angle                            |    ❌ default `0.0`    | ✔ |              |
-| `sk`          | `double`  | volt-ampere (VA) | short circuit power                                |   ❌ default `1e10`    | ❌ |    `> 0`     |
-| `rx_ratio`    | `double`  | -                | R to X ratio                                       |    ❌ default `0.1`    | ❌ |    `>= 0`    |
-| `z01_ratio`   | `double`  | -                | zero-sequence to positive sequence impedance ratio |    ❌ default `1.0`    | ❌ |    `> 0`     |
+| `sk`          | `double`  | volt-ampere (VA) | short circuit power                                |   ❌ default `1e10`    | ✔ |    `> 0`     |
+| `rx_ratio`    | `double`  | -                | R to X ratio                                       |    ❌ default `0.1`    | ✔ |    `>= 0`    |
+| `z01_ratio`   | `double`  | -                | zero-sequence to positive sequence impedance ratio |    ❌ default `1.0`    | ✔ |    `> 0`     |
 
 #### Electric Model
 

power_grid_model_c/power_grid_model/include/power_grid_model/auxiliary/dataset.hpp

@@ -10,18 +10,22 @@
 #include "meta_data.hpp"
 
 #include "../common/common.hpp"
+#include "../common/counting_iterator.hpp"
 #include "../common/exception.hpp"
 #include "../common/iterator_facade.hpp"
+#include "../common/typing.hpp"
 
 #include <algorithm>
 #include <cassert>
 #include <concepts>
 #include <cstddef>
+#include <iterator>
 #include <ranges>
 #include <span>
 #include <string>
 #include <string_view>
 #include <type_traits>
+#include <utility>
 #include <vector>
 
 namespace power_grid_model {
@@ -216,6 +220,8 @@ template <dataset_type_tag dataset_type_> class Dataset {
         std::span<Indptr> indptr{};
     };
 
+    template <class StructType> using SpanRange = std::span<StructType>;
+
     template <class StructType>
     using RangeObject = std::conditional_t<is_data_mutable_v<dataset_type>, mutable_range_object<StructType>,
                                            const_range_object<StructType>>;
@@ -452,7 +458,7 @@ template <dataset_type_tag dataset_type_> class Dataset {
     // get buffer by component type
     template <class type_getter, class ComponentType,
               class StructType = DataStruct<typename type_getter::template type<ComponentType>>>
-    std::span<StructType> get_buffer_span(Idx scenario = invalid_index) const {
+    SpanRange<StructType> get_buffer_span(Idx scenario = invalid_index) const {
         assert(scenario < batch_size());
 
         if (!is_batch() && scenario > 0) {
@@ -476,27 +482,17 @@ template <dataset_type_tag dataset_type_> class Dataset {
         return get_columnar_buffer_span_impl<StructType>(scenario, idx);
     }
 
-    // get buffer by component type for all scenarios in vector span
+    // get buffer by component type for all non-empty scenarios in vector span
     template <class type_getter, class ComponentType,
               class StructType = DataStruct<typename type_getter::template type<ComponentType>>>
-    std::vector<std::span<StructType>> get_buffer_span_all_scenarios() const {
-        Idx const idx = find_component(ComponentType::name, false);
-        std::vector<std::span<StructType>> result(batch_size());
-        for (Idx scenario{}; scenario != batch_size(); scenario++) {
-            result[scenario] = get_buffer_span_impl<StructType>(scenario, idx);
-        }
-        return result;
+    std::vector<SpanRange<StructType>> get_buffer_span_all_scenarios() const {
+        return get_buffer_span_all_scenarios_impl<type_getter, ComponentType, SpanRange>();
     }
 
     template <class type_getter, class ComponentType,
               class StructType = DataStruct<typename type_getter::template type<ComponentType>>>
     std::vector<RangeObject<StructType>> get_columnar_buffer_span_all_scenarios() const {
-        Idx const idx = find_component(ComponentType::name, false);
-        std::vector<RangeObject<StructType>> result(batch_size());
-        for (Idx scenario{}; scenario != batch_size(); scenario++) {
-            result[scenario] = get_columnar_buffer_span_impl<StructType>(scenario, idx);
-        }
-        return result;
+        return get_buffer_span_all_scenarios_impl<type_getter, ComponentType, RangeObject>();
     }
 
     // get individual dataset from batch
@@ -559,7 +555,7 @@ template <dataset_type_tag dataset_type_> class Dataset {
 
     template <class type_getter, class ComponentType, typename Func,
               class StructType = DataStruct<typename type_getter::template type<ComponentType>>>
-        requires std::invocable<Func, std::span<StructType>> && std::invocable<Func, RangeObject<StructType>>
+        requires std::invocable<Func, SpanRange<StructType>> && std::invocable<Func, RangeObject<StructType>>
     auto for_each_component(Func&& func, Idx scenario = invalid_index) const {
         if (is_columnar(ComponentType::name)) {
             return std::forward<Func>(func)(get_columnar_buffer_span<type_getter, ComponentType, StructType>(scenario));
@@ -659,31 +655,53 @@ template <dataset_type_tag dataset_type_> class Dataset {
                          std::begin(total_range) + info.elements_per_scenario * (scenario + 1)};
     }
 
-    // get non-empty row buffer
-    template <class StructType> std::span<StructType> get_buffer_span_impl(Idx scenario, Idx component_idx) const {
+    template <typename StructType, template <typename> typename RangeType>
+        requires std::ranges::view<RangeType<StructType>> &&
+                 (std::same_as<RangeType<StructType>, SpanRange<StructType>> ||
+                  std::same_as<RangeType<StructType>, RangeObject<StructType>>)
+    auto get_buffer_view_impl(Idx scenario, Idx component_idx) const {
+        using RangeType_ = RangeType<StructType>;
+
         // return empty span if the component does not exist
         if (component_idx < 0) {
-            return {};
+            return RangeType_{};
         }
         // return span based on uniform or non-uniform buffer
         ComponentInfo const& info = dataset_info_.component_info[component_idx];
         Buffer const& buffer = buffers_[component_idx];
-        auto const ptr = reinterpret_cast<StructType*>(buffer.data);
-        return get_span_impl(std::span<StructType>{ptr, ptr + info.total_elements}, scenario, buffer, info);
+
+        if constexpr (std::same_as<RangeType_, SpanRange<StructType>>) {
+            assert(is_row_based(buffer) || info.total_elements == 0);
+            auto const ptr = reinterpret_cast<StructType*>(buffer.data);
+            return get_span_impl(RangeType_{ptr, ptr + info.total_elements}, scenario, buffer, info);
+        } else if constexpr (std::same_as<RangeType_, RangeObject<StructType>>) {
+            assert(is_columnar(buffer));
+            return get_span_impl(RangeType_{info.total_elements, buffer.attributes}, scenario, buffer, info);
+        } else {
+            static_assert(false, "only span and RangeObject are supported");
+        }
+    }
+
+    // get non-empty row buffer
+    template <class StructType> SpanRange<StructType> get_buffer_span_impl(Idx scenario, Idx component_idx) const {
+        return get_buffer_view_impl<StructType, SpanRange>(scenario, component_idx);
     }
 
     // get non-empty columnar buffer
     template <class StructType>
     RangeObject<StructType> get_columnar_buffer_span_impl(Idx scenario, Idx component_idx) const {
-        // return empty span if the component does not exist
-        if (component_idx < 0) {
-            return {};
-        }
-        // return span based on uniform or non-uniform buffer
-        ComponentInfo const& info = dataset_info_.component_info[component_idx];
-        Buffer const& buffer = buffers_[component_idx];
-        assert(is_columnar(buffer));
-        return get_span_impl(RangeObject<StructType>{info.total_elements, buffer.attributes}, scenario, buffer, info);
+        return get_buffer_view_impl<StructType, RangeObject>(scenario, component_idx);
+    }
+
+    template <class type_getter, class ComponentType, template <typename> typename RangeType,
+              typename StructType = DataStruct<typename type_getter::template type<ComponentType>>>
+        requires std::ranges::view<RangeType<StructType>>
+    std::vector<RangeType<StructType>> get_buffer_span_all_scenarios_impl() const {
+        Idx const component_idx = find_component(ComponentType::name, false);
+        return IdxRange{batch_size()} | std::views::transform([this, component_idx](Idx scenario) {
+                   return get_buffer_view_impl<StructType, RangeType>(scenario, component_idx);
+               }) |
+               std::ranges::to<std::vector>();
     }
 };
 

power_grid_model_c/power_grid_model/include/power_grid_model/auxiliary/meta_gen/update.hpp

@@ -105,13 +105,16 @@ struct get_attributes_list<LoadGenUpdate<sym_type>> {
 
 template<>
 struct get_attributes_list<SourceUpdate> {
-    static constexpr std::array<MetaAttribute, 4> value{
+    static constexpr std::array<MetaAttribute, 7> value{
             // all attributes including base class
 
             meta_data_gen::get_meta_attribute<&SourceUpdate::id>(offsetof(SourceUpdate, id), "id"),
             meta_data_gen::get_meta_attribute<&SourceUpdate::status>(offsetof(SourceUpdate, status), "status"),
             meta_data_gen::get_meta_attribute<&SourceUpdate::u_ref>(offsetof(SourceUpdate, u_ref), "u_ref"),
             meta_data_gen::get_meta_attribute<&SourceUpdate::u_ref_angle>(offsetof(SourceUpdate, u_ref_angle), "u_ref_angle"),
+            meta_data_gen::get_meta_attribute<&SourceUpdate::sk>(offsetof(SourceUpdate, sk), "sk"),
+            meta_data_gen::get_meta_attribute<&SourceUpdate::rx_ratio>(offsetof(SourceUpdate, rx_ratio), "rx_ratio"),
+            meta_data_gen::get_meta_attribute<&SourceUpdate::z01_ratio>(offsetof(SourceUpdate, z01_ratio), "z01_ratio"),
     };
 };
 

power_grid_model_c/power_grid_model/include/power_grid_model/auxiliary/update.hpp

@@ -104,6 +104,9 @@ struct SourceUpdate {
     IntS status{na_IntS};  // whether the appliance is connected
     double u_ref{nan};  // reference voltage
     double u_ref_angle{nan};  // reference voltage
+    double sk{nan};  // short circuit capacity
+    double rx_ratio{nan};  // short circuit capacity
+    double z01_ratio{nan};  // short circuit capacity
 
     // implicit conversions to BaseUpdate
     operator BaseUpdate&() { return reinterpret_cast<BaseUpdate&>(*this); }

power_grid_model_c/power_grid_model/include/power_grid_model/component/source.hpp

@@ -32,31 +32,22 @@ class Source : public Appliance {
     explicit Source(SourceInput const& source_input, double u)
         : Appliance{source_input, u},
           u_ref_{source_input.u_ref},
-          u_ref_angle_{is_nan(source_input.u_ref_angle) ? 0.0 : source_input.u_ref_angle} {
-        double const sk{is_nan(source_input.sk) ? default_source_sk : source_input.sk};
-        double const rx_ratio{is_nan(source_input.rx_ratio) ? default_source_rx_ratio : source_input.rx_ratio};
-        double const z01_ratio{is_nan(source_input.z01_ratio) ? default_source_z01_ratio : source_input.z01_ratio};
-        calculate_y_ref(sk, rx_ratio, z01_ratio);
-    }
-
-    // calculate y1 y0 ref
-    void calculate_y_ref(double sk, double rx_ratio, double z01_ratio) {
-        double const z_abs = base_power_3p / sk; // s_pu = s/base_s, z = u^2/s = 1/s = base_s/s_pu
-        double const x1 = z_abs / sqrt(rx_ratio * rx_ratio + 1.0);
-        double const r1 = x1 * rx_ratio;
-        y1_ref_ = 1.0 / DoubleComplex{r1, x1};
-        y0_ref_ = y1_ref_ / z01_ratio;
-    }
+          u_ref_angle_{is_nan(source_input.u_ref_angle) ? 0.0 : source_input.u_ref_angle},
+          sk_{is_nan(source_input.sk) ? default_source_sk : source_input.sk},
+          rx_ratio_{is_nan(source_input.rx_ratio) ? default_source_rx_ratio : source_input.rx_ratio},
+          z01_ratio_{is_nan(source_input.z01_ratio) ? default_source_z01_ratio : source_input.z01_ratio} {}
 
     template <symmetry_tag sym> SourceCalcParam math_param() const {
-        // internal element_admittance
-        SourceCalcParam param;
-        param.y0 = y0_ref_;
-        param.y1 = y1_ref_;
-        return param;
+        // calculate y1 y0 ref
+        double const z_abs = base_power_3p / sk_;
+        double const x1 = z_abs / sqrt(rx_ratio_ * rx_ratio_ + 1.0);
+        double const r1 = x1 * rx_ratio_;
+        DoubleComplex const y1_ref = 1.0 / DoubleComplex{r1, x1};
+        DoubleComplex const y0_ref = y1_ref / z01_ratio_;
+        return SourceCalcParam{.y1 = y1_ref, .y0 = y0_ref};
     }
 
-    // setter
+    // setter for u_ref
     bool set_u_ref(double new_u_ref, double new_u_ref_angle) {
         bool changed = false;
         if (!is_nan(new_u_ref)) {
@@ -96,10 +87,13 @@ class Source : public Appliance {
     UpdateChange update(SourceUpdate const& update_data) {
         assert(update_data.id == this->id() || is_nan(update_data.id));
         bool const topo_changed = set_status(update_data.status);
-        bool const param_changed = set_u_ref(update_data.u_ref, update_data.u_ref_angle);
+        set_u_ref(update_data.u_ref, update_data.u_ref_angle);
+        bool const param_changed_impedance =
+            set_sk_rx_ratio_z01_ratio(update_data.sk, update_data.rx_ratio, update_data.z01_ratio);
         // change source connection will change both topo and param
-        // change u ref will change param
-        return {.topo = topo_changed, .param = param_changed || topo_changed};
+        // change u ref will NOT change param
+        // change sk/rx_ratio/z01_ratio will change param
+        return {.topo = topo_changed, .param = param_changed_impedance || topo_changed};
     }
 
     SourceUpdate inverse(SourceUpdate update_data) const {
@@ -108,6 +102,9 @@ class Source : public Appliance {
         set_if_not_nan(update_data.status, status_to_int(this->status()));
         set_if_not_nan(update_data.u_ref, u_ref_);
         set_if_not_nan(update_data.u_ref_angle, u_ref_angle_);
+        set_if_not_nan(update_data.sk, sk_);
+        set_if_not_nan(update_data.rx_ratio, rx_ratio_);
+        set_if_not_nan(update_data.z01_ratio, z01_ratio_);
 
         return update_data;
     }
@@ -117,9 +114,27 @@ class Source : public Appliance {
   private:
     double u_ref_;
     double u_ref_angle_;
-    // positive and zero sequence ref
-    DoubleComplex y1_ref_;
-    DoubleComplex y0_ref_;
+    // source short circuit power
+    double sk_;
+    double rx_ratio_;
+    double z01_ratio_;
+
+    bool set_sk_rx_ratio_z01_ratio(double new_sk, double new_rx_ratio, double new_z01_ratio) {
+        bool changed = false;
+        if (!is_nan(new_sk)) {
+            sk_ = new_sk;
+            changed = true;
+        }
+        if (!is_nan(new_rx_ratio)) {
+            rx_ratio_ = new_rx_ratio;
+            changed = true;
+        }
+        if (!is_nan(new_z01_ratio)) {
+            z01_ratio_ = new_z01_ratio;
+            changed = true;
+        }
+        return changed;
+    }
 
     double injection_direction() const final { return 1.0; }
 };