Merge branch 'main' into feature/dependency-inversion-main-model-impl-info

mgovers · web-flow · commit 3bb015e991a7 · 2025-09-04T08:59:00.000+02:00
Signed-off-by: Martijn Govers &lt;martijn.govers@alliander.com&gt;
diff --git a/.github/workflows/build-test-release.yml b/.github/workflows/build-test-release.yml
@@ -260,9 +260,15 @@ jobs:
           conda info
           conda list
 
-      - uses: ./.github/actions/enable-msvc
+      - name: Enable MSVC
+        uses: ./.github/actions/enable-msvc
         if: runner.os == 'Windows'
 
+      - name: Enable gcc/g++
+        if: matrix.os == 'ubuntu'
+        run: |
+          conda install -y gcc_linux-64 gxx_linux-64
+
       - name: Build and install cmake target for Windows
         if: matrix.os == 'windows'
         run: |          
diff --git a/.github/workflows/check-code-quality.yml b/.github/workflows/check-code-quality.yml
@@ -42,14 +42,14 @@ jobs:
 
       - name: Install and run ruff
         run: |
-          pip install ruff .
+          pip install ruff
           ruff check .
           ruff format .
           git restore README.md
 
       - name: Install and run clang-format
         run: |
-          sudo apt-get update && sudo apt-get install -y clang-format-18
+          sudo apt-get install -y clang-format-18
           find . -regex '.*\.\(h\|c\|cpp\|hpp\|cc\|cxx\)' -exec clang-format-18 -style=file -i {} \;
 
       - name: Install and run markdownlint
@@ -60,7 +60,6 @@ jobs:
 
       - name: If needed raise error
         run: |
-
           if [[ `git status --porcelain --untracked-files=no` ]]; then
             echo "Formatting not correct! See below the files which need to be reformatted!"
             git status --porcelain --untracked-files=no
diff --git a/.readthedocs.yaml b/.readthedocs.yaml
@@ -11,13 +11,15 @@ sphinx:
 build:
   os: "ubuntu-24.04"
   tools:
-    python: "3.11"
+    python: "3.13"
   apt_packages:
     - graphviz
+    - gcc-14
+    - g++-14
   jobs:
     post_install:
       # Build package with doc requirements from pyproject.optional-dependencies
-      - pip install --verbose --editable .[doc]
+      - CC=gcc-14 CXX=g++-14 pip install --verbose --editable .[doc]
 
       # remove API DLL define in header
       - find power_grid_model_c/power_grid_model_c/include -name *.h -exec sed -i -r "s/#define PGM.*//g" {} \;
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/job_interface.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/job_interface.hpp
@@ -76,7 +76,7 @@ template <typename Adapter> class JobInterface {
     }
 
   private:
-    friend Adapter; // CRTP compliance
+    friend Adapter;
     JobInterface() = default;
     JobInterface(const JobInterface& /*other*/) = default;
     JobInterface& operator=(const JobInterface& /*other*/) = default;
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/output.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/output.hpp
@@ -9,6 +9,8 @@
 
 #include "../all_components.hpp"
 
