power-grid-model 1.12.50__tar.gz → 1.12.51__tar.gz

{power_grid_model-1.12.50 → power_grid_model-1.12.51}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: power-grid-model
-Version: 1.12.50
+Version: 1.12.51
 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.51/VERSION

@@ -0,0 +1 @@
+1.12.51

{power_grid_model-1.12.50 → power_grid_model-1.12.51}/power_grid_model_c/power_grid_model/include/power_grid_model/common/statistics.hpp

@@ -126,6 +126,41 @@ template <symmetry_tag sym_type> struct DecomposedComplexRandVar {
     }
 };
 
+namespace detail {
+// Var(f_i) ≈ \Sum_j Var(x_j) * ||df_i/dx_j||^2                              // first order
+//              + 1/2 * \Sum_{jk} Var(x_j) * ||d^2 f_i/dx_jdx_k||^2 Var(x_k) // second order
+//
+// Re{I} = I cos(θ)
+// Im{I} = I sin(θ)
+//
+// dRe{I}/dI = cos(θ)            dIm{I}/dI = sin(θ)
+// dRe{I}/dθ = -I sin(θ)         dIm{I}/dθ = I cos(θ)
+// d^2 Re{I}/dI^2  = 0               d^2 Im{I}/dI^2  = 0
+// d^2 Re{I}/dθ^2  = -I cos(θ)       d^2 Im{I}/dθ^2  = -I sin(θ)
+// d^2 Re{I}/dIdθ = -sin(θ)        d^2 Im{I}/dIdθ = cos(θ)
+//
+// Var(Re{I}) = Var(I cos(θ))
+//            ≈ Var(I) * cos^2(θ) + Var(θ) * I^2  * sin^2(θ)                      // first order
+//               + 1/2 * Var(θ)^2  * I^2  * cos^2(θ) + Var(I) * Var(θ) * sin^2(θ) // second order
+// Var(Im{I}) = Var(I sin(θ))
+//            ≈ Var(I) * sin^2(θ) + Var(θ) * I^2  * cos^2(θ)                      // first order
+//               + 1/2 * Var(θ)^2  * I^2  * sin^2(θ) + Var(I) * Var(θ) * cos^2(θ) // second order
+inline auto compute_decomposed_variance_from_polar(auto const& magnitude, auto const& cos_angle, auto const& sin_angle,
+                                                   auto const& magnitude_variance, auto const& angle_variance) {
+    auto const cos2_angle = cos_angle * cos_angle;
+    auto const sin2_angle = sin_angle * sin_angle;
+    auto const magnitude2 = magnitude * magnitude;
+
+    // second order approximation
+    return std::make_pair(magnitude_variance * cos2_angle + magnitude2 * angle_variance * sin2_angle +
+                              0.5 * magnitude2 * angle_variance * angle_variance * cos2_angle +
+                              magnitude_variance * angle_variance * sin2_angle,
+                          magnitude_variance * sin2_angle + magnitude2 * angle_variance * cos2_angle +
+                              0.5 * magnitude2 * angle_variance * angle_variance * sin2_angle +
+                              magnitude_variance * angle_variance * cos2_angle);
+}
+} // namespace detail
+
 // Complex measured value of a sensor in polar coordinates (magnitude and angle)
 // (rotationally symmetric)
 template <symmetry_tag sym_type> struct PolarComplexRandVar {
@@ -145,45 +180,50 @@ template <symmetry_tag sym_type> struct PolarComplexRandVar {
     }
 
     // For sym to sym conversion:
-    // Var(I_Re) ≈ Var(I) * cos^2(θ) + Var(θ) * I^2 * sin^2(θ)
-    // Var(I_Im) ≈ Var(I) * sin^2(θ) + Var(θ) * I^2 * cos^2(θ)
+    // Var(I_Re) ≈ Var(I) * cos^2(θ) + Var(θ) * I^2 * sin^2(θ)                    // first order
+    //             + 1/2 * Var(θ)^2 * I^2 * cos^2(θ) + Var(I) * Var(θ) * sin^2(θ) // second order
+    // Var(I_Im) ≈ Var(I) * sin^2(θ) + Var(θ) * I^2 * cos^2(θ)                    // first order
+    //             + 1/2 * Var(θ)^2 * I^2 * sin^2(θ) + Var(I) * Var(θ) * cos^2(θ) // second order
     // For asym to asym conversion:
-    // Var(I_Re,p) ≈ Var(I_p) * cos^2(θ_p) + Var(θ_p) * I_p^2 * sin^2(θ_p)
-    // Var(I_Im,p) ≈ Var(I_p) * sin^2(θ_p) + Var(θ_p) * I_p^2 * cos^2(θ_p)
+    // Var(I_Re,p) ≈ Var(I_p) * cos^2(θ_p) + Var(θ_p) * I_p^2 * sin^2(θ_p) + 2nd order terms (idem)
+    // Var(I_Im,p) ≈ Var(I_p) * sin^2(θ_p) + Var(θ_p) * I_p^2 * cos^2(θ_p) + 2nd order terms (idem)
     explicit operator DecomposedComplexRandVar<sym>() const {
         auto const cos_theta = cos(angle.value);
         auto const sin_theta = sin(angle.value);
         auto const real_component = magnitude.value * cos_theta;
         auto const imag_component = magnitude.value * sin_theta;
-        return DecomposedComplexRandVar<sym>{
-            .real_component = {.value = real_component,
-                               .variance = magnitude.variance * cos_theta * cos_theta +
-                                           imag_component * imag_component * angle.variance},
-            .imag_component = {.value = imag_component,
-                               .variance = magnitude.variance * sin_theta * sin_theta +
-                                           real_component * real_component * angle.variance}};
+
+        auto const [real_variance, imag_variance] = detail::compute_decomposed_variance_from_polar(
+            magnitude.value, cos_theta, sin_theta, magnitude.variance, angle.variance);
+
+        return DecomposedComplexRandVar<sym>{.real_component = {.value = real_component, .variance = real_variance},
+                                             .imag_component = {.value = imag_component, .variance = imag_variance}};
     }
 
-    // Var(I_Re,p) ≈ Var(I) * cos^2(θ - 2πp/3) + Var(θ) * I^2 * sin^2(θ - 2πp/3)
-    // Var(I_Im,p) ≈ Var(I) * sin^2(θ - 2πp/3) + Var(θ) * I^2 * cos^2(θ - 2πp/3)
+    // Var(I_Re,p) ≈ Var(I) * cos^2(θ - 2πp/3) + Var(θ) * I^2 * sin^2(θ - 2πp/3) + 2nd order terms
+    // Var(I_Im,p) ≈ Var(I) * sin^2(θ - 2πp/3) + Var(θ) * I^2 * cos^2(θ - 2πp/3) + 2nd order terms
     explicit operator DecomposedComplexRandVar<asymmetric_t>() const
         requires(is_symmetric_v<sym>)
     {
-        ComplexValue<asymmetric_t> const unit_complex{exp(1.0i * angle.value)};
+        ComplexValue<asymmetric_t> const unit_complex{exp(1.0i * angle.value)}; // correctly handle phase shifts
         ComplexValue<asymmetric_t> const complex = magnitude.value * unit_complex;
+        RealValue<asymmetric_t> const cos_theta = real(unit_complex);
+        RealValue<asymmetric_t> const sin_theta = imag(unit_complex);
+        RealValue<asymmetric_t> const real_component = real(complex);
+        RealValue<asymmetric_t> const imag_component = imag(complex);
+
+        auto const [real_variance, imag_variance] = detail::compute_decomposed_variance_from_polar(
+            magnitude.value, cos_theta, sin_theta, magnitude.variance, angle.variance);
+
         return DecomposedComplexRandVar<asymmetric_t>{
-            .real_component = {.value = real(complex),
-                               .variance = magnitude.variance * real(unit_complex) * real(unit_complex) +
-                                           imag(complex) * imag(complex) * angle.variance},
-            .imag_component = {.value = imag(complex),
-                               .variance = magnitude.variance * imag(unit_complex) * imag(unit_complex) +
-                                           real(complex) * real(complex) * angle.variance}};
+            .real_component = {.value = real_component, .variance = real_variance},
+            .imag_component = {.value = imag_component, .variance = imag_variance}};
     }
 
     // Var(I_Re) ≈ (1 / 9) * sum_p(Var(I_p) * cos^2(theta_p + 2 * pi * p / 3) + Var(theta_p) * I_p^2 * sin^2(theta_p + 2
