CAPSTONE PROJECT-II

Implementation and evaluation of a distribution

load flow algorithm for networks with
distributed generation

Submitted in partial fulfillment of the course requirements for the Bachelor of

Engineering (Electrical) degree

Submitted by :-
Sachin Kumar (061358)
Sachin Grover (061356)

Under the supervision of:

Prof. Sandeep Kaur

To :-

DEPARTMENT OF ELECTRICAL ENGINEERING

PEC University of Technology
CHANDIGARH-160012

~1~
 DECLARATION

We hereby declare that the project entitled “Implementation and evaluation of a

distributed load flow Algorithm for networks with distributed generation” is
an authentic record of our own work carried out as a fulfillment of our course
requirements for the award of BE, Electrical Engineering, PEC University of
Technology, Chandigarh, under the guidance of Prof Sandeep Kaur, PEC
University of Technology, during January to May 2010.

Date:
Sachin Kumar (061358)

Sachin Grover (061356)

Certified that the above statement made by the students is correct to the best of our
knowledge and belief.

Place: CHANDIGARH Prof. Sandeep Kaur

~2~
 ACKNOWLEDGEMENT

The submission of the project gives us an opportunity to convey our gratitude to all
those who have helped us in completion of our project. We hereby would like to
acknowledge the invaluable support of our capstone project guide Prof. Sandeep
Kaur, Electrical Engineering Department, PEC University of Technology. She has
helped us through her invaluable suggestions and support throughout the duration
of the project and has been an unending source of inspiration for us.

We would also like to thank Dr. Shiv Narayan (Head of Electrical Engineering
Department, PEC University of Technology, Chandigarh) and Prof. Balwinder
Singh (Department of Electrical Engineering, PEC University of Technology,
Chandigarh) for giving us an opportunity to take up this project in the given field.

Also we would like to extend our deepest thanks to the college authorities, for
showing trust in our abilities and providing us with an atmosphere to work in. We
were allowed usage of all facilities and infrastructure available in the department.
In the end we would like to thank all the people who helped us in the completion of
our project.

Sachin Kumar (061358)

Sachin Grover (061356)

~3~
 ABSTRACT

In this semester project, an existing algorithm for the calculation of power flow in a
distribution network with dispersed generation is implemented in MATLAB and a
given network is analyzed. MATLAB with its toolboxes such as Simulink and
SimPower Systems is one of the most popular software packages used by educators
to enhance teaching the transient and steady-state characteristics of electric
machines and power system . Special consideration was given to the voltage profile
of the network, and active and reactive power flows. Different types of
representative distribution generation profiles and load profiles were adopted.
Comparisons were made in case with and without DG units.

The topic was chosen and was carried out after discussions with our mentor, the
faculty and after doing a secondary research for a variety of projects on distribution
networks. It involved the following steps :-

Phase 1 : Network without dispersed generation

Phase 2 : Network with dispersed generation

~4~
 TABLE OF CONTENTS

1. Chapter 1 Load flow and Distribution Networks ………………....…7-10

1.1 Introduction.....................................................................................7
1.2 Special features of distribution systems ……………...……....... 8
1.3 Summary of some distribution load flow methods ………….. 9
2. Chapter 2 Theoretical Background....................................................11-19
2.1. Basic equations ...........................................................................11
2.2. Dynamic data structure algorithm................................................12
2.3. Power flow calculation algorithm ...............................................15
3. Chapter 3 Case Study.........................................................................20-30
3.1. Network topology ..................................................................................20
3.2. Load and Generation Profiles ................................................................21
3.3. Expected Results of the load flow calculation ......................................29
4 Chapter 4 Results ……………….....................................................31-38
4.1. Voltage profiles without DG………………………………..………....31
4.2. Active & Reactive power profiles without DG……………..………...33
4.3. Voltage profiles with DG……...……………………………….……...35
4.4. Active & Reactive power profiles with DG…………………….….....37
5. Chapter 5 Conclusion …………………………………………….…...39
6. Appendix .……………………………………………………………....40-58
a. Appendix A (MATLAB Code)……………………..………………..40-54
b. Appendix B (E-TAP Simulation)…………………………………....55-58
7. References……………………………………………………………….....59

~5~
List of Figures
Figure 2.1: Model of a transmission line
Figure 2.2: Schematic diagram of a dynamic data structure
Figure 2.3: Radial system used as an example in this work with all the branches
displayed
Figure 2.4: Representation of the data structure storing details of branch I
Figure 2.5: Load flow algorithm for networks with dispersed generation
Figure 3.1: Distribution Network uses as a benchmark
Figure 3.2: Active power load per bus
Figure 3.3: Reactive power load per bus
Figure 3.4: Active power generation per bus
Figure 3.5: Reactive power generation per bus
Figure 3.6: Active load-generation per bus
Figure 3.7: Reactive load-generation per bus
Figure 3.8: Voltage profile without DG
Figure 3.9: Voltage profile with DG

List of Tables
Table 3.1 Load –Generation Active and Reactive Power

Table 3.2 Line Data (Resistance and Inductance)

~6~
 Chapter 1
“Load Flow And Distribution Networks”

1.1 Introduction
Load flow is an important tool for proper design and operation of distribution networks. At the
design stage, load flow analysis can be used to check whether the voltage limits are satisfied all
over the network. At the operation stage, it can be utilized to check the different possible
supplying arrangements to fulfill the required voltage profile and to achieve minimum system
losses. In recent years, introduction of system automation, dispersed generation and the power
industry deregulation have increased the need for powerful tools, including load flow, for the
system analysis. Although the conventional load flow methods, e.g. Newton- Raphson and Fast
Decoupled, are very efficient for transmission networks, they are not so efficient or even may be
unusable in the some cases for distribution networks. The inefficiency of these methods is the
result of inherent features of distribution networks. The inefficiency is the cause of the
divergence, since distribution networks are placed in ill conditioned networks for these methods.
Some of the troublemaking features of distribution networks are: radial or near to radial
structure, high R/X ratio, unbalanced multi-phase operation, distributed loads and generation.
Regarding to the inherent difference between transmission and distribution networks, the
modeling methods of the transmission system components are not suitable for the distribution
networks. Therefore, especial modeling methods are required for the distribution networks.
Many methods are presented for distribution load flow solution. The presented methods can be
categorized in some groups. Some of these methods are modified versions of Newton-Raphson,
and the method deals with formation of Jacobians and computation of power mismatches. Some
others are based on the backward and forward sweep method involving branch current flows
computing. Moreover, a method is presented for direct solution of the network, by modelling
loads as constant impedances. The above mentioned methods are very accurate involving
detailed modelling of the system. Most of them are dealing with deterministic conditions and
accept only fixed inputs. Therefore, their result accuracy greatly depends on the validity of
inputs. The input variables are normally unknown, so they would be obtained by estimation
according some past and present data.

