Merge pull request #578 from PowerGridModel/feature/container-improvements

Feature/container + main core improvements

Author: Jerry-Jinfeng-Guo

power_grid_model_c/power_grid_model/include/power_grid_model/calculation_parameters.hpp

@@ -35,13 +35,6 @@ template <symmetry_tag sym_type> struct BranchCalcParam {
     ComplexTensor<sym> const& ytt() const { return value[3]; }
 };
 
-struct TransformerTapRegulatorCalcParam {
-    double u_set{};
-    double u_band{};
-    DoubleComplex z_compensation{};
-    IntS status{};
-};
-
 template <symmetry_tag sym_type> struct BranchMathOutput {
     using sym = sym_type;
 
@@ -117,15 +110,28 @@ template <symmetry_tag sym_type> struct PowerSensorCalcParam {
 
 template <typename T>
 concept sensor_calc_param_type =
-    std::same_as<T, VoltageSensorCalcParam<symmetric_t>> || std::same_as<T, VoltageSensorCalcParam<asymmetric_t>> ||
-    std::same_as<T, PowerSensorCalcParam<symmetric_t>> || std::same_as<T, PowerSensorCalcParam<asymmetric_t>>;
+    std::derived_from<T, VoltageSensorCalcParam<symmetric_t>> ||
+    std::derived_from<T, VoltageSensorCalcParam<asymmetric_t>> ||
+    std::derived_from<T, PowerSensorCalcParam<symmetric_t>> || std::derived_from<T, PowerSensorCalcParam<asymmetric_t>>;
 
 static_assert(sensor_calc_param_type<VoltageSensorCalcParam<symmetric_t>>);
 static_assert(sensor_calc_param_type<VoltageSensorCalcParam<asymmetric_t>>);
 static_assert(sensor_calc_param_type<PowerSensorCalcParam<symmetric_t>>);
 static_assert(sensor_calc_param_type<PowerSensorCalcParam<asymmetric_t>>);
 
-// from, to side
+struct TransformerTapRegulatorCalcParam {
+    double u_set{};
+    double u_band{};
+    DoubleComplex z_compensation{};
+    IntS status{};
+};
+template <symmetry_tag sym_type> struct TransformerTapRegulatorMathOutput {
+    using sym = sym_type;
+
+    IntS tap_pos{na_IntS};
+};
+
+// from side, to side
 // in case of indices for math model, -1 means the branch is not connected to that side
 using BranchIdx = std::array<Idx, 2>;
 // node 0, 1, 2 side
@@ -221,7 +227,7 @@ struct ShortCircuitInput {
 
 template <typename T>
 concept symmetric_calculation_input_type =
-    std::same_as<T, PowerFlowInput<symmetric_t>> || std::same_as<T, StateEstimationInput<symmetric_t>>;
+    std::derived_from<T, PowerFlowInput<symmetric_t>> || std::derived_from<T, StateEstimationInput<symmetric_t>>;
 
 static_assert(symmetric_calculation_input_type<PowerFlowInput<symmetric_t>>);
 static_assert(symmetric_calculation_input_type<StateEstimationInput<symmetric_t>>);
@@ -231,8 +237,8 @@ static_assert(!symmetric_calculation_input_type<ShortCircuitInput>);
 
 template <typename T>
 concept asymmetric_calculation_input_type =
-    std::same_as<T, PowerFlowInput<asymmetric_t>> || std::same_as<T, StateEstimationInput<asymmetric_t>> ||
-    std::same_as<T, ShortCircuitInput>;
+    std::derived_from<T, PowerFlowInput<asymmetric_t>> || std::derived_from<T, StateEstimationInput<asymmetric_t>> ||
+    std::derived_from<T, ShortCircuitInput>;
 
 static_assert(!asymmetric_calculation_input_type<PowerFlowInput<symmetric_t>>);
 static_assert(!asymmetric_calculation_input_type<StateEstimationInput<symmetric_t>>);
@@ -249,7 +255,10 @@ static_assert(calculation_input_type<PowerFlowInput<asymmetric_t>>);
 static_assert(calculation_input_type<StateEstimationInput<asymmetric_t>>);
 static_assert(calculation_input_type<ShortCircuitInput>);
 
+struct math_output_t {};
+
 template <symmetry_tag sym_type> struct MathOutput {
+    using type = math_output_t;
     using sym = sym_type;
 
     std::vector<ComplexValue<sym>> u;
@@ -258,9 +267,11 @@ template <symmetry_tag sym_type> struct MathOutput {
     std::vector<ApplianceMathOutput<sym>> source;
     std::vector<ApplianceMathOutput<sym>> shunt;
     std::vector<ApplianceMathOutput<sym>> load_gen;
+    std::vector<TransformerTapRegulatorMathOutput<sym>> transformer_tap_regulator;
 };
 
 template <symmetry_tag sym_type> struct ShortCircuitMathOutput {
+    using type = math_output_t;
     using sym = sym_type;
 
     std::vector<ComplexValue<sym>> u_bus;
@@ -271,26 +282,31 @@ template <symmetry_tag sym_type> struct ShortCircuitMathOutput {
 };
 
 template <typename T>
-concept symmetric_math_output_type =
-    std::same_as<T, MathOutput<symmetric_t>> || std::same_as<T, ShortCircuitMathOutput<symmetric_t>>;
+concept math_output_type = std::derived_from<typename T::type, math_output_t>;
+
+static_assert(math_output_type<MathOutput<symmetric_t>>);
+static_assert(math_output_type<MathOutput<asymmetric_t>>);
+static_assert(math_output_type<ShortCircuitMathOutput<symmetric_t>>);
+static_assert(math_output_type<ShortCircuitMathOutput<asymmetric_t>>);
+
+template <typename T>
+concept symmetric_math_output_type = math_output_type<T> && is_symmetric_v<typename T::sym>;
 
 static_assert(symmetric_math_output_type<MathOutput<symmetric_t>>);
 static_assert(!symmetric_math_output_type<MathOutput<asymmetric_t>>);
 static_assert(symmetric_math_output_type<ShortCircuitMathOutput<symmetric_t>>);
 static_assert(!symmetric_math_output_type<ShortCircuitMathOutput<asymmetric_t>>);
 
 template <typename T>
-concept asymmetric_math_output_type =
-    std::same_as<T, MathOutput<asymmetric_t>> || std::same_as<T, ShortCircuitMathOutput<asymmetric_t>>;
+concept asymmetric_math_output_type = math_output_type<T> && is_asymmetric_v<typename T::sym>;
 
 static_assert(!asymmetric_math_output_type<MathOutput<symmetric_t>>);
 static_assert(asymmetric_math_output_type<MathOutput<asymmetric_t>>);
 static_assert(!asymmetric_math_output_type<ShortCircuitMathOutput<symmetric_t>>);
 static_assert(asymmetric_math_output_type<ShortCircuitMathOutput<asymmetric_t>>);
 
 template <typename T>
-concept steady_state_math_output_type =
-    std::same_as<T, MathOutput<symmetric_t>> || std::same_as<T, MathOutput<asymmetric_t>>;
+concept steady_state_math_output_type = math_output_type<T> && std::derived_from<T, MathOutput<typename T::sym>>;
 
 static_assert(steady_state_math_output_type<MathOutput<symmetric_t>>);
 static_assert(steady_state_math_output_type<MathOutput<asymmetric_t>>);
@@ -299,22 +315,13 @@ static_assert(!steady_state_math_output_type<ShortCircuitMathOutput<asymmetric_t
 
 template <typename T>
 concept short_circuit_math_output_type =
-    std::same_as<T, ShortCircuitMathOutput<symmetric_t>> || std::same_as<T, ShortCircuitMathOutput<asymmetric_t>>;
+    math_output_type<T> && std::derived_from<T, ShortCircuitMathOutput<typename T::sym>>;
 
 static_assert(!short_circuit_math_output_type<MathOutput<symmetric_t>>);
 static_assert(!short_circuit_math_output_type<MathOutput<asymmetric_t>>);
 static_assert(short_circuit_math_output_type<ShortCircuitMathOutput<symmetric_t>>);
 static_assert(short_circuit_math_output_type<ShortCircuitMathOutput<asymmetric_t>>);
 
-template <typename T>
-concept math_output_type = (symmetric_math_output_type<T> || asymmetric_math_output_type<T>) &&
-                           (steady_state_math_output_type<T> || short_circuit_math_output_type<T>);
-
-static_assert(math_output_type<MathOutput<symmetric_t>>);
-static_assert(math_output_type<MathOutput<asymmetric_t>>);
-static_assert(math_output_type<ShortCircuitMathOutput<symmetric_t>>);
-static_assert(math_output_type<ShortCircuitMathOutput<asymmetric_t>>);
-
 // component indices at physical model side
 // from, to node indices for branches
 // node1, node2, node3 indices for 3-way branches
@@ -328,12 +335,13 @@ struct ComponentTopology {
     IdxVector load_gen_node_idx;
     std::vector<LoadGenType> load_gen_type;
     IdxVector voltage_sensor_node_idx;
-    IdxVector power_sensor_object_idx; // the index is relative to branch, source, shunt, or load_gen
+    IdxVector power_sensor_object_idx; // the index is relative to branch, source, shunt or load_gen
     std::vector<MeasuredTerminalType> power_sensor_terminal_type;
-    IdxVector regulated_object_idx; // the index is relative to branch
+    std::vector<ComponentType> regulator_type;
+    IdxVector regulated_object_idx; // the index is relative to branch or branch3
     std::vector<ComponentType> regulated_object_type;
 
-    inline Idx n_node_total() const { return n_node + static_cast<Idx>(branch3_node_idx.size()); }
+    Idx n_node_total() const { return n_node + static_cast<Idx>(branch3_node_idx.size()); }
 };
 
 // connection property
@@ -392,14 +400,4 @@ struct TopologicalComponentToMathCoupling {
     std::vector<Idx2D> regulator;
 };
 
-// change of update cause topology and param change, or just param change
-struct UpdateChange {
-    bool topo{};
-    bool param{};
-
-    friend constexpr UpdateChange operator||(UpdateChange const& x, UpdateChange const& y) {
-        return UpdateChange{x.topo || y.topo, x.param || y.param};
-    }
-};
-
 } // namespace power_grid_model

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

@@ -37,6 +37,7 @@ template <typename T>
 concept symmetry_tag = std::derived_from<T, symmetric_t> || std::derived_from<T, asymmetric_t>;
 
 template <symmetry_tag T> constexpr bool is_symmetric_v = std::derived_from<T, symmetric_t>;
+template <symmetry_tag T> constexpr bool is_asymmetric_v = std::derived_from<T, asymmetric_t>;
 
 template <symmetry_tag T> using other_symmetry_t = std::conditional_t<is_symmetric_v<T>, asymmetric_t, symmetric_t>;
 

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

@@ -58,7 +58,8 @@ enum class ComponentType : IntS {
     branch3 = 9,
     fault = 10,
     regulator = 11,
-    transformer_tap_regulator = 12
+    transformer_tap_regulator = 12,
+    test = -128 // any stub or mock may use this. do not use this in production
 };
 
 // DO NOT change the order of enumerations

power_grid_model_c/power_grid_model/include/power_grid_model/component/base.hpp

@@ -4,6 +4,8 @@
 
 #pragma once
 
+#include "component.hpp"
+
 #include "../auxiliary/input.hpp"
 #include "../auxiliary/output.hpp"
 #include "../auxiliary/update.hpp"

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

@@ -0,0 +1,39 @@
+// SPDX-FileCopyrightText: Contributors to the Power Grid Model project <[email protected]>
+//
+// SPDX-License-Identifier: MPL-2.0
+
+#pragma once
+
+#include "../common/common.hpp"
+#include "../common/enum.hpp"
+
+#include <concepts>
+#include <string_view>
+
+namespace power_grid_model {
+
+// change of update cause topology and param change, or just param change
+struct UpdateChange {
+    bool topo{};
+    bool param{};
+
+    friend constexpr UpdateChange operator||(UpdateChange const& x, UpdateChange const& y) {
+        return UpdateChange{x.topo || y.topo, x.param || y.param};
+    }
+};
+
+template <typename T>
+concept component_c = requires(T t, T const& ct, typename T::UpdateType u, typename T::UpdateType const& cu) {
+                          typename T::InputType;
+                          typename T::UpdateType;
+
+                          { T::name } -> std::convertible_to<std::string_view>;
+                          { ct.math_model_type() } -> std::convertible_to<ComponentType>;
+
+                          { ct.id() } -> std::same_as<ID>;
+
+                          { t.update(cu) } -> std::same_as<UpdateChange>;
+                          { ct.inverse(u) } -> std::same_as<typename T::UpdateType>;
+                      };
+
+} // namespace power_grid_model

power_grid_model_c/power_grid_model/include/power_grid_model/component/transformer_utils.hpp

@@ -15,25 +15,16 @@ concept enum_c = std::is_enum_v<T>;
 } // namespace detail
 
 template <typename T>
-concept transformer_c = requires(T const& t, typename T::UpdateType u, typename T::SideType s) {
-                            typename T::UpdateType;
-                            typename T::SideType;
-
-                            { T::name } -> std::convertible_to<std::string_view>;
-                            { t.math_model_type() } -> std::convertible_to<ComponentType>;
-
-                            { t.id() } -> std::same_as<ID>;
-                            { t.node(s) } -> std::same_as<ID>;
-                            { t.status(s) } -> std::convertible_to<bool>;
-
-                            { t.tap_side() } -> std::same_as<typename T::SideType>;
-                            { t.tap_pos() } -> std::convertible_to<IntS>;
-                            { t.tap_min() } -> std::convertible_to<IntS>;
-                            { t.tap_max() } -> std::convertible_to<IntS>;
-                            { t.tap_nom() } -> std::convertible_to<IntS>;
-
-                            { t.inverse(u) } -> std::same_as<typename T::UpdateType>;
-                        };
+concept transformer_c = component_c<T> && requires(T const& t, typename T::UpdateType u, typename T::SideType s) {
+                                              { t.node(s) } -> std::same_as<ID>;
+                                              { t.status(s) } -> std::convertible_to<bool>;
+
+                                              { t.tap_side() } -> std::same_as<typename T::SideType>;
+                                              { t.tap_pos() } -> std::convertible_to<IntS>;
+                                              { t.tap_min() } -> std::convertible_to<IntS>;
+                                              { t.tap_max() } -> std::convertible_to<IntS>;
+                                              { t.tap_nom() } -> std::convertible_to<IntS>;
+                                          };
 
 constexpr double tap_adjust_impedance(double tap_pos, double tap_min, double tap_max, double tap_nom, double xk,
                                       double xk_min, double xk_max) {