-    // * pi * p / 3))
+    // * pi * p / 3)) + 2nd order terms
     // Var(I_Im) ≈ (1 / 9) * sum_p(Var(I_p) * sin^2(theta_p + 2 * pi * p / 3) + Var(theta_p) * I_p^2 *
-    // cos^2(theta_p + 2 * pi * p / 3))
+    // cos^2(theta_p + 2 * pi * p / 3)) + 2nd order terms
     explicit operator DecomposedComplexRandVar<symmetric_t>() const
         requires(is_asymmetric_v<sym>)
     {
@@ -191,19 +231,15 @@ template <symmetry_tag sym_type> struct PolarComplexRandVar {
         ComplexValue<asymmetric_t> const unit_pos_seq_per_phase{unit_complex(0), a * unit_complex(1),
                                                                 a2 * unit_complex(2)};
         DoubleComplex const pos_seq_value = pos_seq(magnitude.value * unit_complex);
+        RealValue<asymmetric_t> const cos_theta = real(unit_pos_seq_per_phase);
+        RealValue<asymmetric_t> const sin_theta = imag(unit_pos_seq_per_phase);
+
+        auto const [real_variance, imag_variance] = detail::compute_decomposed_variance_from_polar(
+            magnitude.value, cos_theta, sin_theta, magnitude.variance, angle.variance);
+
         return DecomposedComplexRandVar<symmetric_t>{
-            .real_component = {.value = real(pos_seq_value),
-                               .variance = sum_val(magnitude.variance * real(unit_pos_seq_per_phase) *
-                                                       real(unit_pos_seq_per_phase) +
-                                                   imag(unit_pos_seq_per_phase) * imag(unit_pos_seq_per_phase) *
-                                                       magnitude.value * magnitude.value * angle.variance) /
-                                           9.0},
-            .imag_component = {
-                .value = imag(pos_seq_value),
-                .variance = sum_val(magnitude.variance * imag(unit_pos_seq_per_phase) * imag(unit_pos_seq_per_phase) +
-                                    real(unit_pos_seq_per_phase) * real(unit_pos_seq_per_phase) * magnitude.value *
-                                        magnitude.value * angle.variance) /
-                            9.0}};
+            .real_component = {.value = real(pos_seq_value), .variance = sum_val(real_variance) / 9.0},
+            .imag_component = {.value = imag(pos_seq_value), .variance = sum_val(imag_variance) / 9.0}};
     }
 };
 
@@ -226,7 +262,7 @@ template <symmetry_tag sym> inline auto conj(PolarComplexRandVar<sym> var) {
 }
 
 namespace statistics {
-// Var(s x) ≈ Var(x) * ||s||²
+// Var(s x) ≈ Var(x) * ||s||^2
 template <symmetry_tag sym, template <symmetry_tag> typename RandVarType>
     requires is_in_list_c<RandVarType<sym>, UniformRealRandVar<sym>, IndependentRealRandVar<sym>,
                           UniformComplexRandVar<sym>, IndependentComplexRandVar<sym>>

{power_grid_model-1.12.50 → power_grid_model-1.12.51}/tests/cpp_unit_tests/test_current_sensor.cpp

@@ -82,11 +82,17 @@ TEST_CASE("Test current sensor") {
                 // Check symmetric sensor output for symmetric parameters
                 CHECK(sym_sensor_param.angle_measurement_type == angle_measurement_type);
                 // Var(I_Re) ≈ Var(I) * cos^2(pi/4) + Var(θ) * I^2 * sin^2(pi/4)
+                //             + (1/2) * Var(θ)^2 * I^2 * cos^2(pi/4) + Var(I) * Var(θ) * sin^2(pi/4)
                 CHECK(sym_sensor_param.measurement.real_component.variance ==
-                      doctest::Approx(0.5 * (i_variance_pu + i_angle_variance_pu * i_pu * i_pu)));
+                      doctest::Approx(0.5 * (i_variance_pu + i_angle_variance_pu * i_pu * i_pu +
+                                             0.5 * i_angle_variance_pu * i_angle_variance_pu * i_pu * i_pu +
+                                             i_variance_pu * i_angle_variance_pu)));
                 // Var(I_Im) ≈ Var(I) * sin^2(pi/4) + Var(θ) * I^2 * cos^2(pi/4)
+                //             + (1/2) * Var(θ)^2 * I^2 * sin^2(pi/4) + Var(I) * Var(θ) * cos^2(pi/4)
                 CHECK(sym_sensor_param.measurement.imag_component.variance ==
-                      doctest::Approx(0.5 * (i_variance_pu + i_angle_variance_pu * i_pu * i_pu)));
+                      doctest::Approx(0.5 * (i_variance_pu + i_angle_variance_pu * i_pu * i_pu +
+                                             0.5 * i_angle_variance_pu * i_angle_variance_pu * i_pu * i_pu +
+                                             i_variance_pu * i_angle_variance_pu)));
                 CHECK(real(sym_sensor_param.measurement.value()) == doctest::Approx(i_pu * cos(i_angle)));
                 CHECK(imag(sym_sensor_param.measurement.value()) == doctest::Approx(i_pu * sin(i_angle)));
 