~7~
1.2 SPECIAL FEATURES OF DISTRIBUTION SYSTEMS

1. Radial or near to radial structure. Similar to transmission systems, distribution

networks have an interconnected structure, but they are operated in radial mode unlike
the transmission systems. One or few rings may exist in the distribution networks, but the
number of rings in the whole system is very low. This is because of the arisen difficulties
in protection of the ringed networks.

2. High R/X ratio. This ratio is low in the transmission systems, e.g. 0.1 or less, whereas in
distribution systems it is in the range of 0.5 to 2 or even higher for the lines with low
cross section conductors.
3. Unbalance multi-phase operation. Transmission system are balanced and the loads are
supplied through the three phases. Loads in distribution systems can be fed through three-
phases, two-phase or single-phase, and so distribution systems may be unbalanced.
Therefore, the methods base on the balanced three-phase loads may not be able to solve
the distribution networks load flow problem.
4. Distributed loads. Transmission system loads are lumped and they are located on the
buses of the system. In the case of each transmission line, there are two loads at each end
and there is rarely tap-off load along the line. On the other hand, loads are tapped along
the length of the distribution feeder. If each load is considered as a node, it may result in
an excessive number of nods. In distribution systems so many laterals are fed via the
main feeder. Therefore, each distribution feeder contains some laterals as well as some
distributed load points.
5. Dispersed generation. In the transmission systems, the generator buses are considered as
a PV bus and their voltage can be set at a desirable value in an allowed rang. In the recent
years, dispersed generation has been introduced into distribution systems. This type of
generation is based on the renewable energy sources such as solar, wind, or small
hydrounits, or on the other hand based on the non-renewable sources such as micro-
turbine and small gas-turbine. The controlling strategy of these generators is not similar
to the large generators. Some of them are set in a way that they generate a fixed P and Q.
On the other hand, some others are set to have a fixed power factor. Only a small fraction
of dispersed generators can stabilise the voltage of their connection point, which can be
considered as a PV bus.

~8~
 6. Loads in distribution networks. In distribution systems, loads are supplied through
very small distribution transformers, e.g. 5 kVA. If each load point is considered as a
node, the number of nods would be so high. Modeling the distributed loads, as two
lumped loads at the end of a selected line sections, overcomes this problem. Beside the
distributed load feature, loads characteristics are also important. Normally, loads are
modelled as a fixed P and Q. In some algorithms, loads are modeled as constant
impedance component. But loads in a distribution network have both fixed P and Q, and
constant impedance features, but the percentage of each one would vary. The validity of a
load flow method can be increased, by considering both models simultaneously.

1.3 SUMMARY OF SOME OF DISTRIBUTION LOAD FLOW METHODS

Many efforts have been done on distribution load flow in recent years and some methods
are presented. These can be grouped as follows:

1. Backward and forward sweep methods, or ladder network based methods. These
methods are based on the radial feature of the distribution networks, i.e. there is a unique
path between each node and the source. The algorithm consists of two stages; backward
and forward sweep, which are repeated until convergence. Currents or powers are
calculated at the backward sweep stage, using the computed voltages. Then voltages are
computed at the forward stage, based on the calculated currents or powers. This method
can be summarized as:
Consider a flat voltage profile for all nodes
Determine the impedance between each node and the source
Calculate the currents at backward stage, starting from the end nodes
Compute the voltages at forward stage, starting from the source
Repeat the above two stages until convergence

2. Shirmohammadi method. Shirmohammadi, present a load flow method, which is three-

phase version of their method presented in. This can consider the specialities of the
distribution systems, especially unbalanced loading. This method can also be used for
weekly meshed networks. In these cases, firstly loops are opened and each opened point
is compensated by two injected current sources with opposite directions. Therefore, the

~9~
 opening point is converts to two nodes with compensating current sources. After opening
the loops, the resultant radial network will be solved. This method can be summarised as:
Consider a flat voltage profile for all nodes
Compute the current injections due to the voltage profile
Determine current flow through the line sections, starting from the end nodes
Compute the node voltages due to the line section current flow, starting from the
source
Repeat the above three stages until convergence

3. Implicit Z method. This method utilizes sparse bifactored Y bus matrix and equivalent
current injections. It is based on the superposition principle for voltages. Here, voltage
consists of two parts: the voltage due to the source and the voltage due to the equivalent
current injections. Loads, generators, capacitors, and reactors are modeled as current
injection sources. The voltage relates to the source is the no load voltage, and it can be
equal to the source voltage. The other part can not be determined directly, and should be
determine through the following procedure:
Form the Y and estimate nodes voltages
Order and factor the Y bus optimally
Calculate the injected current for each node
Compute the voltage mismatches using the injected bus currents and factored Y
Update the voltages applying the super-position principle
Repeat three above stages until convergence

4. Direct method. The previously mentioned methods are based on iterative computations.
Goswami and Basu present a method to solve the load flow directly. Here, the load flow
problem formulated in a way that the direct solution becomes feasible. Loads are
modeled as constant impedances instead of fixed P and Q. Then, KVL's are formed in
loops start from the source and last to the end loads. These equations are ordered in a way
that the node voltage is on one side. Regarding these equations, Z matrix is formed. The
Z matrix then converts to an up-triangular matrix, which is applied to direct solution of
the network.

~ 10 ~
 CHAPTER 2

“Theoretical Background”
The following part explains the theoretical background of load flow algorithm used in this
semester thesis.

2.1 Basic equations

It is assumed that the three-phase distribution system is balanced and can be represented by an
equivalent single line diagram. The line-to-ground capacitance at the distribution voltage level is
small and thus neglected [2, 4]. A simple model of a transmission line, which has been used in
the algorithm, is shown in Figure 1:

Figure 2.1 Model of a Transmission Line

A number of methods for power flow calculation use recursive equations in different forms
considering sending end ( - h end) or receiving end ( - h end). Those equations are proposed in
[2, 3, 5, 6, and 7] and will also be used in this work. The equations are given below:

The receiving end bus voltage considering sending end powers of the line is given
below:

…… 2.1
The receiving end bus voltage considering receiving end powers of the line is given
below:

.….. 2.2

~ 11 ~
 Using the value of receiving end bus voltage, the receiving end bus angle can be
calculated through the equation given below:

………..2.3

The line losses between the receiving and sending end buses and be
calculated using equations (4) and (5):

………2.4

………. 2.5

2.2 Dynamic data structure algorithm

The method used to store dynamic data structure details of a branch is explained below.
The following attributes were taken in to account when this method was developed [4] :-
1. Dynamic nature of data structures is such that it may be created and altered in the
execution stage.
2. Dynamic data structure required for holding the information of a branch must be compact
and addressable from any function.
3. Dynamic data structure must be flexible to accommodate any number of buses within a
branch.
4. Dynamic data structure must be flexible also to address data structures of branches that
emanate from the end of a branch.
The data structure of a branch needs to hold the following information according to [3]:
Parent bus to which the branch is connected;
Number of buses in the branch;
An array to store IDs of all the buses in the order of their location from the head of the
branch;
Number of branches emanating from the last bus of this branch;

~ 12 ~
 An array of pointers pointing to the data structures that store information of emanating
branches;

The schematic diagram of the dynamic data structure is shown in Figure 2.2. Starting from the
main substation, branches are sequentially stored in the data structure using a recursive function.

Figure 2.2 Schematic diagram of a dynamic data structure

The method creates the branch structures by starting at the main substation bus and then
recursively calling a function that forms the first branch by sequentially considering buses until it
finds one that has several branches emanating from it. Referring to Figure 2.3, which presents the
radial system used as an example in this work taken from reference [4], it builds the first branch
from bus 1 up to bus 3, where two branches emanate. Therefore the data structure created for the
branch labeled I, starts with bus 1 and ends with bus 3, comprising three buses. It has two
branches emanating from it, namely II and III. In the structure labeled I pointers that point
towards the structures storing details of branches II and III are stored. The recursive function

~ 13 ~
calls itself five times, once for each branch. This process proceeds until data structures for all the
branches are built.

Figure 2.3 Radial system used as an example in this work with all the branches displayed

A representation of the data structure storing details of branch I is shown in Figure 2.4.

Figure 2.4 Representation of the data structure storing details of branch I

~ 14 ~
2.3 Power flow calculation algorithm
The dynamic data structures presented above are highly flexible and very convenient for usage
by a recursive function that solves the power flow in the radial distribution network. The
recursive algorithm computes voltage magnitudes and phase angles at all buses of a radial
distribution system. It starts by computing the voltage at the furthest end of the first branch using
equation 2.2 . If there are branches emanating from this end bus, this algorithm recursively calls
itself to compute the state of the buses in these branches and the power they draw from the
furthest bus. This recursive call is continued until a branch is reached from which other branches
do not emanate. Then, the algorithm computes the voltage at the furthest bus using voltage
equation 2.2 , with knowledge of its load. Using the expressions for line losses equations 2.4 and
2.2 between the receiving and sending end buses, power loss in the transmission line is computed
connecting this bus and the next bus in a direction leading to the first bus of the branch . With
load known at bus and transmission power loss in the line between buses and known, the
algorithm computes the line load at bus . This process continues until the voltage has been
computed for the first bus. The phase angle of the voltage phasor at the - h bus could be
computed using the equation 2.3. In this work for convergence is checked whether the sum of
powers flowing out of the lines connected to each bus equals (or equals within a tolerable limit)
the net power injected into that bus by the connected generators and loads. Mathematically, this
convergence criterion is described in equations 2.6 and 2.7 where is a tolerance value.

…………2.6

.………2.7

In the MATLAB implementation, the net power injected in the equations 2.6 and 2.7 is in a
slightly different form, which is explained below. The following part explains the derivation of

~ 15 ~
the net apparent power in case of three bus network.

The basic voltage equations between buses 1 and 2 and buses 2 and 3 are:

…………………... 2.a

............................... 2.b
The net apparent power injected 2 into the bus 2 is:

............................... 2.c

From the equations (2.a),(2.b) and (2.c) the following equation for 2 is derived:

............................... 2.d
The final equation for calculation of the net apparent power injected, in which the self impedance
is contained, is given below. This form of the equation is implemented in the code.

So far, a method for the calculation of a distribution load flow without PV buses in a network has
been presented. A modification of this method is possible in order to calculate the load flow in a
distribution system with distributed generation with controllable bus voltage [2]. Any bus
containing a generator with voltage control possibility is represented as a PV bus. All other buses
in the distribution system are represented as PQ buses. The known variables and those to be
calculated during a load flow for PV and PQ buses are as follows:

~ 16 ~
  PV buses:

 known variables are active power and voltage magnitude;

 unknown variables are reactive power and voltage angle;

 PQ buses:
 known variables are active and reactive power;
 unknown variables are voltage magnitude and angle;

Equation 2.2 is used to calculate the voltage of a PQ bus, since the real and reactive powers are
known. A different method is used for calculating the reactive power injected into a PV bus .
With rearrangement of the previously given equation 2.2 , can be a variable to solve and
to be a known variable. Another method for calculating is to use the reactive power injection
equation, as given below:

………………….. 2.8

Due to real and reactive power limits of the generator, it is not sufficient to use the above
equation to calculate the of a PV bus. Once calculated, this value of can be used to
determine the amount of reactive power produced by the generator at that PV bus. The actions
that need to be taken for maximum and minimum reactive power generator limits ( , )
violations are outlined below :

~ 17 ~
 ……...2.9

The distribution load flow algorithm for networks with distributed generation is shown as a flow
chart in Figure 2.5. The subscript refers to the index of the current "receiving end bus" (refer to
Figure 1.1). The "start bus" should be the last bus at the end of a radial branch, as was mentioned
previously in the text, since the load flow iterates from the end of a radial branch up to the top-
most bus (which typically represents the substation bus). The values of and are calculated
with previously given equations 2.2 and 2.3. The reactive power injected into bus is
calculated for PV buses by using the above equations. Then can be used for calculation of the
reactive power generated at that bus . The procedures for generator reactive power limit
violations are given above. The convergence criteria remain the same as previously explained.

~ 18 ~
Figure 2.5 Load flow algorithm for networks with dispersed
generation

~ 19 ~
 Chapter-3
“Case Study”
In this chapter the above presented algorithm implemented in MATLAB code was employed for
a case study. A typical distribution network with DG units shown on Figure 3.1 taken from
reference [3] was used and the following studies were made:
 Study of the impact of DG units on network voltage profile;
 Study of the impact of DG units on active and reactive power flows in the lines;
 Study of the impact of DG units on line losses in the network.