+#include <concepts>
+
 namespace power_grid_model::main_core {
 
 namespace detail {
@@ -103,7 +105,7 @@ template <typename Component, typename IndexType, class ComponentContainer, std:
 constexpr void produce_output(MainModelState<ComponentContainer> const& state, ComponentOutput&& output,
                               ResFunc&& func) {
     std::ranges::transform(get_component_citer<Component>(state), comp_base_sequence<Component>(state),
-                           std::ranges::begin(output), std::forward<ResFunc>(func));
+                           std::ranges::begin(std::forward<ComponentOutput>(output)), std::forward<ResFunc>(func));
 }
 
 } // namespace detail
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp
@@ -180,7 +180,7 @@ constexpr void register_topology_components(ComponentContainer const& components
 
 template <std::same_as<Branch> Component, class ComponentContainer>
     requires common::component_container_c<ComponentContainer, Component>
-constexpr void register_connections_components(ComponentContainer components, ComponentConnections& comp_conn) {
+constexpr void register_connections_components(ComponentContainer const& components, ComponentConnections& comp_conn) {
     apply_registration<Component>(components, comp_conn.branch_connected, [](Branch const& branch) {
         return BranchConnected{static_cast<IntS>(branch.from_status()), static_cast<IntS>(branch.to_status())};
     });
@@ -189,7 +189,7 @@ constexpr void register_connections_components(ComponentContainer components, Co
 }
 template <std::same_as<Branch3> Component, class ComponentContainer>
     requires common::component_container_c<ComponentContainer, Component>
-constexpr void register_connections_components(ComponentContainer components, ComponentConnections& comp_conn) {
+constexpr void register_connections_components(ComponentContainer const& components, ComponentConnections& comp_conn) {
     apply_registration<Component>(components, comp_conn.branch3_connected, [](Branch3 const& branch3) {
         return Branch3Connected{static_cast<IntS>(branch3.status_1()), static_cast<IntS>(branch3.status_2()),
                                 static_cast<IntS>(branch3.status_3())};
@@ -200,7 +200,7 @@ constexpr void register_connections_components(ComponentContainer components, Co
 
 template <std::same_as<Source> Component, class ComponentContainer>
     requires common::component_container_c<ComponentContainer, Component>
-constexpr void register_connections_components(ComponentContainer components, ComponentConnections& comp_conn) {
+constexpr void register_connections_components(ComponentContainer const& components, ComponentConnections& comp_conn) {
     apply_registration<Component>(components, comp_conn.source_connected,
                                   [](Source const& source) { return source.status(); });
 }
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/y_bus.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/y_bus.hpp
@@ -4,6 +4,8 @@
 
 #pragma once
 
+#include "../common/common.hpp"
+
 namespace power_grid_model::main_core {
 
 template <symmetry_tag sym, typename ComponentContainer, typename... ComponentType>
@@ -47,7 +49,7 @@ void prepare_y_bus(MainModelState<ComponentContainer> const& state_, Idx n_math_
 
 template <symmetry_tag sym, typename ComponentContainer, typename... ComponentType>
 static std::vector<MathModelParamIncrement> get_math_param_increment(
-    MainModelState<ComponentContainer> received_state, Idx n_math_solvers_,
+    MainModelState<ComponentContainer>& received_state, Idx n_math_solvers_,
     std::array<std::vector<Idx2D>, main_core::utils::n_types<ComponentType...>> const& parameter_changed_components_) {
     using AddToIncrement =
         void (*)(std::vector<MathModelParamIncrement>&, MainModelState<ComponentContainer> const&, Idx2D const&);
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/y_bus.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/y_bus.hpp
@@ -264,7 +264,8 @@ struct YBusStructure {
         // construct transpose entry
         lu_transpose_entry.resize(nnz_counter_lu);
         // default transpose_entry[i] = i
-        std::iota(lu_transpose_entry.begin(), lu_transpose_entry.end(), 0);
+        std::iota( // NOLINT(modernize-use-ranges) // not yet supported by some compilers
+            lu_transpose_entry.begin(), lu_transpose_entry.end(), 0);
         // fill off-diagonal, loop all the branches
         for (auto const [entry_1, entry_2] : off_diag_map) {
             // for each branch entry tf and ft, they are transpose to each other
diff --git a/tests/benchmark_cpp/benchmark.cpp b/tests/benchmark_cpp/benchmark.cpp
@@ -104,25 +104,26 @@ std::string make_key(LogEvent code) {
 }
 
 auto get_benchmark_run_title(Option const& option, MainModelOptions const& model_options) {
-    auto const mv_ring_type = option.has_mv_ring ? "meshed grid" : "radial grid";
+    using namespace std::string_literals;
+    auto const mv_ring_type = option.has_mv_ring ? "meshed grid"s : "radial grid"s;
     auto const sym_type =
-        model_options.calculation_symmetry == CalculationSymmetry::symmetric ? "symmetric" : "asymmetric";
+        model_options.calculation_symmetry == CalculationSymmetry::symmetric ? "symmetric"s : "asymmetric"s;
     auto const method = [calculation_method = model_options.calculation_method] {
         using enum CalculationMethod;
 
         switch (calculation_method) {
         case newton_raphson:
-            return "Newton-Raphson method";
+            return "Newton-Raphson method"s;
         case linear:
-            return "Linear method";
+            return "Linear method"s;
         case linear_current:
-            return "Linear current method";
+            return "Linear current method"s;
         case iterative_current:
-            return "Iterative current method";
+            return "Iterative current method"s;
         case iterative_linear:
-            return "Iterative linear method";
+            return "Iterative linear method"s;
         case iec60909:
-            return "IEC 60909 method";
+            return "IEC 60909 method"s;
         default:
             throw MissingCaseForEnumError{"get_benchmark_run_title", calculation_method};
         }
@@ -171,15 +172,18 @@ struct PowerGridBenchmark {
         auto const run = [this, &model_options, &info](Idx batch_size_) {
             switch (model_options.calculation_type) {
             case short_circuit:
-                return run_calculation<ShortCircuitOutputData>(model_options, batch_size_, info);
+                run_calculation<ShortCircuitOutputData>(model_options, batch_size_, info);
+                break;
             case power_flow:
                 [[fallthrough]];
             case state_estimation: {
                 switch (model_options.calculation_symmetry) {
                 case CalculationSymmetry::symmetric:
-                    return run_calculation<OutputData<symmetric_t>>(model_options, batch_size_, info);
+                    run_calculation<OutputData<symmetric_t>>(model_options, batch_size_, info);
+                    break;
                 case CalculationSymmetry::asymmetric:
-                    return run_calculation<OutputData<asymmetric_t>>(model_options, batch_size_, info);
+                    run_calculation<OutputData<asymmetric_t>>(model_options, batch_size_, info);
+                    break;
                 default:
                     throw MissingCaseForEnumError{"run_benchmark<calculation_symmetry>",
                                                   model_options.calculation_symmetry};
@@ -231,11 +235,6 @@ struct PowerGridBenchmark {
 } // namespace
 } // namespace power_grid_model::benchmark
 
-namespace {
-using power_grid_model::asymmetric_t;
-using power_grid_model::symmetric_t;
-} // namespace
-
 int main(int /* argc */, char** /* argv */) {
     using enum power_grid_model::CalculationType;
     using enum power_grid_model::CalculationMethod;
diff --git a/tests/benchmark_cpp/fictional_grid_generator.hpp b/tests/benchmark_cpp/fictional_grid_generator.hpp
@@ -646,8 +646,8 @@ class FictionalGridGenerator {
         std::uniform_real_distribution<double> load_scaling_gen{0.0, 1.0};
         load_series.resize(input.size() * batch_size);
         auto const n_object = std::ssize(input);
-        for (Idx batch : IdxRange{batch_size}) {
-            for (Idx object : IdxRange{n_object}) {
+        for (Idx const batch : IdxRange{batch_size}) {
+            for (Idx const object : IdxRange{n_object}) {
                 T const& input_obj = input[object];
                 U& update_obj = load_series[batch * n_object + object];
                 update_obj.id = input_obj.id;
@@ -698,10 +698,10 @@ class FictionalGridGenerator {
 
         sensor_series.resize(input.size() * batch_size);
         auto const n_object = std::ssize(input);
-        for (Idx object : IdxRange{n_object}) {
+        for (Idx const object : IdxRange{n_object}) {
             T const& input_obj = input[object];
 
-            for (Idx batch : IdxRange{batch_size}) {
+            for (Idx const batch : IdxRange{batch_size}) {
                 U& update_obj = sensor_series[batch * n_object + object];
                 update_obj.id = input_obj.id;
                 if constexpr (is_symmetric_v<typename T::sym>) {
diff --git a/tests/cpp_unit_tests/test_dataset.cpp b/tests/cpp_unit_tests/test_dataset.cpp
@@ -1071,8 +1071,10 @@ TEST_CASE_TEMPLATE("Test dataset (common)", DatasetType, ConstDataset, MutableDa
                 auto a_a1_buffer = std::vector<double>(a_elements_per_scenario * batch_size);
                 auto b_indptr = std::vector<Idx>{0, 0, 3};
 
-                std::iota(a_id_buffer.begin(), a_id_buffer.end(), ID{0});
-                std::iota(a_a1_buffer.begin(), a_a1_buffer.end(), 0.0);
+                std::iota( // NOLINT(modernize-use-ranges) // not yet supported by some compilers
+                    a_id_buffer.begin(), a_id_buffer.end(), ID{0});
+                std::iota( // NOLINT(modernize-use-ranges) // not yet supported by some compilers
+                    a_a1_buffer.begin(), a_a1_buffer.end(), 0.0);
 
                 add_homogeneous_buffer(dataset, A::name, a_elements_per_scenario, nullptr);
                 add_attribute_buffer(dataset, A::name, "id", static_cast<void*>(a_id_buffer.data()));
diff --git a/tests/cpp_unit_tests/test_exceptions.cpp b/tests/cpp_unit_tests/test_exceptions.cpp
@@ -38,8 +38,8 @@ TEST_CASE("Exceptions") {
         CHECK(std::string{InvalidArguments{"bar"}.what()} == "bar");
         CHECK(std::string{InvalidArguments{"foo", "bar"}.what()} == "foo is not implemented for bar!\n");
 
-        InvalidArguments::TypeValuePair const foo{"foo", "baz"};
-        InvalidArguments::TypeValuePair const bar{"bar", "bla"};
+        InvalidArguments::TypeValuePair const foo{.name = "foo", .value = "baz"};
+        InvalidArguments::TypeValuePair const bar{.name = "bar", .value = "bla"};
         CHECK(std::string{InvalidArguments{"Test method", foo}.what()} ==
               "Test method is not implemented for the following combination of options!\n"
               " foo: baz\n");
@@ -298,8 +298,8 @@ TEST_CASE("Exceptions") {
         CHECK(std::string{ExperimentalFeature{"bar"}.what()} == "bar");
         CHECK(std::string{ExperimentalFeature{"foo", "bar"}.what()} == "foo is not implemented for bar!\n");
 
-        ExperimentalFeature::TypeValuePair const foo{"foo", "baz"};
-        ExperimentalFeature::TypeValuePair const bar{"bar", "bla"};
+        ExperimentalFeature::TypeValuePair const foo{.name = "foo", .value = "baz"};
+        ExperimentalFeature::TypeValuePair const bar{.name = "bar", .value = "bla"};
         CHECK(std::string{ExperimentalFeature{"Test method", foo}.what()} ==
               "Test method is not implemented for the following combination of options!\n"
               " foo: baz\n");

Original file line number	Diff line number	Diff line change
`@@ -76,7 +76,7 @@ template <typename Adapter> class JobInterface {`
`76`	`76`	`}`
`77`	`77`
`78`	`78`	`private:`
`79`		`- friend Adapter; // CRTP compliance`
	`79`	`+ friend Adapter;`
`80`	`80`	`JobInterface() = default;`
`81`	`81`	`JobInterface(const JobInterface& /other/) = default;`
`82`	`82`	`JobInterface& operator=(const JobInterface& /other/) = default;`