diff options
| author | nice | 2014-09-16 17:48:17 +0530 |
|---|---|---|
| committer | nice | 2014-09-16 17:48:17 +0530 |
| commit | b8bb8bbfa81499ad7fc3f3508be257da65f543af (patch) | |
| tree | 204976d3209b79a52e8518c65fa27a4ca48f8489 /Principles_of_Power_System/chapter18.ipynb | |
| parent | 2792e8d6ecab454e3cb8fb1ea1f26f1613bc1e1c (diff) | |
| download | Python-Textbook-Companions-b8bb8bbfa81499ad7fc3f3508be257da65f543af.tar.gz Python-Textbook-Companions-b8bb8bbfa81499ad7fc3f3508be257da65f543af.tar.bz2 Python-Textbook-Companions-b8bb8bbfa81499ad7fc3f3508be257da65f543af.zip | |
updating repo
Diffstat (limited to 'Principles_of_Power_System/chapter18.ipynb')
| -rwxr-xr-x | Principles_of_Power_System/chapter18.ipynb | 1223 |
1 files changed, 1223 insertions, 0 deletions
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 |