Optimal location and sizing of DG IEEE 33

The optimal location and sizing of distributed generation (DG) units in a power distribution system can be determined using various optimization techniques. One approach is to use a Matlab code to simulate the power distribution system and optimize the placement and size of the DG units to meet certain objectives, such as minimizing losses, maximizing power quality, or maximizing renewable energy penetration.

In the IEEE 33 Bus System, the power distribution system is represented by a network of buses, each representing a node in the system where energy is generated, consumed, or transmitted. The Matlab code can be used to simulate the operation of the system under different scenarios, such as different load patterns, different renewable energy sources, and different DG configurations.

To optimize the location and sizing of DG units in the system, the Matlab code can use an optimization algorithm, such as a genetic algorithm, particle swarm optimization, or linear programming. The optimization algorithm searches for the optimal configuration of DG units that minimizes the objective function, which represents the cost or performance metric of the system.

The Matlab code can also include constraints on the DG units, such as maximum size, maximum power output, and minimum power output. These constraints can be used to ensure that the DG units operate within their technical limits and meet regulatory requirements.

Overall, the Matlab code for the optimal location and sizing of DG units in the IEEE 33 Bus System can be used to analyze and optimize the performance of a power distribution system with distributed generation.

Power Generation Industry

Power generation is an ever-growing industry that has applications in everything from residential to commercial use. One of the most important components of power production is the generator. Generators can be stand-alone units or they may be incorporated into other systems, such as solar panels that have battery storage.

The type of generator you need will depend on your application. Standalone generators are great for producing energy at low demand times, whereas systemized generators are better when high demands for electricity exist.

In this article, we will look at one common type of distributed generation (DG) equipment – photovoltaic (PV) panels! We will also perform some mathematical analysis on a simple circuit using PV cells to determine the optimal placement and size of these cells.

We will assume that the bus bars do not affect the resistance value of the circuit so we will ignore them here. This will make our calculations much simpler because we no longer have to consider what effect they would have on the results!

IEEE grid diagram

This article will apply the theory described in previous chapters to analyze how to maximize the performance of a DG unit. To begin with, we must know where to locate the PV panel(s).

There are two main factors that influence the location of a PV array: potential cost savings and efficiency gains. The first factor evaluates whether it makes more sense to install the PV device close to the load or far away.

clc;
close all,
format short;
tic
m=load('loaddata33bus.m');
l=load('linedata33bus.m');

% m=load('loaddata69bus.m');
% l=load('linedata69bus.m');
PL_Cmp=10^7;
br=length(l);
no=length(m);
f=0;
d=0;
MVAb=100;
KVb=12.66;
Zb=(KVb^2)/MVAb;
% Per unit Values
for i=1:br
    R(i,1)=(l(i,4))/Zb;
    X(i,1)=(l(i,5))/Zb;
end
for i=1:no
    P(i,1)=((m(i,2))/(1000*MVAb));
    Q(i,1)=((m(i,3))/(1000*MVAb));
end
R;
X;
P;
Q;
C=zeros(br,no);
for i=1:br
    a=l(i,2);
    b=l(i,3);
    for j=1:no
        if a==j
            C(i,j)=-1;
        end
        if b==j
            C(i,j)=1;
        end
    end
end
C;
e=1;
for i=1:no
    d=0;
    for j=1:br
        if C(j,i)==-1
            d=1;
        end
    end
    if d==0
        endnode(e,1)=i;
        e=e+1;
    end
end
endnode;
h=length(endnode);
for j=1:h
    e=2;
    
    f=endnode(j,1);
   % while (f~=1)
   for s=1:no
     if (f~=1)
       k=1;  
       for i=1:br
           if ((C(i,f)==1)&&(k==1))
                f=i;
                k=2;
           end
       end
       k=1;
       for i=1:no
           if ((C(f,i)==-1)&&(k==1));
                f=i;
                g(j,e)=i;
                e=e+1;
                k=3;
           end            
       end
     end
   end
end
for i=1:h
    g(i,1)=endnode(i,1);
