Over current relay coordination for radial

systems

Introduction:

Power system equipment needs protection from faults like short

circuits, lightning’s etc… relays detects the faults and gives a tripping

command to circuit breaker. Circuit breaker disconnects the faulty part

from the healthy part of the system. So, for proper protection, relay,

circuit breaker pair is needed for every part of the system which is to be

protected (these are called as primary relays). Back up protection is to be

provided for each part of the system so that the back up protecting device

gives the protection when primary relay fails to work or it is under repair.

Radial distribution system is one in which power flow is

unidirectional. It is having source at either of the ends and no loops.

Relays which are primary relays for specific section are made to work as

back up relays for the down stream parts of the system, so as to provide

optimum number of relays for the given radial system. Back up relays

operate with operating time greater than that of primary relays by giving a

chance to primary relays to operate. Proper coordination between relays

is required for achieving this.

Coordination:
 Figure 1

Consider the above model system. Here R2 must act as

back up relay for R4 and R5. When either of the relays R4 and R5 fails to

operate or it is under repair, then R2 must operate for the fault in the

corresponding sections of either of R4 and R5. Similarly for R6, R3 has

to give back up for R6. R1 has to give for R2 and R3. the operating time

for back up relays must be greater than that of primary relays. The

difference between primary relay operating time and back up relay

operating time is called as coordination (CTI) time interval. It is generally

taken as 0.3. Like wise coordination is done for every primary, back up

relay pair.

Objectives:

1.To obtain different settings for each relay provided for a radial

distribution network.

2. To achieve good coordination among primary and backup relay pairs.

INPUTS :
 node to node information of given radial system, maximum

feeder currents for every feeder, minimum fault current at remote bus for

each node ,maximum fault current seen by each relay, type of relay used.

OUTPUTS :

time multiplier settings, plug multiplier settings, back up plug

multiplier settings, back up operating time for all relays in the given

radial distribution network

Getting coordination:

Consider figure 2. Leaf node is E. Relay R4 has to give no

back up protection. So its settings are independent of others. This relay

should pick up for a current greater than maximum feeder current in the

section DE. A rule of thumb is to take a safety factor of 1.25.

Figure 2

Minimum limit of pick up is 1.25 times the feeder current. It

should picks up at a value less than minimum fault current at remote bus.
Choose a safety factor of (2/3). Maximum limit of pick up current is 2/3

times minimum fault current at remote bus. Select pick up value in

between its limits. Choose time setting multiplier (tsm) value for relay R4

as minimum as possible to provide quick operation of relays. Say it is

0.025.

Plug setting multiplier (psm) of relay R4 is (maximum fault

current)/ (pick up value). Here coordination is done at maximum fault

current implies that coordination is done at minimum fault currents also

because the time-current characteristics becomes more separable when

fault current goes on decreasing. Operating time is calculated using one

of the following formulas.

tsm * const
Operating time= ( psm power −1) -------------------formula (1)

Const, power values for normal inverse, very inverse, extremely inverse

are 0.14, 0.02, 13.5, 1, 80, 2 respectively.

R3 has to give back up for R4. While calculating pick up limits of

R2, minimum fault current of R1 is to be taken. Back up psm for R3 is

(maximum fault current seen by relay R1)/ (pick up of R3). Because it

acts not only for faults in CD but also for faults in section DE with some

time delay. back up operating time for relay R3 is greater than R1 by

CTI. Using formula (1), back up psm of R3 and operating time tsm is

calculated. And for fault in section CD, psm and operating time are
calculated. R2 has to give back up protection for R3, R1 has to give

for R2.similar procedure is to be done for all relays.

If one specific relay is to give back up for more than one

relay, it has to take minimum value from minimum fault currents of those

relays, which it has to give back up protection. while calculating

maximum limit of pick up current, maximum value from maximum fault

currents, maximum value from operating times of those relays which it

has to give back up, while calculating back up psm, back up operating

time respectively. With tsm, psm draw time – current plots of different

relays used in the radial distribution system.

Algorithm:

