More apply clang-tidy-19

Signed-off-by: Martijn Govers <Martijn.Govers@Alliander.com>

Author: mgovers

power_grid_model_c/power_grid_model/include/power_grid_model/auxiliary/serialization/deserializer.hpp

@@ -673,9 +673,11 @@ class Deserializer {
         while (n_components-- != 0) {
             component_key_ = parse_string();
             Idx const component_size = parse_map_array<visit_array_t, stay_offset>().size;
-            count_per_scenario.push_back({.component = component_key_, .size = component_size, .offset = offset_});
-            // skip all the real content
-            parse_skip();
+            size_t const scenario_offset = offset_;
+            // skip all the real content but check if it has map
+            bool const has_map = parse_skip_check_map();
+            count_per_scenario.push_back(
+                {.component = component_key_, .size = component_size, .offset = scenario_offset, .has_map = has_map});
         }
         component_key_ = {};
         return count_per_scenario;
@@ -724,8 +726,8 @@ class Deserializer {
                 elements_per_scenario * batch_size;                                     // multiply
         handler.add_component_info(component_key_, elements_per_scenario, total_elements);
         // check if all scenarios only contain array data
-        bool const only_values_in_data = std::none_of(component_byte_meta.cbegin(), component_byte_meta.cend(),
-                                                      [](auto const& x) { return x.has_map; });
+        bool const only_values_in_data =
+            std::ranges::none_of(component_byte_meta, [](auto const& x) { return x.has_map; });
         msg_data_offsets_.push_back(std::move(component_byte_meta));
         // enable attribute indications if possible
         if (only_values_in_data) {

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

@@ -31,7 +31,7 @@ struct Idx2D {
 };
 
 struct Idx2DHash {
-    std::size_t operator()(const Idx2D& idx) const {
+    std::size_t operator()(Idx2D const& idx) const {
         size_t const h1 = std::hash<Idx>{}(idx.group);
         size_t const h2 = std::hash<Idx>{}(idx.pos);
         return h1 ^ (h2 << 1);

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

@@ -53,7 +53,7 @@ class InvalidArguments : public PowerGridError {
 class MissingCaseForEnumError : public InvalidArguments {
   public:
     template <typename T>
-    MissingCaseForEnumError(std::string const& method, const T& value)
+    MissingCaseForEnumError(std::string const& method, T const& value)
         : InvalidArguments{method, std::string{typeid(T).name()} + " #" + detail::to_string(static_cast<IntS>(value))} {
     }
 };
@@ -291,7 +291,7 @@ class UnreachableHit : public PowerGridError {
 class TapSearchStrategyIncompatibleError : public InvalidArguments {
   public:
     template <typename T1, typename T2>
-    TapSearchStrategyIncompatibleError(std::string const& method, const T1& value1, const T2& value2)
+    TapSearchStrategyIncompatibleError(std::string const& method, T1 const& value1, T2 const& value2)
         : InvalidArguments{
               method, std::string{typeid(T1).name()} + " #" + detail::to_string(static_cast<IntS>(value1)) + " and " +
                           std::string{typeid(T2).name()} + " #" + detail::to_string(static_cast<IntS>(value2))} {}

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

@@ -238,7 +238,7 @@ template <column_vector DerivedA> inline auto mean_val(Eigen::ArrayBase<DerivedA
 inline DoubleComplex mean_val(DoubleComplex const& z) { return z; }
 inline double mean_val(double z) { return z; }
 
-template <symmetry_tag sym, class T> inline auto process_mean_val(const T& m) {
+template <symmetry_tag sym, class T> inline auto process_mean_val(T const& m) {
     if constexpr (is_symmetric_v<sym>) {
         return mean_val(m);
     } else {
@@ -348,9 +348,7 @@ inline auto all_zero(RealValue<asymmetric_t> const& value) { return (value == Re
 //
 // The function assumes that the current value is normalized and new value should be normalized with scalar
 template <symmetry_tag sym, class Proxy>
-inline void
-update_real_value(RealValue<sym> const& new_value, Proxy&& current_value,
-                  double scalar) { // NOLINT(cppcoreguidelines-missing-std-forward) // perfect forward into void
+inline void update_real_value(RealValue<sym> const& new_value, Proxy&& current_value, double scalar) {
     if constexpr (is_symmetric_v<sym>) {
         if (!is_nan(new_value)) {
             std::forward<Proxy>(current_value) = scalar * new_value;

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

@@ -29,9 +29,9 @@ class Timer {
     Timer(CalculationInfo& info, int code, std::string name)
         : info_(&info), code_(code), name_(std::move(name)), start_(Clock::now()) {}
 
-    Timer(const Timer&) = delete;
+    Timer(Timer const&) = delete;
     Timer(Timer&&) = default;
-    Timer& operator=(const Timer&) = delete;
+    Timer& operator=(Timer const&) = delete;
 
     Timer& operator=(Timer&& timer) noexcept {
         // Stop the current timer

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

@@ -36,8 +36,8 @@ class Base {
     Base& operator=(Base&&) = default;
 
   protected:
-    Base(const Base&) = default;
-    Base& operator=(const Base&) = default;
+    Base(Base const&) = default;
+    Base& operator=(Base const&) = default;
 
   private:
     ID id_;

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

@@ -173,9 +173,7 @@ class LoadGen final : public std::conditional_t<is_generator_v<appliance_type_>,
         case const_i:
             return params() * cabs(u);
         default:
-            auto const& load_gen_name =
-                this->name; // NOLINT(readability-static-accessed-through-instance) // for derived class type
-            throw MissingCaseForEnumError(std::string{load_gen_name} + " power scaling factor", this->type());
+            throw MissingCaseForEnumError(std::string{name} + " power scaling factor", this->type());
         }
     }
 };

power_grid_model_c/power_grid_model/include/power_grid_model/main_model_impl.hpp

@@ -369,7 +369,7 @@ class MainModelImpl<ExtraRetrievableTypes<ExtraRetrievableType...>, ComponentLis
             state_, update_data, 0, components_to_update, update_independence, false);
     }
 
-    void update_state(const UpdateChange& changes) {
+    void update_state(UpdateChange const& changes) {
         // if topology changed, everything is not up to date
         // if only param changed, set param to not up to date
         is_topology_up_to_date_ = is_topology_up_to_date_ && !changes.topo;
@@ -523,9 +523,9 @@ class MainModelImpl<ExtraRetrievableTypes<ExtraRetrievableType...>, ComponentLis
                                *meta_data_,
                            },
                            ignore_output);
-        } catch (const SparseMatrixError&) { // NOLINT(bugprone-empty-catch) // NOSONAR
+        } catch (SparseMatrixError const&) { // NOLINT(bugprone-empty-catch) // NOSONAR
             // missing entries are provided in the update data
-        } catch (const NotObservableError&) { // NOLINT(bugprone-empty-catch) // NOSONAR
+        } catch (NotObservableError const&) { // NOLINT(bugprone-empty-catch) // NOSONAR
             // missing entries are provided in the update data
         }
 

power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/iterative_linear_se_solver.hpp

@@ -215,7 +215,7 @@ template <symmetry_tag sym_type> class IterativeLinearSESolver {
                                 auto const& power = std::invoke(branch_power_[measured_side], measured_value, obj);
                                 block.g() +=
                                     dot(hermitian_transpose(param.branch_param[obj].value[measured_side * 2 + b0]),
-                                        diagonal_inverse(power.p_variance + power.q_variance),
+                                        diagonal_inverse(static_cast<IndependentComplexRandVar<sym>>(power).variance),
                                         param.branch_param[obj].value[measured_side * 2 + b1]);
                             }
                         }
@@ -310,7 +310,8 @@ template <symmetry_tag sym_type> class IterativeLinearSESolver {
                             // eta += Y{side, b}^H * (variance^-1) * i_branch_{f, t}
                             rhs_block.eta() +=
                                 dot(hermitian_transpose(param.branch_param[obj].value[measured_side * 2 + b]),
-                                    diagonal_inverse(m.p_variance + m.q_variance), conj(m.value / u[measured_bus]));
+                                    diagonal_inverse(static_cast<IndependentComplexRandVar<sym>>(m).variance),
+                                    conj(m.value() / u[measured_bus]));
                         }
                     }
                 }

power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/measured_values.hpp

@@ -473,14 +473,17 @@ template <symmetry_tag sym> class MeasuredValues {
         }
 
         if (is_normal(accumulated_inverse_p_variance) && is_normal(accumulated_inverse_q_variance)) {
-            return PowerSensorCalcParam<sym>{accumulated_p_value / accumulated_inverse_p_variance +
-                                                 1.0i * accumulated_q_value / accumulated_inverse_q_variance,
-                                             RealValue<sym>{1.0} / accumulated_inverse_p_variance,
-                                             RealValue<sym>{1.0} / accumulated_inverse_q_variance};
+            return PowerSensorCalcParam<sym>{
+                .real_component = {.value = accumulated_p_value / accumulated_inverse_p_variance,
+                                   .variance = RealValue<sym>{1.0} / accumulated_inverse_p_variance},
+                .imag_component = {.value = accumulated_q_value / accumulated_inverse_q_variance,
+                                   .variance = RealValue<sym>{1.0} / accumulated_inverse_q_variance}};
         }
-        return PowerSensorCalcParam<sym>{accumulated_p_value + 1.0i * accumulated_q_value,
-                                         RealValue<sym>{std::numeric_limits<double>::infinity()},
-                                         RealValue<sym>{std::numeric_limits<double>::infinity()}};
+        return PowerSensorCalcParam<sym>{
+            .real_component = {.value = accumulated_p_value,
+                               .variance = RealValue<sym>{std::numeric_limits<double>::infinity()}},
+            .imag_component = {.value = accumulated_q_value,
+                               .variance = RealValue<sym>{std::numeric_limits<double>::infinity()}}};
     }
 
     template <sensor_calc_param_type CalcParam, bool only_magnitude = false>
@@ -588,9 +591,9 @@ template <symmetry_tag sym> class MeasuredValues {
                                              FlowVector& source_flow) const {
         // residual normalized by variance
         // mu = (sum[S_i] - S_cal) / sum[variance]
-        auto const delta = bus_appliance_injection.value - s;
-        ComplexValue<sym> const mu =
-            real(delta) / bus_appliance_injection.p_variance + 1.0i * imag(delta) / bus_appliance_injection.q_variance;
+        auto const delta = ComplexValue<sym>{bus_appliance_injection.value() - s};
+        ComplexValue<sym> const mu = real(delta) / bus_appliance_injection.real_component.variance +
+                                     1.0i * imag(delta) / bus_appliance_injection.imag_component.variance;
 
         // S_i = S_i_mea - var_i * mu
         auto const calculate_injection = [&mu](auto const& power) {

power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/newton_raphson_se_solver.hpp

@@ -436,8 +436,8 @@ template <symmetry_tag sym_type> class NewtonRaphsonSESolver {
     /// @param order Order enum to determine if (chi, psi) = (row, col) or (col, row)
     /// @param measured_power
     void process_branch_measurement(NRSEGainBlock<sym>& block, NRSEGainBlock<sym>& diag_block, NRSERhs<sym>& rhs_block,
-                                    const auto& y_xi_xi, const auto& y_xi_mu, const auto& u_state, Order const order,
-                                    const auto& measured_power) {
+                                    auto const& y_xi_xi, auto const& y_xi_mu, auto const& u_state, Order const order,
+                                    auto const& measured_power) {
         auto const hm_u_chi_u_chi_y_xi_xi = hm_complex_form(y_xi_xi, u_state.u_chi_u_chi_conj(order));
         auto const nl_u_chi_u_chi_y_xi_xi = dot(hm_u_chi_u_chi_y_xi_xi, u_state.abs_u_chi_inv(order));
 
@@ -461,8 +461,8 @@ template <symmetry_tag sym_type> class NewtonRaphsonSESolver {
     }
 
     void multiply_add_branch_blocks(NRSEGainBlock<sym>& block, NRSEGainBlock<sym>& diag_block, NRSERhs<sym>& rhs_block,
-                                    auto& left_block, const auto& right_block, const auto& measured_power,
-                                    const auto& f_x_complex) {
+                                    auto& left_block, auto const& right_block, auto const& measured_power,
+                                    auto const& f_x_complex) {
         auto const& block_F_T_k_w = transpose_multiply_weight(left_block, measured_power);
 
         multiply_add_jacobian_blocks_lhs(diag_block, block_F_T_k_w, left_block);

power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/observability.hpp

@@ -14,7 +14,7 @@ namespace power_grid_model::math_solver {
 namespace detail {
 
 template <symmetry_tag sym>
-std::tuple<Idx, Idx> count_voltage_sensors(const Idx n_bus, const MeasuredValues<sym>& measured_values) {
+std::tuple<Idx, Idx> count_voltage_sensors(Idx const n_bus, MeasuredValues<sym> const& measured_values) {
     Idx n_voltage_sensor{};
     Idx n_voltage_phasor_sensor{};
     for (Idx bus = 0; bus != n_bus; ++bus) {

power_grid_model_c/power_grid_model/include/power_grid_model/optimizer/tap_position_optimizer.hpp

@@ -42,7 +42,6 @@ using RankedTransformerGroups = std::vector<std::vector<Idx2D>>;
 
 constexpr auto infty = std::numeric_limits<Idx>::max();
 constexpr Idx2D unregulated_idx = {.group = -1, .pos = -1};
-
 struct TrafoGraphVertex {
     bool is_source{};
 };
@@ -55,11 +54,11 @@ struct TrafoGraphEdge {
     constexpr TrafoGraphEdge(Idx2D regulated_idx_, EdgeWeight weight_)
         : regulated_idx{regulated_idx_}, weight{weight_} {}
 
-    bool operator==(const TrafoGraphEdge& other) const {
+    bool operator==(TrafoGraphEdge const& other) const {
         return regulated_idx == other.regulated_idx && weight == other.weight;
     } // thanks boost
 
-    auto constexpr operator<=>(const TrafoGraphEdge& other) const {
+    auto constexpr operator<=>(TrafoGraphEdge const& other) const {
         if (auto cmp = weight <=> other.weight; cmp != 0) { // NOLINT(modernize-use-nullptr)
             return cmp;
         }
@@ -334,7 +333,7 @@ inline auto get_edge_weights(TransformerGraph const& graph) -> TrafoGraphEdgePro
                                          "away from the source than the tap side.\n");
         }
         if (!is_unreachable(edge_res)) {
-            result.push_back({.regulated_idx = graph[e].regulated_idx, .weight = edge_res});
+            result.emplace_back(graph[e].regulated_idx, edge_tgt_rank);
         }
     }
 
@@ -345,7 +344,7 @@ inline auto rank_transformers(TrafoGraphEdgeProperties const& w_trafo_list) -> R
     auto sorted_trafos = w_trafo_list;
 
     std::ranges::sort(sorted_trafos,
-                      [](const TrafoGraphEdge& a, const TrafoGraphEdge& b) { return a.weight < b.weight; });
+                      [](TrafoGraphEdge const& a, TrafoGraphEdge const& b) { return a.weight < b.weight; });
 
     RankedTransformerGroups groups;
     auto previous_weight = std::numeric_limits<EdgeWeight>::lowest();

power_grid_model_c/power_grid_model_cpp/include/power_grid_model_cpp/dataset.hpp

@@ -29,8 +29,8 @@ class DatasetInfo {
     DatasetInfo(RawDatasetInfo const* info) noexcept : info_{info} {}
     DatasetInfo(DatasetInfo&&) = default;
     DatasetInfo& operator=(DatasetInfo&&) = default;
-    DatasetInfo(const DatasetInfo&) = delete;            // No copy constructor
-    DatasetInfo& operator=(const DatasetInfo&) = delete; // No copy assignment
+    DatasetInfo(DatasetInfo const&) = delete;            // No copy constructor
+    DatasetInfo& operator=(DatasetInfo const&) = delete; // No copy assignment
     ~DatasetInfo() = default;
 
     std::string name() const { return std::string{handle_.call_with(PGM_dataset_info_name, info_)}; }
@@ -88,8 +88,8 @@ class DatasetWritable {
         : dataset_{dataset}, info_{handle_.call_with(PGM_dataset_writable_get_info, dataset_)} {}
     DatasetWritable(DatasetWritable&&) = default;
     DatasetWritable& operator=(DatasetWritable&&) = default;
-    DatasetWritable(const DatasetWritable&) = delete;            // No copy constructor
-    DatasetWritable& operator=(const DatasetWritable&) = delete; // No copy assignment
+    DatasetWritable(DatasetWritable const&) = delete;            // No copy constructor
+    DatasetWritable& operator=(DatasetWritable const&) = delete; // No copy assignment
     ~DatasetWritable() = default;
 
     RawWritableDataset const* get() const { return dataset_; }

tests/cpp_unit_tests/CMakeLists.txt

@@ -3,8 +3,8 @@
 # SPDX-License-Identifier: MPL-2.0
 
 set(PROJECT_SOURCES
-    "test_all_components.cpp"
     "test_entry_point.cpp"
+    "test_all_components.cpp"
     "test_common.cpp"
     "test_exceptions.cpp"
     "test_component_list.cpp"

tests/cpp_unit_tests/test_current_sensor.cpp

@@ -78,12 +78,12 @@ TEST_CASE("Test current sensor") {
             CHECK(sym_sensor_output.i_angle_residual == doctest::Approx(0.0));
 
             // Check symmetric sensor output for asymmetric parameters
-            CHECK(asym_sensor_param.i_real_variance[0] == doctest::Approx(i_variance_pu));
-            CHECK(asym_sensor_param.i_imag_variance[1] ==
+            CHECK(asym_sensor_param.measurement.real_component.variance[0] == doctest::Approx(i_variance_pu));
+            CHECK(asym_sensor_param.measurement.imag_component.variance[1] ==
                   doctest::Approx(i_variance_pu * sin(deg_240) * sin(deg_240) +
                                   i_angle_variance_pu * i_pu * i_pu * cos(deg_240) * cos(deg_240)));
-            CHECK(real(asym_sensor_param.value[0]) == doctest::Approx(i_pu));
-            CHECK(imag(asym_sensor_param.value[1]) == doctest::Approx(i_pu * sin(deg_240)));
+            CHECK(real(asym_sensor_param.measurement.value()[0]) == doctest::Approx(i_pu));
+            CHECK(imag(asym_sensor_param.measurement.value()[1]) == doctest::Approx(i_pu * sin(deg_240)));
 
             CHECK(sym_sensor_output_asym_param.id == 0);
             CHECK(sym_sensor_output_asym_param.energized == 1);