In the studies two cases were considered: the network with DG units and without DG units.
Representative load profiles used in this work were taken from VDEW association of the
electrical energy industry in Germany [8] available on their web page. Representative generation
profiles except wind infeed were taken from EnBW Energie Baden-Württemberg Regional AG
from Germany [9] available on-line on their internet web page. The wind infeed profile used here
was taken from E.on Netz (Germany) [10] available on-line on their internet web page. More
detailed figures of load profiles used.

3.1 Network topology

The distribution network used in this case study is taken from reference [4]. Bus 3 is considered
as PV bus the rest of the buses are PQ buses with bus 1 as a slack bus. Bus 1 is main substation
bus, it is assumed that its voltage magnitude and angle are constant 1 . and 0
respectively. This network is derived from a German MV distribution network. The network has
rural character and supplies a small town and the surrounding rural area. The rated voltage level
of the network is 11 kV. It is supplied from a 110 kV transformer station with apparent power 1
MVA. Most connections are made with cables, but there are also sections of overhead lines. The
original network had 30 nodes. To reduce the size to a level that is suitable for DG integration
studies while maintaining the realistic character, the original network number of nodes is reduced
[4]. The resulting network from reference [4] proposed as a benchmark in this semester work is
shown in Figure 3.1. The total length of the lines in this distribution network is equal to about 15
km. Due to the fact that different countries have varying distribution network parameters, the
original values given for the German network were transferred into the per unit system. This
facilitates the adaptation of the benchmark to regionally varying parameters. In Figure 3.1 the

~ 20 ~
 distribution of generation and loads per bus is given and is slightly different from the one given
in reference [4]. Installed power per bus and per DG type is given below Table 3.1.

3.2 Load and Generation Profile

Biomass Households + 1
Industry
2

Households +
Industry
4 8

House holds
Biomass Biomass House holds
7
9
5 Industry
Industry PV
PV
House holds
10

Biomass Households +
6 Industry

House holds
11

Biomass House holds

Figure 3.1 Distribution network used as a benchmark network

~ 21 ~
BUS No . Pgen (KW) Qgen (KW) P load (KW) Q load (KW)
1 50 -80 90 30
2 0 0 0 0
3 0 0 90 30
4 30 5 80 25
5 0 0 80 25
6 0 0 80 25
7 40 -15 80 35
8 40 5 80 25
9 30 -10 80 35
10 40 -15 90 30
11 50 -80 80 25

Table 3.1 Load –Generation Active and Reactive Power

BUS BUS ( To) R X (ohm/km) Length R (ohm) L (mH)

(From) (ohm/km) (km)

1 2 0.579 0.367 2.82 1.63 3.29

2 3 0.164 0.113 4.42 0.725 1.59

3 4 0.262 0.121 0.61 0.159 0.235

3 8 0.202 0.122 2.99 0.604 1.06

4 5 0.354 0.129 0.56 0.198 0.230

5 6 0.336 0.126 1.54 0.517 0.618

7 8 0.294 0.123 1.67 0.036 0.650

8 9 0.339 0.130 0.32 0.109 0.133

9 10 0.399 0.133 0.77 0.307 0.326

10 11 0.367 0.133 0.33 0.121 0.118

Table 3.2 Line Data (Resistance and Inductance )

~ 22 ~
Simulink on MATLAB without Dispersed Generation

~ 23 ~
Simulink on MATLAB with Dispersed Generation

~ 24 ~
First, on Figure 3.2 and 3.3 active and reactive power loads on every bus during one working day
are shown. Reactive power loads are calculated from active power loads by assuming a power
factor of cos = 0.9. Active and reactive power generation on every bus in the period of one
working day is shown in Figures 3.4 and 3.5. Reactive power generation is calculated using the
graphic shown in Figure 3.5. In that graphic is the active power generation in a certain moment
of the day at a certain bus and is nominal active power generation in that bus. In our case
is 0.1 . for all PQ buses. This method for DG unit’s reactive power generation is required by
the grid codes [8]. According to them DG units should be helpful and convenient in voltage and
frequency control in the network. With reactive power generation according to the curve shown
on Figure 11 required helpful behavior from DG units for voltage control is achieved. This
procedure for calculation of reactive power generation was used for PQ buses. For PV buses this
is different, reactive power generation is calculated using equations 2.8 and 2.9 .The difference
between active load and active generation per bus is shown on Figure 3.6 and the difference
between reactive load and reactive generation is shown on Figure 3.7.

~ 25 ~
 Figure 3.2 Active power load per bus

Figure 3.3 Reactive Power load per bus

~ 26 ~
 Figure 3.4 Active power generation per bus

Figure 3.5 Reactive Power generation per bus

~ 27 ~
 Figure 3.6 Active load-generation per bus

Figure 3.7 Reactive load Generation per bus

~ 28 ~
3.3. Expected results of the load flow calculation
In Figures 3.8 and 3.9, voltage magnitudes are shown, respectively without and with dispersed
generation. Buses 1, 2 and 3 are in branch I as you can see from Figure 3. Branch II is consists
of buses 4, 5 and 6, branch III is consists of bus 8, branch IV is consists of buses 9, 10 and 11
and branch V is consists of bus 7. With comparison of voltage profiles given on Figures 14 and
15 it can be concluded that the voltage drop in the case without DG is larger than in the case
with DG. In the case without DG can be noticed that the voltage curve is following the load
profile curve and in the period of the day with increased load, the voltage drop is increased too.
While in the case with DG can be noticed improvement in the voltage profile. In some periods of
the day when there is low load, voltage goes even beyond 1 . value but in the given tolerance
limits.

~ 29 ~
Figure 3.8 Voltage profile without DG

Figure 3.9 Voltage Profile with DG

~ 30 ~
 Chapter 4
“Results”
4.1 Voltage profiles without DG

~ 31 ~
~ 32 ~
4.2 Active & Reactive power profile without DG

~ 33 ~
~ 34 ~
4.3 Voltage profiles with DG

Fig. Voltage profiles at bus 1, 2, 3, 4, 5 and 6

~ 35 ~
Fig. Voltage profiles at bus 7, 8, 9, 10, & 11
~ 36 ~
4.4 Active & Reactive power profile with DG

Fig. active and reactive power profiles for bus 1, 2, 3, 4, 5 & 6

~ 37 ~
Fig. active and reactive power profiles for bus 7, 8, 9, 10 & 11

~ 38 ~
 Chapter 5
“Conclusion”

In this semester work the distribution load flow algorithm presented in [2] and [4]
was implemented in MATLAB. The implemented code in MATLAB was used to
perform analyses of the impact of DG units on network voltage profile, on active
and reactive power flows in the lines and the impact of DG units on line losses in
the network. A representative example of distribution network in this work was
analyzed. Different types of representative distribution generation profiles and load
profiles were used in all the studies and comparisons are made between the cases
without and with presence of DG units in the network. The results from
comparisons were shown graphically and structured by bus from where part of the
overall impact of the presence of DG units in the network can be seen.

~ 39 ~
 APPENDIX A

Following is the MATLAB code that implements the presented load flow calculation algorithm.

File: start.m
Network = build_network;
Profiles = build_profiles;

Voltages(Profiles.time_intervals, Network.num_buses)=0;
Angles(Profiles.time_intervals, Network.num_buses)=0;
Ploads(Profiles.time_intervals, Network.num_buses)=0;
Qloads(Profiles.time_intervals, Network.num_buses)=0;
Pgen(Profiles.time_intervals, Network.num_buses)=0;
Qgen(Profiles.time_intervals, Network.num_buses)=0;
Plosses(Profiles.time_intervals, Network.num_buses)=0;
Qlosses(Profiles.time_intervals, Network.num_buses)=0;
Pbus(Profiles.time_intervals, Network.num_buses)=0;
Qbus(Profiles.time_intervals, Network.num_buses)=0;
for i=1:Profiles.time_intervals
Results = compute_DLF(Network, Profiles, i);
for k=1:Network.num_buses
Voltages(i,k)=Results.buses(k).V;
Angles(i,k)=Results.buses(k).delta;
Ploads(i,k)=Results.buses(k).P_load;
Qloads(i,k)=Results.buses(k).Q_load;
Pgen(i,k)=Results.buses(k).P_gen;
Qgen(i,k)=Results.buses(k).Q_gen;
Plosses(i,k)=Results.P_loss(k);
Qlosses(i,k)=Results.Q_loss(k);
Pbus(i,k)=Results.P_per_bus(k);
Qbus(i,k)=Results.Q_per_bus(k);
end

~ 40 ~
end
plot_results(Voltages, Angles, Ploads, Qloads,Pgen,Qgen,Plosses,Qlosses,Pbus,Qbus);

