Академический Документы
Профессиональный Документы
Культура Документы
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
Highly Main
Interconnected Power Sub-transmission Distribution
Transmission Station System Substation
Network
Generating
Station Circuit Breakers …
Feeders
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
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
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.
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
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)
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)
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)
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;
(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)}
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
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.
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.
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).
Fig. 7 Pushing of branch numbers into stack while computing branch 2 current in 69-
node RDS.
3 3 3 Nil
Empty Stack
Fig. 8 Popping of branch numbers out of stack while computing branch 2 current in 69-
node RDS.
// 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++){
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.
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
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)
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.
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)
Receiving Receiving
Branch Sending Receiving Resistance Reactance node real node reactive
number node No node No (ohm) (ohm) load (kW) load (kVAr)
Receiving Receiving
Branch Sending Receiving Resistance Reactance node real node reactive
number node No node No (ohm) (ohm) load (kW) load (kVAr)