Merge pull request #37 from opusonesolutions/tape-shield-cable

Support Tape-shielded cables

Author: andace

README.md

@@ -212,7 +212,51 @@ class Cable:
 For examples of how to use the model, see the [multi-conductor cable
 tests](https://github.com/opusonesolutions/carsons/blob/master/tests/test_multi_conductor.py).
 
-Problem Description
+
+### Tape Shield Cable
+
+`carsons` also supports modelling of tape shield cables of any
+phasings. Its usage is very similar to the example above, only requiring
+a few more parameters about the tape shield conductors in the line model
+object.
+
+```python
+from carsons import (TapeShieldedCableCarsonsEquations,
+                     calculate_impedance)
+
+class Cable:
+   resistance: {
+       'A': per-length resistance of conductor A in ohm/meters
+       ...
+   }
+   geometric_mean_radius: {
+       'A': geometric mean radius of conductor A in meters
+       ...
+   }
+   wire_positions: {
+        'A': (x, y) cross-sectional position of conductor A in meters
+        ...
+   }
+   phases: {'A', ... }
+   tape_shield_thickness: {
+       'A': thickness of tape shield conductor on phase A cable in meters
+       ...
+   }
+   tape_shield_outer_diameter: {
+       'A': outer diameter of tape shield conductor on phase A cable in meters
+       ...
+   }
+   
+
+cable_impedance = calculate_impedance(TapeShieldedCableCarsonsEquations(Cable()))
+```
+
+For examples of how to use the model, see the [tape shielded cable
+tests](https://github.com/opusonesolutions/carsons/blob/master/tests/test_tape_shielded_cables.py).
+
+
+
+## Problem Description
 -------------------
 
 Carsons equations model an AC transmission or distribution line into an

carsons/__init__.py

@@ -4,6 +4,7 @@
                              calculate_sequence_impedances,
                              CarsonsEquations,
                              ConcentricNeutralCarsonsEquations,     # noqa 401
-                             MultiConductorCarsonsEquations)        # noqa 401
+                             MultiConductorCarsonsEquations,        # noqa 401
+                             TapeShieldedCableCarsonsEquations)        # noqa 401
 
 name = "carsons"

carsons/carsons.py

@@ -311,6 +311,67 @@ def GMR_cn(self, phase) -> float:
         return (GMR_s * k * R**(k-1))**(1/k)
 
 
+class TapeShieldedCableCarsonsEquations(ModifiedCarsonsEquations):
+
+    ρ_tape_shield = 1.7721e-8  # copper resistivity at 20 degrees, ohm-meter
+
+    def __init__(self, model, *args, **kwargs):
+        super().__init__(model)
+        self.ds = model.tape_shield_outer_diameter
+        self.thickness = model.tape_shield_thickness
+
+        self.phases.extend(
+            f'{ph}t' for ph in model.tape_shield_outer_diameter.keys()
+        )
+
+        self.r.update({
+            f'{ph}t': self.compute_shield_r(self.ds[ph], self.thickness[ph])
+            for ph in model.tape_shield_outer_diameter.keys()
+        })
+
+        self.gmr.update({
+            f'{ph}t': self.compute_shield_gmr(self.ds[ph], self.thickness[ph])
+            for ph in model.tape_shield_outer_diameter.keys()
+        })
+
+        # set shield position to be the same as its phase conductor position
+        tape_shield_positions = {
+            f'{ph}t': self.phase_positions[ph]
+            for ph in model.tape_shield_outer_diameter.keys()
+        }
+        self.phase_positions.update(tape_shield_positions)
+
+    @staticmethod
+    def compute_shield_gmr(ds, thickness) -> float:
+        return (ds - thickness) / 2
+
+    @classmethod
+    def compute_shield_r(cls, ds, thickness) -> float:
+        area = (π*(ds/2)**2) - (π*(ds/2 - thickness)**2)
+        return cls.ρ_tape_shield/area
+
+    def compute_d(self, i, j) -> float:
+        I, J = set(i), set(j)
+
+        one_tape_shield_same_phase = I ^ J == set('t')
+
+        if one_tape_shield_same_phase:
+            return self.gmr[i] if 't' in i else self.gmr[j]
+        else:
+            return super().compute_d(i, j)
+
+    @property
+    def conductors(self):
+        neutral_conductors = sorted([
+            ph for ph in self.phases if ph.startswith("N")
+        ])
+        shield_conductors = sorted([
+            ph for ph in self.phases if ph.endswith("t")
+        ])
+
+        return ['A', 'B', 'C'] + shield_conductors + neutral_conductors
+
+
 class MultiConductorCarsonsEquations(ModifiedCarsonsEquations):
     def __init__(self, model):
         super().__init__(model)