File: build_network.m
function [Network] = build_network
file1 = 'incidence_matrix_11.dat';
file3 = 'resistance_11.dat';
file4 = 'reactance_11.dat';
A=load(file1);
C=load(file3);
D=load(file4);
clear file1 file3 file4
Network.S_B = 1000; % kVA
Network.V_B = 11; % kV
branches=struct('ID',0,'parent_bus_ID',0,'num_buses_in_branch',0,'array_bus_IDs',0','num_branc
hes_em',0,'array_head_busIDs_em_branches',[],'neigh_branches',[]);
branches = create_structure(branches, 1, 1, A, 0);
Network.branches = branches;
s=size(branches,2);
for i=1:s
branches(i)
end
clear branches;
Network.num_branches=size(Network.branches,2);
Network.num_buses=size(A,2);
resistance=C;
resistance=resistance+resistance'; %make it symmetric
resistance=resistance./400; % divide by impedance base
reactance=D;
reactance=1*(reactance+reactance'); %make it symmetric
reactance=reactance./400; % divide by impedance base
Network.resistance = resistance;
Network.reactance = reactance;
Network.z=zeros(Network.num_buses);

~ 41 ~
Network.teta=zeros(Network.num_buses);
for i=1:Network.num_buses
for j=1:Network.num_buses
Network.z(i,j)=sqrt(Network.resistance(i,j)^2+Network.reactance(i,j)^2);
if Network.resistance(i,j)~=0
Network.teta(i,j)=atan(Network.reactance(i,j)/Network.resistance(i,j));
end
end
end
clear resistance reactance A B C D

File: build_profiles.m
function [Profiles] = build_profiles
Pload=load('P_load_work.dat');
Profiles.P_load = Pload;
Profiles.Q_load = Profiles.P_load*tan(acos(0.95));
PVPQinfo=load('PV_PQ_info11.dat');
Profiles.PVPQinfo=PVPQinfo;
Voltages_init=load('Voltages_init11.dat');
Profiles.Voltages_init=Voltages_init;
Pgen=load('Pgen.dat');
Pn=0.7;
Profiles.P_gen = Pgen;
for i=1:size(Pgen,1)
for j=1:size(Pgen,2)
if((Profiles.P_gen(i,j)/Pn)==0)
Profiles.Q_gen(i,j)=0;
elseif ((Profiles.P_gen(i,j)/Pn)<=0.1)
Profiles.Q_gen(i,j)=Profiles.P_gen(i,j)*tan(acos(0.9));
elseif ((Profiles.P_gen(i,j)/Pn)>=0.9)
Profiles.Q_gen(i,j)=-Profiles.P_gen(i,j)*tan(acos(0.9));
elseif ((Profiles.P_gen(i,j)/Pn)>0.1) &&((Profiles.P_gen(i,j)/Pn)<=0.5)
Profiles.Q_gen(i,j)=Profiles.P_gen(i,j)*tan(acos(0.9+0.25*((Profiles.P_gen(i,j)/Pn)-0.1)));

~ 42 ~
else
Profiles.Q_gen(i,j)=-Profiles.P_gen(i,j)*tan(acos(1-0.25*((Profiles.P_gen(i,j)/Pn)-0.5)));
end
end
end
Profiles.time_intervals=size(Pload,1);

File: compute_DLF.m
function [Results] = compute_DLF(Network, Profiles, t)
fprintf('*******************************\n\t\tTime
Interval:d\n*******************************\n', t)
%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%specify number of iterations
num_itr=100;
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%
% Inititalize the result structure
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%
Results.buses=struct('ID',0,'P_load',0,'Q_load',0,'P_gen',0,'Q_gen',0,'V',1,'delta',0,'isPV',0);
for i=1:Network.num_buses
if ~isempty(Results.buses) && isstruct(Results.buses)
Results.buses(i)=struct('ID',i,'P_load',Profiles.P_load(t,i),'Q_load',Profiles.Q_load(t,i),'P_gen',Pr
ofiles.P_gen(t,i),'Q_gen',Profiles.Q_gen(t,i),'V',Profiles.Voltages_init(i),'delta',0,'isPV',Profiles.P
VPQinfo(i));
end
end
clear i
Results.dP(1:Network.num_buses)=0;
Results.dQ(1:Network.num_buses)=0;
%Initialize vectors containing data
Results.P_per_branch(1:Network.num_branches)=0;

~ 43 ~
Results.Q_per_branch(1:Network.num_branches)=0;
Results.P_loss(1:Network.num_buses)=0;
Results.Q_loss(1:Network.num_buses)=0;
Results.P_per_bus(1:Network.num_buses)=0;
Results.Q_per_bus(1:Network.num_buses)=0;
Results.P_gen(1:Network.num_buses)=0;
Results.Q_gen(1:Network.num_buses)=0;
Results.V(1:Network.num_buses)=0;
Results.delta(1:Network.num_buses)=0;
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%
% Start the iterations
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%
for itr = 1:num_itr
% fprintf('*******************************\n\t\tIterationnumber:
%d\n*******************************\n', itr)
%call the function that calculates the load for every bus.
The
%calculation starts for the first branch but inside the
%function
%calculate_load.m it is called recursivly for all thebranches
[Results.buses, Results.P_per_branch, Results.Q_per_branch,Results.P_loss, Results.Q_loss,
Results.P_per_bus,Results.Q_per_bus]=calculate_load(Network.branches(1),Results.buses,
Network, Results.P_per_bus, Results.Q_per_bus,Results.P_loss, Results.Q_loss,
Results.P_per_branch,Results.Q_per_branch);
P(1:Network.num_buses)=0; % P receiving (used forconvergence check)
Q(1:Network.num_buses)=0; % Q receiving (used forconvergence check)
%For all the buses calculate the differences.
for br=1:Network.num_branches
for n=1:Network.branches(br).num_buses_in_branch
m=Network.branches(br).array_bus_IDs(n);
~ 44 ~
if (n<Network.branches(br).num_buses_in_branch)
%calculation for all but last bus in a branch
% k-m-l busses
l=Network.branches(br).array_bus_IDs(n+1);
if((n==1)&&(br==1))
P(m)=0; Q(m)=0;
elseif ((n==1)&&(br>1))
k=Network.branches(br).parent_bus_ID;
P(m)=Results.buses(m).V*Results.buses(k).V*cos(Results.buses(m).delta-
Results.buses(k).delta+Network.teta(m,k))/Network.z(m,k)+Results.buses(m).V*Results.buses(l)
.V*cos(Results.buses(m).delta-Results.buses(l).delta+Network.teta(m,l))/Network.z(m,l)-
Results.buses(m).V^2*(cos(Network.teta(m,k))/Network.z(m,k)+cos(Network.teta(m,l))/Networ
k.z(m,l));
Q(m)=Results.buses(m).V*Results.buses(k).V*sin(Results.buses(m).delta-
Results.buses(k).delta+Network.teta(m,k))/Network.z(m,k)+Results.buses(m).V*Results.buses(l)
.V*sin(Results.buses(m).delta-Results.buses(l).delta+Network.teta(m,l))/Network.z(m,l)-
Results.buses(m).V^2*(sin(Network.teta(m,k))/Network.z(m,k)+sin(Network.teta(m,l))/Network
.z(m,l));
else
k=Network.branches(br).array_bus_IDs(n-1);
P(m)=Results.buses(m).V*Results.buses(k).V*cos(Results.buses(m).delta-
Results.buses(k).delta+Network.teta(m,k))/Network.z(m,k)+Results.buses(m).V*Results.buses(l)
.V*cos(Results.buses(m).delta-Results.buses(l).delta+Network.teta(m,l))/Network.z(m,l)-
Results.buses(m).V^2*(cos(Network.teta(m,k))/Network.z(m,k)+cos(Network.teta(m,l))/Networ
k.z(m,l));
Q(m)=Results.buses(m).V*Results.buses(k).V*sin(Results.buses(m).delta-
Results.buses(k).delta+Network.teta(m,k))/Network.z(m,k)+Results.buses(m).V*Results.buses(l)
.V*sin(Results.buses(m).delta-Results.buses(l).delta+Network.teta(m,l))/Network.z(m,l)-
Results.buses(m).V^2*(sin(Network.teta(m,k))/Network.z(m,k)+sin(Network.teta(m,l))/Network
.z(m,l));
end
else %calculation for last bus in a branch
for nl=1:Network.branches(br).num_branches_em;
%for all the neighbor busses from the emanating neighborbranches
~ 45 ~
l=Network.branches(br).array_head_busIDs_em_branches(nl);
P(m)=P(m)+Results.buses(m).V*Results.buses(l).V*cos(Results.buses(m).delta-
Results.buses(l).delta+Network.teta(m,l))/Network.z(m,l)-
Results.buses(m).V^2*cos(Network.teta(m,l))/Network.z(m,l);
Q(m)=Q(m)+Results.buses(m).V*Results.buses(l).V*sin(Results.buses(m).delta-
Results.buses(l).delta+Network.teta(m,l))/Network.z(m,l)-
Results.buses(m).V^2*sin(Network.teta(m,l))/Network.z(m,l);
end
if(n==1)
k=Network.branches(br).parent_bus_ID;
else
k=Network.branches(br).array_bus_IDs(n-1);
end
P(m)=P(m)+Results.buses(m).V*Results.buses(k).V*cos(Results.buses(m).delta-
Results.buses(k).delta+Network.teta(m,k))/Network.z(m,k)-
Results.buses(m).V^2*cos(Network.teta(m,k))/Network.z(m,k);
Q(m)=Q(m)+Results.buses(m).V*Results.buses(k).V*sin(Results.buses(m).delta-
Results.buses(k).delta+Network.teta(m,k))/Network.z(m,k)-
Results.buses(m).V^2*sin(Network.teta(m,k))/Network.z(m,k);
end
end
end
%For all the buses calculate the differences.
for i=2:Network.num_buses
dP(i)=P(i) - Results.buses(i).P_load +Results.buses(i).P_gen;
dQ(i)=Q(i) - Results.buses(i).Q_load +Results.buses(i).Q_gen;
Results.P_gen(i)=Results.buses(i).P_gen;
Results.Q_gen(i)=Results.buses(i).Q_gen;
Results.P_load(i)=Results.buses(i).P_load;
Results.Q_load(i)=Results.buses(i).Q_load;
Results.V(i)=Results.buses(i).V;
Results.delta(i)=Results.buses(i).delta;
end
end
~ 46 ~
fprintf('Error for Active Power: \n')
dP
P
fprintf('Error for Reactive Power: \n')
dQ
Q

File: calculate_load.m
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%
%%This function is called recursivly: if the parent branch has children
%%branches that are no calculated, then calculate for them fist.
%%P_branch,Q_branch contain the calculated P and Q powers starting from the
%%last bus and going up to the top of the branch.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%
function [buses, P_branch, Q_branch, P_loss, Q_loss, P_bus,Q_bus] = calculate_load(branch,
buses, Network, P_bus, Q_bus,P_loss, Q_loss, P_branch, Q_branch )
k=branch.ID; % id of the branch that is being calculated
P_branch(k)=0;
Q_branch(k)=0;
%if the branch has children
if (branch.num_branches_em~=0)
for i=1:branch.num_branches_em % for each child
child_branch=branch.neigh_branches(i);
[buses, P_branch, Q_branch, P_loss, Q_loss, P_bus,Q_bus] = calculate_load(child_branch,
buses, Network, P_bus,Q_bus, P_loss, Q_loss, P_branch, Q_branch); %recusivly calculateabout
the child
P_branch(k)=P_branch(k)+P_branch(child_branch.ID); %
add the total absorbed P of the child branch
Q_branch(k)=Q_branch(k)+Q_branch(child_branch.ID); %
add the total absorbed Q of the child branch
end

~ 47 ~
end
% fprintf('********** Calculating for branch: %d **********\n', k)
% if (branch.num_buses_in_branch>1) % if the branch has more
than 1 buses
for n=branch.num_buses_in_branch:-1:1 % start from thelast bus until the second one
j=branch.array_bus_IDs(n);
%%The following part is needed in order to calculate the powers between
%%the fist bus of each branch and the parent bus ofit. Exception is
%%only the first branch of the network, where thecurrent power is summed up.
if n == 1,
if(branch.array_bus_IDs(branch.num_buses_in_branch)~=Network.branches(k).parent_bus_ID)
% now calculate for the fist bus of the branchand the parent bus
i=Network.branches(k).parent_bus_ID;
else
i = 0;
end
else
i=branch.array_bus_IDs(n-1);
end
if (i~=0)
if (buses(j).isPV) %if the bus is PV bus
Qmin=-buses(j).P_gen*tan(acos(0.9));
Qmax=buses(j).P_gen*tan(acos(0.9));
P_branch(k)= P_branch(k) + buses(j).P_load -buses(j).P_gen; % add the load of the bus to the
total absorbedP of the branch
Qs=Q_branch(k);
%
Q_branch(k)=calculate_Q(j,n,k,Network,buses);
%
Q_branch(k)=(P_branch(k)*Network.reactance(i,j)-
buses(j).V*buses(i).V*sin(buses(i).deltabuses(j).delta))/Network.resistance(i,j);
w=buses(j).V^2*Network.reactance(i,j)/(Network.reactance(i,j)^2+Network.resistance(i,j)^2);
q=(buses(j).V^4-
buses(j).V^2*buses(i).V^2+2*buses(j).V^2*P_branch(k)*Network.resistance(i,j)+P_branch(k)^2
~ 48 ~
*Network.resistance(i,j)^2+P_branch(k)^2*Network.reactance(i,j)^2)/(Network.reactance(i,j)^2
+Network.resistance(i,j)^2);Q_branch(k)=-w+sqrt(w^2-q);
buses(j).Q_gen=Qs-Q_branch(k)+buses(j).Q_load;
% fprintf('Calculation for bus : %d \n',j)
% fprintf('Calculation for Qs: %6.5f\n',Qs)
% fprintf('Calculation for Qj: %6.5f\n',Q_branch(k))
% fprintf('Calculation for Qload: %6.5f\n',buses(j).Q_load)
% fprintf('Calculation for Q gen=Qs-Qj+Q_load: %6.5f \n',buses(j).Q_gen)
violation=0;
if (buses(j).Q_gen>Qmax)
buses(j).Q_gen=Qmax;
Q_branch(k)=Qs+buses(j).Q_loadbuses(j).Q_gen;
violation=1;
elseif (buses(j).Q_gen<Qmin)
buses(j).Q_gen=Qmin;
Q_branch(k)=Qs+buses(j).Q_loadbuses(j).Q_gen;
violation=1;
end
if (violation)
% recalculate the voltage of the bus incase of Qgen violation
a=(Network.resistance(i,j)*P_branch(k)+Network.reactance(i,j)*Q_branch(k)-buses(i).V^2/2)^2;
b=(Network.resistance(i,j)^2+Network.reactance(i,j)^2)*(P_branch(k)^2+Q_branch(k)^2);
c=(Network.resistance(i,j)*P_branch(k)+Network.reactance(i,j)*Q_branch(k)-buses(i).V^2/2);
buses(j).V=sqrt(sqrt(a-b)-c);
end
else % if the bus is PQ bus
P_branch(k)= P_branch(k) + buses(j).P_load -buses(j).P_gen; % add the load of the bus to the
total absorbedP of the branch
Q_branch(k)= Q_branch(k) + buses(j).Q_load -buses(j).Q_gen; % add the load of the bus to the
total absorbed Q of the branch% calculate the voltage of the bus
a=(Network.resistance(i,j)*P_branch(k)+Network.reactance(i,j)*Q_branch(k)-buses(i).V^2/2)^2;
b=(Network.resistance(i,j)^2+Network.reactance(i,j)^2)*(P_branch(k)^2+Q_branch(k)^2);
c=(Network.resistance(i,j)*P_branch(k)+Network.reactance(i,j)*Q_branch(k)-buses(i).V^2/2);
buses(j).V=sqrt(sqrt(a-b)-c);
~ 49 ~
end
P_bus(j)=P_branch(k);
Q_bus(j)=Q_branch(k);
buses(j).delta=buses(i).deltaasin((P_branch(k)*Network.reactance(i,j)-
Q_branch(k)*Network.resistance(i,j))/(buses(i).V*buses(j).V));
P_loss(j)=Network.resistance(i,j)*(P_branch(k)^2+Q_branch(k)^2)/buses(j).V^2;
Q_loss(j)=Network.reactance(i,j)*(P_branch(k)^2+Q_branch(k)^2)/buses(j).V^2;
P_branch(k)=P_branch(k)+P_loss(j);
Q_branch(k)=Q_branch(k)+Q_loss(j);
else
P_bus(j)=P_branch(k)+buses(j).P_loadbuses(j).P_gen;
Q_bus(j)=Q_branch(k)+buses(j).Q_loadbuses(j).Q_gen;
end
end

File: plot_results.m
function plot_results(Voltages, Angles, Ploads,Qloads,Pgen,Qgen,Plosses,Qlosses,Pbus,Qbus)
figure(1)
for i=1:size(Voltages,2)
subplot(3,4,i);
plot(Voltages(:,i),'--bs','LineWidth',2,...
'MarkerEdgeColor','k',...
'MarkerFaceColor','b',...
'MarkerSize',3);
xlabel('Intervals')
ylabel('Voltage')
axis([0 100 0.9 1])
ttl=['Bus ' int2str(i)];
title(ttl);
end
figure(2)
for i=1:size(Angles,2)
subplot(3,4,i);

~ 50 ~
plot(Angles(:,i),'--bs','LineWidth',2,...
'MarkerEdgeColor','k',...
'MarkerFaceColor','b',...
'MarkerSize',3);
xlabel('Intervals')
ylabel('Angles')
axis([0 100 -0.014 0.014])
ttl=['Bus ' int2str(i)];
title(ttl);
end
figure(3)
for i=1:size(Ploads,2)
subplot(3,4,i);
plot(Ploads(:,i),'--bs','LineWidth',2,...
'MarkerEdgeColor','k',...
'MarkerFaceColor','b',...
'MarkerSize',3);
xlabel('Intervals')
ylabel('P loads')
ttl=['Bus ' int2str(i)];
title(ttl);
end
figure(4)
for i=1:size(Qloads,2)
subplot(3,4,i);
plot(Qloads(:,i),'--bs','LineWidth',2,...
'MarkerEdgeColor','k',...
'MarkerFaceColor','b',...
'MarkerSize',3);
xlabel('Intervals')
ylabel('Q loads')
axis([0 100 0 0.4])
ttl=['Bus ' int2str(i)];
title(ttl);
~ 51 ~
end
figure(5)
for i=1:size(Pgen,2)
subplot(3,4,i);
plot(Pgen(:,i),'--bs','LineWidth',2,...
'MarkerEdgeColor','k',...
'MarkerFaceColor','b',...
'MarkerSize',3);
xlabel('Intervals')
ylabel('P generation')
ttl=['Bus ' int2str(i)];
title(ttl);
end
figure(6)
for i=1:size(Qgen,2)
subplot(3,4,i);
plot(Qgen(:,i),'--bs','LineWidth',2,...
'MarkerEdgeColor','k',...
'MarkerFaceColor','b',...
'MarkerSize',3);
xlabel('Intervals')
ylabel('Q generation')
ttl=['Bus ' int2str(i)];
title(ttl);
end
figure(7)
for i=2:size(Plosses,2)
subplot(3,4,i-1);
plot(Plosses(:,i),'--bs','LineWidth',2,...
'MarkerEdgeColor','k',...
'MarkerFaceColor','b',...
'MarkerSize',3);
xlabel('Intervals')
ylabel('P losses')
~ 52 ~
axis([0 100 0 0.25])
ttl=['Line between buses ' int2str(i)];
title(ttl);
end
figure(8)
for i=2:size(Qlosses,2)
subplot(3,4,i-1);
plot(Qlosses(:,i),'--bs','LineWidth',2,...
'MarkerEdgeColor','k',...
'MarkerFaceColor','b',...
'MarkerSize',3);
xlabel('Intervals')
ylabel('Q losses')
axis([0 100 0 0.25])
ttl=['Line between buses ' int2str(i)];
title(ttl);
end
figure(9)
for i=1:size(Pbus,2)
subplot(3,4,i);
plot(Pbus(:,i),'--bs','LineWidth',2,...
'MarkerEdgeColor','k',...
'MarkerFaceColor','b',...
'MarkerSize',3);
xlabel('Intervals')
ylabel('P per line')
axis([0 100 0 10])
ttl=['Bus ' int2str(i)];
title(ttl);
end
figure(10)
for i=1:size(Qbus,2)
subplot(3,4,i);
plot(Qbus(:,i),'--bs','LineWidth',2,...
~ 53 ~
'MarkerEdgeColor','k',...
'MarkerFaceColor','b',...
'MarkerSize',3);
xlabel('Intervals')
ylabel('Q per line')
axis([0 100 0 10])
ttl=['Bus ' int2str(i)];
title(ttl);
end

~ 54 ~
 APPENDIX B

E-TAP SIMULATION OF ANALYSED NETWORK WITH FAST

DECOUPLED METHOD TO COMPARE THE RESULTS

Simulation without DG
~ 55 ~
Output of Simulation without DG
~ 56 ~
Simulation with DG
~ 57 ~
Output of Simulation with DG
~ 58 ~
 References

[1] N.I. Voropai: Distributed Generation in Electric Power Systems The DIGESEC CRIS
Workshop, Magdeburg, Germany, Dec. 6-8, 2006

[2] A. Rost, B. Venkatesh and C. P. Diduch: Distribution System with Distributed

Generation Load Flow Department of Electrical and Computer Engineering New
Brunswick, NB, Canada

[3] B. Venkatesh and R. Ranjan: Data Structure for Radial Distribution System Load
Flow Analysis IEE Proc.-Gener. Transm. Distrib. Vol 150 No.1 January 2003

[4] K. Rudion, A. Orths, Z. A. Styczynski, K. Strunz: Design of Benchmark of Medium

Voltage Distribution Network for Investigatioof DG Integration

[5] G. Renato Cespedes: New Method for the Analysis of Distribution Network IEEE
Transactions on Power Delivery, Vol. 5, No. 1, January 1990

[6] S. Ghosh and D. Das: Method for Load-Flow Solution of Radial Distribution
Networks IEE Proc.- Gener. Transm. Distrib., Vol. 146, No. 6, November 1999

[7] G. B. Jasmon and L. H. C. C. Lee: Stability of Load-flow Techniques for Distribution

System Voltage Stability Analysis IEE Proceedings-C, Vol. 138, No. 6, November 1991

[8]„BDEW“:Technische Richtlinie “Erzeugungsanlagen am Mittelspannungsnetz”

BDEW, June 2008

[9] „EnBW Energie Baden-Württemberg Regional AG“: http://www.enbw.com

[10] „E.on Netz (Germany)“: http://www.eon-energie.com

~ 59 ~