@@ -114,11 +120,17 @@ TEST_CASE("Test current sensor") {
                 CHECK(asym_sensor_param.angle_measurement_type == angle_measurement_type);
 
                 CHECK(asym_sensor_param.measurement.real_component.variance[0] ==
-                      doctest::Approx(0.5 * (i_variance_pu + i_angle_variance_pu * i_pu * i_pu)));
+                      doctest::Approx(0.5 * (i_variance_pu + i_angle_variance_pu * i_pu * i_pu +
+                                             0.5 * i_angle_variance_pu * i_angle_variance_pu * i_pu * i_pu +
+                                             i_variance_pu * i_angle_variance_pu)));
                 auto const shifted_i_angle = i_angle + deg_240;
-                CHECK(asym_sensor_param.measurement.imag_component.variance[1] ==
-                      doctest::Approx(i_variance_pu * sin(shifted_i_angle) * sin(shifted_i_angle) +
-                                      i_angle_variance_pu * i_pu * i_pu * cos(shifted_i_angle) * cos(shifted_i_angle)));
+                CHECK(
+                    asym_sensor_param.measurement.imag_component.variance[1] ==
+                    doctest::Approx(i_variance_pu * sin(shifted_i_angle) * sin(shifted_i_angle) +
+                                    i_angle_variance_pu * i_pu * i_pu * cos(shifted_i_angle) * cos(shifted_i_angle) +
+                                    0.5 * i_angle_variance_pu * i_angle_variance_pu * i_pu * i_pu *
+                                        sin(shifted_i_angle) * sin(shifted_i_angle) +
+                                    i_variance_pu * i_angle_variance_pu * cos(shifted_i_angle) * cos(shifted_i_angle)));
                 CHECK(real(asym_sensor_param.measurement.value()[0]) == doctest::Approx(i_pu * cos(i_angle)));
                 CHECK(imag(asym_sensor_param.measurement.value()[1]) == doctest::Approx(i_pu * sin(shifted_i_angle)));
 
@@ -162,8 +174,10 @@ TEST_CASE("Test current sensor") {
                     auto const sym_param = sym_current_sensor.calc_param<symmetric_t>();
 
                     CHECK(sym_param.angle_measurement_type == angle_measurement_type);
-                    CHECK(sym_param.measurement.real_component.variance == doctest::Approx(pow(1.0 / base_current, 2)));
-                    CHECK(sym_param.measurement.imag_component.variance == doctest::Approx(pow(0.2 / base_current, 2)));
+                    CHECK(sym_param.measurement.real_component.variance ==
+                          doctest::Approx(pow(1.0 / base_current, 2) * (1.0 + 0.5 * pow(0.2, 4))));
+                    CHECK(sym_param.measurement.imag_component.variance ==
+                          doctest::Approx(pow(1.0 / base_current, 2) * (pow(0.2, 2) + pow(1.0 * 0.2, 2))));
                     CHECK(real(sym_param.measurement.value()) == doctest::Approx(1.0 / base_current));
                     CHECK(imag(sym_param.measurement.value()) == doctest::Approx(0.0 / base_current));
                 }
