diff options
Diffstat (limited to 'Principles_of_Power_System/chapter18_1.ipynb')
| -rw-r--r-- | Principles_of_Power_System/chapter18_1.ipynb | 1223 |
1 files changed, 0 insertions, 1223 deletions
diff --git a/Principles_of_Power_System/chapter18_1.ipynb b/Principles_of_Power_System/chapter18_1.ipynb deleted file mode 100644 index d291f15a..00000000 --- a/Principles_of_Power_System/chapter18_1.ipynb +++ /dev/null @@ -1,1223 +0,0 @@ -{
- "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 |