end
g;
w=length(g(1,:));
for i=1:h
    j=1;
    for k=1:no 
        for t=1:w
            if g(i,t)==k
                g(i,t)=g(i,j);
                g(i,j)=k;
                j=j+1;
             end
         end
    end
end
g;
for k=1:br
    e=1;
    for i=1:h
        for j=1:w-1
            if (g(i,j)==k) 
                if g(i,j+1)~=0
                    adjb(k,e)=g(i,j+1);            
                    e=e+1;
                else
                    adjb(k,1)=0;
                end
             end
        end
    end
end
adjb;
for i=1:br-1
    for j=h:-1:1
        for k=j:-1:2
            if adjb(i,j)==adjb(i,k-1)
                adjb(i,j)=0;
            end
        end
    end
end
adjb;
x=length(adjb(:,1));
ab=length(adjb(1,:));
for i=1:x
    for j=1:ab
        if adjb(i,j)==0 && j~=ab
            if adjb(i,j+1)~=0
                adjb(i,j)=adjb(i,j+1);
                adjb(i,j+1)=0;
            end
        end
        if adjb(i,j)~=0
            adjb(i,j)=adjb(i,j)-1;
        end
    end
end
adjb;
for i=1:x-1
    for j=1:ab
        adjcb(i,j)=adjb(i+1,j);
    end
end
b=length(adjcb);

% voltage current program

for i=1:no
    vb(i,1)=0.99;
end
% for s=1:10
iterations = 1;
inertia = 1.0;
correction_factor = 2.0;
swarms = 50;

% ---- initial swarm position -----
swarm=zeros(50,7);
step = 1;
for i = 1 : 50
swarm(step, 1:7) = i;
step = step + 1;
end

swarm(:, 7) = 1000;       % Greater than maximum possible value
swarm(:, 5) = 0;          % initial velocity
swarm(:, 6) = 0 ;         % initial velocity

%% Iterations
for iter = 1 : iterations
    
    %-- position of Swarms ---
    for uu = 1 : swarms;
        swarm(uu, 1) = swarm(uu, 1) + swarm(uu, 5)/1.2;     %update u position
        swarm(uu, 2) = swarm(uu, 2) + swarm(uu, 6)/1.2;     %update v position
        u = swarm(uu, 1);
        v = swarm(uu, 2);

for i=1:no
    nlc(i,1)=conj(complex(P(i,1),Q(i,1)))/(vb(i,1));
end
nlc;
for i=1:br
    Ibr(i,1)=nlc(i+1,1);
end
Ibr;
Ibr1=Ibr;
xy=length(adjcb(1,:));
for i=br-1:-1:1
    for k=1:xy
        if adjcb(i,k)~=0
            u=adjcb(i,k);
            %Ibr(i,1)=nlc(i+1,1)+Ibr(k,1);
            Ibr(i,1)=Ibr(i,1)+Ibr(u,1);
        end
    end      
end
Ibr;
Ibr2=Ibr;

%DG1
Reall = 3715;
Reactivee = 2300;
AP_Power = sqrt((Reall )^2 + (Reactivee)^2) ;                 % Appearent Power KVA
Penetration = 30/100 ;
AP_Power = AP_Power * Penetration; 
AP_Pu = AP_Power/(1000*MVAb);   % Converting to per unit
P_Factor   = 0.85;                 % Power Factor
Real_Power = AP_Pu * P_Factor;
Rect_Power = (AP_Pu * (sin (acos (P_Factor))));
 
for ii=32:-1:2
    DG_Location=ii;
    for jj= 0:0.001:Real_Power  % Take Appearent Power Power
        DG_Size = complex(Real_Power,Rect_Power * (-1));
iiii=ii;         
    Ibr=Ibr2;
    Ibr(ii,1)=DG_Size;
    %
            if ii <= 18
    for iii= ii-1:-1:2
    jjj=iii+1;
    Ibr(iii,1)=Ibr(jjj,1)-Ibr1(jjj,1);
    end
