3. Engineering The Physics (Network Classes)

Behind the simple interface lies a rigorous physical model. The project programmed the geometric derivation of transmission line parameters using custom LineCode and LineGeometry classes.

3.1 Spatial Geometry & H-Frame Analysis

The system models the TH-230 H-Frame structure by processing the exact Cartesian coordinates of phases A, B, and C. The coordinates were set to 0ft, 19.5ft, and 39ft respectively. These vectors were utilized to calculate the Geometric Mean Distance (GMD), ensuring that the mutual inductance between phases was accurately represented in the impedance matrix.

Fig 3.1: TH-230 H-Frame Geometry used for GMD Calculation.

3.2 Bundled Conductor Physics

To simulate a real-world high-voltage corridor, the project modeled ACSR Partridge conductors in bundles of two per phase with 1.5' spacing. This specific configuration required manual calculation of the "Bundled GMR" to account for the reduced inductive reactance.

• Self-GMR Derivation: Extracted the manufacturer's GMR (0.0217 ft) and applied the GMR adjustment factor for internal flux linkage.
• Bundling Logic: Programmed a geometric solver to compute the equivalent DSL based on the 1.5ft spacing.
• Thermal Policing: Integrated the ampacity limit (460A per sub-conductor) into the code to automatically flag thermal violations during load flow.

class LineGeometry:
    def __init__(self, num_bundles, bundle_spacing, a1, a2, b1, b2, c1, c2, units='feet'):
        # Calculate phase distances
        self.Dab = self.distance(a1, a2, b1, b2)
        self.Dbc = self.distance(b1, b2, c1, c2)
        self.Dca = self.distance(c1, c2, a1, a2)
        
        # Calculate Equivalent Geometric Mean Distance
        self.Deq = (self.Dab * self.Dbc * self.Dca) ** (1.0 / 3)

5. Newton-Raphson Solver Development

The core computational challenge was solving the Power Flow problem. Unlike linear circuits, power grids are governed by non-linear algebraic equations. The project engineered an iterative Newton-Raphson Solver to find the system state.

5.1 Jacobian Matrix Linearization

The software manually derived and programmed the partial derivatives for the 4-quadrant Jacobian Matrix (J1, J2, J3, J4). This matrix serves as the sensitivity map of the grid, relating power mismatches to voltage changes.

• Mismatch Tracking: Implemented real-time tracking of Real and Reactive power with a convergence tolerance of 0.0001 pu.
• Bus Classification: Programmed the engine to dynamically handle Slack (Bus 1), PQ (Load), and PV (Generator) nodes.
• Reactive Policing: Added logic to check if the PV generator (Bus 7) exceeded its reactive limits, switching it to PQ mode if necessary.

def Newton_Raphson_method(self):
    # Iterative solver loop
    while max_mismatch > self.tolerance:
        # Calculate P and Q mismatches
        P_mismatch, Q_mismatch = self.calculate_mismatches()
        
        # Build 4-Quadrant Jacobian
        J1 = self.calculate_J1()
        J2 = self.calculate_J2()
        J3 = self.calculate_J3()
        J4 = self.calculate_J4()
        
        # Solve for delta Voltage and Angle
        correction = np.linalg.solve(Jacobian, mismatch_vector)

6. Short Circuit & Fault Analysis

The final phase moved the simulator from steady-state analysis to Sub-transient Fault Analysis. This is critical for protection engineering, as asymmetrical faults are the most common grid disturbances.

6.1 Sequence Network Decoupling

The system utilized Symmetrical Component Theory to decouple the grid into three separate networks: Positive, Negative, and Zero sequence.

• Generator Modeling: Modeled the sub-transient reactance for generators.
• Zero Sequence Logic: This was the most complex step. The system accounted for the grounding impedance (1 Ohm) at Bus 7 and the Delta-Wye isolation of the transformers, which alters the zero-sequence path.

6.2 Z-Bus Inversion & Voltage Dip

The project implemented a Z-Bus Matrix Inversion routine. By inverting the faulted Y-Bus matrix, the system obtained the Thevenin equivalent impedance at the fault location to calculate the exact fault current and the resulting voltage dip across the grid.

def calculate_fault_current(self, pre_fault_v, z_bus_fault):
    # Calculate fault current using Thevenin Impedance
    fault_current = pre_fault_v / z_bus_fault.iloc[fault_idx, fault_idx]
    
    # Calculate voltage drop across grid
    voltage_drop = np.matmul(z_bus_fault.values, fault_current)
    post_fault_v = pre_fault_v - voltage_drop
    return post_fault_v

7. Industrial Validation Audit

The project is only valid if verified. A comprehensive Validation Audit was conducted against the industry-standard PowerWorld Simulator v22.

7.1 Methodology

An identical 7-node model was built in PowerWorld to run the same load flow and fault scenarios. The raw data was extracted, and a variance analysis was performed against the Python engine's output. The video on the right demonstrates this live benchmarking process.