Comparative Study of Load-Flow Algorithms on IEEE Bus Systems with an Indian Grid Context

Load flow is the single most executed calculation in power system planning and operation, and three classical algorithms still underpin it: Gauss-Seidel, Newton-Raphson (NR) and the fast decoupled (FD) method. This dissertation implements all three from first principles in Python with NumPy, runs them on the standard IEEE 14, 30, 57 and 118-bus test systems obtained from the University of Washington Power Systems Test Case Archive, and compares them under declared metrics: iterations to a stated tolerance, wall-clock time per solution, final power mismatch, memory pattern of the Jacobian, and robustness under stress.

Two experiments take the study beyond a textbook exercise. First, a loading scale-up raises every system's load in steps until each algorithm stops converging, mapping each method's practical stability region. Second, a high R/X stress test perturbs line parameters to emulate the high resistance-to-reactance ratios typical of Indian 11 kV and 33 kV rural distribution feeders — exactly the networks where the decoupling assumptions behind the FD method are known to strain, and where Indian state utilities still run daily power-flow studies.

Every implementation is cross-validated against pandapower and MATPOWER published solution results (bus voltages within 0.0001 per-unit, angles within 0.01 degrees) before any comparison is trusted. The discussion chapter ties the findings to Indian grid practice — CEA planning criteria, Grid-India's demand-met data volumes, and the daily study cycles of state load dispatch centres. The result is a lab-safe, zero-hardware, fully reproducible dissertation in the classic measurement-study mould expected of Project Work Phase-2.

Power engineers routinely choose a load-flow solver without being able to justify the choice numerically. Gauss-Seidel survives in teaching and in some distribution tools; Newton-Raphson is the default of modern packages; the fast decoupled method still runs in daily utility studies — yet typical academic exposure amounts to one hand-worked three-bus example and a table of iteration counts copied from a textbook, with no declared tolerance, no cross-validation and no sense of where each algorithm breaks down.

The gap is sharper in the Indian context: rural 11 kV and 33 kV feeders commonly exhibit high R/X ratios that violate the assumptions behind fast decoupled load flow, but the consequence is rarely demonstrated numerically on a standard benchmark. There is a need for a rigorous, reproducible comparison that (a) implements the three algorithms from first principles, (b) cross-validates them against established open-source solvers with declared tolerances, (c) measures convergence, speed, robustness and stress behaviour on the IEEE 14/30/57/118-bus systems, and (d) translates the measured results into guidance for transmission and distribution practice, including high R/X feeder studies of the kind common in Indian state utilities.

Abstract

Every planning decision on a power network — where to add generation, whether a feeder can carry a new load, what happens when a line trips — begins with a load-flow solution. Three classical iterative algorithms dominate: Gauss-Seidel (simple, slow), Newton-Raphson (quadratic convergence, per-iteration cost) and the fast decoupled method (approximate Jacobians, the workhorse of daily utility studies). This dissertation implements the three from scratch in Python, validates them against established open-source solvers, and measures their convergence, speed, robustness and stress behaviour on the IEEE 14, 30, 57 and 118-bus standard test systems, closing with an Indian-grid discussion of when each method is the right tool.

Introduction

Indian power system practice runs on load flow: state load dispatch centres and transmission utilities execute study after study for scheduling, expansion planning and outage assessment, distribution engineers run feeder studies on networks whose lines often have high R/X ratios very different from transmission practice, and CEA's planning criteria assume such studies underpin every proposal. An engineer who has implemented the algorithms, not merely invoked them, understands why a study converges or fails — knowledge this dissertation builds deliberately.

Existing work and the gap