%         if ii~=18
%          bkk=1;
%      for iii=ii+1:18
%          bss(bkk)=Ibr1(iii,1); 
%          bkk = bkk + 1 ;
%      end
%     bss=sum(bss);    
% Ibr(ii+1,1)=bss;
%     for iii=ii+1:18
%      jjj=ii+1;
%     Ibr(iii,1)=Ibr(jjj,1)-Ibr1(jjj,1);    
%     end
%         end    
            end  
%
    if ii  >= 19 && ii <= 22        
    for iii= ii-1:-1:19
    jjj=iii+1;
    Ibr(iii,1)=Ibr(jjj,1)-Ibr1(jjj,1);
    end
%         if ii~=22
%          bkk=1;
%      for iii=ii+1:19
%          bss(bkk)=Ibr1(iii,1); 
%          bkk = bkk + 1 ;
%      end
%     bss=sum(bss);   
% Ibr(ii+1,1)=bss;
%     for iii=ii+1:19
%      jjj=ii+1;
%     Ibr(iii,1)=Ibr(jjj,1)-Ibr1(jjj,1);    
%     end
%         end    
    end
%
    if ii >= 23 && ii <= 25
    for iii= ii-1:-1:23
    jjj=iii+1;
    Ibr(iii,1)=Ibr(jjj,1)-Ibr1(jjj,1);
    end
%         if ii~=25
%          bkk=1;
%      for iii=ii+1:23
%          bss(bkk)=Ibr1(iii,1); 
%          bkk = bkk + 1 ;
%      end
%     bss=sum(bss);   
% Ibr(ii+1,1)=bss;
%     for iii=ii+1:23
%      jjj=ii+1;
%     Ibr(iii,1)=Ibr(jjj,1)-Ibr1(jjj,1);    
%     end
%         end    
    end  
    %
    if ii >= 27
                            for iii= ii-1:-1:26
                            jjj=iii+1;
                            Ibr(iii,1)=Ibr(jjj,1)-Ibr1(jjj,1);
                            end
%         bkk=1;
%         if ii~=32
%                 for iii=ii+1:32
%                 bss(bkk)=Ibr1(iii,1); 
%                 bkk = bkk + 1 ;
%                 end
%             bss=sum(bss);      
%         pp=ii+1;
%         Ibr(pp,1)=bss;
%             for iii=pp+1:32
%             Ibr(iii,1)=Ibr(pp,1)-Ibr1(pp,1);    
%             end
%         end
    end
    
Ibr(1,1)=Ibr(1,1) ;
Ibr(2,1)=Ibr(1,1)-Ibr1(1,1)- DG_Size;
Ibr(3,1)=Ibr(2,1)-Ibr1(2,1)-Ibr(18,1);
Ibr(4,1)=Ibr(3,1)-Ibr1(3,1)-Ibr(22,1);
Ibr(5,1)=Ibr(4,1)-Ibr1(4,1);

%%%

for i=2:no
      g=0;
      for a=1:b 
          if xy>1
            if adjcb(a,2)==i-1 
                u=adjcb(a,1);
                vb(i,1)=((vb(u,1))-((Ibr(i-1,1))*(complex((R(i-1,1)),X(i-1,1)))));
                g=1;
            end
            if adjcb(a,3)==i-1 
                u=adjcb(a,1);
                vb(i,1)=((vb(u,1))-((Ibr(i-1,1))*(complex((R(i-1,1)),X(i-1,1)))));
                g=1;
            end
          end
        end
        if g==0
            vb(i,1)=((vb(i-1,1))-((Ibr(i-1,1))*(complex((R(i-1,1)),X(i-1,1)))));
        end
end
% s=s+1;
% end
nlc;
Ibr;
vb;
 vbp=[abs(vb)]; % angle(vb)*(180/pi)];


for i=1:no
%     va(i,2:3)=vbp(i,1:2);
      va(i,2)=vbp(i,1);
end
for i=1:no
    va(i,1)=i;
end
va;


Ibrp=abs(Ibr); % angle(Ibr)*180/pi];
PL(1,1)=0;
QL(1,1)=0;

% losses
for f=1:br
    Pl(f,1)=(Ibrp(f,1)^2)*R(f,1);
    Ql(f,1)=X(f,1)*(Ibrp(f,1)^2);
    PL(1,1)=PL(1,1)+Pl(f,1);
    QL(1,1)=QL(1,1)+Ql(f,1);
