From b8bb8bbfa81499ad7fc3f3508be257da65f543af Mon Sep 17 00:00:00 2001 From: nice Date: Tue, 16 Sep 2014 17:48:17 +0530 Subject: updating repo --- Principles_of_Power_System/chapter18.ipynb | 1223 ++++++++++++++++++++++++++++ 1 file changed, 1223 insertions(+) create mode 100755 Principles_of_Power_System/chapter18.ipynb (limited to 'Principles_of_Power_System/chapter18.ipynb') diff --git a/Principles_of_Power_System/chapter18.ipynb b/Principles_of_Power_System/chapter18.ipynb new file mode 100755 index 00000000..d291f15a --- /dev/null +++ b/Principles_of_Power_System/chapter18.ipynb @@ -0,0 +1,1223 @@ +{ + "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": {} + } + ] +} \ No newline at end of file -- cgit