@@ -174,8 +188,10 @@ TEST_CASE("Test current sensor") {
                     auto const sym_param = sym_current_sensor.calc_param<symmetric_t>();
 
                     CHECK(sym_param.angle_measurement_type == angle_measurement_type);
-                    CHECK(sym_param.measurement.real_component.variance == doctest::Approx(pow(0.2 / base_current, 2)));
-                    CHECK(sym_param.measurement.imag_component.variance == doctest::Approx(pow(1.0 / base_current, 2)));
+                    CHECK(sym_param.measurement.real_component.variance ==
+                          doctest::Approx(pow(1.0 / base_current, 2) * (pow(0.2, 2) + pow(0.2, 2))));
+                    CHECK(sym_param.measurement.imag_component.variance ==
+                          doctest::Approx(pow(1.0 / base_current, 2) * (1.0 + 0.5 * pow(0.2, 4))));
                     CHECK(real(sym_param.measurement.value()) == doctest::Approx(0.0 / base_current));
                     CHECK(imag(sym_param.measurement.value()) == doctest::Approx(1.0 / base_current));
                 }

{power_grid_model-1.12.50 → power_grid_model-1.12.51}/tests/cpp_unit_tests/test_statistics.cpp

@@ -411,9 +411,13 @@ TEST_CASE("Test statistics") {
 
                     CHECK(decomposed.real_component.value == doctest::Approx(polar.magnitude.value));
                     CHECK(decomposed.imag_component.value == doctest::Approx(0.0));
-                    CHECK(decomposed.real_component.variance == doctest::Approx(polar.magnitude.variance));
+                    CHECK(decomposed.real_component.variance ==
+                          doctest::Approx(polar.magnitude.variance +
+                                          0.5 * (polar.magnitude.value * polar.magnitude.value) *
+                                              (polar.angle.variance * polar.angle.variance)));
                     CHECK(decomposed.imag_component.variance ==
-                          doctest::Approx(magnitude * magnitude * polar.angle.variance));
+                          doctest::Approx(magnitude * magnitude * polar.angle.variance +
+                                          polar.magnitude.variance * polar.angle.variance));
                     CHECK(real(decomposed.value()) == doctest::Approx(real(polar.value())));
                     CHECK(imag(decomposed.value()) == doctest::Approx(imag(polar.value())));
                 }
@@ -428,8 +432,12 @@ TEST_CASE("Test statistics") {
                     CHECK(decomposed.real_component.value == doctest::Approx(0.0));
                     CHECK(decomposed.imag_component.value == doctest::Approx(polar.magnitude.value));
                     CHECK(decomposed.real_component.variance ==
-                          doctest::Approx(magnitude * magnitude * polar.angle.variance));
-                    CHECK(decomposed.imag_component.variance == doctest::Approx(polar.magnitude.variance));
+                          doctest::Approx(magnitude * magnitude * polar.angle.variance +
+                                          polar.magnitude.variance * polar.angle.variance));
+                    CHECK(decomposed.imag_component.variance ==
+                          doctest::Approx(polar.magnitude.variance +
+                                          0.5 * (polar.magnitude.value * polar.magnitude.value) *
+                                              (polar.angle.variance * polar.angle.variance)));
                     CHECK(real(decomposed.value()) == doctest::Approx(real(polar.value())));
                     CHECK(imag(decomposed.value()) == doctest::Approx(imag(polar.value())));
                 }
@@ -444,11 +452,34 @@ TEST_CASE("Test statistics") {
 
                     CHECK(decomposed.real_component.value == doctest::Approx(real(uniform.value)));
                     CHECK(decomposed.imag_component.value == doctest::Approx(imag(uniform.value)));
-                    CHECK(decomposed.real_component.variance == doctest::Approx(uniform.variance / 2));
+                    // the following terms break the symmetry between
+                    // - polar -> decomposed -> uniform
+                    // - polar -> independent -> uniform
+                    // note that that is OK because decomposed is a 2D transformation of polar, while
+                    // independent is a radial-only transformation of polar, so it is more stable.
+                    CHECK(decomposed.real_component.variance ==
+                          doctest::Approx(uniform.variance / 2 +
+                                          0.5 * (magnitude * magnitude) * (angle_variance * angle_variance) / 2 +
+                                          magnitude_variance * angle_variance / 2));
                     CHECK(decomposed.imag_component.variance == doctest::Approx(decomposed.real_component.variance));
                     CHECK(real(decomposed.value()) == doctest::Approx(real(polar.value())));
                     CHECK(imag(decomposed.value()) == doctest::Approx(imag(polar.value())));
                 }