end

Plosskw=(Pl)*100000;
Qlosskw=(Ql)*100000;
PL=(PL)*100000;
QL=(QL)*100000;


voltage = vbp(:,1);
% angle = vbp(:,2)*(pi/180);


PL_Sum=PL+QL;
if PL_Cmp > PL_Sum
   PL_Cmp = PL_Sum; 
   DG_Sizr=DG_Size;
   DG_Loc=DG_Location;
   voltr=voltage;
%    angle;
   PLr=PL;
   QLr=QL;
   Plosskwr=Plosskw;
   Qlosskwr=Qlosskw;
   Ibrr=Ibr;
end
    [temp, gbest] = min(swarm(:, 7));        % gbest position
    
    %--- updating velocity vectors
    for vv = 1 : swarms
        swarm(vv, 5) = rand*inertia*swarm(vv, 5) + correction_factor*rand*(swarm(vv, 3)...
            - swarm(vv, 1)) + correction_factor*rand*(swarm(gbest, 3) - swarm(vv, 1));   % u velocity parameters
        swarm(vv, 6) = rand*inertia*swarm(vv, 6) + correction_factor*rand*(swarm(vv, 4)...
            - swarm(vv, 2)) + correction_factor*rand*(swarm(gbest, 4) - swarm(vv, 2));   % v velocity parameters
    end
    
    % Plotting the swarm
%     clf    
%     plot(swarm(:, 1), swarm(:, 2), 'x');   % drawing swarm movements
%     axis([-2 50 -2 50]);
% pause(.0000000000000000001)      
    end
end
    end
end

toc;


%    DG_Sizr;
   DG_Sizrr=(abs(DG_Sizr))*1000*100;

%
Plosskwr(33,1)=PLr;
Qlosskwr(33,1)=QLr;

   DG_Location = DG_Loc + 1;
   
