address comments

Author: andace

carsons/carsons.py

@@ -320,56 +320,35 @@ def __init__(self, model, *args, **kwargs):
         self.ds = model.tape_shield_outer_diameter
         self.thickness = model.tape_shield_thickness
 
-        self.tape_shield_phases = model.tape_shield_outer_diameter.keys()
+        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 self.tape_shield_phases
+            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 self.tape_shield_phases
+            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 self.tape_shield_phases
+            for ph in model.tape_shield_outer_diameter.keys()
         }
         self.phase_positions.update(tape_shield_positions)
 
-    def build_z_primitive(self) -> ndarray:
-        neutral_conductors = sorted([
-            ph for ph in self.phases
-            if ph.startswith("N")
-        ])
-        shield_conductors = sorted([
-            f'{ph}t' for ph in self.tape_shield_phases])
-
-        conductors = ['A', 'B', 'C'] + shield_conductors + neutral_conductors
-
-        dimension = len(conductors)
-        z_primitive = zeros(shape=(dimension, dimension), dtype=complex)
-
-        for index_i, phase_i in enumerate(conductors):
-            for index_j, phase_j in enumerate(conductors):
-                if phase_i.strip('t') not in self.phases \
-                        or phase_j.strip('t') not in self.phases:
-                    continue
-                R = self.compute_R(phase_i, phase_j)
-                X = self.compute_X(phase_i, phase_j)
-                z_primitive[index_i, index_j] = complex(R, X)
-
-        return z_primitive
-
     @staticmethod
     def compute_shield_gmr(ds, thickness) -> float:
         return (ds - thickness) / 2
 
-    def compute_shield_r(self, ds, thickness) -> float:
+    @classmethod
+    def compute_shield_r(cls, ds, thickness) -> float:
         area = (π*(ds/2)**2) - (π*(ds/2 - thickness)**2)
-        return self.ρ_tape_shield/area
+        return cls.ρ_tape_shield/area
 
     def compute_d(self, i, j) -> float:
         I, J = set(i), set(j)
@@ -379,22 +358,18 @@ def compute_d(self, i, j) -> float:
         if one_tape_shield_same_phase:
             return self.gmr[i] if 't' in i else self.gmr[j]
         else:
-            return self.calculate_distance(self.phase_positions[i],
-                                           self.phase_positions[j])
+            return super().compute_d(i, j)
 
-    def compute_X(self, i, j) -> float:
-        Q_first_term = super().compute_Q(i, j, 1)
-
-        # Simplify equations and don't compute Dᵢⱼ explicitly
-        kᵢⱼ_Dᵢⱼ_ratio = sqrt(self.ω * self.μ / self.ρ)
-        ΔX = Q_first_term * 2 + log(2)
-
-        if i == j:
-            X_o = -log(self.gmr[i]) - log(kᵢⱼ_Dᵢⱼ_ratio)
-        else:
-            X_o = -log(self.compute_d(i, j)) - log(kᵢⱼ_Dᵢⱼ_ratio)
+    @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 (X_o + ΔX) * self.ω * self.μ / (2 * π)
+        return ['A', 'B', 'C'] + shield_conductors + neutral_conductors
 
 
 class MultiConductorCarsonsEquations(ModifiedCarsonsEquations):

tests/test_tape_shielded_cables.py

@@ -61,8 +61,6 @@ def phases(self):
 def test_single_phase_tape_shield_with_neutral_Keirsting():
     # Example 4.4, Kiersting, Distribution System Modelling and Analysis
     # 4th Ed, Taylor&Francis, 2018
-    # small numerical error found in solution to Kersting example
-    # and is adjusted for here
 
     n_pos = 3  # n phase conductor placed 3 inches away from phase cond
 
@@ -73,6 +71,10 @@ def test_single_phase_tape_shield_with_neutral_Keirsting():
         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],