• The founding papers (Tinney and Hart 1967 on Newton's method; Stott and Alsac 1974 on fast decoupled load flow) established the algorithms and their convergence claims decades ago.
• Standard packages (MATPOWER, pandapower) ship industrial implementations, but a student who only calls runpp() never sees why the choice of algorithm matters.
• Published classroom comparisons typically report iteration counts on one small system with no validation, no stress testing and no link to practical grid contexts. The gap: a declared-metric, cross-validated, stress-tested comparison on standard systems, reproducible by any college lab at zero cost, with an explicit Indian-distribution-context discussion.

Proposed study

• Implement Gauss-Seidel, Newton-Raphson and the XB fast decoupled method from first principles, with sparse iteration structures where they matter.
• Validate all three against pandapower and MATPOWER reference solutions with declared tolerances before any experiment.
• Measure iterations, wall-clock time, mismatch history and memory structure on all four IEEE systems; map convergence failure under uniform loading scale-up; run the high R/X stress sweep modelling Indian rural feeder parameters.
• Publish every table, curve and tolerance in a version-controlled notebook pack.

Feasibility

• Technical: the four test systems are public in the IEEE Common Data Format; all three algorithms are well documented in the literature; a laptop runs everything in seconds.
• Economic: zero cost — open-source toolchain, no licensed software, no hardware.
• Risk: silent implementation errors are the main threat, which is why cross-validation against two independent solvers with declared tolerances is a gating step, not an afterthought.

In scope

• Three classical algorithms implemented from scratch: Gauss-Seidel, Newton-Raphson with full Jacobian, and the XB fast decoupled variant.
• The IEEE 14, 30, 57 and 118-bus standard test systems in the IEEE Common Data Format, used unmodified for base cases.
• Declared metrics: iterations, wall-clock time, mismatch history, Jacobian memory structure, convergence-failure loading level, high R/X stress response.
• Cross-validation against pandapower and MATPOWER reference results with stated tolerances; all code and results version-controlled.
• A discussion chapter mapping results to Indian transmission and distribution practice (CEA planning criteria context, SLDC study cycles, high R/X rural feeders).

Out of scope

• Optimal power flow, security-constrained dispatch, contingency screening and state estimation — this study stays on deterministic base-case load flow.
• DC (linearised) power flow as a competitor algorithm; it appears only in background discussion.
• Regulator and phase-shifter modelling, HVDC links and FACTS devices; the standard test systems' native modelling is used as published.
• Any interaction with live grid data, utility systems or real-time operations — the study is entirely offline on public benchmark data.

The study follows a quantitative, simulation-experimental research design in four gated stages: implement → validate → experiment → analyse. Each stage ends in a written gate: no experiment runs until validation passes, no analysis until experiments are complete and logged. Version-controlled Jupyter notebooks hold the entire chain, and every dissertation table regenerates from a tagged run.

Protocol skeleton: one Python 3.10+ environment with pinned NumPy/SciPy versions; test-case data fixed at download with file hashes recorded; wall-clock timing by a common timer harness with each algorithm executed 20 times per case and the median reported (to remove startup noise); convergence declared at maximum bus mismatch below 0.0001 per-unit, with the mismatch history stored for every run.

Experiment design: the loading scale-up multiplies every PQ-bus load by a factor raised in 0.02 steps until an algorithm fails to converge within 100 iterations; the high R/X sweep multiplies line resistances by factors from 1.0 to 3.0 in steps, holding reactances fixed, and records iterations, mismatch trajectory and final solution error against the NR reference. Validation: the cross-check against two independent solvers is itself a test of the Y-bus and parser, not just the iteration loops; a hand-worked 3-bus case additionally anchors the parser. Reproducibility: median-of-20 timing, pinned environment, fixed data hashes, and a scripted regeneration of every figure.

The study is a small computation stack with a strict one-way data flow: a data layer parses and hashes the IEEE CDF files into a common network model; a solver layer holds the three algorithms behind one common interface; an experiment layer times, stress-tests and logs every run; and an analysis layer renders every table and curve from logged arrays. Cross-validation against pandapower and MATPOWER sits beside the solver layer as an independent referee.

flowchart TD
  A["IEEE CDF test cases
14 / 30 / 57 / 118 bus"] --> B["Data layer
Y-bus, bus and branch model"]
  B --> C["Solver layer
Gauss-Seidel, Newton-Raphson, fast decoupled"]
  C --> D["Cross-validation gate
pandapower and MATPOWER references"]
  D --> E["Experiment layer
metrics, loading scale-up, high R/X sweep"]
  E --> F["Run logs
mismatch history, timings, failure points"]
  F --> G["Analysis layer
tables, convergence curves, trade-off discussion"]
  G --> H["Dissertation results
and Indian-grid discussion chapter"]

The common solver interface is the design decision that makes the comparison fair: all three algorithms receive the same network model, the same initial guess (flat start, with a documented Gauss-Seidel warm-start exception), the same tolerance and the same timer. The cross-validation gate is placed before the experiment layer deliberately — a solver that has not reproduced pandapower and MATPOWER base cases within 0.0001 per-unit produces no experimental numbers. This is the classic measurement-study shape: frozen inputs, refereed instruments, logged experiments, reproducible outputs.

• Extend to the IEEE 300-bus system and a large synthetic Indian-style network to study how sparse Jacobian handling changes the speed rankings at scale.
• Add the BX decoupled variant and a DC linearised flow, completing the classical algorithm family in one framework.
• Model Indian rural feeder data explicitly: build a documented 15-bus 11 kV feeder case with realistic high R/X conductor parameters and rerun the full campaign.
• Wrap the validated solvers into an open teaching toolkit with exercised notebooks for power-systems courses.