{
"metadata": {
"name": "",
"signature": "sha256:c30652f9881ee18245a1635c17c8cb6587983fc4f38ea35cc91611c084543096"
},
"nbformat": 3,
"nbformat_minor": 0,
"worksheets": [
{
"cells": [
{
"cell_type": "heading",
"level": 1,
"metadata": {},
"source": [
"Chapter 18: Unsymmetrical Fault Calculations"
]
},
{
"cell_type": "heading",
"level": 3,
"metadata": {},
"source": [
"Example 18.2, Page Number: 429"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"from __future__ import division\n",
"from pylab import *\n",
"import cmath\n",
"import math\n",
"\n",
"#Variable declaration:\n",
"Ir = cmath.rect(100,30*math.pi/180) #current in phase R(A)\n",
"Iy = cmath.rect(50,300*math.pi/180) #current in phase Y(A)\n",
"Ib = cmath.rect(30,180*math.pi/180) #current in phase B(A)\n",
"\n",
"\n",
"#Calculation:\n",
"a = cmath.rect(1,120*math.pi/180)\n",
"I0 = 1/3*(Ir+Iy+Ib) #A\n",
"I1 = 1/3*(Ir+a*Iy+a**2*Ib) #A\n",
"I2 = 1/3*(Ir+a**2*Iy+a*Ib) #A\n",
"In = Ir+Iy+Ib #A\n",
"\n",
"\n",
"#Result:\n",
"print \"The positive, negative and zero sequence currents in the R-line are\"\n",
"print \"I0 = (\",round(abs(I0),2),round(rad2deg(angle(I0)),2),\") A\"\n",
"print \"I1 = (\",round(abs(I1),2),round(rad2deg(angle(I1)),1),\") A\"\n",
"print \"I2 = (\",round(abs(I2),2),round(rad2deg(angle(I2)),2),\") A\"\n",
"print \"Return current in the neutral wire is\"\n",
"print \"In =(\",round(abs(In),2),round(rad2deg(angle(In)),1),\") A\""
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"The positive, negative and zero sequence currents in the R-line are\n",
"I0 = ( 27.29 4.69 ) A\n",
"I1 = ( 57.98 43.3 ) A\n",
"I2 = ( 18.97 24.96 ) A\n",
"Return current in the neutral wire is\n",
"In =( 81.88 4.7 ) A\n"
]
}
],
"prompt_number": 2
},
{
"cell_type": "heading",
"level": 3,
"metadata": {},
"source": [
"Example 18.3, Page Number: 430"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"from __future__ import division\n",
"from pylab import *\n",
"import cmath\n",
"import math\n",
"\n",
"#Variable declaration:\n",
"Ir = 12+6j #current in phase A(A)\n",
"Iy = 12-12j #current in phase Y(A)\n",
"Ib = -15+10j #current in phase B(A)\n",
"\n",
"\n",
"#Calculation:\n",
"a = cmath.rect(1,120*math.pi/180)\n",
"#Red phase\n",
"Ir0 = 1/3*(Ir+Iy+Ib) #A\n",
"Ir1 = 1/3*(Ir+a*Iy+a**2*Ib) #A\n",
"Ir2 = 1/3*(Ir+a**2*Iy+a*Ib) #A\n",
"\n",
"#Yellow phase:\n",
"Iy0 = Ir0 #A\n",
"Iy1 = a**2*Ir1 #A\n",
"Iy2 = a*Ir2 #A\n",
"\n",
"\n",
"#Blue phase:\n",
"Ib0 = Ir0 #A\n",
"Ib1 = a*Ir1 #A\n",
"Ib2 = a**2*Ir2 #A\n",
"\n",
"\n",
"#Result:\n",
"print \"The sequence currents of red phase are:\"\n",
"print \"Ir0 =\",Ir0.real+round(Ir0.imag,2)*1j,\"A\"\n",
"print \"Ir1 =\",round(Ir1.real,2)+round(Ir1.imag,2)*1j,\"A\"\n",
"print \"Ir2 =\",round(Ir2.real,2)+round(Ir2.imag,2)*1j,\"A\"\n",
"print \"\\nThe sequence currents of red phase are:\"\n",
"print \"Iy0 =\",Iy0.real+round(Iy0.imag,2)*1j,\"A\"\n",
"print \"Iy1 =\",round(Iy1.real,2)+round(Iy1.imag,1)*1j,\"A\"\n",
"print \"Iy2 =\",round(Iy2.real,1)+round(Iy2.imag,2)*1j,\"A\"\n",
"print \"\\nThe sequence currents of red phase are:\"\n",
"print \"Ib0 =\",Ib0.real+round(Ib0.imag,2)*1j,\"A\"\n",
"print \"Ib1 =\",round(Ib1.real,2)+round(Ib1.imag,2)*1j,\"A\"\n",
"print \"Ib2 =\",round(Ib2.real,2)+round(Ib2.imag,2)*1j,\"A\""
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"The sequence currents of red phase are:\n",
"Ir0 = (3+1.33j) A\n",
"Ir1 = (10.85+10.13j) A\n",
"Ir2 = (-1.85-5.46j) A\n",
"\n",
"The sequence currents of red phase are:\n",
"Iy0 = (3+1.33j) A\n",
"Iy1 = (3.35-14.5j) A\n",
"Iy2 = (5.7+1.13j) A\n",
"\n",
"The sequence currents of red phase are:\n",
"Ib0 = (3+1.33j) A\n",
"Ib1 = (-14.2+4.33j) A\n",
"Ib2 = (-3.8+4.33j) A\n"
]
}
],
"prompt_number": 3
},
{
"cell_type": "heading",
"level": 3,
"metadata": {},
"source": [
"Example 18.4, Page Number: 430"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"from __future__ import division\n",
"from pylab import *\n",
"import cmath\n",
"import math\n",
"\n",
"#Variable declaration:\n",
"Er0 = 100 #zero sequence voltage of phase R(V)\n",
"Er1 = 200-100j #positive sequence voltage of phase R(V)\n",
"Er2 = -100 #negative sequence voltage of phase R(V)\n",
"\n",
"#Calculation:\n",
"a = cmath.rect(1,120*math.pi/180)\n",
"Er = Er0+Er1+Er2 #V\n",
"Ey = Er0+a**2*Er1+a*Er2 #V\n",
"Eb = Er0+a*Er1+a**2*Er2 #V\n",
"\n",
"\n",
"#Result:\n",
"print \"The phase voltages are:\"\n",
"print \"Er =\",(round(abs(Er),2),round(rad2deg(angle(Er)),2)),\"V\"\n",
"print \"Ey =\",(round(abs(Ey)),round(rad2deg(angle(Ey)),2)),\"V\"\n",
"print \"Eb =\",(round(abs(Eb),2),round(rad2deg(angle(Eb)),1)),\"V\""
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"The phase voltages are:\n",
"Er = (223.61, -26.57) V\n",
"Ey = (213.0, -99.9) V\n",
"Eb = (338.59, 66.2) V\n"
]
}
],
"prompt_number": 4
},
{
"cell_type": "heading",
"level": 3,
"metadata": {},
"source": [
"Example 18.5, Page Number: 431"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"from __future__ import division\n",
"from pylab import *\n",
"import cmath\n",
"import math\n",
"\n",
"#Variable declaration:\n",
"Er0 = 0.5-0.866j #zero sequence components of red phase(V)\n",
"Er1 = 2+0j #positive sequence components of red phase(V)\n",
"Er = 3+0j #phase R voltage(V)\n",
"\n",
"#Calculation:\n",
"a = cmath.rect(1,120*math.pi/180)\n",
"Er2 = Er-(Er0+Er1) #negative sequence voltage of red phase(V)\n",
"Ey = Er0+a**2*Er1+a*Er2 #phase Y voltage(V)\n",
"Eb = Er0+a*Er1+a**2*Er2 #phase B voltage(V)\n",
"\n",
"#Result:\n",
"print \"The negative sequence component of red phase is\"\n",
"print \"Ir2 = (\",round(abs(Er2)),round(rad2deg(angle(Er2))),\") V\"\n",
"print \"\\nThe phase voltages are:\"\n",
"print \"Iy = (\",round(abs(Ey)),round(rad2deg(angle(Ey))),\") V\"\n",
"print \"Ib = (\",round(abs(Eb)),round(rad2deg(angle(Eb))),\") V\""
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"The negative sequence component of red phase is\n",
"Ir2 = ( 1.0 60.0 ) V\n",
"\n",
"The phase voltages are:\n",
"Iy = ( 3.0 -120.0 ) V\n",
"Ib = ( 0.0 120.0 ) V\n"
]
}
],
"prompt_number": 5
},
{
"cell_type": "heading",
"level": 3,
"metadata": {},
"source": [
"Example 18.6, Page Number: 431"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"from __future__ import division\n",
"\n",
"\n",
"#Variable declaration:\n",
"In = 12 #current from neutral to ground(A)\n",
"\n",
"\n",
"\n",
"#Calculation:\n",
"I0 = In/3 #A\n",
"\n",
"\n",
"#Result:\n",
"print \"The zero phase sequence components in phases are\",I0,\"A each\""
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"The zero phase sequence components in phases are 4.0 A each\n"
]
}
],
"prompt_number": 6
},
{
"cell_type": "heading",
"level": 3,
"metadata": {},
"source": [
"Example 18.7, Page Number: 432"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"from __future__ import division\n",
"import cmath\n",
"import math\n",
"\n",
"#Variable declaration:\n",
"#(i) Before removal of fuses.\n",
"Iri = cmath.rect(90,0) #phase R current(A)\n",
"Iyi = cmath.rect(90,math.pi/180*240) #phase Y current(A)\n",
"Ibi = cmath.rect(90,math.pi/180*120) #phase B current(A)\n",
"\n",
"#(ii) After removal of fuses.\n",
"Irii = 90+0j #A\n",
"Iyii = 0 #A\n",
"Ibii = 0 #A\n",
"\n",
"\n",
"#Calculation:\n",
"a = cmath.rect(1,120*math.pi/180)\n",
"#(i) Before removal of fuses.\n",
"#Since the system is balanced, it will have only positive sequence currents.\n",
"Ir1i = Iri #A\n",
"Iy1i = Iyi #A\n",
"Ib1i = Ibi #A\n",
"\n",
"\n",
"\n",
"#(ii) After removal of fuses.\n",
"#The sequence currents in the three lines will be:\n",
"Ir0ii = 1/3*(Irii+Iyii+Ibii) #A\n",
"Iy0ii = Ir0ii #A\n",
"Ib0ii = Ir0ii #A\n",
"\n",
"Ir1ii = 1/3*(Irii+Iyii+Ibii) #A\n",
"Iy1ii = a**2*Ir1ii #A\n",
"Ib1ii = a*Ir1ii #A\n",
"\n",
"Ir2ii = 1/3*(Irii+a**2*Iyii+a*Ibii) #A\n",
"Iy2ii = a*Ir2ii #A\n",
"Ib2ii = a**2*Ir2ii #A\n",
"\n",
"#Result:\n",
"print \"(i) Before removal of fuses, the symmetrical components are:\"\n",
"print \"\\tIr1 = (\",round(abs(Ir1i)),round(rad2deg(angle(Ir1i))),\") A\"\n",
"print \"\\tIy1 = (\",round(abs(Iy1i)),360+round(rad2deg(angle(Iy1i))),\") A\"\n",
"print \"\\tIb1 = (\",round(abs(Ib1i)),round(rad2deg(angle(Ib1i))),\") A\"\n",
"print \"\\n(ii) After the removal of fuses, the symmetrical components are:\"\n",
"print \"\\tIr0 = (\",round(abs(Ir0ii)),round(rad2deg(angle(Ir0ii))),\") A\"\n",
"print \"\\tIr1 = (\",round(abs(Ir1ii)),round(rad2deg(angle(Ir1ii))),\") A\"\n",
"print \"\\tIr2 = (\",round(abs(Ir2ii)),round(rad2deg(angle(Ir2ii))),\") A\"\n",
"print \"\\n\\tIy0 = (\",round(abs(Iy0ii)),round(rad2deg(angle(Iy0ii))),\") A\"\n",
"print \"\\tIy1 = (\",round(abs(Iy1ii)),360+round(rad2deg(angle(Iy1ii))),\") A\"\n",
"print \"\\tIy2 = (\",round(abs(Iy2ii)),round(rad2deg(angle(Iy2ii))),\") A\"\n",
"print \"\\n\\tIb0 = (\",round(abs(Ib0ii)),round(rad2deg(angle(Ib0ii))),\") A\"\n",
"print \"\\tIb1 = (\",round(abs(Ib1ii)),round(rad2deg(angle(Ib1ii))),\") A\"\n",
"print \"\\tIb2 = (\",round(abs(Ib2ii)),360+round(rad2deg(angle(Ib2ii))),\") A\""
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"(i) Before removal of fuses, the symmetrical components are:\n",
"\tIr1 = ( 90.0 0.0 ) A\n",
"\tIy1 = ( 90.0 240.0 ) A\n",
"\tIb1 = ( 90.0 120.0 ) A\n",
"\n",
"(ii) After the removal of fuses, the symmetrical components are:\n",
"\tIr0 = ( 30.0 0.0 ) A\n",
"\tIr1 = ( 30.0 0.0 ) A\n",
"\tIr2 = ( 30.0 0.0 ) A\n",
"\n",
"\tIy0 = ( 30.0 0.0 ) A\n",
"\tIy1 = ( 30.0 240.0 ) A\n",
"\tIy2 = ( 30.0 120.0 ) A\n",
"\n",
"\tIb0 = ( 30.0 0.0 ) A\n",
"\tIb1 = ( 30.0 120.0 ) A\n",
"\tIb2 = ( 30.0 240.0 ) A\n"
]
}
],
"prompt_number": 7
},
{
"cell_type": "heading",
"level": 3,
"metadata": {},
"source": [
"Example 18.8, Page Number: 433"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"from __future__ import division\n",
"import cmath\n",
"import math\n",
"\n",
"#Variable declaration:\n",
"Ir1 = cmath.rect(200,0) #positive phase sequence component of current(A)\n",
"Ir2 = cmath.rect(100,60*math.pi/180) #negative phase sequence component of current(A)\n",
"In = cmath.rect(300,300*math.pi/180) #current in the neutral conductor(A)\n",
"\n",
"\n",
"#Calculation:\n",
"a = cmath.rect(1,120*math.pi/180)\n",
"Ir0 = 1/3*In #Zero phase sequence current in R-line(A)\n",
"Ir = Ir0+Ir1+Ir2 #Current in the R-line(A)\n",
"Iy = Ir0+a**2*Ir1+a*Ir2 #Current in the Y-line(A)\n",
"Ib = Ir0+a*Ir1+a**2*Ir2 #Current in the B-line(A)\n",
"\n",
"#Result:\n",
"print \"Current in the R-line is\"\n",
"print \"\\tIr = (\",round(abs(Ir)),round(rad2deg(angle(Ir))),\") A\"\n",
"print \"Current in the Y-line is\"\n",
"print \"\\tIy = (\",round(abs(Iy)),round(rad2deg(angle(Iy))),\") A\"\n",
"print \"Current in the B-line is\"\n",
"print \"\\tIb = (\",round(abs(Ib)),round(rad2deg(angle(Ib))),\") A\""
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Current in the R-line is\n",
"\tIr = ( 300.0 0.0 ) A\n",
"Current in the Y-line is\n",
"\tIy = ( 300.0 -120.0 ) A\n",
"Current in the B-line is\n",
"\tIb = ( 0.0 180.0 ) A\n"
]
}
],
"prompt_number": 8
},
{
"cell_type": "heading",
"level": 3,
"metadata": {},
"source": [
"Example 18.9, Page Number: 434"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"from __future__ import division\n",
"import cmath\n",
"import math\n",
"\n",
"#Variable declaration:\n",
"Ir = cmath.rect(10,0) #current in line R(A)\n",
"Iy = cmath.rect(10,180*math.pi/180) #current in line Y(A)\n",
"Ib = cmath.rect(0,0) #current in line B(A)\n",
"\n",
"\n",
"#Calculation:\n",
"a = cmath.rect(1,120*math.pi/180)\n",
"#For R-line:\n",
"Ir0 = 1/3*(Ir+Iy+Ib) #zero sequence component of Ir(A)\n",
"Ir1 = 1/3*(Ir+a*Iy+a**2*Ib) #positive sequence component of Ir(A)\n",
"Ir2 = 1/3*(Ir+a**2*Iy+a*Ib) #negative sequence component of Iy(A)\n",
"\n",
"#For Y-line:\n",
"Iy0 = Ir0 #zero sequence component of Ir(A)\n",
"Iy1 = a**2*Ir1 #positive sequence component of Ir(A)\n",
"Iy2 = a*Ir2 #negative sequence component of Iy(A)\n",
"\n",
"#For B-line:\n",
"Ib0 = Ir0 #zero sequence component of Ir(A)\n",
"Ib1 = a*Ir1 #positive sequence component of Ir(A)\n",
"Ib2 = a**2*Ir2 #negative sequence component of Iy(A)\n",
"\n",
"\n",
"#Result:\n",
"print \"The sequence components of R-line are:\"\n",
"print \"\\tIr0 = (\",round(abs(Ir0),2),round(rad2deg(angle(Ir0))),\") A\"\n",
"print \"\\tIr0 = (\",round(abs(Ir1),2),round(rad2deg(angle(Ir1))),\") A\"\n",
"print \"\\tIr0 = (\",round(abs(Ir2),2),round(rad2deg(angle(Ir2))),\") A\"\n",
"print \"The sequence components of Y-line are:\"\n",
"print \"\\tIy0 = (\",round(abs(Iy0),2),round(rad2deg(angle(Iy0))),\") A\"\n",
"print \"\\tIy1 = (\",round(abs(Iy1),2),round(rad2deg(angle(Iy1))),\") A\"\n",
"print \"\\tIy2 = (\",round(abs(Iy2),2),round(rad2deg(angle(Iy2))),\") A\"\n",
"print \"The sequence components of B-line are:\"\n",
"print \"\\tIb0 = (\",round(abs(Ib0),2),round(rad2deg(angle(Ib0))),\") A\"\n",
"print \"\\tIb1 = (\",round(abs(Ib1),2),round(rad2deg(angle(Ib1))),\") A\"\n",
"print \"\\tIb2 = (\",round(abs(Ib2),2),round(rad2deg(angle(Ib2))),\") A\""
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"The sequence components of R-line are:\n",
"\tIr0 = ( 0.0 90.0 ) A\n",
"\tIr0 = ( 5.77 -30.0 ) A\n",
"\tIr0 = ( 5.77 30.0 ) A\n",
"The sequence components of Y-line are:\n",
"\tIy0 = ( 0.0 90.0 ) A\n",
"\tIy1 = ( 5.77 -150.0 ) A\n",
"\tIy2 = ( 5.77 150.0 ) A\n",
"The sequence components of B-line are:\n",
"\tIb0 = ( 0.0 90.0 ) A\n",
"\tIb1 = ( 5.77 90.0 ) A\n",
"\tIb2 = ( 5.77 -90.0 ) A\n"
]
}
],
"prompt_number": 9
},