This algorithm shows the procedure for obtaining different

relay settings and plotting time- fault current characteristics. four steps

are involved in this algorithmic procedure. They are

Step (1): Obtaining relative sequence matrix (rsm)

Step (2): Finding set of sequential pairs (ssp)

Step (3): Finding settings for different relays.

Step (4): plotting time- fault current characteristics for each pair in ssp

and for all relays in the system.

Step(1): RSM:
 Relative sequence matrix represents the order in which relays

are to be coordinated. rsm consists several rows. Row number tells which

relays are to be set after which relays. First row elements are to be set

first, next second row, like wise…. The order in which rsm rows are

arranged is important, but the order with in a specific row is of no

interest.

How to obtain rsm:

1. Form adjacency matrix.

Adjacency matrix is N/N matrix, where N is the number of

nodes. if mth node is adjacent to nth node, then (m, n)th element of

adjacency matrix is 1, otherwise 0.So adjacency matrix is symmetric

matrix. Transpose of adjacency matrix is equal to adjacency matrix.

Adjacency matrix for figure 3 is

1 2 3 4 5 6 7 8 9 10 11 12 13 14

………………………………………………………………………

0 1 0 0 0 0 0 0 0 0 0 0 0 0

1 0 1 1 0 0 0 0 0 0 0 1 0ì¥Á65@

66ø¿6666666666666ﾐ q66
7bjbjÏ2Ï2777777777777777777 7 7X77-

X77 ﾍ i77777777777777777777777777777ÿÿ¤777777777ÿÿ¤

777777777ÿÿ¤77777777777777777ˆ777772 7777772 772 7777772

777777‚ 777777‚ 777777‚ 77µ77777777777–

777777žÉ777777žÉ777777žÉ777777žÉ77Œ777*Ê77 77–