+
+                SUBCASE("No magnitude, no angle") {
+                    PolarComplexRandVar<symmetric_t> const polar{
+                        .magnitude = {.value = 0.0, .variance = magnitude_variance},
+                        .angle = {.value = 0.0, .variance = angle_variance}};
+
+                    auto const decomposed = static_cast<DecomposedComplexRandVar<symmetric_t>>(polar);
+
+                    CHECK(decomposed.real_component.value == doctest::Approx(0.0));
+                    CHECK(decomposed.imag_component.value == doctest::Approx(0.0));
+                    CHECK(decomposed.real_component.variance == doctest::Approx(magnitude_variance));
+                    CHECK(decomposed.imag_component.variance == doctest::Approx(magnitude_variance * angle_variance));
+                    CHECK(real(decomposed.value()) == doctest::Approx(0.0));
+                    CHECK(imag(decomposed.value()) == doctest::Approx(0.0));
+                }
             }
         }
         SUBCASE("Conversion to DecomposedComplexRandVar<asymmetric_t>") {
@@ -484,28 +515,50 @@ TEST_CASE("Test statistics") {
                     CHECK(imag(decomposed.value()(2)) == doctest::Approx(imag(three_phase_value(2))));
 
                     // One value of variance to 3 phase
-                    auto const real_variance_a = magnitude_variance * cos(shift) * cos(shift) +
-                                                 magnitude * magnitude * sin(shift) * sin(shift) * angle_variance;
+                    auto const real_variance_a =
+                        magnitude_variance * cos(shift) * cos(shift) +
+                        magnitude * magnitude * sin(shift) * sin(shift) * angle_variance +
+                        0.5 * (magnitude * magnitude) * (angle_variance * angle_variance) * cos(shift) * cos(shift) +
+                        (magnitude_variance * angle_variance) * sin(shift) * sin(shift);
                     CHECK(decomposed.real_component.variance(0) == doctest::Approx(real_variance_a));
+
                     auto const real_variance_b =
                         magnitude_variance * cos(shift - deg_120) * cos(shift - deg_120) +
-                        magnitude * magnitude * sin(shift - deg_120) * sin(shift - deg_120) * angle_variance;
+                        magnitude * magnitude * sin(shift - deg_120) * sin(shift - deg_120) * angle_variance +
+                        0.5 * (magnitude * magnitude) * (angle_variance * angle_variance) * cos(shift - deg_120) *
+                            cos(shift - deg_120) +
+                        (magnitude_variance * angle_variance) * sin(shift - deg_120) * sin(shift - deg_120);
                     CHECK(decomposed.real_component.variance(1) == doctest::Approx(real_variance_b));
+
                     auto const real_variance_c =
                         magnitude_variance * cos(shift - deg_240) * cos(shift - deg_240) +
-                        magnitude * magnitude * sin(shift - deg_240) * sin(shift - deg_240) * angle_variance;
+                        magnitude * magnitude * sin(shift - deg_240) * sin(shift - deg_240) * angle_variance +
+                        0.5 * (magnitude * magnitude) * (angle_variance * angle_variance) * cos(shift - deg_240) *
+                            cos(shift - deg_240) +
+                        (magnitude_variance * angle_variance) * sin(shift - deg_240) * sin(shift - deg_240);
                     CHECK(decomposed.real_component.variance(2) == doctest::Approx(real_variance_c));
 
-                    auto const imag_variance_a = magnitude_variance * sin(shift) * sin(shift) +
-                                                 magnitude * magnitude * cos(shift) * cos(shift) * angle_variance;
+                    auto const imag_variance_a =
+                        magnitude_variance * sin(shift) * sin(shift) +
+                        magnitude * magnitude * cos(shift) * cos(shift) * angle_variance +
+                        0.5 * (magnitude * magnitude) * (angle_variance * angle_variance) * sin(shift) * sin(shift) +
+                        (magnitude_variance * angle_variance) * cos(shift) * cos(shift);
                     CHECK(decomposed.imag_component.variance(0) == doctest::Approx(imag_variance_a));
+
                     auto const imag_variance_b =
                         magnitude_variance * sin(shift - deg_120) * sin(shift - deg_120) +
-                        magnitude * magnitude * cos(shift - deg_120) * cos(shift - deg_120) * angle_variance;
+                        magnitude * magnitude * cos(shift - deg_120) * cos(shift - deg_120) * angle_variance +
+                        0.5 * (magnitude * magnitude) * (angle_variance * angle_variance) * sin(shift - deg_120) *
+                            sin(shift - deg_120) +
+                        (magnitude_variance * angle_variance) * cos(shift - deg_120) * cos(shift - deg_120);
                     CHECK(decomposed.imag_component.variance(1) == doctest::Approx(imag_variance_b));
+
                     auto const imag_variance_c =
                         magnitude_variance * sin(shift - deg_240) * sin(shift - deg_240) +
-                        magnitude * magnitude * cos(shift - deg_240) * cos(shift - deg_240) * angle_variance;
+                        magnitude * magnitude * cos(shift - deg_240) * cos(shift - deg_240) * angle_variance +
+                        0.5 * (magnitude * magnitude) * (angle_variance * angle_variance) * sin(shift - deg_240) *
+                            sin(shift - deg_240) +
+                        (magnitude_variance * angle_variance) * cos(shift - deg_240) * cos(shift - deg_240);
                     CHECK(decomposed.imag_component.variance(2) == doctest::Approx(imag_variance_c));
                 }
             }
