^{1}

^{2}

Reliability of power systems is a key aspect in modern power system planning, design, and operation. The ascendance of the smart grid concept has provided high hopes of developing an intelligent network that is capable of being a self-healing grid, offering the ability to overcome the interruption problems that face the utility and cost it tens of millions in repair and loss. In this work, we develop a MATLAB code to examine the effect of the smart grid applications in improving the reliability of the power distribution networks via Monte Carlo Simulation approach. The system used in this paper is the IEEE 34 test feeder. The objective is to measure the installations of the Automatic Reclosers (ARs) as well as the Distributed Generators (DGs) on the reliability indices, SAIDI, SAIFI, CAIDI and EUE, and make comparisons with results from a previous study done by the authors using another approach. The MATLAB code should provide close results to the output of the previous research to verify its effectiveness.

The application of Monte Carlo simulation (MCS) is a corner-stone in the sensitivity and quantitative probabilistic analysis. Among many of its great virtues is its powerful ability to accurately evaluate the reliability of the electrical grid, which allowed several studies to emerge in this arena. The deterministic approach in assessing the reliability of the power systems is criticized for not being sensitive to the stochastic nature of the grid as well as to customer demands and components failures, which may lead to either an overinvestment or catastrophic consequences. Therefore, the need for probabilistic evaluation of the electrical system behavior has been emphasized in the most recent decade. MCS, as a process of simulation, is strictly random and can be divided into two main types; sequential and non-sequential (random) Monte Carlo methods. The sequential MCS simulates the system operation as an up-and-down, where a system operating cycle is obtained by combining all the cycles of the system components in chronological order. This usually requires more computational efforts than the other approach, the non-sequential MCS, which simulates the system with a higher efficiency by choosing intervals randomly, yet cannot simulate the chronological aspect of the system behavior. The MCS process is central in the stochastic simulation using random variables, where it can simulate the electrical components considering the grid’s behavior with the goal of evaluating its expected reliability parameters [

The goal of this work is to apply the Monte Carlo technique on the IEEE 34-node test system, shown in

rent emerging technologies of the auto-reclosers that are now available in the industry.

A Monte Carlo Simulation’s Matlab code was developed at the University of Southern California by the authors of this paper to achieve the purpose of this study. The code can be found in Appendix of this work. The input data utilized in this work represents a real system data taken from reference [_{i}), average outage time (r), and the average annual unavailability (U). The method considered in the coding is the time-se- quential MCS, which models the system recognizing the chronological order as the incidents occur on the system through the simulation time. An artificial history is generated using the random number generator which produces a uniform random number (between 0 and 1) for each component in the test system for the goal of providing a sequence of the operating-repairing cycle for it.

We simulated the IEEE test system using the famous two-state Markov model shown in

failure process for a component due to contingency event that would take it out of operation. MCS randomly sample the up and down states for each element in the feeder which generates a simulated sequence for the component’s history of operation and failure. This helps in producing an overall conclusion about the system behavior in general, and to identify the component that is prone to outages in particular.

References [

1) Generate a random value for each of the component using the random number generator. The variable obtained for each component take the value between (0, 1) with equal likelihood.

2) Determine the component in the grid with the minimum TTF.

3) Convert the generated values into TTF, TTR for each component in the system. Determine the outage duration for each failed load point indices.

4) Generate a new random number for the failed component and convert it into a new TTF. If the simulation time is less than a year then return to step 2. Otherwise, go to step 7.

5) Calculate the number and duration of failures for each load point per year.

6) Calculate the average value of the load point failure rate and duration for the sample years.

7) Calculate SAIDI, SAIFI and system indices and record the average values of the results.

8) Return to step 2 if the simulation time is less than the specified total simulation years. Otherwise, record the results as final outcomes and end the simulation.

The results of modeling the test system in our MATLAB code are provided in

Case Description | SAIFI | SAIDI | CAIDI | ASAI | EUE (kW/yr) |
---|---|---|---|---|---|

Base Case (no AR) | 15.23 | 6.80 | 0.4466 | 0.9992 | 10,709 |

Add AR [832 - 858] | 12.83 | 5.89 | 0.4595 | 0.9993 | 9248 |

Add AR [858 - 834] | 13.02 | 5.89 | 0.4523 | 0.9993 | 9265 |

Add AR [834 - 860] | 12.90 | 6.25 | 0.4846 | 0.9992 | 9845 |

Add AR [860 - 836] | 12.94 | 6.20 | 0.4791 | 0.9992 | 9763 |

Add AR [834 - 842] | 14.02 | 6.50 | 0.4639 | 0.9992 | 10,224 |

distribution feeder is weighed based on the outcomes (of using the sequential Monte Carlo) that show the impact of the smart grid applications (the auto- recloser in this case) versus the conventional (main) scheme of the test system in

We want to examine in our work the effect of the installation of two automatic reclosers and try to identify if such move will yield more improvement and cost savings. In this case study, we modified the test system to include an automatic recloser in between nodes 832 - 858, and then model the modified system to investigate any further improvements in the reliability indices if we want to add another AR in the test system.

Case Description | SAIFI | SAIDI | CAIDI | EUE (kW) |
---|---|---|---|---|

Add AR [834 - 860] | 11.87 | 5.314 | 0.4474 | 8361 |

Add AR [860 - 836] | 12.30 | 5.541 | 0.4504 | 8707 |

Add AR [834 - 842] | 12.18 | 5.450 | 0.4472 | 8565 |

Add AR [832 - 888] | 12.76 | 5.79 | 0.4587 | 9065 |

Add AR [842 - 844] | 12.61 | 5.64 | 0.4476 | 8869 |

of modeling the system using MCS is its ability to offer the best location for the ARs considering the artificial data it made for each component of up and down history.

We emphasize in this work that the DG units are considered great tools to enhance the reliability of the distribution grid, by providing the energy to the distribution feeder during the islanding scenario when a major outage hits an electrical network. Previous studies have extensively covered the integration of the DG units in the distribution grid [

The best option will be the installation of one automatic recloser between nodes 852 - 832 will improve SAIDI by 60.15%, a change from 6.80 to 2.71 hours/year. SAIFI will experience a great reduction as well from 15.23 to 6.07 occurrence/year, accounting around 60% in improvement as well. In the case of any contingency event, the DG unit will provide the system the ability to operate as a small microgrid, providing service to the unaffected parts of the feeder and improving the system indices. It is worth mentioning that the results using MCS show similar reduction percentage for SAIDI when modeling the same system using the analytical technique and the software that is based on brute force me-

Case Description | SAIFI | SAIDI | CAIDI | EUE (kW) |
---|---|---|---|---|

Base case + one DG (no switch) | 15.23 | 6.80 | 0.4466 | 10,709 |

Add AR [852 - 832] | 6.07 | 2.71 | 0.4465 | 9097 |

Add AR [854 - 852] | 6.81 | 2.94 | 0.4319 | 9099 |

Add AR [830 - 854] | 7.60 | 3.11 | 0.4094 | 9442 |

Add AR [828 - 830] | 7.69 | 3.06 | 0.3987 | 9498 |

Add AR [888 - 890] | 14.13 | 6.61 | 0.4243 | 10,512 |

thod, where there less than 6% in the difference between the reliability indices in the two studies.

Monte Carlo technique is one of the most powerful, efficient methods to evaluate the reliability of the power distribution grids. In this work, we simulate the IEEE 34 node test system using the MSC technique, through a MATLAB code that was written by the authors of this paper and shown in Appendix A of this work. After modeled the IEEE feeder, shown in

The study shows different scenarios of applying the auto reclosers and the DG units in various parts of the feeder. Furthermore, the automatic reclosers, once installed optimally in the grid as proposed by the software, significantly improve the reliability of the power distribution network by isolating the healthy parts of the system automatically, which maintain the service to a substantial number of customers and reduce the repair time. The distributed generators, although dated back to the late 1970’s, are now considered to be one of the applications that define the smart grid concept. The results of integrating them in the distribution feeder show the advantages of using reliable, assumed dispatchable, DG units near load center. Along with the installation of the automatic recloser, the DGs provide the opportunity of operating the distribution grid as a microgrid, allowing service to continue to parts in the network, something will be greatly admired especially during major outages and blackouts. Also, the study provided in this work shows the amount of energy (in kW) that is saved for the utility in this real life test feeder, through the EUE index which measures the reduction in the energy-not-served for each case option. Also, the comparison of these results with that one obtained previously on the same test feeder using the same real-life inputs shows the MCS MATLAB code we developed is effective, and serves as a tool that can be used in evaluating the reliability of distribution feeders when applying small modifications only. That reflects the difference from the test system used in this study.

Aljohani, T.M. and Beshir, M.J. (2017) Matlab Code to Assess the Reliability of the Smart Power Distribution System Using Monte Carlo Simulation. Journal of Power and Energy Engineering, 5, 30-44. https://doi.org/10.4236/jpee.2017.58003

clear;

N = 33; % number of components

lambda = [0.3979; 0.8209; 0.7666; 0.1206; 0.8577; ...

0.2586; 0.7049; 0.2429; 0.3521; 0.8118; ...

0.1850; 0.5135; 0.3920; 0.7194; 0.6776; ...

0.2065; 0.3197; 0.3226; 0.8566; 0.3348; ...

0.8950; 0.8833; 0.6400; 0.0412; 0.0518; ...

0.9458; 0.2257; 0.7303; 0.2191; 0.0101; ...

0.7205; 0.1289; 0.1327];

MTTR = [0.3546; 0.6970; 0.8490; 0.8724; 0.0411; ...

0.2098; 0.7382; 0.7379; 0.1978; 0.4534; ...

0.2299; 0.0704; 0.3979; 0.8555; 0.6809; ...

0.2954; 0.8536; 0.7195; 0.3405; 0.0495; ...

0.0174; 0.7846; 0.2554; 0.6597; 0.8496; ...

0.2965; 0.2238; 0.0066; 0.0684; 0.4306; ...

0.7953; 0.7759; 0.9673];

power = [0 55 0 16 0 0 0 5 34 0 0 4 40 7 45 15 146 82 ...

0 67 9 405 45 83 0 0 4 0 32 0 28 2 0 450];

users = ceil(power/2)-1;

%% failure history

duration = 1000; % years

interuption = 0;

outage_time = 0;

maxT = 0;

for i = 1:N

[downT{i},upT{i}] = failure_history2(lambda(i),MTTR(i),duration);

cur = max(upT{i}(1:end));

if (maxT < cur)

maxT = cur;

end

interuption = interruption + length(downT{i})-1;

outage_time = outage_time + sum(upT{i}-downT{i});

% figure;

line(1:length(downT{i}),downT{i});

line(1:length(downT{i}),upT{i},’color’,’r’,’Marker’,’.’);

end

% INDEXES calculation

average_interuption = interuption/duration;

average_outage_time = outage_time/duration;

customers_num = sum(users);

total_power = sum(power);

SAIFI = average_interuption*customers_num/customers_num;

SAIDI = average_outage_time*customers_num/customers_num;

CAIDI = SAIDI/SAIFI;

ASAI = (customers_num*8760 - average_outage_time*customers_num)/ (customers_num*8760);

EUE = average_outage_time*total_power; % kW*hour

disp(‘-------------------------------’);

disp(‘Step 1’);

disp([‘SAIFI ‘ num2str(SAIFI)]);

disp([‘SAIDI ‘ num2str(SAIDI)]);

disp([‘CAIDI ‘ num2str(CAIDI)]);

disp([‘ASAI ‘ num2str(ASAI)]);

disp([‘EUE ‘ num2str(EUE)]);

%% Step2 switches

switch_834_lines = [20 21 22 31 32];

switch_832_lines = [17 18 19 30 23 24 25 switch_834_lines];

switch_834_elements = [19 20 21 30 31];

switch_832_elements = [switch_834_elements 18 22 23 24 25 29 32];

interaptionXcustomer_number = 0;

interaptionXcustomer_duration = 0;

unservedEnergy = 0;

cur_t = 0;

while cur_t < maxT

% find next failure time

min_t = (duration + 1)*24*365;

fail_line_number = 0;

for i = 1:N

clear indx;

indx = find(downT{i} > cur_t);

if (~isempty(indx))

indx = indx(1);

if (downT{i}(indx) < min_t)

min_t = downT{i}(indx);

fail_line_number = i;

n = indx;

cur_outage_time = upT{i}(indx) − downT{i}(indx);

end

end

end

cur_t = upT{fail_line_number}(n);

in_switch_834 = ~isempty(find(switch_834_lines == fail_line_number));

customer_834 = sum(users(switch_834_elements));

power_834 = sum(power(switch_834_elements));

in_switch_832 = ~isempty(find(switch_832_elements == fail_line_number));

customer_832 = sum(users(switch_832_elements));

power_832 = sum(power(switch_832_elements));

% interaption calculation

if (~in_switch_832)

interaptionXcustomer_number = interaptionXcustomer_number + customers_num;

interaptionXcustomer_duration = interaptionXcustomer_duration + customers_num*cur_outage_time;

unservedEnergy = unservedEnergy + total_power*cur_outage_time;

else

if (in_switch_834)

interaptionXcustomer_number = interaptionXcustomer_number + customer_834;

interaptionXcustomer_duration = interaptionXcustomer_duration + customer_834*cur_outage_time;

unservedEnergy = unservedEnergy + power_834*cur_outage_time;

else

interaptionXcustomer_number = interaptionXcustomer_number + customer_832;

interaptionXcustomer_duration = interaptionXcustomer_duration + customer_832*cur_outage_time;

unservedEnergy = unservedEnergy + power_832*cur_outage_time;

end

end

end

% INDEXES calculation

SAIFI = interaptionXcustomer_number/customers_num/duration;

SAIDI = interaptionXcustomer_duration/customers_num/duration;

CAIDI = SAIDI/SAIFI;

ASAI = (customers_num*8760 − interaptionXcustomer_duration/duration)/ (customers_num*8760);

EUE = unservedEnergy/duration; % kW*hour

disp(‘-------------------------------’);

disp(‘Step 2’);

disp([‘SAIFI ‘ num2str(SAIFI)]);

disp([‘SAIDI ‘ num2str(SAIDI)]);

disp([‘CAIDI ‘ num2str(CAIDI)]);

disp([‘ASAI ‘ num2str(ASAI)]);

disp([‘EUE ‘ num2str(EUE)]);

%% Step 3 switches from Step 2 and DGs

switch_834_lines = [20 21 22 31 32];

switch_832_lines = [17 18 19 30 23 24 25 switch_834_lines];

switch_834_elements = [19 20 21 30 31];

switch_832_elements = [switch_834_elements 18 22 23 24 25 29 32];

interaptionXcustomer_number = 0;

interaptionXcustomer_duration = 0;

unservedEnergy = 0;

cur_t = 0;

while cur_t < maxT

% find next failure time

min_t = (duration + 1)*24*365;

fail_line_number = 0;

for i = 1:N

clearindx;

indx = find(downT{i} > cur_t);

if (~isempty(indx))

indx = indx(1);

if (downT{i}(indx) < min_t)

min_t = downT{i}(indx);

fail_line_number = i;

n = indx;

cur_outage_time = upT{i}(indx) − downT{i}(indx);

end

end

end

cur_t = upT{fail_line_number}(n);

in_switch_834 = ~isempty(find(switch_834_lines == fail_line_number));

customer_834 = sum(users(switch_834_elements));

power_834 = sum(power(switch_834_elements));

in_switch_832 = ~isempty(find(switch_832_elements == fail_line_number));

customer_832 = sum(users(switch_832_elements));

power_832 = sum(power(switch_832_elements));

customer_800 = customers_num-customer_832;

power_800 = total_power-power_832;

% interaption calculation

if (~in_switch_832)

interaptionXcustomer_number = interaptionXcustomer_number + customer_800;

interaptionXcustomer_duration = interaptionXcustomer_duration + customer_800*cur_outage_time;

unservedEnergy = unservedEnergy + power_832*cur_outage_time;

else

if (in_switch_834)

interaptionXcustomer_number = interaptionXcustomer_number + customer_834;

interaptionXcustomer_duration = interaptionXcustomer_duration + customer_834*cur_outage_time;

unservedEnergy = unservedEnergy + power_834*cur_outage_time;

else

interaptionXcustomer_number = interaptionXcustomer_number + customer_832;

interaptionXcustomer_duration = interaptionXcustomer_duration + customer_832*cur_outage_time;

unservedEnergy = unservedEnergy + power_832*cur_outage_time;

end

end

end

% INDEXES calculation

SAIFI = interaptionXcustomer_number/customers_num/duration;

SAIDI = interaptionXcustomer_duration/customers_num/duration;

CAIDI = SAIDI/SAIFI;

ASAI = (customers_num*8760 − interaptionXcustomer_duration/duration)/ (customers_num*8760);

EUE = unservedEnergy/duration; % kW*hour

disp(‘-------------------------------’);

disp(‘Step 3’);

disp([‘SAIFI ‘ num2str(SAIFI)]);

disp([‘SAIDI ‘ num2str(SAIDI)]);

disp([‘CAIDI ‘ num2str(CAIDI)]);

disp([‘ASAI ‘ num2str(ASAI)]);

disp([‘EUE ‘ num2str(EUE)]);

IEEE: Institute of Electrical and Electronics Engineering.

AR: Automatic Recloser.

SAIDI: System Average Interruption Duration Index.

DG: Distributed Generation.

CAIDI: Customer Average Interruption Duration Index.

U: Annual Unavailability Time.

EUE: Expected Un-served Energy.

R: Annual Outage Time.

λ: Failure Rate of an Electrical Component.

TTR: Mean Time to Repair.

TTF: Mean Time to Fail.

MCS: Monte Carlo Simulation.