tests/test_tape_shielded_cables.py

@@ -0,0 +1,107 @@
+from numpy import array
+from numpy.testing import assert_array_almost_equal
+
+from carsons.carsons import (
+    TapeShieldedCableCarsonsEquations,
+    calculate_impedance,
+)
+from tests.test_overhead_line import OHM_PER_MILE_TO_OHM_PER_METER
+from tests.test_concentric_neutral_cable import ureg, feet, inches, miles, ohms
+
+mils = ureg.mil_length
+
+
+class AN_Tape_Shielded_Cable:
+    def __init__(self, n_pos):
+        # parametrize with position of n-phase conductor
+        if n_pos:
+            self.n_pos = n_pos
+
+    @property
+    def resistance(self):
+        return {
+            "A": (0.97 * (ohms / miles)).to("ohm / meters").magnitude,
+            "N": (0.607 * (ohms / miles)).to("ohm / meters").magnitude,
+        }
+
+    @property
+    def geometric_mean_radius(self):
+        return {
+            "A": (0.0111 * feet).to("meters").magnitude,
+            "N": (0.01113 * feet).to("meters").magnitude,
+        }
+
+    @property
+    def wire_positions(self):
+        return {
+            "A": (0, 0),
+            "N": ((self.n_pos * inches).to("meters").magnitude, 0),
+        }
+
+    @property
+    def tape_shield_outer_diameter(self):
+        return {
+            "A": (0.88 * inches).to("meters").magnitude,
+        }
+
+    @property
+    def tape_shield_thickness(self):
+        return {
+            "A": (5 * mils).to("meters").magnitude,
+        }
+
+    @property
+    def phases(self):
+        return [
+            "A",
+            "N",
+        ]
+
+
+def test_single_phase_tape_shield_with_neutral_Keirsting():
+    # Example 4.4, Kiersting, Distribution System Modelling and Analysis
+    # 4th Ed, Taylor&Francis, 2018
+
+    n_pos = 3  # n phase conductor placed 3 inches away from phase cond
+
+    tape_shielded_cable = TapeShieldedCableCarsonsEquations(
+        AN_Tape_Shielded_Cable(n_pos)
+    )
+    assert_array_almost_equal(
+        calculate_impedance(tape_shielded_cable),
+        array(
+            [
+                #  Kersting example has:
+                #  [1.3218 + 1j * 0.6744, ...]
+                #  but we think this is due to a numerical error in
+                #  the calculation of the tape shield resistivity
+                [1.3325 + 1j * 0.6458, 0.0 + 1j * 0.0, 0 + 1j * 0],
+                [0 + 1j * 0, 0 + 1j * 0, 0 + 1j * 0],
+                [0 + 1j * 0, 0 + 1j * 0, 0 + 1j * 0],
+            ]
+        )
+        * OHM_PER_MILE_TO_OHM_PER_METER,
+        decimal=5,
+    )
+
+
+def test_single_phase_tape_shield_with_neutral_IEEE13():
+    # Cable config #607, defined in IEEE13 test feeder
+    # https://cmte.ieee.org/pes-testfeeders/resources/
+    n_pos = 1  # n phase conductor placed 3 inches away from phase cond
+
+    tape_shielded_cable = TapeShieldedCableCarsonsEquations(
+        AN_Tape_Shielded_Cable(n_pos)
+    )
+    assert_array_almost_equal(
+        calculate_impedance(tape_shielded_cable),
+        array(
+            [
+                [1.3425 + 1j * 0.5124, 0.0 + 1j * 0.0, 0 + 1j * 0],
+                [0 + 1j * 0, 0 + 1j * 0, 0 + 1j * 0],
+                [0 + 1j * 0, 0 + 1j * 0, 0 + 1j * 0],
+            ]
+        )
+        * OHM_PER_MILE_TO_OHM_PER_METER,
+        decimal=5,
+    )