@@ -671,27 +724,48 @@ TEST_CASE("Test statistics") {
 
                     // One value of variance to 3 phase
                     auto const real_variance_a = magnitude_variance * cos(shift) * cos(shift) +
-                                                 magnitude_a * magnitude_a * sin(shift) * sin(shift) * angle_variance;
+                                                 magnitude_a * magnitude_a * sin(shift) * sin(shift) * angle_variance +
+                                                 0.5 * (magnitude_a * magnitude_a) * (angle_variance * angle_variance) *
+                                                     cos(shift) * cos(shift) +
+                                                 (magnitude_variance * angle_variance) * sin(shift) * sin(shift);
                     CHECK(decomposed.real_component.variance(0) == doctest::Approx(real_variance_a));
+
                     auto const real_variance_b =
                         magnitude_variance * cos(deg_240 + shift) * cos(deg_240 + shift) +
-                        magnitude_b * magnitude_b * sin(deg_240 + shift) * sin(deg_240 + shift) * angle_variance;
+                        magnitude_b * magnitude_b * sin(deg_240 + shift) * sin(deg_240 + shift) * angle_variance +
+                        0.5 * (magnitude_b * magnitude_b) * (angle_variance * angle_variance) * cos(deg_240 + shift) *
+                            cos(deg_240 + shift) +
+                        (magnitude_variance * angle_variance) * sin(deg_240 + shift) * sin(deg_240 + shift);
                     CHECK(decomposed.real_component.variance(1) == doctest::Approx(real_variance_b));
                     auto const real_variance_c =
                         magnitude_variance * cos(deg_120 + shift) * cos(deg_120 + shift) +
-                        magnitude_c * magnitude_c * sin(deg_120 + shift) * sin(deg_120 + shift) * angle_variance;
+                        magnitude_c * magnitude_c * sin(deg_120 + shift) * sin(deg_120 + shift) * angle_variance +
+                        0.5 * (magnitude_c * magnitude_c) * (angle_variance * angle_variance) * cos(deg_120 + shift) *
+                            cos(deg_120 + shift) +
+                        (magnitude_variance * angle_variance) * sin(deg_120 + shift) * sin(deg_120 + shift);
                     CHECK(decomposed.real_component.variance(2) == doctest::Approx(real_variance_c));
 
                     auto const imag_variance_a = magnitude_variance * sin(shift) * sin(shift) +
-                                                 magnitude_a * magnitude_a * cos(shift) * cos(shift) * angle_variance;
+                                                 magnitude_a * magnitude_a * cos(shift) * cos(shift) * angle_variance +
+                                                 0.5 * (magnitude_a * magnitude_a) * (angle_variance * angle_variance) *
+                                                     sin(shift) * sin(shift) +
+                                                 (magnitude_variance * angle_variance) * cos(shift) * cos(shift);
                     CHECK(decomposed.imag_component.variance(0) == doctest::Approx(imag_variance_a));
+
                     auto const imag_variance_b =
                         magnitude_variance * sin(deg_240 + shift) * sin(deg_240 + shift) +
-                        magnitude_b * magnitude_b * cos(deg_240 + shift) * cos(deg_240 + shift) * angle_variance;
+                        magnitude_b * magnitude_b * cos(deg_240 + shift) * cos(deg_240 + shift) * angle_variance +
+                        0.5 * (magnitude_b * magnitude_b) * (angle_variance * angle_variance) * sin(deg_240 + shift) *
+                            sin(deg_240 + shift) +
+                        (magnitude_variance * angle_variance) * cos(deg_240 + shift) * cos(deg_240 + shift);
                     CHECK(decomposed.imag_component.variance(1) == doctest::Approx(imag_variance_b));
+
                     auto const imag_variance_c =
                         magnitude_variance * sin(deg_120 + shift) * sin(deg_120 + shift) +
-                        magnitude_c * magnitude_c * cos(deg_120 + shift) * cos(deg_120 + shift) * angle_variance;
+                        magnitude_c * magnitude_c * cos(deg_120 + shift) * cos(deg_120 + shift) * angle_variance +
+                        0.5 * (magnitude_c * magnitude_c) * (angle_variance * angle_variance) * sin(deg_120 + shift) *
+                            sin(deg_120 + shift) +
+                        (magnitude_variance * angle_variance) * cos(deg_120 + shift) * cos(deg_120 + shift);
                     CHECK(decomposed.imag_component.variance(2) == doctest::Approx(imag_variance_c));
                 }
             }
@@ -725,22 +799,24 @@ TEST_CASE("Test statistics") {
                     CHECK(imag(decomposed.value()) == doctest::Approx(imag(pos_seq_value)));
 
                     // One value of variance to 3 phase
-                    auto const real_variance = (magnitude_variance * cos(shift) * cos(shift) +
-                                                magnitude_a * magnitude_a * sin(shift) * sin(shift) * angle_variance +
-                                                magnitude_variance * cos(shift) * cos(shift) +
-                                                magnitude_b * magnitude_b * sin(shift) * sin(shift) * angle_variance +
-                                                magnitude_variance * cos(shift) * cos(shift) +
-                                                magnitude_c * magnitude_c * sin(shift) * sin(shift) * angle_variance) /
-                                               9.0;
+                    auto const real_variance =
+                        ((3 * magnitude_variance * cos(shift) * cos(shift)) +
+                         ((magnitude_a * magnitude_a + magnitude_b * magnitude_b + magnitude_c * magnitude_c) *
+                          sin(shift) * sin(shift) * angle_variance) +
+                         0.5 * ((magnitude_a * magnitude_a + magnitude_b * magnitude_b + magnitude_c * magnitude_c) *
+                                cos(shift) * cos(shift) * angle_variance * angle_variance) +
+                         (3 * magnitude_variance * angle_variance * sin(shift) * sin(shift))) /
+                        9.0;
                     CHECK(decomposed.real_component.variance == doctest::Approx(real_variance));
 
-                    auto const imag_variance = (magnitude_variance * sin(shift) * sin(shift) +
-                                                magnitude_a * magnitude_a * cos(shift) * cos(shift) * angle_variance +
-                                                magnitude_variance * sin(shift) * sin(shift) +
-                                                magnitude_b * magnitude_b * cos(shift) * cos(shift) * angle_variance +
-                                                magnitude_variance * sin(shift) * sin(shift) +
-                                                magnitude_c * magnitude_c * cos(shift) * cos(shift) * angle_variance) /
-                                               9.0;
+                    auto const imag_variance =
+                        ((3 * magnitude_variance * sin(shift) * sin(shift)) +
+                         ((magnitude_a * magnitude_a + magnitude_b * magnitude_b + magnitude_c * magnitude_c) *
+                          cos(shift) * cos(shift) * angle_variance) +
+                         0.5 * ((magnitude_a * magnitude_a + magnitude_b * magnitude_b + magnitude_c * magnitude_c) *
+                                sin(shift) * sin(shift) * angle_variance * angle_variance) +
+                         (3 * magnitude_variance * angle_variance * cos(shift) * cos(shift))) /
+                        9.0;
                     CHECK(decomposed.imag_component.variance == doctest::Approx(imag_variance));
                 }
             }

power_grid_model-1.12.50/VERSION

@@ -1 +0,0 @@
-1.12.50