777777{ê77¶777RË77^777°Ë777777°Ë777777°Ë777777°Ë777777AÍ

777777AÍ777777AÍ777777úé77777üé777777üé777777üé777777üé7777

77üé777777üé77$7771ë77R77ƒí77®777 ê77§7777777777777777777‚

777777AÍ7777777777777777777777-

Í77"777AÍ777777AÍ777777AÍ777777 ê7777 0 0 0 0 0 0

0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 1 0 0 0 0 0 0 0 0 0

0 1 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 1 0 0 0 0 0 0

0 0 0 0 0 0 0 1 0 0 0 0 0 0

Figure 3
 S-source

R-relay

1,2..nodes

2. Find

degree of each node. Degree of each node is equal to number of ones in

corresponding row of adjacency matrix.

3. If (m, n)th element in adjacency matrix is 1, then put the relayì¥Á95@

99ø¿9999999999999ﾐ q99
10bjbjÏ2Ï2101010101010101010101010101010101010 10 10X1010-

X1010 ﾍ i1

010101010101010101010101010101010101010101010101010101010ÿÿ

¤101010101010101010ÿÿ¤101010101010101010ÿÿ¤1010101010101010

101010101010101010ˆ10101010102 1010101010102 10102

1010101010102 101010101010‚ 101010101010‚ 101010101010‚

1010µ1010101010101010101010–

101010101010žÉ101010101010žÉ101010101010žÉ101010101010žÉ1

010Œ10ì¥Á105@ 1010ø¿10101010101010101010101010ﾐ q1010

11bjbjÏ2Ï2111111111111111111111111111111111111 11 11X1111-

X1111 ﾍ i1

111111111111111111111111111111111111111111111111111111111ÿÿ

¤111111111111111111ÿÿ¤111111111111111111ÿÿ¤1111111111111111

111111111111111111ˆ11111111112 1111111111112 11112

1111111111112 111111111111‚ 111111111111‚ 111111111111‚

1111µ1111111111111111111111–

111111111111žÉ111111111111žÉ111111111111žÉ111111111111žÉ1

111Œ11m is formed.

Flow chart for finding rsm

Last row of rsm is always contains one relay that too source node.
Rsm 1st row =

11 9 12 6 8 4

Rsm 2nd row =

3 10

Rsm 3rd row =

2 5

Rsm final row =

Step(2): ssp: it consists of primary, back up relay pairs according to the

order followed by rsm.

The following steps illustrates procedure for finding ssp

1. Consider rsm last row

2. Take the first relay as backup relay. Find the adjacent nodes to the

nodes containing the present relay. Print those relays as primary relays to

the present back up relays. Make the flag to those primary relays as 1.

Continue these processes up to all relays in that row are completed.

3. Decrease row number by one. Repeat step 2, up to second row of rsm

with flags not equal to one.

4. Reschedule ssp such that back up relays are according to the order of

rsm.

Ssp for figure 3 is

Back up: R10 R10 R3 R5 R5 R2 R2 R1 R1 R1

Primary : R12 R11 R4 R10 R8 R6 R3 R5 R9 R2

Step(3): Setting relays:

1. Consider first row of rsm. Calculate tsm, psm, operating time of each

relay according to the following formulas.

m i am x_ uf am_uc lu t r_ sr e _ebn _nyt h_ re e l a y

Psm= . . . . . . . eqn.(3).
p i c_ vk au _lop u_ft eh_ re e l a y

Tsm=0.025 (it is the minimum available time setting (because rsm first

row elements belongs to leaf nodes of the given network))

tsm * const
Operating time= ( psm power −1) ------------------- eqn. (4)

Const, power values for normal inverse, very inverse, extremely inverse

are 0.1ì¥Á135@ 1313ø¿13131313131313131313131313ﾐ q1313

14bjbjÏ2Ï2141414141414141414141414141414141414 14 14X1414-

X1414 ﾍ i1

414141414141414141414141414141414141414141414141414141414ÿÿ

¤141414141414141414ÿÿ¤141414141414141414ÿÿ¤1414141414141414

141414141414141414ˆ14141414142 1414141414142 14142

1414141414142 141414141414‚ 141414141414‚ 141414141414‚

1414µ1414141414141414141414–

141414141414žÉ141414141414žÉ141414141414žÉ141414141414žÉ1

414Œ14ì¥Á145@ 1414ø¿14141414141414141414141414ﾐ q1414

15bjbjÏ2Ï2151515151515151515151515151515151515 15 15X1515-

X1515 ﾍ i15151515151515151515151515151515151515151515ÿ1

51515151515151515ÿÿ¤1515151515151515151515151515151515ˆ1515

1515152 1515 151515‚ 151515151515‚ 151515151515‚

15

1515µ1515151515151515151515–

151515151515žÉ151515151515žÉ151515151515žÉ151515151515žÉ1

515Œ15erating time of each relay according to equations

(3), (4). Increase row number by one.

4. Repeat steps 2, 3 for each row of rsm.

Relay_no. tsm psm operating time backup psm backup

operating time

1.0000 0.5819 41.6667 1.0519 41.5417 1.0528

2.0000 0.3913 33.5135 0.7528 33.5135 0.7528

11.0000 0.0250 73.6167 0.0390 0 0

9.0000 0.0250 35.4450 0.0473 0 0

3.0000 0.2295 30.8056 0.4528 34.4444 0.4380

12.0000 0.0250 20.8880 0.0558 0 0

6.0000 0.0250 10.3600 0.0731 0 0

5.0000 0.3909 58.6471 0.6451 58.4824 0.6456

8.0000 0.0250 7.7000 0.0840 0 0

10.0000 0.2197 71.0143 0.3456 63.1000 0.3558

4.0000 0.0250 3.4970 0.1380 0 0

Step(4): Time-fault current characteristics:

1. Consider all pairs in ssp individually. Plot time-fault current

characteristic curves for each pair with tsm values calculated.

2. Each plot consists of two curves, one is for primary relay and the other

is for back up relay. The two curves will not intersect.

3. For each plot, mark operating time, maximum fault current for both

relays and back up operating time for back up relay.

Appendix: Mat lab code for above procedure

clc

clear;

mod_i34;

sourcenode=800;

% datmat

[m,n]=size(data);

adj_mat=0;

flag(m,1)=0;

relay_no=zeros(1,m);

w=0;%how many iterations for completing rsm

%defining adjacency matrix

for i=1:m

j=data(i,1);

k=data(i,2);

adj_mat(j,k)=1;

adj_mat(k,j)=1;
end

%defining adjacency matrix

adj_mat1=adj_mat;

adj_mat;

[g,h]=size(adj_mat);

while all(adj_mat)==0

w=w+1;

wh(w)=w;

for i=1:g,

degree(i,1)=sum(adj_mat(i,:));

end

for i=1:g,

%removing leaf nodes

if((degree(i,1)==1)&(i~=sourcenode))

adj_mat(:,i)=0;

adj_mat(i,:)=0;

adj_mat;

%steps for finding rsm

for k=1:g,

if(adj_mat1(i,k)==1)

for u=1:m,

if((data(u,1)==i)&(data(u,2)==k))|((data(u,2)==i)&(data(u,1)==k))

relay_no(1,u)=data(u,3);

node(1,u)=i;nodes(1,u)=k;

flag(u,1)=1;
end

end

end

end

%steps for finding rsm

end %end for 'if'at removing leaf nodes

end %end for 'for'

degree;

adj_mat;

rel(w,:)=relay_no;

relay=rel;

relay_no;

if(adj_mat==0)

break

end

end %end for 'while'

%putting rsm in a matrix form

for v=1:w

if(v<w)

rel([v+1],:)=relay([v+1],:)-relay(v,:);

end

end

rel;

for i=1:w,
rsm_row_no=i;

rsm_rows=rel(i,find(rel(i,:)))

end

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

cnt=0;

ne=length(wh);

for ki=1:length(wh)

if(ne>0)

qe(ki)=wh(ne);

end

ne=ne-1;

end

we=length(qe);

xxx=rel(1,find(rel(1,:)));

xe=length(xxx);

flag=zeros((we-1),xe);

%finding p_b_pairs

[s,t]=size(rel);

for a=1:(we-1)

x=rel(((qe(a))),find(rel(((qe(a))),:)));

for b=1:length(rel((qe(a)),find(rel((qe(a)),:))))

y=x(1,b);

for c=1:m

if(data(c,3)==y)

first=data(c,1);

last=data(c,2);

z=[first last];
for d=1:2

for e=1:m

if(data(e,1)==z(d))

for an=a:(we-1)

p=rel(((qe(an+1))),find(rel(((qe(an+1))),:))); %comparing rsm rows with previous rows for finding

p_b_pairs

for f=1:length(p)

if((data(e,3)==p(f))&(flag(an,f)~=1))

flag(an,f)=1;

q=p(f);

cnt=cnt+1;

p_b(cnt)=y;

p_ba(cnt)=q;

end

end

end

end

end

end

end

end

flag;

end

end

fprintf('first row is backup(y), 2nd row is primary(q)')

p_b_pairs(1,:)=p_b;

p_b_pairs(2,:)=p_ba;

[si ri]=size(p_b_pairs);

az=ri;

for ki=1:ri

ssp_b(ki)=p_b_pairs(1,ri);

ssp_p(ki)=p_b_pairs(2,ri);

pai(ki)=ri;

ri=ri-1;

end

ssp(1,:)=ssp_b; %ssp formation

ssp(2,:)=ssp_p

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

count=0;

for ct=1:m

re=data(ct,3);

for va=1:az

if(ssp(1,va)==re) %primary relay sets for each backup relay

set(:,va)=ssp(2,va);

end

end

sets=set;

set=zeros(1,az);

back_set(ct,:)=sets;

end

back_set;
for it=1:m

if(any(back_set(it,:))==1) %back set

xx=back_set(it,find(back_set(it,:)));

count=count+1;

for jj=1:length(xx)

for rr=1:m

if(data(rr,3)==xx(1,jj))

pickup(jj)=data(rr,5); %minimum fault of back up relays by comparing vit primary relays

maxf(jj)=data(rr,6);

end

end

end

mx_lm_pick(count,:)=[data(it,3) min(pickup)];

maxfault(count,:)=[data(it,3) max(maxf)];

end

mx_lm_pick;

min_lim_pick(it)=fix(1.25*data(it,7));

end

[mx ss]=size(mx_lm_pick);

for qi=1:mx

for hi=1:m

for gi=1:xe

if(xxx(gi)==data(hi,3)) % max limit of pickup current rsm1st row+++

max_pick(hi)=data(hi,5);

maximum_fault(hi)=data(hi,6);

end

end

if(mx_lm_pick(qi,1)==data(hi,3)) % +++max limit of pickup current of backup relays

max_pick(hi)=mx_lm_pick(qi,2);

end

if(maxfault(qi,1)==data(hi,3)) % max fault current of backup relays fr calculating

b_psm

maximum_fault(hi)=maxfault(qi,2);

end

end

end

maximum_fault

atad=data';

fdr_i(1,:)=atad(7,:)

max_pick

min_lim_pick

max_lim_pick=fix((2/3)*max_pick)

selectivity=1;

for cc=1:m

if(fdr_i(cc)>max_pick(cc))

fprintf('OVER CURRENT PROTECTION SYSTEM DOES NOT WORK FOR THE GIVEN DATA');

selectivity=0;

else

if(min_lim_pick(cc)>max_lim_pick(cc)) %checking whether the protection works r not

fprintf('there is problem in choosing pick up value.OVER CURRENT PROTECTION SYSTEM MAY

NOT WORK FOR THE GIVEN DATA.if safety factor is ignored it may work partially ');

selectivity=0;

break

end

end

end

selectivity;

if(selectivity==1)

pick_up_values=input('enter the values of pickup values of relays according to the order followed by

data matrix in between min_lim_pick&max_lim_pick pickup of any relay must be greater than that of

the down stream relays ');

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

tsm=zeros(1,m);

b_psm=zeros(1,m);

b_op_time=zeros(1,m);

op_time=zeros(1,m);

for bb=1:xe

for nn=1:m

psm(nn)=data(nn,6)/pick_up_values(nn);

if(xxx(bb)==data(nn,3))

tsm(nn)=0.025;

%finding psm,tsm,op tine of rsm 1st row

switch data(nn,4)

case 1
const=0.14; % cadering different types of relays for op-time calculation

npower=0.02;

case 2

const=13.5;

npower=1;

otherwise

const=80;

npower=2;

end

op_time(nn)=const*tsm(nn)./(power(psm(nn),npower)-1);

end

end

end

op_time;

cont=0;

var=zeros(1,m);

for qm=1:m

if(any(back_set(qm,:))==1)

qwe=back_set(qm,find(back_set(qm,:)));

for dp=1:length(qwe)

for sb=1:m

if(qwe(dp)==data(sb,3))

ft(dp)=data(sb,6);

end

end

end
ft;

for wb=1:m

cont=cont+1;

if(max(ft)==data(wb,6))

var(qm)=wb;

end

end

cont=0;

end

ft=0;

end

var;

for aa=2:we

aa;

x=rel(aa,find(rel((aa),:)));

for ab=1:length(rel(aa,find(rel(aa,:))))

y=x(1,ab);

for ac=1:m

ac; %finding b_psm frm 2nd row onwards

if(data(ac,3)==y)

b_psm(ac)=maximum_fault(ac)/pick_up_values(ac);

%%%%%%%%%%%%%%%%%%%%%%%%%%%%

xyz=back_set(ac,find(back_set(ac,:)));

for kk=1:length(xyz)

for kl=1:m

kl;
if(data(kl,3)==xyz(kk))

zyx(kk)=op_time(kl);

xxyy=zyx;

end

end

end

b_op_time(ac)=max(xxyy)+0.3;

switch data(kl,4)

case 1

const=0.14;

npower=0.02;

case 2 %cadering different types of relays for tsm calculation

const=13.5;

npower=1;

otherwise

const=80;

npower=2;

end

if(any(back_set(ac,:))==1)

tsm(ac)=b_op_time(ac).*(power(b_psm(ac),npower)-1)./const;

op_time(ac)=const*tsm(ac)./(power(psm(ac),npower)-1);

end

zyx=0;

%%%%%%%%%%%%%%%%%%%%%

end

end

end

end
ttt=tsm';

ppp=psm';

ooo=op_time';

bbb=b_psm';

bot=b_op_time';

fprintf(' relaly_no. tsm psm op_time b_psm b_op_time')

result(:,1)=data(:,3);

result(:,2)=ttt(:,1);

result(:,3)=ppp(:,1);

result(:,4)=ooo(:,1);

result(:,5)=bbb(:,1);

result(:,6)=bot(:,1)

pri_order=ssp(2,:);

pri_order(m)=rel(w,find(rel(w,:)))

back_order=ssp(1,:);

back_order(m)=0;

for bn=1:m

for mk=1:m

if(pri_order(bn)==data(mk,3))

fc=50:20:10000;

ps=fc./pick_up_values(mk);

xvl(bn)=pick_up_values(mk);

flt_current(bn)=data(mk,6);

tim(bn)=.02;

switch data(mk,4)
case 1

const=0.14;

npower=0.02;

case 2 %cadering different types of relays for tsm calculation

const=13.5;

npower=1;

otherwise

const=80;

npower=2;

end

time=const*tsm(mk)./(power(ps,npower)-1);

loglog(fc,time,'r');

grid off;

hold on;

t_r=[.015 100];

f_r=[data(mk,6) data(mk,6)];

line(f_r,t_r);

hold on;

loglog(data(mk,6),op_time(mk),'*k');

hold on;

for gj=1:m

if(back_order(bn)==data(gj,3))

switch data(gj,4)

case 1
const=0.14;

npower=0.02;

case 2 %cadering different types of relays for tsm calculation

const=13.5;

npower=1;

otherwise

const=80;

npower=2;

end

loglog(data(mk,6),(const*tsm(gj))./(power((data(mk,6)/pick_up_values(gj)),npower)-1),'*m');

hold on;

end

end

yvl(bn)=(const*tsm(mk))./(power((pick_up_values(mk)+10)/pick_up_values(mk),npower)-1);

text(xvl(bn),yvl(bn), cat(2,'R',int2str(data(mk,3))));

hold on;

text(flt_current(bn),tim(bn), cat(2,'F',int2str(data(mk,3))));

hold on;

if(yvl(bn)<1)

yvl(bn)=yvl(bn)-0.3;

else if((yvl(bn)<5)&(yvl(bn)>1))

yvl(bn)=yvl(bn)-1;

else if((yvl(bn)<10)&(yvl(bn)>5))

yvl(bn)=yvl(bn)-3;
else

yvl(bn)=yvl(bn)-8;

end

end

end

text(xvl(bn),(yvl(bn)), cat(2,'tsm=',num2str(tsm(mk))));

hold on;

end

end

end

end

comment='relaly_no. tsm psm op_time s b_psm b_op_time'

save outputfile.m result -ascii;

pwd ;

title('Time current characteristics ');

xlabel('Fault current (A)');

ylabel('Operating time (s)');

for djd=1:length(ssp(1,:))

yyy=ssp(:,djd)

for kdf=1:2

for bnm=1:m

if(yyy(kdf)==data(bnm,3))

tim(bnm)=0.02;

flt_current(djd)==data(bnm,6);
if(kdf==1)

xxvl(djd)=pick_up_values(bnm)+900;

f_current(djd)=(flt_current(djd)+600);

end

if(kdf==2)

xxvl(djd)=pick_up_values(bnm)-70;

f_current(djd)=flt_current(djd)-400;

end

fc=100:20:10000;

ps=fc./pick_up_values(bnm);

switch data(bnm,4)

case 1

const=0.14;

npower=0.02;

case 2 %cadering different types of relays for tsm calculation

const=13.5;

npower=1;

otherwise

const=80;

npower=2;

end

time=const*tsm(bnm)./(power(ps,npower)-1);

figure(djd+1);

loglog(fc,time,'r');

hold on;

t_rr=[.015 100];

f_r r= [data(bnm,6) data(bnm,6)];

line(f_rr,t_rr);
hold on;

loglog(data(bnm,6),op_time(bnm),'*k');

hold on;

title(cat(2,'Time current characteristics of relays ',int2str(ssp(1,djd)),', ',int2str(ssp(2,djd)),' (red), maxflt

(blue line), * (operating times)'))

hold on;

hold on;

xlabel('Fault current (A)');

ylabel(cat(2,'Operating time of relays ',int2str(ssp(1,djd)),', ',int2str(ssp(2,djd)), ' (s)'));

flt_current(djd)==data(bnm,6);

yyvl(djd)=20;

text((xxvl(djd)),(yyvl(djd)), cat(2,'R',int2str(data(bnm,3))));

hold on;

text(xxvl(djd),(yyvl(djd)-5), cat(2,'tsm=',num2str(tsm(bnm))));

hold on;

text(f_current(djd),tim(djd), cat(2,'F',int2str(data(bnm,3))));

hold on;

if(kdf==2)

for mc=1:m

if(ssp(1,djd)==data(mc,3))

loglog(data(bnm,6),(const*tsm(mc))./(power((data(bnm,6)/pick_up_values(mc)),npower)-1),'*m');

end

end
end

end

end

end

end

For figure 4, rsm, ssp, settings for relays are given below.

The results are outputs from the program.

figure 4

fromnode tonode rel type min_f maxf phA-fdr current

800 802 44 1 5492.6 5618 51.58 ;

802 806 2 1 5409.3 5492.6 51.59 ;

806 808 3 1 4108 5409.3 51.76 ;

808 812 5 1 3120.4 4108 51.59 ;

812 814 6 1 2598.4 3120.4 52.10 ;

814 850 7 1 2598.2 2598.4 48.47 ;

816 824 9 1 2414.8 2592.4 35.87 ;

824 828 13 1 2401.1 2414.8 35.83 ;

828 830 14 1 2105.4 2401.1 35.43 ;

830 854 15 1 2098.8 2105.4 34.23 ;

832 858 16 1 1666.7 1708.4 20.86 ;

834 860 18 1 1603.7 1619.4 14.74 ;

834 842 19 1 1617.3 1617.3 14.74 ;

836 840 20 1 1583.2 1583.2 .79 ;

836 862 21 1 1583.2 1581.1 .90 ;

842 844 22 1 1606.7 1617.3 14.47 ;

844 846 23 1 1578.9 1606.7 9.76 ;

846 848 24 1 1578.9 1578.9 9.76 ;

850 8 16 25 1 2414.8 2598.2 48.47 ;

852 832 26 1 1666.7 1708.6 31.77 ;

854 852 28 1 1708.6 2098.8 31.77 ;

858 834 30 1 1617.4 1666.7 20.73 ;

860 836 31 1 1581.1 1603.7 1.49

rsm_rows =

20 21 24

rsm_rows =

23 31

rsm_rows =

18 22

rsm_rows =

19

rsm_rows =

30

rsm_rows =

16

rsm_rows =

26

rsm_rows =

28

rsm_rows =

15

rsm_rows =

14
rsm_rows =

13

rsm_rows =

rsm_rows =

25

rsm_rows =

rsm_rows =

rsm_rows =

rsm_rows =

rsm_rows =

rsm_rows =

44

first row is backup(y), 2nd row is primary(q)

ssp =

Columns 1 through 18

31 31 23 22 18 19 30 30 16 26 28 15 14 13 9 25 7 6

21 20 24 23 31 22 19 18 30 16 26 28 15 14 13 9 25 7

Columns 19 through 22

5 3 2 44

6 5 3 2

maximum_fault =

1.0e+003 *

Columns 1 through 10
5.4926 5.4093 4.1080 3.1204 2.5984 2.5982 2.4148 2.4011 2.1054 2.0988

Columns 11 through 20

1.6667 1.6037 1.6173 1.5832 1.5811 1.6067 1.5789 1.5789 2.5924 1.7084

Columns 21 through 23

1.7086 1.6194 1.5832

fdr_i =

Columns 1 through 10

51.5800 51.5900 51.7600 51.5900 52.1000 48.4700 35.8700 35.8300 35.4300 34.2300

Columns 11 through 20

20.8600 14.7400 14.7400 0.7900 0.9000 14.4700 9.7600 9.7600 48.4700 31.7700

Columns 21 through 23

31.7700 20.7300 1.4900

max_pick =

1.0e+003 *

Columns 1 through 10

5.4093 4.1080 3.1204 2.5984 2.5982 2.4148 2.4011 2.1054 2.0988 1.7086

Columns 11 through 20

1.6174 1.5811 1.6067 1.5832 1.5832 1.5789 1.5789 1.5789 2.4148 1.6667

Columns 21 through 23

1.6667 1.6037 1.5832

min_lim_pick =

Columns 1 through 18

64 64 64 64 65 60 44 44 44 42 26 18 18 0 1 18 12 12

Columns 19 through 23

60 39 39 25 1

max_lim_pick =

Columns 1 through 9

3606 2738 2080 1732 1732 1609 1600 1403 1399

Columns 10 through 18

1139 1078 1054 1071 1055 1055 1052 1052 1052

Columns 19 through 23

1609 1111 1111 1069 1055

enter the values of pickup values of relays according to the order followed by data matrix in between

min_lim_pick&max_lim_pick pickup of any relay must be greater than that of the down stream relays

[904 855 800 750 720 703 640 600 550 500 400 300 347 140 130 250 200 150 670 429 450 350 270]

relaly_no. tsm psm op_time b_psm b_op_time

44.0000 0.8547 6.2146 3.2154 6.0759 3.2564

2.0000 0.8004 6.4241 2.9564 6.3267 2.9813

3.0000 0.7463 6.7616 2.6813 5.1350 3.1410

5.0000 0.7021 5.4773 2.8410 4.1605 3.3984

6.0000 0.6587 4.3339 3.0984 3.6089 3.5469

7.0000 0.6144 3.6962 3.2469 3.6959 3.2470

9.0000 0.5375 4.0506 2.6520 3.7731 2.7957

13.0000 0.5034 4.0247 2.4957 4.0018 2.5061

14.0000 0.4714 4.3656 2.2061 3.8280 2.4253

15.0000 0.4428 4.2108 2.1253 4.1976 2.1300

16.0000 0.3192 4.2710 1.5166 4.1668 1.5433

18.0000 0.1626 5.3980 0.6638 5.3457 0.6677

19.0000 0.2159 4.6608 0.9670 4.6608 0.9670

20.0000 0.0250 11.3086 0.0704 0 0

21.0000 0.0250 12.1623 0.0683 0 0

22.0000 0.1813 6.4692 0.6670 6.4268 0.6694

23.0000 0.1123 8.0335 ì¥Á385@ 3838ø¿38383838383838383838383838ﾐ q3838

39bjbjÏ2Ï2393939393939393939393939393939393939 39 39X3939-

X3939 ﾍ i3939393939393939393939393939393939393939393939393939393939ÿÿ¤3

93939393939393939ÿÿ¤393939393939393939ÿÿ¤3939393939393939393939393939393939ˆ3939393

9392 3939393939392 39392 3939393939392 393939393939‚ 393939393939‚ 393939393939‚

3939µ3939393939393939393939–

393939393939žÉ393939393939žÉ393939393939žÉ393939393939žÉ3939Œ39ì¥Á395@

3939ø¿39393939393939393939393939ﾐ q3939
40bjbjÏ2Ï2404040404040404040404040404040404040 40 40X4040-

X4040 ﾍ i4040404040404040404040404040404040404040404040404040404040ÿÿ¤4

04040404040404040ÿÿ¤404040404040404040ÿÿ¤404040404040