sprintf('Power-Loss= %d KW, Power-Loss= %d KVAr' ,PLr,QLr')  
sprintf('DG Location= %d , DG Power = %d KVA' ,DG_Location,DG_Sizrr') 
Sr=(1:33)';

plot(m(:,1),abs(voltr));

    %% EXCEL FOR DG
% %EXCEL
T =table(Sr,Plosskwr,Qlosskwr,voltr);        
T(:,1:4);
excel_file = 'DG1_IEEE33.xlsx';
writetable(T,excel_file,'Sheet',1,'Range','H1');

Calculate the sizing of the distributed generation unit based on output power and voltage

The next step in calculating your system’s total cost is to determine how much energy you will need to supply during operation hours. You can use an online tool or software that has computational methods for this.

There are two main ways to do this, by using either active or reactive powers. Active power calculates the amount of electricity being used at any given moment while reactive power looks at the effect of electrical current flowing from one part of the grid to another.

By looking at both active and reactive powers it becomes clear which parts of the grid cannot easily supply power due to resistance or lack of current flow. This is where DG comes into play as they create their own internal current source to compensate!

This article will go more in-depth about these concepts but first, we must talk about voltages.

Calculate the sizing of the distributed generation unit based on output power and current

Now that you have determined how many units of DG you need, your next task is to determine what size each one should be. This step is important as it can make a difference in whether or not the system will run smoothly!

There are two main factors that influence the performance of your DGs: their active power and their reactive power. The active power is simply the power being produced by the generator, so this would be calculated using equation 2 below. The total amount of active power generated equals the demand for energy times the efficiency of the generator.

As we saw before, the load factor plays an important role in determining the demand for energy, therefore it makes sense to focus more heavily on the efficiency of the generators. Unfortunately, there are no easy ways to find these numbers online, nor do most manufacturers publish them.

Luckily, you don’t have to take our word for it! There are some free software packages such as MATLAB that allow you to simulate different systems and calculate all sorts of information, including efficiency. All you have to do is input the model of the generator and then enter its load and voltage at which it runs under normal conditions (these cannot exceed its limits) and it spits out its efficiency.

You can test several models and pick the best one by comparing the efficiencies it produces! Another way to determine the efficiency of a generator is to look up past data.

% Line data IEEE 33
          1    1      2     0.0922    0.0470   
          2    2      3     0.4930    0.2511    
          3    3      4     0.3660    0.1864  
          4    4      5     0.3811    0.1941    
          4    5      6     0.8190    0.7070    
          6    6      7     0.1872    0.6188   
          7    7      8     0.7114    0.2351 
          8    8      9     1.0300    0.7400   
          9    9      10    1.0440    0.7400   
         10    10     11    0.1966    0.0650   
         11    11     12    0.3744    0.1238   
         12    12     13    1.4680    1.1550   
         13    13     14    0.5416    0.7129   
         14    14     15    0.5910    0.5260    
         15    15     16    0.7463    0.5450   
         16    16     17    1.2890    1.7210   
         17    17     18    0.7320    0.5740  
         18     2     19    0.2640    0.2565    
         19    19     20    1.5042    1.3554  
         20    20     21    0.4095    0.4784   
         21    21     22    0.7089    0.9373    
         22     3     23    0.4512    0.3083    
         23    23     24    0.8980    0.7091  
         24    24     25    0.8960    0.7011   
         25     6     26    0.2030    0.1034   
         26    26     27    0.2842    0.1447    
         27    27     28    1.0590    0.9337    
         28    28     29    0.8042    0.7006   
         29    29     30    0.5075    0.2585  
         30    30     31    0.9744    0.9630   
         31    31     32    0.3105    0.3619   
         32    32     33    0.3410    0.5302

% IEEE load data
    1	0         0  	  0
    2	100       60 	  0
    3	90        40      0  	
    4	120       80	  0  
    5	60        30	  0  
    6	60        20      0 
    7	200       100	  0
    8	200       100	  0 
    9	60        20      0	
    10	60        20 	  0
    11	45        30 	  0
    12	60        35      0 
    13	60        35      0 
    14	120       80      0 
    15	60        10      0 
    16	60        20      0 
    17	60        20      0 
    18	90        40      0 
    19	90        40      0 
    20	90        40      0 
    21	90        40      0
    22	90        40      0 
    23	90        50      0
    24	420       200	  0
    25	420       200	  0
    26	60        25      0  
    27	60        25      0 
    28	60        20      0
    29	120       70      0
    30	200       600	  0
    31	150       70      0  
    32	210       100	  0
    33	60        40      0

Calculate the sizing of the distributed generation unit based on output power and phase angle

Now that you have determined your cost, efficiency, and reliability parameters, it is time to determine how many units of DG you need to supply energy to the grid!

The next step in determining the size of your solar panel system is calculating the amount of power generated by each module. This calculation is done via what is known as I-V curve testing. The internal voltage drop across the panels will be used to calculate their power.

We can use our earlier results as an example. If one panel produces 1kW then there will be 1000w consumed due to resistance losses within the string. This is why we needed 2kw of series resistance in our calculations before!

To find the total power produced by all strings combine them together using Ohm’s law: Ptotal = V/(I+i) where VT represents the overall string terminal voltage, IO is current through the whole circuit, and i is the internal resistance of each cell (which we already calculated). By solving this equation for IT, we get iplevel=VT/(IO + iT). Plugging these values into our initial formula gives us: Power produced = IV * ln(IPC/IT)/1000

So, if a panel was producing 5 kW then its IPC would be 5 kW / 500 radians*ln(5/0.05)=2190 ohms.

Calculate the sizing of the distributed generation unit based on output power, voltage, and current

In our previous article, we calculated the overall capacity of this system to serve as a source of electricity for your home or business. This included how much energy the battery can store as well as the solar panel’s efficiency in converting sunlight into electricity. Now that you have all those numbers it is time to calculate where each device will be located to achieve its full potential.

We are going to assume that you already determined what type of batteries would work best for your situation (lithium-ion) and what size of battery you wanted to use. You also determined whether you needed high-performance (fast charging) or more budget-friendly (slower charging) units. If not, then feel free to move on to the next section now!

We are going to focus only on calculating the optimal placement of the battery here so that it produces the most efficient amount of power. Because there are two variables, distance from the distribution bus bar and altitude, there is an infinite number of possibilities to find the optimum location. Luckily, mathematicians have created software that does this for us!

Mathematical tools such as these allow computers to perform complex calculations quickly. These types of programs vary in cost depending on who designed them, but they are worth the expense if you want perfect results every time. Some even have graphical interfaces which make it easy to manipulate the settings and run tests.

Here we will look at one such tool called Energy Analyst by Anker.

Calculate the sizing of the distributed generation unit based on output power, voltage, and phase angle

Now that you have determined how many units of DG you need to add to the system, your next step is to determine what size each one should be. This includes deciding where they will run in the grid as well as what efficiency they should have when running. This can be done easily by distributed generation Matlab simulation via the Matlab script and Simulink model.

There are two main factors that influence this: location within the distribution network and string configuration with other generators in the area. The first factor impacts cost while the second factor impacts reliability.

As we discussed before, string configurations refer to connected strings of parallel wires that produce a similar effect as having more powerful transmission lines between them. Having these types of grids reduce the risk of blackouts as there are fewer pieces needed to connect all three phases.

This also means that any losses due to resistance from connecting too many cables together can lower the overall effectiveness of the system. It is best to try and stay away from highly populated areas or stations so that the connection does not affect the surrounding infrastructure negatively.

The second factor comes into play once again by looking at the costs associated with different locations. Power plants that use natural gas typically cost around $20 per MMBTU (million British thermal units) to run, which makes it expensive to just turn off during times of low demand.

This is why some plants are paid to constantly run even when energy demands are down- they supply power for free! Since most homes now have electricity supplied through utilities, finding an appropriate place to install your own generator is important.

Compare the results of each of the above methods

It is important to remember that not only does adding distributed generation influence where you get power, but it also changes how much power you generate at any given time.

By using different locations for the DG generators, you can find different optimal solutions in terms of cost. Try experimenting with all three to see which one gives you the best balance between lower costs and more power generated during peak times.

IEEE 37 Bus System using Artificial Bee Colony 

Calculate the sizing of the distributed generation unit based on power, voltage, and current using MATLAB

https://www.youtube.com/embed/NL-R_qw2qbY

In this section, we will use our installed generator as an example to determine how to size your grid-connected solar panel or wind turbine. To do this, you should first know what the nominal output is for the device. This is usually given in watts (for solar) or kilowatts (for wind turbines). A watt is really just a measure of energy so one can also say that it is dependent on time multiplied by volts times amps.

So if we take the sun’s power at its zenith during the middle of summer when the rays are strongest, then we can calculate how much electricity it would produce at that moment assuming there were no clouds or other factors preventing light from reaching the surface of the panel!

We will assume 1,000 Watts is the average midday maximum power production for a typical monocrystalline silicon photovoltaic module with 25% efficiency. Since these modules have both positive and negative electrodes, they actually generate a little less than half of a full cell but we will ignore this difference for now. Also, note that since we are talking about energy here, not instantaneous power, we need to multiply by time to get actual energy generated.

Now let us look at the system parameters needed to perform these calculations. The active load is defined as the loads being powered by the DG units which include all electronics such as inverters, controllers, etc. As well as resistive losses in the wires running to the devices themselves.

Calculate the sizing of the distributed generation unit based on power, voltage, and phase angle using MATLAB

To determine how many units of DG you need to install in order to meet your demand for electricity, we first need to know what our demand is for energy.

We use an equation called the Power Demand Equation (PDE) to calculate this value. The PDE calculates the total amount of power that will be consumed by all devices connected to the grid in a given time period.

The duration of the time period used in the calculation of the PDE is usually one hour, which makes it appropriate to use when calculating the demands on an hourly or daily basis.

In our case, we are looking at the demands per month so we will have to make the time period longer. We pick one day as our time frame due to consistency. One week would also work but would require more calculations because there would be fewer data points involved.

Contact us to get the optimal placement of distributed generation Matlab code.