
{
"cell_type": "heading",
"level": 3,
"metadata": {},
"source": [
"Example 18.10, Page Number: 435"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"from __future__ import division\n",
"import cmath\n",
"import math\n",
"\n",
"#Variable declaration:\n",
"Rrb = 10 #resistance of branch RB(ohm)\n",
"Rry = 20 #resistance of branch RY(ohm)\n",
"Rby = 5 #resistance of branch BY(ohm)\n",
"Er = cmath.rect(-100,0) #voltage across BY(V)\n",
"Ey = cmath.rect(100,60*math.pi/180) #voltage across BR(V)\n",
"Eb = cmath.rect(100,-60*math.pi/180) #voltage across RY(V)\n",
"\n",
"#Calculation:\n",
"a = cmath.rect(1,120*math.pi/180)\n",
"IR = Er/Rby #Current in in branch BY(A)\n",
"IY = Ey/Rrb #Current in in branch RB(A)\n",
"IB = Eb/Rry #Current in in branch RY(A)\n",
"\n",
"#Sequence currents in resistors:\n",
"IR0 = 1/3*(IR+IY+IB) #Zero sequence component of IR(A)\n",
"IR1 = 1/3*(IR+a*IY+a**2*IB) #Positive sequence component of IR(A)\n",
"IR2 = 1/3*(IR+a**2*IY+a*IB) #Negative sequence component of IR(A)\n",
"\n",
"IY0 = IR0 #Zero sequence component of IY(A)\n",
"IY1 = a**2*IR1 #Positive sequence component of IY(A)\n",
"IY2 = a*IR2 #Negative sequence component of IY(A)\n",
"\n",
"IB0 = IR0 #Zero sequence component of IB(A)\n",
"IB1 = a*IR1 #Positive sequence component of IB(A)\n",
"IB2 = a**2*IR2 #Negative sequence component of IB(A)\n",
"\n",
"#Sequence currents in supply lines:\n",
"Ir = IB-IY #Line current in R-line(A)\n",
"Iy = IR-IB #Line current in Y-line(A)\n",
"Ib = IY-IR #Line current in R-line(A)\n",
"\n",
"Ir0 = 1/3*(Ir+Iy+Ib) #Zero sequence component of Ir(A)\n",
"Ir1 = 1/3*(Ir+a*Iy+a**2*Ib) #Positive sequence component of Ir(A)\n",
"Ir2 = 1/3*(Ir+a**2*Iy+a*Ib) #Negative sequence component of Ir(A)\n",
"\n",
"\n",
"#Result:\n",
"print \"The sequence components of R-line are:\"\n",
"print \"\\tIR0 = (\",round(abs(IR0),2),round(rad2deg(angle(IR0)),1),\") A\"\n",
"print \"\\tIR1 = (\",round(abs(IR1),2),round(rad2deg(angle(IR1))),\") A\"\n",
"print \"\\tIR2 = (\",round(abs(IR2),2),round(rad2deg(angle(IR2)),1),\") A\"\n",
"print \"\\nThe sequence components of Y-line are:\"\n",
"print \"\\tIY0 = (\",round(abs(IY0),2),round(rad2deg(angle(IY0)),1),\") A\"\n",
"print \"\\tIY1 = (\",round(abs(IY1),2),round(rad2deg(angle(IY1))),\") A\"\n",
"print \"\\tIY2 = (\",round(abs(IY2),1),round(rad2deg(angle(IY2)),1),\") A\"\n",
"print \"\\nThe sequence components of B-line are:\"\n",
"print \"\\tIB0 = (\",round(abs(IB0),2),round(rad2deg(angle(IB0)),1),\") A\"\n",
"print \"\\tIB1 = (\",round(abs(IB1),2),360+round(rad2deg(angle(IB1))),\") A\"\n",
"print \"\\tIB2 = (\",round(abs(IB2),1),round(rad2deg(angle(IB2)),1),\") A\"\n",
"print \"\\nThe Sequence currents in supply lines are:\"\n",
"print \"\\tIr0 = (\",round(abs(Ir0),2),round(rad2deg(angle(Ir0))),\") A\"\n",
"print \"\\tIr1 = (\",round(abs(Ir1),1),round(rad2deg(angle(Ir1))),\") A\"\n",
"print \"\\tIr2 = (\",round(abs(Ir2),2),round(rad2deg(angle(Ir2)),1),\") A\""
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"The sequence components of R-line are:\n",
"\tIR0 = ( 4.41 160.9 ) A\n",
"\tIR1 = ( 11.67 180.0 ) A\n",
"\tIR2 = ( 4.41 -160.9 ) A\n",
"\n",
"The sequence components of Y-line are:\n",
"\tIY0 = ( 4.41 160.9 ) A\n",
"\tIY1 = ( 11.67 60.0 ) A\n",
"\tIY2 = ( 4.4 -40.9 ) A\n",
"\n",
"The sequence components of B-line are:\n",
"\tIB0 = ( 4.41 160.9 ) A\n",
"\tIB1 = ( 11.67 300.0 ) A\n",
"\tIB2 = ( 4.4 79.1 ) A\n",
"\n",
"The Sequence currents in supply lines are:\n",
"\tIr0 = ( 0.0 0.0 ) A\n",
"\tIr1 = ( 20.2 -90.0 ) A\n",
"\tIr2 = ( 7.64 109.1 ) A\n"
]
}
],
"prompt_number": 10
},
{
"cell_type": "heading",
"level": 3,
"metadata": {},
"source": [
"Example 18.11, Page Number: 437"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"from __future__ import division\n",
"import cmath\n",
"import math\n",
"\n",
"#Variable declaration:\n",
"I = 20 #current in each line(A)\n",
"\n",
"\n",
"#Calculation:\n",
"a = cmath.rect(1,120*math.pi/180)\n",
"#Let R, Y and B be the supply lines. When fuse in the \n",
"#line B is removed, the various line currents are :\n",
"Ir = cmath.rect(I,0) #A\n",
"Iy = cmath.rect(I,math.pi) #A\n",
"Ib = cmath.rect(0,0) #A\n",
"\n",
"#For R-line:\n",
"Ir0 = 1/3*(Ir+Iy+Ib) #zero sequence component of Ir(A)\n",
"Ir1 = 1/3*(Ir+a*Iy+a**2*Ib) #positive sequence component of Ir(A)\n",
"Ir2 = 1/3*(Ir+a**2*Iy+a*Ib) #negative sequence component of Iy(A)\n",
"\n",
"#For Y-line:\n",
"Iy0 = Ir0 #zero sequence component of Ir(A)\n",
"Iy1 = a**2*Ir1 #positive sequence component of Ir(A)\n",
"Iy2 = a*Ir2 #negative sequence component of Iy(A)\n",
"\n",
"#For B-line:\n",
"Ib0 = Ir0 #zero sequence component of Ir(A)\n",
"Ib1 = a*Ir1 #positive sequence component of Ir(A)\n",
"Ib2 = a**2*Ir2 #negative sequence component of Iy(A)\n",
"\n",
"\n",
"#Result:\n",
"print \"The sequence components of R-line are:\"\n",
"print \"\\tIr0 = (\",round(abs(Ir0),2),round(rad2deg(angle(Ir0))),\") A\"\n",
"print \"\\tIr0 = (\",round(abs(Ir1),2),round(rad2deg(angle(Ir1))),\") A\"\n",
"print \"\\tIr0 = (\",round(abs(Ir2),2),round(rad2deg(angle(Ir2))),\") A\"\n",
"print \"\\nThe sequence components of Y-line are:\"\n",
"print \"\\tIy0 = (\",round(abs(Iy0),2),round(rad2deg(angle(Iy0))),\") A\"\n",
"print \"\\tIy1 = (\",round(abs(Iy1),2),360+round(rad2deg(angle(Iy1))),\") A\"\n",
"print \"\\tIy2 = (\",round(abs(Iy2),2),round(rad2deg(angle(Iy2))),\") A\"\n",
"print \"\\nThe sequence components of B-line are:\"\n",
"print \"\\tIb0 = (\",round(abs(Ib0),2),round(rad2deg(angle(Ib0))),\") A\"\n",
"print \"\\tIb1 = (\",round(abs(Ib1),2),round(rad2deg(angle(Ib1))),\") A\"\n",
"print \"\\tIb2 = (\",round(abs(Ib2),2),360+round(rad2deg(angle(Ib2))),\") A\""
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"The sequence components of R-line are:\n",
"\tIr0 = ( 0.0 90.0 ) A\n",
"\tIr0 = ( 11.55 -30.0 ) A\n",
"\tIr0 = ( 11.55 30.0 ) A\n",
"\n",
"The sequence components of Y-line are:\n",
"\tIy0 = ( 0.0 90.0 ) A\n",
"\tIy1 = ( 11.55 210.0 ) A\n",
"\tIy2 = ( 11.55 150.0 ) A\n",
"\n",
"The sequence components of B-line are:\n",
"\tIb0 = ( 0.0 90.0 ) A\n",
"\tIb1 = ( 11.55 90.0 ) A\n",
"\tIb2 = ( 11.55 270.0 ) A\n"
]
}
],
"prompt_number": 11
},
{
"cell_type": "heading",
"level": 3,
"metadata": {},
"source": [
"Example 18.12, Page Number: 438"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"from __future__ import division\n",
"from pylab import *\n",
"import cmath\n",
"from sympy import *\n",
"\n",
"\n",
"#Variable declaration:\n",
"Zr = 5-10j #impedance connected to line R(ohm)\n",
"Zy = 6+5j #impedance connected to line Y(ohm)\n",
"Zb = 3+15j #impedance connected to line B(ohm)\n",
"VRY = cmath.rect(3300,0) #line RY voltage(V)\n",
"\n",
"\n",
"#Calculation:\n",
"a = cmath.rect(1,120*math.pi/180)\n",
"VYB = a**2*VRY #line YB voltage(V)\n",
"\n",
"#Let VR, VY, and VB be the voltages across impedances in R, Y and B\n",
"#phases respectively and IR, IY, and IB the resulting line currents.\n",
"IR, IY,IB,IR0,IR1,IR2, = symbols('IR IY IB IR0 IR1 IR2')\n",
"\n",
"#IR+IY+IB = 0\n",
"IR0 = 0; IY0 = 0; IB0 = 0;\n",
"VR = Zr*(IR0+IR1+IR2) #V\n",
"VY = Zy*(a**2*IR1+a*IR2) #V\n",
"VB = Zb*(a*IR1+a**2*IR2) #V\n",
"#solving the equations:\n",
"IR11 = solve(VR-VY-VRY,IR1)[0]\n",
"VY = Zy*(a**2*IR11+a*IR2)\n",
"VB = Zb*(a*IR11+a**2*IR2)\n",
"IR22 = solve(VY-VB-VYB,IR2)[0]\n",
"\n",
"VR = Zr*(IR0+IR1+IR22)\n",
"VY = Zy*(a**2*IR1+a*IR22)\n",
"IR11 = solve(VR-VY-VRY,IR1)[0]\n",
"IR = IR11+IR22 #A\n",
"\n",
"\n",
"#Result:\n",
"print \"The line current IR is (\",round(abs(IR)),round(-rad2deg(cmath.phase(IR)),1),\") A\""
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"The line current IR is ( 241.0 -18.5 ) A\n"
]
}
],
"prompt_number": 12
},
{
"cell_type": "heading",
"level": 3,
"metadata": {},
"source": [
"Example 18.13, Page Number: 440"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"from __future__ import division\n",
"import cmath\n",
"import math\n",
"\n",
"#Variable declaration:\n",
"R = 1 #resistance of each load(ohm)\n",
"magVRY = 200 #line RY voltage(V)\n",
"magVBR = 400 #line BR voltage(V)\n",
"magVYB = 346 #line YB voltage(V)\n",
"\n",
"\n",
"#Calculation:\n",
"a = cmath.rect(1,120*math.pi/180)\n",
"#This is a case of a balanced star-connected load supplied\n",
"#from an unbalanced 3-phase supply.\n",
"\n",
"#Now,\n",
"\n",
"# (2)**22 = (1 + 1\u00b775 cos(theta))**2 + (1\u00b775 sin(theta))**2\n",
"# theta = math.acos(4-1+3*1)/3.5\n",
"theta = math.pi/2\n",
"# alpha = math.acos(1+1.75*math.cos(theta))\n",
"alpha = 60*math.pi/180\n",
"\n",
"#As the phase sequence is RYB, therefore, various line voltages are :\n",
"VRY = cmath.rect(200,math.pi) #V\n",
"VYB = cmath.rect(346,theta) #V\n",
"VBR = cmath.rect(400,-alpha) #V\n",
"\n",
"#The current in any phase (or line) is equal to phase voltage \n",
"#divided by resistance in that phase.\n",
"IR = VRY/(1*3**0.5) #A\n",
"IY = VYB/(1*3**0.5) #A\n",
"IB = VBR/(1*3**0.5) #A\n",
"\n",
"#Sequence components in red phase are :\n",
"IR0 = 1/3*(IR+IY+IB) #A\n",
"IR1 = 1/3*(IR+a*IY+a**2*IB) #A\n",
"IR2 = 1/3*(IR+a**2*IY+a*IB) #A\n",
"\n",
"\n",
"#Result:\n",
"print \"The magnitude of current in any phase is:\"\n",
"print \"\\tIR0 = (\",round(abs(IR0)),round(rad2deg(angle(IR0))),\") A\"\n",
"print \"\\tIR1 = (\",round(abs(IR1),1),round(rad2deg(angle(IR1))),\") A\"\n",
"print \"\\tIR2 = (\",round(abs(IR2),2),round(rad2deg(angle(IR2))),\") A\""
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"The magnitude of current in any phase is:\n",
"\tIR0 = ( 0.0 -90.0 ) A\n",
"\tIR1 = ( 176.3 -169.0 ) A\n",
"\tIR2 = ( 66.63 30.0 ) A\n"
]
}
],
"prompt_number": 13
},
{
"cell_type": "heading",
"level": 3,
"metadata": {},
"source": [
"Example 18.14, Page Number: 449"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"from __future__ import division\n",
"\n",
"\n",
"#Variable declaration:\n",
"MVAg = 10 #MVA rating of generator\n",
"Vg = 11 #voltage rating of generator(kV)\n",
"Zg1 = 1.2j #Positive sequence impedance of generator(ohm)\n",
"Zg2 = 0.9j #Negative sequence impedance of generator(ohm)\n",
"Zg0 = 0.4j #Zero sequence impedance of generator(ohm)\n",
"Zf1 = 1.0j #Positive sequence impedance of feeder(ohm)\n",
"Zf2 = 1.0j #Negative sequence impedance of feeder(ohm)\n",
"Zf0 = 3.0j #Zero sequence impedance of feeder(ohm)\n",
"\n",
"\n",
"\n",
"#Calculation:\n",
"#Suppose the fault is occured on the red phase. \n",
"#Taking red phase as the reference,\n",
"ER = Vg*1000/3**0.5 #Phase e.m.f. of R-phase(V)\n",
"\n",
"#(i)The total impedance to any sequence current is given by\n",
"#the sum of generator and feeder impedances to that sequence current.\n",
"Z1 = Zg1+Zf1 #ohm\n",
"Z2 = Zg2+Zf2 #ohm\n",
"Z0 = Zg0+Zf0 #ohm\n",
"\n",
"#For a line-to-ground fault,\n",
"#I1 = I2 = I0\n",
"I0 = ER/(Z1+Z2+Z0) #A\n",
"IR = 3*I0 #fault current(A)\n",
"\n",
"#(ii)Line-to-neutral voltage of R-phase,\n",
"VR = ER-I0*(Zg1+Zg2+Zg0) #V\n",
"\n",
"#Result:\n",
"print \"(i) The magnitude of fault current is\",round(IR.imag)*1j,\"A\"\n",
"print \"(ii) Line to neutral voltage at the generator terminal is\",round(abs(VR)),\"V\""
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"(i) The magnitude of fault current is (-0-2540j) A\n",
"(ii) Line to neutral voltage at the generator terminal is 4234.0 V\n"
]
}
],
"prompt_number": 14
},
{
"cell_type": "heading",
"level": 3,
"metadata": {},
"source": [
"Example 18.15, Page Number: 450"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"from __future__ import division\n",
"\n",
"\n",
"#Variable declaration:\n",
"Vg = 11000 #voltage rating of the alternator(V)\n",
"MVAg = 10 #MVA rating of generator\n",
"X0 = 0.05 #zero sequence reactance(p.u)\n",
"X1 = 0.15 #positive sequence reactance(p.u)\n",
"X2 = 0.15 #negative sequence reactance(p.u)\n",
"\n",
"#Calculation:\n",
"#Taking red phase as the reference, let its phase e.m.f. be\n",
"ER = 1 #p.u\n",
"\n",
"#Line-to-ground fault: \n",
"#Suppose the fault occurs on the red phase.\n",
"#I1 = I2 = I0\n",
"I0 = ER/(1j*(X0+X1+X2))\n",
"IR = 3*I0 #fault current(A)\n",
"\n",
"#Three phase fault: \n",
"#the fault current (say Ish) is limited by the positive sequence reactance only.\n",
"Ish = ER/(1j*X1) #fault current(A)\n",
"r = IR/Ish #ratio of the two fault currents\n",
"\n",
"\n",
"#Result:\n",
"print \"The ratio of two fault currents is\",round(abs(r),3)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"The ratio of two fault currents is 1.286\n"
]
}
],
"prompt_number": 15
},
{
"cell_type": "heading",
"level": 3,
"metadata": {},
"source": [
"Example 18.16, Page Number: 450"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"from __future__ import division\n",
"\n",
"#Variable declaration:\n",
"Vg = 11 #voltage rating of the alternator(kV)\n",
"MVAg = 25 #MVA rating of generator\n",
"X0 = 0.05 #zero sequence reactance(p.u)\n",
"X1 = 0.2 #positive sequence reactance(p.u)\n",
"X2 = 0.2 #negative sequence reactance(p.u)\n",
"Xn = 0.3 #neutral to ground reactance(ohm)\n",
"\n",
"\n",
"#Calculation:\n",
"#Assume that the fault occurs on the red phase.\n",
"#Taking red phase as the reference, let its phase e.m.f. be \n",
"ER = 1 #p.u.\n",
"#First of all, convert the reactance Xn into p.u.\n",
"Xnp = Xn*MVAg*1000/(Vg**2*1000) #p.u\n",
"#For a line-to-ground fault,\n",
"#I1 = I2 = I0\n",
"I0 = ER/(X1+X2+X0+3*Xnp) #p.u\n",
"IR = 3*I0 #fault current(p.u)\n",
"IRa = MVAg*10**6/(3**0.5*Vg*1000) * IR #fault current in amperes\n",
"\n",
"\n",
"\n",
"#Result:\n",
"print \" The fault current for a single line to ground fault is\",round(IRa),\"A\""
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
" The fault current for a single line to ground fault is 6190.0 A\n"
]
}
],
"prompt_number": 16
},