Merge pull request #41 from bluejuniper/master

Calculate sequence impedances

Author: AnjoMan

.gitignore

@@ -1,2 +1,6 @@
 .pytest_cache/
+.mypy_cache/
 */__pycache__/
+
+.coverage
+carsons.code-workspace

carsons/__init__.py

@@ -1,5 +1,8 @@
 from carsons.carsons import (convert_geometric_model,               # noqa 401
                              calculate_impedance,                   # noqa 401
+                             calculate_sequence_impedance_matrix,
+                             calculate_sequence_impedances,
+                             CarsonsEquations,
                              ConcentricNeutralCarsonsEquations,     # noqa 401
                              MultiConductorCarsonsEquations)        # noqa 401
 

carsons/carsons.py

@@ -2,11 +2,25 @@
 from itertools import islice
 from typing import Dict, Iterable, Iterator, Tuple
 
-from numpy import arctan, cos, log, sin, sqrt, zeros
-from numpy import ndarray
+from numpy import arctan, cos, log, sin, sqrt, zeros, exp
+from numpy import array, ndarray
 from numpy import pi as π
 from numpy.linalg import inv
 
+alpha = exp(2j*π/3)
+
+A = array([
+            [1, 1, 1],
+            [1, alpha**2, alpha],
+            [1, alpha, alpha**2],
+])
+
+Ainv = (1/3)*array([
+                [1, 1, 1],
+                [1, alpha, alpha**2],
+                [1, alpha**2, alpha],
+])
+
 
 def convert_geometric_model(geometric_model) -> ndarray:
     carsons_model = CarsonsEquations(geometric_model)
@@ -65,6 +79,15 @@ def perform_kron_reduction(z_primitive: ndarray, dimension=3) -> ndarray:
     return Z_abc
 
 
+def calculate_sequence_impedance_matrix(Z):
+    return Ainv @ Z @ A
+
+
+def calculate_sequence_impedances(Z):
+    Z012 = calculate_sequence_impedance_matrix(Z)
+    return Z012[1, 1], Z012[0, 0]
+
+
 class CarsonsEquations():
 
     ρ = 100  # resistivity, ohms/meter^3

tests/test_carsons.py

@@ -4,6 +4,8 @@
 from carsons.carsons import (
     CarsonsEquations,
     perform_kron_reduction,
+    calculate_sequence_impedance_matrix,
+    calculate_sequence_impedances,
 )
 from tests.test_overhead_line import (
     ACBN_geometry_line,
@@ -136,6 +138,32 @@ def expected_z_abc_three_neutrals():
                 [-14 + 0j, -14 + 0j, -13 + 0j]])
 
 
+def z_abc_kersting_4_1():
+    """Kron-reduced impedance matrix from Kersting 3rd Ed., ex. 4.1"""
+    return array([
+                [0.4576+1.078j, 0.1560+0.5017j, 0.1535+0.3849j],
+                [0.1560+0.5017j, 0.4666+1.*1.0482j, 0.1580+0.4236j],
+                [0.1535+0.3849j, 0.1580+0.4236j, 0.4615+1.0651j]])
+
+
+def z_012_kersting_4_1():
+    """Sequence impedance matrix from Kersting 3rd Ed., ex. 4.1"""
+    return array([
+                [0.7735+1.9373j, 0.0256+0.0115j, -0.0321+0.0159j],
+                [-0.0321+0.0159j, 0.3061+0.6270j, -0.0723-0.0060j],
+                [0.0256+0.0115j, 0.0723-0.0059j, 0.3061+0.6270j]])
+
+
+def z_1_kersting_4_1():
+    """Positive-sequence impedance from Kersting 3rd Ed., ex. 4.1"""
+    return 0.3061 + 0.6270j
+
+
+def z_0_kersting_4_1():
+    """Zero-sequence impedance from Kersting 3rd Ed., ex. 4.1"""
+    return 0.7735 + 1.9373j
+
+
 @pytest.mark.parametrize(
     "line,z_primitive_expected",
     [(ACBN_geometry_line(), ACBN_line_z_primitive()),
@@ -169,3 +197,22 @@ def test_balanced_carsons_equations(line, z_primitive_expected):
 def test_kron_reduction(z_primitive, expected_z_abc):
     actual_z_abc = perform_kron_reduction(z_primitive)
     assert (actual_z_abc == expected_z_abc).all()
+
+
+@pytest.mark.parametrize(
+    "z_abc,z_012_expected",
+    [(z_abc_kersting_4_1(), z_012_kersting_4_1())])
+def test_sequence_impedance_matrix(z_abc, z_012_expected):
+    z_012_computed = calculate_sequence_impedance_matrix(z_abc)
+    assert_array_almost_equal(z_012_expected, z_012_computed, decimal=0.001)
+
+
+@pytest.mark.parametrize(
+    "z_abc,expected_z1,expected_z0",
+    [(z_abc_kersting_4_1(), z_1_kersting_4_1(), z_0_kersting_4_1())])
+def test_sequence_impedance(z_abc, expected_z1, expected_z0):
+    actual_z1, actual_z0 = calculate_sequence_impedances(z_abc)
+    assert actual_z1.real == pytest.approx(expected_z1.real, 0.001)
+    assert actual_z1.imag == pytest.approx(expected_z1.imag, 0.001)
+    assert actual_z0.real == pytest.approx(expected_z0.real, 0.001)
+    assert actual_z0.imag == pytest.approx(expected_z0.imag, 0.001)