power-grid-model 1.12.84__tar.gz → 1.12.91__tar.gz

{power_grid_model-1.12.84 → power_grid_model-1.12.91}/.github/workflows/build-test-release.yml

@@ -48,13 +48,13 @@ jobs:
           uv build --sdist --no-create-gitignore --out-dir wheelhouse .
 
       - name: Keep version file
-        uses: actions/upload-artifact@v5
+        uses: actions/upload-artifact@v6
         with:
           name: version
           path: VERSION
 
       - name: Keep SDist
-        uses: actions/upload-artifact@v5
+        uses: actions/upload-artifact@v6
         with:
           name: wheelhouse
           path: ./wheelhouse/*.tar.gz
@@ -198,7 +198,7 @@ jobs:
     steps:
       - uses: actions/checkout@v6
 
-      - uses: actions/download-artifact@v6
+      - uses: actions/download-artifact@v7
         with:
           name: version
           path: .
@@ -223,7 +223,7 @@ jobs:
           extras: "uv"
 
       - name: Keep wheel files
-        uses: actions/upload-artifact@v5
+        uses: actions/upload-artifact@v6
         with:
           name: wheelhouse-${{ matrix.platform }}
           path: ./wheelhouse/*.whl
@@ -310,9 +310,9 @@ jobs:
 
       - uses: actions/checkout@v6
 
-      - uses: actions/download-artifact@v6
+      - uses: actions/download-artifact@v7
 
-      - uses: actions/download-artifact@v6
+      - uses: actions/download-artifact@v7
         with:
           name: version
           path: .

{power_grid_model-1.12.84 → power_grid_model-1.12.91}/.github/workflows/check-code-quality.yml

@@ -54,7 +54,7 @@ jobs:
 
       - name: Install and run markdownlint
         run: |
-          npm install -g markdownlint-cli@0.46.0
+          npm install -g markdownlint-cli@0.47.0
           echo "Running markdownlint"
           markdownlint --fix .
 
@@ -69,7 +69,7 @@ jobs:
       - name: Check generated code
         if: success()
         run: |
-          uv pip install -r code_generation/requirements.txt
+          uv sync --group code-generation
           uv run code_generation/code_gen.py
           if [ -n "$(git status --porcelain)" ]; then
             echo

{power_grid_model-1.12.84 → power_grid_model-1.12.91}/.github/workflows/refresh-lock-and-linter-dependencies.yml

@@ -85,10 +85,18 @@ jobs:
           source .venv/bin/activate
           pre-commit install
           pre-commit install-hooks
+          pre-commit uninstall
+
+      - name: generate GitHub App token
+        uses: actions/create-github-app-token@v2
+        id: generate-token
+        with:
+          app-id: ${{ secrets.CI_BOT_APP_ID }}
+          private-key: ${{ secrets.CI_BOT_PRIVATE_KEY }}
 
       - name: create pull request
         if: ${{ inputs.create-pr || github.event_name == 'schedule' }}
-        uses: peter-evans/create-pull-request@v7
+        uses: peter-evans/create-pull-request@v8
         with:
           commit-message: "Refresh lock and linter dependencies"
           branch: "dependencies/refresh-lock-and-linter"
@@ -96,5 +104,7 @@ jobs:
           body: "This PR refreshes the lock file and updates linter dependencies to their latest versions."
           labels: "dependencies"
           signoff: true
+          sign-commits: true
           delete-branch: true
           base: ${{ github.head_ref }}
+          token: ${{ steps.generate-token.outputs.token }}

{power_grid_model-1.12.84 → power_grid_model-1.12.91}/.github/workflows/sonar.yml

@@ -47,7 +47,7 @@ jobs:
       - name: Install uv
         uses: astral-sh/setup-uv@v7
       - name: Install build-wrapper
-        uses: SonarSource/sonarqube-scan-action/install-build-wrapper@v6
+        uses: SonarSource/sonarqube-scan-action/install-build-wrapper@v7
         
       - name: Python test and coverage
         run: |
@@ -76,7 +76,7 @@ jobs:
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
-        uses: SonarSource/sonarqube-scan-action@v6
+        uses: SonarSource/sonarqube-scan-action@v7
         with:
           args: >
             --define sonar.cfamily.compile-commands=${{ env.BUILD_WRAPPER_OUT_DIR }}/compile_commands.json

{power_grid_model-1.12.84 → power_grid_model-1.12.91}/.pre-commit-config.yaml

@@ -4,12 +4,12 @@
 
 repos:
   - repo: https://github.com/fsfe/reuse-tool  # outside pypi
-    rev: v4.0.3
+    rev: v6.2.0
     hooks:
       - id: reuse
   - repo: https://github.com/astral-sh/ruff-pre-commit
     # Ruff version.
-    rev: v0.14.7
+    rev: v0.14.9
     hooks:
       # Run the linter.
       - id: ruff-check
@@ -19,7 +19,7 @@ repos:
       - id: ruff-format
         name: ruff-format
   - repo: https://github.com/pre-commit/mirrors-mypy
-    rev: v1.19.0
+    rev: v1.19.1
     hooks:
       - id: mypy
         additional_dependencies:
@@ -38,13 +38,13 @@ repos:
       - id: clang-format
         types_or: [ c++, c ]
   - repo: https://github.com/BlankSpruce/gersemi
-    rev: 0.23.2
+    rev: 0.24.0
     hooks:
     - id: gersemi
       name: cmake-linter
       alias: cmake-linter
   - repo: https://github.com/igorshubovych/markdownlint-cli  # outside pypi 
-    rev: v0.46.0
+    rev: v0.47.0
     hooks:
     - id: markdownlint
       args: ["--fix"]

{power_grid_model-1.12.84 → power_grid_model-1.12.91}/.pre-commit-config.yaml.jinja

@@ -4,7 +4,7 @@
 
 repos:
   - repo: https://github.com/fsfe/reuse-tool  # outside pypi
-    rev: v4.0.3
+    rev: v6.2.0
     hooks:
       - id: reuse
   - repo: https://github.com/astral-sh/ruff-pre-commit
@@ -44,7 +44,7 @@ repos:
       name: cmake-linter
       alias: cmake-linter
   - repo: https://github.com/igorshubovych/markdownlint-cli  # outside pypi 
-    rev: v0.46.0
+    rev: v0.47.0
     hooks:
     - id: markdownlint
       args: ["--fix"]

{power_grid_model-1.12.84 → power_grid_model-1.12.91}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: power-grid-model
-Version: 1.12.84
+Version: 1.12.91
 Summary: Python/C++ library for distribution power system analysis
 Author-Email: Contributors to the Power Grid Model project <powergridmodel@lfenergy.org>
 License-Expression: MPL-2.0

power_grid_model-1.12.91/VERSION

@@ -0,0 +1 @@
+1.12.91

{power_grid_model-1.12.84 → power_grid_model-1.12.91}/code_generation/data/attribute_classes/output.json

@@ -78,6 +78,21 @@
             "base": "BaseOutput",
             "is_template": true,
             "attributes": [
+                {
+                    "data_type": "double",
+                    "names": "loading_1",
+                    "description": "loading of the branch at side 1"
+                },
+                {
+                    "data_type": "double",
+                    "names": "loading_2",
+                    "description": "loading of the branch at side 2"
+                },
+                {
+                    "data_type": "double",
+                    "names": "loading_3",
+                    "description": "loading of the branch at side 3"
+                },
                 {
                     "data_type": "double",
                     "names": "loading",

{power_grid_model-1.12.84 → power_grid_model-1.12.91}/power_grid_model_c/power_grid_model/include/power_grid_model/auxiliary/meta_gen/output.hpp

@@ -73,11 +73,14 @@ template <symmetry_tag sym_type>
 struct get_attributes_list<Branch3Output<sym_type>> {
     using sym = sym_type;
 
-    static constexpr std::array<MetaAttribute, 15> value{
+    static constexpr std::array<MetaAttribute, 18> value{
             // all attributes including base class
             
             meta_data_gen::get_meta_attribute<&Branch3Output<sym>::id>(offsetof(Branch3Output<sym>, id), "id"),
             meta_data_gen::get_meta_attribute<&Branch3Output<sym>::energized>(offsetof(Branch3Output<sym>, energized), "energized"),
+            meta_data_gen::get_meta_attribute<&Branch3Output<sym>::loading_1>(offsetof(Branch3Output<sym>, loading_1), "loading_1"),
+            meta_data_gen::get_meta_attribute<&Branch3Output<sym>::loading_2>(offsetof(Branch3Output<sym>, loading_2), "loading_2"),
+            meta_data_gen::get_meta_attribute<&Branch3Output<sym>::loading_3>(offsetof(Branch3Output<sym>, loading_3), "loading_3"),
             meta_data_gen::get_meta_attribute<&Branch3Output<sym>::loading>(offsetof(Branch3Output<sym>, loading), "loading"),
             meta_data_gen::get_meta_attribute<&Branch3Output<sym>::p_1>(offsetof(Branch3Output<sym>, p_1), "p_1"),
             meta_data_gen::get_meta_attribute<&Branch3Output<sym>::q_1>(offsetof(Branch3Output<sym>, q_1), "q_1"),

{power_grid_model-1.12.84 → power_grid_model-1.12.91}/power_grid_model_c/power_grid_model/include/power_grid_model/auxiliary/output.hpp

@@ -70,6 +70,9 @@ struct Branch3Output {
 
     ID id{na_IntID};  // ID of the object
     IntS energized{na_IntS};  // whether the object is energized
+    double loading_1{nan};  // loading of the branch at side 1
+    double loading_2{nan};  // loading of the branch at side 2
+    double loading_3{nan};  // loading of the branch at side 3
     double loading{nan};  // loading of the branch
     RealValue<sym> p_1{nan};  // power flow at side 1
     RealValue<sym> q_1{nan};  // power flow at side 1

power_grid_model-1.12.91/power_grid_model_c/power_grid_model/include/power_grid_model/calculation_preparation.hpp

@@ -0,0 +1,180 @@
+// SPDX-FileCopyrightText: Contributors to the Power Grid Model project <powergridmodel@lfenergy.org>
+//
+// SPDX-License-Identifier: MPL-2.0
+
+#pragma once
+
+#include "topology.hpp"
+
+#include "common/common.hpp"
+
+#include "math_solver/math_solver_dispatch.hpp"
+
+#include "main_core/main_model_type.hpp"
+#include "main_core/math_state.hpp"
+#include "main_core/topology.hpp"
+#include "main_core/y_bus.hpp"
+
+namespace power_grid_model {
+struct SolverPreparationContext {
+    main_core::MathState math_state;
+    MathSolverDispatcher const* math_solver_dispatcher;
+};
+
+template <class ModelType>
+    requires(main_core::is_main_model_type_v<ModelType>)
+class SolversCacheStatus {
+  public:
+    using SequenceIdx = typename ModelType::SequenceIdx;
+
+  private:
+    struct YBusParameterCacheValidity {
+        bool sym{false};
+        bool asym{false};
+    };
+
+    enum class SymmetryMode : IntS { symmetric = 0, asymmetric = 1, not_set = na_IntS };
+
+    bool topology_cache_validity{false};
+    YBusParameterCacheValidity parameter_cache_validity{};
+    SymmetryMode previous_symmetry_mode{SymmetryMode::not_set};
+    SequenceIdx changed_components_indices_{};
+
+  public:
+    SequenceIdx const& changed_components_indices() const { return changed_components_indices_; }
+    SequenceIdx& changed_components_indices() { return changed_components_indices_; }
+    void clear_changed_components_indices() {
+        std::ranges::for_each(changed_components_indices(), [](auto& comps) { comps.clear(); });
+    }
+
+    bool is_topology_valid() const { return topology_cache_validity; }
+    void set_topology_status(bool topology) { topology_cache_validity = topology; }
+
+    template <symmetry_tag sym> bool is_parameter_valid() const {
+        if constexpr (is_symmetric_v<sym>) {
+            return parameter_cache_validity.sym;
+        } else {
+            return parameter_cache_validity.asym;
+        }
+    }
+    template <symmetry_tag sym> void set_parameter_status(bool parameter) {
+        if constexpr (is_symmetric_v<sym>) {
+            parameter_cache_validity.sym = parameter;
+        } else {
+            parameter_cache_validity.asym = parameter;
+        }
+    }
+
+    template <symmetry_tag sym> bool is_symmetry_mode_conserved() const {
+        if (previous_symmetry_mode == SymmetryMode::not_set) {
+            return false; // No previous calculation
+        }
+
+        if constexpr (is_symmetric_v<sym>) {
+            return previous_symmetry_mode == SymmetryMode::symmetric;
+        } else {
+            return previous_symmetry_mode == SymmetryMode::asymmetric;
+        }
+    }
+    template <symmetry_tag sym> void set_previous_symmetry_mode() {
+        if constexpr (is_symmetric_v<sym>) {
+            previous_symmetry_mode = SymmetryMode::symmetric;
+        } else {
+            previous_symmetry_mode = SymmetryMode::asymmetric;
+        }
+    }
+
+    void update(UpdateChange const& changes) {
+        // if topology changed, everything is not up to date
+        // if only param changed, set param to not up to date
+        if (changes.topo || !is_topology_valid()) {
+            set_topology_status(false);
+            set_parameter_status<symmetric_t>(false);
+            set_parameter_status<asymmetric_t>(false);
+            return;
+        }
+
+        set_topology_status(true);
+        if (changes.param) {
+            set_parameter_status<symmetric_t>(false);
+            set_parameter_status<asymmetric_t>(false);
+            return;
+        }
+        set_parameter_status<symmetric_t>(is_parameter_valid<symmetric_t>());
+        set_parameter_status<asymmetric_t>(is_parameter_valid<asymmetric_t>());
+    }
+};
+
+namespace detail {
+template <class ModelType>
+void reset_solvers(typename ModelType::MainModelState& state, SolverPreparationContext& solver_context,
+                   SolversCacheStatus<ModelType>& solvers_cache_status) {
+    solvers_cache_status.set_topology_status(false);
+    solvers_cache_status.template set_parameter_status<symmetric_t>(false);
+    solvers_cache_status.template set_parameter_status<asymmetric_t>(false);
+    main_core::clear(solver_context.math_state);
+    state.math_topology.clear();
+    state.topo_comp_coup.reset();
+    state.comp_coup = {};
+}
+
+template <class ModelType>
+void rebuild_topology(typename ModelType::MainModelState& state, SolverPreparationContext& solver_context,
+                      SolversCacheStatus<ModelType>& solvers_cache_status) {
+    // clear old solvers
+    reset_solvers(state, solver_context, solvers_cache_status);
+    ComponentConnections const comp_conn = main_core::construct_components_connections<ModelType>(state.components);
+    // re build
+    Topology topology{*state.comp_topo, comp_conn};
+    std::tie(state.math_topology, state.topo_comp_coup) = topology.build_topology();
+    solvers_cache_status.set_topology_status(true);
+    solvers_cache_status.template set_parameter_status<symmetric_t>(false);
+    solvers_cache_status.template set_parameter_status<asymmetric_t>(false);
+}
+} // namespace detail
+
+template <class ModelType> Idx get_n_math_solvers(typename ModelType::MainModelState const& state) {
+    return static_cast<Idx>(state.math_topology.size());
+}
+
+template <symmetry_tag sym, class ModelType>
+void prepare_solvers(typename ModelType::MainModelState& state, SolverPreparationContext& solver_context,
+                     SolversCacheStatus<ModelType>& solvers_cache_status) {
+    std::vector<MathSolverProxy<sym>>& solvers = main_core::get_solvers<sym>(solver_context.math_state);
+    // rebuild topology if needed
+    if (!solvers_cache_status.is_topology_valid()) {
+        detail::rebuild_topology(state, solver_context, solvers_cache_status);
+    }
+    Idx const n_math_solvers = get_n_math_solvers<ModelType>(state);
+    main_core::prepare_y_bus<sym, ModelType>(state, n_math_solvers, solver_context.math_state);
+    if (n_math_solvers != static_cast<Idx>(solvers.size())) {
+        assert(solvers.empty());
+        assert(n_math_solvers == static_cast<Idx>(main_core::get_y_bus<sym>(solver_context.math_state).size()));
+
+        solvers.clear();
+        solvers.reserve(n_math_solvers);
+        std::ranges::transform(state.math_topology, std::back_inserter(solvers),
+                               [&solver_context](auto const& math_topo) {
+                                   return MathSolverProxy<sym>{solver_context.math_solver_dispatcher, math_topo};
+                               });
+        for (Idx idx = 0; idx < n_math_solvers; ++idx) {
+            main_core::get_y_bus<sym>(solver_context.math_state)[idx].register_parameters_changed_callback(
+                [solver = std::ref(solvers[idx])](bool changed) { solver.get().get().parameters_changed(changed); });
+        }
+    } else if (!solvers_cache_status.template is_parameter_valid<sym>()) {
+        std::vector<MathModelParam<sym>> const math_params = main_core::get_math_param<sym>(state, n_math_solvers);
+        if (solvers_cache_status.template is_symmetry_mode_conserved<sym>()) {
+            std::vector<MathModelParamIncrement> const math_param_increments =
+                main_core::get_math_param_increment<ModelType>(state, n_math_solvers,
+                                                               solvers_cache_status.changed_components_indices());
+            main_core::update_y_bus(solver_context.math_state, math_params, math_param_increments);
+        } else {
+            main_core::update_y_bus(solver_context.math_state, math_params);
+        }
+    }
+    // else do nothing, set everything up to date
+    solvers_cache_status.template set_parameter_status<sym>(true);
+    solvers_cache_status.clear_changed_components_indices();
+    solvers_cache_status.template set_previous_symmetry_mode<sym>();
+}
+} // namespace power_grid_model

{power_grid_model-1.12.84 → power_grid_model-1.12.91}/power_grid_model_c/power_grid_model/include/power_grid_model/component/branch3.hpp

@@ -84,7 +84,12 @@ class Branch3 : public Base {
     virtual double base_i_1() const = 0;
     virtual double base_i_2() const = 0;
     virtual double base_i_3() const = 0;
-    virtual double loading(double s_1, double s_2, double s_3) const = 0;
+    virtual double loading_1(double s_1) const = 0;
+    virtual double loading_2(double s_2) const = 0;
+    virtual double loading_3(double s_3) const = 0;
+    double loading(double s_1, double s_2, double s_3) const {
+        return std::max({loading_1(s_1), loading_2(s_2), loading_3(s_3)});
+    }
     virtual std::array<double, 3> phase_shift() const = 0;
 
     template <symmetry_tag sym>
@@ -123,6 +128,9 @@ class Branch3 : public Base {
         output.s_3 = base_power<sym> * cabs(branch_solver_output3.s_f);
 
         output.loading = loading(sum_val(output.s_1), sum_val(output.s_2), sum_val(output.s_3));
+        output.loading_1 = loading_1(sum_val(output.s_1));
+        output.loading_2 = loading_2(sum_val(output.s_2));
+        output.loading_3 = loading_3(sum_val(output.s_3));
 
         return output;
     }

{power_grid_model-1.12.84 → power_grid_model-1.12.91}/power_grid_model_c/power_grid_model/include/power_grid_model/component/three_winding_transformer.hpp

@@ -104,9 +104,9 @@ class ThreeWindingTransformer : public Branch3 {
     double base_i_1() const final { return base_i_1_; }
     double base_i_2() const final { return base_i_2_; }
     double base_i_3() const final { return base_i_3_; }
-    double loading(double s_1, double s_2, double s_3) const final {
-        return std::max({s_1 / sn_1_, s_2 / sn_2_, s_3 / sn_3_});
-    }
+    double loading_1(double s_1) const final { return s_1 / sn_1_; }
+    double loading_2(double s_2) const final { return s_2 / sn_2_; }
+    double loading_3(double s_3) const final { return s_3 / sn_3_; }
     // 3-way branch, phase shift = phase_node_x - phase_internal_node
     // the clock_12 and clock_13 is reverted
     // because clock_12 is the phase shift node_1 - node_2

{power_grid_model-1.12.84 → power_grid_model-1.12.91}/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/calculation_input_preparation.hpp

@@ -12,7 +12,6 @@
 #include <vector>
 
 namespace power_grid_model::main_core {
-constexpr Idx isolated_component{-1};
 constexpr Idx not_connected{-1};
 
 namespace detail {

{power_grid_model-1.12.84 → power_grid_model-1.12.91}/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/y_bus.hpp

@@ -7,6 +7,7 @@
 #include "../common/common.hpp"
 
 namespace power_grid_model::main_core {
+constexpr Idx isolated_component{-1};
 
 namespace detail {
 template <std::derived_from<Branch> ComponentType, typename ComponentContainer>

{power_grid_model-1.12.84 → power_grid_model-1.12.91}/power_grid_model_c/power_grid_model/include/power_grid_model/main_model.hpp

@@ -25,10 +25,14 @@ class MainModel {
 
     explicit MainModel(double system_frequency, ConstDataset const& input_data,
                        MathSolverDispatcher const& math_solver_dispatcher, Idx pos = 0)
-        : impl_{std::make_unique<Impl>(system_frequency, input_data, math_solver_dispatcher, pos)} {}
+        : impl_{std::make_unique<Impl>(
+              system_frequency, input_data,
+              SolverPreparationContext{.math_state = {}, .math_solver_dispatcher = &math_solver_dispatcher}, pos)} {}
     explicit MainModel(double system_frequency, meta_data::MetaData const& meta_data,
                        MathSolverDispatcher const& math_solver_dispatcher)
-        : impl_{std::make_unique<Impl>(system_frequency, meta_data, math_solver_dispatcher)} {};
+        : impl_{std::make_unique<Impl>(
+              system_frequency, meta_data,
+              SolverPreparationContext{.math_state = {}, .math_solver_dispatcher = &math_solver_dispatcher})} {};
 
     // deep copy
     MainModel(MainModel const& other) {