
{
"cell_type": "heading",
"level": 3,
"metadata": {},
"source": [
"Example 18.17, Page Number: 451"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"from __future__ import division\n",
"\n",
"#Variable declaration:\n",
"V = 10.4 #voltage between the lines(kV)\n",
"X0 = 0.2j #zero sequence reactance(p.u)\n",
"X1 = 0.6j #positive sequence reactance(p.u)\n",
"X2 = 0.5j #negative sequence reactance(p.u)\n",
"\n",
"\n",
"#Calculation:\n",
"#Taking red phase as the reference, its phase e.m.f. is :\n",
"ER = round(V*1000/3**0.5) #Phase e.m.f. of R-phase(V)\n",
"IF = 3**0.5*ER/(X1+X2) #fault current(A)\n",
"\n",
"\n",
"#Result:\n",
"print \"The fault current is\",round(abs(IF),1),\"A\""
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"The fault current is 9453.8 A\n"
]
}
],
"prompt_number": 17
},
{
"cell_type": "heading",
"level": 3,
"metadata": {},
"source": [
"Example 18.18, Page Number: 451"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"from __future__ import division\n",
"\n",
"#Variable declaration:\n",
"X0 = 0.05j #zero sequence reactance(p.u)\n",
"X1 = 0.08j #positive sequence reactance(p.u)\n",
"X2 = 0.07j #negative sequence reactance(p.u)\n",
"\n",
"\n",
"\n",
"#Calculation:\n",
"#Taking red phase as the reference, let its phase e.m.f. be \n",
"ER = 1 #p.u\n",
"#For a double line-to-ground fault,\n",
"#IF = IY+IB\n",
"IF = -3*X2*ER/(X1*X2+X2*X0+X2*X0) #fault current(A)\n",
"\n",
"\n",
"#Result:\n",
"print \"The fault current is\",round(IF.imag,1)*1j,\"p.u\"\n"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"The fault current is 16.7j p.u\n"
]
}
],
"prompt_number": 18
},
{
"cell_type": "heading",
"level": 3,
"metadata": {},
"source": [
"Example 18.19, Page Number: 452"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"from __future__ import division\n",
"\n",
"#Variable declaration:\n",
"MVAg = 20 #MVA rating of generator\n",
"V = 11 #voltage rating of generator(V)\n",
"X1 = 20 #positive sequence reactance of generator(%)\n",
"X2 = 10 #negative sequence reactance of generator(%)\n",
"X0 = 15 #zero sequence reactance of generator(%)\n",
"Xn = 5 #generator 1 neutral reactance(%)\n",
"\n",
"#Calculation:\n",
"ER = V*1000/3**0.5 #V\n",
"#The % reactances in Fig. 18.19b can be converted into ohmic values as under:\n",
"x1 = X1*V**2*10/(MVAg*1000) #ohm\n",
"x2 = X2*V**2*10/(MVAg*1000) #ohm\n",
"x0 = X0*V**2*10/(MVAg*1000) #ohm\n",
"IR = 3*ER/(x1+x2+x0)*(-1j) #ohm\n",
"\n",
"\n",
"#Result:\n",
"print \"Fault current is\",round(IR.imag)*1j,\"A\""
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Fault current is (-0-6998j) A\n"
]
}
],
"prompt_number": 19
},
{
"cell_type": "heading",
"level": 3,
"metadata": {},
"source": [
"Example 18.20, Page Number: 453"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"from __future__ import division\n",
"from sympy import *\n",
"\n",
"\n",
"#Variable declaration:\n",
"IF1 = 2000 #3 phase fault current(A)\n",
"IF2 = 2600 #line-to-line fault(A)\n",
"IF0 = 4200 #line-toground fault(A)\n",
"MVAg = 50 #MVA rating of the generator\n",
"V = 11 #voltage rating of the generator(V)\n",
"\n",
"#Calculation:\n",
"#Let X1 = positive sequence reactance,\n",
"# X2 = negative sequence reactance,and\n",
"# X0 = zero sequence reactance of the alternator.\n",
"X1,X2,X0 = symbols('X1 X2 X0')\n",
"Eph = V*1000/3**0.5 #phase voltage(V)\n",
"X11 = solve(Eph/X1-IF1)[0] #positive sequence reactance(ohm)\n",
"X22 = solve(3**0.5*Eph/(X11+X2)-IF2,X2)[0] #negative sequence reactance(ohm)\n",
"X00 = solve(3*Eph/(X11+X22+X0)-IF0)[0] #zero sequence reactance(ohm)\n",
"\n",
"\n",
"#Result:\n",
"print \"The positive sequence reactance is\",round(X11,3),\"ohm\"\n",
"print \"The negative sequence reactance is\",round(X22,3),\"ohm\"\n",
"print \"The zero sequence reactance is\",round(X00,3),\"ohm\""
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"The positive sequence reactance is 3.175 ohm\n",
"The negative sequence reactance is 1.055 ohm\n",
"The zero sequence reactance is 0.306 ohm\n"
]
}
],
"prompt_number": 20
}
],
"metadata": {}
}
]
}