A simple approach for branch current

computation in load flow analysis of radial

distribution systems
K. Prasad,1 N. C. Sahoo,1 A. Chaturvedi1 and R. Ranjan2
1
Faculty of Engineering and Technology, Multimedia University, Melaka, Malaysia
2
Institute of Technology and Management, Gurgaon, Haryana, India
E-mail: nirodchandra.sahoo@mmu.edu.my

Abstract The purpose of this paper is to expose students to a simple and efficient load flow algorithm
for a radial distribution system (RDS). The basic structure and properties of the RDS are discussed,
followed by an illustrative description of the load flow algorithm. The proposed load flow algorithm
exploits the tree-type structure of the RDS and uses data structures efficiently. The flowchart and
pseudo-codes of the algorithm have been included to help the students in writing their own program.
The time and space complexity of the algorithm have also been discussed. The treatment and analysis
will be useful for students’ understanding of RDS, use of data structures in programming, and
approximate complexity analysis of algorithms. The instructors can effectively use the contents of the
paper for a basic lecture on RDS (PDF files of the Microsoft PowerPoint slides and C language program
code can be downloaded from the website http://www1.mmu.edu.my/~nirod/).

Keywords array; complexity analysis; load flow; radial distribution systems; stack

The major components in the hierarchical structure of a typical power system

showing the flow of power from the generating station to the distribution feeders via
transmission system, main power station, sub-transmission system and distribution
substation are illustrated in Fig. 1. The focus of this paper is on the distribution
system that directly delivers power to the customer via primary/secondary feeders.
Generally, the electrical distribution systems are fed at only one point (known as the
substation) and their configurations are either radial or they are conveniently oper-
ated radially. In a radial distribution system (RDS), each component has a unique
power flow path from the substation (source of energy). Thus, the RDS resembles
the structure of a tree. For a better appreciation of the structure of RDS, a RDS con-
taining few typical custom power components/devices is shown in Fig. 2(a) where
the various standard terminologies used in RDS, i.e., substation, main feeder, later-
als, sublaterals, nodes, and branches, etc., are clearly indicated. The skeletal tree
structure of this RDS (for load flow study) is illustrated in Fig. 2(b). The substation
is the root of the tree, which is the source node. Just like a tree, the RDS has a
number of branches and nodes. The different end nodes of the tree are called leaf-
nodes. The loads are connected at different nodes. Owing to the radial nature of the
network, there is only one path connecting any node to the main substation of the
RDS. Two such power flow paths (for nodes N3 and N8) are depicted in Fig. 2(b).
Every node (barring the substation) is uniquely associated with a line, through which
it receives power, called the supply line of that specific node. It is seen that, for a
RDS, the number of branches (Nb) and number of nodes (N) are related by

International Journal of Electrical Engineering Education 44/1

Downloaded from ije.sagepub.com at PENNSYLVANIA STATE UNIV on May 9, 2016

50 K. Prasad et al.

Highly Main
Interconnected Power Sub-transmission Distribution
Transmission Station System Substation
Network

Generating
Station Circuit Breakers …
Feeders

Fig. 1 Hierarchical structure of electric power system.

N9 * N9 *
Load 9 B9 B9
N8 * Load 9
N7 N8 *
B8 N6 * B8
N7
N6 *
C Load 7 Load 7
Load 6 B6 B6
N5 Load 6 N5
Load 8 B7 Load 8 B7

N2 Load 5 B5 B5
B3
N2 Load 5
B4
Load 2 B2 Load 2 B3 B4
N4 B2 N4
N1 N1
LT N
VR 3 N3
Load 1 Load 1
ST Load 3 Load 4 Load 3 Load 4
B1
Switch
B1

Substation (Root) Substation (Root)

(a) (b)

Legend: C ≡ Capacitor Bank; LT ≡ Line Transformer; VR ≡ Voltage Regulator;

ST ≡ Substation Transformer; ≡ Substation; ≡ Main Feeder; ≡ Lateral; ≡ Sublateral;
N1 , … , N9 ≡ Nodes; B1 , … , B8 ≡ Branches; ≡ Power Flow Path; ≡ Node; * ≡ Leaf Node

Fig. 2 (a) A practical RDS showing different components; (b) line diagram model
illustrating the tree structure of RDS shown in (a).

N = Nb + 1 (1)
More details about the distribution systems can be found in Refs 1 and 2.
Recently, research on automated electrical distribution systems has gained
momentum. For day-to-day real-time operation of an RDS, an efficient load flow
algorithm is essential. It has been verified by researchers that conventional load flow
algorithms have convergence problems due to high R/X (resistance/reactance) ratio
of the RDS.3,4 Many other works have suggested modified versions of conventional

International Journal of Electrical Engineering Education 44/1

Downloaded from ije.sagepub.com at PENNSYLVANIA STATE UNIV on May 9, 2016

Load flow analysis of RDS 51

load flow methods for high R/X ratios.5–7 In Refs 8 and 9, ladder theory is used for
advanced load flow technique which is modified in Ref. 10 for faster execution.
However, it fails to converge in some case studies. Baran and Wu have developed
a method based on the Newton-Raphson approach, but it requires involved compu-
tations using a Jacobian matrix.11 In Ref. 12, a load flow solution method is pro-
posed based on a current injection model using involved methodology.
For faster load flow analysis of an RDS, one of the prime objectives is to have
simpler means to compute the branch currents. Most of the algorithms reported so
far in the literature are based on forward sweep and reverse sweep mechanisms for
current and voltage calculations. A forward sweep starts from substation and tra-
verses towards end (leaf) node, whereas a reverse sweep traverses towards substation
from leaf node. The implementations of these two schemes show wide variations.
In Ref. 13, the load currents are calculated first, and then, by reverse sweep, branch
currents are computed by summing all the following branch currents using a module
to find all the branches that emanates from the receiving node of a branch. Thus, for
branches closer to substation, one has to go down all the way till the leaf nodes
arrive, which requires large time and memory space. In Ref. 14, a branch current is
calculated using reverse sweep till the concerned branch arrives. A limitation of this
method is to compute the branch currents in every sweep. In Ref. 15, the branch
currents are also computed by reverse sweep using a (N × N) matrix size for N nodes
and this matrix usually has many zero elements. This is clearly not a good use of
memory space.
In this paper, a simple and computationally efficient approach for RDS branch
current computation is demonstrated. The proposed algorithm exploits the tree-type
structure of the RDS and uses data structures efficiently for the storage of node infor-
mation for operational convenience and faster execution speed. While computing a
branch current, traversing from the branch until a terminal node arrives in all its
down streams is avoided, since the currents flowing in its following branches are
available in advance due to suitable branch indexing and use of a stack for storing
these indices. The branch indexing is done in such a way that, in any lateral/main
feeder, a higher indexed branch will not appear before a lower indexed branch. The
current calculation starts from the highest indexed branch and proceeds towards the
substation. The array storing the branch currents is also filled accordingly. An
approximate time and space complexity analysis of the algorithm has been pre-
sented. The pseudo-codes and flowchart of the algorithm are included. The test
results on a 69-node RDS are reported.

Load flow analysis of radial distribution systems

In RDS, the large R/X ratio causes problems in convergence of conventional load
flow algorithms. For a balanced RDS, the network can be represented by an equiva-
lent single-line diagram. The line shunt capacitances at distribution voltage level are
very small to be neglected. The simplified mathematical model of a section of RDS
is shown in Fig. 3. From circuit analysis, the current in branch m is the phasor sum
of the currents in branch m + 1 and load current at node j + 1. Thus,

International Journal of Electrical Engineering Education 44/1

Downloaded from ije.sagepub.com at PENNSYLVANIA STATE UNIV on May 9, 2016

52 K. Prasad et al.

Node j Node j+1 Node j+2

Im I m+1
Rm + j X m R m +1 + j X m +1

Branch m Branch m+1 V j + 2 ∠θ vj+ 2

V j ∠θ vj I lj +1 I lj + 2
V j +1 ∠θ vj+1

Pjl +1 + jQ lj +1 P jl + 2 + jQ lj + 2

V j = V j ∠θ vj i
; I m = I m ∠θ m ; I lj +1 = I lj +1 ∠θ lj +1

Fig. 3 Electrical equivalent of a section of an RDS (V = node voltage, I = branch current,

Il = load current, θυ = node voltage angle, θi = branch current angle, θl = load current
angle, Pl (Ql) = real (reactive) load.

Im = Im +1 + I jl +1 (2)
⇒ Im ∠q mi = Im +1 ∠q mi +1 + I jl +1 ∠q lj +1 (3)
Pjl+1 − jQ jl +1
I jl +1 = , ‘*’ ≡ complex conjugate operation (4)
Vj*+1
If node j + 2 is a leaf node, I lj+2 is calculated first by an expression (similar to
Eq. (4)) taking load real and reactive powers at that node and its node voltage and,
in that case, the branch current Im+1 is equal to I lj+2. Then, using eqns (2)–(4), current
in branch m is calculated. This process is repeated until the substation of the RDS
is reached. After the calculation (updating) of branch currents, the node voltages are
calculated (updated). The node voltages are updated starting from the leaf node. The
voltage for node j + 1 is given by (phasor calculation)
Vj +1 = Vj − Im Zm (5)
where Zm is the impedance of the branch m given by (Rm = resistance, Xm =
reactance)
Zm = Rm + jXm (6)
Equation (5) can be simplified as:
Vj +1 ∠q vj +1 = Vj ∠q vj − Im Zm ∠f m (7)
where f m = q + tan
i
m
−1
( Xm Rm ) (8)
The separation of eqn (7) into real and imaginary parts and their further algebraic
simplification will yield the following expressions.
Vj +1 = Vj + Im 2 Zm 2 − 2 Vj Im Zm cos (q vj − f m )
2
(9)

International Journal of Electrical Engineering Education 44/1

Downloaded from ije.sagepub.com at PENNSYLVANIA STATE UNIV on May 9, 2016

Load flow analysis of RDS 53

 Vj sin q vj − Im Zm sin f m 
and q vj +1 = tan −1   (10)
 Vj cos q vj − Im Zm cos f m 
Thus, once branch currents are computed, the node voltages are obtained using the
above equations. Hence, the complexity of the solutions lies in the computation of
branch currents. This paper presents a simple algorithm to find out the branch cur-
rents in the following section. In a typical load flow study, without any prior knowl-
edge, the following iterative procedure is followed.
Step 1: Read the system data and set all the node voltages to 1.0 p.u. and branch
currents to 0.
Step 2: Compute the currents for all the branches of the RDS.
Step 3: Update the node voltages using the computed branch currents.
Step 4: If the absolute value of the difference between the previous (iteration) and
present (iteration) voltage at any node is more than some preset value (0.0001),
then go to Step 2 else Stop.
An overall flowchart of the load flow algorithm is presented in Fig. 4. Once the load
flow algorithm has converged, the real and reactive power losses in a branch are
computed as follows.
Real power loss in branch m = LPm = I 2m Rm (11)
Reactive power loss in branch m = LQm = I Xm 2
m (12)

Branch current computation algorithm

For branch current computation in load flow analysis of an RDS, the proposed algo-
rithm uses a standard approach for numbering the branches and ordering the nodes.
This approach is described here followed by the detailed procedure for the branch
current computation algorithm.

Node ordering and branch numbering

A typical RDS consists of a main feeder and several laterals/sublaterals. The nodes
in the main feeder are conveniently numbered (indexed) first. The substation is
assigned as node 1. Then, all the successive nodes in the main feeder are increas-
ingly numbered towards its leaf node. Subsequently, the nodes in the laterals are
numbered one after another and, in each lateral, the nodes are numbered in increas-
ing sequence towards the respective leaf nodes. Then, the branch numbering is done.
A branch is assigned a number (index) which is one less than the number of the
receiving node of that branch such that a higher indexed branch never appears before
a lower indexed branch. Fig. 5 illustrates this numbering scheme for a hypothetical
69-node RDS.11

Branch current calculation procedure

From the circuit analysis, it can be noted that if the receiving node of a branch m,
RN (m), is a leaf node, then the current in branch m, Im, is the load current at RN

International Journal of Electrical Engineering Education 44/1

Downloaded from ije.sagepub.com at PENNSYLVANIA STATE UNIV on May 9, 2016

54 K. Prasad et al.

A
Start

NO
Is i > N ?
Read system data. Assume
flat initial node voltages, YES
i.e., Vnew[i] = 1.0 , ∀i
count ← count +1
Set (iteration) count = 0; Store
the present voltages in another
array: Vold[i] = Vnew[i], ∀i. Is DVmax
< 0.0001?
B
YES
Set the maximum absolute NO
voltage difference: DVmax = 0.0
Vold[i] = Vnew[i] ,∀i.
Compute the load currents and
branch currents
B
i=2
(Note: i = 1 for the substation whose
voltage remains constant at 1.0)

Solution has converged.

Compute node voltage Vnew[i]. Calculate Calculate branch losses,
absolute change in node voltage: print voltages, angles,
DV[i] = abs(Vnew[i]-Vold[i]) and branch currents etc.

YES Stop
Is DV[i] >
DVmax ?

NO Definitions:
DVmax = DV[i] i ≡ node index ; count ≡ iteration counter;
i ← i +1 N = Number of nodes in RDS;
Vnew ≡ present (iteration) node voltage;
Vold ≡ previous (iteration) node voltage;
A DV≡ absolute voltage difference between
present and previous iteration;
DVmax ≡ maximum absolute voltage difference
between present and previous iteration;

Fig. 4 Overall flowchart of the load flow algorithm.

(m); else, Im = sum of currents in all the branches with RN (m) as the sending node
plus load current at RN (m), i.e.,
If {RN (m) is a leaf node}, Im = Load current at RN (m); Else {Im = sum of
currents in all the branches with RN (m) as the sending node + load current at
RN (m)}

International Journal of Electrical Engineering Education 44/1

Downloaded from ije.sagepub.com at PENNSYLVANIA STATE UNIV on May 9, 2016

Load flow analysis of RDS 55

36 37 38 39 40 41 42 43 44 45 46
44 45
36

52 51 67
35
66
51
66
65
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
1 2 12 13
3 26
67 68
S/S 52 68 69
64

27
53 54 55 56 57 58 59 60 61 62 63 64 65

49
47 48 49 50

28 33 34

28 29 30 31 32 33 34 35

Legend: ≡ Substation (S/S); ≡ Node; ≡ Branch; Bold Numeral ≡ Branch Number;

Non-bold Numeral ≡ Node Number

Fig. 5 Single-line diagram of 69-node RDS (ref. 11) showing branch and node numbering
scheme (substation voltage = 12.66 kV, base power = 10 MVA).

An apparently complex task of finding the currents in all the branches following
branch m requires finding the currents in their following branches and so on. Here,
a simple algorithm is developed for computing the currents starting from the
branches having the leaf node as receiving node and then proceeding towards the
substation. This makes the task of finding currents less involved since for every
branch current calculation, the currents in its following branches are already com-
puted and stored in an array. This innovative approach saves computing the sum of
all the currents recursively every time travelling down the network till the leaf nodes
are reached.
The algorithm first checks whether RN (m) for a branch m is a leaf node by search-
ing the sending nodes’ list. If RN (m) is not a leaf node, then the algorithm finds all
the branches for which RN (m) is the sending node and pushes them into a stack.
Later all the branches pushed into the stack are popped out while finding the sum
of the currents in all the branches following branch m. This is discussed taking
Fig. 5 as the example. Table A.1 (in the Appendix) shows the branch numbers, their
sending nodes and receiving nodes for this RDS. The procedural steps are:
Step 1: The leaf nodes are identified using the logic that if the receiving node of a
branch is not a sending node to any branch, then it is a leaf node.
Step 2: The computation starts from highest indexed branch and proceeds towards
substation. The current in a branch with receiving node as a leaf node is equal to
load current at that node.

International Journal of Electrical Engineering Education 44/1

Downloaded from ije.sagepub.com at PENNSYLVANIA STATE UNIV on May 9, 2016

56 K. Prasad et al.

Step 3: The current in branch m with non-leaf receiving node, RN (m), is equal to
load current at RN (m) plus sum of currents flowing in the branches with RN (m)
as the sending node. The branches with RN (m) as the sending node are found
from the network data and the corresponding branch numbers are pushed into a
stack. It should be noted that the currents flowing in these branches are already
calculated because of the branch indexing. For computing the branch m current,
these stored branch numbers are popped out of the stack one by one and the cur-
rents flowing in them are added up with load current at RN (m).

The above steps are illustrated for a 69-node RDS. The array for storing branch
currents is declared as I[68]. The currents are calculated from higher index to lower
index branches. Thus, it starts with branch 68 and RN (68) is 69 which is a leaf node.
Hence, the current in this branch is the load current at node 69 and is stored at I[68].
The next one is branch 67 and RN (67) = 68, which is not a leaf node and the algo-
rithm will find the branches for which node 68 is the sending node. There is only
one branch for which node 68 is the sending node and this branch number is pushed
into a stack, which is later is popped out with the corresponding branch current
(already stored) being added to the load current at node 68 to compute the current
in branch 67and stored at I[67]. The next branch is branch 66 and RN (66) is 67
which is a leaf node and the current flowing in the branch 66 is simply the load
current at bus 67 and is stored at I[66]. The next one is branch 65 and RN (65) is
66 which is not a leaf node and the algorithm finds that there is only one branch fol-
lowing branch 65 (i.e., branch 66) whose current, available at I[66], is added with
load current at node 66 to compute I[65]. Figure 6 shows the storage of the branch
currents in the array. As a more illustrative additional example, when branch 2
current is to be computed, the currents in the following branches with RN (2) as the
sending node, i.e., branches 3, 27, and 35, are already available and are just added
to the load current at node 3 to get I[2]. The branch numbers of these following
branches are pushed into the stack (Fig. 7). Later, these entries are popped out
(Fig. 8) while computing I[2]. The addition of branch and load currents for branch
2 current computation is also illustrated in Fig. 6 with broken lines.
The stack data structure is used for procedural convenience, i.e., to temporarily
store and remove the branch numbers. The use of a stack does not require that the
actual number of data items to be pushed into need be known at the start and, while
popping the data items, the empty stack is automatically indicated by the index stack
top becoming negative. Since branches are considered with descending order of
branch number, it is apparent that the currents in the following branches of any given
branch are readily available in the array. In fact, this is the key idea behind this pro-
posed algorithm to facilitate an easy branch current calculation.

Pseudo-code for load flow algorithm

The pseudo-code for C language implementation of the load flow algorithm is as
follows.

International Journal of Electrical Engineering Education 44/1

Downloaded from ije.sagepub.com at PENNSYLVANIA STATE UNIV on May 9, 2016

Load flow analysis of RDS 57

I[1] Load current

+
I[2] at node 3
I[3] +

I[27]
+

I[35]

I[67]
I[68]

Fig. 6 Stored branch currents in an array for 69-node RDS (the broken-line portion
illustrates branch 2 current calculation as described in Figs 7 and 8).

Push 3 Push 27 Push 35 35 Stack-top

27 27
Stack-top
Nil 3 Stack-top 3 3
Empty Stack

Fig. 7 Pushing of branch numbers into stack while computing branch 2 current in 69-
node RDS.

Pop 35 Pop 27 Pop 3

35
27 27

3 3 3 Nil
Empty Stack

I[2] = I [35] + I [27] + I [3]+Load current at node 3

Fig. 8 Popping of branch numbers out of stack while computing branch 2 current in 69-
node RDS.

International Journal of Electrical Engineering Education 44/1

Downloaded from ije.sagepub.com at PENNSYLVANIA STATE UNIV on May 9, 2016

58 K. Prasad et al.

// Step 1: Initialisation and reading the distribution system data

Read the distribution system data into a data matrix, DATA.
/*Data matrix = DATA[Nb][7]: column 1 = branch number, column 2 = sending
node number, column 3 = receiving node number, column 4 & 5 = branch
resistance & reactance, column 6 & 7 = real & reactive load at the receiving
end of the branch, respectively */
Set Count = 0; //Iteration count is set to zero.
V[i] = Vold[i] =1.0 for i =2, . . . , N; //Initial guess for the node voltages of RDS
I[j] = 0 for j = 1, . . . , Nb //Initial guess for the branch currents;
Nb=N-1

//Step 2: Computation of branch currents

for (j = Nb -1; j > 0; j–) {
flag = 0; // flag is a Boolean variable.
for(i=0;i< Nb ;i++) {if (DATA[j][2]==DATA[i][1],
flag=1;}
//if the receiving node of branch j is a sending node to any branch, flag is
set.
if (flag==0), //receiving node of branch j is a leaf node.
then I[j]=IL[j+1]; // IL[j+1] = load current at node j+1
else { top = -1; //receiving node of branch j is not a leaf node
//initialize the empty stack top, st ≡ stack
for (i=j; i < Nb; i++) {
if(DATA[j-1][2]==DATA[i][1]), st[++top]=(int)DATA[i][0];}; /* Find
all branches for which the receiving node of branch j is the sending node and
push them into stack */
/* The following module calculates the currents flowing in the branches following
branch j for which the receiving node is a non-leaf node. temp is a temporary
variable to store the value popped out of the stack. */
while (top>=0){temp=st[top–]; // pop the branch number from the stack.
I[j]+=I[temp];}; //sum of branch currents following
branch j
end while
I[j]+= IL[j+1];};}; //load current at node j+1 is added to get the current
in branch j
// End of current calculation for all branches

// Step 3: Compute the new (updated) node voltages and test convergence of the
algorithm.
for (i = 2; i <=N, i++) {compute Vnew[i]};
Count++; //Iteration counter is incremented.
DVmax = 0;
//Find the maximum difference in the present and previous voltage among all
nodes.
for(i=2;i<=N; i++){

International Journal of Electrical Engineering Education 44/1

Downloaded from ije.sagepub.com at PENNSYLVANIA STATE UNIV on May 9, 2016

Load flow analysis of RDS 59

if(DVmax < absolute (Vnew [i] - Vold[i]), DVmax = absolute (Vnew[i] - Vold
[i])}
If DVmax > 0.0001 p.u., Vold[i] = Vnew[i]. Go to Step 2, Else go to Step 4.

// Step 4: Solution has converged. Prepare load flow study report.

Compute the real and reactive power losses;
Print voltage magnitude and angle at every node;
Print current in all branches;
Stop.

Simplified complexity analysis of the algorithm

A simplified analysis of the time and space complexity of the algorithm follows.
Time complexity. For finding leaf (non-leaf) nodes, the sending nodes’ list is scanned
once, i.e., the time complexity is O(Nb). Hence, for all Nb nodes, the time complex-
ity is O(Nb × Nb). If a node is not a leaf node, the sending nodes’ list is scanned to
find the branches with this node as sending node. Again, the time complexity is
O(Nb). Under worst case, time complexity for all the nodes is O(Nb × Nb). The rest
of the program codes are repeated in the loop Nb-times, thus their time complexity
is only O(Nb). Hence, the time complexity of the proposed algorithm is O(N 2b).
Space complexity. The array and stack store data of size Nb. Since there are no recur-
sions and dynamic memory allocations, it is apparent that the space complexity
is only O (Nb).

Test results
The proposed load flow algorithm is tested on a hypothetical 69-node RDS (data
provided in Appendix) using C language on a PC (Pentium 4 processor, CPU speed
= 1.6 GHz).11 Table 1 presents computed node voltages. It takes only four iterations
for the algorithm to converge with CPU time less than 10 ms. For the sake of com-
parison, the results obtained in Ref. 12 for the same RDS are listed. The proposed
algorithm is very simple with adequate computational accuracy. Total real and
reactive losses for this RDS are found to be 224.9783 kW and 102.1948 kVAr,
respectively.

Conclusions
A basic introduction to radial distribution systems has been provided with illustra-
tive diagrams highlighting the key concepts along with a novel branch current com-
putation algorithm for load flow analysis. The algorithm exploits the tree-like
structure of the network and it is computationally very fast and accurate. This paper
will expose students of electrical engineering to the structure of RDS along with the
proposed simplified method for its load flow study as well as time and space com-
plexity analysis of the load flow algorithm. The students will also be exposed to an

International Journal of Electrical Engineering Education 44/1

Downloaded from ije.sagepub.com at PENNSYLVANIA STATE UNIV on May 9, 2016

60 K. Prasad et al.

TABLE 1 Comparison of load flow results for 69-node RDS between the proposed
algorithm and the algorithm proposed in Ref. 12

Voltage Voltage
magnitude Voltage magnitude Voltage
(p.u.) magnitude (p.u.) magnitude
Node (proposed (p.u.) Node (proposed (p.u.)
number algorithm) (Ref. 12) number algorithm) (Ref. 12)

1 1.00000 1.00000 36 0.99992 0.99992

2 0.99997 0.99997 37 0.99975 0.99975
3 0.99993 0.99993 38 0.99959 0.99959
4 0.99984 0.99984 39 0.99954 0.99954
5 0.99902 0.99902 40 0.99954 0.99954
6 0.99009 0.99009 41 0.99884 0.99884
7 0.98079 0.98079 42 0.99855 0.99855
8 0.97858 0.97858 43 0.99851 0.99851
9 0.97744 0.97745 44 0.99850 0.99850
10 0.97244 0.97245 45 0.99841 0.99841
11 0.97132 0.97135 46 0.99840 0.99840
12 0.96816 0.96189 47 0.99979 0.99979
13 0.96523 0.96526 48 0.99854 0.99854
14 0.96233 0.96237 49 0.99470 0.99470
15 0.95946 0.95950 50 0.99415 0.99415
16 0.95893 0.95897 51 0.97854 0.97854
17 0.95805 0.95809 52 0.97853 0.97853
18 0.95804 0.95808 53 0.97466 0.97466
19 0.95757 0.95761 54 0.97141 0.97142
20 0.95727 0.95731 55 0.96694 0.96694
21 0.95679 0.95683 56 0.96257 0.96257
22 0.95678 0.95683 57 0.94010 0.94010
23 0.95671 0.95675 58 0.92904 0.92904
24 0.95656 0.95660 59 0.92476 0.92476
25 0.95638 0.95643 60 0.91974 0.91974
26 0.95631 0.95636 61 0.91234 0.91234
27 0.95629 0.95634 62 0.91205 0.91205
28 0.99993 0.99993 63 0.91167 0.91166
29 0.99985 0.99985 64 0.90977 0.90976
30 0.99973 0.99973 65 0.90919 0.90919
31 0.99971 0.99971 66 0.97126 0.97129
32 0.99961 0.99961 67 0.97126 0.97129
33 0.99935 0.99935 68 0.96783 0.96786
34 0.99901 0.99901 69 0.96782 0.96786
35 0.99895 0.99895

efficient use of array and stack data structures in a programming environment. The
pseudo-code and overall flowchart of the algorithm are included for immediate
implementation. This paper is organised in such a way that an instructor can use it
for an introductory lecture on radial distribution systems.

International Journal of Electrical Engineering Education 44/1

Downloaded from ije.sagepub.com at PENNSYLVANIA STATE UNIV on May 9, 2016

Load flow analysis of RDS 61

References
1 W. H. Kersting, Distribution System Modeling and Analysis (CRC Press, Boca Raton, 2002).
2 R. E. Brown, Electric Power Distribution Reliability (Marcel Dekker, New York, 2002).
3 W. F. Tinny and C. E. Hart, ‘Power flow solution of the Newton Method’, IEEE Trans. PAS, 86
(1967), 1449–1456.
4 B. Scott and O. Alsac, ‘Fast decoupled load flow’, IEEE Trans. PAS, 93 (1974), 859–869.
5 B. Scott, ‘Review of load flow calculation methods’, Proc. IEEE, 62(7) (1984), 916–929.
6 D. Rajicic and Y. Tamura, ‘A modification to fast decoupled power flow for network with high R/X
ratios’, IEEE Trans. PWRS, 3 (1988), 743–746.
7 S. C. Tripathy, D. Prasad, O. P. Malik and G. S. Hope, ‘Load flow solution for ill conditioned power
systems by Newton like method’, IEEE Trans. PAS, 101 (1982), 3648–3657.
8 W. H. Kersting and D. L. Mendive, ‘An application of ladder network theory to the solution of three
phase radial load flow problem’, in Proc. IEEE PES Winter Meeting, 1976, New York, paper
A76044-8 (IEEE, New York, 1976).
9 W. H. Kersting, ‘A method to design and operation of distribution system’, IEEE Trans. PAS, 103
(1984), 1945–1952.
10 R. A. Stevens, D. T. Rizy and S. L. Purucker, ‘Performance of conventional power flow routines for
real time distribution automation applications’, in Proc. 18th Southeastern Symposium on Systems
Theory (IEEE Computer Society, New York, 1986), pp. 196–200.
11 M. E. Baran and F. F.Wu, ‘Optimal capacitor placement on radial distribution systems’, IEEE Trans.
Power Delivery, 4(1) (1989), 725–734.
12 S. Ghosh and D. Das, ‘Method of load-flow solution of radial distribution networks’, IEE Proc. Gen-
eration, Transmission and Distribution, 146(6) (1999), 641–648.
13 J. Nanda, M. S. Srinivas, M. Sharma, S. S. Dey and L. L. Lai, ‘New findings on radial distribution
system load flow algorithms’, in Proc. IEEE PES Winter Meeting, 2000, Vol. 2 (IEEE, New York,
2000), pp. 1157–1161.
14 S. Mok, S. Elangovan, C. Longjian and M. M. A. Salama, ‘A new approach for power flow analy-
sis of balanced distribution systems’, Electric Machines and Power Systems, 28 (2000), 325–340.
15 P. Aravindhababu, S. Ganapathy and K. R. Nayar, ‘A novel technique for the analysis of radial dis-
tribution systems’, Intl J. Electrical Power and Energy Systems, 23 (2001), 167–171.

Appendix
TABLE A.1 Data for the 69-node RDS (Base voltage = 12.66 kV, Base power = 10 MVA).

Receiving Receiving
Branch Sending Receiving Resistance Reactance node real node reactive
number node No node No (ohm) (ohm) load (kW) load (kVAr)

1 1 2 0.0005 0.0012 0.0 0.0

2 2 3 0.0005 0.0012 0.0 0.0
3 3 4 0.0015 0.0036 0.0 0.0
4 4 5 0.0251 0.0294 0.0 0.0
5 5 6 0.3660 0.1864 2.60 2.20
6 6 7 0.3811 0.1941 40.40 30.00
7 7 8 0.0922 0.0470 75.0 54.0
8 8 9 0.0493 0.0251 30.0 22.0
9 9 10 0.8190 0.2707 28.0 19.0
10 10 11 0.1872 0.0691 145.00 104.00
11 11 12 0.7114 0.2351 145.0 104.0
12 12 13 1.0300 0.3400 8.0 5.50
13 13 14 1.0440 0.3450 8.0 5.50

International Journal of Electrical Engineering Education 44/1

Downloaded from ije.sagepub.com at PENNSYLVANIA STATE UNIV on May 9, 2016

62 K. Prasad et al.

TABLE A.1 Continued

Receiving Receiving
Branch Sending Receiving Resistance Reactance node real node reactive
number node No node No (ohm) (ohm) load (kW) load (kVAr)

14 14 15 1.0580 0.3496 0.0 0.0

15 15 16 0.1966 0.0650 45.5 30.0
16 16 17 0.3744 0.1238 60.0 35.0
17 17 18 0.0047 0.0016 60.0 35.0
18 18 19 0.3276 0.1083 0.0 0.0
19 19 20 0.2106 0.0696 1.00 0.60
20 20 21 0.3416 0.1129 114.0 81.0
21 21 22 0.0140 0.0046 5.30 3.50
22 22 23 0.1591 0.0526 0.0 0.0
23 23 24 0.3463 0.1145 28.0 20.0
24 24 25 0.7488 0.2745 0.0 0.0
25 25 26 0.3089 0.1021 14.0 10.0
26 26 27 0.1732 0.0572 14.0 10.0
27 3 28 0.0044 0.0108 26.0 18.60
28 28 29 0.0640 0.1565 26.0 18.60
29 29 30 0.3978 0.1315 0.0 0.0
30 30 31 0.0702 0.0232 0.0 0.0
31 31 32 0.3510 0.1160 0.0 0.0
32 32 33 0.8390 0.2816 14.0 10.0
33 33 34 1.7080 0.5646 19.5 14.0
34 34 35 1.4740 0.4873 6.0 4.0
35 3 36 0.0044 0.0108 26.0 18.55
36 36 37 0.0640 0.1565 26.0 18.55
37 37 38 0.1053 0.1230 0.0 0.0
38 38 39 0.0304 0.0355 24.0 17.0
39 39 40 0.0018 0.0021 24.0 17.0
40 40 41 0.7283 0.8509 1.20 1.0
41 41 42 0.3100 0.3623 0.0 0.0
42 42 43 0.0410 0.0478 6.0 4.30
43 43 44 0.0092 0.0116 0.0 0.0
44 44 45 0.1089 0.1373 39.22 26.30
45 45 46 0.0009 0.0012 39.22 26.30
46 4 47 0.0034 0.0084 0.0 0.0
47 47 48 0.0851 0.2083 79.0 56.40
48 48 49 0.2898 0.7091 384.7 274.50
49 49 50 0.0822 0.2011 384.7 274.50
50 8 51 0.0928 0.0473 40.50 28.30
51 51 52 0.3319 0.1114 3.60 2.70
52 9 53 0.1740 0.0886 4.35 3.50
53 53 54 0.2030 0.1034 26.40 19.00
54 54 55 0.2842 0.1447 24.0 17.20
55 55 56 0.2813 0.1433 0.0 0.0
56 56 57 1.5900 0.5337 0.0 0.0
57 57 58 0.7837 0.2630 0.0 0.0
58 58 59 0.3042 0.1006 100.0 72
59 59 60 0.3861 0.1172 0.0 0.0
60 60 61 0.5075 0.2585 1244.0 888.0

International Journal of Electrical Engineering Education 44/1

Downloaded from ije.sagepub.com at PENNSYLVANIA STATE UNIV on May 9, 2016

Load flow analysis of RDS 63

TABLE A.1 Continued

Receiving Receiving
Branch Sending Receiving Resistance Reactance node real node reactive
number node No node No (ohm) (ohm) load (kW) load (kVAr)

61 61 62 0.0974 0.0496 32.0 23.0

62 62 63 0.1450 0.0738 0.0 0.0
63 63 64 0.7105 0.3619 227.0 162.0
64 64 65 1.0410 0.5302 59.0 42.0
65 11 66 0.2012 0.0611 18.0 13.0
66 66 67 0.0047 0.0014 18.0 13.0
67 12 68 0.7394 0.2444 28.0 20.0
68 68 69 0.0047 0.0016 28.0 20.0

International Journal of Electrical Engineering Education 44/1

Downloaded from ije.sagepub.com at PENNSYLVANIA STATE UNIV on May 9, 2016